GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2016 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include "config.h"

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

#include "cache_varnishd.h"
#include "common/heritage.h"

#include "vcl.h"

#include "cache_director.h"
#include "cache_vcl.h"
#include "vcli_serve.h"
#include "vte.h"
#include "vtim.h"
#include "vcc_interface.h"

const struct vcltemp VCL_TEMP_INIT[1] = {{ .name = "init", .is_cold = 1 }};
const struct vcltemp VCL_TEMP_COLD[1] = {{ .name = "cold", .is_cold = 1 }};
const struct vcltemp VCL_TEMP_WARM[1] = {{ .name = "warm", .is_warm = 1 }};
const struct vcltemp VCL_TEMP_BUSY[1] = {{ .name = "busy", .is_warm = 1 }};
const struct vcltemp VCL_TEMP_COOLING[1] = {{ .name = "cooling" }};

// not really a temperature
static const struct vcltemp VCL_TEMP_LABEL[1] = {{ .name = "label" }};

/*
 * XXX: Presently all modifications to this list happen from the
 * CLI event-engine, so no locking is necessary
 */
static VTAILQ_HEAD(, vcl)       vcl_head =
    VTAILQ_HEAD_INITIALIZER(vcl_head);

struct lock             vcl_mtx;
struct vcl              *vcl_active; /* protected by vcl_mtx */

static struct vrt_ctx ctx_cli;
static struct wrk_vpi wrk_vpi_cli;
static struct ws ws_cli;
static uintptr_t ws_snapshot_cli;
static struct vsl_log vsl_cli;

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

void
VCL_Bo2Ctx(struct vrt_ctx *ctx, struct busyobj *bo)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        CHECK_OBJ_NOTNULL(bo->wrk, WORKER_MAGIC);
        ctx->vcl = bo->vcl;
        ctx->syntax = ctx->vcl->conf->syntax;
        ctx->vsl = bo->vsl;
        ctx->http_bereq = bo->bereq;
        ctx->http_beresp = bo->beresp;
        ctx->bo = bo;
        ctx->sp = bo->sp;
        ctx->now = bo->t_prev;
        ctx->ws = bo->ws;
        ctx->vpi = bo->wrk->vpi;
        ctx->vpi->handling = 0;
        ctx->vpi->trace = bo->trace;
}

void
VCL_Req2Ctx(struct vrt_ctx *ctx, struct req *req)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(req->doclose, STREAM_CLOSE_MAGIC);

        ctx->vcl = req->vcl;
        ctx->syntax = ctx->vcl->conf->syntax;
        ctx->vsl = req->vsl;
        ctx->http_req = req->http;
        CHECK_OBJ_NOTNULL(req->top, REQTOP_MAGIC);
        ctx->http_req_top = req->top->topreq->http;
        ctx->http_resp = req->resp;
        ctx->req = req;
        ctx->sp = req->sp;
        ctx->now = req->t_prev;
        ctx->ws = req->ws;
        ctx->vpi = req->wrk->vpi;
        ctx->vpi->handling = 0;
        ctx->vpi->trace = req->trace;
}

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

struct vrt_ctx *
VCL_Get_CliCtx(int msg)
{

        ASSERT_CLI();
        INIT_OBJ(&ctx_cli, VRT_CTX_MAGIC);
        INIT_OBJ(&wrk_vpi_cli, WRK_VPI_MAGIC);
        ctx_cli.vpi = &wrk_vpi_cli;
        wrk_vpi_cli.trace = FEATURE(FEATURE_TRACE);
        ctx_cli.now = VTIM_real();
        if (msg) {
                ctx_cli.msg = VSB_new_auto();
                AN(ctx_cli.msg);
        } else {
                ctx_cli.vsl = &vsl_cli;
        }
        ctx_cli.ws = &ws_cli;
        WS_Assert(ctx_cli.ws);
        return (&ctx_cli);
}

/*
 * releases CLI ctx
 *
 * returns finished error msg vsb if VCL_Get_CliCtx(1) was called
 *
 * caller needs to VSB_destroy a non-NULL return value
 *
 */
struct vsb *
VCL_Rel_CliCtx(struct vrt_ctx **ctx)
{
        struct vsb *r = NULL;

        ASSERT_CLI();
        assert(*ctx == &ctx_cli);
        AN((*ctx)->vpi);
        if (ctx_cli.msg) {
                TAKE_OBJ_NOTNULL(r, &ctx_cli.msg, VSB_MAGIC);
                AZ(VSB_finish(r));
        }
        if (ctx_cli.vsl)
                VSL_Flush(ctx_cli.vsl, 0);
        WS_Assert(ctx_cli.ws);
        WS_Rollback(&ws_cli, ws_snapshot_cli);
        INIT_OBJ(*ctx, VRT_CTX_MAGIC);
        *ctx = NULL;

        return (r);
}

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

/* VRT_fail() can be called
 * - from the vcl sub via a vmod
 * - via a PRIV_TASK .fini callback
 *
 * if this happens during init, we fail it
 * if during fini, we ignore, because otherwise VMOD authors would be forced to
 * handle VCL_MET_FINI specifically everywhere.
 */

static int
vcl_event_handling(VRT_CTX)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        if (ctx->vpi->handling == 0)
                return (0);

        assert(ctx->vpi->handling == VCL_RET_FAIL);

        if (ctx->method == VCL_MET_INIT)
                return (1);

        /*
         * EVENT_WARM / EVENT_COLD: method == 0
         * must not set handling
         */
        assert(ctx->method == VCL_MET_FINI);

        ctx->vpi->handling = 0;
        VRT_fail(ctx, "VRT_fail() from vcl_fini{} has no effect");
        return (0);
}

static int
vcl_send_event(struct vcl *vcl, enum vcl_event_e ev, struct vsb **msg)
{
        int r, havemsg;
        unsigned method = 0;
        struct vrt_ctx *ctx;

        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);
        AN(msg);
        AZ(*msg);

        switch (ev) {
        case VCL_EVENT_LOAD:
                method = VCL_MET_INIT;
                /* FALLTHROUGH */
        case VCL_EVENT_WARM:
                havemsg = 1;
                break;
        case VCL_EVENT_DISCARD:
                method = VCL_MET_FINI;
                /* FALLTHROUGH */
        case VCL_EVENT_COLD:
                havemsg = 0;
                break;
        default:
                WRONG("vcl_event");
        }

        ctx = VCL_Get_CliCtx(havemsg);

        AN(ctx->vpi);
        AZ(ctx->vpi->handling);
        AN(ctx->ws);

        ctx->vcl = vcl;
        ctx->syntax = ctx->vcl->conf->syntax;
        ctx->method = method;

        VCL_TaskEnter(cli_task_privs);
        r = ctx->vcl->conf->event_vcl(ctx, ev);
        VCL_TaskLeave(ctx, cli_task_privs);
        r |= vcl_event_handling(ctx);

        *msg = VCL_Rel_CliCtx(&ctx);

        if (r && (ev == VCL_EVENT_COLD || ev == VCL_EVENT_DISCARD))
                WRONG("A VMOD cannot fail COLD or DISCARD events");

        return (r);
}

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

struct vcl *
vcl_find(const char *name)
{
        struct vcl *vcl;

        ASSERT_CLI();
        VTAILQ_FOREACH(vcl, &vcl_head, list) {
                if (vcl->discard)
                        continue;
                if (!strcmp(vcl->loaded_name, name))
                        return (vcl);
        }
        return (NULL);
}

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

static void
vcl_panic_conf(struct vsb *vsb, const struct VCL_conf *conf)
{
        unsigned u;
        const struct vpi_ii *ii;

        if (PAN_dump_struct(vsb, conf, VCL_CONF_MAGIC, "conf"))
                return;
        VSB_printf(vsb, "syntax = \"%u\",\n", conf->syntax);
        VSB_cat(vsb, "srcname = {\n");
        VSB_indent(vsb, 2);
        for (u = 0; u < conf->nsrc; ++u)
                VSB_printf(vsb, "[%u] = \"%s\",\n", u, conf->srcname[u]);
        VSB_indent(vsb, -2);
        VSB_cat(vsb, "},\n");
        VSB_cat(vsb, "instances = {\n");
        VSB_indent(vsb, 2);
        ii = conf->instance_info;
        while (ii != NULL && ii->p != NULL) {
                VSB_printf(vsb, "\"%s\" = %p,\n", ii->name,
                    (const void *)*(const uintptr_t *)ii->p);
                ii++;
        }
        VSB_indent(vsb, -2);
        VSB_cat(vsb, "},\n");
        VSB_indent(vsb, -2);
        VSB_cat(vsb, "},\n");
}

void
VCL_Panic(struct vsb *vsb, const char *nm, const struct vcl *vcl)
{

        AN(vsb);
        if (PAN_dump_struct(vsb, vcl, VCL_MAGIC, "vcl[%s]", nm))
                return;
        VSB_printf(vsb, "name = \"%s\",\n", vcl->loaded_name);
        VSB_printf(vsb, "busy = %u,\n", vcl->busy);
        VSB_printf(vsb, "discard = %u,\n", vcl->discard);
        VSB_printf(vsb, "state = %s,\n", vcl->state);
        VSB_printf(vsb, "temp = %s,\n", vcl->temp ? vcl->temp->name : "(null)");
        vcl_panic_conf(vsb, vcl->conf);
        VSB_indent(vsb, -2);
        VSB_cat(vsb, "},\n");
}

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

void
VCL_Update(struct vcl **vcc, struct vcl *vcl)
{
        struct vcl *old;

        AN(vcc);

        old = *vcc;
        *vcc = NULL;

        CHECK_OBJ_ORNULL(old, VCL_MAGIC);
        ASSERT_VCL_ACTIVE();

        Lck_Lock(&vcl_mtx);
        if (old != NULL) {
                assert(old->busy > 0);
                old->busy--;
        }

        if (vcl == NULL)
                vcl = vcl_active; /* Sample vcl_active under lock to avoid
                                   * race */
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        if (vcl->label == NULL) {
                AN(strcmp(vcl->state, VCL_TEMP_LABEL->name));
                *vcc = vcl;
        } else {
                AZ(strcmp(vcl->state, VCL_TEMP_LABEL->name));
                *vcc = vcl->label;
        }
        CHECK_OBJ_NOTNULL(*vcc, VCL_MAGIC);
        AZ((*vcc)->discard);
        (*vcc)->busy++;
        Lck_Unlock(&vcl_mtx);
        assert((*vcc)->temp->is_warm);
}

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

static int
vcl_iterdir(struct cli *cli, const char *pat, const struct vcl *vcl,
    vcl_be_func *func, void *priv)
{
        int i, found = 0;
        struct vcldir *vdir;

        Lck_AssertHeld(&vcl_mtx);
        VTAILQ_FOREACH(vdir, &vcl->director_list, list) {
                if (fnmatch(pat, vdir->cli_name, 0))
                        continue;
                found++;
                i = func(cli, vdir->dir, priv);
                if (i < 0)
                        return (i);
                found += i;
        }
        return (found);
}

int
VCL_IterDirector(struct cli *cli, const char *pat,
    vcl_be_func *func, void *priv)
{
        int i, found = 0;
        struct vsb *vsb;
        struct vcl *vcl;

        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        vsb = VSB_new_auto();
        AN(vsb);
        if (pat == NULL || *pat == '\0' || !strcmp(pat, "*")) {
                // all backends in active VCL
                VSB_printf(vsb, "%s.*", VCL_Name(vcl_active));
                vcl = vcl_active;
        } else if (strchr(pat, '.') == NULL) {
                // pattern applies to active vcl
                VSB_printf(vsb, "%s.%s", VCL_Name(vcl_active), pat);
                vcl = vcl_active;
        } else {
                // use pattern as is
                VSB_cat(vsb, pat);
                vcl = NULL;
        }
        AZ(VSB_finish(vsb));
        Lck_Lock(&vcl_mtx);
        if (vcl != NULL) {
                found = vcl_iterdir(cli, VSB_data(vsb), vcl, func, priv);
        } else {
                VTAILQ_FOREACH(vcl, &vcl_head, list) {
                        i = vcl_iterdir(cli, VSB_data(vsb), vcl, func, priv);
                        if (i < 0) {
                                found = i;
                                break;
                        } else {
                                found += i;
                        }
                }
        }
        Lck_Unlock(&vcl_mtx);
        VSB_destroy(&vsb);
        return (found);
}

static void
vcl_BackendEvent(const struct vcl *vcl, enum vcl_event_e e)
{
        struct vcldir *vdir;

        ASSERT_CLI();
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        AZ(vcl->busy);

        Lck_Lock(&vcl_mtx);
        VTAILQ_FOREACH(vdir, &vcl->director_list, list)
                VDI_Event(vdir->dir, e);
        Lck_Unlock(&vcl_mtx);
}

static void
vcl_KillBackends(const struct vcl *vcl)
{
        struct vcldir *vdir, *vdir2;

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        assert(vcl->temp == VCL_TEMP_COLD || vcl->temp == VCL_TEMP_INIT);
        /*
         * Unlocked because no further directors can be added, and the
         * remaining ones need to be able to remove themselves.
         */
        VTAILQ_FOREACH_SAFE(vdir, &vcl->director_list, list, vdir2)
                VDI_Event(vdir->dir, VCL_EVENT_DISCARD);
        assert(VTAILQ_EMPTY(&vcl->director_list));
}

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

static struct vcl *
VCL_Open(const char *fn, struct vsb *msg)
{
        struct vcl *vcl;
        void *dlh;
        struct VCL_conf const *cnf;
        const char *dlerr;
        int err;

        AN(fn);
        AN(msg);

#ifdef RTLD_NOLOAD
        /* Detect bogus caching by dlopen(3) */
        dlh = dlopen(fn, RTLD_NOW | RTLD_NOLOAD);
        AZ(dlh);
#endif
        dlh = dlopen(fn, RTLD_NOW | RTLD_LOCAL);
        if (dlh == NULL) {
                err = errno;
                dlerr = dlerror();
                VSB_cat(msg, "Could not load compiled VCL.\n");
                if (dlerr != NULL)
                        VSB_printf(msg, "\tdlopen() = %s\n", dlerr);
                if (err) {
                        VSB_printf(msg, "\terror = %s (%d)\n",
                            strerror(err), err);
                }
                VSB_cat(msg, "\thint: check for \"noexec\" mount\n");
                VSB_cat(msg, "\thint: check \"vmod_path\" parameter\n");
                return (NULL);
        }
        cnf = dlsym(dlh, "VCL_conf");
        if (cnf == NULL) {
                VSB_cat(msg, "Compiled VCL lacks metadata.\n");
                (void)dlclose(dlh);
                return (NULL);
        }
        if (cnf->magic != VCL_CONF_MAGIC) {
                VSB_cat(msg, "Compiled VCL has mangled metadata.\n");
                (void)dlclose(dlh);
                return (NULL);
        }
        if (cnf->syntax < heritage.min_vcl_version ||
            cnf->syntax > heritage.max_vcl_version) {
                VSB_printf(msg, "Compiled VCL version (%.1f) not supported.\n",
                    .1 * cnf->syntax);
                (void)dlclose(dlh);
                return (NULL);
        }
        ALLOC_OBJ(vcl, VCL_MAGIC);
        AN(vcl);
        vcl->dlh = dlh;
        vcl->conf = cnf;
        return (vcl);
}

static void
VCL_Close(struct vcl **vclp)
{
        struct vcl *vcl;

        TAKE_OBJ_NOTNULL(vcl, vclp, VCL_MAGIC);
        assert(VTAILQ_EMPTY(&vcl->filters));
        AZ(dlclose(vcl->dlh));
        FREE_OBJ(vcl);
}

/*--------------------------------------------------------------------
 * NB: This function is called in/from the test-load subprocess.
 */

int
VCL_TestLoad(const char *fn)
{
        struct vsb *vsb;
        struct vcl *vcl;
        int retval = 0;

        AN(fn);
        vsb = VSB_new_auto();
        AN(vsb);
        vcl = VCL_Open(fn, vsb);
        if (vcl == NULL) {
                AZ(VSB_finish(vsb));
                fprintf(stderr, "%s", VSB_data(vsb));
                retval = -1;
        } else
                VCL_Close(&vcl);
        VSB_destroy(&vsb);
        return (retval);
}

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

static struct vsb *
vcl_print_refs(const struct vcl *vcl)
{
        struct vsb *msg;
        struct vclref *ref;

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        msg = VSB_new_auto();
        AN(msg);

        VSB_printf(msg, "VCL %s is waiting for:", vcl->loaded_name);
        Lck_Lock(&vcl_mtx);
        VTAILQ_FOREACH(ref, &vcl->ref_list, list)
                VSB_printf(msg, "\n\t- %s", ref->desc);
        Lck_Unlock(&vcl_mtx);
        AZ(VSB_finish(msg));
        return (msg);
}

static int
vcl_set_state(struct vcl *vcl, const char *state, struct vsb **msg)
{
        struct vsb *nomsg = NULL;
        int i = 0;

        ASSERT_CLI();

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        AN(state);
        AN(msg);
        AZ(*msg);

        AN(vcl->temp);

        switch (state[0]) {
        case '0':
                if (vcl->temp == VCL_TEMP_COLD)
                        break;
                if (vcl->busy == 0 && vcl->temp->is_warm) {
                        Lck_Lock(&vcl_mtx);
                        vcl->temp = VTAILQ_EMPTY(&vcl->ref_list) ?
                            VCL_TEMP_COLD : VCL_TEMP_COOLING;
                        Lck_Unlock(&vcl_mtx);
                        vcl_BackendEvent(vcl, VCL_EVENT_COLD);
                        AZ(vcl_send_event(vcl, VCL_EVENT_COLD, msg));
                        AZ(*msg);
                }
                else if (vcl->busy)
                        vcl->temp = VCL_TEMP_BUSY;
                else if (VTAILQ_EMPTY(&vcl->ref_list))
                        vcl->temp = VCL_TEMP_COLD;
                else
                        vcl->temp = VCL_TEMP_COOLING;
                break;
        case '1':
                if (vcl->temp == VCL_TEMP_WARM)
                        break;
                /* The warm VCL hasn't seen a cold event yet */
                if (vcl->temp == VCL_TEMP_BUSY)
                        vcl->temp = VCL_TEMP_WARM;
                /* The VCL must first reach a stable cold state */
                else if (vcl->temp == VCL_TEMP_COOLING) {
                        *msg = vcl_print_refs(vcl);
                        i = -1;
                }
                else {
                        Lck_Lock(&vcl_mtx);
                        vcl->temp = VCL_TEMP_WARM;
                        Lck_Unlock(&vcl_mtx);
                        i = vcl_send_event(vcl, VCL_EVENT_WARM, msg);
                        if (i == 0) {
                                vcl_BackendEvent(vcl, VCL_EVENT_WARM);
                                break;
                        }
                        AZ(vcl_send_event(vcl, VCL_EVENT_COLD, &nomsg));
                        AZ(nomsg);
                        vcl->temp = VCL_TEMP_COLD;
                }
                break;
        default:
                WRONG("Wrong enum state");
        }
        if (i == 0 && state[1])
                bprintf(vcl->state, "%s", state + 1);

        return (i);
}

static void
vcl_cancel_load(struct vcl *vcl, struct cli *cli, struct vsb *msg,
    const char *name, const char *step)
{

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);

        VCLI_SetResult(cli, CLIS_CANT);
        VCLI_Out(cli, "VCL \"%s\" Failed %s", name, step);
        if (VSB_len(msg))
                VCLI_Out(cli, "\nMessage:\n\t%s", VSB_data(msg));
        VSB_destroy(&msg);

        AZ(vcl_send_event(vcl, VCL_EVENT_DISCARD, &msg));
        AZ(msg);

        vcl_KillBackends(vcl);
        free(vcl->loaded_name);
        VCL_Close(&vcl);
}

static void
vcl_load(struct cli *cli,
    const char *name, const char *fn, const char *state)
{
        struct vcl *vcl;
        struct vsb *msg;

        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();

        vcl = vcl_find(name);
        AZ(vcl);

        msg = VSB_new_auto();
        AN(msg);
        vcl = VCL_Open(fn, msg);
        AZ(VSB_finish(msg));
        if (vcl == NULL) {
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "%s", VSB_data(msg));
                VSB_destroy(&msg);
                return;
        }

        VSB_destroy(&msg);

        vcl->loaded_name = strdup(name);
        XXXAN(vcl->loaded_name);
        VTAILQ_INIT(&vcl->director_list);
        VTAILQ_INIT(&vcl->ref_list);
        VTAILQ_INIT(&vcl->filters);

        vcl->temp = VCL_TEMP_INIT;

        if (vcl_send_event(vcl, VCL_EVENT_LOAD, &msg)) {
                vcl_cancel_load(vcl, cli, msg, name, "initialization");
                return;
        }
        VSB_destroy(&msg);

        if (vcl_set_state(vcl, state, &msg)) {
                assert(*state == '1');
                vcl_cancel_load(vcl, cli, msg, name, "warmup");
                return;
        }
        if (msg)
                VSB_destroy(&msg);

        VCLI_Out(cli, "Loaded \"%s\" as \"%s\"", fn , name);
        VTAILQ_INSERT_TAIL(&vcl_head, vcl, list);
        VSC_C_main->n_vcl++;
        VSC_C_main->n_vcl_avail++;
}

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

void
VCL_Poll(void)
{
        struct vsb *nomsg = NULL;
        struct vcl *vcl, *vcl2;

        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        VTAILQ_FOREACH_SAFE(vcl, &vcl_head, list, vcl2) {
                if (vcl->temp == VCL_TEMP_BUSY ||
                    vcl->temp == VCL_TEMP_COOLING)
                        AZ(vcl_set_state(vcl, "0", &nomsg));
                AZ(nomsg);
                if (vcl->discard && vcl->temp == VCL_TEMP_COLD) {
                        AZ(vcl->busy);
                        assert(vcl != vcl_active);
                        assert(VTAILQ_EMPTY(&vcl->ref_list));
                        VTAILQ_REMOVE(&vcl_head, vcl, list);
                        AZ(vcl_send_event(vcl, VCL_EVENT_DISCARD, &nomsg));
                        AZ(nomsg);
                        vcl_KillBackends(vcl);
                        free(vcl->loaded_name);
                        VCL_Close(&vcl);
                        VSC_C_main->n_vcl--;
                        VSC_C_main->n_vcl_discard--;
                }
        }
}

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

static void v_matchproto_(cli_func_t)
vcl_cli_list(struct cli *cli, const char * const *av, void *priv)
{
        struct vcl *vcl;
        const char *flg;
        struct vte *vte;

        /* NB: Shall generate same output as mcf_vcl_list() */

        (void)av;
        (void)priv;
        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        vte = VTE_new(7, 80);
        AN(vte);
        VTAILQ_FOREACH(vcl, &vcl_head, list) {
                if (vcl == vcl_active) {
                        flg = "active";
                } else if (vcl->discard) {
                        flg = "discarded";
                } else
                        flg = "available";
                VTE_printf(vte, "%s\t%s\t%s\t\v%u\t%s", flg, vcl->state,
                    vcl->temp->name, vcl->busy, vcl->loaded_name);
                if (vcl->label != NULL) {
                        VTE_printf(vte, "\t->\t%s", vcl->label->loaded_name);
                        if (vcl->nrefs)
                                VTE_printf(vte, " (%d return(vcl)%s)",
                                    vcl->nrefs, vcl->nrefs > 1 ? "'s" : "");
                } else if (vcl->nlabels > 0) {
                        VTE_printf(vte, "\t<-\t(%d label%s)",
                            vcl->nlabels, vcl->nlabels > 1 ? "s" : "");
                }
                VTE_cat(vte, "\n");
        }
        AZ(VTE_finish(vte));
        AZ(VTE_format(vte, VCLI_VTE_format, cli));
        VTE_destroy(&vte);
}

static void v_matchproto_(cli_func_t)
vcl_cli_list_json(struct cli *cli, const char * const *av, void *priv)
{
        struct vcl *vcl;

        (void)priv;
        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        VCLI_JSON_begin(cli, 2, av);
        VCLI_Out(cli, ",\n");
        VTAILQ_FOREACH(vcl, &vcl_head, list) {
                VCLI_Out(cli, "{\n");
                VSB_indent(cli->sb, 2);
                VCLI_Out(cli, "\"status\": ");
                if (vcl == vcl_active) {
                        VCLI_Out(cli, "\"active\",\n");
                } else if (vcl->discard) {
                        VCLI_Out(cli, "\"discarded\",\n");
                } else
                        VCLI_Out(cli, "\"available\",\n");
                VCLI_Out(cli, "\"state\": \"%s\",\n", vcl->state);
                VCLI_Out(cli, "\"temperature\": \"%s\",\n", vcl->temp->name);
                VCLI_Out(cli, "\"busy\": %u,\n", vcl->busy);
                VCLI_Out(cli, "\"name\": \"%s\"", vcl->loaded_name);
                if (vcl->label != NULL) {
                        VCLI_Out(cli, ",\n");
                        VCLI_Out(cli, "\"label\": {\n");
                        VSB_indent(cli->sb, 2);
                                VCLI_Out(cli, "\"name\": \"%s\"",
                                         vcl->label->loaded_name);
                        if (vcl->nrefs)
                                VCLI_Out(cli, ",\n\"refs\": %d", vcl->nrefs);
                        VCLI_Out(cli, "\n");
                        VCLI_Out(cli, "}");
                        VSB_indent(cli->sb, -2);
                } else if (vcl->nlabels > 0) {
                        VCLI_Out(cli, ",\n");
                        VCLI_Out(cli, "\"labels\": %d", vcl->nlabels);
                }
                VSB_indent(cli->sb, -2);
                VCLI_Out(cli, "\n}");
                if (VTAILQ_NEXT(vcl, list) != NULL)
                        VCLI_Out(cli, ",\n");
        }
        VCLI_JSON_end(cli);
}

static void v_matchproto_(cli_func_t)
vcl_cli_load(struct cli *cli, const char * const *av, void *priv)
{

        AZ(priv);
        ASSERT_CLI();
        // XXX move back code from vcl_load?
        vcl_load(cli, av[2], av[3], av[4]);
}

static void v_matchproto_(cli_func_t)
vcl_cli_state(struct cli *cli, const char * const *av, void *priv)
{
        struct vcl *vcl;
        struct vsb *msg = NULL;

        AZ(priv);
        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        AN(av[2]);
        AN(av[3]);

        vcl = vcl_find(av[2]);
        AN(vcl);

        if (vcl_set_state(vcl, av[3], &msg)) {
                CHECK_OBJ_NOTNULL(msg, VSB_MAGIC);

                VCLI_SetResult(cli, CLIS_CANT);
                VCLI_Out(cli, "Failed <vcl.state %s %s>", vcl->loaded_name,
                    av[3] + 1);
                if (VSB_len(msg))
                        VCLI_Out(cli, "\nMessage:\n\t%s", VSB_data(msg));
        }
        if (msg)
                VSB_destroy(&msg);
}

static void v_matchproto_(cli_func_t)
vcl_cli_discard(struct cli *cli, const char * const *av, void *priv)
{
        struct vcl *vcl;

        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        (void)cli;
        AZ(priv);
        vcl = vcl_find(av[2]);
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);              // MGT ensures this
        Lck_Lock(&vcl_mtx);
        assert (vcl != vcl_active);     // MGT ensures this
        AZ(vcl->nlabels);               // MGT ensures this
        VSC_C_main->n_vcl_discard++;
        VSC_C_main->n_vcl_avail--;
        vcl->discard = 1;
        if (vcl->label != NULL) {
                AZ(strcmp(vcl->state, VCL_TEMP_LABEL->name));
                vcl->label->nlabels--;
                vcl->label= NULL;
        }
        Lck_Unlock(&vcl_mtx);

        if (!strcmp(vcl->state, VCL_TEMP_LABEL->name)) {
                VTAILQ_REMOVE(&vcl_head, vcl, list);
                free(vcl->loaded_name);
                FREE_OBJ(vcl);
        } else if (vcl->temp == VCL_TEMP_COLD) {
                VCL_Poll();
        }
}

static void v_matchproto_(cli_func_t)
vcl_cli_label(struct cli *cli, const char * const *av, void *priv)
{
        struct vcl *lbl;
        struct vcl *vcl;

        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        (void)cli;
        (void)priv;
        vcl = vcl_find(av[3]);
        AN(vcl);                                // MGT ensures this
        lbl = vcl_find(av[2]);
        if (lbl == NULL) {
                ALLOC_OBJ(lbl, VCL_MAGIC);
                AN(lbl);
                bprintf(lbl->state, "%s", VCL_TEMP_LABEL->name);
                lbl->temp = VCL_TEMP_WARM;
                REPLACE(lbl->loaded_name, av[2]);
                VTAILQ_INSERT_TAIL(&vcl_head, lbl, list);
        }
        if (lbl->label != NULL)
                lbl->label->nlabels--;
        lbl->label = vcl;
        vcl->nlabels++;
}

static void v_matchproto_(cli_func_t)
vcl_cli_use(struct cli *cli, const char * const *av, void *priv)
{
        struct vcl *vcl;

        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        AN(cli);
        AZ(priv);
        vcl = vcl_find(av[2]);
        AN(vcl);                                // MGT ensures this
        assert(vcl->temp == VCL_TEMP_WARM);     // MGT ensures this
        Lck_Lock(&vcl_mtx);
        vcl_active = vcl;
        Lck_Unlock(&vcl_mtx);
}

static void v_matchproto_(cli_func_t)
vcl_cli_show(struct cli *cli, const char * const *av, void *priv)
{
        struct vcl *vcl;
        int verbose = 0;
        int i = 2;
        unsigned u;

        ASSERT_CLI();
        ASSERT_VCL_ACTIVE();
        AZ(priv);

        if (av[i] != NULL && !strcmp(av[i], "-v")) {
                verbose = 1;
                i++;
        }

        if (av[i] == NULL) {
                vcl = vcl_active;
                AN(vcl);
        } else {
                vcl = vcl_find(av[i]);
                i++;
        }

        if (av[i] != NULL) {
                VCLI_Out(cli, "Too many parameters: '%s'", av[i]);
                VCLI_SetResult(cli, CLIS_PARAM);
                return;
        }

        if (vcl == NULL) {
                VCLI_Out(cli, "No VCL named '%s'", av[i - 1]);
                VCLI_SetResult(cli, CLIS_PARAM);
                return;
        }
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        if (vcl->label) {
                vcl = vcl->label;
                CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
                AZ(vcl->label);
        }
        CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);
        if (verbose) {
                for (u = 0; u < vcl->conf->nsrc; u++)
                        VCLI_Out(cli, "// VCL.SHOW %u %zd %s\n%s\n",
                            u, strlen(vcl->conf->srcbody[u]),
                            vcl->conf->srcname[u],
                            vcl->conf->srcbody[u]);
        } else {
                VCLI_Out(cli, "%s", vcl->conf->srcbody[0]);
        }
}

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

static struct cli_proto vcl_cmds[] = {
        { CLICMD_VCL_LOAD,              "", vcl_cli_load },
        { CLICMD_VCL_LIST,              "", vcl_cli_list, vcl_cli_list_json },
        { CLICMD_VCL_STATE,             "", vcl_cli_state },
        { CLICMD_VCL_DISCARD,           "", vcl_cli_discard },
        { CLICMD_VCL_USE,               "", vcl_cli_use },
        { CLICMD_VCL_SHOW,              "", vcl_cli_show },
        { CLICMD_VCL_LABEL,             "", vcl_cli_label },
        { NULL }
};

void
VCL_Init(void)
{

        assert(cache_param->workspace_client > 0);
        WS_Init(&ws_cli, "cli", malloc(cache_param->workspace_client),
            cache_param->workspace_client);
        ws_snapshot_cli = WS_Snapshot(&ws_cli);
        CLI_AddFuncs(vcl_cmds);
        Lck_New(&vcl_mtx, lck_vcl);
        VSL_Setup(&vsl_cli, NULL, 0);
}

		varnish-cache/bin/varnishd/cache/cache_vcl.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2016 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		*/
31
32		#include "config.h"
33
34		#include <dlfcn.h>
35		#include <fnmatch.h>
36		#include <stdio.h>
37		#include <stdlib.h>
38
39		#include "cache_varnishd.h"
40		#include "common/heritage.h"
41
42		#include "vcl.h"
43
44		#include "cache_director.h"
45		#include "cache_vcl.h"
46		#include "vcli_serve.h"
47		#include "vte.h"
48		#include "vtim.h"
49		#include "vcc_interface.h"
50
51		const struct vcltemp VCL_TEMP_INIT[1] = {{ .name = "init", .is_cold = 1 }};
52		const struct vcltemp VCL_TEMP_COLD[1] = {{ .name = "cold", .is_cold = 1 }};
53		const struct vcltemp VCL_TEMP_WARM[1] = {{ .name = "warm", .is_warm = 1 }};
54		const struct vcltemp VCL_TEMP_BUSY[1] = {{ .name = "busy", .is_warm = 1 }};
55		const struct vcltemp VCL_TEMP_COOLING[1] = {{ .name = "cooling" }};
56
57		// not really a temperature
58		static const struct vcltemp VCL_TEMP_LABEL[1] = {{ .name = "label" }};
59
60		/*
61		* XXX: Presently all modifications to this list happen from the
62		* CLI event-engine, so no locking is necessary
63		*/
64		static VTAILQ_HEAD(, vcl) vcl_head =
65		VTAILQ_HEAD_INITIALIZER(vcl_head);
66
67		struct lock vcl_mtx;
68		struct vcl vcl_active; / protected by vcl_mtx */
69
70		static struct vrt_ctx ctx_cli;
71		static struct wrk_vpi wrk_vpi_cli;
72		static struct ws ws_cli;
73		static uintptr_t ws_snapshot_cli;
74		static struct vsl_log vsl_cli;
75
76		/--------------------------------------------------------------------/
77
78		void
79	597983	VCL_Bo2Ctx(struct vrt_ctx ctx, struct busyobj bo)
80		{
81
82	597983	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
83	597983	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
84	597983	CHECK_OBJ_NOTNULL(bo->wrk, WORKER_MAGIC);
85	597983	ctx->vcl = bo->vcl;
86	597983	ctx->syntax = ctx->vcl->conf->syntax;
87	597983	ctx->vsl = bo->vsl;
88	597983	ctx->http_bereq = bo->bereq;
89	597983	ctx->http_beresp = bo->beresp;
90	597983	ctx->bo = bo;
91	597983	ctx->sp = bo->sp;
92	597983	ctx->now = bo->t_prev;
93	597983	ctx->ws = bo->ws;
94	597983	ctx->vpi = bo->wrk->vpi;
95	597983	ctx->vpi->handling = 0;
96	597983	ctx->vpi->trace = bo->trace;
97	597983	}
98
99		void
100	957148	VCL_Req2Ctx(struct vrt_ctx ctx, struct req req)
101		{
102
103	957148	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
104	957148	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
105	957148	CHECK_OBJ_NOTNULL(req->doclose, STREAM_CLOSE_MAGIC);
106
107	957148	ctx->vcl = req->vcl;
108	957148	ctx->syntax = ctx->vcl->conf->syntax;
109	957148	ctx->vsl = req->vsl;
110	957148	ctx->http_req = req->http;
111	957148	CHECK_OBJ_NOTNULL(req->top, REQTOP_MAGIC);
112	957148	ctx->http_req_top = req->top->topreq->http;
113	957148	ctx->http_resp = req->resp;
114	957148	ctx->req = req;
115	957148	ctx->sp = req->sp;
116	957148	ctx->now = req->t_prev;
117	957148	ctx->ws = req->ws;
118	957148	ctx->vpi = req->wrk->vpi;
119	957148	ctx->vpi->handling = 0;
120	957148	ctx->vpi->trace = req->trace;
121	957148	}
122
123		/--------------------------------------------------------------------/
124
125		struct vrt_ctx *
126	148398	VCL_Get_CliCtx(int msg)
127		{
128
129	148398	ASSERT_CLI();
130	148398	INIT_OBJ(&ctx_cli, VRT_CTX_MAGIC);
131	148398	INIT_OBJ(&wrk_vpi_cli, WRK_VPI_MAGIC);
132	148398	ctx_cli.vpi = &wrk_vpi_cli;
133	148398	wrk_vpi_cli.trace = FEATURE(FEATURE_TRACE);
134	148398	ctx_cli.now = VTIM_real();
135	148398	if (msg) {
136	93200	ctx_cli.msg = VSB_new_auto();
137	93200	AN(ctx_cli.msg);
138	93200	} else {
139	55198	ctx_cli.vsl = &vsl_cli;
140		}
141	148398	ctx_cli.ws = &ws_cli;
142	148398	WS_Assert(ctx_cli.ws);
143	148398	return (&ctx_cli);
144		}
145
146		/*
147		* releases CLI ctx
148		*
149		* returns finished error msg vsb if VCL_Get_CliCtx(1) was called
150		*
151		* caller needs to VSB_destroy a non-NULL return value
152		*
153		*/
154		struct vsb *
155	148358	VCL_Rel_CliCtx(struct vrt_ctx **ctx)
156		{
157	148358	struct vsb *r = NULL;
158
159	148358	ASSERT_CLI();
160	148358	assert(*ctx == &ctx_cli);
161	148358	AN((*ctx)->vpi);
162	148358	if (ctx_cli.msg) {
163	93200	TAKE_OBJ_NOTNULL(r, &ctx_cli.msg, VSB_MAGIC);
164	93200	AZ(VSB_finish(r));
165	93200	}
166	148358	if (ctx_cli.vsl)
167	55158	VSL_Flush(ctx_cli.vsl, 0);
168	148358	WS_Assert(ctx_cli.ws);
169	148358	WS_Rollback(&ws_cli, ws_snapshot_cli);
170	148358	INIT_OBJ(*ctx, VRT_CTX_MAGIC);
171	148358	*ctx = NULL;
172
173	148358	return (r);
174		}
175
176		/--------------------------------------------------------------------/
177
178		/* VRT_fail() can be called
179		* - from the vcl sub via a vmod
180		* - via a PRIV_TASK .fini callback
181		*
182		* if this happens during init, we fail it
183		* if during fini, we ignore, because otherwise VMOD authors would be forced to
184		* handle VCL_MET_FINI specifically everywhere.
185		*/
186
187		static int
188	98158	vcl_event_handling(VRT_CTX)
189		{
190	98158	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
191
192	98158	if (ctx->vpi->handling == 0)
193	96438	return (0);
194
195	1720	assert(ctx->vpi->handling == VCL_RET_FAIL);
196
197	1720	if (ctx->method == VCL_MET_INIT)
198	1640	return (1);
199
200		/*
201		* EVENT_WARM / EVENT_COLD: method == 0
202		* must not set handling
203		*/
204	80	assert(ctx->method == VCL_MET_FINI);
205
206	80	ctx->vpi->handling = 0;
207	80	VRT_fail(ctx, "VRT_fail() from vcl_fini{} has no effect");
208	80	return (0);
209	98158	}
210
211		static int
212	98198	vcl_send_event(struct vcl vcl, enum vcl_event_e ev, struct vsb *msg)
213		{
214		int r, havemsg;
215	98198	unsigned method = 0;
216		struct vrt_ctx *ctx;
217
218	98198	ASSERT_CLI();
219	98198	ASSERT_VCL_ACTIVE();
220
221	98198	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
222	98198	CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);
223	98198	AN(msg);
224	98198	AZ(*msg);
225
226	98198	switch (ev) {
227		case VCL_EVENT_LOAD:
228	47400	method = VCL_MET_INIT;
229		/* FALLTHROUGH */
230		case VCL_EVENT_WARM:
231	93200	havemsg = 1;
232	93200	break;
233		case VCL_EVENT_DISCARD:
234	3101	method = VCL_MET_FINI;
235		/* FALLTHROUGH */
236		case VCL_EVENT_COLD:
237	4998	havemsg = 0;
238	4998	break;
239		default:
240	0	WRONG("vcl_event");
241	0	}
242
243	98198	ctx = VCL_Get_CliCtx(havemsg);
244
245	98198	AN(ctx->vpi);
246	98198	AZ(ctx->vpi->handling);
247	98198	AN(ctx->ws);
248
249	98198	ctx->vcl = vcl;
250	98198	ctx->syntax = ctx->vcl->conf->syntax;
251	98198	ctx->method = method;
252
253	98198	VCL_TaskEnter(cli_task_privs);
254	98198	r = ctx->vcl->conf->event_vcl(ctx, ev);
255	98198	VCL_TaskLeave(ctx, cli_task_privs);
256	98198	r \|= vcl_event_handling(ctx);
257
258	98198	*msg = VCL_Rel_CliCtx(&ctx);
259
260	98198	if (r && (ev == VCL_EVENT_COLD \|\| ev == VCL_EVENT_DISCARD))
261	0	WRONG("A VMOD cannot fail COLD or DISCARD events");
262
263	98198	return (r);
264		}
265
266		/--------------------------------------------------------------------/
267
268		struct vcl *
269	98880	vcl_find(const char *name)
270		{
271		struct vcl *vcl;
272
273	98880	ASSERT_CLI();
274	149252	VTAILQ_FOREACH(vcl, &vcl_head, list) {
275	100812	if (vcl->discard)
276	52	continue;
277	100760	if (!strcmp(vcl->loaded_name, name))
278	50440	return (vcl);
279	50320	}
280	48440	return (NULL);
281	98880	}
282
283		/--------------------------------------------------------------------/
284
285		static void
286	280	vcl_panic_conf(struct vsb vsb, const struct VCL_conf conf)
287		{
288		unsigned u;
289		const struct vpi_ii *ii;
290
291	280	if (PAN_dump_struct(vsb, conf, VCL_CONF_MAGIC, "conf"))
292	0	return;
293	280	VSB_printf(vsb, "syntax = \"%u\",\n", conf->syntax);
294	280	VSB_cat(vsb, "srcname = {\n");
295	280	VSB_indent(vsb, 2);
296	840	for (u = 0; u < conf->nsrc; ++u)
297	560	VSB_printf(vsb, "[%u] = \"%s\",\n", u, conf->srcname[u]);
298	280	VSB_indent(vsb, -2);
299	280	VSB_cat(vsb, "},\n");
300	280	VSB_cat(vsb, "instances = {\n");
301	280	VSB_indent(vsb, 2);
302	280	ii = conf->instance_info;
303	440	while (ii != NULL && ii->p != NULL) {
304	320	VSB_printf(vsb, "\"%s\" = %p,\n", ii->name,
305	160	(const void )(const uintptr_t *)ii->p);
306	160	ii++;
307		}
308	280	VSB_indent(vsb, -2);
309	280	VSB_cat(vsb, "},\n");
310	280	VSB_indent(vsb, -2);
311	280	VSB_cat(vsb, "},\n");
312	280	}
313
314		void
315	520	VCL_Panic(struct vsb vsb, const char nm, const struct vcl *vcl)
316		{
317
318	520	AN(vsb);
319	520	if (PAN_dump_struct(vsb, vcl, VCL_MAGIC, "vcl[%s]", nm))
320	240	return;
321	280	VSB_printf(vsb, "name = \"%s\",\n", vcl->loaded_name);
322	280	VSB_printf(vsb, "busy = %u,\n", vcl->busy);
323	280	VSB_printf(vsb, "discard = %u,\n", vcl->discard);
324	280	VSB_printf(vsb, "state = %s,\n", vcl->state);
325	280	VSB_printf(vsb, "temp = %s,\n", vcl->temp ? vcl->temp->name : "(null)");
326	280	vcl_panic_conf(vsb, vcl->conf);
327	280	VSB_indent(vsb, -2);
328	280	VSB_cat(vsb, "},\n");
329	520	}
330
331		/--------------------------------------------------------------------/
332
333		void
334	54882	VCL_Update(struct vcl *vcc, struct vcl vcl)
335		{
336		struct vcl *old;
337
338	54882	AN(vcc);
339
340	54882	old = *vcc;
341	54882	*vcc = NULL;
342
343	54882	CHECK_OBJ_ORNULL(old, VCL_MAGIC);
344	54882	ASSERT_VCL_ACTIVE();
345
346	54882	Lck_Lock(&vcl_mtx);
347	54882	if (old != NULL) {
348	2779	assert(old->busy > 0);
349	2779	old->busy--;
350	2779	}
351
352	54882	if (vcl == NULL)
353	54362	vcl = vcl_active; /* Sample vcl_active under lock to avoid
354		* race */
355	54882	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
356	54882	if (vcl->label == NULL) {
357	54242	AN(strcmp(vcl->state, VCL_TEMP_LABEL->name));
358	54242	*vcc = vcl;
359	54242	} else {
360	640	AZ(strcmp(vcl->state, VCL_TEMP_LABEL->name));
361	640	*vcc = vcl->label;
362		}
363	54882	CHECK_OBJ_NOTNULL(*vcc, VCL_MAGIC);
364	54882	AZ((*vcc)->discard);
365	54882	(*vcc)->busy++;
366	54882	Lck_Unlock(&vcl_mtx);
367	54882	assert((*vcc)->temp->is_warm);
368	54882	}
369
370		/--------------------------------------------------------------------/
371
372		static int
373	37840	vcl_iterdir(struct cli cli, const char pat, const struct vcl *vcl,
374		vcl_be_func func, void priv)
375		{
376	37840	int i, found = 0;
377		struct vcldir *vdir;
378
379	37840	Lck_AssertHeld(&vcl_mtx);
380	93320	VTAILQ_FOREACH(vdir, &vcl->director_list, list) {
381	55480	if (fnmatch(pat, vdir->cli_name, 0))
382	3880	continue;
383	51600	found++;
384	51600	i = func(cli, vdir->dir, priv);
385	51600	if (i < 0)
386	0	return (i);
387	51600	found += i;
388	51600	}
389	37840	return (found);
390	37840	}
391
392		int
393	37840	VCL_IterDirector(struct cli cli, const char pat,
394		vcl_be_func func, void priv)
395		{
396	37840	int i, found = 0;
397		struct vsb *vsb;
398		struct vcl *vcl;
399
400	37840	ASSERT_CLI();
401	37840	ASSERT_VCL_ACTIVE();
402	37840	vsb = VSB_new_auto();
403	37840	AN(vsb);
404	37840	if (pat == NULL \|\| pat == '\0' \|\| !strcmp(pat, "")) {
405		// all backends in active VCL
406	36080	VSB_printf(vsb, "%s.*", VCL_Name(vcl_active));
407	36080	vcl = vcl_active;
408	37840	} else if (strchr(pat, '.') == NULL) {
409		// pattern applies to active vcl
410	1520	VSB_printf(vsb, "%s.%s", VCL_Name(vcl_active), pat);
411	1520	vcl = vcl_active;
412	1520	} else {
413		// use pattern as is
414	240	VSB_cat(vsb, pat);
415	240	vcl = NULL;
416		}
417	37840	AZ(VSB_finish(vsb));
418	37840	Lck_Lock(&vcl_mtx);
419	37840	if (vcl != NULL) {
420	37600	found = vcl_iterdir(cli, VSB_data(vsb), vcl, func, priv);
421	37600	} else {
422	480	VTAILQ_FOREACH(vcl, &vcl_head, list) {
423	240	i = vcl_iterdir(cli, VSB_data(vsb), vcl, func, priv);
424	240	if (i < 0) {
425	0	found = i;
426	0	break;
427		} else {
428	240	found += i;
429		}
430	240	}
431		}
432	37840	Lck_Unlock(&vcl_mtx);
433	37840	VSB_destroy(&vsb);
434	37840	return (found);
435		}
436
437		static void
438	47457	vcl_BackendEvent(const struct vcl *vcl, enum vcl_event_e e)
439		{
440		struct vcldir *vdir;
441
442	47457	ASSERT_CLI();
443	47457	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
444	47457	AZ(vcl->busy);
445
446	47457	Lck_Lock(&vcl_mtx);
447	107790	VTAILQ_FOREACH(vdir, &vcl->director_list, list)
448	60333	VDI_Event(vdir->dir, e);
449	47457	Lck_Unlock(&vcl_mtx);
450	47457	}
451
452		static void
453	3101	vcl_KillBackends(const struct vcl *vcl)
454		{
455		struct vcldir vdir, vdir2;
456
457	3101	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
458	3101	assert(vcl->temp == VCL_TEMP_COLD \|\| vcl->temp == VCL_TEMP_INIT);
459		/*
460		* Unlocked because no further directors can be added, and the
461		* remaining ones need to be able to remove themselves.
462		*/
463	5762	VTAILQ_FOREACH_SAFE(vdir, &vcl->director_list, list, vdir2)
464	2661	VDI_Event(vdir->dir, VCL_EVENT_DISCARD);
465	3101	assert(VTAILQ_EMPTY(&vcl->director_list));
466	3101	}
467
468		/--------------------------------------------------------------------/
469
470		static struct vcl *
471	95200	VCL_Open(const char fn, struct vsb msg)
472		{
473		struct vcl *vcl;
474		void *dlh;
475		struct VCL_conf const *cnf;
476		const char *dlerr;
477		int err;
478
479	95200	AN(fn);
480	95200	AN(msg);
481
482		#ifdef RTLD_NOLOAD
483		/* Detect bogus caching by dlopen(3) */
484	95200	dlh = dlopen(fn, RTLD_NOW \| RTLD_NOLOAD);
485	95200	AZ(dlh);
486		#endif
487	95200	dlh = dlopen(fn, RTLD_NOW \| RTLD_LOCAL);
488	95200	if (dlh == NULL) {
489	40	err = errno;
490	40	dlerr = dlerror();
491	40	VSB_cat(msg, "Could not load compiled VCL.\n");
492	40	if (dlerr != NULL)
493	40	VSB_printf(msg, "\tdlopen() = %s\n", dlerr);
494	40	if (err) {
495	0	VSB_printf(msg, "\terror = %s (%d)\n",
496	0	strerror(err), err);
497	0	}
498	40	VSB_cat(msg, "\thint: check for \"noexec\" mount\n");
499	40	VSB_cat(msg, "\thint: check \"vmod_path\" parameter\n");