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
 */
500
501
static void * v_matchproto_(bgthread_t)
502 1898
vbp_scheduler(struct worker *wrk, void *priv)
503
{
504
        vtim_real now, nxt;
505
        struct vbp_target *vt;
506
        int r;
507
508 1898
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
509 1898
        AZ(priv);
510 1898
        Lck_Lock(&vbp_mtx);
511 4598
        while (1) {
512 4993
                now = VTIM_real();
513 4993
                vt = VBH_root(vbp_heap);
514 4993
                if (vt == NULL) {
515 2312
                        nxt = 8.192 + now;
516 2312
                        (void)Lck_CondWaitUntil(&vbp_cond, &vbp_mtx, nxt);
517 4993
                } else if (vt->due > now) {
518 388
                        nxt = vt->due;
519 388
                        (void)Lck_CondWaitUntil(&vbp_cond, &vbp_mtx, nxt);
520 388
                } else {
521 2293
                        assert(vt->state == vbp_state_scheduled);
522 395
                        VBH_delete(vbp_heap, vt->heap_idx);
523 395
                        vt->state = vbp_state_running;
524 395
                        vt->task->func = vbp_task;
525 395
                        vt->task->priv = vt;
526 395
                        Lck_Unlock(&vbp_mtx);
527
528 395
                        r = Pool_Task_Any(vt->task, TASK_QUEUE_REQ);
529
530 395
                        Lck_Lock(&vbp_mtx);
531 395
                        if (r == 0)
532 395
                                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 78
vbp_bitmap(struct vsb *vsb, char c, uint64_t map, const char *lbl)
554
{
555
        int i;
556 78
        uint64_t u = (1ULL << 63);
557
558 78
        VSB_cat(vsb, "  ");
559 5070
        for (i = 0; i < 64; i++) {
560 4992
                if (map & u)
561 498
                        VSB_putc(vsb, c);
562
                else
563 4494
                        VSB_putc(vsb, '-');
564 4992
                map <<= 1;
565 4992
        }
566 78
        VSB_printf(vsb, " %s\n", lbl);
567 78
}
568
569
/*lint -e{506} constant value boolean */
570
/*lint -e{774} constant value boolean */
571
void
572 156
VBP_Status(struct vsb *vsb, const struct backend *be, int details, int json)
573
{
574
        struct vbp_target *vt;
575
576 156
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
577 156
        vt = be->probe;
578 156
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
579
580 156
        if (!details) {
581 130
                if (json)
582 12
                        VSB_printf(vsb, "[%u, %u, \"%s\"]",
583 6
                            vt->good, vt->window,
584 6
                            vt->backend->sick ? "sick" : "healthy");
585
                else
586 248
                        VSB_printf(vsb, "%u/%u\t%s", vt->good, vt->window,
587 124
                            vt->backend->sick ? "sick" : "healthy");
588 130
                return;
589
        }
590
591 26
        if (json) {
592 4
                VSB_cat(vsb, "{\n");
593 4
                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 44
        VSB_printf(vsb,
607
            "\n Current states  good: %2u threshold: %2u window: %2u\n",
608 22
            vt->good, vt->threshold, vt->window);
609 44
        VSB_printf(vsb,
610 22
            "  Average response time of good probes: %.6f\n", vt->avg);
611 22
        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 74
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 74
        vsb = VSB_new_auto();
632 74
        AN(vsb);
633 74
        VSB_clear(vsb);
634 74
        if (vbp->request != NULL) {
635 4
                VSB_cat(vsb, vbp->request);
636 4
        } else {
637 70
                AN(be->hosthdr);
638 140
                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 70
                    vbp->url != NULL ?  vbp->url : "/",
644 70
                    be->hosthdr);
645
        }
646 74
        AZ(VSB_finish(vsb));
647 74
        vt->req = strdup(VSB_data(vsb));
648 74
        AN(vt->req);
649 74
        vt->req_len = VSB_len(vsb);
650 74
        VSB_destroy(&vsb);
651 74
}
652
653
/*--------------------------------------------------------------------
654
 * Sanitize and set defaults
655
 * XXX: we could make these defaults parameters
656
 */
657
658
static void
659 74
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 74
        VRT_BACKEND_PROBE_HANDLE();
664
#undef DN
665
666 74
        if (vt->timeout == 0.0)
667 54
                vt->timeout = 2.0;
668 74
        if (vt->interval == 0.0)
669 16
                vt->interval = 5.0;
670 74
        if (vt->window == 0)
671 32
                vt->window = 8;
672 74
        if (vt->threshold == 0)
673 32
                vt->threshold = 3;
674 74
        if (vt->exp_status == 0)
675 74
                vt->exp_status = 200;
676
677 74
        if (vt->initial == ~0U)
678 44
                vt->initial = vt->threshold - 1;
679
680 74
        vt->initial = vmin(vt->initial, vt->threshold);
681 74
}
682
683
/*--------------------------------------------------------------------
684
 */
685
686
void
687 88
VBP_Control(const struct backend *be, int enable)
688
{
689
        struct vbp_target *vt;
690
691 88
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
692 88
        vt = be->probe;
693 88
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
694
695 88
        vbp_reset(vt);
696 88
        VBP_Update_Backend(vt);
697
698 88
        Lck_Lock(&vbp_mtx);
699 88
        if (enable) {
700 74
                if (vt->state == vbp_state_cooling) {
701 0
                        vt->state = vbp_state_running;
702 74
                } else if (vt->state == vbp_state_cold) {
703 74
                        assert(vt->heap_idx == VBH_NOIDX);
704 74
                        vt->due = VTIM_real();
705 74
                        vbp_heap_insert(vt);
706 74
                        vt->state = vbp_state_scheduled;
707 74
                } else
708 0
                        WRONG(vt->state->name);
709 74
        } else {
710 14
                if (vt->state == vbp_state_running) {
711 2
                        vt->state = vbp_state_cooling;
712 14
                } else if (vt->state == vbp_state_scheduled) {
713 12
                        assert(vt->heap_idx != VBH_NOIDX);
714 12
                        VBH_delete(vbp_heap, vt->heap_idx);
715 12
                        vt->state = vbp_state_cold;
716 12
                } else
717 0
                        WRONG(vt->state->name);
718
        }
719 88
        Lck_Unlock(&vbp_mtx);
720 88
}
721
722
/*--------------------------------------------------------------------
723
 * Insert/Remove/Use called from cache_backend.c
724
 */
725
726
void
727 74
VBP_Insert(struct backend *b, const struct vrt_backend_probe *vp,
728
    struct conn_pool *tp)
729
{
730
        struct vbp_target *vt;
731
732 74
        CHECK_OBJ_NOTNULL(b, BACKEND_MAGIC);
733 74
        CHECK_OBJ_NOTNULL(vp, VRT_BACKEND_PROBE_MAGIC);
734
735 74
        AZ(b->probe);
736
737 74
        ALLOC_OBJ(vt, VBP_TARGET_MAGIC);
738 74
        XXXAN(vt);
739
740 74
        vt->state = vbp_state_cold;
741 74
        vt->conn_pool = tp;
742 74
        VCP_AddRef(vt->conn_pool);
743 74
        vt->backend = b;
744 74
        b->probe = vt;
745
746 74
        vbp_set_defaults(vt, vp);
747 74
        vbp_build_req(vt, vp, b);
748
749 74
        vbp_reset(vt);
750 74
}
751
752
void
753 12
VBP_Remove(struct backend *be)
754
{
755
        struct vbp_target *vt;
756
757 12
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
758 12
        vt = be->probe;
759 12
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
760
761 12
        Lck_Lock(&vbp_mtx);
762 12
        be->sick = 1;
763 12
        be->probe = NULL;
764 12
        vt->backend = NULL;
765 12
        if (vt->state == vbp_state_cooling) {
766 0
                vt->state = vbp_state_deleted;
767 0
                vt = NULL;
768 0
        } else
769 12
                assert(vt->state == vbp_state_cold);
770 12
        Lck_Unlock(&vbp_mtx);
771 12
        if (vt != NULL)
772 12
                vbp_delete(vt);
773 12
}
774
775
/*-------------------------------------------------------------------*/
776
777
static int v_matchproto_(vbh_cmp_t)
778 53
vbp_cmp(void *priv, const void *a, const void *b)
779
{
780
        const struct vbp_target *aa, *bb;
781
782 53
        AZ(priv);
783 53
        CAST_OBJ_NOTNULL(aa, a, VBP_TARGET_MAGIC);
784 53
        CAST_OBJ_NOTNULL(bb, b, VBP_TARGET_MAGIC);
785
786 53
        return (aa->due < bb->due);
787
}
788
789
static void v_matchproto_(vbh_update_t)
790 945
vbp_update(void *priv, void *p, unsigned u)
791
{
792
        struct vbp_target *vt;
793
794 945
        AZ(priv);
795 945
        CAST_OBJ_NOTNULL(vt, p, VBP_TARGET_MAGIC);
796 945
        vt->heap_idx = u;
797 945
}
798
799
/*-------------------------------------------------------------------*/
800
801
void
802 1898
VBP_Init(void)
803
{
804
        pthread_t thr;
805
806 1898
        Lck_New(&vbp_mtx, lck_probe);
807 1898
        vbp_heap = VBH_new(NULL, vbp_cmp, vbp_update);
808 1898
        AN(vbp_heap);
809 1898
        PTOK(pthread_cond_init(&vbp_cond, NULL));
810 1898
        WRK_BgThread(&thr, "backend-probe-scheduler", vbp_scheduler, NULL);
811 1898
}