source: bin/varnishd/shmlog.c @ aace69

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

Dump errno and strerror in assert

git-svn-id:  http://www.varnish-cache.org/svn/trunk@406 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;
73        p[2] = id >> 8;
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;
109        p[2] = id >> 8;
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        /* XXX check sanity of loghead */
133        logstart = (unsigned char *)loghead + loghead->start;
134        AZ(pthread_mutex_init(&vsl_mutex, NULL));
135        VSL_stats = &loghead->stats;
136}
137
138/*--------------------------------------------------------------------*/
139
140void
141VSL_MgtInit(const char *fn, unsigned size)
142{
143        struct shmloghead slh;
144        int i;
145
146        heritage.vsl_fd = open(fn, O_RDWR | O_CREAT, 0644);
147        if (heritage.vsl_fd < 0) {
148                fprintf(stderr, "Could not open %s: %s\n",
149                    fn, strerror(errno));
150                exit (1);
151        }
152        i = read(heritage.vsl_fd, &slh, sizeof slh);
153        if (i != sizeof slh || slh.magic != SHMLOGHEAD_MAGIC) {
154                /* XXX more checks */
155
156                slh.magic = SHMLOGHEAD_MAGIC;
157                slh.size = size;
158                slh.ptr = 0;
159                slh.start = sizeof slh;
160                AZ(lseek(heritage.vsl_fd, 0, SEEK_SET));
161                i = write(heritage.vsl_fd, &slh, sizeof slh);
162                assert(i == sizeof slh);
163                AZ(ftruncate(heritage.vsl_fd, sizeof slh + size));
164        }
165        heritage.vsl_size = slh.size + slh.start;
166
167        /*
168         * Call VSL_Init so that we get a VSL_stats pointer in the
169         * management process as well.
170         */
171        VSL_Init();
172        memset(VSL_stats, 0, sizeof *VSL_stats);
173}
174
175/*--------------------------------------------------------------------*/
176
177void
178__assert(const char *func, const char *file, int line, const char *failedexpr)
179{
180        (void)fprintf(stderr,
181             "\r\nAssertion failed: (%s)\n"
182             "    function %s, file %s, line %d.\n"
183             "    errno %d = \"%s\"\n", 
184             failedexpr, func, file, line, errno, strerror(errno));
185        abort();
186        /* NOTREACHED */
187}
Note: See TracBrowser for help on using the repository browser.