| | varnish-cache/vmod/vmod_debug.c |
0 |
|
/*- |
1 |
|
* Copyright (c) 2012-2019 Varnish Software AS |
2 |
|
* All rights reserved. |
3 |
|
* |
4 |
|
* Author: Poul-Henning Kamp <phk@FreeBSD.org> |
5 |
|
* |
6 |
|
* SPDX-License-Identifier: BSD-2-Clause |
7 |
|
* |
8 |
|
* Redistribution and use in source and binary forms, with or without |
9 |
|
* modification, are permitted provided that the following conditions |
10 |
|
* are met: |
11 |
|
* 1. Redistributions of source code must retain the above copyright |
12 |
|
* notice, this list of conditions and the following disclaimer. |
13 |
|
* 2. Redistributions in binary form must reproduce the above copyright |
14 |
|
* notice, this list of conditions and the following disclaimer in the |
15 |
|
* documentation and/or other materials provided with the distribution. |
16 |
|
* |
17 |
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
18 |
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
19 |
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
20 |
|
* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE |
21 |
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
22 |
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
23 |
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
24 |
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
25 |
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
26 |
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
27 |
|
* SUCH DAMAGE. |
28 |
|
*/ |
29 |
|
|
30 |
|
#include "config.h" |
31 |
|
|
32 |
|
#include <stdlib.h> |
33 |
|
#include <stdio.h> |
34 |
|
#include <string.h> |
35 |
|
#include <sys/socket.h> |
36 |
|
#include <unistd.h> |
37 |
|
|
38 |
|
#include "cache/cache_varnishd.h" |
39 |
|
#include "cache/cache_filter.h" |
40 |
|
|
41 |
|
#include "vsa.h" |
42 |
|
#include "vss.h" |
43 |
|
#include "vtcp.h" |
44 |
|
#include "vtim.h" |
45 |
|
#include "vcc_debug_if.h" |
46 |
|
#include "VSC_debug.h" |
47 |
|
|
48 |
|
#include "vmod_debug.h" |
49 |
|
|
50 |
|
struct priv_vcl { |
51 |
|
unsigned magic; |
52 |
|
#define PRIV_VCL_MAGIC 0x8E62FA9D |
53 |
|
char *foo; |
54 |
|
uintptr_t obj_cb; |
55 |
|
struct vclref *vclref_discard; |
56 |
|
struct vclref *vclref_cold; |
57 |
|
VCL_DURATION vcl_discard_delay; |
58 |
|
VCL_BACKEND be; |
59 |
|
unsigned cold_be; |
60 |
|
unsigned cooling_be; |
61 |
|
int tmpf; |
62 |
|
}; |
63 |
|
|
64 |
|
|
65 |
|
static pthread_mutex_t vsc_mtx = PTHREAD_MUTEX_INITIALIZER; |
66 |
|
static struct vsc_seg *vsc_seg = NULL; |
67 |
|
static struct VSC_debug *vsc = NULL; |
68 |
|
static int loads; |
69 |
|
static const int store_ip_token = 0; |
70 |
|
static const int fail_task_fini_token = 0; |
71 |
|
extern void mylog(struct vsl_log *vsl, enum VSL_tag_e tag, |
72 |
|
const char *fmt, ...) v_printflike_(3,4); |
73 |
|
|
74 |
|
/**********************************************************************/ |
75 |
|
|
76 |
|
VCL_STRING v_matchproto_(td_debug_author) |
77 |
135 |
xyzzy_author(VRT_CTX, VCL_ENUM person, VCL_ENUM someone) |
78 |
|
{ |
79 |
135 |
(void)someone; |
80 |
|
|
81 |
135 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
82 |
135 |
if (person == VENUM(phk)) |
83 |
54 |
return ("Poul-Henning"); |
84 |
81 |
assert(strcmp(person, "phk")); |
85 |
81 |
if (person == VENUM(des)) |
86 |
27 |
return ("Dag-Erling"); |
87 |
54 |
assert(strcmp(person, "des")); |
88 |
54 |
if (person == VENUM(kristian)) |
89 |
27 |
return ("Kristian"); |
90 |
27 |
assert(strcmp(person, "kristian")); |
91 |
27 |
if (person == VENUM(mithrandir)) |
92 |
27 |
return ("Tollef"); |
93 |
0 |
assert(strcmp(person, "mithrandir")); |
94 |
0 |
WRONG("Illegal VMOD enum"); |
95 |
135 |
} |
96 |
|
|
97 |
|
#define AN0(x) (void) 0 |
98 |
|
#define AN1(x) AN(x) |
99 |
|
#define PRIV_FINI(name, assert) \ |
100 |
|
static void v_matchproto_(vmod_priv_fini_f) \ |
101 |
|
priv_ ## name ## _fini(VRT_CTX, void *ptr) \ |
102 |
|
{ \ |
103 |
|
const char * const fmt = "priv_" #name "_fini(%p)"; \ |
104 |
|
\ |
105 |
|
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); \ |
106 |
|
AN ## assert (ptr); \ |
107 |
|
mylog(ctx->vsl, SLT_Debug, fmt, (char *)ptr); \ |
108 |
|
free(ptr); \ |
109 |
|
} \ |
110 |
|
\ |
111 |
|
static const struct vmod_priv_methods \ |
112 |
|
xyzzy_test_priv_ ## name ## _methods[1] = {{ \ |
113 |
|
.magic = VMOD_PRIV_METHODS_MAGIC, \ |
114 |
|
.type = "debug_test_priv_" #name, \ |
115 |
|
.fini = priv_ ## name ## _fini \ |
116 |
|
}}; |
117 |
54 |
PRIV_FINI(call, 0) |
118 |
405 |
PRIV_FINI(task, 1) |
119 |
81 |
PRIV_FINI(top, 1) |
120 |
|
#undef PRIV_FINI |
121 |
|
#undef AN0 |
122 |
|
#undef AN1 |
123 |
|
|
124 |
|
VCL_VOID v_matchproto_(td_debug_test_priv_call) |
125 |
54 |
xyzzy_test_priv_call(VRT_CTX, struct vmod_priv *priv) |
126 |
|
{ |
127 |
|
|
128 |
54 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
129 |
54 |
if (priv->priv == NULL) { |
130 |
54 |
priv->priv = strdup("BAR"); |
131 |
54 |
priv->methods = xyzzy_test_priv_call_methods; |
132 |
54 |
} else { |
133 |
0 |
assert(priv->methods == xyzzy_test_priv_call_methods); |
134 |
0 |
assert(!strcmp(priv->priv, "BAR")); |
135 |
|
} |
136 |
54 |
} |
137 |
|
|
138 |
|
VCL_VOID v_matchproto_(td_debug_test_priv_task_get) |
139 |
27 |
xyzzy_test_priv_task_get(VRT_CTX) |
140 |
|
{ |
141 |
|
|
142 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
143 |
27 |
AZ(VRT_priv_task_get(ctx, NULL)); |
144 |
27 |
} |
145 |
|
|
146 |
|
VCL_STRING v_matchproto_(td_debug_test_priv_task) |
147 |
1242 |
xyzzy_test_priv_task(VRT_CTX, struct vmod_priv *priv, VCL_STRING s) |
148 |
|
{ |
149 |
|
|
150 |
1242 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
151 |
1242 |
if (s == NULL || *s == '\0') { |
152 |
1134 |
mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (exists)", |
153 |
567 |
priv, priv->priv); |
154 |
1242 |
} else if (priv->priv == NULL) { |
155 |
405 |
priv->priv = strdup(s); |
156 |
405 |
priv->methods = xyzzy_test_priv_task_methods; |
157 |
810 |
mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (new)", |
158 |
405 |
priv, priv->priv); |
159 |
405 |
} else { |
160 |
540 |
char *n = realloc(priv->priv, |
161 |
270 |
strlen(priv->priv) + strlen(s) + 2); |
162 |
270 |
if (n == NULL) |
163 |
0 |
return (NULL); |
164 |
270 |
strcat(n, " "); |
165 |
270 |
strcat(n, s); |
166 |
270 |
priv->priv = n; |
167 |
540 |
mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (update)", |
168 |
270 |
priv, priv->priv); |
169 |
|
} |
170 |
1242 |
if (priv->priv != NULL) |
171 |
1215 |
assert(priv->methods == xyzzy_test_priv_task_methods); |
172 |
1242 |
return (priv->priv); |
173 |
1242 |
} |
174 |
|
|
175 |
|
VCL_STRING v_matchproto_(td_debug_test_priv_top) |
176 |
648 |
xyzzy_test_priv_top(VRT_CTX, struct vmod_priv *priv, VCL_STRING s) |
177 |
|
{ |
178 |
|
|
179 |
648 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
180 |
648 |
if (priv->priv == NULL) { |
181 |
81 |
priv->priv = strdup(s); |
182 |
81 |
priv->methods = xyzzy_test_priv_top_methods; |
183 |
81 |
} else { |
184 |
567 |
assert(priv->methods == xyzzy_test_priv_top_methods); |
185 |
|
} |
186 |
648 |
return (priv->priv); |
187 |
|
} |
188 |
|
|
189 |
|
VCL_VOID v_matchproto_(td_debug_test_priv_vcl) |
190 |
54 |
xyzzy_test_priv_vcl(VRT_CTX, struct vmod_priv *priv) |
191 |
|
{ |
192 |
|
struct priv_vcl *priv_vcl; |
193 |
|
char t[PATH_MAX]; |
194 |
|
ssize_t l; |
195 |
|
|
196 |
54 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
197 |
54 |
AN(priv); |
198 |
54 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
199 |
|
|
200 |
54 |
l = pread(priv_vcl->tmpf, t, sizeof t, 0); |
201 |
54 |
assert(l > 0); |
202 |
|
|
203 |
54 |
AN(priv_vcl->foo); |
204 |
54 |
assert(!strncmp(priv_vcl->foo, t, l)); |
205 |
54 |
} |
206 |
|
|
207 |
|
VCL_VOID v_matchproto_(td_debug_rot52) |
208 |
54 |
xyzzy_rot52(VRT_CTX, VCL_HTTP hp) |
209 |
|
{ |
210 |
|
|
211 |
54 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
212 |
54 |
CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC); |
213 |
|
|
214 |
54 |
http_PrintfHeader(hp, "Encrypted: ROT52"); |
215 |
54 |
} |
216 |
|
|
217 |
|
VCL_STRING v_matchproto_(td_debug_argtest) |
218 |
189 |
xyzzy_argtest(VRT_CTX, struct VARGS(argtest) *arg) |
219 |
|
{ |
220 |
|
char buf[100]; |
221 |
|
|
222 |
189 |
AN(arg); |
223 |
189 |
bprintf(buf, "%s %g %s %s %jd %d %s", |
224 |
|
arg->one, arg->two, arg->three, arg->comma, (intmax_t)arg->four, |
225 |
|
arg->valid_opt, arg->valid_opt ? arg->opt : "<undef>"); |
226 |
189 |
return (WS_Copy(ctx->ws, buf, -1)); |
227 |
|
} |
228 |
|
|
229 |
|
VCL_INT v_matchproto_(td_debug_vre_limit) |
230 |
54 |
xyzzy_vre_limit(VRT_CTX) |
231 |
|
{ |
232 |
54 |
(void)ctx; |
233 |
54 |
return (cache_param->vre_limits.match); |
234 |
|
} |
235 |
|
|
236 |
|
static void v_matchproto_(obj_event_f) |
237 |
54 |
obj_cb(struct worker *wrk, void *priv, struct objcore *oc, unsigned event) |
238 |
|
{ |
239 |
|
const struct priv_vcl *priv_vcl; |
240 |
|
const char *what; |
241 |
|
|
242 |
54 |
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); |
243 |
54 |
CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC); |
244 |
54 |
CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC); |
245 |
54 |
switch (event) { |
246 |
27 |
case OEV_INSERT: what = "insert"; break; |
247 |
27 |
case OEV_EXPIRE: what = "expire"; break; |
248 |
0 |
default: WRONG("Wrong object event"); |
249 |
0 |
} |
250 |
|
|
251 |
|
/* We cannot trust %p to be 0x... format as expected by m00021.vtc */ |
252 |
108 |
VSL(SLT_Debug, NO_VXID, "Object Event: %s 0x%jx", what, |
253 |
54 |
(intmax_t)(uintptr_t)oc); |
254 |
54 |
} |
255 |
|
|
256 |
|
VCL_VOID v_matchproto_(td_debug_register_obj_events) |
257 |
27 |
xyzzy_register_obj_events(VRT_CTX, struct vmod_priv *priv) |
258 |
|
{ |
259 |
|
struct priv_vcl *priv_vcl; |
260 |
|
|
261 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
262 |
27 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
263 |
27 |
AZ(priv_vcl->obj_cb); |
264 |
27 |
priv_vcl->obj_cb = ObjSubscribeEvents(obj_cb, priv_vcl, |
265 |
|
OEV_INSERT|OEV_EXPIRE); |
266 |
27 |
VSL(SLT_Debug, NO_VXID, "Subscribed to Object Events"); |
267 |
27 |
} |
268 |
|
|
269 |
|
VCL_VOID v_matchproto_(td_debug_fail) |
270 |
432 |
xyzzy_fail(VRT_CTX) |
271 |
|
{ |
272 |
|
|
273 |
432 |
VRT_fail(ctx, "Forced failure"); |
274 |
432 |
} |
275 |
|
|
276 |
|
VCL_BOOL v_matchproto_(td_debug_fail2) |
277 |
27 |
xyzzy_fail2(VRT_CTX) |
278 |
|
{ |
279 |
|
|
280 |
27 |
VRT_fail(ctx, "Forced failure"); |
281 |
27 |
return (1); |
282 |
|
} |
283 |
|
|
284 |
|
static void v_matchproto_(vmod_priv_fini_f) |
285 |
621 |
priv_vcl_fini(VRT_CTX, void *priv) |
286 |
|
{ |
287 |
|
struct priv_vcl *priv_vcl; |
288 |
|
|
289 |
621 |
CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC); |
290 |
621 |
AZ(close(priv_vcl->tmpf)); |
291 |
621 |
AN(priv_vcl->foo); |
292 |
621 |
AZ(unlink(priv_vcl->foo)); |
293 |
621 |
free(priv_vcl->foo); |
294 |
621 |
if (priv_vcl->obj_cb != 0) { |
295 |
27 |
ObjUnsubscribeEvents(&priv_vcl->obj_cb); |
296 |
27 |
VSLb(ctx->vsl, SLT_Debug, "Unsubscribed from Object Events"); |
297 |
27 |
} |
298 |
621 |
AZ(priv_vcl->vclref_discard); |
299 |
621 |
AZ(priv_vcl->vclref_cold); |
300 |
621 |
FREE_OBJ(priv_vcl); |
301 |
621 |
} |
302 |
|
|
303 |
|
static const struct vmod_priv_methods priv_vcl_methods[1] = {{ |
304 |
|
.magic = VMOD_PRIV_METHODS_MAGIC, |
305 |
|
.type = "debug_priv_vcl_fini", |
306 |
|
.fini = priv_vcl_fini |
307 |
|
}}; |
308 |
|
|
309 |
|
static int |
310 |
2673 |
event_load(VRT_CTX, struct vmod_priv *priv) |
311 |
|
{ |
312 |
|
struct priv_vcl *priv_vcl; |
313 |
|
|
314 |
2673 |
AN(ctx->msg); |
315 |
|
|
316 |
2673 |
loads++; |
317 |
|
|
318 |
2673 |
if (cache_param->nuke_limit == 42) { |
319 |
27 |
VSB_cat(ctx->msg, "nuke_limit is not the answer."); |
320 |
27 |
return (-1); |
321 |
|
} |
322 |
|
|
323 |
2646 |
ALLOC_OBJ(priv_vcl, PRIV_VCL_MAGIC); |
324 |
2646 |
AN(priv_vcl); |
325 |
2646 |
priv_vcl->foo = strdup("worker_tmpdir/vmod_debug.XXXXXX"); |
326 |
2646 |
AN(priv_vcl->foo); |
327 |
2646 |
priv_vcl->tmpf = mkstemp(priv_vcl->foo); |
328 |
2646 |
assert(priv_vcl->tmpf >= 0); |
329 |
2646 |
AN(write(priv_vcl->tmpf, priv_vcl->foo, strlen(priv_vcl->foo))); |
330 |
2646 |
priv->priv = priv_vcl; |
331 |
2646 |
priv->methods = priv_vcl_methods; |
332 |
|
|
333 |
2646 |
debug_add_filters(ctx); |
334 |
2646 |
debug_transport_init(); |
335 |
2646 |
return (0); |
336 |
2673 |
} |
337 |
|
|
338 |
|
VCL_VOID |
339 |
27 |
xyzzy_vcl_prevent_cold(VRT_CTX, struct vmod_priv *priv) |
340 |
|
{ |
341 |
|
struct priv_vcl *priv_vcl; |
342 |
|
char buf[32]; |
343 |
|
|
344 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
345 |
27 |
AN(priv); |
346 |
27 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
347 |
27 |
AZ(priv_vcl->vclref_cold); |
348 |
|
|
349 |
27 |
bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl)); |
350 |
27 |
priv_vcl->vclref_cold = VRT_VCL_Prevent_Cold(ctx, buf); |
351 |
27 |
} |
352 |
|
|
353 |
|
VCL_VOID |
354 |
27 |
xyzzy_vcl_allow_cold(VRT_CTX, struct vmod_priv *priv) |
355 |
|
{ |
356 |
|
struct priv_vcl *priv_vcl; |
357 |
|
|
358 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
359 |
27 |
AN(priv); |
360 |
27 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
361 |
27 |
AN(priv_vcl->vclref_cold); |
362 |
27 |
VRT_VCL_Allow_Cold(&priv_vcl->vclref_cold); |
363 |
27 |
} |
364 |
|
|
365 |
|
VCL_VOID |
366 |
0 |
xyzzy_cold_backend(VRT_CTX, struct vmod_priv *priv) |
367 |
|
{ |
368 |
|
struct priv_vcl *priv_vcl; |
369 |
|
|
370 |
0 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
371 |
0 |
AN(priv); |
372 |
0 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
373 |
0 |
priv_vcl->cold_be = 1; |
374 |
0 |
} |
375 |
|
|
376 |
|
VCL_VOID |
377 |
0 |
xyzzy_cooling_backend(VRT_CTX, struct vmod_priv *priv) |
378 |
|
{ |
379 |
|
struct priv_vcl *priv_vcl; |
380 |
|
|
381 |
0 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
382 |
0 |
AN(priv); |
383 |
0 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
384 |
0 |
priv_vcl->cooling_be = 1; |
385 |
0 |
} |
386 |
|
|
387 |
|
static const struct vdi_methods empty_methods[1] = {{ |
388 |
|
.magic = VDI_METHODS_MAGIC, |
389 |
|
.type = "debug.dummy" |
390 |
|
}}; |
391 |
|
|
392 |
|
static int |
393 |
2403 |
event_warm(VRT_CTX, const struct vmod_priv *priv) |
394 |
|
{ |
395 |
|
struct priv_vcl *priv_vcl; |
396 |
|
char buf[32]; |
397 |
2403 |
const char *vcl_name = VCL_Name(ctx->vcl); |
398 |
|
|
399 |
|
// Using VSLs for coverage |
400 |
2403 |
VSLs(SLT_Debug, NO_VXID, TOSTRANDS(2, vcl_name, ": VCL_EVENT_WARM")); |
401 |
|
|
402 |
2403 |
AN(ctx->msg); |
403 |
2403 |
if (cache_param->max_esi_depth == 42) { |
404 |
81 |
VSB_cat(ctx->msg, "max_esi_depth is not the answer."); |
405 |
81 |
return (-1); |
406 |
|
} |
407 |
|
|
408 |
2322 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
409 |
2322 |
AZ(priv_vcl->vclref_discard); |
410 |
|
|
411 |
2322 |
if (!priv_vcl->cold_be) { |
412 |
|
/* NB: set up a COOLING step unless we want a COLD backend. */ |
413 |
2322 |
bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl)); |
414 |
2322 |
priv_vcl->vclref_discard = VRT_VCL_Prevent_Discard(ctx, buf); |
415 |
2322 |
} |
416 |
|
|
417 |
2322 |
AZ(priv_vcl->be); |
418 |
2322 |
priv_vcl->be = VRT_AddDirector(ctx, empty_methods, |
419 |
|
NULL, "%s", "dir_warmcold"); |
420 |
|
|
421 |
2322 |
return (0); |
422 |
2403 |
} |
423 |
|
|
424 |
|
static void* |
425 |
27 |
cooldown_thread(void *priv) |
426 |
|
{ |
427 |
|
struct priv_vcl *priv_vcl; |
428 |
|
|
429 |
27 |
CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC); |
430 |
27 |
AN(priv_vcl->vclref_discard); |
431 |
|
|
432 |
27 |
VTIM_sleep(priv_vcl->vcl_discard_delay); |
433 |
27 |
VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard); |
434 |
27 |
return (NULL); |
435 |
|
} |
436 |
|
|
437 |
|
static VCL_BACKEND |
438 |
0 |
create_cold_backend(VRT_CTX) |
439 |
|
{ |
440 |
|
struct vrt_endpoint vep[1]; |
441 |
|
struct vrt_backend be[1]; |
442 |
|
|
443 |
0 |
INIT_OBJ(vep, VRT_ENDPOINT_MAGIC); |
444 |
0 |
vep->uds_path = "/"; |
445 |
0 |
INIT_OBJ(be, VRT_BACKEND_MAGIC); |
446 |
0 |
be->endpoint = vep; |
447 |
0 |
be->vcl_name = "doomed"; |
448 |
0 |
return (VRT_new_backend(ctx, be, NULL)); |
449 |
|
} |
450 |
|
|
451 |
|
static int |
452 |
375 |
event_cold(VRT_CTX, const struct vmod_priv *priv) |
453 |
|
{ |
454 |
|
pthread_t thread; |
455 |
|
struct priv_vcl *priv_vcl; |
456 |
|
|
457 |
375 |
AZ(ctx->msg); |
458 |
|
|
459 |
375 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
460 |
|
|
461 |
375 |
VSL(SLT_Debug, NO_VXID, "%s: VCL_EVENT_COLD", VCL_Name(ctx->vcl)); |
462 |
|
|
463 |
375 |
VRT_DelDirector(&priv_vcl->be); |
464 |
|
|
465 |
375 |
if (priv_vcl->cold_be) { |
466 |
0 |
AZ(priv_vcl->vclref_discard); |
467 |
0 |
priv_vcl->be = create_cold_backend(ctx); |
468 |
0 |
WRONG("unreachable"); |
469 |
0 |
} |
470 |
|
|
471 |
375 |
if (priv_vcl->cooling_be) { |
472 |
0 |
AN(priv_vcl->vclref_discard); |
473 |
0 |
priv_vcl->be = create_cold_backend(ctx); |
474 |
0 |
AZ(priv_vcl->be); |
475 |
0 |
} |
476 |
|
|
477 |
375 |
if (priv_vcl->vcl_discard_delay == 0.0) { |
478 |
348 |
AN(priv_vcl->vclref_discard); |
479 |
348 |
VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard); |
480 |
348 |
return (0); |
481 |
|
} |
482 |
|
|
483 |
27 |
PTOK(pthread_create(&thread, NULL, cooldown_thread, priv_vcl)); |
484 |
27 |
PTOK(pthread_detach(thread)); |
485 |
27 |
return (0); |
486 |
375 |
} |
487 |
|
|
488 |
|
static int |
489 |
621 |
event_discard(VRT_CTX, void *priv) |
490 |
|
{ |
491 |
|
|
492 |
621 |
(void)priv; |
493 |
|
|
494 |
621 |
AZ(ctx->msg); |
495 |
|
|
496 |
621 |
debug_remove_filters(ctx); |
497 |
|
|
498 |
621 |
if (--loads) |
499 |
405 |
return (0); |
500 |
|
|
501 |
|
/* |
502 |
|
* The vsc and vsc_seg variables are not per-VCL, they are |
503 |
|
* the same in all VCL's which import the same binary version |
504 |
|
* of this VMOD, so we should only carry out cleanup on the |
505 |
|
* last discard event. |
506 |
|
*/ |
507 |
216 |
PTOK(pthread_mutex_lock(&vsc_mtx)); |
508 |
216 |
if (vsc != NULL) { |
509 |
27 |
VSC_debug_Destroy(&vsc_seg); |
510 |
27 |
vsc = NULL; |
511 |
27 |
} |
512 |
216 |
PTOK(pthread_mutex_unlock(&vsc_mtx)); |
513 |
|
|
514 |
216 |
return (0); |
515 |
621 |
} |
516 |
|
|
517 |
|
int v_matchproto_(vmod_event_f) |
518 |
6072 |
xyzzy_event_function(VRT_CTX, struct vmod_priv *priv, enum vcl_event_e e) |
519 |
|
{ |
520 |
|
|
521 |
6072 |
switch (e) { |
522 |
2673 |
case VCL_EVENT_LOAD: return (event_load(ctx, priv)); |
523 |
2403 |
case VCL_EVENT_WARM: return (event_warm(ctx, priv)); |
524 |
375 |
case VCL_EVENT_COLD: return (event_cold(ctx, priv)); |
525 |
621 |
case VCL_EVENT_DISCARD: return (event_discard(ctx, priv)); |
526 |
0 |
default: WRONG("we should test all possible events"); |
527 |
0 |
} |
528 |
6072 |
} |
529 |
|
|
530 |
|
VCL_VOID v_matchproto_(td_debug_vcl_discard_delay) |
531 |
27 |
xyzzy_vcl_discard_delay(VRT_CTX, struct vmod_priv *priv, VCL_DURATION delay) |
532 |
|
{ |
533 |
|
struct priv_vcl *priv_vcl; |
534 |
|
|
535 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
536 |
27 |
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC); |
537 |
27 |
assert(delay > 0.0); |
538 |
27 |
priv_vcl->vcl_discard_delay = delay; |
539 |
27 |
} |
540 |
|
|
541 |
|
VCL_VOID v_matchproto_(td_debug_test_probe) |
542 |
0 |
xyzzy_test_probe(VRT_CTX, VCL_PROBE probe, VCL_PROBE same) |
543 |
|
{ |
544 |
|
|
545 |
0 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
546 |
0 |
CHECK_OBJ_NOTNULL(probe, VRT_BACKEND_PROBE_MAGIC); |
547 |
0 |
CHECK_OBJ_ORNULL(same, VRT_BACKEND_PROBE_MAGIC); |
548 |
0 |
AZ(same == NULL || probe == same); |
549 |
0 |
} |
550 |
|
|
551 |
|
VCL_VOID |
552 |
27 |
xyzzy_vsc_new(VRT_CTX) |
553 |
|
{ |
554 |
27 |
(void)ctx; |
555 |
27 |
PTOK(pthread_mutex_lock(&vsc_mtx)); |
556 |
27 |
if (vsc == NULL) { |
557 |
27 |
AZ(vsc_seg); |
558 |
27 |
vsc = VSC_debug_New(NULL, &vsc_seg, ""); |
559 |
27 |
} |
560 |
27 |
AN(vsc); |
561 |
27 |
AN(vsc_seg); |
562 |
27 |
PTOK(pthread_mutex_unlock(&vsc_mtx)); |
563 |
27 |
} |
564 |
|
|
565 |
|
VCL_VOID |
566 |
27 |
xyzzy_vsc_count(VRT_CTX, VCL_INT cnt) |
567 |
|
{ |
568 |
27 |
(void)ctx; |
569 |
27 |
PTOK(pthread_mutex_lock(&vsc_mtx)); |
570 |
27 |
AN(vsc); |
571 |
27 |
vsc->count += cnt; |
572 |
27 |
PTOK(pthread_mutex_unlock(&vsc_mtx)); |
573 |
27 |
} |
574 |
|
|
575 |
|
VCL_VOID |
576 |
0 |
xyzzy_vsc_destroy(VRT_CTX) |
577 |
|
{ |
578 |
0 |
(void)ctx; |
579 |
0 |
PTOK(pthread_mutex_lock(&vsc_mtx)); |
580 |
0 |
if (vsc != NULL) { |
581 |
0 |
AN(vsc_seg); |
582 |
0 |
VSC_debug_Destroy(&vsc_seg); |
583 |
0 |
} |
584 |
0 |
AZ(vsc_seg); |
585 |
0 |
vsc = NULL; |
586 |
0 |
PTOK(pthread_mutex_unlock(&vsc_mtx)); |
587 |
0 |
} |
588 |
|
|
589 |
|
struct xyzzy_debug_concat { |
590 |
|
unsigned magic; |
591 |
|
#define CONCAT_MAGIC 0x6b746493 |
592 |
|
VCL_STRING s; |
593 |
|
}; |
594 |
|
|
595 |
|
VCL_VOID |
596 |
108 |
xyzzy_concat__init(VRT_CTX, struct xyzzy_debug_concat **concatp, |
597 |
|
const char *vcl_name, VCL_STRANDS s) |
598 |
|
{ |
599 |
|
struct xyzzy_debug_concat *concat; |
600 |
108 |
size_t sz = 0; |
601 |
|
char *p; |
602 |
|
|
603 |
108 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
604 |
108 |
AN(concatp); |
605 |
108 |
AZ(*concatp); |
606 |
108 |
AN(vcl_name); |
607 |
|
|
608 |
108 |
ALLOC_OBJ(concat, CONCAT_MAGIC); |
609 |
108 |
AN(concat); |
610 |
108 |
*concatp = concat; |
611 |
|
|
612 |
324 |
for (int i = 0; i < s->n; i++) |
613 |
432 |
if (s->p[i] != NULL) |
614 |
216 |
sz += strlen(s->p[i]); |
615 |
108 |
p = malloc(sz + 1); |
616 |
108 |
AN(p); |
617 |
108 |
(void)VRT_Strands(p, sz + 1, s); |
618 |
108 |
concat->s = p; |
619 |
108 |
} |
620 |
|
|
621 |
|
VCL_VOID |
622 |
0 |
xyzzy_concat__fini(struct xyzzy_debug_concat **concatp) |
623 |
|
{ |
624 |
|
struct xyzzy_debug_concat *concat; |
625 |
|
|
626 |
|
|
627 |
0 |
TAKE_OBJ_NOTNULL(concat, concatp, CONCAT_MAGIC); |
628 |
0 |
free(TRUST_ME(concat->s)); |
629 |
0 |
FREE_OBJ(concat); |
630 |
0 |
} |
631 |
|
|
632 |
|
VCL_STRING |
633 |
54 |
xyzzy_concat_get(VRT_CTX, struct xyzzy_debug_concat *concat) |
634 |
|
{ |
635 |
54 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
636 |
54 |
CHECK_OBJ_NOTNULL(concat, CONCAT_MAGIC); |
637 |
54 |
return (concat->s); |
638 |
|
} |
639 |
|
|
640 |
|
VCL_STRING |
641 |
216 |
xyzzy_concatenate(VRT_CTX, VCL_STRANDS s) |
642 |
|
{ |
643 |
|
VCL_STRING r; |
644 |
|
|
645 |
216 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
646 |
216 |
r = VRT_StrandsWS(ctx->ws, NULL, s); |
647 |
216 |
if (r != NULL && *r != '\0') |
648 |
162 |
AN(WS_Allocated(ctx->ws, r, strlen(r) + 1)); |
649 |
216 |
return (r); |
650 |
|
} |
651 |
|
|
652 |
|
VCL_STRING |
653 |
216 |
xyzzy_collect(VRT_CTX, VCL_STRANDS s) |
654 |
|
{ |
655 |
|
VCL_STRING r; |
656 |
|
|
657 |
216 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
658 |
216 |
r = VRT_STRANDS_string(ctx, s); |
659 |
216 |
if (r != NULL && *r != '\0') |
660 |
162 |
AN(WS_Allocated(ctx->ws, r, strlen(r) + 1)); |
661 |
216 |
return (r); |
662 |
|
} |
663 |
|
|
664 |
|
/* cf. VRT_SetHdr() */ |
665 |
|
VCL_VOID |
666 |
216 |
xyzzy_sethdr(VRT_CTX, VCL_HEADER hdr, VCL_STRANDS s) |
667 |
|
{ |
668 |
|
struct http *hp; |
669 |
|
const char *b; |
670 |
|
|
671 |
216 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
672 |
216 |
if (hdr == NULL) { |
673 |
0 |
VRT_fail(ctx, "debug.sethdr(): header argument is NULL"); |
674 |
0 |
return; |
675 |
|
} |
676 |
216 |
hp = VRT_selecthttp(ctx, hdr->where); |
677 |
216 |
if (hp == NULL) { |
678 |
0 |
VRT_fail(ctx, "debug.sethdr(): header argument " |
679 |
|
"cannot be used here"); |
680 |
0 |
return; |
681 |
|
} |
682 |
216 |
AN(hdr->what); |
683 |
216 |
CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC); |
684 |
216 |
if (s->n == 0) { |
685 |
0 |
http_Unset(hp, hdr->what); |
686 |
0 |
} else { |
687 |
216 |
b = VRT_StrandsWS(hp->ws, hdr->what + 1, s); |
688 |
216 |
if (b == NULL) { |
689 |
0 |
VSLbs(ctx->vsl, SLT_LostHeader, |
690 |
0 |
TOSTRAND(hdr->what + 1)); |
691 |
0 |
} else { |
692 |
216 |
if (*b != '\0') |
693 |
216 |
AN(WS_Allocated(hp->ws, b, strlen(b) + 1)); |
694 |
216 |
http_Unset(hp, hdr->what); |
695 |
216 |
http_SetHeader(hp, b); |
696 |
|
} |
697 |
|
} |
698 |
216 |
} |
699 |
|
|
700 |
|
void |
701 |
3726 |
mylog(struct vsl_log *vsl, enum VSL_tag_e tag, const char *fmt, ...) |
702 |
|
{ |
703 |
|
va_list ap; |
704 |
|
|
705 |
3726 |
va_start(ap, fmt); |
706 |
3726 |
if (vsl != NULL) |
707 |
3213 |
VSLbv(vsl, tag, fmt, ap); |
708 |
|
else |
709 |
513 |
VSLv(tag, NO_VXID, fmt, ap); |
710 |
3726 |
va_end(ap); |
711 |
3726 |
} |
712 |
|
|
713 |
|
VCL_DURATION |
714 |
108 |
xyzzy_priv_perf(VRT_CTX, VCL_INT size, VCL_INT rounds) |
715 |
|
{ |
716 |
|
vtim_mono t0, t1; |
717 |
|
vtim_dur d; |
718 |
|
struct vmod_priv *p; |
719 |
|
VCL_INT s, r; |
720 |
108 |
uintptr_t check = 0; |
721 |
|
|
722 |
108 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
723 |
|
|
724 |
30105 |
for (s = 1; s <= size; s++) { |
725 |
29997 |
p = VRT_priv_task(ctx, (void *)(uintptr_t)s); |
726 |
29997 |
if (p == NULL) { |
727 |
0 |
VRT_fail(ctx, "no priv task - out of ws?"); |
728 |
0 |
return (-1.0); |
729 |
|
} |
730 |
29997 |
p->priv = NULL; |
731 |
29997 |
} |
732 |
|
|
733 |
108 |
t0 = VTIM_mono(); |
734 |
1080108 |
for (r = 0; r < rounds; r++) { |
735 |
301050000 |
for (s = 1; s <= size; s++) { |
736 |
299970000 |
p = VRT_priv_task_get(ctx, (void *)(uintptr_t)s); |
737 |
299970000 |
AN(p); |
738 |
299970000 |
check += (uintptr_t)p->priv; |
739 |
299970000 |
p->priv = (void *)(uintptr_t)(s * rounds + r); |
740 |
299970000 |
} |
741 |
1080000 |
} |
742 |
108 |
t1 = VTIM_mono(); |
743 |
|
|
744 |
108 |
d = (t1 - t0) * 1e9 / ((double)size * (double)rounds); |
745 |
|
|
746 |
216 |
mylog(ctx->vsl, SLT_Debug, |
747 |
|
"perf size %jd rounds %jd time %.1fns check %jd", |
748 |
108 |
(intmax_t)size, (intmax_t)rounds, d, (uintmax_t)check); |
749 |
|
|
750 |
108 |
return (d); |
751 |
108 |
} |
752 |
|
|
753 |
|
VCL_STRANDS |
754 |
243 |
xyzzy_return_strands(VRT_CTX, VCL_STRANDS strand) |
755 |
|
{ |
756 |
|
|
757 |
243 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
758 |
243 |
if (ctx->vsl) |
759 |
108 |
VSLbs(ctx->vsl, SLT_Debug, strand); |
760 |
|
else |
761 |
135 |
VSLs(SLT_Debug, NO_VXID, strand); |
762 |
243 |
return (strand); |
763 |
|
} |
764 |
|
|
765 |
|
VCL_STRANDS |
766 |
27 |
xyzzy_return_null_strands(VRT_CTX) |
767 |
|
{ |
768 |
27 |
(void)ctx; |
769 |
27 |
return (vrt_null_strands); |
770 |
|
} |
771 |
|
|
772 |
|
VCL_BOOL |
773 |
27 |
xyzzy_is_null_strands(VRT_CTX, VCL_STRANDS s) |
774 |
|
{ |
775 |
27 |
(void)ctx; |
776 |
27 |
return (s == vrt_null_strands); |
777 |
|
} |
778 |
|
|
779 |
|
VCL_VOID |
780 |
54 |
xyzzy_vsl_flush(VRT_CTX) |
781 |
|
{ |
782 |
54 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
783 |
54 |
VSL_Flush(ctx->vsl, 0); |
784 |
54 |
} |
785 |
|
|
786 |
|
/*---------------------------------------------------------------------*/ |
787 |
|
|
788 |
|
static const struct vcf_return * v_matchproto_(vcf_func_f) |
789 |
378 |
xyzzy_catflap_simple(struct req *req, struct objcore **oc, |
790 |
|
struct objcore **oc_exp, int state) |
791 |
|
{ |
792 |
|
|
793 |
378 |
CHECK_OBJ_NOTNULL(req, REQ_MAGIC); |
794 |
378 |
CHECK_OBJ_NOTNULL(req->vcf, VCF_MAGIC); |
795 |
378 |
assert(req->vcf->func == xyzzy_catflap_simple); |
796 |
|
|
797 |
378 |
(void)oc; |
798 |
378 |
(void)oc_exp; |
799 |
378 |
if (state == 0) { |
800 |
108 |
if (req->vcf->priv == VENUM(first)) |
801 |
27 |
return (VCF_HIT); |
802 |
81 |
if (req->vcf->priv == VENUM(miss)) |
803 |
81 |
return (VCF_MISS); |
804 |
0 |
WRONG("Shouldn't get here"); |
805 |
0 |
} |
806 |
270 |
return (VCF_DEFAULT); |
807 |
378 |
} |
808 |
|
|
809 |
|
static const struct vcf_return * v_matchproto_(vcf_func_f) |
810 |
162 |
xyzzy_catflap_last(struct req *req, struct objcore **oc, |
811 |
|
struct objcore **oc_exp, int state) |
812 |
|
{ |
813 |
|
|
814 |
162 |
CHECK_OBJ_NOTNULL(req, REQ_MAGIC); |
815 |
162 |
CHECK_OBJ_NOTNULL(req->vcf, VCF_MAGIC); |
816 |
162 |
assert(req->vcf->func == xyzzy_catflap_last); |
817 |
|
|
818 |
162 |
(void)oc_exp; |
819 |
162 |
if (state == 0) { |
820 |
108 |
AN(oc); |
821 |
108 |
CHECK_OBJ_NOTNULL(*oc, OBJCORE_MAGIC); |
822 |
108 |
req->vcf->priv = *oc; |
823 |
108 |
return (VCF_CONTINUE); |
824 |
|
} |
825 |
54 |
if (state == 1) { |
826 |
27 |
AN(oc); |
827 |
27 |
if (req->vcf->priv != NULL) |
828 |
27 |
CAST_OBJ_NOTNULL(*oc, req->vcf->priv, OBJCORE_MAGIC); |
829 |
27 |
return (VCF_CONTINUE); |
830 |
|
} |
831 |
27 |
return (VCF_DEFAULT); |
832 |
162 |
} |
833 |
|
|
834 |
|
VCL_VOID |
835 |
216 |
xyzzy_catflap(VRT_CTX, VCL_ENUM type) |
836 |
|
{ |
837 |
|
struct req *req; |
838 |
|
|
839 |
216 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
840 |
216 |
req = ctx->req; |
841 |
216 |
CHECK_OBJ_NOTNULL(req, REQ_MAGIC); |
842 |
216 |
XXXAZ(req->vcf); |
843 |
432 |
WS_TASK_ALLOC_OBJ(ctx, req->vcf, VCF_MAGIC); |
844 |
216 |
if (req->vcf == NULL) |
845 |
0 |
return; |
846 |
216 |
if (type == VENUM(first) || type == VENUM(miss)) { |
847 |
189 |
req->vcf->func = xyzzy_catflap_simple; |
848 |
189 |
req->vcf->priv = TRUST_ME(type); |
849 |
216 |
} else if (type == VENUM(last)) { |
850 |
27 |
req->vcf->func = xyzzy_catflap_last; |
851 |
27 |
} else { |
852 |
0 |
WRONG("Wrong VENUM"); |
853 |
|
} |
854 |
216 |
} |
855 |
|
|
856 |
|
VCL_BYTES |
857 |
0 |
xyzzy_stk(VRT_CTX) |
858 |
|
{ |
859 |
0 |
const VCL_BYTES max = 100 * 1024 * 1024; |
860 |
|
const char *a, *b; |
861 |
|
VCL_BYTES r; |
862 |
|
|
863 |
0 |
a = TRUST_ME(&b); |
864 |
0 |
b = TRUST_ME(ctx->req->wrk); |
865 |
0 |
b += sizeof(*ctx->req->wrk); |
866 |
|
|
867 |
0 |
if (b > a && (r = b - a) < max) |
868 |
0 |
return (r); |
869 |
0 |
if (a > b && (r = a - b) < max) |
870 |
0 |
return (r); |
871 |
|
|
872 |
0 |
return (0); |
873 |
0 |
} |
874 |
|
|
875 |
|
VCL_VOID |
876 |
216 |
xyzzy_sndbuf(VRT_CTX, VCL_BYTES arg) |
877 |
|
{ |
878 |
216 |
int fd = -1, oldbuf, newbuf, buflen; |
879 |
216 |
socklen_t intlen = sizeof(int); |
880 |
|
|
881 |
216 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
882 |
|
|
883 |
216 |
if (ctx->bo) { |
884 |
0 |
CHECK_OBJ(ctx->bo, BUSYOBJ_MAGIC); |
885 |
0 |
INCOMPL(); |
886 |
0 |
} |
887 |
216 |
else if (ctx->req) { |
888 |
216 |
CHECK_OBJ(ctx->req, REQ_MAGIC); |
889 |
216 |
CHECK_OBJ(ctx->req->sp, SESS_MAGIC); |
890 |
216 |
fd = ctx->req->sp->fd; |
891 |
216 |
} |
892 |
|
else { |
893 |
0 |
VRT_fail(ctx, "debug.sndbuf() called outside a transaction."); |
894 |
0 |
return; |
895 |
|
} |
896 |
|
|
897 |
216 |
xxxassert(fd >= 0); |
898 |
|
|
899 |
216 |
if (arg > INT_MAX) |
900 |
0 |
buflen = INT_MAX; |
901 |
216 |
else if (arg <= 0) |
902 |
0 |
buflen = 0; |
903 |
|
else |
904 |
216 |
buflen = (int)arg; |
905 |
|
|
906 |
216 |
oldbuf = 0; |
907 |
216 |
AZ(getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &oldbuf, &intlen)); |
908 |
|
|
909 |
216 |
newbuf = buflen; |
910 |
216 |
AZ(setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &newbuf, intlen)); |
911 |
216 |
AZ(getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &newbuf, &intlen)); |
912 |
|
|
913 |
216 |
AN(ctx->vsl); |
914 |
432 |
VSLb(ctx->vsl, SLT_Debug, "SO_SNDBUF fd=%d old=%d new=%d actual=%d", |
915 |
216 |
fd, oldbuf, buflen, newbuf); |
916 |
216 |
} |
917 |
|
|
918 |
|
VCL_VOID |
919 |
378 |
xyzzy_store_ip(VRT_CTX, VCL_IP ip) |
920 |
|
{ |
921 |
|
struct vmod_priv *priv; |
922 |
|
|
923 |
378 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
924 |
|
|
925 |
378 |
priv = VRT_priv_task(ctx, &store_ip_token); |
926 |
378 |
if (priv == NULL) { |
927 |
0 |
VRT_fail(ctx, "no priv task - out of ws?"); |
928 |
0 |
return; |
929 |
|
} |
930 |
|
|
931 |
378 |
AZ(priv->methods); |
932 |
378 |
assert(VSA_Sane(ip)); |
933 |
378 |
priv->priv = TRUST_ME(ip); |
934 |
378 |
} |
935 |
|
|
936 |
|
VCL_IP |
937 |
756 |
xyzzy_get_ip(VRT_CTX) |
938 |
|
{ |
939 |
|
struct vmod_priv *priv; |
940 |
|
VCL_IP ip; |
941 |
|
|
942 |
756 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
943 |
|
|
944 |
756 |
priv = VRT_priv_task_get(ctx, &store_ip_token); |
945 |
756 |
AN(priv); |
946 |
756 |
AZ(priv->methods); |
947 |
|
|
948 |
756 |
ip = priv->priv; |
949 |
756 |
assert(VSA_Sane(ip)); |
950 |
756 |
return (ip); |
951 |
|
} |
952 |
|
|
953 |
|
/*---------------------------------------------------------------------*/ |
954 |
|
|
955 |
|
struct VPFX(debug_director) { |
956 |
|
unsigned magic; |
957 |
|
#define VMOD_DEBUG_DIRECTOR_MAGIC 0x66b9ff3d |
958 |
|
VCL_BACKEND dir; |
959 |
|
}; |
960 |
|
|
961 |
|
/* XXX more callbacks ? */ |
962 |
|
static vdi_healthy_f vmod_debug_director_healthy; |
963 |
|
static vdi_resolve_f vmod_debug_director_resolve; |
964 |
|
|
965 |
|
static const struct vdi_methods vmod_debug_director_methods[1] = {{ |
966 |
|
.magic = VDI_METHODS_MAGIC, |
967 |
|
.type = "debug.director", |
968 |
|
.resolve = vmod_debug_director_resolve, |
969 |
|
.healthy = vmod_debug_director_healthy |
970 |
|
}}; |
971 |
|
|
972 |
|
VCL_VOID v_matchproto_(td_xyzzy_debug_director__init) |
973 |
27 |
xyzzy_director__init(VRT_CTX, struct VPFX(debug_director) **dp, |
974 |
|
const char *vcl_name) |
975 |
|
{ |
976 |
|
struct VPFX(debug_director) *d; |
977 |
|
|
978 |
27 |
AN(dp); |
979 |
27 |
AZ(*dp); |
980 |
27 |
ALLOC_OBJ(d, VMOD_DEBUG_DIRECTOR_MAGIC); |
981 |
27 |
AN(d); |
982 |
|
|
983 |
27 |
*dp = d; |
984 |
54 |
d->dir = VRT_AddDirector(ctx, vmod_debug_director_methods, d, |
985 |
27 |
"%s", vcl_name); |
986 |
27 |
} |
987 |
|
|
988 |
|
VCL_VOID v_matchproto_(td_xyzzy_debug_director__fini) |
989 |
0 |
xyzzy_director__fini(struct VPFX(debug_director) **dp) |
990 |
|
{ |
991 |
|
struct VPFX(debug_director) *d; |
992 |
|
|
993 |
0 |
TAKE_OBJ_NOTNULL(d, dp, VMOD_DEBUG_DIRECTOR_MAGIC); |
994 |
0 |
VRT_DelDirector(&d->dir); |
995 |
0 |
FREE_OBJ(d); |
996 |
0 |
} |
997 |
|
|
998 |
|
VCL_BACKEND v_matchproto_(td_xyzzy_debug_director_fail) |
999 |
54 |
xyzzy_director_fail(VRT_CTX, struct VPFX(debug_director) *d) |
1000 |
|
{ |
1001 |
54 |
CHECK_OBJ_NOTNULL(d, VMOD_DEBUG_DIRECTOR_MAGIC); |
1002 |
54 |
(void) ctx; |
1003 |
|
|
1004 |
54 |
return (d->dir); |
1005 |
|
} |
1006 |
|
|
1007 |
|
static VCL_BOOL v_matchproto_(vdi_healthy_f) |
1008 |
54 |
vmod_debug_director_healthy(VRT_CTX, VCL_BACKEND dir, VCL_TIME *changed) |
1009 |
|
{ |
1010 |
54 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1011 |
|
|
1012 |
54 |
(void) dir; |
1013 |
54 |
(void) changed; |
1014 |
|
|
1015 |
54 |
VRT_fail(ctx, "fail"); |
1016 |
54 |
return (1); |
1017 |
|
} |
1018 |
|
|
1019 |
|
static VCL_BACKEND v_matchproto_(vdi_resolve_f) |
1020 |
27 |
vmod_debug_director_resolve(VRT_CTX, VCL_BACKEND dir) |
1021 |
|
{ |
1022 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1023 |
|
|
1024 |
27 |
(void) dir; |
1025 |
|
|
1026 |
27 |
VRT_fail(ctx, "fail"); |
1027 |
27 |
return (NULL); |
1028 |
|
} |
1029 |
|
|
1030 |
|
VCL_STRING v_matchproto_(td_xyzzy_debug_client_ip) |
1031 |
27 |
xyzzy_client_ip(VRT_CTX) |
1032 |
|
{ |
1033 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1034 |
|
|
1035 |
27 |
return (SES_Get_String_Attr(ctx->sp, SA_CLIENT_IP)); |
1036 |
|
} |
1037 |
|
|
1038 |
|
VCL_STRING v_matchproto_(td_xyzzy_debug_client_port) |
1039 |
27 |
xyzzy_client_port(VRT_CTX) |
1040 |
|
{ |
1041 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1042 |
|
|
1043 |
27 |
return (SES_Get_String_Attr(ctx->sp, SA_CLIENT_PORT)); |
1044 |
|
} |
1045 |
|
|
1046 |
|
static void * fail_magic = &fail_magic; |
1047 |
|
|
1048 |
|
static void |
1049 |
81 |
fail_f(VRT_CTX, void *priv) |
1050 |
|
{ |
1051 |
|
|
1052 |
81 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1053 |
81 |
assert(priv == fail_magic); |
1054 |
|
|
1055 |
81 |
VRT_fail(ctx, "thou shalt not fini"); |
1056 |
81 |
} |
1057 |
|
|
1058 |
|
static const struct vmod_priv_methods xyzzy_fail_task_fini_methods[1] = {{ |
1059 |
|
.magic = VMOD_PRIV_METHODS_MAGIC, |
1060 |
|
.type = "debug_fail_task_fini", |
1061 |
|
.fini = fail_f |
1062 |
|
}}; |
1063 |
|
|
1064 |
|
VCL_VOID v_matchproto_(td_xyzzy_debug_fail_task_fini) |
1065 |
108 |
xyzzy_fail_task_fini(VRT_CTX) |
1066 |
|
{ |
1067 |
|
struct vmod_priv *p; |
1068 |
|
|
1069 |
108 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1070 |
|
|
1071 |
108 |
p = VRT_priv_task(ctx, &fail_task_fini_token); |
1072 |
108 |
if (p == NULL) { |
1073 |
0 |
VRT_fail(ctx, "no priv task - out of ws?"); |
1074 |
0 |
return; |
1075 |
|
} |
1076 |
|
|
1077 |
108 |
if (p->priv != NULL) { |
1078 |
0 |
assert(p->priv == fail_magic); |
1079 |
0 |
assert(p->methods == xyzzy_fail_task_fini_methods); |
1080 |
0 |
return; |
1081 |
|
} |
1082 |
|
|
1083 |
108 |
p->priv = fail_magic; |
1084 |
108 |
p->methods = xyzzy_fail_task_fini_methods; |
1085 |
108 |
} |
1086 |
|
|
1087 |
|
VCL_VOID v_matchproto_(td_xyzzy_debug_ok_task_fini) |
1088 |
27 |
xyzzy_ok_task_fini(VRT_CTX) |
1089 |
|
{ |
1090 |
|
struct vmod_priv *p; |
1091 |
|
|
1092 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1093 |
|
|
1094 |
27 |
p = VRT_priv_task(ctx, &fail_task_fini_token); |
1095 |
27 |
if (p == NULL) { |
1096 |
0 |
VRT_fail(ctx, "no priv task - out of ws?"); |
1097 |
0 |
return; |
1098 |
|
} |
1099 |
|
|
1100 |
27 |
p->priv = NULL; |
1101 |
27 |
p->methods = NULL; |
1102 |
27 |
} |
1103 |
|
|
1104 |
|
VCL_STRING v_matchproto_(td_xyzzy_debug_re_quote) |
1105 |
162 |
xyzzy_re_quote(VRT_CTX, VCL_STRING s) |
1106 |
|
{ |
1107 |
|
struct vsb vsb[1]; |
1108 |
|
char *q; |
1109 |
|
|
1110 |
162 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1111 |
162 |
CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC); |
1112 |
162 |
WS_VSB_new(vsb, ctx->ws); |
1113 |
162 |
VRE_quote(vsb, s); |
1114 |
162 |
q = WS_VSB_finish(vsb, ctx->ws, NULL); |
1115 |
162 |
if (q == NULL) |
1116 |
0 |
WS_MarkOverflow(ctx->ws); |
1117 |
162 |
return (q); |
1118 |
|
} |
1119 |
|
|
1120 |
|
VCL_STRING v_matchproto_(td_xyzzy_priv_task_with_option) |
1121 |
81 |
xyzzy_priv_task_with_option(VRT_CTX, struct VARGS(priv_task_with_option) *args) |
1122 |
|
{ |
1123 |
|
|
1124 |
81 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1125 |
81 |
AN(args->priv); |
1126 |
81 |
if (args->priv->priv == NULL && args->valid_opt) |
1127 |
27 |
args->priv->priv = WS_Copy(ctx->ws, args->opt, -1); |
1128 |
81 |
return (args->priv->priv); |
1129 |
|
} |
1130 |
|
|
1131 |
|
VCL_BOOL v_matchproto_(td_xyzzy_validhdr) |
1132 |
54 |
xyzzy_validhdr(VRT_CTX, VCL_STRANDS s) |
1133 |
|
{ |
1134 |
54 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1135 |
54 |
return (VRT_ValidHdr(ctx, s)); |
1136 |
|
} |
1137 |
|
|
1138 |
|
VCL_REGEX v_matchproto_(td_xyzzy_regex) |
1139 |
162 |
xyzzy_just_return_regex(VRT_CTX, VCL_REGEX r) |
1140 |
|
{ |
1141 |
|
|
1142 |
162 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1143 |
162 |
AN(r); |
1144 |
162 |
return (r); |
1145 |
|
} |
1146 |
|
|
1147 |
|
/*---------------------------------------------------------------------*/ |
1148 |
|
|
1149 |
|
VCL_VOID v_matchproto_(td_xyzzy_call) |
1150 |
324 |
xyzzy_call(VRT_CTX, VCL_SUB sub) |
1151 |
|
{ |
1152 |
324 |
VRT_call(ctx, sub); |
1153 |
324 |
} |
1154 |
|
|
1155 |
|
VCL_STRING v_matchproto_(td_xyzzy_check_call) |
1156 |
27 |
xyzzy_check_call(VRT_CTX, VCL_SUB sub) |
1157 |
|
{ |
1158 |
27 |
return (VRT_check_call(ctx, sub)); |
1159 |
|
} |
1160 |
|
|
1161 |
|
/* the next two are to test WRONG vmod behavior: |
1162 |
|
* holding a VCL_SUB reference across vcls |
1163 |
|
*/ |
1164 |
|
|
1165 |
|
static VCL_SUB wrong = NULL; |
1166 |
|
|
1167 |
|
VCL_VOID v_matchproto_(td_xyzzy_bad_memory) |
1168 |
0 |
xyzzy_bad_memory(VRT_CTX, VCL_SUB sub) |
1169 |
|
{ |
1170 |
0 |
(void) ctx; |
1171 |
|
|
1172 |
0 |
wrong = sub; |
1173 |
0 |
} |
1174 |
|
|
1175 |
|
VCL_SUB v_matchproto_(td_xyzzy_total_recall) |
1176 |
0 |
xyzzy_total_recall(VRT_CTX) |
1177 |
|
{ |
1178 |
0 |
(void) ctx; |
1179 |
|
|
1180 |
0 |
return (wrong); |
1181 |
|
} |
1182 |
|
|
1183 |
|
/*---------------------------------------------------------------------*/ |
1184 |
|
|
1185 |
|
struct VPFX(debug_caller) { |
1186 |
|
unsigned magic; |
1187 |
|
#define DEBUG_CALLER_MAGIC 0xb47f3449 |
1188 |
|
VCL_SUB sub; |
1189 |
|
}; |
1190 |
|
|
1191 |
|
VCL_VOID v_matchproto_(td_xyzzy_debug_caller__init) |
1192 |
54 |
xyzzy_caller__init(VRT_CTX, struct VPFX(debug_caller) **callerp, |
1193 |
|
const char *name, VCL_SUB sub) |
1194 |
|
{ |
1195 |
|
struct VPFX(debug_caller) *caller; |
1196 |
|
|
1197 |
54 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1198 |
54 |
AN(callerp); |
1199 |
54 |
AZ(*callerp); |
1200 |
54 |
AN(name); |
1201 |
54 |
AN(sub); |
1202 |
|
|
1203 |
54 |
ALLOC_OBJ(caller, DEBUG_CALLER_MAGIC); |
1204 |
54 |
AN(caller); |
1205 |
54 |
*callerp = caller; |
1206 |
54 |
caller->sub = sub; |
1207 |
54 |
} |
1208 |
|
|
1209 |
|
VCL_VOID v_matchproto_(td_xyzzy_debug_caller__fini) |
1210 |
0 |
xyzzy_caller__fini(struct VPFX(debug_caller) **callerp) |
1211 |
|
{ |
1212 |
|
struct VPFX(debug_caller) *caller; |
1213 |
|
|
1214 |
0 |
if (callerp == NULL || *callerp == NULL) |
1215 |
0 |
return; |
1216 |
0 |
TAKE_OBJ_NOTNULL(caller, callerp, DEBUG_CALLER_MAGIC); |
1217 |
0 |
FREE_OBJ(caller); |
1218 |
0 |
} |
1219 |
|
|
1220 |
|
VCL_VOID v_matchproto_(td_xyzzy_debug_caller_call) |
1221 |
27 |
xyzzy_caller_call(VRT_CTX, struct VPFX(debug_caller) *caller) |
1222 |
|
{ |
1223 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1224 |
27 |
CHECK_OBJ_NOTNULL(caller, DEBUG_CALLER_MAGIC); |
1225 |
27 |
AN(caller->sub); |
1226 |
|
|
1227 |
27 |
VRT_call(ctx, caller->sub); |
1228 |
27 |
} |
1229 |
|
|
1230 |
|
VCL_SUB v_matchproto_(td_xyzzy_debug_caller_sub) |
1231 |
27 |
xyzzy_caller_xsub(VRT_CTX, struct VPFX(debug_caller) *caller) |
1232 |
|
{ |
1233 |
27 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1234 |
27 |
CHECK_OBJ_NOTNULL(caller, DEBUG_CALLER_MAGIC); |
1235 |
27 |
AN(caller->sub); |
1236 |
|
|
1237 |
27 |
return (caller->sub); |
1238 |
|
} |
1239 |
|
|
1240 |
|
struct resolve_priv { |
1241 |
|
struct vsb vsb[1]; |
1242 |
|
const char *fail_port; |
1243 |
|
const char *errp[1]; |
1244 |
|
}; |
1245 |
|
|
1246 |
|
static int v_matchproto_(vus_resolved_f) |
1247 |
1242 |
resolve_cb(void *priv, const struct suckaddr *sa) |
1248 |
|
{ |
1249 |
|
struct resolve_priv *p; |
1250 |
|
char abuf[VTCP_ADDRBUFSIZE], pbuf[VTCP_PORTBUFSIZE]; |
1251 |
|
|
1252 |
1242 |
p = (struct resolve_priv *)priv; |
1253 |
1242 |
CHECK_OBJ_NOTNULL(p->vsb, VSB_MAGIC); |
1254 |
1242 |
AN(sa); |
1255 |
1242 |
VTCP_name(sa, abuf, sizeof abuf, pbuf, sizeof pbuf); |
1256 |
1242 |
if (p->fail_port != NULL && !strcmp(p->fail_port, pbuf)) { |
1257 |
135 |
*(p->errp) = "bad port"; |
1258 |
135 |
return (-1); |
1259 |
|
} |
1260 |
1107 |
VSB_printf(p->vsb, "%s%s:%s", VSB_len(p->vsb) ? ", " : "", abuf, pbuf); |
1261 |
1107 |
return (0); |
1262 |
1242 |
} |
1263 |
|
|
1264 |
|
VCL_STRING |
1265 |
1296 |
xyzzy_resolve_range(VRT_CTX, struct VARGS(resolve_range) *args) |
1266 |
|
{ |
1267 |
|
struct resolve_priv p; |
1268 |
|
const char *def_port; |
1269 |
|
int ret; |
1270 |
|
|
1271 |
1296 |
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); |
1272 |
1296 |
if (args->addr == NULL) |
1273 |
27 |
return ("vmod-debug: s was NULL"); |
1274 |
1269 |
memset(&p, 0, sizeof p); |
1275 |
1269 |
WS_VSB_new(p.vsb, ctx->ws); |
1276 |
1269 |
p.fail_port = args->valid_fail_port ? args->fail_port : NULL; |
1277 |
1269 |
def_port = args->valid_def_port ? args->def_port : NULL; |
1278 |
1269 |
ret = VSS_resolver_range(args->addr, def_port, resolve_cb, &p, p.errp); |
1279 |
1269 |
if (ret) |
1280 |
1458 |
VSB_printf(p.vsb, "%s%s", VSB_len(p.vsb) ? ", " : "Failed: ", |
1281 |
729 |
*(p.errp)); |
1282 |
1269 |
return (WS_VSB_finish(p.vsb, ctx->ws, NULL)); |
1283 |
1296 |
} |
1284 |
|
|
1285 |
|
VCL_VOID |
1286 |
864 |
xyzzy_use_reembarking_http1(VRT_CTX) |
1287 |
|
{ |
1288 |
864 |
debug_transport_use_reembarking_http1(ctx); |
1289 |
864 |
} |