1 /*
2 * Backtrace debugging
3 * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15 #include "includes.h"
16
17 #include "common.h"
18 #include "trace.h"
19
20 #ifdef WPA_TRACE
21
22 static struct dl_list active_references =
23 { &active_references, &active_references };
24
25 #ifdef WPA_TRACE_BFD
26 #include <bfd.h>
27 #ifdef __linux__
28 #include <demangle.h>
29 #else /* __linux__ */
30 #include <libiberty/demangle.h>
31 #endif /* __linux__ */
32
33 static char *prg_fname = NULL;
34 static bfd *cached_abfd = NULL;
35 static asymbol **syms = NULL;
36
get_prg_fname(void)37 static void get_prg_fname(void)
38 {
39 char exe[50], fname[512];
40 int len;
41 os_snprintf(exe, sizeof(exe) - 1, "/proc/%u/exe", getpid());
42 len = readlink(exe, fname, sizeof(fname) - 1);
43 if (len < 0 || len >= (int) sizeof(fname)) {
44 perror("readlink");
45 return;
46 }
47 fname[len] = '\0';
48 prg_fname = strdup(fname);
49 }
50
51
open_bfd(const char * fname)52 static bfd * open_bfd(const char *fname)
53 {
54 bfd *abfd;
55 char **matching;
56
57 abfd = bfd_openr(prg_fname, NULL);
58 if (abfd == NULL) {
59 wpa_printf(MSG_INFO, "bfd_openr failed");
60 return NULL;
61 }
62
63 if (bfd_check_format(abfd, bfd_archive)) {
64 wpa_printf(MSG_INFO, "bfd_check_format failed");
65 bfd_close(abfd);
66 return NULL;
67 }
68
69 if (!bfd_check_format_matches(abfd, bfd_object, &matching)) {
70 wpa_printf(MSG_INFO, "bfd_check_format_matches failed");
71 free(matching);
72 bfd_close(abfd);
73 return NULL;
74 }
75
76 return abfd;
77 }
78
79
read_syms(bfd * abfd)80 static void read_syms(bfd *abfd)
81 {
82 long storage, symcount;
83 bfd_boolean dynamic = FALSE;
84
85 if (syms)
86 return;
87
88 if (!(bfd_get_file_flags(abfd) & HAS_SYMS)) {
89 wpa_printf(MSG_INFO, "No symbols");
90 return;
91 }
92
93 storage = bfd_get_symtab_upper_bound(abfd);
94 if (storage == 0) {
95 storage = bfd_get_dynamic_symtab_upper_bound(abfd);
96 dynamic = TRUE;
97 }
98 if (storage < 0) {
99 wpa_printf(MSG_INFO, "Unknown symtab upper bound");
100 return;
101 }
102
103 syms = malloc(storage);
104 if (syms == NULL) {
105 wpa_printf(MSG_INFO, "Failed to allocate memory for symtab "
106 "(%ld bytes)", storage);
107 return;
108 }
109 if (dynamic)
110 symcount = bfd_canonicalize_dynamic_symtab(abfd, syms);
111 else
112 symcount = bfd_canonicalize_symtab(abfd, syms);
113 if (symcount < 0) {
114 wpa_printf(MSG_INFO, "Failed to canonicalize %ssymtab",
115 dynamic ? "dynamic " : "");
116 free(syms);
117 syms = NULL;
118 return;
119 }
120 }
121
122
123 struct bfd_data {
124 bfd_vma pc;
125 bfd_boolean found;
126 const char *filename;
127 const char *function;
128 unsigned int line;
129 };
130
131
find_addr_sect(bfd * abfd,asection * section,void * obj)132 static void find_addr_sect(bfd *abfd, asection *section, void *obj)
133 {
134 struct bfd_data *data = obj;
135 bfd_vma vma;
136 bfd_size_type size;
137
138 if (data->found)
139 return;
140
141 if (!(bfd_get_section_vma(abfd, section)))
142 return;
143
144 vma = bfd_get_section_vma(abfd, section);
145 if (data->pc < vma)
146 return;
147
148 size = bfd_get_section_size(section);
149 if (data->pc >= vma + size)
150 return;
151
152 data->found = bfd_find_nearest_line(abfd, section, syms,
153 data->pc - vma,
154 &data->filename,
155 &data->function,
156 &data->line);
157 }
158
159
wpa_trace_bfd_addr(void * pc)160 static void wpa_trace_bfd_addr(void *pc)
161 {
162 bfd *abfd = cached_abfd;
163 struct bfd_data data;
164 const char *name;
165 char *aname = NULL;
166 const char *filename;
167
168 if (abfd == NULL)
169 return;
170
171 data.pc = (bfd_vma) pc;
172 data.found = FALSE;
173 bfd_map_over_sections(abfd, find_addr_sect, &data);
174
175 if (!data.found)
176 return;
177
178 do {
179 if (data.function)
180 aname = bfd_demangle(abfd, data.function,
181 DMGL_ANSI | DMGL_PARAMS);
182 name = aname ? aname : data.function;
183 filename = data.filename;
184 if (filename) {
185 char *end = os_strrchr(filename, '/');
186 int i = 0;
187 while (*filename && *filename == prg_fname[i] &&
188 filename <= end) {
189 filename++;
190 i++;
191 }
192 }
193 wpa_printf(MSG_INFO, " %s() %s:%u",
194 name, filename, data.line);
195 free(aname);
196
197 data.found = bfd_find_inliner_info(abfd, &data.filename,
198 &data.function, &data.line);
199 } while (data.found);
200 }
201
202
wpa_trace_bfd_addr2func(void * pc)203 static const char * wpa_trace_bfd_addr2func(void *pc)
204 {
205 bfd *abfd = cached_abfd;
206 struct bfd_data data;
207
208 if (abfd == NULL)
209 return NULL;
210
211 data.pc = (bfd_vma) pc;
212 data.found = FALSE;
213 bfd_map_over_sections(abfd, find_addr_sect, &data);
214
215 if (!data.found)
216 return NULL;
217
218 return data.function;
219 }
220
221
wpa_trace_bfd_init(void)222 static void wpa_trace_bfd_init(void)
223 {
224 if (!prg_fname) {
225 get_prg_fname();
226 if (!prg_fname)
227 return;
228 }
229
230 if (!cached_abfd) {
231 cached_abfd = open_bfd(prg_fname);
232 if (!cached_abfd) {
233 wpa_printf(MSG_INFO, "Failed to open bfd");
234 return;
235 }
236 }
237
238 read_syms(cached_abfd);
239 if (!syms) {
240 wpa_printf(MSG_INFO, "Failed to read symbols");
241 return;
242 }
243 }
244
245
wpa_trace_dump_funcname(const char * title,void * pc)246 void wpa_trace_dump_funcname(const char *title, void *pc)
247 {
248 wpa_printf(MSG_INFO, "WPA_TRACE: %s: %p", title, pc);
249 wpa_trace_bfd_init();
250 wpa_trace_bfd_addr(pc);
251 }
252
253 #else /* WPA_TRACE_BFD */
254
255 #define wpa_trace_bfd_init() do { } while (0)
256 #define wpa_trace_bfd_addr(pc) do { } while (0)
257 #define wpa_trace_bfd_addr2func(pc) NULL
258
259 #endif /* WPA_TRACE_BFD */
260
wpa_trace_dump_func(const char * title,void ** btrace,int btrace_num)261 void wpa_trace_dump_func(const char *title, void **btrace, int btrace_num)
262 {
263 char **sym;
264 int i;
265 enum { TRACE_HEAD, TRACE_RELEVANT, TRACE_TAIL } state;
266
267 wpa_trace_bfd_init();
268 wpa_printf(MSG_INFO, "WPA_TRACE: %s - START", title);
269 sym = backtrace_symbols(btrace, btrace_num);
270 state = TRACE_HEAD;
271 for (i = 0; i < btrace_num; i++) {
272 const char *func = wpa_trace_bfd_addr2func(btrace[i]);
273 if (state == TRACE_HEAD && func &&
274 (os_strcmp(func, "wpa_trace_add_ref_func") == 0 ||
275 os_strcmp(func, "wpa_trace_check_ref") == 0 ||
276 os_strcmp(func, "wpa_trace_show") == 0))
277 continue;
278 if (state == TRACE_TAIL && sym && sym[i] &&
279 os_strstr(sym[i], "__libc_start_main"))
280 break;
281 if (state == TRACE_HEAD)
282 state = TRACE_RELEVANT;
283 if (sym)
284 wpa_printf(MSG_INFO, "[%d]: %s", i, sym[i]);
285 else
286 wpa_printf(MSG_INFO, "[%d]: ?? [%p]", i, btrace[i]);
287 wpa_trace_bfd_addr(btrace[i]);
288 if (state == TRACE_RELEVANT && func &&
289 os_strcmp(func, "main") == 0)
290 state = TRACE_TAIL;
291 }
292 free(sym);
293 wpa_printf(MSG_INFO, "WPA_TRACE: %s - END", title);
294 }
295
296
wpa_trace_show(const char * title)297 void wpa_trace_show(const char *title)
298 {
299 struct info {
300 WPA_TRACE_INFO
301 } info;
302 wpa_trace_record(&info);
303 wpa_trace_dump(title, &info);
304 }
305
306
wpa_trace_add_ref_func(struct wpa_trace_ref * ref,const void * addr)307 void wpa_trace_add_ref_func(struct wpa_trace_ref *ref, const void *addr)
308 {
309 if (addr == NULL)
310 return;
311 ref->addr = addr;
312 wpa_trace_record(ref);
313 dl_list_add(&active_references, &ref->list);
314 }
315
316
wpa_trace_check_ref(const void * addr)317 void wpa_trace_check_ref(const void *addr)
318 {
319 struct wpa_trace_ref *ref;
320 dl_list_for_each(ref, &active_references, struct wpa_trace_ref, list) {
321 if (addr != ref->addr)
322 continue;
323 wpa_trace_show("Freeing referenced memory");
324 wpa_trace_dump("Reference registration", ref);
325 abort();
326 }
327 }
328
329 #endif /* WPA_TRACE */
330