1 /*
2 * Backtrace debugging
3 * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #ifdef WPA_TRACE_BFD
10 #define _GNU_SOURCE
11 #include <link.h>
12 #endif /* WPA_TRACE_BCD */
13 #include "includes.h"
14
15 #include "common.h"
16 #include "trace.h"
17
18 #ifdef WPA_TRACE
19
20 static struct dl_list active_references =
21 { &active_references, &active_references };
22
23 #ifdef WPA_TRACE_BFD
24 #include <bfd.h>
25
26 #define DMGL_PARAMS (1 << 0)
27 #define DMGL_ANSI (1 << 1)
28
29 static char *prg_fname = NULL;
30 static bfd *cached_abfd = NULL;
31 static asymbol **syms = NULL;
32 static unsigned long start_offset;
33 static int start_offset_looked_up;
34
35
callback(struct dl_phdr_info * info,size_t size,void * data)36 static int callback(struct dl_phdr_info *info, size_t size, void *data)
37 {
38 /*
39 * dl_iterate_phdr(3):
40 * "The first object visited by callback is the main program."
41 */
42 start_offset = info->dlpi_addr;
43
44 /*
45 * dl_iterate_phdr(3):
46 * "The dl_iterate_phdr() function walks through the list of an
47 * application's shared objects and calls the function callback
48 * once for each object, until either all shared objects have
49 * been processed or callback returns a nonzero value."
50 */
51 return 1;
52 }
53
54
get_prg_fname(void)55 static void get_prg_fname(void)
56 {
57 char exe[50], fname[512];
58 int len;
59 os_snprintf(exe, sizeof(exe) - 1, "/proc/%u/exe", getpid());
60 len = readlink(exe, fname, sizeof(fname) - 1);
61 if (len < 0 || len >= (int) sizeof(fname)) {
62 wpa_printf(MSG_ERROR, "readlink: %s", strerror(errno));
63 return;
64 }
65 fname[len] = '\0';
66 prg_fname = strdup(fname);
67 }
68
69
open_bfd(const char * fname)70 static bfd * open_bfd(const char *fname)
71 {
72 bfd *abfd;
73 char **matching;
74
75 abfd = bfd_openr(prg_fname, NULL);
76 if (abfd == NULL) {
77 wpa_printf(MSG_INFO, "bfd_openr failed");
78 return NULL;
79 }
80
81 if (bfd_check_format(abfd, bfd_archive)) {
82 wpa_printf(MSG_INFO, "bfd_check_format failed");
83 bfd_close(abfd);
84 return NULL;
85 }
86
87 if (!bfd_check_format_matches(abfd, bfd_object, &matching)) {
88 wpa_printf(MSG_INFO, "bfd_check_format_matches failed");
89 free(matching);
90 bfd_close(abfd);
91 return NULL;
92 }
93
94 return abfd;
95 }
96
97
read_syms(bfd * abfd)98 static void read_syms(bfd *abfd)
99 {
100 long storage, symcount;
101 bfd_boolean dynamic = FALSE;
102
103 if (syms)
104 return;
105
106 if (!(bfd_get_file_flags(abfd) & HAS_SYMS)) {
107 wpa_printf(MSG_INFO, "No symbols");
108 return;
109 }
110
111 storage = bfd_get_symtab_upper_bound(abfd);
112 if (storage == 0) {
113 storage = bfd_get_dynamic_symtab_upper_bound(abfd);
114 dynamic = TRUE;
115 }
116 if (storage < 0) {
117 wpa_printf(MSG_INFO, "Unknown symtab upper bound");
118 return;
119 }
120
121 syms = malloc(storage);
122 if (syms == NULL) {
123 wpa_printf(MSG_INFO, "Failed to allocate memory for symtab "
124 "(%ld bytes)", storage);
125 return;
126 }
127 if (dynamic)
128 symcount = bfd_canonicalize_dynamic_symtab(abfd, syms);
129 else
130 symcount = bfd_canonicalize_symtab(abfd, syms);
131 if (symcount < 0) {
132 wpa_printf(MSG_INFO, "Failed to canonicalize %ssymtab",
133 dynamic ? "dynamic " : "");
134 free(syms);
135 syms = NULL;
136 return;
137 }
138 }
139
140
141 struct bfd_data {
142 bfd_vma pc;
143 bfd_boolean found;
144 const char *filename;
145 const char *function;
146 unsigned int line;
147 };
148
149 /*
150 * binutils removed the bfd parameter and renamed things but
151 * those were macros so we can detect their absence.
152 * Cf. https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=commitdiff;h=fd3619828e94a24a92cddec42cbc0ab33352eeb4;hp=5dfda3562a69686c43aad4fb0269cc9d5ec010d5
153 */
154 #ifndef bfd_get_section_vma
155 #define bfd_get_section_vma(bfd, section) bfd_section_vma(section)
156 #endif
157 #ifndef bfd_get_section_size
158 #define bfd_get_section_size bfd_section_size
159 #endif
160
find_addr_sect(bfd * abfd,asection * section,void * obj)161 static void find_addr_sect(bfd *abfd, asection *section, void *obj)
162 {
163 struct bfd_data *data = obj;
164 bfd_vma vma;
165 bfd_size_type size;
166
167 if (data->found)
168 return;
169
170 if (!(bfd_get_section_vma(abfd, section)))
171 return;
172
173 vma = bfd_get_section_vma(abfd, section);
174 if (data->pc < vma)
175 return;
176
177 size = bfd_get_section_size(section);
178 if (data->pc >= vma + size)
179 return;
180
181 data->found = bfd_find_nearest_line(abfd, section, syms,
182 data->pc - vma,
183 &data->filename,
184 &data->function,
185 &data->line);
186 }
187
188
wpa_trace_bfd_addr(void * pc)189 static void wpa_trace_bfd_addr(void *pc)
190 {
191 bfd *abfd = cached_abfd;
192 struct bfd_data data;
193 const char *name;
194 char *aname = NULL;
195 const char *filename;
196
197 if (abfd == NULL)
198 return;
199
200 data.pc = (bfd_hostptr_t) ((u8 *) pc - start_offset);
201 data.found = FALSE;
202 bfd_map_over_sections(abfd, find_addr_sect, &data);
203
204 if (!data.found)
205 return;
206
207 do {
208 if (data.function)
209 aname = bfd_demangle(abfd, data.function,
210 DMGL_ANSI | DMGL_PARAMS);
211 name = aname ? aname : data.function;
212 filename = data.filename;
213 if (filename) {
214 char *end = os_strrchr(filename, '/');
215 int i = 0;
216 while (*filename && *filename == prg_fname[i] &&
217 filename <= end) {
218 filename++;
219 i++;
220 }
221 }
222 wpa_printf(MSG_INFO, " %s() %s:%u",
223 name, filename, data.line);
224 free(aname);
225 aname = NULL;
226
227 data.found = bfd_find_inliner_info(abfd, &data.filename,
228 &data.function, &data.line);
229 } while (data.found);
230 }
231
232
wpa_trace_bfd_addr2func(void * pc)233 static const char * wpa_trace_bfd_addr2func(void *pc)
234 {
235 bfd *abfd = cached_abfd;
236 struct bfd_data data;
237
238 if (abfd == NULL)
239 return NULL;
240
241 data.pc = (bfd_hostptr_t) ((u8 *) pc - start_offset);
242 data.found = FALSE;
243 bfd_map_over_sections(abfd, find_addr_sect, &data);
244
245 if (!data.found)
246 return NULL;
247
248 return data.function;
249 }
250
251
wpa_trace_bfd_init(void)252 static void wpa_trace_bfd_init(void)
253 {
254 if (!prg_fname) {
255 get_prg_fname();
256 if (!prg_fname)
257 return;
258 }
259
260 if (!cached_abfd) {
261 cached_abfd = open_bfd(prg_fname);
262 if (!cached_abfd) {
263 wpa_printf(MSG_INFO, "Failed to open bfd");
264 return;
265 }
266 }
267
268 read_syms(cached_abfd);
269 if (!syms) {
270 wpa_printf(MSG_INFO, "Failed to read symbols");
271 return;
272 }
273
274 if (!start_offset_looked_up) {
275 dl_iterate_phdr(callback, NULL);
276 start_offset_looked_up = 1;
277 }
278 }
279
280
wpa_trace_dump_funcname(const char * title,void * pc)281 void wpa_trace_dump_funcname(const char *title, void *pc)
282 {
283 wpa_printf(MSG_INFO, "WPA_TRACE: %s: %p", title, pc);
284 wpa_trace_bfd_init();
285 wpa_trace_bfd_addr(pc);
286 }
287
288
wpa_trace_calling_func(const char * buf[],size_t len)289 size_t wpa_trace_calling_func(const char *buf[], size_t len)
290 {
291 bfd *abfd;
292 void *btrace_res[WPA_TRACE_LEN];
293 int i, btrace_num;
294 size_t pos = 0;
295
296 if (len == 0)
297 return 0;
298 if (len > WPA_TRACE_LEN)
299 len = WPA_TRACE_LEN;
300
301 wpa_trace_bfd_init();
302 abfd = cached_abfd;
303 if (!abfd)
304 return 0;
305
306 btrace_num = backtrace(btrace_res, len);
307 if (btrace_num < 1)
308 return 0;
309
310 for (i = 0; i < btrace_num; i++) {
311 struct bfd_data data;
312
313 data.pc = (bfd_hostptr_t) ((u8 *) btrace_res[i] - start_offset);
314 data.found = FALSE;
315 bfd_map_over_sections(abfd, find_addr_sect, &data);
316
317 while (data.found) {
318 if (data.function &&
319 (pos > 0 ||
320 os_strcmp(data.function, __func__) != 0)) {
321 buf[pos++] = data.function;
322 if (pos == len)
323 return pos;
324 }
325
326 data.found = bfd_find_inliner_info(abfd, &data.filename,
327 &data.function,
328 &data.line);
329 }
330 }
331
332 return pos;
333 }
334
335 #else /* WPA_TRACE_BFD */
336
337 #define wpa_trace_bfd_init() do { } while (0)
338 #define wpa_trace_bfd_addr(pc) do { } while (0)
339 #define wpa_trace_bfd_addr2func(pc) NULL
340
341 #endif /* WPA_TRACE_BFD */
342
wpa_trace_dump_func(const char * title,void ** btrace,int btrace_num)343 void wpa_trace_dump_func(const char *title, void **btrace, int btrace_num)
344 {
345 char **sym;
346 int i;
347 enum { TRACE_HEAD, TRACE_RELEVANT, TRACE_TAIL } state;
348
349 wpa_trace_bfd_init();
350 wpa_printf(MSG_INFO, "WPA_TRACE: %s - START", title);
351 sym = backtrace_symbols(btrace, btrace_num);
352 state = TRACE_HEAD;
353 for (i = 0; i < btrace_num; i++) {
354 const char *func = wpa_trace_bfd_addr2func(btrace[i]);
355 if (state == TRACE_HEAD && func &&
356 (os_strcmp(func, "wpa_trace_add_ref_func") == 0 ||
357 os_strcmp(func, "wpa_trace_check_ref") == 0 ||
358 os_strcmp(func, "wpa_trace_show") == 0))
359 continue;
360 if (state == TRACE_TAIL && sym && sym[i] &&
361 os_strstr(sym[i], "__libc_start_main"))
362 break;
363 if (state == TRACE_HEAD)
364 state = TRACE_RELEVANT;
365 if (sym)
366 wpa_printf(MSG_INFO, "[%d]: %s", i, sym[i]);
367 else
368 wpa_printf(MSG_INFO, "[%d]: ?? [%p]", i, btrace[i]);
369 wpa_trace_bfd_addr(btrace[i]);
370 if (state == TRACE_RELEVANT && func &&
371 os_strcmp(func, "main") == 0)
372 state = TRACE_TAIL;
373 }
374 free(sym);
375 wpa_printf(MSG_INFO, "WPA_TRACE: %s - END", title);
376 }
377
378
wpa_trace_show(const char * title)379 void wpa_trace_show(const char *title)
380 {
381 struct info {
382 WPA_TRACE_INFO
383 } info;
384 wpa_trace_record(&info);
385 wpa_trace_dump(title, &info);
386 }
387
388
wpa_trace_add_ref_func(struct wpa_trace_ref * ref,const void * addr)389 void wpa_trace_add_ref_func(struct wpa_trace_ref *ref, const void *addr)
390 {
391 if (addr == NULL)
392 return;
393 ref->addr = addr;
394 wpa_trace_record(ref);
395 dl_list_add(&active_references, &ref->list);
396 }
397
398
wpa_trace_check_ref(const void * addr)399 void wpa_trace_check_ref(const void *addr)
400 {
401 struct wpa_trace_ref *ref;
402 dl_list_for_each(ref, &active_references, struct wpa_trace_ref, list) {
403 if (addr != ref->addr)
404 continue;
405 wpa_trace_show("Freeing referenced memory");
406 wpa_trace_dump("Reference registration", ref);
407 abort();
408 }
409 }
410
411
wpa_trace_deinit(void)412 void wpa_trace_deinit(void)
413 {
414 #ifdef WPA_TRACE_BFD
415 free(syms);
416 syms = NULL;
417 #endif /* WPA_TRACE_BFD */
418 }
419
420 #endif /* WPA_TRACE */
421
