src/xbt/ex.cpp

   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 <xbt/backtrace.hpp>
  49 #include "src/internal_config.h"           /* execinfo when available */
  50 #include "xbt/ex.h"
  51 #include "xbt/log.h"
  52 #include "xbt/log.hpp"
  53 #include "xbt/backtrace.h"
  54 #include "xbt/backtrace.hpp"
  55 #include "xbt/str.h"
  56 #include "xbt/synchro_core.h"
  57 #include "src/xbt_modinter.h"       /* backtrace initialization headers */
  58
  59 #include "src/xbt/ex_interface.h"
  60 #include "simgrid/sg_config.h"  /* Configuration mechanism of SimGrid */
  61
  62 #include "simgrid/simix.h" /* SIMIX_process_self_get_name() */
  63
  64
  65 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_ex, xbt, "Exception mechanism");
  66
  67 xbt_ex::~xbt_ex() {}
  68
  69 /* Change raw libc symbols to file names and line numbers */
  70 void xbt_setup_backtrace(xbt_backtrace_location_t** loc, std::size_t count,
  71   char** res);
  72
  73 void xbt_backtrace_display(xbt_backtrace_location_t* loc, std::size_t count)
  74 {
  75 #ifdef HAVE_BACKTRACE
  76   std::vector<std::string> backtrace =
  77     simgrid::xbt::resolveBacktrace(loc, count);
  78   if (backtrace.empty()) {
  79     fprintf(stderr, "(backtrace not set)\n");
  80     return;
  81   }
  82   fprintf(stderr, "Backtrace (displayed in process %s):\n", SIMIX_process_self_get_name());
  83   for (std::string const& s : backtrace)
  84     fprintf(stderr, "---> %s\n", s.c_str());
  85 #else
  86   XBT_ERROR("No backtrace on this arch");
  87 #endif
  88 }
  89
  90 void xbt_throw(
  91   char* message, xbt_errcat_t errcat, int value,
  92   const char* file, int line, const char* func)
  93 {
  94   xbt_ex e(message);
  95   free(message);
  96   e.category = errcat;
  97   e.value = value;
  98   e.file = file;
  99   e.line = line;
 100   e.func = func;
 101   throw e;
 102 }
 103
 104 /** @brief shows an exception content and the associated stack if available */
 105 void xbt_ex_display(xbt_ex_t * e)
 106 {
 107   simgrid::xbt::logException(xbt_log_priority_critical, "UNCAUGHT EXCEPTION", *e);
 108 }
 109
 110 /** \brief returns a short name for the given exception category */
 111 const char *xbt_ex_catname(xbt_errcat_t cat)
 112 {
 113   switch (cat) {
 114   case unknown_error:
 115     return "unknown error";
 116   case arg_error:
 117     return "invalid argument";
 118   case bound_error:
 119     return "out of bounds";
 120   case mismatch_error:
 121     return "mismatch";
 122   case not_found_error:
 123     return "not found";
 124   case system_error:
 125     return "system error";
 126   case network_error:
 127     return "network error";
 128   case timeout_error:
 129     return "timeout";
 130   case cancel_error:
 131     return "action canceled";
 132   case thread_error:
 133     return "thread error";
 134   case host_error:
 135     return "host failed";
 136   case tracing_error:
 137     return "tracing error";
 138   case io_error:
 139     return "io error";
 140   case vm_error:
 141     return "vm error";
 142   }
 143   return "INVALID ERROR";
 144 }
 145
 146 #ifdef SIMGRID_TEST
 147 #include <stdio.h>
 148 #include "xbt/ex.h"
 149
 150 XBT_TEST_SUITE("xbt_ex", "Exception Handling");
 151
 152 XBT_TEST_UNIT("controlflow", test_controlflow, "basic nested control flow")
 153 {
 154   xbt_ex_t ex;
 155   int n = 1;
 156
 157   xbt_test_add("basic nested control flow");
 158
 159   try {
 160     if (n != 1)
 161       xbt_test_fail("M1: n=%d (!= 1)", n);
 162     n++;
 163     try {
 164       if (n != 2)
 165         xbt_test_fail("M2: n=%d (!= 2)", n);
 166       n++;
 167       THROWF(unknown_error, 0, "something");
 168     }
 169     catch (xbt_ex& ex) {
 170       if (n != 3)
 171         xbt_test_fail("M3: n=%d (!= 3)", n);
 172       n++;
 173     }
 174     n++;
 175     try {
 176       if (n != 5)
 177         xbt_test_fail("M2: n=%d (!= 5)", n);
 178       n++;
 179       THROWF(unknown_error, 0, "something");
 180     }
 181     catch(xbt_ex& ex){
 182       if (n != 6)
 183         xbt_test_fail("M3: n=%d (!= 6)", n);
 184       n++;
 185       throw;
 186       n++;
 187     }
 188     xbt_test_fail("MX: n=%d (shouldn't reach this point)", n);
 189   }
 190   catch(xbt_ex& e) {
 191     if (n != 7)
 192       xbt_test_fail("M4: n=%d (!= 7)", n);
 193     n++;
 194   }
 195   if (n != 8)
 196     xbt_test_fail("M5: n=%d (!= 8)", n);
 197 }
 198
 199 XBT_TEST_UNIT("value", test_value, "exception value passing")
 200 {
 201   try {
 202     THROWF(unknown_error, 2, "toto");
 203   }
 204   catch (xbt_ex& ex) {
 205     xbt_test_add("exception value passing");
 206     if (ex.category != unknown_error)
 207       xbt_test_fail("category=%d (!= 1)", (int)ex.category);
 208     if (ex.value != 2)
 209       xbt_test_fail("value=%d (!= 2)", ex.value);
 210     if (strcmp(ex.what(), "toto"))
 211       xbt_test_fail("message=%s (!= toto)", ex.what());
 212   }
 213 }
 214
 215 XBT_TEST_UNIT("variables", test_variables, "variable value preservation")
 216 {
 217   xbt_ex_t ex;
 218   int r1;
 219   int XBT_ATTRIB_UNUSED r2;
 220   int v1;
 221   int v2;
 222
 223   r1 = r2 = v1 = v2 = 1234;
 224   try {
 225     r2 = 5678;
 226     v2 = 5678;
 227     THROWF(unknown_error, 0, "toto");
 228   }
 229   catch(xbt_ex& e) {
 230     xbt_test_add("variable preservation");
 231     if (r1 != 1234)
 232       xbt_test_fail("r1=%d (!= 1234)", r1);
 233     if (v1 != 1234)
 234       xbt_test_fail("v1=%d (!= 1234)", v1);
 235     /* r2 is allowed to be destroyed because not volatile */
 236     if (v2 != 5678)
 237       xbt_test_fail("v2=%d (!= 5678)", v2);
 238   }
 239 }
 240
 241 XBT_TEST_UNIT("cleanup", test_cleanup, "cleanup handling")
 242 {
 243   int v1;
 244   int c;
 245
 246   xbt_test_add("cleanup handling");
 247
 248   v1 = 1234;
 249   c = 0;
 250   try {
 251     v1 = 5678;
 252     THROWF(1, 2, "blah");
 253   }
 254   catch (xbt_ex& ex) {
 255     if (v1 != 5678)
 256       xbt_test_fail("v1 = %d (!= 5678)", v1);
 257     c = 1;
 258     if (v1 != 5678)
 259       xbt_test_fail("v1 = %d (!= 5678)", v1);
 260     if (!(ex.category == 1 && ex.value == 2 && !strcmp(ex.what(), "blah")))
 261       xbt_test_fail("unexpected exception contents");
 262   }
 263   if (!c)
 264     xbt_test_fail("xbt_ex_free not executed");
 265 }
 266 #endif                          /* SIMGRID_TEST */