db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-04-19 11:52:32 +02:00
Code Issues Releases Activity
pgbackrest/src/common/debug.h

338 lines
25 KiB
C
Raw Normal View History

Add ASSERT_DEBUG() macro for debugging. Replace all current assert() calls except in tests that can't use the debug code.
2018-03-12 14:31:22 -04:00
/***********************************************************************************************************************************
Debug Routines
***********************************************************************************************************************************/
#ifndef COMMON_DEBUG_H
#define COMMON_DEBUG_H
Add stack trace macros to all functions. Low-level functions only include stack trace in test builds while higher-level functions ship with stack trace built-in. Stack traces include all parameters passed to the function but production builds only create the parameter list when the log level is set high enough, i.e. debug or trace depending on the function.
2018-05-18 11:57:32 -04:00
#include "common/stackTrace.h"
#include "common/type/convert.h"
Add ASSERT_DEBUG() macro for debugging. Replace all current assert() calls except in tests that can't use the debug code.
2018-03-12 14:31:22 -04:00
/***********************************************************************************************************************************
NDEBUG indicates to C library routines that debugging is off -- set a more readable flag to use when debugging is on
***********************************************************************************************************************************/
#ifndef NDEBUG
#define DEBUG
#endif
Improve debugging. * Replace remaining NDEBUG blocks with the more granular DEBUG_UNIT. * Remove some debug memset() calls in MemContext since valgrind is more useful for these checks.
2018-03-12 17:15:14 -04:00
/***********************************************************************************************************************************
Extern variables that are needed for unit testing
***********************************************************************************************************************************/
#ifdef DEBUG_UNIT
#define DEBUG_UNIT_EXTERN
#else
#define DEBUG_UNIT_EXTERN \
static
#endif
Add stack trace macros to all functions. Low-level functions only include stack trace in test builds while higher-level functions ship with stack trace built-in. Stack traces include all parameters passed to the function but production builds only create the parameter list when the log level is set high enough, i.e. debug or trace depending on the function.
2018-05-18 11:57:32 -04:00
/***********************************************************************************************************************************
Base function debugging macros
In debug mode parameters will always be recorded in the stack trace while in production mode they will only be recorded when the log
level is set to debug or trace.
***********************************************************************************************************************************/
#define FUNCTION_DEBUG_LEVEL() \
FUNCTION_DEBUG_logLevel
#ifdef DEBUG
#define FUNCTION_DEBUG_BEGIN_BASE(logLevel) \
LogLevel FUNCTION_DEBUG_LEVEL() = STACK_TRACE_PUSH(logLevel); \
\
{ \
stackTraceParamLog();
#define FUNCTION_DEBUG_END_BASE() \
LOG_WILL(FUNCTION_DEBUG_LEVEL(), 0, "(%s)", stackTraceParam()); \
}
#define FUNCTION_DEBUG_PARAM_BASE_BEGIN() \
stackTraceTestStop() \
#define FUNCTION_DEBUG_PARAM_BASE_END() \
stackTraceTestStart()
#else
#define FUNCTION_DEBUG_BEGIN_BASE(logLevel) \
LogLevel FUNCTION_DEBUG_LEVEL() = STACK_TRACE_PUSH(logLevel); \
\
if (logWill(FUNCTION_DEBUG_LEVEL())) \
{ \
stackTraceParamLog()
#define FUNCTION_DEBUG_END_BASE() \
LOG(FUNCTION_DEBUG_LEVEL(), 0, "(%s)", stackTraceParam()); \
}
#define FUNCTION_DEBUG_PARAM_BASE_BEGIN()
#define FUNCTION_DEBUG_PARAM_BASE_END()
#endif
/***********************************************************************************************************************************
General purpose function debugging macros
FUNCTION_DEBUG_VOID() is provided as a shortcut for functions that have no parameters.
***********************************************************************************************************************************/
#define FUNCTION_DEBUG_BEGIN(logLevel) \
FUNCTION_DEBUG_BEGIN_BASE(logLevel)
#define FUNCTION_DEBUG_END() \
FUNCTION_DEBUG_END_BASE()
#define FUNCTION_DEBUG_VOID(logLevel) \
FUNCTION_DEBUG_BEGIN_BASE(logLevel); \
FUNCTION_DEBUG_END_BASE()
#define FUNCTION_DEBUG_PARAM(typeMacroPrefix, param) \
FUNCTION_DEBUG_PARAM_BASE_BEGIN(); \
stackTraceParamAdd(FUNCTION_DEBUG_##typeMacroPrefix##_FORMAT(param, stackTraceParamBuffer(#param), STACK_TRACE_PARAM_MAX)); \
FUNCTION_DEBUG_PARAM_BASE_END()
#define FUNCTION_DEBUG_PARAM_PTR(typeName, param) \
FUNCTION_DEBUG_PARAM_BASE_BEGIN(); \
stackTraceParamAdd(ptrToLog(param, typeName, stackTraceParamBuffer(#param), STACK_TRACE_PARAM_MAX )); \
FUNCTION_DEBUG_PARAM_BASE_END()
/***********************************************************************************************************************************
Functions and macros to render various data types
***********************************************************************************************************************************/
size_t objToLog(const void *object, const char *objectName, char *buffer, size_t bufferSize);
size_t ptrToLog(const void *pointer, const char *pointerName, char *buffer, size_t bufferSize);
size_t strzToLog(const char *string, char *buffer, size_t bufferSize);
#define FUNCTION_DEBUG_BOOL_TYPE \
bool
#define FUNCTION_DEBUG_BOOL_FORMAT(value, buffer, bufferSize) \
cvtBoolToZ(value, buffer, bufferSize)
#define FUNCTION_DEBUG_BOOLP_TYPE \
bool *
#define FUNCTION_DEBUG_BOOLP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "bool *", buffer, bufferSize)
Add cvtCharToZ() and macro for debugging char params.
2018-08-14 16:18:17 -04:00
#define FUNCTION_DEBUG_CHAR_TYPE \
char
#define FUNCTION_DEBUG_CHAR_FORMAT(value, buffer, bufferSize) \
cvtCharToZ(value, buffer, bufferSize)
Add stack trace macros to all functions. Low-level functions only include stack trace in test builds while higher-level functions ship with stack trace built-in. Stack traces include all parameters passed to the function but production builds only create the parameter list when the log level is set high enough, i.e. debug or trace depending on the function.
2018-05-18 11:57:32 -04:00
#define FUNCTION_DEBUG_CHARP_TYPE \
char *
#define FUNCTION_DEBUG_CHARP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "char *", buffer, bufferSize)
#define FUNCTION_DEBUG_CONST_CHARPP_TYPE \
const char **
#define FUNCTION_DEBUG_CONST_CHARPP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "char **", buffer, bufferSize)
#define FUNCTION_DEBUG_CHARPY_TYPE \
char *[]
#define FUNCTION_DEBUG_CHARPY_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "char *[]", buffer, bufferSize)
#define FUNCTION_DEBUG_DOUBLE_TYPE \
double
#define FUNCTION_DEBUG_DOUBLE_FORMAT(value, buffer, bufferSize) \
cvtDoubleToZ(value, buffer, bufferSize)
#define FUNCTION_DEBUG_DOUBLEP_TYPE \
double *
#define FUNCTION_DEBUG_DOUBLEP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "double *", buffer, bufferSize)
#define FUNCTION_DEBUG_INT_TYPE \
int
#define FUNCTION_DEBUG_INT_FORMAT(value, buffer, bufferSize) \
cvtIntToZ(value, buffer, bufferSize)
#define FUNCTION_DEBUG_INTP_TYPE \
int *
#define FUNCTION_DEBUG_INTP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "int *", buffer, bufferSize)
#define FUNCTION_DEBUG_INT64_TYPE \
int64_t
#define FUNCTION_DEBUG_INT64_FORMAT(value, buffer, bufferSize) \
cvtInt64ToZ(value, buffer, bufferSize)
#define FUNCTION_DEBUG_ENUM_TYPE \
unsigned int
#define FUNCTION_DEBUG_ENUM_FORMAT(value, buffer, bufferSize) \
FUNCTION_DEBUG_UINT_FORMAT(value, buffer, bufferSize)
#define FUNCTION_DEBUG_FUNCTIONP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value == NULL ? NULL : (void *)1, "function *", buffer, bufferSize)
#define FUNCTION_DEBUG_MODE_TYPE \
mode_t
#define FUNCTION_DEBUG_MODE_FORMAT(value, buffer, bufferSize) \
cvtModeToZ(value, buffer, bufferSize)
Construct Wait object in milliseconds instead of fractional seconds. The Wait object accepted a double in the constructor for wait time but used TimeMSec internally. This was done for compatibility with the Perl code. Instead, use TimeMSec in the Wait constructor and make changes as needed to calling code. Note that Perl still uses a double for its Wait object so translation is needed in some places. There are no plans to update the Perl code as it will become obsolete.
2018-11-08 08:37:57 -05:00
#define FUNCTION_DEBUG_TIMEMSEC_TYPE \
TimeMSec
#define FUNCTION_DEBUG_TIMEMSEC_FORMAT(value, buffer, bufferSize) \
cvtUInt64ToZ(value, buffer, bufferSize)
Add stack trace macros to all functions. Low-level functions only include stack trace in test builds while higher-level functions ship with stack trace built-in. Stack traces include all parameters passed to the function but production builds only create the parameter list when the log level is set high enough, i.e. debug or trace depending on the function.
2018-05-18 11:57:32 -04:00
#define FUNCTION_DEBUG_UCHARP_TYPE \
unsigned char *
#define FUNCTION_DEBUG_UCHARP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "unsigned char *", buffer, bufferSize)
#define FUNCTION_DEBUG_SIZE_TYPE \
size_t
#define FUNCTION_DEBUG_SIZE_FORMAT(value, buffer, bufferSize) \
cvtSizeToZ(value, buffer, bufferSize)
#define FUNCTION_DEBUG_UINT_TYPE \
unsigned int
#define FUNCTION_DEBUG_UINT_FORMAT(value, buffer, bufferSize) \
cvtUIntToZ(value, buffer, bufferSize)
Correct cfgDefDataFind() to use UINTP instead of VOIDPP. Also add the UINTP macro. Contributed by Cynthia Shang.
2018-10-19 10:51:33 +02:00
#define FUNCTION_DEBUG_UINTP_TYPE \
unsigned int *
#define FUNCTION_DEBUG_UINTP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "unsigned int *", buffer, bufferSize)
Add stack trace macros to all functions. Low-level functions only include stack trace in test builds while higher-level functions ship with stack trace built-in. Stack traces include all parameters passed to the function but production builds only create the parameter list when the log level is set high enough, i.e. debug or trace depending on the function.
2018-05-18 11:57:32 -04:00
#define FUNCTION_DEBUG_UINT16_TYPE \
uint16_t
#define FUNCTION_DEBUG_UINT16_FORMAT(value, buffer, bufferSize) \
FUNCTION_DEBUG_UINT_FORMAT(value, buffer, bufferSize)
#define FUNCTION_DEBUG_UINT32_TYPE \
uint32_t
#define FUNCTION_DEBUG_UINT32_FORMAT(value, buffer, bufferSize) \
FUNCTION_DEBUG_UINT_FORMAT(value, buffer, bufferSize)
#define FUNCTION_DEBUG_UINT64_TYPE \
uint64_t
#define FUNCTION_DEBUG_UINT64_FORMAT(value, buffer, bufferSize) \
cvtUInt64ToZ(value, buffer, bufferSize)
#define FUNCTION_DEBUG_VOIDP_TYPE \
void *
#define FUNCTION_DEBUG_VOIDP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "void *", buffer, bufferSize)
Full abstraction of storage driver interface. The external storage interfaces (Storage, StorageFileRead, etc.) have been stable for a while, but internally they were calling the posix driver functions directly. Create driver interfaces for storage, fileRead, and fileWrite and remove all references to the posix driver outside storage/driver/posix (with the exception of a direct call to pathRemove() in Perl LibC). Posix is still the only available driver so more adjustment may be needed, but this should represent the bulk of the changes.
2018-09-14 16:08:33 -04:00
#define FUNCTION_DEBUG_CONST_VOIDP_TYPE \
const void *
#define FUNCTION_DEBUG_CONST_VOIDP_FORMAT(value, buffer, bufferSize) \
FUNCTION_DEBUG_VOIDP_FORMAT(value, buffer, bufferSize)
Add stack trace macros to all functions. Low-level functions only include stack trace in test builds while higher-level functions ship with stack trace built-in. Stack traces include all parameters passed to the function but production builds only create the parameter list when the log level is set high enough, i.e. debug or trace depending on the function.
2018-05-18 11:57:32 -04:00
#define FUNCTION_DEBUG_VOIDPP_TYPE \
void **
#define FUNCTION_DEBUG_VOIDPP_FORMAT(value, buffer, bufferSize) \
ptrToLog(value, "void **", buffer, bufferSize)
#define FUNCTION_DEBUG_STRINGZ_TYPE \
const char *
#define FUNCTION_DEBUG_STRINGZ_FORMAT(value, buffer, bufferSize) \
strzToLog(value, buffer, bufferSize)
/***********************************************************************************************************************************
Assert function to be used with function debugging
The assert statement is compiled into production code but only runs when the log level >= debug
***********************************************************************************************************************************/
#define FUNCTION_DEBUG_ASSERT(condition) \
do \
{ \
if (!(condition)) \
THROW_FMT(AssertError, "function debug assertion '%s' failed", #condition); \
} \
while (0)
/***********************************************************************************************************************************
Macros to return function results (or void)
***********************************************************************************************************************************/
#define FUNCTION_DEBUG_RESULT(typeMacroPrefix, result) \
do \
{ \
FUNCTION_DEBUG_##typeMacroPrefix##_TYPE FUNCTION_DEBUG_RESULT_result = result; \
\
STACK_TRACE_POP(); \
\
if (logWill(FUNCTION_DEBUG_LEVEL())) \
{ \
char buffer[STACK_TRACE_PARAM_MAX]; \
\
FUNCTION_DEBUG_##typeMacroPrefix##_FORMAT(FUNCTION_DEBUG_RESULT_result, buffer, sizeof(buffer)); \
LOG(FUNCTION_DEBUG_LEVEL(), 0, "=> %s", buffer); \
} \
\
return FUNCTION_DEBUG_RESULT_result; \
} \
while(0)
#define FUNCTION_DEBUG_RESULT_VOID() \
do \
{ \
STACK_TRACE_POP(); \
\
LOG_WILL(FUNCTION_DEBUG_LEVEL(), 0, "=> void"); \
} \
while(0)
/***********************************************************************************************************************************
Function Test Macros
In debug builds these macros will update the stack trace with function names and parameters but not log. In production builds all
test macros are compiled out.
***********************************************************************************************************************************/
#ifdef DEBUG
#define FUNCTION_TEST_BEGIN() \
if (stackTraceTest()) \
{ \
STACK_TRACE_PUSH(logLevelDebug); \
stackTraceParamLog()
#define FUNCTION_TEST_PARAM(typeMacroPrefix, param) \
FUNCTION_DEBUG_PARAM(typeMacroPrefix, param)
#define FUNCTION_TEST_PARAM_PTR(typeName, param) \
FUNCTION_DEBUG_PARAM_PTR(typeName, param)
#define FUNCTION_TEST_END() \
}
#define FUNCTION_TEST_VOID() \
FUNCTION_TEST_BEGIN(); \
FUNCTION_TEST_END();
#define FUNCTION_TEST_ASSERT(condition) \
do \
{ \
if (!(condition)) \
THROW_FMT(AssertError, "function test assertion '%s' failed", #condition); \
} \
while (0)
#define FUNCTION_TEST_RESULT(typeMacroPrefix, result) \
do \
{ \
FUNCTION_DEBUG_##typeMacroPrefix##_TYPE FUNCTION_DEBUG_RESULT_result = result; \
\
if (stackTraceTest()) \
STACK_TRACE_POP(); \
\
return FUNCTION_DEBUG_RESULT_result; \
} \
while(0);
#define FUNCTION_TEST_RESULT_VOID() \
do \
{ \
if (stackTraceTest()) \
STACK_TRACE_POP(); \
} \
while(0);
#else
#define FUNCTION_TEST_BEGIN()
#define FUNCTION_TEST_PARAM(typeMacroPrefix, param)
#define FUNCTION_TEST_PARAM_PTR(typeName, param)
#define FUNCTION_TEST_END()
#define FUNCTION_TEST_VOID()
#define FUNCTION_TEST_ASSERT(condition)
#define FUNCTION_TEST_RESULT(typeMacroPrefix, result) \
return result
#define FUNCTION_TEST_RESULT_VOID()
#endif
Add ASSERT_DEBUG() macro for debugging. Replace all current assert() calls except in tests that can't use the debug code.
2018-03-12 14:31:22 -04:00
#endif
Reference in New Issue Copy Permalink