lib/util/fault.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Critical Fault handling
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Tim Prouty 2009
   6    Copyright (C) James Peach 2006
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "replace.h"
  23 #include "system/filesys.h"
  24 #include "system/wait.h"
  25 #include "version.h"
  26
  27 #ifdef HAVE_SYS_SYSCTL_H
  28 #include <sys/sysctl.h>
  29 #endif
  30
  31
  32 #ifdef HAVE_SYS_PRCTL_H
  33 #include <sys/prctl.h>
  34 #endif
  35
  36 #include "debug.h"
  37 #include "lib/util/signal.h" /* Avoid /usr/include/signal.h */
  38 #include "fault.h"
  39
  40 static struct {
  41         bool disabled;
  42         smb_panic_handler_t panic_handler;
  43 } fault_state;
  44
  45
  46 /*******************************************************************
  47 setup variables used for fault handling
  48 ********************************************************************/
  49 void fault_configure(smb_panic_handler_t panic_handler)
  50 {
  51         fault_state.panic_handler = panic_handler;
  52 }
  53
  54
  55 /**
  56    disable setting up fault handlers
  57    This is used for the bind9 dlz module, as we
  58    don't want a Samba module in bind9 to override the bind
  59    fault handling
  60 **/
  61 _PUBLIC_ void fault_setup_disable(void)
  62 {
  63         fault_state.disabled = true;
  64 }
  65
  66
  67 #if !defined(HAVE_DISABLE_FAULT_HANDLING)
  68 /*******************************************************************
  69 report a fault
  70 ********************************************************************/
  71 static void fault_report(int sig)
  72 {
  73         static int counter;
  74         char signal_string[128];
  75
  76         if (counter) _exit(1);
  77
  78         counter++;
  79
  80         snprintf(signal_string, sizeof(signal_string),
  81                  "Signal %d: %s", sig, strsignal(sig));
  82         smb_panic(signal_string);
  83
  84         /* smb_panic() never returns, so this is really redundant */
  85         exit(1);
  86 }
  87
  88 /****************************************************************************
  89 catch serious errors
  90 ****************************************************************************/
  91 static void sig_fault(int sig)
  92 {
  93         fault_report(sig);
  94 }
  95 #endif
  96 /*******************************************************************
  97 setup our fault handlers
  98 ********************************************************************/
  99 void fault_setup(void)
 100 {
 101         if (fault_state.disabled) {
 102                 return;
 103         }
 104 #if !defined(HAVE_DISABLE_FAULT_HANDLING)
 105 #ifdef SIGSEGV
 106         CatchSignal(SIGSEGV, sig_fault);
 107 #endif
 108 #ifdef SIGBUS
 109         CatchSignal(SIGBUS, sig_fault);
 110 #endif
 111 #ifdef SIGABRT
 112         CatchSignal(SIGABRT, sig_fault);
 113 #endif
 114 #endif
 115 }
 116
 117 _PUBLIC_ const char *panic_action = NULL;
 118
 119 /*
 120    default smb_panic() implementation
 121 */
 122 static void smb_panic_default(const char *why) _NORETURN_;
 123 static void smb_panic_default(const char *why)
 124 {
 125 #if defined(HAVE_PRCTL) && defined(PR_SET_PTRACER)
 126         /*
 127          * Make sure all children can attach a debugger.
 128          */
 129         prctl(PR_SET_PTRACER, getpid(), 0, 0, 0);
 130 #endif
 131
 132         if (panic_action && *panic_action) {
 133                 char cmdstring[200];
 134                 if (strlcpy(cmdstring, panic_action, sizeof(cmdstring)) < sizeof(cmdstring)) {
 135                         int result;
 136                         char pidstr[20];
 137                         char subst[200];
 138                         char *p = NULL;
 139                         snprintf(pidstr, sizeof(pidstr), "%d", (int) getpid());
 140
 141                         p = strstr(cmdstring, "%d");
 142                         if (p != NULL) {
 143                                 snprintf(subst,
 144                                          sizeof(subst),
 145                                          "%.*s%s%s",
 146                                          (int)(p-cmdstring),
 147                                          cmdstring,
 148                                          pidstr,
 149                                          p+2);
 150                                 strlcpy(cmdstring, subst, sizeof(cmdstring));
 151                         }
 152
 153                         DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmdstring));
 154                         result = system(cmdstring);
 155
 156                         if (result == -1)
 157                                 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
 158                                           strerror(errno)));
 159                         else
 160                                 DEBUG(0, ("smb_panic(): action returned status %d\n",
 161                                           WEXITSTATUS(result)));
 162                 }
 163         }
 164
 165 #ifdef SIGABRT
 166         CatchSignal(SIGABRT, SIG_DFL);
 167 #endif
 168         abort();
 169 }
 170
 171 _PUBLIC_ void smb_panic_log(const char *why)
 172 {
 173         DEBUGSEP(0);
 174         DEBUG(0,("INTERNAL ERROR: %s in pid %lld (%s)\n",
 175                  why,
 176                  (unsigned long long)getpid(),
 177                  SAMBA_VERSION_STRING));
 178         DEBUG(0,("If you are running a recent Samba version, and "
 179                  "if you think this problem is not yet fixed in the "
 180                  "latest versions, please consider reporting this "
 181                  "bug, see "
 182                  "https://wiki.samba.org/index.php/Bug_Reporting\n"));
 183         DEBUGSEP(0);
 184         DEBUG(0,("PANIC (pid %llu): %s in " SAMBA_VERSION_STRING "\n",
 185                  (unsigned long long)getpid(), why));
 186
 187         log_stack_trace();
 188 }
 189
 190 /**
 191    Something really nasty happened - panic !
 192 **/
 193 _PUBLIC_ void smb_panic(const char *why)
 194 {
 195         smb_panic_log(why);
 196
 197         if (fault_state.panic_handler) {
 198                 fault_state.panic_handler(why);
 199                 _exit(1);
 200         }
 201         smb_panic_default(why);
 202 }
 203
 204 /*******************************************************************
 205  Print a backtrace of the stack to the debug log. This function
 206  DELIBERATELY LEAKS MEMORY. The expectation is that you should
 207  exit shortly after calling it.
 208 ********************************************************************/
 209
 210 /* Buffer size to use when printing backtraces */
 211 #define BACKTRACE_STACK_SIZE 64
 212
 213
 214 #ifdef HAVE_LIBUNWIND_H
 215 #include <libunwind.h>
 216 #endif
 217
 218 #ifdef HAVE_EXECINFO_H
 219 #include <execinfo.h>
 220 #endif
 221
 222 void log_stack_trace(void)
 223 {
 224 #ifdef HAVE_LIBUNWIND
 225         /*
 226          * --with-libunwind is required to use libunwind, the
 227          * backtrace_symbols() code below is the default.
 228          *
 229          * This code is available because a previous version of this
 230          * comment asserted that on ia64 libunwind correctly walks the
 231          * stack in more circumstances than backtrace.
 232          */
 233         unw_cursor_t cursor;
 234         unw_context_t uc;
 235         unsigned i = 0;
 236
 237         char procname[256];
 238         unw_word_t ip, sp, off;
 239
 240         procname[sizeof(procname) - 1] = '\0';
 241
 242         if (unw_getcontext(&uc) != 0) {
 243                 goto libunwind_failed;
 244         }
 245
 246         if (unw_init_local(&cursor, &uc) != 0) {
 247                 goto libunwind_failed;
 248         }
 249
 250         DEBUG(0, ("BACKTRACE:\n"));
 251
 252         do {
 253             ip = sp = 0;
 254             unw_get_reg(&cursor, UNW_REG_IP, &ip);
 255             unw_get_reg(&cursor, UNW_REG_SP, &sp);
 256
 257             switch (unw_get_proc_name(&cursor,
 258                         procname, sizeof(procname) - 1, &off) ) {
 259             case 0:
 260                     /* Name found. */
 261             case -UNW_ENOMEM:
 262                     /* Name truncated. */
 263                     DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
 264                             i, procname, (long long)off,
 265                             (long long)ip, (long long) sp));
 266                     break;
 267             default:
 268             /* case -UNW_ENOINFO: */
 269             /* case -UNW_EUNSPEC: */
 270                     /* No symbol name found. */
 271                     DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
 272                             i, "<unknown symbol>",
 273                             (long long)ip, (long long) sp));
 274             }
 275             ++i;
 276         } while (unw_step(&cursor) > 0);
 277
 278         return;
 279
 280 libunwind_failed:
 281         DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
 282
 283 #elif defined(HAVE_BACKTRACE_SYMBOLS)
 284         void *backtrace_stack[BACKTRACE_STACK_SIZE];
 285         size_t backtrace_size;
 286         char **backtrace_strings;
 287
 288         /* get the backtrace (stack frames) */
 289         backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
 290         backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
 291
 292         DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
 293                   (unsigned long)backtrace_size));
 294
 295         if (backtrace_strings) {
 296                 size_t i;
 297
 298                 for (i = 0; i < backtrace_size; i++)
 299                         DEBUGADD(0, (" #%zu %s\n", i, backtrace_strings[i]));
 300
 301                 /* Leak the backtrace_strings, rather than risk what free() might do */
 302         }
 303
 304 #else
 305         DEBUG(0, ("unable to produce a stack trace on this platform\n"));
 306 #endif
 307 }