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 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 140 uptr internal_munmap(void *addr, uptr length) { 141 if (&__munmap) return __munmap(addr, length); 142 return munmap(addr, length); 143 } 144 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 151 int internal_mprotect(void *addr, uptr length, int prot) { 152 return mprotect(addr, length, prot); 153 } 154 155 int internal_madvise(uptr addr, uptr length, int advice) { 156 return madvise((void *)addr, length, advice); 157 } 158 159 uptr internal_close(fd_t fd) { 160 return close(fd); 161 } 162 163 uptr internal_open(const char *filename, int flags) { 164 return open(filename, flags); 165 } 166 167 uptr internal_open(const char *filename, int flags, u32 mode) { 168 return open(filename, flags, mode); 169 } 170 171 uptr internal_read(fd_t fd, void *buf, uptr count) { 172 return read(fd, buf, count); 173 } 174 175 uptr internal_write(fd_t fd, const void *buf, uptr count) { 176 return write(fd, buf, count); 177 } 178 179 uptr internal_stat(const char *path, void *buf) { 180 return stat(path, (struct stat *)buf); 181 } 182 183 uptr internal_lstat(const char *path, void *buf) { 184 return lstat(path, (struct stat *)buf); 185 } 186 187 uptr internal_fstat(fd_t fd, void *buf) { 188 return fstat(fd, (struct stat *)buf); 189 } 190 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 198 uptr internal_dup(int oldfd) { 199 return dup(oldfd); 200 } 201 202 uptr internal_dup2(int oldfd, int newfd) { 203 return dup2(oldfd, newfd); 204 } 205 206 uptr internal_readlink(const char *path, char *buf, uptr bufsize) { 207 return readlink(path, buf, bufsize); 208 } 209 210 uptr internal_unlink(const char *path) { 211 return unlink(path); 212 } 213 214 uptr internal_sched_yield() { 215 return sched_yield(); 216 } 217 218 void internal__exit(int exitcode) { 219 _exit(exitcode); 220 } 221 222 void internal_usleep(u64 useconds) { usleep(useconds); } 223 224 uptr internal_getpid() { 225 return getpid(); 226 } 227 228 int internal_dlinfo(void *handle, int request, void *p) { 229 UNIMPLEMENTED(); 230 } 231 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 237 void internal_sigfillset(__sanitizer_sigset_t *set) { sigfillset(set); } 238 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 248 int internal_fork() { 249 if (&__fork) 250 return __fork(); 251 return fork(); 252 } 253 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 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 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 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 365 uptr internal_rename(const char *oldpath, const char *newpath) { 366 return rename(oldpath, newpath); 367 } 368 369 uptr internal_ftruncate(fd_t fd, uptr size) { 370 return ftruncate(fd, size); 371 } 372 373 uptr internal_execve(const char *filename, char *const argv[], 374 char *const envp[]) { 375 return execve(filename, argv, envp); 376 } 377 378 uptr internal_waitpid(int pid, int *status, int options) { 379 return waitpid(pid, status, options); 380 } 381 382 // ----------------- sanitizer_common.h 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 393 tid_t GetTid() { 394 tid_t tid; 395 pthread_threadid_np(nullptr, &tid); 396 return tid; 397 } 398 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 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 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 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 469 uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) { 470 return ReadBinaryName(buf, buf_len); 471 } 472 473 void ReExec() { 474 UNIMPLEMENTED(); 475 } 476 477 void CheckASLR() { 478 // Do nothing 479 } 480 481 void CheckMPROTECT() { 482 // Do nothing 483 } 484 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. 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 512 void FutexWait(atomic_uint32_t *p, u32 cmp) { 513 // FIXME: implement actual blocking. 514 sched_yield(); 515 } 516 517 void FutexWake(atomic_uint32_t *p, u32 count) {} 518 519 BlockingMutex::BlockingMutex() { 520 internal_memset(this, 0, sizeof(*this)); 521 } 522 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 530 void BlockingMutex::Unlock() { 531 OSSpinLockUnlock((OSSpinLock*)&opaque_storage_); 532 } 533 534 void BlockingMutex::CheckLocked() const { 535 CHECK_NE(*(const OSSpinLock*)&opaque_storage_, 0); 536 } 537 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. 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 552 uptr GetTlsSize() { 553 return 0; 554 } 555 556 void InitTlsSize() { 557 } 558 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. 572 uptr TlsSize() { 573 #if defined(__x86_64__) || defined(__i386__) 574 return 1024 * sizeof(uptr); 575 #else 576 return 0; 577 #endif 578 } 579 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 597 void ListOfModules::init() { 598 clearOrInit(); 599 MemoryMappingLayout memory_mapping(false); 600 memory_mapping.DumpListOfModules(&modules_); 601 } 602 603 void ListOfModules::fallbackInit() { clear(); } 604 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 885 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 894 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 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 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+). 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 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|. 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 999 bool ReexecDisabled() { 1000 return false; 1001 } 1002 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 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 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 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 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 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 1224 uptr GetMaxVirtualAddress() { 1225 return GetMaxUserVirtualAddress(); 1226 } 1227 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 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 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. 1333 void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) { } 1334 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 1387 static inline bool CompareBaseAddress(const LoadedModule &a, 1388 const LoadedModule &b) { 1389 return a.base_address() < b.base_address(); 1390 } 1391 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 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 1418 void CheckNoDeepBind(const char *filename, int flag) { 1419 // Do nothing. 1420 } 1421 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 1430 u32 GetNumberOfCPUs() { 1431 return (u32)sysconf(_SC_NPROCESSORS_ONLN); 1432 } 1433 1434 void InitializePlatformCommonFlags(CommonFlags *cf) {} 1435 1436 } // namespace __sanitizer 1437 1438 #endif // SANITIZER_MAC 1439