1 //===-- sanitizer_mac.cpp -------------------------------------------------===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file is shared between various sanitizers' runtime libraries and
10 // implements OSX-specific functions.
11 //===----------------------------------------------------------------------===//
12
13 #include "sanitizer_platform.h"
14 #if SANITIZER_MAC
15 #include "sanitizer_mac.h"
16 #include "interception/interception.h"
17
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
22 #endif
23 #include <stdio.h>
24
25 #include "sanitizer_common.h"
26 #include "sanitizer_file.h"
27 #include "sanitizer_flags.h"
28 #include "sanitizer_internal_defs.h"
29 #include "sanitizer_libc.h"
30 #include "sanitizer_platform_limits_posix.h"
31 #include "sanitizer_procmaps.h"
32 #include "sanitizer_ptrauth.h"
33
34 #if !SANITIZER_IOS
35 #include <crt_externs.h> // for _NSGetEnviron
36 #else
37 extern char **environ;
38 #endif
39
40 #if defined(__has_include) && __has_include(<os/trace.h>)
41 #define SANITIZER_OS_TRACE 1
42 #include <os/trace.h>
43 #else
44 #define SANITIZER_OS_TRACE 0
45 #endif
46
47 // import new crash reporting api
48 #if defined(__has_include) && __has_include(<CrashReporterClient.h>)
49 #define HAVE_CRASHREPORTERCLIENT_H 1
50 #include <CrashReporterClient.h>
51 #else
52 #define HAVE_CRASHREPORTERCLIENT_H 0
53 #endif
54
55 #if !SANITIZER_IOS
56 #include <crt_externs.h> // for _NSGetArgv and _NSGetEnviron
57 #else
58 extern "C" {
59 extern char ***_NSGetArgv(void);
60 }
61 #endif
62
63 #include <asl.h>
64 #include <dlfcn.h> // for dladdr()
65 #include <errno.h>
66 #include <fcntl.h>
67 #include <libkern/OSAtomic.h>
68 #include <mach-o/dyld.h>
69 #include <mach/mach.h>
70 #include <mach/mach_time.h>
71 #include <mach/vm_statistics.h>
72 #include <malloc/malloc.h>
73 #include <os/log.h>
74 #include <pthread.h>
75 #include <sched.h>
76 #include <signal.h>
77 #include <spawn.h>
78 #include <stdlib.h>
79 #include <sys/ioctl.h>
80 #include <sys/mman.h>
81 #include <sys/resource.h>
82 #include <sys/stat.h>
83 #include <sys/sysctl.h>
84 #include <sys/types.h>
85 #include <sys/wait.h>
86 #include <unistd.h>
87 #include <util.h>
88
89 // From <crt_externs.h>, but we don't have that file on iOS.
90 extern "C" {
91 extern char ***_NSGetArgv(void);
92 extern char ***_NSGetEnviron(void);
93 }
94
95 // From <mach/mach_vm.h>, but we don't have that file on iOS.
96 extern "C" {
97 extern kern_return_t mach_vm_region_recurse(
98 vm_map_t target_task,
99 mach_vm_address_t *address,
100 mach_vm_size_t *size,
101 natural_t *nesting_depth,
102 vm_region_recurse_info_t info,
103 mach_msg_type_number_t *infoCnt);
104 }
105
106 namespace __sanitizer {
107
108 #include "sanitizer_syscall_generic.inc"
109
110 // Direct syscalls, don't call libmalloc hooks (but not available on 10.6).
111 extern "C" void *__mmap(void *addr, size_t len, int prot, int flags, int fildes,
112 off_t off) SANITIZER_WEAK_ATTRIBUTE;
113 extern "C" int __munmap(void *, size_t) SANITIZER_WEAK_ATTRIBUTE;
114
115 // ---------------------- sanitizer_libc.h
116
117 // From <mach/vm_statistics.h>, but not on older OSs.
118 #ifndef VM_MEMORY_SANITIZER
119 #define VM_MEMORY_SANITIZER 99
120 #endif
121
122 // XNU on Darwin provides a mmap flag that optimizes allocation/deallocation of
123 // giant memory regions (i.e. shadow memory regions).
124 #define kXnuFastMmapFd 0x4
125 static size_t kXnuFastMmapThreshold = 2 << 30; // 2 GB
126 static bool use_xnu_fast_mmap = false;
127
internal_mmap(void * addr,size_t length,int prot,int flags,int fd,u64 offset)128 uptr internal_mmap(void *addr, size_t length, int prot, int flags,
129 int fd, u64 offset) {
130 if (fd == -1) {
131 fd = VM_MAKE_TAG(VM_MEMORY_SANITIZER);
132 if (length >= kXnuFastMmapThreshold) {
133 if (use_xnu_fast_mmap) fd |= kXnuFastMmapFd;
134 }
135 }
136 if (&__mmap) return (uptr)__mmap(addr, length, prot, flags, fd, offset);
137 return (uptr)mmap(addr, length, prot, flags, fd, offset);
138 }
139
internal_munmap(void * addr,uptr length)140 uptr internal_munmap(void *addr, uptr length) {
141 if (&__munmap) return __munmap(addr, length);
142 return munmap(addr, length);
143 }
144
internal_mremap(void * old_address,uptr old_size,uptr new_size,int flags,void * new_address)145 uptr internal_mremap(void *old_address, uptr old_size, uptr new_size, int flags,
146 void *new_address) {
147 CHECK(false && "internal_mremap is unimplemented on Mac");
148 return 0;
149 }
150
internal_mprotect(void * addr,uptr length,int prot)151 int internal_mprotect(void *addr, uptr length, int prot) {
152 return mprotect(addr, length, prot);
153 }
154
internal_madvise(uptr addr,uptr length,int advice)155 int internal_madvise(uptr addr, uptr length, int advice) {
156 return madvise((void *)addr, length, advice);
157 }
158
internal_close(fd_t fd)159 uptr internal_close(fd_t fd) {
160 return close(fd);
161 }
162
internal_open(const char * filename,int flags)163 uptr internal_open(const char *filename, int flags) {
164 return open(filename, flags);
165 }
166
internal_open(const char * filename,int flags,u32 mode)167 uptr internal_open(const char *filename, int flags, u32 mode) {
168 return open(filename, flags, mode);
169 }
170
internal_read(fd_t fd,void * buf,uptr count)171 uptr internal_read(fd_t fd, void *buf, uptr count) {
172 return read(fd, buf, count);
173 }
174
internal_write(fd_t fd,const void * buf,uptr count)175 uptr internal_write(fd_t fd, const void *buf, uptr count) {
176 return write(fd, buf, count);
177 }
178
internal_stat(const char * path,void * buf)179 uptr internal_stat(const char *path, void *buf) {
180 return stat(path, (struct stat *)buf);
181 }
182
internal_lstat(const char * path,void * buf)183 uptr internal_lstat(const char *path, void *buf) {
184 return lstat(path, (struct stat *)buf);
185 }
186
internal_fstat(fd_t fd,void * buf)187 uptr internal_fstat(fd_t fd, void *buf) {
188 return fstat(fd, (struct stat *)buf);
189 }
190
internal_filesize(fd_t fd)191 uptr internal_filesize(fd_t fd) {
192 struct stat st;
193 if (internal_fstat(fd, &st))
194 return -1;
195 return (uptr)st.st_size;
196 }
197
internal_dup(int oldfd)198 uptr internal_dup(int oldfd) {
199 return dup(oldfd);
200 }
201
internal_dup2(int oldfd,int newfd)202 uptr internal_dup2(int oldfd, int newfd) {
203 return dup2(oldfd, newfd);
204 }
205
internal_readlink(const char * path,char * buf,uptr bufsize)206 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
207 return readlink(path, buf, bufsize);
208 }
209
internal_unlink(const char * path)210 uptr internal_unlink(const char *path) {
211 return unlink(path);
212 }
213
internal_sched_yield()214 uptr internal_sched_yield() {
215 return sched_yield();
216 }
217
internal__exit(int exitcode)218 void internal__exit(int exitcode) {
219 _exit(exitcode);
220 }
221
internal_usleep(u64 useconds)222 void internal_usleep(u64 useconds) { usleep(useconds); }
223
internal_getpid()224 uptr internal_getpid() {
225 return getpid();
226 }
227
internal_dlinfo(void * handle,int request,void * p)228 int internal_dlinfo(void *handle, int request, void *p) {
229 UNIMPLEMENTED();
230 }
231
internal_sigaction(int signum,const void * act,void * oldact)232 int internal_sigaction(int signum, const void *act, void *oldact) {
233 return sigaction(signum,
234 (const struct sigaction *)act, (struct sigaction *)oldact);
235 }
236
internal_sigfillset(__sanitizer_sigset_t * set)237 void internal_sigfillset(__sanitizer_sigset_t *set) { sigfillset(set); }
238
internal_sigprocmask(int how,__sanitizer_sigset_t * set,__sanitizer_sigset_t * oldset)239 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
240 __sanitizer_sigset_t *oldset) {
241 // Don't use sigprocmask here, because it affects all threads.
242 return pthread_sigmask(how, set, oldset);
243 }
244
245 // Doesn't call pthread_atfork() handlers (but not available on 10.6).
246 extern "C" pid_t __fork(void) SANITIZER_WEAK_ATTRIBUTE;
247
internal_fork()248 int internal_fork() {
249 if (&__fork)
250 return __fork();
251 return fork();
252 }
253
internal_sysctl(const int * name,unsigned int namelen,void * oldp,uptr * oldlenp,const void * newp,uptr newlen)254 int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
255 uptr *oldlenp, const void *newp, uptr newlen) {
256 return sysctl(const_cast<int *>(name), namelen, oldp, (size_t *)oldlenp,
257 const_cast<void *>(newp), (size_t)newlen);
258 }
259
internal_sysctlbyname(const char * sname,void * oldp,uptr * oldlenp,const void * newp,uptr newlen)260 int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
261 const void *newp, uptr newlen) {
262 return sysctlbyname(sname, oldp, (size_t *)oldlenp, const_cast<void *>(newp),
263 (size_t)newlen);
264 }
265
internal_spawn_impl(const char * argv[],const char * envp[],pid_t * pid)266 static fd_t internal_spawn_impl(const char *argv[], const char *envp[],
267 pid_t *pid) {
268 fd_t master_fd = kInvalidFd;
269 fd_t slave_fd = kInvalidFd;
270
271 auto fd_closer = at_scope_exit([&] {
272 internal_close(master_fd);
273 internal_close(slave_fd);
274 });
275
276 // We need a new pseudoterminal to avoid buffering problems. The 'atos' tool
277 // in particular detects when it's talking to a pipe and forgets to flush the
278 // output stream after sending a response.
279 master_fd = posix_openpt(O_RDWR);
280 if (master_fd == kInvalidFd) return kInvalidFd;
281
282 int res = grantpt(master_fd) || unlockpt(master_fd);
283 if (res != 0) return kInvalidFd;
284
285 // Use TIOCPTYGNAME instead of ptsname() to avoid threading problems.
286 char slave_pty_name[128];
287 res = ioctl(master_fd, TIOCPTYGNAME, slave_pty_name);
288 if (res == -1) return kInvalidFd;
289
290 slave_fd = internal_open(slave_pty_name, O_RDWR);
291 if (slave_fd == kInvalidFd) return kInvalidFd;
292
293 // File descriptor actions
294 posix_spawn_file_actions_t acts;
295 res = posix_spawn_file_actions_init(&acts);
296 if (res != 0) return kInvalidFd;
297
298 auto acts_cleanup = at_scope_exit([&] {
299 posix_spawn_file_actions_destroy(&acts);
300 });
301
302 res = posix_spawn_file_actions_adddup2(&acts, slave_fd, STDIN_FILENO) ||
303 posix_spawn_file_actions_adddup2(&acts, slave_fd, STDOUT_FILENO) ||
304 posix_spawn_file_actions_addclose(&acts, slave_fd);
305 if (res != 0) return kInvalidFd;
306
307 // Spawn attributes
308 posix_spawnattr_t attrs;
309 res = posix_spawnattr_init(&attrs);
310 if (res != 0) return kInvalidFd;
311
312 auto attrs_cleanup = at_scope_exit([&] {
313 posix_spawnattr_destroy(&attrs);
314 });
315
316 // In the spawned process, close all file descriptors that are not explicitly
317 // described by the file actions object. This is Darwin-specific extension.
318 res = posix_spawnattr_setflags(&attrs, POSIX_SPAWN_CLOEXEC_DEFAULT);
319 if (res != 0) return kInvalidFd;
320
321 // posix_spawn
322 char **argv_casted = const_cast<char **>(argv);
323 char **envp_casted = const_cast<char **>(envp);
324 res = posix_spawn(pid, argv[0], &acts, &attrs, argv_casted, envp_casted);
325 if (res != 0) return kInvalidFd;
326
327 // Disable echo in the new terminal, disable CR.
328 struct termios termflags;
329 tcgetattr(master_fd, &termflags);
330 termflags.c_oflag &= ~ONLCR;
331 termflags.c_lflag &= ~ECHO;
332 tcsetattr(master_fd, TCSANOW, &termflags);
333
334 // On success, do not close master_fd on scope exit.
335 fd_t fd = master_fd;
336 master_fd = kInvalidFd;
337
338 return fd;
339 }
340
internal_spawn(const char * argv[],const char * envp[],pid_t * pid)341 fd_t internal_spawn(const char *argv[], const char *envp[], pid_t *pid) {
342 // The client program may close its stdin and/or stdout and/or stderr thus
343 // allowing open/posix_openpt to reuse file descriptors 0, 1 or 2. In this
344 // case the communication is broken if either the parent or the child tries to
345 // close or duplicate these descriptors. We temporarily reserve these
346 // descriptors here to prevent this.
347 fd_t low_fds[3];
348 size_t count = 0;
349
350 for (; count < 3; count++) {
351 low_fds[count] = posix_openpt(O_RDWR);
352 if (low_fds[count] >= STDERR_FILENO)
353 break;
354 }
355
356 fd_t fd = internal_spawn_impl(argv, envp, pid);
357
358 for (; count > 0; count--) {
359 internal_close(low_fds[count]);
360 }
361
362 return fd;
363 }
364
internal_rename(const char * oldpath,const char * newpath)365 uptr internal_rename(const char *oldpath, const char *newpath) {
366 return rename(oldpath, newpath);
367 }
368
internal_ftruncate(fd_t fd,uptr size)369 uptr internal_ftruncate(fd_t fd, uptr size) {
370 return ftruncate(fd, size);
371 }
372
internal_execve(const char * filename,char * const argv[],char * const envp[])373 uptr internal_execve(const char *filename, char *const argv[],
374 char *const envp[]) {
375 return execve(filename, argv, envp);
376 }
377
internal_waitpid(int pid,int * status,int options)378 uptr internal_waitpid(int pid, int *status, int options) {
379 return waitpid(pid, status, options);
380 }
381
382 // ----------------- sanitizer_common.h
FileExists(const char * filename)383 bool FileExists(const char *filename) {
384 if (ShouldMockFailureToOpen(filename))
385 return false;
386 struct stat st;
387 if (stat(filename, &st))
388 return false;
389 // Sanity check: filename is a regular file.
390 return S_ISREG(st.st_mode);
391 }
392
GetTid()393 tid_t GetTid() {
394 tid_t tid;
395 pthread_threadid_np(nullptr, &tid);
396 return tid;
397 }
398
GetThreadStackTopAndBottom(bool at_initialization,uptr * stack_top,uptr * stack_bottom)399 void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
400 uptr *stack_bottom) {
401 CHECK(stack_top);
402 CHECK(stack_bottom);
403 uptr stacksize = pthread_get_stacksize_np(pthread_self());
404 // pthread_get_stacksize_np() returns an incorrect stack size for the main
405 // thread on Mavericks. See
406 // https://github.com/google/sanitizers/issues/261
407 if ((GetMacosAlignedVersion() >= MacosVersion(10, 9)) && at_initialization &&
408 stacksize == (1 << 19)) {
409 struct rlimit rl;
410 CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
411 // Most often rl.rlim_cur will be the desired 8M.
412 if (rl.rlim_cur < kMaxThreadStackSize) {
413 stacksize = rl.rlim_cur;
414 } else {
415 stacksize = kMaxThreadStackSize;
416 }
417 }
418 void *stackaddr = pthread_get_stackaddr_np(pthread_self());
419 *stack_top = (uptr)stackaddr;
420 *stack_bottom = *stack_top - stacksize;
421 }
422
GetEnviron()423 char **GetEnviron() {
424 #if !SANITIZER_IOS
425 char ***env_ptr = _NSGetEnviron();
426 if (!env_ptr) {
427 Report("_NSGetEnviron() returned NULL. Please make sure __asan_init() is "
428 "called after libSystem_initializer().\n");
429 CHECK(env_ptr);
430 }
431 char **environ = *env_ptr;
432 #endif
433 CHECK(environ);
434 return environ;
435 }
436
GetEnv(const char * name)437 const char *GetEnv(const char *name) {
438 char **env = GetEnviron();
439 uptr name_len = internal_strlen(name);
440 while (*env != 0) {
441 uptr len = internal_strlen(*env);
442 if (len > name_len) {
443 const char *p = *env;
444 if (!internal_memcmp(p, name, name_len) &&
445 p[name_len] == '=') { // Match.
446 return *env + name_len + 1; // String starting after =.
447 }
448 }
449 env++;
450 }
451 return 0;
452 }
453
ReadBinaryName(char * buf,uptr buf_len)454 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
455 CHECK_LE(kMaxPathLength, buf_len);
456
457 // On OS X the executable path is saved to the stack by dyld. Reading it
458 // from there is much faster than calling dladdr, especially for large
459 // binaries with symbols.
460 InternalMmapVector<char> exe_path(kMaxPathLength);
461 uint32_t size = exe_path.size();
462 if (_NSGetExecutablePath(exe_path.data(), &size) == 0 &&
463 realpath(exe_path.data(), buf) != 0) {
464 return internal_strlen(buf);
465 }
466 return 0;
467 }
468
ReadLongProcessName(char * buf,uptr buf_len)469 uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) {
470 return ReadBinaryName(buf, buf_len);
471 }
472
ReExec()473 void ReExec() {
474 UNIMPLEMENTED();
475 }
476
CheckASLR()477 void CheckASLR() {
478 // Do nothing
479 }
480
CheckMPROTECT()481 void CheckMPROTECT() {
482 // Do nothing
483 }
484
GetPageSize()485 uptr GetPageSize() {
486 return sysconf(_SC_PAGESIZE);
487 }
488
489 extern "C" unsigned malloc_num_zones;
490 extern "C" malloc_zone_t **malloc_zones;
491 malloc_zone_t sanitizer_zone;
492
493 // We need to make sure that sanitizer_zone is registered as malloc_zones[0]. If
494 // libmalloc tries to set up a different zone as malloc_zones[0], it will call
495 // mprotect(malloc_zones, ..., PROT_READ). This interceptor will catch that and
496 // make sure we are still the first (default) zone.
MprotectMallocZones(void * addr,int prot)497 void MprotectMallocZones(void *addr, int prot) {
498 if (addr == malloc_zones && prot == PROT_READ) {
499 if (malloc_num_zones > 1 && malloc_zones[0] != &sanitizer_zone) {
500 for (unsigned i = 1; i < malloc_num_zones; i++) {
501 if (malloc_zones[i] == &sanitizer_zone) {
502 // Swap malloc_zones[0] and malloc_zones[i].
503 malloc_zones[i] = malloc_zones[0];
504 malloc_zones[0] = &sanitizer_zone;
505 break;
506 }
507 }
508 }
509 }
510 }
511
FutexWait(atomic_uint32_t * p,u32 cmp)512 void FutexWait(atomic_uint32_t *p, u32 cmp) {
513 // FIXME: implement actual blocking.
514 sched_yield();
515 }
516
FutexWake(atomic_uint32_t * p,u32 count)517 void FutexWake(atomic_uint32_t *p, u32 count) {}
518
BlockingMutex()519 BlockingMutex::BlockingMutex() {
520 internal_memset(this, 0, sizeof(*this));
521 }
522
Lock()523 void BlockingMutex::Lock() {
524 CHECK(sizeof(OSSpinLock) <= sizeof(opaque_storage_));
525 CHECK_EQ(OS_SPINLOCK_INIT, 0);
526 CHECK_EQ(owner_, 0);
527 OSSpinLockLock((OSSpinLock*)&opaque_storage_);
528 }
529
Unlock()530 void BlockingMutex::Unlock() {
531 OSSpinLockUnlock((OSSpinLock*)&opaque_storage_);
532 }
533
CheckLocked() const534 void BlockingMutex::CheckLocked() const {
535 CHECK_NE(*(const OSSpinLock*)&opaque_storage_, 0);
536 }
537
NanoTime()538 u64 NanoTime() {
539 timeval tv;
540 internal_memset(&tv, 0, sizeof(tv));
541 gettimeofday(&tv, 0);
542 return (u64)tv.tv_sec * 1000*1000*1000 + tv.tv_usec * 1000;
543 }
544
545 // This needs to be called during initialization to avoid being racy.
MonotonicNanoTime()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;
550 }
551
GetTlsSize()552 uptr GetTlsSize() {
553 return 0;
554 }
555
InitTlsSize()556 void InitTlsSize() {
557 }
558
TlsBaseAddr()559 uptr TlsBaseAddr() {
560 uptr segbase = 0;
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 #endif
566 return segbase;
567 }
568
569 // The size of the tls on darwin does not appear to be well documented,
570 // however the vm memory map suggests that it is 1024 uptrs in size,
571 // with a size of 0x2000 bytes on x86_64 and 0x1000 bytes on i386.
TlsSize()572 uptr TlsSize() {
573 #if defined(__x86_64__) || defined(__i386__)
574 return 1024 * sizeof(uptr);
575 #else
576 return 0;
577 #endif
578 }
579
GetThreadStackAndTls(bool main,uptr * stk_addr,uptr * stk_size,uptr * tls_addr,uptr * tls_size)580 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
581 uptr *tls_addr, uptr *tls_size) {
582 #if !SANITIZER_GO
583 uptr stack_top, stack_bottom;
584 GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
585 *stk_addr = stack_bottom;
586 *stk_size = stack_top - stack_bottom;
587 *tls_addr = TlsBaseAddr();
588 *tls_size = TlsSize();
589 #else
590 *stk_addr = 0;
591 *stk_size = 0;
592 *tls_addr = 0;
593 *tls_size = 0;
594 #endif
595 }
596
init()597 void ListOfModules::init() {
598 clearOrInit();
599 MemoryMappingLayout memory_mapping(false);
600 memory_mapping.DumpListOfModules(&modules_);
601 }
602
fallbackInit()603 void ListOfModules::fallbackInit() { clear(); }
604
GetHandleSignalModeImpl(int signum)605 static HandleSignalMode GetHandleSignalModeImpl(int signum) {
606 switch (signum) {
607 case SIGABRT:
608 return common_flags()->handle_abort;
609 case SIGILL:
610 return common_flags()->handle_sigill;
611 case SIGTRAP:
612 return common_flags()->handle_sigtrap;
613 case SIGFPE:
614 return common_flags()->handle_sigfpe;
615 case SIGSEGV:
616 return common_flags()->handle_segv;
617 case SIGBUS:
618 return common_flags()->handle_sigbus;
619 }
620 return kHandleSignalNo;
621 }
622
GetHandleSignalMode(int signum)623 HandleSignalMode GetHandleSignalMode(int signum) {
624 // Handling fatal signals on watchOS and tvOS devices is disallowed.
625 if ((SANITIZER_WATCHOS || SANITIZER_TVOS) && !(SANITIZER_IOSSIM))
626 return kHandleSignalNo;
627 HandleSignalMode result = GetHandleSignalModeImpl(signum);
628 if (result == kHandleSignalYes && !common_flags()->allow_user_segv_handler)
629 return kHandleSignalExclusive;
630 return result;
631 }
632
633 // Offset example:
634 // XNU 17 -- macOS 10.13 -- iOS 11 -- tvOS 11 -- watchOS 4
GetOSMajorKernelOffset()635 constexpr u16 GetOSMajorKernelOffset() {
636 if (TARGET_OS_OSX) return 4;
637 if (TARGET_OS_IOS || TARGET_OS_TV) return 6;
638 if (TARGET_OS_WATCH) return 13;
639 }
640
641 using VersStr = char[64];
642
ApproximateOSVersionViaKernelVersion(VersStr vers)643 static uptr ApproximateOSVersionViaKernelVersion(VersStr vers) {
644 u16 kernel_major = GetDarwinKernelVersion().major;
645 u16 offset = GetOSMajorKernelOffset();
646 CHECK_GE(kernel_major, offset);
647 u16 os_major = kernel_major - offset;
648
649 const char *format = "%d.0";
650 if (TARGET_OS_OSX) {
651 if (os_major >= 16) { // macOS 11+
652 os_major -= 5;
653 } else { // macOS 10.15 and below
654 format = "10.%d";
655 }
656 }
657 return internal_snprintf(vers, sizeof(VersStr), format, os_major);
658 }
659
GetOSVersion(VersStr vers)660 static void GetOSVersion(VersStr vers) {
661 uptr len = sizeof(VersStr);
662 if (SANITIZER_IOSSIM) {
663 const char *vers_env = GetEnv("SIMULATOR_RUNTIME_VERSION");
664 if (!vers_env) {
665 Report("ERROR: Running in simulator but SIMULATOR_RUNTIME_VERSION env "
666 "var is not set.\n");
667 Die();
668 }
669 len = internal_strlcpy(vers, vers_env, len);
670 } else {
671 int res =
672 internal_sysctlbyname("kern.osproductversion", vers, &len, nullptr, 0);
673
674 // XNU 17 (macOS 10.13) and below do not provide the sysctl
675 // `kern.osproductversion` entry (res != 0).
676 bool no_os_version = res != 0;
677
678 // For launchd, sanitizer initialization runs before sysctl is setup
679 // (res == 0 && len != strlen(vers), vers is not a valid version). However,
680 // the kernel version `kern.osrelease` is available.
681 bool launchd = (res == 0 && internal_strlen(vers) < 3);
682 if (launchd) CHECK_EQ(internal_getpid(), 1);
683
684 if (no_os_version || launchd) {
685 len = ApproximateOSVersionViaKernelVersion(vers);
686 }
687 }
688 CHECK_LT(len, sizeof(VersStr));
689 }
690
ParseVersion(const char * vers,u16 * major,u16 * minor)691 void ParseVersion(const char *vers, u16 *major, u16 *minor) {
692 // Format: <major>.<minor>[.<patch>]\0
693 CHECK_GE(internal_strlen(vers), 3);
694 const char *p = vers;
695 *major = internal_simple_strtoll(p, &p, /*base=*/10);
696 CHECK_EQ(*p, '.');
697 p += 1;
698 *minor = internal_simple_strtoll(p, &p, /*base=*/10);
699 }
700
701 // Aligned versions example:
702 // macOS 10.15 -- iOS 13 -- tvOS 13 -- watchOS 6
MapToMacos(u16 * major,u16 * minor)703 static void MapToMacos(u16 *major, u16 *minor) {
704 if (TARGET_OS_OSX)
705 return;
706
707 if (TARGET_OS_IOS || TARGET_OS_TV)
708 *major += 2;
709 else if (TARGET_OS_WATCH)
710 *major += 9;
711 else
712 UNREACHABLE("unsupported platform");
713
714 if (*major >= 16) { // macOS 11+
715 *major -= 5;
716 } else { // macOS 10.15 and below
717 *minor = *major;
718 *major = 10;
719 }
720 }
721
GetMacosAlignedVersionInternal()722 static MacosVersion GetMacosAlignedVersionInternal() {
723 VersStr vers = {};
724 GetOSVersion(vers);
725
726 u16 major, minor;
727 ParseVersion(vers, &major, &minor);
728 MapToMacos(&major, &minor);
729
730 return MacosVersion(major, minor);
731 }
732
733 static_assert(sizeof(MacosVersion) == sizeof(atomic_uint32_t::Type),
734 "MacosVersion cache size");
735 static atomic_uint32_t cached_macos_version;
736
GetMacosAlignedVersion()737 MacosVersion GetMacosAlignedVersion() {
738 atomic_uint32_t::Type result =
739 atomic_load(&cached_macos_version, memory_order_acquire);
740 if (!result) {
741 MacosVersion version = GetMacosAlignedVersionInternal();
742 result = *reinterpret_cast<atomic_uint32_t::Type *>(&version);
743 atomic_store(&cached_macos_version, result, memory_order_release);
744 }
745 return *reinterpret_cast<MacosVersion *>(&result);
746 }
747
GetDarwinKernelVersion()748 DarwinKernelVersion GetDarwinKernelVersion() {
749 VersStr vers = {};
750 uptr len = sizeof(VersStr);
751 int res = internal_sysctlbyname("kern.osrelease", vers, &len, nullptr, 0);
752 CHECK_EQ(res, 0);
753 CHECK_LT(len, sizeof(VersStr));
754
755 u16 major, minor;
756 ParseVersion(vers, &major, &minor);
757
758 return DarwinKernelVersion(major, minor);
759 }
760
GetRSS()761 uptr GetRSS() {
762 struct task_basic_info info;
763 unsigned count = TASK_BASIC_INFO_COUNT;
764 kern_return_t result =
765 task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count);
766 if (UNLIKELY(result != KERN_SUCCESS)) {
767 Report("Cannot get task info. Error: %d\n", result);
768 Die();
769 }
770 return info.resident_size;
771 }
772
internal_start_thread(void * (* func)(void * arg),void * arg)773 void *internal_start_thread(void *(*func)(void *arg), void *arg) {
774 // Start the thread with signals blocked, otherwise it can steal user signals.
775 __sanitizer_sigset_t set, old;
776 internal_sigfillset(&set);
777 internal_sigprocmask(SIG_SETMASK, &set, &old);
778 pthread_t th;
779 pthread_create(&th, 0, func, arg);
780 internal_sigprocmask(SIG_SETMASK, &old, 0);
781 return th;
782 }
783
internal_join_thread(void * th)784 void internal_join_thread(void *th) { pthread_join((pthread_t)th, 0); }
785
786 #if !SANITIZER_GO
787 static BlockingMutex syslog_lock(LINKER_INITIALIZED);
788 #endif
789
WriteOneLineToSyslog(const char * s)790 void WriteOneLineToSyslog(const char *s) {
791 #if !SANITIZER_GO
792 syslog_lock.CheckLocked();
793 if (GetMacosAlignedVersion() >= MacosVersion(10, 12)) {
794 os_log_error(OS_LOG_DEFAULT, "%{public}s", s);
795 } else {
796 asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", s);
797 }
798 #endif
799 }
800
801 // buffer to store crash report application information
802 static char crashreporter_info_buff[__sanitizer::kErrorMessageBufferSize] = {};
803 static BlockingMutex crashreporter_info_mutex(LINKER_INITIALIZED);
804
805 extern "C" {
806 // Integrate with crash reporter libraries.
807 #if HAVE_CRASHREPORTERCLIENT_H
808 CRASH_REPORTER_CLIENT_HIDDEN
809 struct crashreporter_annotations_t gCRAnnotations
810 __attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION))) = {
811 CRASHREPORTER_ANNOTATIONS_VERSION,
812 0,
813 0,
814 0,
815 0,
816 0,
817 0,
818 #if CRASHREPORTER_ANNOTATIONS_VERSION > 4
819 0,
820 #endif
821 };
822
823 #else
824 // fall back to old crashreporter api
825 static const char *__crashreporter_info__ __attribute__((__used__)) =
826 &crashreporter_info_buff[0];
827 asm(".desc ___crashreporter_info__, 0x10");
828 #endif
829
830 } // extern "C"
831
CRAppendCrashLogMessage(const char * msg)832 static void CRAppendCrashLogMessage(const char *msg) {
833 BlockingMutexLock l(&crashreporter_info_mutex);
834 internal_strlcat(crashreporter_info_buff, msg,
835 sizeof(crashreporter_info_buff));
836 #if HAVE_CRASHREPORTERCLIENT_H
837 (void)CRSetCrashLogMessage(crashreporter_info_buff);
838 #endif
839 }
840
LogMessageOnPrintf(const char * str)841 void LogMessageOnPrintf(const char *str) {
842 // Log all printf output to CrashLog.
843 if (common_flags()->abort_on_error)
844 CRAppendCrashLogMessage(str);
845 }
846
LogFullErrorReport(const char * buffer)847 void LogFullErrorReport(const char *buffer) {
848 #if !SANITIZER_GO
849 // Log with os_trace. This will make it into the crash log.
850 #if SANITIZER_OS_TRACE
851 if (GetMacosAlignedVersion() >= MacosVersion(10, 10)) {
852 // os_trace requires the message (format parameter) to be a string literal.
853 if (internal_strncmp(SanitizerToolName, "AddressSanitizer",
854 sizeof("AddressSanitizer") - 1) == 0)
855 os_trace("Address Sanitizer reported a failure.");
856 else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",
857 sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
858 os_trace("Undefined Behavior Sanitizer reported a failure.");
859 else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",
860 sizeof("ThreadSanitizer") - 1) == 0)
861 os_trace("Thread Sanitizer reported a failure.");
862 else
863 os_trace("Sanitizer tool reported a failure.");
864
865 if (common_flags()->log_to_syslog)
866 os_trace("Consult syslog for more information.");
867 }
868 #endif
869
870 // Log to syslog.
871 // The logging on OS X may call pthread_create so we need the threading
872 // environment to be fully initialized. Also, this should never be called when
873 // holding the thread registry lock since that may result in a deadlock. If
874 // the reporting thread holds the thread registry mutex, and asl_log waits
875 // for GCD to dispatch a new thread, the process will deadlock, because the
876 // pthread_create wrapper needs to acquire the lock as well.
877 BlockingMutexLock l(&syslog_lock);
878 if (common_flags()->log_to_syslog)
879 WriteToSyslog(buffer);
880
881 // The report is added to CrashLog as part of logging all of Printf output.
882 #endif
883 }
884
GetWriteFlag() const885 SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
886 #if defined(__x86_64__) || defined(__i386__)
887 ucontext_t *ucontext = static_cast<ucontext_t*>(context);
888 return ucontext->uc_mcontext->__es.__err & 2 /*T_PF_WRITE*/ ? WRITE : READ;
889 #else
890 return UNKNOWN;
891 #endif
892 }
893
IsTrueFaultingAddress() const894 bool SignalContext::IsTrueFaultingAddress() const {
895 auto si = static_cast<const siginfo_t *>(siginfo);
896 // "Real" SIGSEGV codes (e.g., SEGV_MAPERR, SEGV_MAPERR) are non-zero.
897 return si->si_signo == SIGSEGV && si->si_code != 0;
898 }
899
900 #if defined(__aarch64__) && defined(arm_thread_state64_get_sp)
901 #define AARCH64_GET_REG(r) \
902 (uptr)ptrauth_strip( \
903 (void *)arm_thread_state64_get_##r(ucontext->uc_mcontext->__ss), 0)
904 #else
905 #define AARCH64_GET_REG(r) ucontext->uc_mcontext->__ss.__##r
906 #endif
907
GetPcSpBp(void * context,uptr * pc,uptr * sp,uptr * bp)908 static void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
909 ucontext_t *ucontext = (ucontext_t*)context;
910 # if defined(__aarch64__)
911 *pc = AARCH64_GET_REG(pc);
912 # if defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_8_0
913 *bp = AARCH64_GET_REG(fp);
914 # else
915 *bp = AARCH64_GET_REG(lr);
916 # endif
917 *sp = AARCH64_GET_REG(sp);
918 # elif defined(__x86_64__)
919 *pc = ucontext->uc_mcontext->__ss.__rip;
920 *bp = ucontext->uc_mcontext->__ss.__rbp;
921 *sp = ucontext->uc_mcontext->__ss.__rsp;
922 # elif defined(__arm__)
923 *pc = ucontext->uc_mcontext->__ss.__pc;
924 *bp = ucontext->uc_mcontext->__ss.__r[7];
925 *sp = ucontext->uc_mcontext->__ss.__sp;
926 # elif defined(__i386__)
927 *pc = ucontext->uc_mcontext->__ss.__eip;
928 *bp = ucontext->uc_mcontext->__ss.__ebp;
929 *sp = ucontext->uc_mcontext->__ss.__esp;
930 # else
931 # error "Unknown architecture"
932 # endif
933 }
934
InitPcSpBp()935 void SignalContext::InitPcSpBp() {
936 addr = (uptr)ptrauth_strip((void *)addr, 0);
937 GetPcSpBp(context, &pc, &sp, &bp);
938 }
939
940 // ASan/TSan use mmap in a way that creates “deallocation gaps” which triggers
941 // EXC_GUARD exceptions on macOS 10.15+ (XNU 19.0+).
DisableMmapExcGuardExceptions()942 static void DisableMmapExcGuardExceptions() {
943 using task_exc_guard_behavior_t = uint32_t;
944 using task_set_exc_guard_behavior_t =
945 kern_return_t(task_t task, task_exc_guard_behavior_t behavior);
946 auto *set_behavior = (task_set_exc_guard_behavior_t *)dlsym(
947 RTLD_DEFAULT, "task_set_exc_guard_behavior");
948 if (set_behavior == nullptr) return;
949 const task_exc_guard_behavior_t task_exc_guard_none = 0;
950 set_behavior(mach_task_self(), task_exc_guard_none);
951 }
952
InitializePlatformEarly()953 void InitializePlatformEarly() {
954 // Only use xnu_fast_mmap when on x86_64 and the kernel supports it.
955 use_xnu_fast_mmap =
956 #if defined(__x86_64__)
957 GetDarwinKernelVersion() >= DarwinKernelVersion(17, 5);
958 #else
959 false;
960 #endif
961 if (GetDarwinKernelVersion() >= DarwinKernelVersion(19, 0))
962 DisableMmapExcGuardExceptions();
963 }
964
965 #if !SANITIZER_GO
966 static const char kDyldInsertLibraries[] = "DYLD_INSERT_LIBRARIES";
967 LowLevelAllocator allocator_for_env;
968
969 // Change the value of the env var |name|, leaking the original value.
970 // If |name_value| is NULL, the variable is deleted from the environment,
971 // otherwise the corresponding "NAME=value" string is replaced with
972 // |name_value|.
LeakyResetEnv(const char * name,const char * name_value)973 void LeakyResetEnv(const char *name, const char *name_value) {
974 char **env = GetEnviron();
975 uptr name_len = internal_strlen(name);
976 while (*env != 0) {
977 uptr len = internal_strlen(*env);
978 if (len > name_len) {
979 const char *p = *env;
980 if (!internal_memcmp(p, name, name_len) && p[name_len] == '=') {
981 // Match.
982 if (name_value) {
983 // Replace the old value with the new one.
984 *env = const_cast<char*>(name_value);
985 } else {
986 // Shift the subsequent pointers back.
987 char **del = env;
988 do {
989 del[0] = del[1];
990 } while (*del++);
991 }
992 }
993 }
994 env++;
995 }
996 }
997
998 SANITIZER_WEAK_CXX_DEFAULT_IMPL
ReexecDisabled()999 bool ReexecDisabled() {
1000 return false;
1001 }
1002
DyldNeedsEnvVariable()1003 static bool DyldNeedsEnvVariable() {
1004 // If running on OS X 10.11+ or iOS 9.0+, dyld will interpose even if
1005 // DYLD_INSERT_LIBRARIES is not set.
1006 return GetMacosAlignedVersion() < MacosVersion(10, 11);
1007 }
1008
MaybeReexec()1009 void MaybeReexec() {
1010 // FIXME: This should really live in some "InitializePlatform" method.
1011 MonotonicNanoTime();
1012
1013 if (ReexecDisabled()) return;
1014
1015 // Make sure the dynamic runtime library is preloaded so that the
1016 // wrappers work. If it is not, set DYLD_INSERT_LIBRARIES and re-exec
1017 // ourselves.
1018 Dl_info info;
1019 RAW_CHECK(dladdr((void*)((uptr)&__sanitizer_report_error_summary), &info));
1020 char *dyld_insert_libraries =
1021 const_cast<char*>(GetEnv(kDyldInsertLibraries));
1022 uptr old_env_len = dyld_insert_libraries ?
1023 internal_strlen(dyld_insert_libraries) : 0;
1024 uptr fname_len = internal_strlen(info.dli_fname);
1025 const char *dylib_name = StripModuleName(info.dli_fname);
1026 uptr dylib_name_len = internal_strlen(dylib_name);
1027
1028 bool lib_is_in_env = dyld_insert_libraries &&
1029 internal_strstr(dyld_insert_libraries, dylib_name);
1030 if (DyldNeedsEnvVariable() && !lib_is_in_env) {
1031 // DYLD_INSERT_LIBRARIES is not set or does not contain the runtime
1032 // library.
1033 InternalMmapVector<char> program_name(1024);
1034 uint32_t buf_size = program_name.size();
1035 _NSGetExecutablePath(program_name.data(), &buf_size);
1036 char *new_env = const_cast<char*>(info.dli_fname);
1037 if (dyld_insert_libraries) {
1038 // Append the runtime dylib name to the existing value of
1039 // DYLD_INSERT_LIBRARIES.
1040 new_env = (char*)allocator_for_env.Allocate(old_env_len + fname_len + 2);
1041 internal_strncpy(new_env, dyld_insert_libraries, old_env_len);
1042 new_env[old_env_len] = ':';
1043 // Copy fname_len and add a trailing zero.
1044 internal_strncpy(new_env + old_env_len + 1, info.dli_fname,
1045 fname_len + 1);
1046 // Ok to use setenv() since the wrappers don't depend on the value of
1047 // asan_inited.
1048 setenv(kDyldInsertLibraries, new_env, /*overwrite*/1);
1049 } else {
1050 // Set DYLD_INSERT_LIBRARIES equal to the runtime dylib name.
1051 setenv(kDyldInsertLibraries, info.dli_fname, /*overwrite*/0);
1052 }
1053 VReport(1, "exec()-ing the program with\n");
1054 VReport(1, "%s=%s\n", kDyldInsertLibraries, new_env);
1055 VReport(1, "to enable wrappers.\n");
1056 execv(program_name.data(), *_NSGetArgv());
1057
1058 // We get here only if execv() failed.
1059 Report("ERROR: The process is launched without DYLD_INSERT_LIBRARIES, "
1060 "which is required for the sanitizer to work. We tried to set the "
1061 "environment variable and re-execute itself, but execv() failed, "
1062 "possibly because of sandbox restrictions. Make sure to launch the "
1063 "executable with:\n%s=%s\n", kDyldInsertLibraries, new_env);
1064 RAW_CHECK("execv failed" && 0);
1065 }
1066
1067 // Verify that interceptors really work. We'll use dlsym to locate
1068 // "pthread_create", if interceptors are working, it should really point to
1069 // "wrap_pthread_create" within our own dylib.
1070 Dl_info info_pthread_create;
1071 void *dlopen_addr = dlsym(RTLD_DEFAULT, "pthread_create");
1072 RAW_CHECK(dladdr(dlopen_addr, &info_pthread_create));
1073 if (internal_strcmp(info.dli_fname, info_pthread_create.dli_fname) != 0) {
1074 Report(
1075 "ERROR: Interceptors are not working. This may be because %s is "
1076 "loaded too late (e.g. via dlopen). Please launch the executable "
1077 "with:\n%s=%s\n",
1078 SanitizerToolName, kDyldInsertLibraries, info.dli_fname);
1079 RAW_CHECK("interceptors not installed" && 0);
1080 }
1081
1082 if (!lib_is_in_env)
1083 return;
1084
1085 if (!common_flags()->strip_env)
1086 return;
1087
1088 // DYLD_INSERT_LIBRARIES is set and contains the runtime library. Let's remove
1089 // the dylib from the environment variable, because interceptors are installed
1090 // and we don't want our children to inherit the variable.
1091
1092 uptr env_name_len = internal_strlen(kDyldInsertLibraries);
1093 // Allocate memory to hold the previous env var name, its value, the '='
1094 // sign and the '\0' char.
1095 char *new_env = (char*)allocator_for_env.Allocate(
1096 old_env_len + 2 + env_name_len);
1097 RAW_CHECK(new_env);
1098 internal_memset(new_env, '\0', old_env_len + 2 + env_name_len);
1099 internal_strncpy(new_env, kDyldInsertLibraries, env_name_len);
1100 new_env[env_name_len] = '=';
1101 char *new_env_pos = new_env + env_name_len + 1;
1102
1103 // Iterate over colon-separated pieces of |dyld_insert_libraries|.
1104 char *piece_start = dyld_insert_libraries;
1105 char *piece_end = NULL;
1106 char *old_env_end = dyld_insert_libraries + old_env_len;
1107 do {
1108 if (piece_start[0] == ':') piece_start++;
1109 piece_end = internal_strchr(piece_start, ':');
1110 if (!piece_end) piece_end = dyld_insert_libraries + old_env_len;
1111 if ((uptr)(piece_start - dyld_insert_libraries) > old_env_len) break;
1112 uptr piece_len = piece_end - piece_start;
1113
1114 char *filename_start =
1115 (char *)internal_memrchr(piece_start, '/', piece_len);
1116 uptr filename_len = piece_len;
1117 if (filename_start) {
1118 filename_start += 1;
1119 filename_len = piece_len - (filename_start - piece_start);
1120 } else {
1121 filename_start = piece_start;
1122 }
1123
1124 // If the current piece isn't the runtime library name,
1125 // append it to new_env.
1126 if ((dylib_name_len != filename_len) ||
1127 (internal_memcmp(filename_start, dylib_name, dylib_name_len) != 0)) {
1128 if (new_env_pos != new_env + env_name_len + 1) {
1129 new_env_pos[0] = ':';
1130 new_env_pos++;
1131 }
1132 internal_strncpy(new_env_pos, piece_start, piece_len);
1133 new_env_pos += piece_len;
1134 }
1135 // Move on to the next piece.
1136 piece_start = piece_end;
1137 } while (piece_start < old_env_end);
1138
1139 // Can't use setenv() here, because it requires the allocator to be
1140 // initialized.
1141 // FIXME: instead of filtering DYLD_INSERT_LIBRARIES here, do it in
1142 // a separate function called after InitializeAllocator().
1143 if (new_env_pos == new_env + env_name_len + 1) new_env = NULL;
1144 LeakyResetEnv(kDyldInsertLibraries, new_env);
1145 }
1146 #endif // SANITIZER_GO
1147
GetArgv()1148 char **GetArgv() {
1149 return *_NSGetArgv();
1150 }
1151
1152 #if SANITIZER_IOS && !SANITIZER_IOSSIM
1153 // The task_vm_info struct is normally provided by the macOS SDK, but we need
1154 // fields only available in 10.12+. Declare the struct manually to be able to
1155 // build against older SDKs.
1156 struct __sanitizer_task_vm_info {
1157 mach_vm_size_t virtual_size;
1158 integer_t region_count;
1159 integer_t page_size;
1160 mach_vm_size_t resident_size;
1161 mach_vm_size_t resident_size_peak;
1162 mach_vm_size_t device;
1163 mach_vm_size_t device_peak;
1164 mach_vm_size_t internal;
1165 mach_vm_size_t internal_peak;
1166 mach_vm_size_t external;
1167 mach_vm_size_t external_peak;
1168 mach_vm_size_t reusable;
1169 mach_vm_size_t reusable_peak;
1170 mach_vm_size_t purgeable_volatile_pmap;
1171 mach_vm_size_t purgeable_volatile_resident;
1172 mach_vm_size_t purgeable_volatile_virtual;
1173 mach_vm_size_t compressed;
1174 mach_vm_size_t compressed_peak;
1175 mach_vm_size_t compressed_lifetime;
1176 mach_vm_size_t phys_footprint;
1177 mach_vm_address_t min_address;
1178 mach_vm_address_t max_address;
1179 };
1180 #define __SANITIZER_TASK_VM_INFO_COUNT ((mach_msg_type_number_t) \
1181 (sizeof(__sanitizer_task_vm_info) / sizeof(natural_t)))
1182
GetTaskInfoMaxAddress()1183 static uptr GetTaskInfoMaxAddress() {
1184 __sanitizer_task_vm_info vm_info = {} /* zero initialize */;
1185 mach_msg_type_number_t count = __SANITIZER_TASK_VM_INFO_COUNT;
1186 int err = task_info(mach_task_self(), TASK_VM_INFO, (int *)&vm_info, &count);
1187 return err ? 0 : vm_info.max_address;
1188 }
1189
GetMaxUserVirtualAddress()1190 uptr GetMaxUserVirtualAddress() {
1191 static uptr max_vm = GetTaskInfoMaxAddress();
1192 if (max_vm != 0) {
1193 const uptr ret_value = max_vm - 1;
1194 CHECK_LE(ret_value, SANITIZER_MMAP_RANGE_SIZE);
1195 return ret_value;
1196 }
1197
1198 // xnu cannot provide vm address limit
1199 # if SANITIZER_WORDSIZE == 32
1200 constexpr uptr fallback_max_vm = 0xffe00000 - 1;
1201 # else
1202 constexpr uptr fallback_max_vm = 0x200000000 - 1;
1203 # endif
1204 static_assert(fallback_max_vm <= SANITIZER_MMAP_RANGE_SIZE,
1205 "Max virtual address must be less than mmap range size.");
1206 return fallback_max_vm;
1207 }
1208
1209 #else // !SANITIZER_IOS
1210
GetMaxUserVirtualAddress()1211 uptr GetMaxUserVirtualAddress() {
1212 # if SANITIZER_WORDSIZE == 64
1213 constexpr uptr max_vm = (1ULL << 47) - 1; // 0x00007fffffffffffUL;
1214 # else // SANITIZER_WORDSIZE == 32
1215 static_assert(SANITIZER_WORDSIZE == 32, "Wrong wordsize");
1216 constexpr uptr max_vm = (1ULL << 32) - 1; // 0xffffffff;
1217 # endif
1218 static_assert(max_vm <= SANITIZER_MMAP_RANGE_SIZE,
1219 "Max virtual address must be less than mmap range size.");
1220 return max_vm;
1221 }
1222 #endif
1223
GetMaxVirtualAddress()1224 uptr GetMaxVirtualAddress() {
1225 return GetMaxUserVirtualAddress();
1226 }
1227
MapDynamicShadow(uptr shadow_size_bytes,uptr shadow_scale,uptr min_shadow_base_alignment,uptr & high_mem_end)1228 uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
1229 uptr min_shadow_base_alignment, uptr &high_mem_end) {
1230 const uptr granularity = GetMmapGranularity();
1231 const uptr alignment =
1232 Max<uptr>(granularity << shadow_scale, 1ULL << min_shadow_base_alignment);
1233 const uptr left_padding =
1234 Max<uptr>(granularity, 1ULL << min_shadow_base_alignment);
1235
1236 uptr space_size = shadow_size_bytes + left_padding;
1237
1238 uptr largest_gap_found = 0;
1239 uptr max_occupied_addr = 0;
1240 VReport(2, "FindDynamicShadowStart, space_size = %p\n", space_size);
1241 uptr shadow_start =
1242 FindAvailableMemoryRange(space_size, alignment, granularity,
1243 &largest_gap_found, &max_occupied_addr);
1244 // If the shadow doesn't fit, restrict the address space to make it fit.
1245 if (shadow_start == 0) {
1246 VReport(
1247 2,
1248 "Shadow doesn't fit, largest_gap_found = %p, max_occupied_addr = %p\n",
1249 largest_gap_found, max_occupied_addr);
1250 uptr new_max_vm = RoundDownTo(largest_gap_found << shadow_scale, alignment);
1251 if (new_max_vm < max_occupied_addr) {
1252 Report("Unable to find a memory range for dynamic shadow.\n");
1253 Report(
1254 "space_size = %p, largest_gap_found = %p, max_occupied_addr = %p, "
1255 "new_max_vm = %p\n",
1256 space_size, largest_gap_found, max_occupied_addr, new_max_vm);
1257 CHECK(0 && "cannot place shadow");
1258 }
1259 RestrictMemoryToMaxAddress(new_max_vm);
1260 high_mem_end = new_max_vm - 1;
1261 space_size = (high_mem_end >> shadow_scale) + left_padding;
1262 VReport(2, "FindDynamicShadowStart, space_size = %p\n", space_size);
1263 shadow_start = FindAvailableMemoryRange(space_size, alignment, granularity,
1264 nullptr, nullptr);
1265 if (shadow_start == 0) {
1266 Report("Unable to find a memory range after restricting VM.\n");
1267 CHECK(0 && "cannot place shadow after restricting vm");
1268 }
1269 }
1270 CHECK_NE((uptr)0, shadow_start);
1271 CHECK(IsAligned(shadow_start, alignment));
1272 return shadow_start;
1273 }
1274
MapDynamicShadowAndAliases(uptr shadow_size,uptr alias_size,uptr num_aliases,uptr ring_buffer_size)1275 uptr MapDynamicShadowAndAliases(uptr shadow_size, uptr alias_size,
1276 uptr num_aliases, uptr ring_buffer_size) {
1277 CHECK(false && "HWASan aliasing is unimplemented on Mac");
1278 return 0;
1279 }
1280
FindAvailableMemoryRange(uptr size,uptr alignment,uptr left_padding,uptr * largest_gap_found,uptr * max_occupied_addr)1281 uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,
1282 uptr *largest_gap_found,
1283 uptr *max_occupied_addr) {
1284 typedef vm_region_submap_short_info_data_64_t RegionInfo;
1285 enum { kRegionInfoSize = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64 };
1286 // Start searching for available memory region past PAGEZERO, which is
1287 // 4KB on 32-bit and 4GB on 64-bit.
1288 mach_vm_address_t start_address =
1289 (SANITIZER_WORDSIZE == 32) ? 0x000000001000 : 0x000100000000;
1290
1291 mach_vm_address_t address = start_address;
1292 mach_vm_address_t free_begin = start_address;
1293 kern_return_t kr = KERN_SUCCESS;
1294 if (largest_gap_found) *largest_gap_found = 0;
1295 if (max_occupied_addr) *max_occupied_addr = 0;
1296 while (kr == KERN_SUCCESS) {
1297 mach_vm_size_t vmsize = 0;
1298 natural_t depth = 0;
1299 RegionInfo vminfo;
1300 mach_msg_type_number_t count = kRegionInfoSize;
1301 kr = mach_vm_region_recurse(mach_task_self(), &address, &vmsize, &depth,
1302 (vm_region_info_t)&vminfo, &count);
1303 if (kr == KERN_INVALID_ADDRESS) {
1304 // No more regions beyond "address", consider the gap at the end of VM.
1305 address = GetMaxVirtualAddress() + 1;
1306 vmsize = 0;
1307 } else {
1308 if (max_occupied_addr) *max_occupied_addr = address + vmsize;
1309 }
1310 if (free_begin != address) {
1311 // We found a free region [free_begin..address-1].
1312 uptr gap_start = RoundUpTo((uptr)free_begin + left_padding, alignment);
1313 uptr gap_end = RoundDownTo((uptr)address, alignment);
1314 uptr gap_size = gap_end > gap_start ? gap_end - gap_start : 0;
1315 if (size < gap_size) {
1316 return gap_start;
1317 }
1318
1319 if (largest_gap_found && *largest_gap_found < gap_size) {
1320 *largest_gap_found = gap_size;
1321 }
1322 }
1323 // Move to the next region.
1324 address += vmsize;
1325 free_begin = address;
1326 }
1327
1328 // We looked at all free regions and could not find one large enough.
1329 return 0;
1330 }
1331
1332 // FIXME implement on this platform.
GetMemoryProfile(fill_profile_f cb,uptr * stats,uptr stats_size)1333 void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) { }
1334
DumpAllRegisters(void * context)1335 void SignalContext::DumpAllRegisters(void *context) {
1336 Report("Register values:\n");
1337
1338 ucontext_t *ucontext = (ucontext_t*)context;
1339 # define DUMPREG64(r) \
1340 Printf("%s = 0x%016llx ", #r, ucontext->uc_mcontext->__ss.__ ## r);
1341 # define DUMPREGA64(r) \
1342 Printf(" %s = 0x%016llx ", #r, AARCH64_GET_REG(r));
1343 # define DUMPREG32(r) \
1344 Printf("%s = 0x%08x ", #r, ucontext->uc_mcontext->__ss.__ ## r);
1345 # define DUMPREG_(r) Printf(" "); DUMPREG(r);
1346 # define DUMPREG__(r) Printf(" "); DUMPREG(r);
1347 # define DUMPREG___(r) Printf(" "); DUMPREG(r);
1348
1349 # if defined(__x86_64__)
1350 # define DUMPREG(r) DUMPREG64(r)
1351 DUMPREG(rax); DUMPREG(rbx); DUMPREG(rcx); DUMPREG(rdx); Printf("\n");
1352 DUMPREG(rdi); DUMPREG(rsi); DUMPREG(rbp); DUMPREG(rsp); Printf("\n");
1353 DUMPREG_(r8); DUMPREG_(r9); DUMPREG(r10); DUMPREG(r11); Printf("\n");
1354 DUMPREG(r12); DUMPREG(r13); DUMPREG(r14); DUMPREG(r15); Printf("\n");
1355 # elif defined(__i386__)
1356 # define DUMPREG(r) DUMPREG32(r)
1357 DUMPREG(eax); DUMPREG(ebx); DUMPREG(ecx); DUMPREG(edx); Printf("\n");
1358 DUMPREG(edi); DUMPREG(esi); DUMPREG(ebp); DUMPREG(esp); Printf("\n");
1359 # elif defined(__aarch64__)
1360 # define DUMPREG(r) DUMPREG64(r)
1361 DUMPREG_(x[0]); DUMPREG_(x[1]); DUMPREG_(x[2]); DUMPREG_(x[3]); Printf("\n");
1362 DUMPREG_(x[4]); DUMPREG_(x[5]); DUMPREG_(x[6]); DUMPREG_(x[7]); Printf("\n");
1363 DUMPREG_(x[8]); DUMPREG_(x[9]); DUMPREG(x[10]); DUMPREG(x[11]); Printf("\n");
1364 DUMPREG(x[12]); DUMPREG(x[13]); DUMPREG(x[14]); DUMPREG(x[15]); Printf("\n");
1365 DUMPREG(x[16]); DUMPREG(x[17]); DUMPREG(x[18]); DUMPREG(x[19]); Printf("\n");
1366 DUMPREG(x[20]); DUMPREG(x[21]); DUMPREG(x[22]); DUMPREG(x[23]); Printf("\n");
1367 DUMPREG(x[24]); DUMPREG(x[25]); DUMPREG(x[26]); DUMPREG(x[27]); Printf("\n");
1368 DUMPREG(x[28]); DUMPREGA64(fp); DUMPREGA64(lr); DUMPREGA64(sp); Printf("\n");
1369 # elif defined(__arm__)
1370 # define DUMPREG(r) DUMPREG32(r)
1371 DUMPREG_(r[0]); DUMPREG_(r[1]); DUMPREG_(r[2]); DUMPREG_(r[3]); Printf("\n");
1372 DUMPREG_(r[4]); DUMPREG_(r[5]); DUMPREG_(r[6]); DUMPREG_(r[7]); Printf("\n");
1373 DUMPREG_(r[8]); DUMPREG_(r[9]); DUMPREG(r[10]); DUMPREG(r[11]); Printf("\n");
1374 DUMPREG(r[12]); DUMPREG___(sp); DUMPREG___(lr); DUMPREG___(pc); Printf("\n");
1375 # else
1376 # error "Unknown architecture"
1377 # endif
1378
1379 # undef DUMPREG64
1380 # undef DUMPREG32
1381 # undef DUMPREG_
1382 # undef DUMPREG__
1383 # undef DUMPREG___
1384 # undef DUMPREG
1385 }
1386
CompareBaseAddress(const LoadedModule & a,const LoadedModule & b)1387 static inline bool CompareBaseAddress(const LoadedModule &a,
1388 const LoadedModule &b) {
1389 return a.base_address() < b.base_address();
1390 }
1391
FormatUUID(char * out,uptr size,const u8 * uuid)1392 void FormatUUID(char *out, uptr size, const u8 *uuid) {
1393 internal_snprintf(out, size,
1394 "<%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-"
1395 "%02X%02X%02X%02X%02X%02X>",
1396 uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5],
1397 uuid[6], uuid[7], uuid[8], uuid[9], uuid[10], uuid[11],
1398 uuid[12], uuid[13], uuid[14], uuid[15]);
1399 }
1400
DumpProcessMap()1401 void DumpProcessMap() {
1402 Printf("Process module map:\n");
1403 MemoryMappingLayout memory_mapping(false);
1404 InternalMmapVector<LoadedModule> modules;
1405 modules.reserve(128);
1406 memory_mapping.DumpListOfModules(&modules);
1407 Sort(modules.data(), modules.size(), CompareBaseAddress);
1408 for (uptr i = 0; i < modules.size(); ++i) {
1409 char uuid_str[128];
1410 FormatUUID(uuid_str, sizeof(uuid_str), modules[i].uuid());
1411 Printf("0x%zx-0x%zx %s (%s) %s\n", modules[i].base_address(),
1412 modules[i].max_executable_address(), modules[i].full_name(),
1413 ModuleArchToString(modules[i].arch()), uuid_str);
1414 }
1415 Printf("End of module map.\n");
1416 }
1417
CheckNoDeepBind(const char * filename,int flag)1418 void CheckNoDeepBind(const char *filename, int flag) {
1419 // Do nothing.
1420 }
1421
GetRandom(void * buffer,uptr length,bool blocking)1422 bool GetRandom(void *buffer, uptr length, bool blocking) {
1423 if (!buffer || !length || length > 256)
1424 return false;
1425 // arc4random never fails.
1426 REAL(arc4random_buf)(buffer, length);
1427 return true;
1428 }
1429
GetNumberOfCPUs()1430 u32 GetNumberOfCPUs() {
1431 return (u32)sysconf(_SC_NPROCESSORS_ONLN);
1432 }
1433
InitializePlatformCommonFlags(CommonFlags * cf)1434 void InitializePlatformCommonFlags(CommonFlags *cf) {}
1435
1436 } // namespace __sanitizer
1437
1438 #endif // SANITIZER_MAC
1439