Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
8760a893d39444f38a76b1f7381e2c7647815050
[simgrid.git] / src / xbt / backtrace_linux.cpp
1 /* backtrace_linux - backtrace displaying on linux platform                 */
2 /* This file is included by ex.cpp on need (have execinfo.h, popen & addrline)*/
3
4 /* Copyright (c) 2008-2017. The SimGrid Team. All rights reserved.          */
5
6 /* This program is free software; you can redistribute it and/or modify it
7  * under the terms of the license (GNU LGPL) which comes with this package. */
8
9 #include <sstream>
10 #include <string>
11 #include <vector>
12
13 #include <boost/algorithm/string.hpp>
14
15 #include <unistd.h>
16 #include <execinfo.h>
17 #include <sys/stat.h>
18
19 /* This file is to be included in ex.cpp, so the following headers are not mandatory, but it's to make sure that eclipse see them too */
20 #include <xbt/string.hpp>
21 #include <xbt/backtrace.hpp>
22 #include "xbt/ex.h"
23 #include "xbt/log.h"
24 #include "xbt/str.h"
25 #include "xbt/module.h"         /* xbt_binary_name */
26 #include "src/xbt_modinter.h"       /* backtrace initialization headers */
27 #if SIMGRID_HAVE_MC
28 #define UNW_LOCAL_ONLY
29 #include <libunwind.h>
30 #endif
31 /* end of "useless" inclusions */
32
33 extern char **environ;          /* the environment, as specified by the opengroup */
34
35 #include <unwind.h>
36 struct trace_arg {
37   void** array;
38   int cnt;
39   int size;
40 };
41
42 static _Unwind_Reason_Code
43 backtrace_helper (struct _Unwind_Context *ctx, void *a)
44 {
45   struct trace_arg *arg = (struct trace_arg *) a;
46
47   /* We are first called with address in the __backtrace function.
48      Skip it.  */
49   if (arg->cnt != -1)
50     {
51       arg->array[arg->cnt] = (void *) _Unwind_GetIP(ctx);
52
53       /* Check whether we make any progress.  */
54       if (arg->cnt > 0 && arg->array[arg->cnt - 1] == arg->array[arg->cnt])
55         return _URC_END_OF_STACK;
56     }
57   if (++arg->cnt == arg->size)
58     return _URC_END_OF_STACK;
59   return _URC_NO_REASON;
60 }
61
62 /** @brief reimplementation of glibc backtrace based directly on gcc library, without implicit malloc
63  *
64  * See http://people.irisa.fr/Martin.Quinson/blog/2012/0208/system_programming_fun_in_SimGrid/
65  * for the motivation behind this function
66  * */
67
68 int xbt_backtrace_no_malloc(void **array, int size) {
69   int i = 0;
70   for(i=0; i < size; i++)
71     array[i] = nullptr;
72
73   struct trace_arg arg;
74   arg .array = array;
75   arg.size = size;
76   arg.cnt = -1;
77
78   if (size >= 1)
79     _Unwind_Backtrace(backtrace_helper, &arg);
80
81   /* _Unwind_Backtrace on IA-64 seems to put nullptr address above
82      _start.  Fix it up here.  */
83   if (arg.cnt > 1 && arg.array[arg.cnt - 1] == nullptr)
84     --arg.cnt;
85   return arg.cnt != -1 ? arg.cnt : 0;
86 }
87
88 size_t xbt_backtrace_current(xbt_backtrace_location_t* loc, std::size_t count)
89 {
90   std::size_t used = backtrace(loc, count);
91   if (used == 0) {
92     std::fprintf(stderr, "The backtrace() function failed, which probably means that the memory is exhausted\n.");
93     std::fprintf(stderr, "Bailing out now since there is nothing I can do without a decent amount of memory\n.");
94     std::fprintf(stderr, "Please go fix the memleaks\n");
95     std::exit(1);
96   }
97   return used;
98 }
99
100 namespace simgrid {
101 namespace xbt {
102
103 /** Find the path of the binary file from the name found in argv */
104 static std::string get_binary_path()
105 {
106   struct stat stat_buf;
107
108   if (xbt_binary_name == nullptr)
109     return "";
110
111   // We found it, we are happy:
112   if (stat(xbt_binary_name, &stat_buf) == 0)
113     return xbt_binary_name;
114
115   // Not found, look in the PATH:
116   char* path = getenv("PATH");
117   if (path == nullptr)
118     return "";
119   XBT_DEBUG("Looking in the PATH: %s\n", path);
120   std::vector<std::string> path_list;
121   // TODO, on Windows, this is ";"
122   boost::split(path_list, path, boost::is_any_of(":"));
123   for (std::string const& path_item : path_list) {
124     std::string binary_name = simgrid::xbt::string_printf(
125       "%s/%s", path_item.c_str(), xbt_binary_name);
126     bool found = (stat(binary_name.c_str(), &stat_buf) == 0);
127     XBT_DEBUG("Looked in the PATH for the binary. %s %s",
128       found ? "Found" : "Not found",
129       binary_name.c_str());
130     if (found)
131       return binary_name;
132   }
133
134   // Not found at all:
135   return "";
136 }
137
138 //FIXME: This code could be greatly improved/simplifyied with
139 //   http://cairo.sourcearchive.com/documentation/1.9.4/backtrace-symbols_8c-source.html
140 std::vector<std::string> resolveBacktrace(
141   xbt_backtrace_location_t const* loc, std::size_t count)
142 {
143   std::vector<std::string> result;
144
145   if (count == 0)
146     return result;
147
148   if (xbt_binary_name == nullptr)
149     XBT_WARN("XBT not initialized, the backtrace will not be resolved.");
150
151   // Drop the first one:
152   loc++; count--;
153
154   char** backtrace_syms = backtrace_symbols(loc, count);
155   std::string binary_name = get_binary_path();
156
157   if (binary_name.empty()) {
158     for (std::size_t i = 0; i < count; i++)
159       result.push_back(simgrid::xbt::string_printf("%p", loc[i]));
160     return result;
161   }
162
163   // Create the system command for add2line:
164   std::ostringstream stream;
165   stream << ADDR2LINE << " -f -e " << binary_name << ' ';
166   std::vector<std::string> addrs(count);
167   for (std::size_t i = 0; i < count; i++) {
168     /* retrieve this address */
169     XBT_DEBUG("Retrieving address number %zd from '%s'", i, backtrace_syms[i]);
170     char buff[256];
171     snprintf(buff, 256, "%s", strchr(backtrace_syms[i], '[') + 1);
172     char* p = strchr(buff, ']');
173     *p = '\0';
174     if (strcmp(buff, "(nil)"))
175       addrs[i] = buff;
176     else
177       addrs[i] = "0x0";
178     XBT_DEBUG("Set up a new address: %zd, '%s'", i, addrs[i].c_str());
179     /* Add it to the command line args */
180     stream << addrs[i] << ' ';
181   }
182   std::string cmd = stream.str();
183
184   /* size (in char) of pointers on this arch */
185   int addr_len = addrs[0].size();
186
187   XBT_VERB("Fire a first command: '%s'", cmd.c_str());
188   FILE* pipe = popen(cmd.c_str(), "r");
189   if (not pipe) {
190     xbt_die("Cannot fork addr2line to display the backtrace");
191   }
192
193   /* To read the output of addr2line */
194   char line_func[1024];
195   char line_pos[1024];
196   for (std::size_t i = 0; i < count; i++) {
197     XBT_DEBUG("Looking for symbol %zd, addr = '%s'", i, addrs[i].c_str());
198     if (fgets(line_func, 1024, pipe)) {
199       line_func[strlen(line_func) - 1] = '\0';
200     } else {
201       XBT_VERB("Cannot run fgets to look for symbol %zd, addr %s", i, addrs[i].c_str());
202       strncpy(line_func, "???",3);
203     }
204     if (fgets(line_pos, 1024, pipe)) {
205       line_pos[strlen(line_pos) - 1] = '\0';
206     } else {
207       XBT_VERB("Cannot run fgets to look for symbol %zd, addr %s", i, addrs[i].c_str());
208       strncpy(line_pos, backtrace_syms[i],1024);
209     }
210
211     if (strcmp("??", line_func) != 0) {
212       auto name = simgrid::xbt::demangle(line_func);
213       XBT_DEBUG("Found static symbol %s at %s", name.get(), line_pos);
214       result.push_back(simgrid::xbt::string_printf(
215         "%s at %s, %p", name.get(), line_pos, loc[i]
216       ));
217     } else {
218       /* Damn. The symbol is in a dynamic library. Let's get wild */
219
220       char maps_buff[512];
221       long int offset = 0;
222       char* p;
223       int found = 0;
224
225       /* let's look for the offset of this library in our addressing space */
226       char* maps_name = bprintf("/proc/%d/maps", (int) getpid());
227       FILE* maps = fopen(maps_name, "r");
228
229       long int addr = strtol(addrs[i].c_str(), &p, 16);
230       if (*p != '\0') {
231         XBT_CRITICAL("Cannot parse backtrace address '%s' (addr=%#lx)",
232           addrs[i].c_str(), addr);
233       }
234       XBT_DEBUG("addr=%s (as string) =%#lx (as number)",
235         addrs[i].c_str(), addr);
236
237       while (not found) {
238         long int first;
239         long int last;
240
241         if (fgets(maps_buff, 512, maps) == nullptr)
242           break;
243         if (i == 0) {
244           maps_buff[strlen(maps_buff) - 1] = '\0';
245           XBT_DEBUG("map line: %s", maps_buff);
246         }
247         sscanf(maps_buff, "%lx", &first);
248         p = strchr(maps_buff, '-') + 1;
249         sscanf(p, "%lx", &last);
250         if (first < addr && addr < last) {
251           offset = first;
252           found = 1;
253         }
254         if (found) {
255           XBT_DEBUG("%#lx in [%#lx-%#lx]", addr, first, last);
256           XBT_DEBUG("Symbol found, map lines not further displayed (even if looking for next ones)");
257         }
258       }
259       fclose(maps);
260       free(maps_name);
261       addrs[i].clear();
262
263       if (not found) {
264         XBT_VERB("Problem while reading the maps file. Following backtrace will be mangled.");
265         XBT_DEBUG("No dynamic. Static symbol: %s", backtrace_syms[i]);
266         result.push_back(simgrid::xbt::string_printf("?? (%s)", backtrace_syms[i]));
267         continue;
268       }
269
270       /* Ok, Found the offset of the maps line containing the searched symbol.
271          We now need to substract this from the address we got from backtrace.
272        */
273
274       addrs[i] = simgrid::xbt::string_printf("0x%0*lx", addr_len - 2, addr - offset);
275       XBT_DEBUG("offset=%#lx new addr=%s", offset, addrs[i].c_str());
276
277       /* Got it. We have our new address. Let's get the library path and we are set */
278       p = xbt_strdup(backtrace_syms[i]);
279       if (p[0] == '[') {
280         /* library path not displayed in the map file either... */
281         free(p);
282         snprintf(line_func,3, "??");
283       } else {
284         char* p2 = strrchr(p, '(');
285         if (p2)
286           *p2 = '\0';
287         p2 = strrchr(p, ' ');
288         if (p2)
289           *p2 = '\0';
290
291         /* Here we go, fire an addr2line up */
292         char* subcmd = bprintf("%s -f -e %s %s", ADDR2LINE, p, addrs[i].c_str());
293         free(p);
294         XBT_VERB("Fire a new command: '%s'", subcmd);
295         FILE* subpipe = popen(subcmd, "r");
296         if (not subpipe) {
297           xbt_die("Cannot fork addr2line to display the backtrace");
298         }
299         if (fgets(line_func, 1024, subpipe)) {
300           line_func[strlen(line_func) - 1] = '\0';
301         } else {
302           XBT_VERB("Cannot read result of subcommand %s", subcmd);
303           strncpy(line_func, "???",3);
304         }
305         if (fgets(line_pos, 1024, subpipe)) {
306           line_pos[strlen(line_pos) - 1] = '\0';
307         } else {
308           XBT_VERB("Cannot read result of subcommand %s", subcmd);
309           strncpy(line_pos, backtrace_syms[i],1024);
310         }
311         pclose(subpipe);
312         free(subcmd);
313       }
314
315       /* check whether the trick worked */
316       if (strcmp("??", line_func)) {
317         auto name = simgrid::xbt::demangle(line_func);
318         XBT_DEBUG("Found dynamic symbol %s at %s", name.get(), line_pos);
319         result.push_back(simgrid::xbt::string_printf(
320           "%s at %s, %p", name.get(), line_pos, loc[i]));
321       } else {
322         /* damn, nothing to do here. Let's print the raw address */
323         XBT_DEBUG("Dynamic symbol not found. Raw address = %s", backtrace_syms[i]);
324         result.push_back(simgrid::xbt::string_printf(
325           "?? at %s", backtrace_syms[i]));
326       }
327     }
328     addrs[i].clear();
329
330     /* Mask the bottom of the stack */
331     if (not strncmp("main", line_func, strlen("main")) ||
332         not strncmp("xbt_thread_context_wrapper", line_func, strlen("xbt_thread_context_wrapper")) ||
333         not strncmp("smx_ctx_sysv_wrapper", line_func, strlen("smx_ctx_sysv_wrapper")))
334       break;
335   }
336   pclose(pipe);
337   free(backtrace_syms);
338   return result;
339 }
340
341 }
342 }
343
344 #if SIMGRID_HAVE_MC
345 int xbt_libunwind_backtrace(void** bt, int size){
346   for (int i = 0; i < size; i++)
347     bt[i] = nullptr;
348
349   unw_cursor_t c;
350   unw_context_t uc;
351
352   unw_getcontext (&uc);
353   unw_init_local (&c, &uc);
354
355   unw_step(&c);
356
357   int i;
358   for (i = 0; unw_step(&c) >= 0 && i < size; i++) {
359     unw_word_t ip;
360     unw_get_reg(&c, UNW_REG_IP, &ip);
361     bt[i] = (void*)(long)ip;
362   }
363
364   return i;
365 }
366 #endif