1 //===-- asan_interceptors.cpp ---------------------------------------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file is a part of AddressSanitizer, an address sanity checker.
11 // Intercept various libc functions.
12 //===----------------------------------------------------------------------===//
14 #include "asan_interceptors.h"
15 #include "asan_allocator.h"
16 #include "asan_internal.h"
17 #include "asan_mapping.h"
18 #include "asan_poisoning.h"
19 #include "asan_report.h"
20 #include "asan_stack.h"
21 #include "asan_stats.h"
22 #include "asan_suppressions.h"
23 #include "lsan/lsan_common.h"
24 #include "sanitizer_common/sanitizer_libc.h"
26 // There is no general interception at all on Fuchsia.
27 // Only the functions in asan_interceptors_memintrinsics.cpp are
28 // really defined to replace libc functions.
29 #if !SANITIZER_FUCHSIA
32 # include "sanitizer_common/sanitizer_posix.h"
35 # if ASAN_INTERCEPT__UNWIND_RAISEEXCEPTION || \
36 ASAN_INTERCEPT__SJLJ_UNWIND_RAISEEXCEPTION
40 # if defined(__i386) && SANITIZER_LINUX
41 # define ASAN_PTHREAD_CREATE_VERSION "GLIBC_2.1"
42 # elif defined(__mips__) && SANITIZER_LINUX
43 # define ASAN_PTHREAD_CREATE_VERSION "GLIBC_2.2"
48 #define ASAN_READ_STRING_OF_LEN(ctx, s, len, n) \
49 ASAN_READ_RANGE((ctx), (s), \
50 common_flags()->strict_string_checks ? (len) + 1 : (n))
52 # define ASAN_READ_STRING(ctx, s, n) \
53 ASAN_READ_STRING_OF_LEN((ctx), (s), internal_strlen(s), (n))
55 static inline uptr
MaybeRealStrnlen(const char *s
, uptr maxlen
) {
56 #if SANITIZER_INTERCEPT_STRNLEN
58 return REAL(strnlen
)(s
, maxlen
);
61 return internal_strnlen(s
, maxlen
);
64 void SetThreadName(const char *name
) {
65 AsanThread
*t
= GetCurrentThread();
67 asanThreadRegistry().SetThreadName(t
->tid(), name
);
71 if (CAN_SANITIZE_LEAKS
&& common_flags()->detect_leaks
&&
72 __lsan::HasReportedLeaks()) {
73 return common_flags()->exitcode
;
75 // FIXME: ask frontend whether we need to return failure.
81 // ---------------------- Wrappers ---------------- {{{1
82 using namespace __asan
;
84 DECLARE_REAL_AND_INTERCEPTOR(void *, malloc
, uptr
)
85 DECLARE_REAL_AND_INTERCEPTOR(void, free
, void *)
87 #define ASAN_INTERCEPTOR_ENTER(ctx, func) \
88 AsanInterceptorContext _ctx = {#func}; \
89 ctx = (void *)&_ctx; \
92 #define COMMON_INTERCEPT_FUNCTION(name) ASAN_INTERCEPT_FUNC(name)
93 #define COMMON_INTERCEPT_FUNCTION_VER(name, ver) \
94 ASAN_INTERCEPT_FUNC_VER(name, ver)
95 #define COMMON_INTERCEPT_FUNCTION_VER_UNVERSIONED_FALLBACK(name, ver) \
96 ASAN_INTERCEPT_FUNC_VER_UNVERSIONED_FALLBACK(name, ver)
97 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
98 ASAN_WRITE_RANGE(ctx, ptr, size)
99 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
100 ASAN_READ_RANGE(ctx, ptr, size)
101 #define COMMON_INTERCEPTOR_ENTER(ctx, func, ...) \
102 ASAN_INTERCEPTOR_ENTER(ctx, func); \
104 if (asan_init_is_running) \
105 return REAL(func)(__VA_ARGS__); \
106 if (SANITIZER_MAC && UNLIKELY(!asan_inited)) \
107 return REAL(func)(__VA_ARGS__); \
108 ENSURE_ASAN_INITED(); \
110 #define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
113 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
116 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
119 #define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
122 #define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) SetThreadName(name)
123 // Should be asanThreadRegistry().SetThreadNameByUserId(thread, name)
124 // But asan does not remember UserId's for threads (pthread_t);
125 // and remembers all ever existed threads, so the linear search by UserId
127 #define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
130 #define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
131 // Strict init-order checking is dlopen-hostile:
132 // https://github.com/google/sanitizers/issues/178
133 #define COMMON_INTERCEPTOR_ON_DLOPEN(filename, flag) \
135 if (flags()->strict_init_order) \
136 StopInitOrderChecking(); \
137 CheckNoDeepBind(filename, flag); \
139 #define COMMON_INTERCEPTOR_ON_EXIT(ctx) OnExit()
140 #define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle)
141 #define COMMON_INTERCEPTOR_LIBRARY_UNLOADED()
142 #define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (!asan_inited)
143 #define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end) \
144 if (AsanThread *t = GetCurrentThread()) { \
145 *begin = t->tls_begin(); \
146 *end = t->tls_end(); \
151 #define COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, to, from, size) \
153 ASAN_INTERCEPTOR_ENTER(ctx, memmove); \
154 ASAN_MEMMOVE_IMPL(ctx, to, from, size); \
157 #define COMMON_INTERCEPTOR_MEMCPY_IMPL(ctx, to, from, size) \
159 ASAN_INTERCEPTOR_ENTER(ctx, memcpy); \
160 ASAN_MEMCPY_IMPL(ctx, to, from, size); \
163 #define COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, block, c, size) \
165 ASAN_INTERCEPTOR_ENTER(ctx, memset); \
166 ASAN_MEMSET_IMPL(ctx, block, c, size); \
169 #if CAN_SANITIZE_LEAKS
170 #define COMMON_INTERCEPTOR_STRERROR() \
171 __lsan::ScopedInterceptorDisabler disabler
174 #include "sanitizer_common/sanitizer_common_interceptors.inc"
175 #include "sanitizer_common/sanitizer_signal_interceptors.inc"
177 // Syscall interceptors don't have contexts, we don't support suppressions
179 #define COMMON_SYSCALL_PRE_READ_RANGE(p, s) ASAN_READ_RANGE(nullptr, p, s)
180 #define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) ASAN_WRITE_RANGE(nullptr, p, s)
181 #define COMMON_SYSCALL_POST_READ_RANGE(p, s) \
186 #define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) \
191 #include "sanitizer_common/sanitizer_common_syscalls.inc"
192 #include "sanitizer_common/sanitizer_syscalls_netbsd.inc"
194 #if ASAN_INTERCEPT_PTHREAD_CREATE
195 static thread_return_t THREAD_CALLING_CONV
asan_thread_start(void *arg
) {
196 AsanThread
*t
= (AsanThread
*)arg
;
198 return t
->ThreadStart(GetTid());
201 INTERCEPTOR(int, pthread_create
, void *thread
,
202 void *attr
, void *(*start_routine
)(void*), void *arg
) {
203 EnsureMainThreadIDIsCorrect();
204 // Strict init-order checking is thread-hostile.
205 if (flags()->strict_init_order
)
206 StopInitOrderChecking();
207 GET_STACK_TRACE_THREAD
;
210 REAL(pthread_attr_getdetachstate
)(attr
, &detached
);
212 u32 current_tid
= GetCurrentTidOrInvalid();
214 AsanThread::Create(start_routine
, arg
, current_tid
, &stack
, detached
);
218 // Ignore all allocations made by pthread_create: thread stack/TLS may be
219 // stored by pthread for future reuse even after thread destruction, and
220 // the linked list it's stored in doesn't even hold valid pointers to the
221 // objects, the latter are calculated by obscure pointer arithmetic.
222 #if CAN_SANITIZE_LEAKS
223 __lsan::ScopedInterceptorDisabler disabler
;
225 result
= REAL(pthread_create
)(thread
, attr
, asan_thread_start
, t
);
228 // If the thread didn't start delete the AsanThread to avoid leaking it.
229 // Note AsanThreadContexts never get destroyed so the AsanThreadContext
230 // that was just created for the AsanThread is wasted.
236 INTERCEPTOR(int, pthread_join
, void *t
, void **arg
) {
237 return real_pthread_join(t
, arg
);
240 DEFINE_REAL_PTHREAD_FUNCTIONS
241 #endif // ASAN_INTERCEPT_PTHREAD_CREATE
243 #if ASAN_INTERCEPT_SWAPCONTEXT
244 static void ClearShadowMemoryForContextStack(uptr stack
, uptr ssize
) {
245 // Align to page size.
246 uptr PageSize
= GetPageSizeCached();
247 uptr bottom
= stack
& ~(PageSize
- 1);
248 ssize
+= stack
- bottom
;
249 ssize
= RoundUpTo(ssize
, PageSize
);
250 static const uptr kMaxSaneContextStackSize
= 1 << 22; // 4 Mb
251 if (AddrIsInMem(bottom
) && ssize
&& ssize
<= kMaxSaneContextStackSize
) {
252 PoisonShadow(bottom
, ssize
, 0);
256 INTERCEPTOR(int, swapcontext
, struct ucontext_t
*oucp
,
257 struct ucontext_t
*ucp
) {
258 static bool reported_warning
= false;
259 if (!reported_warning
) {
260 Report("WARNING: ASan doesn't fully support makecontext/swapcontext "
261 "functions and may produce false positives in some cases!\n");
262 reported_warning
= true;
264 // Clear shadow memory for new context (it may share stack
265 // with current context).
267 ReadContextStack(ucp
, &stack
, &ssize
);
268 ClearShadowMemoryForContextStack(stack
, ssize
);
269 #if __has_attribute(__indirect_return__) && \
270 (defined(__x86_64__) || defined(__i386__))
271 int (*real_swapcontext
)(struct ucontext_t
*, struct ucontext_t
*)
272 __attribute__((__indirect_return__
))
274 int res
= real_swapcontext(oucp
, ucp
);
276 int res
= REAL(swapcontext
)(oucp
, ucp
);
278 // swapcontext technically does not return, but program may swap context to
279 // "oucp" later, that would look as if swapcontext() returned 0.
280 // We need to clear shadow for ucp once again, as it may be in arbitrary
282 ClearShadowMemoryForContextStack(stack
, ssize
);
285 #endif // ASAN_INTERCEPT_SWAPCONTEXT
288 #define longjmp __longjmp14
289 #define siglongjmp __siglongjmp14
292 INTERCEPTOR(void, longjmp
, void *env
, int val
) {
293 __asan_handle_no_return();
294 REAL(longjmp
)(env
, val
);
297 #if ASAN_INTERCEPT__LONGJMP
298 INTERCEPTOR(void, _longjmp
, void *env
, int val
) {
299 __asan_handle_no_return();
300 REAL(_longjmp
)(env
, val
);
304 #if ASAN_INTERCEPT___LONGJMP_CHK
305 INTERCEPTOR(void, __longjmp_chk
, void *env
, int val
) {
306 __asan_handle_no_return();
307 REAL(__longjmp_chk
)(env
, val
);
311 #if ASAN_INTERCEPT_SIGLONGJMP
312 INTERCEPTOR(void, siglongjmp
, void *env
, int val
) {
313 __asan_handle_no_return();
314 REAL(siglongjmp
)(env
, val
);
318 #if ASAN_INTERCEPT___CXA_THROW
319 INTERCEPTOR(void, __cxa_throw
, void *a
, void *b
, void *c
) {
320 CHECK(REAL(__cxa_throw
));
321 __asan_handle_no_return();
322 REAL(__cxa_throw
)(a
, b
, c
);
326 #if ASAN_INTERCEPT___CXA_RETHROW_PRIMARY_EXCEPTION
327 INTERCEPTOR(void, __cxa_rethrow_primary_exception
, void *a
) {
328 CHECK(REAL(__cxa_rethrow_primary_exception
));
329 __asan_handle_no_return();
330 REAL(__cxa_rethrow_primary_exception
)(a
);
334 #if ASAN_INTERCEPT__UNWIND_RAISEEXCEPTION
335 INTERCEPTOR(_Unwind_Reason_Code
, _Unwind_RaiseException
,
336 _Unwind_Exception
*object
) {
337 CHECK(REAL(_Unwind_RaiseException
));
338 __asan_handle_no_return();
339 return REAL(_Unwind_RaiseException
)(object
);
343 #if ASAN_INTERCEPT__SJLJ_UNWIND_RAISEEXCEPTION
344 INTERCEPTOR(_Unwind_Reason_Code
, _Unwind_SjLj_RaiseException
,
345 _Unwind_Exception
*object
) {
346 CHECK(REAL(_Unwind_SjLj_RaiseException
));
347 __asan_handle_no_return();
348 return REAL(_Unwind_SjLj_RaiseException
)(object
);
352 #if ASAN_INTERCEPT_INDEX
353 # if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
354 INTERCEPTOR(char*, index
, const char *string
, int c
)
355 ALIAS(WRAPPER_NAME(strchr
));
358 DECLARE_REAL(char*, index
, const char *string
, int c
)
359 OVERRIDE_FUNCTION(index
, strchr
);
361 DEFINE_REAL(char*, index
, const char *string
, int c
)
364 #endif // ASAN_INTERCEPT_INDEX
366 // For both strcat() and strncat() we need to check the validity of |to|
367 // argument irrespective of the |from| length.
368 INTERCEPTOR(char *, strcat
, char *to
, const char *from
) {
370 ASAN_INTERCEPTOR_ENTER(ctx
, strcat
);
371 ENSURE_ASAN_INITED();
372 if (flags()->replace_str
) {
373 uptr from_length
= internal_strlen(from
);
374 ASAN_READ_RANGE(ctx
, from
, from_length
+ 1);
375 uptr to_length
= internal_strlen(to
);
376 ASAN_READ_STRING_OF_LEN(ctx
, to
, to_length
, to_length
);
377 ASAN_WRITE_RANGE(ctx
, to
+ to_length
, from_length
+ 1);
378 // If the copying actually happens, the |from| string should not overlap
379 // with the resulting string starting at |to|, which has a length of
380 // to_length + from_length + 1.
381 if (from_length
> 0) {
382 CHECK_RANGES_OVERLAP("strcat", to
, from_length
+ to_length
+ 1, from
,
386 return REAL(strcat
)(to
, from
);
389 INTERCEPTOR(char*, strncat
, char *to
, const char *from
, uptr size
) {
391 ASAN_INTERCEPTOR_ENTER(ctx
, strncat
);
392 ENSURE_ASAN_INITED();
393 if (flags()->replace_str
) {
394 uptr from_length
= MaybeRealStrnlen(from
, size
);
395 uptr copy_length
= Min(size
, from_length
+ 1);
396 ASAN_READ_RANGE(ctx
, from
, copy_length
);
397 uptr to_length
= internal_strlen(to
);
398 ASAN_READ_STRING_OF_LEN(ctx
, to
, to_length
, to_length
);
399 ASAN_WRITE_RANGE(ctx
, to
+ to_length
, from_length
+ 1);
400 if (from_length
> 0) {
401 CHECK_RANGES_OVERLAP("strncat", to
, to_length
+ copy_length
+ 1,
405 return REAL(strncat
)(to
, from
, size
);
408 INTERCEPTOR(char *, strcpy
, char *to
, const char *from
) {
410 ASAN_INTERCEPTOR_ENTER(ctx
, strcpy
);
412 if (UNLIKELY(!asan_inited
))
413 return REAL(strcpy
)(to
, from
);
415 // strcpy is called from malloc_default_purgeable_zone()
416 // in __asan::ReplaceSystemAlloc() on Mac.
417 if (asan_init_is_running
) {
418 return REAL(strcpy
)(to
, from
);
420 ENSURE_ASAN_INITED();
421 if (flags()->replace_str
) {
422 uptr from_size
= internal_strlen(from
) + 1;
423 CHECK_RANGES_OVERLAP("strcpy", to
, from_size
, from
, from_size
);
424 ASAN_READ_RANGE(ctx
, from
, from_size
);
425 ASAN_WRITE_RANGE(ctx
, to
, from_size
);
427 return REAL(strcpy
)(to
, from
);
430 INTERCEPTOR(char*, strdup
, const char *s
) {
432 ASAN_INTERCEPTOR_ENTER(ctx
, strdup
);
433 if (UNLIKELY(!asan_inited
)) return internal_strdup(s
);
434 ENSURE_ASAN_INITED();
435 uptr length
= internal_strlen(s
);
436 if (flags()->replace_str
) {
437 ASAN_READ_RANGE(ctx
, s
, length
+ 1);
439 GET_STACK_TRACE_MALLOC
;
440 void *new_mem
= asan_malloc(length
+ 1, &stack
);
441 REAL(memcpy
)(new_mem
, s
, length
+ 1);
442 return reinterpret_cast<char*>(new_mem
);
445 #if ASAN_INTERCEPT___STRDUP
446 INTERCEPTOR(char*, __strdup
, const char *s
) {
448 ASAN_INTERCEPTOR_ENTER(ctx
, strdup
);
449 if (UNLIKELY(!asan_inited
)) return internal_strdup(s
);
450 ENSURE_ASAN_INITED();
451 uptr length
= internal_strlen(s
);
452 if (flags()->replace_str
) {
453 ASAN_READ_RANGE(ctx
, s
, length
+ 1);
455 GET_STACK_TRACE_MALLOC
;
456 void *new_mem
= asan_malloc(length
+ 1, &stack
);
457 REAL(memcpy
)(new_mem
, s
, length
+ 1);
458 return reinterpret_cast<char*>(new_mem
);
460 #endif // ASAN_INTERCEPT___STRDUP
462 INTERCEPTOR(char*, strncpy
, char *to
, const char *from
, uptr size
) {
464 ASAN_INTERCEPTOR_ENTER(ctx
, strncpy
);
465 ENSURE_ASAN_INITED();
466 if (flags()->replace_str
) {
467 uptr from_size
= Min(size
, MaybeRealStrnlen(from
, size
) + 1);
468 CHECK_RANGES_OVERLAP("strncpy", to
, from_size
, from
, from_size
);
469 ASAN_READ_RANGE(ctx
, from
, from_size
);
470 ASAN_WRITE_RANGE(ctx
, to
, size
);
472 return REAL(strncpy
)(to
, from
, size
);
475 INTERCEPTOR(long, strtol
, const char *nptr
, char **endptr
, int base
) {
477 ASAN_INTERCEPTOR_ENTER(ctx
, strtol
);
478 ENSURE_ASAN_INITED();
479 if (!flags()->replace_str
) {
480 return REAL(strtol
)(nptr
, endptr
, base
);
483 long result
= REAL(strtol
)(nptr
, &real_endptr
, base
);
484 StrtolFixAndCheck(ctx
, nptr
, endptr
, real_endptr
, base
);
488 INTERCEPTOR(int, atoi
, const char *nptr
) {
490 ASAN_INTERCEPTOR_ENTER(ctx
, atoi
);
492 if (UNLIKELY(!asan_inited
)) return REAL(atoi
)(nptr
);
494 ENSURE_ASAN_INITED();
495 if (!flags()->replace_str
) {
496 return REAL(atoi
)(nptr
);
499 // "man atoi" tells that behavior of atoi(nptr) is the same as
500 // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the
501 // parsed integer can't be stored in *long* type (even if it's
502 // different from int). So, we just imitate this behavior.
503 int result
= REAL(strtol
)(nptr
, &real_endptr
, 10);
504 FixRealStrtolEndptr(nptr
, &real_endptr
);
505 ASAN_READ_STRING(ctx
, nptr
, (real_endptr
- nptr
) + 1);
509 INTERCEPTOR(long, atol
, const char *nptr
) {
511 ASAN_INTERCEPTOR_ENTER(ctx
, atol
);
513 if (UNLIKELY(!asan_inited
)) return REAL(atol
)(nptr
);
515 ENSURE_ASAN_INITED();
516 if (!flags()->replace_str
) {
517 return REAL(atol
)(nptr
);
520 long result
= REAL(strtol
)(nptr
, &real_endptr
, 10);
521 FixRealStrtolEndptr(nptr
, &real_endptr
);
522 ASAN_READ_STRING(ctx
, nptr
, (real_endptr
- nptr
) + 1);
526 #if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
527 INTERCEPTOR(long long, strtoll
, const char *nptr
, char **endptr
, int base
) {
529 ASAN_INTERCEPTOR_ENTER(ctx
, strtoll
);
530 ENSURE_ASAN_INITED();
531 if (!flags()->replace_str
) {
532 return REAL(strtoll
)(nptr
, endptr
, base
);
535 long long result
= REAL(strtoll
)(nptr
, &real_endptr
, base
);
536 StrtolFixAndCheck(ctx
, nptr
, endptr
, real_endptr
, base
);
540 INTERCEPTOR(long long, atoll
, const char *nptr
) {
542 ASAN_INTERCEPTOR_ENTER(ctx
, atoll
);
543 ENSURE_ASAN_INITED();
544 if (!flags()->replace_str
) {
545 return REAL(atoll
)(nptr
);
548 long long result
= REAL(strtoll
)(nptr
, &real_endptr
, 10);
549 FixRealStrtolEndptr(nptr
, &real_endptr
);
550 ASAN_READ_STRING(ctx
, nptr
, (real_endptr
- nptr
) + 1);
553 #endif // ASAN_INTERCEPT_ATOLL_AND_STRTOLL
555 #if ASAN_INTERCEPT___CXA_ATEXIT || ASAN_INTERCEPT_ATEXIT
556 static void AtCxaAtexit(void *unused
) {
558 StopInitOrderChecking();
562 #if ASAN_INTERCEPT___CXA_ATEXIT
563 INTERCEPTOR(int, __cxa_atexit
, void (*func
)(void *), void *arg
,
566 if (UNLIKELY(!asan_inited
)) return REAL(__cxa_atexit
)(func
, arg
, dso_handle
);
568 ENSURE_ASAN_INITED();
569 #if CAN_SANITIZE_LEAKS
570 __lsan::ScopedInterceptorDisabler disabler
;
572 int res
= REAL(__cxa_atexit
)(func
, arg
, dso_handle
);
573 REAL(__cxa_atexit
)(AtCxaAtexit
, nullptr, nullptr);
576 #endif // ASAN_INTERCEPT___CXA_ATEXIT
578 #if ASAN_INTERCEPT_ATEXIT
579 INTERCEPTOR(int, atexit
, void (*func
)()) {
580 ENSURE_ASAN_INITED();
581 #if CAN_SANITIZE_LEAKS
582 __lsan::ScopedInterceptorDisabler disabler
;
584 // Avoid calling real atexit as it is unreachable on at least on Linux.
585 int res
= REAL(__cxa_atexit
)((void (*)(void *a
))func
, nullptr, nullptr);
586 REAL(__cxa_atexit
)(AtCxaAtexit
, nullptr, nullptr);
591 #if ASAN_INTERCEPT_PTHREAD_ATFORK
593 extern int _pthread_atfork(void (*prepare
)(), void (*parent
)(),
597 INTERCEPTOR(int, pthread_atfork
, void (*prepare
)(), void (*parent
)(),
599 #if CAN_SANITIZE_LEAKS
600 __lsan::ScopedInterceptorDisabler disabler
;
602 // REAL(pthread_atfork) cannot be called due to symbol indirections at least
604 return _pthread_atfork(prepare
, parent
, child
);
608 #if ASAN_INTERCEPT_VFORK
609 DEFINE_REAL(int, vfork
)
610 DECLARE_EXTERN_INTERCEPTOR_AND_WRAPPER(int, vfork
)
613 // ---------------------- InitializeAsanInterceptors ---------------- {{{1
615 void InitializeAsanInterceptors() {
616 static bool was_called_once
;
617 CHECK(!was_called_once
);
618 was_called_once
= true;
619 InitializeCommonInterceptors();
620 InitializeSignalInterceptors();
622 // Intercept str* functions.
623 ASAN_INTERCEPT_FUNC(strcat
);
624 ASAN_INTERCEPT_FUNC(strcpy
);
625 ASAN_INTERCEPT_FUNC(strncat
);
626 ASAN_INTERCEPT_FUNC(strncpy
);
627 ASAN_INTERCEPT_FUNC(strdup
);
628 #if ASAN_INTERCEPT___STRDUP
629 ASAN_INTERCEPT_FUNC(__strdup
);
631 #if ASAN_INTERCEPT_INDEX && ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
632 ASAN_INTERCEPT_FUNC(index
);
635 ASAN_INTERCEPT_FUNC(atoi
);
636 ASAN_INTERCEPT_FUNC(atol
);
637 ASAN_INTERCEPT_FUNC(strtol
);
638 #if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
639 ASAN_INTERCEPT_FUNC(atoll
);
640 ASAN_INTERCEPT_FUNC(strtoll
);
643 // Intecept jump-related functions.
644 ASAN_INTERCEPT_FUNC(longjmp
);
646 #if ASAN_INTERCEPT_SWAPCONTEXT
647 ASAN_INTERCEPT_FUNC(swapcontext
);
649 #if ASAN_INTERCEPT__LONGJMP
650 ASAN_INTERCEPT_FUNC(_longjmp
);
652 #if ASAN_INTERCEPT___LONGJMP_CHK
653 ASAN_INTERCEPT_FUNC(__longjmp_chk
);
655 #if ASAN_INTERCEPT_SIGLONGJMP
656 ASAN_INTERCEPT_FUNC(siglongjmp
);
659 // Intercept exception handling functions.
660 #if ASAN_INTERCEPT___CXA_THROW
661 ASAN_INTERCEPT_FUNC(__cxa_throw
);
663 #if ASAN_INTERCEPT___CXA_RETHROW_PRIMARY_EXCEPTION
664 ASAN_INTERCEPT_FUNC(__cxa_rethrow_primary_exception
);
666 // Indirectly intercept std::rethrow_exception.
667 #if ASAN_INTERCEPT__UNWIND_RAISEEXCEPTION
668 INTERCEPT_FUNCTION(_Unwind_RaiseException
);
670 // Indirectly intercept std::rethrow_exception.
671 #if ASAN_INTERCEPT__UNWIND_SJLJ_RAISEEXCEPTION
672 INTERCEPT_FUNCTION(_Unwind_SjLj_RaiseException
);
675 // Intercept threading-related functions
676 #if ASAN_INTERCEPT_PTHREAD_CREATE
677 // TODO: this should probably have an unversioned fallback for newer arches?
678 #if defined(ASAN_PTHREAD_CREATE_VERSION)
679 ASAN_INTERCEPT_FUNC_VER(pthread_create
, ASAN_PTHREAD_CREATE_VERSION
);
681 ASAN_INTERCEPT_FUNC(pthread_create
);
683 ASAN_INTERCEPT_FUNC(pthread_join
);
686 // Intercept atexit function.
687 #if ASAN_INTERCEPT___CXA_ATEXIT
688 ASAN_INTERCEPT_FUNC(__cxa_atexit
);
691 #if ASAN_INTERCEPT_ATEXIT
692 ASAN_INTERCEPT_FUNC(atexit
);
695 #if ASAN_INTERCEPT_PTHREAD_ATFORK
696 ASAN_INTERCEPT_FUNC(pthread_atfork
);
699 #if ASAN_INTERCEPT_VFORK
700 ASAN_INTERCEPT_FUNC(vfork
);
703 InitializePlatformInterceptors();
705 VReport(1, "AddressSanitizer: libc interceptors initialized\n");
708 } // namespace __asan
710 #endif // !SANITIZER_FUCHSIA