src/util/error.h

   1
   2 #ifndef EL__UTIL_ERROR_H
   3 #define EL__UTIL_ERROR_H
   4
   5
   6 /* Here you will found a chunk of functions useful for error states --- from
   7  * reporting of various problems to generic error tests/workarounds to some
   8  * tools to be used when you got into an error state already. Some of the
   9  * functions are also useful for debugging. */
  10
  11
  12 /* This errfile thing is needed, as we don't have var-arg macros in standart,
  13  * only as gcc extension :(. */
  14 extern int errline;
  15 extern unsigned char *errfile;
  16
  17 /* @DBG(format_string) is used for printing of debugging information. It
  18  * should not be used anywhere in the official codebase (although it is often
  19  * lying there commented out, as it may get handy). */
  20 #undef DBG
  21 #define DBG errfile = __FILE__, errline = __LINE__, elinks_debug
  22 void elinks_debug(unsigned char *fmt, ...);
  23
  24 /* @WDBG(format_string) is used for printing of debugging information, akin
  25  * to DBG(). However, it sleep(1)s, therefore being useful when it is going
  26  * to be overdrawn or so. It should not be used anywhere in the official
  27  * codebase (although it is often lying there commented out, as it may get
  28  * handy). */
  29 #undef WDBG
  30 #define WDBG errfile = __FILE__, errline = __LINE__, elinks_wdebug
  31 void elinks_wdebug(unsigned char *fmt, ...);
  32
  33 /* @ERROR(format_string) is used to report non-fatal unexpected errors during
  34  * the ELinks run. It tries to (not that agressively) draw user's attention to
  35  * the error, but never dumps core or so. Note that this should be used only in
  36  * cases of non-severe internal inconsistences etc, never as an indication of
  37  * user error (bad parameter, config file error etc.). We have usrerror() for
  38  * this kind of stuff, and there's nothing naughty about using that. */
  39 #undef ERROR
  40 #define ERROR errfile = __FILE__, errline = __LINE__, elinks_error
  41 void elinks_error(unsigned char *fmt, ...);
  42
  43 /* @INTERNAL(format_string) is used to report fatal errors during the ELinks
  44  * run. It tries to draw user's attention to the error and dumps core if ELinks
  45  * is running in the CONFIG_DEBUG mode. */
  46 #undef INTERNAL
  47 #define INTERNAL errfile = __FILE__, errline = __LINE__, elinks_internal
  48 void elinks_internal(unsigned char *fmt, ...);
  49
  50
  51 /* @usrerror(format_string) is used to report user errors during a peaceful
  52  * ELinks run. It does not belong to the family above - it doesn't print code
  53  * location, beep nor sleep, it just wraps around fprintf(stderr, "...\n");. */
  54 void usrerror(unsigned char *fmt, ...);
  55
  56
  57 #ifdef HAVE_VARIADIC_MACROS
  58 #ifdef CONFIG_DEBUG
  59 /* The LOG_*() macros can be used to log to a file, however, by default log
  60  * messages are written to stderr. Set the following environment variables
  61  * to configure the log behavior:
  62  *
  63  *      ELINKS_LOG      - The path to the log file, it is opened for appending
  64  *      ELINKS_MSG      - A comma separated list containing "error", "warn",
  65  *                        "info" and/or "debug" which can be used to limit
  66  *                        what messages to emit to the log.
  67  *      ELINKS_FILES    - A comma separated list of which files names to
  68  *                        emit log messages from.
  69  */
  70 void
  71 elinks_log(unsigned char *msg, unsigned char *file, int line,
  72            unsigned char *fmt, ...);
  73
  74 #undef LOG_ERR
  75 #define LOG_ERR(args...) \
  76         elinks_log("error", __FILE__, __LINE__, args)
  77
  78 #undef LOG_WARN
  79 #define LOG_WARN(args...) \
  80         elinks_log("warn", __FILE__, __LINE__, args)
  81
  82 #undef LOG_INFO
  83 #define LOG_INFO(args...) \
  84         elinks_log("info", __FILE__, __LINE__, args)
  85
  86 #undef LOG_DBG
  87 #define LOG_DBG(args...) \
  88         elinks_log("debug", __FILE__, __LINE__, args)
  89
  90 #endif
  91 #endif
  92
  93
  94
  95 /* This is our smart assert(). It is basically equivalent to if (x) INTERNAL(),
  96  * but it generates a uniform message and mainly does not do the test if we are
  97  * supposed to be lightning fast. Use it, use it a lot! And never forget the
  98  * recovery path, see below if_assert_failed. */
  99
 100 #undef assert
 101 #ifdef CONFIG_FASTMEM
 102 #define assert(x) /* We don't do anything in CONFIG_FASTMEM mode. */
 103 #else
 104 #define assert(x) \
 105 do { if (!assert_failed && (assert_failed = !(x))) { \
 106         INTERNAL("assertion " #x " failed!"); \
 107 } } while (0)
 108 #endif
 109
 110
 111 /* This is extended assert() version, it can print additional user-specified
 112  * message. Quite useful not only to detect that _something_ is wrong, but also
 113  * _how_ wrong is it ;-). Note that the format string must always be a regular
 114  * string, not a variable reference. Also, be careful _what_ will you attempt
 115  * to print, or you could easily get just a SIGSEGV instead of the assertion
 116  * failed message. */
 117
 118 #undef assertm
 119 #ifdef HAVE_VARIADIC_MACROS
 120 #ifdef CONFIG_FASTMEM
 121 #define assertm(x,m...) /* We don't do anything in CONFIG_FASTMEM mode. */
 122 #else
 123 #define assertm(x,m...) \
 124 do { if (!assert_failed && (assert_failed = !(x))) { \
 125         INTERNAL("assertion " #x " failed: " m); \
 126 } } while (0)
 127 #endif
 128 #else /* HAVE_VARIADIC_MACROS */
 129 #ifdef CONFIG_FASTMEM
 130 #define assertm elinks_assertm
 131 #else
 132 #define assertm errfile = __FILE__, errline = __LINE__, elinks_assertm
 133 #endif
 134 /* This is not nice at all, and does not really work that nice as macros do
 135  * But it is good to try to do at least _some_ assertm()ing even when the
 136  * variadic macros are not supported. */
 137 /* XXX: assertm() usage could generate warnings (we assume that the assert()ed
 138  * expression is int (and that's completely fine, I do *NOT* want to see any
 139  * stinking assert((int) pointer) ! ;-)), so CONFIG_DEBUG (-Werror) and
 140  * !HAVE_VARIADIC_MACROS won't play well together. Hrm. --pasky */
 141 #ifdef CONFIG_FASTMEM
 142 static inline
 143 #endif
 144 void elinks_assertm(int x, unsigned char *fmt, ...)
 145 #ifdef CONFIG_FASTMEM
 146 {
 147         /* We don't do anything in CONFIG_FASTMEM mode. Let's hope that the compiler
 148          * will at least optimize out the @x computation. */
 149 }
 150 #else
 151         ;
 152 #endif
 153 #endif /* HAVE_VARIADIC_MACROS */
 154
 155
 156 /* To make recovery path possible (assertion failed may not mean end of the
 157  * world, the execution goes on if we're outside of CONFIG_DEBUG and CONFIG_FASTMEM),
 158  * @assert_failed is set to true if the last assert() failed, otherwise it's
 159  * zero. Note that you must never change assert_failed value, sorry guys.
 160  *
 161  * You should never test assert_failed directly anyway. Use if_assert_failed
 162  * instead, it will attempt to hint compiler to optimize out the recovery path
 163  * if we're CONFIG_FASTMEM. So it should go like:
 164  *
 165  * assertm(1 == 1, "The world's gonna blow up!");
 166  * if_assert_failed { schedule_time_machine(); return; } */
 167
 168 /* In-depth explanation: this restriction is here because in the CONFIG_FASTMEM mode,
 169  * assert_failed is initially initialized to zero and then not ever touched
 170  * anymore. So if you change it to non-zero failure, your all further recovery
 171  * paths will get hit (and since developers usually don't test CONFIG_FASTMEM mode
 172  * extensively...). So better don't mess with it, even if you would do that
 173  * with awareness of this fact. We don't want to iterate over tens of spots all
 174  * over the code when we chane one detail regarding CONFIG_FASTMEM operation.
 175  *
 176  * This is not that actual after introduction of if_assert_failed, but it's
 177  * a safe recommendation anyway, so... ;-) */
 178
 179 extern int assert_failed;
 180
 181 #undef if_assert_failed
 182 #ifdef CONFIG_FASTMEM
 183 #define if_assert_failed if (0) /* This should be optimalized away. */
 184 #else
 185 #define if_assert_failed if (assert_failed && !(assert_failed = 0))
 186 #endif
 187
 188
 189
 190 /* This will print some fancy message, version string and possibly do something
 191  * else useful. Then, it will dump core. */
 192 #ifdef CONFIG_DEBUG
 193 void force_dump(void);
 194 #endif
 195
 196
 197 /* This function does nothing, except making compiler not to optimize certains
 198  * spots of code --- this is useful when that particular optimization is buggy.
 199  * So we are just workarounding buggy compilers. */
 200 /* This function should be always used only in context of compiler version
 201  * specific macros. */
 202 void do_not_optimize_here(void *x);
 203
 204 #if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ <= 7
 205 #define do_not_optimize_here_gcc_2_7(x) do_not_optimize_here(x)
 206 #else
 207 #define do_not_optimize_here_gcc_2_7(x)
 208 #endif
 209
 210 #if defined(__GNUC__) && __GNUC__ == 3
 211 #define do_not_optimize_here_gcc_3_x(x) do_not_optimize_here(x)
 212 #else
 213 #define do_not_optimize_here_gcc_3_x(x)
 214 #endif
 215
 216 #if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ == 3
 217 #define do_not_optimize_here_gcc_3_3(x) do_not_optimize_here(x)
 218 #else
 219 #define do_not_optimize_here_gcc_3_3(x)
 220 #endif
 221
 222
 223 /* This function dumps backtrace (or whatever similiar it founds on the stack)
 224  * nicely formatted and with symbols resolved to @f. When @trouble is set, it
 225  * tells it to be extremely careful and not use dynamic memory allocation
 226  * functions etc (useful in SIGSEGV handler etc). */
 227 /* Note that this function just calls system-specific backend provided by the
 228  * libc, so it is available only on some systems. CONFIG_BACKTRACE is defined
 229  * if it is available on yours. */
 230 #ifdef CONFIG_BACKTRACE
 231 #include <stdio.h>
 232 void dump_backtrace(FILE *f, int trouble);
 233 #endif
 234
 235 /* This is needed for providing info about features when dumping core */
 236 extern unsigned char full_static_version[1024];
 237
 238 #endif