varnish-cache/bin/varnishd/storage/storage_simple.c
0
/*-
1
 * Copyright (c) 2007-2015 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
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
 */
30
31
#include "config.h"
32
33
#include "cache/cache_varnishd.h"
34
35 2717
#include "cache/cache_obj.h"
36 2215
#include "cache/cache_objhead.h"
37 514
38 356
#include "storage/storage.h"
39 2215
#include "storage/storage_simple.h"
40
41
#include "vtim.h"
42
43
/* Flags for allocating memory in sml_stv_alloc */
44
#define LESS_MEM_ALLOCED_IS_OK  1
45 3002
46 5727
// marker pointer for sml_trimstore
47
static void *trim_once = &trim_once;
48
49
/*-------------------------------------------------------------------*/
50
51
static struct storage *
52 3968
objallocwithnuke(struct worker *, const struct stevedore *, ssize_t size,
53
    int flags);
54
55
static struct storage *
56 3386
sml_stv_alloc(const struct stevedore *stv, ssize_t size, int flags)
57
{
58
        struct storage *st;
59
60 3386
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
61 3386
        AN(stv->sml_alloc);
62
63 3386
        if (!(flags & LESS_MEM_ALLOCED_IS_OK)) {
64 582
                if (size > cache_param->fetch_maxchunksize)
65 0
                        return (NULL);
66
                else
67 582
                        return (stv->sml_alloc(stv, size));
68
        }
69
70 2804
        if (size > cache_param->fetch_maxchunksize)
71 0
                size = cache_param->fetch_maxchunksize;
72
73 2804
        assert(size <= UINT_MAX);       /* field limit in struct storage */
74
75 2939
        for (;;) {
76
                /* try to allocate from it */
77 2939
                assert(size > 0);
78 2939
                st = stv->sml_alloc(stv, size);
79 2939
                if (st != NULL)
80 2793
                        break;
81
82 146
                if (size <= cache_param->fetch_chunksize)
83 11
                        break;
84
85 135
                size /= 2;
86
        }
87 2804
        CHECK_OBJ_ORNULL(st, STORAGE_MAGIC);
88 2804
        return (st);
89 3386
}
90
91
static void
92 4369
sml_stv_free(const struct stevedore *stv, struct storage *st)
93
{
94
95 4369
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
96 4369
        CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
97 4369
        if (stv->sml_free != NULL)
98 4369
                stv->sml_free(st);
99 4369
}
100
101
/*--------------------------------------------------------------------
102
 * This function is called by stevedores ->allocobj() method, which
103
 * very often will be SML_allocobj() below, to convert a slab
104
 * of storage into object which the stevedore can then register in its
105
 * internal state, before returning it to STV_NewObject().
106
 * As you probably guessed: All this for persistence.
107
 */
108
109
struct object *
110 2838
SML_MkObject(const struct stevedore *stv, struct objcore *oc, void *ptr)
111
{
112
        struct object *o;
113
114 2838
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
115 2838
        AN(stv->methods);
116 2838
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
117
118 2838
        assert(PAOK(ptr));
119
120 2838
        o = ptr;
121 2838
        INIT_OBJ(o, OBJECT_MAGIC);
122
123 2838
        VTAILQ_INIT(&o->list);
124
125 2838
        oc->stobj->stevedore = stv;
126 2838
        oc->stobj->priv = o;
127 2838
        oc->stobj->priv2 = 0;
128 2838
        return (o);
129
}
130
131
/*--------------------------------------------------------------------
132
 * This is the default ->allocobj() which all stevedores who do not
133
 * implement persistent storage can rely on.
134
 */
135
136
int v_matchproto_(storage_allocobj_f)
137 2827
SML_allocobj(struct worker *wrk, const struct stevedore *stv,
138
    struct objcore *oc, unsigned wsl)
139
{
140
        struct object *o;
141 2827
        struct storage *st = NULL;
142
        unsigned ltot;
143
144 2827
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
145 2827
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
146 2827
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
147
148 2827
        AN(stv->sml_alloc);
149
150 2827
        ltot = sizeof(*o) + PRNDUP(wsl);
151
152 2827
        do {
153 2830
                st = stv->sml_alloc(stv, ltot);
154 2830
                if (st != NULL && st->space < ltot) {
155 0
                        stv->sml_free(st);
156 0
                        st = NULL;
157 0
                }
158 2830
        } while (st == NULL && LRU_NukeOne(wrk, stv->lru));
159 2827
        if (st == NULL)
160 11
                return (0);
161
162 2816
        CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
163 2816
        o = SML_MkObject(stv, oc, st->ptr);
164 2816
        CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
165 2816
        st->len = sizeof(*o);
166 2816
        o->objstore = st;
167 2816
        return (1);
168 2827
}
169
170
void * v_matchproto_(storage_allocbuf_t)
171 269
SML_AllocBuf(struct worker *wrk, const struct stevedore *stv, size_t size,
172
    uintptr_t *ppriv)
173
{
174
        struct storage *st;
175
176 269
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
177 269
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
178 269
        AN(ppriv);
179
180 269
        if (size > UINT_MAX)
181 0
                return (NULL);
182 269
        st = objallocwithnuke(wrk, stv, size, 0);
183 269
        if (st == NULL)
184 0
                return (NULL);
185 269
        assert(st->space >= size);
186 269
        st->flags = STORAGE_F_BUFFER;
187 269
        st->len = size;
188 269
        *ppriv = (uintptr_t)st;
189 269
        return (st->ptr);
190 269
}
191
192
void v_matchproto_(storage_freebuf_t)
193 269
SML_FreeBuf(struct worker *wrk, const struct stevedore *stv, uintptr_t priv)
194
{
195
        struct storage *st;
196
197 269
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
198 269
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
199
200 269
        CAST_OBJ_NOTNULL(st, (void *)priv, STORAGE_MAGIC);
201 269
        assert(st->flags == STORAGE_F_BUFFER);
202 269
        sml_stv_free(stv, st);
203 269
}
204
205
/*---------------------------------------------------------------------
206
 */
207
208
static struct object *
209 154318
sml_getobj(struct worker *wrk, struct objcore *oc)
210
{
211
        const struct stevedore *stv;
212
        struct object *o;
213
214 154318
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
215 154318
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
216 154318
        stv = oc->stobj->stevedore;
217 154318
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
218 154318
        if (stv->sml_getobj != NULL)
219 290
                return (stv->sml_getobj(wrk, oc));
220 154028
        if (oc->stobj->priv == NULL)
221 0
                return (NULL);
222 154028
        CAST_OBJ_NOTNULL(o, oc->stobj->priv, OBJECT_MAGIC);
223 154028
        return (o);
224 154318
}
225
226
static void v_matchproto_(objslim_f)
227 3191
sml_slim(struct worker *wrk, struct objcore *oc)
228
{
229
        const struct stevedore *stv;
230
        struct object *o;
231
        struct storage *st, *stn;
232
233 3191
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
234
235 3191
        stv = oc->stobj->stevedore;
236 3191
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
237 3191
        o = sml_getobj(wrk, oc);
238 3191
        CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
239
240
#define OBJ_AUXATTR(U, l)                                       \
241
        do {                                                    \
242
                if (o->aa_##l != NULL) {                        \
243
                        sml_stv_free(stv, o->aa_##l);           \
244
                        o->aa_##l = NULL;                       \
245
                }                                               \
246
        } while (0);
247
#include "tbl/obj_attr.h"
248
249 4025
        VTAILQ_FOREACH_SAFE(st, &o->list, list, stn) {
250 834
                CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
251 834
                VTAILQ_REMOVE(&o->list, st, list);
252 834
                sml_stv_free(stv, st);
253 834
        }
254
}
255
256
static void
257 2855
sml_bocfini(const struct stevedore *stv, struct boc *boc)
258
{
259
        struct storage *st;
260
261 2855
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
262 2855
        CHECK_OBJ_NOTNULL(boc, BOC_MAGIC);
263
264 2855
        if (boc->stevedore_priv == NULL ||
265 1878
            boc->stevedore_priv == trim_once)
266 2653
                return;
267
268
        /* Free any leftovers from Trim */
269 202
        TAKE_OBJ_NOTNULL(st, &boc->stevedore_priv, STORAGE_MAGIC);
270 202
        sml_stv_free(stv, st);
271 2855
}
272
273
/*
274
 * called in two cases:
275
 * - oc->boc == NULL: cache object on LRU freed
276
 * - oc->boc != NULL: cache object replaced for backend error
277
 */
278
static void v_matchproto_(objfree_f)
279 1786
sml_objfree(struct worker *wrk, struct objcore *oc)
280
{
281
        const struct stevedore *stv;
282
        struct storage *st;
283
        struct object *o;
284
285 1786
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
286 1786
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
287 1786
        stv = oc->stobj->stevedore;
288 1786
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
289 1786
        CAST_OBJ_NOTNULL(o, oc->stobj->priv, OBJECT_MAGIC);
290
291 1786
        sml_slim(wrk, oc);
292 1786
        st = o->objstore;
293 1786
        CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
294 1786
        FINI_OBJ(o);
295
296 1786
        if (oc->boc != NULL)
297 21
                sml_bocfini(stv, oc->boc);
298 1765
        else if (stv->lru != NULL)
299 1765
                LRU_Remove(oc);
300
301 1786
        sml_stv_free(stv, st);
302
303 1786
        memset(oc->stobj, 0, sizeof oc->stobj);
304
305 1786
        wrk->stats->n_object--;
306 1786
}
307
308
static int v_matchproto_(objiterator_f)
309 2404
sml_iterator(struct worker *wrk, struct objcore *oc,
310
    void *priv, objiterate_f *func, int final)
311
{
312
        struct boc *boc;
313
        enum boc_state_e state;
314
        struct object *obj;
315
        struct storage *st;
316 2404
        struct storage *checkpoint = NULL;
317
        const struct stevedore *stv;
318 2404
        ssize_t checkpoint_len = 0;
319 2404
        ssize_t len = 0;
320 2404
        int ret = 0, ret2;
321
        ssize_t ol;
322
        ssize_t nl;
323
        ssize_t sl;
324
        void *p;
325
        ssize_t l;
326
        unsigned u;
327
328 2404
        obj = sml_getobj(wrk, oc);
329 2404
        CHECK_OBJ_NOTNULL(obj, OBJECT_MAGIC);
330 2404
        stv = oc->stobj->stevedore;
331 2404
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
332
333 2404
        boc = HSH_RefBoc(oc);
334
335 2404
        if (boc == NULL) {
336 3442
                VTAILQ_FOREACH_REVERSE_SAFE(
337
                    st, &obj->list, storagehead, list, checkpoint) {
338
339 1824
                        u = 0;
340 1824
                        if (VTAILQ_PREV(st, storagehead, list) == NULL)
341 1649
                                u |= OBJ_ITER_END;
342 1824
                        if (final)
343 765
                                u |= OBJ_ITER_FLUSH;
344 1824
                        if (ret == 0 && st->len > 0)
345 1824
                                ret = func(priv, u, st->ptr, st->len);
346 1824
                        if (final) {
347 765
                                VTAILQ_REMOVE(&obj->list, st, list);
348 765
                                sml_stv_free(stv, st);
349 1824
                        } else if (ret)
350 32
                                break;
351 1792
                }
352 1650
                return (ret);
353
        }
354
355 754
        p = NULL;
356 754
        l = 0;
357
358 754
        u = 0;
359 754
        if (boc->fetched_so_far == 0) {
360 85
                ret = func(priv, OBJ_ITER_FLUSH, NULL, 0);
361 85
                if (ret)
362 0
                        return (ret);
363 85
        }
364 2173
        while (1) {
365 2173
                ol = len;
366 2173
                nl = ObjWaitExtend(wrk, oc, ol, &state);
367 2173
                if (state == BOS_FAILED) {
368 15
                        ret = -1;
369 15
                        break;
370
                }
371 2158
                if (nl == ol) {
372 721
                        assert(state == BOS_FINISHED);
373 721
                        break;
374
                }
375 1437
                assert(nl > ol);
376 1437
                Lck_Lock(&boc->mtx);
377 1437
                AZ(VTAILQ_EMPTY(&obj->list));
378 1437
                if (checkpoint == NULL) {
379 884
                        st = VTAILQ_LAST(&obj->list, storagehead);
380 884
                        sl = 0;
381 884
                } else {
382 553
                        st = checkpoint;
383 553
                        sl = checkpoint_len;
384 553
                        ol -= checkpoint_len;
385
                }
386 1986
                while (st != NULL) {
387 1986
                        if (st->len > ol) {
388 1437
                                p = st->ptr + ol;
389 1437
                                l = st->len - ol;
390 1437
                                len += l;
391 1437
                                break;
392
                        }
393 549
                        ol -= st->len;
394 549
                        assert(ol >= 0);
395 549
                        nl -= st->len;
396 549
                        assert(nl > 0);
397 549
                        sl += st->len;
398 549
                        st = VTAILQ_PREV(st, storagehead, list);
399 549
                        if (final && checkpoint != NULL) {
400 501
                                if (checkpoint == boc->stevedore_priv)
401 0
                                        boc->stevedore_priv = trim_once;
402
                                else
403 501
                                        VTAILQ_REMOVE(&obj->list, checkpoint, list);
404 501
                                sml_stv_free(stv, checkpoint);
405 501
                        }
406 549
                        checkpoint = st;
407 549
                        checkpoint_len = sl;
408
                }
409 1437
                CHECK_OBJ_NOTNULL(obj, OBJECT_MAGIC);
410 1437
                CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
411 1437
                st = VTAILQ_PREV(st, storagehead, list);
412 1437
                if (st != NULL && st->len == 0)
413 242
                        st = NULL;
414 1437
                Lck_Unlock(&boc->mtx);
415 1437
                assert(l > 0 || state == BOS_FINISHED);
416 1437
                u = 0;
417 1437
                if (st == NULL || final)
418 1419
                        u |= OBJ_ITER_FLUSH;
419 1437
                if (st == NULL && state == BOS_FINISHED)
420 9
                        u |= OBJ_ITER_END;
421 1437
                ret = func(priv, u, p, l);
422 1437
                if (ret)
423 18
                        break;
424
        }
425 754
        HSH_DerefBoc(wrk, oc);
426 754
        if ((u & OBJ_ITER_END) == 0) {
427 745
                ret2 = func(priv, OBJ_ITER_END, NULL, 0);
428 745
                if (ret == 0)
429 712
                        ret = ret2;
430 745
        }
431 754
        return (ret);
432 2404
}
433
434
/*--------------------------------------------------------------------
435
 */
436
437
static struct storage *
438 3184
objallocwithnuke(struct worker *wrk, const struct stevedore *stv, ssize_t size,
439
    int flags)
440
{
441 3184
        struct storage *st = NULL;
442
443 3184
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
444 3184
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
445
446 3184
        if (size > cache_param->fetch_maxchunksize) {
447 2
                if (!(flags & LESS_MEM_ALLOCED_IS_OK))
448 0
                        return (NULL);
449 2
                size = cache_param->fetch_maxchunksize;
450 2
        }
451
452 3184
        assert(size <= UINT_MAX);       /* field limit in struct storage */
453
454 3184
        do {
455
                /* try to allocate from it */
456 3192
                st = sml_stv_alloc(stv, size, flags);
457 3192
                if (st != NULL)
458 3179
                        break;
459
460
                /* no luck; try to free some space and keep trying */
461 13
                if (stv->lru == NULL)
462 0
                        break;
463 13
        } while (LRU_NukeOne(wrk, stv->lru));
464
465 3184
        CHECK_OBJ_ORNULL(st, STORAGE_MAGIC);
466 3184
        return (st);
467 3184
}
468
469
static int v_matchproto_(objgetspace_f)
470 57892
sml_getspace(struct worker *wrk, struct objcore *oc, ssize_t *sz,
471
    uint8_t **ptr)
472
{
473
        struct object *o;
474
        struct storage *st;
475
476 57892
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
477 57892
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
478 57892
        CHECK_OBJ_NOTNULL(oc->boc, BOC_MAGIC);
479 57892
        AN(sz);
480 57892
        AN(ptr);
481 57892
        if (*sz == 0)
482 54312
                *sz = cache_param->fetch_chunksize;
483 57892
        assert(*sz > 0);
484 57892
        if (oc->boc->transit_buffer > 0)
485 486
                *sz = vmin_t(ssize_t, *sz, oc->boc->transit_buffer);
486
487 57892
        o = sml_getobj(wrk, oc);
488 57892
        CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
489 57892
        CHECK_OBJ_NOTNULL(oc->boc, BOC_MAGIC);
490
491 57892
        st = VTAILQ_FIRST(&o->list);
492 57892
        if (st != NULL && st->len < st->space) {
493 55094
                *sz = st->space - st->len;
494 55094
                *ptr = st->ptr + st->len;
495 55094
                assert (*sz > 0);
496 55094
                return (1);
497
        }
498
499 2798
        st = objallocwithnuke(wrk, oc->stobj->stevedore, *sz,
500
            LESS_MEM_ALLOCED_IS_OK);
501 2798
        if (st == NULL)
502 5
                return (0);
503
504 2793
        CHECK_OBJ_NOTNULL(oc->boc, BOC_MAGIC);
505 2793
        Lck_Lock(&oc->boc->mtx);
506 2793
        VTAILQ_INSERT_HEAD(&o->list, st, list);
507 2793
        Lck_Unlock(&oc->boc->mtx);
508
509 2793
        *sz = st->space - st->len;
510 2793
        assert (*sz > 0);
511 2793
        *ptr = st->ptr + st->len;
512 2793
        return (1);
513 57892
}
514
515
static void v_matchproto_(objextend_f)
516 56427
sml_extend(struct worker *wrk, struct objcore *oc, ssize_t l)
517
{
518
        struct object *o;
519
        struct storage *st;
520
521 56427
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
522 56427
        assert(l > 0);
523
524 56427
        o = sml_getobj(wrk, oc);
525 56427
        CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
526 56427
        st = VTAILQ_FIRST(&o->list);
527 56427
        CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
528 56427
        assert(st->len + l <= st->space);
529 56427
        st->len += l;
530 56427
}
531
532
static void v_matchproto_(objtrimstore_f)
533 1878
sml_trimstore(struct worker *wrk, struct objcore *oc)
534
{
535
        const struct stevedore *stv;
536
        struct storage *st, *st1;
537
        struct object *o;
538
539 1878
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
540 1878
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
541 1878
        CHECK_OBJ_NOTNULL(oc->boc, BOC_MAGIC);
542
543 1878
        stv = oc->stobj->stevedore;
544 1878
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
545
546 1878
        if (oc->boc->stevedore_priv != NULL)
547 0
                WRONG("sml_trimstore already called");
548 1878
        oc->boc->stevedore_priv = trim_once;
549
550 1878
        if (stv->sml_free == NULL)
551 0
                return;
552
553 1878
        o = sml_getobj(wrk, oc);
554 1878
        CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
555 1878
        st = VTAILQ_FIRST(&o->list);
556
557 1878
        if (st == NULL)
558 0
                return;
559
560 1878
        if (st->len == 0) {
561 8
                Lck_Lock(&oc->boc->mtx);
562 8
                VTAILQ_REMOVE(&o->list, st, list);
563 8
                Lck_Unlock(&oc->boc->mtx);
564
                /* sml_bocdone frees this */
565 8
                oc->boc->stevedore_priv = st;
566 8
                return;
567
        }
568
569 1870
        if (st->space - st->len < 512)
570 1676
                return;
571
572 194
        st1 = sml_stv_alloc(stv, st->len, 0);
573 194
        if (st1 == NULL)
574 0
                return;
575 194
        assert(st1->space >= st->len);
576
577 194
        memcpy(st1->ptr, st->ptr, st->len);
578 194
        st1->len = st->len;
579 194
        Lck_Lock(&oc->boc->mtx);
580 194
        VTAILQ_REMOVE(&o->list, st, list);
581 194
        VTAILQ_INSERT_HEAD(&o->list, st1, list);
582 194
        Lck_Unlock(&oc->boc->mtx);
583
        /* sml_bocdone frees this */
584 194
        oc->boc->stevedore_priv = st;
585 1878
}
586
587
static void v_matchproto_(objbocdone_f)
588 2834
sml_bocdone(struct worker *wrk, struct objcore *oc, struct boc *boc)
589
{
590
        const struct stevedore *stv;
591
592 2834
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
593 2834
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
594 2834
        CHECK_OBJ_NOTNULL(boc, BOC_MAGIC);
595 2834
        stv = oc->stobj->stevedore;
596 2834
        CHECK_OBJ_NOTNULL(stv, STEVEDORE_MAGIC);
597
598 2834
        sml_bocfini(stv, boc);
599
600 2834
        if (stv->lru != NULL) {
601 2795
                if (isnan(wrk->lastused))
602 0
                        wrk->lastused = VTIM_real();
603 2795
                LRU_Add(oc, wrk->lastused);     // approx timestamp is OK
604 2795
        }
605 2834
}
606
607
static const void * v_matchproto_(objgetattr_f)
608 21985
sml_getattr(struct worker *wrk, struct objcore *oc, enum obj_attr attr,
609
   ssize_t *len)
610
{
611
        struct object *o;
612
        ssize_t dummy;
613
614 21985
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
615
616 21985
        if (len == NULL)
617 13487
                len = &dummy;
618 21985
        o = sml_getobj(wrk, oc);
619 21985
        CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
620
621 21985
        switch (attr) {
622
                /* Fixed size attributes */
623
#define OBJ_FIXATTR(U, l, s)                                            \
624
        case OA_##U:                                                    \
625
                *len = sizeof o->fa_##l;                                \
626
                return (o->fa_##l);
627
#include "tbl/obj_attr.h"
628
629
                /* Variable size attributes */
630
#define OBJ_VARATTR(U, l)                                               \
631
        case OA_##U:                                                    \
632
                if (o->va_##l == NULL)                                  \
633
                        return (NULL);                                  \
634
                *len = o->va_##l##_len;                                 \
635
                return (o->va_##l);
636
#include "tbl/obj_attr.h"
637
638
                /* Auxiliary attributes */
639
#define OBJ_AUXATTR(U, l)                                               \
640
        case OA_##U:                                                    \
641
                if (o->aa_##l == NULL)                                  \
642
                        return (NULL);                                  \
643
                CHECK_OBJ_NOTNULL(o->aa_##l, STORAGE_MAGIC);            \
644
                *len = o->aa_##l->len;                                  \
645
                return (o->aa_##l->ptr);
646
#include "tbl/obj_attr.h"
647
648
        default:
649
                break;
650
        }
651 0
        WRONG("Unsupported OBJ_ATTR");
652 21985
}
653
654
static void * v_matchproto_(objsetattr_f)
655 10560
sml_setattr(struct worker *wrk, struct objcore *oc, enum obj_attr attr,
656
    ssize_t len, const void *ptr)
657
{
658
        struct object *o;
659 10560
        void *retval = NULL;
660
        struct storage *st;
661
662 10560
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
663
664 10560
        o = sml_getobj(wrk, oc);
665 10560
        CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
666 10560
        st = o->objstore;
667
668 10560
        switch (attr) {
669
                /* Fixed size attributes */
670
#define OBJ_FIXATTR(U, l, s)                                            \
671
        case OA_##U:                                                    \
672
                assert(len == sizeof o->fa_##l);                        \
673
                retval = o->fa_##l;                                     \
674
                break;
675
#include "tbl/obj_attr.h"
676
677
                /* Variable size attributes */
678
#define OBJ_VARATTR(U, l)                                               \
679
        case OA_##U:                                                    \
680
                if (o->va_##l##_len > 0) {                              \
681
                        AN(o->va_##l);                                  \
682
                        assert(len == o->va_##l##_len);                 \
683
                        retval = o->va_##l;                             \
684
                } else if (len > 0) {                                   \
685
                        assert(len <= UINT_MAX);                        \
686
                        assert(st->len + len <= st->space);             \
687
                        o->va_##l = st->ptr + st->len;                  \
688
                        st->len += len;                                 \
689
                        o->va_##l##_len = len;                          \
690
                        retval = o->va_##l;                             \
691
                }                                                       \
692
                break;
693
#include "tbl/obj_attr.h"
694
695
                /* Auxiliary attributes */
696
#define OBJ_AUXATTR(U, l)                                               \
697
        case OA_##U:                                                    \
698
                if (o->aa_##l != NULL) {                                \
699
                        CHECK_OBJ_NOTNULL(o->aa_##l, STORAGE_MAGIC);    \
700
                        assert(len == o->aa_##l->len);                  \
701
                        retval = o->aa_##l->ptr;                        \
702
                        break;                                          \
703
                }                                                       \
704
                if (len == 0)                                           \
705
                        break;                                          \
706
                o->aa_##l = objallocwithnuke(wrk, oc->stobj->stevedore, \
707
                    len, 0);                                            \
708
                if (o->aa_##l == NULL)                                  \
709
                        break;                                          \
710
                CHECK_OBJ_NOTNULL(o->aa_##l, STORAGE_MAGIC);            \
711
                assert(len <= o->aa_##l->space);                        \
712
                o->aa_##l->len = len;                                   \
713
                retval = o->aa_##l->ptr;                                \
714
                break;
715
#include "tbl/obj_attr.h"
716
717
        default:
718 0
                WRONG("Unsupported OBJ_ATTR");
719
                break;
720
        }
721
722 10560
        if (retval != NULL && ptr != NULL)
723 376
                memcpy(retval, ptr, len);
724 10560
        return (retval);
725
}
726
727
const struct obj_methods SML_methods = {
728
        .objfree        = sml_objfree,
729
        .objiterator    = sml_iterator,
730
        .objgetspace    = sml_getspace,
731
        .objextend      = sml_extend,
732
        .objtrimstore   = sml_trimstore,
733
        .objbocdone     = sml_bocdone,
734
        .objslim        = sml_slim,
735
        .objgetattr     = sml_getattr,
736
        .objsetattr     = sml_setattr,
737
        .objtouch       = LRU_Touch,
738
};
739
740
static void
741 3
sml_panic_st(struct vsb *vsb, const char *hd, const struct storage *st)
742
{
743 6
        VSB_printf(vsb, "%s = %p {priv=%p, ptr=%p, len=%u, space=%u},\n",
744 3
            hd, st, st->priv, st->ptr, st->len, st->space);
745 3
}
746
747
void
748 2
SML_panic(struct vsb *vsb, const struct objcore *oc)
749
{
750
        struct object *o;
751
        struct storage *st;
752
753 2
        VSB_printf(vsb, "Simple = %p,\n", oc->stobj->priv);
754 2
        if (oc->stobj->priv == NULL)
755 0
                return;
756 2
        o = oc->stobj->priv;
757 2
        PAN_CheckMagic(vsb, o, OBJECT_MAGIC);
758 2
        sml_panic_st(vsb, "Obj", o->objstore);
759
760
#define OBJ_FIXATTR(U, l, sz) \
761
        VSB_printf(vsb, "%s = ", #U); \
762
        VSB_quote(vsb, (const void*)o->fa_##l, sz, VSB_QUOTE_HEX); \
763
        VSB_printf(vsb, ",\n");
764
765
#define OBJ_VARATTR(U, l) \
766
        VSB_printf(vsb, "%s = {len=%u, ptr=%p},\n", \
767
            #U, o->va_##l##_len, o->va_##l);
768
769
#define OBJ_AUXATTR(U, l)                                               \
770
        do {                                                            \
771
                if (o->aa_##l != NULL) sml_panic_st(vsb, #U, o->aa_##l);\
772
        } while(0);
773
774
#include "tbl/obj_attr.h"
775
776 3
        VTAILQ_FOREACH(st, &o->list, list) {
777 1
                sml_panic_st(vsb, "Body", st);
778 1
        }
779
}