From 259b9a9d2427a47eae736aa660182ec77c659f0b Mon Sep 17 00:00:00 2001 From: Andrew Bettison Date: Tue, 16 Oct 2012 16:46:52 +1030 Subject: [PATCH] Logging/debug improvements: __WHENCE__, __whence Introduce __WHENCE__ macro and a block comment in log.h explaining it. In "primitive" kinds of functions, rename 'whence' arguments to '__whence' and use WHYF(), WARNF(), DEBUGF() macros instead of calling logMessage() directly. --- log.c | 48 +++++++++++---------- log.h | 74 ++++++++++++++++++++++++++------ net.c | 70 ++++++++++++------------------ net.h | 34 +++++++-------- overlay_buffer.c | 12 +++--- overlay_interface.c | 10 +++-- rhizome.h | 42 +++++++++--------- rhizome_bundle.c | 46 ++++++++++---------- rhizome_database.c | 102 ++++++++++++++++++++------------------------ serval.h | 14 +++--- 10 files changed, 238 insertions(+), 214 deletions(-) diff --git a/log.c b/log.c index 646ea434..f44f8440 100644 --- a/log.c +++ b/log.c @@ -39,6 +39,8 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #include "strbuf.h" #include "strbuf_helpers.h" +const struct __sourceloc __whence = __NOWHERE__; + debugflags_t debug = 0; static FILE *logfile = NULL; @@ -131,7 +133,7 @@ static const char *_trimbuildpath(const char *path) return &path[lastsep]; } -static int _log_prepare(int level, struct __sourceloc where) +static int _log_prepare(int level, struct __sourceloc whence) { if (level == LOG_LEVEL_SILENT) return 0; @@ -164,15 +166,15 @@ static int _log_prepare(int level, struct __sourceloc where) strbuf_sprintf(&logbuf, "%s.%03u ", buf, tv.tv_usec / 1000); } } - if (where.file) { - strbuf_sprintf(&logbuf, "%s", _trimbuildpath(where.file)); - if (where.line) - strbuf_sprintf(&logbuf, ":%u", where.line); - if (where.function) - strbuf_sprintf(&logbuf, ":%s()", where.function); + if (whence.file) { + strbuf_sprintf(&logbuf, "%s", _trimbuildpath(whence.file)); + if (whence.line) + strbuf_sprintf(&logbuf, ":%u", whence.line); + if (whence.function) + strbuf_sprintf(&logbuf, ":%s()", whence.function); strbuf_putc(&logbuf, ' '); - } else if (where.function) { - strbuf_sprintf(&logbuf, "%s() ", where.function); + } else if (whence.function) { + strbuf_sprintf(&logbuf, "%s() ", whence.function); } strbuf_putc(&logbuf, ' '); return 1; @@ -213,9 +215,9 @@ void set_log_implementation(void (*log_function)(int level, struct strbuf *buf)) _log_implementation=log_function; } -void logArgv(int level, struct __sourceloc where, const char *label, int argc, const char *const *argv) +void logArgv(int level, struct __sourceloc whence, const char *label, int argc, const char *const *argv) { - if (_log_prepare(level, where)) { + if (_log_prepare(level, whence)) { if (label) { strbuf_puts(&logbuf, label); strbuf_putc(&logbuf, ' '); @@ -233,47 +235,47 @@ void logArgv(int level, struct __sourceloc where, const char *label, int argc, c } } -void logString(int level, struct __sourceloc where, const char *str) +void logString(int level, struct __sourceloc whence, const char *str) { const char *s = str; const char *p; for (p = str; *p; ++p) { if (*p == '\n') { - if (_log_prepare(level, where)) { + if (_log_prepare(level, whence)) { strbuf_ncat(&logbuf, s, p - s); _log_finish(level); } s = p + 1; } } - if (p > s && _log_prepare(level, where)) { + if (p > s && _log_prepare(level, whence)) { strbuf_ncat(&logbuf, s, p - s); _log_finish(level); } } -void logMessage(int level, struct __sourceloc where, const char *fmt, ...) +void logMessage(int level, struct __sourceloc whence, const char *fmt, ...) { va_list ap; va_start(ap, fmt); - vlogMessage(level, where, fmt, ap); + vlogMessage(level, whence, fmt, ap); va_end(ap); } -void vlogMessage(int level, struct __sourceloc where, const char *fmt, va_list ap) +void vlogMessage(int level, struct __sourceloc whence, const char *fmt, va_list ap) { - if (_log_prepare(level, where)) { + if (_log_prepare(level, whence)) { strbuf_vsprintf(&logbuf, fmt, ap); _log_finish(level); } } -int logDump(int level, struct __sourceloc where, char *name, const unsigned char *addr, size_t len) +int logDump(int level, struct __sourceloc whence, char *name, const unsigned char *addr, size_t len) { char buf[100]; size_t i; if (name) - logMessage(level, where, "Dump of %s", name); + logMessage(level, whence, "Dump of %s", name); for(i = 0; i < len; i += 16) { strbuf b = strbuf_local(buf, sizeof buf); strbuf_sprintf(b, " %04x :", i); @@ -285,7 +287,7 @@ int logDump(int level, struct __sourceloc where, char *name, const unsigned char strbuf_puts(b, " "); for (j = 0; j < 16 && i + j < len; j++) strbuf_sprintf(b, "%c", addr[i+j] >= ' ' && addr[i+j] < 0x7f ? addr[i+j] : '.'); - logMessage(level, where, "%s", strbuf_str(b)); + logMessage(level, whence, "%s", strbuf_str(b)); } return 0; } @@ -422,7 +424,7 @@ ssize_t get_self_executable_path(char *buf, size_t len) #endif } -int log_backtrace(struct __sourceloc where) +int log_backtrace(struct __sourceloc whence) { open_logging(); char execpath[MAXPATHLEN]; @@ -476,7 +478,7 @@ int log_backtrace(struct __sourceloc where) } // parent close(stdout_fds[1]); - logMessage(LOG_LEVEL_DEBUG, where, "GDB BACKTRACE"); + logMessage(LOG_LEVEL_DEBUG, whence, "GDB BACKTRACE"); char buf[1024]; char *const bufe = buf + sizeof buf; char *linep = buf; diff --git a/log.h b/log.h index f01586e7..259d02e3 100644 --- a/log.h +++ b/log.h @@ -66,27 +66,73 @@ extern debugflags_t debug; struct strbuf; +/* + * Every log message identifies the location in the source code at which the + * message was produced. This location is represented by a struct __sourceloc, + * which is passed by value to the logMessage() function and its ilk. + * + * A struct __sourceloc value is generated by the __HERE__ macro, which uses + * the cpp(1) built-in macros __FILE__, __LINE__ and __FUNCTION__ to generate + * its elements. The __NOWHERE__ macro creates a struct __sourceloc with NULL + * and zero fields. If you pass __NOWHERE__ to logMessage(), it will omit + * location information from the log line. + * + * Sometimes, a function wants to log a message as though its caller were the + * origin of the message. This is typical of "primitive" type functions that + * are used in many places throughout the code, and whose internal workings are + * generally well-debugged and of little interest for ongoing development. In + * this case, the code pattern is to declare the underscore-prefixed function + * as taking a struct __sourceloc argument, and a macro that invokes the + * function, passing the __HERE__ macro for that argument: + * + * int _primitive(struct __sourceloc __whence, int arg1, const char *arg2); + * + * #define primitive(arg1, arg2) _primitive(__HERE__, (arg1), (arg2)) + * + * Within the _primitive() function, the standard logging macros defined below + * (WHYF(), WARNF(), INFOF(), DEBUGF() etc.) will use the __whence argument + * instead of __HERE__ when logging their message. This is achieved using a + * dirty trick: in the function *definition*, the __sourceloc argument MUST be + * named '__whence'. The trick is that there is a global variable called + * '__whence' which always contains the value of __NOWHERE__. If that variable + * is lexically obscured by a local variable or parameter called '__whence', + * then the DEBUG macros will use __whence, otherwise they will use __HERE__. + * This logic is encapsulated in the __WHENCE__ macro, to make it available to + * for other purposes. For example, a better definition of the primitive() + * macro above would be: + * + * #define primitive(arg1, arg2) _primitive(__WHENCE__, (arg1), (arg2)) + * + * Then, if it were invoked from within another primitive-type function, it + * would log messages with the __sourceloc of that primitive's caller, which is + * probably the most useful for diagnosis. + * + * @author Andrew Bettison + */ + struct __sourceloc { const char *file; unsigned int line; const char *function; }; +extern const struct __sourceloc __whence; // see above + void set_logging(FILE *f); FILE *open_logging(); void close_logging(); -void logArgv(int level, struct __sourceloc where, const char *label, int argc, const char *const *argv); -void logString(int level, struct __sourceloc where, const char *str); -void logMessage(int level, struct __sourceloc where, const char *fmt, ...); -void vlogMessage(int level, struct __sourceloc where, const char *fmt, va_list); +void logArgv(int level, struct __sourceloc whence, const char *label, int argc, const char *const *argv); +void logString(int level, struct __sourceloc whence, const char *str); +void logMessage(int level, struct __sourceloc whence, const char *fmt, ...); +void vlogMessage(int level, struct __sourceloc whence, const char *fmt, va_list); debugflags_t debugFlagMask(const char *flagname); -int logDump(int level, struct __sourceloc where, char *name, const unsigned char *addr, size_t len); +int logDump(int level, struct __sourceloc whence, char *name, const unsigned char *addr, size_t len); char *toprint(char *dstStr, ssize_t dstBufSiz, const char *srcBuf, size_t srcBytes, const char quotes[2]); char *toprint_str(char *dstStr, ssize_t dstBufSiz, const char *srcStr, const char quotes[2]); size_t toprint_len(const char *srcBuf, size_t srcBytes, const char quotes[2]); size_t toprint_str_len(const char *srcStr, const char quotes[2]); ssize_t get_self_executable_path(char *buf, size_t len); -int log_backtrace(struct __sourceloc where); +int log_backtrace(struct __sourceloc whence); void set_log_implementation(void (*log_function)(int level, struct strbuf *buf)); #define alloca_toprint(dstlen,buf,len) toprint((char *)alloca((dstlen) == -1 ? toprint_len((buf),(len), "``") + 1 : (dstlen)), (dstlen), (buf), (len), "``") @@ -95,11 +141,13 @@ void set_log_implementation(void (*log_function)(int level, struct strbuf *buf)) #define __HERE__ ((struct __sourceloc){ .file = __FILE__, .line = __LINE__, .function = __FUNCTION__ }) #define __NOWHERE__ ((struct __sourceloc){ .file = NULL, .line = 0, .function = NULL }) -#define LOGF(L,F,...) logMessage(L, __HERE__, F, ##__VA_ARGS__) -#define LOGF_perror(L,F,...) logMessage_perror(L, __HERE__, F, ##__VA_ARGS__) +#define __WHENCE__ (__whence.file ? __whence : __HERE__) + +#define LOGF(L,F,...) logMessage(L, __WHENCE__, F, ##__VA_ARGS__) +#define LOGF_perror(L,F,...) logMessage_perror(L, __WHENCE__, F, ##__VA_ARGS__) #define LOG_perror(L,X) LOGF_perror(L, "%s", (X)) -#define logMessage_perror(L,where,F,...) (logMessage(L, where, F ": %s [errno=%d]", ##__VA_ARGS__, strerror(errno), errno)) +#define logMessage_perror(L,whence,F,...) (logMessage(L, whence, F ": %s [errno=%d]", ##__VA_ARGS__, strerror(errno), errno)) #define FATALF(F,...) do { LOGF(LOG_LEVEL_FATAL, F, ##__VA_ARGS__); exit(-1); } while (1) #define FATAL(X) FATALF("%s", (X)) @@ -117,7 +165,7 @@ void set_log_implementation(void (*log_function)(int level, struct strbuf *buf)) #define WARN(X) WARNF("%s", (X)) #define WARNF_perror(F,...) LOGF_perror(LOG_LEVEL_WARN, F, ##__VA_ARGS__) #define WARN_perror(X) WARNF_perror("%s", (X)) -#define WHY_argv(X,ARGC,ARGV) logArgv(LOG_LEVEL_ERROR, __HERE__, (X), (ARGC), (ARGV)) +#define WHY_argv(X,ARGC,ARGV) logArgv(LOG_LEVEL_ERROR, __WHENCE__, (X), (ARGC), (ARGV)) #define INFOF(F,...) LOGF(LOG_LEVEL_INFO, F, ##__VA_ARGS__) #define INFO(X) INFOF("%s", (X)) @@ -127,10 +175,10 @@ void set_log_implementation(void (*log_function)(int level, struct strbuf *buf)) #define DEBUGF_perror(F,...) LOGF_perror(LOG_LEVEL_DEBUG, F, ##__VA_ARGS__) #define DEBUG_perror(X) DEBUGF_perror("%s", (X)) #define D DEBUG("D") -#define DEBUG_argv(X,ARGC,ARGV) logArgv(LOG_LEVEL_DEBUG, __HERE__, (X), (ARGC), (ARGV)) +#define DEBUG_argv(X,ARGC,ARGV) logArgv(LOG_LEVEL_DEBUG, __WHENCE__, (X), (ARGC), (ARGV)) -#define dump(X,A,N) logDump(LOG_LEVEL_DEBUG, __HERE__, (X), (const unsigned char *)(A), (size_t)(N)) +#define dump(X,A,N) logDump(LOG_LEVEL_DEBUG, __WHENCE__, (X), (const unsigned char *)(A), (size_t)(N)) -#define BACKTRACE log_backtrace(__HERE__) +#define BACKTRACE log_backtrace(__WHENCE__) #endif // __SERVALD_LOG_H diff --git a/net.c b/net.c index 18d702f5..8b3d8eee 100644 --- a/net.c +++ b/net.c @@ -26,35 +26,27 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #include "net.h" #include "serval.h" -int _set_nonblock(int fd, struct __sourceloc where) +int _set_nonblock(int fd, struct __sourceloc __whence) { int flags; - if ((flags = fcntl(fd, F_GETFL, NULL)) == -1) { - logMessage_perror(LOG_LEVEL_ERROR, where, "set_nonblock: fcntl(%d,F_GETFL,NULL)", fd); - return -1; - } - if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) { - logMessage_perror(LOG_LEVEL_ERROR, where, "set_nonblock: fcntl(%d,F_SETFL,0x%x|O_NONBLOCK)", fd, flags); - return -1; - } + if ((flags = fcntl(fd, F_GETFL, NULL)) == -1) + return WHYF_perror("set_nonblock: fcntl(%d,F_GETFL,NULL)", fd); + if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) + return WHYF_perror("set_nonblock: fcntl(%d,F_SETFL,0x%x|O_NONBLOCK)", fd, flags); return 0; } -int _set_block(int fd, struct __sourceloc where) +int _set_block(int fd, struct __sourceloc __whence) { int flags; - if ((flags = fcntl(fd, F_GETFL, NULL)) == -1) { - logMessage_perror(LOG_LEVEL_ERROR, where, "set_block: fcntl(%d,F_GETFL,NULL)", fd); - return -1; - } - if (fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == -1) { - logMessage_perror(LOG_LEVEL_ERROR, where, "set_block: fcntl(%d,F_SETFL,0x%x&~O_NONBLOCK)", fd, flags); - return -1; - } + if ((flags = fcntl(fd, F_GETFL, NULL)) == -1) + return WHYF_perror("set_block: fcntl(%d,F_GETFL,NULL)", fd); + if (fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == -1) + return WHYF_perror("set_block: fcntl(%d,F_SETFL,0x%x&~O_NONBLOCK)", fd, flags); return 0; } -ssize_t _read_nonblock(int fd, void *buf, size_t len, struct __sourceloc where) +ssize_t _read_nonblock(int fd, void *buf, size_t len, struct __sourceloc __whence) { ssize_t nread = read(fd, buf, len); if (nread == -1) { @@ -66,30 +58,24 @@ ssize_t _read_nonblock(int fd, void *buf, size_t len, struct __sourceloc where) #endif return 0; } - logMessage_perror(LOG_LEVEL_ERROR, where, "read_nonblock: read(%d,%p,%lu)", - fd, buf, (unsigned long)len); - return -1; + return WHYF_perror("read_nonblock: read(%d,%p,%lu)", fd, buf, (unsigned long)len); } return nread; } -ssize_t _write_all(int fd, const void *buf, size_t len, struct __sourceloc where) +ssize_t _write_all(int fd, const void *buf, size_t len, struct __sourceloc __whence) { ssize_t written = write(fd, buf, len); - if (written == -1) { - logMessage_perror(LOG_LEVEL_ERROR, where, "write_all: write(%d,%p %s,%lu)", + if (written == -1) + return WHYF_perror("write_all: write(%d,%p %s,%lu)", fd, buf, alloca_toprint(30, buf, len), (unsigned long)len); - return -1; - } - if (written != len) { - logMessage(LOG_LEVEL_ERROR, where, "write_all: write(%d,%p %s,%lu) returned %ld", + if (written != len) + return WHYF_perror("write_all: write(%d,%p %s,%lu) returned %ld", fd, buf, alloca_toprint(30, buf, len), (unsigned long)len, (long)written); - return -1; - } return written; } -ssize_t _write_nonblock(int fd, const void *buf, size_t len, struct __sourceloc where) +ssize_t _write_nonblock(int fd, const void *buf, size_t len, struct __sourceloc __whence) { ssize_t written = write(fd, buf, len); if (written == -1) { @@ -101,32 +87,30 @@ ssize_t _write_nonblock(int fd, const void *buf, size_t len, struct __sourceloc #endif return 0; } - logMessage_perror(LOG_LEVEL_ERROR, where, "write_nonblock: write(%d,%p %s,%lu)", + return WHYF_perror("write_nonblock: write(%d,%p %s,%lu)", fd, buf, alloca_toprint(30, buf, len), (unsigned long)len); return -1; } return written; } -ssize_t _write_all_nonblock(int fd, const void *buf, size_t len, struct __sourceloc where) +ssize_t _write_all_nonblock(int fd, const void *buf, size_t len, struct __sourceloc __whence) { - ssize_t written = _write_nonblock(fd, buf, len, where); - if (written != -1 && written != len) { - logMessage(LOG_LEVEL_ERROR, where, "write_all_nonblock: write(%d,%p %s,%lu) returned %ld", + ssize_t written = _write_nonblock(fd, buf, len, __whence); + if (written != -1 && written != len) + return WHYF("write_all_nonblock: write(%d,%p %s,%lu) returned %ld", fd, buf, alloca_toprint(30, buf, len), (unsigned long)len, (long)written); - return -1; - } return written; } -ssize_t _write_str(int fd, const char *str, struct __sourceloc where) +ssize_t _write_str(int fd, const char *str, struct __sourceloc __whence) { - return _write_all(fd, str, strlen(str), where); + return _write_all(fd, str, strlen(str), __whence); } -ssize_t _write_str_nonblock(int fd, const char *str, struct __sourceloc where) +ssize_t _write_str_nonblock(int fd, const char *str, struct __sourceloc __whence) { - return _write_all_nonblock(fd, str, strlen(str), where); + return _write_all_nonblock(fd, str, strlen(str), __whence); } ssize_t recvwithttl(int sock,unsigned char *buffer, size_t bufferlen,int *ttl, diff --git a/net.h b/net.h index 541eda8b..e9c04a60 100644 --- a/net.h +++ b/net.h @@ -20,24 +20,24 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #define __SERVALD_NET_H #include // for size_t, ssize_t -#include "log.h" // for __HERE__ and struct __sourceloc +#include "log.h" // for __WHENCE__ and struct __sourceloc -#define set_nonblock(fd) (_set_nonblock(fd, __HERE__)) -#define set_block(fd) (_set_block(fd, __HERE__)) -#define read_nonblock(fd,buf,len) (_read_nonblock(fd, buf, len, __HERE__)) -#define write_all(fd,buf,len) (_write_all(fd, buf, len, __HERE__)) -#define write_nonblock(fd,buf,len) (_write_nonblock(fd, buf, len, __HERE__)) -#define write_all_nonblock(fd,buf,len) (_write_all_nonblock(fd, buf, len, __HERE__)) -#define write_str(fd,str) (_write_str(fd, str, __HERE__)) -#define write_str_nonblock(fd,str) (_write_str_nonblock(fd, str, __HERE__)) +#define set_nonblock(fd) (_set_nonblock(fd, __WHENCE__)) +#define set_block(fd) (_set_block(fd, __WHENCE__)) +#define read_nonblock(fd,buf,len) (_read_nonblock(fd, buf, len, __WHENCE__)) +#define write_all(fd,buf,len) (_write_all(fd, buf, len, __WHENCE__)) +#define write_nonblock(fd,buf,len) (_write_nonblock(fd, buf, len, __WHENCE__)) +#define write_all_nonblock(fd,buf,len) (_write_all_nonblock(fd, buf, len, __WHENCE__)) +#define write_str(fd,str) (_write_str(fd, str, __WHENCE__)) +#define write_str_nonblock(fd,str) (_write_str_nonblock(fd, str, __WHENCE__)) -int _set_nonblock(int fd, struct __sourceloc where); -int _set_block(int fd, struct __sourceloc where); -ssize_t _read_nonblock(int fd, void *buf, size_t len, struct __sourceloc where); -ssize_t _write_all(int fd, const void *buf, size_t len, struct __sourceloc where); -ssize_t _write_nonblock(int fd, const void *buf, size_t len, struct __sourceloc where); -ssize_t _write_all_nonblock(int fd, const void *buf, size_t len, struct __sourceloc where); -ssize_t _write_str(int fd, const char *str, struct __sourceloc where); -ssize_t _write_str_nonblock(int fd, const char *str, struct __sourceloc where); +int _set_nonblock(int fd, struct __sourceloc __whence); +int _set_block(int fd, struct __sourceloc __whence); +ssize_t _read_nonblock(int fd, void *buf, size_t len, struct __sourceloc __whence); +ssize_t _write_all(int fd, const void *buf, size_t len, struct __sourceloc __whence); +ssize_t _write_nonblock(int fd, const void *buf, size_t len, struct __sourceloc __whence); +ssize_t _write_all_nonblock(int fd, const void *buf, size_t len, struct __sourceloc __whence); +ssize_t _write_str(int fd, const char *str, struct __sourceloc __whence); +ssize_t _write_str_nonblock(int fd, const char *str, struct __sourceloc __whence); #endif // __SERVALD_NET_H diff --git a/overlay_buffer.c b/overlay_buffer.c index 7604fd80..d1242e17 100644 --- a/overlay_buffer.c +++ b/overlay_buffer.c @@ -460,22 +460,22 @@ int ob_dump(struct overlay_buffer *b,char *desc) #undef realloc #define SDM_GUARD_AFTER 16384 -void *_serval_debug_malloc(unsigned int bytes, struct __sourceloc where) +void *_serval_debug_malloc(unsigned int bytes, struct __sourceloc __whence) { void *r=malloc(bytes+SDM_GUARD_AFTER); - logMessage(LOG_LEVEL_DEBUG, where, "malloc(%d) -> %p", bytes, r); + DEBUGF("malloc(%d) -> %p", bytes, r); return r; } -void *_serval_debug_calloc(unsigned int bytes, unsigned int count, struct __sourceloc where) +void *_serval_debug_calloc(unsigned int bytes, unsigned int count, struct __sourceloc __whence) { void *r=calloc((bytes*count)+SDM_GUARD_AFTER,1); - logMessage(LOG_LEVEL_DEBUG, where, "calloc(%d,%d) -> %p", bytes, count, r); + DEBUGF("calloc(%d,%d) -> %p", bytes, count, r); return r; } -void _serval_debug_free(void *p, struct __sourceloc where) +void _serval_debug_free(void *p, struct __sourceloc __whence) { free(p); - logMessage(LOG_LEVEL_DEBUG, where, "free(%p)", p); + DEBUGF("free(%p)", p); } diff --git a/overlay_interface.c b/overlay_interface.c index 81a71022..39c20ef4 100644 --- a/overlay_interface.c +++ b/overlay_interface.c @@ -68,8 +68,10 @@ struct profile_total send_packet; static int overlay_tick_interface(int i, time_ms_t now); static void overlay_interface_poll(struct sched_ent *alarm); -static void logServalPacket(int level, struct __sourceloc where, const char *message, const unsigned char *packet, size_t len); -static long long parse_quantity(char *q); +static void logServalPacket(int level, struct __sourceloc __whence, const char *message, const unsigned char *packet, size_t len); +static long long parse_quantity(char *q); + +#define DEBUG_packet_visualise(M,P,N) logServalPacket(LOG_LEVEL_DEBUG, __WHENCE__, (M), (P), (N)) unsigned char magic_header[]={/* Magic */ 'O',0x10, /* Version */ 0x00,0x01}; @@ -1314,14 +1316,14 @@ parse_quantity(char *q) { } static void -logServalPacket(int level, struct __sourceloc where, const char *message, const unsigned char *packet, size_t len) { +logServalPacket(int level, struct __sourceloc __whence, const char *message, const unsigned char *packet, size_t len) { struct mallocbuf mb = STRUCT_MALLOCBUF_NULL; if (serval_packetvisualise(XPRINTF_MALLOCBUF(&mb), message, packet, len) == -1) WHY("serval_packetvisualise() failed"); else if (mb.buffer == NULL) WHYF("serval_packetvisualise() output buffer missing, message=%s packet=%p len=%lu", alloca_toprint(-1, message, strlen(message)), packet, len); else - logString(level, where, mb.buffer); + logString(level, __whence, mb.buffer); if (mb.buffer) free(mb.buffer); } diff --git a/rhizome.h b/rhizome.h index fe7dc3c4..772f8cf9 100644 --- a/rhizome.h +++ b/rhizome.h @@ -210,10 +210,10 @@ int rhizome_manifest_set_ll(rhizome_manifest *m,char *var,long long value); int rhizome_manifest_set(rhizome_manifest *m, const char *var, const char *value); int rhizome_manifest_del(rhizome_manifest *m, const char *var); long long rhizome_file_size(char *filename); -void _rhizome_manifest_free(struct __sourceloc where, rhizome_manifest *m); -#define rhizome_manifest_free(m) _rhizome_manifest_free(__HERE__,m) -rhizome_manifest *_rhizome_new_manifest(struct __sourceloc where); -#define rhizome_new_manifest() _rhizome_new_manifest(__HERE__) +void _rhizome_manifest_free(struct __sourceloc __whence, rhizome_manifest *m); +#define rhizome_manifest_free(m) _rhizome_manifest_free(__WHENCE__,m) +rhizome_manifest *_rhizome_new_manifest(struct __sourceloc __whence); +#define rhizome_new_manifest() _rhizome_new_manifest(__WHENCE__) int rhizome_manifest_pack_variables(rhizome_manifest *m); int rhizome_store_bundle(rhizome_manifest *m); int rhizome_manifest_add_group(rhizome_manifest *m,char *groupid); @@ -248,11 +248,11 @@ __RHIZOME_INLINE int sqlite_code_busy(int code) debugflags_t sqlite_set_debugmask(debugflags_t newmask); -sqlite3_stmt *_sqlite_prepare(struct __sourceloc where, sqlite_retry_state *retry, const char *sqlformat, ...); -sqlite3_stmt *_sqlite_prepare_loglevel(struct __sourceloc where, int log_level, sqlite_retry_state *retry, strbuf stmt); -int _sqlite_retry(struct __sourceloc where, sqlite_retry_state *retry, const char *action); -void _sqlite_retry_done(struct __sourceloc where, sqlite_retry_state *retry, const char *action); -int _sqlite_step_retry(struct __sourceloc where, int log_level, sqlite_retry_state *retry, sqlite3_stmt *statement); +sqlite3_stmt *_sqlite_prepare(struct __sourceloc __whence, sqlite_retry_state *retry, const char *sqlformat, ...); +sqlite3_stmt *_sqlite_prepare_loglevel(struct __sourceloc __whence, int log_level, sqlite_retry_state *retry, strbuf stmt); +int _sqlite_retry(struct __sourceloc __whence, sqlite_retry_state *retry, const char *action); +void _sqlite_retry_done(struct __sourceloc __whence, sqlite_retry_state *retry, const char *action); +int _sqlite_step_retry(struct __sourceloc __whence, int log_level, sqlite_retry_state *retry, sqlite3_stmt *statement); int _sqlite_exec_void(struct __sourceloc, const char *sqlformat, ...); int _sqlite_exec_void_loglevel(struct __sourceloc, int log_level, const char *sqlformat, ...); int _sqlite_exec_void_retry(struct __sourceloc, sqlite_retry_state *retry, const char *sqlformat, ...); @@ -260,18 +260,18 @@ int _sqlite_exec_int64(struct __sourceloc, long long *result, const char *sqlfor int _sqlite_exec_int64_retry(struct __sourceloc, sqlite_retry_state *retry, long long *result, const char *sqlformat,...); int _sqlite_exec_strbuf(struct __sourceloc, strbuf sb, const char *sqlformat,...); -#define sqlite_prepare(rs,fmt,...) _sqlite_prepare(__HERE__, (rs), (fmt), ##__VA_ARGS__) -#define sqlite_prepare_loglevel(ll,rs,sb) _sqlite_prepare_loglevel(__HERE__, (ll), (rs), (sb)) -#define sqlite_retry(rs,action) _sqlite_retry(__HERE__, (rs), (action)) -#define sqlite_retry_done(rs,action) _sqlite_retry_done(__HERE__, (rs), (action)) -#define sqlite_step(stmt) _sqlite_step_retry(__HERE__, LOG_LEVEL_ERROR, NULL, (stmt)) -#define sqlite_step_retry(rs,stmt) _sqlite_step_retry(__HERE__, LOG_LEVEL_ERROR, (rs), (stmt)) -#define sqlite_exec_void(fmt,...) _sqlite_exec_void(__HERE__, (fmt), ##__VA_ARGS__) -#define sqlite_exec_void_loglevel(ll,fmt,...) _sqlite_exec_void_loglevel(__HERE__, (ll), (fmt), ##__VA_ARGS__) -#define sqlite_exec_void_retry(rs,fmt,...) _sqlite_exec_void_retry(__HERE__, (rs), (fmt), ##__VA_ARGS__) -#define sqlite_exec_int64(res,fmt,...) _sqlite_exec_int64(__HERE__, (res), (fmt), ##__VA_ARGS__) -#define sqlite_exec_int64_retry(rs,res,fmt,...) _sqlite_exec_int64_retry(__HERE__, (rs), (res), (fmt), ##__VA_ARGS__) -#define sqlite_exec_strbuf(sb,fmt,...) _sqlite_exec_strbuf(__HERE__, (sb), (fmt), ##__VA_ARGS__) +#define sqlite_prepare(rs,fmt,...) _sqlite_prepare(__WHENCE__, (rs), (fmt), ##__VA_ARGS__) +#define sqlite_prepare_loglevel(ll,rs,sb) _sqlite_prepare_loglevel(__WHENCE__, (ll), (rs), (sb)) +#define sqlite_retry(rs,action) _sqlite_retry(__WHENCE__, (rs), (action)) +#define sqlite_retry_done(rs,action) _sqlite_retry_done(__WHENCE__, (rs), (action)) +#define sqlite_step(stmt) _sqlite_step_retry(__WHENCE__, LOG_LEVEL_ERROR, NULL, (stmt)) +#define sqlite_step_retry(rs,stmt) _sqlite_step_retry(__WHENCE__, LOG_LEVEL_ERROR, (rs), (stmt)) +#define sqlite_exec_void(fmt,...) _sqlite_exec_void(__WHENCE__, (fmt), ##__VA_ARGS__) +#define sqlite_exec_void_loglevel(ll,fmt,...) _sqlite_exec_void_loglevel(__WHENCE__, (ll), (fmt), ##__VA_ARGS__) +#define sqlite_exec_void_retry(rs,fmt,...) _sqlite_exec_void_retry(__WHENCE__, (rs), (fmt), ##__VA_ARGS__) +#define sqlite_exec_int64(res,fmt,...) _sqlite_exec_int64(__WHENCE__, (res), (fmt), ##__VA_ARGS__) +#define sqlite_exec_int64_retry(rs,res,fmt,...) _sqlite_exec_int64_retry(__WHENCE__, (rs), (res), (fmt), ##__VA_ARGS__) +#define sqlite_exec_strbuf(sb,fmt,...) _sqlite_exec_strbuf(__WHENCE__, (sb), (fmt), ##__VA_ARGS__) double rhizome_manifest_get_double(rhizome_manifest *m,char *var,double default_value); int rhizome_manifest_extract_signature(rhizome_manifest *m,int *ofs); diff --git a/rhizome_bundle.c b/rhizome_bundle.c index 13867a8d..25b59979 100644 --- a/rhizome_bundle.c +++ b/rhizome_bundle.c @@ -430,27 +430,27 @@ int rhizome_manifest_set_ll(rhizome_manifest *m,char *var,long long value) rhizome_manifest manifests[MAX_RHIZOME_MANIFESTS]; char manifest_free[MAX_RHIZOME_MANIFESTS]; int manifest_first_free=-1; -struct __sourceloc manifest_alloc_where[MAX_RHIZOME_MANIFESTS]; -struct __sourceloc manifest_free_where[MAX_RHIZOME_MANIFESTS]; +struct __sourceloc manifest_alloc_whence[MAX_RHIZOME_MANIFESTS]; +struct __sourceloc manifest_free_whence[MAX_RHIZOME_MANIFESTS]; -static void _log_manifest_trace(struct __sourceloc where, const char *operation) +static void _log_manifest_trace(struct __sourceloc __whence, const char *operation) { int count_free = 0; int i; for (i = 0; i != MAX_RHIZOME_MANIFESTS; ++i) if (manifest_free[i]) ++count_free; - logMessage(LOG_LEVEL_DEBUG, where, "%s(): count_free = %d", operation, count_free); + DEBUGF("%s(): count_free = %d", operation, count_free); } -rhizome_manifest *_rhizome_new_manifest(struct __sourceloc where) +rhizome_manifest *_rhizome_new_manifest(struct __sourceloc __whence) { if (manifest_first_free<0) { /* Setup structures */ int i; for(i=0;i=MAX_RHIZOME_MANIFESTS) { int i; - logMessage(LOG_LEVEL_ERROR, where, "%s(): no free manifest records, this probably indicates a memory leak", __FUNCTION__); + WHYF("%s(): no free manifest records, this probably indicates a memory leak", __FUNCTION__); WHYF(" Slot# | Last allocated by"); for(i=0;imanifest_record_number; if (m!=&manifests[mid]) { - logMessage(LOG_LEVEL_ERROR, where, - "%s(): asked to free manifest %p, which claims to be manifest slot #%d (%p), but isn't", + WHYF("%s(): asked to free manifest %p, which claims to be manifest slot #%d (%p), but isn't", __FUNCTION__, m, mid, &manifests[mid] ); exit(-1); } if (manifest_free[mid]) { - logMessage(LOG_LEVEL_ERROR, where, - "%s(): asked to free manifest slot #%d (%p), which was already freed at %s:%d:%s()", + WHYF("%s(): asked to free manifest slot #%d (%p), which was already freed at %s:%d:%s()", __FUNCTION__, mid, m, - manifest_free_where[mid].file, - manifest_free_where[mid].line, - manifest_free_where[mid].function + manifest_free_whence[mid].file, + manifest_free_whence[mid].line, + manifest_free_whence[mid].function ); exit(-1); } @@ -531,10 +529,10 @@ void _rhizome_manifest_free(struct __sourceloc where, rhizome_manifest *m) m->dataFileName=NULL; manifest_free[mid]=1; - manifest_free_where[mid]=where; + manifest_free_whence[mid]=__whence; if (midbusytries; @@ -285,8 +285,7 @@ int _sqlite_retry(struct __sourceloc where, sqlite_retry_state *retry, const cha retry->start = now; else retry->elapsed += now - retry->start; - logMessage(LOG_LEVEL_INFO, where, - "%s on try %u after %.3f seconds (%.3f elapsed): %s", + INFOF("%s on try %u after %.3f seconds (%.3f elapsed): %s", sqlite3_errmsg(rhizome_db), retry->busytries, (now - retry->start) / 1e3, @@ -305,12 +304,11 @@ int _sqlite_retry(struct __sourceloc where, sqlite_retry_state *retry, const cha return 1; // tell caller to try again } -void _sqlite_retry_done(struct __sourceloc where, sqlite_retry_state *retry, const char *action) +void _sqlite_retry_done(struct __sourceloc __whence, sqlite_retry_state *retry, const char *action) { if (retry->busytries) { time_ms_t now = gettime_ms(); - logMessage(LOG_LEVEL_INFO, where, - "succeeded on try %u after %.3f seconds (%.3f elapsed): %s", + INFOF("succeeded on try %u after %.3f seconds (%.3f elapsed): %s", retry->busytries + 1, (now - retry->start) / 1e3, retry->elapsed / 1e3, @@ -328,20 +326,18 @@ void _sqlite_retry_done(struct __sourceloc where, sqlite_retry_state *retry, con Returns -1 if an error occurs (logged as an error), otherwise zero with the prepared statement in *statement. */ -sqlite3_stmt *_sqlite_prepare(struct __sourceloc where, sqlite_retry_state *retry, const char *sqlformat, ...) +sqlite3_stmt *_sqlite_prepare(struct __sourceloc __whence, sqlite_retry_state *retry, const char *sqlformat, ...) { strbuf sql = strbuf_alloca(8192); strbuf_va_printf(sql, sqlformat); - return _sqlite_prepare_loglevel(where, LOG_LEVEL_ERROR, retry, sql); + return _sqlite_prepare_loglevel(__whence, LOG_LEVEL_ERROR, retry, sql); } -sqlite3_stmt *_sqlite_prepare_loglevel(struct __sourceloc where, int log_level, sqlite_retry_state *retry, strbuf stmt) +sqlite3_stmt *_sqlite_prepare_loglevel(struct __sourceloc __whence, int log_level, sqlite_retry_state *retry, strbuf stmt) { sqlite3_stmt *statement = NULL; - if (strbuf_overrun(stmt)) { - logMessage(LOG_LEVEL_ERROR, where, "SQL overrun: %s", strbuf_str(stmt)); - return NULL; - } + if (strbuf_overrun(stmt)) + return WHYFNULL("SQL overrun: %s", strbuf_str(stmt)); if (!rhizome_db && rhizome_opendb() == -1) return NULL; while (1) { @@ -351,22 +347,22 @@ sqlite3_stmt *_sqlite_prepare_loglevel(struct __sourceloc where, int log_level, return statement; case SQLITE_BUSY: case SQLITE_LOCKED: - if (retry && _sqlite_retry(where, retry, strbuf_str(stmt))) { + if (retry && _sqlite_retry(__whence, retry, strbuf_str(stmt))) { break; // back to sqlite3_prepare_v2() } // fall through... default: - logMessage(log_level, where, "query invalid, %s: %s", sqlite3_errmsg(rhizome_db), strbuf_str(stmt)); + LOGF(log_level, "query invalid, %s: %s", sqlite3_errmsg(rhizome_db), strbuf_str(stmt)); sqlite3_finalize(statement); return NULL; } } } -int _sqlite_step_retry(struct __sourceloc where, int log_level, sqlite_retry_state *retry, sqlite3_stmt *statement) +int _sqlite_step_retry(struct __sourceloc __whence, int log_level, sqlite_retry_state *retry, sqlite3_stmt *statement) { int ret = -1; - sqlite_trace_where = &where; + sqlite_trace_whence = &__whence; while (statement) { int stepcode = sqlite3_step(statement); switch (stepcode) { @@ -374,25 +370,25 @@ int _sqlite_step_retry(struct __sourceloc where, int log_level, sqlite_retry_sta case SQLITE_DONE: case SQLITE_ROW: if (retry) - _sqlite_retry_done(where, retry, sqlite3_sql(statement)); + _sqlite_retry_done(__whence, retry, sqlite3_sql(statement)); ret = stepcode; statement = NULL; break; case SQLITE_BUSY: case SQLITE_LOCKED: - if (retry && _sqlite_retry(where, retry, sqlite3_sql(statement))) { + if (retry && _sqlite_retry(__whence, retry, sqlite3_sql(statement))) { sqlite3_reset(statement); break; // back to sqlite3_step() } // fall through... default: - logMessage(log_level, where, "query failed, %s: %s", sqlite3_errmsg(rhizome_db), sqlite3_sql(statement)); + LOGF(log_level, "query failed, %s: %s", sqlite3_errmsg(rhizome_db), sqlite3_sql(statement)); ret = -1; statement = NULL; break; } } - sqlite_trace_where = NULL; + sqlite_trace_whence = NULL; return ret; } @@ -403,37 +399,37 @@ int _sqlite_step_retry(struct __sourceloc where, int log_level, sqlite_retry_sta the statement and retries while sqlite_retry() returns true. If sqlite_retry() returns false then returns -1. Otherwise returns zero. Always finalises the statement before returning. */ -static int _sqlite_exec_void_prepared(struct __sourceloc where, int log_level, sqlite_retry_state *retry, sqlite3_stmt *statement) +static int _sqlite_exec_void_prepared(struct __sourceloc __whence, int log_level, sqlite_retry_state *retry, sqlite3_stmt *statement) { if (!statement) return -1; int rowcount = 0; int stepcode; - while ((stepcode = _sqlite_step_retry(where, log_level, retry, statement)) == SQLITE_ROW) + while ((stepcode = _sqlite_step_retry(__whence, log_level, retry, statement)) == SQLITE_ROW) ++rowcount; if (rowcount) - logMessage(LOG_LEVEL_WARN, where, "void query unexpectedly returned %d row%s", rowcount, rowcount == 1 ? "" : "s"); + WARNF("void query unexpectedly returned %d row%s", rowcount, rowcount == 1 ? "" : "s"); sqlite3_finalize(statement); return sqlite_code_ok(stepcode) ? 0 : -1; } -static int _sqlite_vexec_void(struct __sourceloc where, int log_level, sqlite_retry_state *retry, const char *sqlformat, va_list ap) +static int _sqlite_vexec_void(struct __sourceloc __whence, int log_level, sqlite_retry_state *retry, const char *sqlformat, va_list ap) { strbuf stmt = strbuf_alloca(8192); strbuf_vsprintf(stmt, sqlformat, ap); - return _sqlite_exec_void_prepared(where, log_level, retry, _sqlite_prepare_loglevel(where, log_level, retry, stmt)); + return _sqlite_exec_void_prepared(__whence, log_level, retry, _sqlite_prepare_loglevel(__whence, log_level, retry, stmt)); } /* Convenience wrapper for executing an SQL command that returns no value. If an error occurs then logs it at ERROR level and returns -1. Otherwise returns zero. @author Andrew Bettison */ -int _sqlite_exec_void(struct __sourceloc where, const char *sqlformat, ...) +int _sqlite_exec_void(struct __sourceloc __whence, const char *sqlformat, ...) { va_list ap; va_start(ap, sqlformat); sqlite_retry_state retry = SQLITE_RETRY_STATE_DEFAULT; - int ret = _sqlite_vexec_void(where, LOG_LEVEL_ERROR, &retry, sqlformat, ap); + int ret = _sqlite_vexec_void(__whence, LOG_LEVEL_ERROR, &retry, sqlformat, ap); va_end(ap); return ret; } @@ -441,12 +437,12 @@ int _sqlite_exec_void(struct __sourceloc where, const char *sqlformat, ...) /* Same as sqlite_exec_void(), but logs any error at the given level instead of ERROR. @author Andrew Bettison */ -int _sqlite_exec_void_loglevel(struct __sourceloc where, int log_level, const char *sqlformat, ...) +int _sqlite_exec_void_loglevel(struct __sourceloc __whence, int log_level, const char *sqlformat, ...) { va_list ap; va_start(ap, sqlformat); sqlite_retry_state retry = SQLITE_RETRY_STATE_DEFAULT; - int ret = _sqlite_vexec_void(where, log_level, &retry, sqlformat, ap); + int ret = _sqlite_vexec_void(__whence, log_level, &retry, sqlformat, ap); va_end(ap); return ret; } @@ -457,36 +453,34 @@ int _sqlite_exec_void_loglevel(struct __sourceloc where, int log_level, const ch all in the event of a busy condition, but will log it as an error and return immediately. @author Andrew Bettison */ -int _sqlite_exec_void_retry(struct __sourceloc where, sqlite_retry_state *retry, const char *sqlformat, ...) +int _sqlite_exec_void_retry(struct __sourceloc __whence, sqlite_retry_state *retry, const char *sqlformat, ...) { va_list ap; va_start(ap, sqlformat); - int ret = _sqlite_vexec_void(where, LOG_LEVEL_ERROR, retry, sqlformat, ap); + int ret = _sqlite_vexec_void(__whence, LOG_LEVEL_ERROR, retry, sqlformat, ap); va_end(ap); return ret; } -static int _sqlite_vexec_int64(struct __sourceloc where, sqlite_retry_state *retry, long long *result, const char *sqlformat, va_list ap) +static int _sqlite_vexec_int64(struct __sourceloc __whence, sqlite_retry_state *retry, long long *result, const char *sqlformat, va_list ap) { strbuf stmt = strbuf_alloca(8192); strbuf_vsprintf(stmt, sqlformat, ap); - sqlite3_stmt *statement = _sqlite_prepare_loglevel(where, LOG_LEVEL_ERROR, retry, stmt); + sqlite3_stmt *statement = _sqlite_prepare_loglevel(__whence, LOG_LEVEL_ERROR, retry, stmt); if (!statement) return -1; int ret = 0; int rowcount = 0; int stepcode; - while ((stepcode = _sqlite_step_retry(where, LOG_LEVEL_ERROR, retry, statement)) == SQLITE_ROW) { + while ((stepcode = _sqlite_step_retry(__whence, LOG_LEVEL_ERROR, retry, statement)) == SQLITE_ROW) { int columncount = sqlite3_column_count(statement); - if (columncount != 1) { - logMessage(LOG_LEVEL_ERROR, where, "incorrect column count %d (should be 1): %s", columncount, sqlite3_sql(statement)); - ret = -1; - } + if (columncount != 1) + ret = WHYF("incorrect column count %d (should be 1): %s", columncount, sqlite3_sql(statement)); else if (++rowcount == 1) *result = sqlite3_column_int64(statement, 0); } if (rowcount > 1) - logMessage(LOG_LEVEL_WARN, where, "query unexpectedly returned %d rows, ignored all but first", rowcount); + WARNF("query unexpectedly returned %d rows, ignored all but first", rowcount); sqlite3_finalize(statement); return sqlite_code_ok(stepcode) && ret != -1 ? rowcount : -1; } @@ -499,12 +493,12 @@ static int _sqlite_vexec_int64(struct __sourceloc where, sqlite_retry_state *ret If more than one row is found, then logs a warning, assigns the value of the first row to *result and returns the number of rows. */ -int _sqlite_exec_int64(struct __sourceloc where, long long *result, const char *sqlformat,...) +int _sqlite_exec_int64(struct __sourceloc __whence, long long *result, const char *sqlformat,...) { va_list ap; va_start(ap, sqlformat); sqlite_retry_state retry = SQLITE_RETRY_STATE_DEFAULT; - int ret = _sqlite_vexec_int64(where, &retry, result, sqlformat, ap); + int ret = _sqlite_vexec_int64(__whence, &retry, result, sqlformat, ap); va_end(ap); return ret; } @@ -515,11 +509,11 @@ int _sqlite_exec_int64(struct __sourceloc where, long long *result, const char * all in the event of a busy condition, but will log it as an error and return immediately. @author Andrew Bettison */ -int _sqlite_exec_int64_retry(struct __sourceloc where, sqlite_retry_state *retry, long long *result, const char *sqlformat,...) +int _sqlite_exec_int64_retry(struct __sourceloc __whence, sqlite_retry_state *retry, long long *result, const char *sqlformat,...) { va_list ap; va_start(ap, sqlformat); - int ret = _sqlite_vexec_int64(where, retry, result, sqlformat, ap); + int ret = _sqlite_vexec_int64(__whence, retry, result, sqlformat, ap); va_end(ap); return ret; } @@ -532,28 +526,26 @@ int _sqlite_exec_int64_retry(struct __sourceloc where, sqlite_retry_state *retry 2 more than one row, logs a warning and appends the first row's column to the strbuf @author Andrew Bettison */ -int _sqlite_exec_strbuf(struct __sourceloc where, strbuf sb, const char *sqlformat,...) +int _sqlite_exec_strbuf(struct __sourceloc __whence, strbuf sb, const char *sqlformat,...) { strbuf stmt = strbuf_alloca(8192); strbuf_va_printf(stmt, sqlformat); sqlite_retry_state retry = SQLITE_RETRY_STATE_DEFAULT; - sqlite3_stmt *statement = _sqlite_prepare_loglevel(where, LOG_LEVEL_ERROR, &retry, stmt); + sqlite3_stmt *statement = _sqlite_prepare_loglevel(__whence, LOG_LEVEL_ERROR, &retry, stmt); if (!statement) return -1; int ret = 0; int rowcount = 0; int stepcode; - while ((stepcode = _sqlite_step_retry(where, LOG_LEVEL_ERROR, &retry, statement)) == SQLITE_ROW) { + while ((stepcode = _sqlite_step_retry(__whence, LOG_LEVEL_ERROR, &retry, statement)) == SQLITE_ROW) { int columncount = sqlite3_column_count(statement); - if (columncount != 1) { - logMessage(LOG_LEVEL_ERROR, where, "incorrect column count %d (should be 1): %s", columncount, sqlite3_sql(statement)); - ret = -1; - } + if (columncount != 1) + ret - WHYF("incorrect column count %d (should be 1): %s", columncount, sqlite3_sql(statement)); else if (++rowcount == 1) strbuf_puts(sb, (const char *)sqlite3_column_text(statement, 0)); } if (rowcount > 1) - logMessage(LOG_LEVEL_WARN, where, "query unexpectedly returned %d rows, ignored all but first", rowcount); + WARNF("query unexpectedly returned %d rows, ignored all but first", rowcount); sqlite3_finalize(statement); return sqlite_code_ok(stepcode) && ret != -1 ? rowcount : -1; } @@ -1034,7 +1026,7 @@ int rhizome_store_file(rhizome_manifest *m,const unsigned char *key) goto insert_row_fail; } /* Do actual insert, and abort if it fails */ - if (_sqlite_exec_void_prepared(__HERE__, LOG_LEVEL_ERROR, &retry, statement) == -1) { + if (_sqlite_exec_void_prepared(__WHENCE__, LOG_LEVEL_ERROR, &retry, statement) == -1) { insert_row_fail: WHYF("Failed to insert row for fileid=%s", hash); goto error; diff --git a/serval.h b/serval.h index 08047a00..142a313a 100644 --- a/serval.h +++ b/serval.h @@ -566,8 +566,6 @@ int overlay_frame_resolve_addresses(struct overlay_frame *f); time_ms_t overlay_time_until_next_tick(); int overlay_rx_messages(); -#define DEBUG_packet_visualise(M,P,N) logServalPacket(LOG_LEVEL_DEBUG, __HERE__, (M), (P), (N)) - int overlay_add_selfannouncement(); int overlay_frame_append_payload(overlay_interface *interface, struct overlay_frame *p, struct subscriber *next_hop, struct overlay_buffer *b); int overlay_interface_args(const char *arg); @@ -766,13 +764,13 @@ int dump_payload(struct overlay_frame *p, char *message); int urandombytes(unsigned char *x,unsigned long long xlen); #ifdef MALLOC_PARANOIA -#define malloc(X) _serval_debug_malloc(X,__HERE__) -#define calloc(X,Y) _serval_debug_calloc(X,Y,__HERE__) -#define free(X) _serval_debug_free(X,__HERE__) +#define malloc(X) _serval_debug_malloc(X,__WHENCE__) +#define calloc(X,Y) _serval_debug_calloc(X,Y,__WHENCE__) +#define free(X) _serval_debug_free(X,__WHENCE__) -void *_serval_debug_malloc(unsigned int bytes, struct __sourceloc where); -void *_serval_debug_calloc(unsigned int bytes, unsigned int count, struct __sourceloc where); -void _serval_debug_free(void *p, struct __sourceloc where); +void *_serval_debug_malloc(unsigned int bytes, struct __sourceloc whence); +void *_serval_debug_calloc(unsigned int bytes, unsigned int count, struct __sourceloc whence); +void _serval_debug_free(void *p, struct __sourceloc whence); #endif