GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2011 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.
 *
 * Poll backends for collection of health statistics
 *
 * We co-opt threads from the worker pool for probing the backends,
 * but we want to avoid a potentially messy cleanup operation when we
 * retire the backend, so the thread owns the health information, which
 * the backend references, rather than the other way around.
 *
 */

#include "config.h"

#include <poll.h>
#include <stdio.h>
#include <stdlib.h>

#include "cache_varnishd.h"

#include "vbh.h"
#include "vsa.h"
#include "vtcp.h"
#include "vtim.h"

#include "cache_backend.h"
#include "cache_conn_pool.h"

#include "VSC_vbe.h"

struct vbp_state {
        const char                      *name;
};

#define VBP_STATE(n) static const struct vbp_state vbp_state_ ## n [1] = {{ .name = #n }}
VBP_STATE(scheduled);
VBP_STATE(running);
VBP_STATE(cold);
VBP_STATE(cooling);
VBP_STATE(deleted);
#undef VBP_STATE

/* Default averaging rate, we want something pretty responsive */
#define AVG_RATE                        4

struct vbp_target {
        unsigned                        magic;
#define VBP_TARGET_MAGIC                0x6b7cb656

        VRT_BACKEND_PROBE_FIELDS()

        struct backend                  *backend;
        struct conn_pool                *conn_pool;

        char                            *req;
        int                             req_len;

        char                            resp_buf[128];
        unsigned                        good;

        /* Collected statistics */
#define BITMAP(n, c, t, b)      uintmax_t       n;
#include "tbl/backend_poll.h"

        vtim_dur                        last;
        vtim_dur                        avg;
        double                          rate;

        vtim_real                       due;
        const struct vbp_state          *state;
        int                             heap_idx;
        struct pool_task                task[1];
};

static struct lock                      vbp_mtx;
static pthread_cond_t                   vbp_cond;
static struct vbh                       *vbp_heap;

static const unsigned char vbp_proxy_local[] = {
        0x0d, 0x0a, 0x0d, 0x0a, 0x00, 0x0d, 0x0a, 0x51,
        0x55, 0x49, 0x54, 0x0a, 0x20, 0x00, 0x00, 0x00,
};

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

static void
vbp_delete(struct vbp_target *vt)
{
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);

        assert(vt->heap_idx == VBH_NOIDX);

#define DN(x)   /**/
        VRT_BACKEND_PROBE_HANDLE();
#undef DN
        VCP_Rel(&vt->conn_pool);
        free(vt->req);
        FREE_OBJ(vt);
}


/*--------------------------------------------------------------------
 * Record pokings...
 */

static void
vbp_start_poke(struct vbp_target *vt)
{
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);

#define BITMAP(n, c, t, b) \
        vt->n <<= 1;
#include "tbl/backend_poll.h"

        vt->last = 0;
        vt->resp_buf[0] = '\0';
}

static void
vbp_has_poked(struct vbp_target *vt)
{
        unsigned i, j;
        uint64_t u;

        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);

        /* Calculate exponential average */
        if (vt->happy & 1) {
                if (vt->rate < AVG_RATE)
                        vt->rate += 1.0;
                vt->avg += (vt->last - vt->avg) / vt->rate;
        }

        u = vt->happy;
        for (i = j = 0; i < vt->window; i++) {
                if (u & 1)
                        j++;
                u >>= 1;
        }
        vt->good = j;
}

void
VBP_Update_Backend(struct vbp_target *vt)
{
        unsigned i = 0, chg;
        char bits[10];

        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);

#define BITMAP(n, c, t, b)                      \
        bits[i++] = (vt->n & 1) ? c : '-';
#include "tbl/backend_poll.h"
        bits[i] = '\0';
        assert(i < sizeof bits);

        Lck_Lock(&vbp_mtx);
        if (vt->backend == NULL) {
                Lck_Unlock(&vbp_mtx);
                return;
        }

        i = (vt->good < vt->threshold);
        chg = (i != vt->backend->sick);
        vt->backend->sick = i;
        if (i && chg && vt->backend->director != NULL)
                VDI_Event(vt->backend->director, VDI_EVENT_SICK);

        AN(vt->backend->vcl_name);
        VSL(SLT_Backend_health, NO_VXID,
            "%s %s %s %s %u %u %u %.6f %.6f \"%s\"",
            vt->backend->vcl_name, chg ? "Went" : "Still",
            i ? "sick" : "healthy", bits,
            vt->good, vt->threshold, vt->window,
            vt->last, vt->avg, vt->resp_buf);
        vt->backend->vsc->happy = vt->happy;
        if (chg)
                vt->backend->changed = VTIM_real();
        Lck_Unlock(&vbp_mtx);
}

static void
vbp_reset(struct vbp_target *vt)
{
        unsigned u;

        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
        vt->avg = 0.0;
        vt->rate = 0.0;
#define BITMAP(n, c, t, b) \
        vt->n = 0;
#include "tbl/backend_poll.h"

        for (u = 0; u < vt->initial; u++) {
                vbp_start_poke(vt);
                vt->happy |= 1;
                vbp_has_poked(vt);
        }
}

/*--------------------------------------------------------------------
 * Poke one backend, once, but possibly at both IPv4 and IPv6 addresses.
 *
 * We do deliberately not use the stuff in cache_backend.c, because we
 * want to measure the backends response without local distractions.
 */

static int
vbp_write(struct vbp_target *vt, int *sock, const void *buf, size_t len)
{
        int i;

        i = write(*sock, buf, len);
        VTCP_Assert(i);
        if (i != len) {
                if (i < 0) {
                        vt->err_xmit |= 1;
                        bprintf(vt->resp_buf, "Write error %d (%s)",
                                errno, VAS_errtxt(errno));
                } else {
                        bprintf(vt->resp_buf,
                                "Short write (%d/%zu) error %d (%s)",
                                i, len, errno, VAS_errtxt(errno));
                }
                VTCP_close(sock);
                return (-1);
        }
        return (0);
}

static int
vbp_write_proxy_v1(struct vbp_target *vt, int *sock)
{
        char buf[105]; /* maximum size for a TCP6 PROXY line with null char */
        char addr[VTCP_ADDRBUFSIZE];
        char port[VTCP_PORTBUFSIZE];
        char vsabuf[vsa_suckaddr_len];
        const struct suckaddr *sua;
        int proto;
        struct vsb vsb;

        sua = VSA_getsockname(*sock, vsabuf, sizeof vsabuf);
        AN(sua);
        AN(VSB_init(&vsb, buf, sizeof buf));

        proto = VSA_Get_Proto(sua);
        if (proto == AF_INET || proto == AF_INET6) {
                VTCP_name(sua, addr, sizeof addr, port, sizeof port);
                VSB_printf(&vsb, "PROXY %s %s %s %s %s\r\n",
                    proto == AF_INET ? "TCP4" : "TCP6",
                    addr, addr, port, port);
        } else {
                VSB_cat(&vsb, "PROXY UNKNOWN\r\n");
        }
        AZ(VSB_finish(&vsb));

        VSB_fini(&vsb);
        return (vbp_write(vt, sock, buf, strlen(buf)));
}

static void
vbp_poke(struct vbp_target *vt)
{
        int s, i, proxy_header, err;
        vtim_real t_start, t_now, t_end;
        vtim_dur tmo;
        unsigned rlen, resp;
        char buf[8192], *p;
        struct pollfd pfda[1], *pfd = pfda;
        const struct suckaddr *sa;

        t_start = t_now = VTIM_real();
        t_end = t_start + vt->timeout;

        s = VCP_Open(vt->conn_pool, t_end - t_now, &sa, &err);
        if (s < 0) {
                bprintf(vt->resp_buf, "Open error %d (%s)", err, VAS_errtxt(err));
                Lck_Lock(&vbp_mtx);
                if (vt->backend)
                        VBE_Connect_Error(vt->backend->vsc, err);
                Lck_Unlock(&vbp_mtx);
                return;
        }

        i = VSA_Get_Proto(sa);
        if (VSA_Compare(sa, bogo_ip) == 0)
                vt->good_unix |= 1;
        else if (i == AF_INET)
                vt->good_ipv4 |= 1;
        else if (i == AF_INET6)
                vt->good_ipv6 |= 1;
        else
                WRONG("Wrong probe protocol family");

        t_now = VTIM_real();
        tmo = t_end - t_now;
        if (tmo <= 0) {
                bprintf(vt->resp_buf,
                        "Open timeout %.3fs exceeded by %.3fs",
                        vt->timeout, -tmo);
                VTCP_close(&s);
                return;
        }

        Lck_Lock(&vbp_mtx);
        if (vt->backend != NULL)
                proxy_header = vt->backend->proxy_header;
        else
                proxy_header = -1;
        Lck_Unlock(&vbp_mtx);

        if (proxy_header < 0) {
                bprintf(vt->resp_buf, "%s", "No backend");
                VTCP_close(&s);
                return;
        }

        /* Send the PROXY header */
        assert(proxy_header <= 2);
        if (proxy_header == 1) {
                if (vbp_write_proxy_v1(vt, &s) != 0)
                        return;
        } else if (proxy_header == 2 &&
            vbp_write(vt, &s, vbp_proxy_local, sizeof vbp_proxy_local) != 0)
                return;

        /* Send the request */
        if (vbp_write(vt, &s, vt->req, vt->req_len) != 0)
                return;

        vt->good_xmit |= 1;

        pfd->fd = s;
        rlen = 0;
        while (1) {
                pfd->events = POLLIN;
                pfd->revents = 0;
                t_now = VTIM_real();
                tmo = t_end - t_now;
                if (tmo <= 0) {
                        bprintf(vt->resp_buf,
                            "Poll timeout %.3fs exceeded by %.3fs",
                            vt->timeout, -tmo);
                        i = -1;
                        break;
                }
                i = poll(pfd, 1, VTIM_poll_tmo(tmo));
                if (i <= 0) {
                        if (!i) {
                                if (!vt->exp_close)
                                        break;
                                errno = ETIMEDOUT;
                        }
                        bprintf(vt->resp_buf, "Poll error %d (%s)",
                            errno, VAS_errtxt(errno));
                        i = -1;
                        break;
                }
                if (rlen < sizeof vt->resp_buf)
                        i = read(s, vt->resp_buf + rlen,
                            sizeof vt->resp_buf - rlen);
                else
                        i = read(s, buf, sizeof buf);
                VTCP_Assert(i);
                if (i <= 0) {
                        if (i < 0)
                                bprintf(vt->resp_buf, "Read error %d (%s)",
                                        errno, VAS_errtxt(errno));
                        break;
                }
                rlen += i;
        }

        VTCP_close(&s);

        if (i < 0) {
                /* errno reported above */
                vt->err_recv |= 1;
                return;
        }

        if (rlen == 0) {
                bprintf(vt->resp_buf, "%s", "Empty response");
                return;
        }

        /* So we have a good receive ... */
        t_now = VTIM_real();
        vt->last = t_now - t_start;
        vt->good_recv |= 1;

        /* Now find out if we like the response */
        vt->resp_buf[sizeof vt->resp_buf - 1] = '\0';
        p = strchr(vt->resp_buf, '\r');
        if (p != NULL)
                *p = '\0';
        p = strchr(vt->resp_buf, '\n');
        if (p != NULL)
                *p = '\0';

        i = sscanf(vt->resp_buf, "HTTP/%*f %u ", &resp);

        if (i == 1 && resp == vt->exp_status)
                vt->happy |= 1;
}

/*--------------------------------------------------------------------
 */
static void
vbp_heap_insert(struct vbp_target *vt)
{
        // Lck_AssertHeld(&vbp_mtx);
        VBH_insert(vbp_heap, vt);
        if (VBH_root(vbp_heap) == vt)
                PTOK(pthread_cond_signal(&vbp_cond));
}

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

/*
 * called when a task was successful or could not get scheduled
 * returns non-NULL if target is to be deleted (outside mtx)
 */
static struct vbp_target *
vbp_task_complete(struct vbp_target *vt)
{
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);

        Lck_AssertHeld(&vbp_mtx);

        assert(vt->heap_idx == VBH_NOIDX);

        if (vt->state == vbp_state_running) {
                vt->state = vbp_state_scheduled;
                vt->due = VTIM_real() + vt->interval;
                vbp_heap_insert(vt);
                vt = NULL;
        } else if (vt->state == vbp_state_cooling) {
                vt->state = vbp_state_cold;
                vt = NULL;
        } else if (vt->state != vbp_state_deleted) {
                WRONG(vt->state->name);
        }
        return (vt);
}

static void v_matchproto_(task_func_t)
vbp_task(struct worker *wrk, void *priv)
{
        struct vbp_target *vt;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CAST_OBJ_NOTNULL(vt, priv, VBP_TARGET_MAGIC);

        AN(vt->req);
        assert(vt->req_len > 0);

        vbp_start_poke(vt);
        vbp_poke(vt);
        vbp_has_poked(vt);
        VBP_Update_Backend(vt);

        Lck_Lock(&vbp_mtx);
        vt = vbp_task_complete(vt);
        Lck_Unlock(&vbp_mtx);
        if (vt == NULL)
                return;
        vbp_delete(vt);
}

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

static void * v_matchproto_(bgthread_t)
vbp_scheduler(struct worker *wrk, void *priv)
{
        vtim_real now, nxt;
        struct vbp_target *vt;
        int r;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        AZ(priv);
        Lck_Lock(&vbp_mtx);
        while (1) {
                now = VTIM_real();
                vt = VBH_root(vbp_heap);
                if (vt == NULL) {
                        nxt = 8.192 + now;
                        (void)Lck_CondWaitUntil(&vbp_cond, &vbp_mtx, nxt);
                } else if (vt->due > now) {
                        nxt = vt->due;
                        (void)Lck_CondWaitUntil(&vbp_cond, &vbp_mtx, nxt);
                } else {
                        assert(vt->state == vbp_state_scheduled);
                        VBH_delete(vbp_heap, vt->heap_idx);
                        vt->state = vbp_state_running;
                        vt->task->func = vbp_task;
                        vt->task->priv = vt;
                        Lck_Unlock(&vbp_mtx);

                        r = Pool_Task_Any(vt->task, TASK_QUEUE_REQ);

                        Lck_Lock(&vbp_mtx);
                        if (r == 0)
                                continue;
                        vt = vbp_task_complete(vt);
                        if (vt == NULL)
                                continue;
                        Lck_Unlock(&vbp_mtx);

                        vbp_delete(vt);

                        Lck_Lock(&vbp_mtx);
                }
        }
        NEEDLESS(Lck_Unlock(&vbp_mtx));
        NEEDLESS(return (NULL));
}


/*--------------------------------------------------------------------
 * Cli functions
 */

static void
vbp_bitmap(struct vsb *vsb, char c, uint64_t map, const char *lbl)
{
        int i;
        uint64_t u = (1ULL << 63);

        VSB_cat(vsb, "  ");
        for (i = 0; i < 64; i++) {
                if (map & u)
                        VSB_putc(vsb, c);
                else
                        VSB_putc(vsb, '-');
                map <<= 1;
        }
        VSB_printf(vsb, " %s\n", lbl);
}

/*lint -e{506} constant value boolean */
/*lint -e{774} constant value boolean */
void
VBP_Status(struct vsb *vsb, const struct backend *be, int details, int json)
{
        struct vbp_target *vt;

        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
        vt = be->probe;
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);

        if (!details) {
                if (json)
                        VSB_printf(vsb, "[%u, %u, \"%s\"]",
                            vt->good, vt->window,
                            vt->backend->sick ? "sick" : "healthy");
                else
                        VSB_printf(vsb, "%u/%u\t%s", vt->good, vt->window,
                            vt->backend->sick ? "sick" : "healthy");
                return;
        }

        if (json) {
                VSB_cat(vsb, "{\n");
                VSB_indent(vsb, 2);
#define BITMAP(nn, cc, tt, bb)                                  \
                VSB_printf(vsb, "\"bits_%c\": %ju,\n", cc, vt->nn);
#include "tbl/backend_poll.h"
                VSB_printf(vsb, "\"good\": %u,\n", vt->good);
                VSB_printf(vsb, "\"threshold\": %u,\n", vt->threshold);
                VSB_printf(vsb, "\"window\": %u", vt->window);
                VSB_indent(vsb, -2);
                VSB_cat(vsb, "\n");
                VSB_cat(vsb, "},\n");
                return;
        }

        VSB_printf(vsb,
            "\n Current states  good: %2u threshold: %2u window: %2u\n",
            vt->good, vt->threshold, vt->window);
        VSB_printf(vsb,
            "  Average response time of good probes: %.6f\n", vt->avg);
        VSB_cat(vsb,
            "  Oldest ======================"
            "============================ Newest\n");

#define BITMAP(n, c, t, b)                                      \
                if ((vt->n != 0) || (b))                        \
                        vbp_bitmap(vsb, (c), vt->n, (t));
#include "tbl/backend_poll.h"
}

/*--------------------------------------------------------------------
 * Build request from probe spec
 */

static void
vbp_build_req(struct vbp_target *vt, const struct vrt_backend_probe *vbp,
    const struct backend *be)
{
        struct vsb *vsb;

        vsb = VSB_new_auto();
        AN(vsb);
        VSB_clear(vsb);
        if (vbp->request != NULL) {
                VSB_cat(vsb, vbp->request);
        } else {
                AN(be->hosthdr);
                VSB_printf(vsb,
                    "GET %s HTTP/1.1\r\n"
                    "Host: %s\r\n"
                    "Connection: close\r\n"
                    "\r\n",
                    vbp->url != NULL ?  vbp->url : "/",
                    be->hosthdr);
        }
        AZ(VSB_finish(vsb));
        vt->req = strdup(VSB_data(vsb));
        AN(vt->req);
        vt->req_len = VSB_len(vsb);
        VSB_destroy(&vsb);
}

/*--------------------------------------------------------------------
 * Sanitize and set defaults
 * XXX: we could make these defaults parameters
 */

static void
vbp_set_defaults(struct vbp_target *vt, const struct vrt_backend_probe *vp)
{

#define DN(x)   do { vt->x = vp->x; } while (0)
        VRT_BACKEND_PROBE_HANDLE();
#undef DN

        if (vt->timeout == 0.0)
                vt->timeout = 2.0;
        if (vt->interval == 0.0)
                vt->interval = 5.0;
        if (vt->window == 0)
                vt->window = 8;
        if (vt->threshold == 0)
                vt->threshold = 3;
        if (vt->exp_status == 0)
                vt->exp_status = 200;

        if (vt->initial == ~0U)
                vt->initial = vt->threshold - 1;

        vt->initial = vmin(vt->initial, vt->threshold);
}

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

void
VBP_Control(const struct backend *be, int enable)
{
        struct vbp_target *vt;

        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
        vt = be->probe;
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);

        vbp_reset(vt);
        VBP_Update_Backend(vt);

        Lck_Lock(&vbp_mtx);
        if (enable) {
                if (vt->state == vbp_state_cooling) {
                        vt->state = vbp_state_running;
                } else if (vt->state == vbp_state_cold) {
                        assert(vt->heap_idx == VBH_NOIDX);
                        vt->due = VTIM_real();
                        vbp_heap_insert(vt);
                        vt->state = vbp_state_scheduled;
                } else
                        WRONG(vt->state->name);
        } else {
                if (vt->state == vbp_state_running) {
                        vt->state = vbp_state_cooling;
                } else if (vt->state == vbp_state_scheduled) {
                        assert(vt->heap_idx != VBH_NOIDX);
                        VBH_delete(vbp_heap, vt->heap_idx);
                        vt->state = vbp_state_cold;
                } else
                        WRONG(vt->state->name);
        }
        Lck_Unlock(&vbp_mtx);
}

/*--------------------------------------------------------------------
 * Insert/Remove/Use called from cache_backend.c
 */

void
VBP_Insert(struct backend *b, const struct vrt_backend_probe *vp,
    struct conn_pool *tp)
{
        struct vbp_target *vt;

        CHECK_OBJ_NOTNULL(b, BACKEND_MAGIC);
        CHECK_OBJ_NOTNULL(vp, VRT_BACKEND_PROBE_MAGIC);

        AZ(b->probe);

        ALLOC_OBJ(vt, VBP_TARGET_MAGIC);
        XXXAN(vt);

        vt->state = vbp_state_cold;
        vt->conn_pool = tp;
        VCP_AddRef(vt->conn_pool);
        vt->backend = b;
        b->probe = vt;

        vbp_set_defaults(vt, vp);
        vbp_build_req(vt, vp, b);

        vbp_reset(vt);
}

void
VBP_Remove(struct backend *be)
{
        struct vbp_target *vt;

        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
        vt = be->probe;
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);

        Lck_Lock(&vbp_mtx);
        be->sick = 1;
        be->probe = NULL;
        vt->backend = NULL;
        if (vt->state == vbp_state_cooling) {
                vt->state = vbp_state_deleted;
                vt = NULL;
        } else
                assert(vt->state == vbp_state_cold);
        Lck_Unlock(&vbp_mtx);
        if (vt != NULL)
                vbp_delete(vt);
}

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

static int v_matchproto_(vbh_cmp_t)
vbp_cmp(void *priv, const void *a, const void *b)
{
        const struct vbp_target *aa, *bb;

        AZ(priv);
        CAST_OBJ_NOTNULL(aa, a, VBP_TARGET_MAGIC);
        CAST_OBJ_NOTNULL(bb, b, VBP_TARGET_MAGIC);

        return (aa->due < bb->due);
}

static void v_matchproto_(vbh_update_t)
vbp_update(void *priv, void *p, unsigned u)
{
        struct vbp_target *vt;

        AZ(priv);
        CAST_OBJ_NOTNULL(vt, p, VBP_TARGET_MAGIC);
        vt->heap_idx = u;
}

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

void
VBP_Init(void)
{
        pthread_t thr;

        Lck_New(&vbp_mtx, lck_probe);
        vbp_heap = VBH_new(NULL, vbp_cmp, vbp_update);
        AN(vbp_heap);
        PTOK(pthread_cond_init(&vbp_cond, NULL));
        WRK_BgThread(&thr, "backend-probe-scheduler", vbp_scheduler, NULL);
}

		varnish-cache/bin/varnishd/cache/cache_backend_probe.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2011 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		* Poll backends for collection of health statistics
31		*
32		* We co-opt threads from the worker pool for probing the backends,
33	440	* but we want to avoid a potentially messy cleanup operation when we
34	440	* retire the backend, so the thread owns the health information, which
35	440	* the backend references, rather than the other way around.
36	440	*
37	440	*/
38	440
39	440	#include "config.h"
40	520
41		#include <poll.h>
42		#include <stdio.h>
43		#include <stdlib.h>
44
45		#include "cache_varnishd.h"
46
47		#include "vbh.h"
48		#include "vsa.h"
49		#include "vtcp.h"
50		#include "vtim.h"
51
52		#include "cache_backend.h"
53		#include "cache_conn_pool.h"
54
55		#include "VSC_vbe.h"
56
57		struct vbp_state {
58		const char *name;
59		};
60
61		#define VBP_STATE(n) static const struct vbp_state vbp_state_ ## n [1] = {{ .name = #n }}
62		VBP_STATE(scheduled);
63		VBP_STATE(running);
64		VBP_STATE(cold);
65		VBP_STATE(cooling);
66		VBP_STATE(deleted);
67		#undef VBP_STATE
68
69		/* Default averaging rate, we want something pretty responsive */
70		#define AVG_RATE 4
71
72		struct vbp_target {
73		unsigned magic;
74		#define VBP_TARGET_MAGIC 0x6b7cb656
75
76		VRT_BACKEND_PROBE_FIELDS()
77
78		struct backend *backend;
79		struct conn_pool *conn_pool;
80
81		char *req;
82		int req_len;
83
84		char resp_buf[128];
85		unsigned good;
86
87		/* Collected statistics */
88		#define BITMAP(n, c, t, b) uintmax_t n;
89		#include "tbl/backend_poll.h"
90
91		vtim_dur last;
92		vtim_dur avg;
93		double rate;
94
95		vtim_real due;
96		const struct vbp_state *state;
97		int heap_idx;
98		struct pool_task task[1];
99		};
100
101		static struct lock vbp_mtx;
102		static pthread_cond_t vbp_cond;
103		static struct vbh *vbp_heap;
104
105		static const unsigned char vbp_proxy_local[] = {
106		0x0d, 0x0a, 0x0d, 0x0a, 0x00, 0x0d, 0x0a, 0x51,
107		0x55, 0x49, 0x54, 0x0a, 0x20, 0x00, 0x00, 0x00,
108		};
109
110		/--------------------------------------------------------------------/
111
112		static void
113	240	vbp_delete(struct vbp_target *vt)
114		{
115	240	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
116
117	240	assert(vt->heap_idx == VBH_NOIDX);
118
119		#define DN(x) /**/
120	240	VRT_BACKEND_PROBE_HANDLE();
121		#undef DN
122	240	VCP_Rel(&vt->conn_pool);
123	240	free(vt->req);
124	240	FREE_OBJ(vt);
125	240	}
126
127
128		/*--------------------------------------------------------------------
129		* Record pokings...
130		*/
131
132		static void
133	15789	vbp_start_poke(struct vbp_target *vt)
134		{
135	15789	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
136
137		#define BITMAP(n, c, t, b) \
138		vt->n <<= 1;
139		#include "tbl/backend_poll.h"
140
141		vt->last = 0;
142		vt->resp_buf[0] = '\0';
143		}
144
145		static void
146	15671	vbp_has_poked(struct vbp_target *vt)
147		{
148		unsigned i, j;
149		uint64_t u;
150
151	15671	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
152
153		/* Calculate exponential average */
154	15671	if (vt->happy & 1) {
155	13639	if (vt->rate < AVG_RATE)
156	7208	vt->rate += 1.0;
157	13639	vt->avg += (vt->last - vt->avg) / vt->rate;
158	13639	}
159
160	15671	u = vt->happy;
161	129207	for (i = j = 0; i < vt->window; i++) {
162	113536	if (u & 1)
163	62791	j++;
164	113536	u >>= 1;
165	113536	}
166	15671	vt->good = j;
167	15671	}
168
169		void
170	10951	VBP_Update_Backend(struct vbp_target *vt)
171		{
172	10951	unsigned i = 0, chg;
173		char bits[10];
174
175	10951	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
176
177		#define BITMAP(n, c, t, b) \
178		bits[i++] = (vt->n & 1) ? c : '-';
179		#include "tbl/backend_poll.h"
180		bits[i] = '\0';
181	10951	assert(i < sizeof bits);
182
183		Lck_Lock(&vbp_mtx);
184	10951	if (vt->backend == NULL) {
185	0	Lck_Unlock(&vbp_mtx);
186	0	return;
187		}
188
189		i = (vt->good < vt->threshold);
190		chg = (i != vt->backend->sick);
191		vt->backend->sick = i;
192	10951	if (i && chg && vt->backend->director != NULL)
193	1940	VDI_Event(vt->backend->director, VDI_EVENT_SICK);
194
195	10951	AN(vt->backend->vcl_name);
196		VSL(SLT_Backend_health, NO_VXID,
197		"%s %s %s %s %u %u %u %.6f %.6f \"%s\"",
198		vt->backend->vcl_name, chg ? "Went" : "Still",
199		i ? "sick" : "healthy", bits,
200		vt->good, vt->threshold, vt->window,
201		vt->last, vt->avg, vt->resp_buf);
202		vt->backend->vsc->happy = vt->happy;
203	10951	if (chg)
204	2820	vt->backend->changed = VTIM_real();
205		Lck_Unlock(&vbp_mtx);
206		}
207
208		static void
209	3240	vbp_reset(struct vbp_target *vt)
210		{
211		unsigned u;
212
213	3240	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
214	3240	vt->avg = 0.0;
215	3240	vt->rate = 0.0;
216		#define BITMAP(n, c, t, b) \
217		vt->n = 0;
218		#include "tbl/backend_poll.h"
219
220	11200	for (u = 0; u < vt->initial; u++) {
221	7960	vbp_start_poke(vt);
222	7960	vt->happy \|= 1;
223	7960	vbp_has_poked(vt);
224	7960	}
225		}
226
227		/*--------------------------------------------------------------------
228		* Poke one backend, once, but possibly at both IPv4 and IPv6 addresses.
229		*
230		* We do deliberately not use the stuff in cache_backend.c, because we
231		* want to measure the backends response without local distractions.
232		*/
233
234		static int
235	7852	vbp_write(struct vbp_target vt, int sock, const void *buf, size_t len)
236		{
237		int i;
238
239	7852	i = write(*sock, buf, len);
240	7852	VTCP_Assert(i);
241	7852	if (i != len) {
242	0	if (i < 0) {
243	0	vt->err_xmit \|= 1;
244	0	bprintf(vt->resp_buf, "Write error %d (%s)",
245		errno, VAS_errtxt(errno));
246	0	} else {
247	0	bprintf(vt->resp_buf,
248		"Short write (%d/%zu) error %d (%s)",
249		i, len, errno, VAS_errtxt(errno));
250		}
251	0	VTCP_close(sock);
252	0	return (-1);
253		}
254	7852	return (0);
255	7852	}
256
257		static int
258	244	vbp_write_proxy_v1(struct vbp_target vt, int sock)
259		{
260		char buf[105]; /* maximum size for a TCP6 PROXY line with null char */
261		char addr[VTCP_ADDRBUFSIZE];
262		char port[VTCP_PORTBUFSIZE];
263	244	char vsabuf[vsa_suckaddr_len];
264		const struct suckaddr *sua;
265		int proto;
266		struct vsb vsb;
267
268	244	sua = VSA_getsockname(*sock, vsabuf, sizeof vsabuf);
269	244	AN(sua);
270	244	AN(VSB_init(&vsb, buf, sizeof buf));
271
272	244	proto = VSA_Get_Proto(sua);
273	244	if (proto == AF_INET \|\| proto == AF_INET6) {
274	124	VTCP_name(sua, addr, sizeof addr, port, sizeof port);
275	124	VSB_printf(&vsb, "PROXY %s %s %s %s %s\r\n",
276	124	proto == AF_INET ? "TCP4" : "TCP6",
277	124	addr, addr, port, port);
278	124	} else {
279	120	VSB_cat(&vsb, "PROXY UNKNOWN\r\n");
280		}
281	244	AZ(VSB_finish(&vsb));
282
283	244	VSB_fini(&vsb);
284	244	return (vbp_write(vt, sock, buf, strlen(buf)));
285	244	}
286
287		static void
288	7789	vbp_poke(struct vbp_target *vt)
289		{
290		int s, i, proxy_header, err;
291		vtim_real t_start, t_now, t_end;
292		vtim_dur tmo;
293		unsigned rlen, resp;
294		char buf[8192], *p;
295	7789	struct pollfd pfda[1], *pfd = pfda;
296		const struct suckaddr *sa;
297
298	7789	t_start = t_now = VTIM_real();
299	7789	t_end = t_start + vt->timeout;
300
301	7789	s = VCP_Open(vt->conn_pool, t_end - t_now, &sa, &err);
302	7789	if (s < 0) {
303	489	bprintf(vt->resp_buf, "Open error %d (%s)", err, VAS_errtxt(err));
304	489	Lck_Lock(&vbp_mtx);
305	489	if (vt->backend)
306	489	VBE_Connect_Error(vt->backend->vsc, err);
307	489	Lck_Unlock(&vbp_mtx);
308	489	return;
309		}
310
311	7300	i = VSA_Get_Proto(sa);
312	7300	if (VSA_Compare(sa, bogo_ip) == 0)
313	2577	vt->good_unix \|= 1;
314	4723	else if (i == AF_INET)
315	4723	vt->good_ipv4 \|= 1;
316	0	else if (i == AF_INET6)
317	0	vt->good_ipv6 \|= 1;
318		else
319	0	WRONG("Wrong probe protocol family");
320
321	7300	t_now = VTIM_real();
322	7300	tmo = t_end - t_now;
323	7300	if (tmo <= 0) {
324	78	bprintf(vt->resp_buf,
325		"Open timeout %.3fs exceeded by %.3fs",
326		vt->timeout, -tmo);
327	78	VTCP_close(&s);
328	78	return;
329		}
330
331	7222	Lck_Lock(&vbp_mtx);
332	7222	if (vt->backend != NULL)
333	7222	proxy_header = vt->backend->proxy_header;
334		else
335	0	proxy_header = -1;
336	7222	Lck_Unlock(&vbp_mtx);
337
338	7222	if (proxy_header < 0) {
339	0	bprintf(vt->resp_buf, "%s", "No backend");
340	0	VTCP_close(&s);
341	0	return;
342		}
343
344		/* Send the PROXY header */
345	7222	assert(proxy_header <= 2);
346	7222	if (proxy_header == 1) {
347	244	if (vbp_write_proxy_v1(vt, &s) != 0)
348	0	return;
349	7222	} else if (proxy_header == 2 &&
350	308	vbp_write(vt, &s, vbp_proxy_local, sizeof vbp_proxy_local) != 0)
351	0	return;
352
353		/* Send the request */
354	7222	if (vbp_write(vt, &s, vt->req, vt->req_len) != 0)
355	0	return;
356
357	7222	vt->good_xmit \|= 1;
358
359	7222	pfd->fd = s;
360	7222	rlen = 0;
361	14515	while (1) {
362	14515	pfd->events = POLLIN;
363	14515	pfd->revents = 0;
364	14515	t_now = VTIM_real();
365	14515	tmo = t_end - t_now;
366	14515	if (tmo <= 0) {
367	0	bprintf(vt->resp_buf,
368		"Poll timeout %.3fs exceeded by %.3fs",
369		vt->timeout, -tmo);
370	0	i = -1;
371	0	break;
372		}
373	14515	i = poll(pfd, 1, VTIM_poll_tmo(tmo));
374	14515	if (i <= 0) {
375	815	if (!i) {
376	815	if (!vt->exp_close)
377	172	break;
378	643	errno = ETIMEDOUT;
379	643	}
380	643	bprintf(vt->resp_buf, "Poll error %d (%s)",
381		errno, VAS_errtxt(errno));
382	643	i = -1;
383	643	break;
384		}
385	13700	if (rlen < sizeof vt->resp_buf)
386	25074	i = read(s, vt->resp_buf + rlen,
387	12537	sizeof vt->resp_buf - rlen);
388		else
389	1163	i = read(s, buf, sizeof buf);
390	13700	VTCP_Assert(i);
391	13700	if (i <= 0) {
392	6407	if (i < 0)
393	60	bprintf(vt->resp_buf, "Read error %d (%s)",
394		errno, VAS_errtxt(errno));
395	6407	break;
396		}
397	7293	rlen += i;
398		}
399
400	7222	VTCP_close(&s);
401
402	7222	if (i < 0) {
403		/* errno reported above */
404	703	vt->err_recv \|= 1;
405	703	return;
406		}
407
408	6519	if (rlen == 0) {
409	240	bprintf(vt->resp_buf, "%s", "Empty response");
410	240	return;
411		}
412
413		/* So we have a good receive ... */
414	6279	t_now = VTIM_real();
415	6279	vt->last = t_now - t_start;
416	6279	vt->good_recv \|= 1;
417
418		/* Now find out if we like the response */
419	6279	vt->resp_buf[sizeof vt->resp_buf - 1] = '\0';
420	6279	p = strchr(vt->resp_buf, '\r');
421	6279	if (p != NULL)
422	6279	*p = '\0';
423	6279	p = strchr(vt->resp_buf, '\n');
424	6279	if (p != NULL)
425	0	*p = '\0';
426
427	6279	i = sscanf(vt->resp_buf, "HTTP/%*f %u ", &resp);
428
429	6279	if (i == 1 && resp == vt->exp_status)
430	5639	vt->happy \|= 1;
431	7789	}
432
433		/*--------------------------------------------------------------------
434		*/
435		static void
436	9151	vbp_heap_insert(struct vbp_target *vt)
437		{
438		// Lck_AssertHeld(&vbp_mtx);
439	9151	VBH_insert(vbp_heap, vt);
440	9151	if (VBH_root(vbp_heap) == vt)
441	8467	PTOK(pthread_cond_signal(&vbp_cond));
442	9151	}
443
444		/*--------------------------------------------------------------------
445		*/
446
447		/*
448		* called when a task was successful or could not get scheduled
449		* returns non-NULL if target is to be deleted (outside mtx)
450		*/
451		static struct vbp_target *
452	7711	vbp_task_complete(struct vbp_target *vt)
453		{
454	7711	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
455
456	7711	Lck_AssertHeld(&vbp_mtx);
457
458	7711	assert(vt->heap_idx == VBH_NOIDX);
459
460	7711	if (vt->state == vbp_state_running) {
461	7671	vt->state = vbp_state_scheduled;
462	7671	vt->due = VTIM_real() + vt->interval;
463	7671	vbp_heap_insert(vt);
464	7671	vt = NULL;
465	7711	} else if (vt->state == vbp_state_cooling) {
466	40	vt->state = vbp_state_cold;
467	40	vt = NULL;
468	40	} else if (vt->state != vbp_state_deleted) {
469	0	WRONG(vt->state->name);
470	0	}
471	7711	return (vt);
472		}
473
474		static void v_matchproto_(task_func_t)
475	7711	vbp_task(struct worker wrk, void priv)
476		{
477		struct vbp_target *vt;
478
479	7711	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
480	7711	CAST_OBJ_NOTNULL(vt, priv, VBP_TARGET_MAGIC);
481
482	7711	AN(vt->req);
483	7711	assert(vt->req_len > 0);
484
485	7711	vbp_start_poke(vt);
486	7711	vbp_poke(vt);
487	7711	vbp_has_poked(vt);
488	7711	VBP_Update_Backend(vt);
489
490	7711	Lck_Lock(&vbp_mtx);
491	7711	vt = vbp_task_complete(vt);
492	7711	Lck_Unlock(&vbp_mtx);
493	7711	if (vt == NULL)
494	7711	return;
495	0	vbp_delete(vt);
496	7711	}
497
498		/*--------------------------------------------------------------------
499		*/