Home | History | Annotate | Download | only in strace
      1 /*
      2  * Copyright (c) 2013 Luca Clementi <luca.clementi (at) gmail.com>
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      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.
     14  *
     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.
     25  */
     26 
     27 #include "defs.h"
     28 #include <limits.h>
     29 #include <libunwind-ptrace.h>
     30 
     31 #ifdef _LARGEFILE64_SOURCE
     32 # ifdef HAVE_FOPEN64
     33 #  define fopen_for_input fopen64
     34 # else
     35 #  define fopen_for_input fopen
     36 # endif
     37 #else
     38 # define fopen_for_input fopen
     39 #endif
     40 
     41 #define DPRINTF(F, A, ...) if (debug_flag) fprintf(stderr, " [unwind(" A ")] " F "\n", __VA_ARGS__)
     42 
     43 /*
     44  * eep a sorted array of cache entries,
     45  * so that we can binary search through it.
     46  */
     47 struct mmap_cache_t {
     48 	/**
     49 	 * example entry:
     50 	 * 7fabbb09b000-7fabbb09f000 r-xp 00179000 fc:00 1180246 /lib/libc-2.11.1.so
     51 	 *
     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"
     56 	 */
     57 	unsigned long start_addr;
     58 	unsigned long end_addr;
     59 	unsigned long mmap_offset;
     60 	char *binary_filename;
     61 };
     62 
     63 /*
     64  * Type used in stacktrace walker
     65  */
     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,
     72 				const char *error,
     73 				unsigned long true_offset);
     74 
     75 /*
     76  * Type used in stacktrace capturing
     77  */
     78 struct call_t {
     79        struct call_t* next;
     80        char *output_line;
     81 };
     82 
     83 struct queue_t {
     84        struct call_t *tail;
     85        struct call_t *head;
     86 };
     87 
     88 static void queue_print(struct queue_t *queue);
     89 static void delete_mmap_cache(struct tcb *tcp, const char *caller);
     90 
     91 static unw_addr_space_t libunwind_as;
     92 static unsigned int mmap_cache_generation;
     93 
     94 void
     95 unwind_init(void)
     96 {
     97 	libunwind_as = unw_create_addr_space(&_UPT_accessors, 0);
     98 	if (!libunwind_as)
     99 		error_msg_and_die("failed to create address space for stack tracing");
    100 	unw_set_caching_policy(libunwind_as, UNW_CACHE_GLOBAL);
    101 }
    102 
    103 void
    104 unwind_tcb_init(struct tcb *tcp)
    105 {
    106 	tcp->libunwind_ui = _UPT_create(tcp->pid);
    107 	if (!tcp->libunwind_ui)
    108 		die_out_of_memory();
    109 
    110 	tcp->queue = malloc(sizeof(*tcp->queue));
    111 	if (!tcp->queue)
    112 		die_out_of_memory();
    113 	tcp->queue->head = NULL;
    114 	tcp->queue->tail = NULL;
    115 }
    116 
    117 void
    118 unwind_tcb_fin(struct tcb *tcp)
    119 {
    120 	queue_print(tcp->queue);
    121 	free(tcp->queue);
    122 	tcp->queue = NULL;
    123 
    124 	delete_mmap_cache(tcp, __FUNCTION__);
    125 
    126 	_UPT_destroy(tcp->libunwind_ui);
    127 	tcp->libunwind_ui = NULL;
    128 }
    129 
    130 /*
    131  * caching of /proc/ID/maps for each process to speed up stack tracing
    132  *
    133  * The cache must be refreshed after syscalls that affect memory mappings,
    134  * e.g. mmap, mprotect, munmap, execve.
    135  */
    136 static void
    137 build_mmap_cache(struct tcb* tcp)
    138 {
    139 	FILE *fp;
    140 	struct mmap_cache_t *cache_head;
    141 	/* start with a small dynamically-allocated array and then expand it */
    142 	size_t cur_array_size = 10;
    143 	char filename[sizeof("/proc/4294967296/maps")];
    144 	char buffer[PATH_MAX + 80];
    145 
    146 	unw_flush_cache(libunwind_as, 0, 0);
    147 
    148 	sprintf(filename, "/proc/%u/maps", tcp->pid);
    149 	fp = fopen_for_input(filename, "r");
    150 	if (!fp) {
    151 		perror_msg("fopen: %s", filename);
    152 		return;
    153 	}
    154 
    155 	cache_head = calloc(cur_array_size, sizeof(*cache_head));
    156 	if (!cache_head)
    157 		die_out_of_memory();
    158 
    159 	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
    160 		struct mmap_cache_t *entry;
    161 		unsigned long start_addr, end_addr, mmap_offset;
    162 		char exec_bit;
    163 		char binary_path[PATH_MAX];
    164 
    165 		if (sscanf(buffer, "%lx-%lx %*c%*c%c%*c %lx %*x:%*x %*d %[^\n]",
    166 			   &start_addr, &end_addr, &exec_bit,
    167 			   &mmap_offset, binary_path) != 5)
    168 			continue;
    169 
    170 		/* ignore mappings that have no PROT_EXEC bit set */
    171 		if (exec_bit != 'x')
    172 			continue;
    173 
    174 		if (end_addr < start_addr) {
    175 			error_msg("%s: unrecognized file format", filename);
    176 			break;
    177 		}
    178 
    179 		/*
    180 		 * sanity check to make sure that we're storing
    181 		 * non-overlapping regions in ascending order
    182 		 */
    183 		if (tcp->mmap_cache_size > 0) {
    184 			entry = &cache_head[tcp->mmap_cache_size - 1];
    185 			if (entry->start_addr == start_addr &&
    186 			    entry->end_addr == end_addr) {
    187 				/* duplicate entry, e.g. [vsyscall] */
    188 				continue;
    189 			}
    190 			if (start_addr <= entry->start_addr ||
    191 			    start_addr < entry->end_addr) {
    192 				error_msg("%s: overlapping memory region",
    193 					  filename);
    194 				continue;
    195 			}
    196 		}
    197 
    198 		if (tcp->mmap_cache_size >= cur_array_size) {
    199 			cur_array_size *= 2;
    200 			cache_head = realloc(cache_head,
    201 					     cur_array_size * sizeof(*cache_head));
    202 			if (!cache_head)
    203 				die_out_of_memory();
    204 		}
    205 
    206 		entry = &cache_head[tcp->mmap_cache_size];
    207 		entry->start_addr = start_addr;
    208 		entry->end_addr = end_addr;
    209 		entry->mmap_offset = mmap_offset;
    210 		entry->binary_filename = strdup(binary_path);
    211 		if (!entry->binary_filename)
    212 			die_out_of_memory();
    213 		tcp->mmap_cache_size++;
    214 	}
    215 	fclose(fp);
    216 	tcp->mmap_cache = cache_head;
    217 	tcp->mmap_cache_generation = mmap_cache_generation;
    218 
    219 	DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p",
    220 		"cache-build",
    221 		tcp->mmap_cache_generation,
    222 		mmap_cache_generation,
    223 		tcp, tcp->mmap_cache);
    224 }
    225 
    226 /* deleting the cache */
    227 static void
    228 delete_mmap_cache(struct tcb *tcp, const char *caller)
    229 {
    230 	unsigned int i;
    231 
    232 	DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p, caller=%s",
    233 		"cache-delete",
    234 		tcp->mmap_cache_generation,
    235 		mmap_cache_generation,
    236 		tcp, tcp->mmap_cache, caller);
    237 
    238 	for (i = 0; i < tcp->mmap_cache_size; i++) {
    239 		free(tcp->mmap_cache[i].binary_filename);
    240 		tcp->mmap_cache[i].binary_filename = NULL;
    241 	}
    242 	free(tcp->mmap_cache);
    243 	tcp->mmap_cache = NULL;
    244 	tcp->mmap_cache_size = 0;
    245 }
    246 
    247 static bool
    248 rebuild_cache_if_invalid(struct tcb *tcp, const char *caller)
    249 {
    250 	if ((tcp->mmap_cache_generation != mmap_cache_generation)
    251 	    && tcp->mmap_cache)
    252 		delete_mmap_cache(tcp, caller);
    253 
    254 	if (!tcp->mmap_cache)
    255 		build_mmap_cache(tcp);
    256 
    257 	if (!tcp->mmap_cache || !tcp->mmap_cache_size)
    258 		return false;
    259 	else
    260 		return true;
    261 }
    262 
    263 void
    264 unwind_cache_invalidate(struct tcb* tcp)
    265 {
    266 #if SUPPORTED_PERSONALITIES > 1
    267 	if (tcp->currpers != DEFAULT_PERSONALITY) {
    268 		/* disable strack trace */
    269 		return;
    270 	}
    271 #endif
    272 	mmap_cache_generation++;
    273 	DPRINTF("tgen=%u, ggen=%u, tcp=%p, cache=%p", "increment",
    274 		tcp->mmap_cache_generation,
    275 		mmap_cache_generation,
    276 		tcp,
    277 		tcp->mmap_cache);
    278 }
    279 
    280 static void
    281 get_symbol_name(unw_cursor_t *cursor, char **name,
    282 		size_t *size, unw_word_t *offset)
    283 {
    284 	for (;;) {
    285 		int rc = unw_get_proc_name(cursor, *name, *size, offset);
    286 		if (rc == 0)
    287 			break;
    288 		if (rc != -UNW_ENOMEM) {
    289 			**name = '\0';
    290 			*offset = 0;
    291 			break;
    292 		}
    293 		*size *= 2;
    294 		*name = realloc(*name, *size);
    295 		if (!*name)
    296 			die_out_of_memory();
    297 	}
    298 }
    299 
    300 static int
    301 print_stack_frame(struct tcb *tcp,
    302 		  call_action_fn call_action,
    303 		  error_action_fn error_action,
    304 		  void *data,
    305 		  unw_cursor_t *cursor,
    306 		  char **symbol_name,
    307 		  size_t *symbol_name_size)
    308 {
    309 	unw_word_t ip;
    310 	int lower = 0;
    311 	int upper = (int) tcp->mmap_cache_size - 1;
    312 
    313 	if (unw_get_reg(cursor, UNW_REG_IP, &ip) < 0) {
    314 		perror_msg("Can't walk the stack of process %d", tcp->pid);
    315 		return -1;
    316 	}
    317 
    318 	while (lower <= upper) {
    319 		struct mmap_cache_t *cur_mmap_cache;
    320 		int mid = (upper + lower) / 2;
    321 
    322 		cur_mmap_cache = &tcp->mmap_cache[mid];
    323 
    324 		if (ip >= cur_mmap_cache->start_addr &&
    325 		    ip < cur_mmap_cache->end_addr) {
    326 			unsigned long true_offset;
    327 			unw_word_t function_offset;
    328 
    329 			get_symbol_name(cursor, symbol_name, symbol_name_size,
    330 					&function_offset);
    331 			true_offset = ip - cur_mmap_cache->start_addr +
    332 				cur_mmap_cache->mmap_offset;
    333 			call_action(data,
    334 				    cur_mmap_cache->binary_filename,
    335 				    *symbol_name,
    336 				    function_offset,
    337 				    true_offset);
    338 			return 0;
    339 		}
    340 		else if (ip < cur_mmap_cache->start_addr)
    341 			upper = mid - 1;
    342 		else
    343 			lower = mid + 1;
    344 	}
    345 
    346 	/*
    347 	 * there is a bug in libunwind >= 1.0
    348 	 * after a set_tid_address syscall
    349 	 * unw_get_reg returns IP == 0
    350 	 */
    351 	if(ip)
    352 		error_action(data, "unexpected_backtracing_error", ip);
    353 	return -1;
    354 }
    355 
    356 /*
    357  * walking the stack
    358  */
    359 static void
    360 stacktrace_walk(struct tcb *tcp,
    361 		call_action_fn call_action,
    362 		error_action_fn error_action,
    363 		void *data)
    364 {
    365 	char *symbol_name;
    366 	size_t symbol_name_size = 40;
    367 	unw_cursor_t cursor;
    368 	int stack_depth;
    369 
    370 	if (!tcp->mmap_cache)
    371 		error_msg_and_die("bug: mmap_cache is NULL");
    372 	if (tcp->mmap_cache_size == 0)
    373 		error_msg_and_die("bug: mmap_cache is empty");
    374 
    375 	symbol_name = malloc(symbol_name_size);
    376 	if (!symbol_name)
    377 		die_out_of_memory();
    378 
    379 	if (unw_init_remote(&cursor, libunwind_as, tcp->libunwind_ui) < 0)
    380 		perror_msg_and_die("Can't initiate libunwind");
    381 
    382 	for (stack_depth = 0; stack_depth < 256; ++stack_depth) {
    383 		if (print_stack_frame(tcp, call_action, error_action, data,
    384 				&cursor, &symbol_name, &symbol_name_size) < 0)
    385 			break;
    386 		if (unw_step(&cursor) <= 0)
    387 			break;
    388 	}
    389 	if (stack_depth >= 256)
    390 		error_action(data, "too many stack frames", 0);
    391 
    392 	free(symbol_name);
    393 }
    394 
    395 /*
    396  * printing an entry in stack to stream or buffer
    397  */
    398 /*
    399  * we want to keep the format used by backtrace_symbols from the glibc
    400  *
    401  * ./a.out() [0x40063d]
    402  * ./a.out() [0x4006bb]
    403  * ./a.out() [0x4006c6]
    404  * /lib64/libc.so.6(__libc_start_main+0xed) [0x7fa2f8a5976d]
    405  * ./a.out() [0x400569]
    406  */
    407 #define STACK_ENTRY_SYMBOL_FMT			\
    408 	" > %s(%s+0x%lx) [0x%lx]\n",		\
    409 	binary_filename,			\
    410 	symbol_name,				\
    411 	(unsigned long) function_offset,	\
    412 	true_offset
    413 #define STACK_ENTRY_NOSYMBOL_FMT		\
    414 	" > %s() [0x%lx]\n",			\
    415 	binary_filename, true_offset
    416 #define STACK_ENTRY_BUG_FMT			\
    417 	" > BUG IN %s\n"
    418 #define STACK_ENTRY_ERROR_WITH_OFFSET_FMT	\
    419 	" > %s [0x%lx]\n", error, true_offset
    420 #define STACK_ENTRY_ERROR_FMT			\
    421 	" > %s\n", error
    422 
    423 static void
    424 print_call_cb(void *dummy,
    425 	      const char *binary_filename,
    426 	      const char *symbol_name,
    427 	      unw_word_t function_offset,
    428 	      unsigned long true_offset)
    429 {
    430 	if (symbol_name && (symbol_name[0] != '\0'))
    431 		tprintf(STACK_ENTRY_SYMBOL_FMT);
    432 	else if (binary_filename)
    433 		tprintf(STACK_ENTRY_NOSYMBOL_FMT);
    434 	else
    435 		tprintf(STACK_ENTRY_BUG_FMT, __FUNCTION__);
    436 
    437 	line_ended();
    438 }
    439 
    440 static void
    441 print_error_cb(void *dummy,
    442 	       const char *error,
    443 	       unsigned long true_offset)
    444 {
    445 	if (true_offset)
    446 		tprintf(STACK_ENTRY_ERROR_WITH_OFFSET_FMT);
    447 	else
    448 		tprintf(STACK_ENTRY_ERROR_FMT);
    449 
    450 	line_ended();
    451 }
    452 
    453 static char *
    454 sprint_call_or_error(const char *binary_filename,
    455 		     const char *symbol_name,
    456 		     unw_word_t function_offset,
    457 		     unsigned long true_offset,
    458 		     const char *error)
    459 {
    460        char *output_line = NULL;
    461        int n;
    462 
    463        if (symbol_name)
    464                n = asprintf(&output_line, STACK_ENTRY_SYMBOL_FMT);
    465        else if (binary_filename)
    466                n = asprintf(&output_line, STACK_ENTRY_NOSYMBOL_FMT);
    467        else if (error)
    468                n = true_offset
    469                        ? asprintf(&output_line, STACK_ENTRY_ERROR_WITH_OFFSET_FMT)
    470                        : asprintf(&output_line, STACK_ENTRY_ERROR_FMT);
    471        else
    472                n = asprintf(&output_line, STACK_ENTRY_BUG_FMT, __FUNCTION__);
    473 
    474        if (n < 0)
    475                error_msg_and_die("error in asprintf");
    476 
    477        return output_line;
    478 }
    479 
    480 /*
    481  * queue manipulators
    482  */
    483 static void
    484 queue_put(struct queue_t *queue,
    485 	  const char *binary_filename,
    486 	  const char *symbol_name,
    487 	  unw_word_t function_offset,
    488 	  unsigned long true_offset,
    489 	  const char *error)
    490 {
    491 	struct call_t *call;
    492 
    493 	call = malloc(sizeof(*call));
    494 	if (!call)
    495 		die_out_of_memory();
    496 
    497 	call->output_line = sprint_call_or_error(binary_filename,
    498 						 symbol_name,
    499 						 function_offset,
    500 						 true_offset,
    501 						 error);
    502 	call->next = NULL;
    503 
    504 	if (!queue->head) {
    505 		queue->head = call;
    506 		queue->tail = call;
    507 	} else {
    508 		queue->tail->next = call;
    509 		queue->tail = call;
    510 	}
    511 }
    512 
    513 static void
    514 queue_put_call(void *queue,
    515 	       const char *binary_filename,
    516 	       const char *symbol_name,
    517 	       unw_word_t function_offset,
    518 	       unsigned long true_offset)
    519 {
    520 	queue_put(queue,
    521 		  binary_filename,
    522 		  symbol_name,
    523 		  function_offset,
    524 		  true_offset,
    525 		  NULL);
    526 }
    527 
    528 static void
    529 queue_put_error(void *queue,
    530 		const char *error,
    531 		unsigned long ip)
    532 {
    533 	queue_put(queue, NULL, NULL, 0, ip, error);
    534 }
    535 
    536 static void
    537 queue_print(struct queue_t *queue)
    538 {
    539 	struct call_t *call, *tmp;
    540 
    541 	queue->tail = NULL;
    542 	call = queue->head;
    543 	queue->head = NULL;
    544 	while (call) {
    545 		tmp = call;
    546 		call = call->next;
    547 
    548 		tprints(tmp->output_line);
    549 		line_ended();
    550 
    551 		free(tmp->output_line);
    552 		tmp->output_line = NULL;
    553 		tmp->next = NULL;
    554 		free(tmp);
    555 	}
    556 }
    557 
    558 /*
    559  * printing stack
    560  */
    561 void
    562 unwind_print_stacktrace(struct tcb* tcp)
    563 {
    564 #if SUPPORTED_PERSONALITIES > 1
    565 	if (tcp->currpers != DEFAULT_PERSONALITY) {
    566 		/* disable strack trace */
    567 		return;
    568 	}
    569 #endif
    570        if (tcp->queue->head) {
    571 	       DPRINTF("tcp=%p, queue=%p", "queueprint", tcp, tcp->queue->head);
    572 	       queue_print(tcp->queue);
    573        }
    574        else if (rebuild_cache_if_invalid(tcp, __FUNCTION__)) {
    575                DPRINTF("tcp=%p, queue=%p", "stackprint", tcp, tcp->queue->head);
    576                stacktrace_walk(tcp, print_call_cb, print_error_cb, NULL);
    577        }
    578 }
    579 
    580 /*
    581  * capturing stack
    582  */
    583 void
    584 unwind_capture_stacktrace(struct tcb *tcp)
    585 {
    586 #if SUPPORTED_PERSONALITIES > 1
    587 	if (tcp->currpers != DEFAULT_PERSONALITY) {
    588 		/* disable strack trace */
    589 		return;
    590 	}
    591 #endif
    592 	if (tcp->queue->head)
    593 		error_msg_and_die("bug: unprinted entries in queue");
    594 
    595 	if (rebuild_cache_if_invalid(tcp, __FUNCTION__)) {
    596 		stacktrace_walk(tcp, queue_put_call, queue_put_error,
    597 				tcp->queue);
    598 		DPRINTF("tcp=%p, queue=%p", "captured", tcp, tcp->queue->head);
    599 	}
    600 }
    601