Code Coverage: vinyl-cache/bin/vinyld/storage/storage_synth.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright 2025 UPLEX - Nils Goroll Systemoptimierung
2
 * All rights reserved.
3
 *
4
 * Author: Nils Goroll <slink@uplex.de>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 *
29
 * Special-purpose stevedore for use with transient synth objects as those
30
 * created from vcl_synth {}: Does not copy, only references on-workspace
31
 * data
32
 */
33
34
/*lint --e{801} */
35
36
#include "config.h"
37
38
#include <stdlib.h>
39
40
#include "cache/cache_int.h"
41
42
#include "cache/cache_obj.h"
43
#include "cache/cache_objhead.h"
44
45
#include "storage/storage.h"
46
#include "storage/storage_simple.h"
47
#include "storage/storage_vai.h"
48
49
#include "VSC_ssy.h"
50
51
#include "vend.h"
52
53
struct ssy_st {
54
        unsigned                        magic;
55
#define SSY_ST_MAGIC                    0x236918b3
56
        VSTAILQ_ENTRY(ssy_st)           list;
57
        struct vscarab                  scarab;
58
};
59
60
//lint -emacro({413}, SSY_ST_SIZE)
61 2538
#define SSY_ST_SIZE(cap) (offsetof(struct ssy_st, scarab) + VSCARAB_SIZE(cap))
62
63
struct ssy {
64
        unsigned                        magic;
65
#define SSY_MAGIC                       0xfb41f362
66
        unsigned                        flags;
67 5739
#define SSY_F_LEN                       1
68
        struct ws                       *ws;
69
        VSTAILQ_HEAD(,ssy_st)           head;
70
        // getattr needs to return *pointer* to len as big endian
71
        uint8_t                         len_be[sizeof(uint64_t)];
72
};
73
74
static struct VSC_ssy *stats = NULL;
75
static struct vsc_seg *vsc_seg = NULL;
76
static unsigned refcnt = 0;
77
78
static void v_matchproto_(objfree_f)
79
ssy_objfree(struct worker *wrk, struct objcore *oc)
80 2105
{
81
82 2105
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
83
        // object is on workspace, nothing to free here
84 2105
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
85 2105
        memset(oc->stobj, 0, sizeof *oc->stobj);
86 2105
        wrk->stats->n_object--;
87 2105
}
88
89
static struct ssy_st *
90
ssy_st_alloc(struct ssy *ssy)
91 2538
{
92 2538
        struct ssy_st *st;
93 2538
        const size_t cap = 8;                   // XXX GOOD?
94 2538
        const size_t sz = SSY_ST_SIZE(cap);
95
96 2538
        CHECK_OBJ_NOTNULL(ssy, SSY_MAGIC);
97 2538
        st = WS_Alloc(ssy->ws, sz);
98 2538
        if (st == NULL)
99 0
                return (st);
100 2538
        INIT_OBJ(st, SSY_ST_MAGIC);
101 2538
        VSCARAB_INIT(&st->scarab, cap);
102 2538
        VSTAILQ_INSERT_TAIL(&ssy->head, st, list);
103 2538
        return (st);
104 2538
}
105
106
/*
107
 * deliberate API violation: does not return space, but a VSCARAB
108
 *
109
 * XXX own stevedore method?
110
 */
111
static int v_matchproto_(objgetspace_f)
112
ssy_getspace(struct worker *wrk, struct objcore *oc, ssize_t *sz,
113
    uint8_t **ptr)
114 2453
{
115 2453
        struct ssy *ssy;
116 2453
        struct ssy_st *st;
117
118 2453
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
119 2453
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
120 2453
        CAST_OBJ_NOTNULL(ssy, oc->stobj->priv, SSY_MAGIC);
121 2453
        (void) sz;
122
123 2453
        st = VSTAILQ_LAST(&ssy->head, ssy_st, list);
124 2453
        CHECK_OBJ_NOTNULL(st, SSY_ST_MAGIC);
125 2453
        CHECK_OBJ_NOTNULL(&st->scarab, VSCARAB_MAGIC);
126
127 2453
        if (st->scarab.used == st->scarab.capacity)
128 433
                st = ssy_st_alloc(ssy);
129 2453
        if (st == NULL) {
130 0
                stats->c_getspace_fail++;
131 0
                return (0);
132 0
        }
133 2453
        *ptr = (void*)(&st->scarab);
134 2453
        stats->c_getspace_success++;
135 2453
        return (1);
136 2453
}
137
138
/*
139
 * VAI for ssy is really simple because we never block, hence need no
140
 * notification
141
 */
142
143
struct ssy_hdl {
144
        struct vai_hdl_preamble preamble;
145
#define SSY_HDL_MAGIC           0x07a0be62
146
        //struct ssy            *ssy;
147
        struct ssy_st           *st;
148
        struct viov             *viov;
149
};
150
151
static int
152
ssy_ai_lease(struct worker *wrk, vai_hdl vhdl, struct vscarab *dst)
153 3952
{
154 3952
        struct ssy_hdl *hdl;
155 3952
        struct viov *dviov;
156 3952
        int r = 0;
157
158 3952
        (void) wrk;
159 3952
        CAST_VAI_HDL_NOTNULL(hdl, vhdl, SSY_HDL_MAGIC);
160 3952
        VSCARAB_CHECK_NOTNULL(dst);
161
162 3952
        if (hdl->st == NULL) {
163 1974
                dst->flags |= VSCARAB_F_END;
164 1974
                return (r);
165 1974
        }
166
167 1978
        CHECK_OBJ(hdl->st, SSY_ST_MAGIC);
168 1978
        VSCARAB_CHECK(&hdl->st->scarab);
169 1978
        AN(hdl->viov);
170
171 2393
        do {
172 2393
                dviov = NULL;
173 10028
                VSCARAB_FOREACH_RESUME(hdl->viov, &hdl->st->scarab) {
174 10028
                        dviov = VSCARAB_GET(dst);
175 10028
                        if (dviov == NULL)
176 1
                                break;
177 10027
                        *dviov = *hdl->viov;
178 10027
                        dviov->lease = VAI_LEASE_NORET;
179 10027
                        r++;
180 10027
                }
181 2393
                if (dviov == NULL)
182 1
                        break;
183 2392
                if (hdl->viov == NULL) {
184 2392
                        hdl->st = VSTAILQ_NEXT(hdl->st, list);
185 2392
                        if (hdl->st == NULL)
186 1977
                                dst->flags |= VSCARAB_F_END;
187 415
                        else
188 415
                                hdl->viov = &hdl->st->scarab.s[0];
189 2392
                }
190 2392
        } while (hdl->viov != NULL);
191
192 0
        return (r);
193 1978
}
194
195
// just malloc
196
static int
197
ssy_ai_buffer(struct worker *wrk, vai_hdl vhdl, struct vscarab *scarab)
198 0
{
199 0
        struct ssy_hdl *hdl;
200 0
        struct viov *vio;
201 0
        void *p;
202 0
        int r = 0;
203
204 0
        (void) wrk;
205 0
        CAST_VAI_HDL_NOTNULL(hdl, vhdl, SSY_HDL_MAGIC);
206
207 0
        VSCARAB_FOREACH(vio, scarab)
208 0
                if (vio->iov.iov_len == 0 || vio->iov.iov_len > UINT_MAX)
209 0
                        return (-EINVAL);
210
211 0
        VSCARAB_FOREACH(vio, scarab) {
212 0
                p = malloc(vio->iov.iov_len);
213 0
                AN(p);
214 0
                vio->iov.iov_base = p;
215 0
                vio->lease = ptr2lease(p);
216 0
                r++;
217 0
        }
218 0
        return (r);
219 0
}
220
221
// just free buffers
222
static void v_matchproto_(vai_return_f)
223
ssy_ai_return(struct worker *wrk, vai_hdl vhdl, struct vscaret *scaret)
224 1978
{
225 1978
        struct ssy_hdl *hdl;
226 1978
        viov_lease_t *p;
227
228 1978
        (void) wrk;
229 1978
        CAST_VAI_HDL_NOTNULL(hdl, vhdl, SSY_HDL_MAGIC);
230 1978
        VSCARET_CHECK_NOTNULL(scaret);
231 10027
        VSCARET_FOREACH(p, scaret) {
232 10027
                 if (*p != VAI_LEASE_NORET)
233 0
                        free (lease2ptr(*p));
234 10027
        }
235 1978
        VSCARET_INIT(scaret, scaret->capacity);
236 1978
}
237
238
static void v_matchproto_(vai_fini_f)
239
ssy_ai_fini(struct worker *wrk, vai_hdl *vai_hdlp)
240 1977
{
241 1977
        struct ssy_hdl *hdl;
242
243 1977
        (void)wrk;
244 1977
        AN(vai_hdlp);
245 1977
        CAST_VAI_HDL_NOTNULL(hdl, *vai_hdlp, SSY_HDL_MAGIC);
246 1977
        *vai_hdlp = NULL;
247 1977
}
248
249
static void * v_matchproto_(objsetattr_f)
250
ssy_setattr(struct worker *wrk, struct objcore *oc, enum obj_attr attr,
251
    ssize_t len, const void *ptr)
252 0
{
253 0
        static uint64_t ignored;
254
255 0
        (void)wrk;
256 0
        (void)oc;
257 0
        assert(attr == OA_LEN);
258 0
        (void)len;
259 0
        (void)ptr;
260 0
        return (&ignored);
261 0
}
262
263
static const void * v_matchproto_(objgetattr_f)
264
ssy_getattr(struct worker *wrk, struct objcore *oc, enum obj_attr attr,
265
   ssize_t *len)
266 7837
{
267 7837
        struct ssy *ssy;
268 7837
        struct ssy_st *st;
269 7837
        struct viov *viov;
270 7837
        static const uint8_t flags = 0;
271 7837
        uint64_t l = 0;
272
273 7837
        (void)wrk;
274 7837
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
275
276 7837
        if (attr == OA_FLAGS) {
277 2099
                AZ(len);
278 2099
                return (&flags);
279 2099
        }
280
281 5738
        if (attr != OA_LEN)
282 2098
                return (NULL);
283
284 3640
        AN(len);
285 3640
        CAST_OBJ_NOTNULL(ssy, oc->stobj->priv, SSY_MAGIC);
286 3640
        assert(attr == OA_LEN);
287
288 3640
        if ((ssy->flags & SSY_F_LEN) == 0) {
289 2532
                VSTAILQ_FOREACH(st, &ssy->head, list) {
290 2532
                        VSCARAB_FOREACH(viov, &st->scarab)
291 10261
                                l += viov->iov.iov_len;
292 2532
                }
293 2099
                vbe64enc(ssy->len_be, l);
294 2099
                ssy->flags |= SSY_F_LEN;
295 2099
        }
296 3640
        *len = sizeof ssy->len_be;
297 3640
        return (ssy->len_be);
298 3640
}
299
300
static vai_hdl v_matchproto_(vai_init_f)
301
ssy_ai_init(struct worker *wrk, struct objcore *oc, struct ws *ws,
302
    vai_notify_cb *notify, void *notify_priv)
303 1977
{
304 1977
        struct ssy_hdl *hdl;
305 1977
        struct ssy *ssy;
306
307 1977
        (void)wrk;
308 1977
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
309 1977
        CAST_OBJ_NOTNULL(ssy, oc->stobj->priv, SSY_MAGIC);
310 1977
        (void)notify;
311 1977
        (void)notify_priv;
312
313 1977
        if (ws == NULL)
314 1977
                ws = ssy->ws;
315 1977
        hdl = WS_Alloc(ws, sizeof *hdl);
316 1977
        if (hdl == NULL)
317 0
                return (NULL);
318
319 1977
        INIT_VAI_HDL(hdl, SSY_HDL_MAGIC);
320 1977
        hdl->st = VSTAILQ_FIRST(&ssy->head);
321 1977
        CHECK_OBJ(hdl->st, SSY_ST_MAGIC);
322 1977
        VSCARAB_CHECK(&hdl->st->scarab);
323 1977
        hdl->viov = &hdl->st->scarab.s[0];
324
325 1977
        AN(hdl);
326 1977
        hdl->preamble.vai_lease = ssy_ai_lease;
327 1977
        hdl->preamble.vai_buffer = ssy_ai_buffer;
328 1977
        hdl->preamble.vai_return = ssy_ai_return;
329 1977
        hdl->preamble.vai_fini = ssy_ai_fini;
330 1977
        return (hdl);
331 1977
}
332
333
static const struct obj_methods ssy_methods = {
334
        .objfree        = ssy_objfree,
335
        .objiterator    = SML_iterator,
336
        .objgetspace    = ssy_getspace,
337
        .objextend      = NULL,         // don't call, asserts in cache_obj.c
338
        .objtrimstore   = NULL,
339
        .objbocdone     = NULL,
340
        .objslim        = NULL,
341
        .objgetattr     = ssy_getattr,  // only OA_LEN, OA_FLAGS, others not
342
        .objsetattr     = ssy_setattr,  // only OA_LEN, ignores value
343
        .objtouch       = NULL,
344
        .vai_init       = ssy_ai_init
345
};
346
347
static int v_matchproto_(storage_allocobj_f)
348
ssy_allocobj(struct worker *wrk, const struct stevedore *stv,
349
    struct objcore *oc, unsigned wsl)
350 2108
{
351 2108
        struct req *req;
352 2108
        struct ssy *ssy;
353
354 2108
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
355 2108
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
356 2108
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
357
358 2108
        req = THR_GetRequest();
359
360 2108
        if (wsl != 0 || req == NULL)
361 1
                goto wrong_ctx;
362
363 2107
        CHECK_OBJ(req, REQ_MAGIC);
364 2107
        if (oc != req->objcore)
365 1
                goto wrong_ctx;
366
367 2106
        ssy = WS_Alloc(req->ws, sizeof *ssy);
368 2106
        if (ssy == NULL)
369 1
                goto err;
370 2105
        INIT_OBJ(ssy, SSY_MAGIC);
371 2105
        ssy->ws = req->ws;
372 2105
        VSTAILQ_INIT(&ssy->head);
373 2105
        if (ssy_st_alloc(ssy) == NULL)
374 0
                goto err;
375 2105
        oc->stobj->stevedore = stv;
376 2105
        oc->stobj->priv = ssy;
377 2105
        stats->c_allocobj_success++;
378 2105
        return (1);
379 2
    wrong_ctx:
380 2
        VSLb(wrk->vsl, SLT_Error,
381 2
            "synth storage can only be used for resp.storage in vcl_synth {}");
382 3
    err:
383 3
        stats->c_allocobj_fail++;
384 3
        return (0);
385 2
}
386
387
static void v_matchproto_(storage_close_f)
388
ssy_close(struct stevedore *st, int warn)
389 2024
{
390
391 2024
        (void)st;
392
393 2024
        ASSERT_CLI();
394 2024
        if (warn)
395 1012
                return;
396 1012
        AN(refcnt);
397 1012
        if (--refcnt > 0)
398 0
                return;
399
400 1012
        VSC_ssy_Destroy(&vsc_seg);
401 1012
        AZ(vsc_seg);
402 1012
        stats = NULL;
403 1012
}
404
405
static void v_matchproto_(storage_open_f)
406
ssy_open(struct stevedore *st)
407 1023
{
408
409 1023
        (void)st;
410 1023
        ASSERT_CLI();
411 1023
        if (refcnt++ > 0)
412 0
                return;
413
414 1023
        stats = VSC_ssy_New(NULL, &vsc_seg, "synth");
415 1023
        AN(stats);
416 1023
}
417
418
const struct stevedore ssy_stevedore = {
419
        .magic          =       STEVEDORE_MAGIC,
420
        .name           =       "synth",
421
        .vclname        =       "storage.synth",
422
        .ident          =       "synth",
423
        .open           =       ssy_open,
424
        .close          =       ssy_close,
425
        .allocobj       =       ssy_allocobj,
426
        .methods        =       &ssy_methods
427
};