女同性恋cbcb


/*-
 * 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	22	* but we want to avoid a potentially messy cleanup operation when we
34	22	* retire the backend, so the thread owns the health information, which
35	22	* the backend references, rather than the other way around.
36	22	*
37	22	*/
38	22
39	22	#include "config.h"
40	26
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	12	vbp_delete(struct vbp_target *vt)
114		{
115	12	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
116
117	12	assert(vt->heap_idx == VBH_NOIDX);
118
119		#define DN(x) /**/
120	12	VRT_BACKEND_PROBE_HANDLE();
121		#undef DN
122	12	VCP_Rel(&vt->conn_pool);
123	12	free(vt->req);
124	12	FREE_OBJ(vt);
125	12	}
126
127
128		/*--------------------------------------------------------------------
129		* Record pokings...
130		*/
131
132		static void
133	793	vbp_start_poke(struct vbp_target *vt)
134		{
135	793	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	787	vbp_has_poked(struct vbp_target *vt)
147		{
148		unsigned i, j;
149		uint64_t u;
150
151	787	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
152
153		/* Calculate exponential average */
154	787	if (vt->happy & 1) {
155	680	if (vt->rate < AVG_RATE)
156	360	vt->rate += 1.0;
157	680	vt->avg += (vt->last - vt->avg) / vt->rate;
158	680	}
159
160	787	u = vt->happy;
161	6458	for (i = j = 0; i < vt->window; i++) {
162	5671	if (u & 1)
163	3123	j++;
164	5671	u >>= 1;
165	5671	}
166	787	vt->good = j;
167	787	}
168
169		void
170	551	VBP_Update_Backend(struct vbp_target *vt)
171		{
172	551	unsigned i = 0, chg;
173		char bits[10];
174
175	551	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	551	assert(i < sizeof bits);
182
183		Lck_Lock(&vbp_mtx);
184	551	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	551	if (i && chg && vt->backend->director != NULL)
193	98	VDI_Event(vt->backend->director, VDI_EVENT_SICK);
194
195	551	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	551	if (chg)
204	142	vt->backend->changed = VTIM_real();
205		Lck_Unlock(&vbp_mtx);
206		}
207
208		static void
209	162	vbp_reset(struct vbp_target *vt)
210		{
211		unsigned u;
212
213	162	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
214	162	vt->avg = 0.0;
215	162	vt->rate = 0.0;
216		#define BITMAP(n, c, t, b) \
217		vt->n = 0;
218		#include "tbl/backend_poll.h"
219
220	560	for (u = 0; u < vt->initial; u++) {
221	398	vbp_start_poke(vt);
222	398	vt->happy \|= 1;
223	398	vbp_has_poked(vt);
224	398	}
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	390	vbp_write(struct vbp_target vt, int sock, const void *buf, size_t len)
236		{
237		int i;
238
239	390	i = write(*sock, buf, len);
240	390	VTCP_Assert(i);
241	390	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	390	return (0);
255	390	}
256
257		static int
258	12	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	12	char vsabuf[vsa_suckaddr_len];
264		const struct suckaddr *sua;
265		int proto;
266		struct vsb vsb;
267
268	12	sua = VSA_getsockname(*sock, vsabuf, sizeof vsabuf);
269	12	AN(sua);
270	12	AN(VSB_init(&vsb, buf, sizeof buf));
271
272	12	proto = VSA_Get_Proto(sua);
273	12	if (proto == AF_INET \|\| proto == AF_INET6) {
274	6	VTCP_name(sua, addr, sizeof addr, port, sizeof port);
275	6	VSB_printf(&vsb, "PROXY %s %s %s %s %s\r\n",
276	6	proto == AF_INET ? "TCP4" : "TCP6",
277	6	addr, addr, port, port);
278	6	} else {
279	6	VSB_cat(&vsb, "PROXY UNKNOWN\r\n");
280		}
281	12	AZ(VSB_finish(&vsb));
282
283	12	VSB_fini(&vsb);
284	12	return (vbp_write(vt, sock, buf, strlen(buf)));
285	12	}
286
287		static void
288	393	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	393	struct pollfd pfda[1], *pfd = pfda;
296		const struct suckaddr *sa;
297
298	393	t_start = t_now = VTIM_real();
299	393	t_end = t_start + vt->timeout;
300
301	393	s = VCP_Open(vt->conn_pool, t_end - t_now, &sa, &err);
302	393	if (s < 0) {
303	31	bprintf(vt->resp_buf, "Open error %d (%s)", err, VAS_errtxt(err));
304	31	Lck_Lock(&vbp_mtx);
305	31	if (vt->backend)
306	31	VBE_Connect_Error(vt->backend->vsc, err);
307	31	Lck_Unlock(&vbp_mtx);
308	31	return;
309		}
310
311	362	i = VSA_Get_Proto(sa);
312	362	if (VSA_Compare(sa, bogo_ip) == 0)
313	126	vt->good_unix \|= 1;
314	236	else if (i == AF_INET)
315	236	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	362	t_now = VTIM_real();
322	362	tmo = t_end - t_now;
323	362	if (tmo <= 0) {
324	4	bprintf(vt->resp_buf,
325		"Open timeout %.3fs exceeded by %.3fs",
326		vt->timeout, -tmo);
327	4	VTCP_close(&s);
328	4	return;
329		}
330
331	358	Lck_Lock(&vbp_mtx);
332	358	if (vt->backend != NULL)
333	358	proxy_header = vt->backend->proxy_header;
334		else
335	0	proxy_header = -1;
336	358	Lck_Unlock(&vbp_mtx);
337
338	358	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	358	assert(proxy_header <= 2);
346	358	if (proxy_header == 1) {
347	12	if (vbp_write_proxy_v1(vt, &s) != 0)
348	0	return;
349	358	} else if (proxy_header == 2 &&
350	16	vbp_write(vt, &s, vbp_proxy_local, sizeof vbp_proxy_local) != 0)
351	0	return;
352
353		/* Send the request */
354	358	if (vbp_write(vt, &s, vt->req, vt->req_len) != 0)
355	0	return;
356
357	358	vt->good_xmit \|= 1;
358
359	358	pfd->fd = s;
360	358	rlen = 0;
361	722	while (1) {
362	722	pfd->events = POLLIN;
363	722	pfd->revents = 0;
364	722	t_now = VTIM_real();
365	722	tmo = t_end - t_now;
366	722	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	722	i = poll(pfd, 1, VTIM_poll_tmo(tmo));
374	722	if (i <= 0) {
375	41	if (!i) {
376	41	if (!vt->exp_close)
377	9	break;
378	32	errno = ETIMEDOUT;
379	32	}
380	32	bprintf(vt->resp_buf, "Poll error %d (%s)",
381		errno, VAS_errtxt(errno));
382	32	i = -1;
383	32	break;
384		}
385	681	if (rlen < sizeof vt->resp_buf)
386	1242	i = read(s, vt->resp_buf + rlen,
387	621	sizeof vt->resp_buf - rlen);
388		else
389	60	i = read(s, buf, sizeof buf);
390	681	VTCP_Assert(i);
391	681	if (i <= 0) {
392	317	if (i < 0)
393	2	bprintf(vt->resp_buf, "Read error %d (%s)",
394		errno, VAS_errtxt(errno));
395	317	break;
396		}
397	364	rlen += i;
398		}
399
400	358	VTCP_close(&s);
401
402	358	if (i < 0) {
403		/* errno reported above */
404	34	vt->err_recv \|= 1;
405	34	return;
406		}
407
408	324	if (rlen == 0) {
409	12	bprintf(vt->resp_buf, "%s", "Empty response");
410	12	return;
411		}
412
413		/* So we have a good receive ... */
414	312	t_now = VTIM_real();
415	312	vt->last = t_now - t_start;
416	312	vt->good_recv \|= 1;
417
418		/* Now find out if we like the response */
419	312	vt->resp_buf[sizeof vt->resp_buf - 1] = '\0';
420	312	p = strchr(vt->resp_buf, '\r');
421	312	if (p != NULL)
422	312	*p = '\0';
423	312	p = strchr(vt->resp_buf, '\n');
424	312	if (p != NULL)
425	0	*p = '\0';
426
427	312	i = sscanf(vt->resp_buf, "HTTP/%*f %u ", &resp);
428
429	312	if (i == 1 && resp == vt->exp_status)
430	280	vt->happy \|= 1;
431	393	}
432
433		/*--------------------------------------------------------------------
434		*/
435		static void
436	461	vbp_heap_insert(struct vbp_target *vt)
437		{
438		// Lck_AssertHeld(&vbp_mtx);
439	461	VBH_insert(vbp_heap, vt);
440	461	if (VBH_root(vbp_heap) == vt)
441	428	PTOK(pthread_cond_signal(&vbp_cond));
442	461	}
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	389	vbp_task_complete(struct vbp_target *vt)
453		{
454	389	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
455
456	389	Lck_AssertHeld(&vbp_mtx);
457
458	389	assert(vt->heap_idx == VBH_NOIDX);
459
460	389	if (vt->state == vbp_state_running) {
461	387	vt->state = vbp_state_scheduled;
462	387	vt->due = VTIM_real() + vt->interval;
463	387	vbp_heap_insert(vt);
464	387	vt = NULL;
465	389	} else if (vt->state == vbp_state_cooling) {
466	2	vt->state = vbp_state_cold;
467	2	vt = NULL;
468	2	} else if (vt->state != vbp_state_deleted) {
469	0	WRONG(vt->state->name);
470	0	}
471	389	return (vt);
472		}
473
474		static void v_matchproto_(task_func_t)
475	389	vbp_task(struct worker wrk, void priv)
476		{
477		struct vbp_target *vt;
478
479	389	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
480	389	CAST_OBJ_NOTNULL(vt, priv, VBP_TARGET_MAGIC);
481
482	389	AN(vt->req);
483	389	assert(vt->req_len > 0);
484
485	389	vbp_start_poke(vt);
486	389	vbp_poke(vt);
487	389	vbp_has_poked(vt);
488	389	VBP_Update_Backend(vt);
489
490	389	Lck_Lock(&vbp_mtx);
491	389	vt = vbp_task_complete(vt);
492	389	Lck_Unlock(&vbp_mtx);
493	389	if (vt == NULL)
494	389	return;
495	0	vbp_delete(vt);
496	389	}
497
498		/*--------------------------------------------------------------------
499		*/

Henceforth, whatever our philosopher says about Matter will apply to extension and to extension alone. It cannot be apprehended by sight, nor by hearing, nor by smell, nor by taste, for it is neither colour, nor sound, nor odour, nor juice. Neither can it be touched, for it is not a body, but it becomes corporeal on being blended with sensible qualities. And, in a later essay, he describes it as receiving all things and letting them depart again without retaining the slightest trace of their presence.483 Why then, it may be asked, if Plotinus meant extension, could he not say so at once, and save us all this trouble in hunting out his meaning? There were very good reasons why he should not. In the first place, he wished to express himself, so far as possible, in Aristotelian phraseology, and this was incompatible with the reduction of Matter to extension. In the next place, the idea of an infinite void had been already appropriated by the Epicureans, to whose system he was bitterly opposed. And, finally, the extension of ordinary327 experience had not the absolute generality which was needed in order to bring Matter into relation with that ultimate abstraction whence, like everything else, it has now to be derived. That the millionaire was genuine, “in person and not a caricature,” as Dick put it, was evident. Both the nurse, his relative, and his wife, were chatting with him as Jeff delivered the heavy packed ball made up of the gum. 233 "I guess not," said Landor, tolerantly, as he turned[Pg 106] his horse over to his orderly; "but, anyway," he added to Ellton, "we had a picnic—of a sort." Si, unable to think of anything better, went with him. The train had stopped on a switch, and seemed likely to rust fast to the rails, from the way other trains were going by in both directions. The bridge gang, under charge of a burly, red-faced young Englishman, was in the rear car, with their tools, equipments, bedding and cooking utensils. THE DEACON HAS SOME EXPERIENCES WITH THE QUADRUPED. "You are not within a mile of the truth. I know it. Look here: I believe that is Gen. Rosecrans's own cow. She's gone, and I got an order to look around for her. I've never seen her, but from the description given me I believe that's she. Who brought her here?" "Deacon, these brothers and sisters who have come here with me to-night are, like myself, deeply interested in the moral condition of the army, where we all have sons or kinsmen. Now, can't you sit right there and tell us of your observations and experiences, as a Christian man and father, from day to day, of every day that you were down there? Tell us everything, just as it happened each day, that we may be able to judge for ourselves." HAS AN ENCOUNTER WITH THE PROVOST-MARSHAL. "Wonder which one o' them is the 200th Injianny's?" said Si to Shorty. "And your mother, and Harry?" The daughter must be the girl who was talking to him now. She sat on a little stool by the fire, and had brought out some sewing. "Over at Grandturzel—can't see wot's burning from here. Git buckets and come!" These things, however, gave little concern to the worthy who commanded the Kentish division. Tyler, though an excellent blacksmith, possessed few of the qualities requisite for forming a good general. Provided there was no very sensible diminution in the number of his followers, he cared not a straw for the score or two who, after quarrelling, or perhaps fighting, withdrew in such disgust that they vowed rather to pay the full tax for ever than submit to the insolence of the rebels. One man could fight as well as another, reasoned he; and, provided he was obeyed, what mattered it by whom. Dick went and Tom came—it was sure to be all one in the end. But this burst of indignation soon passed away, and upon the suggestion of the prudent Sir Robert Hailes, he sent an evasive answer, with a command that the Commons should attend him at Windsor on the Sunday following. That it was a stratagem to gain entrance to the Tower, was the opinion of several, but, after much discussion, it was decided that the man should be admitted, and that the monk should be exhibited merely to intimidate the rebels, until the result of this promised communication should be known. HoME 女同性恋cbcb ENTER NUMBET 0017
www.secaila.com.cn
mawu8.net.cn
anguo9.com.cn
toude1.com.cn
fanci1.com.cn
www.laoer1.net.cn
wanda6.com.cn
nazao5.net.cn
yuemi3.com.cn
www.28fa.com.cn