varnish-cache/bin/varnishd/cache/cache_shmlog.c
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 */
30
31
#include "config.h"
32
33
#include "cache_varnishd.h"
34
35
#include <stdio.h>
36
#include <stdlib.h>
37
38
#include "vgz.h"
39
#include "vsl_priv.h"
40
#include "vmb.h"
41
42
#include "common/heritage.h"
43
#include "common/vsmw.h"
44
45
/* ------------------------------------------------------------
46
 * strands helpers - move elsewhere?
47
 */
48
49
static unsigned
50 48359
strands_len(const struct strands *s)
51
{
52 48359
        unsigned r = 0;
53
        int i;
54
55 96780
        for (i = 0; i < s->n; i++) {
56 48421
                if (s->p[i] == NULL || *s->p[i] == '\0')
57 4629
                        continue;
58 43792
                r += strlen(s->p[i]);
59 43792
        }
60
61 48359
        return (r);
62
}
63
64
/*
65
 * like VRT_Strands(), but truncating instead of failing for end of buffer
66
 *
67
 * returns number of bytes including NUL
68
 */
69
static unsigned
70 48546
strands_cat(char *buf, unsigned bufl, const struct strands *s)
71
{
72 48546
        unsigned l = 0, ll;
73
        int i;
74
75
        /* NUL-terminated */
76 48546
        assert(bufl > 0);
77 48546
        bufl--;
78
79 92623
        for (i = 0; i < s->n && bufl > 0; i++) {
80 44077
                if (s->p[i] == NULL || *s->p[i] == '\0')
81 2
                        continue;
82 44075
                ll = vmin_t(unsigned, strlen(s->p[i]), bufl);
83 44075
                memcpy(buf, s->p[i], ll);
84 44075
                l += ll;
85 44075
                buf += ll;
86 44075
                bufl -= ll;
87 44075
        }
88 48546
        *buf = '\0';    /* NUL-terminated */
89 48546
        return (l + 1);
90
}
91
92
/* These cannot be struct lock, which depends on vsm/vsl working */
93
static pthread_mutex_t vsl_mtx;
94
static pthread_mutex_t vsc_mtx;
95
static pthread_mutex_t vsm_mtx;
96
97
static struct VSL_head          *vsl_head;
98
static const uint32_t           *vsl_end;
99
static uint32_t                 *vsl_ptr;
100
static unsigned                 vsl_segment_n;
101
static ssize_t                  vsl_segsize;
102
103
struct VSC_main *VSC_C_main;
104
105
static void
106 476823
vsl_sanity(const struct vsl_log *vsl)
107
{
108 476823
        AN(vsl);
109 476823
        AN(vsl->wlp);
110 476823
        AN(vsl->wlb);
111 476823
        AN(vsl->wle);
112 476823
        assert(vsl->wlb <= vsl->wlp);
113 476823
        assert(vsl->wlp <= vsl->wle);
114 476823
}
115
116
/*--------------------------------------------------------------------
117
 * Check if the VSL_tag is masked by parameter bitmap
118
 */
119
120
static inline int
121 357524
vsl_tag_is_masked(enum VSL_tag_e tag)
122
{
123 357524
        volatile uint8_t *bm = &cache_param->vsl_mask[0];
124
        uint8_t b;
125
126 357524
        assert(tag > SLT__Bogus);
127 357524
        assert(tag < SLT__Reserved);
128 357524
        bm += ((unsigned)tag >> 3);
129 357524
        b = (0x80 >> ((unsigned)tag & 7));
130 357524
        return (*bm & b);
131
}
132
133
int
134 1260
VSL_tag_is_masked(enum VSL_tag_e tag)
135
{
136 1260
        return (vsl_tag_is_masked(tag));
137
}
138
139
/*--------------------------------------------------------------------
140
 * Lay down a header fields, and return pointer to the next record
141
 */
142
143
static inline uint32_t *
144 294202
vsl_hdr(enum VSL_tag_e tag, uint32_t *p, unsigned len, vxid_t vxid)
145
{
146
147 294202
        AZ((uintptr_t)p & 0x3);
148 294202
        assert(tag > SLT__Bogus);
149 294202
        assert(tag < SLT__Reserved);
150 294202
        AZ(len & ~VSL_LENMASK);
151
152 294202
        p[2] = vxid.vxid >> 32;
153 294202
        p[1] = vxid.vxid;
154 588404
        p[0] = (((unsigned)tag & VSL_IDMASK) << VSL_IDSHIFT) |
155 294202
             (VSL_VERSION_3 << VSL_VERSHIFT) |
156 294202
             len;
157 294202
        return (VSL_END(p, len));
158
}
159
160
/*--------------------------------------------------------------------
161
 * Space available in a VSL buffer when accounting for overhead
162
 */
163
164
static unsigned
165 71287
vsl_space(const struct vsl_log *vsl)
166
{
167
        ptrdiff_t mlen;
168
169 71287
        mlen = vsl->wle - vsl->wlp;
170 71287
        assert(mlen >= 0);
171 71287
        if (mlen < VSL_OVERHEAD + 1)
172 2
                return (0);
173 71285
        mlen -= VSL_OVERHEAD;
174 71285
        mlen *= sizeof *vsl->wlp;
175 71285
        if (mlen > cache_param->vsl_reclen)
176 71267
                mlen = cache_param->vsl_reclen;
177 71285
        return(mlen);
178 71287
}
179
180
/*--------------------------------------------------------------------
181
 * Wrap the VSL buffer
182
 */
183
184
static void
185 0
vsl_wrap(void)
186
{
187
188 0
        assert(vsl_ptr >= vsl_head->log);
189 0
        assert(vsl_ptr < vsl_end);
190 0
        vsl_segment_n += VSL_SEGMENTS - (vsl_segment_n % VSL_SEGMENTS);
191 0
        assert(vsl_segment_n % VSL_SEGMENTS == 0);
192 0
        vsl_head->offset[0] = 0;
193 0
        vsl_head->log[0] = VSL_ENDMARKER;
194 0
        VWMB();
195 0
        if (vsl_ptr != vsl_head->log) {
196 0
                *vsl_ptr = VSL_WRAPMARKER;
197 0
                vsl_ptr = vsl_head->log;
198 0
        }
199 0
        vsl_head->segment_n = vsl_segment_n;
200 0
        VSC_C_main->shm_cycles++;
201 0
}
202
203
/*--------------------------------------------------------------------
204
 * Reserve bytes for a record, wrap if necessary
205
 */
206
207
static uint32_t *
208 84838
vsl_get(unsigned len, unsigned records, unsigned flushes)
209
{
210
        uint32_t *p;
211
        int err;
212
213 84838
        err = pthread_mutex_trylock(&vsl_mtx);
214 84838
        if (err == EBUSY) {
215 458
                PTOK(pthread_mutex_lock(&vsl_mtx));
216 458
                VSC_C_main->shm_cont++;
217 458
        } else {
218 84380
                AZ(err);
219
        }
220 84838
        assert(vsl_ptr < vsl_end);
221 84838
        AZ((uintptr_t)vsl_ptr & 0x3);
222
223 84838
        VSC_C_main->shm_writes++;
224 84838
        VSC_C_main->shm_flushes += flushes;
225 84838
        VSC_C_main->shm_records += records;
226 84838
        VSC_C_main->shm_bytes +=
227 84838
            VSL_BYTES(VSL_OVERHEAD + VSL_WORDS((uint64_t)len));
228
229
        /* Wrap if necessary */
230 84838
        if (VSL_END(vsl_ptr, len) >= vsl_end)
231 0
                vsl_wrap();
232
233 84838
        p = vsl_ptr;
234 84838
        vsl_ptr = VSL_END(vsl_ptr, len);
235 84838
        assert(vsl_ptr < vsl_end);
236 84838
        AZ((uintptr_t)vsl_ptr & 0x3);
237
238 84838
        *vsl_ptr = VSL_ENDMARKER;
239
240 84840
        while ((vsl_ptr - vsl_head->log) / vsl_segsize >
241 84840
            vsl_segment_n % VSL_SEGMENTS) {
242 2
                vsl_segment_n++;
243 2
                vsl_head->offset[vsl_segment_n % VSL_SEGMENTS] =
244 2
                    vsl_ptr - vsl_head->log;
245
        }
246
247 84838
        PTOK(pthread_mutex_unlock(&vsl_mtx));
248
        /* Implicit VWMB() in mutex op ensures ENDMARKER and new table
249
           values are seen before new segment number */
250 84838
        vsl_head->segment_n = vsl_segment_n;
251
252 84838
        return (p);
253
}
254
255
/*--------------------------------------------------------------------
256
 * Stick a finished record into VSL.
257
 */
258
259
static void
260 57004
vslr(enum VSL_tag_e tag, vxid_t vxid, const char *b, unsigned len)
261
{
262
        uint32_t *p;
263
        unsigned mlen;
264
265 57004
        mlen = cache_param->vsl_reclen;
266
267
        /* Truncate */
268 57004
        if (len > mlen)
269 0
                len = mlen;
270
271 57004
        p = vsl_get(len, 1, 0);
272
273 57004
        memcpy(p + VSL_OVERHEAD, b, len);
274
275
        /*
276
         * the vxid needs to be written before the barrier to
277
         * ensure it is valid when vsl_hdr() marks the record
278
         * ready by writing p[0]
279
         */
280 57004
        p[2] = vxid.vxid >> 32;
281 57004
        p[1] = vxid.vxid;
282 57004
        VWMB();
283 57004
        (void)vsl_hdr(tag, p, len, vxid);
284 57004
}
285
286
/*--------------------------------------------------------------------
287
 * Add a unbuffered record to VSL
288
 *
289
 * NB: This variant should be used sparingly and only for low volume
290
 * NB: since it significantly adds to the mutex load on the VSL.
291
 */
292
293
void
294 76674
VSLv(enum VSL_tag_e tag, vxid_t vxid, const char *fmt, va_list ap)
295
{
296 76674
        unsigned n, mlen = cache_param->vsl_reclen;
297 76674
        char buf[mlen];
298
299 76674
        AN(fmt);
300 76674
        if (vsl_tag_is_masked(tag))
301 19865
                return;
302
303 56809
        if (strchr(fmt, '%') == NULL) {
304 1121
                vslr(tag, vxid, fmt, strlen(fmt) + 1);
305 1121
        } else {
306 55688
                n = vsnprintf(buf, mlen, fmt, ap);
307 55688
                n = vmin(n, mlen - 1);
308 55688
                buf[n++] = '\0'; /* NUL-terminated */
309 55688
                vslr(tag, vxid, buf, n);
310
        }
311
312 76674
}
313
314
void
315 194
VSLs(enum VSL_tag_e tag, vxid_t vxid, const struct strands *s)
316
{
317 194
        unsigned n, mlen = cache_param->vsl_reclen;
318 194
        char buf[mlen];
319
320 194
        if (vsl_tag_is_masked(tag))
321 0
                return;
322
323 194
        n = strands_cat(buf, mlen, s);
324
325 194
        vslr(tag, vxid, buf, n);
326 194
}
327
328
void
329 75031
VSL(enum VSL_tag_e tag, vxid_t vxid, const char *fmt, ...)
330
{
331
        va_list ap;
332
333 75031
        va_start(ap, fmt);
334 75031
        VSLv(tag, vxid, fmt, ap);
335 75031
        va_end(ap);
336 75031
}
337
338
/*--------------------------------------------------------------------*/
339
340
void
341 35506
VSL_Flush(struct vsl_log *vsl, int overflow)
342
{
343
        uint32_t *p;
344
        unsigned l;
345
346 35506
        vsl_sanity(vsl);
347 35506
        l = pdiff(vsl->wlb, vsl->wlp);
348 35506
        if (l == 0)
349 7750
                return;
350
351 27756
        assert(l >= 8);
352
353 27756
        p = vsl_get(l, vsl->wlr, overflow);
354
355 27756
        memcpy(p + VSL_OVERHEAD, vsl->wlb, l);
356 27756
        p[1] = l;
357 27756
        VWMB();
358 27756
        p[0] = ((((unsigned)SLT__Batch & 0xff) << VSL_IDSHIFT));
359 27756
        vsl->wlp = vsl->wlb;
360 27756
        vsl->wlr = 0;
361 35506
}
362
363
/*--------------------------------------------------------------------
364
 * Buffered VSLs
365
 */
366
367
static char *
368 235869
vslb_get(struct vsl_log *vsl, enum VSL_tag_e tag, unsigned *length)
369
{
370 235869
        unsigned mlen = cache_param->vsl_reclen;
371
        char *retval;
372
373 235869
        vsl_sanity(vsl);
374 235869
        if (*length < mlen)
375 235269
                mlen = *length;
376
377 235869
        if (VSL_END(vsl->wlp, mlen) > vsl->wle)
378 7
                VSL_Flush(vsl, 1);
379
380 235869
        retval = VSL_DATA(vsl->wlp);
381
382
        /* If it still doesn't fit, truncate */
383 235869
        if (VSL_END(vsl->wlp, mlen) > vsl->wle)
384 2
                mlen = vsl_space(vsl);
385
386 235869
        vsl->wlp = vsl_hdr(tag, vsl->wlp, mlen, vsl->wid);
387 235869
        vsl->wlr++;
388 235869
        *length = mlen;
389 235869
        return (retval);
390
}
391
392
static void
393 116362
vslb_simple(struct vsl_log *vsl, enum VSL_tag_e tag,
394
    unsigned length, const char *str)
395
{
396
        char *p;
397
398 116362
        if (length == 0)
399 9145
                length = strlen(str);
400 116362
        length += 1; // NUL
401 116362
        p = vslb_get(vsl, tag, &length);
402 116362
        memcpy(p, str, length - 1);
403 116362
        p[length - 1] = '\0';
404
405 116362
        if (DO_DEBUG(DBG_SYNCVSL))
406 10057
                VSL_Flush(vsl, 0);
407 116362
}
408
409
/*--------------------------------------------------------------------
410
 * VSL-buffered-txt
411
 */
412
413
void
414 130730
VSLbt(struct vsl_log *vsl, enum VSL_tag_e tag, txt t)
415
{
416
417 130730
        Tcheck(t);
418 130730
        if (vsl_tag_is_masked(tag))
419 17389
                return;
420
421 113341
        vslb_simple(vsl, tag, Tlen(t), t.b);
422 130730
}
423
424
/*--------------------------------------------------------------------
425
 * VSL-buffered-strands
426
 */
427
void
428 57307
VSLbs(struct vsl_log *vsl, enum VSL_tag_e tag, const struct strands *s)
429
{
430
        unsigned l;
431
        char *p;
432
433 57307
        if (vsl_tag_is_masked(tag))
434 8948
                return;
435
436 48359
        l = strands_len(s) + 1;
437 48359
        p = vslb_get(vsl, tag, &l);
438
439 48359
        (void)strands_cat(p, l, s);
440
441 48359
        if (DO_DEBUG(DBG_SYNCVSL))
442 4013
                VSL_Flush(vsl, 0);
443 57307
}
444
445
/*--------------------------------------------------------------------
446
 * VSL-buffered
447
 */
448
449
void
450 88785
VSLbv(struct vsl_log *vsl, enum VSL_tag_e tag, const char *fmt, va_list ap)
451
{
452
        char *p, *p1;
453 88785
        unsigned n = 0, mlen;
454
        va_list ap2;
455
456 88785
        AN(fmt);
457 88785
        if (vsl_tag_is_masked(tag))
458 14475
                return;
459
460
        /*
461
         * If there are no printf-expansions, don't waste time expanding them
462
         */
463 74310
        if (strchr(fmt, '%') == NULL) {
464 3003
                vslb_simple(vsl, tag, 0, fmt);
465 3003
                return;
466
        }
467
468
        /*
469
         * If the format is trivial, deal with it directly
470
         */
471 71307
        if (!strcmp(fmt, "%s")) {
472 18
                p1 = va_arg(ap, char *);
473 18
                vslb_simple(vsl, tag, 0, p1);
474 18
                return;
475
        }
476
477 71289
        vsl_sanity(vsl);
478
479 71289
        mlen = vsl_space(vsl);
480
481
        // First attempt, only if any space at all
482 71289
        if (mlen > 0) {
483 71263
                p = VSL_DATA(vsl->wlp);
484 71263
                va_copy(ap2, ap);
485 71263
                n = vsnprintf(p, mlen, fmt, ap2);
486 71263
                va_end(ap2);
487 71263
        }
488
489
        // Second attempt, if a flush might help
490 71289
        if (mlen == 0 || (n + 1 > mlen && n + 1 <= cache_param->vsl_reclen)) {
491 58
                VSL_Flush(vsl, 1);
492 58
                mlen = vsl_space(vsl);
493 58
                p = VSL_DATA(vsl->wlp);
494 58
                n = vsnprintf(p, mlen, fmt, ap);
495 58
        }
496 71301
        if (n + 1 < mlen)
497 71033
                mlen = n + 1;
498 71301
        (void)vslb_get(vsl, tag, &mlen);
499
500 71301
        if (DO_DEBUG(DBG_SYNCVSL))
501 7405
                VSL_Flush(vsl, 0);
502 88797
}
503
504
void
505 85331
VSLb(struct vsl_log *vsl, enum VSL_tag_e tag, const char *fmt, ...)
506
{
507
        va_list ap;
508
509 85331
        vsl_sanity(vsl);
510 85331
        va_start(ap, fmt);
511 85331
        VSLbv(vsl, tag, fmt, ap);
512 85331
        va_end(ap);
513 85331
}
514
515
#define Tf6 "%ju.%06ju"
516
#define Ta6(t) (uintmax_t)floor((t)), (uintmax_t)floor((t) * 1e6) % 1000000U
517
518
void
519 32320
VSLb_ts(struct vsl_log *vsl, const char *event, vtim_real first,
520
    vtim_real *pprev, vtim_real now)
521
{
522
523
        /*
524
         * XXX: Make an option to turn off some unnecessary timestamp
525
         * logging. This must be done carefully because some functions
526
         * (e.g. V1L_Open) takes the last timestamp as its initial
527
         * value for timeout calculation.
528
         */
529 32320
        vsl_sanity(vsl);
530 32320
        AN(event);
531 32320
        AN(pprev);
532 32320
        assert(!isnan(now) && now != 0.);
533 64640
        VSLb(vsl, SLT_Timestamp, "%s: " Tf6 " " Tf6 " " Tf6,
534 32320
            event, Ta6(now), Ta6(now - first), Ta6(now - *pprev));
535 32320
        *pprev = now;
536 32320
}
537
538
void
539 2765
VSLb_bin(struct vsl_log *vsl, enum VSL_tag_e tag, ssize_t len, const void *ptr)
540
{
541
        unsigned mlen;
542
        char *p;
543
544 2765
        vsl_sanity(vsl);
545 2765
        AN(ptr);
546 2765
        if (vsl_tag_is_masked(tag))
547 1292
                return;
548 1473
        mlen = cache_param->vsl_reclen;
549
550
        /* Truncate */
551 1473
        len = vmin_t(ssize_t, len, mlen);
552
553 1473
        assert(vsl->wlp <= vsl->wle);
554
555
        /* Flush if necessary */
556 1473
        if (VSL_END(vsl->wlp, len) > vsl->wle)
557 9
                VSL_Flush(vsl, 1);
558 1473
        assert(VSL_END(vsl->wlp, len) <= vsl->wle);
559 1473
        p = VSL_DATA(vsl->wlp);
560 1473
        memcpy(p, ptr, len);
561 1473
        vsl->wlp = vsl_hdr(tag, vsl->wlp, len, vsl->wid);
562 1473
        assert(vsl->wlp <= vsl->wle);
563 1473
        vsl->wlr++;
564
565 1473
        if (DO_DEBUG(DBG_SYNCVSL))
566 607
                VSL_Flush(vsl, 0);
567 2765
}
568
569
/*--------------------------------------------------------------------
570
 * Setup a VSL buffer, allocate space if none provided.
571
 */
572
573
void
574 8093
VSL_Setup(struct vsl_log *vsl, void *ptr, size_t len)
575
{
576
577 8093
        if (ptr == NULL) {
578 2803
                len = cache_param->vsl_buffer;
579 2803
                ptr = malloc(len);
580 2803
                AN(ptr);
581 2803
        }
582 8093
        vsl->wlp = ptr;
583 8093
        vsl->wlb = ptr;
584 8093
        vsl->wle = ptr;
585 8093
        vsl->wle += len / sizeof(*vsl->wle);
586 8093
        vsl->wlr = 0;
587 8093
        vsl->wid = NO_VXID;
588 8093
        vsl_sanity(vsl);
589 8093
}
590
591
/*--------------------------------------------------------------------*/
592
593
void
594 96
VSL_ChgId(struct vsl_log *vsl, const char *typ, const char *why, vxid_t vxid)
595
{
596
        vxid_t ovxid;
597
598 96
        vsl_sanity(vsl);
599 96
        ovxid = vsl->wid;
600 96
        VSLb(vsl, SLT_Link, "%s %ju %s", typ, VXID(vxid), why);
601 96
        VSL_End(vsl);
602 96
        vsl->wid = vxid;
603 96
        VSLb(vsl, SLT_Begin, "%s %ju %s", typ, VXID(ovxid), why);
604 96
}
605
606
/*--------------------------------------------------------------------*/
607
608
void
609 6124
VSL_End(struct vsl_log *vsl)
610
{
611
        txt t;
612 6124
        char p[] = "";
613
614 6124
        vsl_sanity(vsl);
615 6124
        assert(!IS_NO_VXID(vsl->wid));
616 6124
        t.b = p;
617 6124
        t.e = p;
618 6124
        VSLbt(vsl, SLT_End, t);
619 6124
        VSL_Flush(vsl, 0);
620 6124
        vsl->wid = NO_VXID;
621 6124
}
622
623
static void v_matchproto_(vsm_lock_f)
624 35284
vsm_vsc_lock(void)
625
{
626 35284
        PTOK(pthread_mutex_lock(&vsc_mtx));
627 35284
}
628
629
static void v_matchproto_(vsm_lock_f)
630 35284
vsm_vsc_unlock(void)
631
{
632 35284
        PTOK(pthread_mutex_unlock(&vsc_mtx));
633 35284
}
634
635
static void v_matchproto_(vsm_lock_f)
636 43703
vsm_vsmw_lock(void)
637
{
638 43703
        PTOK(pthread_mutex_lock(&vsm_mtx));
639 43703
}
640
641
static void v_matchproto_(vsm_lock_f)
642 43703
vsm_vsmw_unlock(void)
643
{
644 43703
        PTOK(pthread_mutex_unlock(&vsm_mtx));
645 43703
}
646
647
/*--------------------------------------------------------------------*/
648
649
void
650 935
VSM_Init(void)
651
{
652
        unsigned u;
653
654 935
        assert(UINT_MAX % VSL_SEGMENTS == VSL_SEGMENTS - 1);
655
656 935
        PTOK(pthread_mutex_init(&vsl_mtx, &mtxattr_errorcheck));
657 935
        PTOK(pthread_mutex_init(&vsc_mtx, &mtxattr_errorcheck));
658 935
        PTOK(pthread_mutex_init(&vsm_mtx, &mtxattr_errorcheck));
659
660 935
        vsc_lock = vsm_vsc_lock;
661 935
        vsc_unlock = vsm_vsc_unlock;
662 935
        vsmw_lock = vsm_vsmw_lock;
663 935
        vsmw_unlock = vsm_vsmw_unlock;
664
665 935
        heritage.proc_vsmw = VSMW_New(heritage.vsm_fd, 0640, "_.index");
666 935
        AN(heritage.proc_vsmw);
667
668 935
        VSC_C_main = VSC_main_New(NULL, NULL, "");
669 935
        AN(VSC_C_main);
670
671 935
        AN(heritage.proc_vsmw);
672 1870
        vsl_head = VSMW_Allocf(heritage.proc_vsmw, NULL, VSL_CLASS,
673 935
            cache_param->vsl_space, VSL_CLASS);
674 935
        AN(vsl_head);
675 1870
        vsl_segsize = ((cache_param->vsl_space - sizeof *vsl_head) /
676 935
            sizeof *vsl_end) / VSL_SEGMENTS;
677 935
        vsl_end = vsl_head->log + vsl_segsize * VSL_SEGMENTS;
678
        /* Make segment_n always overflow on first log wrap to make any
679
           problems with regard to readers on that event visible */
680 935
        vsl_segment_n = UINT_MAX - (VSL_SEGMENTS - 1);
681 935
        AZ(vsl_segment_n % VSL_SEGMENTS);
682 935
        vsl_ptr = vsl_head->log;
683 935
        *vsl_ptr = VSL_ENDMARKER;
684
685 935
        memset(vsl_head, 0, sizeof *vsl_head);
686 935
        vsl_head->segsize = vsl_segsize;
687 935
        vsl_head->offset[0] = 0;
688 935
        vsl_head->segment_n = vsl_segment_n;
689 7480
        for (u = 1; u < VSL_SEGMENTS; u++)
690 6545
                vsl_head->offset[u] = -1;
691 935
        VWMB();
692 935
        memcpy(vsl_head->marker, VSL_HEAD_MARKER, sizeof vsl_head->marker);
693 935
}