2 * Copyright (c) 2013 Luca Clementi <luca.clementi@gmail.com>
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #include <libunwind-ptrace.h>
31 #ifdef _LARGEFILE64_SOURCE
33 # define fopen_for_input fopen64
35 # define fopen_for_input fopen
38 # define fopen_for_input fopen
41 #define DPRINTF(F, A, ...) if (debug_flag) fprintf(stderr, " [unwind(" A ")] " F "\n", __VA_ARGS__)
44 * Кeep a sorted array of cache entries,
45 * so that we can binary search through it.
50 * 7fabbb09b000-7fabbb09f000 r-xp 00179000 fc:00 1180246 /lib/libc-2.11.1.so
52 * start_addr is 0x7fabbb09b000
53 * end_addr is 0x7fabbb09f000
54 * mmap_offset is 0x179000
55 * binary_filename is "/lib/libc-2.11.1.so"
57 unsigned long start_addr;
58 unsigned long end_addr;
59 unsigned long mmap_offset;
60 char *binary_filename;
64 * Type used in stacktrace walker
66 typedef void (*call_action_fn)(void *data,
67 const char *binary_filename,
68 const char *symbol_name,
69 unw_word_t function_offset,
70 unsigned long true_offset);
71 typedef void (*error_action_fn)(void *data,
73 unsigned long true_offset);
76 * Type used in stacktrace capturing
88 static void queue_print(struct queue_t *queue);
89 static void delete_mmap_cache(struct tcb *tcp, const char *caller);
91 static unw_addr_space_t libunwind_as;
92 static unsigned int mmap_cache_generation;
97 libunwind_as = unw_create_addr_space(&_UPT_accessors, 0);
99 error_msg_and_die("failed to create address space for stack tracing");
100 unw_set_caching_policy(libunwind_as, UNW_CACHE_GLOBAL);
104 unwind_tcb_init(struct tcb *tcp)
106 tcp->libunwind_ui = _UPT_create(tcp->pid);
107 if (!tcp->libunwind_ui)
110 tcp->queue = xmalloc(sizeof(*tcp->queue));
111 tcp->queue->head = NULL;
112 tcp->queue->tail = NULL;
116 unwind_tcb_fin(struct tcb *tcp)
118 queue_print(tcp->queue);
122 delete_mmap_cache(tcp, __FUNCTION__);
124 _UPT_destroy(tcp->libunwind_ui);
125 tcp->libunwind_ui = NULL;
129 * caching of /proc/ID/maps for each process to speed up stack tracing
131 * The cache must be refreshed after syscalls that affect memory mappings,
132 * e.g. mmap, mprotect, munmap, execve.
135 build_mmap_cache(struct tcb* tcp)
138 struct mmap_cache_t *cache_head;
139 /* start with a small dynamically-allocated array and then expand it */
140 size_t cur_array_size = 10;
141 char filename[sizeof("/proc/4294967296/maps")];
142 char buffer[PATH_MAX + 80];
144 unw_flush_cache(libunwind_as, 0, 0);
146 sprintf(filename, "/proc/%u/maps", tcp->pid);
147 fp = fopen_for_input(filename, "r");
149 perror_msg("fopen: %s", filename);
153 cache_head = xcalloc(cur_array_size, sizeof(*cache_head));
155 while (fgets(buffer, sizeof(buffer), fp) != NULL) {
156 struct mmap_cache_t *entry;
157 unsigned long start_addr, end_addr, mmap_offset;
159 char binary_path[PATH_MAX];
161 if (sscanf(buffer, "%lx-%lx %*c%*c%c%*c %lx %*x:%*x %*d %[^\n]",
162 &start_addr, &end_addr, &exec_bit,
163 &mmap_offset, binary_path) != 5)
166 /* ignore mappings that have no PROT_EXEC bit set */
170 if (end_addr < start_addr) {
171 error_msg("%s: unrecognized file format", filename);
176 * sanity check to make sure that we're storing
177 * non-overlapping regions in ascending order
179 if (tcp->mmap_cache_size > 0) {
180 entry = &cache_head[tcp->mmap_cache_size - 1];
181 if (entry->start_addr == start_addr &&
182 entry->end_addr == end_addr) {
183 /* duplicate entry, e.g. [vsyscall] */
186 if (start_addr <= entry->start_addr ||
187 start_addr < entry->end_addr) {
188 error_msg("%s: overlapping memory region",
194 if (tcp->mmap_cache_size >= cur_array_size) {
196 cache_head = xreallocarray(cache_head, cur_array_size,
197 sizeof(*cache_head));
200 entry = &cache_head[tcp->mmap_cache_size];
201 entry->start_addr = start_addr;
202 entry->end_addr = end_addr;
203 entry->mmap_offset = mmap_offset;
204 entry->binary_filename = xstrdup(binary_path);
205 tcp->mmap_cache_size++;
208 tcp->mmap_cache = cache_head;
209 tcp->mmap_cache_generation = mmap_cache_generation;
211 DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p",
213 tcp->mmap_cache_generation,
214 mmap_cache_generation,
215 tcp, tcp->mmap_cache);
218 /* deleting the cache */
220 delete_mmap_cache(struct tcb *tcp, const char *caller)
224 DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p, caller=%s",
226 tcp->mmap_cache_generation,
227 mmap_cache_generation,
228 tcp, tcp->mmap_cache, caller);
230 for (i = 0; i < tcp->mmap_cache_size; i++) {
231 free(tcp->mmap_cache[i].binary_filename);
232 tcp->mmap_cache[i].binary_filename = NULL;
234 free(tcp->mmap_cache);
235 tcp->mmap_cache = NULL;
236 tcp->mmap_cache_size = 0;
240 rebuild_cache_if_invalid(struct tcb *tcp, const char *caller)
242 if ((tcp->mmap_cache_generation != mmap_cache_generation)
244 delete_mmap_cache(tcp, caller);
246 if (!tcp->mmap_cache)
247 build_mmap_cache(tcp);
249 if (!tcp->mmap_cache || !tcp->mmap_cache_size)
256 unwind_cache_invalidate(struct tcb* tcp)
258 #if SUPPORTED_PERSONALITIES > 1
259 if (tcp->currpers != DEFAULT_PERSONALITY) {
260 /* disable strack trace */
264 mmap_cache_generation++;
265 DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p", "increment",
266 tcp->mmap_cache_generation,
267 mmap_cache_generation,
273 get_symbol_name(unw_cursor_t *cursor, char **name,
274 size_t *size, unw_word_t *offset)
277 int rc = unw_get_proc_name(cursor, *name, *size, offset);
280 if (rc != -UNW_ENOMEM) {
285 *name = xreallocarray(*name, 2, *size);
291 print_stack_frame(struct tcb *tcp,
292 call_action_fn call_action,
293 error_action_fn error_action,
295 unw_cursor_t *cursor,
297 size_t *symbol_name_size)
301 int upper = (int) tcp->mmap_cache_size - 1;
303 if (unw_get_reg(cursor, UNW_REG_IP, &ip) < 0) {
304 perror_msg("Can't walk the stack of process %d", tcp->pid);
308 while (lower <= upper) {
309 struct mmap_cache_t *cur_mmap_cache;
310 int mid = (upper + lower) / 2;
312 cur_mmap_cache = &tcp->mmap_cache[mid];
314 if (ip >= cur_mmap_cache->start_addr &&
315 ip < cur_mmap_cache->end_addr) {
316 unsigned long true_offset;
317 unw_word_t function_offset;
319 get_symbol_name(cursor, symbol_name, symbol_name_size,
321 true_offset = ip - cur_mmap_cache->start_addr +
322 cur_mmap_cache->mmap_offset;
324 cur_mmap_cache->binary_filename,
330 else if (ip < cur_mmap_cache->start_addr)
337 * there is a bug in libunwind >= 1.0
338 * after a set_tid_address syscall
339 * unw_get_reg returns IP == 0
342 error_action(data, "unexpected_backtracing_error", ip);
350 stacktrace_walk(struct tcb *tcp,
351 call_action_fn call_action,
352 error_action_fn error_action,
356 size_t symbol_name_size = 40;
360 if (!tcp->mmap_cache)
361 error_msg_and_die("bug: mmap_cache is NULL");
362 if (tcp->mmap_cache_size == 0)
363 error_msg_and_die("bug: mmap_cache is empty");
365 symbol_name = xmalloc(symbol_name_size);
367 if (unw_init_remote(&cursor, libunwind_as, tcp->libunwind_ui) < 0)
368 perror_msg_and_die("Can't initiate libunwind");
370 for (stack_depth = 0; stack_depth < 256; ++stack_depth) {
371 if (print_stack_frame(tcp, call_action, error_action, data,
372 &cursor, &symbol_name, &symbol_name_size) < 0)
374 if (unw_step(&cursor) <= 0)
377 if (stack_depth >= 256)
378 error_action(data, "too many stack frames", 0);
384 * printing an entry in stack to stream or buffer
387 * we want to keep the format used by backtrace_symbols from the glibc
389 * ./a.out() [0x40063d]
390 * ./a.out() [0x4006bb]
391 * ./a.out() [0x4006c6]
392 * /lib64/libc.so.6(__libc_start_main+0xed) [0x7fa2f8a5976d]
393 * ./a.out() [0x400569]
395 #define STACK_ENTRY_SYMBOL_FMT \
396 " > %s(%s+0x%lx) [0x%lx]\n", \
399 (unsigned long) function_offset, \
401 #define STACK_ENTRY_NOSYMBOL_FMT \
402 " > %s() [0x%lx]\n", \
403 binary_filename, true_offset
404 #define STACK_ENTRY_BUG_FMT \
406 #define STACK_ENTRY_ERROR_WITH_OFFSET_FMT \
407 " > %s [0x%lx]\n", error, true_offset
408 #define STACK_ENTRY_ERROR_FMT \
412 print_call_cb(void *dummy,
413 const char *binary_filename,
414 const char *symbol_name,
415 unw_word_t function_offset,
416 unsigned long true_offset)
418 if (symbol_name && (symbol_name[0] != '\0'))
419 tprintf(STACK_ENTRY_SYMBOL_FMT);
420 else if (binary_filename)
421 tprintf(STACK_ENTRY_NOSYMBOL_FMT);
423 tprintf(STACK_ENTRY_BUG_FMT, __FUNCTION__);
429 print_error_cb(void *dummy,
431 unsigned long true_offset)
434 tprintf(STACK_ENTRY_ERROR_WITH_OFFSET_FMT);
436 tprintf(STACK_ENTRY_ERROR_FMT);
442 sprint_call_or_error(const char *binary_filename,
443 const char *symbol_name,
444 unw_word_t function_offset,
445 unsigned long true_offset,
448 char *output_line = NULL;
452 n = asprintf(&output_line, STACK_ENTRY_SYMBOL_FMT);
453 else if (binary_filename)
454 n = asprintf(&output_line, STACK_ENTRY_NOSYMBOL_FMT);
457 ? asprintf(&output_line, STACK_ENTRY_ERROR_WITH_OFFSET_FMT)
458 : asprintf(&output_line, STACK_ENTRY_ERROR_FMT);
460 n = asprintf(&output_line, STACK_ENTRY_BUG_FMT, __FUNCTION__);
463 error_msg_and_die("error in asprintf");
472 queue_put(struct queue_t *queue,
473 const char *binary_filename,
474 const char *symbol_name,
475 unw_word_t function_offset,
476 unsigned long true_offset,
481 call = xmalloc(sizeof(*call));
482 call->output_line = sprint_call_or_error(binary_filename,
493 queue->tail->next = call;
499 queue_put_call(void *queue,
500 const char *binary_filename,
501 const char *symbol_name,
502 unw_word_t function_offset,
503 unsigned long true_offset)
514 queue_put_error(void *queue,
518 queue_put(queue, NULL, NULL, 0, ip, error);
522 queue_print(struct queue_t *queue)
524 struct call_t *call, *tmp;
533 tprints(tmp->output_line);
536 free(tmp->output_line);
537 tmp->output_line = NULL;
547 unwind_print_stacktrace(struct tcb* tcp)
549 #if SUPPORTED_PERSONALITIES > 1
550 if (tcp->currpers != DEFAULT_PERSONALITY) {
551 /* disable strack trace */
555 if (tcp->queue->head) {
556 DPRINTF("tcp=%p, queue=%p", "queueprint", tcp, tcp->queue->head);
557 queue_print(tcp->queue);
559 else if (rebuild_cache_if_invalid(tcp, __FUNCTION__)) {
560 DPRINTF("tcp=%p, queue=%p", "stackprint", tcp, tcp->queue->head);
561 stacktrace_walk(tcp, print_call_cb, print_error_cb, NULL);
569 unwind_capture_stacktrace(struct tcb *tcp)
571 #if SUPPORTED_PERSONALITIES > 1
572 if (tcp->currpers != DEFAULT_PERSONALITY) {
573 /* disable strack trace */
577 if (tcp->queue->head)
578 error_msg_and_die("bug: unprinted entries in queue");
580 if (rebuild_cache_if_invalid(tcp, __FUNCTION__)) {
581 stacktrace_walk(tcp, queue_put_call, queue_put_error,
583 DPRINTF("tcp=%p, queue=%p", "captured", tcp, tcp->queue->head);