src/xbt/ex.c

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