Code Coverage: vinyl-cache/bin/vinyld/common/common_vsmw.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2010-2011 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
 * VSM stuff common to manager and child.
30
 *
31
 */
32
33
#include "config.h"
34
35
#include <fcntl.h>
36
#include <stdarg.h>
37
#include <stdio.h>
38
#include <stdint.h>
39
#include <stdlib.h>
40
#include <string.h>
41
#include <time.h>
42
#include <unistd.h>
43
#include <sys/mman.h>
44
#include <sys/resource.h>
45
#include <sys/stat.h>
46
47
#include "vdef.h"
48
#include "vas.h"
49
#include "vsb.h"
50
#include "miniobj.h"
51
#include "vqueue.h"
52
53
#include "vfil.h"
54
#include "vrnd.h"
55
56
#include "heritage.h"
57
#include "vsmw.h"
58
59
#ifndef MAP_HASSEMAPHORE
60
#  define MAP_HASSEMAPHORE 0 /* XXX Linux */
61
#endif
62
63
#ifndef MAP_NOSYNC
64
#  define MAP_NOSYNC 0 /* XXX Linux */
65
#endif
66
67
static void v_matchproto_(vsm_lock_f)
68
vsmw_dummy_lock(void)
69 22786
{
70 22786
}
71
72
static int vsmw_haslock;
73
vsm_lock_f *vsmw_lock = vsmw_dummy_lock;
74
vsm_lock_f *vsmw_unlock = vsmw_dummy_lock;
75
76 309920
#define vsmw_assert_lock()      AN(vsmw_haslock)
77
78 63376
#define vsmw_do_lock() vsmw_do_lock_(__func__, __LINE__)
79
80
#define vsmw_do_lock_(f, l)                             \
81 63376
        do {                                    \
82 63376
                vsmw_lock();                    \
83 63376
                AZ(vsmw_haslock);               \
84 63376
                vsmw_haslock = 1;               \
85 63376
        } while(0)
86
87 63376
#define vsmw_do_unlock() vsmw_do_unlock_(__func__, __LINE__)
88
#define vsmw_do_unlock_(f, l)                           \
89 63376
        do {                                    \
90 63376
                AN(vsmw_haslock);               \
91 63376
                vsmw_haslock = 0;               \
92 63376
                vsmw_unlock();                  \
93 63376
        } while(0)
94
95
/*--------------------------------------------------------------------*/
96
97
struct vsmw_cluster {
98
        unsigned                        magic;
99
#define VSMW_CLUSTER_MAGIC              0x28b74c00
100
101
        VTAILQ_ENTRY(vsmw_cluster)      list;
102
        struct vsmwseg                  *cseg;
103
        char                            *fn;
104
        size_t                          len;
105
        void                            *ptr;
106
        size_t                          next;
107
        int                             refs;
108
        int                             named;
109
};
110
111
struct vsmwseg {
112
        unsigned                        magic;
113
#define VSMWSEG_MAGIC                   0x7e4ccaea
114
        VTAILQ_ENTRY(vsmwseg)           list;
115
        struct vsmw_cluster             *cluster;
116
117
        char                            *category;
118
        size_t                          off;
119
        size_t                          len;
120
        char                            *id;
121
        void                            *ptr;
122
};
123
124
struct vsmw {
125
        unsigned                        magic;
126
#define VSMW_MAGIC                      0xc2ca2cd9
127
        int                             vdirfd;
128
        int                             mode;
129
        char                            *idx;
130
        VTAILQ_HEAD(, vsmw_cluster)     clusters;
131
        VTAILQ_HEAD(, vsmwseg)          segs;
132
        struct vsb                      *vsb;
133
        pid_t                           pid;
134
        time_t                          birth;
135
        uint64_t                        nsegs;
136
        uint64_t                        nsubs;
137
};
138
139
/* Allocations in clusters never start at offset zero */
140 2658
#define VSM_CLUSTER_OFFSET 16
141
142
/*--------------------------------------------------------------------*/
143
144
static void
145
vsmw_idx_head(const struct vsmw *vsmw, int fd)
146 2074
{
147 2074
        char buf[64];
148
149 2074
        bprintf(buf, "# %jd %jd\n", (intmax_t)vsmw->pid, (intmax_t)vsmw->birth);
150
        // XXX handle ENOSPC? #2764
151 2074
        assert(write(fd, buf, vstrlen(buf)) == vstrlen(buf));
152 2074
}
153
154 131034
#define ASSERT_SEG_STR(x) do {                  \
155 131034
                AN(x);                          \
156 131034
                AZ(strchr(x, '\n'));            \
157 131034
        } while (0);
158
159
static void
160
vsmw_fmt_index(const struct vsmw *vsmw, const struct vsmwseg *seg, char act)
161 65517
{
162
163 65517
        vsmw_assert_lock();
164 65517
        CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
165 65517
        CHECK_OBJ_NOTNULL(seg, VSMWSEG_MAGIC);
166 65517
        AN(seg->cluster);
167 65517
        ASSERT_SEG_STR(seg->category);
168 65517
        ASSERT_SEG_STR(seg->id);
169
170 65517
        VSB_printf(vsmw->vsb, "%c %s %zu %zu %s %s\n",
171 65517
            act,
172 65517
            seg->cluster->fn,
173 65517
            seg->off,
174 65517
            seg->len,
175 65517
            seg->category,
176 65517
            seg->id);
177 65517
}
178
179
/*--------------------------------------------------------------------*/
180
181
static void
182
vsmw_mkent(const struct vsmw *vsmw, const char *pfx)
183 54642
{
184 54642
        int fd;
185 54642
        uint64_t rn;
186
187 54642
        AN(pfx);
188 54642
        vsmw_assert_lock();
189 54642
        while (1) {
190 54642
                VSB_clear(vsmw->vsb);
191 54642
                VSB_printf(vsmw->vsb, "_.%s", pfx);
192 54642
                AZ(VRND_RandomCrypto(&rn, sizeof rn));
193 54642
                VSB_printf(vsmw->vsb, ".%016jx", (uintmax_t)rn);
194 54642
                AZ(VSB_finish(vsmw->vsb));
195 54642
                fd = openat(vsmw->vdirfd, VSB_data(vsmw->vsb), O_RDONLY);
196 54642
                if (fd < 0 && errno == ENOENT)
197 54642
                        return;
198 0
                if (fd >= 0)
199 0
                        closefd(&fd);
200 0
        }
201 54642
}
202
203
/*--------------------------------------------------------------------*/
204
205
static void
206
vsmw_append_record(struct vsmw *vsmw, struct vsmwseg *seg, char act)
207 65453
{
208 65453
        int fd;
209
210 65453
        vsmw_assert_lock();
211 65453
        CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
212 65453
        CHECK_OBJ_NOTNULL(seg, VSMWSEG_MAGIC);
213 65453
        fd = openat(vsmw->vdirfd, vsmw->idx, O_APPEND | O_WRONLY);
214 65453
        assert(fd >= 0);
215 65453
        VSB_clear(vsmw->vsb);
216 65453
        vsmw_fmt_index(vsmw, seg, act);
217 65453
        AZ(VSB_finish(vsmw->vsb));
218 65453
        XXXAZ(VSB_tofile(vsmw->vsb, fd)); // XXX handle ENOSPC? #2764
219 65453
        closefd(&fd);
220 65453
}
221
222
/*--------------------------------------------------------------------*/
223
224
static void
225
vsmw_addseg(struct vsmw *vsmw, struct vsmwseg *seg)
226 55998
{
227
228 55998
        vsmw_assert_lock();
229 55998
        VTAILQ_INSERT_TAIL(&vsmw->segs, seg, list);
230 55998
        vsmw_append_record(vsmw, seg, '+');
231 55998
        vsmw->nsegs++;
232 55998
}
233
234
/*--------------------------------------------------------------------*/
235
236
static void
237
vsmw_delseg(struct vsmw *vsmw, struct vsmwseg *seg)
238 9465
{
239 9465
        char *t = NULL;
240 9465
        int fd;
241 9465
        struct vsmwseg *s2;
242
243 9465
        vsmw_assert_lock();
244 9465
        CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
245 9465
        CHECK_OBJ_NOTNULL(seg, VSMWSEG_MAGIC);
246
247 9465
        VTAILQ_REMOVE(&vsmw->segs, seg, list);
248
249 9465
        vsmw->nsegs--;
250 9465
        if (vsmw->nsubs < 10 || vsmw->nsubs * 2 < vsmw->nsegs) {
251 9455
                vsmw_append_record(vsmw, seg, '-');
252 9455
                vsmw->nsubs++;
253 9455
        } else {
254 10
                vsmw_mkent(vsmw, vsmw->idx);
255 10
                REPLACE(t, VSB_data(vsmw->vsb));
256 10
                fd = openat(vsmw->vdirfd,
257 10
                    t, O_WRONLY|O_CREAT|O_EXCL, vsmw->mode);
258 10
                assert(fd >= 0);
259 10
                vsmw_idx_head(vsmw, fd);
260 10
                VSB_clear(vsmw->vsb);
261 10
                VTAILQ_FOREACH(s2, &vsmw->segs, list)
262 64
                        vsmw_fmt_index(vsmw, s2, '+');
263 10
                AZ(VSB_finish(vsmw->vsb));
264 10
                XXXAZ(VSB_tofile(vsmw->vsb, fd)); // XXX handle ENOSPC? #2764
265 10
                closefd(&fd);
266 10
                AZ(renameat(vsmw->vdirfd, t, vsmw->vdirfd, vsmw->idx));
267 10
                REPLACE(t, NULL);
268 10
                vsmw->nsubs = 0;
269 10
        }
270 9465
        REPLACE(seg->category, NULL);
271 9465
        REPLACE(seg->id, NULL);
272 9465
        FREE_OBJ(seg);
273 9465
}
274
275
/*--------------------------------------------------------------------*/
276
277
#ifdef RLIMIT_MEMLOCK
278
static void
279
printlim(const char *name, rlim_t lim)
280 2076
{
281
282 2076
        fprintf(stderr, "Info: %s: ", name);
283 2076
        if (lim == RLIM_INFINITY)
284 46
                fprintf(stderr, "unlimited\n");
285 2030
        else
286 2030
                fprintf(stderr, "%ju bytes\n", (uintmax_t)lim);
287 2076
}
288
289
static void
290 1038
printmemlock(void) {
291 1038
        struct rlimit rlim;
292
293 1038
        AZ(getrlimit(RLIMIT_MEMLOCK, &rlim));
294 1038
        printlim("max locked memory (soft)", rlim.rlim_cur);
295 1038
        printlim("max locked memory (hard)", rlim.rlim_max);
296 1038
}
297
#else
298
static void printmemlock(void) {}
299
#endif
300
301
static struct vsmw_cluster *
302
vsmw_newcluster(struct vsmw *vsmw, size_t len, const char *pfx)
303 54632
{
304 54632
        struct vsmw_cluster *vc;
305 54632
        static int warn = 0;
306 54632
        int fd;
307 54632
        size_t ps;
308
309 54632
        vsmw_assert_lock();
310 54632
        ALLOC_OBJ(vc, VSMW_CLUSTER_MAGIC);
311 54632
        AN(vc);
312
313 54632
        vsmw_mkent(vsmw, pfx);
314 54632
        REPLACE(vc->fn, VSB_data(vsmw->vsb));
315
316 54632
        VTAILQ_INSERT_TAIL(&vsmw->clusters, vc, list);
317
318 54632
        ps = getpagesize();
319 54632
        len = RUP2(len, ps);
320 54632
        vc->len = len;
321
322 54632
        fd = openat(vsmw->vdirfd, vc->fn,
323 54632
            O_RDWR | O_CREAT | O_EXCL, vsmw->mode);
324 54632
        assert(fd >= 0);
325
326 54632
        AZ(VFIL_allocate(fd, (off_t)len, 1));
327
328 54632
        vc->ptr = (void *)mmap(NULL, len,
329 54632
            PROT_READ|PROT_WRITE,
330 54632
            MAP_HASSEMAPHORE | MAP_NOSYNC | MAP_SHARED,
331 54632
            fd, 0);
332
333 54632
        closefd(&fd);
334 54632
        assert(vc->ptr != MAP_FAILED);
335 54632
        if (mlock(vc->ptr, len) && warn++ == 0)  {
336 1038
                fprintf(stderr, "Warning: mlock() of VSM failed: %s (%d)\n",
337 1038
                    VAS_errtxt(errno), errno);
338 1038
                printmemlock();
339 1038
        }
340
341 54632
        return (vc);
342 54632
}
343
344
struct vsmw_cluster *
345
VSMW_NewCluster(struct vsmw *vsmw, size_t len, const char *pfx)
346 1329
{
347 1329
        struct vsmw_cluster *vc;
348 1329
        struct vsmwseg *seg;
349
350 1329
        vsmw_do_lock();
351 1329
        vc = vsmw_newcluster(vsmw, len + VSM_CLUSTER_OFFSET, pfx);
352 1329
        AN(vc);
353 1329
        vc->next += VSM_CLUSTER_OFFSET;
354
355 1329
        ALLOC_OBJ(seg, VSMWSEG_MAGIC);
356 1329
        AN(seg);
357 1329
        vc->cseg = seg;
358 1329
        seg->len = vc->len;
359 1329
        seg->cluster = vc;
360 1329
        REPLACE(seg->category, "");
361 1329
        REPLACE(seg->id, "");
362 1329
        vc->refs++;
363 1329
        vc->named = 1;
364 1329
        vsmw_addseg(vsmw, seg);
365
366 1329
        vsmw_do_unlock();
367 1329
        return (vc);
368 1329
}
369
370
static void
371
vsmw_DestroyCluster_locked(struct vsmw *vsmw, struct vsmw_cluster *vc)
372 4213
{
373
374 4213
        vsmw_assert_lock();
375 4213
        CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
376 4213
        CHECK_OBJ_NOTNULL(vc, VSMW_CLUSTER_MAGIC);
377
378 4213
        AZ(vc->refs);
379
380 4213
        AZ(munmap(vc->ptr, vc->len));
381 4213
        if (vc->named)
382 78
                vsmw_delseg(vsmw, vc->cseg);
383 4213
        vc->cseg = 0;
384
385 4213
        VTAILQ_REMOVE(&vsmw->clusters, vc, list);
386 4213
        if (unlinkat(vsmw->vdirfd, vc->fn, 0))
387 0
                assert (errno == ENOENT);
388 4213
        REPLACE(vc->fn, NULL);
389 4213
        FREE_OBJ(vc);
390 4213
}
391
392
void
393
VSMW_DestroyCluster(struct vsmw *vsmw, struct vsmw_cluster **vsmcp)
394 78
{
395 78
        struct vsmw_cluster *vc;
396
397 78
        TAKE_OBJ_NOTNULL(vc, vsmcp, VSMW_CLUSTER_MAGIC);
398
399 78
        vsmw_do_lock();
400 78
        if (--vc->refs == 0)
401 45
                vsmw_DestroyCluster_locked(vsmw, vc);
402 78
        vsmw_do_unlock();
403 78
}
404
405
/*--------------------------------------------------------------------*/
406
407
void *
408
VSMW_Allocv(struct vsmw *vsmw, struct vsmw_cluster *vc,
409
    const char *category, size_t payload, const char *prefix,
410
    const char *fmt, va_list va)
411 54669
{
412 54669
        struct vsmwseg *seg;
413 54669
        ssize_t l;
414
415 54669
        vsmw_do_lock();
416 54669
        CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
417
418 54669
        ALLOC_OBJ(seg, VSMWSEG_MAGIC);
419 54669
        AN(seg);
420 54669
        REPLACE(seg->category, category);
421 54669
        seg->len = PRNDUP(payload);
422
423 54669
        VSB_clear(vsmw->vsb);
424 54669
        if (prefix != NULL) {
425 39333
                assert(prefix[0] != '\0');
426 39333
                VSB_cat(vsmw->vsb, prefix);
427 39333
                if (fmt[0] != '\0')
428 36242
                        VSB_cat(vsmw->vsb, ".");
429 39333
        }
430 54669
        l = VSB_len(vsmw->vsb);
431 54669
        assert(l >= 0);
432 54669
        VSB_vprintf(vsmw->vsb, fmt, va);
433 54669
        AZ(VSB_finish(vsmw->vsb));
434 54669
        assert(fmt[0] == '\0' || l < VSB_len(vsmw->vsb));
435
436 54669
        REPLACE(seg->id, VSB_data(vsmw->vsb));
437
438 54669
        if (vc == NULL)
439 53303
                vc = vsmw_newcluster(vsmw, seg->len, category);
440 54669
        AN(vc);
441 54669
        vc->refs++;
442
443 54669
        seg->cluster = vc;
444 54669
        seg->off = vc->next;
445 54669
        vc->next += seg->len;
446 54669
        assert(vc->next <= vc->len);
447 54669
        seg->ptr = seg->off + (char*)vc->ptr;
448
449 54669
        vsmw_addseg(vsmw, seg);
450
451 54669
        vsmw_do_unlock();
452 54669
        return (seg->ptr);
453 54669
}
454
455
void *
456
VSMW_Allocf(struct vsmw *vsmw, struct vsmw_cluster *vc,
457
    const char *category, size_t len, const char *fmt, ...)
458 6203
{
459 6203
        va_list ap;
460 6203
        void *p;
461
462 6203
        va_start(ap, fmt);
463 6203
        p = VSMW_Allocv(vsmw, vc, category, len, NULL, fmt, ap);
464 6203
        va_end(ap);
465 6203
        return (p);
466 6203
}
467
468
/*--------------------------------------------------------------------*/
469
470
void
471
VSMW_Free(struct vsmw *vsmw, void **pp)
472 4198
{
473 4198
        struct vsmwseg *seg;
474 4198
        struct vsmw_cluster *cp;
475
476 4198
        vsmw_do_lock();
477 4198
        CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
478 4198
        AN(pp);
479 4198
        VTAILQ_FOREACH(seg, &vsmw->segs, list)
480 100688
                if (seg->ptr == *pp)
481 4198
                        break;
482 4198
        AN(seg);
483 4198
        *pp = NULL;
484
485 4198
        cp = seg->cluster;
486 4198
        CHECK_OBJ_NOTNULL(cp, VSMW_CLUSTER_MAGIC);
487 4198
        assert(cp->refs > 0);
488
489 4198
        vsmw_delseg(vsmw, seg);
490
491 4198
        if (!--cp->refs)
492 4168
                vsmw_DestroyCluster_locked(vsmw, cp);
493 4198
        vsmw_do_unlock();
494 4198
}
495
496
/*--------------------------------------------------------------------*/
497
498
struct vsmw *
499
VSMW_New(int vdirfd, int mode, const char *idxname)
500 2064
{
501 2064
        struct vsmw *vsmw;
502 2064
        int fd;
503
504 2064
        assert(vdirfd > 0);
505 2064
        assert(mode > 0);
506 2064
        AN(idxname);
507
508 2064
        vsmw_do_lock();
509 2064
        ALLOC_OBJ(vsmw, VSMW_MAGIC);
510 2064
        AN(vsmw);
511
512 2064
        VTAILQ_INIT(&vsmw->segs);
513 2064
        VTAILQ_INIT(&vsmw->clusters);
514 2064
        vsmw->vsb = VSB_new_auto();
515 2064
        AN(vsmw->vsb);
516 2064
        REPLACE(vsmw->idx, idxname);
517 2064
        vsmw->mode = mode;
518 2064
        vsmw->vdirfd = vdirfd;
519 2064
        vsmw->pid = getpid();
520 2064
        vsmw->birth = time(NULL);
521
522 2064
        if (unlinkat(vdirfd, vsmw->idx, 0))
523 2064
                assert (errno == ENOENT);
524 2064
        fd = openat(vdirfd,
525 2064
            vsmw->idx, O_APPEND | O_WRONLY | O_CREAT, vsmw->mode);
526 2064
        assert(fd >= 0);
527 2064
        vsmw_idx_head(vsmw, fd);
528 2064
        closefd(&fd);
529
530 2064
        vsmw_do_unlock();
531 2064
        return (vsmw);
532 2064
}
533
534
void
535
VSMW_Destroy(struct vsmw **pp)
536 1038
{
537 1038
        struct vsmw *vsmw;
538 1038
        struct vsmwseg *seg, *s2;
539
540 1038
        vsmw_do_lock();
541 1038
        TAKE_OBJ_NOTNULL(vsmw, pp, VSMW_MAGIC);
542 1038
        VTAILQ_FOREACH_SAFE(seg, &vsmw->segs, list, s2)
543 5189
                vsmw_delseg(vsmw, seg);
544 1038
        if (unlinkat(vsmw->vdirfd, vsmw->idx, 0))
545 0
                assert (errno == ENOENT);
546 1038
        REPLACE(vsmw->idx, NULL);
547 1038
        VSB_destroy(&vsmw->vsb);
548 1038
        closefd(&vsmw->vdirfd);
549 1038
        FREE_OBJ(vsmw);
550 1038
        vsmw_do_unlock();
551 1038
}