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);
        assert(pid > 1);

        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	45	vsm_diag(struct vsm vd, const char fmt, ...)
161		{
162		va_list ap;
163
164	45	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
165	45	AN(fmt);
166
167	45	if (vd->diag == NULL)
168	45	vd->diag = VSB_new_auto();
169	45	AN(vd->diag);
170	45	VSB_clear(vd->diag);
171	45	va_start(ap, fmt);
172	45	VSB_vprintf(vd->diag, fmt, ap);
173	45	va_end(ap);
174	45	AZ(VSB_finish(vd->diag));
175	45	return (-1);
176		}
177
178		/--------------------------------------------------------------------/
179
180		static int
181	6204	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	6204	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
189
190	6204	if (vg->s != NULL)
191	100	return (0);
192
193	6104	ps = getpagesize();
194
195	6104	of = strtoul(vg->av[2], NULL, 10);
196	6104	off = RDN2(of, ps);
197
198	6104	if (vg->flags & VSM_FLAG_CLUSTER)
199	43	assert(of == 0);
200	6104	assert(vg->cluster == NULL);
201
202	6104	sz = strtoul(vg->av[3], NULL, 10);
203	6104	assert(sz > 0);
204	6104	assert(of >= off);
205	6104	len = RUP2((of - off) + sz, ps);
206
207	6104	vsb = VSB_new_auto();
208	6104	AN(vsb);
209	6104	VSB_printf(vsb, "%s/%s/%s", vd->wdname, vg->set->dname, vg->av[1]);
210	6104	AZ(VSB_finish(vsb));
211
212	6104	fd = open(VSB_data(vsb), O_RDONLY); // XXX: openat
213	6104	if (fd < 0) {
214	0	VSB_destroy(&vsb);
215	0	return (vsm_diag(vd, "Could not open segment"));
216		}
217
218	12208	s = (void*)mmap(NULL, len,
219		PROT_READ,
220		MAP_HASSEMAPHORE \| MAP_NOSYNC \| MAP_SHARED,
221	6104	fd, (off_t)off);
222
223	6104	VSB_destroy(&vsb);
224
225	6104	closefd(&fd);
226	6104	if (s == MAP_FAILED)
227	0	return (vsm_diag(vd, "Could not mmap segment"));
228
229	6104	vg->s = s;
230	6104	vg->b = (char*)(vg->s) + of - off;
231	6104	vg->e = (char *)vg->b + sz;
232	6104	vg->sz = len;
233
234	6104	return (0);
235	6204	}
236
237		static void
238	5448	vsm_unmapseg(struct vsm_seg *vg)
239		{
240
241	5448	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
242
243	5448	AN(vg->b);
244	5448	AN(vg->e);
245	5448	AZ(munmap(vg->s, vg->sz));
246	5448	vg->s = vg->b = vg->e = NULL;
247	5448	vg->sz = 0;
248	5448	}
249
250		/--------------------------------------------------------------------/
251
252		static void
253	74723	vsm_delseg(struct vsm_seg *vg, int refsok)
254		{
255
256	74723	CHECK_OBJ_NOTNULL(vg, VSM_SEG_MAGIC);
257
258	74723	if (vg->set->vg == vg) {
259	4812	AZ(vg->flags & VSM_FLAG_STALE);
260	4812	vg->set->vg = VTAILQ_NEXT(vg, list);
261	4812	}
262
263	74723	if (refsok && vg->refs) {
264	133	AZ(vg->flags & VSM_FLAG_STALE);
265	133	vg->flags \|= VSM_FLAG_STALE;
266	133	VTAILQ_REMOVE(&vg->set->segs, vg, list);
267	133	VTAILQ_INSERT_TAIL(&vg->set->stale, vg, list);
268	133	return;
269		}
270
271	74590	if (vg->s != NULL)
272	0	vsm_unmapseg(vg);
273
274	74590	if (vg->flags & VSM_FLAG_CLUSTER) {
275	1865	vg->flags &= ~VSM_FLAG_CLUSTER;
276	1865	VTAILQ_REMOVE(&vg->set->clusters, vg, clist);
277	1865	}
278
279	74590	if (vg->flags & VSM_FLAG_STALE)
280	133	VTAILQ_REMOVE(&vg->set->stale, vg, list);
281		else
282	74457	VTAILQ_REMOVE(&vg->set->segs, vg, list);
283	74590	VAV_Free(vg->av);
284	74590	FREE_OBJ(vg);
285	74723	}
286
287		/--------------------------------------------------------------------/
288
289		static struct vsm_set *
290	4420	vsm_newset(const char *dirname)
291		{
292		struct vsm_set *vs;
293
294	4420	ALLOC_OBJ(vs, VSM_SET_MAGIC);
295	4420	AN(vs);
296	4420	VTAILQ_INIT(&vs->segs);
297	4420	VTAILQ_INIT(&vs->stale);
298	4420	VTAILQ_INIT(&vs->clusters);
299	4420	vs->dname = dirname;
300	4420	vs->dfd = vs->fd = -1;
301	4420	vs->vlu = VLU_New(vsm_vlu_func, vs, 0);
302	4420	AN(vs->vlu);
303	4420	if (getenv("VSM_NOPID") != NULL)
304	0	vs->couldkill = -1;
305	4420	return (vs);
306		}
307
308		static void
309	4364	vsm_delset(struct vsm_set **p)
310		{
311		struct vsm_set *vs;
312		struct vsm_seg *vg;
313
314	4364	TAKE_OBJ_NOTNULL(vs, p, VSM_SET_MAGIC);
315
316	4364	if (vs->fd >= 0)
317	2673	closefd(&vs->fd);
318	4364	if (vs->dfd >= 0)
319	3591	closefd(&vs->dfd);
320	4364	while ((vg = VTAILQ_FIRST(&vs->stale)) != NULL) {
321	0	AN(vg->flags & VSM_FLAG_STALE);
322	0	vsm_delseg(vg, 0);
323		}
324	74680	while ((vg = VTAILQ_FIRST(&vs->segs)) != NULL) {
325	70316	AZ(vg->flags & VSM_FLAG_STALE);
326	70316	vsm_delseg(vg, 0);
327		}
328	4364	assert(VTAILQ_EMPTY(&vs->clusters));
329	4364	VLU_Destroy(&vs->vlu);
330	4364	FREE_OBJ(vs);
331	4364	}
332
333		static void
334	9728	vsm_wash_set(const struct vsm_set *vs, int all)
335		{
336		struct vsm_seg vg, vg2;
337
338	81865	VTAILQ_FOREACH_SAFE(vg, &vs->segs, list, vg2) {
339	72137	if (all \|\| (vg->flags & VSM_FLAG_MARKSCAN) == 0)
340	2404	vsm_delseg(vg, 1);
341	72137	}
342	9728	}
343
344		/--------------------------------------------------------------------/
345
346		struct vsm *
347	2210	VSM_New(void)
348		{
349		struct vsm *vd;
350
351	2210	ALLOC_OBJ(vd, VSM_MAGIC);
352	2210	AN(vd);
353
354	2210	vd->mgt = vsm_newset(VSM_MGT_DIRNAME);
355	2210	vd->mgt->flag_running = VSM_MGT_RUNNING;
356	2210	vd->mgt->flag_changed = VSM_MGT_CHANGED;
357	2210	vd->mgt->flag_restarted = VSM_MGT_RESTARTED;
358
359	2210	vd->child = vsm_newset(VSM_CHILD_DIRNAME);
360	2210	vd->child->flag_running = VSM_WRK_RUNNING;
361	2210	vd->child->flag_changed = VSM_WRK_CHANGED;
362	2210	vd->child->flag_restarted = VSM_WRK_RESTARTED;
363
364	2210	vd->mgt->vsm = vd;
365	2210	vd->child->vsm = vd;
366	2210	vd->wdfd = -1;
367	2210	vd->patience = 5;
368	2210	return (vd);
369		}
370
371		/--------------------------------------------------------------------/
372
373		int
374	2253	VSM_Arg(struct vsm vd, char flag, const char arg)
375		{
376	2253	char *p = NULL;
377
378	2253	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
379
380	2253	if (arg == NULL)
381	40	return (1);
382	2213	switch (flag) {
383		case 't':
384	13	if (!strcasecmp(arg, "off")) {
385	0	vd->patience = -1;
386	0	} else {
387	13	vd->patience = strtod(arg, &p);
388	21	if ((p != NULL && *p != '\0') \|\|
389	8	!isfinite(vd->patience) \|\| vd->patience < 0)
390	14	return (vsm_diag(vd,
391	7	"-t: Invalid argument: %s", arg));
392		}
393	6	break;
394		case 'n':
395	2200	if (vd->wdname != NULL)
396	0	free(vd->wdname);
397	2200	vd->wdname = VIN_n_Arg(arg);
398	2200	if (vd->wdname == NULL)
399	0	return (vsm_diag(vd, "Invalid instance name: %s",
400	0	strerror(errno)));
401	2200	break;
402		default:
403	0	return (vsm_diag(vd, "Unknown VSM_Arg('%c')", flag));
404		}
405	2206	return (1);
406	2253	}
407
408		/--------------------------------------------------------------------/
409
410		void
411	2182	VSM_Destroy(struct vsm **vdp)
412		{
413		struct vsm *vd;
414
415	2182	TAKE_OBJ_NOTNULL(vd, vdp, VSM_MAGIC);
416
417	2182	VSM_ResetError(vd);
418	2182	REPLACE(vd->wdname, NULL);
419	2182	if (vd->diag != NULL)
420	0	VSB_destroy(&vd->diag);
421	2182	if (vd->wdfd >= 0)
422	2180	closefd(&vd->wdfd);
423	2182	vsm_delset(&vd->mgt);
424	2182	vsm_delset(&vd->child);
425	2182	FREE_OBJ(vd);
426	2182	}
427
428		/--------------------------------------------------------------------/
429
430		const char *
431	11	VSM_Error(const struct vsm *vd)
432		{
433
434	11	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
435
436	11	if (vd->diag == NULL)
437	0	return ("No VSM error");
438		else
439	11	return (VSB_data(vd->diag));
440	11	}
441
442		/--------------------------------------------------------------------/
443
444		void
445	4414	VSM_ResetError(struct vsm *vd)
446		{
447
448	4414	CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
449
450	4414	if (vd->diag == NULL)
451	4378	return;
452	36	VSB_destroy(&vd->diag);
453	4414	}
454
455		/*--------------------------------------------------------------------
456		*/
457
458		static int
459	16419	vsm_cmp_av(char * const a1, char const *a2)
460		{
461
462	24235	while (1) {
463	24235	if (a1 == NULL && a2 == NULL)
464	1920	return (0);
465	22315	if (a1 == NULL \|\| a2 == NULL)
466	0	return (1);
467	22315	if (strcmp(a1, a2))
468	14499	return (1);
469	7816	a1++;
470	7816	a2++;
471		}
472	16419	}
473
474		static struct vsm_seg *
475	2020	vsm_findcluster(const struct vsm_set vs, const char cnam)
476		{
477		struct vsm_seg *vg;
478	2020	AN(vs);
479	2020	AN(cnam);
480	2787	VTAILQ_FOREACH(vg, &vs->clusters, clist) {
481	2787	AN(vg->av[1]);
482	2787	if (!strcmp(cnam, vg->av[1]))
483	2020	return (vg);
484	767	}
485	0	return (NULL);
486	2020	}
487
488		static unsigned
489	60476	vsm_running(struct vsm_set *vs, pid_t pid)
490		{
491
492	60476	AN(vs);
493
494	60476	if (pid == 0)
495	0	return (0);
496	60476	assert(pid > 1);
497
498	60476	if (kill(pid, 0) == 0) {
499	58356	vs->couldkill = 1;