Code Coverage: vinyl-cache/bin/vinyld/cache/cache_ws.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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_int.h"
36
37 39360
#define WS_REDZONE_END          '\x15'
38
39
static const uintptr_t snap_overflowed = (uintptr_t)&snap_overflowed;
40
41
void
42
WS_Assert(const struct ws *ws)
43 1339795
{
44
45 1339795
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
46 1339795
        DSLb(DBG_WORKSPACE, "WS(%s, %p) = {%p %zu %zu %zu}",
47 1339795
            ws->id, ws, ws->s, pdiff(ws->s, ws->f),
48 1339795
            ws->r == NULL ? 0 : pdiff(ws->f, ws->r),
49 1339795
            pdiff(ws->s, ws->e));
50 1339795
        assert(ws->s != NULL);
51 1339795
        assert(PAOK(ws->s));
52 1339795
        assert(ws->e != NULL);
53 1339795
        assert(PAOK(ws->e));
54 1339795
        assert(ws->s < ws->e);
55 1339795
        assert(ws->f >= ws->s);
56 1339795
        assert(ws->f <= ws->e);
57 1339795
        assert(PAOK(ws->f));
58 1339795
        if (ws->r) {
59 456335
                assert(ws->r >= ws->f);
60 456335
                assert(ws->r <= ws->e);
61 456335
        }
62 1339795
        assert(*ws->e == WS_REDZONE_END);
63 1339795
}
64
65
int
66
WS_Allocated(const struct ws *ws, const void *ptr, ssize_t len)
67 74310
{
68 74310
        const char *p = ptr;
69
70 74310
        WS_Assert(ws);
71 74310
        if (len < 0)
72 21
                len = vstrlen(p) + 1;
73 74310
        assert(!(p > ws->f && p <= ws->e));
74 74310
        return (p >= ws->s && (p + len) <= ws->f);
75 74310
}
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
WS_Init(struct ws *ws, const char *id, void *space, unsigned len)
84 39360
{
85 39360
        unsigned l;
86
87 39360
        DSLb(DBG_WORKSPACE,
88 39360
            "WS_Init(%s, %p, %p, %u)", id, ws, space, len);
89 39360
        assert(space != NULL);
90 39360
        INIT_OBJ(ws, WS_MAGIC);
91 39360
        ws->s = space;
92 39360
        assert(PAOK(space));
93 39360
        l = PRNDDN(len - 1);
94 39360
        ws->e = ws->s + l;
95 39360
        memset(ws->e, WS_REDZONE_END, len - l);
96 39360
        ws->f = ws->s;
97 39360
        assert(id[0] & 0x20);           // cheesy islower()
98 39360
        bstrcpy(ws->id, id);
99 39360
        WS_Assert(ws);
100 39360
}
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
WS_Reset(struct ws *ws, uintptr_t pp)
113 56409
{
114 56409
        char *p;
115
116 56409
        WS_Assert(ws);
117 56409
        AN(pp);
118 56409
        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 1
        }
123 56408
        p = (char *)pp;
124 56408
        DSLb(DBG_WORKSPACE, "WS_Reset(%s, %p, %p)", ws->id, ws, p);
125 56408
        assert(ws->r == NULL);
126 56408
        assert(p >= ws->s);
127 56408
        assert(p <= ws->e);
128 56408
        ws->f = p;
129 56408
        WS_Assert(ws);
130 56408
}
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
WS_Pipeline(struct ws *ws, const void *b, const void *e, unsigned rollback)
139 10124
{
140 10124
        unsigned r, l;
141
142 10124
        WS_Assert(ws);
143
144 10124
        if (rollback)
145 7330
                WS_Rollback(ws, 0);
146
147 10124
        r = WS_ReserveAll(ws);
148
149 10124
        if (b == NULL) {
150 9783
                AZ(e);
151 9783
                return (0);
152 9783
        }
153
154 341
        AN(e);
155 341
        l = pdiff(b, e);
156 341
        if (l > r)
157 0
                return (-1);
158 341
        vmemmove(ws->f, b, l);
159 341
        return (l);
160 341
}
161
162
void *
163
WS_Alloc(struct ws *ws, unsigned bytes)
164 39827
{
165 39827
        char *r;
166
167 39827
        WS_Assert(ws);
168 39827
        assert(bytes > 0);
169 39827
        bytes = PRNDUP(bytes);
170
171 39827
        assert(ws->r == NULL);
172 39827
        if (ws->f + bytes > ws->e) {
173 343
                WS_MarkOverflow(ws);
174 343
                return (NULL);
175 343
        }
176 39484
        r = ws->f;
177 39484
        ws->f += bytes;
178 39484
        DSLb(DBG_WORKSPACE, "WS_Alloc(%s, %p, %u) = %p", ws->id, ws, bytes, r);
179 39484
        WS_Assert(ws);
180 39484
        return (r);
181 39827
}
182
183
void *
184
WS_Copy(struct ws *ws, const void *str, int len)
185 22474
{
186 22474
        char *r;
187 22474
        unsigned bytes;
188
189 22474
        WS_Assert(ws);
190 22474
        assert(ws->r == NULL);
191
192 22474
        if (len == -1)
193 449
                len = vstrlen(str) + 1;
194 22474
        assert(len > 0);
195
196 22474
        bytes = PRNDUP((unsigned)len);
197 22474
        if (ws->f + bytes > ws->e) {
198 4
                WS_MarkOverflow(ws);
199 4
                return (NULL);
200 4
        }
201 22470
        r = ws->f;
202 22470
        ws->f += bytes;
203 22470
        vmemcpy(r, str, len);
204 22470
        DSLb(DBG_WORKSPACE, "WS_Copy(%s, %p, %d) = %p", ws->id, ws, len, r);
205 22470
        WS_Assert(ws);
206 22470
        return (r);
207 22474
}
208
209
uintptr_t
210
WS_Snapshot(struct ws *ws)
211 101715
{
212
213 101715
        WS_Assert(ws);
214 101715
        assert(ws->r == NULL);
215 101715
        if (WS_Overflowed(ws)) {
216 3
                DSLb(DBG_WORKSPACE, "WS_Snapshot(%s, %p) = overflowed",
217 3
                    ws->id, ws);
218 3
                return (snap_overflowed);
219 3
        }
220 101712
        DSLb(DBG_WORKSPACE, "WS_Snapshot(%s, %p) = %p", ws->id, ws, ws->f);
221 101712
        return ((uintptr_t)ws->f);
222 101715
}
223
224
/*
225
 * WS_Release() must be called in all cases
226
 */
227
unsigned
228
WS_ReserveAll(struct ws *ws)
229 103550
{
230 103550
        unsigned b;
231
232 103550
        WS_Assert(ws);
233 103550
        assert(ws->r == NULL);
234
235 103550
        ws->r = ws->e;
236 103550
        b = pdiff(ws->f, ws->r);
237
238 103550
        WS_Assert(ws);
239 103550
        DSLb(DBG_WORKSPACE, "WS_ReserveAll(%s, %p) = %u", ws->id, ws, b);
240
241 103550
        return (b);
242 103550
}
243
244
/*
245
 * WS_Release() must be called for retval > 0 only
246
 */
247
unsigned
248
WS_ReserveSize(struct ws *ws, unsigned bytes)
249 16599
{
250 16599
        unsigned l;
251
252 16599
        WS_Assert(ws);
253 16599
        assert(ws->r == NULL);
254 16599
        assert(bytes > 0);
255
256 16599
        l = pdiff(ws->f, ws->e);
257 16599
        if (bytes > l) {
258 67
                WS_MarkOverflow(ws);
259 67
                return (0);
260 67
        }
261 16532
        ws->r = ws->f + bytes;
262 16532
        DSLb(DBG_WORKSPACE, "WS_ReserveSize(%s, %p, %u/%u) = %u", ws->id,
263 16532
            ws, bytes, l, bytes);
264 16532
        WS_Assert(ws);
265 16532
        return (bytes);
266 16599
}
267
268
void
269
WS_Release(struct ws *ws, unsigned bytes)
270 99991
{
271 99991
        WS_Assert(ws);
272 99991
        assert(bytes <= ws->e - ws->f);
273 99991
        DSLb(DBG_WORKSPACE, "WS_Release(%s, %p, %u)", ws->id, ws, bytes);
274 99991
        assert(ws->r != NULL);
275 99991
        assert(ws->f + bytes <= ws->r);
276 99991
        ws->f += PRNDUP(bytes);
277 99991
        ws->r = NULL;
278 99991
        WS_Assert(ws);
279 99991
}
280
281
void
282
WS_ReleaseP(struct ws *ws, const char *ptr)
283 20053
{
284 20053
        WS_Assert(ws);
285 20053
        DSLb(DBG_WORKSPACE, "WS_ReleaseP(%s, %p, %p (%zd))", ws->id, ws, ptr,
286 20053
            ptr - ws->f);
287 20053
        assert(ws->r != NULL);
288 20053
        assert(ptr >= ws->f);
289 20053
        assert(ptr <= ws->r);
290 20053
        ws->f += PRNDUP(ptr - ws->f);
291 20053
        ws->r = NULL;
292 20053
        WS_Assert(ws);
293 20053
}
294
295
void *
296
WS_AtOffset(const struct ws *ws, unsigned off, unsigned len)
297 50814
{
298 50814
        char *ptr;
299
300 50814
        WS_Assert(ws);
301 50814
        ptr = ws->s + off;
302 50814
        AN(WS_Allocated(ws, ptr, len));
303 50814
        return (ptr);
304 50814
}
305
306
unsigned
307
WS_ReservationOffset(const struct ws *ws)
308 11808
{
309
310 11808
        AN(ws->r);
311 11808
        return (ws->f - ws->s);
312 11808
}
313
314
/*--------------------------------------------------------------------*/
315
316
unsigned
317
WS_Dump(const struct ws *ws, char where, size_t off, void *buf, size_t len)
318 12
{
319 12
        char *b, *p;
320 12
        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 0
        default:
331 0
                errno = EINVAL;
332 0
                return (0);
333 12
        }
334
335 12
        if (p == NULL) {
336 0
                errno = EAGAIN;
337 0
                return (0);
338 0
        }
339
340 12
        p += off;
341 12
        if (p >= ws->e) {
342 0
                errno = EFAULT;
343 0
                return (0);
344 0
        }
345
346 12
        l = pdiff(p, ws->e);
347 12
        if (len <= l) {
348 12
                vmemcpy(buf, p, len);
349 12
                return (len);
350 12
        }
351
352 0
        b = buf;
353 0
        vmemcpy(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
ws_printptr(struct vsb *vsb, const char *s, const char *p)
362 63
{
363 63
        if (p >= s)
364 42
                VSB_printf(vsb, ", +%ld", (long) (p - s));
365 21
        else
366 21
                VSB_printf(vsb, ", %p", p);
367 63
}
368
369
void
370
WS_Panic(struct vsb *vsb, const struct ws *ws)
371 38
{
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 21
}