| blob | a16865c242adc6c815009e1e48b400833c358040 |
1 /*
2 This file is part of the NoBug debugging library.
4 Copyright (C)
5 2006, 2007, 2008, 2009, Christian Thaeter <ct@pipapo.org>
6 2010, Christian Thaeter <ct@pipapo.org>
7 2009, Francois Kubler <ih8tehuman@free.fr>
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.
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.
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
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
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
52 /*
53 HEADERS
54 */
56 #include <syslog.h>
57 #include <stdlib.h>
58 #include <string.h>
59 #include <stdio.h>
60 #include <stdarg.h>
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
71 #if NOBUG_USE_EXECINFO
72 #include <execinfo.h>
73 #endif
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
84 #if NOBUG_USE_VALGRIND
85 #include <valgrind.h>
86 #endif
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
99 #if NOBUG_USE_PTHREAD
100 #include <pthread.h>
101 #endif
104 /*
105 figure out how to find out the current function name, this is compiler and language dependent
106 */
107 #if !defined(NOBUG_FUNC) && defined(__STDC_VERSION__)
108 /* C99 defines __func__ */
109 # if __STDC_VERSION__ >= 199901L
110 # define NOBUG_FUNC __func__
111 # endif
112 #endif
114 #if !defined(NOBUG_FUNC) && defined(__GNUC__)
115 /* the gnu compiler (since 2.x) defines __FUNCTION__ */
116 # if __GNUC__ >= 2
117 # define NOBUG_FUNC __FUNCTION__
118 # endif
119 #endif
121 #if !defined(NOBUG_FUNC) && defined(__SUNPRO_C)
122 /* the sun C compiler defines __FUNCTION__, the version is determined by a sochastic test, please report! */
123 # if __SUNPRO_C >= 0x5100
124 # define NOBUG_FUNC __FUNCTION__
125 # endif
126 #endif
128 /* add more heuristics here... */
131 /* generic fallback, check for some common definitions (its not guranteed that this symbols are preprocessor defines), just some guesswork */
132 #ifndef NOBUG_FUNC
133 # ifdef __func__
134 # define NOBUG_FUNC __func__
135 # elif defined(__FUNCTION__)
136 # define NOBUG_FUNC __FUNCTION__
137 # else
138 /* finally a fallback when nothing found */
140 # endif
141 #endif
144 /*
145 //assertions HEAD- Assertions;;
146 //assertions
147 //assertions PARA CHECK; CHECK; unnconditional assertion for testsuites
148 //assertions CHECK(expr, ...)
149 //assertions CHECK_IF(when, expr, ...)
150 //assertions
151 //assertions This assertion is never optimized out. Its main purpose is for implementing
152 //assertions testsuites where one want to assert tests independent of the build level
153 //assertions
154 */
155 #define NOBUG_CHECK(expr, ...) \
158 #define NOBUG_CHECK_IF(when, expr, ...) \
162 /*
163 //assertions PARA REQUIRE; REQUIRE; preconditions (input parameters)
164 //assertions REQUIRE(expr, ...)
165 //assertions REQUIRE_IF(when, expr, ...)
166 //assertions NOBUG_REQUIRE_CTX(expr, context,...)
167 //assertions NOBUG_REQUIRE_IF_CTX(when, expr, context, ...)
168 //assertions
169 //assertions Precondition (input) check. Use these macros to validate input a
170 //assertions function receives. The checks are enabled in *ALPHA* and *BETA* builds and
171 //assertions optimized out in *RELEASE* builds.
172 //assertions
173 */
174 #define NOBUG_REQUIRE(expr, ...) \
177 #define NOBUG_REQUIRE_CTX(expr, context, ...) \
181 #define NOBUG_REQUIRE_IF(when, expr, context,...) \
184 #define NOBUG_REQUIRE_IF_CTX(when, expr, context,...) \
185 NOBUG_IF_NOT_RELEASE ( \
187 )
190 /*
191 //assertions PARA ENSURE; ENSURE; postconditions (computation outcomes)
192 //assertions ENSURE(expr, ...)
193 //assertions ENSURE_IF(when, expr, ...)
194 //assertions NOBUG_ENSURE_CTX(expr, context, ...)
195 //assertions NOBUG_ENSURE_IF_CTX(when, expr, context, ...)
196 //assertions
197 //assertions Postcondition (progress/output) check. Use these macros to validate the
198 //assertions data a function produces (example: return value). `ENSURE` is enabled
199 //assertions unconditionally in *ALPHA* builds and optimized out in *BETA* builds for
200 //assertions scopes which are tagged as `CHECKED`.
201 //assertions
202 //assertions The `ENSURE_IF` variants are enabled in *ALPHA* and *BETA* builds.
203 //assertions
204 //assertions In *RELEASE* builds this checks are
205 //assertions always optimized out, scopes tagged as `UNCHECKED` are not permitted.
206 //assertions
207 */
208 #define NOBUG_ENSURE(expr, ...) \
211 #define NOBUG_ENSURE_CTX(expr, context, ...) \
214 NOBUG_IF_BETA ( \
215 NOBUG_WHEN (NOBUG_SCOPE_UNCHECKED, \
218 ) \
219 )
222 #define NOBUG_ENSURE_IF(when, expr, ...) \
225 #define NOBUG_ENSURE_IF_CTX(when, expr, context, ...) \
229 /*
230 //assertions PARA ASSERT; ASSERT; generic assertion
231 //assertions ASSERT(expr, ...)
232 //assertions ASSERT_IF(when, expr, ...)
233 //assertions NOBUG_ASSERT_CTX(expr, context, ...)
234 //assertions NOBUG_ASSERT_IF_CTX(when, expr, context, ...)
235 //assertions
236 //assertions Generic check. Use these macros when you want to validate something
237 //assertions which doesn't fall into one of the above categories. A example is when
238 //assertions a library function can return a unexpected result (scanf with syntax
239 //assertions error in the formatstring, when a constant/literal formatstring is
240 //assertions expected). The checks are enabled in *ALPHA* and *BETA* builds and
241 //assertions optimized out in *RELEASE* builds.
242 //assertions
243 */
244 #define NOBUG_ASSERT(expr, ...) \
247 #define NOBUG_ASSERT_CTX(expr, context, ...) \
248 NOBUG_IF_NOT_RELEASE( \
251 )
254 #define NOBUG_ASSERT_IF(when, expr, ...) \
257 #define NOBUG_ASSERT_IF_CTX(when, expr, context, ...) \
261 /*
262 //assertions PARA assert; assert; C standard assertion
263 //assertions assert(expr)
264 //assertions
265 //assertions NoBug overrides the standard `assert` macro, using `NOBUG_ASSERT`.
266 //assertions This is just a compatibility feature, its use is not suggested.
267 //assertions
268 */
269 #undef assert
270 #define assert(expr) NOBUG_ASSERT(expr)
273 /*
274 low level assert
275 */
276 #ifdef __GNUC__
277 #define NOBUG_ASSERT_(expr, what, context, fmt, ...) \
278 NOBUG_WHEN (!(expr), \
279 NOBUG_LOG_( &nobug_flag_NOBUG_ON, LOG_EMERG, \
281 #expr, ## __VA_ARGS__); \
282 NOBUG_BACKTRACE_CTX(context); \
283 NOBUG_ABORT \
284 )
285 #else /* , ## __VA_ARGS__ eating the comma when the arglist is empty is a gcc extension, fallback for other compilers */
286 #define NOBUG_ASSERT_(expr, what, context, ...) \
287 NOBUG_WHEN (!(expr), \
288 NOBUG_LOG_( &nobug_flag_NOBUG_ON, LOG_EMERG, \
289 what, context, \
291 NOBUG_BACKTRACE_CTX(context); \
292 NOBUG_ABORT \
293 )
294 #endif
296 /*
297 //assertions PARA INVARIANT; INVARIANT; validate invariant state
298 //assertions INVARIANT(type, pointer, depth)
299 //assertions INVARIANT_IF(when,type, pointer, depth)
300 //assertions INVARIANT_ASSERT(expr, ...)
301 //assertions
302 //assertions Checking invariants. You can provide more complex checking functions
303 //assertions which test the validity of datastructures. Invariants are only enabled
304 //assertions in *ALPHA* builds for scopes which are not tagged as `CHECKED` and
305 //assertions otherwise optimized out.
306 //assertions
307 //assertions TODO: describe how to create invariant checks
308 //assertions
309 // 'invariant_context' must be passed in
310 */
311 #define NOBUG_INVARIANT(type, pointer, depth, extra) \
312 NOBUG_IF_ALPHA( \
313 NOBUG_WHEN (NOBUG_SCOPE_UNCHECKED, \
314 NOBUG_CAT3(nobug_, type,_invariant)(pointer, depth, \
315 NOBUG_CONTEXT, extra) \
316 ) \
317 )
320 #define NOBUG_INVARIANT_IF(when, type, pointer, depth, extra) \
321 NOBUG_IF_ALPHA( \
322 NOBUG_WHEN (NOBUG_SCOPE_UNCHECKED, \
323 NOBUG_WHEN (when, \
324 NOBUG_CAT3(nobug_, type,_invariant)(pointer, depth, \
325 NOBUG_CONTEXT, \
326 extra) \
327 ) \
328 ))
330 #define NOBUG_INVARIANT_ASSERT(expr, ...) \
334 /*
335 checked/unchecked tagged scopes
336 */
337 #define NOBUG_SCOPE_UNCHECKED NOBUG_CHECKED_VALUE == 0
339 #define NOBUG_CHECKED NOBUG_IF_NOT_RELEASE(enum {NOBUG_CHECKED_VALUE=1})
341 #define NOBUG_UNCHECKED \
342 NOBUG_IF_NOT_RELEASE(enum {NOBUG_CHECKED_VALUE=0}) \
343 NOBUG_IF_RELEASE(NOBUG_UNCHECKED_NOT_ALLOWED_IN_RELEASE_BUILD)
347 /*TODO dump-level for flags instead limits[0]*/
348 /*
349 //dumpmacros PARA DUMP; DUMP; dumping datastructures
350 //dumpmacros DUMP(flag, type, pointer, depth, extra)
351 //dumpmacros DUMP_IF(when, flag, type, pointer, depth, extra)
352 //dumpmacros
353 //dumpmacros This macros call a datastructure dump of the object (`pointer`) in question.
354 //dumpmacros `DUMP` is only available in *ALPHA* and *BETA* builds, `DUMP_IF` is also
355 //dumpmacros enabled for the RELEASE builds.
356 //dumpmacros
357 //dumpmacros `extra` is a void* which is transparently passed around and can be used to
358 //dumpmacros pass some state around. NoBug does not touch it.
359 //dumpmacros
360 */
361 #define NOBUG_DUMP(flag, type, pointer, depth, extra) \
362 NOBUG_IF_NOT_RELEASE( \
363 NOBUG_WHEN (NOBUG_DUMP_LEVEL >= NOBUG_FLAG(flag).limits[NOBUG_LOG_TARGET], \
364 NOBUG_CAT3 (nobug_, type, _dump)(pointer, depth, NOBUG_CONTEXT, extra) \
365 ) \
366 )
368 #define NOBUG_DUMP_IF(when, flag, type, pointer, depth, extra) \
369 NOBUG_WHEN (NOBUG_DUMP_LEVEL >= NOBUG_FLAG(flag).limits[NOBUG_LOG_TARGET] && when, \
370 NOBUG_CAT3 (nobug_, type, _dump)(pointer, depth, NOBUG_CONTEXT, extra) \
371 )
374 /*
375 //dumpmacros PARA DUMP_LOG; DUMP_LOG; logging helper for dumping
376 //dumpmacros DUMP_LOG(...)
377 //dumpmacros DUMP_LOG_IF(when, ...)
378 //dumpmacros
379 //dumpmacros Any output from `DUMP` handlers should be done by these macros.
380 //dumpmacros
381 //dumpmacros Dumping is by default done on level `LOG_DEBUG`, this can be overridden by
382 //dumpmacros defining `NOBUG_DUMP_LEVEL` to some other level.
383 //dumpmacros
384 */
386 #define NOBUG_DUMP_LOG(...) \
387 NOBUG_LOG_( &nobug_flag_NOBUG_ON, NOBUG_DUMP_LEVEL, \
391 #define NOBUG_DUMP_LOG_IF(expr, ...) \
392 NOBUG_WHEN (expr, \
393 NOBUG_LOG_( &nobug_flag_NOBUG_ON, NOBUG_DUMP_LEVEL, \
396 )
399 #ifndef NOBUG_DUMP_LEVEL
400 #define NOBUG_DUMP_LEVEL LOG_DEBUG
401 #endif
403 /*
404 //logmacros HEAD- Logging Macros;;
405 //logmacros
406 //logmacros Logging targets a flag (except for `ECHO`) and is done at a log-level relating to syslog levels.
407 //logmacros
408 //logmacros NOTE: there is no logging macro for `LOG_EMERG`, this is only used by the assertions as fatal message
409 //logmacros
410 //logmacros PARA ECHO; ECHO; unconditional logging for tests
411 //logmacros ECHO(...)
412 //logmacros
413 //logmacros Never optimized out, logs at LOG_NOTICE level. Its main purpose is for implementing
414 //logmacros testsuites where one want to print and log messages independent of the build level
415 //logmacros
416 */
417 #define NOBUG_ECHO(...) \
420 /*
421 //logmacros PARA ALERT; ALERT; about to die
422 //logmacros ALERT(flag, ...)
423 //logmacros ALERT_IF(when, flag, ...)
424 //logmacros NOBUG_ALERT_CTX(flag, context, ...)
425 //logmacros NOBUG_ALERT_IF_CTX(when, flag, context, ...)
426 //logmacros
427 //logmacros This is the most critical condition an application might log. This might be used
428 //logmacros if an error occurs which can not be handled except a safe shutdown for example.
429 //logmacros
430 */
431 #define NOBUG_ALERT(flag, ...) \
434 #define NOBUG_ALERT_IF(expr, flag, ...) \
438 #define NOBUG_ALERT_CTX(flag, context, ...) \
441 #define NOBUG_ALERT_IF_CTX(expr, flag, context, ...) \
446 /*
447 //logmacros PARA CRITICAL; CRITICAL; can not continue
448 //logmacros CRITICAL(flag, ...)
449 //logmacros CRITICAL_IF(when, flag, ...)
450 //logmacros NOBUG_CRITICAL_CTX(flag, context, ...)
451 //logmacros NOBUG_CRITICAL_IF_CTX(when, flag, context, ...)
452 //logmacros
453 //logmacros An error which can not be handled occured but the application does not need to be
454 //logmacros shutdowen, perhaps waiting for an operator to fix the cause.
455 //logmacros
456 */
457 #define NOBUG_CRITICAL(flag, ...) \
460 #define NOBUG_CRITICAL_CTX(flag, context, ...) \
464 #define NOBUG_CRITICAL_IF(expr, flag, ...) \
467 #define NOBUG_CRITICAL_IF_CTX(expr, flag, context, ...) \
471 /*
472 //logmacros PARA ERROR; ERROR; something gone wrong
473 //logmacros ERROR(flag, ...)
474 //logmacros ERROR_IF(when, flag, ...)
475 //logmacros NOBUG_ERROR_CTX(flag, context, ...)
476 //logmacros NOBUG_ERROR_IF_CTX(when, flag, context, ...)
477 //logmacros
478 //logmacros Application takes a error handling brach
479 //logmacros
480 */
481 #define NOBUG_ERROR(flag, ...) \
484 #define NOBUG_ERROR_CTX(flag, context, ...) \
488 #define NOBUG_ERROR_IF(expr, flag, ...) \
491 #define NOBUG_ERROR_IF_CTX(expr, flag, context, ...) \
495 /*
496 //logmacros PARA WARN; WARN; unexpected fixable error
497 //logmacros WARN(flag, ...)
498 //logmacros WARN_IF(when, flag, ...)
499 //logmacros NOBUG_WARN_CTX(flag, context, ...)
500 //logmacros NOBUG_WARN_IF_CTX(when, flag, context, ...)
501 //logmacros
502 //logmacros Rare, handled but unexpected branch
503 //logmacros
504 */
505 #define NOBUG_WARN(flag, ...) \
508 #define NOBUG_WARN_CTX(flag, context, ...) \
512 #define NOBUG_WARN_IF(expr, flag, ...) \
515 #define NOBUG_WARN_IF_CTX(expr, flag, context, ...) \
519 /*
520 //logmacros PARA INFO; INFO; progress message
521 //logmacros INFO(flag, ...)
522 //logmacros INFO_IF(when, flag, ...)
523 //logmacros NOBUG_INFO_CTX(flag, context, ...)
524 //logmacros NOBUG_INFO_IF_CTX(when, flag, context, ...)
525 //logmacros
526 //logmacros Message about program progress
527 //logmacros
528 */
529 #define NOBUG_INFO(flag, ...) \
532 #define NOBUG_INFO_CTX(flag, context, ...) \
536 #define NOBUG_INFO_IF(expr, flag, ...) \
539 #define NOBUG_INFO_IF_CTX(expr, flag, context, ...) \
543 /*
544 //logmacros PARA NOTICE; NOTICE; detailed progress message
545 //logmacros NOTICE(flag, ...)
546 //logmacros NOTICE_IF(when, flag, ...)
547 //logmacros NOBUG_NOTICE_CTX(flag, context, ...)
548 //logmacros NOBUG_NOTICE_IF_CTX(when, flag, context, ...)
549 //logmacros
550 //logmacros More detailed progress message
551 //logmacros
552 */
553 #define NOBUG_NOTICE(flag, ...) \
556 #define NOBUG_NOTICE_CTX(flag, context, ...) \
560 #define NOBUG_NOTICE_IF(expr, flag, ...) \
563 #define NOBUG_NOTICE_IF_CTX(expr, flag, context, ...) \
566 /*
567 //logmacros PARA TRACE; TRACE; debugging level message
568 //logmacros TRACE(flag, ...)
569 //logmacros TRACE_IF(when, flag, ...)
570 //logmacros NOBUG_TRACE_CTX(flag, context, ...)
571 //logmacros NOBUG_TRACE_IF_CTX(when, flag, context, ...)
572 //logmacros
573 //logmacros Very fine grained messages
574 //logmacros
575 //logmacros NOTE: that `TRACE` corresponds to `LOG_DEBUG`, because using `DEBUG` could be ambiguous.
576 //logmacros
577 */
578 #define NOBUG_TRACE(flag, ...) \
581 #define NOBUG_TRACE_CTX(flag, context, ...) \
585 #define NOBUG_TRACE_IF(expr, flag, ...) \
588 #define NOBUG_TRACE_IF_CTX(expr, flag, context, ...) \
592 /*
593 //logmacros PARA LOG; LOG; generic logging
594 //logmacros NOBUG_LOG_CTX(flag, lvl, context, ...)
595 //logmacros NOBUG_LOG_IF_CTX(when, flag, lvl, context, ...)
596 //logmacros
597 //logmacros Generic logging macro which takes the level explicitly,
598 //logmacros avoid this, unless you implement your own logging facilities.
599 //logmacros
600 */
601 #define NOBUG_LOG_CTX(flag, lvl, context, ...) \
605 #define NOBUG_LOG_IF_CTX(expr, flag, lvl, context, ...) \
606 NOBUG_WHEN (expr, \
608 )
611 /*
612 low level logging handler
614 Note: all fmt concatenations use an empty string ""__VA_ARG__
615 except this one which must use a single space " " before __VA_ARGS__ for formatting the log message correctly (and silence a gcc warning)
616 */
617 #define NOBUG_LOG_(flag, lvl, what, context, ...) \
618 NOBUG_WHEN (lvl <= NOBUG_LOG_BASELIMIT && lvl <= (flag)->limits[NOBUG_TARGET_RINGBUFFER], \
620 )
623 #define NOBUG_LVL(lvl) NOBUG_LVL_##lvl
633 /*
634 //logmacros PARA LOG_BASELIMIT; LOG_BASELIMIT; minimum compliled-in logging limit
635 //logmacros NOBUG_LOG_BASELIMIT_ALPHA
636 //logmacros NOBUG_LOG_BASELIMIT_BETA
637 //logmacros NOBUG_LOG_BASELIMIT_RELEASE
638 //logmacros NOBUG_LOG_BASELIMIT
639 //logmacros
640 //logmacros anything more detailed than this base limits will be optimized out.
641 //logmacros This is used to reduce the logging overhead for *RELEASE* builds.
642 //logmacros By default the limit is set to `LOG_DEBUG` for *ALPHA* and *BETA*
643 //logmacros builds, so all logging is retained and `LOG_NOTICE` in *RELEASE*
644 //logmacros builds to log the application progress only coarsely then.
645 //logmacros
646 //logmacros This macros can be defined before including 'nobug.h' to some other
647 //logmacros log level (as defined in 'syslog.h').
648 //logmacros
649 */
650 #ifndef NOBUG_LOG_BASELIMIT_ALPHA
651 #define NOBUG_LOG_BASELIMIT_ALPHA LOG_DEBUG
652 #endif
654 #ifndef NOBUG_LOG_BASELIMIT_BETA
655 #define NOBUG_LOG_BASELIMIT_BETA LOG_DEBUG
656 #endif
658 #ifndef NOBUG_LOG_BASELIMIT_RELEASE
659 #define NOBUG_LOG_BASELIMIT_RELEASE LOG_NOTICE
660 #endif
662 #ifndef NOBUG_LOG_BASELIMIT
663 #define NOBUG_LOG_BASELIMIT \
664 NOBUG_IF_ALPHA(NOBUG_LOG_BASELIMIT_ALPHA) \
665 NOBUG_IF_BETA(NOBUG_LOG_BASELIMIT_BETA) \
666 NOBUG_IF_RELEASE(NOBUG_LOG_BASELIMIT_RELEASE)
667 #endif
670 /*
671 //srccontext HEAD~ Source Contexts; NOBUG_CONTEXT; pass information about the source location
672 //srccontext NOBUG_CONTEXT
673 //srccontext NOBUG_CONTEXT_NOFUNC
674 //srccontext
675 //srccontext NoBug passes information about the source location of a given statement in
676 //srccontext `const struct nobug_context` structures. These can be generated with
677 //srccontext `NOBUG_CONTEXT` or `NOBUG_CONTEXT_NOFUNC`. The later one doesn't define a
678 //srccontext function name and must be used when the function context is not available
679 //srccontext like in static initialization etc..
680 //srccontext
681 */
683 #ifndef __cplusplus
684 #define NOBUG_CONTEXT ((const struct nobug_context){__FILE__, __LINE__, NOBUG_FUNC})
689 #else
691 #define NOBUG_CONTEXT (nobug_context(__FILE__, __LINE__, NOBUG_FUNC))
696 #endif
698 /*
699 //annotations HEAD- Source Annotations;;
700 //annotations
701 //annotations One can tag features as:
702 //annotations
703 */
705 /*
706 alpha beta release
707 DEPRECATED log nothing wont compile
709 //annotations PARA DEPRECATED; DEPRECATED; to be discarded in future
710 //annotations DEPRECATED(...)
711 //annotations
712 //annotations Something which shouldn't be used in future
713 //annotations
714 */
715 #define NOBUG_DEPRECATED(...) \
716 NOBUG_IF_ALPHA(NOBUG_LOG_(&nobug_flag_NOBUG_ANN, LOG_WARN, \
718 ) \
719 NOBUG_IF_RELEASE(NOBUG_DEPRECATED_NOT_ALLOWED_IN_RELEASE_BUILD(__VA_ARGS__))
722 /*
723 alpha beta release
724 UNIMPLEMENTED abort abort wont compile
726 //annotations PARA UNIMPLEMENTED; UNIMPLEMENTED; not yet implemented
727 //annotations UNIMPLEMENTED(...)
728 //annotations
729 //annotations not yet finished feature
730 //annotations
731 */
732 #define NOBUG_UNIMPLEMENTED(...) \
733 NOBUG_IF_NOT_RELEASE ( do { \
734 NOBUG_LOG_ (&nobug_flag_NOBUG_ANN, LOG_EMERG, \
736 NOBUG_ABORT; \
737 } while (0)) \
738 NOBUG_IF_RELEASE( NOBUG_UNIMPLEMENTED_NOT_ALLOWED_IN_RELEASE_BUILD(__VA_ARGS__))
741 /*
742 alpha beta release
743 FIXME log wont compile wont compile
745 //annotations PARA FIXME; FIXME; known bug
746 //annotations FIXME(...)
747 //annotations
748 //annotations known bug to be fixed later
749 //annotations
750 */
751 #define NOBUG_FIXME(...) \
752 NOBUG_IF_ALPHA( NOBUG_ONCE( NOBUG_LOG_(&nobug_flag_NOBUG_ANN, LOG_ALERT, \
754 NOBUG_IF_BETA( NOBUG_FIXME_NOT_ALLOWED_IN_BETA_BUILD(__VA_ARGS__)) \
755 NOBUG_IF_RELEASE( NOBUG_FIXME_NOT_ALLOWED_IN_RELEASE_BUILD(__VA_ARGS__))
758 /*
759 alpha beta release
760 TODO log log wont compile
762 //annotations PARA TODO; TODO; things to be done
763 //annotations TODO(...)
764 //annotations
765 //annotations enhancement to be done soon
766 //annotations
767 */
768 #define NOBUG_TODO(...) \
769 NOBUG_IF_NOT_RELEASE ( \
770 NOBUG_ONCE ( \
771 NOBUG_LOG_( &nobug_flag_NOBUG_ANN, LOG_NOTICE, \
773 )) \
774 NOBUG_IF_RELEASE(NOBUG_TODO_NOT_ALLOWED_IN_RELEASE_BUILD(__VA_ARGS__))
777 /*
778 alpha beta release
779 PLANNED log nothing nothing
781 //annotations PARA PLANNED; PLANNED; ideas for future
782 //annotations PLANNED(...)
783 //annotations
784 //annotations future enhancement
785 //annotations
786 */
787 #define NOBUG_PLANNED(...) \
788 NOBUG_IF_ALPHA( NOBUG_ONCE(NOBUG_LOG_ (&nobug_flag_NOBUG_ANN, LOG_INFO, \
792 /*
793 alpha beta release
794 NOTREACHED abort abort nothing
796 //annotations PARA NOTREACHED; NOTREACHED; code path never taken
797 //annotations NOTREACHED(...)
798 //annotations
799 //annotations used to tag code-path which shall be never executed.
800 //annotations
801 */
802 #define NOBUG_NOTREACHED(...) \
803 NOBUG_IF_NOT_RELEASE( do { \
804 NOBUG_LOG_( &nobug_flag_NOBUG_ANN, LOG_EMERG, \
806 NOBUG_ABORT; \
807 } while (0))
810 /*
811 //annotations PARA ELSE_NOTREACHED; ELSE_NOTREACHED; alternative never taken
812 //annotations ELSE_NOTREACHED(...)
813 //annotations
814 //annotations same as `else NOTREACHED()`, but wholly optimized out in release builds.
815 //annotations
816 */
817 #define NOBUG_ELSE_NOTREACHED(...) \
818 NOBUG_IF_NOT_RELEASE( else do { \
819 NOBUG_LOG_( &nobug_flag_NOBUG_ANN, LOG_EMERG, \
821 NOBUG_ABORT; \
822 } while (0))
825 /*
826 //faultinjection HEAD- Fault injection;;
827 //faultinjection
828 //faultinjection NoBug has some macros which can be used to simulate errorneous behaviour:
829 //faultinjection
830 //faultinjection PARA INJECT_GOODBAD; INJECT_GOODBAD; fault injection expression
831 //faultinjection INJECT_GOODBAD(expr, good, bad)
832 //faultinjection
833 //faultinjection substitutes to an expression and returns good when expr is false and
834 //faultinjection bad when expr is true. In BETA and RELEASE builds 'good' is always returned.
835 //faultinjection
836 */
837 #define NOBUG_INJECT_GOODBAD(expr, good, bad) \
839 NOBUG_IF_NOT_ALPHA(good)
842 /*
843 //faultinjection PARA INJECT_FAULT; INJECT_FAULT; fault injection statement
844 //faultinjection INJECT_FAULT(expr, bad)
845 //faultinjection
846 //faultinjection substitutes to a statement which executes 'bad'
847 //faultinjection when expr is true. Optimitzed out in BETA and RELEASE builds.
848 //faultinjection
849 */
850 #define NOBUG_INJECT_FAULT(expr, bad) \
854 /*
855 //faultinjection PARA INJECT_LEVEL; INJECT_LEVEL; log level for fault injection
856 //faultinjection In both cases, when a fault is injected it will be logged at
857 //faultinjection `NOBUG_INJECT_LEVEL` (default: `LOG_NOTICE`). This can be defined
858 //faultinjection before including 'nobug.h' to override it.
859 //faultinjection
860 */
861 #define NOBUG_INJECT_LOG(msg) \
862 NOBUG_LOG_( &nobug_flag_NOBUG_ON, NOBUG_INJECT_LEVEL, \
864 msg)
867 #ifndef NOBUG_INJECT_LEVEL
868 #define NOBUG_INJECT_LEVEL LOG_NOTICE
869 #endif
872 /*
873 Flag handling
874 */
875 #define NOBUG_FLAG(name) NOBUG_CAT(nobug_flag_, name)
877 #define NOBUG_DECLARE_FLAG(name) extern struct nobug_flag NOBUG_FLAG(name)
880 #define NOBUG_DEFINE_FLAG(name) \
881 NOBUG_FLAG_IF_DECLAREONLY(NOBUG_DECLARE_FLAG(name)) \
882 NOBUG_FLAG_IF_NOT_DECLAREONLY( \
883 struct nobug_flag NOBUG_FLAG(name) = \
884 NOBUG_IF(NOBUG_MODE_ALPHA, {#name, NULL, 0, \
885 {LOG_DEBUG, LOG_INFO, LOG_DEBUG, -1, LOG_INFO}, &nobug_default_ringbuffer, NULL,NULL}) \
886 NOBUG_IF(NOBUG_MODE_BETA, {#name, NULL, 0, \
887 {LOG_INFO, LOG_NOTICE, LOG_NOTICE, LOG_NOTICE, LOG_WARNING}, &nobug_default_ringbuffer, NULL,NULL}) \
888 NOBUG_IF(NOBUG_MODE_RELEASE, {#name, NULL, 0, \
889 {LOG_NOTICE, -1, LOG_WARNING, LOG_WARNING, LOG_ERR}, &nobug_default_ringbuffer, NULL,NULL}) \
890 )
893 #define NOBUG_DEFINE_FLAG_PARENT(name, parent) \
894 NOBUG_FLAG_IF_DECLAREONLY(NOBUG_DECLARE_FLAG(name)) \
895 NOBUG_FLAG_IF_NOT_DECLAREONLY( \
896 NOBUG_DECLARE_FLAG(parent); \
897 struct nobug_flag NOBUG_FLAG(name) = \
898 NOBUG_IF(NOBUG_MODE_ALPHA, {#name, &NOBUG_FLAG(parent), 0, \
899 {LOG_DEBUG, LOG_INFO, LOG_DEBUG, -1, LOG_INFO}, &nobug_default_ringbuffer, NULL,NULL}) \
900 NOBUG_IF(NOBUG_MODE_BETA, {#name, &NOBUG_FLAG(parent), 0, \
901 {LOG_INFO, LOG_NOTICE, LOG_NOTICE, LOG_NOTICE, LOG_WARNING}, &nobug_default_ringbuffer, NULL,NULL}) \
902 NOBUG_IF(NOBUG_MODE_RELEASE, {#name, &NOBUG_FLAG(parent), 0, \
903 {LOG_NOTICE, -1, LOG_WARNING, LOG_WARNING, LOG_ERR}, &nobug_default_ringbuffer, NULL,NULL}) \
904 )
907 #define NOBUG_DEFINE_FLAG_LIMIT(name, limit) \
908 NOBUG_FLAG_IF_DECLAREONLY(NOBUG_DECLARE_FLAG(name)) \
909 NOBUG_FLAG_IF_NOT_DECLAREONLY( \
910 struct nobug_flag NOBUG_FLAG(name) = \
911 NOBUG_IF(NOBUG_MODE_ALPHA, {#name, NULL, 0, \
912 {LOG_DEBUG, limit, LOG_DEBUG, -1, LOG_INFO}, &nobug_default_ringbuffer, NULL,NULL}) \
913 NOBUG_IF(NOBUG_MODE_BETA, {#name, NULL, 0, \
914 {LOG_INFO, LOG_NOTICE, limit, LOG_NOTICE, LOG_WARNING}, &nobug_default_ringbuffer, NULL,NULL}) \
915 NOBUG_IF(NOBUG_MODE_RELEASE, {#name, NULL, 0, \
916 {LOG_NOTICE, -1, LOG_WARNING, limit, LOG_ERR}, &nobug_default_ringbuffer, NULL,NULL}) \
917 )
920 #define NOBUG_DEFINE_FLAG_PARENT_LIMIT(name, parent, limit) \
921 NOBUG_FLAG_IF_DECLAREONLY(NOBUG_DECLARE_FLAG(name)) \
922 NOBUG_FLAG_IF_NOT_DECLAREONLY( \
923 NOBUG_DECLARE_FLAG(parent); \
924 struct nobug_flag NOBUG_FLAG(name) = \
925 NOBUG_IF(NOBUG_MODE_ALPHA, {#name, &NOBUG_FLAG(parent), 0, \
926 {LOG_DEBUG, limit, LOG_DEBUG, -1, LOG_INFO}, &nobug_default_ringbuffer, NULL,NULL}) \
927 NOBUG_IF(NOBUG_MODE_BETA, {#name, &NOBUG_FLAG(parent), 0, \
928 {LOG_INFO, LOG_NOTICE, limit, LOG_NOTICE, LOG_WARNING}, &nobug_default_ringbuffer, NULL,NULL}) \
929 NOBUG_IF(NOBUG_MODE_RELEASE, {#name, &NOBUG_FLAG(parent), 0, \
930 {LOG_NOTICE, -1, LOG_WARNING, limit, LOG_ERR}, &nobug_default_ringbuffer, NULL,NULL}) \
931 )
934 #define NOBUG_INIT_FLAG(name) \
935 nobug_env_init_flag (&NOBUG_FLAG(name), NOBUG_LOG_TARGET, NOBUG_LOG_LIMIT, NOBUG_CONTEXT_NOFUNC)
938 #define NOBUG_INIT_FLAG_LIMIT(name, default) \
939 nobug_env_init_flag (&NOBUG_FLAG(name), NOBUG_LOG_TARGET, default, NOBUG_CONTEXT_NOFUNC)
942 #define NOBUG_CPP_DEFINE_FLAG(name) \
943 NOBUG_FLAG_IF_DECLAREONLY( \
944 NOBUG_DECLARE_FLAG(name); \
945 extern int nobug_cppflag_##name \
946 ) \
947 NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP( \
948 NOBUG_DEFINE_FLAG(name); \
949 int nobug_cppflag_##name = NOBUG_INIT_FLAG(name) \
950 )
953 #define NOBUG_CPP_DEFINE_FLAG_PARENT(name, parent) \
954 NOBUG_FLAG_IF_DECLAREONLY( \
955 NOBUG_DECLARE_FLAG(name); \
956 extern int nobug_cppflag_##name \
957 ) \
958 NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP( \
959 NOBUG_DEFINE_FLAG_PARENT(name, parent); \
960 int nobug_cppflag_##name = NOBUG_INIT_FLAG(name) \
961 )
964 #define NOBUG_CPP_DEFINE_FLAG_LIMIT(name, default) \
965 NOBUG_FLAG_IF_DECLAREONLY( \
966 NOBUG_DECLARE_FLAG(name); \
967 extern int nobug_cppflag_##name \
968 ) \
969 NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP( \
970 NOBUG_DEFINE_FLAG_LIMIT(name, default); \
971 int nobug_cppflag_##name = NOBUG_INIT_FLAG_LIMIT(name, default) \
972 )
975 #define NOBUG_CPP_DEFINE_FLAG_PARENT_LIMIT(name, parent, default) \
976 NOBUG_FLAG_IF_DECLAREONLY( \
977 NOBUG_DECLARE_FLAG(name); \
978 extern int nobug_cppflag_##name \
979 ) \
980 NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP( \
981 NOBUG_DEFINE_FLAG_PARENT_LIMIT(name, parent, default); \
982 int nobug_cppflag_##name = NOBUG_INIT_FLAG_LIMIT(name, default) \
983 )
986 #ifndef NOBUG_DECLARE_ONLY
987 #define NOBUG_DECLARE_ONLY 0
988 #endif
990 #define NOBUG_FLAG_IF_DECLAREONLY(...) \
991 NOBUG_IF(NOBUG_DECLARE_ONLY, __VA_ARGS__)
993 #define NOBUG_FLAG_IF_NOT_DECLAREONLY(...) \
994 NOBUG_IFNOT(NOBUG_DECLARE_ONLY, __VA_ARGS__)
996 #ifdef __cplusplus
997 #define NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP(...) \
998 NOBUG_IFNOT(NOBUG_DECLARE_ONLY, __VA_ARGS__)
999 #else
1000 #define NOBUG_FLAG_IF_NOT_DECLAREONLY_CPP(...) \
1001 NOBUG_IFNOT(NOBUG_DECLARE_ONLY, NOBUG_ERROR_CANT_DEFINE_AUTOINITIALIZED_CPP_FLAGS_IN_C)
1002 #endif
1004 #ifndef NOBUG_LOG_LIMIT_ALPHA
1005 # define NOBUG_LOG_LIMIT_ALPHA LOG_INFO
1006 #endif
1007 #ifndef NOBUG_LOG_LIMIT_BETA
1008 # define NOBUG_LOG_LIMIT_BETA LOG_WARNING
1009 #endif
1010 #ifndef NOBUG_LOG_LIMIT_RELEASE
1011 # define NOBUG_LOG_LIMIT_RELEASE LOG_CRIT
1012 #endif
1014 #ifndef NOBUG_LOG_LIMIT
1015 # define NOBUG_LOG_LIMIT \
1016 NOBUG_IF_ALPHA( NOBUG_LOG_LIMIT_ALPHA) \
1017 NOBUG_IF_BETA( NOBUG_LOG_LIMIT_BETA) \
1018 NOBUG_IF_RELEASE( NOBUG_LOG_LIMIT_RELEASE)
1019 #endif
1021 #ifndef NOBUG_LOG_TARGET_ALPHA
1022 # define NOBUG_LOG_TARGET_ALPHA NOBUG_TARGET_CONSOLE
1023 #endif
1024 #ifndef NOBUG_LOG_TARGET_BETA
1025 # define NOBUG_LOG_TARGET_BETA NOBUG_TARGET_FILE
1026 #endif
1027 #ifndef NOBUG_LOG_TARGET_RELEASE
1028 # define NOBUG_LOG_TARGET_RELEASE NOBUG_TARGET_SYSLOG
1029 #endif
1031 #ifndef NOBUG_LOG_TARGET
1032 # define NOBUG_LOG_TARGET \
1033 NOBUG_IF_ALPHA( NOBUG_LOG_TARGET_ALPHA) \
1034 NOBUG_IF_BETA( NOBUG_LOG_TARGET_BETA) \
1035 NOBUG_IF_RELEASE( NOBUG_LOG_TARGET_RELEASE)
1036 #endif
1038 #define NOBUG_SET_LIMIT(flag, min) \
1039 NOBUG_IF_NOT_RELEASE( NOBUG_FLAG(flag) = (min))
1042 /*
1043 //resourcemacros HEAD~ Resource tracking macros;;
1044 //resourcemacros
1045 //resourcemacros INDEX RESOURCE_LOGGING; RESOURCE_LOGGING; switch resource logging on and off
1046 //resourcemacros INDEX RESOURCE_LOG_LEVEL; RESOURCE_LOG_LEVEL; select the log level for resource logging
1047 //resourcemacros
1048 //resourcemacros Unless the user defines `NOBUG_RESOURCE_LOGGING` to 0 each of the above macros
1049 //resourcemacros will emit a log message at `NOBUG_RESOURCE_LOG_LEVEL` which defaults to
1050 //resourcemacros `LOG_DEBUG`.
1051 //resourcemacros
1052 */
1053 #ifndef NOBUG_RESOURCE_LOGGING
1054 #define NOBUG_RESOURCE_LOGGING 1
1055 #endif
1057 #ifndef NOBUG_RESOURCE_LOG_LEVEL
1058 #define NOBUG_RESOURCE_LOG_LEVEL LOG_DEBUG
1059 #endif
1062 /*
1063 //resourcemacros PARA RESOURCE_HANDLE; RESOURCE_HANDLE; define resource handles
1064 //resourcemacros RESOURCE_HANDLE(name)
1065 //resourcemacros RESOURCE_HANDLE_INIT(name)
1066 //resourcemacros RESOURCE_USER(name)
1067 //resourcemacros RESOURCE_USER_INIT(name)
1068 //resourcemacros
1069 //resourcemacros Define and initialize handles for to track resources.
1070 //resourcemacros
1071 //resourcemacros `name`::
1072 //resourcemacros identifer to be used for the handle
1073 //resourcemacros
1074 //resourcemacros There are two kinds of handles, each resource itself is abstracted with a
1075 //resourcemacros `RESOURCE_HANDLE` and every access to this resources is tracked through a
1076 //resourcemacros `RESOURCE_USER` handle. These macros takes care that the declaration is optimized
1077 //resourcemacros out in the same manner as the rest of the resource tracker would be disabled.
1078 //resourcemacros You can still instantiate handles as `struct nobug_resource_record*` or
1079 //resourcemacros `struct nobug_resource_user*` in structures which must have a constant size
1080 //resourcemacros unconditional of the build level. The two `*_INIT` macros can be used to initialize
1081 //resourcemacros resource handles and are optimized out when the resource tracker gets disabled.
1082 //resourcemacros
1083 */
1084 #define NOBUG_RESOURCE_HANDLE(handle) \
1085 NOBUG_IF_ALPHA(struct nobug_resource_record* handle)
1087 #define NOBUG_RESOURCE_HANDLE_INIT(handle) NOBUG_IF_ALPHA(handle = NULL)
1089 #define NOBUG_RESOURCE_USER(handle) \
1090 NOBUG_IF_ALPHA(struct nobug_resource_user* handle)
1092 #define NOBUG_RESOURCE_USER_INIT(handle) NOBUG_IF_ALPHA(handle = NULL)
1095 /*
1096 //resourcemacros PARA RESOURCE_ANNOUNCE; RESOURCE_ANNOUNCE; publish new resources
1097 //resourcemacros RESOURCE_ANNOUNCE(flag, type, name, identifier, handle)
1098 //resourcemacros NOBUG_RESOURCE_ANNOUNCE_RAW(flagptr, type, name, ptr, handle)
1099 //resourcemacros NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(flagptr, type, name, ptr, handle, context)
1100 //resourcemacros
1101 //resourcemacros Publishes resources.
1102 //resourcemacros
1103 //resourcemacros `flag`::
1104 //resourcemacros the NoBug flag name which turns logging on for this macro
1105 //resourcemacros `type`::
1106 //resourcemacros a string which should denote the domain of the resource,
1107 //resourcemacros examples are "file", "mutex", "lock", "database" and so on
1108 //resourcemacros `name`::
1109 //resourcemacros the actual name of a named resource this as string which
1110 //resourcemacros together with type forms a unique identifier of the resource. `type` and
1111 //resourcemacros `name` must be available through the entire lifetime of the resource, using
1112 //resourcemacros literal strings is recommended
1113 //resourcemacros `identifier`::
1114 //resourcemacros a pointer which should be unique for this resource, any
1115 //resourcemacros kind of pointer will suffice, it is only used for identification. In
1116 //resourcemacros multithreaded applications the thread identifier becomes an additional
1117 //resourcemacros identifier
1118 //resourcemacros `handle`::
1119 //resourcemacros a `NOBUG_RESOURCE_HANDLE` which will be initialized to point to
1120 //resourcemacros the newly created resource.
1121 //resourcemacros
1122 //resourcemacros Resources must be unique, it is a fatal error when a resource it tried to be
1123 //resourcemacros announced more than one time.
1124 //resourcemacros
1125 //resourcemacros 'RESOURCE_ANNOUNCE()' acts like the head of a C loop statement, it ties to the following
1126 //resourcemacros (block-) statement. Leaving and the user defined following statement are atomic.
1127 //resourcemacros This statement must not be left by break, return or any other kind of jump.
1128 //resourcemacros
1129 */
1130 #define NOBUG_RESOURCE_ANNOUNCE(flag, type, name, ptr, handle) \
1131 NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(&NOBUG_FLAG(flag), type, name, ptr, handle, NOBUG_CONTEXT)
1134 #define NOBUG_RESOURCE_ANNOUNCE_RAW(flag, type, name, ptr, handle) \
1135 NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(flag, type, name, ptr, handle, NOBUG_CONTEXT)
1138 #define NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(flag, type, name, ptr, handle, context) \
1139 NOBUG_IF_NOT_RELEASE( for ( \
1140 int NOBUG_CLEANUP(nobug_section_cleaned) section_ = \
1141 ({ \
1143 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1144 NOBUG_LOG_(flag, NOBUG_RESOURCE_LOG_LEVEL, \
1147 NOBUG_IF_ALPHA ( \
1148 NOBUG_RESOURCE_ASSERT_CTX(handle = nobug_resource_announce (type, name, \
1149 (const void*)ptr, \
1150 context), \
1153 ) \
1154 1; \
1155 }); \
1156 section_; \
1157 ({ \
1158 NOBUG_IF_ALPHA (nobug_resource_announce_complete ();) \
1159 section_ = 0; \
1160 })))
1163 /*
1164 //resourcemacros PARA RESOURCE_FORGET; RESOURCE_FORGET; remove resources
1165 //resourcemacros RESOURCE_FORGET(flag, handle)
1166 //resourcemacros NOBUG_RESOURCE_FORGET_RAW(flagptr, handle)
1167 //resourcemacros NOBUG_RESOURCE_FORGET_RAW_CTX(flagptr, handle, context)
1168 //resourcemacros
1169 //resourcemacros Removes resources that have become unavailable from the registry.
1170 //resourcemacros
1171 //resourcemacros `flag`::
1172 //resourcemacros the NoBug flag which turns logging on for this macro
1173 //resourcemacros `handle`::
1174 //resourcemacros the `NOBUG_RESOURCE_HANDLE` used to track this resource
1175 //resourcemacros
1176 //resourcemacros The resource must still exist and no users must be attached to it, else a fatal
1177 //resourcemacros error is raised.
1178 //resourcemacros
1179 //resourcemacros 'RESOURCE_FORGET()' acts like the head of a C loop statement, it ties to the following
1180 //resourcemacros (block-) statement. Leaving and the user defined following statement are atomic.
1181 //resourcemacros This statement must not be left by break, return or any other kind of jump.
1182 //resourcemacros
1183 */
1184 #define NOBUG_RESOURCE_FORGET(flag, handle) \
1185 NOBUG_RESOURCE_FORGET_RAW_CTX(&NOBUG_FLAG(flag), handle, NOBUG_CONTEXT)
1187 #define NOBUG_RESOURCE_FORGET_RAW(flag, handle) \
1188 NOBUG_RESOURCE_FORGET_RAW_CTX(flag, handle, NOBUG_CONTEXT)
1190 #define NOBUG_RESOURCE_FORGET_RAW_CTX(flag, handle, context) \
1191 NOBUG_IF_NOT_RELEASE( for ( \
1192 int NOBUG_CLEANUP(nobug_section_cleaned) section_ = \
1193 ({ \
1194 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1195 NOBUG_LOG_(flag, NOBUG_RESOURCE_LOG_LEVEL, \
1199 (handle)?(handle)->object_id:NULL);) \
1200 1; \
1201 }); \
1202 section_; \
1203 ({ \
1204 NOBUG_IF_ALPHA ( \
1205 NOBUG_RESOURCE_ASSERT_CTX(nobug_resource_forget (handle), \
1209 (handle)?(handle)->object_id:NULL, \
1210 nobug_resource_error); \
1211 handle = NULL;) \
1212 section_ = 0; \
1213 }) \
1214 ))
1217 /*
1218 //resourcemacros PARA RESOURCE_ENTER; RESOURCE_ENTER; claim a resource
1219 //resourcemacros RESOURCE_ENTER(flag, announced, user, state, handle)
1220 //resourcemacros NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, state, handle, context)
1221 //resourcemacros
1222 //resourcemacros Acquire a resource.
1223 //resourcemacros
1224 //resourcemacros `flag`::
1225 //resourcemacros nobug flag which turns logging on for this macro
1226 //resourcemacros `announced`::
1227 //resourcemacros the handle set by `RESOURCE_ANNOUNCE`
1228 //resourcemacros `user`::
1229 //resourcemacros a free-form identifier
1230 //resourcemacros `state`::
1231 //resourcemacros the initial state, one of `NOBUG_RESOURCE_WAITING`, `NOBUG_RESOURCE_TRYING`,
1232 //resourcemacros `NOBUG_RESOURCE_EXCLUSIVE`, `NOBUG_RESOURCE_RECURSIVE` or `NOBUG_RESOURCE_SHARED`
1233 //resourcemacros `handle`::
1234 //resourcemacros a `NOBUG_RESOURCE_HANDLE` which will be initialized to the
1235 //resourcemacros entering node
1236 //resourcemacros
1237 //resourcemacros 'RESOURCE_ENTER()' acts like the head of a C loop statement, it ties to the following
1238 //resourcemacros (block-) statement. Leaving and the user defined following statement are atomic.
1239 //resourcemacros This statement must not be left by break, return or any other kind of jump.
1240 //resourcemacros
1241 */
1242 #define NOBUG_RESOURCE_ENTER(flag, resource, user, state, handle) \
1243 NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, state, handle, NOBUG_CONTEXT)
1246 #define NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, state, handle, context) \
1247 NOBUG_IF_NOT_RELEASE( for ( \
1248 int NOBUG_CLEANUP(nobug_section_cleaned) section_ = \
1249 ({ \
1250 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1251 NOBUG_LOG_(&NOBUG_FLAG(flag), NOBUG_RESOURCE_LOG_LEVEL, \
1256 (resource)?(resource)->object_id:NULL, \
1257 user, \
1258 nobug_resource_states[state]);) \
1259 NOBUG_IF_ALPHA ( \
1260 NOBUG_RESOURCE_ASSERT_CTX(handle = \
1261 nobug_resource_enter (resource, \
1262 user, state, \
1263 context), \
1268 (resource)?(resource)->object_id:NULL, \
1269 user, nobug_resource_states[state], \
1270 nobug_resource_error);) \
1271 1; \
1272 }); \
1273 section_; \
1274 section_ = 0 \
1275 ))
1278 //resourcemacros PARA RESOURCE_WAIT; RESOURCE_WAIT; wait for a resource to become available
1279 //resourcemacros RESOURCE_WAIT(flag, resource, user, handle)
1280 //resourcemacros NOBUG_RESOURCE_WAIT_CTX(flag, resource, user, handle, context)
1281 //resourcemacros
1282 //resourcemacros This is just an alias for RESOURCE_ENTER(flag, resource, user, NOBUG_RESOURCE_WAITING, handle)
1283 //resourcemacros
1284 //resourcemacros .How to use it
1285 //resourcemacros [source,c]
1286 //resourcemacros ----
1287 //resourcemacros RESOURCE_WAIT(flag, resource, user, handle);
1288 //resourcemacros if (lock_my_resource() == ERROR)
1289 //resourcemacros NOBUG_RESOURCE_LEAVE(flag, handle);
1290 //resourcemacros else
1291 //resourcemacros RESOURCE_STATE(flag, NOBUG_RESOURCE_EXCLUSIVE, handle);
1292 //resourcemacros ----
1293 //resourcemacros
1294 #define NOBUG_RESOURCE_WAIT(flag, resource, user, handle) \
1295 NOBUG_RESOURCE_ENTER(flag, resource, user, NOBUG_RESOURCE_WAITING, handle)
1297 #define NOBUG_RESOURCE_WAIT_CTX(flag, resource, user, handle, context) \
1298 NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, NOBUG_RESOURCE_WAITING, handle, context)
1301 //resourcemacros PARA RESOURCE_TRY; RESOURCE_TRY; wait for a resource to become available
1302 //resourcemacros RESOURCE_TRY(flag, resource, user, handle)
1303 //resourcemacros NOBUG_RESOURCE_TRY_CTX(flag, resource, user, handle, context)
1304 //resourcemacros
1305 //resourcemacros This is just an alias for RESOURCE_ENTER(flag, resource, user, NOBUG_RESOURCE_TRYING, handle).
1306 //resourcemacros Trying on a resource is similar to waiting but will not trigger a deadlock check. This can be used
1307 //resourcemacros when a deadlock is expected at runtime and one handles this otherwise (by a timed wait or something like that).
1308 //resourcemacros
1309 #define NOBUG_RESOURCE_TRY(flag, resource, user, handle) \
1310 NOBUG_RESOURCE_ENTER(flag, resource, user, NOBUG_RESOURCE_TRYING, handle)
1312 #define NOBUG_RESOURCE_TRY_CTX(flag, resource, user, handle, context) \
1313 NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, NOBUG_RESOURCE_TRYING, handle, context)
1316 /*
1317 //resourcemacros PARA RESOURCE_STATE; RESOURCE_STATE; change the state of a resource
1318 //resourcemacros RESOURCE_STATE(flag, entered, state)
1319 //resourcemacros NOBUG_RESOURCE_STATE_CTX(flag, state, entered, context)
1320 //resourcemacros NOBUG_RESOURCE_STATE_RAW(flagptr, state, entered)
1321 //resourcemacros NOBUG_RESOURCE_STATE_RAW_CTX(flagptr, nstate, entered, context)
1322 //resourcemacros
1323 //resourcemacros Changes resource's state.
1324 //resourcemacros
1325 //resourcemacros `flag`::
1326 //resourcemacros is nobug flag which turns logging on for this macro
1327 //resourcemacros `state`::
1328 //resourcemacros the new state Note that only certain state transitions are
1329 //resourcemacros allowed, see discussion/diagram above
1330 //resourcemacros `entered`::
1331 //resourcemacros the handle set by `RESOURCE_ENTER`
1332 //resourcemacros
1333 //resourcemacros 'RESOURCE_STATE()' acts like the head of a C loop statement, it ties to the following
1334 //resourcemacros (block-) statement. Leaving and the user defined following statement are atomic.
1335 //resourcemacros This statement must not be left by break, return or any other kind of jump.
1336 //resourcemacros
1337 */
1338 #define NOBUG_RESOURCE_STATE(flag, state, entered) \
1339 NOBUG_RESOURCE_STATE_RAW_CTX(&NOBUG_FLAG(flag), state, entered, NOBUG_CONTEXT)
1341 #define NOBUG_RESOURCE_STATE_CTX(flag, state, entered, context) \
1342 NOBUG_RESOURCE_STATE_RAW_CTX(&NOBUG_FLAG(flag), state, entered, context)
1344 #define NOBUG_RESOURCE_STATE_RAW(flag, state, entered) \
1345 NOBUG_RESOURCE_STATE_RAW_CTX(flag, state, entered, NOBUG_CONTEXT)
1347 #define NOBUG_RESOURCE_STATE_RAW_CTX(flag, nstate, entered, context) \
1348 NOBUG_IF_NOT_RELEASE( for ( \
1349 int NOBUG_CLEANUP(nobug_section_cleaned) section_ = \
1350 ({ \
1351 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1352 NOBUG_LOG_(flag, NOBUG_RESOURCE_LOG_LEVEL, \
1359 nobug_resource_states[(entered)?(entered)->state \
1360 :NOBUG_RESOURCE_INVALID], \
1361 nobug_resource_states[nstate]); \
1362 ) \
1363 NOBUG_IF_ALPHA( \
1364 NOBUG_RESOURCE_ASSERT_CTX(nobug_resource_state ((entered), nstate), \
1371 nobug_resource_states[(entered)?(entered)->state \
1372 :NOBUG_RESOURCE_INVALID], \
1373 nobug_resource_states[nstate], \
1374 nobug_resource_error); \
1375 ) \
1376 1; \
1377 }); \
1378 section_; \
1379 section_ = 0))
1381 /*
1382 //resourcemacros PARA RESOURCE_LEAVE; RESOURCE_LEAVE; relinquish a claimed resource
1383 //resourcemacros RESOURCE_LEAVE(flag, handle){}
1384 //resourcemacros NOBUG_RESOURCE_LEAVE_RAW(flagptr, handle){}
1385 //resourcemacros NOBUG_RESOURCE_LEAVE_RAW_CTX(flagptr, handle, context){}
1386 //resourcemacros
1387 //resourcemacros Disconnect from a resource identified with its handle.
1388 //resourcemacros
1389 //resourcemacros `flag`::
1390 //resourcemacros nobug flag which turns logging on for this macro
1391 //resourcemacros `handle`::
1392 //resourcemacros the handle you got while entering the resource
1393 //resourcemacros
1394 //resourcemacros 'RESOURCE_LEAVE()' acts like the head of a C loop statement, it ties to the following
1395 //resourcemacros (block-) statement. Leaving and the user defined following statement are atomic.
1396 //resourcemacros This statement must not be left by break, return or any other kind of jump.
1397 //resourcemacros
1398 //resourcemacros .How to use it
1399 //resourcemacros [source,c]
1400 //resourcemacros ----
1401 //resourcemacros NOBUG_RESOURCE_LEAVE(flag, handle)
1402 //resourcemacros {
1403 //resourcemacros unlock_my_resource();
1404 //resourcemacros }
1405 //resourcemacros ----
1406 //resourcemacros
1407 */
1408 #define NOBUG_RESOURCE_LEAVE(flag, handle) \
1409 NOBUG_RESOURCE_LEAVE_RAW_CTX(&NOBUG_FLAG(flag), handle, NOBUG_CONTEXT)
1411 #define NOBUG_RESOURCE_LEAVE_RAW(flag, handle) \
1412 NOBUG_RESOURCE_LEAVE_RAW_CTX(flag, handle, NOBUG_CONTEXT)
1414 #define NOBUG_RESOURCE_LEAVE_RAW_CTX(flag, handle, context) \
1415 NOBUG_IF_NOT_RELEASE( \
1416 for ( \
1417 int NOBUG_CLEANUP(nobug_section_cleaned) section_ = ({ \
1418 nobug_resource_leave_pre(); \
1419 1; \
1420 }); \
1421 section_; \
1422 ({ \
1423 NOBUG_IF(NOBUG_RESOURCE_LOGGING, \
1424 NOBUG_LOG_(flag, NOBUG_RESOURCE_LOG_LEVEL, \
1431 nobug_resource_states[(handle)?(handle)->state \
1432 :NOBUG_RESOURCE_INVALID]); \
1433 ) \
1434 NOBUG_IF_ALPHA( \
1435 NOBUG_RESOURCE_ASSERT_CTX(nobug_resource_leave (handle), \
1442 nobug_resource_states[(handle)?(handle)->state \
1443 :NOBUG_RESOURCE_INVALID], \
1444 nobug_resource_error); \
1445 handle = NULL; \
1446 ) \
1447 section_ = 0; \
1448 })))
1450 /*
1451 //resourcemacros PARA RESOURCE_ASSERT_STATE; RESOURCE_ASSERT_STATE; assert the state of a resource
1452 //resourcemacros RESOURCE_ASSERT_STATE(resource, state)
1453 //resourcemacros RESOURCE_ASSERT_STATE_IF(when, resource, state)
1454 //resourcemacros NOBUG_RESOURCE_ASSERT_STATE_CTX(resource, state, context)
1455 //resourcemacros NOBUG_RESOURCE_ASSERT_STATE_IF_CTX(when, resource, state, context)
1456 //resourcemacros
1457 //resourcemacros Assert that we have a resource in a given state. For multithreaded programms the topmost
1458 //resourcemacros state of the calling thread is checked, for non threadeded programs the most recent state on
1459 //resourcemacros resource is used.
1460 //resourcemacros
1461 //resourcemacros `when`::
1462 //resourcemacros Condition which must be true for testing the assertion
1463 //resourcemacros `resource`::
1464 //resourcemacros Resource handle
1465 //resourcemacros `state`::
1466 //resourcemacros The expected state
1467 //resourcemacros
1468 */
1469 #define NOBUG_RESOURCE_ASSERT_STATE(resource, state) \
1470 NOBUG_RESOURCE_ASSERT_STATE_CTX(resource, state, NOBUG_CONTEXT)
1472 #define NOBUG_RESOURCE_ASSERT_STATE_CTX(resource, state, context) \
1473 NOBUG_IF_ALPHA( \
1474 do { \
1475 enum nobug_resource_state mystate = nobug_resource_mystate (resource); \
1476 NOBUG_RESOURCE_ASSERT_CTX(mystate == state, \
1479 resource, nobug_resource_states[mystate], nobug_resource_states[state]); \
1480 } while (0))
1483 #define NOBUG_RESOURCE_ASSERT_STATE_IF(when, resource, state) \
1484 NOBUG_WHEN(when, NOBUG_RESOURCE_ASSERT_STATE (resource, state))
1487 /* assertion which dumps all resources */
1488 #define NOBUG_RESOURCE_ASSERT_CTX(expr, what, context, ...) \
1489 NOBUG_IF_ALPHA( \
1490 NOBUG_WHEN (!(expr), \
1491 NOBUG_LOG_( &nobug_flag_NOBUG_ON, LOG_EMERG, \
1492 what, context, \
1494 nobug_resource_dump_all (NOBUG_RESOURCE_DUMP_CONTEXT( \
1495 &nobug_flag_NOBUG_ON, \
1496 LOG_EMERG, \
1497 context)); \
1498 NOBUG_BACKTRACE_CTX(context); \
1499 NOBUG_ABORT))
1502 /*
1503 //resourcemacros PARA RESOURCE_DUMP; RESOURCE_DUMP; dump the state of a single resource
1504 //resourcemacros NOBUG_RESOURCE_DUMP(flag, handle)
1505 //resourcemacros NOBUG_RESOURCE_DUMP_IF(when, flag, handle)
1506 //resourcemacros
1507 //resourcemacros Dump the state of a single resource.
1508 //resourcemacros
1509 //resourcemacros `when`::
1510 //resourcemacros Condition which must be true to dump the resource
1511 //resourcemacros `flag`::
1512 //resourcemacros Nobug flag for the log channel
1513 //resourcemacros `handle`::
1514 //resourcemacros handle of the resource to be dumped
1515 //resourcemacros
1516 */
1517 #define NOBUG_RESOURCE_DUMP(flag, handle) \
1518 NOBUG_IF_ALPHA( \
1519 do { \
1520 nobug_resource_dump (handle, NOBUG_RESOURCE_DUMP_CONTEXT( \
1521 &NOBUG_FLAG(flag), \
1522 NOBUG_RESOURCE_LOG_LEVEL, \
1523 NOBUG_CONTEXT)); \
1524 } while (0))
1526 #define NOBUG_RESOURCE_DUMP_IF(when, flag, handle) \
1527 NOBUG_IF_ALPHA( \
1528 NOBUG_WHEN(when, \
1529 nobug_resource_dump (handle, NOBUG_RESOURCE_DUMP_CONTEXT( \
1530 &NOBUG_FLAG(flag), \
1531 NOBUG_RESOURCE_LOG_LEVEL, \
1532 NOBUG_CONTEXT)); \
1533 ))
1536 /*
1537 //resourcemacros PARA RESOURCE_DUMPALL; RESOURCE_DUMPALL; dump the state of all resources
1538 //resourcemacros NOBUG_RESOURCE_DUMPALL(flag)
1539 //resourcemacros NOBUG_RESOURCE_DUMPALL_IF(when, flag)
1540 //resourcemacros
1541 //resourcemacros Dump the state of all resources.
1542 //resourcemacros
1543 //resourcemacros `when`::
1544 //resourcemacros Condition which must be true to dump the resources
1545 //resourcemacros `flag`::
1546 //resourcemacros Nobug flag for the log channel
1547 //resourcemacros
1548 */
1549 #define NOBUG_RESOURCE_DUMPALL(flag) \
1550 NOBUG_IF_ALPHA( \
1551 do { \
1552 nobug_resource_dump_all (NOBUG_RESOURCE_DUMP_CONTEXT( \
1553 &NOBUG_FLAG(flag), \
1554 NOBUG_RESOURCE_LOG_LEVEL, \
1555 NOBUG_CONTEXT)); \
1556 } while (0))
1559 #define NOBUG_RESOURCE_DUMPALL_IF(when, flag) \
1560 NOBUG_IF_ALPHA( \
1561 NOBUG_WHEN(when, \
1562 nobug_resource_dump_all (NOBUG_RESOURCE_DUMP_CONTEXT( \
1563 &NOBUG_FLAG(flag), \
1564 NOBUG_RESOURCE_LOG_LEVEL, \
1565 NOBUG_CONTEXT)); \
1566 ))
1568 /*
1569 //resourcemacros PARA RESOURCE_LIST; RESOURCE_LIST; enumerate all registered resources
1570 //resourcemacros NOBUG_RESOURCE_LIST(flag)
1571 //resourcemacros NOBUG_RESOURCE_LIST_IF(when, flag)
1572 //resourcemacros
1573 //resourcemacros List all registered resources.
1574 //resourcemacros
1575 //resourcemacros `when`::
1576 //resourcemacros Condition which must be true to list the resources
1577 //resourcemacros `flag`::
1578 //resourcemacros Nobug flag for the log channel
1579 //resourcemacros
1580 */
1581 #define NOBUG_RESOURCE_LIST(flag) \
1582 NOBUG_IF_ALPHA( \
1583 do { \
1584 nobug_resource_list (NOBUG_RESOURCE_DUMP_CONTEXT( \
1585 &NOBUG_FLAG(flag), \
1586 NOBUG_RESOURCE_LOG_LEVEL, \
1587 NOBUG_CONTEXT)); \
1588 } while (0))
1591 #define NOBUG_RESOURCE_LIST_IF(when, flag) \
1592 NOBUG_IF_ALPHA( \
1593 NOBUG_WHEN(when, \
1594 nobug_resource_list (NOBUG_RESOURCE_DUMP_CONTEXT( \
1595 &NOBUG_FLAG(flag), \
1596 NOBUG_RESOURCE_LOG_LEVEL, \
1597 NOBUG_CONTEXT)); \
1598 ))
1601 /* constructing a resource-dump context */
1602 #ifndef __cplusplus
1603 #define NOBUG_RESOURCE_DUMP_CONTEXT(flag, level, context) \
1604 ((struct nobug_resource_dump_context){ \
1605 flag, \
1606 level, \
1607 context})
1608 #else
1609 #define NOBUG_CONTEXT (nobug_context(__FILE__, __LINE__, NOBUG_FUNC))
1610 #define NOBUG_RESOURCE_DUMP_CONTEXT(flag, level, context) \
1611 (nobug_resource_dump_context(flag, level, context))
1612 #endif
1615 /*
1616 threading support
1617 */
1618 #if NOBUG_USE_PTHREAD
1619 #define NOBUG_THREAD_ID_SET(name) nobug_thread_id_set(name)
1620 #define NOBUG_THREAD_ID_GET nobug_thread_id_get()
1622 #else
1623 #define NOBUG_THREAD_ID_SET(name)
1625 #endif
1627 #define NOBUG_THREAD_DATA (*nobug_thread_data())
1630 /*
1631 Debuggers
1632 */
1634 #define NOBUG_DBG_NONE 0
1635 #define NOBUG_DBG_GDB 1
1636 #define NOBUG_DBG_VALGRIND 2
1638 #define NOBUG_ACTIVE_DBG \
1639 NOBUG_IF(NOBUG_USE_VALGRIND, (RUNNING_ON_VALGRIND?2:0)) \
1640 NOBUG_IFNOT(NOBUG_USE_VALGRIND, 0)
1642 /*
1643 //toolmacros HEAD- Tool Macros;;
1644 //toolmacros
1645 //toolmacros PARA NOBUG_FLAG_RAW; NOBUG_FLAG_RAW; pass direct flag pointer
1646 //toolmacros NOBUG_FLAG_RAW(ptr)
1647 //toolmacros
1648 //toolmacros Using this macro one can pass a direct pointer to a flag where a name would
1649 //toolmacros be expected. This is sometimes convinient when flag pointers are passed around
1650 //toolmacros in management strutures and one wants to tie logging to dynamic targets.
1651 //toolmacros
1652 //toolmacros [source,c]
1653 //toolmacros ----
1654 //toolmacros NOBUG_DEFINE_FLAG(myflag);
1655 //toolmacros ...
1656 //toolmacros struct nobug_flag* ptr = &NOBUG_FLAG(myflag);
1657 //toolmacros TRACE(NOBUG_FLAG_RAW(ptr), "Passed flag by pointer")
1658 //toolmacros ----
1659 //toolmacros
1660 */
1661 #define nobug_flag_NOBUG_FLAG_RAW(name) *name
1663 /*
1664 //toolmacros PARA Backtraces; BACKTRACE; generate a backtrace
1665 //toolmacros BACKTRACE
1666 //toolmacros NOBUG_BACKTRACE_CTX(context)
1667 //toolmacros
1668 //toolmacros The backtrace macro logs a stacktrace using the NoBug facilities.
1669 //toolmacros This is automatically called when NoBug finds an error and is due
1670 //toolmacros to abort. But one might call it manually too.
1671 //toolmacros
1672 */
1673 #define NOBUG_BACKTRACE NOBUG_BACKTRACE_CTX(NOBUG_CONTEXT)
1675 #define NOBUG_BACKTRACE_CTX(context) \
1676 NOBUG_IF_ALPHA( \
1677 switch (NOBUG_ACTIVE_DBG) { \
1678 case NOBUG_DBG_VALGRIND: \
1679 NOBUG_BACKTRACE_VALGRIND(context); \
1680 break; \
1681 default: \
1682 NOBUG_BACKTRACE_GLIBC(context); \
1683 }) \
1684 NOBUG_IF_NOT_ALPHA (NOBUG_BACKTRACE_GLIBC(context))
1686 #define NOBUG_BACKTRACE_GDB(context) UNIMPLEMENTED
1688 #define NOBUG_BACKTRACE_VALGRIND(context) \
1689 NOBUG_IF(NOBUG_USE_VALGRIND, \
1690 nobug_backtrace_valgrind (context) \
1691 )
1694 #ifndef NOBUG_BACKTRACE_DEPTH
1695 #define NOBUG_BACKTRACE_DEPTH 256
1696 #endif
1698 #define NOBUG_BACKTRACE_GLIBC(context) \
1699 NOBUG_IF_NOT_RELEASE( \
1700 NOBUG_IF(NOBUG_USE_EXECINFO, do { \
1701 nobug_backtrace_glibc (context); \
1702 } while (0)))
1705 #ifndef NOBUG_TAB
1707 #endif
1709 //toolmacros PARA Aborting; ABORT; abort the program
1710 //toolmacros NOBUG_ABORT_
1711 //toolmacros
1712 //toolmacros This is the default implementation for aborting the program, it first syncs all ringbuffers to disk, then
1713 //toolmacros calls the abort callback if defined and then `abort()`.
1714 //toolmacros
1715 //toolmacros NOBUG_ABORT
1716 //toolmacros
1717 //toolmacros If not overridden, evaluates to `NOBUG_ABORT_`. One can override this before including
1718 //toolmacros `nobug.h` to customize abortion behaviour. This will be local to the translation unit then.
1719 //toolmacros
1720 #ifndef NOBUG_ABORT
1721 #define NOBUG_ABORT NOBUG_ABORT_
1722 #endif
1724 #define NOBUG_ABORT_ \
1725 do { \
1726 nobug_ringbuffer_allsync (); \
1727 if (nobug_abort_callback) \
1728 nobug_abort_callback (nobug_callback_data); \
1729 abort(); \
1730 } while(0)
1733 /*
1734 init and other function wrapers
1735 */
1736 #define NOBUG_INIT nobug_init(NOBUG_CONTEXT)
1738 /*
1739 short macros without NOBUG_
1740 */
1741 #ifndef NOBUG_DISABLE_SHORTNAMES
1742 #ifndef REQUIRE
1743 #define REQUIRE NOBUG_REQUIRE
1744 #endif
1745 #ifndef REQUIRE_IF
1746 #define REQUIRE_IF NOBUG_REQUIRE_IF
1747 #endif
1748 #ifndef ENSURE
1749 #define ENSURE NOBUG_ENSURE
1750 #endif
1751 #ifndef ENSURE_IF
1752 #define ENSURE_IF NOBUG_ENSURE_IF
1753 #endif
1754 #ifndef ASSERT
1755 #define ASSERT NOBUG_ASSERT
1756 #endif
1757 #ifndef ASSERT_IF
1758 #define ASSERT_IF NOBUG_ASSERT_IF
1759 #endif
1760 #ifndef CHECK
1761 #define CHECK NOBUG_CHECK
1762 #endif
1763 #ifndef CHECK
1764 #define CHECK NOBUG_CHECK
1765 #endif
1766 #ifndef INVARIANT
1767 #define INVARIANT NOBUG_INVARIANT
1768 #endif
1769 #ifndef INVARIANT_IF
1770 #define INVARIANT_IF NOBUG_INVARIANT_IF
1771 #endif
1772 #ifndef INVARIANT_ASSERT
1773 #define INVARIANT_ASSERT NOBUG_INVARIANT_ASSERT
1774 #endif
1775 #ifndef DUMP
1776 #define DUMP NOBUG_DUMP
1777 #endif
1778 #ifndef DUMP_IF
1779 #define DUMP_IF NOBUG_DUMP_IF
1780 #endif
1781 #ifndef DUMP_LOG
1782 #define DUMP_LOG NOBUG_DUMP_LOG
1783 #endif
1784 #ifndef DUMP_LOG_IF
1785 #define DUMP_LOG_IF NOBUG_DUMP_LOG_IF
1786 #endif
1787 #ifndef LOG
1788 #define LOG NOBUG_LOG
1789 #endif
1790 #ifndef LOG_IF
1791 #define LOG_IF NOBUG_LOG_IF
1792 #endif
1793 #ifndef ECHO
1794 #define ECHO NOBUG_ECHO
1795 #endif
1796 #ifndef ALERT
1797 #define ALERT NOBUG_ALERT
1798 #endif
1799 #ifndef ALERT_IF
1800 #define ALERT_IF NOBUG_ALERT_IF
1801 #endif
1802 #ifndef CRITICAL
1803 #define CRITICAL NOBUG_CRITICAL
1804 #endif
1805 #ifndef CRITICAL_IF
1806 #define CRITICAL_IF NOBUG_CRITICAL_IF
1807 #endif
1808 #ifndef ERROR
1809 #define ERROR NOBUG_ERROR
1810 #endif
1811 #ifndef ERROR_IF
1812 #define ERROR_IF NOBUG_ERROR_IF
1813 #endif
1814 #ifndef WARN
1815 #define WARN NOBUG_WARN
1816 #endif
1817 #ifndef WARN_IF
1818 #define WARN_IF NOBUG_WARN_IF
1819 #endif
1820 #ifndef INFO
1821 #define INFO NOBUG_INFO
1822 #endif
1823 #ifndef INFO_IF
1824 #define INFO_IF NOBUG_INFO_IF
1825 #endif
1826 #ifndef NOTICE
1827 #define NOTICE NOBUG_NOTICE
1828 #endif
1829 #ifndef NOTICE_IF
1830 #define NOTICE_IF NOBUG_NOTICE_IF
1831 #endif
1832 #ifndef TRACE
1833 #define TRACE NOBUG_TRACE
1834 #endif
1835 #ifndef TRACE_IF
1836 #define TRACE_IF NOBUG_TRACE_IF
1837 #endif
1838 #ifndef BACKTRACE
1839 #define BACKTRACE NOBUG_BACKTRACE
1840 #endif
1841 #ifndef DEPRECATED
1842 #define DEPRECATED NOBUG_DEPRECATED
1843 #endif
1844 #ifndef UNIMPLEMENTED
1845 #define UNIMPLEMENTED NOBUG_UNIMPLEMENTED
1846 #endif
1847 #ifndef FIXME
1848 #define FIXME NOBUG_FIXME
1849 #endif
1850 #ifndef TODO
1851 #define TODO NOBUG_TODO
1852 #endif
1853 #ifndef PLANNED
1854 #define PLANNED NOBUG_PLANNED
1855 #endif
1856 #ifndef NOTREACHED
1857 #define NOTREACHED NOBUG_NOTREACHED
1858 #endif
1859 #ifndef ELSE_NOTREACHED
1860 #define ELSE_NOTREACHED NOBUG_ELSE_NOTREACHED
1861 #endif
1862 #ifndef INJECT_GOODBAD
1863 #define INJECT_GOODBAD NOBUG_INJECT_GOODBAD
1864 #endif
1865 #ifndef INJECT_FAULT
1866 #define INJECT_FAULT NOBUG_INJECT_FAULT
1867 #endif
1868 #ifndef CLEANUP
1869 #define CLEANUP NOBUG_CLEANUP
1870 #endif
1871 #ifndef CHECKED
1872 #define CHECKED NOBUG_CHECKED
1873 #endif
1874 #ifndef UNCHECKED
1875 #define UNCHECKED NOBUG_UNCHECKED
1876 #endif
1877 #ifndef RESOURCE_ANNOUNCE
1878 #define RESOURCE_ANNOUNCE NOBUG_RESOURCE_ANNOUNCE
1879 #endif
1880 #ifndef RESOURCE_FORGET
1881 #define RESOURCE_FORGET NOBUG_RESOURCE_FORGET
1882 #endif
1883 #ifndef RESOURCE_ENTER
1884 #define RESOURCE_ENTER NOBUG_RESOURCE_ENTER
1885 #endif
1886 #ifndef RESOURCE_WAIT
1887 #define RESOURCE_WAIT NOBUG_RESOURCE_WAIT
1888 #endif
1889 #ifndef RESOURCE_TRY
1890 #define RESOURCE_TRY NOBUG_RESOURCE_TRY
1891 #endif
1892 #ifndef RESOURCE_STATE
1893 #define RESOURCE_STATE NOBUG_RESOURCE_STATE
1894 #endif
1895 #ifndef RESOURCE_LEAVE
1896 #define RESOURCE_LEAVE NOBUG_RESOURCE_LEAVE
1897 #endif
1898 #ifndef RESOURCE_LEAVE_LOOKUP
1899 #define RESOURCE_LEAVE_LOOKUP NOBUG_RESOURCE_LEAVE_LOOKUP
1900 #endif
1901 #ifndef RESOURCE_HANDLE
1902 #define RESOURCE_HANDLE NOBUG_RESOURCE_HANDLE
1903 #endif
1904 #ifndef RESOURCE_HANDLE_INIT
1905 #define RESOURCE_HANDLE_INIT NOBUG_RESOURCE_HANDLE_INIT
1906 #endif
1907 #ifndef RESOURCE_USER
1908 #define RESOURCE_USER NOBUG_RESOURCE_USER
1909 #endif
1910 #ifndef RESOURCE_ASSERT_STATE
1911 #define RESOURCE_ASSERT_STATE NOBUG_RESOURCE_ASSERT_STATE
1912 #endif
1913 #ifndef RESOURCE_ASSERT_STATE_IF
1914 #define RESOURCE_ASSERT_STATE_IF NOBUG_RESOURCE_ASSERT_STATE_IF
1915 #endif
1916 #ifndef RESOURCE_USER_INIT
1917 #define RESOURCE_USER_INIT NOBUG_RESOURCE_USER_INIT
1918 #endif
1919 #ifndef RESOURCE_DUMP
1920 #define RESOURCE_DUMP NOBUG_RESOURCE_DUMP
1921 #endif
1922 #ifndef RESOURCE_DUMP_IF
1923 #define RESOURCE_DUMP_IF NOBUG_RESOURCE_DUMP_IF
1924 #endif
1925 #ifndef RESOURCE_DUMPALL
1926 #define RESOURCE_DUMPALL NOBUG_RESOURCE_DUMPALL
1927 #endif
1928 #ifndef RESOURCE_DUMPALL_IF
1929 #define RESOURCE_DUMPALL_IF NOBUG_RESOURCE_DUMPALL_IF
1930 #endif
1931 #ifndef RESOURCE_LIST
1932 #define RESOURCE_LIST NOBUG_RESOURCE_LIST
1933 #endif
1934 #ifndef RESOURCE_LIST_IF
1935 #define RESOURCE_LIST_IF NOBUG_RESOURCE_LIST_IF
1936 #endif
1940 /*
1941 Tool macros
1942 */
1943 #ifdef __GNUC__
1944 #define NOBUG_CLEANUP(fn) NOBUG_IF_ALPHA(__attribute__((cleanup(fn))))
1945 #define NOBUG_ATTR_PRINTF(fmt, ell) __attribute__ ((format (printf, fmt, ell)))
1946 #else
1947 #define NOBUG_CLEANUP(fn)
1948 #define NOBUG_ATTR_PRINTF(fmt, ell)
1949 #endif
1951 /*
1952 //toolmacros PARA NOBUG_ALPHA_COMMA; NOBUG_ALPHA_COMMA; append something after a comma in *ALPHA* builds
1953 //toolmacros NOBUG_ALPHA_COMMA(something)
1954 //toolmacros NOBUG_ALPHA_COMMA_NULL
1955 //toolmacros
1956 //toolmacros Sometimes it is useful to have initializer code only in *ALPHA* builds, for example when you
1957 //toolmacros conditionally include resource handles only in *ALPHA* versions. An initializer can then
1958 //toolmacros use this macros to append a comman and something else only in *ALPHA* builds as in:
1959 //toolmacros struct foo = {"foo", "bar" NOBUG_ALPHA_COMMA_NULL };
1960 //toolmacros
1961 */
1962 #define NOBUG_COMMA ,
1963 #define NOBUG_ALPHA_COMMA(something) NOBUG_IF_ALPHA(NOBUG_COMMA something)
1964 #define NOBUG_ALPHA_COMMA_NULL NOBUG_ALPHA_COMMA(NULL)
1966 #define NOBUG_ONCE(code) \
1967 do { \
1968 static volatile int NOBUG_CAT(nobug_once_,__LINE__) = 1; \
1969 if (NOBUG_EXPECT_FALSE(NOBUG_CAT(nobug_once_,__LINE__))) \
1970 { \
1971 NOBUG_CAT(nobug_once_,__LINE__) = 0; \
1972 code; \
1973 } \
1974 } while (0)
1976 #if __GNUC__
1977 #define NOBUG_EXPECT_FALSE(x) __builtin_expect(!!(x),0)
1978 #else
1979 #define NOBUG_EXPECT_FALSE(x) x
1980 #endif
1982 #define NOBUG_WHEN(when, ...) \
1983 do{ if (NOBUG_EXPECT_FALSE(when)){ __VA_ARGS__;}} while(0)
1985 /*
1986 //toolmacros PARA NOBUG_IF_*; NOBUG_IF; include code conditionally on build level
1987 //toolmacros NOBUG_IF_ALPHA(...)
1988 //toolmacros NOBUG_IF_NOT_ALPHA(...)
1989 //toolmacros NOBUG_IF_BETA(...)
1990 //toolmacros NOBUG_IF_NOT_BETA(...)
1991 //toolmacros NOBUG_IF_RELEASE(...)
1992 //toolmacros NOBUG_IF_NOT_RELEASE(...)
1993 //toolmacros
1994 //toolmacros This macros allow one to conditionally include the code in '(...)' only if the
1995 //toolmacros criteria on the build level is met. If not, nothing gets substituted. Mostly used
1996 //toolmacros internally, but can also be used for custom things.
1997 //toolmacros
1998 */
1999 #define NOBUG_IF_ALPHA(...) \
2000 NOBUG_IF(NOBUG_MODE_ALPHA, __VA_ARGS__) \
2002 #define NOBUG_IF_NOT_ALPHA(...) \
2003 NOBUG_IFNOT(NOBUG_MODE_ALPHA, __VA_ARGS__) \
2005 #define NOBUG_IF_BETA(...) \
2006 NOBUG_IF(NOBUG_MODE_BETA, __VA_ARGS__) \
2008 #define NOBUG_IF_NOT_BETA(...) \
2009 NOBUG_IFNOT(NOBUG_MODE_BETA, __VA_ARGS__) \
2011 #define NOBUG_IF_RELEASE(...) \
2012 NOBUG_IF(NOBUG_MODE_RELEASE, __VA_ARGS__) \
2014 #define NOBUG_IF_NOT_RELEASE(...) \
2015 NOBUG_IFNOT(NOBUG_MODE_RELEASE, __VA_ARGS__) \
2017 /*
2018 preprocessor hacks/metaprogramming
2019 */
2021 #define NOBUG_IF(bool, ...) NOBUG_CAT(NOBUG_IF_,bool)(__VA_ARGS__)
2022 #define NOBUG_IF_1(...) __VA_ARGS__
2023 #define NOBUG_IF_0(...)
2025 #define NOBUG_IFNOT(bool, ...) NOBUG_CAT(NOBUG_IF_, NOBUG_NOT(bool))(__VA_ARGS__)
2027 #define NOBUG_NOT(bool) NOBUG_CAT(NOBUG_NOT_, bool)
2028 #define NOBUG_NOT_1 0
2029 #define NOBUG_NOT_0 1
2031 #define NOBUG_AND(a,b) NOBUG_CAT3(NOBUG_AND_, a, b)
2032 #define NOBUG_AND_00 0
2033 #define NOBUG_AND_01 0
2034 #define NOBUG_AND_10 0
2035 #define NOBUG_AND_11 1
2037 #define NOBUG_OR(a,b) NOBUG_CAT3(NOBUG_OR_, a, b)
2038 #define NOBUG_OR_00 0
2039 #define NOBUG_OR_01 1
2040 #define NOBUG_OR_10 1
2041 #define NOBUG_OR_11 1
2043 #define NOBUG_XOR(a,b) NOBUG_CAT( NOBUG_XOR_, NOBUG_CAT(a,b))
2044 #define NOBUG_XOR_00 0
2045 #define NOBUG_XOR_01 1
2046 #define NOBUG_XOR_10 1
2047 #define NOBUG_XOR_11 0
2049 #define NOBUG_CAT(a,b) NOBUG_CAT_(a,b)
2050 #define NOBUG_CAT_(a,b) a##b
2052 #define NOBUG_CAT3(a,b,c) NOBUG_CAT3_(a,b,c)
2053 #define NOBUG_CAT3_(a,b,c) a##b##c
2055 #define NOBUG_STRINGIZE(s) NOBUG_STRINGIZE_(s)
2056 #define NOBUG_STRINGIZE_(s) #s
2059 /*
2060 LIBNOBUG DECLARATIONS
2061 */
2062 #ifdef __cplusplus
2064 #elif 0
2066 #endif
2068 #ifndef LLIST_DEFINED
2069 #define LLIST_DEFINED
2070 struct llist_struct
2071 {
2074 };
2075 #endif
2077 /*
2078 source context
2079 */
2081 struct nobug_context
2082 {
2087 #ifdef __cplusplus
2090 #endif
2091 };
2096 /*
2097 envvar control
2098 */
2099 enum nobug_log_targets
2100 {
2101 NOBUG_TARGET_RINGBUFFER,
2102 NOBUG_TARGET_CONSOLE,
2103 NOBUG_TARGET_FILE,
2104 NOBUG_TARGET_SYSLOG,
2105 NOBUG_TARGET_APPLICATION
2106 };
2108 struct nobug_flag
2109 {
2117 };
2119 int
2120 nobug_env_parse_flag (const char* env, struct nobug_flag* flag, int default_target, int default_limit, const struct nobug_context context);
2122 int
2123 nobug_env_init_flag (struct nobug_flag* flag, int default_target, int default_limit, const struct nobug_context context);
2126 /*
2127 ringbuffer
2128 */
2129 struct nobug_ringbuffer
2130 {
2137 };
2139 enum nobug_ringbuffer_flags
2140 {
2141 NOBUG_RINGBUFFER_DEFAULT, /* Default is to overwrite file and delete it on nobug_ringbuffer_destroy */
2145 };
2146 /*
2147 Note: some flags conflict (TEMP with KEEP) nobug_ringbuffer will not error on these but continue gracefully
2148 with sane (but undefined) semantics.
2149 */
2161 void
2164 void
2167 void
2170 int
2173 int
2179 int
2188 int
2191 int
2197 void
2201 /*
2202 multithreading extras
2203 */
2204 #if NOBUG_USE_PTHREAD
2206 struct nobug_tls_data
2207 {
2213 };
2231 #endif
2236 /*
2237 resource registry
2238 */
2239 enum nobug_resource_state
2240 {
2241 NOBUG_RESOURCE_INVALID,
2242 NOBUG_RESOURCE_WAITING,
2243 NOBUG_RESOURCE_TRYING,
2244 NOBUG_RESOURCE_EXCLUSIVE,
2245 NOBUG_RESOURCE_RECURSIVE,
2246 NOBUG_RESOURCE_SHARED
2247 };
2250 struct nobug_resource_header
2251 {
2255 };
2260 struct nobug_resource_record
2261 {
2268 #if NOBUG_USE_PTHREAD
2270 #endif
2271 };
2274 struct nobug_resource_node
2275 {
2281 struct llist_struct childs; /* down the tree, all nodes pointing to here (TODO make this a slist) */
2283 };
2286 struct nobug_resource_user
2287 {
2293 #if NOBUG_USE_PTHREAD
2296 #endif
2297 };
2305 void
2308 void
2313 nobug_resource_announce (const char* type, const char* name, const void* object_id, const struct nobug_context extra);
2315 void
2318 int
2329 int
2333 void
2337 unsigned
2341 unsigned
2345 #if NOBUG_USE_PTHREAD
2346 unsigned
2348 #endif
2351 struct nobug_resource_dump_context
2352 {
2357 #ifdef __cplusplus
2362 #endif
2363 };
2365 enum nobug_resource_state
2368 void
2369 nobug_resource_dump (struct nobug_resource_record* resource, const struct nobug_resource_dump_context context);
2371 void
2374 int
2379 void
2383 /*
2384 global config, data and defaults
2385 */
2388 /*
2389 the destroy function is optional, since nobug should stay alive for the whole application lifetime
2390 (and destroying is global!) it is only provided for the nobug testsuite itself
2391 */
2394 void
2397 void
2401 nobug_log_begin (char* header, struct nobug_flag* flag, const char* what, const struct nobug_context ctx);
2404 void
2408 /* must be called inbetween log_begin and log_end */
2409 void
2410 nobug_log_line (char** start, char* header, struct nobug_flag* flag, int lvl, const char* fmt, ...);
2413 void
2426 //callbacks HEAD- Callbacks;;
2427 //callbacks
2428 //callbacks NoBug provides callbacks, applications can use these
2429 //callbacks to present logging information in some custom way or hook some special processing in.
2430 //callbacks The callbacks are initialized to NULL and never modified by NoBug, its the solve responsibility
2431 //callbacks of the user to manage them.
2432 //callbacks
2433 //callbacks CAUTION: There are certain constraints what and what not can be done in callbacks
2434 //callbacks documented below which must be followed.
2435 //callbacks
2436 //callbacks PARA type of logging callbacks; logging_cb; type of a logging callback function
2437 typedef void (*nobug_logging_cb)(const struct nobug_flag* flag, int priority, const char *log, void* data); //callbacks VERBATIM;
2438 //callbacks
2439 //callbacks used for the logging callbacks
2440 //callbacks
2441 //callbacks `flag`::
2442 //callbacks Flag structure which defines the logging configuration for this event
2443 //callbacks `priority`::
2444 //callbacks Log level of the current event
2445 //callbacks `log`::
2446 //callbacks Pointing to the current log line in the ringbuffer or `NULL`
2447 //callbacks `data`::
2448 //callbacks Global pointer defined by the user, passed arround (see below)
2449 //callbacks
2451 //callbacks PARA type of abort callback; abort_cb; type of a abort callback function
2453 //callbacks
2454 //callbacks used for the abort callback
2455 //callbacks
2456 //callbacks `data`::
2457 //callbacks Global data defined by the user, passed arround (see below)
2458 //callbacks
2460 //callbacks PARA passing data to callbacks; callback_data; data to be passed to callbacks
2461 extern
2463 //callbacks
2464 //callbacks This global variable is initialized to `NULL` and will never be touched by NoBug. One can use it
2465 //callbacks to pass extra data to the callback functions.
2466 //callbacks
2468 //callbacks PARA callback when logging; logging_callback; hook when something get logged
2469 extern
2471 //callbacks
2472 //callbacks This callback gets called when something gets logged.
2473 //callbacks NoBug will still hold its mutexes when calling this hook, calling NoBug logging or resource tracking
2474 //callbacks functions from here recursively will deadlock and must be avoided.
2475 //callbacks The `log` parameter points to the logging message in the ringbuffer.
2476 //callbacks Unlike other logging targets it is not automatically limited to the log level configured
2477 //callbacks in the flag but called unconditionally. The callback should implement its own limiting.
2478 //callbacks
2479 //callbacks When one wants to do complex calls which may include recursion into logging and resource tracking
2480 //callbacks functions, the intended way is to pass contextual information possibly including a __copy__ of the
2481 //callbacks `log` parameter in xref:THREAD_DATA[NOBUG_THREAD_DATA] to the postlogging callback (see below).
2482 //callbacks Other internal NoBug facilties, like the ringbuffer etc, are protected by the mutexes and may be accessed
2483 //callbacks from this function.
2484 //callbacks
2486 //callbacks PARA callback after logging; postlogging_callback; hook after something get logged
2487 extern
2489 //callbacks
2490 //callbacks This callback gets called after something got logged. The `log` parameter is always NULL and all
2491 //callbacks NoBug mutexes are released. This means that this function may call any complex things, including
2492 //callbacks calling logging and resource tracking, but may not call internal NoBug facilities.
2493 //callbacks Contextual created in the `nobug_logging_callback` and stored in xref:THREAD_DATA[NOBUG_THREAD_DATA] can be
2494 //callbacks retrieved here and may need to be cleaned up here.
2495 //callbacks
2497 //callbacks PARA callback for aborting; abort_callback; hook to handle a termination
2498 extern
2500 //callbacks
2501 //callbacks This callback gets called when the application shall be terminated due an error.
2502 //callbacks It can be used to hook exceptions or similar things in. When it returns, `abort()`
2503 //callbacks is called.
2504 //callbacks
2505 //callbacks IMPORTANT: Errors detected by NoBug are always fatal. If one handles and possible
2506 //callbacks throws an exception here, the application must shut down as soon as possible.
2507 //callbacks Most causes for aborts are optimitzed out in `RELEASE` builds.
2508 //callbacks
2511 /* block statement macros for sections must not be left by a jump this function will assert this with a NOBUG_CLEANUP attribute */
2514 {
2516 {
2519 NOBUG_CONTEXT_NIL,
2522 }
2523 }
2526 #ifdef __cplusplus
2528 #endif
2530 #ifndef NOBUG_LIBNOBUG_C
2532 /*
2533 tag this translation unit as unchecked in ALPHA and BETA builds
2534 */
2537 #else
2538 /* some configuration when compiling nobug */
2539 /* Maximal length of a log line header (silently truncated if exceed) */
2540 #define NOBUG_MAX_LOG_HEADER_SIZE 128
2541 /* Maximal linebreaks in a single logging instruction which get translated to multiple lines */
2542 #define NOBUG_MAX_LOG_LINES 32
2545 #endif