/* libunwind - a platform-independent unwind library Copyright (C) 2014 The Android Open Source Project This file is part of libunwind. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #define UNW_LOCAL_ONLY #include <libunwind.h> #include "libunwind_i.h" /* Global to hold the map for all local unwinds. */ extern struct map_info *local_map_list; extern lock_rdwr_var (local_rdwr_lock); static pthread_once_t local_rdwr_lock_init = PTHREAD_ONCE_INIT; static void map_local_init_once (void) { lock_rdwr_init (&local_rdwr_lock); } HIDDEN void map_local_init (void) { pthread_once (&local_rdwr_lock_init, map_local_init_once); } static void move_cached_elf_data (struct map_info *old_list, struct map_info *new_list) { while (old_list) { if (!old_list->ei.valid) { old_list = old_list->next; continue; } /* Both lists are in order, so it's not necessary to scan through from the beginning of new_list each time looking for a match to the current map. As we progress, simply start from the last element in new_list we checked. */ while (new_list && old_list->start <= new_list->start) { if (old_list->start == new_list->start && old_list->end == new_list->end) { /* No need to do any lock, the entire local_map_list is locked at this point. */ new_list->ei = old_list->ei; /* Adjust the map pointer in the elf image data if necessary. */ if (!new_list->ei.mapped) new_list->ei.u.memory.map = new_list; /* If it was mapped before, make sure to mark it unmapped now. */ old_list->ei.mapped = false; /* Don't bother breaking out of the loop, the next while check is guaranteed to fail, causing us to break out of the loop after advancing to the next map element. */ } new_list = new_list->next; } old_list = old_list->next; } } /* In order to cache as much as possible while unwinding the local process, we gather a map of the process before starting. If the cache is missing a map, or a map exists but doesn't have the "expected_flags" set, then check if the cache needs to be regenerated. While regenerating the list, grab a write lock to avoid any readers using the list while it's being modified. */ static int rebuild_if_necessary (unw_word_t addr, int expected_flags) { struct map_info *map; struct map_info *new_list; int ret_value = -1; intrmask_t saved_mask; new_list = map_create_list (UNW_MAP_CREATE_LOCAL, getpid()); map = map_find_from_addr (new_list, addr); if (map && (expected_flags == 0 || (map->flags & expected_flags))) { /* Get a write lock on local_map_list since it's going to be modified. */ lock_rdwr_wr_acquire (&local_rdwr_lock, saved_mask); /* Just in case another thread rebuilt the map, check to see if the ip with expected_flags is in local_map_list. If not, the assumption is that new_list is newer than local_map_list because the map only gets new maps with new permissions. If this is not true, then it would be necessary to regenerate the list one more time. */ ret_value = 0; map = map_find_from_addr (local_map_list, addr); if (!map || (expected_flags != 0 && !(map->flags & expected_flags))) { /* Move any cached items to the new list. */ move_cached_elf_data (local_map_list, new_list); map = local_map_list; local_map_list = new_list; new_list = map; } lock_rdwr_release (&local_rdwr_lock, saved_mask); } map_destroy_list (new_list); return ret_value; } static int is_flag_set (unw_word_t addr, int flag) { struct map_info *map; int ret = 0; intrmask_t saved_mask; lock_rdwr_rd_acquire (&local_rdwr_lock, saved_mask); map = map_find_from_addr (local_map_list, addr); if (map != NULL) { if (map->flags & MAP_FLAGS_DEVICE_MEM) { lock_rdwr_release (&local_rdwr_lock, saved_mask); return 0; } ret = map->flags & flag; } lock_rdwr_release (&local_rdwr_lock, saved_mask); if (!ret && rebuild_if_necessary (addr, flag) == 0) { return 1; } return ret; } PROTECTED int map_local_is_readable (unw_word_t addr) { return is_flag_set (addr, PROT_READ); } PROTECTED int map_local_is_writable (unw_word_t addr) { return is_flag_set (addr, PROT_WRITE); } PROTECTED int local_get_elf_image (unw_addr_space_t as, struct elf_image *ei, unw_word_t ip, unsigned long *segbase, unsigned long *mapoff, char **path, void *as_arg) { struct map_info *map; intrmask_t saved_mask; int return_value = -UNW_ENOINFO; lock_rdwr_rd_acquire (&local_rdwr_lock, saved_mask); map = map_find_from_addr (local_map_list, ip); if (!map) { lock_rdwr_release (&local_rdwr_lock, saved_mask); if (rebuild_if_necessary (ip, 0) < 0) return -UNW_ENOINFO; lock_rdwr_rd_acquire (&local_rdwr_lock, saved_mask); map = map_find_from_addr (local_map_list, ip); } if (map && elf_map_cached_image (as, as_arg, map, ip)) { *ei = map->ei; *segbase = map->start; if (ei->mapped) *mapoff = map->offset; else /* Always use zero as the map offset for in memory maps. The * dlopen of a shared library from an APK will result in a * non-zero offset so it won't match the elf data and cause * unwinds to fail. Currently, only in memory unwinds of an APK * are possible, so only modify this path. */ *mapoff = 0; if (path != NULL) { if (map->path) *path = strdup(map->path); else *path = NULL; } return_value = 0; } lock_rdwr_release (&local_rdwr_lock, saved_mask); return return_value; } PROTECTED char * map_local_get_image_name (unw_word_t ip) { struct map_info *map; intrmask_t saved_mask; char *image_name = NULL; lock_rdwr_rd_acquire (&local_rdwr_lock, saved_mask); map = map_find_from_addr (local_map_list, ip); if (!map) { lock_rdwr_release (&local_rdwr_lock, saved_mask); if (rebuild_if_necessary (ip, 0) < 0) return NULL; lock_rdwr_rd_acquire (&local_rdwr_lock, saved_mask); map = map_find_from_addr (local_map_list, ip); } if (map) image_name = strdup (map->path); lock_rdwr_release (&local_rdwr_lock, saved_mask); return image_name; }