libeap/src/utils/trace.c

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