GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * 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.
 *
 * The director implementation for VCL backends.
 *
 */

#include "config.h"

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

#include "cache_int.h"
#include "cache_director.h"

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

#include "cache_backend.h"
#include "cache_conn_pool.h"
#include "cache_transport.h"
#include "cache_vcl.h"
#include "http1/cache_http1.h"
#include "proxy/cache_proxy.h"

#include "VSC_vbe.h"

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

enum connwait_e {
        CW_DO_CONNECT = 1,
        CW_QUEUED,
        CW_DEQUEUED,
        CW_BE_BUSY,
};

struct connwait {
        unsigned                        magic;
#define CONNWAIT_MAGIC                  0x75c7a52b
        enum connwait_e                 cw_state;
        VTAILQ_ENTRY(connwait)          cw_list;
        pthread_cond_t                  cw_cond;
};

static const char * const vbe_proto_ident = "HTTP Backend";

static struct lock backends_mtx;

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

void
VBE_Connect_Error(struct VSC_vbe *vsc, int err)
{

        switch(err) {
        case 0:
                /*
                 * This is kind of brittle, but zero is the only
                 * value of errno we can trust to have no meaning.
                 */
                vsc->helddown++;
                break;
        case EACCES:
        case EPERM:
                vsc->fail_eacces++;
                break;
        case EADDRNOTAVAIL:
                vsc->fail_eaddrnotavail++;
                break;
        case ECONNREFUSED:
                vsc->fail_econnrefused++;
                break;
        case ENETUNREACH:
                vsc->fail_enetunreach++;
                break;
        case ETIMEDOUT:
                vsc->fail_etimedout++;
                break;
        default:
                vsc->fail_other++;
        }
}

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

#define FIND_TMO(tmx, dst, bo, be)                                      \
        do {                                                            \
                CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);                   \
                dst = bo->tmx;                                          \
                if (isnan(dst) && be->tmx >= 0.0)                       \
                        dst = be->tmx;                                  \
                if (isnan(dst))                                         \
                        dst = cache_param->tmx;                         \
        } while (0)

#define FIND_BE_SPEC(tmx, dst, be, def)                                 \
        do {                                                            \
                CHECK_OBJ_NOTNULL(bp, BACKEND_MAGIC);                   \
                dst = be->tmx;                                          \
                if (dst == def)                                         \
                        dst = cache_param->tmx;                         \
        } while (0)

#define FIND_BE_PARAM(tmx, dst, be)                                     \
        FIND_BE_SPEC(tmx, dst, be, 0)

#define FIND_BE_TMO(tmx, dst, be)                                       \
        FIND_BE_SPEC(tmx, dst, be, -1.0)

#define BE_BUSY(be)     \
        (be->max_connections > 0 && be->n_conn >= be->max_connections)

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

static void
vbe_connwait_broadcast(const struct backend *bp)
{
        struct connwait *cw;

        CHECK_OBJ_NOTNULL(bp, BACKEND_MAGIC);

        Lck_Lock(bp->director->mtx);
        VTAILQ_FOREACH(cw, &bp->cw_head, cw_list) {
                CHECK_OBJ(cw, CONNWAIT_MAGIC);
                assert(cw->cw_state == CW_QUEUED);
                PTOK(pthread_cond_signal(&cw->cw_cond));
        }
        Lck_Unlock(bp->director->mtx);
}

static void
vbe_connwait_signal_locked(const struct backend *bp)
{
        struct connwait *cw;

        Lck_AssertHeld(bp->director->mtx);

        if (bp->n_conn < bp->max_connections) {
                cw = VTAILQ_FIRST(&bp->cw_head);
                if (cw != NULL) {
                        CHECK_OBJ(cw, CONNWAIT_MAGIC);
                        assert(cw->cw_state == CW_QUEUED);
                        PTOK(pthread_cond_signal(&cw->cw_cond));
                }
        }
}

static void
vbe_connwait_fini(struct connwait *cw)
{
        CHECK_OBJ_NOTNULL(cw, CONNWAIT_MAGIC);
        assert(cw->cw_state != CW_QUEUED);
        PTOK(pthread_cond_destroy(&cw->cw_cond));
        FINI_OBJ(cw);
}

/*--------------------------------------------------------------------
 * Update bc_ counters by reason (implementing ses_close_acct for backends)
 *
 * assuming that the approximation of non-atomic global counters is sufficient.
 * if not: update to per-wrk
 */

static void
vbe_close_acct(const struct pfd *pfd, struct VSC_vbe *vsc,
    const stream_close_t reason)
{

        if (reason == SC_NULL) {
                assert(PFD_State(pfd) == PFD_STATE_USED);
                VSC_C_main->bc_tx_proxy++;
                vsc->tx_proxy++;
                return;
        }

#define SESS_CLOSE(U, l, err, desc)                                     \
        if (reason == SC_ ## U) {                                       \
                VSC_C_main->bc_ ## l++;                                 \
                vsc->l++;                                               \
                if (err) {                                              \
                        VSC_C_main->backend_closed_err++;               \
                        vsc->closed_err++;                              \
                }                                                       \
                return;                                                 \
        }
#include "tbl/sess_close.h"
        else
                WRONG("Wrong event in vbe_close_acct");
}

static void v_matchproto_(vdi_finish_f)
vbe_dir_finish(VRT_CTX, VCL_BACKEND d)
{
        struct backend *bp;
        struct busyobj *bo;
        struct pfd *pfd;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
        bo = ctx->bo;
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        CAST_OBJ_NOTNULL(bp, d->priv, BACKEND_MAGIC);
        AN(bp->vsc);

        CHECK_OBJ_NOTNULL(bo->htc, HTTP_CONN_MAGIC);
        CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);

        pfd = bo->htc->priv;
        bo->htc->priv = NULL;
        if (bo->htc->doclose != SC_NULL || bp->proxy_header != 0) {
                vbe_close_acct(pfd, bp->vsc, bo->htc->doclose);
                VSLb(bo->vsl, SLT_BackendClose, "%d %s close %s", *PFD_Fd(pfd),
                    VRT_BACKEND_string(d), bo->htc->doclose->name);
                VCP_Close(&pfd);
                AZ(pfd);
                Lck_Lock(bp->director->mtx);
                VSC_C_main->backend_closed++;
                bp->vsc->closed++;
        } else {
                assert (PFD_State(pfd) == PFD_STATE_USED);
                /*
                 * Recycling a connection with an unread body hands the
                 * next fetch somebody else's octets.
                 */
                assert(bo->htc->body_status == BS_NONE ||
                    bo->htc->body_status == BS_TAKEN);
                VSLb(bo->vsl, SLT_BackendClose, "%d %s recycle", *PFD_Fd(pfd),
                    VRT_BACKEND_string(d));
                Lck_Lock(bp->director->mtx);
                VSC_C_main->backend_recycle++;
                VCP_Recycle(bo->wrk, &pfd);
        }
        assert(bp->n_conn > 0);
        bp->n_conn--;
        AN(bp->vsc);
        bp->vsc->conn--;
#define ACCT(foo)       bp->vsc->foo += bo->acct.foo;
#include "tbl/acct_fields_bereq.h"
        vbe_connwait_signal_locked(bp);
        Lck_Unlock(bp->director->mtx);
        bo->htc = NULL;
}

/*--------------------------------------------------------------------
 * Get a connection to the backend
 *
 * note: wrk is a separate argument because it differs for pipe vs. fetch
 */

static struct pfd *
vbe_dir_getfd(VRT_CTX, struct worker *wrk, VCL_BACKEND dir, struct backend *bp,
    unsigned force_fresh)
{
        struct busyobj *bo;
        struct pfd *pfd;
        int *fdp, err;
        vtim_dur tmod;
        char abuf1[VTCP_ADDRBUFSIZE], abuf2[VTCP_ADDRBUFSIZE];
        char pbuf1[VTCP_PORTBUFSIZE], pbuf2[VTCP_PORTBUFSIZE];
        unsigned wait_limit;
        vtim_dur wait_tmod;
        vtim_dur wait_end;
        struct connwait cw[1];

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
        bo = ctx->bo;
        CHECK_OBJ_NOTNULL(bp, BACKEND_MAGIC);
        AN(bp->vsc);

        if (!VRT_Healthy(ctx, dir, NULL)) {
                VSLb(bo->vsl, SLT_FetchError,
                     "backend %s: unhealthy", VRT_BACKEND_string(dir));
                bp->vsc->unhealthy++;
                VSC_C_main->backend_unhealthy++;
                return (NULL);
        }
        INIT_OBJ(cw, CONNWAIT_MAGIC);
        PTOK(pthread_cond_init(&cw->cw_cond, NULL));
        Lck_Lock(bp->director->mtx);
        FIND_BE_PARAM(backend_wait_limit, wait_limit, bp);
        FIND_BE_TMO(backend_wait_timeout, wait_tmod, bp);
        cw->cw_state = CW_DO_CONNECT;
        if (!VTAILQ_EMPTY(&bp->cw_head) || BE_BUSY(bp))
                cw->cw_state = CW_BE_BUSY;

        if (cw->cw_state == CW_BE_BUSY && wait_limit > 0 &&
            wait_tmod > 0.0 && bp->cw_count < wait_limit) {
                VTAILQ_INSERT_TAIL(&bp->cw_head, cw, cw_list);
                bp->cw_count++;
                VSC_C_main->backend_wait++;
                cw->cw_state = CW_QUEUED;
                wait_end = VTIM_real() + wait_tmod;
                do {
                        err = Lck_CondWaitUntil(&cw->cw_cond, bp->director->mtx,
                            wait_end);
                } while (err == EINTR);
                assert(cw->cw_state == CW_QUEUED);
                VTAILQ_REMOVE(&bp->cw_head, cw, cw_list);
                cw->cw_state = CW_DEQUEUED;
                bp->cw_count--;
                if ((err != 0 && BE_BUSY(bp)) || !VRT_Healthy(ctx, dir, NULL)) {
                        VSC_C_main->backend_wait_fail++;
                        cw->cw_state = CW_BE_BUSY;
                }
        }
        if (cw->cw_state != CW_BE_BUSY)
                bp->n_conn++;

        if (!VTAILQ_EMPTY(&bp->cw_head) && !BE_BUSY(bp)) {
                /* Signal the new head of the waiting queue */
                vbe_connwait_signal_locked(bp);
        }

        Lck_Unlock(bp->director->mtx);

        if (cw->cw_state == CW_BE_BUSY) {
                VSLb(bo->vsl, SLT_FetchError,
                     "backend %s: busy", VRT_BACKEND_string(dir));
                bp->vsc->busy++;
                VSC_C_main->backend_busy++;
                vbe_connwait_fini(cw);
                return (NULL);
        }

        AZ(bo->htc);
        bo->htc = WS_Alloc(bo->ws, sizeof *bo->htc);
        /* XXX: we may want to detect the ws overflow sooner */
        if (bo->htc == NULL) {
                VSLb(bo->vsl, SLT_FetchError, "out of workspace");
                /* XXX: counter ? */
                Lck_Lock(bp->director->mtx);
                bp->n_conn--;
                vbe_connwait_signal_locked(bp);
                Lck_Unlock(bp->director->mtx);
                vbe_connwait_fini(cw);
                return (NULL);
        }
        bo->htc->doclose = SC_NULL;
        CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);

        FIND_TMO(connect_timeout, tmod, bo, bp);
        pfd = VCP_Get(bp->conn_pool, tmod, wrk, force_fresh, &err);
        if (pfd == NULL) {
                Lck_Lock(bp->director->mtx);
                VBE_Connect_Error(bp->vsc, err);
                bp->n_conn--;
                vbe_connwait_signal_locked(bp);
                Lck_Unlock(bp->director->mtx);
                VSLb(bo->vsl, SLT_FetchError,
                     "backend %s: fail errno %d (%s)",
                     VRT_BACKEND_string(dir), err, VAS_errtxt(err));
                VSC_C_main->backend_fail++;
                bo->htc = NULL;
                vbe_connwait_fini(cw);
                return (NULL);
        }

        VSLb_ts_busyobj(bo, "Connected", W_TIM_real(wrk));
        fdp = PFD_Fd(pfd);
        AN(fdp);
        assert(*fdp >= 0);

        Lck_Lock(bp->director->mtx);
        bp->vsc->conn++;
        bp->vsc->req++;
        Lck_Unlock(bp->director->mtx);

        INIT_OBJ(bo->htc, HTTP_CONN_MAGIC);
        bo->htc->priv = pfd;
        bo->htc->rfd = fdp;
        bo->htc->doclose = SC_NULL;
        CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);

        err = 0;
        if (bp->proxy_header != 0)
                err = VPX_Send_Proxy(*fdp, bp->proxy_header, bo->sp);
        if (err < 0) {
                VSLb(bo->vsl, SLT_FetchError,
                     "backend %s: proxy write errno %d (%s)",
                     VRT_BACKEND_string(dir),
                     errno, VAS_errtxt(errno));
                bo->htc->doclose = SC_TX_ERROR;
                Lck_Lock(bp->director->mtx);
                VSC_C_main->backend_fail++;
                bp->vsc->req--;
                Lck_Unlock(bp->director->mtx);
                vbe_dir_finish(ctx, dir);
                vbe_connwait_fini(cw);
                return (NULL);
        }
        bo->acct.bereq_hdrbytes += err;

        PFD_LocalName(pfd, abuf1, sizeof abuf1, pbuf1, sizeof pbuf1);
        PFD_RemoteName(pfd, abuf2, sizeof abuf2, pbuf2, sizeof pbuf2);
        if (PFD_State(pfd) != PFD_STATE_STOLEN) {
                VSLb(bo->vsl, SLT_BackendOpen, "%d %s %s %s %s %s connect",
                    *fdp, VRT_BACKEND_string(dir), abuf2, pbuf2, abuf1, pbuf1);
        } else {
                VSLb(bo->vsl, SLT_BackendOpen,
                    "%d %s %s %s %s %s reuse %.6f %ju", *fdp,
                    VRT_BACKEND_string(dir), abuf2, pbuf2, abuf1, pbuf1,
                    PFD_Age(pfd), (uintmax_t)PFD_Reused(pfd));
        }

        FIND_TMO(first_byte_timeout,
            bo->htc->first_byte_timeout, bo, bp);
        FIND_TMO(between_bytes_timeout,
            bo->htc->between_bytes_timeout, bo, bp);
        vbe_connwait_fini(cw);
        return (pfd);
}

static int v_matchproto_(vdi_gethdrs_f)
vbe_dir_gethdrs(VRT_CTX, VCL_BACKEND d)
{
        int i, retry_connect = 1;
        struct backend *bp;
        struct pfd *pfd;
        struct busyobj *bo;
        struct worker *wrk;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
        bo = ctx->bo;
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
        CHECK_OBJ_NOTNULL(bo->bereq, HTTP_MAGIC);
        if (bo->htc != NULL)
                CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
        wrk = ctx->bo->wrk;
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CAST_OBJ_NOTNULL(bp, d->priv, BACKEND_MAGIC);

        /*
         * Now that we know our backend, we can set a default Host:
         * header if one is necessary.  This cannot be done in the VCL
         * because the backend may be chosen by a director.
         */
        if (!http_GetHdr(bo->bereq, H_Host, NULL) && bp->hosthdr != NULL)
                http_PrintfHeader(bo->bereq, "Host: %s", bp->hosthdr);

        do {
                if (bo->htc != NULL)
                        CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
                pfd = vbe_dir_getfd(ctx, wrk, d, bp, retry_connect == 0 ? 1 : 0);
                if (pfd == NULL)
                        return (-1);
                AN(bo->htc);
                CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
                if (PFD_State(pfd) != PFD_STATE_STOLEN)
                        retry_connect = 0;

                i = V1F_SendReq(wrk, bo, &bo->acct.bereq_hdrbytes,
                    &bo->acct.bereq_bodybytes);

                if (i == 0 && PFD_State(pfd) != PFD_STATE_USED) {
                        if (VCP_Wait(wrk, pfd, VTIM_real() +
                            bo->htc->first_byte_timeout) != 0) {
                                bo->htc->doclose = SC_RX_TIMEOUT;
                                VSLb(bo->vsl, SLT_FetchError,
                                     "first byte timeout (reused connection)");
                                retry_connect = 0;
                        }
                }

                if (bo->htc->doclose == SC_NULL) {
                        assert(PFD_State(pfd) == PFD_STATE_USED);
                        if (i == 0)
                                i = V1F_FetchRespHdr(bo);
                        if (i == 0) {
                                AN(bo->htc->priv);
                                http_VSL_log(bo->beresp);
                                return (0);
                        }
                }
                CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);

                /*
                 * If we recycled a backend connection, there is a finite chance
                 * that the backend closed it before we got the bereq to it.
                 * In that case do a single automatic retry if req.body allows.
                 */
                vbe_dir_finish(ctx, d);
                AZ(bo->htc);
                if (i < 0 || retry_connect == 0)
                        break;
                if (bo->no_retry != NULL)
                        break;
                VSC_C_main->backend_retry++;
        } while (retry_connect--);
        return (-1);
}

static VCL_IP v_matchproto_(vdi_getip_f)
vbe_dir_getip(VRT_CTX, VCL_BACKEND d)
{
        struct pfd *pfd;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->bo->htc, HTTP_CONN_MAGIC);
        pfd = ctx->bo->htc->priv;

        return (VCP_GetIp(pfd));
}

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

static stream_close_t v_matchproto_(vdi_http1pipe_f)
vbe_dir_http1pipe(VRT_CTX, VCL_BACKEND d)
{
        int i;
        stream_close_t retval;
        struct backend *bp;
        struct v1p_acct v1a;
        struct pfd *pfd;
        vtim_real deadline;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
        CAST_OBJ_NOTNULL(bp, d->priv, BACKEND_MAGIC);

        memset(&v1a, 0, sizeof v1a);

        /* This is hackish... */
        v1a.req = ctx->req->acct.req_hdrbytes;
        ctx->req->acct.req_hdrbytes = 0;

        ctx->req->res_pipe = 1;

        retval = SC_TX_ERROR;
        pfd = vbe_dir_getfd(ctx, ctx->req->wrk, d, bp, 0);

        if (pfd != NULL) {
                CHECK_OBJ_NOTNULL(ctx->bo->htc, HTTP_CONN_MAGIC);
                i = V1F_SendReq(ctx->req->wrk, ctx->bo,
                    &v1a.bereq, &v1a.out);
                VSLb_ts_req(ctx->req, "Pipe", W_TIM_real(ctx->req->wrk));
                if (i == 0) {
                        deadline = ctx->bo->task_deadline;
                        if (isnan(deadline))
                                deadline = cache_param->pipe_task_deadline;
                        if (deadline > 0.)
                                deadline += ctx->req->sp->t_idle;
                        retval = V1P_Process(ctx->req, *PFD_Fd(pfd), &v1a,
                            deadline);
                }
                VSLb_ts_req(ctx->req, "PipeSess", W_TIM_real(ctx->req->wrk));
                ctx->bo->htc->doclose = retval;
                vbe_dir_finish(ctx, d);
        }
        V1P_Charge(ctx->req, &v1a, bp->vsc);
        CHECK_OBJ_NOTNULL(retval, STREAM_CLOSE_MAGIC);
        return (retval);
}

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

static void
vbe_dir_event(const struct director *d, enum vcl_event_e ev)
{
        struct backend *bp;

        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
        CAST_OBJ_NOTNULL(bp, d->priv, BACKEND_MAGIC);

        if (ev == VCL_EVENT_WARM) {
                VRT_VSC_Reveal(bp->vsc_seg);
                if (bp->probe != NULL)
                        VBP_Control(bp, 1);
        } else if (ev == VCL_EVENT_COLD) {
                if (bp->probe != NULL)
                        VBP_Control(bp, 0);
                VRT_VSC_Hide(bp->vsc_seg);
        } else if (ev == VCL_EVENT_DISCARD) {
                VRT_DelDirector(&bp->director);
        } else if (ev == VDI_EVENT_SICK) {
                const struct vdi_ahealth *ah = d->vdir->admin_health;

                if (ah == VDI_AH_SICK || (ah == VDI_AH_AUTO && bp->sick))
                        vbe_connwait_broadcast(bp);
        }
}

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

static void
vbe_free(struct backend *be)
{

        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);

        if (be->probe != NULL)
                VBP_Remove(be);

        VSC_vbe_Destroy(&be->vsc_seg);
        Lck_Lock(&backends_mtx);
        VSC_C_main->n_backend--;
        Lck_Unlock(&backends_mtx);
        VCP_Rel(&be->conn_pool);

#define DA(x)   do { if (be->x != NULL) free(be->x); } while (0)
#define DN(x)   /**/
        VRT_BACKEND_HANDLE();
#undef DA
#undef DN
        free(be->endpoint);

        assert(VTAILQ_EMPTY(&be->cw_head));
        FREE_OBJ(be);
}

static void v_matchproto_(vdi_destroy_f)
vbe_destroy(const struct director *d)
{
        struct backend *be;

        CAST_OBJ_NOTNULL(be, d->priv, BACKEND_MAGIC);
        vbe_free(be);
}

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

static void
vbe_panic(const struct director *d, struct vsb *vsb)
{
        struct backend *bp;

        PAN_CheckMagic(vsb, d, DIRECTOR_MAGIC);
        bp = d->priv;
        PAN_CheckMagic(vsb, bp, BACKEND_MAGIC);

        VCP_Panic(vsb, bp->conn_pool);
        VSB_printf(vsb, "hosthdr = %s,\n", bp->hosthdr);
        VSB_printf(vsb, "n_conn = %u,\n", bp->n_conn);
}

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

static void v_matchproto_(vdi_list_f)
vbe_list(VRT_CTX, const struct director *d, struct vsb *vsb, int pflag,
    int jflag)
{
        char buf[VTCP_ADDRBUFSIZE];
        struct backend *bp;
        struct vrt_endpoint *vep;

        (void)ctx;

        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
        CAST_OBJ_NOTNULL(bp, d->priv, BACKEND_MAGIC);
        CHECK_OBJ_NOTNULL(bp->endpoint, VRT_ENDPOINT_MAGIC);

        vep = bp->endpoint;

        if (bp->probe != NULL)
                VBP_Status(vsb, bp, pflag, jflag);
        else if (jflag && pflag)
                VSB_cat(vsb, "{},\n");
        else if (jflag)
                VSB_cat(vsb, "[0, 0, \"healthy\"]");
        else if (pflag)
                return;
        else
                VSB_cat(vsb, "0/0\thealthy");

        if (jflag && pflag) {
                if (vep->ipv4 != NULL) {
                        VTCP_name(vep->ipv4, buf, sizeof buf, NULL, 0);
                        VSB_printf(vsb, "\"ipv4\": \"%s\",\n", buf);
                }
                if (vep->ipv6 != NULL) {
                        VTCP_name(vep->ipv6, buf, sizeof buf, NULL, 0);
                        VSB_printf(vsb, "\"ipv6\": \"%s\",\n", buf);
                }
        }
}

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

static VCL_BOOL v_matchproto_(vdi_healthy_f)
vbe_healthy(VRT_CTX, VCL_BACKEND d, VCL_TIME *t)
{
        struct backend *bp;

        (void)ctx;
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
        CAST_OBJ_NOTNULL(bp, d->priv, BACKEND_MAGIC);

        if (t != NULL)
                *t = bp->changed;

        return (!bp->sick);
}

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

static const struct vdi_methods vbe_methods[1] = {{
        .magic =                VDI_METHODS_MAGIC,
        .type =                 "backend",
        .http1pipe =            vbe_dir_http1pipe,
        .gethdrs =              vbe_dir_gethdrs,
        .getip =                vbe_dir_getip,
        .finish =               vbe_dir_finish,
        .event =                vbe_dir_event,
        .destroy =              vbe_destroy,
        .panic =                vbe_panic,
        .list =                 vbe_list,
        .healthy =              vbe_healthy
}};

static const struct vdi_methods vbe_methods_noprobe[1] = {{
        .magic =                VDI_METHODS_MAGIC,
        .type =                 "backend",
        .http1pipe =            vbe_dir_http1pipe,
        .gethdrs =              vbe_dir_gethdrs,
        .getip =                vbe_dir_getip,
        .finish =               vbe_dir_finish,
        .event =                vbe_dir_event,
        .destroy =              vbe_destroy,
        .panic =                vbe_panic,
        .list =                 vbe_list
}};

/*--------------------------------------------------------------------
 * Create a new static or dynamic director::backend instance.
 */

size_t
VRT_backend_vsm_need(VRT_CTX)
{
        (void)ctx;
        return (VRT_VSC_Overhead(VSC_vbe_size));
}

/*
 * The new_backend via parameter is a VCL_BACKEND, but we need a (struct
 * backend)
 *
 * For now, we resolve it when creating the backend, which implies no redundancy
 * / load balancing across the via director if it is more than a simple backend.
 */

static const struct backend *
via_resolve(VRT_CTX, const struct vrt_endpoint *vep, VCL_BACKEND via)
{
        const struct backend *viabe = NULL;

        CHECK_OBJ_NOTNULL(vep, VRT_ENDPOINT_MAGIC);
        CHECK_OBJ_NOTNULL(via, DIRECTOR_MAGIC);

        if (vep->uds_path) {
                VRT_fail(ctx, "Via is only supported for IP addresses");
                return (NULL);
        }

        via = VRT_DirectorResolve(ctx, via);

        if (via == NULL) {
                VRT_fail(ctx, "Via resolution failed");
                return (NULL);
        }

        CHECK_OBJ(via, DIRECTOR_MAGIC);
        CHECK_OBJ_NOTNULL(via->vdir, VCLDIR_MAGIC);

        if (via->vdir->methods == vbe_methods ||
            via->vdir->methods == vbe_methods_noprobe)
                CAST_OBJ_NOTNULL(viabe, via->priv, BACKEND_MAGIC);

        if (viabe == NULL)
                VRT_fail(ctx, "Via does not resolve to a backend");

        return (viabe);
}

/*
 * construct a new endpoint identical to vep with sa in a proxy header
 */
static struct vrt_endpoint *
via_endpoint(const struct vrt_endpoint *vep, const struct suckaddr *sa,
    const char *auth)
{
        struct vsb *preamble;
        struct vrt_blob blob[1];
        struct vrt_endpoint *nvep, *ret;
        const struct suckaddr *client_bogo;

        CHECK_OBJ_NOTNULL(vep, VRT_ENDPOINT_MAGIC);
        AN(sa);

        nvep = VRT_Endpoint_Clone(vep);
        CHECK_OBJ_NOTNULL(nvep, VRT_ENDPOINT_MAGIC);

        if (VSA_Get_Proto(sa) == AF_INET6)
                client_bogo = bogo_ip6;
        else
                client_bogo = bogo_ip;

        preamble = VSB_new_auto();
        AN(preamble);
        VPX_Format_Proxy(preamble, 2, client_bogo, sa, auth);
        INIT_OBJ(blob, VRT_BLOB_MAGIC);
        blob->blob = VSB_data(preamble);
        blob->len = VSB_len(preamble);
        nvep->preamble = blob;
        ret = VRT_Endpoint_Clone(nvep);
        CHECK_OBJ_NOTNULL(ret, VRT_ENDPOINT_MAGIC);
        VSB_destroy(&preamble);
        FREE_OBJ(nvep);

        return (ret);
}

VCL_BACKEND
VRT_new_backend_clustered(VRT_CTX, struct vsmw_cluster *vc,
    const struct vrt_backend *vrt, VCL_BACKEND via)
{
        struct backend *be;
        struct vcl *vcl;
        const struct vrt_backend_probe *vbp;
        const struct vrt_endpoint *vep;
        const struct vdi_methods *m;
        const struct suckaddr *sa = NULL;
        char abuf[VTCP_ADDRBUFSIZE];
        const struct backend *viabe = NULL;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vrt, VRT_BACKEND_MAGIC);
        vep = vrt->endpoint;
        CHECK_OBJ_NOTNULL(vep, VRT_ENDPOINT_MAGIC);
        if (vep->uds_path == NULL) {
                if (vep->ipv4 == NULL && vep->ipv6 == NULL) {
                        VRT_fail(ctx, "%s: Illegal IP", __func__);
                        return (NULL);
                }
        } else {
                assert(vep->ipv4== NULL && vep->ipv6== NULL);
        }

        if (via != NULL) {
                viabe = via_resolve(ctx, vep, via);
                if (viabe == NULL)
                        return (NULL);
        }

        vcl = ctx->vcl;
        AN(vcl);
        AN(vrt->vcl_name);

        if (vrt->authority && vstrlen(vrt->authority) > BUFSIZ) {
                VRT_fail(ctx, "%s: Excessive authority length", vrt->vcl_name);
                return (NULL);
        }
        if (vrt->hosthdr && vstrlen(vrt->hosthdr) > BUFSIZ) {
                VRT_fail(ctx, "%s: Excessive hosthdr length", vrt->vcl_name);
                return (NULL);
        }

        /* Create new backend */
        ALLOC_OBJ(be, BACKEND_MAGIC);
        if (be == NULL)
                return (NULL);
        VTAILQ_INIT(&be->cw_head);

#define DA(x)   do { if (vrt->x != NULL) REPLACE((be->x), (vrt->x)); } while (0)
#define DN(x)   do { be->x = vrt->x; } while (0)
        VRT_BACKEND_HANDLE();
#undef DA
#undef DN

#define CPTMO(a, b, x) do {                             \
                if ((a)->x < 0.0 || isnan((a)->x))      \
                        (a)->x = (b)->x;                \
        } while(0)

        if (viabe != NULL) {
                CPTMO(be, viabe, connect_timeout);
                CPTMO(be, viabe, first_byte_timeout);
                CPTMO(be, viabe, between_bytes_timeout);
        }
#undef CPTMO

        if (viabe || be->hosthdr == NULL) {
                if (vrt->endpoint->uds_path != NULL)
                        sa = bogo_ip;
                else if (cache_param->prefer_ipv6 && vep->ipv6 != NULL)
                        sa = vep->ipv6;
                else if (vep->ipv4!= NULL)
                        sa = vep->ipv4;
                else
                        sa = vep->ipv6;
                if (be->hosthdr == NULL) {
                        VTCP_name(sa, abuf, sizeof abuf, NULL, 0);
                        REPLACE(be->hosthdr, abuf);
                }
        }

        be->vsc = VSC_vbe_New(vc, &be->vsc_seg,
            "%s.%s", VCL_Name(ctx->vcl), vrt->vcl_name);
        AN(be->vsc);
        if (! vcl->temp->is_warm)
                VRT_VSC_Hide(be->vsc_seg);

        if (viabe)
                vep = be->endpoint = via_endpoint(viabe->endpoint, sa,
                    be->authority);
        else
                vep = be->endpoint = VRT_Endpoint_Clone(vep);

        AN(vep);
        be->conn_pool = VCP_Ref(vep, vbe_proto_ident);
        AN(be->conn_pool);

        vbp = vrt->probe;
        if (vbp == NULL)
                vbp = VCL_DefaultProbe(vcl);

        if (vbp != NULL) {
                VBP_Insert(be, vbp, be->conn_pool);
                m = vbe_methods;
        } else {
                be->sick = 0;
                be->vsc->happy = UINT64_MAX;
                m = vbe_methods_noprobe;
        }

        Lck_Lock(&backends_mtx);
        VSC_C_main->n_backend++;
        Lck_Unlock(&backends_mtx);

        be->director = VRT_AddDirector(ctx, m, be, "%s", vrt->vcl_name);

        if (be->director == NULL) {
                vbe_free(be);
                return (NULL);
        }
        /* for cold VCL, update initial director state */
        if (be->probe != NULL)
                VBP_Update_Backend(be->probe);
        return (be->director);
}

VCL_BACKEND
VRT_new_backend(VRT_CTX, const struct vrt_backend *vrt, VCL_BACKEND via)
{

        CHECK_OBJ_NOTNULL(vrt, VRT_BACKEND_MAGIC);
        CHECK_OBJ_NOTNULL(vrt->endpoint, VRT_ENDPOINT_MAGIC);
        return (VRT_new_backend_clustered(ctx, NULL, vrt, via));
}

/*--------------------------------------------------------------------
 * Delete a dynamic director::backend instance.  Undeleted dynamic and
 * static instances are GC'ed when the VCL is discarded (in cache_vcl.c)
 */

void
VRT_delete_backend(VRT_CTX, VCL_BACKEND *dp)
{

        (void)ctx;
        CHECK_OBJ_NOTNULL(*dp, DIRECTOR_MAGIC);
        VRT_DisableDirector(*dp);
        VRT_Assign_Backend(dp, NULL);
}

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

void
VBE_InitCfg(void)
{

        Lck_New(&backends_mtx, lck_vbe);
}

		vinyl-cache/bin/vinyld/cache/cache_backend.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
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		* The director implementation for VCL backends.
31		*
32		*/
33
34		#include "config.h"
35
36		#include <stdlib.h>
37		#include <stdio.h>
38	8659
39	8218	#include "cache_int.h"
40	7945	#include "cache_director.h"
41	7819
42	7672	#include "vtcp.h"
43	5593	#include "vtim.h"
44	5110	#include "vsa.h"
45	4354
46	4123	#include "cache_backend.h"
47	3724	#include "cache_conn_pool.h"
48	3388	#include "cache_transport.h"
49	3388	#include "cache_vcl.h"
50	882	#include "http1/cache_http1.h"
51		#include "proxy/cache_proxy.h"
52
53		#include "VSC_vbe.h"
54
55		/--------------------------------------------------------------------/
56
57		enum connwait_e {
58		CW_DO_CONNECT = 1,
59		CW_QUEUED,
60		CW_DEQUEUED,
61		CW_BE_BUSY,
62		};
63
64		struct connwait {
65		unsigned magic;
66		#define CONNWAIT_MAGIC 0x75c7a52b
67		enum connwait_e cw_state;
68		VTAILQ_ENTRY(connwait) cw_list;
69		pthread_cond_t cw_cond;
70		};
71
72		static const char * const vbe_proto_ident = "HTTP Backend";
73
74		static struct lock backends_mtx;
75
76		/--------------------------------------------------------------------/
77
78		void
79	1302	VBE_Connect_Error(struct VSC_vbe *vsc, int err)
80		{
81
82	1302	switch(err) {
83		case 0:
84		/*
85		* This is kind of brittle, but zero is the only
86		* value of errno we can trust to have no meaning.
87		*/
88	636	vsc->helddown++;
89	636	break;
90		case EACCES:
91		case EPERM:
92	0	vsc->fail_eacces++;
93	0	break;
94		case EADDRNOTAVAIL:
95	0	vsc->fail_eaddrnotavail++;
96	0	break;
97		case ECONNREFUSED:
98	645	vsc->fail_econnrefused++;
99	645	break;
100		case ENETUNREACH:
101	0	vsc->fail_enetunreach++;
102	0	break;
103		case ETIMEDOUT:
104	19	vsc->fail_etimedout++;
105	19	break;
106		default:
107	2	vsc->fail_other++;
108	2	}
109	1302	}
110
111		/--------------------------------------------------------------------/
112
113		#define FIND_TMO(tmx, dst, bo, be) \
114		do { \
115		CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC); \
116		dst = bo->tmx; \
117		if (isnan(dst) && be->tmx >= 0.0) \
118		dst = be->tmx; \
119		if (isnan(dst)) \
120		dst = cache_param->tmx; \
121		} while (0)
122
123		#define FIND_BE_SPEC(tmx, dst, be, def) \
124		do { \
125		CHECK_OBJ_NOTNULL(bp, BACKEND_MAGIC); \
126		dst = be->tmx; \
127		if (dst == def) \
128		dst = cache_param->tmx; \
129		} while (0)
130
131		#define FIND_BE_PARAM(tmx, dst, be) \
132		FIND_BE_SPEC(tmx, dst, be, 0)
133
134		#define FIND_BE_TMO(tmx, dst, be) \
135		FIND_BE_SPEC(tmx, dst, be, -1.0)
136
137		#define BE_BUSY(be) \
138		(be->max_connections > 0 && be->n_conn >= be->max_connections)
139
140		/--------------------------------------------------------------------/
141
142		static void
143	1511	vbe_connwait_broadcast(const struct backend *bp)
144		{
145		struct connwait *cw;
146
147	1511	CHECK_OBJ_NOTNULL(bp, BACKEND_MAGIC);
148
149	1511	Lck_Lock(bp->director->mtx);
150	1700	VTAILQ_FOREACH(cw, &bp->cw_head, cw_list) {
151	189	CHECK_OBJ(cw, CONNWAIT_MAGIC);
152	189	assert(cw->cw_state == CW_QUEUED);
153	189	PTOK(pthread_cond_signal(&cw->cw_cond));
154	189	}
155	1511	Lck_Unlock(bp->director->mtx);
156	1511	}
157
158		static void
159	50021	vbe_connwait_signal_locked(const struct backend *bp)
160		{
161		struct connwait *cw;
162
163	50021	Lck_AssertHeld(bp->director->mtx);
164
165	50021	if (bp->n_conn < bp->max_connections) {
166	231	cw = VTAILQ_FIRST(&bp->cw_head);
167	231	if (cw != NULL) {
168	21	CHECK_OBJ(cw, CONNWAIT_MAGIC);
169	21	assert(cw->cw_state == CW_QUEUED);
170	21	PTOK(pthread_cond_signal(&cw->cw_cond));
171	21	}
172	231	}
173	50021	}
174
175		static void
176	50315	vbe_connwait_fini(struct connwait *cw)
177		{
178	50315	CHECK_OBJ_NOTNULL(cw, CONNWAIT_MAGIC);
179	50315	assert(cw->cw_state != CW_QUEUED);
180	50315	PTOK(pthread_cond_destroy(&cw->cw_cond));
181	50315	FINI_OBJ(cw);
182	50315	}
183
184		/*--------------------------------------------------------------------
185		* Update bc_ counters by reason (implementing ses_close_acct for backends)
186		*
187		* assuming that the approximation of non-atomic global counters is sufficient.
188		* if not: update to per-wrk
189		*/
190
191		static void
192	8743	vbe_close_acct(const struct pfd pfd, struct VSC_vbe vsc,
193		const stream_close_t reason)
194		{
195
196	8743	if (reason == SC_NULL) {
197	84	assert(PFD_State(pfd) == PFD_STATE_USED);
198	84	VSC_C_main->bc_tx_proxy++;
199	84	vsc->tx_proxy++;
200	84	return;
201		}
202
203		#define SESS_CLOSE(U, l, err, desc) \
204		if (reason == SC_ ## U) { \
205		VSC_C_main->bc_ ## l++; \
206		vsc->l++; \
207		if (err) { \
208		VSC_C_main->backend_closed_err++; \
209		vsc->closed_err++; \
210		} \
211		return; \
212		}
213		#include "tbl/sess_close.h"
214		else
215	0	WRONG("Wrong event in vbe_close_acct");
216		}
217
218		static void v_matchproto_(vdi_finish_f)
219	48741	vbe_dir_finish(VRT_CTX, VCL_BACKEND d)
220		{
221		struct backend *bp;
222		struct busyobj *bo;
223		struct pfd *pfd;
224
225	48741	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
226	48741	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
227	48741	bo = ctx->bo;
228	48741	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
229	48741	CAST_OBJ_NOTNULL(bp, d->priv, BACKEND_MAGIC);
230	48741	AN(bp->vsc);
231
232	48741	CHECK_OBJ_NOTNULL(bo->htc, HTTP_CONN_MAGIC);
233	48741	CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
234
235	48741	pfd = bo->htc->priv;
236	48741	bo->htc->priv = NULL;
237	48741	if (bo->htc->doclose != SC_NULL \|\| bp->proxy_header != 0) {
238	8743	vbe_close_acct(pfd, bp->vsc, bo->htc->doclose);
239	17486	VSLb(bo->vsl, SLT_BackendClose, "%d %s close %s", *PFD_Fd(pfd),
240	8743	VRT_BACKEND_string(d), bo->htc->doclose->name);
241	8743	VCP_Close(&pfd);
242	8743	AZ(pfd);
243	8743	Lck_Lock(bp->director->mtx);
244	8743	VSC_C_main->backend_closed++;
245	8743	bp->vsc->closed++;
246	8743	} else {
247	39998	assert (PFD_State(pfd) == PFD_STATE_USED);
248		/*
249		* Recycling a connection with an unread body hands the
250		* next fetch somebody else's octets.
251		*/
252	39998	assert(bo->htc->body_status == BS_NONE \|\|
253		bo->htc->body_status == BS_TAKEN);
254	79996	VSLb(bo->vsl, SLT_BackendClose, "%d %s recycle", *PFD_Fd(pfd),
255	39998	VRT_BACKEND_string(d));
256	39998	Lck_Lock(bp->director->mtx);
257	39998	VSC_C_main->backend_recycle++;
258	39998	VCP_Recycle(bo->wrk, &pfd);
259		}
260	48741	assert(bp->n_conn > 0);
261	48741	bp->n_conn--;
262	48741	AN(bp->vsc);
263	48741	bp->vsc->conn--;
264		#define ACCT(foo) bp->vsc->foo += bo->acct.foo;
265		#include "tbl/acct_fields_bereq.h"
266		vbe_connwait_signal_locked(bp);
267		Lck_Unlock(bp->director->mtx);
268		bo->htc = NULL;
269		}
270
271		/*--------------------------------------------------------------------
272		* Get a connection to the backend
273		*
274		* note: wrk is a separate argument because it differs for pipe vs. fetch
275		*/
276
277		static struct pfd *
278	50420	vbe_dir_getfd(VRT_CTX, struct worker wrk, VCL_BACKEND dir, struct backend bp,
279		unsigned force_fresh)
280		{
281		struct busyobj *bo;
282		struct pfd *pfd;
283		int *fdp, err;
284		vtim_dur tmod;
285		char abuf1[VTCP_ADDRBUFSIZE], abuf2[VTCP_ADDRBUFSIZE];
286		char pbuf1[VTCP_PORTBUFSIZE], pbuf2[VTCP_PORTBUFSIZE];
287		unsigned wait_limit;
288		vtim_dur wait_tmod;
289		vtim_dur wait_end;
290		struct connwait cw[1];
291
292	50420	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
293	50420	CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
294	50420	bo = ctx->bo;
295	50420	CHECK_OBJ_NOTNULL(bp, BACKEND_MAGIC);
296	50420	AN(bp->vsc);
297
298	50420	if (!VRT_Healthy(ctx, dir, NULL)) {
299	210	VSLb(bo->vsl, SLT_FetchError,
300	105	"backend %s: unhealthy", VRT_BACKEND_string(dir));
301	105	bp->vsc->unhealthy++;
302	105	VSC_C_main->backend_unhealthy++;
303	105	return (NULL);
304		}
305	50315	INIT_OBJ(cw, CONNWAIT_MAGIC);
306	50315	PTOK(pthread_cond_init(&cw->cw_cond, NULL));
307	50315	Lck_Lock(bp->director->mtx);
308	50315	FIND_BE_PARAM(backend_wait_limit, wait_limit, bp);
309	50315	FIND_BE_TMO(backend_wait_timeout, wait_tmod, bp);
310	50315	cw->cw_state = CW_DO_CONNECT;
311	50315	if (!VTAILQ_EMPTY(&bp->cw_head) \|\| BE_BUSY(bp))
312	294	cw->cw_state = CW_BE_BUSY;
313
314	50567	if (cw->cw_state == CW_BE_BUSY && wait_limit > 0 &&
315	252	wait_tmod > 0.0 && bp->cw_count < wait_limit) {
316	252	VTAILQ_INSERT_TAIL(&bp->cw_head, cw, cw_list);
317	252	bp->cw_count++;
318	252	VSC_C_main->backend_wait++;
319	252	cw->cw_state = CW_QUEUED;
320	252	wait_end = VTIM_real() + wait_tmod;
321	252	do {
322	504	err = Lck_CondWaitUntil(&cw->cw_cond, bp->director->mtx,
323	252	wait_end);
324	252	} while (err == EINTR);
325	252	assert(cw->cw_state == CW_QUEUED);
326	252	VTAILQ_REMOVE(&bp->cw_head, cw, cw_list);
327	252	cw->cw_state = CW_DEQUEUED;
328	252	bp->cw_count--;
329	252	if ((err != 0 && BE_BUSY(bp)) \|\| !VRT_Healthy(ctx, dir, NULL)) {
330	231	VSC_C_main->backend_wait_fail++;
331	231	cw->cw_state = CW_BE_BUSY;
332	231	}
333	252	}
334	50315	if (cw->cw_state != CW_BE_BUSY)
335	50041	bp->n_conn++;
336
337	50315	if (!VTAILQ_EMPTY(&bp->cw_head) && !BE_BUSY(bp)) {
338		/* Signal the new head of the waiting queue */
339	0	vbe_connwait_signal_locked(bp);
340	0	}
341
342	50315	Lck_Unlock(bp->director->mtx);
343
344	50315	if (cw->cw_state == CW_BE_BUSY) {
345	546	VSLb(bo->vsl, SLT_FetchError,
346	273	"backend %s: busy", VRT_BACKEND_string(dir));
347	273	bp->vsc->busy++;
348	273	VSC_C_main->backend_busy++;
349	273	vbe_connwait_fini(cw);
350	273	return (NULL);
351		}
352
353	50042	AZ(bo->htc);
354	50042	bo->htc = WS_Alloc(bo->ws, sizeof *bo->htc);
355		/* XXX: we may want to detect the ws overflow sooner */
356	50042	if (bo->htc == NULL) {
357	630	VSLb(bo->vsl, SLT_FetchError, "out of workspace");
358		/* XXX: counter ? */
359	630	Lck_Lock(bp->director->mtx);
360	630	bp->n_conn--;
361	630	vbe_connwait_signal_locked(bp);
362	630	Lck_Unlock(bp->director->mtx);
363	630	vbe_connwait_fini(cw);
364	630	return (NULL);
365		}
366	49412	bo->htc->doclose = SC_NULL;
367	49412	CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
368
369	49412	FIND_TMO(connect_timeout, tmod, bo, bp);
370	49412	pfd = VCP_Get(bp->conn_pool, tmod, wrk, force_fresh, &err);
371	49412	if (pfd == NULL) {
372	651	Lck_Lock(bp->director->mtx);
373	651	VBE_Connect_Error(bp->vsc, err);
374	651	bp->n_conn--;
375	651	vbe_connwait_signal_locked(bp);
376	651	Lck_Unlock(bp->director->mtx);
377	1302	VSLb(bo->vsl, SLT_FetchError,
378		"backend %s: fail errno %d (%s)",
379	651	VRT_BACKEND_string(dir), err, VAS_errtxt(err));
380	651	VSC_C_main->backend_fail++;
381	651	bo->htc = NULL;
382	651	vbe_connwait_fini(cw);
383	651	return (NULL);
384		}
385
386	48761	VSLb_ts_busyobj(bo, "Connected", W_TIM_real(wrk));
387	48761	fdp = PFD_Fd(pfd);
388	48761	AN(fdp);
389	48761	assert(*fdp >= 0);
390
391	48761	Lck_Lock(bp->director->mtx);
392	48761	bp->vsc->conn++;
393	48761	bp->vsc->req++;
394	48761	Lck_Unlock(bp->director->mtx);
395
396	48761	INIT_OBJ(bo->htc, HTTP_CONN_MAGIC);
397	48761	bo->htc->priv = pfd;
398	48761	bo->htc->rfd = fdp;
399	48761	bo->htc->doclose = SC_NULL;
400	48761	CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
401
402	48761	err = 0;
403	48761	if (bp->proxy_header != 0)
404	126	err = VPX_Send_Proxy(*fdp, bp->proxy_header, bo->sp);
405	48761	if (err < 0) {
406	42	VSLb(bo->vsl, SLT_FetchError,
407		"backend %s: proxy write errno %d (%s)",
408	21	VRT_BACKEND_string(dir),
409	21	errno, VAS_errtxt(errno));
410	21	bo->htc->doclose = SC_TX_ERROR;
411	21	Lck_Lock(bp->director->mtx);
412	21	VSC_C_main->backend_fail++;
413	21	bp->vsc->req--;
414	21	Lck_Unlock(bp->director->mtx);
415	21	vbe_dir_finish(ctx, dir);
416	21	vbe_connwait_fini(cw);
417	21	return (NULL);
418		}
419	48740	bo->acct.bereq_hdrbytes += err;
420
421	48740	PFD_LocalName(pfd, abuf1, sizeof abuf1, pbuf1, sizeof pbuf1);
422	48740	PFD_RemoteName(pfd, abuf2, sizeof abuf2, pbuf2, sizeof pbuf2);
423	48740	if (PFD_State(pfd) != PFD_STATE_STOLEN) {
424	58768	VSLb(bo->vsl, SLT_BackendOpen, "%d %s %s %s %s %s connect",
425	29384	*fdp, VRT_BACKEND_string(dir), abuf2, pbuf2, abuf1, pbuf1);
426	29384	} else {
427	38712	VSLb(bo->vsl, SLT_BackendOpen,
428	19356	"%d %s %s %s %s %s reuse %.6f %ju", *fdp,
429	19356	VRT_BACKEND_string(dir), abuf2, pbuf2, abuf1, pbuf1,
430	19356	PFD_Age(pfd), (uintmax_t)PFD_Reused(pfd));
431		}
432
433	48740	FIND_TMO(first_byte_timeout,
434		bo->htc->first_byte_timeout, bo, bp);
435	48740	FIND_TMO(between_bytes_timeout,
436		bo->htc->between_bytes_timeout, bo, bp);
437	48740	vbe_connwait_fini(cw);
438	48740	return (pfd);
439	50420	}
440
441		static int v_matchproto_(vdi_gethdrs_f)
442	49790	vbe_dir_gethdrs(VRT_CTX, VCL_BACKEND d)
443		{
444	49790	int i, retry_connect = 1;
445		struct backend *bp;
446		struct pfd *pfd;
447		struct busyobj *bo;
448		struct worker *wrk;
449
450	49790	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
451	49790	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
452	49790	bo = ctx->bo;
453	49790	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
454	49790	CHECK_OBJ_NOTNULL(bo->bereq, HTTP_MAGIC);
455	49790	if (bo->htc != NULL)
456	0	CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
457	49790	wrk = ctx->bo->wrk;
458	49790	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
459	49790	CAST_OBJ_NOTNULL(bp, d->priv, BACKEND_MAGIC);
460
461		/*
462		* Now that we know our backend, we can set a default Host:
463		* header if one is necessary. This cannot be done in the VCL
464		* because the backend may be chosen by a director.
465		*/
466	49790	if (!http_GetHdr(bo->bereq, H_Host, NULL) && bp->hosthdr != NULL)
467	4032	http_PrintfHeader(bo->bereq, "Host: %s", bp->hosthdr);
468
469	49790	do {
470	49917	if (bo->htc != NULL)
471	0	CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
472	49917	pfd = vbe_dir_getfd(ctx, wrk, d, bp, retry_connect == 0 ? 1 : 0);
473	49917	if (pfd == NULL)
474	1659	return (-1);
475	48258	AN(bo->htc);
476	48258	CHECK_OBJ_NOTNULL(bo->htc->doclose, STREAM_CLOSE_MAGIC);
477	48258	if (PFD_State(pfd) != PFD_STATE_STOLEN)
478	28944	retry_connect = 0;
479
480	96516	i = V1F_SendReq(wrk, bo, &bo->acct.bereq_hdrbytes,
481	48258	&bo->acct.bereq_bodybytes);
482
483	48258	if (i == 0 && PFD_State(pfd) != PFD_STATE_USED) {
484	57879	if (VCP_Wait(wrk, pfd, VTIM_real() +
485	38586	bo->htc->first_byte_timeout) != 0) {
486	21	bo->htc->doclose = SC_RX_TIMEOUT;
487	21	VSLb(bo->vsl, SLT_FetchError,
488		"first byte timeout (reused connection)");
489	21	retry_connect = 0;
490	21	}
491	19293	}
492
493	48258	if (bo->htc->doclose == SC_NULL) {
494	47544	assert(PFD_State(pfd) == PFD_STATE_USED);
495	47544	if (i == 0)
496	47544	i = V1F_FetchRespHdr(bo);
497	47544	if (i == 0) {
498	45738	AN(bo->htc->priv);
499	45738	http_VSL_log(bo->beresp);