Code Coverage: vinyl-cache/bin/vinyld/cache/cache_ban.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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
 */
31
32
#include "config.h"
33
34
#include <stdlib.h>
35
#include <stdio.h>
36
37
#include "cache_int.h"
38
#include "cache_ban.h"
39
#include "cache_objhead.h"
40
41
#include "vcli_serve.h"
42
#include "vend.h"
43
#include "vmb.h"
44
45
/* cache_ban_build.c */
46
void BAN_Build_Init(void);
47
void BAN_Build_Fini(void);
48
49
struct lock ban_mtx;
50
int ban_shutdown;
51
struct banhead_s ban_head = VTAILQ_HEAD_INITIALIZER(ban_head);
52
struct ban * volatile ban_start;
53
54
static pthread_t ban_thread;
55
static int ban_holds;
56
uint64_t bans_persisted_bytes;
57
uint64_t bans_persisted_fragmentation;
58
59
struct ban_test {
60
        uint8_t                 oper;
61
        uint8_t                 arg1;
62
        uint8_t                 arg2_bool;
63
        const char              *arg1_spec;
64
        const char              *arg2;
65
        double                  arg2_double;
66
        const void              *arg2_spec;
67
};
68
69
static const char * const arg_name[BAN_ARGARRSZ + 1] = {
70
#define PVAR(a, b, c) [BAN_ARGIDX(c)] = (a),
71
#include "tbl/ban_vars.h"
72
        [BAN_ARGARRSZ] = NULL
73
};
74
75
/*--------------------------------------------------------------------
76
 * Storage handling of bans
77
 */
78
79
static struct ban *
80
ban_alloc(void)
81 25
{
82 25
        struct ban *b;
83
84 25
        ALLOC_OBJ(b, BAN_MAGIC);
85 25
        if (b != NULL)
86 25
                VTAILQ_INIT(&b->objcore);
87 25
        return (b);
88 25
}
89
90
void
91
BAN_Free(struct ban *b)
92 92
{
93
94 92
        CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
95 92
        AZ(b->refcount);
96 92
        assert(VTAILQ_EMPTY(&b->objcore));
97
98 92
        if (b->spec != NULL)
99 92
                free(b->spec);
100 92
        FREE_OBJ(b);
101 92
}
102
103
/*--------------------------------------------------------------------
104
 * Get/release holds which prevent the ban_lurker from starting.
105
 * Holds are held while stevedores load zombie objects.
106
 */
107
108
void
109
BAN_Hold(void)
110 36
{
111
112 36
        Lck_Lock(&ban_mtx);
113
        /* Once holds are released, we allow no more */
114 36
        assert(ban_holds > 0);
115 36
        ban_holds++;
116 36
        Lck_Unlock(&ban_mtx);
117 36
}
118
119
void
120
BAN_Release(void)
121 1060
{
122
123 1060
        Lck_Lock(&ban_mtx);
124 1060
        assert(ban_holds > 0);
125 1060
        ban_holds--;
126 1060
        Lck_Unlock(&ban_mtx);
127 1060
        if (ban_holds == 0) {
128 1024
                BANIDX_fini();
129 1024
                WRK_BgThread(&ban_thread, "ban-lurker", ban_lurker, NULL);
130 1024
        }
131 1060
}
132
133
/*--------------------------------------------------------------------
134
 * Extract time and length from ban-spec
135
 */
136
137
vtim_real
138
ban_time(const uint8_t *banspec)
139 966
{
140 966
        vtim_real t;
141 966
        uint64_t u;
142
143 966
        assert(sizeof t == sizeof u);
144 966
        assert(sizeof t == (BANS_LENGTH - BANS_TIMESTAMP));
145 966
        u = vbe64dec(banspec + BANS_TIMESTAMP);
146 966
        vmemcpy(&t, &u, sizeof t);
147 966
        return (t);
148 966
}
149
150
unsigned
151
ban_len(const uint8_t *banspec)
152 6584
{
153 6584
        unsigned u;
154
155 6584
        u = vbe32dec(banspec + BANS_LENGTH);
156 6584
        return (u);
157 6584
}
158
159
int
160
ban_equal(const uint8_t *bs1, const uint8_t *bs2)
161 273
{
162 273
        unsigned u;
163
164
        /*
165
         * Compare two ban-strings.
166
         */
167 273
        u = ban_len(bs1);
168 273
        if (u != ban_len(bs2))
169 103
                return (0);
170 170
        if (bs1[BANS_FLAGS] & BANS_FLAG_NODEDUP)
171 3
                return (0);
172
173 167
        return (!vmemcmp(bs1 + BANS_LENGTH, bs2 + BANS_LENGTH, u - BANS_LENGTH));
174 170
}
175
176
void
177
ban_mark_completed(struct ban *b)
178 1098
{
179 1098
        unsigned ln;
180
181 1098
        CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
182 1098
        Lck_AssertHeld(&ban_mtx);
183
184 1098
        AN(b->spec);
185 1098
        if (!(b->flags & BANS_FLAG_COMPLETED)) {
186 1098
                ln = ban_len(b->spec);
187 1098
                b->flags |= BANS_FLAG_COMPLETED;
188 1098
                b->spec[BANS_FLAGS] |= BANS_FLAG_COMPLETED;
189 1098
                VWMB();
190 1098
                vbe32enc(b->spec + BANS_LENGTH, BANS_HEAD_LEN);
191 1098
                VSC_C_main->bans_completed++;
192 1098
                bans_persisted_fragmentation += ln - ban_len(b->spec);
193 1098
                VSC_C_main->bans_persisted_fragmentation =
194 1098
                    bans_persisted_fragmentation;
195 1098
        }
196 1098
}
197
198
/*--------------------------------------------------------------------
199
 * Access a lump of bytes in a ban test spec
200
 */
201
202
static const void *
203
ban_get_lump(const uint8_t **bs)
204 448
{
205 448
        const void *r;
206 448
        unsigned ln;
207
208 2800
        while (**bs == 0xff)
209 2352
                *bs += 1;
210 448
        ln = vbe32dec(*bs);
211 448
        *bs += PRNDUP(sizeof(uint32_t));
212 448
        assert(PAOK(*bs));
213 448
        r = (const void*)*bs;
214 448
        *bs += ln;
215 448
        return (r);
216 448
}
217
218
/*--------------------------------------------------------------------
219
 * Pick a test apart from a spec string
220
 */
221
222
static void
223
ban_iter(const uint8_t **bs, struct ban_test *bt)
224 398
{
225 398
        const void *lump;
226 398
        uint64_t dtmp;
227
228 398
        memset(bt, 0, sizeof *bt);
229 398
        bt->arg2_double = nan("");
230 398
        bt->arg1 = *(*bs)++;
231 398
        if (BANS_HAS_ARG1_SPEC(bt->arg1)) {
232 102
                bt->arg1_spec = (const char *)*bs;
233 102
                (*bs) += (*bs)[0] + 2;
234 102
        }
235 398
        lump = ban_get_lump(bs);
236 398
        bt->oper = *(*bs)++;
237 398
        if (BANS_HAS_ARG2_DOUBLE(bt->arg1)) {
238 157
                dtmp = vbe64dec(lump);
239 157
                vmemcpy(&bt->arg2_double, &dtmp, sizeof dtmp);
240 157
                return;
241 241
        } else if (BANS_HAS_ARG2_BOOL(bt->arg1)) {
242 35
                bt->arg2_bool = *(uint8_t const *)lump;
243 35
                return;
244 35
        }
245 206
        bt->arg2 = lump;
246 206
        if (BANS_HAS_ARG2_SPEC(bt->oper))
247 50
                bt->arg2_spec = ban_get_lump(bs);
248 206
}
249
250
/*--------------------------------------------------------------------
251
 * A new object is created, grab a reference to the newest ban
252
 */
253
254
void
255
BAN_NewObjCore(struct objcore *oc)
256 1482
{
257
258 1482
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
259 1482
        AZ(oc->ban);
260 1482
        AN(oc->objhead);
261 1482
        Lck_Lock(&ban_mtx);
262 1482
        oc->ban = ban_start;
263 1482
        ban_start->refcount++;
264 1482
        VTAILQ_INSERT_TAIL(&ban_start->objcore, oc, ban_list);
265 1482
        Lck_Unlock(&ban_mtx);
266 1482
}
267
268
/*--------------------------------------------------------------------
269
 * An object is destroyed, release its ban reference
270
 */
271
272
void
273
BAN_DestroyObj(struct objcore *oc)
274 5852
{
275
276 5852
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
277 5852
        if (oc->ban == NULL)
278 5431
                return;
279 421
        Lck_Lock(&ban_mtx);
280 421
        CHECK_OBJ_ORNULL(oc->ban, BAN_MAGIC);
281 421
        if (oc->ban != NULL) {
282 421
                assert(oc->ban->refcount > 0);
283 421
                oc->ban->refcount--;
284 421
                VTAILQ_REMOVE(&oc->ban->objcore, oc, ban_list);
285 421
                oc->ban = NULL;
286 421
        }
287 421
        Lck_Unlock(&ban_mtx);
288 421
}
289
290
/*--------------------------------------------------------------------
291
 * Find a ban based on a timestamp.
292
 * Assume we have a BAN_Hold, so list traversal is safe.
293
 */
294
295
struct ban *
296
BAN_FindBan(vtim_real t0)
297 16
{
298 16
        struct ban *b;
299 16
        vtim_real t1;
300
301 16
        assert(ban_holds > 0);
302 16
        b = BANIDX_lookup(t0);
303 16
        VTAILQ_FOREACH_FROM(b, &ban_head, list) {
304 16
                t1 = ban_time(b->spec);
305 16
                if (t1 == t0)
306 16
                        return (b);
307 0
                if (t1 < t0)
308 0
                        break;
309 0
        }
310 0
        return (NULL);
311 16
}
312
313
/*--------------------------------------------------------------------
314
 * Grab a reference to a ban and associate the objcore with that ban.
315
 * Assume we have a BAN_Hold, so list traversal is safe.
316
 */
317
318
void
319
BAN_RefBan(struct objcore *oc, struct ban *b)
320 16
{
321
322 16
        Lck_Lock(&ban_mtx);
323 16
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
324 16
        AZ(oc->ban);
325 16
        CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
326 16
        assert(ban_holds > 0);
327 16
        b->refcount++;
328 16
        VTAILQ_INSERT_TAIL(&b->objcore, oc, ban_list);
329 16
        oc->ban = b;
330 16
        Lck_Unlock(&ban_mtx);
331 16
}
332
333
/*--------------------------------------------------------------------
334
 * Compile a full ban list and export this area to the stevedores for
335
 * persistence.
336
 */
337
338
static void
339
ban_export(void)
340 2037
{
341 2037
        struct ban *b;
342 2037
        struct vsb *vsb;
343 2037
        unsigned ln;
344
345 2037
        Lck_AssertHeld(&ban_mtx);
346 2037
        ln = bans_persisted_bytes - bans_persisted_fragmentation;
347 2037
        vsb = VSB_new_auto();
348 2037
        AN(vsb);
349 2037
        VTAILQ_FOREACH_REVERSE(b, &ban_head, banhead_s, list)
350 2119
                AZ(VSB_bcat(vsb, b->spec, ban_len(b->spec)));
351 2037
        AZ(VSB_finish(vsb));
352 2037
        assert(VSB_len(vsb) == ln);
353 2037
        Lck_Unlock(&ban_mtx);
354 2037
        STV_BanExport((const uint8_t *)VSB_data(vsb), VSB_len(vsb));
355 2037
        VSB_destroy(&vsb);
356 2037
        Lck_Lock(&ban_mtx);
357 2037
        VSC_C_main->bans_persisted_bytes =
358 2037
            bans_persisted_bytes = ln;
359 2037
        VSC_C_main->bans_persisted_fragmentation =
360 2037
            bans_persisted_fragmentation = 0;
361 2037
}
362
363
/*
364
 * For both of these we do a full export on info failure to remove
365
 * holes in the exported list.
366
 * XXX: we should keep track of the size of holes in the last exported list
367
 * XXX: check if the ban_export should be batched in ban_cleantail
368
 */
369
void
370
ban_info_new(const uint8_t *ban, unsigned len)
371 1148
{
372 1148
        Lck_AssertHeld(&ban_mtx);
373 1148
        if (STV_BanInfoNew(ban, len))
374 0
                ban_export();
375 1148
}
376
377
void
378
ban_info_drop(const uint8_t *ban, unsigned len)
379 92
{
380 92
        Lck_AssertHeld(&ban_mtx);
381 92
        if (STV_BanInfoDrop(ban, len))
382 0
                ban_export();
383 92
}
384
385
/*--------------------------------------------------------------------
386
 * Put a skeleton ban in the list, unless there is an identical,
387
 * time & condition, ban already in place.
388
 *
389
 * If a newer ban has same condition, mark the inserted ban COMPLETED,
390
 * also mark any older bans, with the same condition COMPLETED.
391
 */
392
393
static void
394
ban_reload(const uint8_t *ban, unsigned len)
395 33
{
396 33
        struct ban *b, *b2;
397 33
        int duplicate = 0;
398 33
        vtim_real t0, t1, t2 = 9e99;
399 33
        ASSERT_CLI();
400 33
        Lck_AssertHeld(&ban_mtx);
401 33
        assert(ban_holds > 0);
402
403 33
        t0 = ban_time(ban);
404 33
        assert(len == ban_len(ban));
405
406 33
        b = BANIDX_lookup(t0);
407 43
        VTAILQ_FOREACH_FROM(b, &ban_head, list) {
408 43
                t1 = ban_time(b->spec);
409 43
                assert(t1 < t2);
410 43
                t2 = t1;
411 43
                if (t1 == t0)
412 8
                        return;
413 35
                if (t1 < t0)
414 10
                        break;
415 25
                if (ban_equal(b->spec, ban))
416 17
                        duplicate = 1;
417 25
        }
418
419 25
        VSC_C_main->bans++;
420 25
        VSC_C_main->bans_added++;
421
422 25
        b2 = ban_alloc();
423 25
        AN(b2);
424 25
        b2->spec = malloc(len);
425 25
        AN(b2->spec);
426 25
        vmemcpy(b2->spec, ban, len);
427 25
        if (ban[BANS_FLAGS] & BANS_FLAG_REQ) {
428 5
                VSC_C_main->bans_req++;
429 5
                b2->flags |= BANS_FLAG_REQ;
430 5
        }
431 25
        if (duplicate)
432 17
                VSC_C_main->bans_dups++;
433 25
        if (duplicate || (ban[BANS_FLAGS] & BANS_FLAG_COMPLETED))
434 18
                ban_mark_completed(b2);
435 25
        if (b == NULL)
436 15
                VTAILQ_INSERT_TAIL(&ban_head, b2, list);
437 10
        else
438 10
                VTAILQ_INSERT_BEFORE(b, b2, list);
439 25
        bans_persisted_bytes += len;
440 25
        VSC_C_main->bans_persisted_bytes = bans_persisted_bytes;
441
442
        /* Hunt down older duplicates */
443 40
        for (b = VTAILQ_NEXT(b2, list); b != NULL; b = VTAILQ_NEXT(b, list)) {
444 15
                if (b->flags & BANS_FLAG_COMPLETED)
445 14
                        continue;
446 1
                if (ban_equal(b->spec, ban)) {
447 0
                        ban_mark_completed(b);
448 0
                        VSC_C_main->bans_dups++;
449 0
                }
450 1
        }
451 25
}
452
453
/*--------------------------------------------------------------------
454
 * Reload a series of persisted ban specs
455
 */
456
457
void
458
BAN_Reload(const uint8_t *ptr, unsigned len)
459 36
{
460 36
        const uint8_t *pe;
461 36
        unsigned l;
462
463 36
        AZ(ban_shutdown);
464 36
        pe = ptr + len;
465 36
        Lck_Lock(&ban_mtx);
466 69
        while (ptr < pe) {
467
                /* XXX: This can be optimized by traversing the live
468
                 * ban list together with the reload list (combining
469
                 * the loops in BAN_Reload and ban_reload). */
470 33
                l = ban_len(ptr);
471 33
                assert(ptr + l <= pe);
472 33
                ban_reload(ptr, l);
473 33
                ptr += l;
474 33
        }
475 36
        Lck_Unlock(&ban_mtx);
476 36
}
477
478
/*--------------------------------------------------------------------
479
 * Get a bans timestamp
480
 */
481
482
vtim_real
483
BAN_Time(const struct ban *b)
484 62
{
485
486 62
        if (b == NULL)
487 19
                return (0.0);
488
489 43
        CHECK_OBJ(b, BAN_MAGIC);
490 43
        return (ban_time(b->spec));
491 43
}
492
493
/*--------------------------------------------------------------------
494
 * Evaluate ban-spec
495
 */
496
497
int
498
ban_evaluate(struct worker *wrk, const uint8_t *bsarg, struct objcore *oc,
499
    const struct http *reqhttp, unsigned *tests)
500 125
{
501 125
        struct ban_test bt;
502 125
        const uint8_t *bs, *be;
503 125
        const char *p;
504 125
        const char *arg1;
505 125
        double darg1, darg2;
506 125
        int barg1, barg2;
507 125
        hdr_t hdr;
508 125
        int rv;
509
510
        /*
511
         * for ttl, age and last_hit, fix the point in time such that banning
512
         * refers to the same point in time when the ban is evaluated
513
         *
514
         * for grace/keep, we assume that the absolute values are pola and that
515
         * users will most likely also specify a ttl criterion if they want to
516
         * fix a point in time (such as "obj.ttl > 5h && obj.keep > 3h")
517
         */
518
519 125
        bs = bsarg;
520 125
        be = bs + ban_len(bs);
521 125
        bs += BANS_HEAD_LEN;
522 206
        while (bs < be) {
523 139
                (*tests)++;
524 139
                ban_iter(&bs, &bt);
525 139
                arg1 = NULL;
526 139
                darg1 = darg2 = nan("");
527 139
                barg1 = barg2 = -1;
528 139
                switch (bt.arg1) {
529 27
                case BANS_ARG_URL:
530 27
                        AN(reqhttp);
531 27
                        arg1 = reqhttp->hd[HTTP_HDR_URL].b;
532 27
                        break;
533 9
                case BANS_ARG_REQHTTP:
534 9
                        AN(reqhttp);
535 9
                        CAST_HDR(hdr, bt.arg1_spec);
536 9
                        (void)http_GetHdr(reqhttp, hdr, &p);
537 9
                        arg1 = p;
538 9
                        break;
539 32
                case BANS_ARG_OBJHTTP:
540 32
                        CAST_HDR(hdr, bt.arg1_spec);
541 32
                        arg1 = HTTP_GetHdrPack(wrk, oc, hdr);
542 32
                        break;
543 14
                case BANS_ARG_OBJSTATUS:
544 14
                        arg1 = HTTP_GetHdrPack(wrk, oc, H__Status);
545 14
                        break;
546 5
                case BANS_ARG_OBJTTL:
547 5
                        darg1 = oc->ttl + oc->t_origin;
548 5
                        darg2 = bt.arg2_double + ban_time(bsarg);
549 5
                        break;
550 5
                case BANS_ARG_OBJAGE:
551 5
                        darg1 = 0.0 - oc->t_origin;
552 5
                        darg2 = 0.0 - (ban_time(bsarg) - bt.arg2_double);
553 5
                        break;
554 3
                case BANS_ARG_OBJGRACE:
555 3
                        darg1 = oc->grace;
556 3
                        darg2 = bt.arg2_double;
557 3
                        break;
558 7
                case BANS_ARG_OBJKEEP:
559 7
                        darg1 = oc->keep;
560 7
                        darg2 = bt.arg2_double;
561 7
                        break;
562 2
                case BANS_ARG_OBJLASTHIT:
563 2
                        if (isnan(oc->last_lru))
564 0
                                return (0);
565 2
                        darg1 = 0.0 - oc->last_lru;
566 2
                        darg2 = 0.0 - (ban_time(bsarg) - bt.arg2_double);
567 2
                        break;
568 10
                case BANS_ARG_OBJHFM:
569 10
                        barg1 = oc->flags & OC_F_HFM ? 1 : 0;
570 10
                        barg2 = bt.arg2_bool;
571 10
                        break;
572 10
                case BANS_ARG_OBJHFP:
573 10
                        barg1 = oc->flags & OC_F_HFP ? 1 : 0;
574 10
                        barg2 = bt.arg2_bool;
575 10
                        break;
576 15
                case BANS_ARG_OBJUNCACHEABLE:
577 15
                        barg1 = (oc->flags & (OC_F_HFM | OC_F_HFP)) ? 1 : 0;
578 15
                        barg2 = bt.arg2_bool;
579 15
                        break;
580 0
                default:
581 0
                        WRONG("Wrong BAN_ARG code");
582 139
                }
583
584 139
                switch (bt.oper) {
585 70
                case BANS_OPER_EQ:
586 70
                        if (barg1 != -1) {
587 14
                                if (barg1 != barg2)
588 7
                                        return (0);
589 56
                        } else if (arg1 == NULL) {
590 11
                                if (isnan(darg1) || darg1 != darg2)
591 5
                                        return (0);
592 45
                        } else if (vstrcmp(arg1, bt.arg2)) {
593 21
                                return (0);
594 21
                        }
595 37
                        break;
596 37
                case BANS_OPER_NEQ:
597 33
                        if (barg1 != -1) {
598 21
                                if (barg1 == barg2)
599 7
                                        return (0);
600 21
                        } else if (arg1 == NULL) {
601 7
                                if (! isnan(darg1) && darg1 == darg2)
602 4
                                        return (0);
603 7
                        } else if (!vstrcmp(arg1, bt.arg2)) {
604 2
                                return (0);
605 2
                        }
606 20
                        break;
607 24
                case BANS_OPER_MATCH:
608 24
                        if (arg1 == NULL)
609 1
                                return (0);
610 23
                        rv = VRE_match(bt.arg2_spec, arg1, 0, 0, NULL);
611 23
                        xxxassert(rv >= -1);
612 23
                        if (rv < 0)
613 2
                                return (0);
614 21
                        break;
615 21
                case BANS_OPER_NMATCH:
616 0
                        if (arg1 == NULL)
617 0
                                return (0);
618 0
                        rv = VRE_match(bt.arg2_spec, arg1, 0, 0, NULL);
619 0
                        xxxassert(rv >= -1);
620 0
                        if (rv >= 0)
621 0
                                return (0);
622 0
                        break;
623 8
                case BANS_OPER_GT:
624 8
                        AZ(arg1);
625 8
                        assert(! isnan(darg1));
626 8
                        if (!(darg1 > darg2))
627 8
                                return (0);
628 0
                        break;
629 0
                case BANS_OPER_GTE:
630 0
                        AZ(arg1);
631 0
                        assert(! isnan(darg1));
632 0
                        if (!(darg1 >= darg2))
633 0
                                return (0);
634 0
                        break;
635 3
                case BANS_OPER_LT:
636 3
                        AZ(arg1);
637 3
                        assert(! isnan(darg1));
638 3
                        if (!(darg1 < darg2))
639 1
                                return (0);
640 2
                        break;
641 2
                case BANS_OPER_LTE:
642 1
                        AZ(arg1);
643 1
                        assert(! isnan(darg1));
644 1
                        if (!(darg1 <= darg2))
645 0
                                return (0);
646 1
                        break;
647 1
                default:
648 0
                        WRONG("Wrong BAN_OPER code");
649 139
                }
650 139
        }
651 67
        return (1);
652 125
}
653
654
/*--------------------------------------------------------------------
655
 * Check an object against all applicable bans
656
 *
657
 * Return:
658
 *      -1 not all bans checked, but none of the checked matched
659
 *              Only if !has_req
660
 *      0 No bans matched, object moved to ban_start.
661
 *      1 Ban matched, object removed from ban list.
662
 */
663
664
int
665
BAN_CheckObject(struct worker *wrk, struct objcore *oc, struct req *req)
666 2263
{
667 2263
        struct ban *b;
668 2263
        struct vsl_log *vsl;
669 2263
        struct ban *b0, *bn;
670 2263
        unsigned tests;
671
672 2263
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
673 2263
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
674 2263
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
675 2263
        Lck_AssertHeld(&oc->objhead->mtx);
676 2263
        assert(oc->refcnt > 0);
677
678 2263
        vsl = req->vsl;
679
680 2263
        CHECK_OBJ_NOTNULL(oc->ban, BAN_MAGIC);
681
682
        /* First do an optimistic unlocked check */
683 2263
        b0 = ban_start;
684 2263
        CHECK_OBJ_NOTNULL(b0, BAN_MAGIC);
685
686 2263
        if (b0 == oc->ban)
687 2204
                return (0);
688
689
        /* If that fails, make a safe check */
690 59
        Lck_Lock(&ban_mtx);
691 59
        b0 = ban_start;
692 59
        bn = oc->ban;
693 59
        if (b0 != bn)
694 60
                bn->refcount++;
695 59
        Lck_Unlock(&ban_mtx);
696
697 59
        AN(bn);
698
699 59
        if (b0 == bn)
700 0
                return (0);
701
702 59
        AN(b0);
703 59
        AN(bn);
704
705
        /*
706
         * This loop is safe without locks, because we know we hold
707
         * a refcount on a ban somewhere in the list and we do not
708
         * inspect the list past that ban.
709
         */
710 59
        tests = 0;
711 101
        for (b = b0; b != bn; b = VTAILQ_NEXT(b, list)) {
712 76
                CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
713 76
                if (b->flags & BANS_FLAG_COMPLETED)
714 19
                        continue;
715 57
                if (ban_evaluate(wrk, b->spec, oc, req->http, &tests))
716 34
                        break;
717 57
        }
718
719 59
        Lck_Lock(&ban_mtx);
720 59
        bn->refcount--;
721 59
        VSC_C_main->bans_tested++;
722 59
        VSC_C_main->bans_tests_tested += tests;
723
724 59
        if (b == bn) {
725
                /* not banned */
726 26
                oc->ban->refcount--;
727 26
                VTAILQ_REMOVE(&oc->ban->objcore, oc, ban_list);
728 26
                VTAILQ_INSERT_TAIL(&b0->objcore, oc, ban_list);
729 26
                b0->refcount++;
730 26
                oc->ban = b0;
731 26
                b = NULL;
732 26
        }
733 59
        if (b != NULL)
734 34
                VSC_C_main->bans_obj_killed++;
735
736 59
        if (VTAILQ_LAST(&ban_head, banhead_s)->refcount == 0)
737 21
                ban_kick_lurker();
738
739 59
        Lck_Unlock(&ban_mtx);
740
741 59
        if (b == NULL) {
742
                /* not banned */
743 26
                ObjSendEvent(wrk, oc, OEV_BANCHG);
744 26
                return (0);
745 33
        } else {
746 33
                VSLb(vsl, SLT_ExpBan,
747 33
                    "%ju banned lookup", VXID(ObjGetXID(wrk, oc)));
748 33
                return (1);
749 33
        }
750 59
}
751
752
/*--------------------------------------------------------------------
753
 * CLI functions to add bans
754
 */
755
756
static void v_matchproto_(cli_func_t)
757
ccf_ban(struct cli *cli, const char * const *av, void *priv)
758 128
{
759 128
        int narg, i;
760 128
        struct ban_proto *bp;
761 128
        const char *err = NULL;
762
763 128
        (void)priv;
764
765
        /* First do some cheap checks on the arguments */
766 557
        for (narg = 0; av[narg + 2] != NULL; narg++)
767 429
                continue;
768 128
        if ((narg % 4) != 3) {
769 2
                VCLI_Out(cli, "Wrong number of arguments");
770 2
                VCLI_SetResult(cli, CLIS_PARAM);
771 2
                return;
772 2
        }
773 135
        for (i = 3; i < narg; i += 4) {
774 10
                if (vstrcmp(av[i + 2], "&&")) {
775 1
                        VCLI_Out(cli, "Found \"%s\" expected &&", av[i + 2]);
776 1
                        VCLI_SetResult(cli, CLIS_PARAM);
777 1
                        return;
778 1
                }
779 10
        }
780
781 125
        bp = BAN_Build();
782 125
        if (bp == NULL) {
783 0
                VCLI_Out(cli, "Out of Memory");
784 0
                VCLI_SetResult(cli, CLIS_CANT);
785 0
                return;
786 0
        }
787 240
        for (i = 0; i < narg; i += 4) {
788 134
                err = BAN_AddTest(bp, av[i + 2], av[i + 3], av[i + 4]);
789 134
                if (err)
790 19
                        break;
791 134
        }
792
793 125
        if (err == NULL) {
794
                // XXX racy - grab wstat lock?
795 106
                err = BAN_Commit(bp);
796 106
        }
797
798 125
        if (err != NULL) {
799 19
                VCLI_Out(cli, "%s", err);
800 19
                BAN_Abandon(bp);
801 19
                VCLI_SetResult(cli, CLIS_PARAM);
802 19
        }
803 125
}
804
805
#define Ms 60
806
#define Hs (Ms * 60)
807
#define Ds (Hs * 24)
808
#define Ws (Ds * 7)
809
#define Ys (Ds * 365)
810
811
#define Xfmt(buf, var, s, unit)                                         \
812 275
        ((var) >= s && (var) % s == 0)                                  \
813 275
                bprintf((buf), "%ju" unit, (var) / s)
814
815
// XXX move to VTIM?
816 135
#define vdur_render(buf, dur) do {                                      \
817 135
        uintmax_t dec = (uintmax_t)floor(dur);                          \
818 135
        uintmax_t frac = (uintmax_t)floor((dur) * 1e3) % UINTMAX_C(1000); \
819 135
        if (dec == 0 && frac == 0)                                      \
820 135
                (void) strncpy(buf, "0s", sizeof(buf));                 \
821 135
        else if (dec == 0)                                              \
822 126
                bprintf((buf), "%jums", frac);                          \
823 126
        else if (frac != 0)                                             \
824 101
                bprintf((buf), "%ju.%03jus", dec, frac);                \
825 101
        else if Xfmt(buf, dec, Ys, "y");                                \
826 90
        else if Xfmt(buf, dec, Ws, "w");                                \
827 71
        else if Xfmt(buf, dec, Ds, "d");                                \
828 56
        else if Xfmt(buf, dec, Hs, "h");                                \
829 31
        else if Xfmt(buf, dec, Ms, "m");                                \
830 27
        else                                                            \
831 27
                bprintf((buf), "%jus", dec);                            \
832 135
        } while (0)
833
834
static void
835
ban_render(struct cli *cli, const uint8_t *bs, int quote)
836 324
{
837 324
        struct ban_test bt;
838 324
        const uint8_t *be;
839 324
        char buf[64];
840
841 324
        be = bs + ban_len(bs);
842 324
        bs += BANS_HEAD_LEN;
843 583
        while (bs < be) {
844 259
                ban_iter(&bs, &bt);
845 259
                ASSERT_BAN_ARG(bt.arg1);
846 259
                ASSERT_BAN_OPER(bt.oper);
847
848 259
                if (BANS_HAS_ARG1_SPEC(bt.arg1))
849 61
                        VCLI_Out(cli, "%s%.*s",
850 61
                            arg_name[BAN_ARGIDX(bt.arg1)],
851 61
                            bt.arg1_spec[0] - 1, bt.arg1_spec + 1);
852 198
                else
853 198
                        VCLI_Out(cli, "%s", arg_name[BAN_ARGIDX(bt.arg1)]);
854
855 259
                VCLI_Out(cli, " %s ", ban_oper[BAN_OPERIDX(bt.oper)]);
856
857 259
                if (BANS_HAS_ARG2_DOUBLE(bt.arg1)) {
858 135
                        vdur_render(buf, bt.arg2_double);
859 135
                        VCLI_Out(cli, "%s", buf);
860 135
                } else if (BANS_HAS_ARG2_BOOL(bt.arg1)) {
861 0
                        VCLI_Out(cli, "%s", bt.arg2_bool ? "true" : "false");
862 124
                } else if (quote) {
863 13
                        VCLI_Quote(cli, bt.arg2);
864 111
                } else {
865 111
                        VCLI_Out(cli, "%s", bt.arg2);
866 111
                }
867
868 259
                if (bs < be)
869 25
                        VCLI_Out(cli, " && ");
870 259
        }
871 324
}
872
873
static void
874
ban_list(struct cli *cli, struct ban *bl)
875 73
{
876 73
        struct ban *b;
877 73
        int64_t o;
878
879 73
        VCLI_Out(cli, "Present bans:\n");
880 299
        VTAILQ_FOREACH(b, &ban_head, list) {
881 299
                o = bl == b ? 1 : 0;
882 299
                VCLI_Out(cli, "%10.6f %5ju %s", ban_time(b->spec),
883 299
                    (intmax_t)(b->refcount - o),
884 299
                    b->flags & BANS_FLAG_COMPLETED ? "C" : "-");
885 299
                if (DO_DEBUG(DBG_LURKER)) {
886 47
                        VCLI_Out(cli, "%s%s %p ",
887 47
                            b->flags & BANS_FLAG_REQ ? "R" : "-",
888 47
                            b->flags & BANS_FLAG_OBJ ? "O" : "-",
889 47
                            b);
890 47
                }
891 299
                VCLI_Out(cli, "  ");
892 299
                ban_render(cli, b->spec, 0);
893 299
                VCLI_Out(cli, "\n");
894 299
                if (VCLI_Overflow(cli))
895 0
                        break;
896 299
                if (DO_DEBUG(DBG_LURKER)) {
897 47
                        Lck_Lock(&ban_mtx);
898 47
                        struct objcore *oc;
899 47
                        VTAILQ_FOREACH(oc, &b->objcore, ban_list)
900 32
                                VCLI_Out(cli, "  oc = %p\n", oc);
901 47
                        Lck_Unlock(&ban_mtx);
902 47
                }
903 299
        }
904 73
}
905
906
static void
907
ban_list_json(struct cli *cli, const char * const *av, struct ban *bl)
908 6
{
909 6
        struct ban *b;
910 6
        int64_t o;
911 6
        int n = 0;
912 6
        int ocs;
913
914 6
        VCLI_JSON_begin(cli, 2, av);
915 6
        VCLI_Out(cli, ",\n");
916 25
        VTAILQ_FOREACH(b, &ban_head, list) {
917 25
                o = bl == b ? 1 : 0;
918 25
                VCLI_Out(cli, "%s", n ? ",\n" : "");
919 25
                n++;
920 25
                VCLI_Out(cli, "{\n");
921 25
                VSB_indent(cli->sb, 2);
922 25
                VCLI_Out(cli, "\"time\": %.6f,\n", ban_time(b->spec));
923 25
                VCLI_Out(cli, "\"refs\": %ju,\n", (intmax_t)(b->refcount - o));
924 25
                VCLI_Out(cli, "\"completed\": %s,\n",
925 25
                         b->flags & BANS_FLAG_COMPLETED ? "true" : "false");
926 25
                VCLI_Out(cli, "\"spec\": \"");
927 25
                ban_render(cli, b->spec, 1);
928 25
                VCLI_Out(cli, "\"");
929
930 25
                if (DO_DEBUG(DBG_LURKER)) {
931 6
                        VCLI_Out(cli, ",\n");
932 6
                        VCLI_Out(cli, "\"req_tests\": %s,\n",
933 6
                                 b->flags & BANS_FLAG_REQ ? "true" : "false");
934 6
                        VCLI_Out(cli, "\"obj_tests\": %s,\n",
935 6
                                 b->flags & BANS_FLAG_OBJ ? "true" : "false");
936 6
                        VCLI_Out(cli, "\"pointer\": \"%p\",\n", b);
937 6
                        if (VCLI_Overflow(cli))
938 0
                                break;
939
940 6
                        ocs = 0;
941 6
                        VCLI_Out(cli, "\"objcores\": [\n");
942 6
                        VSB_indent(cli->sb, 2);
943 6
                        Lck_Lock(&ban_mtx);
944 6
                        struct objcore *oc;
945 6
                        VTAILQ_FOREACH(oc, &b->objcore, ban_list) {
946 0
                                if (ocs)
947 0
                                        VCLI_Out(cli, ",\n");
948 0
                                VCLI_Out(cli, "%p", oc);
949 0
                                ocs++;
950 0
                        }
951 6
                        Lck_Unlock(&ban_mtx);
952 6
                        VSB_indent(cli->sb, -2);
953 6
                        VCLI_Out(cli, "\n]");
954 6
                }
955 25
                VSB_indent(cli->sb, -2);
956 25
                VCLI_Out(cli, "\n}");
957 25
        }
958 6
        VCLI_JSON_end(cli);
959 6
}
960
961
static void v_matchproto_(cli_func_t)
962
ccf_ban_list(struct cli *cli, const char * const *av, void *priv)
963 79
{
964 79
        struct ban *bl;
965
966 79
        (void)priv;
967
968
        /* Get a reference so we are safe to traverse the list */
969 79
        Lck_Lock(&ban_mtx);
970 79
        bl = VTAILQ_LAST(&ban_head, banhead_s);
971 79
        bl->refcount++;
972 79
        Lck_Unlock(&ban_mtx);
973
974 79
        if (av[2] != NULL && vstrcmp(av[2], "-j") == 0)
975 6
                ban_list_json(cli, av, bl);
976 73
        else
977 73
                ban_list(cli, bl);
978
979 79
        Lck_Lock(&ban_mtx);
980 79
        bl->refcount--;
981 79
        ban_kick_lurker();      // XXX: Mostly for testcase b00009.vtc
982 79
        Lck_Unlock(&ban_mtx);
983 79
}
984
985
static struct cli_proto ban_cmds[] = {
986
        { CLICMD_BAN,                           "", ccf_ban },
987
        { CLICMD_BAN_LIST,                      "", ccf_ban_list,
988
          ccf_ban_list },
989
        { NULL }
990
};
991
992
/*--------------------------------------------------------------------
993
 */
994
995
void
996
BAN_Compile(void)
997 1024
{
998 1024
        struct ban *b;
999
1000
        /*
1001
         * All bans have been read from all persistent stevedores. Export
1002
         * the compiled list
1003
         */
1004
1005 1024
        ASSERT_CLI();
1006 1024
        AZ(ban_shutdown);
1007
1008 1024
        Lck_Lock(&ban_mtx);
1009
1010
        /* Report the place-holder ban */
1011 1024
        b = VTAILQ_FIRST(&ban_head);
1012 1024
        ban_info_new(b->spec, ban_len(b->spec));
1013
1014 1024
        ban_export();
1015
1016 1024
        Lck_Unlock(&ban_mtx);
1017
1018 1024
        ban_start = VTAILQ_FIRST(&ban_head);
1019 1024
        BAN_Release();
1020 1024
}
1021
1022
void
1023
BAN_Init(void)
1024 1026
{
1025 1026
        struct ban_proto *bp;
1026
1027 1026
        BAN_Build_Init();
1028 1026
        Lck_New(&ban_mtx, lck_ban);
1029 1026
        CLI_AddFuncs(ban_cmds);
1030
1031 1026
        ban_holds = 1;
1032
1033
        /* Add a placeholder ban */
1034 1026
        bp = BAN_Build();
1035 1026
        AN(bp);
1036 1026
        PTOK(pthread_cond_init(&ban_lurker_cond, NULL));
1037 1026
        AZ(BAN_Commit(bp));
1038 1026
        Lck_Lock(&ban_mtx);
1039 1026
        ban_mark_completed(VTAILQ_FIRST(&ban_head));
1040 1026
        Lck_Unlock(&ban_mtx);
1041 1026
}
1042
1043
/*--------------------------------------------------------------------
1044
 * Shutdown of the ban system.
1045
 *
1046
 * When this function returns, no new bans will be accepted, and no
1047
 * bans will be dropped (ban lurker thread stopped), so that no
1048
 * STV_BanInfo calls will be executed.
1049
 */
1050
1051
void
1052
BAN_Shutdown(void)
1053 1013
{
1054 1013
        void *status;
1055
1056 1013
        Lck_Lock(&ban_mtx);
1057 1013
        ban_shutdown = 1;
1058 1013
        ban_kick_lurker();
1059 1013
        Lck_Unlock(&ban_mtx);
1060
1061 1013
        PTOK(pthread_join(ban_thread, &status));
1062 1013
        AZ(status);
1063
1064 1013
        Lck_Lock(&ban_mtx);
1065
        /* Export the ban list to compact it */
1066 1013
        ban_export();
1067 1013
        Lck_Unlock(&ban_mtx);
1068
1069 1013
        BAN_Build_Fini();
1070 1013
}