GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include "config.h"

#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>

#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "vdef.h"
#include "vas.h"
#include "miniobj.h"
#include "vmb.h"

#include "vqueue.h"
#include "vre.h"
#include "vsl_priv.h"

#include "vapi/vsl.h"
#include "vapi/vsm.h"

#include "vsl_api.h"

struct vslc_vsm {
        unsigned                        magic;
#define VSLC_VSM_MAGIC                  0x4D3903A6

        struct VSL_cursor               cursor;

        unsigned                        options;

        struct vsm                      *vsm;
        struct vsm_fantom               vf;

        const struct VSL_head           *head;
        const uint32_t                  *end;
        struct VSLC_ptr                 next;
};

static void
vslc_vsm_delete(const struct VSL_cursor *cursor)
{
        struct vslc_vsm *c;

        AN(cursor);
        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_VSM_MAGIC);
        AZ(VSM_Unmap(c->vsm, &c->vf));
        assert(&c->cursor == cursor);
        FREE_OBJ(c);
}

/*
 * We tolerate the fact that segment_n wraps around eventually: for the default
 * vsl_space of 80MB and 8 segments, each segment is 10MB long, so we wrap
 * roughly after 40 pebibytes (32bit) or 160 yobibytes (64bit) worth of vsl
 * written.
 *
 * The vsm_check would fail if a vslc paused while this amount of data was
 * written
 */

static enum vsl_check v_matchproto_(vslc_check_f)
vslc_vsm_check(const struct VSL_cursor *cursor, const struct VSLC_ptr *ptr)
{
        const struct vslc_vsm *c;
        unsigned dist;

        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_VSM_MAGIC);
        assert(&c->cursor == cursor);

        if (ptr->ptr == NULL)
                return (vsl_check_e_inval);

        dist = c->head->segment_n - ptr->priv;

        if (dist >= VSL_SEGMENTS - 2)
                /* Too close to continue */
                return (vsl_check_e_inval);
        if (dist >= VSL_SEGMENTS - 4)
                /* Warning level */
                return (vsl_check_warn);
        /* Safe */
        return (vsl_check_valid);
}

static enum vsl_status v_matchproto_(vslc_next_f)
vslc_vsm_next(const struct VSL_cursor *cursor)
{
        struct vslc_vsm *c;
        enum vsl_check i;
        uint32_t t;

        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_VSM_MAGIC);
        assert(&c->cursor == cursor);

        while (1) {
                i = vslc_vsm_check(&c->cursor, &c->next);
                if (i < vsl_check_warn) {
                        if (VSM_StillValid(c->vsm, &c->vf) != VSM_valid)
                                return (vsl_e_abandon);
                        else
                                return (vsl_e_overrun);
                }

                t = *(volatile const uint32_t *)c->next.ptr;
                AN(t);

                if (t == VSL_ENDMARKER) {
                        if (VSM_StillValid(c->vsm, &c->vf) != VSM_valid)
                                return (vsl_e_abandon);
                        if (c->options & VSL_COPT_TAILSTOP)
                                return (vsl_e_eof);
                        /* No new records available */
                        return (vsl_end);
                }

                /* New data observed. Ensure load ordering with the log
                 * writer. */
                VRMB();

                if (t == VSL_WRAPMARKER) {
                        /* Wrap around not possible at front */
                        assert(c->next.ptr != c->head->log);
                        c->next.ptr = c->head->log;
                        while (c->next.priv % VSL_SEGMENTS)
                                c->next.priv++;
                        continue;
                }

                c->cursor.rec = c->next;
                c->next.ptr = VSL_NEXT(c->next.ptr);

                if (VSL_TAG(c->cursor.rec.ptr) == SLT__Batch) {
                        if (!(c->options & VSL_COPT_BATCH))
                                /* Skip the batch record */
                                continue;
                        /* Next call will point to the first record past
                           the batch */
                        c->next.ptr +=
                            VSL_WORDS(VSL_BATCHLEN(c->cursor.rec.ptr));
                }

                while ((c->next.ptr - c->head->log) / c->head->segsize >
                    c->next.priv % VSL_SEGMENTS)
                        c->next.priv++;

                assert(c->next.ptr >= c->head->log);
                assert(c->next.ptr < c->end);

                return (vsl_more);
        }
}

static enum vsl_status v_matchproto_(vslc_reset_f)
vslc_vsm_reset(const struct VSL_cursor *cursor)
{
        struct vslc_vsm *c;
        unsigned u, segment_n;
        enum vsl_status r;

        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_VSM_MAGIC);
        assert(&c->cursor == cursor);
        c->cursor.rec.ptr = NULL;

        segment_n = c->head->segment_n;
        /* Make sure offset table is not stale compared to segment_n */
        VRMB();

        if (c->options & VSL_COPT_TAIL) {
                /* Start in the same segment varnishd currently is in and
                   run forward until we see the end */
                u = c->next.priv = segment_n;
                assert(c->head->offset[c->next.priv % VSL_SEGMENTS] >= 0);
                c->next.ptr = c->head->log +
                    c->head->offset[c->next.priv % VSL_SEGMENTS];
                do {
                        if (c->head->segment_n - u > 1) {
                                /* Give up if varnishd is moving faster
                                   than us */
                                return (vsl_e_overrun);
                        }
                        r = vslc_vsm_next(&c->cursor);
                } while (r == vsl_more);
                if (r != vsl_end)
                        return (r);
        } else {
                /* Starting (VSL_SEGMENTS - 3) behind varnishd. This way
                 * even if varnishd advances segment_n immediately, we'll
                 * still have a full segment worth of log before the
                 * general constraint of at least 2 segments apart will be
                 * broken.
                 */
                c->next.priv = segment_n - (VSL_SEGMENTS - 3);
                while (c->head->offset[c->next.priv % VSL_SEGMENTS] < 0) {
                        /* seg 0 must be initialized */
                        assert(c->next.priv % VSL_SEGMENTS != 0);
                        c->next.priv++;
                }
                assert(c->head->offset[c->next.priv % VSL_SEGMENTS] >= 0);
                c->next.ptr = c->head->log +
                    c->head->offset[c->next.priv % VSL_SEGMENTS];
        }
        assert(c->next.ptr >= c->head->log);
        assert(c->next.ptr < c->end);
        return (vsl_end);
}

static const struct vslc_tbl vslc_vsm_tbl = {
        .magic          = VSLC_TBL_MAGIC,
        .delete         = vslc_vsm_delete,
        .next           = vslc_vsm_next,
        .reset          = vslc_vsm_reset,
        .check          = vslc_vsm_check,
};

struct VSL_cursor *
VSL_CursorVSM(struct VSL_data *vsl, struct vsm *vsm, unsigned options)
{
        struct vslc_vsm *c;
        struct vsm_fantom vf;
        struct VSL_head *head;
        enum vsl_status r;

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);

        if (!VSM_Get(vsm, &vf, VSL_CLASS, NULL)) {
                (void)vsl_diag(vsl,
                    "No VSL chunk found (child not started ?)");
                return (NULL);
        }
        if (VSM_Map(vsm, &vf)) {
                (void)vsl_diag(vsl,
                    "VSM_Map(): %s", VSM_Error(vsm));
                return (NULL);
        }
        AN(vf.b);

        head = vf.b;
        if (memcmp(head->marker, VSL_HEAD_MARKER, sizeof head->marker)) {
                AZ(VSM_Unmap(vsm, &vf));
                (void)vsl_diag(vsl, "Not a VSL chunk");
                return (NULL);
        }
        ALLOC_OBJ(c, VSLC_VSM_MAGIC);
        if (c == NULL) {
                AZ(VSM_Unmap(vsm, &vf));
                (void)vsl_diag(vsl, "Out of memory");
                return (NULL);
        }
        c->cursor.priv_tbl = &vslc_vsm_tbl;
        c->cursor.priv_data = c;

        c->options = options;
        c->vsm = vsm;
        c->vf = vf;
        c->head = head;
        c->end = c->head->log + c->head->segsize * VSL_SEGMENTS;
        assert(c->end <= (const uint32_t *)vf.e);

        r = vslc_vsm_reset(&c->cursor);
        if (r != vsl_end) {
                AZ(VSM_Unmap(vsm, &vf));
                (void)vsl_diag(vsl, "Cursor initialization failure (%d)", r);
                FREE_OBJ(c);
                return (NULL);
        }

        return (&c->cursor);
}

struct vslc_file {
        unsigned                        magic;
#define VSLC_FILE_MAGIC                 0x1D65FFEF

        int                             fd;
        int                             close_fd;
        ssize_t                         buflen;
        uint32_t                        *buf;

        struct VSL_cursor               cursor;

};

static void
vslc_file_delete(const struct VSL_cursor *cursor)
{
        struct vslc_file *c;

        AN(cursor);
        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_FILE_MAGIC);
        assert(&c->cursor == cursor);
        if (c->close_fd)
                (void)close(c->fd);
        if (c->buf != NULL)
                free(c->buf);
        FREE_OBJ(c);
}

/* Read n bytes from fd into buf */
static ssize_t
vslc_file_readn(int fd, void *buf, ssize_t n)
{
        ssize_t t = 0;
        ssize_t l;

        while (t < n) {
                l = read(fd, (char *)buf + t, n - t);
                if (l <= 0)
                        return (l);
                t += l;
        }
        return (t);
}

static enum vsl_status v_matchproto_(vslc_next_f)
vslc_file_next(const struct VSL_cursor *cursor)
{
        struct vslc_file *c;
        ssize_t i;
        ssize_t l;

        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_FILE_MAGIC);
        assert(&c->cursor == cursor);

        do {
                c->cursor.rec.ptr = NULL;
                assert(c->buflen >= 2);
                i = vslc_file_readn(c->fd, c->buf, VSL_BYTES(VSL_OVERHEAD));
                if (i < 0)
                        return (vsl_e_io);
                if (i == 0)
                        return (vsl_e_eof);
                assert(i == VSL_BYTES(VSL_OVERHEAD));
                l = VSL_OVERHEAD + VSL_WORDS(VSL_LEN(c->buf));
                if (c->buflen < l) {
                        while (c->buflen < l)
                                c->buflen = 2 * l;
                        c->buf = realloc(c->buf, VSL_BYTES(c->buflen));
                        AN(c->buf);
                }
                if (l > 2) {
                        i = vslc_file_readn(c->fd, c->buf + VSL_OVERHEAD,
                            VSL_BYTES(l - VSL_OVERHEAD));
                        if (i < 0)
                                return (vsl_e_io);
                        if (i == 0)
                                return (vsl_e_eof);
                        assert(i == VSL_BYTES(l - VSL_OVERHEAD));
                }
                c->cursor.rec.ptr = c->buf;
        } while (VSL_TAG(c->cursor.rec.ptr) == SLT__Batch);
        return (vsl_more);
}

static enum vsl_status v_matchproto_(vslc_reset_f)
vslc_file_reset(const struct VSL_cursor *cursor)
{
        (void)cursor;
        /* XXX: Implement me */
        return (vsl_e_eof);
}

static const struct vslc_tbl vslc_file_tbl = {
        .magic          = VSLC_TBL_MAGIC,
        .delete         = vslc_file_delete,
        .next           = vslc_file_next,
        .reset          = vslc_file_reset,
        .check          = NULL,
};

struct vslc_mmap {
        unsigned                        magic;
#define VSLC_MMAP_MAGIC                 0x7de15f61
        int                             fd;
        int                             close_fd;
        char                            *b;
        char                            *e;
        struct VSL_cursor               cursor;
        struct VSLC_ptr                 next;
};

static void
vslc_mmap_delete(const struct VSL_cursor *cursor)
{
        struct vslc_mmap *c;

        AN(cursor);
        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_MMAP_MAGIC);
        assert(&c->cursor == cursor);
        AZ(munmap(c->b, c->e - c->b));
        if (c->close_fd)
                (void)close(c->fd);
        FREE_OBJ(c);
}

static enum vsl_status v_matchproto_(vslc_next_f)
vslc_mmap_next(const struct VSL_cursor *cursor)
{
        struct vslc_mmap *c;
        const char *t;

        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_MMAP_MAGIC);
        assert(&c->cursor == cursor);
        c->cursor.rec = c->next;
        t = TRUST_ME(c->cursor.rec.ptr);
        if (t == c->e)
                return (vsl_e_eof);
        c->next.ptr = VSL_NEXT(c->next.ptr);
        t = TRUST_ME(c->next.ptr);
        if (t > c->e)
                return (vsl_e_io);
        return (vsl_more);
}

static enum vsl_status v_matchproto_(vslc_reset_f)
vslc_mmap_reset(const struct VSL_cursor *cursor)
{
        struct vslc_mmap *c;

        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_MMAP_MAGIC);
        assert(&c->cursor == cursor);
        return (vsl_e_eof);
}

static enum vsl_check v_matchproto_(vslc_check_f)
vslc_mmap_check(const struct VSL_cursor *cursor, const struct VSLC_ptr *ptr)
{
        struct vslc_mmap *c;
        const char *t;

        CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_MMAP_MAGIC);
        assert(&c->cursor == cursor);
        AN(ptr->ptr);
        t = TRUST_ME(ptr->ptr);
        assert(t > c->b);
        assert(t <= c->e);
        return (vsl_check_valid);
}

static const struct vslc_tbl vslc_mmap_tbl = {
        .magic          = VSLC_TBL_MAGIC,
        .delete         = vslc_mmap_delete,
        .next           = vslc_mmap_next,
        .reset          = vslc_mmap_reset,
        .check          = vslc_mmap_check,
};

static struct VSL_cursor *
vsl_cursor_mmap(struct VSL_data *vsl, int fd, int close_fd)
{
        struct vslc_mmap *c;
        struct stat st[1];
        void *p;

        AZ(fstat(fd, st));
        if ((st->st_mode & S_IFMT) != S_IFREG)
                return (MAP_FAILED);

        assert(st->st_size >= (off_t)(sizeof VSL_FILE_ID));
        p = mmap(NULL, st->st_size, PROT_READ, MAP_PRIVATE, fd, 0);
        if (p == MAP_FAILED) {
                vsl_diag(vsl, "Cannot mmap: %s", strerror(errno));
                return (MAP_FAILED);
        }

        ALLOC_OBJ(c, VSLC_MMAP_MAGIC);
        if (c == NULL) {
                (void)munmap(p, st->st_size);
                if (close_fd)
                        (void)close(fd);
                vsl_diag(vsl, "Out of memory");
                return (NULL);
        }
        c->cursor.priv_tbl = &vslc_mmap_tbl;
        c->cursor.priv_data = c;

        c->fd = fd;
        c->close_fd = close_fd;
        c->b = p;
        c->e = c->b + st->st_size;
        c->next.ptr = TRUST_ME(c->b + sizeof VSL_FILE_ID);

        return (&c->cursor);
}

struct VSL_cursor *
VSL_CursorFile(struct VSL_data *vsl, const char *name, unsigned options)
{
        struct VSL_cursor *mc;
        struct vslc_file *c;
        int fd;
        int close_fd = 0;
        char buf[sizeof VSL_FILE_ID];
        ssize_t i;

        CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
        AN(name);
        (void)options;

        if (!strcmp(name, "-"))
                fd = STDIN_FILENO;
        else {
                fd = open(name, O_RDONLY);
                if (fd < 0) {
                        vsl_diag(vsl, "Cannot open %s: %s", name,
                            strerror(errno));
                        return (NULL);
                }
                close_fd = 1;
        }

        i = vslc_file_readn(fd, buf, sizeof buf);
        if (i <= 0) {
                if (close_fd)
                        (void)close(fd);
                vsl_diag(vsl, "VSL file read error: %s",
                    i < 0 ? strerror(errno) : "EOF");
                return (NULL);
        }
        assert(i == sizeof buf);
        if (memcmp(buf, VSL_FILE_ID, sizeof buf)) {
                if (close_fd)
                        (void)close(fd);
                vsl_diag(vsl, "Not a VSL file: %s", name);
                return (NULL);
        }

        mc = vsl_cursor_mmap(vsl, fd, close_fd);
        if (mc == NULL)
                return (NULL);
        if (mc != MAP_FAILED)
                return (mc);

        ALLOC_OBJ(c, VSLC_FILE_MAGIC);
        if (c == NULL) {
                if (close_fd)
                        (void)close(fd);
                vsl_diag(vsl, "Out of memory");
                return (NULL);
        }
        c->cursor.priv_tbl = &vslc_file_tbl;
        c->cursor.priv_data = c;

        c->fd = fd;
        c->close_fd = close_fd;
        c->buflen = VSL_WORDS(BUFSIZ);
        c->buf = malloc(VSL_BYTES(c->buflen));
        AN(c->buf);

        return (&c->cursor);
}

void
VSL_DeleteCursor(const struct VSL_cursor *cursor)
{
        const struct vslc_tbl *tbl;

        CAST_OBJ_NOTNULL(tbl, cursor->priv_tbl, VSLC_TBL_MAGIC);
        if (tbl->delete == NULL)
                return;
        (tbl->delete)(cursor);
}

enum vsl_status
VSL_ResetCursor(const struct VSL_cursor *cursor)
{
        const struct vslc_tbl *tbl;

        CAST_OBJ_NOTNULL(tbl, cursor->priv_tbl, VSLC_TBL_MAGIC);
        if (tbl->reset == NULL)
                return (vsl_e_eof);
        return ((tbl->reset)(cursor));
}

enum vsl_status
VSL_Next(const struct VSL_cursor *cursor)
{
        const struct vslc_tbl *tbl;

        CAST_OBJ_NOTNULL(tbl, cursor->priv_tbl, VSLC_TBL_MAGIC);
        AN(tbl->next);
        return ((tbl->next)(cursor));
}

enum vsl_check
VSL_Check(const struct VSL_cursor *cursor, const struct VSLC_ptr *ptr)
{
        const struct vslc_tbl *tbl;

        CAST_OBJ_NOTNULL(tbl, cursor->priv_tbl, VSLC_TBL_MAGIC);
        if (tbl->check == NULL)
                return (vsl_check_e_notsupp);
        return ((tbl->check)(cursor, ptr));
}

		varnish-cache/lib/libvarnishapi/vsl_cursor.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		* Author: Martin Blix Grydeland <martin@varnish-software.com>
7		*
8		* SPDX-License-Identifier: BSD-2-Clause
9		*
10		* Redistribution and use in source and binary forms, with or without
11		* modification, are permitted provided that the following conditions
12		* are met:
13		* 1. Redistributions of source code must retain the above copyright
14		* notice, this list of conditions and the following disclaimer.
15		* 2. Redistributions in binary form must reproduce the above copyright
16		* notice, this list of conditions and the following disclaimer in the
17		* documentation and/or other materials provided with the distribution.
18		*
19		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29		* SUCH DAMAGE.
30		*
31		*/
32
33		#include "config.h"
34
35		#include <sys/mman.h>
36		#include <sys/stat.h>
37		#include <sys/types.h>
38
39		#include <fcntl.h>
40		#include <stdint.h>
41		#include <stdio.h>
42		#include <stdlib.h>
43		#include <string.h>
44		#include <unistd.h>
45
46		#include "vdef.h"
47		#include "vas.h"
48		#include "miniobj.h"
49		#include "vmb.h"
50
51		#include "vqueue.h"
52		#include "vre.h"
53		#include "vsl_priv.h"
54
55		#include "vapi/vsl.h"
56		#include "vapi/vsm.h"
57
58		#include "vsl_api.h"
59
60		struct vslc_vsm {
61		unsigned magic;
62		#define VSLC_VSM_MAGIC 0x4D3903A6
63
64		struct VSL_cursor cursor;
65
66		unsigned options;
67
68		struct vsm *vsm;
69		struct vsm_fantom vf;
70
71		const struct VSL_head *head;
72		const uint32_t *end;
73		struct VSLC_ptr next;
74		};
75
76		static void
77	30847	vslc_vsm_delete(const struct VSL_cursor *cursor)
78		{
79		struct vslc_vsm *c;
80
81	30847	AN(cursor);
82	30847	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_VSM_MAGIC);
83	30847	AZ(VSM_Unmap(c->vsm, &c->vf));
84	30847	assert(&c->cursor == cursor);
85	30847	FREE_OBJ(c);
86	30847	}
87
88		/*
89		* We tolerate the fact that segment_n wraps around eventually: for the default
90		* vsl_space of 80MB and 8 segments, each segment is 10MB long, so we wrap
91		* roughly after 40 pebibytes (32bit) or 160 yobibytes (64bit) worth of vsl
92		* written.
93		*
94		* The vsm_check would fail if a vslc paused while this amount of data was
95		* written
96		*/
97
98		static enum vsl_check v_matchproto_(vslc_check_f)
99	9496600	vslc_vsm_check(const struct VSL_cursor cursor, const struct VSLC_ptr ptr)
100		{
101		const struct vslc_vsm *c;
102		unsigned dist;
103
104	9496600	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_VSM_MAGIC);
105	9496600	assert(&c->cursor == cursor);
106
107	9496600	if (ptr->ptr == NULL)
108	0	return (vsl_check_e_inval);
109
110	9496600	dist = c->head->segment_n - ptr->priv;
111
112	9496600	if (dist >= VSL_SEGMENTS - 2)
113		/* Too close to continue */
114	0	return (vsl_check_e_inval);
115	9496600	if (dist >= VSL_SEGMENTS - 4)
116		/* Warning level */
117	0	return (vsl_check_warn);
118		/* Safe */
119	9496600	return (vsl_check_valid);
120	9496600	}
121
122		static enum vsl_status v_matchproto_(vslc_next_f)
123	8434352	vslc_vsm_next(const struct VSL_cursor *cursor)
124		{
125		struct vslc_vsm *c;
126		enum vsl_check i;
127		uint32_t t;
128
129	8434352	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_VSM_MAGIC);
130	8434352	assert(&c->cursor == cursor);
131
132	8434352	while (1) {
133	9075761	i = vslc_vsm_check(&c->cursor, &c->next);
134	9075761	if (i < vsl_check_warn) {
135	0	if (VSM_StillValid(c->vsm, &c->vf) != VSM_valid)
136	0	return (vsl_e_abandon);
137		else
138	0	return (vsl_e_overrun);
139		}
140
141	9075761	t = (volatile const uint32_t )c->next.ptr;
142	9075761	AN(t);
143
144	9075761	if (t == VSL_ENDMARKER) {
145	754652	if (VSM_StillValid(c->vsm, &c->vf) != VSM_valid)
146	874	return (vsl_e_abandon);
147	753778	if (c->options & VSL_COPT_TAILSTOP)
148	1350	return (vsl_e_eof);
149		/* No new records available */
150	752428	return (vsl_end);
151		}
152
153		/* New data observed. Ensure load ordering with the log
154		* writer. */
155	8321109	VRMB();
156
157	8321109	if (t == VSL_WRAPMARKER) {
158		/* Wrap around not possible at front */
159	0	assert(c->next.ptr != c->head->log);
160	0	c->next.ptr = c->head->log;
161	0	while (c->next.priv % VSL_SEGMENTS)
162	0	c->next.priv++;
163	0	continue;
164		}
165
166	8321109	c->cursor.rec = c->next;
167	8321109	c->next.ptr = VSL_NEXT(c->next.ptr);
168
169	8321109	if (VSL_TAG(c->cursor.rec.ptr) == SLT__Batch) {
170	898629	if (!(c->options & VSL_COPT_BATCH))
171		/* Skip the batch record */
172	641409	continue;
173		/* Next call will point to the first record past
174		the batch */
175	257220	c->next.ptr +=
176	257220	VSL_WORDS(VSL_BATCHLEN(c->cursor.rec.ptr));
177	257220	}
178
179	7679750	while ((c->next.ptr - c->head->log) / c->head->segsize >
180	7679750	c->next.priv % VSL_SEGMENTS)
181	50	c->next.priv++;
182
183	7679700	assert(c->next.ptr >= c->head->log);
184	7679700	assert(c->next.ptr < c->end);
185
186	7679700	return (vsl_more);
187		}
188	8434352	}
189
190		static enum vsl_status v_matchproto_(vslc_reset_f)
191	30847	vslc_vsm_reset(const struct VSL_cursor *cursor)
192		{
193		struct vslc_vsm *c;
194		unsigned u, segment_n;
195		enum vsl_status r;
196
197	30847	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_VSM_MAGIC);
198	30847	assert(&c->cursor == cursor);
199	30847	c->cursor.rec.ptr = NULL;
200
201	30847	segment_n = c->head->segment_n;
202		/* Make sure offset table is not stale compared to segment_n */
203	30847	VRMB();
204
205	30847	if (c->options & VSL_COPT_TAIL) {
206		/* Start in the same segment varnishd currently is in and
207		run forward until we see the end */
208	5772	u = c->next.priv = segment_n;
209	5772	assert(c->head->offset[c->next.priv % VSL_SEGMENTS] >= 0);
210	11544	c->next.ptr = c->head->log +
211	5772	c->head->offset[c->next.priv % VSL_SEGMENTS];
212	5772	do {
213	388353	if (c->head->segment_n - u > 1) {
214		/* Give up if varnishd is moving faster
215		than us */
216	0	return (vsl_e_overrun);
217		}
218	388353	r = vslc_vsm_next(&c->cursor);
219	388353	} while (r == vsl_more);
220	5772	if (r != vsl_end)
221	0	return (r);
222	5772	} else {
223		/* Starting (VSL_SEGMENTS - 3) behind varnishd. This way
224		* even if varnishd advances segment_n immediately, we'll
225		* still have a full segment worth of log before the
226		* general constraint of at least 2 segments apart will be
227		* broken.
228		*/
229	25075	c->next.priv = segment_n - (VSL_SEGMENTS - 3);
230	150450	while (c->head->offset[c->next.priv % VSL_SEGMENTS] < 0) {
231		/* seg 0 must be initialized */
232	125375	assert(c->next.priv % VSL_SEGMENTS != 0);
233	125375	c->next.priv++;
234		}
235	25075	assert(c->head->offset[c->next.priv % VSL_SEGMENTS] >= 0);
236	50150	c->next.ptr = c->head->log +
237	25075	c->head->offset[c->next.priv % VSL_SEGMENTS];
238		}
239	30847	assert(c->next.ptr >= c->head->log);
240	30847	assert(c->next.ptr < c->end);
241	30847	return (vsl_end);
242	30847	}
243
244		static const struct vslc_tbl vslc_vsm_tbl = {
245		.magic = VSLC_TBL_MAGIC,
246		.delete = vslc_vsm_delete,
247		.next = vslc_vsm_next,
248		.reset = vslc_vsm_reset,
249		.check = vslc_vsm_check,
250		};
251
252		struct VSL_cursor *
253	135608	VSL_CursorVSM(struct VSL_data vsl, struct vsm vsm, unsigned options)
254		{
255		struct vslc_vsm *c;
256		struct vsm_fantom vf;
257		struct VSL_head *head;
258		enum vsl_status r;
259
260	135608	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
261
262	135608	if (!VSM_Get(vsm, &vf, VSL_CLASS, NULL)) {
263	104761	(void)vsl_diag(vsl,
264		"No VSL chunk found (child not started ?)");
265	104761	return (NULL);
266		}
267	30847	if (VSM_Map(vsm, &vf)) {
268	0	(void)vsl_diag(vsl,
269	0	"VSM_Map(): %s", VSM_Error(vsm));
270	0	return (NULL);
271		}
272	30847	AN(vf.b);
273
274	30847	head = vf.b;
275	30847	if (memcmp(head->marker, VSL_HEAD_MARKER, sizeof head->marker)) {
276	0	AZ(VSM_Unmap(vsm, &vf));
277	0	(void)vsl_diag(vsl, "Not a VSL chunk");
278	0	return (NULL);
279		}
280	30847	ALLOC_OBJ(c, VSLC_VSM_MAGIC);
281	30847	if (c == NULL) {
282	0	AZ(VSM_Unmap(vsm, &vf));
283	0	(void)vsl_diag(vsl, "Out of memory");
284	0	return (NULL);
285		}
286	30847	c->cursor.priv_tbl = &vslc_vsm_tbl;
287	30847	c->cursor.priv_data = c;
288
289	30847	c->options = options;
290	30847	c->vsm = vsm;
291	30847	c->vf = vf;
292	30847	c->head = head;
293	30847	c->end = c->head->log + c->head->segsize * VSL_SEGMENTS;
294	30847	assert(c->end <= (const uint32_t *)vf.e);
295
296	30847	r = vslc_vsm_reset(&c->cursor);
297	30847	if (r != vsl_end) {
298	0	AZ(VSM_Unmap(vsm, &vf));
299	0	(void)vsl_diag(vsl, "Cursor initialization failure (%d)", r);
300	0	FREE_OBJ(c);
301	0	return (NULL);
302		}
303
304	30847	return (&c->cursor);
305	135608	}
306
307		struct vslc_file {
308		unsigned magic;
309		#define VSLC_FILE_MAGIC 0x1D65FFEF
310
311		int fd;
312		int close_fd;
313		ssize_t buflen;
314		uint32_t *buf;
315
316		struct VSL_cursor cursor;
317
318		};
319
320		static void
321	50	vslc_file_delete(const struct VSL_cursor *cursor)
322		{
323		struct vslc_file *c;
324
325	50	AN(cursor);
326	50	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_FILE_MAGIC);
327	50	assert(&c->cursor == cursor);
328	50	if (c->close_fd)
329	0	(void)close(c->fd);
330	50	if (c->buf != NULL)
331	50	free(c->buf);
332	50	FREE_OBJ(c);
333	50	}
334
335		/* Read n bytes from fd into buf */
336		static ssize_t
337	5000	vslc_file_readn(int fd, void *buf, ssize_t n)
338		{
339	5000	ssize_t t = 0;
340		ssize_t l;
341
342	9950	while (t < n) {
343	5000	l = read(fd, (char *)buf + t, n - t);
344	5000	if (l <= 0)
345	50	return (l);
346	4950	t += l;
347		}
348	4950	return (t);
349	5000	}
350
351		static enum vsl_status v_matchproto_(vslc_next_f)
352	2450	vslc_file_next(const struct VSL_cursor *cursor)
353		{
354		struct vslc_file *c;
355		ssize_t i;
356		ssize_t l;
357
358	2450	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_FILE_MAGIC);
359	2450	assert(&c->cursor == cursor);
360
361	2450	do {
362	2450	c->cursor.rec.ptr = NULL;
363	2450	assert(c->buflen >= 2);
364	2450	i = vslc_file_readn(c->fd, c->buf, VSL_BYTES(VSL_OVERHEAD));
365	2450	if (i < 0)
366	0	return (vsl_e_io);
367	2450	if (i == 0)
368	50	return (vsl_e_eof);
369	2400	assert(i == VSL_BYTES(VSL_OVERHEAD));
370	2400	l = VSL_OVERHEAD + VSL_WORDS(VSL_LEN(c->buf));
371	2400	if (c->buflen < l) {
372	0	while (c->buflen < l)
373	0	c->buflen = 2 * l;
374	0	c->buf = realloc(c->buf, VSL_BYTES(c->buflen));
375	0	AN(c->buf);
376	0	}
377	2400	if (l > 2) {
378	4800	i = vslc_file_readn(c->fd, c->buf + VSL_OVERHEAD,
379	2400	VSL_BYTES(l - VSL_OVERHEAD));
380	2400	if (i < 0)
381	0	return (vsl_e_io);
382	2400	if (i == 0)
383	0	return (vsl_e_eof);
384	2400	assert(i == VSL_BYTES(l - VSL_OVERHEAD));
385	2400	}
386	2400	c->cursor.rec.ptr = c->buf;
387	2400	} while (VSL_TAG(c->cursor.rec.ptr) == SLT__Batch);
388	2400	return (vsl_more);
389	2450	}
390
391		static enum vsl_status v_matchproto_(vslc_reset_f)
392	0	vslc_file_reset(const struct VSL_cursor *cursor)
393		{
394	0	(void)cursor;
395		/* XXX: Implement me */
396	0	return (vsl_e_eof);
397		}
398
399		static const struct vslc_tbl vslc_file_tbl = {
400		.magic = VSLC_TBL_MAGIC,
401		.delete = vslc_file_delete,
402		.next = vslc_file_next,
403		.reset = vslc_file_reset,
404		.check = NULL,
405		};
406
407		struct vslc_mmap {
408		unsigned magic;
409		#define VSLC_MMAP_MAGIC 0x7de15f61
410		int fd;
411		int close_fd;
412		char *b;
413		char *e;
414		struct VSL_cursor cursor;
415		struct VSLC_ptr next;
416		};
417
418		static void
419	75	vslc_mmap_delete(const struct VSL_cursor *cursor)
420		{
421		struct vslc_mmap *c;
422
423	75	AN(cursor);
424	75	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_MMAP_MAGIC);
425	75	assert(&c->cursor == cursor);
426	75	AZ(munmap(c->b, c->e - c->b));
427	75	if (c->close_fd)
428	75	(void)close(c->fd);
429	75	FREE_OBJ(c);
430	75	}
431
432		static enum vsl_status v_matchproto_(vslc_next_f)
433	900	vslc_mmap_next(const struct VSL_cursor *cursor)
434		{
435		struct vslc_mmap *c;
436		const char *t;
437
438	900	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_MMAP_MAGIC);
439	900	assert(&c->cursor == cursor);
440	900	c->cursor.rec = c->next;
441	900	t = TRUST_ME(c->cursor.rec.ptr);
442	900	if (t == c->e)
443	75	return (vsl_e_eof);
444	825	c->next.ptr = VSL_NEXT(c->next.ptr);
445	825	t = TRUST_ME(c->next.ptr);
446	825	if (t > c->e)
447	0	return (vsl_e_io);
448	825	return (vsl_more);
449	900	}
450
451		static enum vsl_status v_matchproto_(vslc_reset_f)
452	0	vslc_mmap_reset(const struct VSL_cursor *cursor)
453		{
454		struct vslc_mmap *c;
455
456	0	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_MMAP_MAGIC);
457	0	assert(&c->cursor == cursor);
458	0	return (vsl_e_eof);
459		}
460
461		static enum vsl_check v_matchproto_(vslc_check_f)
462	1250	vslc_mmap_check(const struct VSL_cursor cursor, const struct VSLC_ptr ptr)
463		{
464		struct vslc_mmap *c;
465		const char *t;
466
467	1250	CAST_OBJ_NOTNULL(c, cursor->priv_data, VSLC_MMAP_MAGIC);
468	1250	assert(&c->cursor == cursor);
469	1250	AN(ptr->ptr);
470	1250	t = TRUST_ME(ptr->ptr);
471	1250	assert(t > c->b);
472	1250	assert(t <= c->e);
473	1250	return (vsl_check_valid);
474		}
475
476		static const struct vslc_tbl vslc_mmap_tbl = {
477		.magic = VSLC_TBL_MAGIC,
478		.delete = vslc_mmap_delete,
479		.next = vslc_mmap_next,
480		.reset = vslc_mmap_reset,
481		.check = vslc_mmap_check,
482		};
483
484		static struct VSL_cursor *
485	125	vsl_cursor_mmap(struct VSL_data *vsl, int fd, int close_fd)
486		{
487		struct vslc_mmap *c;
488		struct stat st[1];
489		void *p;
490
491	125	AZ(fstat(fd, st));
492	125	if ((st->st_mode & S_IFMT) != S_IFREG)
493	50	return (MAP_FAILED);
494
495	75	assert(st->st_size >= (off_t)(sizeof VSL_FILE_ID));
496	75	p = mmap(NULL, st->st_size, PROT_READ, MAP_PRIVATE, fd, 0);
497	75	if (p == MAP_FAILED) {
498	0	vsl_diag(vsl, "Cannot mmap: %s", strerror(errno));
499	0	return (MAP_FAILED);