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 <stdio.h>
#include <stdlib.h>

#include "cache_varnishd.h"

#include "vcl.h"
#include "vtim.h"
#include "vbm.h"

#include "cache_director.h"
#include "cache_transport.h"
#include "cache_vcl.h"
#include "vcc_interface.h"

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

const char *
VCL_Return_Name(unsigned r)
{

        switch (r) {
#define VCL_RET_MAC(l, U, B)    \
        case VCL_RET_##U:       \
                return(#l);
#include "tbl/vcl_returns.h"
        default:
                return (NULL);
        }
}

const char *
VCL_Method_Name(unsigned m)
{

        switch (m) {
#define VCL_MET_MAC(func, upper, typ, bitmap)   \
        case VCL_MET_##upper:                   \
                return (#upper);
#include "tbl/vcl_returns.h"
        default:
                return (NULL);
        }
}

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

void
VCL_Refresh(struct vcl **vcc)
{

        while (vcl_active == NULL)
                (void)usleep(100000);

        ASSERT_VCL_ACTIVE();
        if (*vcc == vcl_active)
                return;

        VCL_Update(vcc, NULL);
}

void
VCL_Recache(const struct worker *wrk, struct vcl **vclp)
{

        AN(wrk);
        AN(vclp);
        CHECK_OBJ_NOTNULL(*vclp, VCL_MAGIC);
        ASSERT_VCL_ACTIVE();

        if (*vclp != vcl_active || wrk->wpriv->vcl == vcl_active) {
                VCL_Rel(vclp);
                return;
        }
        if (wrk->wpriv->vcl != NULL)
                VCL_Rel(&wrk->wpriv->vcl);
        wrk->wpriv->vcl = *vclp;
        *vclp = NULL;
}

void
VCL_Ref(struct vcl *vcl)
{

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        assert(!vcl->temp->is_cold);
        Lck_Lock(&vcl_mtx);
        assert(vcl->busy > 0);
        vcl->busy++;
        Lck_Unlock(&vcl_mtx);
}

void
VCL_Rel(struct vcl **vcc)
{
        struct vcl *vcl;

        TAKE_OBJ_NOTNULL(vcl, vcc, VCL_MAGIC);
        Lck_Lock(&vcl_mtx);
        assert(vcl->busy > 0);
        vcl->busy--;
        /*
         * We do not garbage collect discarded VCL's here, that happens
         * in VCL_Poll() which is called from the CLI thread.
         */
        Lck_Unlock(&vcl_mtx);
}

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

static void
vcldir_free(struct vcldir *vdir)
{

        CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
        CHECK_OBJ_NOTNULL(vdir->dir, DIRECTOR_MAGIC);
        AZ(vdir->refcnt);
        Lck_Delete(&vdir->dlck);
        free(vdir->cli_name);
        FREE_OBJ(vdir->dir);
        FREE_OBJ(vdir);
}

static VCL_BACKEND
vcldir_surplus(struct vcldir *vdir)
{

        CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
        assert(vdir->refcnt == 1);
        vdir->refcnt = 0;
        vcldir_free(vdir);
        return (NULL);
}

VCL_BACKEND
VRT_AddDirector(VRT_CTX, const struct vdi_methods *m, void *priv,
    const char *fmt, ...)
{
        struct vsb *vsb;
        struct vcl *vcl;
        struct vcldir *vdir;
        const struct vcltemp *temp;
        va_list ap;
        int i;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(m, VDI_METHODS_MAGIC);
        AN(fmt);
        vcl = ctx->vcl;
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);

        // opportunistic, re-checked again under lock
        if (vcl->temp == VCL_TEMP_COOLING && !DO_DEBUG(DBG_VTC_MODE))
                return (NULL);

        ALLOC_OBJ(vdir, VCLDIR_MAGIC);
        AN(vdir);
        ALLOC_OBJ(vdir->dir, DIRECTOR_MAGIC);
        AN(vdir->dir);
        vdir->dir->vdir = vdir;

        vdir->methods = m;
        vdir->dir->priv = priv;
        vsb = VSB_new_auto();
        AN(vsb);
        VSB_printf(vsb, "%s.", VCL_Name(vcl));
        i = VSB_len(vsb);
        va_start(ap, fmt);
        VSB_vprintf(vsb, fmt, ap);
        va_end(ap);
        AZ(VSB_finish(vsb));
        REPLACE(vdir->cli_name, VSB_data(vsb));
        VSB_destroy(&vsb);
        vdir->dir->vcl_name = vdir->cli_name + i;

        vdir->vcl = vcl;
        vdir->admin_health = VDI_AH_AUTO;
        vdir->health_changed = VTIM_real();

        vdir->refcnt++;
        Lck_New(&vdir->dlck, lck_director);
        vdir->dir->mtx = &vdir->dlck;

        /* NB: at this point we look at the VCL temperature after getting
         * through the trouble of creating the director even though it might
         * not be legal to do so. Because we change the VCL temperature before
         * sending COLD events we have to tolerate and undo attempts for the
         * COOLING case.
         *
         * To avoid deadlocks during vcl_BackendEvent, we only wait for vcl_mtx
         * if the vcl is busy (ref vcl_set_state())
         */

        while (1) {
                temp = vcl->temp;
                if (temp == VCL_TEMP_COOLING)
                        return (vcldir_surplus(vdir));
                if (vcl->busy == 0 && vcl->temp->is_warm) {
                        if (! Lck_Trylock(&vcl_mtx))
                                break;
                        usleep(10 * 1000);
                        continue;
                }
                Lck_Lock(&vcl_mtx);
                break;
        }
        Lck_AssertHeld(&vcl_mtx);
        temp = vcl->temp;
        if (temp != VCL_TEMP_COOLING)
                VTAILQ_INSERT_TAIL(&vcl->director_list, vdir, list);
        if (temp->is_warm)
                VDI_Event(vdir->dir, VCL_EVENT_WARM);
        Lck_Unlock(&vcl_mtx);

        if (temp == VCL_TEMP_COOLING)
                return (vcldir_surplus(vdir));

        if (!temp->is_warm && temp != VCL_TEMP_INIT)
                WRONG("Dynamic Backends can only be added to warm VCLs");

        return (vdir->dir);
}

void
VRT_StaticDirector(VCL_BACKEND b)
{
        struct vcldir *vdir;

        CHECK_OBJ_NOTNULL(b, DIRECTOR_MAGIC);
        vdir = b->vdir;
        CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
        assert(vdir->refcnt == 1);
        AZ(vdir->flags & VDIR_FLG_NOREFCNT);
        vdir->flags |= VDIR_FLG_NOREFCNT;
}

static void
vcldir_retire(struct vcldir *vdir)
{
        const struct vcltemp *temp;

        CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
        assert(vdir->refcnt == 0);
        CHECK_OBJ_NOTNULL(vdir->vcl, VCL_MAGIC);

        Lck_Lock(&vcl_mtx);
        temp = vdir->vcl->temp;
        VTAILQ_REMOVE(&vdir->vcl->director_list, vdir, list);
        Lck_Unlock(&vcl_mtx);

        if (temp->is_warm)
                VDI_Event(vdir->dir, VCL_EVENT_COLD);
        if (vdir->methods->destroy != NULL)
                vdir->methods->destroy(vdir->dir);
        vcldir_free(vdir);
}

static int
vcldir_deref(struct vcldir *vdir)
{
        int busy;

        CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
        AZ(vdir->flags & VDIR_FLG_NOREFCNT);

        Lck_Lock(&vdir->dlck);
        assert(vdir->refcnt > 0);
        busy = --vdir->refcnt;
        Lck_Unlock(&vdir->dlck);

        if (!busy)
                vcldir_retire(vdir);
        return (busy);
}

void
VRT_DelDirector(VCL_BACKEND *dirp)
{
        VCL_BACKEND dir;
        struct vcldir *vdir;

        TAKE_OBJ_NOTNULL(dir, dirp, DIRECTOR_MAGIC);

        vdir = dir->vdir;
        CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);

        if (vdir->methods->release != NULL)
                vdir->methods->release(vdir->dir);

        if (vdir->flags & VDIR_FLG_NOREFCNT) {
                vdir->flags &= ~VDIR_FLG_NOREFCNT;
                AZ(vcldir_deref(vdir));
        } else {
                (void) vcldir_deref(vdir);
        }
}

void
VRT_Assign_Backend(VCL_BACKEND *dst, VCL_BACKEND src)
{
        struct vcldir *vdir;

        AN(dst);
        CHECK_OBJ_ORNULL((*dst), DIRECTOR_MAGIC);
        CHECK_OBJ_ORNULL(src, DIRECTOR_MAGIC);
        if (*dst != NULL) {
                vdir = (*dst)->vdir;
                CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
                if (!(vdir->flags & VDIR_FLG_NOREFCNT))
                        (void)vcldir_deref(vdir);
        }
        if (src != NULL) {
                vdir = src->vdir;
                CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
                if (!(vdir->flags & VDIR_FLG_NOREFCNT)) {
                        Lck_Lock(&vdir->dlck);
                        assert(vdir->refcnt > 0);
                        vdir->refcnt++;
                        Lck_Unlock(&vdir->dlck);
                }
        }
        *dst = src;
}

void
VRT_DisableDirector(VCL_BACKEND d)
{
        struct vcldir *vdir;

        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
        vdir = d->vdir;
        CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);

        vdir->admin_health = VDI_AH_DELETED;
        vdir->health_changed = VTIM_real();
}

VCL_BACKEND
VRT_LookupDirector(VRT_CTX, VCL_STRING name)
{
        struct vcl *vcl;
        struct vcldir *vdir;
        VCL_BACKEND dd, d = NULL;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(name);

        assert(ctx->method & VCL_MET_TASK_H);
        ASSERT_CLI();

        vcl = ctx->vcl;
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);

        Lck_Lock(&vcl_mtx);
        VTAILQ_FOREACH(vdir, &vcl->director_list, list) {
                dd = vdir->dir;
                if (strcmp(dd->vcl_name, name))
                        continue;
                d = dd;
                break;
        }
        Lck_Unlock(&vcl_mtx);

        return (d);
}

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

VCL_BACKEND
VCL_DefaultDirector(const struct vcl *vcl)
{

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);
        return (*vcl->conf->default_director);
}

const char *
VCL_Name(const struct vcl *vcl)
{

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        return (vcl->loaded_name);
}

VCL_PROBE
VCL_DefaultProbe(const struct vcl *vcl)
{

        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);
        return (vcl->conf->default_probe);
}

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

void
VRT_CTX_Assert(VRT_CTX)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        if (ctx->msg != NULL)
                CHECK_OBJ(ctx->msg, VSB_MAGIC);
        else
                AN(ctx->vsl);
        CHECK_OBJ_NOTNULL(ctx->vcl, VCL_MAGIC);
        WS_Assert(ctx->ws);

        CHECK_OBJ_ORNULL(ctx->sp, SESS_MAGIC);

        CHECK_OBJ_ORNULL(ctx->req, REQ_MAGIC);
        CHECK_OBJ_ORNULL(ctx->http_req, HTTP_MAGIC);
        CHECK_OBJ_ORNULL(ctx->http_req_top, HTTP_MAGIC);
        CHECK_OBJ_ORNULL(ctx->http_resp, HTTP_MAGIC);

        CHECK_OBJ_ORNULL(ctx->bo, BUSYOBJ_MAGIC);
        CHECK_OBJ_ORNULL(ctx->http_bereq, HTTP_MAGIC);
        CHECK_OBJ_ORNULL(ctx->http_beresp, HTTP_MAGIC);
}

struct vclref *
VRT_VCL_Prevent_Cold(VRT_CTX, const char *desc)
{
        struct vclref* ref;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->vcl, VCL_MAGIC);

        ALLOC_OBJ(ref, VCLREF_MAGIC);
        AN(ref);
        ref->vcl = ctx->vcl;
        REPLACE(ref->desc, desc);

        VCL_Ref(ctx->vcl);

        Lck_Lock(&vcl_mtx);
        VTAILQ_INSERT_TAIL(&ctx->vcl->ref_list, ref, list);
        Lck_Unlock(&vcl_mtx);

        return (ref);
}

void
VRT_VCL_Allow_Cold(struct vclref **refp)
{
        struct vcl *vcl;
        struct vclref *ref;

        TAKE_OBJ_NOTNULL(ref, refp, VCLREF_MAGIC);
        vcl = ref->vcl;
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);

        Lck_Lock(&vcl_mtx);
        assert(!VTAILQ_EMPTY(&vcl->ref_list));
        VTAILQ_REMOVE(&vcl->ref_list, ref, list);
        Lck_Unlock(&vcl_mtx);

        VCL_Rel(&vcl);

        REPLACE(ref->desc, NULL);
        FREE_OBJ(ref);
}

struct vclref *
VRT_VCL_Prevent_Discard(VRT_CTX, const char *desc)
{
        struct vcl *vcl;
        struct vclref* ref;

        ASSERT_CLI();
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(desc);
        AN(*desc);

        vcl = ctx->vcl;
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
        assert(vcl->temp->is_warm);

        ALLOC_OBJ(ref, VCLREF_MAGIC);
        AN(ref);
        ref->vcl = vcl;
        REPLACE(ref->desc, desc);

        Lck_Lock(&vcl_mtx);
        VTAILQ_INSERT_TAIL(&vcl->ref_list, ref, list);
        vcl->nrefs++;
        Lck_Unlock(&vcl_mtx);

        return (ref);
}

void
VRT_VCL_Allow_Discard(struct vclref **refp)
{
        struct vcl *vcl;
        struct vclref *ref;

        TAKE_OBJ_NOTNULL(ref, refp, VCLREF_MAGIC);
        vcl = ref->vcl;
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);

        /* NB: A VCL may be released by a VMOD at any time, but it must happen
         * after a warmup and before the end of a cooldown. The release may or
         * may not happen while the same thread holds the temperature lock, so
         * instead we check that all references are gone in VCL_Nuke.
         */

        Lck_Lock(&vcl_mtx);
        assert(!VTAILQ_EMPTY(&vcl->ref_list));
        VTAILQ_REMOVE(&vcl->ref_list, ref, list);
        vcl->nrefs--;
        /* No garbage collection here, for the same reasons as in VCL_Rel. */
        Lck_Unlock(&vcl_mtx);

        REPLACE(ref->desc, NULL);
        FREE_OBJ(ref);
}

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

static int
req_poll(struct worker *wrk, struct req *req)
{
        struct req *top;

        /* NB: Since a fail transition leads to vcl_synth, the request may be
         * short-circuited twice.
         */
        if (req->req_reset) {
                wrk->vpi->handling = VCL_RET_FAIL;
                return (-1);
        }

        top = req->top->topreq;
        CHECK_OBJ_NOTNULL(top, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(top->transport, TRANSPORT_MAGIC);

        if (!FEATURE(FEATURE_VCL_REQ_RESET))
                return (0);
        if (top->transport->poll == NULL)
                return (0);
        if (top->transport->poll(top) >= 0)
                return (0);

        VSLb_ts_req(req, "Reset", W_TIM_real(wrk));
        wrk->stats->req_reset++;
        wrk->vpi->handling = VCL_RET_FAIL;
        req->req_reset = 1;
        return (-1);
}

/*--------------------------------------------------------------------
 * Method functions to call into VCL programs.
 *
 * Either the request or busyobject must be specified, but not both.
 * The workspace argument is where random VCL stuff gets space from.
 */

static void
vcl_call_method(struct worker *wrk, struct req *req, struct busyobj *bo,
    void *specific, unsigned method, vcl_func_f *func, unsigned track_call)
{
        uintptr_t rws = 0, aws;
        struct vrt_ctx ctx;
        struct vbitmap *vbm;
        void *p;
        size_t sz;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        INIT_OBJ(&ctx, VRT_CTX_MAGIC);
        if (bo != NULL) {
                CHECK_OBJ(bo, BUSYOBJ_MAGIC);
                CHECK_OBJ_NOTNULL(bo->vcl, VCL_MAGIC);
                VCL_Bo2Ctx(&ctx, bo);
        }
        if (req != NULL) {
                if (bo != NULL)
                        assert(method == VCL_MET_PIPE);
                CHECK_OBJ(req, REQ_MAGIC);
                CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);
                CHECK_OBJ_NOTNULL(req->vcl, VCL_MAGIC);
                CHECK_OBJ_NOTNULL(req->top, REQTOP_MAGIC);
                if (req_poll(wrk, req))
                        return;
                VCL_Req2Ctx(&ctx, req);
        }
        assert(ctx.now != 0);
        ctx.specific = specific;
        ctx.method = method;
        if (track_call > 0) {
                rws = WS_Snapshot(wrk->aws);
                sz = VBITMAP_SZ(track_call);
                p = WS_Alloc(wrk->aws, sz);
                // No use to attempt graceful failure, all VCL calls will fail
                AN(p);
                vbm = vbit_init(p, sz);
                ctx.called = vbm;
        }
        aws = WS_Snapshot(wrk->aws);
        wrk->cur_method = method;
        wrk->seen_methods |= method;
        AN(ctx.vsl);
        VSLbs(ctx.vsl, SLT_VCL_call, TOSTRAND(VCL_Method_Name(method)));
        func(&ctx, VSUB_STATIC, NULL);
        VSLbs(ctx.vsl, SLT_VCL_return,
            TOSTRAND(VCL_Return_Name(wrk->vpi->handling)));
        wrk->cur_method |= 1;           // Magic marker
        if (wrk->vpi->handling == VCL_RET_FAIL)
                wrk->stats->vcl_fail++;

        /*
         * VCL/Vmods are not allowed to make permanent allocations from
         * wrk->aws, but they can reserve and return from it.
         */
        assert(aws == WS_Snapshot(wrk->aws));
        if (rws != 0)
                WS_Reset(wrk->aws, rws);
}

#define VCL_MET_MAC(func, upper, typ, bitmap)                           \
void                                                                    \
VCL_##func##_method(struct vcl *vcl, struct worker *wrk,                \
     struct req *req, struct busyobj *bo, void *specific)               \
{                                                                       \
                                                                        \
        CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);                              \
        CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);                   \
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);                           \
        vcl_call_method(wrk, req, bo, specific,                         \
            VCL_MET_ ## upper, vcl->conf->func##_func, vcl->conf->nsub);\
        AN((1U << wrk->vpi->handling) & bitmap);                        \
}

#include "tbl/vcl_returns.h"

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

VCL_STRING
VRT_check_call(VRT_CTX, VCL_SUB sub)
{
        VCL_STRING err = NULL;
        enum vcl_func_fail_e fail;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(sub, VCL_SUB_MAGIC);

        AN(sub->func);
        sub->func(ctx, VSUB_CHECK, &fail);

        switch (fail) {
        case VSUB_E_OK:
                break;
        case VSUB_E_METHOD:
                err = WS_Printf(ctx->ws, "Dynamic call to \"sub %s{}\""
                    " not allowed from here", sub->name);
                if (err == NULL)
                        err = "Dynamic call not allowed and workspace overflow";
                break;
        case VSUB_E_RECURSE:
                err = WS_Printf(ctx->ws, "Recursive dynamic call to"
                    " \"sub %s{}\"", sub->name);
                if (err == NULL)
                        err = "Recursive dynamic call and workspace overflow";
                break;
        default:
                INCOMPL();
        }

        return (err);
}

VCL_VOID
VRT_call(VRT_CTX, VCL_SUB sub)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(sub, VCL_SUB_MAGIC);

        AZ(VRT_handled(ctx));
        AN(sub->func);
        sub->func(ctx, VSUB_DYNAMIC, NULL);
}

		varnish-cache/bin/varnishd/cache/cache_vrt_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	825	* 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	164245	* 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	300	* 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	3600	* SUCH DAMAGE.
29		*
30		*/
31
32		#include "config.h"
33
34		#include <stdio.h>
35		#include <stdlib.h>
36
37		#include "cache_varnishd.h"
38
39		#include "vcl.h"
40		#include "vtim.h"
41		#include "vbm.h"
42
43		#include "cache_director.h"
44	105446	#include "cache_transport.h"
45		#include "cache_vcl.h"
46		#include "vcc_interface.h"
47
48		/--------------------------------------------------------------------/
49
50	60035	const char *
51	450795	VCL_Return_Name(unsigned r)
52		{
53
54	450795	switch (r) {
55		#define VCL_RET_MAC(l, U, B) \
56		case VCL_RET_##U: \
57		return(#l);
58	0	#include "tbl/vcl_returns.h"
59		default:
60	150	return (NULL);
61		}
62	450795	}
63	18649
64		const char *
65	451185	VCL_Method_Name(unsigned m)
66		{
67
68	451185	switch (m) {
69		#define VCL_MET_MAC(func, upper, typ, bitmap) \
70	1475	case VCL_MET_##upper: \
71		return (#upper);
72		#include "tbl/vcl_returns.h"
73		default:
74	0	return (NULL);
75	175	}
76	451185	}
77
78		/--------------------------------------------------------------------/
79	1700
80		void
81	76788	VCL_Refresh(struct vcl **vcc)
82		{
83
84	76788	while (vcl_active == NULL)
85	0	(void)usleep(100000);
86
87	76788	ASSERT_VCL_ACTIVE();
88	76786	if (*vcc == vcl_active)
89	45059	return;
90
91	32702	VCL_Update(vcc, NULL);
92	76786	}
93
94	7125	void
95	76932	VCL_Recache(const struct worker wrk, struct vcl *vclp)
96		{
97
98	76932	AN(wrk);
99	76932	AN(vclp);
100	76932	CHECK_OBJ_NOTNULL(*vclp, VCL_MAGIC);
101	76932	ASSERT_VCL_ACTIVE();
102
103	76934	if (*vclp != vcl_active \|\| wrk->wpriv->vcl == vcl_active) {
104	1749	VCL_Rel(vclp);
105	1324	return;
106		}
107	75610	if (wrk->wpriv->vcl != NULL)
108	0	VCL_Rel(&wrk->wpriv->vcl);
109	75610	wrk->wpriv->vcl = *vclp;
110	75610	*vclp = NULL;
111	76934	}
112	8801
113		void
114	63450	VCL_Ref(struct vcl *vcl)
115		{
116
117	63450	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
118	63450	assert(!vcl->temp->is_cold);
119	117872	Lck_Lock(&vcl_mtx);
120	63450	assert(vcl->busy > 0);
121	63450	vcl->busy++;
122	63450	Lck_Unlock(&vcl_mtx);
123	63450	}
124
125		void
126	118830	VCL_Rel(struct vcl **vcc)
127		{
128		struct vcl *vcl;
129
130	70532	TAKE_OBJ_NOTNULL(vcl, vcc, VCL_MAGIC);
131	70532	Lck_Lock(&vcl_mtx);
132	70532	assert(vcl->busy > 0);
133	70532	vcl->busy--;
134		/*
135	76076	* We do not garbage collect discarded VCL's here, that happens
136		* in VCL_Poll() which is called from the CLI thread.
137		*/
138	70532	Lck_Unlock(&vcl_mtx);
139	70532	}
140
141		/--------------------------------------------------------------------/
142	0
143		static void
144	2643	vcldir_free(struct vcldir *vdir)
145		{
146	85716
147	2643	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
148	2643	CHECK_OBJ_NOTNULL(vdir->dir, DIRECTOR_MAGIC);
149	2643	AZ(vdir->refcnt);
150	2643	Lck_Delete(&vdir->dlck);
151	28612	free(vdir->cli_name);
152	2643	FREE_OBJ(vdir->dir);
153	2643	FREE_OBJ(vdir);
154	2643	}
155
156		static VCL_BACKEND
157	0	vcldir_surplus(struct vcldir *vdir)
158		{
159	0
160	0	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
161	0	assert(vdir->refcnt == 1);
162	0	vdir->refcnt = 0;
163	0	vcldir_free(vdir);
164	33625	return (NULL);
165		}
166
167		VCL_BACKEND
168	35275	VRT_AddDirector(VRT_CTX, const struct vdi_methods m, void priv,
169		const char *fmt, ...)
170		{
171		struct vsb *vsb;
172	18349	struct vcl *vcl;
173		struct vcldir *vdir;
174		const struct vcltemp *temp;
175		va_list ap;
176		int i;
177
178	35275	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
179	36025	CHECK_OBJ_NOTNULL(m, VDI_METHODS_MAGIC);
180	35275	AN(fmt);
181	35275	vcl = ctx->vcl;
182	35275	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
183
184		// opportunistic, re-checked again under lock
185	35450	if (vcl->temp == VCL_TEMP_COOLING && !DO_DEBUG(DBG_VTC_MODE))
186	0	return (NULL);
187
188	35275	ALLOC_OBJ(vdir, VCLDIR_MAGIC);
189	35275	AN(vdir);
190	35275	ALLOC_OBJ(vdir->dir, DIRECTOR_MAGIC);
191	122755	AN(vdir->dir);
192	35275	vdir->dir->vdir = vdir;
193
194	35275	vdir->methods = m;
195	35275	vdir->dir->priv = priv;
196	35275	vsb = VSB_new_auto();
197	35275	AN(vsb);
198	35275	VSB_printf(vsb, "%s.", VCL_Name(vcl));
199	35275	i = VSB_len(vsb);
200	35275	va_start(ap, fmt);
201	35275	VSB_vprintf(vsb, fmt, ap);
202	46799	va_end(ap);
203	35275	AZ(VSB_finish(vsb));
204	35275	REPLACE(vdir->cli_name, VSB_data(vsb));
205	35275	VSB_destroy(&vsb);
206	35275	vdir->dir->vcl_name = vdir->cli_name + i;
207
208	35275	vdir->vcl = vcl;
209	35275	vdir->admin_health = VDI_AH_AUTO;
210	35275	vdir->health_changed = VTIM_real();
211
212	35275	vdir->refcnt++;
213	35275	Lck_New(&vdir->dlck, lck_director);
214	35275	vdir->dir->mtx = &vdir->dlck;
215
216		/* NB: at this point we look at the VCL temperature after getting
217		* through the trouble of creating the director even though it might
218		* not be legal to do so. Because we change the VCL temperature before
219		* sending COLD events we have to tolerate and undo attempts for the
220		* COOLING case.
221		*
222		* To avoid deadlocks during vcl_BackendEvent, we only wait for vcl_mtx
223		* if the vcl is busy (ref vcl_set_state())
224		*/
225
226	35275	while (1) {
227	35275	temp = vcl->temp;
228	35275	if (temp == VCL_TEMP_COOLING)
229	0	return (vcldir_surplus(vdir));
230	35275	if (vcl->busy == 0 && vcl->temp->is_warm) {
231	2100	if (! Lck_Trylock(&vcl_mtx))
232	2100	break;
233	0	usleep(10 * 1000);
234	0	continue;
235		}
236	33175	Lck_Lock(&vcl_mtx);
237	33175	break;
238		}
239	35275	Lck_AssertHeld(&vcl_mtx);
240	35275	temp = vcl->temp;
241	35275	if (temp != VCL_TEMP_COOLING)
242	35275	VTAILQ_INSERT_TAIL(&vcl->director_list, vdir, list);
243	35275	if (temp->is_warm)
244	2450	VDI_Event(vdir->dir, VCL_EVENT_WARM);
245	35275	Lck_Unlock(&vcl_mtx);
246
247	35275	if (temp == VCL_TEMP_COOLING)
248	0	return (vcldir_surplus(vdir));
249
250	35275	if (!temp->is_warm && temp != VCL_TEMP_INIT)
251	25	WRONG("Dynamic Backends can only be added to warm VCLs");
252
253	35250	return (vdir->dir);
254	35250	}
255
256		void
257	30825	VRT_StaticDirector(VCL_BACKEND b)
258		{
259		struct vcldir *vdir;
260
261	30825	CHECK_OBJ_NOTNULL(b, DIRECTOR_MAGIC);
262	30825	vdir = b->vdir;
263	30825	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
264	30825	assert(vdir->refcnt == 1);
265	30825	AZ(vdir->flags & VDIR_FLG_NOREFCNT);
266	30825	vdir->flags \|= VDIR_FLG_NOREFCNT;
267	30825	}
268
269		static void
270	2643	vcldir_retire(struct vcldir *vdir)
271		{
272		const struct vcltemp *temp;
273
274	2643	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
275	2643	assert(vdir->refcnt == 0);
276	2643	CHECK_OBJ_NOTNULL(vdir->vcl, VCL_MAGIC);
277
278	2643	Lck_Lock(&vcl_mtx);
279	2643	temp = vdir->vcl->temp;
280	2643	VTAILQ_REMOVE(&vdir->vcl->director_list, vdir, list);
281	2643	Lck_Unlock(&vcl_mtx);
282
283	2643	if (temp->is_warm)
284	350	VDI_Event(vdir->dir, VCL_EVENT_COLD);
285	2643	if (vdir->methods->destroy != NULL)
286	2271	vdir->methods->destroy(vdir->dir);
287	2643	vcldir_free(vdir);
288	2643	}
289
290		static int
291	7841	vcldir_deref(struct vcldir *vdir)
292		{
293		int busy;
294
295	7841	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
296	7841	AZ(vdir->flags & VDIR_FLG_NOREFCNT);
297
298	7841	Lck_Lock(&vdir->dlck);
299	7841	assert(vdir->refcnt > 0);
300	7841	busy = --vdir->refcnt;
301	7841	Lck_Unlock(&vdir->dlck);
302
303	7841	if (!busy)
304	2643	vcldir_retire(vdir);
305	7841	return (busy);
306		}
307
308		void
309	2293	VRT_DelDirector(VCL_BACKEND *dirp)
310		{
311		VCL_BACKEND dir;
312		struct vcldir *vdir;
313
314	2293	TAKE_OBJ_NOTNULL(dir, dirp, DIRECTOR_MAGIC);
315
316	2293	vdir = dir->vdir;
317	2293	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
318
319	2293	if (vdir->methods->release != NULL)
320	325	vdir->methods->release(vdir->dir);
321
322	2293	if (vdir->flags & VDIR_FLG_NOREFCNT) {
323	1546	vdir->flags &= ~VDIR_FLG_NOREFCNT;
324	1546	AZ(vcldir_deref(vdir));
325	1546	} else {
326	747	(void) vcldir_deref(vdir);
327		}
328	2293	}
329
330		void
331	407639	VRT_Assign_Backend(VCL_BACKEND *dst, VCL_BACKEND src)
332		{
333		struct vcldir *vdir;
334
335	407639	AN(dst);
336	407639	CHECK_OBJ_ORNULL((*dst), DIRECTOR_MAGIC);
337	407639	CHECK_OBJ_ORNULL(src, DIRECTOR_MAGIC);
338	407639	if (*dst != NULL) {
339	198151	vdir = (*dst)->vdir;
340	198151	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
341	198151	if (!(vdir->flags & VDIR_FLG_NOREFCNT))
342	5549	(void)vcldir_deref(vdir);
343	198151	}
344	407639	if (src != NULL) {
345	199732	vdir = src->vdir;
346	199732	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
347	199732	if (!(vdir->flags & VDIR_FLG_NOREFCNT)) {
348	5325	Lck_Lock(&vdir->dlck);
349	5325	assert(vdir->refcnt > 0);
350	5325	vdir->refcnt++;
351	5325	Lck_Unlock(&vdir->dlck);
352	5325	}
353	199732	}
354	407639	*dst = src;
355	407639	}
356
357		void
358	1896	VRT_DisableDirector(VCL_BACKEND d)
359		{
360		struct vcldir *vdir;
361
362	1896	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
363	1896	vdir = d->vdir;
364	1896	CHECK_OBJ_NOTNULL(vdir, VCLDIR_MAGIC);
365
366	1896	vdir->admin_health = VDI_AH_DELETED;
367	1896	vdir->health_changed = VTIM_real();
368	1896	}
369
370		VCL_BACKEND
371	25	VRT_LookupDirector(VRT_CTX, VCL_STRING name)
372		{
373		struct vcl *vcl;
374		struct vcldir *vdir;
375	25	VCL_BACKEND dd, d = NULL;
376
377	25	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
378	25	AN(name);
379
380	25	assert(ctx->method & VCL_MET_TASK_H);
381	25	ASSERT_CLI();
382
383	25	vcl = ctx->vcl;
384	25	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
385
386	25	Lck_Lock(&vcl_mtx);
387	25	VTAILQ_FOREACH(vdir, &vcl->director_list, list) {
388	25	dd = vdir->dir;
389	25	if (strcmp(dd->vcl_name, name))
390	0	continue;
391	25	d = dd;
392	25	break;
393		}
394	25	Lck_Unlock(&vcl_mtx);
395
396	25	return (d);
397		}
398
399		/--------------------------------------------------------------------/
400
401		VCL_BACKEND
402	85989	VCL_DefaultDirector(const struct vcl *vcl)
403		{
404
405	85989	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
406	85989	CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);
407	85989	return (*vcl->conf->default_director);
408		}
409
410		const char *
411	224734	VCL_Name(const struct vcl *vcl)
412		{
413
414	224734	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
415	224734	return (vcl->loaded_name);
416		}
417
418		VCL_PROBE
419	31000	VCL_DefaultProbe(const struct vcl *vcl)
420		{
421
422	31000	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
423	31000	CHECK_OBJ_NOTNULL(vcl->conf, VCL_CONF_MAGIC);
424	31000	return (vcl->conf->default_probe);
425		}
426
427		/--------------------------------------------------------------------/
428
429		void
430	6748	VRT_CTX_Assert(VRT_CTX)
431		{
432	6748	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
433
434	6748	if (ctx->msg != NULL)
435	550	CHECK_OBJ(ctx->msg, VSB_MAGIC);
436		else
437	6198	AN(ctx->vsl);
438	6748	CHECK_OBJ_NOTNULL(ctx->vcl, VCL_MAGIC);
439	6748	WS_Assert(ctx->ws);
440
441	6748	CHECK_OBJ_ORNULL(ctx->sp, SESS_MAGIC);
442
443	6748	CHECK_OBJ_ORNULL(ctx->req, REQ_MAGIC);
444	6748	CHECK_OBJ_ORNULL(ctx->http_req, HTTP_MAGIC);
445	6748	CHECK_OBJ_ORNULL(ctx->http_req_top, HTTP_MAGIC);
446	6748	CHECK_OBJ_ORNULL(ctx->http_resp, HTTP_MAGIC);
447
448	6748	CHECK_OBJ_ORNULL(ctx->bo, BUSYOBJ_MAGIC);
449	6748	CHECK_OBJ_ORNULL(ctx->http_bereq, HTTP_MAGIC);
450	6748	CHECK_OBJ_ORNULL(ctx->http_beresp, HTTP_MAGIC);
451	6748	}
452
453		struct vclref *
454	25	VRT_VCL_Prevent_Cold(VRT_CTX, const char *desc)
455		{
456		struct vclref* ref;
457
458	25	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
459	25	CHECK_OBJ_NOTNULL(ctx->vcl, VCL_MAGIC);
460
461	25	ALLOC_OBJ(ref, VCLREF_MAGIC);
462	25	AN(ref);
463	25	ref->vcl = ctx->vcl;
464	25	REPLACE(ref->desc, desc);
465
466	25	VCL_Ref(ctx->vcl);
467
468	25	Lck_Lock(&vcl_mtx);
469	25	VTAILQ_INSERT_TAIL(&ctx->vcl->ref_list, ref, list);
470	25	Lck_Unlock(&vcl_mtx);
471
472	25	return (ref);
473		}
474
475		void
476	25	VRT_VCL_Allow_Cold(struct vclref **refp)
477		{
478		struct vcl *vcl;
479		struct vclref *ref;
480
481	25	TAKE_OBJ_NOTNULL(ref, refp, VCLREF_MAGIC);
482	25	vcl = ref->vcl;
483	25	CHECK_OBJ_NOTNULL(vcl, VCL_MAGIC);
484
485	25	Lck_Lock(&vcl_mtx);
486	25	assert(!VTAILQ_EMPTY(&vcl->ref_list));
487	25	VTAILQ_REMOVE(&vcl->ref_list, ref, list);
488	25	Lck_Unlock(&vcl_mtx);
489
490	25	VCL_Rel(&vcl);
491
492	25	REPLACE(ref->desc, NULL);
493	25	FREE_OBJ(ref);
494	25	}
495
496		struct vclref *
497	2075	VRT_VCL_Prevent_Discard(VRT_CTX, const char *desc)
498		{
499		struct vcl *vcl;