varnish-cache/bin/varnishd/cache/cache_busyobj.c
0
/*-
1
 * Copyright (c) 2013-2015 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
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
 * Handle backend connections and backend request structures.
31
 *
32
 */
33
34
#include "config.h"
35
36
#include <stdlib.h>
37
38
#include "cache_varnishd.h"
39
#include "cache_filter.h"
40
#include "cache_objhead.h"
41
42
static struct mempool           *vbopool;
43
44
/*--------------------------------------------------------------------
45
 */
46
47
void
48 22197
VBO_Init(void)
49
{
50
51 44394
        vbopool = MPL_New("busyobj", &cache_param->pool_vbo,
52 22197
            &cache_param->workspace_backend);
53 22197
        AN(vbopool);
54 22197
}
55
56
/*--------------------------------------------------------------------
57
 * BusyObj handling
58
 */
59
60
static struct busyobj *
61 54350
vbo_New(void)
62
{
63
        struct busyobj *bo;
64
        unsigned sz;
65
66 54350
        bo = MPL_Get(vbopool, &sz);
67 54350
        XXXAN(bo);
68 54350
        bo->magic = BUSYOBJ_MAGIC;
69 54350
        bo->end = (char *)bo + sz;
70 54350
        return (bo);
71
}
72
73
static void
74 54300
vbo_Free(struct busyobj **bop)
75
{
76
        struct busyobj *bo;
77
78 54300
        TAKE_OBJ_NOTNULL(bo, bop, BUSYOBJ_MAGIC);
79 54300
        AZ(bo->htc);
80 54300
        MPL_Free(vbopool, bo);
81 54300
}
82
83
struct busyobj *
84 54347
VBO_GetBusyObj(const struct worker *wrk, const struct req *req)
85
{
86
        struct busyobj *bo;
87
        uint16_t nhttp;
88
        unsigned sz;
89
        char *p;
90
91 54347
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
92
93 54347
        bo = vbo_New();
94 54347
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
95
96 54347
        p = (void*)(bo + 1);
97 54347
        p = (void*)PRNDUP(p);
98 54347
        assert(p < bo->end);
99
100 54347
        nhttp = (uint16_t)cache_param->http_max_hdr;
101 54347
        sz = HTTP_estimate(nhttp);
102
103 54347
        bo->bereq0 = HTTP_create(p, nhttp, sz);
104 54347
        p += sz;
105 54347
        p = (void*)PRNDUP(p);
106 54347
        assert(p < bo->end);
107
108 54347
        bo->bereq = HTTP_create(p, nhttp, sz);
109 54347
        p += sz;
110 54347
        p = (void*)PRNDUP(p);
111 54347
        assert(p < bo->end);
112
113 54347
        bo->beresp = HTTP_create(p, nhttp, sz);
114 54347
        p += sz;
115 54347
        p = (void*)PRNDUP(p);
116 54347
        assert(p < bo->end);
117
118 54347
        sz = cache_param->vsl_buffer;
119 54347
        VSL_Setup(bo->vsl, p, sz);
120 54347
        bo->vsl->wid = VXID_Get(wrk, VSL_BACKENDMARKER);
121 54347
        p += sz;
122 54347
        p = (void*)PRNDUP(p);
123 54347
        assert(p < bo->end);
124
125 54347
        bo->vfc = (void*)p;
126 54347
        p += sizeof (*bo->vfc);
127 54347
        p = (void*)PRNDUP(p);
128 54347
        INIT_OBJ(bo->vfc, VFP_CTX_MAGIC);
129
130 54347
        WS_Init(bo->ws, "bo", p, bo->end - p);
131
132 54347
        bo->do_stream = 1;
133
134 54347
        if (req->client_identity != NULL) {
135 25
                bo->client_identity = WS_Copy(bo->ws, req->client_identity, -1);
136 25
                XXXAN(bo->client_identity);
137 25
        }
138
139 54347
        VRT_Assign_Backend(&bo->director_req, req->director_hint);
140 54347
        bo->vcl = req->vcl;
141 54347
        VCL_Ref(bo->vcl);
142
143 54347
        bo->t_first = bo->t_prev = NAN;
144
145 54347
        memcpy(bo->digest, req->digest, sizeof bo->digest);
146
147 54347
        return (bo);
148
}
149
150
void
151 54300
VBO_ReleaseBusyObj(struct worker *wrk, struct busyobj **pbo)
152
{
153
        struct busyobj *bo;
154
155 54300
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
156 54300
        TAKE_OBJ_NOTNULL(bo, pbo, BUSYOBJ_MAGIC);
157 54300
        CHECK_OBJ_ORNULL(bo->fetch_objcore, OBJCORE_MAGIC);
158
159 54300
        AZ(bo->htc);
160 54300
        AZ(bo->stale_oc);
161
162 108600
        VSLb(bo->vsl, SLT_BereqAcct, "%ju %ju %ju %ju %ju %ju",
163 54300
            (uintmax_t)bo->acct.bereq_hdrbytes,
164 54300
            (uintmax_t)bo->acct.bereq_bodybytes,
165 54300
            (uintmax_t)(bo->acct.bereq_hdrbytes + bo->acct.bereq_bodybytes),
166 54300
            (uintmax_t)bo->acct.beresp_hdrbytes,
167 54300
            (uintmax_t)bo->acct.beresp_bodybytes,
168 54300
            (uintmax_t)(bo->acct.beresp_hdrbytes + bo->acct.beresp_bodybytes));
169
170 54300
        VSL_End(bo->vsl);
171
172 54300
        AZ(bo->htc);
173
174 54300
        if (WS_Overflowed(bo->ws))
175 3850
                wrk->stats->ws_backend_overflow++;
176
177 54300
        if (bo->fetch_objcore != NULL) {
178 53525
                (void)HSH_DerefObjCore(wrk, &bo->fetch_objcore,
179
                    HSH_RUSH_POLICY);
180 53525
        }
181
182 54300
        VRT_Assign_Backend(&bo->director_req, NULL);
183 54300
        VRT_Assign_Backend(&bo->director_resp, NULL);
184 54300
        VCL_Rel(&bo->vcl);
185
#ifdef ENABLE_WORKSPACE_EMULATOR
186
        WS_Rollback(bo->ws, 0);
187
#endif
188
189 54300
        memset(&bo->retries, 0,
190
            sizeof *bo - offsetof(struct busyobj, retries));
191
192 54300
        vbo_Free(&bo);
193 54300
}