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 1135280
strands_len(const struct strands *s)
51
{
52 1135280
        unsigned r = 0;
53
        int i;
54
55 2272034
        for (i = 0; i < s->n; i++) {
56 1136754
                if (s->p[i] == NULL || *s->p[i] == '\0')
57 109082
                        continue;
58 1027672
                r += strlen(s->p[i]);
59 1027672
        }
60
61 1135280
        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 1139624
strands_cat(char *buf, unsigned bufl, const struct strands *s)
71
{
72 1139624
        unsigned l = 0, ll;
73
        int i;
74
75
        /* NUL-terminated */
76 1139624
        assert(bufl > 0);
77 1139624
        bufl--;
78
79 2173824
        for (i = 0; i < s->n && bufl > 0; i++) {
80 1034202
                if (s->p[i] == NULL || *s->p[i] == '\0')
81 60
                        continue;
82 1034150
                ll = vmin_t(unsigned, strlen(s->p[i]), bufl);
83 1034150
                memcpy(buf, s->p[i], ll);
84 1034150
                l += ll;
85 1034150
                buf += ll;
86 1034150
                bufl -= ll;
87 1034150
        }
88 1139622
        *buf = '\0';    /* NUL-terminated */
89 1139622
        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 11063969
vsl_sanity(const struct vsl_log *vsl)
107
{
108 11063969
        AN(vsl);
109 11063969
        AN(vsl->wlp);
110 11063969
        AN(vsl->wlb);
111 11063969
        AN(vsl->wle);
112 11063969
        assert(vsl->wlb <= vsl->wlp);
113 11063969
        assert(vsl->wlp <= vsl->wle);
114 11063969
}
115
116
/*--------------------------------------------------------------------
117
 * Check if the VSL_tag is masked by parameter bitmap
118
 */
119
120
static inline int
121 8341936
vsl_tag_is_masked(enum VSL_tag_e tag)
122
{
123 8341936
        volatile uint8_t *bm = &cache_param->vsl_mask[0];
124
        uint8_t b;
125
126 8341936
        assert(tag > SLT__Bogus);
127 8341936
        assert(tag < SLT__Reserved);
128 8341936
        bm += ((unsigned)tag >> 3);
129 8341936
        b = (0x80 >> ((unsigned)tag & 7));
130 8341936
        return (*bm & b);
131
}
132
133
int
134 20050
VSL_tag_is_masked(enum VSL_tag_e tag)
135
{
136 20050
        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 6881191
vsl_hdr(enum VSL_tag_e tag, uint32_t *p, unsigned len, vxid_t vxid)
145
{
146
147 6881191
        AZ((uintptr_t)p & 0x3);
148 6881191
        assert(tag > SLT__Bogus);
149 6881191
        assert(tag < SLT__Reserved);
150 6881191
        AZ(len & ~VSL_LENMASK);
151
152 6881191
        p[2] = vxid.vxid >> 32;
153 6881191
        p[1] = vxid.vxid;
154 13762382
        p[0] = (((unsigned)tag & VSL_IDMASK) << VSL_IDSHIFT) |
155 6881191
             (VSL_VERSION_3 << VSL_VERSHIFT) |
156 6881191
             len;
157 6881191
        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 1675635
vsl_space(const struct vsl_log *vsl)
166
{
167
        ptrdiff_t mlen;
168
169 1675635
        mlen = vsl->wle - vsl->wlp;
170 1675635
        assert(mlen >= 0);
171 1675635
        if (mlen < VSL_OVERHEAD + 1)
172 75
                return (0);
173 1675560
        mlen -= VSL_OVERHEAD;
174 1675560
        mlen *= sizeof *vsl->wlp;
175 1675560
        if (mlen > cache_param->vsl_reclen)
176 1675055
                mlen = cache_param->vsl_reclen;
177 1675560
        return(mlen);
178 1675635
}
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 1986412
vsl_get(unsigned len, unsigned records, unsigned flushes)
209
{
210
        uint32_t *p;
211
        int err;
212
213 1986412
        err = pthread_mutex_trylock(&vsl_mtx);
214 1986412
        if (err == EBUSY) {
215 10537
                PTOK(pthread_mutex_lock(&vsl_mtx));
216 10537
                VSC_C_main->shm_cont++;
217 10537
        } else {
218 1975875
                AZ(err);
219
        }
220 1986412
        assert(vsl_ptr < vsl_end);
221 1986412
        AZ((uintptr_t)vsl_ptr & 0x3);
222
223 1986412
        VSC_C_main->shm_writes++;
224 1986412
        VSC_C_main->shm_flushes += flushes;
225 1986412
        VSC_C_main->shm_records += records;
226 1986412
        VSC_C_main->shm_bytes +=
227 1986412
            VSL_BYTES(VSL_OVERHEAD + VSL_WORDS((uint64_t)len));
228
229
        /* Wrap if necessary */
230 1986412
        if (VSL_END(vsl_ptr, len) >= vsl_end)
231 0
                vsl_wrap();
232
233 1986412
        p = vsl_ptr;
234 1986412
        vsl_ptr = VSL_END(vsl_ptr, len);
235 1986412
        assert(vsl_ptr < vsl_end);
236 1986412
        AZ((uintptr_t)vsl_ptr & 0x3);
237
238 1986412
        *vsl_ptr = VSL_ENDMARKER;
239
240 1986462
        while ((vsl_ptr - vsl_head->log) / vsl_segsize >
241 1986462
            vsl_segment_n % VSL_SEGMENTS) {
242 50
                vsl_segment_n++;
243 50
                vsl_head->offset[vsl_segment_n % VSL_SEGMENTS] =
244 50
                    vsl_ptr - vsl_head->log;
245
        }
246
247 1986412
        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 1986412
        vsl_head->segment_n = vsl_segment_n;
251
252 1986412
        return (p);
253
}
254
255
/*--------------------------------------------------------------------
256
 * Stick a finished record into VSL.
257
 */
258
259
static void
260 1345639
vslr(enum VSL_tag_e tag, vxid_t vxid, const char *b, unsigned len)
261
{
262
        uint32_t *p;
263
        unsigned mlen;
264
265 1345639
        mlen = cache_param->vsl_reclen;
266
267
        /* Truncate */
268 1345639
        if (len > mlen)
269 0
                len = mlen;
270
271 1345639
        p = vsl_get(len, 1, 0);
272
273 1345639
        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 1345639
        p[2] = vxid.vxid >> 32;
281 1345639
        p[1] = vxid.vxid;
282 1345639
        VWMB();
283 1345639
        (void)vsl_hdr(tag, p, len, vxid);
284 1345639
}
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 1833704
VSLv(enum VSL_tag_e tag, vxid_t vxid, const char *fmt, va_list ap)
295
{
296 1833704
        unsigned n, mlen = cache_param->vsl_reclen;
297 1833704
        char buf[mlen];
298
299 1833704
        AN(fmt);
300 1833704
        if (vsl_tag_is_masked(tag))
301 492590
                return;
302
303 1341114
        if (strchr(fmt, '%') == NULL) {
304 23008
                vslr(tag, vxid, fmt, strlen(fmt) + 1);
305 23008
        } else {
306 1318106
                n = vsnprintf(buf, mlen, fmt, ap);
307 1318106
                n = vmin(n, mlen - 1);
308 1318106
                buf[n++] = '\0'; /* NUL-terminated */
309 1318106
                vslr(tag, vxid, buf, n);
310
        }
311
312 1833704
}
313
314
void
315 4500
VSLs(enum VSL_tag_e tag, vxid_t vxid, const struct strands *s)
316
{
317 4500
        unsigned n, mlen = cache_param->vsl_reclen;
318 4500
        char buf[mlen];
319
320 4500
        if (vsl_tag_is_masked(tag))
321 0
                return;
322
323 4500
        n = strands_cat(buf, mlen, s);
324
325 4500
        vslr(tag, vxid, buf, n);
326 4500
}
327
328
void
329 1792607
VSL(enum VSL_tag_e tag, vxid_t vxid, const char *fmt, ...)
330
{
331
        va_list ap;
332
333 1792607
        va_start(ap, fmt);
334 1792607
        VSLv(tag, vxid, fmt, ap);
335 1792607
        va_end(ap);
336 1792607
}
337
338
/*--------------------------------------------------------------------*/
339
340
void
341 817284
VSL_Flush(struct vsl_log *vsl, int overflow)
342
{
343
        uint32_t *p;
344
        unsigned l;
345
346 817284
        vsl_sanity(vsl);
347 817284
        l = pdiff(vsl->wlb, vsl->wlp);
348 817284
        if (l == 0)
349 177999
                return;
350
351 639285
        assert(l >= 8);
352
353 639285
        p = vsl_get(l, vsl->wlr, overflow);
354
355 639285
        memcpy(p + VSL_OVERHEAD, vsl->wlb, l);
356 639285
        p[1] = l;
357 639285
        VWMB();
358 639285
        p[0] = ((((unsigned)SLT__Batch & 0xff) << VSL_IDSHIFT));
359 639285
        vsl->wlp = vsl->wlb;
360 639285
        vsl->wlr = 0;
361 817284
}
362
363
/*--------------------------------------------------------------------
364
 * Buffered VSLs
365
 */
366
367
static char *
368 5504245
vslb_get(struct vsl_log *vsl, enum VSL_tag_e tag, unsigned *length)
369
{
370 5504245
        unsigned mlen = cache_param->vsl_reclen;
371
        char *retval;
372
373 5504245
        vsl_sanity(vsl);
374 5504245
        if (*length < mlen)
375 5490107
                mlen = *length;
376
377 5504245
        if (VSL_END(vsl->wlp, mlen) > vsl->wle)
378 200
                VSL_Flush(vsl, 1);
379
380 5504245
        retval = VSL_DATA(vsl->wlp);
381
382
        /* If it still doesn't fit, truncate */
383 5504245
        if (VSL_END(vsl->wlp, mlen) > vsl->wle)
384 50
                mlen = vsl_space(vsl);
385
386 5504245
        vsl->wlp = vsl_hdr(tag, vsl->wlp, mlen, vsl->wid);
387 5504245
        vsl->wlr++;
388 5504245
        *length = mlen;
389 5504245
        return (retval);
390
}
391
392
static void
393 2695251
vslb_simple(struct vsl_log *vsl, enum VSL_tag_e tag,
394
    unsigned length, const char *str)
395
{
396
        char *p;
397
398 2695251
        if (length == 0)
399 171577
                length = strlen(str);
400 2695251
        length += 1; // NUL
401 2695251
        p = vslb_get(vsl, tag, &length);
402 2695251
        memcpy(p, str, length - 1);
403 2695251
        p[length - 1] = '\0';
404
405 2695251
        if (DO_DEBUG(DBG_SYNCVSL))
406 230017
                VSL_Flush(vsl, 0);
407 2695251
}
408
409
/*--------------------------------------------------------------------
410
 * VSL-buffered-txt
411
 */
412
413
void
414 3084459
VSLbt(struct vsl_log *vsl, enum VSL_tag_e tag, txt t)
415
{
416
417 3084459
        Tcheck(t);
418 3084459
        if (vsl_tag_is_masked(tag))
419 416396
                return;
420
421 2668063
        vslb_simple(vsl, tag, Tlen(t), t.b);
422 3084459
}
423
424
/*--------------------------------------------------------------------
425
 * VSL-buffered-strands
426
 */
427
void
428 1347839
VSLbs(struct vsl_log *vsl, enum VSL_tag_e tag, const struct strands *s)
429
{
430
        unsigned l;
431
        char *p;
432
433 1347839
        if (vsl_tag_is_masked(tag))
434 212539
                return;
435
436 1135300
        l = strands_len(s) + 1;
437 1135300
        p = vslb_get(vsl, tag, &l);
438
439 1135300
        (void)strands_cat(p, l, s);
440
441 1135300
        if (DO_DEBUG(DBG_SYNCVSL))
442 91549
                VSL_Flush(vsl, 0);
443 1347839
}
444
445
/*--------------------------------------------------------------------
446
 * VSL-buffered
447
 */
448
449
void
450 1997650
VSLbv(struct vsl_log *vsl, enum VSL_tag_e tag, const char *fmt, va_list ap)
451
{
452
        char *p, *p1;
453 1997650
        unsigned n = 0, mlen;
454
        va_list ap2;
455
456 1997650
        AN(fmt);
457 1997650
        if (vsl_tag_is_masked(tag))
458 294761
                return;
459
460
        /*
461
         * If there are no printf-expansions, don't waste time expanding them
462
         */
463 1702889
        if (strchr(fmt, '%') == NULL) {
464 27219
                vslb_simple(vsl, tag, 0, fmt);
465 27219
                return;
466
        }
467
468
        /*
469
         * If the format is trivial, deal with it directly
470
         */
471 1675670
        if (!strcmp(fmt, "%s")) {
472 0
                p1 = va_arg(ap, char *);
473 0
                vslb_simple(vsl, tag, 0, p1);
474 0
                return;
475
        }
476
477 1675670
        vsl_sanity(vsl);
478
479 1675670
        mlen = vsl_space(vsl);
480
481
        // First attempt, only if any space at all
482 1675670
        if (mlen > 0) {
483 1675298
                p = VSL_DATA(vsl->wlp);
484 1675298
                va_copy(ap2, ap);
485 1675298
                n = vsnprintf(p, mlen, fmt, ap2);
486 1675298
                va_end(ap2);
487 1675298
        }
488
489
        // Second attempt, if a flush might help
490 1675670
        if (mlen == 0 || (n + 1 > mlen && n + 1 <= cache_param->vsl_reclen)) {
491 1341
                VSL_Flush(vsl, 1);
492 1341
                mlen = vsl_space(vsl);
493 1341
                p = VSL_DATA(vsl->wlp);
494 1341
                n = vsnprintf(p, mlen, fmt, ap);
495 1341
        }
496 1675920
        if (n + 1 < mlen)
497 1669262
                mlen = n + 1;
498 1675920
        (void)vslb_get(vsl, tag, &mlen);
499
500 1675920
        if (DO_DEBUG(DBG_SYNCVSL))
501 167985
                VSL_Flush(vsl, 0);
502 1997900
}
503
504
void
505 1919023
VSLb(struct vsl_log *vsl, enum VSL_tag_e tag, const char *fmt, ...)
506
{
507
        va_list ap;
508
509 1919023
        vsl_sanity(vsl);
510 1919023
        va_start(ap, fmt);
511 1919023
        VSLbv(vsl, tag, fmt, ap);
512 1919023
        va_end(ap);
513 1919023
}
514
515
#define Tf6 "%ju.%06ju"
516
#define Ta6(t) (uintmax_t)floor((t)), (uintmax_t)floor((t) * 1e6) % 1000000U
517
518
void
519 764918
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 764918
        vsl_sanity(vsl);
530 764918
        AN(event);
531 764918
        AN(pprev);
532 764918
        assert(!isnan(now) && now != 0.);
533 1529836
        VSLb(vsl, SLT_Timestamp, "%s: " Tf6 " " Tf6 " " Tf6,
534 764918
            event, Ta6(now), Ta6(now - first), Ta6(now - *pprev));
535 764918
        *pprev = now;
536 764918
}
537
538
void
539 58675
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 58675
        vsl_sanity(vsl);
545 58675
        AN(ptr);
546 58675
        if (vsl_tag_is_masked(tag))
547 24425
                return;
548 34250
        mlen = cache_param->vsl_reclen;
549
550
        /* Truncate */
551 34250
        len = vmin_t(ssize_t, len, mlen);
552
553 34250
        assert(vsl->wlp <= vsl->wle);
554
555
        /* Flush if necessary */
556 34250
        if (VSL_END(vsl->wlp, len) > vsl->wle)
557 225
                VSL_Flush(vsl, 1);
558 34250
        assert(VSL_END(vsl->wlp, len) <= vsl->wle);
559 34250
        p = VSL_DATA(vsl->wlp);
560 34250
        memcpy(p, ptr, len);
561 34250
        vsl->wlp = vsl_hdr(tag, vsl->wlp, len, vsl->wid);
562 34250
        assert(vsl->wlp <= vsl->wle);
563 34250
        vsl->wlr++;
564
565 34250
        if (DO_DEBUG(DBG_SYNCVSL))
566 14300
                VSL_Flush(vsl, 0);
567 58675
}
568
569
/*--------------------------------------------------------------------
570
 * Setup a VSL buffer, allocate space if none provided.
571
 */
572
573
void
574 191174
VSL_Setup(struct vsl_log *vsl, void *ptr, size_t len)
575
{
576
577 191174
        if (ptr == NULL) {
578 66535
                len = cache_param->vsl_buffer;
579 66535
                ptr = malloc(len);
580 66535
                AN(ptr);
581 66535
        }
582 191174
        vsl->wlp = ptr;
583 191174
        vsl->wlb = ptr;
584 191174
        vsl->wle = ptr;
585 191174
        vsl->wle += len / sizeof(*vsl->wle);
586 191174
        vsl->wlr = 0;
587 191174
        vsl->wid = NO_VXID;
588 191174
        vsl_sanity(vsl);
589 191174
}
590
591
/*--------------------------------------------------------------------*/
592
593
void
594 2275
VSL_ChgId(struct vsl_log *vsl, const char *typ, const char *why, vxid_t vxid)
595
{
596
        vxid_t ovxid;
597
598 2275
        vsl_sanity(vsl);
599 2275
        ovxid = vsl->wid;
600 2275
        VSLb(vsl, SLT_Link, "%s %ju %s", typ, VXID(vxid), why);
601 2275
        VSL_End(vsl);
602 2275
        vsl->wid = vxid;
603 2275
        VSLb(vsl, SLT_Begin, "%s %ju %s", typ, VXID(ovxid), why);
604 2275
}
605
606
/*--------------------------------------------------------------------*/
607
608
void
609 144356
VSL_End(struct vsl_log *vsl)
610
{
611
        txt t;
612 144356
        char p[] = "";
613
614 144356
        vsl_sanity(vsl);
615 144356
        assert(!IS_NO_VXID(vsl->wid));
616 144356
        t.b = p;
617 144356
        t.e = p;
618 144356
        VSLbt(vsl, SLT_End, t);
619 144356
        VSL_Flush(vsl, 0);
620 144356
        vsl->wid = NO_VXID;
621 144356
}
622
623
static void v_matchproto_(vsm_lock_f)
624 727322
vsm_vsc_lock(void)
625
{
626 727322
        PTOK(pthread_mutex_lock(&vsc_mtx));
627 727322
}
628
629
static void v_matchproto_(vsm_lock_f)
630 727322
vsm_vsc_unlock(void)
631
{
632 727322
        PTOK(pthread_mutex_unlock(&vsc_mtx));
633 727322
}
634
635
static void v_matchproto_(vsm_lock_f)
636 883097
vsm_vsmw_lock(void)
637
{
638 883097
        PTOK(pthread_mutex_lock(&vsm_mtx));
639 883097
}
640
641
static void v_matchproto_(vsm_lock_f)
642 883097
vsm_vsmw_unlock(void)
643
{
644 883097
        PTOK(pthread_mutex_unlock(&vsm_mtx));
645 883097
}
646
647
/*--------------------------------------------------------------------*/
648
649
void
650 22197
VSM_Init(void)
651
{
652
        unsigned u;
653
654 22197
        assert(UINT_MAX % VSL_SEGMENTS == VSL_SEGMENTS - 1);
655
656 22197
        PTOK(pthread_mutex_init(&vsl_mtx, &mtxattr_errorcheck));
657 22197
        PTOK(pthread_mutex_init(&vsc_mtx, &mtxattr_errorcheck));
658 22197
        PTOK(pthread_mutex_init(&vsm_mtx, &mtxattr_errorcheck));
659
660 22197
        vsc_lock = vsm_vsc_lock;
661 22197
        vsc_unlock = vsm_vsc_unlock;
662 22197
        vsmw_lock = vsm_vsmw_lock;
663 22197
        vsmw_unlock = vsm_vsmw_unlock;
664
665 22197
        heritage.proc_vsmw = VSMW_New(heritage.vsm_fd, 0640, "_.index");
666 22197
        AN(heritage.proc_vsmw);
667
668 22197
        VSC_C_main = VSC_main_New(NULL, NULL, "");
669 22197
        AN(VSC_C_main);
670
671 22197
        AN(heritage.proc_vsmw);
672 44394
        vsl_head = VSMW_Allocf(heritage.proc_vsmw, NULL, VSL_CLASS,
673 22197
            cache_param->vsl_space, VSL_CLASS);
674 22197
        AN(vsl_head);
675 44394
        vsl_segsize = ((cache_param->vsl_space - sizeof *vsl_head) /
676 22197
            sizeof *vsl_end) / VSL_SEGMENTS;
677 22197
        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 22197
        vsl_segment_n = UINT_MAX - (VSL_SEGMENTS - 1);
681 22197
        AZ(vsl_segment_n % VSL_SEGMENTS);
682 22197
        vsl_ptr = vsl_head->log;
683 22197
        *vsl_ptr = VSL_ENDMARKER;
684
685 22197
        memset(vsl_head, 0, sizeof *vsl_head);
686 22197
        vsl_head->segsize = vsl_segsize;
687 22197
        vsl_head->offset[0] = 0;
688 22197
        vsl_head->segment_n = vsl_segment_n;
689 177576
        for (u = 1; u < VSL_SEGMENTS; u++)
690 155379
                vsl_head->offset[u] = -1;
691 22197
        VWMB();
692 22197
        memcpy(vsl_head->marker, VSL_HEAD_MARKER, sizeof vsl_head->marker);
693 22197
}