1 //===-- sanitizer_mac.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 shared between various sanitizers' runtime libraries and
10 // implements OSX-specific functions.
11 //===----------------------------------------------------------------------===//
13 #include "sanitizer_platform.h"
15 # include "interception/interception.h"
16 # include "sanitizer_mac.h"
18 // Use 64-bit inodes in file operations. ASan does not support OS X 10.5, so
19 // the clients will most certainly use 64-bit ones as well.
20 # ifndef _DARWIN_USE_64_BIT_INODE
21 # define _DARWIN_USE_64_BIT_INODE 1
25 # include "sanitizer_common.h"
26 # include "sanitizer_file.h"
27 # include "sanitizer_flags.h"
28 # include "sanitizer_interface_internal.h"
29 # include "sanitizer_internal_defs.h"
30 # include "sanitizer_libc.h"
31 # include "sanitizer_platform_limits_posix.h"
32 # include "sanitizer_procmaps.h"
33 # include "sanitizer_ptrauth.h"
36 # include <crt_externs.h> // for _NSGetEnviron
38 extern char **environ
;
41 # if defined(__has_include) && __has_include(<os/trace.h>) && defined(__BLOCKS__)
42 # define SANITIZER_OS_TRACE 1
43 # include <os/trace.h>
45 # define SANITIZER_OS_TRACE 0
48 // import new crash reporting api
49 # if defined(__has_include) && __has_include(<CrashReporterClient.h>)
50 # define HAVE_CRASHREPORTERCLIENT_H 1
51 # include <CrashReporterClient.h>
53 # define HAVE_CRASHREPORTERCLIENT_H 0
57 # include <crt_externs.h> // for _NSGetArgv and _NSGetEnviron
60 extern char ***_NSGetArgv(void);
65 # include <dlfcn.h> // for dladdr()
68 # include <libkern/OSAtomic.h>
69 # include <mach-o/dyld.h>
70 # include <mach/mach.h>
71 # include <mach/mach_time.h>
72 # include <mach/vm_statistics.h>
73 # include <malloc/malloc.h>
74 # if defined(__has_builtin) && __has_builtin(__builtin_os_log_format)
77 /* Without support for __builtin_os_log_format, fall back to the older
79 # define OS_LOG_DEFAULT 0
80 # define os_log_error(A,B,C) \
81 asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", (C));
84 # include <pthread/introspection.h>
89 # include <sys/ioctl.h>
90 # include <sys/mman.h>
91 # include <sys/resource.h>
92 # include <sys/stat.h>
93 # include <sys/sysctl.h>
94 # include <sys/types.h>
95 # include <sys/wait.h>
99 // From <crt_externs.h>, but we don't have that file on iOS.
101 extern char ***_NSGetArgv(void);
102 extern char ***_NSGetEnviron(void);
105 // From <mach/mach_vm.h>, but we don't have that file on iOS.
107 extern kern_return_t
mach_vm_region_recurse(
108 vm_map_t target_task
,
109 mach_vm_address_t
*address
,
110 mach_vm_size_t
*size
,
111 natural_t
*nesting_depth
,
112 vm_region_recurse_info_t info
,
113 mach_msg_type_number_t
*infoCnt
);
116 namespace __sanitizer
{
118 #include "sanitizer_syscall_generic.inc"
120 // Direct syscalls, don't call libmalloc hooks (but not available on 10.6).
121 extern "C" void *__mmap(void *addr
, size_t len
, int prot
, int flags
, int fildes
,
122 off_t off
) SANITIZER_WEAK_ATTRIBUTE
;
123 extern "C" int __munmap(void *, size_t) SANITIZER_WEAK_ATTRIBUTE
;
125 // ---------------------- sanitizer_libc.h
127 // From <mach/vm_statistics.h>, but not on older OSs.
128 #ifndef VM_MEMORY_SANITIZER
129 #define VM_MEMORY_SANITIZER 99
132 // XNU on Darwin provides a mmap flag that optimizes allocation/deallocation of
133 // giant memory regions (i.e. shadow memory regions).
134 #define kXnuFastMmapFd 0x4
135 static size_t kXnuFastMmapThreshold
= 2 << 30; // 2 GB
136 static bool use_xnu_fast_mmap
= false;
138 uptr
internal_mmap(void *addr
, size_t length
, int prot
, int flags
,
139 int fd
, u64 offset
) {
141 fd
= VM_MAKE_TAG(VM_MEMORY_SANITIZER
);
142 if (length
>= kXnuFastMmapThreshold
) {
143 if (use_xnu_fast_mmap
) fd
|= kXnuFastMmapFd
;
146 if (&__mmap
) return (uptr
)__mmap(addr
, length
, prot
, flags
, fd
, offset
);
147 return (uptr
)mmap(addr
, length
, prot
, flags
, fd
, offset
);
150 uptr
internal_munmap(void *addr
, uptr length
) {
151 if (&__munmap
) return __munmap(addr
, length
);
152 return munmap(addr
, length
);
155 uptr
internal_mremap(void *old_address
, uptr old_size
, uptr new_size
, int flags
,
157 CHECK(false && "internal_mremap is unimplemented on Mac");
161 int internal_mprotect(void *addr
, uptr length
, int prot
) {
162 return mprotect(addr
, length
, prot
);
165 int internal_madvise(uptr addr
, uptr length
, int advice
) {
166 return madvise((void *)addr
, length
, advice
);
169 uptr
internal_close(fd_t fd
) {
173 uptr
internal_open(const char *filename
, int flags
) {
174 return open(filename
, flags
);
177 uptr
internal_open(const char *filename
, int flags
, u32 mode
) {
178 return open(filename
, flags
, mode
);
181 uptr
internal_read(fd_t fd
, void *buf
, uptr count
) {
182 return read(fd
, buf
, count
);
185 uptr
internal_write(fd_t fd
, const void *buf
, uptr count
) {
186 return write(fd
, buf
, count
);
189 uptr
internal_stat(const char *path
, void *buf
) {
190 return stat(path
, (struct stat
*)buf
);
193 uptr
internal_lstat(const char *path
, void *buf
) {
194 return lstat(path
, (struct stat
*)buf
);
197 uptr
internal_fstat(fd_t fd
, void *buf
) {
198 return fstat(fd
, (struct stat
*)buf
);
201 uptr
internal_filesize(fd_t fd
) {
203 if (internal_fstat(fd
, &st
))
205 return (uptr
)st
.st_size
;
208 uptr
internal_dup(int oldfd
) {
212 uptr
internal_dup2(int oldfd
, int newfd
) {
213 return dup2(oldfd
, newfd
);
216 uptr
internal_readlink(const char *path
, char *buf
, uptr bufsize
) {
217 return readlink(path
, buf
, bufsize
);
220 uptr
internal_unlink(const char *path
) {
224 uptr
internal_sched_yield() {
225 return sched_yield();
228 void internal__exit(int exitcode
) {
232 void internal_usleep(u64 useconds
) { usleep(useconds
); }
234 uptr
internal_getpid() {
238 int internal_dlinfo(void *handle
, int request
, void *p
) {
242 int internal_sigaction(int signum
, const void *act
, void *oldact
) {
243 return sigaction(signum
,
244 (const struct sigaction
*)act
, (struct sigaction
*)oldact
);
247 void internal_sigfillset(__sanitizer_sigset_t
*set
) { sigfillset(set
); }
249 uptr
internal_sigprocmask(int how
, __sanitizer_sigset_t
*set
,
250 __sanitizer_sigset_t
*oldset
) {
251 // Don't use sigprocmask here, because it affects all threads.
252 return pthread_sigmask(how
, set
, oldset
);
255 // Doesn't call pthread_atfork() handlers (but not available on 10.6).
256 extern "C" pid_t
__fork(void) SANITIZER_WEAK_ATTRIBUTE
;
258 int internal_fork() {
264 int internal_sysctl(const int *name
, unsigned int namelen
, void *oldp
,
265 uptr
*oldlenp
, const void *newp
, uptr newlen
) {
266 return sysctl(const_cast<int *>(name
), namelen
, oldp
, (size_t *)oldlenp
,
267 const_cast<void *>(newp
), (size_t)newlen
);
270 int internal_sysctlbyname(const char *sname
, void *oldp
, uptr
*oldlenp
,
271 const void *newp
, uptr newlen
) {
272 return sysctlbyname(sname
, oldp
, (size_t *)oldlenp
, const_cast<void *>(newp
),
276 static fd_t
internal_spawn_impl(const char *argv
[], const char *envp
[],
278 fd_t primary_fd
= kInvalidFd
;
279 fd_t secondary_fd
= kInvalidFd
;
281 auto fd_closer
= at_scope_exit([&] {
282 internal_close(primary_fd
);
283 internal_close(secondary_fd
);
286 // We need a new pseudoterminal to avoid buffering problems. The 'atos' tool
287 // in particular detects when it's talking to a pipe and forgets to flush the
288 // output stream after sending a response.
289 primary_fd
= posix_openpt(O_RDWR
);
290 if (primary_fd
== kInvalidFd
)
293 int res
= grantpt(primary_fd
) || unlockpt(primary_fd
);
294 if (res
!= 0) return kInvalidFd
;
296 // Use TIOCPTYGNAME instead of ptsname() to avoid threading problems.
297 char secondary_pty_name
[128];
298 res
= ioctl(primary_fd
, TIOCPTYGNAME
, secondary_pty_name
);
299 if (res
== -1) return kInvalidFd
;
301 secondary_fd
= internal_open(secondary_pty_name
, O_RDWR
);
302 if (secondary_fd
== kInvalidFd
)
305 // File descriptor actions
306 posix_spawn_file_actions_t acts
;
307 res
= posix_spawn_file_actions_init(&acts
);
308 if (res
!= 0) return kInvalidFd
;
310 auto acts_cleanup
= at_scope_exit([&] {
311 posix_spawn_file_actions_destroy(&acts
);
314 res
= posix_spawn_file_actions_adddup2(&acts
, secondary_fd
, STDIN_FILENO
) ||
315 posix_spawn_file_actions_adddup2(&acts
, secondary_fd
, STDOUT_FILENO
) ||
316 posix_spawn_file_actions_addclose(&acts
, secondary_fd
);
317 if (res
!= 0) return kInvalidFd
;
320 posix_spawnattr_t attrs
;
321 res
= posix_spawnattr_init(&attrs
);
322 if (res
!= 0) return kInvalidFd
;
324 auto attrs_cleanup
= at_scope_exit([&] {
325 posix_spawnattr_destroy(&attrs
);
328 // In the spawned process, close all file descriptors that are not explicitly
329 // described by the file actions object. This is Darwin-specific extension.
330 res
= posix_spawnattr_setflags(&attrs
, POSIX_SPAWN_CLOEXEC_DEFAULT
);
331 if (res
!= 0) return kInvalidFd
;
334 char **argv_casted
= const_cast<char **>(argv
);
335 char **envp_casted
= const_cast<char **>(envp
);
336 res
= posix_spawn(pid
, argv
[0], &acts
, &attrs
, argv_casted
, envp_casted
);
337 if (res
!= 0) return kInvalidFd
;
339 // Disable echo in the new terminal, disable CR.
340 struct termios termflags
;
341 tcgetattr(primary_fd
, &termflags
);
342 termflags
.c_oflag
&= ~ONLCR
;
343 termflags
.c_lflag
&= ~ECHO
;
344 tcsetattr(primary_fd
, TCSANOW
, &termflags
);
346 // On success, do not close primary_fd on scope exit.
347 fd_t fd
= primary_fd
;
348 primary_fd
= kInvalidFd
;
353 fd_t
internal_spawn(const char *argv
[], const char *envp
[], pid_t
*pid
) {
354 // The client program may close its stdin and/or stdout and/or stderr thus
355 // allowing open/posix_openpt to reuse file descriptors 0, 1 or 2. In this
356 // case the communication is broken if either the parent or the child tries to
357 // close or duplicate these descriptors. We temporarily reserve these
358 // descriptors here to prevent this.
362 for (; count
< 3; count
++) {
363 low_fds
[count
] = posix_openpt(O_RDWR
);
364 if (low_fds
[count
] >= STDERR_FILENO
)
368 fd_t fd
= internal_spawn_impl(argv
, envp
, pid
);
370 for (; count
> 0; count
--) {
371 internal_close(low_fds
[count
]);
377 uptr
internal_rename(const char *oldpath
, const char *newpath
) {
378 return rename(oldpath
, newpath
);
381 uptr
internal_ftruncate(fd_t fd
, uptr size
) {
382 return ftruncate(fd
, size
);
385 uptr
internal_execve(const char *filename
, char *const argv
[],
386 char *const envp
[]) {
387 return execve(filename
, argv
, envp
);
390 uptr
internal_waitpid(int pid
, int *status
, int options
) {
391 return waitpid(pid
, status
, options
);
394 // ----------------- sanitizer_common.h
395 bool FileExists(const char *filename
) {
396 if (ShouldMockFailureToOpen(filename
))
399 if (stat(filename
, &st
))
401 // Sanity check: filename is a regular file.
402 return S_ISREG(st
.st_mode
);
405 bool DirExists(const char *path
) {
409 return S_ISDIR(st
.st_mode
);
414 pthread_threadid_np(nullptr, &tid
);
418 void GetThreadStackTopAndBottom(bool at_initialization
, uptr
*stack_top
,
419 uptr
*stack_bottom
) {
422 uptr stacksize
= pthread_get_stacksize_np(pthread_self());
423 // pthread_get_stacksize_np() returns an incorrect stack size for the main
424 // thread on Mavericks. See
425 // https://github.com/google/sanitizers/issues/261
426 if ((GetMacosAlignedVersion() >= MacosVersion(10, 9)) && at_initialization
&&
427 stacksize
== (1 << 19)) {
429 CHECK_EQ(getrlimit(RLIMIT_STACK
, &rl
), 0);
430 // Most often rl.rlim_cur will be the desired 8M.
431 if (rl
.rlim_cur
< kMaxThreadStackSize
) {
432 stacksize
= rl
.rlim_cur
;
434 stacksize
= kMaxThreadStackSize
;
437 void *stackaddr
= pthread_get_stackaddr_np(pthread_self());
438 *stack_top
= (uptr
)stackaddr
;
439 *stack_bottom
= *stack_top
- stacksize
;
442 char **GetEnviron() {
444 char ***env_ptr
= _NSGetEnviron();
446 Report("_NSGetEnviron() returned NULL. Please make sure __asan_init() is "
447 "called after libSystem_initializer().\n");
450 char **environ
= *env_ptr
;
456 const char *GetEnv(const char *name
) {
457 char **env
= GetEnviron();
458 uptr name_len
= internal_strlen(name
);
460 uptr len
= internal_strlen(*env
);
461 if (len
> name_len
) {
462 const char *p
= *env
;
463 if (!internal_memcmp(p
, name
, name_len
) &&
464 p
[name_len
] == '=') { // Match.
465 return *env
+ name_len
+ 1; // String starting after =.
473 uptr
ReadBinaryName(/*out*/char *buf
, uptr buf_len
) {
474 CHECK_LE(kMaxPathLength
, buf_len
);
476 // On OS X the executable path is saved to the stack by dyld. Reading it
477 // from there is much faster than calling dladdr, especially for large
478 // binaries with symbols.
479 InternalMmapVector
<char> exe_path(kMaxPathLength
);
480 uint32_t size
= exe_path
.size();
481 if (_NSGetExecutablePath(exe_path
.data(), &size
) == 0 &&
482 realpath(exe_path
.data(), buf
) != 0) {
483 return internal_strlen(buf
);
488 uptr
ReadLongProcessName(/*out*/char *buf
, uptr buf_len
) {
489 return ReadBinaryName(buf
, buf_len
);
500 void CheckMPROTECT() {
505 return sysconf(_SC_PAGESIZE
);
508 extern "C" unsigned malloc_num_zones
;
509 extern "C" malloc_zone_t
**malloc_zones
;
510 malloc_zone_t sanitizer_zone
;
512 // We need to make sure that sanitizer_zone is registered as malloc_zones[0]. If
513 // libmalloc tries to set up a different zone as malloc_zones[0], it will call
514 // mprotect(malloc_zones, ..., PROT_READ). This interceptor will catch that and
515 // make sure we are still the first (default) zone.
516 void MprotectMallocZones(void *addr
, int prot
) {
517 if (addr
== malloc_zones
&& prot
== PROT_READ
) {
518 if (malloc_num_zones
> 1 && malloc_zones
[0] != &sanitizer_zone
) {
519 for (unsigned i
= 1; i
< malloc_num_zones
; i
++) {
520 if (malloc_zones
[i
] == &sanitizer_zone
) {
521 // Swap malloc_zones[0] and malloc_zones[i].
522 malloc_zones
[i
] = malloc_zones
[0];
523 malloc_zones
[0] = &sanitizer_zone
;
531 void FutexWait(atomic_uint32_t
*p
, u32 cmp
) {
532 // FIXME: implement actual blocking.
536 void FutexWake(atomic_uint32_t
*p
, u32 count
) {}
540 internal_memset(&tv
, 0, sizeof(tv
));
541 gettimeofday(&tv
, 0);
542 return (u64
)tv
.tv_sec
* 1000*1000*1000 + tv
.tv_usec
* 1000;
545 // This needs to be called during initialization to avoid being racy.
546 u64
MonotonicNanoTime() {
547 static mach_timebase_info_data_t timebase_info
;
548 if (timebase_info
.denom
== 0) mach_timebase_info(&timebase_info
);
549 return (mach_absolute_time() * timebase_info
.numer
) / timebase_info
.denom
;
561 #if defined(__x86_64__)
562 asm("movq %%gs:0,%0" : "=r"(segbase
));
563 #elif defined(__i386__)
564 asm("movl %%gs:0,%0" : "=r"(segbase
));
565 #elif defined(__aarch64__)
566 asm("mrs %x0, tpidrro_el0" : "=r"(segbase
));
567 segbase
&= 0x07ul
; // clearing lower bits, cpu id stored there
572 // The size of the tls on darwin does not appear to be well documented,
573 // however the vm memory map suggests that it is 1024 uptrs in size,
574 // with a size of 0x2000 bytes on x86_64 and 0x1000 bytes on i386.
576 #if defined(__x86_64__) || defined(__i386__)
577 return 1024 * sizeof(uptr
);
583 void GetThreadStackAndTls(bool main
, uptr
*stk_addr
, uptr
*stk_size
,
584 uptr
*tls_addr
, uptr
*tls_size
) {
586 uptr stack_top
, stack_bottom
;
587 GetThreadStackTopAndBottom(main
, &stack_top
, &stack_bottom
);
588 *stk_addr
= stack_bottom
;
589 *stk_size
= stack_top
- stack_bottom
;
590 *tls_addr
= TlsBaseAddr();
591 *tls_size
= TlsSize();
600 void ListOfModules::init() {
602 MemoryMappingLayout
memory_mapping(false);
603 memory_mapping
.DumpListOfModules(&modules_
);
606 void ListOfModules::fallbackInit() { clear(); }
608 static HandleSignalMode
GetHandleSignalModeImpl(int signum
) {
611 return common_flags()->handle_abort
;
613 return common_flags()->handle_sigill
;
615 return common_flags()->handle_sigtrap
;
617 return common_flags()->handle_sigfpe
;
619 return common_flags()->handle_segv
;
621 return common_flags()->handle_sigbus
;
623 return kHandleSignalNo
;
626 HandleSignalMode
GetHandleSignalMode(int signum
) {
627 // Handling fatal signals on watchOS and tvOS devices is disallowed.
628 if ((SANITIZER_WATCHOS
|| SANITIZER_TVOS
) && !(SANITIZER_IOSSIM
))
629 return kHandleSignalNo
;
630 HandleSignalMode result
= GetHandleSignalModeImpl(signum
);
631 if (result
== kHandleSignalYes
&& !common_flags()->allow_user_segv_handler
)
632 return kHandleSignalExclusive
;
637 // XNU 17 -- macOS 10.13 -- iOS 11 -- tvOS 11 -- watchOS 4
638 constexpr u16
GetOSMajorKernelOffset() {
639 if (TARGET_OS_OSX
) return 4;
640 if (TARGET_OS_IOS
|| TARGET_OS_TV
) return 6;
641 if (TARGET_OS_WATCH
) return 13;
644 using VersStr
= char[64];
646 static uptr
ApproximateOSVersionViaKernelVersion(VersStr vers
) {
647 u16 kernel_major
= GetDarwinKernelVersion().major
;
648 u16 offset
= GetOSMajorKernelOffset();
649 CHECK_GE(kernel_major
, offset
);
650 u16 os_major
= kernel_major
- offset
;
652 const char *format
= "%d.0";
654 if (os_major
>= 16) { // macOS 11+
656 } else { // macOS 10.15 and below
660 return internal_snprintf(vers
, sizeof(VersStr
), format
, os_major
);
663 static void GetOSVersion(VersStr vers
) {
664 uptr len
= sizeof(VersStr
);
665 if (SANITIZER_IOSSIM
) {
666 const char *vers_env
= GetEnv("SIMULATOR_RUNTIME_VERSION");
668 Report("ERROR: Running in simulator but SIMULATOR_RUNTIME_VERSION env "
669 "var is not set.\n");
672 len
= internal_strlcpy(vers
, vers_env
, len
);
675 internal_sysctlbyname("kern.osproductversion", vers
, &len
, nullptr, 0);
677 // XNU 17 (macOS 10.13) and below do not provide the sysctl
678 // `kern.osproductversion` entry (res != 0).
679 bool no_os_version
= res
!= 0;
681 // For launchd, sanitizer initialization runs before sysctl is setup
682 // (res == 0 && len != strlen(vers), vers is not a valid version). However,
683 // the kernel version `kern.osrelease` is available.
684 bool launchd
= (res
== 0 && internal_strlen(vers
) < 3);
685 if (launchd
) CHECK_EQ(internal_getpid(), 1);
687 if (no_os_version
|| launchd
) {
688 len
= ApproximateOSVersionViaKernelVersion(vers
);
691 CHECK_LT(len
, sizeof(VersStr
));
694 void ParseVersion(const char *vers
, u16
*major
, u16
*minor
) {
695 // Format: <major>.<minor>[.<patch>]\0
696 CHECK_GE(internal_strlen(vers
), 3);
697 const char *p
= vers
;
698 *major
= internal_simple_strtoll(p
, &p
, /*base=*/10);
701 *minor
= internal_simple_strtoll(p
, &p
, /*base=*/10);
704 // Aligned versions example:
705 // macOS 10.15 -- iOS 13 -- tvOS 13 -- watchOS 6
706 static void MapToMacos(u16
*major
, u16
*minor
) {
710 if (TARGET_OS_IOS
|| TARGET_OS_TV
)
712 else if (TARGET_OS_WATCH
)
715 UNREACHABLE("unsupported platform");
717 if (*major
>= 16) { // macOS 11+
719 } else { // macOS 10.15 and below
725 static MacosVersion
GetMacosAlignedVersionInternal() {
730 ParseVersion(vers
, &major
, &minor
);
731 MapToMacos(&major
, &minor
);
733 return MacosVersion(major
, minor
);
736 static_assert(sizeof(MacosVersion
) == sizeof(atomic_uint32_t::Type
),
737 "MacosVersion cache size");
738 static atomic_uint32_t cached_macos_version
;
740 MacosVersion
GetMacosAlignedVersion() {
741 atomic_uint32_t::Type result
=
742 atomic_load(&cached_macos_version
, memory_order_acquire
);
744 MacosVersion version
= GetMacosAlignedVersionInternal();
745 result
= *reinterpret_cast<atomic_uint32_t::Type
*>(&version
);
746 atomic_store(&cached_macos_version
, result
, memory_order_release
);
748 return *reinterpret_cast<MacosVersion
*>(&result
);
751 DarwinKernelVersion
GetDarwinKernelVersion() {
753 uptr len
= sizeof(VersStr
);
754 int res
= internal_sysctlbyname("kern.osrelease", vers
, &len
, nullptr, 0);
756 CHECK_LT(len
, sizeof(VersStr
));
759 ParseVersion(vers
, &major
, &minor
);
761 return DarwinKernelVersion(major
, minor
);
765 struct task_basic_info info
;
766 unsigned count
= TASK_BASIC_INFO_COUNT
;
767 kern_return_t result
=
768 task_info(mach_task_self(), TASK_BASIC_INFO
, (task_info_t
)&info
, &count
);
769 if (UNLIKELY(result
!= KERN_SUCCESS
)) {
770 Report("Cannot get task info. Error: %d\n", result
);
773 return info
.resident_size
;
776 void *internal_start_thread(void *(*func
)(void *arg
), void *arg
) {
777 // Start the thread with signals blocked, otherwise it can steal user signals.
778 __sanitizer_sigset_t set
, old
;
779 internal_sigfillset(&set
);
780 internal_sigprocmask(SIG_SETMASK
, &set
, &old
);
782 pthread_create(&th
, 0, func
, arg
);
783 internal_sigprocmask(SIG_SETMASK
, &old
, 0);
787 void internal_join_thread(void *th
) { pthread_join((pthread_t
)th
, 0); }
790 static Mutex syslog_lock
;
793 void WriteOneLineToSyslog(const char *s
) {
795 syslog_lock
.CheckLocked();
796 if (GetMacosAlignedVersion() >= MacosVersion(10, 12)) {
797 os_log_error(OS_LOG_DEFAULT
, "%{public}s", s
);
799 asl_log(nullptr, nullptr, ASL_LEVEL_ERR
, "%s", s
);
804 // buffer to store crash report application information
805 static char crashreporter_info_buff
[__sanitizer::kErrorMessageBufferSize
] = {};
806 static Mutex crashreporter_info_mutex
;
809 // Integrate with crash reporter libraries.
810 #if HAVE_CRASHREPORTERCLIENT_H
811 CRASH_REPORTER_CLIENT_HIDDEN
812 struct crashreporter_annotations_t gCRAnnotations
813 __attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION
))) = {
814 CRASHREPORTER_ANNOTATIONS_VERSION
,
821 #if CRASHREPORTER_ANNOTATIONS_VERSION > 4
827 // fall back to old crashreporter api
828 static const char *__crashreporter_info__
__attribute__((__used__
)) =
829 &crashreporter_info_buff
[0];
830 asm(".desc ___crashreporter_info__, 0x10");
835 static void CRAppendCrashLogMessage(const char *msg
) {
836 Lock
l(&crashreporter_info_mutex
);
837 internal_strlcat(crashreporter_info_buff
, msg
,
838 sizeof(crashreporter_info_buff
));
839 #if HAVE_CRASHREPORTERCLIENT_H
840 (void)CRSetCrashLogMessage(crashreporter_info_buff
);
844 void LogMessageOnPrintf(const char *str
) {
845 // Log all printf output to CrashLog.
846 if (common_flags()->abort_on_error
)
847 CRAppendCrashLogMessage(str
);
850 void LogFullErrorReport(const char *buffer
) {
852 // Log with os_trace. This will make it into the crash log.
853 #if SANITIZER_OS_TRACE
854 if (GetMacosAlignedVersion() >= MacosVersion(10, 10)) {
855 // os_trace requires the message (format parameter) to be a string literal.
856 if (internal_strncmp(SanitizerToolName
, "AddressSanitizer",
857 sizeof("AddressSanitizer") - 1) == 0)
858 os_trace("Address Sanitizer reported a failure.");
859 else if (internal_strncmp(SanitizerToolName
, "UndefinedBehaviorSanitizer",
860 sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
861 os_trace("Undefined Behavior Sanitizer reported a failure.");
862 else if (internal_strncmp(SanitizerToolName
, "ThreadSanitizer",
863 sizeof("ThreadSanitizer") - 1) == 0)
864 os_trace("Thread Sanitizer reported a failure.");
866 os_trace("Sanitizer tool reported a failure.");
868 if (common_flags()->log_to_syslog
)
869 os_trace("Consult syslog for more information.");
874 // The logging on OS X may call pthread_create so we need the threading
875 // environment to be fully initialized. Also, this should never be called when
876 // holding the thread registry lock since that may result in a deadlock. If
877 // the reporting thread holds the thread registry mutex, and asl_log waits
878 // for GCD to dispatch a new thread, the process will deadlock, because the
879 // pthread_create wrapper needs to acquire the lock as well.
880 Lock
l(&syslog_lock
);
881 if (common_flags()->log_to_syslog
)
882 WriteToSyslog(buffer
);
884 // The report is added to CrashLog as part of logging all of Printf output.
888 SignalContext::WriteFlag
SignalContext::GetWriteFlag() const {
889 #if defined(__x86_64__) || defined(__i386__)
890 ucontext_t
*ucontext
= static_cast<ucontext_t
*>(context
);
891 return ucontext
->uc_mcontext
->__es
.__err
& 2 /*T_PF_WRITE*/ ? Write
: Read
;
892 #elif defined(__arm64__)
893 ucontext_t
*ucontext
= static_cast<ucontext_t
*>(context
);
894 return ucontext
->uc_mcontext
->__es
.__esr
& 0x40 /*ISS_DA_WNR*/ ? Write
: Read
;
900 bool SignalContext::IsTrueFaultingAddress() const {
901 auto si
= static_cast<const siginfo_t
*>(siginfo
);
902 // "Real" SIGSEGV codes (e.g., SEGV_MAPERR, SEGV_MAPERR) are non-zero.
903 return si
->si_signo
== SIGSEGV
&& si
->si_code
!= 0;
906 #if defined(__aarch64__) && defined(arm_thread_state64_get_sp)
907 #define AARCH64_GET_REG(r) \
908 (uptr)ptrauth_strip( \
909 (void *)arm_thread_state64_get_##r(ucontext->uc_mcontext->__ss), 0)
911 #define AARCH64_GET_REG(r) (uptr)ucontext->uc_mcontext->__ss.__##r
914 static void GetPcSpBp(void *context
, uptr
*pc
, uptr
*sp
, uptr
*bp
) {
915 ucontext_t
*ucontext
= (ucontext_t
*)context
;
916 # if defined(__aarch64__)
917 *pc
= AARCH64_GET_REG(pc
);
918 *bp
= AARCH64_GET_REG(fp
);
919 *sp
= AARCH64_GET_REG(sp
);
920 # elif defined(__x86_64__)
921 *pc
= ucontext
->uc_mcontext
->__ss
.__rip
;
922 *bp
= ucontext
->uc_mcontext
->__ss
.__rbp
;
923 *sp
= ucontext
->uc_mcontext
->__ss
.__rsp
;
924 # elif defined(__arm__)
925 *pc
= ucontext
->uc_mcontext
->__ss
.__pc
;
926 *bp
= ucontext
->uc_mcontext
->__ss
.__r
[7];
927 *sp
= ucontext
->uc_mcontext
->__ss
.__sp
;
928 # elif defined(__i386__)
929 *pc
= ucontext
->uc_mcontext
->__ss
.__eip
;
930 *bp
= ucontext
->uc_mcontext
->__ss
.__ebp
;
931 *sp
= ucontext
->uc_mcontext
->__ss
.__esp
;
933 # error "Unknown architecture"
937 void SignalContext::InitPcSpBp() {
938 addr
= (uptr
)ptrauth_strip((void *)addr
, 0);
939 GetPcSpBp(context
, &pc
, &sp
, &bp
);
942 // ASan/TSan use mmap in a way that creates “deallocation gaps” which triggers
943 // EXC_GUARD exceptions on macOS 10.15+ (XNU 19.0+).
944 static void DisableMmapExcGuardExceptions() {
945 using task_exc_guard_behavior_t
= uint32_t;
946 using task_set_exc_guard_behavior_t
=
947 kern_return_t(task_t task
, task_exc_guard_behavior_t behavior
);
948 auto *set_behavior
= (task_set_exc_guard_behavior_t
*)dlsym(
949 RTLD_DEFAULT
, "task_set_exc_guard_behavior");
950 if (set_behavior
== nullptr) return;
951 const task_exc_guard_behavior_t task_exc_guard_none
= 0;
952 set_behavior(mach_task_self(), task_exc_guard_none
);
955 static void VerifyInterceptorsWorking();
956 static void StripEnv();
958 void InitializePlatformEarly() {
959 // Only use xnu_fast_mmap when on x86_64 and the kernel supports it.
961 #if defined(__x86_64__)
962 GetDarwinKernelVersion() >= DarwinKernelVersion(17, 5);
966 if (GetDarwinKernelVersion() >= DarwinKernelVersion(19, 0))
967 DisableMmapExcGuardExceptions();
970 MonotonicNanoTime(); // Call to initialize mach_timebase_info
971 VerifyInterceptorsWorking();
977 static const char kDyldInsertLibraries
[] = "DYLD_INSERT_LIBRARIES";
978 LowLevelAllocator allocator_for_env
;
980 static bool ShouldCheckInterceptors() {
981 // Restrict "interceptors working?" check to ASan and TSan.
982 const char *sanitizer_names
[] = {"AddressSanitizer", "ThreadSanitizer"};
983 size_t count
= sizeof(sanitizer_names
) / sizeof(sanitizer_names
[0]);
984 for (size_t i
= 0; i
< count
; i
++) {
985 if (internal_strcmp(sanitizer_names
[i
], SanitizerToolName
) == 0)
991 static void VerifyInterceptorsWorking() {
992 if (!common_flags()->verify_interceptors
|| !ShouldCheckInterceptors())
995 // Verify that interceptors really work. We'll use dlsym to locate
996 // "puts", if interceptors are working, it should really point to
997 // "wrap_puts" within our own dylib.
998 Dl_info info_puts
, info_runtime
;
999 RAW_CHECK(dladdr(dlsym(RTLD_DEFAULT
, "puts"), &info_puts
));
1000 RAW_CHECK(dladdr((void *)&VerifyInterceptorsWorking
, &info_runtime
));
1001 if (internal_strcmp(info_puts
.dli_fname
, info_runtime
.dli_fname
) != 0) {
1003 "ERROR: Interceptors are not working. This may be because %s is "
1004 "loaded too late (e.g. via dlopen). Please launch the executable "
1006 SanitizerToolName
, kDyldInsertLibraries
, info_runtime
.dli_fname
);
1007 RAW_CHECK("interceptors not installed" && 0);
1011 // Change the value of the env var |name|, leaking the original value.
1012 // If |name_value| is NULL, the variable is deleted from the environment,
1013 // otherwise the corresponding "NAME=value" string is replaced with
1015 static void LeakyResetEnv(const char *name
, const char *name_value
) {
1016 char **env
= GetEnviron();
1017 uptr name_len
= internal_strlen(name
);
1019 uptr len
= internal_strlen(*env
);
1020 if (len
> name_len
) {
1021 const char *p
= *env
;
1022 if (!internal_memcmp(p
, name
, name_len
) && p
[name_len
] == '=') {
1025 // Replace the old value with the new one.
1026 *env
= const_cast<char*>(name_value
);
1028 // Shift the subsequent pointers back.
1040 static void StripEnv() {
1041 if (!common_flags()->strip_env
)
1044 char *dyld_insert_libraries
=
1045 const_cast<char *>(GetEnv(kDyldInsertLibraries
));
1046 if (!dyld_insert_libraries
)
1050 RAW_CHECK(dladdr((void *)&StripEnv
, &info
));
1051 const char *dylib_name
= StripModuleName(info
.dli_fname
);
1052 bool lib_is_in_env
= internal_strstr(dyld_insert_libraries
, dylib_name
);
1056 // DYLD_INSERT_LIBRARIES is set and contains the runtime library. Let's remove
1057 // the dylib from the environment variable, because interceptors are installed
1058 // and we don't want our children to inherit the variable.
1060 uptr old_env_len
= internal_strlen(dyld_insert_libraries
);
1061 uptr dylib_name_len
= internal_strlen(dylib_name
);
1062 uptr env_name_len
= internal_strlen(kDyldInsertLibraries
);
1063 // Allocate memory to hold the previous env var name, its value, the '='
1064 // sign and the '\0' char.
1065 char *new_env
= (char*)allocator_for_env
.Allocate(
1066 old_env_len
+ 2 + env_name_len
);
1068 internal_memset(new_env
, '\0', old_env_len
+ 2 + env_name_len
);
1069 internal_strncpy(new_env
, kDyldInsertLibraries
, env_name_len
);
1070 new_env
[env_name_len
] = '=';
1071 char *new_env_pos
= new_env
+ env_name_len
+ 1;
1073 // Iterate over colon-separated pieces of |dyld_insert_libraries|.
1074 char *piece_start
= dyld_insert_libraries
;
1075 char *piece_end
= NULL
;
1076 char *old_env_end
= dyld_insert_libraries
+ old_env_len
;
1078 if (piece_start
[0] == ':') piece_start
++;
1079 piece_end
= internal_strchr(piece_start
, ':');
1080 if (!piece_end
) piece_end
= dyld_insert_libraries
+ old_env_len
;
1081 if ((uptr
)(piece_start
- dyld_insert_libraries
) > old_env_len
) break;
1082 uptr piece_len
= piece_end
- piece_start
;
1084 char *filename_start
=
1085 (char *)internal_memrchr(piece_start
, '/', piece_len
);
1086 uptr filename_len
= piece_len
;
1087 if (filename_start
) {
1088 filename_start
+= 1;
1089 filename_len
= piece_len
- (filename_start
- piece_start
);
1091 filename_start
= piece_start
;
1094 // If the current piece isn't the runtime library name,
1095 // append it to new_env.
1096 if ((dylib_name_len
!= filename_len
) ||
1097 (internal_memcmp(filename_start
, dylib_name
, dylib_name_len
) != 0)) {
1098 if (new_env_pos
!= new_env
+ env_name_len
+ 1) {
1099 new_env_pos
[0] = ':';
1102 internal_strncpy(new_env_pos
, piece_start
, piece_len
);
1103 new_env_pos
+= piece_len
;
1105 // Move on to the next piece.
1106 piece_start
= piece_end
;
1107 } while (piece_start
< old_env_end
);
1109 // Can't use setenv() here, because it requires the allocator to be
1111 // FIXME: instead of filtering DYLD_INSERT_LIBRARIES here, do it in
1112 // a separate function called after InitializeAllocator().
1113 if (new_env_pos
== new_env
+ env_name_len
+ 1) new_env
= NULL
;
1114 LeakyResetEnv(kDyldInsertLibraries
, new_env
);
1116 #endif // SANITIZER_GO
1119 return *_NSGetArgv();
1122 #if SANITIZER_IOS && !SANITIZER_IOSSIM
1123 // The task_vm_info struct is normally provided by the macOS SDK, but we need
1124 // fields only available in 10.12+. Declare the struct manually to be able to
1125 // build against older SDKs.
1126 struct __sanitizer_task_vm_info
{
1127 mach_vm_size_t virtual_size
;
1128 integer_t region_count
;
1129 integer_t page_size
;
1130 mach_vm_size_t resident_size
;
1131 mach_vm_size_t resident_size_peak
;
1132 mach_vm_size_t device
;
1133 mach_vm_size_t device_peak
;
1134 mach_vm_size_t internal
;
1135 mach_vm_size_t internal_peak
;
1136 mach_vm_size_t external
;
1137 mach_vm_size_t external_peak
;
1138 mach_vm_size_t reusable
;
1139 mach_vm_size_t reusable_peak
;
1140 mach_vm_size_t purgeable_volatile_pmap
;
1141 mach_vm_size_t purgeable_volatile_resident
;
1142 mach_vm_size_t purgeable_volatile_virtual
;
1143 mach_vm_size_t compressed
;
1144 mach_vm_size_t compressed_peak
;
1145 mach_vm_size_t compressed_lifetime
;
1146 mach_vm_size_t phys_footprint
;
1147 mach_vm_address_t min_address
;
1148 mach_vm_address_t max_address
;
1150 #define __SANITIZER_TASK_VM_INFO_COUNT ((mach_msg_type_number_t) \
1151 (sizeof(__sanitizer_task_vm_info) / sizeof(natural_t)))
1153 static uptr
GetTaskInfoMaxAddress() {
1154 __sanitizer_task_vm_info vm_info
= {} /* zero initialize */;
1155 mach_msg_type_number_t count
= __SANITIZER_TASK_VM_INFO_COUNT
;
1156 int err
= task_info(mach_task_self(), TASK_VM_INFO
, (int *)&vm_info
, &count
);
1157 return err
? 0 : vm_info
.max_address
;
1160 uptr
GetMaxUserVirtualAddress() {
1161 static uptr max_vm
= GetTaskInfoMaxAddress();
1163 const uptr ret_value
= max_vm
- 1;
1164 CHECK_LE(ret_value
, SANITIZER_MMAP_RANGE_SIZE
);
1168 // xnu cannot provide vm address limit
1169 # if SANITIZER_WORDSIZE == 32
1170 constexpr uptr fallback_max_vm
= 0xffe00000 - 1;
1172 constexpr uptr fallback_max_vm
= 0x200000000 - 1;
1174 static_assert(fallback_max_vm
<= SANITIZER_MMAP_RANGE_SIZE
,
1175 "Max virtual address must be less than mmap range size.");
1176 return fallback_max_vm
;
1179 #else // !SANITIZER_IOS
1181 uptr
GetMaxUserVirtualAddress() {
1182 # if SANITIZER_WORDSIZE == 64
1183 constexpr uptr max_vm
= (1ULL << 47) - 1; // 0x00007fffffffffffUL;
1184 # else // SANITIZER_WORDSIZE == 32
1185 static_assert(SANITIZER_WORDSIZE
== 32, "Wrong wordsize");
1186 constexpr uptr max_vm
= (1ULL << 32) - 1; // 0xffffffff;
1188 static_assert(max_vm
<= SANITIZER_MMAP_RANGE_SIZE
,
1189 "Max virtual address must be less than mmap range size.");
1194 uptr
GetMaxVirtualAddress() {
1195 return GetMaxUserVirtualAddress();
1198 uptr
MapDynamicShadow(uptr shadow_size_bytes
, uptr shadow_scale
,
1199 uptr min_shadow_base_alignment
, uptr
&high_mem_end
) {
1200 const uptr granularity
= GetMmapGranularity();
1201 const uptr alignment
=
1202 Max
<uptr
>(granularity
<< shadow_scale
, 1ULL << min_shadow_base_alignment
);
1203 const uptr left_padding
=
1204 Max
<uptr
>(granularity
, 1ULL << min_shadow_base_alignment
);
1206 uptr space_size
= shadow_size_bytes
+ left_padding
;
1208 uptr largest_gap_found
= 0;
1209 uptr max_occupied_addr
= 0;
1210 VReport(2, "FindDynamicShadowStart, space_size = %p\n", (void *)space_size
);
1212 FindAvailableMemoryRange(space_size
, alignment
, granularity
,
1213 &largest_gap_found
, &max_occupied_addr
);
1214 // If the shadow doesn't fit, restrict the address space to make it fit.
1215 if (shadow_start
== 0) {
1218 "Shadow doesn't fit, largest_gap_found = %p, max_occupied_addr = %p\n",
1219 (void *)largest_gap_found
, (void *)max_occupied_addr
);
1220 uptr new_max_vm
= RoundDownTo(largest_gap_found
<< shadow_scale
, alignment
);
1221 if (new_max_vm
< max_occupied_addr
) {
1222 Report("Unable to find a memory range for dynamic shadow.\n");
1224 "space_size = %p, largest_gap_found = %p, max_occupied_addr = %p, "
1225 "new_max_vm = %p\n",
1226 (void *)space_size
, (void *)largest_gap_found
,
1227 (void *)max_occupied_addr
, (void *)new_max_vm
);
1228 CHECK(0 && "cannot place shadow");
1230 RestrictMemoryToMaxAddress(new_max_vm
);
1231 high_mem_end
= new_max_vm
- 1;
1232 space_size
= (high_mem_end
>> shadow_scale
) + left_padding
;
1233 VReport(2, "FindDynamicShadowStart, space_size = %p\n", (void *)space_size
);
1234 shadow_start
= FindAvailableMemoryRange(space_size
, alignment
, granularity
,
1236 if (shadow_start
== 0) {
1237 Report("Unable to find a memory range after restricting VM.\n");
1238 CHECK(0 && "cannot place shadow after restricting vm");
1241 CHECK_NE((uptr
)0, shadow_start
);
1242 CHECK(IsAligned(shadow_start
, alignment
));
1243 return shadow_start
;
1246 uptr
MapDynamicShadowAndAliases(uptr shadow_size
, uptr alias_size
,
1247 uptr num_aliases
, uptr ring_buffer_size
) {
1248 CHECK(false && "HWASan aliasing is unimplemented on Mac");
1252 uptr
FindAvailableMemoryRange(uptr size
, uptr alignment
, uptr left_padding
,
1253 uptr
*largest_gap_found
,
1254 uptr
*max_occupied_addr
) {
1255 typedef vm_region_submap_short_info_data_64_t RegionInfo
;
1256 enum { kRegionInfoSize
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
};
1257 // Start searching for available memory region past PAGEZERO, which is
1258 // 4KB on 32-bit and 4GB on 64-bit.
1259 mach_vm_address_t start_address
=
1260 (SANITIZER_WORDSIZE
== 32) ? 0x000000001000 : 0x000100000000;
1262 const mach_vm_address_t max_vm_address
= GetMaxVirtualAddress() + 1;
1263 mach_vm_address_t address
= start_address
;
1264 mach_vm_address_t free_begin
= start_address
;
1265 kern_return_t kr
= KERN_SUCCESS
;
1266 if (largest_gap_found
) *largest_gap_found
= 0;
1267 if (max_occupied_addr
) *max_occupied_addr
= 0;
1268 while (kr
== KERN_SUCCESS
) {
1269 mach_vm_size_t vmsize
= 0;
1270 natural_t depth
= 0;
1272 mach_msg_type_number_t count
= kRegionInfoSize
;
1273 kr
= mach_vm_region_recurse(mach_task_self(), &address
, &vmsize
, &depth
,
1274 (vm_region_info_t
)&vminfo
, &count
);
1275 if (kr
== KERN_INVALID_ADDRESS
) {
1276 // No more regions beyond "address", consider the gap at the end of VM.
1277 address
= max_vm_address
;
1280 if (max_occupied_addr
) *max_occupied_addr
= address
+ vmsize
;
1282 if (free_begin
!= address
) {
1283 // We found a free region [free_begin..address-1].
1284 uptr gap_start
= RoundUpTo((uptr
)free_begin
+ left_padding
, alignment
);
1285 uptr gap_end
= RoundDownTo((uptr
)Min(address
, max_vm_address
), alignment
);
1286 uptr gap_size
= gap_end
> gap_start
? gap_end
- gap_start
: 0;
1287 if (size
< gap_size
) {
1291 if (largest_gap_found
&& *largest_gap_found
< gap_size
) {
1292 *largest_gap_found
= gap_size
;
1295 // Move to the next region.
1297 free_begin
= address
;
1300 // We looked at all free regions and could not find one large enough.
1304 // FIXME implement on this platform.
1305 void GetMemoryProfile(fill_profile_f cb
, uptr
*stats
) {}
1307 void SignalContext::DumpAllRegisters(void *context
) {
1308 Report("Register values:\n");
1310 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1311 # define DUMPREG64(r) \
1312 Printf("%s = 0x%016llx ", #r, ucontext->uc_mcontext->__ss.__ ## r);
1313 # define DUMPREGA64(r) \
1314 Printf(" %s = 0x%016lx ", #r, AARCH64_GET_REG(r));
1315 # define DUMPREG32(r) \
1316 Printf("%s = 0x%08x ", #r, ucontext->uc_mcontext->__ss.__ ## r);
1317 # define DUMPREG_(r) Printf(" "); DUMPREG(r);
1318 # define DUMPREG__(r) Printf(" "); DUMPREG(r);
1319 # define DUMPREG___(r) Printf(" "); DUMPREG(r);
1321 # if defined(__x86_64__)
1322 # define DUMPREG(r) DUMPREG64(r)
1323 DUMPREG(rax
); DUMPREG(rbx
); DUMPREG(rcx
); DUMPREG(rdx
); Printf("\n");
1324 DUMPREG(rdi
); DUMPREG(rsi
); DUMPREG(rbp
); DUMPREG(rsp
); Printf("\n");
1325 DUMPREG_(r8
); DUMPREG_(r9
); DUMPREG(r10
); DUMPREG(r11
); Printf("\n");
1326 DUMPREG(r12
); DUMPREG(r13
); DUMPREG(r14
); DUMPREG(r15
); Printf("\n");
1327 # elif defined(__i386__)
1328 # define DUMPREG(r) DUMPREG32(r)
1329 DUMPREG(eax
); DUMPREG(ebx
); DUMPREG(ecx
); DUMPREG(edx
); Printf("\n");
1330 DUMPREG(edi
); DUMPREG(esi
); DUMPREG(ebp
); DUMPREG(esp
); Printf("\n");
1331 # elif defined(__aarch64__)
1332 # define DUMPREG(r) DUMPREG64(r)
1333 DUMPREG_(x
[0]); DUMPREG_(x
[1]); DUMPREG_(x
[2]); DUMPREG_(x
[3]); Printf("\n");
1334 DUMPREG_(x
[4]); DUMPREG_(x
[5]); DUMPREG_(x
[6]); DUMPREG_(x
[7]); Printf("\n");
1335 DUMPREG_(x
[8]); DUMPREG_(x
[9]); DUMPREG(x
[10]); DUMPREG(x
[11]); Printf("\n");
1336 DUMPREG(x
[12]); DUMPREG(x
[13]); DUMPREG(x
[14]); DUMPREG(x
[15]); Printf("\n");
1337 DUMPREG(x
[16]); DUMPREG(x
[17]); DUMPREG(x
[18]); DUMPREG(x
[19]); Printf("\n");
1338 DUMPREG(x
[20]); DUMPREG(x
[21]); DUMPREG(x
[22]); DUMPREG(x
[23]); Printf("\n");
1339 DUMPREG(x
[24]); DUMPREG(x
[25]); DUMPREG(x
[26]); DUMPREG(x
[27]); Printf("\n");
1340 DUMPREG(x
[28]); DUMPREGA64(fp
); DUMPREGA64(lr
); DUMPREGA64(sp
); Printf("\n");
1341 # elif defined(__arm__)
1342 # define DUMPREG(r) DUMPREG32(r)
1343 DUMPREG_(r
[0]); DUMPREG_(r
[1]); DUMPREG_(r
[2]); DUMPREG_(r
[3]); Printf("\n");
1344 DUMPREG_(r
[4]); DUMPREG_(r
[5]); DUMPREG_(r
[6]); DUMPREG_(r
[7]); Printf("\n");
1345 DUMPREG_(r
[8]); DUMPREG_(r
[9]); DUMPREG(r
[10]); DUMPREG(r
[11]); Printf("\n");
1346 DUMPREG(r
[12]); DUMPREG___(sp
); DUMPREG___(lr
); DUMPREG___(pc
); Printf("\n");
1348 # error "Unknown architecture"
1359 static inline bool CompareBaseAddress(const LoadedModule
&a
,
1360 const LoadedModule
&b
) {
1361 return a
.base_address() < b
.base_address();
1364 void FormatUUID(char *out
, uptr size
, const u8
*uuid
) {
1365 internal_snprintf(out
, size
,
1366 "<%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-"
1367 "%02X%02X%02X%02X%02X%02X>",
1368 uuid
[0], uuid
[1], uuid
[2], uuid
[3], uuid
[4], uuid
[5],
1369 uuid
[6], uuid
[7], uuid
[8], uuid
[9], uuid
[10], uuid
[11],
1370 uuid
[12], uuid
[13], uuid
[14], uuid
[15]);
1373 void DumpProcessMap() {
1374 Printf("Process module map:\n");
1375 MemoryMappingLayout
memory_mapping(false);
1376 InternalMmapVector
<LoadedModule
> modules
;
1377 modules
.reserve(128);
1378 memory_mapping
.DumpListOfModules(&modules
);
1379 Sort(modules
.data(), modules
.size(), CompareBaseAddress
);
1380 for (uptr i
= 0; i
< modules
.size(); ++i
) {
1382 FormatUUID(uuid_str
, sizeof(uuid_str
), modules
[i
].uuid());
1383 Printf("0x%zx-0x%zx %s (%s) %s\n", modules
[i
].base_address(),
1384 modules
[i
].max_address(), modules
[i
].full_name(),
1385 ModuleArchToString(modules
[i
].arch()), uuid_str
);
1387 Printf("End of module map.\n");
1390 void CheckNoDeepBind(const char *filename
, int flag
) {
1394 bool GetRandom(void *buffer
, uptr length
, bool blocking
) {
1395 if (!buffer
|| !length
|| length
> 256)
1397 // arc4random never fails.
1398 REAL(arc4random_buf
)(buffer
, length
);
1402 u32
GetNumberOfCPUs() {
1403 return (u32
)sysconf(_SC_NPROCESSORS_ONLN
);
1406 void InitializePlatformCommonFlags(CommonFlags
*cf
) {}
1408 // Pthread introspection hook
1410 // * GCD worker threads are created without a call to pthread_create(), but we
1411 // still need to register these threads (with ThreadCreate/Start()).
1412 // * We use the "pthread introspection hook" below to observe the creation of
1414 // * GCD worker threads don't have parent threads and the CREATE event is
1415 // delivered in the context of the thread itself. CREATE events for regular
1416 // threads, are delivered on the parent. We use this to tell apart which
1417 // threads are GCD workers with `thread == pthread_self()`.
1419 static pthread_introspection_hook_t prev_pthread_introspection_hook
;
1420 static ThreadEventCallbacks thread_event_callbacks
;
1422 static void sanitizer_pthread_introspection_hook(unsigned int event
,
1423 pthread_t thread
, void *addr
,
1425 // create -> start -> terminate -> destroy
1426 // * create/destroy are usually (not guaranteed) delivered on the parent and
1427 // track resource allocation/reclamation
1428 // * start/terminate are guaranteed to be delivered in the context of the
1429 // thread and give hooks into "just after (before) thread starts (stops)
1431 DCHECK(event
>= PTHREAD_INTROSPECTION_THREAD_CREATE
&&
1432 event
<= PTHREAD_INTROSPECTION_THREAD_DESTROY
);
1434 if (event
== PTHREAD_INTROSPECTION_THREAD_CREATE
) {
1435 bool gcd_worker
= (thread
== pthread_self());
1436 if (thread_event_callbacks
.create
)
1437 thread_event_callbacks
.create((uptr
)thread
, gcd_worker
);
1438 } else if (event
== PTHREAD_INTROSPECTION_THREAD_START
) {
1439 CHECK_EQ(thread
, pthread_self());
1440 if (thread_event_callbacks
.start
)
1441 thread_event_callbacks
.start((uptr
)thread
);
1444 if (prev_pthread_introspection_hook
)
1445 prev_pthread_introspection_hook(event
, thread
, addr
, size
);
1447 if (event
== PTHREAD_INTROSPECTION_THREAD_TERMINATE
) {
1448 CHECK_EQ(thread
, pthread_self());
1449 if (thread_event_callbacks
.terminate
)
1450 thread_event_callbacks
.terminate((uptr
)thread
);
1451 } else if (event
== PTHREAD_INTROSPECTION_THREAD_DESTROY
) {
1452 if (thread_event_callbacks
.destroy
)
1453 thread_event_callbacks
.destroy((uptr
)thread
);
1457 void InstallPthreadIntrospectionHook(const ThreadEventCallbacks
&callbacks
) {
1458 thread_event_callbacks
= callbacks
;
1459 prev_pthread_introspection_hook
=
1460 pthread_introspection_hook_install(&sanitizer_pthread_introspection_hook
);
1463 } // namespace __sanitizer
1465 #endif // SANITIZER_APPLE