From: des Date: Thu, 15 Nov 2007 16:01:21 +0000 (+0000) Subject: Bigger hammer: panic() is similar to lbv_assert() but takes a struct sess * X-Git-Url: https://err.no/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=d052930abf12365425e1d19e838bb82163470a4e;p=varnish Bigger hammer: panic() is similar to lbv_assert() but takes a struct sess * from which it tries to extract as much useful information as possible before it croaks. The corresponding macro is spassert(), which assumes you have a struct sess *sp in scope. This should help a lot with bugs like #167 where important information is not available post-mortem (because sp->obj points into the cache, which is not included in the core dump) git-svn-id: svn+ssh://projects.linpro.no/svn/varnish/trunk@2254 d4fa192b-c00b-0410-8231-f00ffab90ce4 --- diff --git a/varnish-cache/bin/varnishd/Makefile.am b/varnish-cache/bin/varnishd/Makefile.am index 5cbee2c6..e152b0f8 100644 --- a/varnish-cache/bin/varnishd/Makefile.am +++ b/varnish-cache/bin/varnishd/Makefile.am @@ -24,6 +24,7 @@ varnishd_SOURCES = \ cache_http.c \ cache_httpconn.c \ cache_main.c \ + cache_panic.c \ cache_pool.c \ cache_pipe.c \ cache_response.c \ diff --git a/varnish-cache/bin/varnishd/cache.h b/varnish-cache/bin/varnishd/cache.h index 6970ae29..374b3438 100644 --- a/varnish-cache/bin/varnishd/cache.h +++ b/varnish-cache/bin/varnishd/cache.h @@ -668,3 +668,17 @@ Tlen(const txt t) return ((unsigned)(t.e - t.b)); } + +#ifdef WITHOUT_ASSERTS +#define spassert(cond) ((void)0) +#else +void panic(const char *, int, const char *, + const struct sess *, const char *, ...); +#define spassert(cond) \ + do { \ + int ok = !!(cond); \ + if (!ok) \ + panic(__FILE__, __LINE__, __func__, sp, \ + "assertion failed: %s\n", #cond); \ + } while (0) +#endif diff --git a/varnish-cache/bin/varnishd/cache_panic.c b/varnish-cache/bin/varnishd/cache_panic.c new file mode 100644 index 00000000..0255c43b --- /dev/null +++ b/varnish-cache/bin/varnishd/cache_panic.c @@ -0,0 +1,188 @@ +/*- + * Copyright (c) 2006 Verdens Gang AS + * Copyright (c) 2006-2007 Linpro AS + * All rights reserved. + * + * Author: Dag-Erling Smørgrav + * + * 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. + * + * $Id$ + */ + +#include +#include +#include + +#include "cache.h" + +#ifndef WITHOUT_ASSERTS + +/* panic string */ +char panicstr[65536]; +static char *pstr = panicstr; + +#define fp(...) \ + pstr += snprintf(pstr, \ + (panicstr + sizeof panicstr) - pstr, \ + __VA_ARGS__) +#define vfp(fmt, ap) \ + pstr += vsnprintf(pstr, \ + (panicstr + sizeof panicstr) - pstr, \ + (fmt), (ap)) + +/* step names */ +static const char *steps[] = { +#define STEP(l, u) "STP_" #u, +#include "steps.h" +#undef STEP +}; +static int nsteps = sizeof steps / sizeof *steps; + +/* dump a struct storage */ +static void +dump_storage(const struct storage *st) +{ + int i, j; + +#define MAX_BYTES (4*16) +#define show(ch) (((ch) > 31 && (ch) < 127) ? (ch) : '.') + + for (i = 0; i < MAX_BYTES && i < st->len; i += 16) { + fp(" "); + for (j = 0; j < 16; ++j) { + if (i + j < st->len) + fp("%02x ", st->ptr[i + j]); + else + fp(" "); + } + fp("|"); + for (j = 0; j < 16; ++j) + if (i + j < st->len) + fp("%c", show(st->ptr[i + j])); + fp("|\n"); + } + if (st->len > MAX_BYTES) + fp(" [%u more]\n", st->len - MAX_BYTES); + +#undef show +#undef MAX_BYTES +} + +/* dump a struct http */ +static void +dump_http(const struct http *h) +{ + int i; + + fp(" http = {\n"); + if (h->nhd > HTTP_HDR_FIRST) { + fp(" hd = {\n"); + for (i = HTTP_HDR_FIRST; i < h->nhd; ++i) + fp(" \"%.*s\",\n", + (int)(h->hd[i].e - h->hd[i].b), + h->hd[i].b); + fp(" },\n"); + } + fp(" },\n"); +} + +/* dump a struct object */ +static void +dump_object(const struct object *o) +{ + const struct storage *st; + + fp(" obj = %p {\n", o); + fp(" refcnt = %u, xid = %u,\n", o->refcnt, o->xid); + dump_http(o->http); + fp(" store = {\n"); + VTAILQ_FOREACH(st, &o->store, list) { + dump_storage(st); + } + fp(" },\n"); + fp(" },\n"); +} + +/* dump a struct backend */ +static void +dump_backend(const struct backend *be) +{ + + fp(" backend = %p {\n", be); + fp(" vcl_name = \"%s\",\n", + be->vcl_name ? be->vcl_name : "(null)"); + fp(" },\n"); +} + +/* dump a struct sess */ +static void +dump_sess(const struct sess *sp) +{ + const struct backend *be = sp->backend; + const struct object *obj = sp->obj; + + fp("sp = %p {\n", sp); + fp(" fd = %d, id = %d, xid = %u,\n", sp->fd, sp->id, sp->xid); + fp(" client = %s:%s,\n", + sp->addr ? sp->addr : "?.?.?.?", + sp->port ? sp->port : "?"); + if (sp->step < nsteps) + fp(" step = %s,\n", steps[sp->step]); + else + fp(" step = %d,\n", sp->step); + if (sp->err_code) + fp(" err_code = %d, err_reason = %s,\n", sp->err_code, + sp->err_reason ? sp->err_reason : "(null)"); + + if (VALID_OBJ(be, BACKEND_MAGIC)) + dump_backend(be); + + if (VALID_OBJ(obj, OBJECT_MAGIC)) + dump_object(obj); + + fp("},\n"); +} + +/* report as much information as we can before we croak */ +void +panic(const char *file, int line, const char *func, + const struct sess *sp, const char *fmt, ...) +{ + va_list ap; + + fp("panic in %s() at %s:%d\n", func, file, line); + va_start(ap, fmt); + vfp(fmt, ap); + va_end(ap); + + if (VALID_OBJ(sp, SESS_MAGIC)) + dump_sess(sp); + + fputs(panicstr, stderr); + + /* I wish there was a way to flush the log buffers... */ + signal(SIGABRT, SIG_DFL); + raise(SIGABRT); +} + +#endif