contrib/libjeffpc/error.c

   1 /*
   2  * Copyright (c) 2013-2016 Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #include <inttypes.h>
  24 #include <syslog.h>
  25 #include <stdio.h>
  26 #include <stdbool.h>
  27 #include <assert.h>
  28 #include <pthread.h>
  29 #include <execinfo.h>
  30 #include <ucontext.h>
  31
  32 #include <jeffpc/config.h>
  33 #include <jeffpc/error.h>
  34
  35 #include "init.h"
  36
  37 #ifndef HAVE_ASSFAIL
  38 static int assfail(const char *assertion, const char *file, int line)
  39 {
  40         __assert(assertion, file, line);
  41
  42         return 0; /* not reached */
  43 }
  44 #else
  45 extern int assfail(const char *a, const char *f, int l);
  46 #endif
  47
  48 void default_print(enum errlevel level, const char *fmt, va_list ap)
  49 {
  50         FILE *out;
  51
  52         switch (level) {
  53                 case CE_DEBUG:
  54                 case CE_INFO:
  55                         out = stdout;
  56                         break;
  57                 case CE_WARN:
  58                 case CE_ERROR:
  59                 case CE_CRIT:
  60                 case CE_PANIC:
  61                 default:
  62                         out = stderr;
  63                         break;
  64         }
  65
  66         vfprintf(out, fmt, ap);
  67 }
  68
  69 void jeffpc_print(enum errlevel level, const char *fmt, ...)
  70 {
  71         va_list ap;
  72
  73         va_start(ap, fmt);
  74         libops.print(level, fmt, ap);
  75         va_end(ap);
  76 }
  77
  78 void default_log(int loglevel, const char *fmt, va_list ap)
  79 {
  80         /*
  81          * This function is a no-op but it exists to allow consumers of
  82          * libjeffpc to override it with their own log implementation.
  83          */
  84 }
  85
  86 void jeffpc_log(int loglevel, const char *fmt, ...)
  87 {
  88         va_list ap;
  89
  90         va_start(ap, fmt);
  91         libops.log(loglevel, fmt, ap);
  92         va_end(ap);
  93 }
  94
  95 void default_assfail(const char *a, const char *f, int l)
  96 {
  97         jeffpc_log(LOG_ALERT, "assertion failed: %s, file: %s, line: %d",
  98                    a, f, l);
  99
 100         print_stacktrace(CE_CRIT, NULL);
 101
 102         assfail(a, f, l);
 103 }
 104
 105 void jeffpc_assfail(const char *a, const char *f, int l)
 106 {
 107         libops.assfail(a, f, l);
 108
 109         /* this is a hack to shut up gcc */
 110         abort();
 111 }
 112
 113 void default_assfail3(const char *a, uintmax_t lv, const char *op, uintmax_t rv,
 114                       const char *f, int l)
 115 {
 116         char msg[512];
 117
 118         snprintf(msg, sizeof(msg), "%s (0x%"PRIx64" %s 0x%"PRIx64")", a, lv,
 119                  op, rv);
 120
 121         jeffpc_log(LOG_ALERT, "assertion failed: %s, file: %s, line: %d",
 122                    msg, f, l);
 123
 124         print_stacktrace(CE_CRIT, NULL);
 125
 126         assfail(msg, f, l);
 127 }
 128
 129 void jeffpc_assfail3(const char *a, uintmax_t lv, const char *op, uintmax_t rv,
 130                      const char *f, int l)
 131 {
 132         libops.assfail3(a, lv, op, rv, f, l);
 133
 134         /* this is a hack to shut up gcc */
 135         abort();
 136 }
 137
 138 void cmn_verr(enum errlevel level, const char *fmt, va_list ap)
 139 {
 140         const char *levelstr;
 141         unsigned long tid;
 142         int loglevel;
 143         bool panic;
 144         char buf[256];
 145
 146         tid = (unsigned long) pthread_self();
 147         panic = false;
 148
 149         switch (level) {
 150                 case CE_DEBUG:
 151                         levelstr = "DEBUG";
 152                         loglevel = LOG_DEBUG;
 153                         break;
 154                 case CE_INFO:
 155                         levelstr = "INFO";
 156                         loglevel = LOG_INFO;
 157                         break;
 158                 case CE_WARN:
 159                         levelstr = "WARN";
 160                         loglevel = LOG_WARNING;
 161                         break;
 162                 case CE_ERROR:
 163                         levelstr = "ERROR";
 164                         loglevel = LOG_ERR;
 165                         break;
 166                 case CE_CRIT:
 167                         levelstr = "CRIT";
 168                         loglevel = LOG_CRIT;
 169                         break;
 170                 case CE_PANIC:
 171                         levelstr = "PANIC";
 172                         loglevel = LOG_ALERT;
 173                         panic = true;
 174                         break;
 175                 default:
 176                         levelstr = "?????";
 177                         loglevel = LOG_CRIT;
 178                         panic = true;
 179                         break;
 180         }
 181
 182         vsnprintf(buf, sizeof(buf), fmt, ap);
 183
 184         /*
 185          * We are printing the thread ID as a 4-digit number. This will
 186          * allow systems that use small integers (e.g., Illumos) to have
 187          * short IDs.  Systems that use large integers (e.g., Linux) will
 188          * use more digits.  Since on those systems the IDs will be
 189          * clustered around some big integer, they will very likely always
 190          * print as the same number of digits.
 191          */
 192         jeffpc_log(loglevel, "[%04lx] %-5s %s\n", tid, levelstr, buf);
 193         jeffpc_print(level, "[%04lx] %-5s %s\n", tid, levelstr, buf);
 194
 195         if (panic) {
 196                 print_stacktrace(CE_CRIT, NULL);
 197                 abort();
 198         }
 199 }
 200
 201 void cmn_err(enum errlevel level, const char *fmt, ...)
 202 {
 203         va_list ap;
 204
 205         va_start(ap, fmt);
 206         cmn_verr(level, fmt, ap);
 207         va_end(ap);
 208 }
 209
 210 void panic(const char *fmt, ...)
 211 {
 212         va_list ap;
 213
 214         va_start(ap, fmt);
 215         cmn_verr(CE_PANIC, fmt, ap);
 216         va_end(ap);
 217
 218         /* this is a hack to shut up gcc */
 219         abort();
 220 }
 221
 222 /*
 223  * Note: We must not allocate any memory, etc. because we want this function
 224  * to be callable from any context.
 225  */
 226 void save_stacktrace(struct stack *stack)
 227 {
 228         size_t nframes;
 229
 230         nframes = backtrace(stack->frames, ERROR_STACK_FRAMES);
 231         stack->nframes = nframes;
 232
 233         /* NULL-out any unused frames */
 234         while (nframes < ERROR_STACK_FRAMES)
 235                 stack->frames[nframes++] = NULL;
 236 }
 237
 238 #ifndef HAVE_ADDRTOSYMSTR
 239 static void addrtosymstr(void *pc, char *buf, size_t buflen)
 240 {
 241         snprintf(buf, buflen, "[%p]", pc);
 242 }
 243 #endif
 244
 245 /*
 246  * Note: We must not allocate any memory, etc. because we want this function
 247  * to be callable from any context.
 248  */
 249 void print_stacktrace(enum errlevel level, struct stack *stack)
 250 {
 251         struct stack here;
 252         size_t i;
 253
 254         if (!stack) {
 255                 save_stacktrace(&here);
 256                 stack = &here;
 257         }
 258
 259         for (i = 0; i < stack->nframes; i++) {
 260                 char tmp[256];
 261
 262                 addrtosymstr(stack->frames[i], tmp, sizeof(tmp));
 263
 264                 cmn_err(level, "  %s", tmp);
 265         }
 266 }
 267
 268 /*
 269  * If we have sys/debug.h, let's include it so that the assfail function
 270  * signature gets checked to be what we expect.
 271  *
 272  * This include is at the end of this file because it polutes the namespace
 273  * big time.
 274  */
 275 #ifdef HAVE_SYS_DEBUG_H
 276 #include <sys/debug.h>
 277 #endif