![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to backtrace.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / utils|
Return to backtrace.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / utils |
1.1 misho 1: /*
2: * Copyright (C) 2006-2013 Martin Willi
3: * HSR Hochschule fuer Technik Rapperswil
4: * Copyright (C) 2013 revosec AG
5: *
6: * This program is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the
8: * Free Software Foundation; either version 2 of the License, or (at your
9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10: *
11: * This program is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14: * for more details.
15: */
16:
17: #define _GNU_SOURCE
18:
19: #ifdef HAVE_BACKTRACE
20: # include <execinfo.h>
21: #endif /* HAVE_BACKTRACE */
22: #ifdef HAVE_DBGHELP
23: # include <winsock2.h>
24: # include <windows.h>
25: # include <dbghelp.h>
26: #endif /* HAVE_DBGHELP */
27: #include <string.h>
28:
29: #include "backtrace.h"
30:
31: #include <utils/debug.h>
32:
33: #ifdef WIN32
34: # include <psapi.h>
35: /* missing in MinGW */
36: #ifdef WIN64
37: #ifndef GetModuleInformation
38: WINBOOL K32GetModuleInformation(HANDLE hProcess, HMODULE hModule,
39: LPMODULEINFO lpmodinfo, DWORD cb);
40: #define GetModuleInformation K32GetModuleInformation
41: #endif /* !GetModuleInformation */
42: #ifndef GetModuleFileNameEx
43: DWORD K32GetModuleFileNameExA(HANDLE hProcess, HMODULE hModule,
44: LPTSTR lpFilename, DWORD nSize);
45: #define GetModuleFileNameEx K32GetModuleFileNameExA
46: #endif /* !GetModuleFileNameEx */
47: #endif /* WIN64 */
48: #endif
49:
50: typedef struct private_backtrace_t private_backtrace_t;
51:
52: /**
53: * Private data of an backtrace_t object.
54: */
55: struct private_backtrace_t {
56:
57: /**
58: * Public backtrace_t interface.
59: */
60: backtrace_t public;
61:
62: /**
63: * Number of stacks frames obtained in stack_frames
64: */
65: int frame_count;
66:
67: /**
68: * Recorded stack frames.
69: */
70: void *frames[];
71: };
72:
73: /**
74: * Forward declaration of method getter
75: */
76: static backtrace_t get_methods();
77:
78: /**
79: * Write a format string with arguments to a FILE line, if it is NULL to DBG
80: */
81: static void println(FILE *file, char *format, ...)
82: {
83: char buf[512];
84: va_list args;
85:
86: va_start(args, format);
87: if (file)
88: {
89: vfprintf(file, format, args);
90: fputs("\n", file);
91: }
92: else
93: {
94: vsnprintf(buf, sizeof(buf), format, args);
95: DBG1(DBG_LIB, "%s", buf);
96: }
97: va_end(args);
98: }
99:
100: /**
101: * Same as tty_escape_get(), but for a potentially NULL FILE*
102: */
103: static inline char* esc(FILE *file, tty_escape_t escape)
104: {
105: if (file)
106: {
107: return tty_escape_get(fileno(file), escape);
108: }
109: return "";
110: }
111:
112: #ifdef HAVE_DBGHELP
113:
114: #include <dbghelp.h>
115: #include <threading/mutex.h>
116:
117: /**
118: * Mutex to access non-thread-safe dbghelp functions
119: */
120: static mutex_t *dbghelp_mutex;
121:
122: void backtrace_init()
123: {
124: SymSetOptions(SYMOPT_LOAD_LINES);
125: SymInitialize(GetCurrentProcess(), NULL, TRUE);
126: dbghelp_mutex = mutex_create(MUTEX_TYPE_DEFAULT);
127: }
128:
129: void backtrace_deinit()
130: {
131: dbghelp_mutex->destroy(dbghelp_mutex);
132: SymCleanup(GetCurrentProcess());
133: }
134:
135: #elif defined(HAVE_DLADDR) || defined(HAVE_BFD_H)
136:
137: #ifdef HAVE_DLADDR
138: #include <dlfcn.h>
139: #endif
140:
141: #ifdef HAVE_BFD_H
142:
143: #include <bfd.h>
144: #include <collections/hashtable.h>
145: #include <threading/mutex.h>
146:
147: /**
148: * Hashtable-cached bfd handle
149: */
150: typedef struct {
151: /** binary file name on disk */
152: char *filename;
153: /** bfd handle */
154: bfd *abfd;
155: /** loaded symbols */
156: asymbol **syms;
157: } bfd_entry_t;
158:
159: /**
160: * Destroy a bfd_entry
161: */
162: static void bfd_entry_destroy(bfd_entry_t *this)
163: {
164: free(this->filename);
165: free(this->syms);
166: bfd_close(this->abfd);
167: free(this);
168: }
169:
170: /**
171: * Data to pass to find_addr()
172: */
173: typedef struct {
174: /** used bfd entry */
175: bfd_entry_t *entry;
176: /** backtrace address */
177: bfd_vma vma;
178: /** stream to log to */
179: FILE *file;
180: /** TRUE if complete */
181: bool found;
182: } bfd_find_data_t;
183:
184: /**
185: * bfd entry cache
186: */
187: static hashtable_t *bfds;
188:
189: static mutex_t *bfd_mutex;
190:
191: /**
192: * Hashtable hash function
193: */
194: static u_int bfd_hash(char *key)
195: {
196: return chunk_hash(chunk_create(key, strlen(key)));
197: }
198:
199: /**
200: * Hashtable equals function
201: */
202: static bool bfd_equals(char *a, char *b)
203: {
204: return streq(a, b);
205: }
206:
207: /**
208: * See header.
209: */
210: void backtrace_init()
211: {
212: bfd_init();
213: bfds = hashtable_create((hashtable_hash_t)bfd_hash,
214: (hashtable_equals_t)bfd_equals, 8);
215: bfd_mutex = mutex_create(MUTEX_TYPE_DEFAULT);
216: }
217:
218: /**
219: * See header.
220: */
221: void backtrace_deinit()
222: {
223: enumerator_t *enumerator;
224: bfd_entry_t *entry;
225: char *key;
226:
227: enumerator = bfds->create_enumerator(bfds);
228: while (enumerator->enumerate(enumerator, &key, &entry))
229: {
230: bfds->remove_at(bfds, enumerator);
231: bfd_entry_destroy(entry);
232: }
233: enumerator->destroy(enumerator);
234:
235: bfds->destroy(bfds);
236: bfd_mutex->destroy(bfd_mutex);
237: }
238:
239: /**
240: * Find and print information to an address
241: */
242: static void find_addr(bfd *abfd, asection *section, bfd_find_data_t *data)
243: {
244: bfd_size_type size;
245: bfd_vma vma;
246: const char *source;
247: const char *function;
248: char fbuf[512] = "", sbuf[512] = "";
249: u_int line;
250:
251: if (!data->found || (bfd_get_section_flags(abfd, section) & SEC_ALLOC) != 0)
252: {
253: vma = bfd_get_section_vma(abfd, section);
254: if (data->vma >= vma)
255: {
256: size = bfd_get_section_size(section);
257: if (data->vma < vma + size)
258: {
259: data->found = bfd_find_nearest_line(abfd, section,
260: data->entry->syms, data->vma - vma,
261: &source, &function, &line);
262: if (data->found)
263: {
264: if (source || function)
265: {
266: if (function)
267: {
268: snprintf(fbuf, sizeof(fbuf), "%s%s() ",
269: esc(data->file, TTY_FG_BLUE), function);
270: }
271: if (source)
272: {
273: snprintf(sbuf, sizeof(sbuf), "%s@ %s:%d",
274: esc(data->file, TTY_FG_GREEN), source, line);
275: }
276: println(data->file, " -> %s%s%s", fbuf, sbuf,
277: esc(data->file, TTY_FG_DEF));
278: }
279: }
280: }
281: }
282: }
283: }
284:
285: /**
286: * Find a cached bfd entry, create'n'cache if not found
287: */
288: static bfd_entry_t *get_bfd_entry(char *filename)
289: {
290: bool dynamic = FALSE, ok = FALSE;
291: bfd_entry_t *entry;
292: long size;
293:
294: /* check cache */
295: entry = bfds->get(bfds, filename);
296: if (entry)
297: {
298: return entry;
299: }
300:
301: INIT(entry,
302: .abfd = bfd_openr(filename, NULL),
303: );
304:
305: if (!entry->abfd)
306: {
307: free(entry);
308: return NULL;
309: }
310: #ifdef BFD_DECOMPRESS
311: entry->abfd->flags |= BFD_DECOMPRESS;
312: #endif
313: if (bfd_check_format(entry->abfd, bfd_archive) == 0 &&
314: bfd_check_format_matches(entry->abfd, bfd_object, NULL))
315: {
316: if (bfd_get_file_flags(entry->abfd) & HAS_SYMS)
317: {
318: size = bfd_get_symtab_upper_bound(entry->abfd);
319: if (size == 0)
320: {
321: size = bfd_get_dynamic_symtab_upper_bound(entry->abfd);
322: dynamic = TRUE;
323: }
324: if (size >= 0)
325: {
326: entry->syms = malloc(size);
327: if (dynamic)
328: {
329: ok = bfd_canonicalize_dynamic_symtab(entry->abfd,
330: entry->syms) >= 0;
331: }
332: else
333: {
334: ok = bfd_canonicalize_symtab(entry->abfd,
335: entry->syms) >= 0;
336: }
337: }
338: }
339: }
340: if (ok)
341: {
342: entry->filename = strdup(filename);
343: bfds->put(bfds, entry->filename, entry);
344: return entry;
345: }
346: bfd_entry_destroy(entry);
347: return NULL;
348: }
349:
350: /**
351: * Print the source file with line number to file, libbfd variant
352: */
353: static void print_sourceline(FILE *file, char *filename, void *ptr, void *base)
354: {
355: bfd_entry_t *entry;
356: bfd_find_data_t data = {
357: .file = file,
358: .vma = (uintptr_t)ptr,
359: };
360: bool old = FALSE;
361:
362: bfd_mutex->lock(bfd_mutex);
363: if (lib && lib->leak_detective)
364: {
365: old = lib->leak_detective->set_state(lib->leak_detective, FALSE);
366: }
367: entry = get_bfd_entry(filename);
368: if (entry)
369: {
370: data.entry = entry;
371: bfd_map_over_sections(entry->abfd, (void*)find_addr, &data);
372: }
373: if (lib && lib->leak_detective)
374: {
375: lib->leak_detective->set_state(lib->leak_detective, old);
376: }
377: bfd_mutex->unlock(bfd_mutex);
378: }
379:
380: #else /* !HAVE_BFD_H */
381:
382: void backtrace_init() {}
383: void backtrace_deinit() {}
384:
385: /**
386: * Print the source file with line number to file, slow addr2line variant
387: */
388: static void print_sourceline(FILE *file, char *filename, void *ptr, void* base)
389: {
390: char buf[1024];
391: FILE *output;
392: int c, i = 0;
393:
394: #ifdef __APPLE__
395: snprintf(buf, sizeof(buf), "atos -o %s -l %p %p 2>&1 | tail -n1",
396: filename, base, ptr);
397: #else /* !__APPLE__ */
398: snprintf(buf, sizeof(buf), "addr2line -e %s %p", filename, ptr);
399: #endif /* __APPLE__ */
400:
401: output = popen(buf, "r");
402: if (output)
403: {
404: while (i < sizeof(buf))
405: {
406: c = getc(output);
407: if (c == '\n' || c == EOF)
408: {
409: buf[i++] = 0;
410: break;
411: }
412: buf[i++] = c;
413: }
414: pclose(output);
415:
416: println(file, " -> %s%s%s", esc(file, TTY_FG_GREEN), buf,
417: esc(file, TTY_FG_DEF));
418: }
419: }
420:
421: #endif /* HAVE_BFD_H */
422:
423: #else /* !HAVE_DLADDR && !HAVE_DBGHELP */
424:
425: void backtrace_init() {}
426: void backtrace_deinit() {}
427:
428: #endif /* HAVE_DLADDR */
429:
430: METHOD(backtrace_t, log_, void,
431: private_backtrace_t *this, FILE *file, bool detailed)
432: {
433: #if defined(HAVE_BACKTRACE) || defined(HAVE_LIBUNWIND_H) || defined(WIN32)
434: size_t i;
435: char **strings = NULL;
436:
437: println(file, " dumping %d stack frame addresses:", this->frame_count);
438: for (i = 0; i < this->frame_count; i++)
439: {
440: #ifdef HAVE_DLADDR
441: Dl_info info;
442:
443: if (dladdr(this->frames[i], &info))
444: {
445: void *ptr = this->frames[i];
446:
447: if (strstr(info.dli_fname, ".so"))
448: {
449: ptr = (void*)(this->frames[i] - info.dli_fbase);
450: }
451: if (info.dli_sname)
452: {
453: println(file, " %s%s%s @ %p (%s%s%s+0x%tx) [%p]",
454: esc(file, TTY_FG_YELLOW), info.dli_fname,
455: esc(file, TTY_FG_DEF), info.dli_fbase,
456: esc(file, TTY_FG_RED), info.dli_sname,
457: esc(file, TTY_FG_DEF), this->frames[i] - info.dli_saddr,
458: this->frames[i]);
459: }
460: else
461: {
462: println(file, " %s%s%s @ %p [%p]",
463: esc(file, TTY_FG_YELLOW), info.dli_fname,
464: esc(file, TTY_FG_DEF), info.dli_fbase, this->frames[i]);
465: }
466: if (detailed && info.dli_fname[0])
467: {
468: print_sourceline(file, (char*)info.dli_fname,
469: ptr, info.dli_fbase);
470: }
471: }
472: else
473: #elif defined(HAVE_DBGHELP)
474: struct {
475: SYMBOL_INFO hdr;
476: char buf[128];
477: } symbol;
478: char filename[MAX_PATH];
479: HINSTANCE module;
480: HANDLE process;
481: DWORD64 displace, frame;
482:
483: process = GetCurrentProcess();
484: frame = (uintptr_t)this->frames[i];
485:
486: memset(&symbol, 0, sizeof(symbol));
487: symbol.hdr.SizeOfStruct = sizeof(symbol.hdr);
488: symbol.hdr.MaxNameLen = sizeof(symbol.buf) - 1;
489:
490: dbghelp_mutex->lock(dbghelp_mutex);
491:
492: module = (HINSTANCE)SymGetModuleBase64(process, frame);
493:
494: if (module && GetModuleFileName(module, filename, sizeof(filename)))
495: {
496: if (SymFromAddr(process, frame, &displace, &symbol.hdr))
497: {
498: println(file, " %s%s%s @ %p (%s%s%s+0x%tx) [%p]",
499: esc(file, TTY_FG_YELLOW), filename,
500: esc(file, TTY_FG_DEF), (void*)module,
501: esc(file, TTY_FG_RED), symbol.hdr.Name,
502: esc(file, TTY_FG_DEF), displace,
503: this->frames[i]);
504: }
505: else
506: {
507: println(file, " %s%s%s @ %p [%p]",
508: esc(file, TTY_FG_YELLOW), filename,
509: esc(file, TTY_FG_DEF), (void*)module, this->frames[i]);
510: }
511: if (detailed)
512: {
513: IMAGEHLP_LINE64 line;
514: DWORD off;
515:
516: memset(&line, 0, sizeof(line));
517: line.SizeOfStruct = sizeof(line);
518:
519: if (SymGetLineFromAddr64(process, frame, &off, &line))
520: {
521:
522: println(file, " -> %s%s:%u%s", esc(file, TTY_FG_GREEN),
523: line.FileName, line.LineNumber,
524: esc(file, TTY_FG_DEF));
525: }
526: }
527: }
528: else
529: #elif defined(WIN32)
530: HMODULE module;
531: MODULEINFO info;
532: char filename[MAX_PATH];
533:
534: if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
535: this->frames[i], &module) &&
536: GetModuleInformation(GetCurrentProcess(), module,
537: &info, sizeof(info)) &&
538: GetModuleFileNameEx(GetCurrentProcess(), module,
539: filename, sizeof(filename)))
540: {
541: println(file, " %s%s%s @ %p [%p]",
542: esc(file, TTY_FG_YELLOW), filename,
543: esc(file, TTY_FG_DEF), info.lpBaseOfDll, this->frames[i]);
544: #ifdef HAVE_BFD_H
545: print_sourceline(file, filename, this->frames[i], info.lpBaseOfDll);
546: #endif /* HAVE_BFD_H */
547: }
548: else
549: #endif /* HAVE_DLADDR/HAVE_DBGHELP */
550: {
551: #ifdef HAVE_BACKTRACE
552: if (!strings)
553: {
554: strings = backtrace_symbols(this->frames, this->frame_count);
555: }
556: if (strings)
557: {
558: println(file, " %s", strings[i]);
559: }
560: else
561: #endif /* HAVE_BACKTRACE */
562: {
563: println(file, " %p", this->frames[i]);
564: }
565: }
566: #ifdef HAVE_DBGHELP
567: dbghelp_mutex->unlock(dbghelp_mutex);
568: #endif
569: }
570: free(strings);
571: #else /* !HAVE_BACKTRACE && !HAVE_LIBUNWIND_H */
572: println(file, "no support for capturing backtraces");
573: #endif /* HAVE_BACKTRACE/HAVE_LIBUNWIND_H */
574: }
575:
576: METHOD(backtrace_t, contains_function, bool,
577: private_backtrace_t *this, char *function[], int count)
578: {
579: #ifdef HAVE_DLADDR
580: int i, j;
581:
582: for (i = 0; i< this->frame_count; i++)
583: {
584: Dl_info info;
585:
586: if (dladdr(this->frames[i], &info) && info.dli_sname)
587: {
588: for (j = 0; j < count; j++)
589: {
590: if (streq(info.dli_sname, function[j]))
591: {
592: return TRUE;
593: }
594: }
595: }
596: }
597: #elif defined(HAVE_DBGHELP)
598: int i, j;
599: HANDLE process;
600:
601: process = GetCurrentProcess();
602:
603: dbghelp_mutex->lock(dbghelp_mutex);
604:
605: for (i = 0; i < this->frame_count; i++)
606: {
607: struct {
608: SYMBOL_INFO hdr;
609: char buf[128];
610: } symbol;
611:
612: memset(&symbol, 0, sizeof(symbol));
613: symbol.hdr.SizeOfStruct = sizeof(symbol.hdr);
614: symbol.hdr.MaxNameLen = sizeof(symbol.buf) - 1;
615:
616: if (SymFromAddr(process, (DWORD64)this->frames[i], NULL, &symbol.hdr))
617: {
618: for (j = 0; j < count; j++)
619: {
620: if (streq(symbol.hdr.Name, function[j]))
621: {
622: dbghelp_mutex->unlock(dbghelp_mutex);
623: return TRUE;
624: }
625: }
626: }
627: }
628:
629: dbghelp_mutex->unlock(dbghelp_mutex);
630: #endif /* HAVE_DLADDR/HAVE_DBGHELP */
631: return FALSE;
632: }
633:
634: METHOD(backtrace_t, equals, bool,
635: private_backtrace_t *this, backtrace_t *other_public)
636: {
637: private_backtrace_t *other = (private_backtrace_t*)other_public;
638: int i;
639:
640: if (this == other)
641: {
642: return TRUE;
643: }
644: if (this->frame_count != other->frame_count)
645: {
646: return FALSE;
647: }
648: for (i = 0; i < this->frame_count; i++)
649: {
650: if (this->frames[i] != other->frames[i])
651: {
652: return FALSE;
653: }
654: }
655: return TRUE;
656: }
657:
658: /**
659: * Frame enumerator
660: */
661: typedef struct {
662: /** implements enumerator_t */
663: enumerator_t public;
664: /** reference to backtrace */
665: private_backtrace_t *bt;
666: /** current position */
667: int i;
668: } frame_enumerator_t;
669:
670: METHOD(enumerator_t, frame_enumerate, bool,
671: frame_enumerator_t *this, va_list args)
672: {
673: void **addr;
674:
675: VA_ARGS_VGET(args, addr);
676:
677: if (this->i < this->bt->frame_count)
678: {
679: *addr = this->bt->frames[this->i++];
680: return TRUE;
681: }
682: return FALSE;
683: }
684:
685: METHOD(backtrace_t, create_frame_enumerator, enumerator_t*,
686: private_backtrace_t *this)
687: {
688: frame_enumerator_t *enumerator;
689:
690: INIT(enumerator,
691: .public = {
692: .enumerate = enumerator_enumerate_default,
693: .venumerate = _frame_enumerate,
694: .destroy = (void*)free,
695: },
696: .bt = this,
697: );
698: return &enumerator->public;
699: }
700:
701: METHOD(backtrace_t, clone_, backtrace_t*,
702: private_backtrace_t *this)
703: {
704: private_backtrace_t *clone;
705:
706: clone = malloc(sizeof(private_backtrace_t) +
707: this->frame_count * sizeof(void*));
708: memcpy(clone->frames, this->frames, this->frame_count * sizeof(void*));
709: clone->frame_count = this->frame_count;
710:
711: clone->public = get_methods();
712:
713: return &clone->public;
714: }
715:
716: METHOD(backtrace_t, destroy, void,
717: private_backtrace_t *this)
718: {
719: free(this);
720: }
721:
722: #ifdef HAVE_LIBUNWIND_H
723: #define UNW_LOCAL_ONLY
724: #include <libunwind.h>
725:
726: /**
727: * libunwind variant for glibc backtrace()
728: */
729: static inline int backtrace_unwind(void **frames, int count)
730: {
731: unw_context_t context;
732: unw_cursor_t cursor;
733: unw_word_t ip;
734: int depth = 0;
735:
736: unw_getcontext(&context);
737: unw_init_local(&cursor, &context);
738: do
739: {
740: unw_get_reg(&cursor, UNW_REG_IP, &ip);
741: frames[depth++] = (void*)ip;
742: }
743: while (depth < count && unw_step(&cursor) > 0);
744:
745: return depth;
746: }
747: #endif /* HAVE_UNWIND */
748:
749: #ifdef HAVE_DBGHELP
750:
751: /**
752: * Windows dbghelp variant for glibc backtrace()
753: */
754: static inline int backtrace_win(void **frames, int count)
755: {
756: STACKFRAME frame;
757: HANDLE process, thread;
758: DWORD machine;
759: CONTEXT context;
760: int got = 0;
761:
762: memset(&frame, 0, sizeof(frame));
763: memset(&context, 0, sizeof(context));
764:
765: process = GetCurrentProcess();
766: thread = GetCurrentThread();
767:
768: #ifdef __x86_64
769: machine = IMAGE_FILE_MACHINE_AMD64;
770:
771: frame.AddrPC.Offset = context.Rip;
772: frame.AddrPC.Mode = AddrModeFlat;
773: frame.AddrStack.Offset = context.Rsp;
774: frame.AddrStack.Mode = AddrModeFlat;
775: frame.AddrFrame.Offset = context.Rbp;
776: frame.AddrFrame.Mode = AddrModeFlat;
777: #else /* x86 */
778: machine = IMAGE_FILE_MACHINE_I386;
779:
780: frame.AddrPC.Offset = context.Eip;
781: frame.AddrPC.Mode = AddrModeFlat;
782: frame.AddrStack.Offset = context.Esp;
783: frame.AddrStack.Mode = AddrModeFlat;
784: frame.AddrFrame.Offset = context.Ebp;
785: frame.AddrFrame.Mode = AddrModeFlat;
786: #endif /* x86_64/x86 */
787:
788: dbghelp_mutex->lock(dbghelp_mutex);
789:
790: RtlCaptureContext(&context);
791:
792: while (got < count)
793: {
794: if (!StackWalk64(machine, process, thread, &frame, &context,
795: NULL, SymFunctionTableAccess, SymGetModuleBase, NULL))
796: {
797: break;
798: }
799: frames[got++] = (void*)frame.AddrPC.Offset;
800: }
801:
802: dbghelp_mutex->unlock(dbghelp_mutex);
803:
804: return got;
805: }
806:
807: #endif /* HAVE_DBGHELP */
808:
809: /**
810: * Get implementation methods of backtrace_t
811: */
812: static backtrace_t get_methods()
813: {
814: return (backtrace_t) {
815: .log = _log_,
816: .contains_function = _contains_function,
817: .equals = _equals,
818: .clone = _clone_,
819: .create_frame_enumerator = _create_frame_enumerator,
820: .destroy = _destroy,
821: };
822: }
823:
824: /**
825: * See header
826: */
827: backtrace_t *backtrace_create(int skip)
828: {
829: private_backtrace_t *this;
830: void *frames[50];
831: int frame_count = 0;
832:
833: #ifdef HAVE_LIBUNWIND_H
834: frame_count = backtrace_unwind(frames, countof(frames));
835: #elif defined(HAVE_BACKTRACE)
836: frame_count = backtrace(frames, countof(frames));
837: #elif defined(HAVE_DBGHELP)
838: frame_count = backtrace_win(frames, countof(frames));
839: #elif defined(WIN32)
840: frame_count = CaptureStackBackTrace(skip, countof(frames), frames, NULL);
841: skip = 0;
842: #endif
843: frame_count = max(frame_count - skip, 0);
844: this = malloc(sizeof(private_backtrace_t) + frame_count * sizeof(void*));
845: memcpy(this->frames, frames + skip, frame_count * sizeof(void*));
846: this->frame_count = frame_count;
847:
848: this->public = get_methods();
849:
850: return &this->public;
851: }
852:
853: /**
854: * See header
855: */
856: void backtrace_dump(char *label, FILE *file, bool detailed)
857: {
858: backtrace_t *backtrace;
859:
860: backtrace = backtrace_create(2);
861:
862: if (label)
863: {
864: println(file, "Debug backtrace: %s", label);
865: }
866: backtrace->log(backtrace, file, detailed);
867: backtrace->destroy(backtrace);
868: }