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
15 #include "sanitizer_common/sanitizer_platform.h"
16 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
17 SANITIZER_SOLARIS
18
19 #include "asan_interceptors.h"
20 #include "asan_internal.h"
21 #include "asan_premap_shadow.h"
22 #include "asan_thread.h"
23 #include "sanitizer_common/sanitizer_flags.h"
24 #include "sanitizer_common/sanitizer_freebsd.h"
25 #include "sanitizer_common/sanitizer_libc.h"
26 #include "sanitizer_common/sanitizer_procmaps.h"
27
28 #include <sys/time.h>
29 #include <sys/resource.h>
30 #include <sys/mman.h>
31 #include <sys/syscall.h>
32 #include <sys/types.h>
33 #include <dlfcn.h>
34 #include <fcntl.h>
35 #include <limits.h>
36 #include <pthread.h>
37 #include <stdio.h>
38 #include <unistd.h>
39 #include <unwind.h>
40
41 #if SANITIZER_FREEBSD
42 #include <sys/link_elf.h>
43 #endif
44
45 #if SANITIZER_SOLARIS
46 #include <link.h>
47 #endif
48
49 #if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS
50 #include <ucontext.h>
51 extern "C" void* _DYNAMIC;
52 #elif SANITIZER_NETBSD
53 #include <link_elf.h>
54 #include <ucontext.h>
55 extern Elf_Dyn _DYNAMIC;
56 #else
57 #include <sys/ucontext.h>
58 #include <link.h>
59 #endif
60
61 // x86-64 FreeBSD 9.2 and older define 'ucontext_t' incorrectly in
62 // 32-bit mode.
63 #if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32) && \
64 __FreeBSD_version <= 902001 // v9.2
65 #define ucontext_t xucontext_t
66 #endif
67
68 typedef enum {
69 ASAN_RT_VERSION_UNDEFINED = 0,
70 ASAN_RT_VERSION_DYNAMIC,
71 ASAN_RT_VERSION_STATIC,
72 } asan_rt_version_t;
73
74 // FIXME: perhaps also store abi version here?
75 extern "C" {
76 SANITIZER_INTERFACE_ATTRIBUTE
77 asan_rt_version_t __asan_rt_version;
78 }
79
80 namespace __asan {
81
InitializePlatformInterceptors()82 void InitializePlatformInterceptors() {}
InitializePlatformExceptionHandlers()83 void InitializePlatformExceptionHandlers() {}
IsSystemHeapAddress(uptr addr)84 bool IsSystemHeapAddress (uptr addr) { return false; }
85
AsanDoesNotSupportStaticLinkage()86 void *AsanDoesNotSupportStaticLinkage() {
87 // This will fail to link with -static.
88 return &_DYNAMIC; // defined in link.h
89 }
90
UnmapFromTo(uptr from,uptr to)91 static void UnmapFromTo(uptr from, uptr to) {
92 CHECK(to >= from);
93 if (to == from) return;
94 uptr res = internal_munmap(reinterpret_cast<void *>(from), to - from);
95 if (UNLIKELY(internal_iserror(res))) {
96 Report(
97 "ERROR: AddresSanitizer failed to unmap 0x%zx (%zd) bytes at address "
98 "%p\n",
99 to - from, to - from, from);
100 CHECK("unable to unmap" && 0);
101 }
102 }
103
104 #if ASAN_PREMAP_SHADOW
FindPremappedShadowStart()105 uptr FindPremappedShadowStart() {
106 uptr granularity = GetMmapGranularity();
107 uptr shadow_start = reinterpret_cast<uptr>(&__asan_shadow);
108 uptr premap_shadow_size = PremapShadowSize();
109 uptr shadow_size = RoundUpTo(kHighShadowEnd, granularity);
110 // We may have mapped too much. Release extra memory.
111 UnmapFromTo(shadow_start + shadow_size, shadow_start + premap_shadow_size);
112 return shadow_start;
113 }
114 #endif
115
FindDynamicShadowStart()116 uptr FindDynamicShadowStart() {
117 #if ASAN_PREMAP_SHADOW
118 if (!PremapShadowFailed())
119 return FindPremappedShadowStart();
120 #endif
121
122 uptr granularity = GetMmapGranularity();
123 uptr alignment = granularity * 8;
124 uptr left_padding = granularity;
125 uptr shadow_size = RoundUpTo(kHighShadowEnd, granularity);
126 uptr map_size = shadow_size + left_padding + alignment;
127
128 uptr map_start = (uptr)MmapNoAccess(map_size);
129 CHECK_NE(map_start, ~(uptr)0);
130
131 uptr shadow_start = RoundUpTo(map_start + left_padding, alignment);
132 UnmapFromTo(map_start, shadow_start - left_padding);
133 UnmapFromTo(shadow_start + shadow_size, map_start + map_size);
134
135 return shadow_start;
136 }
137
AsanApplyToGlobals(globals_op_fptr op,const void * needle)138 void AsanApplyToGlobals(globals_op_fptr op, const void *needle) {
139 UNIMPLEMENTED();
140 }
141
142 #if SANITIZER_ANDROID
143 // FIXME: should we do anything for Android?
AsanCheckDynamicRTPrereqs()144 void AsanCheckDynamicRTPrereqs() {}
AsanCheckIncompatibleRT()145 void AsanCheckIncompatibleRT() {}
146 #else
FindFirstDSOCallback(struct dl_phdr_info * info,size_t size,void * data)147 static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size,
148 void *data) {
149 VReport(2, "info->dlpi_name = %s\tinfo->dlpi_addr = %p\n",
150 info->dlpi_name, info->dlpi_addr);
151
152 // Continue until the first dynamic library is found
153 if (!info->dlpi_name || info->dlpi_name[0] == 0)
154 return 0;
155
156 // Ignore vDSO
157 if (internal_strncmp(info->dlpi_name, "linux-", sizeof("linux-") - 1) == 0)
158 return 0;
159
160 #if SANITIZER_FREEBSD || SANITIZER_NETBSD
161 // Ignore first entry (the main program)
162 char **p = (char **)data;
163 if (!(*p)) {
164 *p = (char *)-1;
165 return 0;
166 }
167 #endif
168
169 #if SANITIZER_SOLARIS
170 // Ignore executable on Solaris
171 if (info->dlpi_addr == 0)
172 return 0;
173 #endif
174
175 *(const char **)data = info->dlpi_name;
176 return 1;
177 }
178
IsDynamicRTName(const char * libname)179 static bool IsDynamicRTName(const char *libname) {
180 return internal_strstr(libname, "libclang_rt.asan") ||
181 internal_strstr(libname, "libasan.so");
182 }
183
ReportIncompatibleRT()184 static void ReportIncompatibleRT() {
185 Report("Your application is linked against incompatible ASan runtimes.\n");
186 Die();
187 }
188
AsanCheckDynamicRTPrereqs()189 void AsanCheckDynamicRTPrereqs() {
190 if (!ASAN_DYNAMIC || !flags()->verify_asan_link_order)
191 return;
192
193 // Ensure that dynamic RT is the first DSO in the list
194 const char *first_dso_name = nullptr;
195 dl_iterate_phdr(FindFirstDSOCallback, &first_dso_name);
196 if (first_dso_name && !IsDynamicRTName(first_dso_name)) {
197 Report("ASan runtime does not come first in initial library list; "
198 "you should either link runtime to your application or "
199 "manually preload it with LD_PRELOAD.\n");
200 Die();
201 }
202 }
203
AsanCheckIncompatibleRT()204 void AsanCheckIncompatibleRT() {
205 if (ASAN_DYNAMIC) {
206 if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) {
207 __asan_rt_version = ASAN_RT_VERSION_DYNAMIC;
208 } else if (__asan_rt_version != ASAN_RT_VERSION_DYNAMIC) {
209 ReportIncompatibleRT();
210 }
211 } else {
212 if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) {
213 // Ensure that dynamic runtime is not present. We should detect it
214 // as early as possible, otherwise ASan interceptors could bind to
215 // the functions in dynamic ASan runtime instead of the functions in
216 // system libraries, causing crashes later in ASan initialization.
217 MemoryMappingLayout proc_maps(/*cache_enabled*/true);
218 char filename[PATH_MAX];
219 MemoryMappedSegment segment(filename, sizeof(filename));
220 while (proc_maps.Next(&segment)) {
221 if (IsDynamicRTName(segment.filename)) {
222 Report("Your application is linked against "
223 "incompatible ASan runtimes.\n");
224 Die();
225 }
226 }
227 __asan_rt_version = ASAN_RT_VERSION_STATIC;
228 } else if (__asan_rt_version != ASAN_RT_VERSION_STATIC) {
229 ReportIncompatibleRT();
230 }
231 }
232 }
233 #endif // SANITIZER_ANDROID
234
235 #if !SANITIZER_ANDROID
ReadContextStack(void * context,uptr * stack,uptr * ssize)236 void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
237 ucontext_t *ucp = (ucontext_t*)context;
238 *stack = (uptr)ucp->uc_stack.ss_sp;
239 *ssize = ucp->uc_stack.ss_size;
240 }
241 #else
ReadContextStack(void * context,uptr * stack,uptr * ssize)242 void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
243 UNIMPLEMENTED();
244 }
245 #endif
246
AsanDlSymNext(const char * sym)247 void *AsanDlSymNext(const char *sym) {
248 return dlsym(RTLD_NEXT, sym);
249 }
250
HandleDlopenInit()251 bool HandleDlopenInit() {
252 // Not supported on this platform.
253 static_assert(!SANITIZER_SUPPORTS_INIT_FOR_DLOPEN,
254 "Expected SANITIZER_SUPPORTS_INIT_FOR_DLOPEN to be false");
255 return false;
256 }
257
258 } // namespace __asan
259
260 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD ||
261 // SANITIZER_SOLARIS
262