source: bin/varnishd/shmlog.c @ 198b1cb

Revision 198b1cb, 4.2 KB checked in by Poul-Henning Kamp <phk@…>, 8 years ago (diff)

Flexelint'ing, found a spurious ';'

git-svn-id:  http://www.varnish-cache.org/svn/trunk@473 d4fa192b-c00b-0410-8231-f00ffab90ce4

  • Property mode set to 100644
Line 
1/*
2 * $Id$
3 */
4
5#include <stdio.h>
6#include <stdlib.h>
7#include <unistd.h>
8#include <errno.h>
9#include <fcntl.h>
10#include <string.h>
11#include <stdarg.h>
12#include <sys/mman.h>
13
14#include "libvarnish.h"
15#include "shmlog.h"
16#include "cache.h"
17
18#include "heritage.h"
19
20#ifndef MAP_HASSEMAPHORE
21#define MAP_HASSEMAPHORE 0 /* XXX Linux */
22#endif
23
24#ifndef MAP_NOSYNC
25#define MAP_NOSYNC 0 /* XXX Linux */
26#endif
27
28struct varnish_stats *VSL_stats;
29static struct shmloghead *loghead;
30static unsigned char *logstart;
31static pthread_mutex_t vsl_mutex;
32
33/*
34 * This variant copies a byte-range directly to the log, without
35 * taking the detour over sprintf()
36 */
37
38static void
39vsl_wrap(void)
40{
41
42        *logstart = SLT_ENDMARKER;
43        logstart[loghead->ptr] = SLT_WRAPMARKER;
44        loghead->ptr = 0;
45}
46 
47void
48VSLR(enum shmlogtag tag, unsigned id, const char *b, const char *e)
49{
50        unsigned char *p;
51        unsigned l;
52
53        assert(b != NULL);
54        if (e == NULL)
55                e = strchr(b, '\0');
56        assert(e != NULL);
57
58        /* Truncate */
59        l = e - b;
60        if (l > 255) {
61                l = 255;
62                e = b + l;
63        }
64
65        AZ(pthread_mutex_lock(&vsl_mutex));
66        assert(loghead->ptr < loghead->size);
67
68        /* Wrap if necessary */
69        if (loghead->ptr + 4 + l + 1 > loghead->size)
70                vsl_wrap();
71        p = logstart + loghead->ptr;
72        p[1] = l & 0xff;
73        p[2] = (id >> 8) & 0xff;
74        p[3] = id & 0xff;
75        memcpy(p + 4, b, l);
76        p[4 + l] = SLT_ENDMARKER;
77        p[0] = tag;
78
79        loghead->ptr += 4 + l;
80        assert(loghead->ptr < loghead->size);
81        AZ(pthread_mutex_unlock(&vsl_mutex));
82}
83
84
85void
86VSL(enum shmlogtag tag, unsigned id, const char *fmt, ...)
87{
88        va_list ap;
89        unsigned char *p;
90        unsigned n;
91
92        va_start(ap, fmt);
93
94        AZ(pthread_mutex_lock(&vsl_mutex));
95        assert(loghead->ptr < loghead->size);
96
97        /* Wrap if we cannot fit a full size record */
98        if (loghead->ptr + 4 + 255 + 1 > loghead->size) 
99                vsl_wrap();
100
101        p = logstart + loghead->ptr;
102        n = 0;
103        if (fmt != NULL) {
104                n = vsnprintf((char *)(p + 4), 256, fmt, ap);
105                if (n > 255)
106                        n = 255;        /* we truncate long fields */
107        }
108        p[1] = n & 0xff;
109        p[2] = (id >> 8) & 0xff;
110        p[3] = id & 0xff;
111        p[4 + n] = SLT_ENDMARKER;
112        p[0] = tag;
113
114        loghead->ptr += 4 + n;
115        assert(loghead->ptr < loghead->size);
116       
117        AZ(pthread_mutex_unlock(&vsl_mutex));
118
119        va_end(ap);
120}
121
122void
123VSL_Init(void)
124{
125
126        loghead = mmap(NULL, heritage.vsl_size,
127            PROT_READ|PROT_WRITE,
128            MAP_HASSEMAPHORE | MAP_NOSYNC | MAP_SHARED,
129            heritage.vsl_fd, 0);
130        assert(loghead != MAP_FAILED);
131
132        assert(loghead->magic == SHMLOGHEAD_MAGIC);
133        assert(loghead->hdrsize == sizeof *loghead);
134        /* XXX check sanity of loghead */
135        logstart = (unsigned char *)loghead + loghead->start;
136        AZ(pthread_mutex_init(&vsl_mutex, NULL));
137        VSL_stats = &loghead->stats;
138}
139
140/*--------------------------------------------------------------------*/
141
142void
143VSL_MgtInit(const char *fn, unsigned size)
144{
145        struct shmloghead slh;
146        int i = 0;
147
148        memset(&slh, 0, sizeof slh);    /* XXX: for flexelint */
149        heritage.vsl_fd = open(fn, O_RDWR, 0644);
150        if (heritage.vsl_fd >= 0)
151                i = read(heritage.vsl_fd, &slh, sizeof slh);
152        if (heritage.vsl_fd < 0 || i != sizeof slh ||
153            slh.magic != SHMLOGHEAD_MAGIC ||
154            slh.hdrsize != sizeof slh) {
155                /* XXX more checks */
156
157                fprintf(stderr, "Creating new SHMFILE\n");
158                if (heritage.vsl_fd >= 0)
159                        close(heritage.vsl_fd);
160                (void)unlink(fn);
161                heritage.vsl_fd = open(fn, O_RDWR | O_CREAT, 0644);
162                if (heritage.vsl_fd < 0) {
163                        fprintf(stderr, "Could not open %s: %s\n",
164                            fn, strerror(errno));
165                        exit (1);
166                }
167
168                memset(&slh, 0, sizeof slh);
169                slh.magic = SHMLOGHEAD_MAGIC;
170                slh.hdrsize = sizeof slh;
171                slh.size = size;
172                slh.ptr = 0;
173                slh.start = sizeof slh;
174                AZ(lseek(heritage.vsl_fd, 0, SEEK_SET));
175                i = write(heritage.vsl_fd, &slh, sizeof slh);
176                assert(i == sizeof slh);
177                AZ(ftruncate(heritage.vsl_fd, (off_t)sizeof slh + (off_t)size));
178        }
179        heritage.vsl_size = slh.size + slh.start;
180
181        /*
182         * Call VSL_Init so that we get a VSL_stats pointer in the
183         * management process as well.
184         */
185        VSL_Init();
186        memset(VSL_stats, 0, sizeof *VSL_stats);
187}
188
189/*--------------------------------------------------------------------*/
190
191void
192__assert(const char *func, const char *file, int line, const char *failedexpr)
193{
194        (void)fprintf(stderr,
195             "\r\nAssertion failed: (%s)\n"
196             "    function %s, file %s, line %d.\n"
197             "    errno %d = \"%s\"\n", 
198             failedexpr, func, file, line, errno, strerror(errno));
199        abort();
200        /* NOTREACHED */
201}
Note: See TracBrowser for help on using the repository browser.