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 1982682
strands_len(const struct strands *s)
51
{
52 1982682
        unsigned r = 0;
53
        int i;
54
55 1982682
        CHECK_OBJ_NOTNULL(s, STRANDS_MAGIC);
56 3967812
        for (i = 0; i < s->n; i++) {
57 1985130
                if (s->p[i] == NULL || *s->p[i] == '\0')
58 188793
                        continue;
59 1796337
                r += strlen(s->p[i]);
60 1796337
        }
61
62 1982682
        return (r);
63
}
64
65
/*
66
 * like VRT_Strands(), but truncating instead of failing for end of buffer
67
 *
68
 * returns number of bytes including NUL
69
 */
70
static unsigned
71 1990390
strands_cat(char *buf, unsigned bufl, const struct strands *s)
72
{
73 1990390
        unsigned l = 0, ll;
74
        int i;
75
76
        /* NUL-terminated */
77 1990390
        assert(bufl > 0);
78 1990390
        bufl--;
79 1990390
        CHECK_OBJ_NOTNULL(s, STRANDS_MAGIC);
80
81 3798383
        for (i = 0; i < s->n && bufl > 0; i++) {
82 1808003
                if (s->p[i] == NULL || *s->p[i] == '\0')
83 94
                        continue;
84 1807913
                ll = vmin_t(unsigned, strlen(s->p[i]), bufl);
85 1807913
                memcpy(buf, s->p[i], ll);
86 1807913
                l += ll;
87 1807913
                buf += ll;
88 1807913
                bufl -= ll;
89 1807913
        }
90 1990380
        *buf = '\0';    /* NUL-terminated */
91 1990380
        return (l + 1);
92
}
93
94
/* These cannot be struct lock, which depends on vsm/vsl working */
95
static pthread_mutex_t vsl_mtx;
96
static pthread_mutex_t vsc_mtx;
97
static pthread_mutex_t vsm_mtx;
98
99
static struct VSL_head          *vsl_head;
100
static const uint32_t           *vsl_end;
101
static uint32_t                 *vsl_ptr;
102
static unsigned                 vsl_segment_n;
103
static ssize_t                  vsl_segsize;
104
105
struct VSC_main *VSC_C_main;
106
107
static void
108 19692247
vsl_sanity(const struct vsl_log *vsl)
109
{
110 19692247
        AN(vsl);
111 19692247
        AN(vsl->wlp);
112 19692247
        AN(vsl->wlb);
113 19692247
        AN(vsl->wle);
114 19692247
        assert(vsl->wlb <= vsl->wlp);
115 19692247
        assert(vsl->wlp <= vsl->wle);
116 19692247
}
117
118
/*--------------------------------------------------------------------
119
 * Check if the VSL_tag is masked by parameter bitmap
120
 */
121
122
static inline int
123 14640950
vsl_tag_is_masked(enum VSL_tag_e tag)
124
{
125 14640950
        volatile uint8_t *bm = &cache_param->vsl_mask[0];
126
        uint8_t b;
127
128 14640950
        assert(tag > SLT__Bogus);
129 14640950
        assert(tag < SLT__Reserved);
130 14640950
        bm += ((unsigned)tag >> 3);
131 14640950
        b = (0x80 >> ((unsigned)tag & 7));
132 14640950
        return (*bm & b);
133
}
134
135
int
136 51068
VSL_tag_is_masked(enum VSL_tag_e tag)
137
{
138 51068
        return (vsl_tag_is_masked(tag));
139
}
140
141
/*--------------------------------------------------------------------
142
 * Lay down a header fields, and return pointer to the next record
143
 */
144
145
static inline uint32_t *
146 12065860
vsl_hdr(enum VSL_tag_e tag, uint32_t *p, unsigned len, vxid_t vxid)
147
{
148
149 12065860
        AZ((uintptr_t)p & 0x3);
150 12065860
        assert(tag > SLT__Bogus);
151 12065860
        assert(tag < SLT__Reserved);
152 12065860
        AZ(len & ~VSL_LENMASK);
153
154 12065860
        p[2] = vxid.vxid >> 32;
155 12065860
        p[1] = vxid.vxid;
156 24131720
        p[0] = (((unsigned)tag & VSL_IDMASK) << VSL_IDSHIFT) |
157 12065860
             (VSL_VERSION_3 << VSL_VERSHIFT) |
158 12065860
             len;
159 12065860
        return (VSL_END(p, len));
160
}
161
162
/*--------------------------------------------------------------------
163
 * Space available in a VSL buffer when accounting for overhead
164
 */
165
166
static unsigned
167 2933103
vsl_space(const struct vsl_log *vsl)
168
{
169
        ptrdiff_t mlen;
170
171 2933103
        mlen = vsl->wle - vsl->wlp;
172 2933103
        assert(mlen >= 0);
173 2933103
        if (mlen < VSL_OVERHEAD + 1)
174 80
                return (0);
175 2933023
        mlen -= VSL_OVERHEAD;
176 2933023
        mlen *= sizeof *vsl->wlp;
177 2933023
        if (mlen > cache_param->vsl_reclen)
178 2932299
                mlen = cache_param->vsl_reclen;
179 2933023
        return(mlen);
180 2933103
}
181
182
/*--------------------------------------------------------------------
183
 * Wrap the VSL buffer
184
 */
185
186
static void
187 0
vsl_wrap(void)
188
{
189
190 0
        assert(vsl_ptr >= vsl_head->log);
191 0
        assert(vsl_ptr < vsl_end);
192 0
        vsl_segment_n += VSL_SEGMENTS - (vsl_segment_n % VSL_SEGMENTS);
193 0
        assert(vsl_segment_n % VSL_SEGMENTS == 0);
194 0
        vsl_head->offset[0] = 0;
195 0
        vsl_head->log[0] = VSL_ENDMARKER;
196 0
        VWMB();
197 0
        if (vsl_ptr != vsl_head->log) {
198 0
                *vsl_ptr = VSL_WRAPMARKER;
199 0
                vsl_ptr = vsl_head->log;
200 0
        }
201 0
        vsl_head->segment_n = vsl_segment_n;
202 0
        VSC_C_main->shm_cycles++;
203 0
}
204
205
/*--------------------------------------------------------------------
206
 * Reserve bytes for a record, wrap if necessary
207
 */
208
209
static uint32_t *
210 3578278
vsl_get(unsigned len, unsigned records, unsigned flushes)
211
{
212
        uint32_t *p;
213
        int err;
214
215 3578278
        err = pthread_mutex_trylock(&vsl_mtx);
216 3578278
        if (err == EBUSY) {
217 22859
                PTOK(pthread_mutex_lock(&vsl_mtx));
218 22859
                VSC_C_main->shm_cont++;
219 22859
        } else {
220 3555419
                AZ(err);
221
        }
222 3578278
        assert(vsl_ptr < vsl_end);
223 3578278
        AZ((uintptr_t)vsl_ptr & 0x3);
224
225 3578278
        VSC_C_main->shm_writes++;
226 3578278
        VSC_C_main->shm_flushes += flushes;
227 3578278
        VSC_C_main->shm_records += records;
228 3578278
        VSC_C_main->shm_bytes +=
229 3578278
            VSL_BYTES(VSL_OVERHEAD + VSL_WORDS((uint64_t)len));
230
231
        /* Wrap if necessary */
232 3578278
        if (VSL_END(vsl_ptr, len) >= vsl_end)
233 0
                vsl_wrap();
234
235 3578278
        p = vsl_ptr;
236 3578278
        vsl_ptr = VSL_END(vsl_ptr, len);
237 3578278
        assert(vsl_ptr < vsl_end);
238 3578278
        AZ((uintptr_t)vsl_ptr & 0x3);
239
240 3578278
        *vsl_ptr = VSL_ENDMARKER;
241
242 3578358
        while ((vsl_ptr - vsl_head->log) / vsl_segsize >
243 3578358
            vsl_segment_n % VSL_SEGMENTS) {
244 80
                vsl_segment_n++;
245 80
                vsl_head->offset[vsl_segment_n % VSL_SEGMENTS] =
246 80
                    vsl_ptr - vsl_head->log;
247
        }
248
249 3578278
        PTOK(pthread_mutex_unlock(&vsl_mtx));
250
        /* Implicit VWMB() in mutex op ensures ENDMARKER and new table
251
           values are seen before new segment number */
252 3578278
        vsl_head->segment_n = vsl_segment_n;
253
254 3578278
        return (p);
255
}
256
257
/*--------------------------------------------------------------------
258
 * Stick a finished record into VSL.
259
 */
260
261
static void
262 2325150
vslr(enum VSL_tag_e tag, vxid_t vxid, const char *b, unsigned len)
263
{
264
        uint32_t *p;
265
        unsigned mlen;
266
267 2325150
        mlen = cache_param->vsl_reclen;
268
269
        /* Truncate */
270 2325150
        if (len > mlen)
271 0
                len = mlen;
272
273 2325150
        p = vsl_get(len, 1, 0);
274
275 2325150
        memcpy(p + VSL_OVERHEAD, b, len);
276
277
        /*
278
         * the vxid needs to be written before the barrier to
279
         * ensure it is valid when vsl_hdr() marks the record
280
         * ready by writing p[0]
281
         */
282 2325150
        p[2] = vxid.vxid >> 32;
283 2325150
        p[1] = vxid.vxid;
284 2325150
        VWMB();
285 2325150
        (void)vsl_hdr(tag, p, len, vxid);
286 2325150
}
287
288
/*--------------------------------------------------------------------
289
 * Add a unbuffered record to VSL
290
 *
291
 * NB: This variant should be used sparingly and only for low volume
292
 * NB: since it significantly adds to the mutex load on the VSL.
293
 */
294
295
void
296 3124081
VSLv(enum VSL_tag_e tag, vxid_t vxid, const char *fmt, va_list ap)
297
{
298 3124081
        unsigned n, mlen = cache_param->vsl_reclen;
299 3124081
        char buf[mlen];
300
301 3124081
        AN(fmt);
302 3124081
        if (vsl_tag_is_masked(tag))
303 806902
                return;
304
305 2317179
        if (strchr(fmt, '%') == NULL) {
306 45895
                vslr(tag, vxid, fmt, strlen(fmt) + 1);
307 45895
        } else {
308 2271284
                n = vsnprintf(buf, mlen, fmt, ap);
309 2271284
                n = vmin(n, mlen - 1);
310 2271284
                buf[n++] = '\0'; /* NUL-terminated */
311 2271284
                vslr(tag, vxid, buf, n);
312
        }
313
314 3124081
}
315
316
void
317 7960
VSLs(enum VSL_tag_e tag, vxid_t vxid, const struct strands *s)
318
{
319 7960
        unsigned n, mlen = cache_param->vsl_reclen;
320 7960
        char buf[mlen];
321
322 7960
        if (vsl_tag_is_masked(tag))
323 0
                return;
324
325 7960
        n = strands_cat(buf, mlen, s);
326
327 7960
        vslr(tag, vxid, buf, n);
328 7960
}
329
330
void
331 3058352
VSL(enum VSL_tag_e tag, vxid_t vxid, const char *fmt, ...)
332
{
333
        va_list ap;
334
335 3058352
        va_start(ap, fmt);
336 3058352
        VSLv(tag, vxid, fmt, ap);
337 3058352
        va_end(ap);
338 3058352
}
339
340
/*--------------------------------------------------------------------*/
341
342
void
343 1577214
VSL_Flush(struct vsl_log *vsl, int overflow)
344
{
345
        uint32_t *p;
346
        unsigned l;
347
348 1577214
        vsl_sanity(vsl);
349 1577214
        l = pdiff(vsl->wlb, vsl->wlp);
350 1577214
        if (l == 0)
351 327989
                return;
352
353 1249225
        assert(l >= 8);
354
355 1249225
        p = vsl_get(l, vsl->wlr, overflow);
356
357 1249225
        memcpy(p + VSL_OVERHEAD, vsl->wlb, l);
358 1249225
        p[1] = l;
359 1249225
        VWMB();
360 1249225
        p[0] = ((((unsigned)SLT__Batch & 0xff) << VSL_IDSHIFT));
361 1249225
        vsl->wlp = vsl->wlb;
362 1249225
        vsl->wlr = 0;
363 1577214
}
364
365
/*--------------------------------------------------------------------
366
 * Buffered VSLs
367
 */
368
369
static char *
370 9685033
vslb_get(struct vsl_log *vsl, enum VSL_tag_e tag, unsigned *length)
371
{
372 9685033
        unsigned mlen = cache_param->vsl_reclen;
373
        char *retval;
374
375 9685033
        vsl_sanity(vsl);
376 9685033
        if (*length < mlen)
377 9662525
                mlen = *length;
378
379 9685033
        if (VSL_END(vsl->wlp, mlen) > vsl->wle)
380 280
                VSL_Flush(vsl, 1);
381
382 9685033
        retval = VSL_DATA(vsl->wlp);
383
384
        /* If it still doesn't fit, truncate */
385 9685033
        if (VSL_END(vsl->wlp, mlen) > vsl->wle)
386 80
                mlen = vsl_space(vsl);
387
388 9685033
        vsl->wlp = vsl_hdr(tag, vsl->wlp, mlen, vsl->wid);
389 9685033
        vsl->wlr++;
390 9685033
        *length = mlen;
391 9685033
        return (retval);
392
}
393
394
static void
395 4773857
vslb_simple(struct vsl_log *vsl, enum VSL_tag_e tag,
396
    unsigned length, const char *str)
397
{
398
        char *p;
399
400 4773857
        if (length == 0)
401 372974
                length = strlen(str);
402 4773857
        length += 1; // NUL
403 4773857
        p = vslb_get(vsl, tag, &length);
404 4773857
        memcpy(p, str, length - 1);
405 4773857
        p[length - 1] = '\0';
406
407 4773857
        if (DO_DEBUG(DBG_SYNCVSL))
408 463731
                VSL_Flush(vsl, 0);
409 4773857
}
410
411
/*--------------------------------------------------------------------
412
 * VSL-buffered-txt
413
 */
414
415
void
416 5357944
VSLbt(struct vsl_log *vsl, enum VSL_tag_e tag, txt t)
417
{
418
419 5357944
        Tcheck(t);
420 5357944
        if (vsl_tag_is_masked(tag))
421 706832
                return;
422
423 4651112
        vslb_simple(vsl, tag, Tlen(t), t.b);
424 5357944
}
425
426
/*--------------------------------------------------------------------
427
 * VSL-buffered-strands
428
 */
429
void
430 2346249
VSLbs(struct vsl_log *vsl, enum VSL_tag_e tag, const struct strands *s)
431
{
432
        unsigned l;
433
        char *p;
434
435 2346249
        if (vsl_tag_is_masked(tag))
436 363525
                return;
437
438 1982724
        l = strands_len(s) + 1;
439 1982724
        p = vslb_get(vsl, tag, &l);
440
441 1982724
        (void)strands_cat(p, l, s);
442
443 1982724
        if (DO_DEBUG(DBG_SYNCVSL))
444 184832
                VSL_Flush(vsl, 0);
445 2346249
}
446
447
/*--------------------------------------------------------------------
448
 * VSL-buffered
449
 */
450
451
void
452 3650938
VSLbv(struct vsl_log *vsl, enum VSL_tag_e tag, const char *fmt, va_list ap)
453
{
454
        char *p, *p1;
455 3650938
        unsigned n = 0, mlen;
456
        va_list ap2;
457
458 3650938
        AN(fmt);
459 3650938
        if (vsl_tag_is_masked(tag))
460 594588
                return;
461
462
        /*
463
         * If there are no printf-expansions, don't waste time expanding them
464
         */
465 3056350
        if (strchr(fmt, '%') == NULL) {
466 122067
                vslb_simple(vsl, tag, 0, fmt);
467 122067
                return;
468
        }
469
470
        /*
471
         * If the format is trivial, deal with it directly
472
         */
473 2934283
        if (!strcmp(fmt, "%s")) {
474 720
                p1 = va_arg(ap, char *);
475 720
                vslb_simple(vsl, tag, 0, p1);
476 720
                return;
477
        }
478
479 2933563
        vsl_sanity(vsl);
480
481 2933563
        mlen = vsl_space(vsl);
482
483
        // First attempt, only if any space at all
484 2933563
        if (mlen > 0) {
485 2931996
                p = VSL_DATA(vsl->wlp);
486 2931996
                va_copy(ap2, ap);
487 2931996
                n = vsnprintf(p, mlen, fmt, ap2);
488 2931996
                va_end(ap2);
489 2931996
        }
490
491
        // Second attempt, if a flush might help
492 2933563
        if (mlen == 0 || (n + 1 > mlen && n + 1 <= cache_param->vsl_reclen)) {
493 2428
                VSL_Flush(vsl, 1);
494 2428
                mlen = vsl_space(vsl);
495 2428
                p = VSL_DATA(vsl->wlp);
496 2428
                n = vsnprintf(p, mlen, fmt, ap);
497 2428
        }
498 2934043
        if (n + 1 < mlen)
499 2923323
                mlen = n + 1;
500 2934043
        (void)vslb_get(vsl, tag, &mlen);
501
502 2934043
        if (DO_DEBUG(DBG_SYNCVSL))
503 345901
                VSL_Flush(vsl, 0);
504 3651418
}
505
506
void
507 3511967
VSLb(struct vsl_log *vsl, enum VSL_tag_e tag, const char *fmt, ...)
508
{
509
        va_list ap;
510
511 3511967
        vsl_sanity(vsl);
512 3511967
        va_start(ap, fmt);
513 3511967
        VSLbv(vsl, tag, fmt, ap);
514 3511967
        va_end(ap);
515 3511967
}
516
517
#define Tf6 "%ju.%06ju"
518
#define Ta6(t) (uintmax_t)floor((t)), (uintmax_t)floor((t) * 1e6) % 1000000U
519
520
void
521 1319832
VSLb_ts(struct vsl_log *vsl, const char *event, vtim_real first,
522
    vtim_real *pprev, vtim_real now)
523
{
524
525
        /*
526
         * XXX: Make an option to turn off some unnecessary timestamp
527
         * logging. This must be done carefully because some functions
528
         * (e.g. V1L_Open) takes the last timestamp as its initial
529
         * value for timeout calculation.
530
         */
531 1319832
        vsl_sanity(vsl);
532 1319832
        AN(event);
533 1319832
        AN(pprev);
534 1319832
        assert(!isnan(now) && now != 0.);
535 2639664
        VSLb(vsl, SLT_Timestamp, "%s: " Tf6 " " Tf6 " " Tf6,
536 1319832
            event, Ta6(now), Ta6(now - first), Ta6(now - *pprev));
537 1319832
        *pprev = now;
538 1319832
}
539
540
void
541 111967
VSLb_bin(struct vsl_log *vsl, enum VSL_tag_e tag, ssize_t len, const void *ptr)
542
{
543
        unsigned mlen;
544
        char *p;
545
546 111967
        vsl_sanity(vsl);
547 111967
        AN(ptr);
548 111967
        if (vsl_tag_is_masked(tag))
549 52327
                return;
550 59640
        mlen = cache_param->vsl_reclen;
551
552
        /* Truncate */
553 59640
        len = vmin_t(ssize_t, len, mlen);
554
555 59640
        assert(vsl->wlp <= vsl->wle);
556
557
        /* Flush if necessary */
558 59640
        if (VSL_END(vsl->wlp, len) > vsl->wle)
559 360
                VSL_Flush(vsl, 1);
560 59640
        assert(VSL_END(vsl->wlp, len) <= vsl->wle);
561 59640
        p = VSL_DATA(vsl->wlp);
562 59640
        memcpy(p, ptr, len);
563 59640
        vsl->wlp = vsl_hdr(tag, vsl->wlp, len, vsl->wid);
564 59640
        assert(vsl->wlp <= vsl->wle);
565 59640
        vsl->wlr++;
566
567 59640
        if (DO_DEBUG(DBG_SYNCVSL))
568 25000
                VSL_Flush(vsl, 0);
569 111967
}
570
571
/*--------------------------------------------------------------------
572
 * Setup a VSL buffer, allocate space if none provided.
573
 */
574
575
void
576 329081
VSL_Setup(struct vsl_log *vsl, void *ptr, size_t len)
577
{
578
579 329081
        if (ptr == NULL) {
580 114012
                len = cache_param->vsl_buffer;
581 114012
                ptr = malloc(len);
582 114012
                AN(ptr);
583 114012
        }
584 329081
        vsl->wlp = ptr;
585 329081
        vsl->wlb = ptr;
586 329081
        vsl->wle = ptr;
587 329081
        vsl->wle += len / sizeof(*vsl->wle);
588 329081
        vsl->wlr = 0;
589 329081
        vsl->wid = NO_VXID;
590 329081
        vsl_sanity(vsl);
591 329081
}
592
593
/*--------------------------------------------------------------------*/
594
595
void
596 3902
VSL_ChgId(struct vsl_log *vsl, const char *typ, const char *why, vxid_t vxid)
597
{
598
        vxid_t ovxid;
599
600 3902
        vsl_sanity(vsl);
601 3902
        ovxid = vsl->wid;
602 3902
        VSLb(vsl, SLT_Link, "%s %ju %s", typ, VXID(vxid), why);
603 3902
        VSL_End(vsl);
604 3902
        vsl->wid = vxid;
605 3902
        VSLb(vsl, SLT_Begin, "%s %ju %s", typ, VXID(ovxid), why);
606 3902
}
607
608
/*--------------------------------------------------------------------*/
609
610
void
611 250187
VSL_End(struct vsl_log *vsl)
612
{
613
        txt t;
614 250187
        char p[] = "";
615
616 250187
        vsl_sanity(vsl);
617 250187
        assert(!IS_NO_VXID(vsl->wid));
618 250187
        t.b = p;
619 250187
        t.e = p;
620 250187
        VSLbt(vsl, SLT_End, t);
621 250187
        VSL_Flush(vsl, 0);
622 250187
        vsl->wid = NO_VXID;
623 250187
}
624
625
static void v_matchproto_(vsm_lock_f)
626 1435119
vsm_vsc_lock(void)
627
{
628 1435119
        PTOK(pthread_mutex_lock(&vsc_mtx));
629 1435119
}
630
631
static void v_matchproto_(vsm_lock_f)
632 1435119
vsm_vsc_unlock(void)
633
{
634 1435119
        PTOK(pthread_mutex_unlock(&vsc_mtx));
635 1435119
}
636
637
static void v_matchproto_(vsm_lock_f)
638 1777533
vsm_vsmw_lock(void)
639
{
640 1777533
        PTOK(pthread_mutex_lock(&vsm_mtx));
641 1777533
}
642
643
static void v_matchproto_(vsm_lock_f)
644 1777533
vsm_vsmw_unlock(void)
645
{
646 1777533
        PTOK(pthread_mutex_unlock(&vsm_mtx));
647 1777533
}
648
649
/*--------------------------------------------------------------------*/
650
651
void
652 38034
VSM_Init(void)
653
{
654
        unsigned u;
655
656 38034
        assert(UINT_MAX % VSL_SEGMENTS == VSL_SEGMENTS - 1);
657
658 38034
        PTOK(pthread_mutex_init(&vsl_mtx, &mtxattr_errorcheck));
659 38034
        PTOK(pthread_mutex_init(&vsc_mtx, &mtxattr_errorcheck));
660 38034
        PTOK(pthread_mutex_init(&vsm_mtx, &mtxattr_errorcheck));
661
662 38034
        vsc_lock = vsm_vsc_lock;
663 38034
        vsc_unlock = vsm_vsc_unlock;
664 38034
        vsmw_lock = vsm_vsmw_lock;
665 38034
        vsmw_unlock = vsm_vsmw_unlock;
666
667 38034
        heritage.proc_vsmw = VSMW_New(heritage.vsm_fd, 0640, "_.index");
668 38034
        AN(heritage.proc_vsmw);
669
670 38034
        VSC_C_main = VSC_main_New(NULL, NULL, "");
671 38034
        AN(VSC_C_main);
672
673 38034
        AN(heritage.proc_vsmw);
674 76068
        vsl_head = VSMW_Allocf(heritage.proc_vsmw, NULL, VSL_CLASS,
675 38034
            cache_param->vsl_space, VSL_CLASS);
676 38034
        AN(vsl_head);
677 76068
        vsl_segsize = ((cache_param->vsl_space - sizeof *vsl_head) /
678 38034
            sizeof *vsl_end) / VSL_SEGMENTS;
679 38034
        vsl_end = vsl_head->log + vsl_segsize * VSL_SEGMENTS;
680
        /* Make segment_n always overflow on first log wrap to make any
681
           problems with regard to readers on that event visible */
682 38034
        vsl_segment_n = UINT_MAX - (VSL_SEGMENTS - 1);
683 38034
        AZ(vsl_segment_n % VSL_SEGMENTS);
684 38034
        vsl_ptr = vsl_head->log;
685 38034
        *vsl_ptr = VSL_ENDMARKER;
686
687 38034
        memset(vsl_head, 0, sizeof *vsl_head);
688 38034
        vsl_head->segsize = vsl_segsize;
689 38034
        vsl_head->offset[0] = 0;
690 38034
        vsl_head->segment_n = vsl_segment_n;
691 304272
        for (u = 1; u < VSL_SEGMENTS; u++)
692 266238
                vsl_head->offset[u] = -1;
693 38034
        VWMB();
694 38034
        memcpy(vsl_head->marker, VSL_HEAD_MARKER, sizeof vsl_head->marker);
695 38034
}