• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- sanitizer_mac.cc --------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file is shared between various sanitizers' runtime libraries and
11 // implements OSX-specific functions.
12 //===----------------------------------------------------------------------===//
13 
14 #include "sanitizer_platform.h"
15 #if SANITIZER_MAC
16 #include "sanitizer_mac.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_flags.h"
27 #include "sanitizer_internal_defs.h"
28 #include "sanitizer_libc.h"
29 #include "sanitizer_placement_new.h"
30 #include "sanitizer_platform_limits_posix.h"
31 #include "sanitizer_procmaps.h"
32 
33 #if !SANITIZER_IOS
34 #include <crt_externs.h>  // for _NSGetEnviron
35 #else
36 extern char **environ;
37 #endif
38 
39 #if defined(__has_include) && __has_include(<os/trace.h>)
40 #define SANITIZER_OS_TRACE 1
41 #include <os/trace.h>
42 #else
43 #define SANITIZER_OS_TRACE 0
44 #endif
45 
46 #if !SANITIZER_IOS
47 #include <crt_externs.h>  // for _NSGetArgv and _NSGetEnviron
48 #else
49 extern "C" {
50   extern char ***_NSGetArgv(void);
51 }
52 #endif
53 
54 #include <asl.h>
55 #include <dlfcn.h>  // for dladdr()
56 #include <errno.h>
57 #include <fcntl.h>
58 #include <libkern/OSAtomic.h>
59 #include <mach-o/dyld.h>
60 #include <mach/mach.h>
61 #include <mach/vm_statistics.h>
62 #include <pthread.h>
63 #include <sched.h>
64 #include <signal.h>
65 #include <stdlib.h>
66 #include <sys/mman.h>
67 #include <sys/resource.h>
68 #include <sys/stat.h>
69 #include <sys/sysctl.h>
70 #include <sys/types.h>
71 #include <sys/wait.h>
72 #include <unistd.h>
73 #include <util.h>
74 
75 // from <crt_externs.h>, but we don't have that file on iOS
76 extern "C" {
77   extern char ***_NSGetArgv(void);
78   extern char ***_NSGetEnviron(void);
79 }
80 
81 namespace __sanitizer {
82 
83 #include "sanitizer_syscall_generic.inc"
84 
85 // Direct syscalls, don't call libmalloc hooks.
86 extern "C" void *__mmap(void *addr, size_t len, int prot, int flags, int fildes,
87                         off_t off);
88 extern "C" int __munmap(void *, size_t);
89 
90 // ---------------------- sanitizer_libc.h
internal_mmap(void * addr,size_t length,int prot,int flags,int fd,u64 offset)91 uptr internal_mmap(void *addr, size_t length, int prot, int flags,
92                    int fd, u64 offset) {
93   if (fd == -1) fd = VM_MAKE_TAG(VM_MEMORY_ANALYSIS_TOOL);
94   return (uptr)__mmap(addr, length, prot, flags, fd, offset);
95 }
96 
internal_munmap(void * addr,uptr length)97 uptr internal_munmap(void *addr, uptr length) {
98   return __munmap(addr, length);
99 }
100 
internal_mprotect(void * addr,uptr length,int prot)101 int internal_mprotect(void *addr, uptr length, int prot) {
102   return mprotect(addr, length, prot);
103 }
104 
internal_close(fd_t fd)105 uptr internal_close(fd_t fd) {
106   return close(fd);
107 }
108 
internal_open(const char * filename,int flags)109 uptr internal_open(const char *filename, int flags) {
110   return open(filename, flags);
111 }
112 
internal_open(const char * filename,int flags,u32 mode)113 uptr internal_open(const char *filename, int flags, u32 mode) {
114   return open(filename, flags, mode);
115 }
116 
internal_read(fd_t fd,void * buf,uptr count)117 uptr internal_read(fd_t fd, void *buf, uptr count) {
118   return read(fd, buf, count);
119 }
120 
internal_write(fd_t fd,const void * buf,uptr count)121 uptr internal_write(fd_t fd, const void *buf, uptr count) {
122   return write(fd, buf, count);
123 }
124 
internal_stat(const char * path,void * buf)125 uptr internal_stat(const char *path, void *buf) {
126   return stat(path, (struct stat *)buf);
127 }
128 
internal_lstat(const char * path,void * buf)129 uptr internal_lstat(const char *path, void *buf) {
130   return lstat(path, (struct stat *)buf);
131 }
132 
internal_fstat(fd_t fd,void * buf)133 uptr internal_fstat(fd_t fd, void *buf) {
134   return fstat(fd, (struct stat *)buf);
135 }
136 
internal_filesize(fd_t fd)137 uptr internal_filesize(fd_t fd) {
138   struct stat st;
139   if (internal_fstat(fd, &st))
140     return -1;
141   return (uptr)st.st_size;
142 }
143 
internal_dup2(int oldfd,int newfd)144 uptr internal_dup2(int oldfd, int newfd) {
145   return dup2(oldfd, newfd);
146 }
147 
internal_readlink(const char * path,char * buf,uptr bufsize)148 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
149   return readlink(path, buf, bufsize);
150 }
151 
internal_unlink(const char * path)152 uptr internal_unlink(const char *path) {
153   return unlink(path);
154 }
155 
internal_sched_yield()156 uptr internal_sched_yield() {
157   return sched_yield();
158 }
159 
internal__exit(int exitcode)160 void internal__exit(int exitcode) {
161   _exit(exitcode);
162 }
163 
internal_sleep(unsigned int seconds)164 unsigned int internal_sleep(unsigned int seconds) {
165   return sleep(seconds);
166 }
167 
internal_getpid()168 uptr internal_getpid() {
169   return getpid();
170 }
171 
internal_sigaction(int signum,const void * act,void * oldact)172 int internal_sigaction(int signum, const void *act, void *oldact) {
173   return sigaction(signum,
174                    (struct sigaction *)act, (struct sigaction *)oldact);
175 }
176 
internal_sigfillset(__sanitizer_sigset_t * set)177 void internal_sigfillset(__sanitizer_sigset_t *set) { sigfillset(set); }
178 
internal_sigprocmask(int how,__sanitizer_sigset_t * set,__sanitizer_sigset_t * oldset)179 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
180                           __sanitizer_sigset_t *oldset) {
181   return sigprocmask(how, set, oldset);
182 }
183 
184 // Doesn't call pthread_atfork() handlers.
185 extern "C" pid_t __fork(void);
186 
internal_fork()187 int internal_fork() {
188   return __fork();
189 }
190 
internal_forkpty(int * amaster)191 int internal_forkpty(int *amaster) {
192   int master, slave;
193   if (openpty(&master, &slave, nullptr, nullptr, nullptr) == -1) return -1;
194   int pid = __fork();
195   if (pid == -1) {
196     close(master);
197     close(slave);
198     return -1;
199   }
200   if (pid == 0) {
201     close(master);
202     if (login_tty(slave) != 0) {
203       // We already forked, there's not much we can do.  Let's quit.
204       Report("login_tty failed (errno %d)\n", errno);
205       internal__exit(1);
206     }
207   } else {
208     *amaster = master;
209     close(slave);
210   }
211   return pid;
212 }
213 
internal_rename(const char * oldpath,const char * newpath)214 uptr internal_rename(const char *oldpath, const char *newpath) {
215   return rename(oldpath, newpath);
216 }
217 
internal_ftruncate(fd_t fd,uptr size)218 uptr internal_ftruncate(fd_t fd, uptr size) {
219   return ftruncate(fd, size);
220 }
221 
internal_execve(const char * filename,char * const argv[],char * const envp[])222 uptr internal_execve(const char *filename, char *const argv[],
223                      char *const envp[]) {
224   return execve(filename, argv, envp);
225 }
226 
internal_waitpid(int pid,int * status,int options)227 uptr internal_waitpid(int pid, int *status, int options) {
228   return waitpid(pid, status, options);
229 }
230 
231 // ----------------- sanitizer_common.h
FileExists(const char * filename)232 bool FileExists(const char *filename) {
233   struct stat st;
234   if (stat(filename, &st))
235     return false;
236   // Sanity check: filename is a regular file.
237   return S_ISREG(st.st_mode);
238 }
239 
GetTid()240 uptr GetTid() {
241   // FIXME: This can potentially get truncated on 32-bit, where uptr is 4 bytes.
242   uint64_t tid;
243   pthread_threadid_np(nullptr, &tid);
244   return tid;
245 }
246 
GetThreadStackTopAndBottom(bool at_initialization,uptr * stack_top,uptr * stack_bottom)247 void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
248                                 uptr *stack_bottom) {
249   CHECK(stack_top);
250   CHECK(stack_bottom);
251   uptr stacksize = pthread_get_stacksize_np(pthread_self());
252   // pthread_get_stacksize_np() returns an incorrect stack size for the main
253   // thread on Mavericks. See
254   // https://github.com/google/sanitizers/issues/261
255   if ((GetMacosVersion() >= MACOS_VERSION_MAVERICKS) && at_initialization &&
256       stacksize == (1 << 19))  {
257     struct rlimit rl;
258     CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
259     // Most often rl.rlim_cur will be the desired 8M.
260     if (rl.rlim_cur < kMaxThreadStackSize) {
261       stacksize = rl.rlim_cur;
262     } else {
263       stacksize = kMaxThreadStackSize;
264     }
265   }
266   void *stackaddr = pthread_get_stackaddr_np(pthread_self());
267   *stack_top = (uptr)stackaddr;
268   *stack_bottom = *stack_top - stacksize;
269 }
270 
GetEnviron()271 char **GetEnviron() {
272 #if !SANITIZER_IOS
273   char ***env_ptr = _NSGetEnviron();
274   if (!env_ptr) {
275     Report("_NSGetEnviron() returned NULL. Please make sure __asan_init() is "
276            "called after libSystem_initializer().\n");
277     CHECK(env_ptr);
278   }
279   char **environ = *env_ptr;
280 #endif
281   CHECK(environ);
282   return environ;
283 }
284 
GetEnv(const char * name)285 const char *GetEnv(const char *name) {
286   char **env = GetEnviron();
287   uptr name_len = internal_strlen(name);
288   while (*env != 0) {
289     uptr len = internal_strlen(*env);
290     if (len > name_len) {
291       const char *p = *env;
292       if (!internal_memcmp(p, name, name_len) &&
293           p[name_len] == '=') {  // Match.
294         return *env + name_len + 1;  // String starting after =.
295       }
296     }
297     env++;
298   }
299   return 0;
300 }
301 
ReadBinaryName(char * buf,uptr buf_len)302 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
303   CHECK_LE(kMaxPathLength, buf_len);
304 
305   // On OS X the executable path is saved to the stack by dyld. Reading it
306   // from there is much faster than calling dladdr, especially for large
307   // binaries with symbols.
308   InternalScopedString exe_path(kMaxPathLength);
309   uint32_t size = exe_path.size();
310   if (_NSGetExecutablePath(exe_path.data(), &size) == 0 &&
311       realpath(exe_path.data(), buf) != 0) {
312     return internal_strlen(buf);
313   }
314   return 0;
315 }
316 
ReadLongProcessName(char * buf,uptr buf_len)317 uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) {
318   return ReadBinaryName(buf, buf_len);
319 }
320 
ReExec()321 void ReExec() {
322   UNIMPLEMENTED();
323 }
324 
GetPageSize()325 uptr GetPageSize() {
326   return sysconf(_SC_PAGESIZE);
327 }
328 
BlockingMutex()329 BlockingMutex::BlockingMutex() {
330   internal_memset(this, 0, sizeof(*this));
331 }
332 
Lock()333 void BlockingMutex::Lock() {
334   CHECK(sizeof(OSSpinLock) <= sizeof(opaque_storage_));
335   CHECK_EQ(OS_SPINLOCK_INIT, 0);
336   CHECK_NE(owner_, (uptr)pthread_self());
337   OSSpinLockLock((OSSpinLock*)&opaque_storage_);
338   CHECK(!owner_);
339   owner_ = (uptr)pthread_self();
340 }
341 
Unlock()342 void BlockingMutex::Unlock() {
343   CHECK(owner_ == (uptr)pthread_self());
344   owner_ = 0;
345   OSSpinLockUnlock((OSSpinLock*)&opaque_storage_);
346 }
347 
CheckLocked()348 void BlockingMutex::CheckLocked() {
349   CHECK_EQ((uptr)pthread_self(), owner_);
350 }
351 
NanoTime()352 u64 NanoTime() {
353   return 0;
354 }
355 
GetTlsSize()356 uptr GetTlsSize() {
357   return 0;
358 }
359 
InitTlsSize()360 void InitTlsSize() {
361 }
362 
GetThreadStackAndTls(bool main,uptr * stk_addr,uptr * stk_size,uptr * tls_addr,uptr * tls_size)363 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
364                           uptr *tls_addr, uptr *tls_size) {
365 #ifndef SANITIZER_GO
366   uptr stack_top, stack_bottom;
367   GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
368   *stk_addr = stack_bottom;
369   *stk_size = stack_top - stack_bottom;
370   *tls_addr = 0;
371   *tls_size = 0;
372 #else
373   *stk_addr = 0;
374   *stk_size = 0;
375   *tls_addr = 0;
376   *tls_size = 0;
377 #endif
378 }
379 
init()380 void ListOfModules::init() {
381   clear();
382   MemoryMappingLayout memory_mapping(false);
383   memory_mapping.DumpListOfModules(&modules_);
384 }
385 
IsHandledDeadlySignal(int signum)386 bool IsHandledDeadlySignal(int signum) {
387   if ((SANITIZER_WATCHOS || SANITIZER_TVOS) && !(SANITIZER_IOSSIM))
388     // Handling fatal signals on watchOS and tvOS devices is disallowed.
389     return false;
390   return (signum == SIGSEGV || signum == SIGBUS) && common_flags()->handle_segv;
391 }
392 
393 MacosVersion cached_macos_version = MACOS_VERSION_UNINITIALIZED;
394 
GetMacosVersionInternal()395 MacosVersion GetMacosVersionInternal() {
396   int mib[2] = { CTL_KERN, KERN_OSRELEASE };
397   char version[100];
398   uptr len = 0, maxlen = sizeof(version) / sizeof(version[0]);
399   for (uptr i = 0; i < maxlen; i++) version[i] = '\0';
400   // Get the version length.
401   CHECK_NE(sysctl(mib, 2, 0, &len, 0, 0), -1);
402   CHECK_LT(len, maxlen);
403   CHECK_NE(sysctl(mib, 2, version, &len, 0, 0), -1);
404   switch (version[0]) {
405     case '9': return MACOS_VERSION_LEOPARD;
406     case '1': {
407       switch (version[1]) {
408         case '0': return MACOS_VERSION_SNOW_LEOPARD;
409         case '1': return MACOS_VERSION_LION;
410         case '2': return MACOS_VERSION_MOUNTAIN_LION;
411         case '3': return MACOS_VERSION_MAVERICKS;
412         case '4': return MACOS_VERSION_YOSEMITE;
413         default:
414           if (IsDigit(version[1]))
415             return MACOS_VERSION_UNKNOWN_NEWER;
416           else
417             return MACOS_VERSION_UNKNOWN;
418       }
419     }
420     default: return MACOS_VERSION_UNKNOWN;
421   }
422 }
423 
GetMacosVersion()424 MacosVersion GetMacosVersion() {
425   atomic_uint32_t *cache =
426       reinterpret_cast<atomic_uint32_t*>(&cached_macos_version);
427   MacosVersion result =
428       static_cast<MacosVersion>(atomic_load(cache, memory_order_acquire));
429   if (result == MACOS_VERSION_UNINITIALIZED) {
430     result = GetMacosVersionInternal();
431     atomic_store(cache, result, memory_order_release);
432   }
433   return result;
434 }
435 
GetRSS()436 uptr GetRSS() {
437   struct task_basic_info info;
438   unsigned count = TASK_BASIC_INFO_COUNT;
439   kern_return_t result =
440       task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count);
441   if (UNLIKELY(result != KERN_SUCCESS)) {
442     Report("Cannot get task info. Error: %d\n", result);
443     Die();
444   }
445   return info.resident_size;
446 }
447 
internal_start_thread(void (* func)(void * arg),void * arg)448 void *internal_start_thread(void(*func)(void *arg), void *arg) {
449   // Start the thread with signals blocked, otherwise it can steal user signals.
450   __sanitizer_sigset_t set, old;
451   internal_sigfillset(&set);
452   internal_sigprocmask(SIG_SETMASK, &set, &old);
453   pthread_t th;
454   pthread_create(&th, 0, (void*(*)(void *arg))func, arg);
455   internal_sigprocmask(SIG_SETMASK, &old, 0);
456   return th;
457 }
458 
internal_join_thread(void * th)459 void internal_join_thread(void *th) { pthread_join((pthread_t)th, 0); }
460 
461 #ifndef SANITIZER_GO
462 static BlockingMutex syslog_lock(LINKER_INITIALIZED);
463 #endif
464 
WriteOneLineToSyslog(const char * s)465 void WriteOneLineToSyslog(const char *s) {
466 #ifndef SANITIZER_GO
467   syslog_lock.CheckLocked();
468   asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", s);
469 #endif
470 }
471 
LogMessageOnPrintf(const char * str)472 void LogMessageOnPrintf(const char *str) {
473   // Log all printf output to CrashLog.
474   if (common_flags()->abort_on_error)
475     CRAppendCrashLogMessage(str);
476 }
477 
LogFullErrorReport(const char * buffer)478 void LogFullErrorReport(const char *buffer) {
479 #ifndef SANITIZER_GO
480   // Log with os_trace. This will make it into the crash log.
481 #if SANITIZER_OS_TRACE
482   if (GetMacosVersion() >= MACOS_VERSION_YOSEMITE) {
483     // os_trace requires the message (format parameter) to be a string literal.
484     if (internal_strncmp(SanitizerToolName, "AddressSanitizer",
485                          sizeof("AddressSanitizer") - 1) == 0)
486       os_trace("Address Sanitizer reported a failure.");
487     else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",
488                               sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
489       os_trace("Undefined Behavior Sanitizer reported a failure.");
490     else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",
491                               sizeof("ThreadSanitizer") - 1) == 0)
492       os_trace("Thread Sanitizer reported a failure.");
493     else
494       os_trace("Sanitizer tool reported a failure.");
495 
496     if (common_flags()->log_to_syslog)
497       os_trace("Consult syslog for more information.");
498   }
499 #endif
500 
501   // Log to syslog.
502   // The logging on OS X may call pthread_create so we need the threading
503   // environment to be fully initialized. Also, this should never be called when
504   // holding the thread registry lock since that may result in a deadlock. If
505   // the reporting thread holds the thread registry mutex, and asl_log waits
506   // for GCD to dispatch a new thread, the process will deadlock, because the
507   // pthread_create wrapper needs to acquire the lock as well.
508   BlockingMutexLock l(&syslog_lock);
509   if (common_flags()->log_to_syslog)
510     WriteToSyslog(buffer);
511 
512   // The report is added to CrashLog as part of logging all of Printf output.
513 #endif
514 }
515 
GetWriteFlag(void * context)516 SignalContext::WriteFlag SignalContext::GetWriteFlag(void *context) {
517 #if defined(__x86_64__) || defined(__i386__)
518   ucontext_t *ucontext = static_cast<ucontext_t*>(context);
519   return ucontext->uc_mcontext->__es.__err & 2 /*T_PF_WRITE*/ ? WRITE : READ;
520 #else
521   return UNKNOWN;
522 #endif
523 }
524 
GetPcSpBp(void * context,uptr * pc,uptr * sp,uptr * bp)525 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
526   ucontext_t *ucontext = (ucontext_t*)context;
527 # if defined(__aarch64__)
528   *pc = ucontext->uc_mcontext->__ss.__pc;
529 #   if defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_8_0
530   *bp = ucontext->uc_mcontext->__ss.__fp;
531 #   else
532   *bp = ucontext->uc_mcontext->__ss.__lr;
533 #   endif
534   *sp = ucontext->uc_mcontext->__ss.__sp;
535 # elif defined(__x86_64__)
536   *pc = ucontext->uc_mcontext->__ss.__rip;
537   *bp = ucontext->uc_mcontext->__ss.__rbp;
538   *sp = ucontext->uc_mcontext->__ss.__rsp;
539 # elif defined(__arm__)
540   *pc = ucontext->uc_mcontext->__ss.__pc;
541   *bp = ucontext->uc_mcontext->__ss.__r[7];
542   *sp = ucontext->uc_mcontext->__ss.__sp;
543 # elif defined(__i386__)
544   *pc = ucontext->uc_mcontext->__ss.__eip;
545   *bp = ucontext->uc_mcontext->__ss.__ebp;
546   *sp = ucontext->uc_mcontext->__ss.__esp;
547 # else
548 # error "Unknown architecture"
549 # endif
550 }
551 
552 #ifndef SANITIZER_GO
553 static const char kDyldInsertLibraries[] = "DYLD_INSERT_LIBRARIES";
554 LowLevelAllocator allocator_for_env;
555 
556 // Change the value of the env var |name|, leaking the original value.
557 // If |name_value| is NULL, the variable is deleted from the environment,
558 // otherwise the corresponding "NAME=value" string is replaced with
559 // |name_value|.
LeakyResetEnv(const char * name,const char * name_value)560 void LeakyResetEnv(const char *name, const char *name_value) {
561   char **env = GetEnviron();
562   uptr name_len = internal_strlen(name);
563   while (*env != 0) {
564     uptr len = internal_strlen(*env);
565     if (len > name_len) {
566       const char *p = *env;
567       if (!internal_memcmp(p, name, name_len) && p[name_len] == '=') {
568         // Match.
569         if (name_value) {
570           // Replace the old value with the new one.
571           *env = const_cast<char*>(name_value);
572         } else {
573           // Shift the subsequent pointers back.
574           char **del = env;
575           do {
576             del[0] = del[1];
577           } while (*del++);
578         }
579       }
580     }
581     env++;
582   }
583 }
584 
585 SANITIZER_WEAK_CXX_DEFAULT_IMPL
ReexecDisabled()586 bool ReexecDisabled() {
587   return false;
588 }
589 
590 extern "C" SANITIZER_WEAK_ATTRIBUTE double dyldVersionNumber;
591 static const double kMinDyldVersionWithAutoInterposition = 360.0;
592 
DyldNeedsEnvVariable()593 bool DyldNeedsEnvVariable() {
594   // Although sanitizer support was added to LLVM on OS X 10.7+, GCC users
595   // still may want use them on older systems. On older Darwin platforms, dyld
596   // doesn't export dyldVersionNumber symbol and we simply return true.
597   if (!&dyldVersionNumber) return true;
598   // If running on OS X 10.11+ or iOS 9.0+, dyld will interpose even if
599   // DYLD_INSERT_LIBRARIES is not set. However, checking OS version via
600   // GetMacosVersion() doesn't work for the simulator. Let's instead check
601   // `dyldVersionNumber`, which is exported by dyld, against a known version
602   // number from the first OS release where this appeared.
603   return dyldVersionNumber < kMinDyldVersionWithAutoInterposition;
604 }
605 
MaybeReexec()606 void MaybeReexec() {
607   if (ReexecDisabled()) return;
608 
609   // Make sure the dynamic runtime library is preloaded so that the
610   // wrappers work. If it is not, set DYLD_INSERT_LIBRARIES and re-exec
611   // ourselves.
612   Dl_info info;
613   RAW_CHECK(dladdr((void*)((uptr)&__sanitizer_report_error_summary), &info));
614   char *dyld_insert_libraries =
615       const_cast<char*>(GetEnv(kDyldInsertLibraries));
616   uptr old_env_len = dyld_insert_libraries ?
617       internal_strlen(dyld_insert_libraries) : 0;
618   uptr fname_len = internal_strlen(info.dli_fname);
619   const char *dylib_name = StripModuleName(info.dli_fname);
620   uptr dylib_name_len = internal_strlen(dylib_name);
621 
622   bool lib_is_in_env = dyld_insert_libraries &&
623                        internal_strstr(dyld_insert_libraries, dylib_name);
624   if (DyldNeedsEnvVariable() && !lib_is_in_env) {
625     // DYLD_INSERT_LIBRARIES is not set or does not contain the runtime
626     // library.
627     InternalScopedString program_name(1024);
628     uint32_t buf_size = program_name.size();
629     _NSGetExecutablePath(program_name.data(), &buf_size);
630     char *new_env = const_cast<char*>(info.dli_fname);
631     if (dyld_insert_libraries) {
632       // Append the runtime dylib name to the existing value of
633       // DYLD_INSERT_LIBRARIES.
634       new_env = (char*)allocator_for_env.Allocate(old_env_len + fname_len + 2);
635       internal_strncpy(new_env, dyld_insert_libraries, old_env_len);
636       new_env[old_env_len] = ':';
637       // Copy fname_len and add a trailing zero.
638       internal_strncpy(new_env + old_env_len + 1, info.dli_fname,
639                        fname_len + 1);
640       // Ok to use setenv() since the wrappers don't depend on the value of
641       // asan_inited.
642       setenv(kDyldInsertLibraries, new_env, /*overwrite*/1);
643     } else {
644       // Set DYLD_INSERT_LIBRARIES equal to the runtime dylib name.
645       setenv(kDyldInsertLibraries, info.dli_fname, /*overwrite*/0);
646     }
647     VReport(1, "exec()-ing the program with\n");
648     VReport(1, "%s=%s\n", kDyldInsertLibraries, new_env);
649     VReport(1, "to enable wrappers.\n");
650     execv(program_name.data(), *_NSGetArgv());
651 
652     // We get here only if execv() failed.
653     Report("ERROR: The process is launched without DYLD_INSERT_LIBRARIES, "
654            "which is required for the sanitizer to work. We tried to set the "
655            "environment variable and re-execute itself, but execv() failed, "
656            "possibly because of sandbox restrictions. Make sure to launch the "
657            "executable with:\n%s=%s\n", kDyldInsertLibraries, new_env);
658     RAW_CHECK("execv failed" && 0);
659   }
660 
661   // Verify that interceptors really work.  We'll use dlsym to locate
662   // "pthread_create", if interceptors are working, it should really point to
663   // "wrap_pthread_create" within our own dylib.
664   Dl_info info_pthread_create;
665   void *dlopen_addr = dlsym(RTLD_DEFAULT, "pthread_create");
666   RAW_CHECK(dladdr(dlopen_addr, &info_pthread_create));
667   if (internal_strcmp(info.dli_fname, info_pthread_create.dli_fname) != 0) {
668     Report(
669         "ERROR: Interceptors are not working. This may be because %s is "
670         "loaded too late (e.g. via dlopen). Please launch the executable "
671         "with:\n%s=%s\n",
672         SanitizerToolName, kDyldInsertLibraries, info.dli_fname);
673     RAW_CHECK("interceptors not installed" && 0);
674   }
675 
676   if (!lib_is_in_env)
677     return;
678 
679   // DYLD_INSERT_LIBRARIES is set and contains the runtime library. Let's remove
680   // the dylib from the environment variable, because interceptors are installed
681   // and we don't want our children to inherit the variable.
682 
683   uptr env_name_len = internal_strlen(kDyldInsertLibraries);
684   // Allocate memory to hold the previous env var name, its value, the '='
685   // sign and the '\0' char.
686   char *new_env = (char*)allocator_for_env.Allocate(
687       old_env_len + 2 + env_name_len);
688   RAW_CHECK(new_env);
689   internal_memset(new_env, '\0', old_env_len + 2 + env_name_len);
690   internal_strncpy(new_env, kDyldInsertLibraries, env_name_len);
691   new_env[env_name_len] = '=';
692   char *new_env_pos = new_env + env_name_len + 1;
693 
694   // Iterate over colon-separated pieces of |dyld_insert_libraries|.
695   char *piece_start = dyld_insert_libraries;
696   char *piece_end = NULL;
697   char *old_env_end = dyld_insert_libraries + old_env_len;
698   do {
699     if (piece_start[0] == ':') piece_start++;
700     piece_end = internal_strchr(piece_start, ':');
701     if (!piece_end) piece_end = dyld_insert_libraries + old_env_len;
702     if ((uptr)(piece_start - dyld_insert_libraries) > old_env_len) break;
703     uptr piece_len = piece_end - piece_start;
704 
705     char *filename_start =
706         (char *)internal_memrchr(piece_start, '/', piece_len);
707     uptr filename_len = piece_len;
708     if (filename_start) {
709       filename_start += 1;
710       filename_len = piece_len - (filename_start - piece_start);
711     } else {
712       filename_start = piece_start;
713     }
714 
715     // If the current piece isn't the runtime library name,
716     // append it to new_env.
717     if ((dylib_name_len != filename_len) ||
718         (internal_memcmp(filename_start, dylib_name, dylib_name_len) != 0)) {
719       if (new_env_pos != new_env + env_name_len + 1) {
720         new_env_pos[0] = ':';
721         new_env_pos++;
722       }
723       internal_strncpy(new_env_pos, piece_start, piece_len);
724       new_env_pos += piece_len;
725     }
726     // Move on to the next piece.
727     piece_start = piece_end;
728   } while (piece_start < old_env_end);
729 
730   // Can't use setenv() here, because it requires the allocator to be
731   // initialized.
732   // FIXME: instead of filtering DYLD_INSERT_LIBRARIES here, do it in
733   // a separate function called after InitializeAllocator().
734   if (new_env_pos == new_env + env_name_len + 1) new_env = NULL;
735   LeakyResetEnv(kDyldInsertLibraries, new_env);
736 }
737 #endif  // SANITIZER_GO
738 
GetArgv()739 char **GetArgv() {
740   return *_NSGetArgv();
741 }
742 
743 }  // namespace __sanitizer
744 
745 #endif  // SANITIZER_MAC
746