debug: Add ability to dump_data per debug class
[sfrench/samba-autobuild/.git] / 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 _DEBUG_H
24 #define _DEBUG_H
25
26 /* -------------------------------------------------------------------------- **
27  * Debugging code.  See also debug.c
28  */
29
30 /* the maximum debug level to compile into the code. This assumes a good
31    optimising compiler that can remove unused code
32    for embedded or low-memory systems set this to a value like 2 to get
33    only important messages. This gives *much* smaller binaries
34 */
35 #ifndef MAX_DEBUG_LEVEL
36 #define MAX_DEBUG_LEVEL 1000
37 #endif
38
39 int  Debug1( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
40 bool dbgtext( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
41 bool dbghdrclass( int level, int cls, const char *location, const char *func);
42 bool dbghdr( int level, const char *location, const char *func);
43
44 /*
45  * Redefine DEBUGLEVEL because so we don't have to change every source file
46  * that *unnecessarily* references it.
47  */
48 #define DEBUGLEVEL DEBUGLEVEL_CLASS[DBGC_ALL]
49
50 /*
51  * Define all new debug classes here. A class is represented by an entry in
52  * the DEBUGLEVEL_CLASS array. Index zero of this arrray is equivalent to the
53  * old DEBUGLEVEL. Any source file that does NOT add the following lines:
54  *
55  *   #undef  DBGC_CLASS
56  *   #define DBGC_CLASS DBGC_<your class name here>
57  *
58  * at the start of the file (after #include "includes.h") will default to
59  * using index zero, so it will behaive just like it always has.
60  */
61 #define DBGC_ALL                0 /* index equivalent to DEBUGLEVEL */
62
63 #define DBGC_TDB                1
64 #define DBGC_PRINTDRIVERS       2
65 #define DBGC_LANMAN             3
66 #define DBGC_SMB                4
67 #define DBGC_RPC_PARSE          5
68 #define DBGC_RPC_SRV            6
69 #define DBGC_RPC_CLI            7
70 #define DBGC_PASSDB             8
71 #define DBGC_SAM                9
72 #define DBGC_AUTH               10
73 #define DBGC_WINBIND            11
74 #define DBGC_VFS                12
75 #define DBGC_IDMAP              13
76 #define DBGC_QUOTA              14
77 #define DBGC_ACLS               15
78 #define DBGC_LOCKING            16
79 #define DBGC_MSDFS              17
80 #define DBGC_DMAPI              18
81 #define DBGC_REGISTRY           19
82 #define DBGC_SCAVENGER          20
83 #define DBGC_DNS                21
84
85 /* Always ensure this is updated when new fixed classes area added, to ensure the array in debug.c is the right size */
86 #define DBGC_MAX_FIXED          21
87
88 /* So you can define DBGC_CLASS before including debug.h */
89 #ifndef DBGC_CLASS
90 #define DBGC_CLASS            0     /* override as shown above */
91 #endif
92
93 extern int  *DEBUGLEVEL_CLASS;
94
95 /* Debugging macros
96  *
97  * DEBUGLVL()
98  *   If the 'file specific' debug class level >= level OR the system-wide
99  *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
100  *   generate a header using the default macros for file, line, and
101  *   function name. Returns True if the debug level was <= DEBUGLEVEL.
102  *
103  *   Example: if( DEBUGLVL( 2 ) ) dbgtext( "Some text.\n" );
104  *
105  * DEBUG()
106  *   If the 'file specific' debug class level >= level OR the system-wide
107  *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
108  *   generate a header using the default macros for file, line, and
109  *   function name. Each call to DEBUG() generates a new header *unless* the
110  *   previous debug output was unterminated (i.e. no '\n').
111  *   See debug.c:dbghdr() for more info.
112  *
113  *   Example: DEBUG( 2, ("Some text and a value %d.\n", value) );
114  *
115  * DEBUGC()
116  *   If the 'macro specified' debug class level >= level OR the system-wide
117  *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
118  *   generate a header using the default macros for file, line, and
119  *   function name. Each call to DEBUG() generates a new header *unless* the
120  *   previous debug output was unterminated (i.e. no '\n').
121  *   See debug.c:dbghdr() for more info.
122  *
123  *   Example: DEBUGC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
124  *
125  *  DEBUGADD(), DEBUGADDC()
126  *    Same as DEBUG() and DEBUGC() except the text is appended to the previous
127  *    DEBUG(), DEBUGC(), DEBUGADD(), DEBUGADDC() with out another interviening
128  *    header.
129  *
130  *    Example: DEBUGADD( 2, ("Some text and a value %d.\n", value) );
131  *             DEBUGADDC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
132  *
133  * Note: If the debug class has not be redeined (see above) then the optimizer
134  * will remove the extra conditional test.
135  */
136
137 /*
138  * From talloc.c:
139  */
140
141 /* these macros gain us a few percent of speed on gcc */
142 #if (__GNUC__ >= 3)
143 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
144    as its first argument */
145 #ifndef likely
146 #define likely(x)   __builtin_expect(!!(x), 1)
147 #endif
148 #ifndef unlikely
149 #define unlikely(x) __builtin_expect(!!(x), 0)
150 #endif
151 #else
152 #ifndef likely
153 #define likely(x) (x)
154 #endif
155 #ifndef unlikely
156 #define unlikely(x) (x)
157 #endif
158 #endif
159
160 #define CHECK_DEBUGLVL( level ) \
161   ( ((level) <= MAX_DEBUG_LEVEL) && \
162     unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level)))
163
164 #define CHECK_DEBUGLVLC( dbgc_class, level ) \
165   ( ((level) <= MAX_DEBUG_LEVEL) && \
166     unlikely(DEBUGLEVEL_CLASS[ dbgc_class ] >= (level)))
167
168 #define DEBUGLVL( level ) \
169   ( CHECK_DEBUGLVL(level) \
170    && dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ ) )
171
172 #define DEBUGLVLC( dbgc_class, level ) \
173   ( CHECK_DEBUGLVLC( dbgc_class, level ) \
174    && dbghdrclass( level, dbgc_class, __location__, __FUNCTION__ ) )
175
176 #define DEBUG( level, body ) \
177   (void)( ((level) <= MAX_DEBUG_LEVEL) && \
178           unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))           \
179        && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
180        && (dbgtext body) )
181
182 #define DEBUGC( dbgc_class, level, body ) \
183   (void)( ((level) <= MAX_DEBUG_LEVEL) && \
184           unlikely(DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))           \
185        && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
186        && (dbgtext body) )
187
188 #define DEBUGADD( level, body ) \
189   (void)( ((level) <= MAX_DEBUG_LEVEL) && \
190           unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))   \
191        && (dbgtext body) )
192
193 #define DEBUGADDC( dbgc_class, level, body ) \
194   (void)( ((level) <= MAX_DEBUG_LEVEL) && \
195           unlikely((DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))) \
196        && (dbgtext body) )
197
198 /* Print a separator to the debug log. */
199 #define DEBUGSEP(level)\
200         DEBUG((level),("===============================================================\n"))
201
202 /* The following definitions come from lib/debug.c  */
203
204 /** Possible destinations for the debug log (in order of precedence -
205  * once set to DEBUG_FILE, it is not possible to reset to DEBUG_STDOUT
206  * for example.  This makes it easy to override for debug to stderr on
207  * the command line, as the smb.conf cannot reset it back to
208  * file-based logging */
209 enum debug_logtype {DEBUG_DEFAULT_STDERR = 0, DEBUG_DEFAULT_STDOUT = 1, DEBUG_FILE = 2, DEBUG_STDOUT = 3, DEBUG_STDERR = 4, DEBUG_CALLBACK = 5};
210
211 struct debug_settings {
212         size_t max_log_size;
213         int syslog;
214         bool syslog_only;
215         bool timestamp_logs;
216         bool debug_prefix_timestamp;
217         bool debug_hires_timestamp;
218         bool debug_pid;
219         bool debug_uid;
220         bool debug_class;
221 };
222
223 void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
224
225 void debug_close_dbf(void);
226 void gfree_debugsyms(void);
227 int debug_add_class(const char *classname);
228 int debug_lookup_classname(const char *classname);
229 bool debug_parse_levels(const char *params_str);
230 void debug_setup_talloc_log(void);
231 void debug_set_logfile(const char *name);
232 void debug_set_settings(struct debug_settings *settings);
233 bool reopen_logs_internal( void );
234 void force_check_log_size( void );
235 bool need_to_check_log_size( void );
236 void check_log_size( void );
237 void dbgflush( void );
238 bool dbghdrclass(int level, int cls, const char *location, const char *func);
239 bool dbghdr(int level, const char *location, const char *func);
240 bool debug_get_output_is_stderr(void);
241 bool debug_get_output_is_stdout(void);
242 void debug_schedule_reopen_logs(void);
243 char *debug_list_class_names_and_levels(void);
244
245 typedef void (*debug_callback_fn)(void *private_ptr, int level, const char *msg);
246
247 /**
248    Set a callback for all debug messages.  Use in dlz_bind9 to push output to the bind logs
249  */
250 void debug_set_callback(void *private_ptr, debug_callback_fn fn);
251
252 /**
253   log suspicious usage - print comments and backtrace
254 */      
255 _PUBLIC_ void log_suspicious_usage(const char *from, const char *info);
256
257 /**
258   print suspicious usage - print comments and backtrace
259 */      
260 _PUBLIC_ void print_suspicious_usage(const char* from, const char* info);
261 _PUBLIC_ uint32_t get_task_id(void);
262 _PUBLIC_ void log_task_id(void);
263
264 /* the debug operations structure - contains function pointers to
265    various debug implementations of each operation */
266 struct debug_ops {
267         /* function to log (using DEBUG) suspicious usage of data structure */
268         void (*log_suspicious_usage)(const char* from, const char* info);
269
270         /* function to log (using printf) suspicious usage of data structure.
271          * To be used in circumstances when using DEBUG would cause loop. */
272         void (*print_suspicious_usage)(const char* from, const char* info);
273
274         /* function to return process/thread id */
275         uint32_t (*get_task_id)(void);
276
277         /* function to log process/thread id */
278         void (*log_task_id)(int fd);
279 };
280
281 /**
282   register a set of debug handlers. 
283 */
284 _PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops);
285
286 #endif