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 55
 * but we want to avoid a potentially messy cleanup operation when we
34 55
 * retire the backend, so the thread owns the health information, which
35 55
 * the backend references, rather than the other way around.
36 55
 *
37 55
 */
38 55
39 55
#include "config.h"
40 65
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 30
vbp_delete(struct vbp_target *vt)
114
{
115 30
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
116
117 30
        assert(vt->heap_idx == VBH_NOIDX);
118
119
#define DN(x)   /**/
120 30
        VRT_BACKEND_PROBE_HANDLE();
121
#undef DN
122 30
        VCP_Rel(&vt->conn_pool);
123 30
        free(vt->req);
124 30
        FREE_OBJ(vt);
125 30
}
126
127
128
/*--------------------------------------------------------------------
129
 * Record pokings...
130
 */
131
132
static void
133 1987
vbp_start_poke(struct vbp_target *vt)
134
{
135 1987
        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 1974
vbp_has_poked(struct vbp_target *vt)
147
{
148
        unsigned i, j;
149
        uint64_t u;
150
151 1974
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
152
153
        /* Calculate exponential average */
154 1974
        if (vt->happy & 1) {
155 1709
                if (vt->rate < AVG_RATE)
156 902
                        vt->rate += 1.0;
157 1709
                vt->avg += (vt->last - vt->avg) / vt->rate;
158 1709
        }
159
160 1974
        u = vt->happy;
161 16233
        for (i = j = 0; i < vt->window; i++) {
162 14259
                if (u & 1)
163 7881
                        j++;
164 14259
                u >>= 1;
165 14259
        }
166 1974
        vt->good = j;
167 1974
}
168
169
void
170 1384
VBP_Update_Backend(struct vbp_target *vt)
171
{
172 1384
        unsigned i = 0, chg;
173
        char bits[10];
174
175 1384
        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 1384
        assert(i < sizeof bits);
182
183
        Lck_Lock(&vbp_mtx);
184 1384
        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 1384
        if (i && chg && vt->backend->director != NULL)
193 244
                VDI_Event(vt->backend->director, VDI_EVENT_SICK);
194
195 1384
        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 1384
        if (chg)
204 354
                vt->backend->changed = VTIM_real();
205
        Lck_Unlock(&vbp_mtx);
206
}
207
208
static void
209 405
vbp_reset(struct vbp_target *vt)
210
{
211
        unsigned u;
212
213 405
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
214 405
        vt->avg = 0.0;
215 405
        vt->rate = 0.0;
216
#define BITMAP(n, c, t, b) \
217
        vt->n = 0;
218
#include "tbl/backend_poll.h"
219
220 1400
        for (u = 0; u < vt->initial; u++) {
221 995
                vbp_start_poke(vt);
222 995
                vt->happy |= 1;
223 995
                vbp_has_poked(vt);
224 995
        }
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 984
vbp_write(struct vbp_target *vt, int *sock, const void *buf, size_t len)
236
{
237
        int i;
238
239 984
        i = write(*sock, buf, len);
240 984
        VTCP_Assert(i);
241 984
        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 984
        return (0);
255 984
}
256
257
static int
258 31
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 31
        char vsabuf[vsa_suckaddr_len];
264
        const struct suckaddr *sua;
265
        int proto;
266
        struct vsb vsb;
267
268 31
        sua = VSA_getsockname(*sock, vsabuf, sizeof vsabuf);
269 31
        AN(sua);
270 31
        AN(VSB_init(&vsb, buf, sizeof buf));
271
272 31
        proto = VSA_Get_Proto(sua);
273 31
        if (proto == AF_INET || proto == AF_INET6) {
274 16
                VTCP_name(sua, addr, sizeof addr, port, sizeof port);
275 16
                VSB_printf(&vsb, "PROXY %s %s %s %s %s\r\n",
276 16
                    proto == AF_INET ? "TCP4" : "TCP6",
277 16
                    addr, addr, port, port);
278 16
        } else {
279 15
                VSB_cat(&vsb, "PROXY UNKNOWN\r\n");
280
        }
281 31
        AZ(VSB_finish(&vsb));
282
283 31
        VSB_fini(&vsb);
284 31
        return (vbp_write(vt, sock, buf, strlen(buf)));
285 31
}
286
287
static void
288 987
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 987
        struct pollfd pfda[1], *pfd = pfda;
296
        const struct suckaddr *sa;
297
298 987
        t_start = t_now = VTIM_real();
299 987
        t_end = t_start + vt->timeout;
300
301 987
        s = VCP_Open(vt->conn_pool, t_end - t_now, &sa, &err);
302 987
        if (s < 0) {
303 73
                bprintf(vt->resp_buf, "Open error %d (%s)", err, VAS_errtxt(err));
304 73
                Lck_Lock(&vbp_mtx);
305 73
                if (vt->backend)
306 73
                        VBE_Connect_Error(vt->backend->vsc, err);
307 73
                Lck_Unlock(&vbp_mtx);
308 73
                return;
309
        }
310
311 914
        i = VSA_Get_Proto(sa);
312 914
        if (VSA_Compare(sa, bogo_ip) == 0)
313 324
                vt->good_unix |= 1;
314 590
        else if (i == AF_INET)
315 590
                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 914
        t_now = VTIM_real();
322 914
        tmo = t_end - t_now;
323 914
        if (tmo <= 0) {
324 8
                bprintf(vt->resp_buf,
325
                        "Open timeout %.3fs exceeded by %.3fs",
326
                        vt->timeout, -tmo);
327 8
                VTCP_close(&s);
328 8
                return;
329
        }
330
331 906
        Lck_Lock(&vbp_mtx);
332 906
        if (vt->backend != NULL)
333 906
                proxy_header = vt->backend->proxy_header;
334
        else
335 0
                proxy_header = -1;
336 906
        Lck_Unlock(&vbp_mtx);
337
338 906
        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 906
        assert(proxy_header <= 2);
346 906
        if (proxy_header == 1) {
347 31
                if (vbp_write_proxy_v1(vt, &s) != 0)
348 0
                        return;
349 906
        } else if (proxy_header == 2 &&
350 39
            vbp_write(vt, &s, vbp_proxy_local, sizeof vbp_proxy_local) != 0)
351 0
                return;
352
353
        /* Send the request */
354 906
        if (vbp_write(vt, &s, vt->req, vt->req_len) != 0)
355 0
                return;
356
357 906
        vt->good_xmit |= 1;
358
359 906
        pfd->fd = s;
360 906
        rlen = 0;
361 1824
        while (1) {
362 1824
                pfd->events = POLLIN;
363 1824
                pfd->revents = 0;
364 1824
                t_now = VTIM_real();
365 1824
                tmo = t_end - t_now;
366 1824
                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 1824
                i = poll(pfd, 1, VTIM_poll_tmo(tmo));
374 1824
                if (i <= 0) {
375 101
                        if (!i) {
376 101
                                if (!vt->exp_close)
377 20
                                        break;
378 81
                                errno = ETIMEDOUT;
379 81
                        }
380 81
                        bprintf(vt->resp_buf, "Poll error %d (%s)",
381
                            errno, VAS_errtxt(errno));
382 81
                        i = -1;
383 81
                        break;
384
                }
385 1723
                if (rlen < sizeof vt->resp_buf)
386 3146
                        i = read(s, vt->resp_buf + rlen,
387 1573
                            sizeof vt->resp_buf - rlen);
388
                else
389 150
                        i = read(s, buf, sizeof buf);
390 1723
                VTCP_Assert(i);
391 1723
                if (i <= 0) {
392 805
                        if (i < 0)
393 6
                                bprintf(vt->resp_buf, "Read error %d (%s)",
394
                                        errno, VAS_errtxt(errno));
395 805
                        break;
396
                }
397 918
                rlen += i;
398
        }
399
400 906
        VTCP_close(&s);
401
402 906
        if (i < 0) {
403
                /* errno reported above */
404 87
                vt->err_recv |= 1;
405 87
                return;
406
        }
407
408 819
        if (rlen == 0) {
409 30
                bprintf(vt->resp_buf, "%s", "Empty response");
410 30
                return;
411
        }
412
413
        /* So we have a good receive ... */
414 789
        t_now = VTIM_real();
415 789
        vt->last = t_now - t_start;
416 789
        vt->good_recv |= 1;
417
418
        /* Now find out if we like the response */
419 789
        vt->resp_buf[sizeof vt->resp_buf - 1] = '\0';
420 789
        p = strchr(vt->resp_buf, '\r');
421 789
        if (p != NULL)
422 789
                *p = '\0';
423 789
        p = strchr(vt->resp_buf, '\n');
424 789
        if (p != NULL)
425 0
                *p = '\0';
426
427 789
        i = sscanf(vt->resp_buf, "HTTP/%*f %u ", &resp);
428
429 789
        if (i == 1 && resp == vt->exp_status)
430 709
                vt->happy |= 1;
431 987
}
432
433
/*--------------------------------------------------------------------
434
 */
435
static void
436 1159
vbp_heap_insert(struct vbp_target *vt)
437
{
438
        // Lck_AssertHeld(&vbp_mtx);
439 1159
        VBH_insert(vbp_heap, vt);
440 1159
        if (VBH_root(vbp_heap) == vt)
441 1074
                PTOK(pthread_cond_signal(&vbp_cond));
442 1159
}
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 979
vbp_task_complete(struct vbp_target *vt)
453
{
454 979
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
455
456 979
        Lck_AssertHeld(&vbp_mtx);
457
458 979
        assert(vt->heap_idx == VBH_NOIDX);
459
460 979
        if (vt->state == vbp_state_running) {
461 974
                vt->state = vbp_state_scheduled;
462 974
                vt->due = VTIM_real() + vt->interval;
463 974
                vbp_heap_insert(vt);
464 974
                vt = NULL;
465 979
        } else if (vt->state == vbp_state_cooling) {
466 5
                vt->state = vbp_state_cold;
467 5
                vt = NULL;
468 5
        } else if (vt->state != vbp_state_deleted) {
469 0
                WRONG(vt->state->name);
470 0
        }
471 979
        return (vt);
472
}
473
474
static void v_matchproto_(task_func_t)
475 979
vbp_task(struct worker *wrk, void *priv)
476
{
477
        struct vbp_target *vt;
478
479 979
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
480 979
        CAST_OBJ_NOTNULL(vt, priv, VBP_TARGET_MAGIC);
481
482 979
        AN(vt->req);
483 979
        assert(vt->req_len > 0);
484
485 979
        vbp_start_poke(vt);
486 979
        vbp_poke(vt);
487 979
        vbp_has_poked(vt);
488 979
        VBP_Update_Backend(vt);
489
490 979
        Lck_Lock(&vbp_mtx);
491 979
        vt = vbp_task_complete(vt);
492 979
        Lck_Unlock(&vbp_mtx);
493 979
        if (vt == NULL)
494 979
                return;
495 0
        vbp_delete(vt);
496 979
}
497
498
/*--------------------------------------------------------------------
499
 */
500
501
static void * v_matchproto_(bgthread_t)
502 4613
vbp_scheduler(struct worker *wrk, void *priv)
503
{
504
        vtim_real now, nxt;
505
        struct vbp_target *vt;
506
        int r;
507
508 4613
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
509 4613
        AZ(priv);
510 4613
        Lck_Lock(&vbp_mtx);
511 11222
        while (1) {
512 12214
                now = VTIM_real();
513 12214
                vt = VBH_root(vbp_heap);
514 12214
                if (vt == NULL) {
515 5630
                        nxt = 8.192 + now;
516 5630
                        (void)Lck_CondWaitUntil(&vbp_cond, &vbp_mtx, nxt);
517 12214
                } else if (vt->due > now) {
518 979
                        nxt = vt->due;
519 979
                        (void)Lck_CondWaitUntil(&vbp_cond, &vbp_mtx, nxt);
520 979
                } else {
521 5605
                        assert(vt->state == vbp_state_scheduled);
522 992
                        VBH_delete(vbp_heap, vt->heap_idx);
523 992
                        vt->state = vbp_state_running;
524 992
                        vt->task->func = vbp_task;
525 992
                        vt->task->priv = vt;
526 992
                        Lck_Unlock(&vbp_mtx);
527
528 992
                        r = Pool_Task_Any(vt->task, TASK_QUEUE_REQ);
529
530 992
                        Lck_Lock(&vbp_mtx);
531 992
                        if (r == 0)
532 992
                                continue;
533 0
                        vt = vbp_task_complete(vt);
534 0
                        if (vt == NULL)
535 0
                                continue;
536 0
                        Lck_Unlock(&vbp_mtx);
537
538 0
                        vbp_delete(vt);
539
540 0
                        Lck_Lock(&vbp_mtx);
541
                }
542
        }
543
        NEEDLESS(Lck_Unlock(&vbp_mtx));
544
        NEEDLESS(return (NULL));
545
}
546
547
548
/*--------------------------------------------------------------------
549
 * Cli functions
550
 */
551
552
static void
553 195
vbp_bitmap(struct vsb *vsb, char c, uint64_t map, const char *lbl)
554
{
555
        int i;
556 195
        uint64_t u = (1ULL << 63);
557
558 195
        VSB_cat(vsb, "  ");
559 12675
        for (i = 0; i < 64; i++) {
560 12480
                if (map & u)
561 1245
                        VSB_putc(vsb, c);
562
                else
563 11235
                        VSB_putc(vsb, '-');
564 12480
                map <<= 1;
565 12480
        }
566 195
        VSB_printf(vsb, " %s\n", lbl);
567 195
}
568
569
/*lint -e{506} constant value boolean */
570
/*lint -e{774} constant value boolean */
571
void
572 390
VBP_Status(struct vsb *vsb, const struct backend *be, int details, int json)
573
{
574
        struct vbp_target *vt;
575
576 390
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
577 390
        vt = be->probe;
578 390
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
579
580 390
        if (!details) {
581 325
                if (json)
582 30
                        VSB_printf(vsb, "[%u, %u, \"%s\"]",
583 15
                            vt->good, vt->window,
584 15
                            vt->backend->sick ? "sick" : "healthy");
585
                else
586 620
                        VSB_printf(vsb, "%u/%u\t%s", vt->good, vt->window,
587 310
                            vt->backend->sick ? "sick" : "healthy");
588 325
                return;
589
        }
590
591 65
        if (json) {
592 10
                VSB_cat(vsb, "{\n");
593 10
                VSB_indent(vsb, 2);
594
#define BITMAP(nn, cc, tt, bb)                                  \
595
                VSB_printf(vsb, "\"bits_%c\": %ju,\n", cc, vt->nn);
596
#include "tbl/backend_poll.h"
597
                VSB_printf(vsb, "\"good\": %u,\n", vt->good);
598
                VSB_printf(vsb, "\"threshold\": %u,\n", vt->threshold);
599
                VSB_printf(vsb, "\"window\": %u", vt->window);
600
                VSB_indent(vsb, -2);
601
                VSB_cat(vsb, "\n");
602
                VSB_cat(vsb, "},\n");
603
                return;
604
        }
605
606 110
        VSB_printf(vsb,
607
            "\n Current states  good: %2u threshold: %2u window: %2u\n",
608 55
            vt->good, vt->threshold, vt->window);
609 110
        VSB_printf(vsb,
610 55
            "  Average response time of good probes: %.6f\n", vt->avg);
611 55
        VSB_cat(vsb,
612
            "  Oldest ======================"
613
            "============================ Newest\n");
614
615
#define BITMAP(n, c, t, b)                                      \
616
                if ((vt->n != 0) || (b))                        \
617
                        vbp_bitmap(vsb, (c), vt->n, (t));
618
#include "tbl/backend_poll.h"
619
}
620
621
/*--------------------------------------------------------------------
622
 * Build request from probe spec
623
 */
624
625
static void
626 185
vbp_build_req(struct vbp_target *vt, const struct vrt_backend_probe *vbp,
627
    const struct backend *be)
628
{
629
        struct vsb *vsb;
630
631 185
        vsb = VSB_new_auto();
632 185
        AN(vsb);
633 185
        VSB_clear(vsb);
634 185
        if (vbp->request != NULL) {
635 10
                VSB_cat(vsb, vbp->request);
636 10
        } else {
637 175
                AN(be->hosthdr);
638 350
                VSB_printf(vsb,
639
                    "GET %s HTTP/1.1\r\n"
640
                    "Host: %s\r\n"
641
                    "Connection: close\r\n"
642
                    "\r\n",
643 175
                    vbp->url != NULL ?  vbp->url : "/",
644 175
                    be->hosthdr);
645
        }
646 185
        AZ(VSB_finish(vsb));
647 185
        vt->req = strdup(VSB_data(vsb));
648 185
        AN(vt->req);
649 185
        vt->req_len = VSB_len(vsb);
650 185
        VSB_destroy(&vsb);
651 185
}
652
653
/*--------------------------------------------------------------------
654
 * Sanitize and set defaults
655
 * XXX: we could make these defaults parameters
656
 */
657
658
static void
659 185
vbp_set_defaults(struct vbp_target *vt, const struct vrt_backend_probe *vp)
660
{
661
662
#define DN(x)   do { vt->x = vp->x; } while (0)
663 185
        VRT_BACKEND_PROBE_HANDLE();
664
#undef DN
665
666 185
        if (vt->timeout == 0.0)
667 135
                vt->timeout = 2.0;
668 185
        if (vt->interval == 0.0)
669 40
                vt->interval = 5.0;
670 185
        if (vt->window == 0)
671 80
                vt->window = 8;
672 185
        if (vt->threshold == 0)
673 80
                vt->threshold = 3;
674 185
        if (vt->exp_status == 0)
675 185
                vt->exp_status = 200;
676
677 185
        if (vt->initial == ~0U)
678 110
                vt->initial = vt->threshold - 1;
679
680 185
        vt->initial = vmin(vt->initial, vt->threshold);
681 185
}
682
683
/*--------------------------------------------------------------------
684
 */
685
686
void
687 220
VBP_Control(const struct backend *be, int enable)
688
{
689
        struct vbp_target *vt;
690
691 220
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
692 220
        vt = be->probe;
693 220
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
694
695 220
        vbp_reset(vt);
696 220
        VBP_Update_Backend(vt);
697
698 220
        Lck_Lock(&vbp_mtx);
699 220
        if (enable) {
700 185
                if (vt->state == vbp_state_cooling) {
701 0
                        vt->state = vbp_state_running;
702 185
                } else if (vt->state == vbp_state_cold) {
703 185
                        assert(vt->heap_idx == VBH_NOIDX);
704 185
                        vt->due = VTIM_real();
705 185
                        vbp_heap_insert(vt);
706 185
                        vt->state = vbp_state_scheduled;
707 185
                } else
708 0
                        WRONG(vt->state->name);
709 185
        } else {
710 35
                if (vt->state == vbp_state_running) {
711 5
                        vt->state = vbp_state_cooling;
712 35
                } else if (vt->state == vbp_state_scheduled) {
713 30
                        assert(vt->heap_idx != VBH_NOIDX);
714 30
                        VBH_delete(vbp_heap, vt->heap_idx);
715 30
                        vt->state = vbp_state_cold;
716 30
                } else
717 0
                        WRONG(vt->state->name);
718
        }
719 220
        Lck_Unlock(&vbp_mtx);
720 220
}
721
722
/*--------------------------------------------------------------------
723
 * Insert/Remove/Use called from cache_backend.c
724
 */
725
726
void
727 185
VBP_Insert(struct backend *b, const struct vrt_backend_probe *vp,
728
    struct conn_pool *tp)
729
{
730
        struct vbp_target *vt;
731
732 185
        CHECK_OBJ_NOTNULL(b, BACKEND_MAGIC);
733 185
        CHECK_OBJ_NOTNULL(vp, VRT_BACKEND_PROBE_MAGIC);
734
735 185
        AZ(b->probe);
736
737 185
        ALLOC_OBJ(vt, VBP_TARGET_MAGIC);
738 185
        XXXAN(vt);
739
740 185
        vt->state = vbp_state_cold;
741 185
        vt->conn_pool = tp;
742 185
        VCP_AddRef(vt->conn_pool);
743 185
        vt->backend = b;
744 185
        b->probe = vt;
745
746 185
        vbp_set_defaults(vt, vp);
747 185
        vbp_build_req(vt, vp, b);
748
749 185
        vbp_reset(vt);
750 185
}
751
752
void
753 30
VBP_Remove(struct backend *be)
754
{
755
        struct vbp_target *vt;
756
757 30
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
758 30
        vt = be->probe;
759 30
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
760
761 30
        Lck_Lock(&vbp_mtx);
762 30
        be->sick = 1;
763 30
        be->probe = NULL;
764 30
        vt->backend = NULL;
765 30
        if (vt->state == vbp_state_cooling) {
766 0
                vt->state = vbp_state_deleted;
767 0
                vt = NULL;
768 0
        } else
769 30
                assert(vt->state == vbp_state_cold);
770 30
        Lck_Unlock(&vbp_mtx);
771 30
        if (vt != NULL)
772 30
                vbp_delete(vt);
773 30
}
774
775
/*-------------------------------------------------------------------*/
776
777
static int v_matchproto_(vbh_cmp_t)
778 139
vbp_cmp(void *priv, const void *a, const void *b)
779
{
780
        const struct vbp_target *aa, *bb;
781
782 139
        AZ(priv);
783 139
        CAST_OBJ_NOTNULL(aa, a, VBP_TARGET_MAGIC);
784 139
        CAST_OBJ_NOTNULL(bb, b, VBP_TARGET_MAGIC);
785
786 139
        return (aa->due < bb->due);
787
}
788
789
static void v_matchproto_(vbh_update_t)
790 2386
vbp_update(void *priv, void *p, unsigned u)
791
{
792
        struct vbp_target *vt;
793
794 2386
        AZ(priv);
795 2386
        CAST_OBJ_NOTNULL(vt, p, VBP_TARGET_MAGIC);
796 2386
        vt->heap_idx = u;
797 2386
}
798
799
/*-------------------------------------------------------------------*/
800
801
void
802 4613
VBP_Init(void)
803
{
804
        pthread_t thr;
805
806 4613
        Lck_New(&vbp_mtx, lck_probe);
807 4613
        vbp_heap = VBH_new(NULL, vbp_cmp, vbp_update);
808 4613
        AN(vbp_heap);
809 4613
        PTOK(pthread_cond_init(&vbp_cond, NULL));
810 4613
        WRK_BgThread(&thr, "backend-probe-scheduler", vbp_scheduler, NULL);
811 4613
}