Code Coverage: vinyl-cache/bin/vinyld/cache/cache_req.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2011 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 *
30
 * Request management
31
 *
32
 */
33
34
#include "config.h"
35
36
#include <stdio.h>
37
#include <stdlib.h>
38
39
#include "cache_int.h"
40
#include "cache_filter.h"
41
#include "cache_objhead.h"
42
#include "cache_pool.h"
43
#include "cache_transport.h"
44
#include "storage/storage.h"            // stv_default
45
46
#include "common/heritage.h"
47
#include "vtim.h"
48
49
/*--------------------------------------------------------------------
50
 * Facility to keep obcore references until the end of the task across restarts
51
 */
52
53
struct ocstash {
54
        unsigned                magic;
55 7369
#define OCSTASH_MAGIC           0x242031b5
56
        uint16_t                l;
57
        uint16_t                n;
58
        struct objcore *        ocs[] v_counted_by_(l);
59
};
60
61
static void
62
ocstash_push(struct ocstash *stash, struct objcore **ocp)
63 186
{
64
65 186
        CHECK_OBJ_NOTNULL(stash, OCSTASH_MAGIC);
66 186
        assert(stash->n < stash->l);
67 186
        TAKE_OBJ_NOTNULL(stash->ocs[stash->n], ocp, OBJCORE_MAGIC);
68 186
        stash->n++;
69 186
}
70
71
static void
72
ocstash_clear(struct worker *wrk, struct ocstash *stash)
73 9243
{
74 9243
        uint16_t u;
75
76 9243
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
77 9243
        CHECK_OBJ_NOTNULL(stash, OCSTASH_MAGIC);
78 9243
        assert(stash->n <= stash->l);
79 9429
        for (u = 0; u < stash->n; u++)
80 186
                (void)HSH_DerefObjCore(wrk, &stash->ocs[u]);
81 92138
        for (; u < stash->l; u++)
82 82895
                AZ(stash->ocs[u]);
83 9243
        stash->n = 0;
84 9243
}
85
86
void
87
Req_StashObjcore(const struct req *req, struct objcore **ocp)
88 186
{
89
90 186
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
91 186
        ocstash_push(req->stash, ocp);
92 186
}
93
94
/*--------------------------------------------------------------------*/
95
96
void
97
Req_AcctLogCharge(struct VSC_main_wrk *ds, struct req *req)
98 10533
{
99 10533
        struct acct_req *a;
100
101 10533
        AN(ds);
102 10533
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
103
104 10533
        a = &req->acct;
105
106 10533
        if (!IS_NO_VXID(req->vsl->wid) && !req->res_pipe) {
107 8920
                VSLb(req->vsl, SLT_ReqAcct, "%ju %ju %ju %ju %ju %ju",
108 8920
                    (uintmax_t)a->req_hdrbytes,
109 8920
                    (uintmax_t)a->req_bodybytes,
110 8920
                    (uintmax_t)(a->req_hdrbytes + a->req_bodybytes),
111 8920
                    (uintmax_t)a->resp_hdrbytes,
112 8920
                    (uintmax_t)a->resp_bodybytes,
113 8920
                    (uintmax_t)(a->resp_hdrbytes + a->resp_bodybytes));
114 8920
        }
115
116 10533
        if (IS_TOPREQ(req)) {
117 24500
#define ACCT(foo) ds->s_##foo += a->foo;
118 6125
#include "tbl/acct_fields_req.h"
119 6125
        }
120 10533
        memset(a, 0, sizeof *a);
121 10533
}
122
123
void
124
Req_LogHit(struct worker *wrk, struct req *req, struct objcore *oc,
125
    intmax_t fetch_progress)
126 2173
{
127 2173
        const char *clen, *sep;
128
129 2173
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
130 2173
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
131 2173
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
132
133 2173
        if (fetch_progress >= 0) {
134 110
                clen = HTTP_GetHdrPack(wrk, oc, H_Content_Length);
135 110
                if (clen == NULL)
136 7
                        clen = sep = "";
137 103
                else
138 103
                        sep = " ";
139 110
                VSLb(req->vsl, SLT_Hit, "%ju %.6f %.6f %.6f %jd%s%s",
140 110
                    VXID(ObjGetXID(wrk, oc)), EXP_Dttl(req, oc),
141 110
                    oc->grace, oc->keep,
142 110
                    fetch_progress, sep, clen);
143 2063
        } else {
144 2063
                VSLb(req->vsl, SLT_Hit, "%ju %.6f %.6f %.6f",
145 2063
                    VXID(ObjGetXID(wrk, oc)), EXP_Dttl(req, oc),
146 2063
                    oc->grace, oc->keep);
147 2063
        }
148 2173
}
149
150
const char *
151
Req_LogStart(const struct worker *wrk, struct req *req)
152 8802
{
153 8802
        const char *ci, *cp, *endpname;
154
155 8802
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
156 8802
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
157 8802
        CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);
158
159 8802
        ci = SES_Get_String_Attr(req->sp, SA_CLIENT_IP);
160 8802
        cp = SES_Get_String_Attr(req->sp, SA_CLIENT_PORT);
161 8802
        CHECK_OBJ_NOTNULL(req->sp->listen_sock, LISTEN_SOCK_MAGIC);
162 8802
        endpname = req->sp->listen_sock->name;
163 8802
        AN(endpname);
164 8802
        VSLb(req->vsl, SLT_ReqStart, "%s %s %s", ci, cp, endpname);
165
166 8802
        return (ci);
167 8802
}
168
169
/*--------------------------------------------------------------------
170
 * Alloc/Free a request
171
 */
172
173
struct req *
174
Req_New(struct sess *sp, const struct req *preq)
175 7369
{
176 7369
        struct pool *pp;
177 7369
        struct req *req;
178 7369
        uint16_t l, nhttp;
179 7369
        unsigned sz, hl;
180 7369
        char *p, *e;
181
182 7369
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
183 7369
        pp = sp->pool;
184 7369
        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
185 7369
        CHECK_OBJ_ORNULL(preq, REQ_MAGIC);
186
187 7369
        req = MPL_Get(pp->mpl_req, &sz);
188 7369
        AN(req);
189 7369
        req->magic = REQ_MAGIC;
190 7369
        req->sp = sp;
191
192 7369
        e = (char*)req + sz;
193 7369
        p = (char*)(req + 1);
194 7369
        p = (void*)PRNDUP(p);
195 7369
        assert(p < e);
196
197 7369
        nhttp = (uint16_t)cache_param->http_max_hdr;
198 7369
        hl = HTTP_estimate(nhttp);
199
200 7369
        req->http = HTTP_create(p, nhttp, hl);
201 7369
        p += hl;
202 7369
        p = (void*)PRNDUP(p);
203 7369
        assert(p < e);
204
205 7369
        req->http0 = HTTP_create(p, nhttp, hl);
206 7369
        p += hl;
207 7369
        p = (void*)PRNDUP(p);
208 7369
        assert(p < e);
209
210 7369
        req->resp = HTTP_create(p, nhttp, hl);
211 7369
        p += hl;
212 7369
        p = (void*)PRNDUP(p);
213 7369
        assert(p < e);
214
215 7369
        sz = cache_param->vsl_buffer;
216 7369
        VSL_Init(req->vsl, p, sz);
217 7369
        p += sz;
218 7369
        p = (void*)PRNDUP(p);
219
220 7369
        req->vfc = (void*)p;
221 7369
        INIT_OBJ(req->vfc, VFP_CTX_MAGIC);
222 7369
        p = (void*)PRNDUP(p + sizeof(*req->vfc));
223
224 7369
        req->vdc = (void*)p;
225 7369
        ZERO_OBJ(req->vdc, sizeof *req->vdc);
226 7369
        p = (void*)PRNDUP(p + sizeof(*req->vdc));
227
228 7369
        req->htc = (void*)p;
229 7369
        INIT_OBJ(req->htc, HTTP_CONN_MAGIC);
230 7369
        req->htc->doclose = SC_NULL;
231 7369
        p = (void*)PRNDUP(p + sizeof(*req->htc));
232
233 7369
        if (UNLIKELY(preq != NULL))
234 4407
                req->top = preq->top;
235 2962
        else {
236 2962
                req->top = (void*)p;
237 2962
                INIT_OBJ(req->top, REQTOP_MAGIC);
238 2962
                req->top->topreq = req;
239 2962
                p = (void*)PRNDUP(p + sizeof(*req->top));
240 2962
        }
241
242 7369
        req->max_restarts = cache_param->max_restarts;
243 7369
        assert(req->max_restarts + 1 <= UINT16_MAX);
244
        // each restart may ref one stale_oc and one oc
245 7369
        l = (2 * req->max_restarts) + 1;
246 7369
        sz = SIZEOF_FLEX_OBJ(req->stash, ocs, l);
247 7369
        req->stash = (void*)p;
248 7369
        req->stash->magic = OCSTASH_MAGIC;
249 7369
        req->stash->l = l;
250 7369
        p += sz;
251 7369
        p = (void*)PRNDUP(p);
252
253 7369
        assert(p < e);
254
255 7369
        WS_Init(req->ws, "req", p, e - p);
256
257 7369
        req->t_first = NAN;
258 7369
        req->t_prev = NAN;
259 7369
        req->t_req = NAN;
260 7369
        req->req_step = R_STP_TRANSPORT;
261 7369
        req->doclose = SC_NULL;
262
263 7369
        return (req);
264 7369
}
265
266
void
267
Req_Release(struct req *req)
268 7365
{
269 7365
        struct sess *sp;
270 7365
        struct pool *pp;
271
272 7365
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
273
274
        /* Make sure the request counters have all been zeroed */
275 7365
#define ACCT(foo) \
276 29460
        AZ(req->acct.foo);
277 7365
#include "tbl/acct_fields_req.h"
278
279 7365
        AZ(req->vcl);
280 7365
        if (!IS_NO_VXID(req->vsl->wid))
281 2
                VSL_End(req->vsl);
282
#ifdef ENABLE_WORKSPACE_EMULATOR
283
        WS_Rollback(req->ws, 0);
284
#endif
285 7365
        TAKE_OBJ_NOTNULL(sp, &req->sp, SESS_MAGIC);
286 7365
        pp = sp->pool;
287 7365
        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
288 7365
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
289 7365
        MPL_AssertSane(req);
290 7365
        VSL_Flush(req->vsl, 0);
291 7365
        MPL_Free(pp->mpl_req, req);
292 7365
}
293
294
/*----------------------------------------------------------------------
295
 * TODO:
296
 * - check for code duplication with cnt_recv_prep
297
 * - re-check if complete
298
 * - XXX should PRIV_TOP use vcl0?
299
 * - XXX PRIV_TOP does not get rolled back, should it for !IS_TOPREQ ?
300
 */
301
302
void
303
Req_Rollback(VRT_CTX)
304 142
{
305 142
        struct req *req;
306
307 142
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
308 142
        req = ctx->req;
309 142
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
310
311 142
        if (IS_TOPREQ(req))
312 139
                VCL_TaskLeave(ctx, req->top->privs);
313 142
        VCL_TaskLeave(ctx, req->privs);
314 142
        ocstash_clear(req->wrk, req->stash);
315 142
        VCL_TaskEnter(req->privs);
316 142
        if (IS_TOPREQ(req))
317 138
                VCL_TaskEnter(req->top->privs);
318 142
        HTTP_Clone(req->http, req->http0);
319 142
        req->vdp_filter_list = NULL;
320 142
        req->vfp_filter_list = NULL;
321 142
        req->vcf = NULL;
322 142
        if (WS_Overflowed(req->ws))
323 10
                req->wrk->stats->ws_client_overflow++;
324 142
        AN(req->ws_req);
325 142
        WS_Rollback(req->ws, req->ws_req);
326 142
}
327
328
/*----------------------------------------------------------------------
329
 * TODO: remove code duplication with cnt_recv_prep
330
 */
331
332
void
333
Req_Cleanup(struct sess *sp, struct worker *wrk, struct req *req)
334 9103
{
335
336 9103
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
337 9103
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
338 9103
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
339 9103
        assert(sp == req->sp);
340 9103
        if (IS_TOPREQ(req))
341 4694
                AZ(req->top->vcl0);
342 9103
        assert(VRBT_EMPTY(req->privs));
343
344 9103
        AZ(req->director_hint);
345 9103
        req->restarts = 0;
346
347 9103
        ocstash_clear(wrk, req->stash);
348
349 9103
        if (req->vcl != NULL)
350 4280
                VCL_Recache(wrk, &req->vcl);
351
352
        /* Charge and log byte counters */
353 9103
        if (!IS_NO_VXID(req->vsl->wid)) {
354 8943
                Req_AcctLogCharge(wrk->stats, req);
355 8943
                if (!IS_SAME_VXID(req->vsl->wid, sp->vxid))
356 8785
                        VSL_End(req->vsl);
357 158
                else
358 158
                        req->vsl->wid = NO_VXID; /* ending an h2 stream 0 */
359 8943
        }
360
361 9103
        if (!isnan(req->t_prev) && req->t_prev > 0. && req->t_prev > sp->t_idle)
362 8623
                sp->t_idle = req->t_prev;
363 480
        else
364 480
                sp->t_idle = W_TIM_real(wrk);
365
366 9103
        req->t_first = NAN;
367 9103
        req->t_prev = NAN;
368 9103
        req->t_req = NAN;
369 9103
        req->req_body_status = NULL;
370
371 9103
        req->hash_always_miss = 0;
372 9103
        req->hash_ignore_busy = 0;
373 9103
        req->hash_ignore_vary = 0;
374 9103
        req->esi_level = 0;
375 9103
        req->is_hit = 0;
376 9103
        req->req_step = R_STP_TRANSPORT;
377 9103
        req->vcf = NULL;
378 9103
        req->doclose = SC_NULL;
379 9103
        req->htc->doclose = SC_NULL;
380 9103
        req->htc->body_status = NULL;
381
382 9103
        if (WS_Overflowed(req->ws))
383 168
                wrk->stats->ws_client_overflow++;
384
385 9103
        wrk->seen_methods = 0;
386
387 9103
        VDP_Fini(req->vdc);
388 9103
}
389
390
/*----------------------------------------------------------------------
391
 * response body for vcl_synth {}
392
 */
393
394
void
395
Resp_u_storage(struct req *req)
396 10
{
397
398 10
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
399 10
        HSH_DerefBoc(req->wrk, req->objcore);
400 10
        (void)HSH_DerefObjCore(req->wrk, &req->objcore);
401 10
}
402
403
int
404
Resp_l_storage(struct req *req, const struct stevedore *stv)
405 3655
{
406 3655
        int r;
407
408 3655
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
409 3655
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
410
411 3655
        if (req->objcore != NULL)
412 4
                Resp_u_storage(req);
413 3655
        AZ(req->objcore);
414 3655
        req->objcore = HSH_Private(req->wrk);
415 3655
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
416 3655
        r = STV_NewObject(req->wrk, req->objcore, stv, 0);
417 3655
        if (r == 0)
418 2
                Resp_u_storage(req);
419 3655
        return (r);
420 3655
}
421
422
423
/*----------------------------------------------------------------------
424
 */
425
426
void v_matchproto_(vtr_req_fail_f)
427
Req_Fail(struct req *req, stream_close_t reason)
428 34
{
429 34
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
430
431 34
        AN(req->transport->req_fail);
432 34
        req->transport->req_fail(req, reason);
433 34
}