lib/util/debug.h

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB debug stuff
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) John H Terpstra 1996-1998
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1998
   7    Copyright (C) Paul Ashton 1998
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #ifndef _SAMBA_DEBUG_H
  24 #define _SAMBA_DEBUG_H
  25
  26 #include <stdbool.h>
  27 #include <stddef.h>
  28 #include <stdarg.h>
  29 #include "attr.h"
  30
  31
  32 /* -------------------------------------------------------------------------- **
  33  * Debugging code.  See also debug.c
  34  */
  35
  36 /* the maximum debug level to compile into the code. This assumes a good
  37    optimising compiler that can remove unused code
  38    for embedded or low-memory systems set this to a value like 2 to get
  39    only important messages. This gives *much* smaller binaries
  40 */
  41 #ifndef MAX_DEBUG_LEVEL
  42 #define MAX_DEBUG_LEVEL 1000
  43 #endif
  44
  45 bool dbgtext_va(const char *, va_list ap) PRINTF_ATTRIBUTE(1,0);
  46 bool dbgtext( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
  47 bool dbghdrclass( int level, int cls, const char *location, const char *func);
  48 bool dbghdr( int level, const char *location, const char *func);
  49
  50 /*
  51  * Redefine DEBUGLEVEL because so we don't have to change every source file
  52  * that *unnecessarily* references it.
  53  */
  54 #define DEBUGLEVEL DEBUGLEVEL_CLASS[DBGC_ALL]
  55
  56 /*
  57  * Define all new debug classes here. A class is represented by an entry in
  58  * the DEBUGLEVEL_CLASS array. Index zero of this arrray is equivalent to the
  59  * old DEBUGLEVEL. Any source file that does NOT add the following lines:
  60  *
  61  *   #undef  DBGC_CLASS
  62  *   #define DBGC_CLASS DBGC_<your class name here>
  63  *
  64  * at the start of the file (after #include "includes.h") will default to
  65  * using index zero, so it will behaive just like it always has.
  66  */
  67 #define DBGC_ALL                0 /* index equivalent to DEBUGLEVEL */
  68
  69 #define DBGC_TDB                1
  70 #define DBGC_PRINTDRIVERS       2
  71 #define DBGC_LANMAN             3
  72 #define DBGC_SMB                4
  73 #define DBGC_RPC_PARSE          5
  74 #define DBGC_RPC_SRV            6
  75 #define DBGC_RPC_CLI            7
  76 #define DBGC_PASSDB             8
  77 #define DBGC_SAM                9
  78 #define DBGC_AUTH               10
  79 #define DBGC_WINBIND            11
  80 #define DBGC_VFS                12
  81 #define DBGC_IDMAP              13
  82 #define DBGC_QUOTA              14
  83 #define DBGC_ACLS               15
  84 #define DBGC_LOCKING            16
  85 #define DBGC_MSDFS              17
  86 #define DBGC_DMAPI              18
  87 #define DBGC_REGISTRY           19
  88 #define DBGC_SCAVENGER          20
  89 #define DBGC_DNS                21
  90 #define DBGC_LDB                22
  91 #define DBGC_TEVENT             23
  92 #define DBGC_AUTH_AUDIT         24
  93 #define DBGC_AUTH_AUDIT_JSON    25
  94 #define DBGC_KERBEROS           26
  95 #define DBGC_DRS_REPL           27
  96 #define DBGC_SMB2               28
  97 #define DBGC_SMB2_CREDITS       29
  98 #define DBGC_DSDB_AUDIT 30
  99 #define DBGC_DSDB_AUDIT_JSON    31
 100 #define DBGC_DSDB_PWD_AUDIT             32
 101 #define DBGC_DSDB_PWD_AUDIT_JSON        33
 102 #define DBGC_DSDB_TXN_AUDIT             34
 103 #define DBGC_DSDB_TXN_AUDIT_JSON        35
 104 #define DBGC_DSDB_GROUP_AUDIT   36
 105 #define DBGC_DSDB_GROUP_AUDIT_JSON      37
 106
 107 /* So you can define DBGC_CLASS before including debug.h */
 108 #ifndef DBGC_CLASS
 109 #define DBGC_CLASS            0     /* override as shown above */
 110 #endif
 111
 112 extern int  *DEBUGLEVEL_CLASS;
 113
 114 /* Debugging macros
 115  *
 116  * DEBUGLVL()
 117  *   If the 'file specific' debug class level >= level OR the system-wide
 118  *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
 119  *   generate a header using the default macros for file, line, and
 120  *   function name. Returns True if the debug level was <= DEBUGLEVEL.
 121  *
 122  *   Example: if( DEBUGLVL( 2 ) ) dbgtext( "Some text.\n" );
 123  *
 124  * DEBUG()
 125  *   If the 'file specific' debug class level >= level OR the system-wide
 126  *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
 127  *   generate a header using the default macros for file, line, and
 128  *   function name. Each call to DEBUG() generates a new header *unless* the
 129  *   previous debug output was unterminated (i.e. no '\n').
 130  *   See debug.c:dbghdr() for more info.
 131  *
 132  *   Example: DEBUG( 2, ("Some text and a value %d.\n", value) );
 133  *
 134  * DEBUGC()
 135  *   If the 'macro specified' debug class level >= level OR the system-wide
 136  *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
 137  *   generate a header using the default macros for file, line, and
 138  *   function name. Each call to DEBUG() generates a new header *unless* the
 139  *   previous debug output was unterminated (i.e. no '\n').
 140  *   See debug.c:dbghdr() for more info.
 141  *
 142  *   Example: DEBUGC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
 143  *
 144  *  DEBUGADD(), DEBUGADDC()
 145  *    Same as DEBUG() and DEBUGC() except the text is appended to the previous
 146  *    DEBUG(), DEBUGC(), DEBUGADD(), DEBUGADDC() with out another interviening
 147  *    header.
 148  *
 149  *    Example: DEBUGADD( 2, ("Some text and a value %d.\n", value) );
 150  *             DEBUGADDC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
 151  *
 152  * Note: If the debug class has not be redeined (see above) then the optimizer
 153  * will remove the extra conditional test.
 154  */
 155
 156 /*
 157  * From talloc.c:
 158  */
 159
 160 /* these macros gain us a few percent of speed on gcc */
 161 #if (__GNUC__ >= 3)
 162 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
 163    as its first argument */
 164 #ifndef likely
 165 #define likely(x)   __builtin_expect(!!(x), 1)
 166 #endif
 167 #ifndef unlikely
 168 #define unlikely(x) __builtin_expect(!!(x), 0)
 169 #endif
 170 #else
 171 #ifndef likely
 172 #define likely(x) (x)
 173 #endif
 174 #ifndef unlikely
 175 #define unlikely(x) (x)
 176 #endif
 177 #endif
 178
 179 #define CHECK_DEBUGLVL( level ) \
 180   ( ((level) <= MAX_DEBUG_LEVEL) && \
 181     unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level)))
 182
 183 #define CHECK_DEBUGLVLC( dbgc_class, level ) \
 184   ( ((level) <= MAX_DEBUG_LEVEL) && \
 185     unlikely(DEBUGLEVEL_CLASS[ dbgc_class ] >= (level)))
 186
 187 #define DEBUGLVL( level ) \
 188   ( CHECK_DEBUGLVL(level) \
 189    && dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ ) )
 190
 191 #define DEBUGLVLC( dbgc_class, level ) \
 192   ( CHECK_DEBUGLVLC( dbgc_class, level ) \
 193    && dbghdrclass( level, dbgc_class, __location__, __FUNCTION__ ) )
 194
 195 #define DEBUG( level, body ) \
 196   (void)( ((level) <= MAX_DEBUG_LEVEL) && \
 197           unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))           \
 198        && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
 199        && (dbgtext body) )
 200
 201 #define DEBUGC( dbgc_class, level, body ) \
 202   (void)( ((level) <= MAX_DEBUG_LEVEL) && \
 203           unlikely(DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))           \
 204        && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
 205        && (dbgtext body) )
 206
 207 #define DEBUGADD( level, body ) \
 208   (void)( ((level) <= MAX_DEBUG_LEVEL) && \
 209           unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))   \
 210        && (dbgtext body) )
 211
 212 #define DEBUGADDC( dbgc_class, level, body ) \
 213   (void)( ((level) <= MAX_DEBUG_LEVEL) && \
 214           unlikely((DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))) \
 215        && (dbgtext body) )
 216
 217 /* Print a separator to the debug log. */
 218 #define DEBUGSEP(level)\
 219         DEBUG((level),("===============================================================\n"))
 220
 221 /* Prefix messages with the function name */
 222 #define DBG_PREFIX(level, body ) \
 223         (void)( ((level) <= MAX_DEBUG_LEVEL) &&                 \
 224                 unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))     \
 225                 && (dbghdrclass(level, DBGC_CLASS, __location__, __func__ )) \
 226                 && (dbgtext("%s: ", __func__))                          \
 227                 && (dbgtext body) )
 228
 229 /* Prefix messages with the function name - class specific */
 230 #define DBGC_PREFIX(dbgc_class, level, body ) \
 231         (void)( ((level) <= MAX_DEBUG_LEVEL) &&                 \
 232                 unlikely(DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))     \
 233                 && (dbghdrclass(level, dbgc_class, __location__, __func__ )) \
 234                 && (dbgtext("%s: ", __func__))                          \
 235                 && (dbgtext body) )
 236
 237 /*
 238  * Debug levels matching RFC 3164
 239  */
 240 #define DBGLVL_ERR       0      /* error conditions */
 241 #define DBGLVL_WARNING   1      /* warning conditions */
 242 #define DBGLVL_NOTICE    3      /* normal, but significant, condition */
 243 #define DBGLVL_INFO      5      /* informational message */
 244 #define DBGLVL_DEBUG    10      /* debug-level message */
 245
 246 #define DBG_ERR(...)            DBG_PREFIX(DBGLVL_ERR,          (__VA_ARGS__))
 247 #define DBG_WARNING(...)        DBG_PREFIX(DBGLVL_WARNING,      (__VA_ARGS__))
 248 #define DBG_NOTICE(...)         DBG_PREFIX(DBGLVL_NOTICE,       (__VA_ARGS__))
 249 #define DBG_INFO(...)           DBG_PREFIX(DBGLVL_INFO,         (__VA_ARGS__))
 250 #define DBG_DEBUG(...)          DBG_PREFIX(DBGLVL_DEBUG,        (__VA_ARGS__))
 251
 252 #define DBGC_ERR(dbgc_class, ...)       DBGC_PREFIX(dbgc_class, \
 253                                                 DBGLVL_ERR, (__VA_ARGS__))
 254 #define DBGC_WARNING(dbgc_class, ...)   DBGC_PREFIX(dbgc_class, \
 255                                                 DBGLVL_WARNING, (__VA_ARGS__))
 256 #define DBGC_NOTICE(dbgc_class, ...)    DBGC_PREFIX(dbgc_class, \
 257                                                 DBGLVL_NOTICE,  (__VA_ARGS__))
 258 #define DBGC_INFO(dbgc_class, ...)      DBGC_PREFIX(dbgc_class, \
 259                                                 DBGLVL_INFO,    (__VA_ARGS__))
 260 #define DBGC_DEBUG(dbgc_class, ...)     DBGC_PREFIX(dbgc_class, \
 261                                                 DBGLVL_DEBUG,   (__VA_ARGS__))
 262
 263 #define D_ERR(...)              DEBUG(DBGLVL_ERR,       (__VA_ARGS__))
 264 #define D_WARNING(...)          DEBUG(DBGLVL_WARNING,   (__VA_ARGS__))
 265 #define D_NOTICE(...)           DEBUG(DBGLVL_NOTICE,    (__VA_ARGS__))
 266 #define D_INFO(...)             DEBUG(DBGLVL_INFO,      (__VA_ARGS__))
 267 #define D_DEBUG(...)            DEBUG(DBGLVL_DEBUG,     (__VA_ARGS__))
 268
 269 #define DC_ERR(...)             DEBUGC(dbgc_class, \
 270                                         DBGLVL_ERR,     (__VA_ARGS__))
 271 #define DC_WARNING(...)         DEBUGC(dbgc_class, \
 272                                         DBGLVL_WARNING, (__VA_ARGS__))
 273 #define DC_NOTICE(...)          DEBUGC(dbgc_class, \
 274                                         DBGLVL_NOTICE,  (__VA_ARGS__))
 275 #define DC_INFO(...)            DEBUGC(dbgc_class, \
 276                                         DBGLVL_INFO,    (__VA_ARGS__))
 277 #define DC_DEBUG(...)           DEBUGC(dbgc_class, \
 278                                         DBGLVL_DEBUG,   (__VA_ARGS__))
 279
 280 /* The following definitions come from lib/debug.c  */
 281
 282 /** Possible destinations for the debug log (in order of precedence -
 283  * once set to DEBUG_FILE, it is not possible to reset to DEBUG_STDOUT
 284  * for example.  This makes it easy to override for debug to stderr on
 285  * the command line, as the smb.conf cannot reset it back to
 286  * file-based logging */
 287 enum debug_logtype {
 288         DEBUG_DEFAULT_STDERR = 0,
 289         DEBUG_DEFAULT_STDOUT = 1,
 290         DEBUG_FILE = 2,
 291         DEBUG_STDOUT = 3,
 292         DEBUG_STDERR = 4,
 293         DEBUG_CALLBACK = 5
 294 };
 295
 296 struct debug_settings {
 297         size_t max_log_size;
 298         bool timestamp_logs;
 299         bool debug_prefix_timestamp;
 300         bool debug_hires_timestamp;
 301         bool debug_pid;
 302         bool debug_uid;
 303         bool debug_class;
 304 };
 305
 306 void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
 307
 308 void gfree_debugsyms(void);
 309 int debug_add_class(const char *classname);
 310 bool debug_parse_levels(const char *params_str);
 311 void debug_setup_talloc_log(void);
 312 void debug_set_logfile(const char *name);
 313 void debug_set_settings(struct debug_settings *settings,
 314                         const char *logging_param,
 315                         int syslog_level, bool syslog_only);
 316 bool reopen_logs_internal( void );
 317 void force_check_log_size( void );
 318 bool need_to_check_log_size( void );
 319 void check_log_size( void );
 320 void dbgflush( void );
 321 bool dbghdrclass(int level, int cls, const char *location, const char *func);
 322 bool debug_get_output_is_stderr(void);
 323 bool debug_get_output_is_stdout(void);
 324 void debug_schedule_reopen_logs(void);
 325 char *debug_list_class_names_and_levels(void);
 326
 327 typedef void (*debug_callback_fn)(void *private_ptr, int level, const char *msg);
 328
 329 /**
 330    Set a callback for all debug messages.  Use in dlz_bind9 to push output to the bind logs
 331  */
 332 void debug_set_callback(void *private_ptr, debug_callback_fn fn);
 333
 334 char *debug_get_ringbuf(void);
 335 size_t debug_get_ringbuf_size(void);
 336
 337 #endif /* _SAMBA_DEBUG_H */