varnish-cache/bin/varnishd/cache/cache_ws.c
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2021 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 * Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.com>
7
 *
8
 * SPDX-License-Identifier: BSD-2-Clause
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions
12
 * are met:
13
 * 1. Redistributions of source code must retain the above copyright
14
 *    notice, this list of conditions and the following disclaimer.
15
 * 2. Redistributions in binary form must reproduce the above copyright
16
 *    notice, this list of conditions and the following disclaimer in the
17
 *    documentation and/or other materials provided with the distribution.
18
 *
19
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29
 * SUCH DAMAGE.
30
 *
31
 */
32
33
#include "config.h"
34
35
#include "cache_varnishd.h"
36
37
#define WS_REDZONE_END          '\x15'
38
39
static const uintptr_t snap_overflowed = (uintptr_t)&snap_overflowed;
40
41
void
42 835842
WS_Assert(const struct ws *ws)
43
{
44
45 835842
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
46 835842
        DSLb(DBG_WORKSPACE, "WS(%s, %p) = {%p %zu %zu %zu}",
47
            ws->id, ws, ws->s, pdiff(ws->s, ws->f),
48
            ws->r == NULL ? 0 : pdiff(ws->f, ws->r),
49
            pdiff(ws->s, ws->e));
50 835842
        assert(ws->s != NULL);
51 835842
        assert(PAOK(ws->s));
52 835842
        assert(ws->e != NULL);
53 835842
        assert(PAOK(ws->e));
54 835842
        assert(ws->s < ws->e);
55 835842
        assert(ws->f >= ws->s);
56 835842
        assert(ws->f <= ws->e);
57 835842
        assert(PAOK(ws->f));
58 835842
        if (ws->r) {
59 275542
                assert(ws->r >= ws->f);
60 275542
                assert(ws->r <= ws->e);
61 275542
        }
62 835842
        assert(*ws->e == WS_REDZONE_END);
63 835842
}
64
65
int
66 52158
WS_Allocated(const struct ws *ws, const void *ptr, ssize_t len)
67
{
68 52158
        const char *p = ptr;
69
70 52158
        WS_Assert(ws);
71 52158
        if (len < 0)
72 311
                len = strlen(p) + 1;
73 52158
        assert(!(p > ws->f && p <= ws->e));
74 52158
        return (p >= ws->s && (p + len) <= ws->f);
75
}
76
77
/*
78
 * NB: The id must be max 3 char and lower-case.
79
 * (upper-case the first char to indicate overflow)
80
 */
81
82
void
83 27379
WS_Init(struct ws *ws, const char *id, void *space, unsigned len)
84
{
85
        unsigned l;
86
87 27379
        DSLb(DBG_WORKSPACE,
88
            "WS_Init(%s, %p, %p, %u)", id, ws, space, len);
89 27379
        assert(space != NULL);
90 27379
        INIT_OBJ(ws, WS_MAGIC);
91 27379
        ws->s = space;
92 27379
        assert(PAOK(space));
93 27379
        l = PRNDDN(len - 1);
94 27379
        ws->e = ws->s + l;
95 27379
        memset(ws->e, WS_REDZONE_END, len - l);
96 27379
        ws->f = ws->s;
97 27379
        assert(id[0] & 0x20);           // cheesy islower()
98 27379
        bstrcpy(ws->id, id);
99 27379
        WS_Assert(ws);
100 27379
}
101
102
/*
103
 * Reset a WS to a cookie from WS_Snapshot
104
 *
105
 * for use by any code using cache.h
106
 *
107
 * does not reset the overflow bit and asserts that, if WS_Snapshot had found
108
 * the workspace overflown, the marker is intact
109
 */
110
111
void
112 44477
WS_Reset(struct ws *ws, uintptr_t pp)
113
{
114
        char *p;
115
116 44477
        WS_Assert(ws);
117 44477
        AN(pp);
118 44477
        if (pp == snap_overflowed) {
119 1
                DSLb(DBG_WORKSPACE, "WS_Reset(%s, %p, overflowed)", ws->id, ws);
120 1
                AN(WS_Overflowed(ws));
121 1
                return;
122
        }
123 44476
        p = (char *)pp;
124 44476
        DSLb(DBG_WORKSPACE, "WS_Reset(%s, %p, %p)", ws->id, ws, p);
125 44476
        assert(ws->r == NULL);
126 44476
        assert(p >= ws->s);
127 44476
        assert(p <= ws->e);
128 44476
        ws->f = p;
129 44476
        WS_Assert(ws);
130 44477
}
131
132
/*
133
 * Make a reservation and optionally pipeline a memory region that may or
134
 * may not originate from the same workspace.
135
 */
136
137
int
138 8272
WS_Pipeline(struct ws *ws, const void *b, const void *e, unsigned rollback)
139
{
140
        unsigned r, l;
141
142 8272
        WS_Assert(ws);
143
144 8272
        if (rollback)
145 6201
                WS_Rollback(ws, 0);
146
147 8272
        r = WS_ReserveAll(ws);
148
149 8272
        if (b == NULL) {
150 7940
                AZ(e);
151 7940
                return (0);
152
        }
153
154 332
        AN(e);
155 332
        l = pdiff(b, e);
156 332
        if (l > r)
157 0
                return (-1);
158 332
        memmove(ws->f, b, l);
159 332
        return (l);
160 8272
}
161
162
void *
163 17967
WS_Alloc(struct ws *ws, unsigned bytes)
164
{
165
        char *r;
166
167 17967
        WS_Assert(ws);
168 17967
        assert(bytes > 0);
169 17967
        bytes = PRNDUP(bytes);
170
171 17967
        assert(ws->r == NULL);
172 17967
        if (ws->f + bytes > ws->e) {
173 344
                WS_MarkOverflow(ws);
174 344
                return (NULL);
175
        }
176 17623
        r = ws->f;
177 17623
        ws->f += bytes;
178 17623
        DSLb(DBG_WORKSPACE, "WS_Alloc(%s, %p, %u) = %p", ws->id, ws, bytes, r);
179 17623
        WS_Assert(ws);
180 17623
        return (r);
181 17967
}
182
183
void *
184 16621
WS_Copy(struct ws *ws, const void *str, int len)
185
{
186
        char *r;
187
        unsigned bytes;
188
189 16621
        WS_Assert(ws);
190 16621
        assert(ws->r == NULL);
191
192 16621
        if (len == -1)
193 359
                len = strlen(str) + 1;
194 16621
        assert(len > 0);
195
196 16621
        bytes = PRNDUP((unsigned)len);
197 16621
        if (ws->f + bytes > ws->e) {
198 4
                WS_MarkOverflow(ws);
199 4
                return (NULL);
200
        }
201 16617
        r = ws->f;
202 16617
        ws->f += bytes;
203 16617
        memcpy(r, str, len);
204 16617
        DSLb(DBG_WORKSPACE, "WS_Copy(%s, %p, %d) = %p", ws->id, ws, len, r);
205 16617
        WS_Assert(ws);
206 16617
        return (r);
207 16621
}
208
209
uintptr_t
210 51092
WS_Snapshot(struct ws *ws)
211
{
212
213 51092
        WS_Assert(ws);
214 51092
        assert(ws->r == NULL);
215 51092
        if (WS_Overflowed(ws)) {
216 3
                DSLb(DBG_WORKSPACE, "WS_Snapshot(%s, %p) = overflowed",
217
                    ws->id, ws);
218 3
                return (snap_overflowed);
219
        }
220 51089
        DSLb(DBG_WORKSPACE, "WS_Snapshot(%s, %p) = %p", ws->id, ws, ws->f);
221 51089
        return ((uintptr_t)ws->f);
222 51092
}
223
224
/*
225
 * WS_Release() must be called in all cases
226
 */
227
unsigned
228 56710
WS_ReserveAll(struct ws *ws)
229
{
230
        unsigned b;
231
232 56710
        WS_Assert(ws);
233 56710
        assert(ws->r == NULL);
234
235 56710
        ws->r = ws->e;
236 56710
        b = pdiff(ws->f, ws->r);
237
238 56710
        WS_Assert(ws);
239 56710
        DSLb(DBG_WORKSPACE, "WS_ReserveAll(%s, %p) = %u", ws->id, ws, b);
240
241 56710
        return (b);
242
}
243
244
/*
245
 * WS_Release() must be called for retval > 0 only
246
 */
247
unsigned
248 15251
WS_ReserveSize(struct ws *ws, unsigned bytes)
249
{
250
        unsigned l;
251
252 15251
        WS_Assert(ws);
253 15251
        assert(ws->r == NULL);
254 15251
        assert(bytes > 0);
255
256 15251
        l = pdiff(ws->f, ws->e);
257 15251
        if (bytes > l) {
258 67
                WS_MarkOverflow(ws);
259 67
                return (0);
260
        }
261 15184
        ws->r = ws->f + bytes;
262 15184
        DSLb(DBG_WORKSPACE, "WS_ReserveSize(%s, %p, %u/%u) = %u", ws->id,
263
            ws, bytes, l, bytes);
264 15184
        WS_Assert(ws);
265 15184
        return (bytes);
266 15251
}
267
268
void
269 58633
WS_Release(struct ws *ws, unsigned bytes)
270
{
271 58633
        WS_Assert(ws);
272 58633
        assert(bytes <= ws->e - ws->f);
273 58633
        DSLb(DBG_WORKSPACE, "WS_Release(%s, %p, %u)", ws->id, ws, bytes);
274 58633
        assert(ws->r != NULL);
275 58633
        assert(ws->f + bytes <= ws->r);
276 58633
        ws->f += PRNDUP(bytes);
277 58633
        ws->r = NULL;
278 58633
        WS_Assert(ws);
279 58633
}
280
281
void
282 13246
WS_ReleaseP(struct ws *ws, const char *ptr)
283
{
284 13246
        WS_Assert(ws);
285 13246
        DSLb(DBG_WORKSPACE, "WS_ReleaseP(%s, %p, %p (%zd))", ws->id, ws, ptr,
286
            ptr - ws->f);
287 13246
        assert(ws->r != NULL);
288 13246
        assert(ptr >= ws->f);
289 13246
        assert(ptr <= ws->r);
290 13246
        ws->f += PRNDUP(ptr - ws->f);
291 13246
        ws->r = NULL;
292 13246
        WS_Assert(ws);
293 13246
}
294
295
void *
296 34169
WS_AtOffset(const struct ws *ws, unsigned off, unsigned len)
297
{
298
        char *ptr;
299
300 34169
        WS_Assert(ws);
301 34169
        ptr = ws->s + off;
302 34169
        AN(WS_Allocated(ws, ptr, len));
303 34169
        return (ptr);
304
}
305
306
unsigned
307 10793
WS_ReservationOffset(const struct ws *ws)
308
{
309
310 10793
        AN(ws->r);
311 10793
        return (ws->f - ws->s);
312
}
313
314
/*--------------------------------------------------------------------*/
315
316
unsigned
317 12
WS_Dump(const struct ws *ws, char where, size_t off, void *buf, size_t len)
318
{
319
        char *b, *p;
320
        size_t l;
321
322 12
        WS_Assert(ws);
323 12
        AN(buf);
324 12
        AN(len);
325
326 12
        switch (where) {
327 0
        case 's': p = ws->s; break;
328 12
        case 'f': p = ws->f; break;
329 0
        case 'r': p = ws->r; break;
330
        default:
331 0
                errno = EINVAL;
332 0
                return (0);
333
        }
334
335 12
        if (p == NULL) {
336 0
                errno = EAGAIN;
337 0
                return (0);
338
        }
339
340 12
        p += off;
341 12
        if (p >= ws->e) {
342 0
                errno = EFAULT;
343 0
                return (0);
344
        }
345
346 12
        l = pdiff(p, ws->e);
347 12
        if (len <= l) {
348 12
                memcpy(buf, p, len);
349 12
                return (len);
350
        }
351
352 0
        b = buf;
353 0
        memcpy(b, p, l);
354 0
        memset(b + l, WS_REDZONE_END, len - l);
355 0
        return (l);
356 12
}
357
358
/*--------------------------------------------------------------------*/
359
360
static inline void
361 63
ws_printptr(struct vsb *vsb, const char *s, const char *p)
362
{
363 63
        if (p >= s)
364 42
                VSB_printf(vsb, ", +%ld", (long) (p - s));
365
        else
366 21
                VSB_printf(vsb, ", %p", p);
367 63
}
368
369
void
370 38
WS_Panic(struct vsb *vsb, const struct ws *ws)
371
{
372
373 38
        if (PAN_dump_struct(vsb, ws, WS_MAGIC, "ws"))
374 17
                return;
375 21
        if (ws->id[0] != '\0' && (!(ws->id[0] & 0x20))) // cheesy islower()
376 0
                VSB_cat(vsb, "OVERFLOWED ");
377 21
        VSB_printf(vsb, "id = \"%s\",\n", ws->id);
378 21
        VSB_printf(vsb, "{s, f, r, e} = {%p", ws->s);
379 21
        ws_printptr(vsb, ws->s, ws->f);
380 21
        ws_printptr(vsb, ws->s, ws->r);
381 21
        ws_printptr(vsb, ws->s, ws->e);
382 21
        VSB_cat(vsb, "},\n");
383 21
        VSB_indent(vsb, -2);
384 21
        VSB_cat(vsb, "},\n");
385 38
}