| | 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 |
26 |
ban_alloc(void) |
| 80 |
|
{ |
| 81 |
|
struct ban *b; |
| 82 |
|
|
| 83 |
26 |
ALLOC_OBJ(b, BAN_MAGIC); |
| 84 |
26 |
if (b != NULL) |
| 85 |
26 |
VTAILQ_INIT(&b->objcore); |
| 86 |
26 |
return (b); |
| 87 |
|
} |
| 88 |
|
|
| 89 |
|
void |
| 90 |
72 |
BAN_Free(struct ban *b) |
| 91 |
|
{ |
| 92 |
|
|
| 93 |
72 |
CHECK_OBJ_NOTNULL(b, BAN_MAGIC); |
| 94 |
72 |
AZ(b->refcount); |
| 95 |
72 |
assert(VTAILQ_EMPTY(&b->objcore)); |
| 96 |
|
|
| 97 |
72 |
if (b->spec != NULL) |
| 98 |
72 |
free(b->spec); |
| 99 |
72 |
FREE_OBJ(b); |
| 100 |
72 |
} |
| 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 |
38 |
BAN_Hold(void) |
| 109 |
|
{ |
| 110 |
|
|
| 111 |
38 |
Lck_Lock(&ban_mtx); |
| 112 |
|
/* Once holds are released, we allow no more */ |
| 113 |
38 |
assert(ban_holds > 0); |
| 114 |
38 |
ban_holds++; |
| 115 |
38 |
Lck_Unlock(&ban_mtx); |
| 116 |
38 |
} |
| 117 |
|
|
| 118 |
|
void |
| 119 |
971 |
BAN_Release(void) |
| 120 |
|
{ |
| 121 |
|
|
| 122 |
971 |
Lck_Lock(&ban_mtx); |
| 123 |
971 |
assert(ban_holds > 0); |
| 124 |
971 |
ban_holds--; |
| 125 |
971 |
Lck_Unlock(&ban_mtx); |
| 126 |
971 |
if (ban_holds == 0) { |
| 127 |
933 |
BANIDX_fini(); |
| 128 |
933 |
WRK_BgThread(&ban_thread, "ban-lurker", ban_lurker, NULL); |
| 129 |
933 |
} |
| 130 |
971 |
} |
| 131 |
|
|
| 132 |
|
/*-------------------------------------------------------------------- |
| 133 |
|
* Extract time and length from ban-spec |
| 134 |
|
*/ |
| 135 |
|
|
| 136 |
|
vtim_real |
| 137 |
952 |
ban_time(const uint8_t *banspec) |
| 138 |
|
{ |
| 139 |
|
vtim_real t; |
| 140 |
|
uint64_t u; |
| 141 |
|
|
| 142 |
952 |
assert(sizeof t == sizeof u); |
| 143 |
952 |
assert(sizeof t == (BANS_LENGTH - BANS_TIMESTAMP)); |
| 144 |
952 |
u = vbe64dec(banspec + BANS_TIMESTAMP); |
| 145 |
952 |
memcpy(&t, &u, sizeof t); |
| 146 |
952 |
return (t); |
| 147 |
|
} |
| 148 |
|
|
| 149 |
|
unsigned |
| 150 |
6011 |
ban_len(const uint8_t *banspec) |
| 151 |
|
{ |
| 152 |
|
unsigned u; |
| 153 |
|
|
| 154 |
6011 |
u = vbe32dec(banspec + BANS_LENGTH); |
| 155 |
6011 |
return (u); |
| 156 |
|
} |
| 157 |
|
|
| 158 |
|
int |
| 159 |
274 |
ban_equal(const uint8_t *bs1, const uint8_t *bs2) |
| 160 |
|
{ |
| 161 |
|
unsigned u; |
| 162 |
|
|
| 163 |
|
/* |
| 164 |
|
* Compare two ban-strings. |
| 165 |
|
*/ |
| 166 |
274 |
u = ban_len(bs1); |
| 167 |
274 |
if (u != ban_len(bs2)) |
| 168 |
103 |
return (0); |
| 169 |
171 |
if (bs1[BANS_FLAGS] & BANS_FLAG_NODEDUP) |
| 170 |
3 |
return (0); |
| 171 |
|
|
| 172 |
168 |
return (!memcmp(bs1 + BANS_LENGTH, bs2 + BANS_LENGTH, u - BANS_LENGTH)); |
| 173 |
274 |
} |
| 174 |
|
|
| 175 |
|
void |
| 176 |
984 |
ban_mark_completed(struct ban *b) |
| 177 |
|
{ |
| 178 |
|
unsigned ln; |
| 179 |
|
|
| 180 |
984 |
CHECK_OBJ_NOTNULL(b, BAN_MAGIC); |
| 181 |
984 |
Lck_AssertHeld(&ban_mtx); |
| 182 |
|
|
| 183 |
984 |
AN(b->spec); |
| 184 |
984 |
if (!(b->flags & BANS_FLAG_COMPLETED)) { |
| 185 |
984 |
ln = ban_len(b->spec); |
| 186 |
984 |
b->flags |= BANS_FLAG_COMPLETED; |
| 187 |
984 |
b->spec[BANS_FLAGS] |= BANS_FLAG_COMPLETED; |
| 188 |
984 |
VWMB(); |
| 189 |
984 |
vbe32enc(b->spec + BANS_LENGTH, BANS_HEAD_LEN); |
| 190 |
984 |
VSC_C_main->bans_completed++; |
| 191 |
984 |
bans_persisted_fragmentation += ln - ban_len(b->spec); |
| 192 |
984 |
VSC_C_main->bans_persisted_fragmentation = |
| 193 |
984 |
bans_persisted_fragmentation; |
| 194 |
984 |
} |
| 195 |
984 |
} |
| 196 |
|
|
| 197 |
|
/*-------------------------------------------------------------------- |
| 198 |
|
* Access a lump of bytes in a ban test spec |
| 199 |
|
*/ |
| 200 |
|
|
| 201 |
|
static const void * |
| 202 |
413 |
ban_get_lump(const uint8_t **bs) |
| 203 |
|
{ |
| 204 |
|
const void *r; |
| 205 |
|
unsigned ln; |
| 206 |
|
|
| 207 |
2541 |
while (**bs == 0xff) |
| 208 |
2128 |
*bs += 1; |
| 209 |
413 |
ln = vbe32dec(*bs); |
| 210 |
413 |
*bs += PRNDUP(sizeof(uint32_t)); |
| 211 |
413 |
assert(PAOK(*bs)); |
| 212 |
413 |
r = (const void*)*bs; |
| 213 |
413 |
*bs += ln; |
| 214 |
413 |
return (r); |
| 215 |
|
} |
| 216 |
|
|
| 217 |
|
/*-------------------------------------------------------------------- |
| 218 |
|
* Pick a test apart from a spec string |
| 219 |
|
*/ |
| 220 |
|
|
| 221 |
|
static void |
| 222 |
363 |
ban_iter(const uint8_t **bs, struct ban_test *bt) |
| 223 |
|
{ |
| 224 |
|
const void *lump; |
| 225 |
|
uint64_t dtmp; |
| 226 |
|
|
| 227 |
363 |
memset(bt, 0, sizeof *bt); |
| 228 |
363 |
bt->arg2_double = nan(""); |
| 229 |
363 |
bt->arg1 = *(*bs)++; |
| 230 |
363 |
if (BANS_HAS_ARG1_SPEC(bt->arg1)) { |
| 231 |
102 |
bt->arg1_spec = (const char *)*bs; |
| 232 |
102 |
(*bs) += (*bs)[0] + 2; |
| 233 |
102 |
} |
| 234 |
363 |
lump = ban_get_lump(bs); |
| 235 |
363 |
bt->oper = *(*bs)++; |
| 236 |
363 |
if (BANS_HAS_ARG2_DOUBLE(bt->arg1)) { |
| 237 |
157 |
dtmp = vbe64dec(lump); |
| 238 |
157 |
memcpy(&bt->arg2_double, &dtmp, sizeof dtmp); |
| 239 |
157 |
return; |
| 240 |
|
} |
| 241 |
206 |
bt->arg2 = lump; |
| 242 |
206 |
if (BANS_HAS_ARG2_SPEC(bt->oper)) |
| 243 |
50 |
bt->arg2_spec = ban_get_lump(bs); |
| 244 |
363 |
} |
| 245 |
|
|
| 246 |
|
/*-------------------------------------------------------------------- |
| 247 |
|
* A new object is created, grab a reference to the newest ban |
| 248 |
|
*/ |
| 249 |
|
|
| 250 |
|
void |
| 251 |
1419 |
BAN_NewObjCore(struct objcore *oc) |
| 252 |
|
{ |
| 253 |
|
|
| 254 |
1419 |
CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC); |
| 255 |
1419 |
AZ(oc->ban); |
| 256 |
1419 |
AN(oc->objhead); |
| 257 |
1419 |
Lck_Lock(&ban_mtx); |
| 258 |
1419 |
oc->ban = ban_start; |
| 259 |
1419 |
ban_start->refcount++; |
| 260 |
1419 |
VTAILQ_INSERT_TAIL(&ban_start->objcore, oc, ban_list); |
| 261 |
1419 |
Lck_Unlock(&ban_mtx); |
| 262 |
1419 |
} |
| 263 |
|
|
| 264 |
|
/*-------------------------------------------------------------------- |
| 265 |
|
* An object is destroyed, release its ban reference |
| 266 |
|
*/ |
| 267 |
|
|
| 268 |
|
void |
| 269 |
1858 |
BAN_DestroyObj(struct objcore *oc) |
| 270 |
|
{ |
| 271 |
|
|
| 272 |
1858 |
CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC); |
| 273 |
1858 |
if (oc->ban == NULL) |
| 274 |
1487 |
return; |
| 275 |
371 |
Lck_Lock(&ban_mtx); |
| 276 |
371 |
CHECK_OBJ_ORNULL(oc->ban, BAN_MAGIC); |
| 277 |
371 |
if (oc->ban != NULL) { |
| 278 |
371 |
assert(oc->ban->refcount > 0); |
| 279 |
371 |
oc->ban->refcount--; |
| 280 |
371 |
VTAILQ_REMOVE(&oc->ban->objcore, oc, ban_list); |
| 281 |
371 |
oc->ban = NULL; |
| 282 |
371 |
} |
| 283 |
371 |
Lck_Unlock(&ban_mtx); |
| 284 |
1858 |
} |
| 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 |
17 |
BAN_FindBan(vtim_real t0) |
| 293 |
|
{ |
| 294 |
|
struct ban *b; |
| 295 |
|
vtim_real t1; |
| 296 |
|
|
| 297 |
17 |
assert(ban_holds > 0); |
| 298 |
17 |
b = BANIDX_lookup(t0); |
| 299 |
17 |
VTAILQ_FOREACH_FROM(b, &ban_head, list) { |
| 300 |
17 |
t1 = ban_time(b->spec); |
| 301 |
17 |
if (t1 == t0) |
| 302 |
17 |
return (b); |
| 303 |
0 |
if (t1 < t0) |
| 304 |
0 |
break; |
| 305 |
0 |
} |
| 306 |
0 |
return (NULL); |
| 307 |
17 |
} |
| 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 |
17 |
BAN_RefBan(struct objcore *oc, struct ban *b) |
| 316 |
|
{ |
| 317 |
|
|
| 318 |
17 |
Lck_Lock(&ban_mtx); |
| 319 |
17 |
CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC); |
| 320 |
17 |
AZ(oc->ban); |
| 321 |
17 |
CHECK_OBJ_NOTNULL(b, BAN_MAGIC); |
| 322 |
17 |
assert(ban_holds > 0); |
| 323 |
17 |
b->refcount++; |
| 324 |
17 |
VTAILQ_INSERT_TAIL(&b->objcore, oc, ban_list); |
| 325 |
17 |
oc->ban = b; |
| 326 |
17 |
Lck_Unlock(&ban_mtx); |
| 327 |
17 |
} |
| 328 |
|
|
| 329 |
|
/*-------------------------------------------------------------------- |
| 330 |
|
* Compile a full ban list and export this area to the stevedores for |
| 331 |
|
* persistence. |
| 332 |
|
*/ |
| 333 |
|
|
| 334 |
|
static void |
| 335 |
1856 |
ban_export(void) |
| 336 |
|
{ |
| 337 |
|
struct ban *b; |
| 338 |
|
struct vsb *vsb; |
| 339 |
|
unsigned ln; |
| 340 |
|
|
| 341 |
1856 |
Lck_AssertHeld(&ban_mtx); |
| 342 |
1856 |
ln = bans_persisted_bytes - bans_persisted_fragmentation; |
| 343 |
1856 |
vsb = VSB_new_auto(); |
| 344 |
1856 |
AN(vsb); |
| 345 |
3792 |
VTAILQ_FOREACH_REVERSE(b, &ban_head, banhead_s, list) |
| 346 |
1936 |
AZ(VSB_bcat(vsb, b->spec, ban_len(b->spec))); |
| 347 |
1856 |
AZ(VSB_finish(vsb)); |
| 348 |
1856 |
assert(VSB_len(vsb) == ln); |
| 349 |
1856 |
STV_BanExport((const uint8_t *)VSB_data(vsb), VSB_len(vsb)); |
| 350 |
1856 |
VSB_destroy(&vsb); |
| 351 |
1856 |
VSC_C_main->bans_persisted_bytes = |
| 352 |
1856 |
bans_persisted_bytes = ln; |
| 353 |
1856 |
VSC_C_main->bans_persisted_fragmentation = |
| 354 |
1856 |
bans_persisted_fragmentation = 0; |
| 355 |
1856 |
} |
| 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 |
1033 |
ban_info_new(const uint8_t *ban, unsigned len) |
| 365 |
|
{ |
| 366 |
|
/* XXX martin pls review if ban_mtx needs to be held */ |
| 367 |
1033 |
Lck_AssertHeld(&ban_mtx); |
| 368 |
1033 |
if (STV_BanInfoNew(ban, len)) |
| 369 |
0 |
ban_export(); |
| 370 |
1033 |
} |
| 371 |
|
|
| 372 |
|
void |
| 373 |
72 |
ban_info_drop(const uint8_t *ban, unsigned len) |
| 374 |
|
{ |
| 375 |
|
/* XXX martin pls review if ban_mtx needs to be held */ |
| 376 |
72 |
Lck_AssertHeld(&ban_mtx); |
| 377 |
72 |
if (STV_BanInfoDrop(ban, len)) |
| 378 |
0 |
ban_export(); |
| 379 |
72 |
} |
| 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 |
34 |
ban_reload(const uint8_t *ban, unsigned len) |
| 391 |
|
{ |
| 392 |
|
struct ban *b, *b2; |
| 393 |
34 |
int duplicate = 0; |
| 394 |
34 |
vtim_real t0, t1, t2 = 9e99; |
| 395 |
34 |
ASSERT_CLI(); |
| 396 |
34 |
Lck_AssertHeld(&ban_mtx); |
| 397 |
34 |
assert(ban_holds > 0); |
| 398 |
|
|
| 399 |
34 |
t0 = ban_time(ban); |
| 400 |
34 |
assert(len == ban_len(ban)); |
| 401 |
|
|
| 402 |
34 |
b = BANIDX_lookup(t0); |
| 403 |
60 |
VTAILQ_FOREACH_FROM(b, &ban_head, list) { |
| 404 |
44 |
t1 = ban_time(b->spec); |
| 405 |
44 |
assert(t1 < t2); |
| 406 |
44 |
t2 = t1; |
| 407 |
44 |
if (t1 == t0) |
| 408 |
8 |
return; |
| 409 |
36 |
if (t1 < t0) |
| 410 |
10 |
break; |
| 411 |
26 |
if (ban_equal(b->spec, ban)) |
| 412 |
18 |
duplicate = 1; |
| 413 |
26 |
} |
| 414 |
|
|
| 415 |
26 |
VSC_C_main->bans++; |
| 416 |
26 |
VSC_C_main->bans_added++; |
| 417 |
|
|
| 418 |
26 |
b2 = ban_alloc(); |
| 419 |
26 |
AN(b2); |
| 420 |
26 |
b2->spec = malloc(len); |
| 421 |
26 |
AN(b2->spec); |
| 422 |
26 |
memcpy(b2->spec, ban, len); |
| 423 |
26 |
if (ban[BANS_FLAGS] & BANS_FLAG_REQ) { |
| 424 |
5 |
VSC_C_main->bans_req++; |
| 425 |
5 |
b2->flags |= BANS_FLAG_REQ; |
| 426 |
5 |
} |
| 427 |
26 |
if (duplicate) |
| 428 |
18 |
VSC_C_main->bans_dups++; |
| 429 |
26 |
if (duplicate || (ban[BANS_FLAGS] & BANS_FLAG_COMPLETED)) |
| 430 |
19 |
ban_mark_completed(b2); |
| 431 |
26 |
if (b == NULL) |
| 432 |
16 |
VTAILQ_INSERT_TAIL(&ban_head, b2, list); |
| 433 |
|
else |
| 434 |
10 |
VTAILQ_INSERT_BEFORE(b, b2, list); |
| 435 |
26 |
bans_persisted_bytes += len; |
| 436 |
26 |
VSC_C_main->bans_persisted_bytes = bans_persisted_bytes; |
| 437 |
|
|
| 438 |
|
/* Hunt down older duplicates */ |
| 439 |
41 |
for (b = VTAILQ_NEXT(b2, list); b != NULL; b = VTAILQ_NEXT(b, list)) { |
| 440 |
15 |
if (b->flags & BANS_FLAG_COMPLETED) |
| 441 |
14 |
continue; |
| 442 |
1 |
if (ban_equal(b->spec, ban)) { |
| 443 |
0 |
ban_mark_completed(b); |
| 444 |
0 |
VSC_C_main->bans_dups++; |
| 445 |
0 |
} |
| 446 |
1 |
} |
| 447 |
34 |
} |
| 448 |
|
|
| 449 |
|
/*-------------------------------------------------------------------- |
| 450 |
|
* Reload a series of persisted ban specs |
| 451 |
|
*/ |
| 452 |
|
|
| 453 |
|
void |
| 454 |
38 |
BAN_Reload(const uint8_t *ptr, unsigned len) |
| 455 |
|
{ |
| 456 |
|
const uint8_t *pe; |
| 457 |
|
unsigned l; |
| 458 |
|
|
| 459 |
38 |
AZ(ban_shutdown); |
| 460 |
38 |
pe = ptr + len; |
| 461 |
38 |
Lck_Lock(&ban_mtx); |
| 462 |
72 |
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 |
34 |
l = ban_len(ptr); |
| 467 |
34 |
assert(ptr + l <= pe); |
| 468 |
34 |
ban_reload(ptr, l); |
| 469 |
34 |
ptr += l; |
| 470 |
|
} |
| 471 |
38 |
Lck_Unlock(&ban_mtx); |
| 472 |
38 |
} |
| 473 |
|
|
| 474 |
|
/*-------------------------------------------------------------------- |
| 475 |
|
* Get a bans timestamp |
| 476 |
|
*/ |
| 477 |
|
|
| 478 |
|
vtim_real |
| 479 |
70 |
BAN_Time(const struct ban *b) |
| 480 |
|
{ |
| 481 |
|
|
| 482 |
70 |
if (b == NULL) |
| 483 |
22 |
return (0.0); |
| 484 |
|
|
| 485 |
48 |
CHECK_OBJ_NOTNULL(b, BAN_MAGIC); |
| 486 |
48 |
return (ban_time(b->spec)); |
| 487 |
70 |
} |
| 488 |
|
|
| 489 |
|
/*-------------------------------------------------------------------- |
| 490 |
|
* Evaluate ban-spec |
| 491 |
|
*/ |
| 492 |
|
|
| 493 |
|
int |
| 494 |
90 |
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 |
90 |
bs = bsarg; |
| 515 |
90 |
be = bs + ban_len(bs); |
| 516 |
90 |
bs += BANS_HEAD_LEN; |
| 517 |
150 |
while (bs < be) { |
| 518 |
104 |
(*tests)++; |
| 519 |
104 |
ban_iter(&bs, &bt); |
| 520 |
104 |
arg1 = NULL; |
| 521 |
104 |
darg1 = darg2 = nan(""); |
| 522 |
104 |
switch (bt.arg1) { |
| 523 |
|
case BANS_ARG_URL: |
| 524 |
27 |
AN(reqhttp); |
| 525 |
27 |
arg1 = reqhttp->hd[HTTP_HDR_URL].b; |
| 526 |
27 |
break; |
| 527 |
|
case BANS_ARG_REQHTTP: |
| 528 |
9 |
AN(reqhttp); |
| 529 |
9 |
CAST_HDR(hdr, bt.arg1_spec); |
| 530 |
9 |
(void)http_GetHdr(reqhttp, hdr, &p); |
| 531 |
9 |
arg1 = p; |
| 532 |
9 |
break; |
| 533 |
|
case BANS_ARG_OBJHTTP: |
| 534 |
32 |
CAST_HDR(hdr, bt.arg1_spec); |
| 535 |
32 |
arg1 = HTTP_GetHdrPack(wrk, oc, hdr); |
| 536 |
32 |
break; |
| 537 |
|
case BANS_ARG_OBJSTATUS: |
| 538 |
14 |
arg1 = HTTP_GetHdrPack(wrk, oc, H__Status); |
| 539 |
14 |
break; |
| 540 |
|
case BANS_ARG_OBJTTL: |
| 541 |
5 |
darg1 = oc->ttl + oc->t_origin; |
| 542 |
5 |
darg2 = bt.arg2_double + ban_time(bsarg); |
| 543 |
5 |
break; |
| 544 |
|
case BANS_ARG_OBJAGE: |
| 545 |
5 |
darg1 = 0.0 - oc->t_origin; |
| 546 |
5 |
darg2 = 0.0 - (ban_time(bsarg) - bt.arg2_double); |
| 547 |
5 |
break; |
| 548 |
|
case BANS_ARG_OBJGRACE: |
| 549 |
3 |
darg1 = oc->grace; |
| 550 |
3 |
darg2 = bt.arg2_double; |
| 551 |
3 |
break; |
| 552 |
|
case BANS_ARG_OBJKEEP: |
| 553 |
7 |
darg1 = oc->keep; |
| 554 |
7 |
darg2 = bt.arg2_double; |
| 555 |
7 |
break; |
| 556 |
|
case BANS_ARG_OBJLASTHIT: |
| 557 |
2 |
if (isnan(oc->last_lru)) |
| 558 |
0 |
return (0); |
| 559 |
2 |
darg1 = 0.0 - oc->last_lru; |
| 560 |
2 |
darg2 = 0.0 - (ban_time(bsarg) - bt.arg2_double); |
| 561 |
2 |
break; |
| 562 |
|
default: |
| 563 |
0 |
WRONG("Wrong BAN_ARG code"); |
| 564 |
0 |
} |
| 565 |
|
|
| 566 |
104 |
switch (bt.oper) { |
| 567 |
|
case BANS_OPER_EQ: |
| 568 |
56 |
if (arg1 == NULL) { |
| 569 |
11 |
if (isnan(darg1) || darg1 != darg2) |
| 570 |
5 |
return (0); |
| 571 |
51 |
} else if (strcmp(arg1, bt.arg2)) { |
| 572 |
21 |
return (0); |
| 573 |
|
} |
| 574 |
30 |
break; |
| 575 |
|
case BANS_OPER_NEQ: |
| 576 |
12 |
if (arg1 == NULL) { |
| 577 |
7 |
if (! isnan(darg1) && darg1 == darg2) |
| 578 |
4 |
return (0); |
| 579 |
8 |
} else if (!strcmp(arg1, bt.arg2)) { |
| 580 |
2 |
return (0); |
| 581 |
|
} |
| 582 |
6 |
break; |
| 583 |
|
case BANS_OPER_MATCH: |
| 584 |
24 |
if (arg1 == NULL) |
| 585 |
1 |
return (0); |
| 586 |
23 |
rv = VRE_match(bt.arg2_spec, arg1, 0, 0, NULL); |
| 587 |
23 |
xxxassert(rv >= -1); |
| 588 |
23 |
if (rv < 0) |
| 589 |
2 |
return (0); |
| 590 |
21 |
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 |
8 |
AZ(arg1); |
| 601 |
8 |
assert(! isnan(darg1)); |
| 602 |
8 |
if (!(darg1 > darg2)) |
| 603 |
8 |
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 |
3 |
AZ(arg1); |
| 613 |
3 |
assert(! isnan(darg1)); |
| 614 |
3 |
if (!(darg1 < darg2)) |
| 615 |
1 |
return (0); |
| 616 |
2 |
break; |
| 617 |
|
case BANS_OPER_LTE: |
| 618 |
1 |
AZ(arg1); |
| 619 |
1 |
assert(! isnan(darg1)); |
| 620 |
1 |
if (!(darg1 <= darg2)) |
| 621 |
0 |
return (0); |
| 622 |
1 |
break; |
| 623 |
|
default: |
| 624 |
0 |
WRONG("Wrong BAN_OPER code"); |
| 625 |
0 |
} |
| 626 |
|
} |
| 627 |
46 |
return (1); |
| 628 |
90 |
} |
| 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 |
3867 |
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 |
3867 |
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); |
| 649 |
3867 |
CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC); |
| 650 |
3867 |
CHECK_OBJ_NOTNULL(req, REQ_MAGIC); |
| 651 |
3867 |
Lck_AssertHeld(&oc->objhead->mtx); |
| 652 |
3867 |
assert(oc->refcnt > 0); |
| 653 |
|
|
| 654 |
3867 |
vsl = req->vsl; |
| 655 |
|
|
| 656 |
3867 |
CHECK_OBJ_NOTNULL(oc->ban, BAN_MAGIC); |
| 657 |
|
|
| 658 |
|
/* First do an optimistic unlocked check */ |
| 659 |
3867 |
b0 = ban_start; |
| 660 |
3867 |
CHECK_OBJ_NOTNULL(b0, BAN_MAGIC); |
| 661 |
|
|
| 662 |
3867 |
if (b0 == oc->ban) |
| 663 |
3806 |
return (0); |
| 664 |
|
|
| 665 |
|
/* If that fails, make a safe check */ |
| 666 |
61 |
Lck_Lock(&ban_mtx); |
| 667 |
61 |
b0 = ban_start; |
| 668 |
61 |
bn = oc->ban; |
| 669 |
61 |
if (b0 != bn) |
| 670 |
61 |
bn->refcount++; |
| 671 |
61 |
Lck_Unlock(&ban_mtx); |
| 672 |
|
|
| 673 |
61 |
AN(bn); |
| 674 |
|
|
| 675 |
61 |
if (b0 == bn) |
| 676 |
0 |
return (0); |
| 677 |
|
|
| 678 |
61 |
AN(b0); |
| 679 |
61 |
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 |
61 |
tests = 0; |
| 687 |
104 |
for (b = b0; b != bn; b = VTAILQ_NEXT(b, list)) { |
| 688 |
77 |
CHECK_OBJ_NOTNULL(b, BAN_MAGIC); |
| 689 |
77 |
if (b->flags & BANS_FLAG_COMPLETED) |
| 690 |
20 |
continue; |
| 691 |
57 |
if (ban_evaluate(wrk, b->spec, oc, req->http, &tests)) |
| 692 |
34 |
break; |
| 693 |
23 |
} |
| 694 |
|
|
| 695 |
61 |
Lck_Lock(&ban_mtx); |
| 696 |
61 |
bn->refcount--; |
| 697 |
61 |
VSC_C_main->bans_tested++; |
| 698 |
61 |
VSC_C_main->bans_tests_tested += tests; |
| 699 |
|
|
| 700 |
61 |
if (b == bn) { |
| 701 |
|
/* not banned */ |
| 702 |
27 |
oc->ban->refcount--; |
| 703 |
27 |
VTAILQ_REMOVE(&oc->ban->objcore, oc, ban_list); |
| 704 |
27 |
VTAILQ_INSERT_TAIL(&b0->objcore, oc, ban_list); |
| 705 |
27 |
b0->refcount++; |
| 706 |
27 |
oc->ban = b0; |
| 707 |
27 |
b = NULL; |
| 708 |
27 |
} |
| 709 |
61 |
if (b != NULL) |
| 710 |
34 |
VSC_C_main->bans_obj_killed++; |
| 711 |
|
|
| 712 |
61 |
if (VTAILQ_LAST(&ban_head, banhead_s)->refcount == 0) |
| 713 |
22 |
ban_kick_lurker(); |
| 714 |
|
|
| 715 |
61 |
Lck_Unlock(&ban_mtx); |
| 716 |
|
|
| 717 |
61 |
if (b == NULL) { |
| 718 |
|
/* not banned */ |
| 719 |
27 |
ObjSendEvent(wrk, oc, OEV_BANCHG); |
| 720 |
27 |
return (0); |
| 721 |
|
} else { |
| 722 |
68 |
VSLb(vsl, SLT_ExpBan, |
| 723 |
34 |
"%ju banned lookup", VXID(ObjGetXID(wrk, oc))); |
| 724 |
34 |
return (1); |
| 725 |
|
} |
| 726 |
3867 |
} |
| 727 |
|
|
| 728 |
|
/*-------------------------------------------------------------------- |
| 729 |
|
* CLI functions to add bans |
| 730 |
|
*/ |
| 731 |
|
|
| 732 |
|
static void v_matchproto_(cli_func_t) |
| 733 |
92 |
ccf_ban(struct cli *cli, const char * const *av, void *priv) |
| 734 |
|
{ |
| 735 |
|
int narg, i; |
| 736 |
|
struct ban_proto *bp; |
| 737 |
92 |
const char *err = NULL; |
| 738 |
|
|
| 739 |
92 |
(void)priv; |
| 740 |
|
|
| 741 |
|
/* First do some cheap checks on the arguments */ |
| 742 |
413 |
for (narg = 0; av[narg + 2] != NULL; narg++) |
| 743 |
321 |
continue; |
| 744 |
92 |
if ((narg % 4) != 3) { |
| 745 |
2 |
VCLI_Out(cli, "Wrong number of arguments"); |
| 746 |
2 |
VCLI_SetResult(cli, CLIS_PARAM); |
| 747 |
2 |
return; |
| 748 |
|
} |
| 749 |
99 |
for (i = 3; i < narg; i += 4) { |
| 750 |
10 |
if (strcmp(av[i + 2], "&&")) { |
| 751 |
1 |
VCLI_Out(cli, "Found \"%s\" expected &&", av[i + 2]); |
| 752 |
1 |
VCLI_SetResult(cli, CLIS_PARAM); |
| 753 |
1 |
return; |
| 754 |
|
} |
| 755 |
9 |
} |
| 756 |
|
|
| 757 |
89 |
bp = BAN_Build(); |
| 758 |
89 |
if (bp == NULL) { |
| 759 |
0 |
VCLI_Out(cli, "Out of Memory"); |
| 760 |
0 |
VCLI_SetResult(cli, CLIS_CANT); |
| 761 |
0 |
return; |
| 762 |
|
} |
| 763 |
180 |
for (i = 0; i < narg; i += 4) { |
| 764 |
98 |
err = BAN_AddTest(bp, av[i + 2], av[i + 3], av[i + 4]); |
| 765 |
98 |
if (err) |
| 766 |
7 |
break; |
| 767 |
91 |
} |
| 768 |
|
|
| 769 |
89 |
if (err == NULL) { |
| 770 |
|
// XXX racy - grab wstat lock? |
| 771 |
82 |
err = BAN_Commit(bp); |
| 772 |
82 |
} |
| 773 |
|
|
| 774 |
89 |
if (err != NULL) { |
| 775 |
7 |
VCLI_Out(cli, "%s", err); |
| 776 |
7 |
BAN_Abandon(bp); |
| 777 |
7 |
VCLI_SetResult(cli, CLIS_PARAM); |
| 778 |
7 |
} |
| 779 |
92 |
} |
| 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 |
324 |
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 |
324 |
be = bs + ban_len(bs); |
| 818 |
324 |
bs += BANS_HEAD_LEN; |
| 819 |
583 |
while (bs < be) { |
| 820 |
259 |
ban_iter(&bs, &bt); |
| 821 |
259 |
ASSERT_BAN_ARG(bt.arg1); |
| 822 |
259 |
ASSERT_BAN_OPER(bt.oper); |
| 823 |
|
|
| 824 |
259 |
if (BANS_HAS_ARG1_SPEC(bt.arg1)) |
| 825 |
122 |
VCLI_Out(cli, "%s%.*s", |
| 826 |
61 |
arg_name[BAN_ARGIDX(bt.arg1)], |
| 827 |
61 |
bt.arg1_spec[0] - 1, bt.arg1_spec + 1); |
| 828 |
|
else |
| 829 |
198 |
VCLI_Out(cli, "%s", arg_name[BAN_ARGIDX(bt.arg1)]); |
| 830 |
|
|
| 831 |
259 |
VCLI_Out(cli, " %s ", ban_oper[BAN_OPERIDX(bt.oper)]); |
| 832 |
|
|
| 833 |
259 |
if (BANS_HAS_ARG2_DOUBLE(bt.arg1)) { |
| 834 |
261 |
vdur_render(buf, bt.arg2_double); |
| 835 |
135 |
VCLI_Out(cli, "%s", buf); |
| 836 |
259 |
} else if (quote) { |
| 837 |
13 |
VCLI_Quote(cli, bt.arg2); |
| 838 |
13 |
} else { |
| 839 |
111 |
VCLI_Out(cli, "%s", bt.arg2); |
| 840 |
|
} |
| 841 |
|
|
| 842 |
259 |
if (bs < be) |
| 843 |
25 |
VCLI_Out(cli, " && "); |
| 844 |
|
} |
| 845 |
324 |
} |
| 846 |
|
|
| 847 |
|
static void |
| 848 |
73 |
ban_list(struct cli *cli, struct ban *bl) |
| 849 |
|
{ |
| 850 |
|
struct ban *b; |
| 851 |
|
int64_t o; |
| 852 |
|
|
| 853 |
73 |
VCLI_Out(cli, "Present bans:\n"); |
| 854 |
372 |
VTAILQ_FOREACH(b, &ban_head, list) { |
| 855 |
299 |
o = bl == b ? 1 : 0; |
| 856 |
598 |
VCLI_Out(cli, "%10.6f %5ju %s", ban_time(b->spec), |
| 857 |
299 |
(intmax_t)(b->refcount - o), |
| 858 |
299 |
b->flags & BANS_FLAG_COMPLETED ? "C" : "-"); |
| 859 |
299 |
if (DO_DEBUG(DBG_LURKER)) { |
| 860 |
94 |
VCLI_Out(cli, "%s%s %p ", |
| 861 |
47 |
b->flags & BANS_FLAG_REQ ? "R" : "-", |
| 862 |
47 |
b->flags & BANS_FLAG_OBJ ? "O" : "-", |
| 863 |
47 |
b); |
| 864 |
47 |
} |
| 865 |
299 |
VCLI_Out(cli, " "); |
| 866 |
299 |
ban_render(cli, b->spec, 0); |
| 867 |
299 |
VCLI_Out(cli, "\n"); |
| 868 |
299 |
if (VCLI_Overflow(cli)) |
| 869 |
0 |
break; |
| 870 |
299 |
if (DO_DEBUG(DBG_LURKER)) { |
| 871 |
47 |
Lck_Lock(&ban_mtx); |
| 872 |
|
struct objcore *oc; |
| 873 |
79 |
VTAILQ_FOREACH(oc, &b->objcore, ban_list) |
| 874 |
32 |
VCLI_Out(cli, " oc = %p\n", oc); |
| 875 |
47 |
Lck_Unlock(&ban_mtx); |
| 876 |
47 |
} |
| 877 |
299 |
} |
| 878 |
73 |
} |
| 879 |
|
|
| 880 |
|
static void |
| 881 |
6 |
ban_list_json(struct cli *cli, const char * const *av, struct ban *bl) |
| 882 |
|
{ |
| 883 |
|
struct ban *b; |
| 884 |
|
int64_t o; |
| 885 |
6 |
int n = 0; |
| 886 |
|
int ocs; |
| 887 |
|
|
| 888 |
6 |
VCLI_JSON_begin(cli, 2, av); |
| 889 |
6 |
VCLI_Out(cli, ",\n"); |
| 890 |
31 |
VTAILQ_FOREACH(b, &ban_head, list) { |
| 891 |
25 |
o = bl == b ? 1 : 0; |
| 892 |
25 |
VCLI_Out(cli, "%s", n ? ",\n" : ""); |
| 893 |
25 |
n++; |
| 894 |
25 |
VCLI_Out(cli, "{\n"); |
| 895 |
25 |
VSB_indent(cli->sb, 2); |
| 896 |
25 |
VCLI_Out(cli, "\"time\": %.6f,\n", ban_time(b->spec)); |
| 897 |
25 |
VCLI_Out(cli, "\"refs\": %ju,\n", (intmax_t)(b->refcount - o)); |
| 898 |
50 |
VCLI_Out(cli, "\"completed\": %s,\n", |
| 899 |
25 |
b->flags & BANS_FLAG_COMPLETED ? "true" : "false"); |
| 900 |
25 |
VCLI_Out(cli, "\"spec\": \""); |
| 901 |
25 |
ban_render(cli, b->spec, 1); |
| 902 |
25 |
VCLI_Out(cli, "\""); |
| 903 |
|
|
| 904 |
25 |
if (DO_DEBUG(DBG_LURKER)) { |
| 905 |
6 |
VCLI_Out(cli, ",\n"); |
| 906 |
12 |
VCLI_Out(cli, "\"req_tests\": %s,\n", |
| 907 |
6 |
b->flags & BANS_FLAG_REQ ? "true" : "false"); |
| 908 |
12 |
VCLI_Out(cli, "\"obj_tests\": %s,\n", |
| 909 |
6 |
b->flags & BANS_FLAG_OBJ ? "true" : "false"); |
| 910 |
6 |
VCLI_Out(cli, "\"pointer\": \"%p\",\n", b); |
| 911 |
6 |
if (VCLI_Overflow(cli)) |
| 912 |
0 |
break; |
| 913 |
|
|
| 914 |
6 |
ocs = 0; |
| 915 |
6 |
VCLI_Out(cli, "\"objcores\": [\n"); |
| 916 |
6 |
VSB_indent(cli->sb, 2); |
| 917 |
6 |
Lck_Lock(&ban_mtx); |
| 918 |
|
struct objcore *oc; |
| 919 |
6 |
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 |
6 |
Lck_Unlock(&ban_mtx); |
| 926 |
6 |
VSB_indent(cli->sb, -2); |
| 927 |
6 |
VCLI_Out(cli, "\n]"); |
| 928 |
6 |
} |
| 929 |
25 |
VSB_indent(cli->sb, -2); |
| 930 |
25 |
VCLI_Out(cli, "\n}"); |
| 931 |
25 |
} |
| 932 |
6 |
VCLI_JSON_end(cli); |
| 933 |
6 |
} |
| 934 |
|
|
| 935 |
|
static void v_matchproto_(cli_func_t) |
| 936 |
79 |
ccf_ban_list(struct cli *cli, const char * const *av, void *priv) |
| 937 |
|
{ |
| 938 |
|
struct ban *bl; |
| 939 |
|
|
| 940 |
79 |
(void)priv; |
| 941 |
|
|
| 942 |
|
/* Get a reference so we are safe to traverse the list */ |
| 943 |
79 |
Lck_Lock(&ban_mtx); |
| 944 |
79 |
bl = VTAILQ_LAST(&ban_head, banhead_s); |
| 945 |
79 |
bl->refcount++; |
| 946 |
79 |
Lck_Unlock(&ban_mtx); |
| 947 |
|
|
| 948 |
79 |
if (av[2] != NULL && strcmp(av[2], "-j") == 0) |
| 949 |
6 |
ban_list_json(cli, av, bl); |
| 950 |
|
else |
| 951 |
73 |
ban_list(cli, bl); |
| 952 |
|
|
| 953 |
79 |
Lck_Lock(&ban_mtx); |
| 954 |
79 |
bl->refcount--; |
| 955 |
79 |
ban_kick_lurker(); // XXX: Mostly for testcase b00009.vtc |
| 956 |
79 |
Lck_Unlock(&ban_mtx); |
| 957 |
79 |
} |
| 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 |
933 |
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 |
933 |
ASSERT_CLI(); |
| 980 |
933 |
AZ(ban_shutdown); |
| 981 |
|
|
| 982 |
933 |
Lck_Lock(&ban_mtx); |
| 983 |
|
|
| 984 |
|
/* Report the place-holder ban */ |
| 985 |
933 |
b = VTAILQ_FIRST(&ban_head); |
| 986 |
933 |
ban_info_new(b->spec, ban_len(b->spec)); |
| 987 |
|
|
| 988 |
933 |
ban_export(); |
| 989 |
|
|
| 990 |
933 |
Lck_Unlock(&ban_mtx); |
| 991 |
|
|
| 992 |
933 |
ban_start = VTAILQ_FIRST(&ban_head); |
| 993 |
933 |
BAN_Release(); |
| 994 |
933 |
} |
| 995 |
|
|
| 996 |
|
void |
| 997 |
935 |
BAN_Init(void) |
| 998 |
|
{ |
| 999 |
|
struct ban_proto *bp; |
| 1000 |
|
|
| 1001 |
935 |
BAN_Build_Init(); |
| 1002 |
935 |
Lck_New(&ban_mtx, lck_ban); |
| 1003 |
935 |
CLI_AddFuncs(ban_cmds); |
| 1004 |
|
|
| 1005 |
935 |
ban_holds = 1; |
| 1006 |
|
|
| 1007 |
|
/* Add a placeholder ban */ |
| 1008 |
935 |
bp = BAN_Build(); |
| 1009 |
935 |
AN(bp); |
| 1010 |
935 |
PTOK(pthread_cond_init(&ban_lurker_cond, NULL)); |
| 1011 |
935 |
AZ(BAN_Commit(bp)); |
| 1012 |
935 |
Lck_Lock(&ban_mtx); |
| 1013 |
935 |
ban_mark_completed(VTAILQ_FIRST(&ban_head)); |
| 1014 |
935 |
Lck_Unlock(&ban_mtx); |
| 1015 |
935 |
} |
| 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 |
923 |
BAN_Shutdown(void) |
| 1027 |
|
{ |
| 1028 |
|
void *status; |
| 1029 |
|
|
| 1030 |
923 |
Lck_Lock(&ban_mtx); |
| 1031 |
923 |
ban_shutdown = 1; |
| 1032 |
923 |
ban_kick_lurker(); |
| 1033 |
923 |
Lck_Unlock(&ban_mtx); |
| 1034 |
|
|
| 1035 |
923 |
PTOK(pthread_join(ban_thread, &status)); |
| 1036 |
923 |
AZ(status); |
| 1037 |
|
|
| 1038 |
923 |
Lck_Lock(&ban_mtx); |
| 1039 |
|
/* Export the ban list to compact it */ |
| 1040 |
923 |
ban_export(); |
| 1041 |
923 |
Lck_Unlock(&ban_mtx); |
| 1042 |
|
|
| 1043 |
923 |
BAN_Build_Fini(); |
| 1044 |
923 |
} |