Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Actually use given parameters.
[simgrid.git] / src / xbt / exception.cpp
1 /* Copyright (c) 2005-2018. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "simgrid/Exception.hpp"
7 #include <xbt/config.hpp>
8 #include <xbt/log.hpp>
9
10 #include <mutex>
11 #include <sstream>
12
13 XBT_LOG_EXTERNAL_CATEGORY(xbt);
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_exception, xbt, "Exceptions");
15
16 // DO NOT define ~xbt_ex() in exception.hpp.
17 // Defining it here ensures that xbt_ex is defined only in libsimgrid, but not in libsimgrid-java.
18 // Doing otherwise naturally breaks things (at least on freebsd with clang).
19
20 xbt_ex::~xbt_ex() = default;
21
22 void _xbt_throw(char* message, xbt_errcat_t errcat, int value, const char* file, int line, const char* func)
23 {
24   xbt_ex e(simgrid::xbt::ThrowPoint(file, line, func, simgrid::xbt::backtrace(), xbt_procname(), xbt_getpid()),
25            message);
26   xbt_free(message);
27   e.category = errcat;
28   e.value    = value;
29   throw e;
30 }
31
32 /** @brief shows an exception content and the associated stack if available */
33 void xbt_ex_display(xbt_ex_t* e)
34 {
35   simgrid::xbt::log_exception(xbt_log_priority_critical, "UNCAUGHT EXCEPTION", *e);
36 }
37
38 /** @brief returns a short name for the given exception category */
39 const char* xbt_ex_catname(xbt_errcat_t cat)
40 {
41   switch (cat) {
42     case unknown_error:
43       return "unknown error";
44     case arg_error:
45       return "invalid argument";
46     case bound_error:
47       return "out of bounds";
48     case mismatch_error:
49       return "mismatch";
50     case not_found_error:
51       return "not found";
52     case system_error:
53       return "system error";
54     case network_error:
55       return "network error";
56     case timeout_error:
57       return "timeout";
58     case cancel_error:
59       return "action canceled";
60     case thread_error:
61       return "thread error";
62     case host_error:
63       return "host failed";
64     case tracing_error:
65       return "tracing error";
66     case io_error:
67       return "io error";
68     case vm_error:
69       return "vm error";
70     default:
71       return "INVALID ERROR";
72   }
73   return "INVALID ERROR";
74 }
75
76 namespace simgrid {
77 namespace xbt {
78
79 void log_exception(e_xbt_log_priority_t prio, const char* context, std::exception const& exception)
80 {
81   try {
82     auto name = simgrid::xbt::demangle(typeid(exception).name());
83
84     auto* with_context = dynamic_cast<const simgrid::Exception*>(&exception);
85     if (with_context != nullptr)
86       XBT_LOG(prio, "%s %s by %s/%d: %s", context, name.get(), with_context->throw_point().procname_.c_str(),
87               with_context->throw_point().pid_, exception.what());
88     else
89       XBT_LOG(prio, "%s %s: %s", context, name.get(), exception.what());
90
91     // Do we have a backtrace?
92     if (with_context != nullptr && not simgrid::config::get_value<bool>("exception/cutpath")) {
93       auto backtrace = simgrid::xbt::resolve_backtrace(with_context->throw_point().backtrace_.data(),
94                                                        with_context->throw_point().backtrace_.size());
95       for (std::string const& s : backtrace)
96         XBT_LOG(prio, "  -> %s", s.c_str());
97     }
98
99     // Do we have a nested exception?
100     auto* with_nested = dynamic_cast<const std::nested_exception*>(&exception);
101     if (with_nested == nullptr ||  with_nested->nested_ptr() == nullptr)
102       return;
103     try {
104       with_nested->rethrow_nested();
105     }
106     catch (std::exception& nested_exception) {
107       log_exception(prio, "Caused by", nested_exception);
108     }
109     // We could catch nested_exception or WithContextException but we don't bother:
110     catch (...) {
111       XBT_LOG(prio, "Caused by an unknown exception");
112     }
113   }
114   catch (...) {
115     // Don't log exceptions we got when trying to log exception
116   }
117 }
118
119 static void showBacktrace(std::vector<xbt_backtrace_location_t>& bt)
120 {
121   if (simgrid::config::get_value<bool>("exception/cutpath")) {
122     XBT_LOG(xbt_log_priority_critical, "Display of current backtrace disabled by --cfg=exception/cutpath.");
123     return;
124   }
125   std::vector<std::string> res = resolve_backtrace(&bt[0], bt.size());
126   XBT_LOG(xbt_log_priority_critical, "Current backtrace:");
127   for (std::string const& s : res)
128     XBT_LOG(xbt_log_priority_critical, "  -> %s", s.c_str());
129 }
130
131 static std::terminate_handler previous_terminate_handler = nullptr;
132
133 static void handler()
134 {
135   // Avoid doing crazy things if we get an uncaught exception inside
136   // an uncaught exception
137   static std::atomic_flag lock = ATOMIC_FLAG_INIT;
138   if (lock.test_and_set()) {
139     XBT_ERROR("Handling an exception raised an exception. Bailing out.");
140     std::abort();
141   }
142
143   // Get the current backtrace and exception
144   auto e = std::current_exception();
145   auto bt = backtrace();
146   try {
147     std::rethrow_exception(e);
148   }
149
150   // We manage C++ exception ourselves
151   catch (std::exception& e) {
152     log_exception(xbt_log_priority_critical, "Uncaught exception", e);
153     showBacktrace(bt);
154     std::abort();
155   }
156
157   // We don't know how to manage other exceptions
158   catch (...) {
159     // If there was another handler let's delegate to it
160     if (previous_terminate_handler)
161       previous_terminate_handler();
162     else {
163       XBT_ERROR("Unknown uncaught exception");
164       showBacktrace(bt);
165       std::abort();
166     }
167   }
168
169 }
170
171 void install_exception_handler()
172 {
173   static std::once_flag handler_flag;
174   std::call_once(handler_flag, [] {
175     previous_terminate_handler = std::set_terminate(handler);
176   });
177 }
178 // deprecated
179 void logException(e_xbt_log_priority_t priority, const char* context, std::exception const& exception)
180 {
181   log_exception(priority, context, exception);
182 }
183 void installExceptionHandler()
184 {
185   install_exception_handler();
186 }
187
188 } // namespace xbt
189 } // namespace simgrid
190
191 void xbt_throw_impossible(const char* file, int line, const char* func)
192 {
193   std::stringstream ss;
194   ss << file << ":" << line << ":" << func << ": The Impossible Did Happen (yet again). Please report this bug.";
195   throw std::runtime_error(ss.str());
196 }
197 void xbt_throw_unimplemented(const char* file, int line, const char* func)
198 {
199   std::stringstream ss;
200   ss << file << ":" << line << ":" << func << ": Feature unimplemented yet. Please report this bug.";
201   throw std::runtime_error(ss.str());
202 }