asan_linux.cc revision 49d616ec42ab420ce3ebcbe846b21e3729adf5ac 
1//===-- asan_linux.cc -----------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file is a part of AddressSanitizer, an address sanity checker.
11//
12// Linux-specific details.
13//===----------------------------------------------------------------------===//
14#ifdef __linux__
15
16#include "asan_interceptors.h"
17#include "asan_internal.h"
18#include "asan_lock.h"
19#include "asan_thread.h"
20#include "asan_thread_registry.h"
21#include "sanitizer_common/sanitizer_libc.h"
22#include "sanitizer_common/sanitizer_procmaps.h"
23
24#include <sys/time.h>
25#include <sys/resource.h>
26#include <sys/mman.h>
27#include <sys/syscall.h>
28#include <sys/types.h>
29#include <fcntl.h>
30#include <pthread.h>
31#include <stdio.h>
32#include <unistd.h>
33#include <unwind.h>
34
35#if !ASAN_ANDROID
36// FIXME: where to get ucontext on Android?
37#include <sys/ucontext.h>
38#endif
39
40extern "C" void* _DYNAMIC;
41
42namespace __asan {
43
44void MaybeReexec() {
45  // No need to re-exec on Linux.
46}
47
48void *AsanDoesNotSupportStaticLinkage() {
49  // This will fail to link with -static.
50  return &_DYNAMIC;  // defined in link.h
51}
52
53void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
54#if ASAN_ANDROID
55  *pc = *sp = *bp = 0;
56#elif defined(__arm__)
57  ucontext_t *ucontext = (ucontext_t*)context;
58  *pc = ucontext->uc_mcontext.arm_pc;
59  *bp = ucontext->uc_mcontext.arm_fp;
60  *sp = ucontext->uc_mcontext.arm_sp;
61# elif defined(__x86_64__)
62  ucontext_t *ucontext = (ucontext_t*)context;
63  *pc = ucontext->uc_mcontext.gregs[REG_RIP];
64  *bp = ucontext->uc_mcontext.gregs[REG_RBP];
65  *sp = ucontext->uc_mcontext.gregs[REG_RSP];
66# elif defined(__i386__)
67  ucontext_t *ucontext = (ucontext_t*)context;
68  *pc = ucontext->uc_mcontext.gregs[REG_EIP];
69  *bp = ucontext->uc_mcontext.gregs[REG_EBP];
70  *sp = ucontext->uc_mcontext.gregs[REG_ESP];
71# elif defined(__powerpc__) || defined(__powerpc64__)
72  ucontext_t *ucontext = (ucontext_t*)context;
73  *pc = ucontext->uc_mcontext.regs->nip;
74  *sp = ucontext->uc_mcontext.regs->gpr[PT_R1];
75  // The powerpc{,64}-linux ABIs do not specify r31 as the frame
76  // pointer, but GCC always uses r31 when we need a frame pointer.
77  *bp = ucontext->uc_mcontext.regs->gpr[PT_R31];
78# elif defined(__sparc__)
79  ucontext_t *ucontext = (ucontext_t*)context;
80  uptr *stk_ptr;
81# if defined (__arch64__)
82  *pc = ucontext->uc_mcontext.mc_gregs[MC_PC];
83  *sp = ucontext->uc_mcontext.mc_gregs[MC_O6];
84  stk_ptr = (uptr *) (*sp + 2047);
85  *bp = stk_ptr[15];
86# else
87  *pc = ucontext->uc_mcontext.gregs[REG_PC];
88  *sp = ucontext->uc_mcontext.gregs[REG_O6];
89  stk_ptr = (uptr *) *sp;
90  *bp = stk_ptr[15];
91# endif
92#else
93# error "Unsupported arch"
94#endif
95}
96
97bool AsanInterceptsSignal(int signum) {
98  return signum == SIGSEGV && flags()->handle_segv;
99}
100
101void AsanPlatformThreadInit() {
102  // Nothing here for now.
103}
104
105AsanLock::AsanLock(LinkerInitialized) {
106  // We assume that pthread_mutex_t initialized to all zeroes is a valid
107  // unlocked mutex. We can not use PTHREAD_MUTEX_INITIALIZER as it triggers
108  // a gcc warning:
109  // extended initializer lists only available with -std=c++0x or -std=gnu++0x
110}
111
112void AsanLock::Lock() {
113  CHECK(sizeof(pthread_mutex_t) <= sizeof(opaque_storage_));
114  pthread_mutex_lock((pthread_mutex_t*)&opaque_storage_);
115  CHECK(!owner_);
116  owner_ = (uptr)pthread_self();
117}
118
119void AsanLock::Unlock() {
120  CHECK(owner_ == (uptr)pthread_self());
121  owner_ = 0;
122  pthread_mutex_unlock((pthread_mutex_t*)&opaque_storage_);
123}
124
125void GetStackTrace(StackTrace *stack, uptr max_s, uptr pc, uptr bp, bool fast) {
126#if defined(__arm__) || \
127    defined(__powerpc__) || defined(__powerpc64__) || \
128    defined(__sparc__)
129  fast = false;
130#endif
131  if (!fast)
132    return stack->SlowUnwindStack(pc, max_s);
133  stack->size = 0;
134  stack->trace[0] = pc;
135  if (max_s > 1) {
136    stack->max_size = max_s;
137    if (!asan_inited) return;
138    if (AsanThread *t = asanThreadRegistry().GetCurrent())
139      stack->FastUnwindStack(pc, bp, t->stack_top(), t->stack_bottom());
140  }
141}
142
143#if !ASAN_ANDROID
144void ClearShadowMemoryForContext(void *context) {
145  ucontext_t *ucp = (ucontext_t*)context;
146  uptr sp = (uptr)ucp->uc_stack.ss_sp;
147  uptr size = ucp->uc_stack.ss_size;
148  // Align to page size.
149  uptr PageSize = GetPageSizeCached();
150  uptr bottom = sp & ~(PageSize - 1);
151  size += sp - bottom;
152  size = RoundUpTo(size, PageSize);
153  PoisonShadow(bottom, size, 0);
154}
155#else
156void ClearShadowMemoryForContext(void *context) {
157  UNIMPLEMENTED();
158}
159#endif
160
161}  // namespace __asan
162
163#endif  // __linux__
164