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;

        int                     couldkill;
};

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;
        void *s;
        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"));
        }

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

        VSB_destroy(&vsb);

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

        vg->s = s;
        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);
        if (getenv("VSM_NOPID") != NULL)
                vs->couldkill = -1;
        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 unsigned
vsm_running(struct vsm_set *vs, pid_t pid)
{

        AN(vs);

        if (pid == 0)
                return (0);

        if (kill(pid, 0) == 0) {
                vs->couldkill = 1;
                return (1);
        }
        if (errno == EPERM)     /* a process exists, assume running */
                return (1);
        assert(errno != EINVAL);
        return (0);
}

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

        i = sscanf(line, "# %ju %ju", &id1, &id2);
        if (i != 2) {
                vs->retval |= vs->flag_restarted;
                return (0);
        }
        if (vs->couldkill >= 0 && vsm_running(vs, id1)) {
                /* nothing to do */
        } else if (vs->couldkill > 0 && errno == ESRCH) {
                vs->retval |= vs->flag_restarted | VSM_MGT_CHANGED;
                return (0);
        }
        vs->retval |= VSM_MGT_RUNNING;
        if (id1 != vs->id1 || id2 != vs->id2) {
                vs->retval |= vs->flag_restarted;
                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);
                }
                vs->retval |= vs->flag_changed;
        }
        return (0);
}

static int
vsm_vlu_minus(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_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])) {
                        vs->retval |= vs->flag_changed;
                        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(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)
{
        unsigned restarted = 0;
        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);
                restarted = vs->flag_restarted;
        }

        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 | 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);
                vs->retval |= vs->flag_changed;
        }

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

        if (vs->couldkill < 0 || vsm_running(vs, vs->id1))
                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_WRK_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 (vd->mgt->couldkill > 0 && (retval & VSM_MGT_RESTARTED))
                        vd->mgt->couldkill = 0;
                if (retval & VSM_MGT_RUNNING)
                        retval |= vsm_refresh_set(vd, vd->child);
                if (vd->child->couldkill > 0 && (retval & VSM_WRK_RESTARTED))
                        vd->child->couldkill = 0;
        }
        return (retval);
}

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

int
VSM_Attach(struct vsm *vd, int progress)
{
        const char *def;
        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) {
                def = getenv("VARNISH_DEFAULT_N");
                if (def == NULL)
                        def = ""; /* Use default (hostname) */
                i = VSM_Arg(vd, 'n', def);
                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_set_findseg(const struct vsm_set *vs, uintptr_t serial)
{
        struct vsm_seg *vg;

        VTAILQ_FOREACH(vg, &vs->segs, list) {
                if (vg->serial == serial)
                        return (vg);
        }
        VTAILQ_FOREACH(vg, &vs->stale, list) {
                if (vg->serial == serial)
                        return (vg);
        }
        return (NULL);
}

static struct vsm_seg *
vsm_findseg(const struct vsm *vd, const struct vsm_fantom *vf)
{
        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);
        vg = vsm_set_findseg(vd->mgt, x);
        if (vg == NULL)
                vg = vsm_set_findseg(vd->child, x);
        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		int couldkill;
137		};
138
139		struct vsm {
140		unsigned magic;
141		#define VSM_MAGIC 0x6e3bd69b
142
143		struct vsb *diag;
144		uint64_t serial;
145
146		int wdfd;
147		struct stat wdst;
148		char *wdname;
149
150		struct vsm_set *mgt;
151		struct vsm_set *child;
152
153		int attached;
154		double patience;
155		};
156
157		/--------------------------------------------------------------------/
158
159		static int
160	780	vsm_diag(struct vsm vd, const char fmt, ...)
161		{
162		va_list ap;
163
164	780	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
165	780	AN(fmt);
166
167	780	if (vd->diag == NULL)
168	779	vd->diag = VSB_new_auto();
169	780	AN(vd->diag);
170	780	VSB_clear(vd->diag);
171	780	va_start(ap, fmt);
172	780	VSB_vprintf(vd->diag, fmt, ap);
173	780	va_end(ap);
174	780	AZ(VSB_finish(vd->diag));
175	780	return (-1);
176		}
177
178		/--------------------------------------------------------------------/
179
180		static int
181	109326	vsm_mapseg(struct vsm vd, struct vsm_seg vg)
182		{
183		size_t of, off, sz, ps, len;
184		struct vsb *vsb;
185		void *s;
186		int fd;
187
188	109326	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
189
190	109326	if (vg->s != NULL)
191	1717	return (0);
192
193	107609	ps = getpagesize();
194
195	107609	of = strtoul(vg->av[2], NULL, 10);
196	107609	off = RDN2(of, ps);
197
198	107609	if (vg->flags & VSM_FLAG_CLUSTER)
199	738	assert(of == 0);
200	107609	assert(vg->cluster == NULL);
201
202	107609	sz = strtoul(vg->av[3], NULL, 10);
203	107609	assert(sz > 0);
204	107609	assert(of >= off);
205	107609	len = RUP2((of - off) + sz, ps);
206
207	107609	vsb = VSB_new_auto();
208	107609	AN(vsb);
209	107609	VSB_printf(vsb, "%s/%s/%s", vd->wdname, vg->set->dname, vg->av[1]);
210	107609	AZ(VSB_finish(vsb));
211
212	107609	fd = open(VSB_data(vsb), O_RDONLY); // XXX: openat
213	107609	if (fd < 0) {
214	12	VSB_destroy(&vsb);
215	12	return (vsm_diag(vd, "Could not open segment"));
216		}
217
218	215194	s = (void*)mmap(NULL, len,
219		PROT_READ,
220		MAP_HASSEMAPHORE \| MAP_NOSYNC \| MAP_SHARED,
221	107597	fd, (off_t)off);
222
223	107597	VSB_destroy(&vsb);
224
225	107597	closefd(&fd);
226	107597	if (s == MAP_FAILED)
227	0	return (vsm_diag(vd, "Could not mmap segment"));
228
229	107597	vg->s = s;
230	107597	vg->b = (char*)(vg->s) + of - off;
231	107597	vg->e = (char *)vg->b + sz;
232	107597	vg->sz = len;
233
234	107597	return (0);
235	109326	}
236
237		static void
238	96173	vsm_unmapseg(struct vsm_seg *vg)
239		{
240
241	96173	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
242
243	96173	AN(vg->b);
244	96173	AN(vg->e);
245	96173	AZ(munmap(vg->s, vg->sz));
246	96173	vg->s = vg->b = vg->e = NULL;
247	96173	vg->sz = 0;
248	96173	}
249
250		/--------------------------------------------------------------------/
251
252		static void
253	1322622	vsm_delseg(struct vsm_seg *vg, int refsok)
254		{
255
256	1322622	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
257
258	1322622	if (vg->set->vg == vg) {
259	82367	AZ(vg->flags & VSM_FLAG_STALE);
260	82367	vg->set->vg = VTAILQ_NEXT(vg, list);
261	82367	}
262
263	1322622	if (refsok && vg->refs) {
264	2291	AZ(vg->flags & VSM_FLAG_STALE);
265	2291	vg->flags \|= VSM_FLAG_STALE;
266	2291	VTAILQ_REMOVE(&vg->set->segs, vg, list);
267	2291	VTAILQ_INSERT_TAIL(&vg->set->stale, vg, list);
268	2291	return;
269		}
270
271	1320331	if (vg->s != NULL)
272	0	vsm_unmapseg(vg);
273
274	1320331	if (vg->flags & VSM_FLAG_CLUSTER) {
275	32521	vg->flags &= ~VSM_FLAG_CLUSTER;
276	32521	VTAILQ_REMOVE(&vg->set->clusters, vg, clist);
277	32521	}
278
279	1320331	if (vg->flags & VSM_FLAG_STALE)
280	2291	VTAILQ_REMOVE(&vg->set->stale, vg, list);
281		else
282	1318040	VTAILQ_REMOVE(&vg->set->segs, vg, list);
283	1320331	VAV_Free(vg->av);
284	1320331	FREE_OBJ(vg);
285	1322622	}
286
287		/--------------------------------------------------------------------/
288
289		static struct vsm_set *
290	76534	vsm_newset(const char *dirname)
291		{
292		struct vsm_set *vs;
293
294	76534	ALLOC_OBJ(vs, VSM_SET_MAGIC);
295	76534	AN(vs);
296	76534	VTAILQ_INIT(&vs->segs);
297	76534	VTAILQ_INIT(&vs->stale);
298	76534	VTAILQ_INIT(&vs->clusters);
299	76534	vs->dname = dirname;
300	76534	vs->dfd = vs->fd = -1;
301	76534	vs->vlu = VLU_New(vsm_vlu_func, vs, 0);
302	76534	AN(vs->vlu);
303	76534	if (getenv("VSM_NOPID") != NULL)
304	0	vs->couldkill = -1;
305	76534	return (vs);
306		}
307
308		static void
309	75582	vsm_delset(struct vsm_set **p)
310		{
311		struct vsm_set *vs;
312		struct vsm_seg *vg;
313
314	75582	TAKE_OBJ_NOTNULL(vs, p, VSM_SET_MAGIC);
315
316	75582	if (vs->fd >= 0)
317	46376	closefd(&vs->fd);
318	75582	if (vs->dfd >= 0)
319	62220	closefd(&vs->dfd);
320	75582	while ((vg = VTAILQ_FIRST(&vs->stale)) != NULL) {
321	0	AN(vg->flags & VSM_FLAG_STALE);
322	0	vsm_delseg(vg, 0);
323		}
324	1318601	while ((vg = VTAILQ_FIRST(&vs->segs)) != NULL) {
325	1243019	AZ(vg->flags & VSM_FLAG_STALE);
326	1243019	vsm_delseg(vg, 0);
327		}
328	75582	assert(VTAILQ_EMPTY(&vs->clusters));
329	75582	VLU_Destroy(&vs->vlu);
330	75582	FREE_OBJ(vs);
331	75582	}
332
333		static void
334	167179	vsm_wash_set(const struct vsm_set *vs, int all)
335		{
336		struct vsm_seg vg, vg2;
337
338	1433661	VTAILQ_FOREACH_SAFE(vg, &vs->segs, list, vg2) {
339	1266482	if (all \|\| (vg->flags & VSM_FLAG_MARKSCAN) == 0)
340	44113	vsm_delseg(vg, 1);
341	1266482	}
342	167179	}
343
344		/--------------------------------------------------------------------/
345
346		struct vsm *
347	38267	VSM_New(void)
348		{
349		struct vsm *vd;
350
351	38267	ALLOC_OBJ(vd, VSM_MAGIC);
352	38267	AN(vd);
353
354	38267	vd->mgt = vsm_newset(VSM_MGT_DIRNAME);
355	38267	vd->mgt->flag_running = VSM_MGT_RUNNING;
356	38267	vd->mgt->flag_changed = VSM_MGT_CHANGED;
357	38267	vd->mgt->flag_restarted = VSM_MGT_RESTARTED;
358
359	38267	vd->child = vsm_newset(VSM_CHILD_DIRNAME);
360	38267	vd->child->flag_running = VSM_WRK_RUNNING;
361	38267	vd->child->flag_changed = VSM_WRK_CHANGED;
362	38267	vd->child->flag_restarted = VSM_WRK_RESTARTED;
363
364	38267	vd->mgt->vsm = vd;
365	38267	vd->child->vsm = vd;
366	38267	vd->wdfd = -1;
367	38267	vd->patience = 5;
368	38267	return (vd);
369		}
370
371		/--------------------------------------------------------------------/
372
373		int
374	39015	VSM_Arg(struct vsm vd, char flag, const char arg)
375		{
376	39015	char *p = NULL;
377
378	39015	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
379
380	39015	if (arg == NULL)
381	697	return (1);
382	38318	switch (flag) {
383		case 't':
384	221	if (!strcasecmp(arg, "off")) {
385	0	vd->patience = -1;
386	0	} else {
387	221	vd->patience = strtod(arg, &p);
388	357	if ((p != NULL && *p != '\0') \|\|
389	136	!isfinite(vd->patience) \|\| vd->patience < 0)
390	238	return (vsm_diag(vd,
391	119	"-t: Invalid argument: %s", arg));
392		}
393	102	break;
394		case 'n':
395	38097	if (vd->wdname != NULL)
396	0	free(vd->wdname);
397	38097	vd->wdname = VIN_n_Arg(arg);
398	38097	if (vd->wdname == NULL)
399	0	return (vsm_diag(vd, "Invalid instance name: %s",
400	0	strerror(errno)));
401	38097	break;
402		default:
403	0	return (vsm_diag(vd, "Unknown VSM_Arg('%c')", flag));
404		}
405	38199	return (1);
406	39015	}
407
408		/--------------------------------------------------------------------/
409
410		void
411	37791	VSM_Destroy(struct vsm **vdp)
412		{
413		struct vsm *vd;
414
415	37791	TAKE_OBJ_NOTNULL(vd, vdp, VSM_MAGIC);
416
417	37791	VSM_ResetError(vd);
418	37791	REPLACE(vd->wdname, NULL);
419	37791	if (vd->diag != NULL)
420	0	VSB_destroy(&vd->diag);
421	37791	if (vd->wdfd >= 0)
422	37757	closefd(&vd->wdfd);
423	37791	vsm_delset(&vd->mgt);
424	37791	vsm_delset(&vd->child);
425	37791	FREE_OBJ(vd);
426	37791	}
427
428		/--------------------------------------------------------------------/
429
430		const char *
431	199	VSM_Error(const struct vsm *vd)
432		{
433
434	199	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
435
436	199	if (vd->diag == NULL)
437	0	return ("No VSM error");
438		else
439	199	return (VSB_data(vd->diag));
440	199	}
441
442		/--------------------------------------------------------------------/
443
444		void
445	76435	VSM_ResetError(struct vsm *vd)
446		{
447
448	76435	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
449
450	76435	if (vd->diag == NULL)
451	75809	return;
452	626	VSB_destroy(&vd->diag);
453	76435	}
454
455		/*--------------------------------------------------------------------
456		*/
457
458		static int
459	290904	vsm_cmp_av(char * const a1, char const *a2)
460		{
461
462	429108	while (1) {
463	429108	if (a1 == NULL && a2 == NULL)
464	34038	return (0);
465	395070	if (a1 == NULL \|\| a2 == NULL)
466	14	return (1);
467	395070	if (strcmp(a1, a2))
468	256866	return (1);
469	138204	a1++;
470	138204	a2++;
471		}
472	290904	}
473
474		static struct vsm_seg *
475	35154	vsm_findcluster(const struct vsm_set vs, const char cnam)
476		{
477		struct vsm_seg *vg;
478	35154	AN(vs);
479	35154	AN(cnam);
480	49836	VTAILQ_FOREACH(vg, &vs->clusters, clist) {
481	49836	AN(vg->av[1]);
482	49836	if (!strcmp(cnam, vg->av[1]))
483	35154	return (vg);
484	14682	}
485	0	return (NULL);
486	35154	}
487
488		static unsigned
489	1041528	vsm_running(struct vsm_set *vs, pid_t pid)
490		{
491
492	1041528	AN(vs);
493
494	1041528	if (pid == 0)
495	0	return (0);
496
497	1041528	if (kill(pid, 0) == 0) {
498	1003125	vs->couldkill = 1;
499	1003125	return (1);