varnish-cache/bin/varnishd/cache/cache_req.c
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 6096
#include <stdio.h>
37 6096
#include <stdlib.h>
38 6096
39 6096
#include "cache_varnishd.h"
40
#include "cache_filter.h"
41
#include "cache_pool.h"
42
#include "cache_transport.h"
43
44
#include "common/heritage.h"
45
#include "vtim.h"
46
47
void
48 10917
Req_AcctLogCharge(struct VSC_main_wrk *ds, struct req *req)
49
{
50
        struct acct_req *a;
51
52 10917
        AN(ds);
53 10917
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
54
55 10917
        a = &req->acct;
56
57 10917
        if (!IS_NO_VXID(req->vsl->wid) && !req->res_pipe) {
58 15868
                VSLb(req->vsl, SLT_ReqAcct, "%ju %ju %ju %ju %ju %ju",
59 7934
                    (uintmax_t)a->req_hdrbytes,
60 7934
                    (uintmax_t)a->req_bodybytes,
61 7934
                    (uintmax_t)(a->req_hdrbytes + a->req_bodybytes),
62 7934
                    (uintmax_t)a->resp_hdrbytes,
63 7934
                    (uintmax_t)a->resp_bodybytes,
64 7934
                    (uintmax_t)(a->resp_hdrbytes + a->resp_bodybytes));
65 7934
        }
66
67 10917
        if (IS_TOPREQ(req)) {
68
#define ACCT(foo) ds->s_##foo += a->foo;
69
#include "tbl/acct_fields_req.h"
70
        }
71 10917
        memset(a, 0, sizeof *a);
72 10917
}
73
74
void
75 2336
Req_LogHit(struct worker *wrk, struct req *req, struct objcore *oc,
76
    intmax_t fetch_progress)
77
{
78
        const char *clen, *sep;
79
80 2336
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
81 2336
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
82 2336
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
83
84 2336
        if (fetch_progress >= 0) {
85 204
                clen = HTTP_GetHdrPack(wrk, oc, H_Content_Length);
86 204
                if (clen == NULL)
87 21
                        clen = sep = "";
88
                else
89 183
                        sep = " ";
90 408
                VSLb(req->vsl, SLT_Hit, "%ju %.6f %.6f %.6f %jd%s%s",
91 204
                    VXID(ObjGetXID(wrk, oc)), EXP_Dttl(req, oc),
92 204
                    oc->grace, oc->keep,
93 204
                    fetch_progress, sep, clen);
94 204
        } else {
95 4264
                VSLb(req->vsl, SLT_Hit, "%ju %.6f %.6f %.6f",
96 2132
                    VXID(ObjGetXID(wrk, oc)), EXP_Dttl(req, oc),
97 2132
                    oc->grace, oc->keep);
98
        }
99 2336
}
100
101
const char *
102 7696
Req_LogStart(const struct worker *wrk, struct req *req)
103
{
104
        const char *ci, *cp, *endpname;
105
106 7696
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
107 7696
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
108 7696
        CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);
109
110 7696
        ci = SES_Get_String_Attr(req->sp, SA_CLIENT_IP);
111 7696
        cp = SES_Get_String_Attr(req->sp, SA_CLIENT_PORT);
112 7696
        CHECK_OBJ_NOTNULL(req->sp->listen_sock, LISTEN_SOCK_MAGIC);
113 7696
        endpname = req->sp->listen_sock->name;
114 7696
        AN(endpname);
115 7696
        VSLb(req->vsl, SLT_ReqStart, "%s %s %s", ci, cp, endpname);
116
117 7696
        return (ci);
118
}
119
120
/*--------------------------------------------------------------------
121
 * Alloc/Free a request
122
 */
123
124
struct req *
125 6115
Req_New(struct sess *sp, const struct req *preq)
126
{
127
        struct pool *pp;
128
        struct req *req;
129
        uint16_t nhttp;
130
        unsigned sz, hl;
131
        char *p, *e;
132
133 6115
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
134 6115
        pp = sp->pool;
135 6115
        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
136 6115
        CHECK_OBJ_ORNULL(preq, REQ_MAGIC);
137
138 6115
        req = MPL_Get(pp->mpl_req, &sz);
139 6115
        AN(req);
140 6115
        req->magic = REQ_MAGIC;
141 6115
        req->sp = sp;
142
143 6115
        e = (char*)req + sz;
144 6115
        p = (char*)(req + 1);
145 6115
        p = (void*)PRNDUP(p);
146 6115
        assert(p < e);
147
148 6115
        nhttp = (uint16_t)cache_param->http_max_hdr;
149 6115
        hl = HTTP_estimate(nhttp);
150
151 6115
        req->http = HTTP_create(p, nhttp, hl);
152 6115
        p += hl;
153 6115
        p = (void*)PRNDUP(p);
154 6115
        assert(p < e);
155
156 6115
        req->http0 = HTTP_create(p, nhttp, hl);
157 6115
        p += hl;
158 6115
        p = (void*)PRNDUP(p);
159 6115
        assert(p < e);
160
161 6115
        req->resp = HTTP_create(p, nhttp, hl);
162 6115
        p += hl;
163 6115
        p = (void*)PRNDUP(p);
164 6115
        assert(p < e);
165
166 6115
        sz = cache_param->vsl_buffer;
167 6115
        VSL_Setup(req->vsl, p, sz);
168 6115
        p += sz;
169 6115
        p = (void*)PRNDUP(p);
170
171 6115
        req->vfc = (void*)p;
172 6115
        INIT_OBJ(req->vfc, VFP_CTX_MAGIC);
173 6115
        p = (void*)PRNDUP(p + sizeof(*req->vfc));
174
175 6115
        req->vdc = (void*)p;
176 6115
        ZERO_OBJ(req->vdc, sizeof *req->vdc);
177 6115
        p = (void*)PRNDUP(p + sizeof(*req->vdc));
178
179 6115
        req->htc = (void*)p;
180 6115
        INIT_OBJ(req->htc, HTTP_CONN_MAGIC);
181 6115
        req->htc->doclose = SC_NULL;
182 6115
        p = (void*)PRNDUP(p + sizeof(*req->htc));
183
184 6115
        if (UNLIKELY(preq != NULL))
185 732
                req->top = preq->top;
186
        else {
187 5383
                req->top = (void*)p;
188 5383
                INIT_OBJ(req->top, REQTOP_MAGIC);
189 5383
                req->top->topreq = req;
190 5383
                p = (void*)PRNDUP(p + sizeof(*req->top));
191
        }
192
193 6115
        assert(p < e);
194
195 6115
        WS_Init(req->ws, "req", p, e - p);
196
197 6115
        req->t_first = NAN;
198 6115
        req->t_prev = NAN;
199 6115
        req->t_req = NAN;
200 6115
        req->req_step = R_STP_TRANSPORT;
201 6115
        req->doclose = SC_NULL;
202 6115
        req->max_restarts = cache_param->max_restarts;
203
204 6115
        return (req);
205
}
206
207
void
208 6096
Req_Release(struct req *req)
209
{
210
        struct sess *sp;
211
        struct pool *pp;
212
213 6096
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
214
215
        /* Make sure the request counters have all been zeroed */
216
#define ACCT(foo) \
217
        AZ(req->acct.foo);
218
#include "tbl/acct_fields_req.h"
219
220 6096
        AZ(req->vcl);
221 6096
        if (!IS_NO_VXID(req->vsl->wid))
222 4
                VSL_End(req->vsl);
223
#ifdef ENABLE_WORKSPACE_EMULATOR
224
        WS_Rollback(req->ws, 0);
225
#endif
226 6096
        TAKE_OBJ_NOTNULL(sp, &req->sp, SESS_MAGIC);
227
        pp = sp->pool;
228 6096
        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
229 6096
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
230
        MPL_AssertSane(req);
231
        VSL_Flush(req->vsl, 0);
232
        MPL_Free(pp->mpl_req, req);
233
}
234
235
/*----------------------------------------------------------------------
236
 * TODO:
237
 * - check for code duplication with cnt_recv_prep
238
 * - re-check if complete
239
 * - XXX should PRIV_TOP use vcl0?
240
 * - XXX PRIV_TOP does not get rolled back, should it for !IS_TOPREQ ?
241
 */
242
243
void
244 377
Req_Rollback(VRT_CTX)
245
{
246
        struct req *req;
247
248 377
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
249 377
        req = ctx->req;
250 377
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
251
252 377
        if (IS_TOPREQ(req))
253 372
                VCL_TaskLeave(ctx, req->top->privs);
254 377
        VCL_TaskLeave(ctx, req->privs);
255 377
        VCL_TaskEnter(req->privs);
256 377
        if (IS_TOPREQ(req))
257 372
                VCL_TaskEnter(req->top->privs);
258 377
        HTTP_Clone(req->http, req->http0);
259 377
        req->vdp_filter_list = NULL;
260 377
        req->vfp_filter_list = NULL;
261 377
        req->vcf = NULL;
262 377
        if (WS_Overflowed(req->ws))
263 20
                req->wrk->stats->ws_client_overflow++;
264 377
        AN(req->ws_req);
265 377
        WS_Rollback(req->ws, req->ws_req);
266 377
}
267
268
/*----------------------------------------------------------------------
269
 * TODO: remove code duplication with cnt_recv_prep
270
 */
271
272
void
273 8288
Req_Cleanup(struct sess *sp, struct worker *wrk, struct req *req)
274
{
275
276 8288
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
277 8288
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
278 8288
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
279 8288
        assert(sp == req->sp);
280 8288
        if (IS_TOPREQ(req))
281 7556
                AZ(req->top->vcl0);
282
283 8288
        AZ(req->director_hint);
284 8288
        req->restarts = 0;
285
286 8288
        if (req->vcl != NULL)
287 6768
                VCL_Recache(wrk, &req->vcl);
288
289
        /* Charge and log byte counters */
290 8288
        if (!IS_NO_VXID(req->vsl->wid)) {
291 7978
                Req_AcctLogCharge(wrk->stats, req);
292 7978
                if (!IS_SAME_VXID(req->vsl->wid, sp->vxid))
293 7672
                        VSL_End(req->vsl);
294
                else
295 306
                        req->vsl->wid = NO_VXID; /* ending an h2 stream 0 */
296 7978
        }
297
298 8288
        if (!isnan(req->t_prev) && req->t_prev > 0. && req->t_prev > sp->t_idle)
299 7505
                sp->t_idle = req->t_prev;
300
        else
301 783
                sp->t_idle = W_TIM_real(wrk);
302
303 8288
        req->t_first = NAN;
304 8288
        req->t_prev = NAN;
305 8288
        req->t_req = NAN;
306 8288
        req->req_body_status = NULL;
307
308 8288
        req->hash_always_miss = 0;
309 8288
        req->hash_ignore_busy = 0;
310 8288
        req->hash_ignore_vary = 0;
311 8288
        req->esi_level = 0;
312 8288
        req->is_hit = 0;
313 8288
        req->req_step = R_STP_TRANSPORT;
314 8288
        req->vcf = NULL;
315 8288
        req->doclose = SC_NULL;
316 8288
        req->htc->doclose = SC_NULL;
317 8288
        req->htc->body_status = NULL;
318
319 8288
        if (WS_Overflowed(req->ws))
320 334
                wrk->stats->ws_client_overflow++;
321
322 8288
        wrk->seen_methods = 0;
323
324 8288
        VDP_Fini(req->vdc);
325 8288
}
326
327
/*----------------------------------------------------------------------
328
 */
329
330
void v_matchproto_(vtr_req_fail_f)
331 62
Req_Fail(struct req *req, stream_close_t reason)
332
{
333 62
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
334
335 62
        AN(req->transport->req_fail);
336 62
        req->transport->req_fail(req, reason);
337 62
}