src/xbt/ex.c

   1 /* ex - Exception Handling                                                  */
   2
   3 /* Copyright (c) 2005-2015. The SimGrid Team.
   4  * All rights reserved.                                                     */
   5
   6 /*  Copyright (c) 2002-2004 Ralf S. Engelschall <rse@engelschall.com>       */
   7 /*  Copyright (c) 2002-2004 The OSSP Project <http://www.ossp.org/>         */
   8 /*  Copyright (c) 2002-2004 Cable & Wireless <http://www.cw.com/>           */
   9 /*  All rights reserved.                                                    */
  10
  11 /* This code is inspirated from the OSSP version (as retrieved back in 2004)*/
  12 /* It was heavily modified to fit the SimGrid framework.                    */
  13
  14 /* The OSSP version has the following copyright notice:
  15 **  OSSP ex - Exception Handling
  16 **  Copyright (c) 2002-2004 Ralf S. Engelschall <rse@engelschall.com>
  17 **  Copyright (c) 2002-2004 The OSSP Project <http://www.ossp.org/>
  18 **  Copyright (c) 2002-2004 Cable & Wireless <http://www.cw.com/>
  19 **
  20 **  This file is part of OSSP ex, an exception handling library
  21 **  which can be found at http://www.ossp.org/pkg/lib/ex/.
  22 **
  23 **  Permission to use, copy, modify, and distribute this software for
  24 **  any purpose with or without fee is hereby granted, provided that
  25 **  the above copyright notice and this permission notice appear in all
  26 **  copies.
  27 **
  28 **  THIS SOFTWARE IS PROVIDED `AS IS'' AND ANY EXPRESSED OR IMPLIED
  29 **  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  30 **  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  31 **  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
  32 **  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  33 **  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  34 **  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  35 **  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  36 **  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  37 **  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  38 **  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  39 **  SUCH DAMAGE.
  40  */
  41
  42 /* The extensions made for the SimGrid project can either be distributed    */
  43 /* under the same license, or under the LGPL v2.1                           */
  44
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47
  48 #include "src/portable.h"           /* execinfo when available */
  49 #include "xbt/ex.h"
  50 #include "xbt/str.h"
  51 #include "xbt/synchro_core.h"
  52 #include "src/xbt_modinter.h"       /* backtrace initialization headers */
  53
  54 #include "src/xbt/ex_interface.h"
  55 #include "simgrid/sg_config.h"  /* Configuration mechanism of SimGrid */
  56
  57 #include "simgrid/simix.h" /* SIMIX_process_self_get_name() */
  58
  59 #undef HAVE_BACKTRACE
  60 #if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE)
  61 # define HAVE_BACKTRACE 1       /* Hello linux box */
  62 #endif
  63
  64 #if defined(_WIN32) && defined(_M_IX86) && !defined(__GNUC__)
  65 # define HAVE_BACKTRACE 1       /* Hello x86 windows box */
  66 #endif
  67
  68
  69 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_ex, xbt, "Exception mecanism");
  70
  71 XBT_EXPORT_NO_IMPORT(const xbt_running_ctx_t) __xbt_ex_ctx_initializer = XBT_RUNNING_CTX_INITIALIZER;
  72
  73 /* default __ex_ctx callback function */
  74 xbt_running_ctx_t *__xbt_ex_ctx_default(void)
  75 {
  76   /* Don't scream: this is a default which is never used (so, yes,
  77      there is one setjump container by running entity).
  78
  79      This default gets overriden in xbt/xbt_os_thread.c so that it works in
  80      real life and in simulation when using threads to implement the simulation
  81      processes (ie, with pthreads and on windows).
  82
  83      It also gets overriden in xbt/context.c when using ucontexts (as well as
  84      in Java for now, but after the java overhaul, it will get cleaned out)
  85    */
  86   static xbt_running_ctx_t ctx = XBT_RUNNING_CTX_INITIALIZER;
  87
  88   return &ctx;
  89 }
  90
  91 /* Change raw libc symbols to file names and line numbers */
  92 void xbt_ex_setup_backtrace(xbt_ex_t * e);
  93
  94 void xbt_backtrace_display(xbt_ex_t * e)
  95 {
  96   xbt_ex_setup_backtrace(e);
  97
  98 #ifdef HAVE_BACKTRACE
  99   if (e->used == 0) {
 100     fprintf(stderr, "(backtrace not set)\n");
 101   } else {
 102     fprintf(stderr, "Backtrace (displayed in process %s):\n", SIMIX_process_self_get_name());
 103     for (int i = 1; i < e->used; i++)       /* no need to display "xbt_backtrace_display" */
 104       fprintf(stderr, "---> %s\n", e->bt_strings[i] + 4);
 105   }
 106
 107   /* don't fool xbt_ex_free with uninitialized msg field */
 108   e->msg = NULL;
 109   xbt_ex_free(*e);
 110 #else
 111   XBT_ERROR("No backtrace on this arch");
 112 #endif
 113 }
 114
 115 /** \brief show the backtrace of the current point (lovely while debuging) */
 116 void xbt_backtrace_display_current(void)
 117 {
 118   xbt_ex_t e;
 119   xbt_backtrace_current(&e);
 120   xbt_backtrace_display(&e);
 121 }
 122
 123 #if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE)
 124 # include "src/xbt/backtrace_linux.c"
 125 #elif (defined(_WIN32) && defined (_M_IX86)) && !defined(__GNUC__)
 126 # include "src/xbt/backtrace_windows.c"
 127 #else
 128 # include "src/xbt/backtrace_dummy.c"
 129 #endif
 130
 131 /** @brief shows an exception content and the associated stack if available */
 132 void xbt_ex_display(xbt_ex_t * e)
 133 {
 134   char *thrower = NULL;
 135   if (e->pid != xbt_getpid())
 136     thrower = bprintf(" on process %d",e->pid);
 137
 138   fprintf(stderr,
 139           "** SimGrid: UNCAUGHT EXCEPTION received on %s(%d): category: %s; value: %d\n"
 140           "** %s\n"
 141           "** Thrown by %s()%s\n",
 142           xbt_binary_name, xbt_getpid(),
 143           xbt_ex_catname(e->category), e->value, e->msg,
 144           e->procname, thrower ? thrower : " in this process");
 145   XBT_CRITICAL("%s", e->msg);
 146   xbt_free(thrower);
 147
 148   if (xbt_initialized==0 || smx_cleaned) {
 149     fprintf(stderr, "Ouch. SimGrid is not initialized yet, or already closing. No backtrace available.\n");
 150     return; /* Not started yet or already closing. Trying to generate a backtrace would probably fail */
 151   }
 152
 153   if (!e->bt_strings)
 154     xbt_ex_setup_backtrace(e);
 155
 156 #ifdef HAVE_BACKTRACE
 157   if (e->used && e->bt_strings) {
 158     /* We have everything to build neat backtraces */
 159     int i;
 160     int cutpath = 0;
 161     TRY { // We don't want to have an exception while checking how to deal with the one we already have, do we?
 162       cutpath = sg_cfg_get_boolean("exception/cutpath");
 163     } CATCH_ANONYMOUS { }
 164
 165     fprintf(stderr, "\n");
 166     for (i = 0; i < e->used; i++) {
 167
 168       if (cutpath) {
 169         char* p = e->bt_strings[i];
 170         xbt_str_rtrim(p, ":0123456789");
 171         char* filename = strrchr(p, '/')+1;
 172         char* end_of_message  = strrchr(p, ' ');
 173
 174         int length = strlen(p)-strlen(end_of_message);
 175         char* dest = malloc(length);
 176
 177         memcpy(dest, &p[0], length);
 178         dest[length] = 0;
 179
 180         fprintf(stderr, "%s %s\n", dest, filename);
 181
 182         free(dest);
 183       }
 184       else {
 185         fprintf(stderr, "%s\n", e->bt_strings[i]);
 186       }
 187     }
 188
 189   } else
 190 #endif
 191     fprintf(stderr, "\n"
 192         "**   In %s() at %s:%d\n"
 193         "**   (no backtrace available)\n", e->func, e->file, e->line);
 194 }
 195
 196
 197 /* default __ex_terminate callback function */
 198 void __xbt_ex_terminate_default(xbt_ex_t * e)
 199 {
 200   xbt_ex_display(e);
 201   xbt_abort();
 202 }
 203
 204 /* the externally visible API */
 205 XBT_EXPORT_NO_IMPORT(xbt_running_ctx_fetcher_t) __xbt_running_ctx_fetch = &__xbt_ex_ctx_default;
 206 XBT_EXPORT_NO_IMPORT(ex_term_cb_t) __xbt_ex_terminate = &__xbt_ex_terminate_default;
 207
 208
 209 void xbt_ex_free(xbt_ex_t e)
 210 {
 211   free(e.msg);
 212
 213   if (e.bt_strings) {
 214     for (int i = 0; i < e.used; i++)
 215       free(e.bt_strings[i]);
 216     free(e.bt_strings);
 217   }
 218 }
 219
 220 /** \brief returns a short name for the given exception category */
 221 const char *xbt_ex_catname(xbt_errcat_t cat)
 222 {
 223   switch (cat) {
 224   case unknown_error:
 225     return "unknown error";
 226   case arg_error:
 227     return "invalid argument";
 228   case bound_error:
 229     return "out of bounds";
 230   case mismatch_error:
 231     return "mismatch";
 232   case not_found_error:
 233     return "not found";
 234   case system_error:
 235     return "system error";
 236   case network_error:
 237     return "network error";
 238   case timeout_error:
 239     return "timeout";
 240   case cancel_error:
 241     return "action canceled";
 242   case thread_error:
 243     return "thread error";
 244   case host_error:
 245     return "host failed";
 246   case tracing_error:
 247     return "tracing error";
 248   case io_error:
 249     return "io error";
 250   case vm_error:
 251     return "vm error";
 252
 253   }
 254   return "INVALID ERROR";
 255 }
 256
 257
 258 #ifdef SIMGRID_TEST
 259 #include <stdio.h>
 260 #include "xbt/ex.h"
 261
 262 XBT_TEST_SUITE("xbt_ex", "Exception Handling");
 263
 264 XBT_TEST_UNIT("controlflow", test_controlflow, "basic nested control flow")
 265 {
 266   xbt_ex_t ex;
 267   volatile int n = 1;
 268
 269   xbt_test_add("basic nested control flow");
 270
 271   TRY {
 272     if (n != 1)
 273       xbt_test_fail("M1: n=%d (!= 1)", n);
 274     n++;
 275     TRY {
 276       if (n != 2)
 277         xbt_test_fail("M2: n=%d (!= 2)", n);
 278       n++;
 279       THROWF(unknown_error, 0, "something");
 280     }
 281     CATCH(ex) {
 282       if (n != 3)
 283         xbt_test_fail("M3: n=%d (!= 3)", n);
 284       n++;
 285       xbt_ex_free(ex);
 286     }
 287     n++;
 288     TRY {
 289       if (n != 5)
 290         xbt_test_fail("M2: n=%d (!= 5)", n);
 291       n++;
 292       THROWF(unknown_error, 0, "something");
 293     }
 294     CATCH_ANONYMOUS {
 295       if (n != 6)
 296         xbt_test_fail("M3: n=%d (!= 6)", n);
 297       n++;
 298       RETHROW;
 299       n++;
 300     }
 301     xbt_test_fail("MX: n=%d (shouldn't reach this point)", n);
 302   }
 303   CATCH(ex) {
 304     if (n != 7)
 305       xbt_test_fail("M4: n=%d (!= 7)", n);
 306     n++;
 307     xbt_ex_free(ex);
 308   }
 309   if (n != 8)
 310     xbt_test_fail("M5: n=%d (!= 8)", n);
 311 }
 312
 313 XBT_TEST_UNIT("value", test_value, "exception value passing")
 314 {
 315   xbt_ex_t ex;
 316
 317   TRY {
 318     THROWF(unknown_error, 2, "toto");
 319   }
 320   CATCH(ex) {
 321     xbt_test_add("exception value passing");
 322     if (ex.category != unknown_error)
 323       xbt_test_fail("category=%d (!= 1)", (int)ex.category);
 324     if (ex.value != 2)
 325       xbt_test_fail("value=%d (!= 2)", ex.value);
 326     if (strcmp(ex.msg, "toto"))
 327       xbt_test_fail("message=%s (!= toto)", ex.msg);
 328     xbt_ex_free(ex);
 329   }
 330 }
 331
 332 XBT_TEST_UNIT("variables", test_variables, "variable value preservation")
 333 {
 334   xbt_ex_t ex;
 335   int r1;
 336   int XBT_ATTRIB_UNUSED r2;
 337   int v1;
 338   volatile int v2;
 339
 340   r1 = r2 = v1 = v2 = 1234;
 341   TRY {
 342     r2 = 5678;
 343     v2 = 5678;
 344     THROWF(unknown_error, 0, "toto");
 345   }
 346   CATCH(ex) {
 347     xbt_test_add("variable preservation");
 348     if (r1 != 1234)
 349       xbt_test_fail("r1=%d (!= 1234)", r1);
 350     if (v1 != 1234)
 351       xbt_test_fail("v1=%d (!= 1234)", v1);
 352     /* r2 is allowed to be destroyed because not volatile */
 353     if (v2 != 5678)
 354       xbt_test_fail("v2=%d (!= 5678)", v2);
 355     xbt_ex_free(ex);
 356   }
 357 }
 358
 359 XBT_TEST_UNIT("cleanup", test_cleanup, "cleanup handling")
 360 {
 361   xbt_ex_t ex;
 362   volatile int v1;
 363   int c;
 364
 365   xbt_test_add("cleanup handling");
 366
 367   v1 = 1234;
 368   c = 0;
 369   TRY {
 370     v1 = 5678;
 371     THROWF(1, 2, "blah");
 372   }
 373   TRY_CLEANUP {
 374     if (v1 != 5678)
 375       xbt_test_fail("v1 = %d (!= 5678)", v1);
 376     c = 1;
 377   }
 378   CATCH(ex) {
 379     if (v1 != 5678)
 380       xbt_test_fail("v1 = %d (!= 5678)", v1);
 381     if (!(ex.category == 1 && ex.value == 2 && !strcmp(ex.msg, "blah")))
 382       xbt_test_fail("unexpected exception contents");
 383     xbt_ex_free(ex);
 384   }
 385   if (!c)
 386     xbt_test_fail("xbt_ex_free not executed");
 387 }
 388
 389
 390 /*
 391  * The following is the example included in the documentation. It's a good
 392  * idea to check its syntax even if we don't try to run it.
 393  * And actually, it allows to put comments in the code despite doxygen.
 394  */
 395 static char *mallocex(int size)
 396 {
 397   return NULL;
 398 }
 399
 400 #define SMALLAMOUNT 10
 401 #define TOOBIG 100000000
 402
 403 typedef struct {
 404   char *first;
 405 } global_context_t;
 406
 407 static void good_example(void)
 408 {
 409   global_context_t *global_context = xbt_malloc(sizeof(global_context_t));
 410
 411   /* GOOD_EXAMPLE */
 412   {                             /*01 */
 413     char *volatile /*03 */ cp1 = NULL /*02 */ ;
 414     char *volatile /*03 */ cp2 = NULL /*02 */ ;
 415     char *volatile /*03 */ cp3 = NULL /*02 */ ;
 416     TRY {
 417       cp1 = mallocex(SMALLAMOUNT);
 418       global_context->first = cp1;
 419       cp1 = NULL /*05 give away */ ;
 420       cp2 = mallocex(TOOBIG);
 421       cp3 = mallocex(SMALLAMOUNT);
 422       strcpy(cp1, "foo");
 423       strcpy(cp2, "bar");
 424     }
 425     TRY_CLEANUP {               /*04 */
 426       printf("cp3=%s", cp3 == NULL /*02 */ ? "" : cp3);
 427       free(cp3);
 428       free(cp2);
 429       /*05 cp1 was given away */
 430     }
 431     CATCH_ANONYMOUS {
 432       /*05 global context untouched */
 433       RETHROW;
 434     }
 435   }
 436   /* end_of_good_example */
 437 }
 438 #endif                          /* SIMGRID_TEST */