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