| //===-- asan_linux.cc -----------------------------------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file is a part of AddressSanitizer, an address sanity checker. |
| // |
| // Linux-specific details. |
| //===----------------------------------------------------------------------===// |
| |
| #include "sanitizer_common/sanitizer_platform.h" |
| #if SANITIZER_FREEBSD || SANITIZER_LINUX |
| |
| #include "asan_interceptors.h" |
| #include "asan_internal.h" |
| #include "asan_thread.h" |
| #include "sanitizer_common/sanitizer_flags.h" |
| #include "sanitizer_common/sanitizer_libc.h" |
| #include "sanitizer_common/sanitizer_procmaps.h" |
| |
| #include <sys/time.h> |
| #include <sys/resource.h> |
| #include <sys/mman.h> |
| #include <sys/syscall.h> |
| #include <sys/types.h> |
| #include <fcntl.h> |
| #include <pthread.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <unwind.h> |
| |
| #if SANITIZER_FREEBSD |
| #include <sys/link_elf.h> |
| #endif |
| |
| #if SANITIZER_ANDROID || SANITIZER_FREEBSD |
| #include <ucontext.h> |
| extern "C" void* _DYNAMIC; |
| #else |
| #include <sys/ucontext.h> |
| #include <dlfcn.h> |
| #include <link.h> |
| #endif |
| |
| // x86_64 FreeBSD 9.2 and older define 64-bit register names in both 64-bit |
| // and 32-bit modes. |
| #if SANITIZER_FREEBSD |
| #include <sys/param.h> |
| # if __FreeBSD_version <= 902001 // v9.2 |
| # define mc_eip mc_rip |
| # define mc_ebp mc_rbp |
| # define mc_esp mc_rsp |
| # endif |
| #endif |
| |
| typedef enum { |
| ASAN_RT_VERSION_UNDEFINED = 0, |
| ASAN_RT_VERSION_DYNAMIC, |
| ASAN_RT_VERSION_STATIC, |
| } asan_rt_version_t; |
| |
| // FIXME: perhaps also store abi version here? |
| extern "C" { |
| SANITIZER_INTERFACE_ATTRIBUTE |
| asan_rt_version_t __asan_rt_version; |
| } |
| |
| namespace __asan { |
| |
| void MaybeReexec() { |
| // No need to re-exec on Linux. |
| } |
| |
| void *AsanDoesNotSupportStaticLinkage() { |
| // This will fail to link with -static. |
| return &_DYNAMIC; // defined in link.h |
| } |
| |
| #if SANITIZER_ANDROID |
| // FIXME: should we do anything for Android? |
| void AsanCheckDynamicRTPrereqs() {} |
| void AsanCheckIncompatibleRT() {} |
| #else |
| static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size, |
| void *data) { |
| // Continue until the first dynamic library is found |
| if (!info->dlpi_name || info->dlpi_name[0] == 0) |
| return 0; |
| |
| *(const char **)data = info->dlpi_name; |
| return 1; |
| } |
| |
| static bool IsDynamicRTName(const char *libname) { |
| return internal_strstr(libname, "libclang_rt.asan") || |
| internal_strstr(libname, "libasan.so"); |
| } |
| |
| static void ReportIncompatibleRT() { |
| Report("Your application is linked against incompatible ASan runtimes.\n"); |
| Die(); |
| } |
| |
| void AsanCheckDynamicRTPrereqs() { |
| // Ensure that dynamic RT is the first DSO in the list |
| const char *first_dso_name = 0; |
| dl_iterate_phdr(FindFirstDSOCallback, &first_dso_name); |
| if (first_dso_name && !IsDynamicRTName(first_dso_name)) { |
| Report("ASan runtime does not come first in initial library list; " |
| "you should either link runtime to your application or " |
| "manually preload it with LD_PRELOAD.\n"); |
| Die(); |
| } |
| } |
| |
| void AsanCheckIncompatibleRT() { |
| if (ASAN_DYNAMIC) { |
| if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) { |
| __asan_rt_version = ASAN_RT_VERSION_DYNAMIC; |
| } else if (__asan_rt_version != ASAN_RT_VERSION_DYNAMIC) { |
| ReportIncompatibleRT(); |
| } |
| } else { |
| if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) { |
| // Ensure that dynamic runtime is not present. We should detect it |
| // as early as possible, otherwise ASan interceptors could bind to |
| // the functions in dynamic ASan runtime instead of the functions in |
| // system libraries, causing crashes later in ASan initialization. |
| MemoryMappingLayout proc_maps(/*cache_enabled*/true); |
| char filename[128]; |
| while (proc_maps.Next(0, 0, 0, filename, sizeof(filename), 0)) { |
| if (IsDynamicRTName(filename)) { |
| Report("Your application is linked against " |
| "incompatible ASan runtimes.\n"); |
| Die(); |
| } |
| } |
| __asan_rt_version = ASAN_RT_VERSION_STATIC; |
| } else if (__asan_rt_version != ASAN_RT_VERSION_STATIC) { |
| ReportIncompatibleRT(); |
| } |
| } |
| } |
| #endif // SANITIZER_ANDROID |
| |
| void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) { |
| #if defined(__arm__) |
| ucontext_t *ucontext = (ucontext_t*)context; |
| *pc = ucontext->uc_mcontext.arm_pc; |
| *bp = ucontext->uc_mcontext.arm_fp; |
| *sp = ucontext->uc_mcontext.arm_sp; |
| #elif defined(__aarch64__) |
| ucontext_t *ucontext = (ucontext_t*)context; |
| *pc = ucontext->uc_mcontext.pc; |
| *bp = ucontext->uc_mcontext.regs[29]; |
| *sp = ucontext->uc_mcontext.sp; |
| #elif defined(__hppa__) |
| ucontext_t *ucontext = (ucontext_t*)context; |
| *pc = ucontext->uc_mcontext.sc_iaoq[0]; |
| /* GCC uses %r3 whenever a frame pointer is needed. */ |
| *bp = ucontext->uc_mcontext.sc_gr[3]; |
| *sp = ucontext->uc_mcontext.sc_gr[30]; |
| #elif defined(__x86_64__) |
| # if SANITIZER_FREEBSD |
| ucontext_t *ucontext = (ucontext_t*)context; |
| *pc = ucontext->uc_mcontext.mc_rip; |
| *bp = ucontext->uc_mcontext.mc_rbp; |
| *sp = ucontext->uc_mcontext.mc_rsp; |
| # else |
| ucontext_t *ucontext = (ucontext_t*)context; |
| *pc = ucontext->uc_mcontext.gregs[REG_RIP]; |
| *bp = ucontext->uc_mcontext.gregs[REG_RBP]; |
| *sp = ucontext->uc_mcontext.gregs[REG_RSP]; |
| # endif |
| #elif defined(__i386__) |
| # if SANITIZER_FREEBSD |
| ucontext_t *ucontext = (ucontext_t*)context; |
| *pc = ucontext->uc_mcontext.mc_eip; |
| *bp = ucontext->uc_mcontext.mc_ebp; |
| *sp = ucontext->uc_mcontext.mc_esp; |
| # else |
| ucontext_t *ucontext = (ucontext_t*)context; |
| *pc = ucontext->uc_mcontext.gregs[REG_EIP]; |
| *bp = ucontext->uc_mcontext.gregs[REG_EBP]; |
| *sp = ucontext->uc_mcontext.gregs[REG_ESP]; |
| # endif |
| #elif defined(__sparc__) |
| ucontext_t *ucontext = (ucontext_t*)context; |
| uptr *stk_ptr; |
| # if defined (__arch64__) |
| *pc = ucontext->uc_mcontext.mc_gregs[MC_PC]; |
| *sp = ucontext->uc_mcontext.mc_gregs[MC_O6]; |
| stk_ptr = (uptr *) (*sp + 2047); |
| *bp = stk_ptr[15]; |
| # else |
| *pc = ucontext->uc_mcontext.gregs[REG_PC]; |
| *sp = ucontext->uc_mcontext.gregs[REG_O6]; |
| stk_ptr = (uptr *) *sp; |
| *bp = stk_ptr[15]; |
| # endif |
| #elif defined(__mips__) |
| ucontext_t *ucontext = (ucontext_t*)context; |
| *pc = ucontext->uc_mcontext.gregs[31]; |
| *bp = ucontext->uc_mcontext.gregs[30]; |
| *sp = ucontext->uc_mcontext.gregs[29]; |
| #else |
| # error "Unsupported arch" |
| #endif |
| } |
| |
| bool AsanInterceptsSignal(int signum) { |
| return signum == SIGSEGV && common_flags()->handle_segv; |
| } |
| |
| void AsanPlatformThreadInit() { |
| // Nothing here for now. |
| } |
| |
| #if !SANITIZER_ANDROID |
| void ReadContextStack(void *context, uptr *stack, uptr *ssize) { |
| ucontext_t *ucp = (ucontext_t*)context; |
| *stack = (uptr)ucp->uc_stack.ss_sp; |
| *ssize = ucp->uc_stack.ss_size; |
| } |
| #else |
| void ReadContextStack(void *context, uptr *stack, uptr *ssize) { |
| UNIMPLEMENTED(); |
| } |
| #endif |
| |
| } // namespace __asan |
| |
| #endif // SANITIZER_FREEBSD || SANITIZER_LINUX |