?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Enable resource logging in BETA builds
[nobug.git] / src / nobug.h
blob3deeae4174e6677e80056df5729241b2bcd1f280
1 /*
2 This file is part of the NoBug debugging library.
3
4 Copyright (C)
5 2006, 2007, 2008, 2009,
6 2010, Christian Thaeter <ct@pipapo.org>
7 2009, Francois Kubler <ih8tehuman@free.fr>
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 2 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, contact Christian Thaeter <ct@pipapo.org>.
21 */
22 #ifndef NOBUG_H
23 #define NOBUG_H
24
25 #ifndef NOBUG_LIBNOBUG_C /* not when building libnobug */
26 #ifdef NDEBUG
27 #ifdef EBUG_ALPHA
28 #error NDEBUG incompatible with -DEBUG_ALPHA
29 #endif
30 #ifdef EBUG_BETA
31 #error NDEBUG incompatible with -DEBUG_BETA
32 #endif
33 #endif
34
35 #if defined(EBUG_ALPHA)
36 # define NOBUG_MODE_ALPHA 1
37 # define NOBUG_MODE_BETA 0
38 # define NOBUG_MODE_RELEASE 0
39 #elif defined(EBUG_BETA)
40 # define NOBUG_MODE_ALPHA 0
41 # define NOBUG_MODE_BETA 1
42 # define NOBUG_MODE_RELEASE 0
43 #elif defined(NDEBUG)
44 # define NOBUG_MODE_ALPHA 0
45 # define NOBUG_MODE_BETA 0
46 # define NOBUG_MODE_RELEASE 1
47 #else
48 #error no debug level and no NDEBUG defined
49 #endif
50 #endif /* NOBUG_LIBNOBUG_C */
51
52 /*
53 HEADERS
54 */
55
56 #include <syslog.h>
57 #include <stdlib.h>
58 #include <string.h>
59 #include <stdio.h>
60 #include <stdarg.h>
61
62 #ifdef HAVE_EXECINFO_H
63 # ifndef NOBUG_USE_EXECINFO
64 # define NOBUG_USE_EXECINFO 1
65 # endif
66 #else
67 # undef NOBUG_USE_EXECINFO
68 # define NOBUG_USE_EXECINFO 0
69 #endif
70
71 #if NOBUG_USE_EXECINFO
72 #include <execinfo.h>
73 #endif
74
75 #if defined(HAVE_VALGRIND) && !defined(NVALGRIND)
76 # ifndef NOBUG_USE_VALGRIND
77 # define NOBUG_USE_VALGRIND 1
78 # endif
79 #else
80 # undef NOBUG_USE_VALGRIND
81 # define NOBUG_USE_VALGRIND 0
82 #endif
83
84 #if NOBUG_USE_VALGRIND
85 #include <valgrind.h>
86 #endif
87
88 #ifdef HAVE_PTHREAD
89 # ifndef NOBUG_USE_PTHREAD
90 # define NOBUG_USE_PTHREAD 1
91 # endif
92 #else
93 # ifdef NOBUG_USE_PTHREAD
94 # undef NOBUG_USE_PTHREAD
95 # endif
96 # define NOBUG_USE_PTHREAD 0
97 #endif
98
99 #if NOBUG_USE_PTHREAD
100 #include <pthread.h>
101 #endif
102
103 /*
104 //assertions HEAD- Assertions;;
105 //assertions
106 //assertions PARA CHECK; CHECK; unnconditional assertion for testsuites
107 //assertions CHECK(expr, ...)
108 //assertions CHECK_IF(when, expr, ...)
109 //assertions
110 //assertions This assertion is never optimized out. Its main purpose is for implementing
111 //assertions testsuites where one want to assert tests independent of the build level
112 //assertions
113 */
114 #define NOBUG_CHECK(expr, ...) \
115 NOBUG_ASSERT_(expr, "CHECK", NOBUG_CONTEXT, ""__VA_ARGS__)
116
117 #define NOBUG_CHECK_IF(when, expr, ...) \
118 NOBUG_WHEN(when, NOBUG_CHECK(expr, ""__VA_ARGS__))
119
120
121 /*
122 //assertions PARA REQUIRE; REQUIRE; preconditions (input parameters)
123 //assertions REQUIRE(expr, ...)
124 //assertions REQUIRE_IF(when, expr, ...)
125 //assertions NOBUG_REQUIRE_CTX(expr, context,...)
126 //assertions NOBUG_REQUIRE_IF_CTX(when, expr, context, ...)
127 //assertions
128 //assertions Precondition (input) check. Use these macros to validate input a
129 //assertions function receives. The checks are enabled in *ALPHA* and *BETA* builds and
130 //assertions optimized out in *RELEASE* builds.
131 //assertions
132 */
133 #define NOBUG_REQUIRE(expr, ...) \
134 NOBUG_REQUIRE_CTX(expr, NOBUG_CONTEXT, ""__VA_ARGS__)
135
136 #define NOBUG_REQUIRE_CTX(expr, context, ...) \
137 NOBUG_IF_NOT_RELEASE(NOBUG_ASSERT_(expr, "PRECONDITION", context, ""__VA_ARGS__))
138
139
140 #define NOBUG_REQUIRE_IF(when, expr, context,...) \
141 NOBUG_REQUIRE_IF_CTX(when, expr, NOBUG_CONTEXT, ""__VA_ARGS__)
142
143 #define NOBUG_REQUIRE_IF_CTX(when, expr, context,...) \
144 NOBUG_IF_NOT_RELEASE ( \
145 NOBUG_WHEN(when, NOBUG_REQUIRE_CTX(expr, context, ""__VA_ARGS__)) \
146 )
147
148
149 /*
150 //assertions PARA ENSURE; ENSURE; postconditions (computation outcomes)
151 //assertions ENSURE(expr, ...)
152 //assertions ENSURE_IF(when, expr, ...)
153 //assertions NOBUG_ENSURE_CTX(expr, context, ...)
154 //assertions NOBUG_ENSURE_IF_CTX(when, expr, context, ...)
155 //assertions
156 //assertions Postcondition (progress/output) check. Use these macros to validate the
157 //assertions data a function produces (example: return value). `ENSURE` is enabled
158 //assertions unconditionally in *ALPHA* builds and optimized out in *BETA* builds for
159 //assertions scopes which are tagged as `CHECKED`.
160 //assertions
161 //assertions The `ENSURE_IF` variants are enabled in *ALPHA* and *BETA* builds.
162 //assertions
163 //assertions In *RELEASE* builds this checks are
164 //assertions always optimized out, scopes tagged as `UNCHECKED` are not permitted.
165 //assertions
166 */
167 #define NOBUG_ENSURE(expr, ...) \
168 NOBUG_ENSURE_CTX(expr, NOBUG_CONTEXT, ""__VA_ARGS__)
169
170 #define NOBUG_ENSURE_CTX(expr, context, ...) \
171 NOBUG_IF_ALPHA (NOBUG_ASSERT_(expr, "POSTCONDITION", \
172 context, ""__VA_ARGS__)) \
173 NOBUG_IF_BETA ( \
174 NOBUG_WHEN (NOBUG_SCOPE_UNCHECKED, \
175 NOBUG_ASSERT_(expr, "POSTCONDITION", \
176 context, ""__VA_ARGS__) \
177 ) \
178 )
179
180
181 #define NOBUG_ENSURE_IF(when, expr, ...) \
182 NOBUG_ENSURE_IF_CTX(when, expr, NOBUG_CONTEXT, ""__VA_ARGS__)
183
184 #define NOBUG_ENSURE_IF_CTX(when, expr, context, ...) \
185 NOBUG_IF_NOT_RELEASE (NOBUG_WHEN(when, NOBUG_ENSURE(expr, context, ""__VA_ARGS__)))
186
187
188 /*
189 //assertions PARA ASSERT; ASSERT; generic assertion
190 //assertions ASSERT(expr, ...)
191 //assertions ASSERT_IF(when, expr, ...)
192 //assertions NOBUG_ASSERT_CTX(expr, context, ...)
193 //assertions NOBUG_ASSERT_IF_CTX(when, expr, context, ...)
194 //assertions
195 //assertions Generic check. Use these macros when you want to validate something
196 //assertions which doesn't fall into one of the above categories. A example is when
197 //assertions a library function can return a unexpected result (scanf with syntax
198 //assertions error in the formatstring, when a constant/literal formatstring is
199 //assertions expected). The checks are enabled in *ALPHA* and *BETA* builds and
200 //assertions optimized out in *RELEASE* builds.
201 //assertions
202 */
203 #define NOBUG_ASSERT(expr, ...) \
204 NOBUG_ASSERT_CTX(expr, NOBUG_CONTEXT, ""__VA_ARGS__)
205
206 #define NOBUG_ASSERT_CTX(expr, context, ...) \
207 NOBUG_IF_NOT_RELEASE( \
208 NOBUG_ASSERT_(expr, "ASSERTION", \
209 context, ""__VA_ARGS__) \
210 )
211
212
213 #define NOBUG_ASSERT_IF(when, expr, ...) \
214 NOBUG_ASSERT_IF_CTX(when, expr, NOBUG_CONTEXT, ""__VA_ARGS__)
215
216 #define NOBUG_ASSERT_IF_CTX(when, expr, context, ...) \
217 NOBUG_IF_NOT_RELEASE (NOBUG_WHEN(when, NOBUG_ASSERT_CTX(expr, context, ""__VA_ARGS__)))
218
219
220 /*
221 //assertions PARA assert; assert; C standard assertion
222 //assertions assert(expr)
223 //assertions
224 //assertions NoBug overrides the standard `assert` macro, using `NOBUG_ASSERT`.
225 //assertions This is just a compatibility feature, its use is not suggested.
226 //assertions
227 */
228 #undef assert
229 #define assert(expr) NOBUG_ASSERT(expr)
230
231
232 /*
233 low level assert
234 */
235 #ifdef __GNUC__
236 #define NOBUG_ASSERT_(expr, what, context, fmt, ...) \
237 NOBUG_WHEN (!(expr), \
238 NOBUG_LOG_( &nobug_flag_NOBUG_ON, LOG_EMERG, \
239 what, context, "(%s) " fmt, \
240 #expr, ## __VA_ARGS__); \
241 NOBUG_BACKTRACE_CTX(context); \
242 NOBUG_ABORT \
243 )
244 #else /* , ## __VA_ARGS__ eating the comma when the arglist is empty is a gcc extension, fallback for other compilers */
245 #define NOBUG_ASSERT_(expr, what, context, ...) \
246 NOBUG_WHEN (!(expr), \
247 NOBUG_LOG_( &nobug_flag_NOBUG_ON, LOG_EMERG, \
248 what, context, \
249 , ""__VA_ARGS__); \
250 NOBUG_BACKTRACE_CTX(context); \
251 NOBUG_ABORT \
252 )
253 #endif
254
255 /*
256 //assertions PARA INVARIANT; INVARIANT; validate invariant state
257 //assertions INVARIANT(type, pointer, depth)
258 //assertions INVARIANT_IF(when,type, pointer, depth)
259 //assertions INVARIANT_ASSERT(expr, ...)
260 //assertions
261 //assertions Checking invariants. You can provide more complex checking functions
262 //assertions which test the validity of datastructures. Invariants are only enabled
263 //assertions in *ALPHA* builds for scopes which are not tagged as `CHECKED` and
264 //assertions otherwise optimized out.
265 //assertions
266 //assertions TODO: describe how to create invariant checks
267 //assertions
268 // 'invariant_context' must be passed in
269 */
270 #define NOBUG_INVARIANT(type, pointer, depth) \
271 NOBUG_IF_ALPHA( \
272 NOBUG_WHEN (NOBUG_SCOPE_UNCHECKED, \
273 NOBUG_CAT(type,_invariant)(pointer, depth, \
274 NOBUG_CONTEXT) \
275 ) \
276 )
277
278
279 #define NOBUG_INVARIANT_IF(when, type, pointer, depth) \
280 NOBUG_IF_ALPHA( \
281 NOBUG_WHEN (NOBUG_SCOPE_UNCHECKED, \
282 NOBUG_WHEN (when, \
283 NOBUG_CAT(type,_invariant)(pointer, depth, \
284 NOBUG_CONTEXT) \
285 ) \
286 ))
287
288 #define NOBUG_INVARIANT_ASSERT(expr, ...) \
289 NOBUG_ASSERT_(expr, "INVARIANT", invariant_context, ""__VA_ARGS__)
290
291
292 /*
293 checked/unchecked tagged scopes
294 */
295 #define NOBUG_SCOPE_UNCHECKED NOBUG_CHECKED_VALUE == 0
296
297 #define NOBUG_CHECKED NOBUG_IF_NOT_RELEASE(enum {NOBUG_CHECKED_VALUE=1})
298
299 #define NOBUG_UNCHECKED \
300 NOBUG_IF_NOT_RELEASE(enum {NOBUG_CHECKED_VALUE=0}) \
301 NOBUG_IF_RELEASE(NOBUG_UNCHECKED_NOT_ALLOWED_IN_RELEASE_BUILD)
302
303
304
305 /*TODO dump-level for flags instead limits[0]*/
306 /*
307 //dumpmacros PARA DUMP; DUMP; dumping datastructures
308 //dumpmacros DUMP(flag, type, pointer, depth)
309 //dumpmacros DUMP_IF(when, flag, type, pointer, depth)
310 //dumpmacros
311 //dumpmacros This macros call a datastructure dump of the object (`pointer`) in question.
312 //dumpmacros `DUMP` is only available in *ALPHA* and *BETA* builds, `DUMP_IF` is also
313 //dumpmacros enabled for the RELEASE builds.
314 //dumpmacros
315 */
316 #define NOBUG_DUMP(flag, type, pointer, depth) \
317 NOBUG_IF_NOT_RELEASE( \
318 NOBUG_WHEN (NOBUG_DUMP_LEVEL >= NOBUG_FLAG(flag).limits[NOBUG_LOG_TARGET], \
319 NOBUG_CAT3 (nobug_, type, _dump)(pointer, depth, NOBUG_CONTEXT) \
320 ) \
321 )
322
323 #define NOBUG_DUMP_IF(when, flag, type, pointer, depth) \
324 NOBUG_WHEN (NOBUG_DUMP_LEVEL >= NOBUG_FLAG(flag).limits[NOBUG_LOG_TARGET] && when, \
325 NOBUG_CAT3 (nobug_, type, _dump)(pointer, depth, NOBUG_CONTEXT) \
326 )
327
328
329 /*
330 //dumpmacros PARA DUMP_LOG; DUMP_LOG; logging helper for dumping
331 //dumpmacros DUMP_LOG(...)
332 //dumpmacros DUMP_LOG_IF(when, ...)
333 //dumpmacros
334 //dumpmacros Any output from `DUMP` handlers should be done by these macros.
335 //dumpmacros
336 //dumpmacros Dumping is by default done on level `LOG_DEBUG`, this can be overridden by
337 //dumpmacros defining `NOBUG_DUMP_LEVEL` to some other level.
338 //dumpmacros
339 // TODO document: 'dump_context' must be passed in
340 */
341
342 #define NOBUG_DUMP_LOG(...) \
343 NOBUG_LOG_( &nobug_flag_NOBUG_ON, NOBUG_DUMP_LEVEL, \
344 "DUMP", dump_context, \
345 ""__VA_ARGS__)
346
347 #define NOBUG_DUMP_LOG_IF(expr, ...) \
348 NOBUG_WHEN (expr, \
349 NOBUG_LOG_( &nobug_flag_NOBUG_ON, NOBUG_DUMP_LEVEL, \
350 "DUMP", dump_context, \
351 ""__VA_ARGS__) \
352 )
353
354
355
356 #ifndef NOBUG_DUMP_LEVEL
357 #define NOBUG_DUMP_LEVEL LOG_DEBUG
358 #endif
359
360 /*
361 //logmacros HEAD- Logging Macros;;
362 //logmacros
363 //logmacros Logging targets a flag (except for `ECHO`) and is done at a log-level relating to syslog levels.
364 //logmacros
365 //logmacros NOTE: there is no logging macro for `LOG_EMERG`, this is only used by the assertions as fatal message
366 //logmacros
367 //logmacros PARA ECHO; ECHO; unconditional logging for tests
368 //logmacros ECHO(...)
369 //logmacros
370 //logmacros Never optimized out, logs at LOG_NOTICE level. Its main purpose is for implementing
371 //logmacros testsuites where one want to print and log messages independent of the build level
372 //logmacros
373 */
374 #define NOBUG_ECHO(...) \
375 NOBUG_LOG_(&nobug_flag_NOBUG_ANN, LOG_NOTICE, "ECHO", NOBUG_CONTEXT, ""__VA_ARGS__)
376
377 /*
378 //logmacros PARA ALERT; ALERT; about to die
379 //logmacros ALERT(flag, ...)
380 //logmacros ALERT_IF(when, flag, ...)
381 //logmacros NOBUG_ALERT_CTX(flag, context, ...)
382 //logmacros NOBUG_ALERT_IF_CTX(when, flag, context, ...)
383 //logmacros
384 //logmacros This is the most critical condition an application might log. This might be used
385 //logmacros if an error occurs which can not be handled except a safe shutdown for example.
386 //logmacros
387 */
388 #define NOBUG_ALERT(flag, ...) \
389 NOBUG_ALERT_CTX(flag, NOBUG_CONTEXT, ""__VA_ARGS__)
390
391 #define NOBUG_ALERT_IF(expr, flag, ...) \
392 NOBUG_ALERT_IF_CTX(expr, flag, NOBUG_CONTEXT, ""__VA_ARGS__)
393
394
395 #define NOBUG_ALERT_CTX(flag, context, ...) \
396 NOBUG_LOG_CTX(flag, LOG_ALERT, context, ""__VA_ARGS__)
397
398 #define NOBUG_ALERT_IF_CTX(expr, flag, context, ...) \
399 NOBUG_LOG_IF(expr, flag, LOG_ALERT, context, ""__VA_ARGS__)
400
401
402
403 /*
404 //logmacros PARA CRITICAL; CRITICAL; can not continue
405 //logmacros CRITICAL(flag, ...)
406 //logmacros CRITICAL_IF(when, flag, ...)
407 //logmacros NOBUG_CRITICAL_CTX(flag, context, ...)
408 //logmacros NOBUG_CRITICAL_IF_CTX(when, flag, context, ...)
409 //logmacros
410 //logmacros An error which can not be handled occured but the application does not need to be
411 //logmacros shutdowen, perhaps waiting for an operator to fix the cause.
412 //logmacros
413 */
414 #define NOBUG_CRITICAL(flag, ...) \
415 NOBUG_CRITICAL_CTX(flag, NOBUG_CONTEXT, ""__VA_ARGS__)
416
417 #define NOBUG_CRITICAL_CTX(flag, context, ...) \
418 NOBUG_LOG_CTX(flag, LOG_CRIT, context, ""__VA_ARGS__)
419
420
421 #define NOBUG_CRITICAL_IF(expr, flag, ...) \
422 NOBUG_CRITICAL_IF_CTX(expr, flag, NOBUG_CONTEXT, ""__VA_ARGS__)
423
424 #define NOBUG_CRITICAL_IF_CTX(expr, flag, context, ...) \
425 NOBUG_LOG_IF_CTX(expr, flag, LOG_CRIT, context, ""__VA_ARGS__)
426
427
428 /*
429 //logmacros PARA ERROR; ERROR; something gone wrong
430 //logmacros ERROR(flag, ...)
431 //logmacros ERROR_IF(when, flag, ...)
432 //logmacros NOBUG_ERROR_CTX(flag, context, ...)
433 //logmacros NOBUG_ERROR_IF_CTX(when, flag, context, ...)
434 //logmacros
435 //logmacros Application takes a error handling brach
436 //logmacros
437 */
438 #define NOBUG_ERROR(flag, ...) \
439 NOBUG_ERROR_CTX(flag, NOBUG_CONTEXT, ""__VA_ARGS__)
440
441 #define NOBUG_ERROR_CTX(flag, context, ...) \
442 NOBUG_LOG_CTX(flag, LOG_ERR, context, ""__VA_ARGS__)
443
444
445 #define NOBUG_ERROR_IF(expr, flag, ...) \
446 NOBUG_ERROR_IF_CTX(expr, flag, NOBUG_CONTEXT, ""__VA_ARGS__)
447
448 #define NOBUG_ERROR_IF_CTX(expr, flag, context, ...) \
449 NOBUG_LOG_IF_CTX(expr, flag, LOG_ERR, context, ""__VA_ARGS__)
450
451
452 /*
453 //logmacros PARA WARN; WARN; unexpected fixable error
454 //logmacros WARN(flag, ...)
455 //logmacros WARN_IF(when, flag, ...)
456 //logmacros NOBUG_WARN_CTX(flag, context, ...)
457 //logmacros NOBUG_WARN_IF_CTX(when, flag, context, ...)
458 //logmacros
459 //logmacros Rare, handled but unexpected branch
460 //logmacros
461 */
462 #define NOBUG_WARN(flag, ...) \
463 NOBUG_WARN_CTX(flag, NOBUG_CONTEXT, ""__VA_ARGS__)
464
465 #define NOBUG_WARN_CTX(flag, context, ...) \
466 NOBUG_LOG_CTX(flag, LOG_WARNING, context, ""__VA_ARGS__)
467
468
469 #define NOBUG_WARN_IF(expr, flag, ...) \
470 NOBUG_WARN_IF_CTX(expr, flag, NOBUG_CONTEXT, ""__VA_ARGS__)
471
472 #define NOBUG_WARN_IF_CTX(expr, flag, context, ...) \
473 NOBUG_LOG_IF_CTX(expr, flag, LOG_WARNING, context, ""__VA_ARGS__)
474
475
476 /*
477 //logmacros PARA INFO; INFO; progress message
478 //logmacros INFO(flag, ...)
479 //logmacros INFO_IF(when, flag, ...)
480 //logmacros NOBUG_INFO_CTX(flag, context, ...)
481 //logmacros NOBUG_INFO_IF_CTX(when, flag, context, ...)
482 //logmacros
483 //logmacros Message about program progress
484 //logmacros
485 */
486 #define NOBUG_INFO(flag, ...) \
487 NOBUG_INFO_CTX(flag, NOBUG_CONTEXT, ""__VA_ARGS__)
488
489 #define NOBUG_INFO_CTX(flag, context, ...) \
490 NOBUG_LOG_CTX(flag, LOG_INFO, context, ""__VA_ARGS__)
491
492
493 #define NOBUG_INFO_IF(expr, flag, ...) \
494 NOBUG_INFO_IF_CTX(expr, flag, NOBUG_CONTEXT, ""__VA_ARGS__)
495
496 #define NOBUG_INFO_IF_CTX(expr, flag, context, ...) \
497 NOBUG_LOG_IF_CTX(expr, flag, LOG_INFO, context, ""__VA_ARGS__)
498
499
500 /*
501 //logmacros PARA NOTICE; NOTICE; detailed progress message
502 //logmacros NOTICE(flag, ...)
503 //logmacros NOTICE_IF(when, flag, ...)
504 //logmacros NOBUG_NOTICE_CTX(flag, context, ...)
505 //logmacros NOBUG_NOTICE_IF_CTX(when, flag, context, ...)
506 //logmacros
507 //logmacros More detailed progress message
508 //logmacros
509 */
510 #define NOBUG_NOTICE(flag, ...) \
511 NOBUG_NOTICE_CTX(flag, NOBUG_CONTEXT, ""__VA_ARGS__)
512
513 #define NOBUG_NOTICE_CTX(flag, context, ...) \
514 NOBUG_LOG_CTX(flag, LOG_NOTICE, context, ""__VA_ARGS__)
515
516
517 #define NOBUG_NOTICE_IF(expr, flag, ...) \
518 NOBUG_NOTICE_IF_CTX(expr, flag, NOBUG_CONTEXT, ""__VA_ARGS__)
519
520 #define NOBUG_NOTICE_IF_CTX(expr, flag, context, ...) \
521 NOBUG_LOG_IF_CTX(expr, flag, LOG_NOTICE, context, ""__VA_ARGS__)
522
523 /*
524 //logmacros PARA TRACE; TRACE; debugging level message
525 //logmacros TRACE(flag, ...)
526 //logmacros TRACE_IF(when, flag, ...)
527 //logmacros NOBUG_TRACE_CTX(flag, context, ...)
528 //logmacros NOBUG_TRACE_IF_CTX(when, flag, context, ...)
529 //logmacros
530 //logmacros Very fine grained messages
531 //logmacros
532 //logmacros NOTE: that `TRACE` corresponds to `LOG_DEBUG`, because using `DEBUG` could be ambiguous.
533 //logmacros
534 */
535 #define NOBUG_TRACE(flag, ...) \
536 NOBUG_TRACE_CTX(flag, NOBUG_CONTEXT, ""__VA_ARGS__)
537
538 #define NOBUG_TRACE_CTX(flag, context, ...) \
539 NOBUG_LOG_CTX(flag, LOG_DEBUG, context, ""__VA_ARGS__)
540
541
542 #define NOBUG_TRACE_IF(expr, flag, ...) \
543 NOBUG_TRACE_IF_CTX(expr, flag, NOBUG_CONTEXT, ""__VA_ARGS__)
544
545 #define NOBUG_TRACE_IF_CTX(expr, flag, context, ...) \
546 NOBUG_LOG_IF_CTX(expr, flag, LOG_DEBUG, context, ""__VA_ARGS__)
547
548
549 /*
550 //logmacros PARA LOG; LOG; generic logging
551 //logmacros NOBUG_LOG_CTX(flag, lvl, context, ...)
552 //logmacros NOBUG_LOG_IF_CTX(when, flag, lvl, context, ...)
553 //logmacros
554 //logmacros Generic logging macro which takes the level explicitly,
555 //logmacros avoid this, unless you implement your own logging facilities.
556 //logmacros
557 */
558 #define NOBUG_LOG_CTX(flag, lvl, context, ...) \
559 NOBUG_LOG_(&NOBUG_FLAG(flag), lvl, NOBUG_LVL(lvl), context, ""__VA_ARGS__)
560
561
562 #define NOBUG_LOG_IF_CTX(expr, flag, lvl, context, ...) \
563 NOBUG_WHEN (expr, \
564 NOBUG_LOG_CTX(flag, lvl, context, ""__VA_ARGS__) \
565 )
566
567
568 /*
569 low level logging handler
570
571 Note: all fmt concatenations use an empty string ""__VA_ARG__
572 except this one which must use a single space " " before __VA_ARGS__ for formatting the log message correctly (and silence a gcc warning)
573 */
574 #define NOBUG_LOG_(flag, lvl, what, context, ...) \
575 NOBUG_WHEN (lvl <= NOBUG_LOG_BASELIMIT && lvl <= (flag)->limits[NOBUG_TARGET_RINGBUFFER], \
576 nobug_log (flag, lvl, what, context, " "__VA_ARGS__) \
577 )
578
579
580 #define NOBUG_LVL(lvl) NOBUG_LVL_##lvl
581 #define NOBUG_LVL_0 "EMERG"
582 #define NOBUG_LVL_1 "ALERT"
583 #define NOBUG_LVL_2 "CRIT"
584 #define NOBUG_LVL_3 "ERR"
585 #define NOBUG_LVL_4 "WARNING"
586 #define NOBUG_LVL_5 "NOTICE"
587 #define NOBUG_LVL_6 "INFO"
588 #define NOBUG_LVL_7 "TRACE"
589
590 /*
591 //logmacros PARA LOG_BASELIMIT; LOG_BASELIMIT; minimum compliled-in logging limit
592 //logmacros NOBUG_LOG_BASELIMIT_ALPHA
593 //logmacros NOBUG_LOG_BASELIMIT_BETA
594 //logmacros NOBUG_LOG_BASELIMIT_RELEASE
595 //logmacros NOBUG_LOG_BASELIMIT
596 //logmacros
597 //logmacros anything more detailed than this base limits will be optimized out.
598 //logmacros This is used to reduce the logging overhead for *RELEASE* builds.
599 //logmacros By default the limit is set to `LOG_DEBUG` for *ALPHA* and *BETA*
600 //logmacros builds, so all logging is retained and `LOG_NOTICE` in *RELEASE*
601 //logmacros builds to log the application progress only coarsely then.
602 //logmacros
603 //logmacros This macros can be defined before including 'nobug.h' to some other
604 //logmacros log level (as defined in 'syslog.h').
605 //logmacros
606 */
607 #ifndef NOBUG_LOG_BASELIMIT_ALPHA
608 #define NOBUG_LOG_BASELIMIT_ALPHA LOG_DEBUG
609 #endif
610
611 #ifndef NOBUG_LOG_BASELIMIT_BETA
612 #define NOBUG_LOG_BASELIMIT_BETA LOG_DEBUG
613 #endif
614
615 #ifndef NOBUG_LOG_BASELIMIT_RELEASE
616 #define NOBUG_LOG_BASELIMIT_RELEASE LOG_NOTICE
617 #endif
618
619 #ifndef NOBUG_LOG_BASELIMIT
620 #define NOBUG_LOG_BASELIMIT \
621 NOBUG_IF_ALPHA(NOBUG_LOG_BASELIMIT_ALPHA) \
622 NOBUG_IF_BETA(NOBUG_LOG_BASELIMIT_BETA) \
623 NOBUG_IF_RELEASE(NOBUG_LOG_BASELIMIT_RELEASE)
624 #endif
625
626 /*
627 //srccontext HEAD~ Source Contexts; NOBUG_CONTEXT; pass information about the source location
628 //srccontext NOBUG_CONTEXT
629 //srccontext NOBUG_CONTEXT_NOFUNC
630 //srccontext
631 //srccontext NoBug passes information about the source location of a given statement in
632 //srccontext `const struct nobug_context` structures. These can be generated with
633 //srccontext `NOBUG_CONTEXT` or `NOBUG_CONTEXT_NOFUNC`. The later one doesn't define a
634 //srccontext function name and must be used when the function context is not available
635 //srccontext like in static initialization etc..
636 //srccontext
637 */
638
639 #define NOBUG_CONTEXT ((const struct nobug_context){__FILE__, __LINE__, __func__})
640
641 #define NOBUG_CONTEXT_NOFUNC ((const struct nobug_context){__FILE__, __LINE__, "NOFUNC"})
642
643 #define NOBUG_CONTEXT_NIL ((const struct nobug_context){"NIL", 0, "NIL"})
644
645
646 /*
647 //annotations HEAD- Source Annotations;;
648 //annotations
649 //annotations One can tag features as:
650 //annotations
651 */
652
653 /*
654 alpha beta release
655 DEPRECATED log nothing wont compile
656
657 //annotations PARA DEPRECATED; DEPRECATED; to be discarded in future
658 //annotations DEPRECATED(...)
659 //annotations
660 //annotations Something which shouldn't be used in future
661 //annotations
662 */
663 #define NOBUG_DEPRECATED(...) \
664 NOBUG_IF_ALPHA(NOBUG_LOG_(&nobug_flag_NOBUG_ANN, LOG_WARN, \
665 "DEPRECATED", NOBUG_CONTEXT, ""__VA_ARGS__) \
666 ) \
667 NOBUG_IF_RELEASE(NOBUG_DEPRECATED_NOT_ALLOWED_IN_RELEASE_BUILD(__VA_ARGS__))
668
669
670 /*
671 alpha beta release
672 UNIMPLEMENTED abort abort wont compile
673
674 //annotations PARA UNIMPLEMENTED; UNIMPLEMENTED; not yet implemented
675 //annotations UNIMPLEMENTED(...)
676 //annotations
677 //annotations not yet finished feature
678 //annotations
679 */
680 #define NOBUG_UNIMPLEMENTED(...) \
681 NOBUG_IF_NOT_RELEASE ( do { \
682 NOBUG_LOG_ (&nobug_flag_NOBUG_ANN, LOG_EMERG, \
683 "UNIMPLEMENTED", NOBUG_CONTEXT, ""__VA_ARGS__); \
684 NOBUG_ABORT; \
685 } while (0)) \
686 NOBUG_IF_RELEASE( NOBUG_UNIMPLEMENTED_NOT_ALLOWED_IN_RELEASE_BUILD(__VA_ARGS__))
687
688
689 /*
690 alpha beta release
691 FIXME log wont compile wont compile
692
693 //annotations PARA FIXME; FIXME; known bug
694 //annotations FIXME(...)
695 //annotations
696 //annotations known bug to be fixed later
697 //annotations
698 */
699 #define NOBUG_FIXME(...) \
700 NOBUG_IF_ALPHA( NOBUG_ONCE( NOBUG_LOG_(&nobug_flag_NOBUG_ANN, LOG_ALERT, \
701 "FIXME", NOBUG_CONTEXT, ""__VA_ARGS__))) \
702 NOBUG_IF_BETA( NOBUG_FIXME_NOT_ALLOWED_IN_BETA_BUILD(__VA_ARGS__)) \
703 NOBUG_IF_RELEASE( NOBUG_FIXME_NOT_ALLOWED_IN_RELEASE_BUILD(__VA_ARGS__))
704
705
706 /*
707 alpha beta release
708 TODO log log wont compile
709
710 //annotations PARA TODO; TODO; things to be done
711 //annotations TODO(...)
712 //annotations
713 //annotations enhancement to be done soon
714 //annotations
715 */
716 #define NOBUG_TODO(...) \
717 NOBUG_IF_NOT_RELEASE ( \
718 NOBUG_ONCE ( \
719 NOBUG_LOG_( &nobug_flag_NOBUG_ANN, LOG_NOTICE, \
720 "TODO", NOBUG_CONTEXT, ""__VA_ARGS__); \
721 )) \
722 NOBUG_IF_RELEASE(NOBUG_TODO_NOT_ALLOWED_IN_RELEASE_BUILD(__VA_ARGS__))
723
724
725 /*
726 alpha beta release
727 PLANNED log nothing nothing
728
729 //annotations PARA PLANNED; PLANNED; ideas for future
730 //annotations PLANNED(...)
731 //annotations
732 //annotations future enhancement
733 //annotations
734 */
735 #define NOBUG_PLANNED(...) \
736 NOBUG_IF_ALPHA( NOBUG_ONCE(NOBUG_LOG_ (&nobug_flag_NOBUG_ANN, LOG_INFO, \
737 "PLANNED", NOBUG_CONTEXT, ""__VA_ARGS__)))
738
739
740 /*
741 alpha beta release
742 NOTREACHED abort abort nothing
743
744 //annotations PARA NOTREACHED; NOTREACHED; code path never taken
745 //annotations NOTREACHED(...)
746 //annotations
747 //annotations used to tag code-path which shall be never executed.
748 //annotations
749 */
750 #define NOBUG_NOTREACHED(...) \
751 NOBUG_IF_NOT_RELEASE( do { \
752 NOBUG_LOG_( &nobug_flag_NOBUG_ANN, LOG_EMERG, \
753 "NOTREACHED", NOBUG_CONTEXT, ""__VA_ARGS__); \
754 NOBUG_ABORT; \
755 } while (0))
756
757
758 /*
759 //annotations PARA ELSE_NOTREACHED; ELSE_NOTREACHED; alternative never taken
760 //annotations ELSE_NOTREACHED(...)
761 //annotations
762 //annotations same as `else NOTREACHED()`, but wholly optimized out in release builds.
763 //annotations
764 */
765 #define NOBUG_ELSE_NOTREACHED(...) \
766 NOBUG_IF_NOT_RELEASE( else do { \
767 NOBUG_LOG_( &nobug_flag_NOBUG_ANN, LOG_EMERG, \
768 "ELSE_NOTREACHED", NOBUG_CONTEXT, ""__VA_ARGS__); \
769 NOBUG_ABORT; \
770 } while (0))
771
772
773 /*
774 //faultinjection HEAD- Fault injection;;
775 //faultinjection
776 //faultinjection NoBug has some macros which can be used to simulate errorneous behaviour:
777 //faultinjection
778 //faultinjection PARA INJECT_GOODBAD; INJECT_GOODBAD; fault injection expression
779 //faultinjection INJECT_GOODBAD(expr, good, bad)
780 //faultinjection
781 //faultinjection substitutes to an expression and returns good when expr is false and
782 //faultinjection bad when expr is true. In BETA and RELEASE builds 'good' is always returned.
783 //faultinjection
784 */
785 #define NOBUG_INJECT_GOODBAD(expr, good, bad) \
786 NOBUG_IF_ALPHA((expr)?({NOBUG_INJECT_LOG(#expr": "#bad);bad;}):good) \
787 NOBUG_IF_NOT_ALPHA(good)
788
789
790 /*
791 //faultinjection PARA INJECT_FAULT; INJECT_FAULT; fault injection statement
792 //faultinjection INJECT_FAULT(expr, bad)
793 //faultinjection
794 //faultinjection substitutes to a statement which executes 'bad'
795 //faultinjection when expr is true. Optimitzed out in BETA and RELEASE builds.
796 //faultinjection
797 */
798 #define NOBUG_INJECT_FAULT(expr, bad) \
799 NOBUG_IF_ALPHA(NOBUG_WHEN(expr,NOBUG_INJECT_LOG(#expr": "#bad); bad))
800
801
802 /*
803 //faultinjection PARA INJECT_LEVEL; INJECT_LEVEL; log level for fault injection
804 //faultinjection In both cases, when a fault is injected it will be logged at
805 //faultinjection `NOBUG_INJECT_LEVEL` (default: `LOG_NOTICE`). This can be defined
806 //faultinjection before including 'nobug.h' to override it.
807 //faultinjection
808 */
809 #define NOBUG_INJECT_LOG(msg) \
810 NOBUG_LOG_( &nobug_flag_NOBUG_ON, NOBUG_INJECT_LEVEL, \
811 "INJECT_FAULT", NOBUG_CONTEXT, \
812 msg)
813
814
815 #ifndef NOBUG_INJECT_LEVEL
816 #define NOBUG_INJECT_LEVEL LOG_NOTICE
817 #endif
818
819
820 /*
821 Flag handling
822 */
823 #define NOBUG_FLAG(name) NOBUG_CAT(nobug_flag_, name)
824
825 #define NOBUG_DECLARE_FLAG(name) extern struct nobug_flag NOBUG_FLAG(name)
826
827
828 #define NOBUG_DEFINE_FLAG(name) \
829 NOBUG_FLAG_IF_DECLAREONLY(NOBUG_DECLARE_FLAG(name)) \
830 NOBUG_FLAG_IF_NOT_DECLAREONLY( \
831 struct nobug_flag NOBUG_FLAG(name) = \
832 NOBUG_IF(NOBUG_MODE_ALPHA, {#name, NULL, 0, \
833 {LOG_DEBUG, LOG_INFO, LOG_DEBUG, -1, LOG_INFO}, &nobug_default_ringbuffer, NULL,NULL}) \
834 NOBUG_IF(NOBUG_MODE_BETA, {#name, NULL, 0, \
835 {LOG_INFO, LOG_NOTICE, LOG_NOTICE, LOG_NOTICE, LOG_WARNING}, &nobug_default_ringbuffer, NULL,NULL}) \
836 NOBUG_IF(NOBUG_MODE_RELEASE, {#name, NULL, 0, \
837 {LOG_NOTICE, -1, LOG_WARNING, LOG_WARNING, LOG_ERR}, &nobug_default_ringbuffer, NULL,NULL}) \
838 )
839
840
841 #define NOBUG_DEFINE_FLAG_PARENT(name, parent) \
842 NOBUG_FLAG_IF_DECLAREONLY(NOBUG_DECLARE_FLAG(name)) \
843 NOBUG_FLAG_IF_NOT_DECLAREONLY( \
844 NOBUG_DECLARE_FLAG(parent); \
845 struct nobug_flag NOBUG_FLAG(name) = \
846 NOBUG_IF(NOBUG_MODE_ALPHA, {#name, &NOBUG_FLAG(parent), 0, \
847 {LOG_DEBUG, LOG_INFO, LOG_DEBUG, -1, LOG_INFO}, &nobug_default_ringbuffer, NULL,NULL}) \
848 NOBUG_IF(NOBUG_MODE_BETA, {#name, &NOBUG_FLAG(parent), 0, \
849 {LOG_INFO, LOG_NOTICE, LOG_NOTICE, LOG_NOTICE, LOG_WARNING}, &nobug_default_ringbuffer, NULL,NULL}) \
850 NOBUG_IF(NOBUG_MODE_RELEASE, {#name, &NOBUG_FLAG(parent), 0, \
851 {LOG_NOTICE, -1, LOG_WARNING, LOG_WARNING, LOG_ERR}, &nobug_default_ringbuffer, NULL,NULL}) \
852 )
853
854
855 #define NOBUG_DEFINE_FLAG_LIMIT(name, limit) \
856 NOBUG_FLAG_IF_DECLAREONLY(NOBUG_DECLARE_FLAG(name)) \
857 NOBUG_FLAG_IF_NOT_DECLAREONLY( \
858 struct nobug_flag NOBUG_FLAG(name) = \
859 NOBUG_IF(NOBUG_MODE_ALPHA, {#name, NULL, 0, \
860 {LOG_DEBUG, limit, LOG_DEBUG, -1, LOG_INFO}, &nobug_default_ringbuffer, NULL,NULL}) \
861 NOBUG_IF(NOBUG_MODE_BETA, {#name, NULL, 0, \
862 {LOG_INFO, LOG_NOTICE, limit, LOG_NOTICE, LOG_WARNING}, &nobug_default_ringbuffer, NULL,NULL}) \
863 NOBUG_IF(NOBUG_MODE_RELEASE, {#name, NULL, 0, \
864 {LOG_NOTICE, -1, LOG_WARNING, limit, LOG_ERR}, &nobug_default_ringbuffer, NULL,NULL}) \
865 )
866
867
868 #define NOBUG_DEFINE_FLAG_PARENT_LIMIT(name, parent, limit) \
869 NOBUG_FLAG_IF_DECLAREONLY(NOBUG_DECLARE_FLAG(name)) \
870 NOBUG_FLAG_IF_NOT_DECLAREONLY( \
871 NOBUG_DECLARE_FLAG(parent); \
872 struct nobug_flag NOBUG_FLAG(name) = \
873 NOBUG_IF(NOBUG_MODE_ALPHA, {#name, &NOBUG_FLAG(parent), 0, \
874 {LOG_DEBUG, limit, LOG_DEBUG, -1, LOG_INFO}, &nobug_default_ringbuffer, NULL,NULL}) \
875 NOBUG_IF(NOBUG_MODE_BETA, {#name, &NOBUG_FLAG(parent), 0, \
876 {LOG_INFO, LOG_NOTICE, limit, LOG_NOTICE, LOG_WARNING}, &nobug_default_ringbuffer, NULL,NULL}) \
877 NOBUG_IF(NOBUG_MODE_RELEASE, {#name, &NOBUG_FLAG(parent), 0, \
878 {LOG_NOTICE, -1, LOG_WARNING, limit, LOG_ERR}, &nobug_default_ringbuffer, NULL,NULL}) \
879 )
880
881
882 #define NOBUG_INIT_FLAG(name) \
883 nobug_env_init_flag (&NOBUG_FLAG(name), NOBUG_LOG_TARGET, NOBUG_LOG_LIMIT, NOBUG_CONTEXT_NOFUNC)
884
885
886 #define NOBUG_INIT_FLAG_LIMIT(name, default) \
887 nobug_env_init_flag (&NOBUG_FLAG(name), NOBUG_LOG_TARGET, default, NOBUG_CONTEXT_NOFUNC)
888
889
890 #define NOBUG_CPP_DEFINE_FLAG(name) \
891 NOBUG_FLAG_IF_DECLAREONLY( \
892 NOBUG_DECLARE_FLAG(name); \
893 extern int nobug_cppflag_##name \
894 ) \
895 NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP( \
896 NOBUG_DEFINE_FLAG(name); \
897 int nobug_cppflag_##name = NOBUG_INIT_FLAG(name) \
898 )
899
900
901 #define NOBUG_CPP_DEFINE_FLAG_PARENT(name, parent) \
902 NOBUG_FLAG_IF_DECLAREONLY( \
903 NOBUG_DECLARE_FLAG(name); \
904 extern int nobug_cppflag_##name \
905 ) \
906 NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP( \
907 NOBUG_DEFINE_FLAG_PARENT(name, parent); \
908 int nobug_cppflag_##name = NOBUG_INIT_FLAG(name) \
909 )
910
911
912 #define NOBUG_CPP_DEFINE_FLAG_LIMIT(name, default) \
913 NOBUG_FLAG_IF_DECLAREONLY( \
914 NOBUG_DECLARE_FLAG(name); \
915 extern int nobug_cppflag_##name \
916 ) \
917 NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP( \
918 NOBUG_DEFINE_FLAG_LIMIT(name, default); \
919 int nobug_cppflag_##name = NOBUG_INIT_FLAG_LIMIT(name, default) \
920 )
921
922
923 #define NOBUG_CPP_DEFINE_FLAG_PARENT_LIMIT(name, parent, default) \
924 NOBUG_FLAG_IF_DECLAREONLY( \
925 NOBUG_DECLARE_FLAG(name); \
926 extern int nobug_cppflag_##name \
927 ) \
928 NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP( \
929 NOBUG_DEFINE_FLAG_PARENT_LIMIT(name, parent, default); \
930 int nobug_cppflag_##name = NOBUG_INIT_FLAG_LIMIT(name, default) \
931 )
932
933
934 #ifndef NOBUG_DECLARE_ONLY
935 #define NOBUG_DECLARE_ONLY 0
936 #endif
937
938 #define NOBUG_FLAG_IF_DECLAREONLY(...) \
939 NOBUG_IF(NOBUG_DECLARE_ONLY, __VA_ARGS__)
940
941 #define NOBUG_FLAG_IF_NOT_DECLAREONLY(...) \
942 NOBUG_IFNOT(NOBUG_DECLARE_ONLY, __VA_ARGS__)
943
944 #ifdef __cplusplus
945 #define NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP(...) \
946 NOBUG_IFNOT(NOBUG_DECLARE_ONLY, __VA_ARGS__)
947 #else
948 #define NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP(...) \
949 NOBUG_IFNOT(NOBUG_DECLARE_ONLY, NOBUG_ERROR_CANT_DEFINE_AUTOINITIALIZED_CPP_FLAGS_IN_C)
950 #endif
951
952 #ifndef NOBUG_LOG_LIMIT_ALPHA
953 # define NOBUG_LOG_LIMIT_ALPHA LOG_INFO
954 #endif
955 #ifndef NOBUG_LOG_LIMIT_BETA
956 # define NOBUG_LOG_LIMIT_BETA LOG_WARNING
957 #endif
958 #ifndef NOBUG_LOG_LIMIT_RELEASE
959 # define NOBUG_LOG_LIMIT_RELEASE LOG_CRIT
960 #endif
961
962 #ifndef NOBUG_LOG_LIMIT
963 # define NOBUG_LOG_LIMIT \
964 NOBUG_IF_ALPHA( NOBUG_LOG_LIMIT_ALPHA) \
965 NOBUG_IF_BETA( NOBUG_LOG_LIMIT_BETA) \
966 NOBUG_IF_RELEASE( NOBUG_LOG_LIMIT_RELEASE)
967 #endif
968
969 #ifndef NOBUG_LOG_TARGET_ALPHA
970 # define NOBUG_LOG_TARGET_ALPHA NOBUG_TARGET_CONSOLE
971 #endif
972 #ifndef NOBUG_LOG_TARGET_BETA
973 # define NOBUG_LOG_TARGET_BETA NOBUG_TARGET_FILE
974 #endif
975 #ifndef NOBUG_LOG_TARGET_RELEASE
976 # define NOBUG_LOG_TARGET_RELEASE NOBUG_TARGET_SYSLOG
977 #endif
978
979 #ifndef NOBUG_LOG_TARGET
980 # define NOBUG_LOG_TARGET \
981 NOBUG_IF_ALPHA( NOBUG_LOG_TARGET_ALPHA) \
982 NOBUG_IF_BETA( NOBUG_LOG_TARGET_BETA) \
983 NOBUG_IF_RELEASE( NOBUG_LOG_TARGET_RELEASE)
984 #endif
985
986 #define NOBUG_SET_LIMIT(flag, min) \
987 NOBUG_IF_NOT_RELEASE( NOBUG_FLAG(flag) = (min))
988
989
990 /*
991 //resourcemacros HEAD~ Resource tracking macros;;
992 //resourcemacros
993 //resourcemacros INDEX RESOURCE_LOGGING; RESOURCE_LOGGING; switch resource logging on and off
994 //resourcemacros INDEX RESOURCE_LOG_LEVEL; RESOURCE_LOG_LEVEL; select the log level for resource logging
995 //resourcemacros
996 //resourcemacros Unless the user defines `NOBUG_RESOURCE_LOGGING` to 0 each of the above macros
997 //resourcemacros will emit a log message at `NOBUG_RESOURCE_LOG_LEVEL` which defaults to
998 //resourcemacros `LOG_DEBUG`.
999 //resourcemacros
1000 */
1001 #ifndef NOBUG_RESOURCE_LOGGING
1002 #define NOBUG_RESOURCE_LOGGING 1
1003 #endif
1004
1005 #ifndef NOBUG_RESOURCE_LOG_LEVEL
1006 #define NOBUG_RESOURCE_LOG_LEVEL LOG_DEBUG
1007 #endif
1008
1009
1010 /*
1011 //resourcemacros PARA RESOURCE_HANDLE; RESOURCE_HANDLE; define resource handles
1012 //resourcemacros RESOURCE_HANDLE(name)
1013 //resourcemacros RESOURCE_HANDLE_INIT(name)
1014 //resourcemacros RESOURCE_USER(name)
1015 //resourcemacros RESOURCE_USER_INIT(name)
1016 //resourcemacros
1017 //resourcemacros Define and initialize handles for to track resources.
1018 //resourcemacros
1019 //resourcemacros `name`::
1020 //resourcemacros identifer to be used for the handle
1021 //resourcemacros
1022 //resourcemacros There are two kinds of handles, each resource itself is abstracted with a
1023 //resourcemacros `RESOURCE_HANDLE` and every access to this resources is tracked through a
1024 //resourcemacros `RESOURCE_USER` handle. These macros takes care that the declaration is optimized
1025 //resourcemacros out in the same manner as the rest of the resource tracker would be disabled.
1026 //resourcemacros You can still instantiate handles as `struct nobug_resource_record*` or
1027 //resourcemacros `struct nobug_resource_user*` in structures which must have a constant size
1028 //resourcemacros unconditional of the build level. The two `*_INIT` macros can be used to initialize
1029 //resourcemacros resource handles and are optimized out when the resource tracker gets disabled.
1030 //resourcemacros
1031 */
1032 #define NOBUG_RESOURCE_HANDLE(handle) \
1033 NOBUG_IF_ALPHA(struct nobug_resource_record* handle)
1034
1035 #define NOBUG_RESOURCE_HANDLE_INIT(handle) NOBUG_IF_ALPHA(handle = NULL)
1036
1037 #define NOBUG_RESOURCE_USER(handle) \
1038 NOBUG_IF_ALPHA(struct nobug_resource_user* handle)
1039
1040 #define NOBUG_RESOURCE_USER_INIT(handle) NOBUG_IF_ALPHA(handle = NULL)
1041
1042
1043 /*
1044 //resourcemacros PARA RESOURCE_ANNOUNCE; RESOURCE_ANNOUNCE; publish new resources
1045 //resourcemacros RESOURCE_ANNOUNCE(flag, type, name, identifier, handle)
1046 //resourcemacros NOBUG_RESOURCE_ANNOUNCE_RAW(flagptr, type, name, ptr, handle)
1047 //resourcemacros NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(flagptr, type, name, ptr, handle, context)
1048 //resourcemacros
1049 //resourcemacros Publishes resources.
1050 //resourcemacros
1051 //resourcemacros `flag`::
1052 //resourcemacros the NoBug flag name which turns logging on for this macro
1053 //resourcemacros `type`::
1054 //resourcemacros a string which should denote the domain of the resource,
1055 //resourcemacros examples are "file", "mutex", "lock", "database" and so on
1056 //resourcemacros `name`::
1057 //resourcemacros the actual name of a named resource this as string which
1058 //resourcemacros together with type forms a unique identifier of the resource. `type` and
1059 //resourcemacros `name` must be available through the entire lifetime of the resource, using
1060 //resourcemacros literal strings is recommended
1061 //resourcemacros `identifier`::
1062 //resourcemacros a pointer which should be unique for this resource, any
1063 //resourcemacros kind of pointer will suffice, it is only used for identification. In
1064 //resourcemacros multithreaded applications the thread identifier becomes an additional
1065 //resourcemacros identifier
1066 //resourcemacros `handle`::
1067 //resourcemacros a `NOBUG_RESOURCE_HANDLE` which will be initialized to point to
1068 //resourcemacros the newly created resource.
1069 //resourcemacros
1070 //resourcemacros Resources must be unique, it is a fatal error when a resource it tried to be
1071 //resourcemacros announced more than one time.
1072 //resourcemacros
1073 */
1074 #define NOBUG_RESOURCE_ANNOUNCE(flag, type, name, ptr, handle) \
1075 NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(&NOBUG_FLAG(flag), type, name, ptr, handle, NOBUG_CONTEXT)
1076
1077 #define NOBUG_RESOURCE_ANNOUNCE_RAW(flag, type, name, ptr, handle) \
1078 NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(flag, type, name, ptr, handle, NOBUG_CONTEXT)
1079
1080 #define NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(flag, type, name, ptr, handle, context) \
1081 NOBUG_IF_NOT_RELEASE( do { \
1082 NOBUG_IF_ALPHA (NOBUG_RESOURCE_LOCK;) \
1083 NOBUG_REQUIRE_CTX(!handle, context, "Announced resource handle not initialized"); \
1084 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1085 NOBUG_LOG_(flag, NOBUG_RESOURCE_LOG_LEVEL, \
1086 "RESOURCE_ANNOUNCE", context, \
1087 "%s: %s@%p", type, name, ptr);) \
1088 NOBUG_IF_ALPHA ( \
1089 NOBUG_RESOURCE_ASSERT_CTX(handle = nobug_resource_announce (type, name, ptr, \
1090 context), \
1091 "RESOURCE_ASSERT_ANNOUNCE", context, \
1092 "%s: %s@%p %s", type, name, ptr, nobug_resource_error); \
1093 NOBUG_RESOURCE_UNLOCK;) \
1094 } while (0))
1095
1096
1097 /*
1098 //resourcemacros PARA RESOURCE_FORGET; RESOURCE_FORGET; remove resources
1099 //resourcemacros RESOURCE_FORGET(flag, handle)
1100 //resourcemacros NOBUG_RESOURCE_FORGET_RAW(flagptr, handle)
1101 //resourcemacros NOBUG_RESOURCE_FORGET_RAW_CTX(flagptr, handle, context)
1102 //resourcemacros
1103 //resourcemacros Removes resources that have become unavailable from the registry.
1104 //resourcemacros
1105 //resourcemacros `flag`::
1106 //resourcemacros the NoBug flag which turns logging on for this macro
1107 //resourcemacros `handle`::
1108 //resourcemacros the `NOBUG_RESOURCE_HANDLE` used to track this resource
1109 //resourcemacros
1110 //resourcemacros The resource must still exist and no users must be attached to it, else a fatal
1111 //resourcemacros error is raised.
1112 //resourcemacros
1113 */
1114 #define NOBUG_RESOURCE_FORGET(flag, handle) \
1115 NOBUG_RESOURCE_FORGET_RAW_CTX(&NOBUG_FLAG(flag), handle, NOBUG_CONTEXT)
1116
1117 #define NOBUG_RESOURCE_FORGET_RAW(flag, handle) \
1118 NOBUG_RESOURCE_FORGET_RAW_CTX(flag, handle, NOBUG_CONTEXT)
1119
1120 #define NOBUG_RESOURCE_FORGET_RAW_CTX(flag, handle, context) \
1121 NOBUG_IF_NOT_RELEASE( do { \
1122 NOBUG_IF_ALPHA (NOBUG_RESOURCE_LOCK;) \
1123 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1124 NOBUG_LOG_(flag, NOBUG_RESOURCE_LOG_LEVEL, \
1125 "RESOURCE_FORGET", context, "%s: %s@%p", \
1126 (handle)?(handle)->type:"", \
1127 (handle)?(handle)->hdr.name:"", \
1128 (handle)?(handle)->object_id:NULL);) \
1129 NOBUG_IF_ALPHA ( \
1130 NOBUG_RESOURCE_ASSERT_CTX(nobug_resource_forget (handle), \
1131 "RESOURCE_ASSERT_FORGET", context, "%s: %s@%p: %s", \
1132 (handle)?(handle)->type:"", \
1133 (handle)?(handle)->hdr.name:"", \
1134 (handle)?(handle)->object_id:NULL, \
1135 nobug_resource_error); \
1136 handle = NULL; \
1137 NOBUG_RESOURCE_UNLOCK;) \
1138 } while (0))
1139
1140
1141 /*
1142 //resourcemacros PARA RESOURCE_ENTER; RESOURCE_ENTER; claim a resource
1143 //resourcemacros RESOURCE_ENTER(flag, announced, user, state, handle)
1144 //resourcemacros NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, state, handle, context)
1145 //resourcemacros
1146 //resourcemacros Acquire a resource.
1147 //resourcemacros
1148 //resourcemacros `flag`::
1149 //resourcemacros nobug flag which turns logging on for this macro
1150 //resourcemacros `announced`::
1151 //resourcemacros the handle set by `RESOURCE_ANNOUNCE`
1152 //resourcemacros `user`::
1153 //resourcemacros a free-form identifier
1154 //resourcemacros `state`::
1155 //resourcemacros the initial state, one of `NOBUG_RESOURCE_WAITING`, `NOBUG_RESOURCE_TRYING`,
1156 //resourcemacros `NOBUG_RESOURCE_EXCLUSIVE`, `NOBUG_RESOURCE_RECURSIVE` or `NOBUG_RESOURCE_SHARED`
1157 //resourcemacros `handle`::
1158 //resourcemacros a `NOBUG_RESOURCE_HANDLE` which will be initialized to the
1159 //resourcemacros entering node
1160 //resourcemacros
1161 */
1162 #define NOBUG_RESOURCE_ENTER(flag, resource, user, state, handle) \
1163 NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, state, handle, NOBUG_CONTEXT)
1164
1165 #define NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, state, handle, context) \
1166 NOBUG_IF_NOT_RELEASE( \
1167 do { \
1168 NOBUG_REQUIRE_CTX(resource, context, "Announced resource handle not initialized"); \
1169 NOBUG_REQUIRE_CTX(!(handle), context, "Resource handle already entered"); \
1170 NOBUG_IF_ALPHA (NOBUG_RESOURCE_LOCK;) \
1171 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1172 NOBUG_LOG_(&NOBUG_FLAG(flag), NOBUG_RESOURCE_LOG_LEVEL, \
1173 "RESOURCE_ENTER", context, \
1174 "%s: %s@%p: %s: %s", \
1175 (resource)?(resource)->type:"", \
1176 (resource)?(resource)->hdr.name:"", \
1177 (resource)?(resource)->object_id:NULL, \
1178 user, \
1179 nobug_resource_states[state]);) \
1180 NOBUG_IF_ALPHA ( \
1181 NOBUG_RESOURCE_ASSERT_CTX(handle = \
1182 nobug_resource_enter (resource, \
1183 user, state, \
1184 context), \
1185 "RESOURCE_ASSERT_ENTER", context, \
1186 "%s: %s@%p: %s: %s: %s", \
1187 (resource)?(resource)->type:"", \
1188 (resource)?(resource)->hdr.name:"", \
1189 (resource)?(resource)->object_id:NULL, \
1190 user, nobug_resource_states[state], \
1191 nobug_resource_error); \
1192 NOBUG_RESOURCE_UNLOCK;) \
1193 } while(0))
1194
1195
1196 //resourcemacros PARA RESOURCE_WAIT; RESOURCE_WAIT; wait for a resource to become available
1197 //resourcemacros RESOURCE_WAIT(flag, resource, user, handle)
1198 //resourcemacros NOBUG_RESOURCE_WAIT_CTX(flag, resource, user, handle, context)
1199 //resourcemacros
1200 //resourcemacros This is just an alias for RESOURCE_ENTER(flag, resource, user, NOBUG_RESOURCE_WAITING, handle)
1201 //resourcemacros
1202 //resourcemacros .How to use it
1203 //resourcemacros [source,c]
1204 //resourcemacros ----
1205 //resourcemacros RESOURCE_WAIT(flag, resource, user, handle);
1206 //resourcemacros if (lock_my_resource() == ERROR)
1207 //resourcemacros NOBUG_RESOURCE_LEAVE(flag, handle);
1208 //resourcemacros else
1209 //resourcemacros RESOURCE_STATE(flag, NOBUG_RESOURCE_EXCLUSIVE, handle);
1210 //resourcemacros ----
1211 //resourcemacros
1212 #define NOBUG_RESOURCE_WAIT(flag, resource, user, handle) \
1213 NOBUG_RESOURCE_ENTER(flag, resource, user, NOBUG_RESOURCE_WAITING, handle)
1214
1215 #define NOBUG_RESOURCE_WAIT_CTX(flag, resource, user, handle, context) \
1216 NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, NOBUG_RESOURCE_WAITING, handle, context)
1217
1218
1219 //resourcemacros PARA RESOURCE_TRY; RESOURCE_TRY; wait for a resource to become available
1220 //resourcemacros RESOURCE_TRY(flag, resource, user, handle)
1221 //resourcemacros NOBUG_RESOURCE_TRY_CTX(flag, resource, user, handle, context)
1222 //resourcemacros
1223 //resourcemacros This is just an alias for RESOURCE_ENTER(flag, resource, user, NOBUG_RESOURCE_TRYING, handle).
1224 //resourcemacros Trying on a resource is similar to waiting but will not trigger a deadlock check. This can be used
1225 //resourcemacros when a deadlock is expected at runtime and one handles this otherwise (by a timed wait or something like that).
1226 //resourcemacros
1227 #define NOBUG_RESOURCE_TRY(flag, resource, user, handle) \
1228 NOBUG_RESOURCE_ENTER(flag, resource, user, NOBUG_RESOURCE_TRYING, handle)
1229
1230 #define NOBUG_RESOURCE_TRY_CTX(flag, resource, user, handle, context) \
1231 NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, NOBUG_RESOURCE_TRYING, handle, context)
1232
1233
1234 /*
1235 //resourcemacros PARA RESOURCE_STATE; RESOURCE_STATE; change the state of a resource
1236 //resourcemacros RESOURCE_STATE(flag, entered, state)
1237 //resourcemacros NOBUG_RESOURCE_STATE_CTX(flag, state, entered, context)
1238 //resourcemacros NOBUG_RESOURCE_STATE_RAW(flagptr, state, entered)
1239 //resourcemacros NOBUG_RESOURCE_STATE_RAW_CTX(flagptr, nstate, entered, context)
1240 //resourcemacros
1241 //resourcemacros Changes resource's state.
1242 //resourcemacros
1243 //resourcemacros `flag`::
1244 //resourcemacros is nobug flag which turns logging on for this macro
1245 //resourcemacros `state`::
1246 //resourcemacros the new state Note that only certain state transitions are
1247 //resourcemacros allowed, see discussion/diagram above
1248 //resourcemacros `entered`::
1249 //resourcemacros the handle set by `RESOURCE_ENTER`
1250 //resourcemacros
1251 */
1252 #define NOBUG_RESOURCE_STATE(flag, state, entered) \
1253 NOBUG_RESOURCE_STATE_RAW_CTX(&NOBUG_FLAG(flag), state, entered, NOBUG_CONTEXT)
1254
1255 #define NOBUG_RESOURCE_STATE_CTX(flag, state, entered, context) \
1256 NOBUG_RESOURCE_STATE_RAW_CTX(&NOBUG_FLAG(flag), state, entered, context)
1257
1258 #define NOBUG_RESOURCE_STATE_RAW(flag, state, entered) \
1259 NOBUG_RESOURCE_STATE_RAW_CTX(flag, state, entered, NOBUG_CONTEXT)
1260
1261 #define NOBUG_RESOURCE_STATE_RAW_CTX(flag, nstate, entered, context) \
1262 NOBUG_IF_NOT_RELEASE( \
1263 do { \
1264 NOBUG_IF_ALPHA(NOBUG_RESOURCE_LOCK;) \
1265 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1266 NOBUG_LOG_(flag, NOBUG_RESOURCE_LOG_LEVEL, \
1267 "RESOURCE_STATE", context, \
1268 "%s: %s@%p: %s: %s->%s", \
1269 (entered)?(entered)->current->resource->type:"", \
1270 (entered)?(entered)->current->resource->hdr.name:"", \
1271 (entered)?(entered)->current->resource->object_id:"", \
1272 (entered)?(entered)->hdr.name:"", \
1273 nobug_resource_states[(entered)?(entered)->state \
1274 :NOBUG_RESOURCE_INVALID], \
1275 nobug_resource_states[nstate]); \
1276 ) \
1277 NOBUG_IF_ALPHA( \
1278 NOBUG_RESOURCE_ASSERT_CTX(nobug_resource_state ((entered), nstate), \
1279 "RESOURCE_ASSERT_STATE", context, \
1280 "%s: %s@%p: %s: %s->%s: %s", \
1281 (entered)?(entered)->current->resource->type:"", \
1282 (entered)?(entered)->current->resource->hdr.name:"", \
1283 (entered)?(entered)->current->resource->object_id:"", \
1284 (entered)?(entered)->hdr.name:"", \
1285 nobug_resource_states[(entered)?(entered)->state \
1286 :NOBUG_RESOURCE_INVALID], \
1287 nobug_resource_states[nstate], \
1288 nobug_resource_error); \
1289 NOBUG_RESOURCE_UNLOCK;) \
1290 } while (0))
1291
1292
1293 /*
1294 //resourcemacros PARA RESOURCE_LEAVE; RESOURCE_LEAVE; relinquish a claimed resource
1295 //resourcemacros RESOURCE_LEAVE(flag, handle){}
1296 //resourcemacros NOBUG_RESOURCE_LEAVE_RAW(flagptr, handle){}
1297 //resourcemacros NOBUG_RESOURCE_LEAVE_RAW_CTX(flagptr, handle, context){}
1298 //resourcemacros
1299 //resourcemacros Disconnect from a resource identified with its handle.
1300 //resourcemacros
1301 //resourcemacros `flag`::
1302 //resourcemacros nobug flag which turns logging on for this macro
1303 //resourcemacros `handle`::
1304 //resourcemacros the handle you got while entering the resource
1305 //resourcemacros
1306 //resourcemacros 'RESOURCE_LEAVE()' acts like the head of a C loop statement, it ties to the following
1307 //resourcemacros (block-) statement. Leaving and the user defined following statement are atomic.
1308 //resourcemacros This statement must not be left by break, return or any other kind of jump. NoBug does
1309 //resourcemacros not assert this (for for Performance reasons).
1310 //resourcemacros
1311 //resourcemacros .How to use it
1312 //resourcemacros [source,c]
1313 //resourcemacros ----
1314 //resourcemacros NOBUG_RESOURCE_LEAVE(flag, handle)
1315 //resourcemacros {
1316 //resourcemacros unlock_my_resource();
1317 //resourcemacros }
1318 //resourcemacros ----
1319 //resourcemacros
1320 */
1321 #define NOBUG_RESOURCE_LEAVE(flag, handle) \
1322 NOBUG_RESOURCE_LEAVE_RAW_CTX(&NOBUG_FLAG(flag), handle, NOBUG_CONTEXT)
1323
1324 #define NOBUG_RESOURCE_LEAVE_RAW(flag, handle) \
1325 NOBUG_RESOURCE_LEAVE_RAW_CTX(flag, handle, NOBUG_CONTEXT)
1326
1327 #define NOBUG_RESOURCE_LEAVE_RAW_CTX(flag, handle, context) \
1328 NOBUG_IF_NOT_RELEASE( \
1329 for ( \
1330 int nobug_locked_ = (NOBUG_IF_ALPHA(NOBUG_RESOURCE_LOCK NOBUG_COMMA) 1); \
1331 nobug_locked_; \
1332 ({ \
1333 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1334 NOBUG_LOG_(flag, NOBUG_RESOURCE_LOG_LEVEL, \
1335 "RESOURCE_LEAVE", context, \
1336 "%s: %s@%p: %s: %s", \
1337 (handle)?(handle)->current->resource->type:"", \
1338 (handle)?(handle)->current->resource->hdr.name:"", \
1339 (handle)?(handle)->current->resource->object_id:"", \
1340 (handle)?(handle)->hdr.name:"", \
1341 nobug_resource_states[(handle)?(handle)->state \
1342 :NOBUG_RESOURCE_INVALID]); \
1343 ) \
1344 NOBUG_IF_ALPHA( \
1345 NOBUG_RESOURCE_ASSERT_CTX(nobug_resource_leave (handle), \
1346 "RESOURCE_ASSERT_LEAVE", context, \
1347 "%s: %s@%p: %s: %s: %s", \
1348 (handle)?(handle)->current->resource->type:"", \
1349 (handle)?(handle)->current->resource->hdr.name:"", \
1350 (handle)?(handle)->current->resource->object_id:"", \
1351 (handle)?(handle)->hdr.name:"", \
1352 nobug_resource_states[(handle)?(handle)->state \
1353 :NOBUG_RESOURCE_INVALID], \
1354 nobug_resource_error); \
1355 handle = NULL; \
1356 NOBUG_RESOURCE_UNLOCK;) \
1357 nobug_locked_ = 0; \
1358 })))
1359
1360
1361 /*
1362 //resourcemacros PARA RESOURCE_ASSERT_STATE; RESOURCE_ASSERT_STATE; assert the state of a resource
1363 //resourcemacros RESOURCE_ASSERT_STATE(resource, state)
1364 //resourcemacros RESOURCE_ASSERT_STATE_IF(when, resource, state)
1365 //resourcemacros NOBUG_RESOURCE_ASSERT_STATE_CTX(resource, state, context)
1366 //resourcemacros NOBUG_RESOURCE_ASSERT_STATE_IF_CTX(when, resource, state, context)
1367 //resourcemacros
1368 //resourcemacros Assert that we have a resource in a given state. For multithreaded programms the topmost
1369 //resourcemacros state of the calling thread is checked, for non threadeded programs the most recent state on
1370 //resourcemacros resource is used.
1371 //resourcemacros
1372 //resourcemacros `when`::
1373 //resourcemacros Condition which must be true for testing the assertion
1374 //resourcemacros `resource`::
1375 //resourcemacros Resource handle
1376 //resourcemacros `state`::
1377 //resourcemacros The expected state
1378 //resourcemacros
1379 */
1380 #define NOBUG_RESOURCE_ASSERT_STATE(resource, state) \
1381 NOBUG_RESOURCE_ASSERT_STATE_CTX(resource, state, NOBUG_CONTEXT)
1382
1383 #define NOBUG_RESOURCE_ASSERT_STATE_CTX(resource, state, context) \
1384 NOBUG_IF_ALPHA( \
1385 do { \
1386 enum nobug_resource_state mystate = nobug_resource_mystate (resource); \
1387 NOBUG_RESOURCE_ASSERT_CTX(mystate == state, \
1388 "RESOURCE_ASSERT_STATE", context, \
1389 "resource %p has state %s but %s was expected", \
1390 resource, nobug_resource_states[mystate], nobug_resource_states[state]); \
1391 } while (0))
1392
1393
1394 #define NOBUG_RESOURCE_ASSERT_STATE_IF(when, resource, state) \
1395 NOBUG_WHEN(when, NOBUG_RESOURCE_ASSERT_STATE (resource, state))
1396
1397
1398 /* assertion which dumps all resources */
1399 #define NOBUG_RESOURCE_ASSERT_CTX(expr, what, context, ...) \
1400 NOBUG_IF_ALPHA( \
1401 NOBUG_WHEN (!(expr), \
1402 NOBUG_LOG_( &nobug_flag_NOBUG_ON, LOG_EMERG, \
1403 what, context, \
1404 ""__VA_ARGS__); \
1405 nobug_resource_dump_all ((struct nobug_resource_dump_context) \
1406 { \
1407 &nobug_flag_NOBUG_ON, \
1408 LOG_EMERG, \
1409 context \
1410 }); \
1411 NOBUG_BACKTRACE_CTX(context); \
1412 NOBUG_ABORT))
1413
1414
1415 /*
1416 //resourcemacros PARA RESOURCE_DUMP; RESOURCE_DUMP; dump the state of a single resource
1417 //resourcemacros NOBUG_RESOURCE_DUMP(flag, handle)
1418 //resourcemacros NOBUG_RESOURCE_DUMP_IF(when, flag, handle)
1419 //resourcemacros
1420 //resourcemacros Dump the state of a single resource.
1421 //resourcemacros
1422 //resourcemacros `when`::
1423 //resourcemacros Condition which must be true to dump the resource
1424 //resourcemacros `flag`::
1425 //resourcemacros Nobug flag for the log channel
1426 //resourcemacros `handle`::
1427 //resourcemacros handle of the resource to be dumped
1428 //resourcemacros
1429 */
1430 #define NOBUG_RESOURCE_DUMP(flag, handle) \
1431 NOBUG_IF_ALPHA( \
1432 do { \
1433 NOBUG_RESOURCE_LOCK; \
1434 nobug_resource_dump (handle, (struct nobug_resource_dump_context) \
1435 {&NOBUG_FLAG(flag), \
1436 NOBUG_RESOURCE_LOG_LEVEL, \
1437 NOBUG_CONTEXT}); \
1438 NOBUG_RESOURCE_UNLOCK; \
1439 } while (0))
1440
1441 #define NOBUG_RESOURCE_DUMP_IF(when, flag, handle) \
1442 NOBUG_IF_ALPHA( \
1443 NOBUG_WHEN(when, NOBUG_RESOURCE_LOCK; \
1444 nobug_resource_dump (handle, (struct nobug_resource_dump_context) \
1445 {&NOBUG_FLAG(flag), \
1446 NOBUG_RESOURCE_LOG_LEVEL, \
1447 NOBUG_CONTEXT}); \
1448 NOBUG_RESOURCE_UNLOCK))
1449
1450
1451 /*
1452 //resourcemacros PARA RESOURCE_DUMPALL; RESOURCE_DUMPALL; dump the state of all resources
1453 //resourcemacros NOBUG_RESOURCE_DUMPALL(flag)
1454 //resourcemacros NOBUG_RESOURCE_DUMPALL_IF(when, flag)
1455 //resourcemacros
1456 //resourcemacros Dump the state of all resources.
1457 //resourcemacros
1458 //resourcemacros `when`::
1459 //resourcemacros Condition which must be true to dump the resources
1460 //resourcemacros `flag`::
1461 //resourcemacros Nobug flag for the log channel
1462 //resourcemacros
1463 */
1464 #define NOBUG_RESOURCE_DUMPALL(flag) \
1465 NOBUG_IF_ALPHA( \
1466 do { \
1467 NOBUG_RESOURCE_LOCK; \
1468 nobug_resource_dump_all ((struct nobug_resource_dump_context) \
1469 {&NOBUG_FLAG(flag), \
1470 NOBUG_RESOURCE_LOG_LEVEL, \
1471 NOBUG_CONTEXT}); \
1472 NOBUG_RESOURCE_UNLOCK; \
1473 } while (0))
1474
1475
1476 #define NOBUG_RESOURCE_DUMPALL_IF(when, flag) \
1477 NOBUG_IF_ALPHA( \
1478 NOBUG_WHEN(when, \
1479 NOBUG_RESOURCE_LOCK; \
1480 nobug_resource_dump_all ((struct nobug_resource_dump_context) \
1481 {&NOBUG_FLAG(flag), \
1482 NOBUG_RESOURCE_LOG_LEVEL, \
1483 NOBUG_CONTEXT}); \
1484 NOBUG_RESOURCE_UNLOCK))
1485
1486 /*
1487 //resourcemacros PARA RESOURCE_LIST; RESOURCE_LIST; enumerate all registered resources
1488 //resourcemacros NOBUG_RESOURCE_LIST(flag)
1489 //resourcemacros NOBUG_RESOURCE_LIST_IF(when, flag)
1490 //resourcemacros
1491 //resourcemacros List all registered resources.
1492 //resourcemacros
1493 //resourcemacros `when`::
1494 //resourcemacros Condition which must be true to list the resources
1495 //resourcemacros `flag`::
1496 //resourcemacros Nobug flag for the log channel
1497 //resourcemacros
1498 */
1499 #define NOBUG_RESOURCE_LIST(flag) \
1500 NOBUG_IF_ALPHA( \
1501 do { \
1502 NOBUG_RESOURCE_LOCK; \
1503 nobug_resource_list ((struct nobug_resource_dump_context) \
1504 {&NOBUG_FLAG(flag), \
1505 NOBUG_RESOURCE_LOG_LEVEL, \
1506 NOBUG_CONTEXT}); \
1507 NOBUG_RESOURCE_UNLOCK; \
1508 } while (0))
1509
1510
1511 #define NOBUG_RESOURCE_LIST_IF(when, flag) \
1512 NOBUG_IF_ALPHA( \
1513 NOBUG_WHEN(when, \
1514 NOBUG_RESOURCE_LOCK; \
1515 nobug_resource_list ((struct nobug_resource_dump_context) \
1516 {&NOBUG_FLAG(flag), \
1517 NOBUG_RESOURCE_LOG_LEVEL, \
1518 NOBUG_CONTEXT}); \
1519 NOBUG_RESOURCE_UNLOCK))
1520
1521
1522 /*
1523 threading support
1524 */
1525 #if NOBUG_USE_PTHREAD
1526 #define NOBUG_THREAD_ID_SET(name) nobug_thread_id_set(name)
1527 #define NOBUG_THREAD_ID_GET nobug_thread_id_get()
1528
1529 #else
1530 #define NOBUG_THREAD_ID_SET(name)
1531 #define NOBUG_THREAD_ID_GET ""
1532 #endif
1533
1534 #define NOBUG_THREAD_DATA (*nobug_thread_data())
1535
1536
1537 /*
1538 Debuggers
1539 */
1540
1541 #define NOBUG_DBG_NONE 0
1542 #define NOBUG_DBG_GDB 1
1543 #define NOBUG_DBG_VALGRIND 2
1544
1545 #define NOBUG_ACTIVE_DBG \
1546 NOBUG_IF(NOBUG_USE_VALGRIND, (RUNNING_ON_VALGRIND?2:0)) \
1547 NOBUG_IFNOT(NOBUG_USE_VALGRIND, 0)
1548
1549 /*
1550 //toolmacros HEAD- Tool Macros;;
1551 //toolmacros
1552 //toolmacros PARA NOBUG_FLAG_RAW; NOBUG_FLAG_RAW; pass direct flag pointer
1553 //toolmacros NOBUG_FLAG_RAW(ptr)
1554 //toolmacros
1555 //toolmacros Using this macro one can pass a direct pointer to a flag where a name would
1556 //toolmacros be expected. This is sometimes convinient when flag pointers are passed around
1557 //toolmacros in management strutures and one wants to tie logging to dynamic targets.
1558 //toolmacros
1559 //toolmacros [source,c]
1560 //toolmacros ----
1561 //toolmacros NOBUG_DEFINE_FLAG(myflag);
1562 //toolmacros ...
1563 //toolmacros struct nobug_flag* ptr = &NOBUG_FLAG(myflag);
1564 //toolmacros TRACE(NOBUG_FLAG_RAW(ptr), "Passed flag by pointer")
1565 //toolmacros ----
1566 //toolmacros
1567 */
1568 #define nobug_flag_NOBUG_FLAG_RAW(name) *name
1569
1570 /*
1571 //toolmacros PARA Backtraces; BACKTRACE; generate a backtrace
1572 //toolmacros BACKTRACE
1573 //toolmacros NOBUG_BACKTRACE_CTX(context)
1574 //toolmacros
1575 //toolmacros The backtrace macro logs a stacktrace using the NoBug facilities.
1576 //toolmacros This is automatically called when NoBug finds an error and is due
1577 //toolmacros to abort. But one might call it manually too.
1578 //toolmacros
1579 */
1580 #define NOBUG_BACKTRACE NOBUG_BACKTRACE_CTX(NOBUG_CONTEXT)
1581
1582 #define NOBUG_BACKTRACE_CTX(context) \
1583 NOBUG_IF_ALPHA( \
1584 switch (NOBUG_ACTIVE_DBG) { \
1585 case NOBUG_DBG_VALGRIND: \
1586 NOBUG_BACKTRACE_VALGRIND(context); \
1587 break; \
1588 default: \
1589 NOBUG_BACKTRACE_GLIBC(context); \
1590 }) \
1591 NOBUG_IF_NOT_ALPHA (NOBUG_BACKTRACE_GLIBC(context))
1592
1593 #define NOBUG_BACKTRACE_GDB(context) UNIMPLEMENTED
1594
1595 #define NOBUG_BACKTRACE_VALGRIND(context) \
1596 NOBUG_IF(NOBUG_USE_VALGRIND, \
1597 NOBUG_LOGGING_LOCK; \
1598 struct nobug_context ctx = context; \
1599 VALGRIND_PRINTF_BACKTRACE("----------: BACKTRACE: %s@%d %s", \
1600 nobug_basename(ctx.file), \
1601 ctx.line, \
1602 ctx.func); \
1603 NOBUG_LOGGING_UNLOCK)
1604
1605 #ifndef NOBUG_BACKTRACE_DEPTH
1606 #define NOBUG_BACKTRACE_DEPTH 256
1607 #endif
1608
1609 #define NOBUG_BACKTRACE_GLIBC(context) \
1610 NOBUG_IF_NOT_RELEASE( \
1611 NOBUG_IF(NOBUG_USE_EXECINFO, do { \
1612 nobug_backtrace_glibc (context); \
1613 } while (0)))
1614
1615
1616 #ifndef NOBUG_TAB
1617 #define NOBUG_TAB " "
1618 #endif
1619
1620 //toolmacros PARA Aborting; ABORT; abort the program
1621 //toolmacros NOBUG_ABORT_
1622 //toolmacros
1623 //toolmacros This is the default implementation for aborting the program, it first syncs all ringbuffers to disk, then
1624 //toolmacros calls the abort callback if defined and then `abort()`.
1625 //toolmacros
1626 //toolmacros NOBUG_ABORT
1627 //toolmacros
1628 //toolmacros If not overridden, evaluates to `NOBUG_ABORT_`. One can override this before including
1629 //toolmacros `nobug.h` to customize abortion behaviour. This will be local to the translation unit then.
1630 //toolmacros
1631 #ifndef NOBUG_ABORT
1632 #define NOBUG_ABORT NOBUG_ABORT_
1633 #endif
1634
1635 #define NOBUG_ABORT_ \
1636 do { \
1637 nobug_ringbuffer_allsync (); \
1638 if (nobug_abort_callback) \
1639 nobug_abort_callback (nobug_callback_data); \
1640 abort(); \
1641 } while(0)
1642
1643
1644 /*
1645 init and other function wrapers
1646 */
1647 #define NOBUG_INIT nobug_init(NOBUG_CONTEXT)
1648
1649 /*
1650 short macros without NOBUG_
1651 */
1652 #ifndef NOBUG_DISABLE_SHORTNAMES
1653 #ifndef REQUIRE
1654 #define REQUIRE NOBUG_REQUIRE
1655 #endif
1656 #ifndef REQUIRE_IF
1657 #define REQUIRE_IF NOBUG_REQUIRE_IF
1658 #endif
1659 #ifndef ENSURE
1660 #define ENSURE NOBUG_ENSURE
1661 #endif
1662 #ifndef ENSURE_IF
1663 #define ENSURE_IF NOBUG_ENSURE_IF
1664 #endif
1665 #ifndef ASSERT
1666 #define ASSERT NOBUG_ASSERT
1667 #endif
1668 #ifndef ASSERT_IF
1669 #define ASSERT_IF NOBUG_ASSERT_IF
1670 #endif
1671 #ifndef CHECK
1672 #define CHECK NOBUG_CHECK
1673 #endif
1674 #ifndef CHECK
1675 #define CHECK NOBUG_CHECK
1676 #endif
1677 #ifndef INVARIANT
1678 #define INVARIANT NOBUG_INVARIANT
1679 #endif
1680 #ifndef INVARIANT_IF
1681 #define INVARIANT_IF NOBUG_INVARIANT_IF
1682 #endif
1683 #ifndef INVARIANT_ASSERT
1684 #define INVARIANT_ASSERT NOBUG_INVARIANT_ASSERT
1685 #endif
1686 #ifndef DUMP
1687 #define DUMP NOBUG_DUMP
1688 #endif
1689 #ifndef DUMP_IF
1690 #define DUMP_IF NOBUG_DUMP_IF
1691 #endif
1692 #ifndef DUMP_LOG
1693 #define DUMP_LOG NOBUG_DUMP_LOG
1694 #endif
1695 #ifndef DUMP_LOG_IF
1696 #define DUMP_LOG_IF NOBUG_DUMP_LOG_IF
1697 #endif
1698 #ifndef LOG
1699 #define LOG NOBUG_LOG
1700 #endif
1701 #ifndef LOG_IF
1702 #define LOG_IF NOBUG_LOG_IF
1703 #endif
1704 #ifndef ECHO
1705 #define ECHO NOBUG_ECHO
1706 #endif
1707 #ifndef ALERT
1708 #define ALERT NOBUG_ALERT
1709 #endif
1710 #ifndef ALERT_IF
1711 #define ALERT_IF NOBUG_ALERT_IF
1712 #endif
1713 #ifndef CRITICAL
1714 #define CRITICAL NOBUG_CRITICAL
1715 #endif
1716 #ifndef CRITICAL_IF
1717 #define CRITICAL_IF NOBUG_CRITICAL_IF
1718 #endif
1719 #ifndef ERROR
1720 #define ERROR NOBUG_ERROR
1721 #endif
1722 #ifndef ERROR_IF
1723 #define ERROR_IF NOBUG_ERROR_IF
1724 #endif
1725 #ifndef WARN
1726 #define WARN NOBUG_WARN
1727 #endif
1728 #ifndef WARN_IF
1729 #define WARN_IF NOBUG_WARN_IF
1730 #endif
1731 #ifndef INFO
1732 #define INFO NOBUG_INFO
1733 #endif
1734 #ifndef INFO_IF
1735 #define INFO_IF NOBUG_INFO_IF
1736 #endif
1737 #ifndef NOTICE
1738 #define NOTICE NOBUG_NOTICE
1739 #endif
1740 #ifndef NOTICE_IF
1741 #define NOTICE_IF NOBUG_NOTICE_IF
1742 #endif
1743 #ifndef TRACE
1744 #define TRACE NOBUG_TRACE
1745 #endif
1746 #ifndef TRACE_IF
1747 #define TRACE_IF NOBUG_TRACE_IF
1748 #endif
1749 #ifndef BACKTRACE
1750 #define BACKTRACE NOBUG_BACKTRACE
1751 #endif
1752 #ifndef DEPRECATED
1753 #define DEPRECATED NOBUG_DEPRECATED
1754 #endif
1755 #ifndef UNIMPLEMENTED
1756 #define UNIMPLEMENTED NOBUG_UNIMPLEMENTED
1757 #endif
1758 #ifndef FIXME
1759 #define FIXME NOBUG_FIXME
1760 #endif
1761 #ifndef TODO
1762 #define TODO NOBUG_TODO
1763 #endif
1764 #ifndef PLANNED
1765 #define PLANNED NOBUG_PLANNED
1766 #endif
1767 #ifndef NOTREACHED
1768 #define NOTREACHED NOBUG_NOTREACHED
1769 #endif
1770 #ifndef ELSE_NOTREACHED
1771 #define ELSE_NOTREACHED NOBUG_ELSE_NOTREACHED
1772 #endif
1773 #ifndef INJECT_GOODBAD
1774 #define INJECT_GOODBAD NOBUG_INJECT_GOODBAD
1775 #endif
1776 #ifndef INJECT_FAULT
1777 #define INJECT_FAULT NOBUG_INJECT_FAULT
1778 #endif
1779 #ifndef CLEANUP
1780 #define CLEANUP NOBUG_CLEANUP
1781 #endif
1782 #ifndef CHECKED
1783 #define CHECKED NOBUG_CHECKED
1784 #endif
1785 #ifndef UNCHECKED
1786 #define UNCHECKED NOBUG_UNCHECKED
1787 #endif
1788 #ifndef RESOURCE_ANNOUNCE
1789 #define RESOURCE_ANNOUNCE NOBUG_RESOURCE_ANNOUNCE
1790 #endif
1791 #ifndef RESOURCE_FORGET
1792 #define RESOURCE_FORGET NOBUG_RESOURCE_FORGET
1793 #endif
1794 #ifndef RESOURCE_ENTER
1795 #define RESOURCE_ENTER NOBUG_RESOURCE_ENTER
1796 #endif
1797 #ifndef RESOURCE_WAIT
1798 #define RESOURCE_WAIT NOBUG_RESOURCE_WAIT
1799 #endif
1800 #ifndef RESOURCE_TRY
1801 #define RESOURCE_TRY NOBUG_RESOURCE_TRY
1802 #endif
1803 #ifndef RESOURCE_STATE
1804 #define RESOURCE_STATE NOBUG_RESOURCE_STATE
1805 #endif
1806 #ifndef RESOURCE_LEAVE
1807 #define RESOURCE_LEAVE NOBUG_RESOURCE_LEAVE
1808 #endif
1809 #ifndef RESOURCE_LEAVE_LOOKUP
1810 #define RESOURCE_LEAVE_LOOKUP NOBUG_RESOURCE_LEAVE_LOOKUP
1811 #endif
1812 #ifndef RESOURCE_HANDLE
1813 #define RESOURCE_HANDLE NOBUG_RESOURCE_HANDLE
1814 #endif
1815 #ifndef RESOURCE_HANDLE_INIT
1816 #define RESOURCE_HANDLE_INIT NOBUG_RESOURCE_HANDLE_INIT
1817 #endif
1818 #ifndef RESOURCE_USER
1819 #define RESOURCE_USER NOBUG_RESOURCE_USER
1820 #endif
1821 #ifndef RESOURCE_ASSERT_STATE
1822 #define RESOURCE_ASSERT_STATE NOBUG_RESOURCE_ASSERT_STATE
1823 #endif
1824 #ifndef RESOURCE_ASSERT_STATE_IF
1825 #define RESOURCE_ASSERT_STATE_IF NOBUG_RESOURCE_ASSERT_STATE_IF
1826 #endif
1827 #ifndef RESOURCE_USER_INIT
1828 #define RESOURCE_USER_INIT NOBUG_RESOURCE_USER_INIT
1829 #endif
1830 #ifndef RESOURCE_DUMP
1831 #define RESOURCE_DUMP NOBUG_RESOURCE_DUMP
1832 #endif
1833 #ifndef RESOURCE_DUMP_IF
1834 #define RESOURCE_DUMP_IF NOBUG_RESOURCE_DUMP_IF
1835 #endif
1836 #ifndef RESOURCE_DUMPALL
1837 #define RESOURCE_DUMPALL NOBUG_RESOURCE_DUMPALL
1838 #endif
1839 #ifndef RESOURCE_DUMPALL_IF
1840 #define RESOURCE_DUMPALL_IF NOBUG_RESOURCE_DUMPALL_IF
1841 #endif
1842 #ifndef RESOURCE_LIST
1843 #define RESOURCE_LIST NOBUG_RESOURCE_LIST
1844 #endif
1845 #ifndef RESOURCE_LIST_IF
1846 #define RESOURCE_LIST_IF NOBUG_RESOURCE_LIST_IF
1847 #endif
1848 #endif /* NOBUG_DISABLE_SHORTNAMES */
1849
1850
1851 /*
1852 Tool macros
1853 */
1854 #ifdef __GNUC__
1855 #define NOBUG_CLEANUP(fn) NOBUG_IF_ALPHA(__attribute__((cleanup(fn))))
1856 #define NOBUG_ATTR_PRINTF(fmt, ell) __attribute__ ((format (printf, fmt, ell)))
1857 #else
1858 #define NOBUG_CLEANUP(fn)
1859 #define NOBUG_ATTR_PRINTF(fmt, ell)
1860 #endif
1861
1862 /*
1863 //toolmacros PARA NOBUG_ALPHA_COMMA; NOBUG_ALPHA_COMMA; append something after a comma in *ALPHA* builds
1864 //toolmacros NOBUG_ALPHA_COMMA(something)
1865 //toolmacros NOBUG_ALPHA_COMMA_NULL
1866 //toolmacros
1867 //toolmacros Sometimes it is useful to have initializer code only in *ALPHA* builds, for example when you
1868 //toolmacros conditionally include resource handles only in *ALPHA* versions. An initializer can then
1869 //toolmacros use this macros to append a comman and something else only in *ALPHA* builds as in:
1870 //toolmacros struct foo = {"foo", "bar" NOBUG_ALPHA_COMMA_NULL };
1871 //toolmacros
1872 */
1873 #define NOBUG_COMMA ,
1874 #define NOBUG_ALPHA_COMMA(something) NOBUG_IF_ALPHA(NOBUG_COMMA something)
1875 #define NOBUG_ALPHA_COMMA_NULL NOBUG_ALPHA_COMMA(NULL)
1876
1877 #define NOBUG_ONCE(code) \
1878 do { \
1879 static volatile int NOBUG_CAT(nobug_once_,__LINE__) = 1; \
1880 if (NOBUG_EXPECT_FALSE(NOBUG_CAT(nobug_once_,__LINE__))) \
1881 { \
1882 NOBUG_CAT(nobug_once_,__LINE__) = 0; \
1883 code; \
1884 } \
1885 } while (0)
1886
1887 #if __GNUC__
1888 #define NOBUG_EXPECT_FALSE(x) __builtin_expect(!!(x),0)
1889 #else
1890 #define NOBUG_EXPECT_FALSE(x) x
1891 #endif
1892
1893 #define NOBUG_WHEN(when, ...) \
1894 do{ if (NOBUG_EXPECT_FALSE(when)){ __VA_ARGS__;}} while(0)
1895
1896 /*
1897 //toolmacros PARA NOBUG_IF_*; NOBUG_IF; include code conditionally on build level
1898 //toolmacros NOBUG_IF_ALPHA(...)
1899 //toolmacros NOBUG_IF_NOT_ALPHA(...)
1900 //toolmacros NOBUG_IF_BETA(...)
1901 //toolmacros NOBUG_IF_NOT_BETA(...)
1902 //toolmacros NOBUG_IF_RELEASE(...)
1903 //toolmacros NOBUG_IF_NOT_RELEASE(...)
1904 //toolmacros
1905 //toolmacros This macros allow one to conditionally include the code in '(...)' only if the
1906 //toolmacros criteria on the build level is met. If not, nothing gets substituted. Mostly used
1907 //toolmacros internally, but can also be used for custom things.
1908 //toolmacros
1909 */
1910 #define NOBUG_IF_ALPHA(...) \
1911 NOBUG_IF(NOBUG_MODE_ALPHA, __VA_ARGS__) \
1912
1913 #define NOBUG_IF_NOT_ALPHA(...) \
1914 NOBUG_IFNOT(NOBUG_MODE_ALPHA, __VA_ARGS__) \
1915
1916 #define NOBUG_IF_BETA(...) \
1917 NOBUG_IF(NOBUG_MODE_BETA, __VA_ARGS__) \
1918
1919 #define NOBUG_IF_NOT_BETA(...) \
1920 NOBUG_IFNOT(NOBUG_MODE_BETA, __VA_ARGS__) \
1921
1922 #define NOBUG_IF_RELEASE(...) \
1923 NOBUG_IF(NOBUG_MODE_RELEASE, __VA_ARGS__) \
1924
1925 #define NOBUG_IF_NOT_RELEASE(...) \
1926 NOBUG_IFNOT(NOBUG_MODE_RELEASE, __VA_ARGS__) \
1927
1928 /*
1929 preprocessor hacks/metaprogramming
1930 */
1931
1932 #define NOBUG_IF(bool, ...) NOBUG_CAT(NOBUG_IF_,bool)(__VA_ARGS__)
1933 #define NOBUG_IF_1(...) __VA_ARGS__
1934 #define NOBUG_IF_0(...)
1935
1936 #define NOBUG_IFNOT(bool, ...) NOBUG_CAT(NOBUG_IF_, NOBUG_NOT(bool))(__VA_ARGS__)
1937
1938 #define NOBUG_NOT(bool) NOBUG_CAT(NOBUG_NOT_, bool)
1939 #define NOBUG_NOT_1 0
1940 #define NOBUG_NOT_0 1
1941
1942 #define NOBUG_AND(a,b) NOBUG_CAT3(NOBUG_AND_, a, b)
1943 #define NOBUG_AND_00 0
1944 #define NOBUG_AND_01 0
1945 #define NOBUG_AND_10 0
1946 #define NOBUG_AND_11 1
1947
1948 #define NOBUG_OR(a,b) NOBUG_CAT3(NOBUG_OR_, a, b)
1949 #define NOBUG_OR_00 0
1950 #define NOBUG_OR_01 1
1951 #define NOBUG_OR_10 1
1952 #define NOBUG_OR_11 1
1953
1954 #define NOBUG_XOR(a,b) NOBUG_CAT( NOBUG_XOR_, NOBUG_CAT(a,b))
1955 #define NOBUG_XOR_00 0
1956 #define NOBUG_XOR_01 1
1957 #define NOBUG_XOR_10 1
1958 #define NOBUG_XOR_11 0
1959
1960 #define NOBUG_CAT(a,b) NOBUG_CAT_(a,b)
1961 #define NOBUG_CAT_(a,b) a##b
1962
1963 #define NOBUG_CAT3(a,b,c) NOBUG_CAT3_(a,b,c)
1964 #define NOBUG_CAT3_(a,b,c) a##b##c
1965
1966 #define NOBUG_STRINGIZE(s) NOBUG_STRINGIZE_(s)
1967 #define NOBUG_STRINGIZE_(s) #s
1968
1969
1970 /*
1971 LIBNOBUG DECLARATIONS
1972 */
1973 #ifdef __cplusplus
1974 extern "C" {
1975 #elif 0
1976 } /* fix emacs indent */
1977 #endif
1978
1979 #ifndef LLIST_DEFINED
1980 #define LLIST_DEFINED
1981 struct llist_struct
1982 {
1983 struct llist_struct *next;
1984 struct llist_struct *prev;
1985 };
1986 #endif
1987
1988 /*
1989 source context
1990 */
1991
1992 struct nobug_context
1993 {
1994 const char* file;
1995 int line;
1996 const char* func;
1997 };
1998
1999 const char*
2000 nobug_basename (const char* const file);
2001
2002 /*
2003 envvar control
2004 */
2005 enum nobug_log_targets
2006 {
2007 NOBUG_TARGET_RINGBUFFER,
2008 NOBUG_TARGET_CONSOLE,
2009 NOBUG_TARGET_FILE,
2010 NOBUG_TARGET_SYSLOG,
2011 NOBUG_TARGET_APPLICATION
2012 };
2013
2014 struct nobug_flag
2015 {
2016 const char* name;
2017 struct nobug_flag* parent;
2018 volatile int initialized;
2019 int limits[5];
2020 struct nobug_ringbuffer* ringbuffer_target;
2021 FILE* console_target;
2022 FILE* file_target;
2023 };
2024
2025 int
2026 nobug_env_parse_flag (const char* env, struct nobug_flag* flag, int default_target, int default_limit, const struct nobug_context context);
2027
2028 int
2029 nobug_env_init_flag (struct nobug_flag* flag, int default_target, int default_limit, const struct nobug_context context);
2030
2031
2032 /*
2033 ringbuffer
2034 */
2035 struct nobug_ringbuffer
2036 {
2037 struct llist_struct node; /* all ringbufers are chained together, needed for sync */
2038 char* pos;
2039 char* start;
2040 size_t size;
2041 size_t guard;
2042 char name[256];
2043 };
2044
2045 enum nobug_ringbuffer_flags
2046 {
2047 NOBUG_RINGBUFFER_DEFAULT, /* Default is to overwrite file and delete it on nobug_ringbuffer_destroy */
2048 NOBUG_RINGBUFFER_APPEND = 1, /* use existing backing file, append if possible */
2049 NOBUG_RINGBUFFER_TEMP = 2, /* unlink file instantly */
2050 NOBUG_RINGBUFFER_KEEP = 4 /* dont unlink the file at destroy */
2051 };
2052 /*
2053 Note: some flags conflict (TEMP with KEEP) nobug_ringbuffer will not error on these but continue gracefully
2054 with sane (but undefined) semantics.
2055 */
2056
2057 struct nobug_ringbuffer*
2058 nobug_ringbuffer_init (struct nobug_ringbuffer* self, size_t size,
2059 size_t guard, const char * name, int flags);
2060
2061 struct nobug_ringbuffer*
2062 nobug_ringbuffer_new (size_t size, size_t guard, const char * name, int flags);
2063
2064 struct nobug_ringbuffer*
2065 nobug_ringbuffer_destroy (struct nobug_ringbuffer* self);
2066
2067 void
2068 nobug_ringbuffer_delete (struct nobug_ringbuffer* self);
2069
2070 void
2071 nobug_ringbuffer_sync (struct nobug_ringbuffer* self);
2072
2073 void
2074 nobug_ringbuffer_allsync (void);
2075
2076 int
2077 nobug_ringbuffer_vprintf (struct nobug_ringbuffer* self, const char* fmt, va_list ap);
2078
2079 int
2080 nobug_ringbuffer_printf (struct nobug_ringbuffer* self, const char* fmt, ...);
2081
2082 char*
2083 nobug_ringbuffer_append (struct nobug_ringbuffer* self);
2084
2085 int
2086 nobug_ringbuffer_extend (struct nobug_ringbuffer* self, size_t newsize, const char fill);
2087
2088 char*
2089 nobug_ringbuffer_prev (struct nobug_ringbuffer* self, char* pos);
2090
2091 char*
2092 nobug_ringbuffer_next (struct nobug_ringbuffer* self, char* pos);
2093
2094 int
2095 nobug_ringbuffer_save (struct nobug_ringbuffer* self, FILE* out);
2096
2097 int
2098 nobug_ringbuffer_load (struct nobug_ringbuffer* self, FILE* in);
2099
2100 char*
2101 nobug_ringbuffer_pos (struct nobug_ringbuffer* self);
2102
2103 void
2104 nobug_ringbuffer_pop (struct nobug_ringbuffer* self);
2105
2106
2107 /*
2108 multithreading extras
2109 */
2110 #if NOBUG_USE_PTHREAD
2111
2112 struct nobug_tls_data
2113 {
2114 const char* thread_id;
2115 unsigned thread_num; /* thread counter at initialization, gives a unique thread number */
2116 unsigned thread_gen; /* incremented at each name reset, (currently unused) */
2117 void* data;
2118 struct llist_struct res_stack; /* resources of this thread */
2119 };
2120
2121 extern pthread_key_t nobug_tls_key;
2122
2123 struct nobug_tls_data*
2124 nobug_thread_set (const char* name);
2125
2126 struct nobug_tls_data*
2127 nobug_thread_get (void);
2128
2129 const char*
2130 nobug_thread_id_set (const char* name);
2131
2132 const char*
2133 nobug_thread_id_get (void);
2134
2135 extern pthread_mutex_t nobug_logging_mutex;
2136 extern pthread_mutex_t nobug_resource_mutex;
2137 #endif
2138
2139 void**
2140 nobug_thread_data (void);
2141
2142 /*
2143 resource registry
2144 */
2145
2146 #if NOBUG_USE_PTHREAD
2147 #define NOBUG_RESOURCE_LOCK pthread_mutex_lock (&nobug_resource_mutex)
2148 #define NOBUG_RESOURCE_UNLOCK pthread_mutex_unlock (&nobug_resource_mutex)
2149 #define NOBUG_LOGGING_LOCK pthread_mutex_lock (&nobug_logging_mutex)
2150 #define NOBUG_LOGGING_UNLOCK pthread_mutex_unlock (&nobug_logging_mutex)
2151 #else
2152 #define NOBUG_RESOURCE_LOCK
2153 #define NOBUG_RESOURCE_UNLOCK
2154 #define NOBUG_LOGGING_LOCK
2155 #define NOBUG_LOGGING_UNLOCK
2156 #endif
2157
2158 enum nobug_resource_state
2159 {
2160 NOBUG_RESOURCE_INVALID,
2161 NOBUG_RESOURCE_WAITING,
2162 NOBUG_RESOURCE_TRYING,
2163 NOBUG_RESOURCE_EXCLUSIVE,
2164 NOBUG_RESOURCE_RECURSIVE,
2165 NOBUG_RESOURCE_SHARED
2166 };
2167
2168
2169 struct nobug_resource_header
2170 {
2171 struct llist_struct node; /* link node for resource registry or users */
2172 const char* name; /* name */
2173 struct nobug_context extra; /* context information */
2174 };
2175
2176 struct nobug_resource_node;
2177 struct nobug_resource_user;
2178
2179 struct nobug_resource_record
2180 {
2181 struct nobug_resource_header hdr;
2182
2183 struct llist_struct users; /* list of users of this resource */
2184 const void* object_id; /* unique identifer, usually a this pointer or similar */
2185 const char* type; /* type */
2186
2187 #if NOBUG_USE_PTHREAD
2188 struct llist_struct nodes;
2189 #endif
2190 };
2191
2192
2193 struct nobug_resource_node
2194 {
2195 struct llist_struct node; /* all nodes for one resource */
2196
2197 struct nobug_resource_record* resource; /* backpointer */
2198 struct nobug_resource_node* parent; /* upwards the tree */
2199
2200 struct llist_struct childs; /* down the tree, all nodes pointing to here (TODO make this a slist) */
2201 struct llist_struct cldnode; /* node to accumulate all childrens of a parent (TODO slist) */
2202 };
2203
2204
2205 struct nobug_resource_user
2206 {
2207 struct nobug_resource_header hdr;
2208
2209 struct nobug_resource_node* current; /* this resource */
2210 enum nobug_resource_state state; /* state */
2211
2212 #if NOBUG_USE_PTHREAD
2213 struct nobug_tls_data* thread; /* pointer to this theads id */
2214 struct llist_struct res_stack; /* resources of this thread */
2215 #endif
2216 };
2217
2218
2219 extern const char* nobug_resource_error;
2220
2221 extern const char* nobug_resource_states[];
2222
2223
2224 void
2225 nobug_resource_init (void);
2226
2227 void
2228 nobug_resource_destroy (void);
2229
2230
2231 struct nobug_resource_record*
2232 nobug_resource_announce (const char* type, const char* name, const void* object_id, const struct nobug_context extra);
2233
2234 int
2235 nobug_resource_forget (struct nobug_resource_record* node);
2236
2237
2238 struct nobug_resource_user*
2239 nobug_resource_enter (struct nobug_resource_record* resource,
2240 const char* name,
2241 enum nobug_resource_state state,
2242 const struct nobug_context extra);
2243
2244 int
2245 nobug_resource_leave (struct nobug_resource_user* handle);
2246
2247
2248 unsigned
2249 nobug_resource_record_available (void);
2250
2251
2252 unsigned
2253 nobug_resource_user_available (void);
2254
2255
2256 #if NOBUG_USE_PTHREAD
2257 unsigned
2258 nobug_resource_node_available (void);
2259 #endif
2260
2261
2262 struct nobug_resource_dump_context
2263 {
2264 struct nobug_flag* flag;
2265 int level;
2266 struct nobug_context ctx;
2267 };
2268
2269 enum nobug_resource_state
2270 nobug_resource_mystate (struct nobug_resource_record* res);
2271
2272 void
2273 nobug_resource_dump (struct nobug_resource_record* resource, const struct nobug_resource_dump_context context);
2274
2275 void
2276 nobug_resource_dump_all (const struct nobug_resource_dump_context context);
2277
2278 int
2279 nobug_resource_state (struct nobug_resource_user* resource,
2280 enum nobug_resource_state state);
2281
2282
2283 void
2284 nobug_resource_list (const struct nobug_resource_dump_context context);
2285
2286
2287 /*
2288 global config, data and defaults
2289 */
2290 void nobug_init (const struct nobug_context context);
2291
2292 /*
2293 the destroy function is optional, since nobug should stay alive for the whole application lifetime
2294 (and destroying is global!) it is only provided for the nobug testsuite itself
2295 */
2296 void nobug_destroy (const struct nobug_context context);
2297
2298 void
2299 nobug_backtrace_glibc (const struct nobug_context context);
2300
2301
2302 char*
2303 nobug_log_begin (char* header, struct nobug_flag* flag, const char* what, const struct nobug_context ctx);
2304
2305
2306 void
2307 nobug_log_end (struct nobug_flag* flag, int lvl);
2308
2309
2310 /* must be called inbetween log_begin and log_end */
2311 void
2312 nobug_log_line (char** start, char* header, struct nobug_flag* flag, int lvl, const char* fmt, ...);
2313
2314
2315 void
2316 nobug_log (struct nobug_flag* flag, int lvl, const char* what,
2317 const struct nobug_context ctx,
2318 const char* fmt, ...) NOBUG_ATTR_PRINTF(5, 6);
2319
2320
2321 extern struct nobug_ringbuffer nobug_default_ringbuffer;
2322 extern FILE* nobug_default_file;
2323 extern struct nobug_flag nobug_flag_NOBUG_ON;
2324 extern struct nobug_flag nobug_flag_NOBUG_ANN;
2325 extern struct nobug_flag nobug_flag_nobug;
2326 extern unsigned long long nobug_counter;
2327
2328 //callbacks HEAD- Callbacks;;
2329 //callbacks
2330 //callbacks NoBug provides callbacks, applications can use these
2331 //callbacks to present logging information in some custom way or hook some special processing in.
2332 //callbacks The callbacks are initialized to NULL and never modified by NoBug, its the solve responsibility
2333 //callbacks of the user to manage them.
2334 //callbacks
2335 //callbacks CAUTION: There are certain constraints what and what not can be done in callbacks
2336 //callbacks documented below which must be followed.
2337 //callbacks
2338 //callbacks PARA type of logging callbacks; logging_cb; type of a logging callback function
2339 typedef void (*nobug_logging_cb)(const struct nobug_flag* flag, int priority, const char *log, void* data); //callbacks VERBATIM;
2340 //callbacks
2341 //callbacks used for the logging callbacks
2342 //callbacks
2343 //callbacks `flag`::
2344 //callbacks Flag structure which defines the logging configuration for this event
2345 //callbacks `priority`::
2346 //callbacks Log level of the current event
2347 //callbacks `log`::
2348 //callbacks Pointing to the current log line in the ringbuffer or `NULL`
2349 //callbacks `data`::
2350 //callbacks Global pointer defined by the user, passed arround (see below)
2351 //callbacks
2352
2353 //callbacks PARA type of abort callback; abort_cb; type of a abort callback function
2354 typedef void (*nobug_abort_cb)(void* data); //callbacks VERBATIM;
2355 //callbacks
2356 //callbacks used for the abort callback
2357 //callbacks
2358 //callbacks `data`::
2359 //callbacks Global data defined by the user, passed arround (see below)
2360 //callbacks
2361
2362 //callbacks PARA passing data to callbacks; callback_data; data to be passed to callbacks
2363 extern
2364 void* nobug_callback_data; //callbacks VERBATIM;
2365 //callbacks
2366 //callbacks This global variable is initialized to `NULL` and will never be touched by NoBug. One can use it
2367 //callbacks to pass extra data to the callback functions.
2368 //callbacks
2369
2370 //callbacks PARA callback when logging; logging_callback; hook when something get logged
2371 extern
2372 nobug_logging_cb nobug_logging_callback; //callbacks VERBATIM;
2373 //callbacks
2374 //callbacks This callback gets called when something gets logged.
2375 //callbacks NoBug will still hold its mutexes when calling this hook, calling NoBug logging or resource tracking
2376 //callbacks functions from here recursively will deadlock and must be avoided.
2377 //callbacks The `log` parameter points to the logging message in the ringbuffer.
2378 //callbacks Unlike other logging targets it is not automatically limited to the log level configured
2379 //callbacks in the flag but called unconditionally. The callback should implement its own limiting.
2380 //callbacks
2381 //callbacks When one wants to do complex calls which may include recursion into logging and resource tracking
2382 //callbacks functions, the intended way is to pass contextual information possibly including a __copy__ of the
2383 //callbacks `log` parameter in xref:THREAD_DATA[NOBUG_THREAD_DATA] to the postlogging callback (see below).
2384 //callbacks Other internal NoBug facilties, like the ringbuffer etc, are protected by the mutexes and may be accessed
2385 //callbacks from this function.
2386 //callbacks
2387
2388 //callbacks PARA callback after logging; postlogging_callback; hook after something get logged
2389 extern
2390 nobug_logging_cb nobug_postlogging_callback; //callbacks VERBATIM;
2391 //callbacks
2392 //callbacks This callback gets called after something got logged. The `log` parameter is always NULL and all
2393 //callbacks NoBug mutexes are released. This means that this function may call any complex things, including
2394 //callbacks calling logging and resource tracking, but may not call internal NoBug facilities.
2395 //callbacks Contextual created in the `nobug_logging_callback` and stored in xref:THREAD_DATA[NOBUG_THREAD_DATA] can be
2396 //callbacks retrieved here and may need to be cleaned up here.
2397 //callbacks
2398
2399 //callbacks PARA callback for aborting; abort_callback; hook to handle a termination
2400 extern
2401 nobug_abort_cb nobug_abort_callback; //callbacks VERBATIM;
2402 //callbacks
2403 //callbacks This callback gets called when the application shall be terminated due an error.
2404 //callbacks It can be used to hook exceptions or similar things in. When it returns, `abort()`
2405 //callbacks is called.
2406 //callbacks
2407 //callbacks IMPORTANT: Errors detected by NoBug are always fatal. If one handles and possible
2408 //callbacks throws an exception here, the application must shut down as soon as possible.
2409 //callbacks Most causes for aborts are optimitzed out in `RELEASE` builds.
2410 //callbacks
2411
2412 #ifdef __cplusplus
2413 } /* extern "C" */
2414 #endif
2415
2416 #ifndef NOBUG_LIBNOBUG_C
2417
2418 /*
2419 tag this translation unit as unchecked in ALPHA and BETA builds
2420 */
2421 NOBUG_IF_NOT_RELEASE(NOBUG_UNCHECKED);
2422
2423 #else
2424 /* some configuration when compiling nobug */
2425 /* Maximal length of a log line header (silently truncated if exceed) */
2426 #define NOBUG_MAX_LOG_HEADER_SIZE 128
2427 /* Maximal linebreaks in a single logging instruction which get translated to multiple lines */
2428 #define NOBUG_MAX_LOG_LINES 32
2429
2430 #endif /* NOBUG_LIBNOBUG_C */
2431 #endif
Nobug debugging library