1 //===-- sanitizer_linux.cc ------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file is shared between AddressSanitizer and ThreadSanitizer
11 // run-time libraries and implements linux-specific functions from
13 //===----------------------------------------------------------------------===//
15 #include "sanitizer_platform.h"
16 #if SANITIZER_FREEBSD || SANITIZER_LINUX
18 #include "sanitizer_common.h"
19 #include "sanitizer_flags.h"
20 #include "sanitizer_internal_defs.h"
21 #include "sanitizer_libc.h"
22 #include "sanitizer_linux.h"
23 #include "sanitizer_mutex.h"
24 #include "sanitizer_placement_new.h"
25 #include "sanitizer_procmaps.h"
26 #include "sanitizer_stacktrace.h"
27 #include "sanitizer_symbolizer.h"
29 #if !SANITIZER_FREEBSD
30 #include <asm/param.h>
36 #if !SANITIZER_ANDROID
42 #include <sys/ptrace.h>
43 #include <sys/resource.h>
45 #include <sys/syscall.h>
47 #include <sys/types.h>
51 #include <sys/sysctl.h>
52 #include <machine/atomic.h>
54 // <sys/umtx.h> must be included after <errno.h> and <sys/types.h> on
55 // FreeBSD 9.2 and 10.0.
58 extern char **environ
; // provided by crt1
59 #endif // SANITIZER_FREEBSD
61 #if !SANITIZER_ANDROID
62 #include <sys/signal.h>
66 #include <android/log.h>
67 #include <sys/system_properties.h>
72 struct kernel_timeval
{
77 // <linux/futex.h> is broken on some linux distributions.
78 const int FUTEX_WAIT
= 0;
79 const int FUTEX_WAKE
= 1;
80 #endif // SANITIZER_LINUX
82 // Are we using 32-bit or 64-bit Linux syscalls?
83 // x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32
84 // but it still needs to use 64-bit syscalls.
85 #if SANITIZER_LINUX && (defined(__x86_64__) || SANITIZER_WORDSIZE == 64)
86 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
88 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
91 namespace __sanitizer
{
93 #if SANITIZER_LINUX && defined(__x86_64__)
94 #include "sanitizer_syscall_linux_x86_64.inc"
96 #include "sanitizer_syscall_generic.inc"
99 // --------------- sanitizer_libc.h
100 uptr
internal_mmap(void *addr
, uptr length
, int prot
, int flags
,
101 int fd
, u64 offset
) {
102 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
103 return internal_syscall(SYSCALL(mmap
), (uptr
)addr
, length
, prot
, flags
, fd
,
106 return internal_syscall(SYSCALL(mmap2
), addr
, length
, prot
, flags
, fd
,
111 uptr
internal_munmap(void *addr
, uptr length
) {
112 return internal_syscall(SYSCALL(munmap
), (uptr
)addr
, length
);
115 uptr
internal_close(fd_t fd
) {
116 return internal_syscall(SYSCALL(close
), fd
);
119 uptr
internal_open(const char *filename
, int flags
) {
120 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
121 return internal_syscall(SYSCALL(openat
), AT_FDCWD
, (uptr
)filename
, flags
);
123 return internal_syscall(SYSCALL(open
), (uptr
)filename
, flags
);
127 uptr
internal_open(const char *filename
, int flags
, u32 mode
) {
128 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
129 return internal_syscall(SYSCALL(openat
), AT_FDCWD
, (uptr
)filename
, flags
,
132 return internal_syscall(SYSCALL(open
), (uptr
)filename
, flags
, mode
);
136 uptr
OpenFile(const char *filename
, bool write
) {
137 return internal_open(filename
,
138 write
? O_RDWR
| O_CREAT
/*| O_CLOEXEC*/ : O_RDONLY
, 0660);
141 uptr
internal_read(fd_t fd
, void *buf
, uptr count
) {
143 HANDLE_EINTR(res
, (sptr
)internal_syscall(SYSCALL(read
), fd
, (uptr
)buf
,
148 uptr
internal_write(fd_t fd
, const void *buf
, uptr count
) {
150 HANDLE_EINTR(res
, (sptr
)internal_syscall(SYSCALL(write
), fd
, (uptr
)buf
,
155 uptr
internal_ftruncate(fd_t fd
, uptr size
) {
157 HANDLE_EINTR(res
, (sptr
)internal_syscall(SYSCALL(ftruncate
), fd
, size
));
161 #if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && !SANITIZER_FREEBSD
162 static void stat64_to_stat(struct stat64
*in
, struct stat
*out
) {
163 internal_memset(out
, 0, sizeof(*out
));
164 out
->st_dev
= in
->st_dev
;
165 out
->st_ino
= in
->st_ino
;
166 out
->st_mode
= in
->st_mode
;
167 out
->st_nlink
= in
->st_nlink
;
168 out
->st_uid
= in
->st_uid
;
169 out
->st_gid
= in
->st_gid
;
170 out
->st_rdev
= in
->st_rdev
;
171 out
->st_size
= in
->st_size
;
172 out
->st_blksize
= in
->st_blksize
;
173 out
->st_blocks
= in
->st_blocks
;
174 out
->st_atime
= in
->st_atime
;
175 out
->st_mtime
= in
->st_mtime
;
176 out
->st_ctime
= in
->st_ctime
;
177 out
->st_ino
= in
->st_ino
;
181 uptr
internal_stat(const char *path
, void *buf
) {
182 #if SANITIZER_FREEBSD
183 return internal_syscall(SYSCALL(stat
), path
, buf
);
184 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
185 return internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, (uptr
)path
,
187 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
188 return internal_syscall(SYSCALL(stat
), (uptr
)path
, (uptr
)buf
);
191 int res
= internal_syscall(SYSCALL(stat64
), path
, &buf64
);
192 stat64_to_stat(&buf64
, (struct stat
*)buf
);
197 uptr
internal_lstat(const char *path
, void *buf
) {
198 #if SANITIZER_FREEBSD
199 return internal_syscall(SYSCALL(lstat
), path
, buf
);
200 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
201 return internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, (uptr
)path
,
202 (uptr
)buf
, AT_SYMLINK_NOFOLLOW
);
203 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
204 return internal_syscall(SYSCALL(lstat
), (uptr
)path
, (uptr
)buf
);
207 int res
= internal_syscall(SYSCALL(lstat64
), path
, &buf64
);
208 stat64_to_stat(&buf64
, (struct stat
*)buf
);
213 uptr
internal_fstat(fd_t fd
, void *buf
) {
214 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
215 return internal_syscall(SYSCALL(fstat
), fd
, (uptr
)buf
);
218 int res
= internal_syscall(SYSCALL(fstat64
), fd
, &buf64
);
219 stat64_to_stat(&buf64
, (struct stat
*)buf
);
224 uptr
internal_filesize(fd_t fd
) {
226 if (internal_fstat(fd
, &st
))
228 return (uptr
)st
.st_size
;
231 uptr
internal_dup2(int oldfd
, int newfd
) {
232 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
233 return internal_syscall(SYSCALL(dup3
), oldfd
, newfd
, 0);
235 return internal_syscall(SYSCALL(dup2
), oldfd
, newfd
);
239 uptr
internal_readlink(const char *path
, char *buf
, uptr bufsize
) {
240 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
241 return internal_syscall(SYSCALL(readlinkat
), AT_FDCWD
,
242 (uptr
)path
, (uptr
)buf
, bufsize
);
244 return internal_syscall(SYSCALL(readlink
), (uptr
)path
, (uptr
)buf
, bufsize
);
248 uptr
internal_unlink(const char *path
) {
249 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
250 return internal_syscall(SYSCALL(unlinkat
), AT_FDCWD
, (uptr
)path
, 0);
252 return internal_syscall(SYSCALL(unlink
), (uptr
)path
);
256 uptr
internal_rename(const char *oldpath
, const char *newpath
) {
257 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
258 return internal_syscall(SYSCALL(renameat
), AT_FDCWD
, (uptr
)oldpath
, AT_FDCWD
,
261 return internal_syscall(SYSCALL(rename
), (uptr
)oldpath
, (uptr
)newpath
);
265 uptr
internal_sched_yield() {
266 return internal_syscall(SYSCALL(sched_yield
));
269 void internal__exit(int exitcode
) {
270 #if SANITIZER_FREEBSD
271 internal_syscall(SYSCALL(exit
), exitcode
);
273 internal_syscall(SYSCALL(exit_group
), exitcode
);
275 Die(); // Unreachable.
278 uptr
internal_execve(const char *filename
, char *const argv
[],
279 char *const envp
[]) {
280 return internal_syscall(SYSCALL(execve
), (uptr
)filename
, (uptr
)argv
,
284 // ----------------- sanitizer_common.h
285 bool FileExists(const char *filename
) {
286 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
288 if (internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, filename
, &st
, 0))
292 if (internal_stat(filename
, &st
))
294 // Sanity check: filename is a regular file.
295 return S_ISREG(st
.st_mode
);
300 #if SANITIZER_FREEBSD
301 return (uptr
)pthread_self();
303 return internal_syscall(SYSCALL(gettid
));
308 #if SANITIZER_FREEBSD
313 internal_memset(&tv
, 0, sizeof(tv
));
314 internal_syscall(SYSCALL(gettimeofday
), (uptr
)&tv
, 0);
315 return (u64
)tv
.tv_sec
* 1000*1000*1000 + tv
.tv_usec
* 1000;
318 // Like getenv, but reads env directly from /proc (on Linux) or parses the
319 // 'environ' array (on FreeBSD) and does not use libc. This function should be
320 // called first inside __asan_init.
321 const char *GetEnv(const char *name
) {
322 #if SANITIZER_FREEBSD
323 if (::environ
!= 0) {
324 uptr NameLen
= internal_strlen(name
);
325 for (char **Env
= ::environ
; *Env
!= 0; Env
++) {
326 if (internal_strncmp(*Env
, name
, NameLen
) == 0 && (*Env
)[NameLen
] == '=')
327 return (*Env
) + NameLen
+ 1;
330 return 0; // Not found.
331 #elif SANITIZER_LINUX
332 static char *environ
;
338 len
= ReadFileToBuffer("/proc/self/environ",
339 &environ
, &environ_size
, 1 << 26);
341 if (!environ
|| len
== 0) return 0;
342 uptr namelen
= internal_strlen(name
);
343 const char *p
= environ
;
344 while (*p
!= '\0') { // will happen at the \0\0 that terminates the buffer
345 // proc file has the format NAME=value\0NAME=value\0NAME=value\0...
347 (char*)internal_memchr(p
, '\0', len
- (p
- environ
));
348 if (endp
== 0) // this entry isn't NUL terminated
350 else if (!internal_memcmp(p
, name
, namelen
) && p
[namelen
] == '=') // Match.
351 return p
+ namelen
+ 1; // point after =
354 return 0; // Not found.
356 #error "Unsupported platform"
361 SANITIZER_WEAK_ATTRIBUTE
extern void *__libc_stack_end
;
365 static void ReadNullSepFileToArray(const char *path
, char ***arr
,
369 *arr
= (char **)MmapOrDie(arr_size
* sizeof(char *), "NullSepFileArray");
370 ReadFileToBuffer(path
, &buff
, &buff_size
, 1024 * 1024);
373 for (count
= 1, i
= 1; ; i
++) {
375 if (buff
[i
+1] == 0) break;
376 (*arr
)[count
] = &buff
[i
+1];
377 CHECK_LE(count
, arr_size
- 1); // FIXME: make this more flexible.
385 static void GetArgsAndEnv(char*** argv
, char*** envp
) {
387 if (&__libc_stack_end
) {
389 uptr
* stack_end
= (uptr
*)__libc_stack_end
;
390 int argc
= *stack_end
;
391 *argv
= (char**)(stack_end
+ 1);
392 *envp
= (char**)(stack_end
+ argc
+ 2);
395 static const int kMaxArgv
= 2000, kMaxEnvp
= 2000;
396 ReadNullSepFileToArray("/proc/self/cmdline", argv
, kMaxArgv
);
397 ReadNullSepFileToArray("/proc/self/environ", envp
, kMaxEnvp
);
404 GetArgsAndEnv(&argv
, &envp
);
405 uptr rv
= internal_execve("/proc/self/exe", argv
, envp
);
407 CHECK_EQ(internal_iserror(rv
, &rverrno
), true);
408 Printf("execve failed, errno %d\n", rverrno
);
412 // Stub implementation of GetThreadStackAndTls for Go.
414 void GetThreadStackAndTls(bool main
, uptr
*stk_addr
, uptr
*stk_size
,
415 uptr
*tls_addr
, uptr
*tls_size
) {
421 #endif // SANITIZER_GO
429 BlockingMutex::BlockingMutex(LinkerInitialized
) {
433 BlockingMutex::BlockingMutex() {
434 internal_memset(this, 0, sizeof(*this));
437 void BlockingMutex::Lock() {
438 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
439 if (atomic_exchange(m
, MtxLocked
, memory_order_acquire
) == MtxUnlocked
)
441 while (atomic_exchange(m
, MtxSleeping
, memory_order_acquire
) != MtxUnlocked
) {
442 #if SANITIZER_FREEBSD
443 _umtx_op(m
, UMTX_OP_WAIT_UINT
, MtxSleeping
, 0, 0);
445 internal_syscall(SYSCALL(futex
), (uptr
)m
, FUTEX_WAIT
, MtxSleeping
, 0, 0, 0);
450 void BlockingMutex::Unlock() {
451 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
452 u32 v
= atomic_exchange(m
, MtxUnlocked
, memory_order_relaxed
);
453 CHECK_NE(v
, MtxUnlocked
);
454 if (v
== MtxSleeping
) {
455 #if SANITIZER_FREEBSD
456 _umtx_op(m
, UMTX_OP_WAKE
, 1, 0, 0);
458 internal_syscall(SYSCALL(futex
), (uptr
)m
, FUTEX_WAKE
, 1, 0, 0, 0);
463 void BlockingMutex::CheckLocked() {
464 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
465 CHECK_NE(MtxUnlocked
, atomic_load(m
, memory_order_relaxed
));
468 // ----------------- sanitizer_linux.h
469 // The actual size of this structure is specified by d_reclen.
470 // Note that getdents64 uses a different structure format. We only provide the
471 // 32-bit syscall here.
472 struct linux_dirent
{
480 unsigned short d_reclen
;
485 uptr
internal_ptrace(int request
, int pid
, void *addr
, void *data
) {
486 return internal_syscall(SYSCALL(ptrace
), request
, pid
, (uptr
)addr
,
490 uptr
internal_waitpid(int pid
, int *status
, int options
) {
491 return internal_syscall(SYSCALL(wait4
), pid
, (uptr
)status
, options
,
495 uptr
internal_getpid() {
496 return internal_syscall(SYSCALL(getpid
));
499 uptr
internal_getppid() {
500 return internal_syscall(SYSCALL(getppid
));
503 uptr
internal_getdents(fd_t fd
, struct linux_dirent
*dirp
, unsigned int count
) {
504 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
505 return internal_syscall(SYSCALL(getdents64
), fd
, (uptr
)dirp
, count
);
507 return internal_syscall(SYSCALL(getdents
), fd
, (uptr
)dirp
, count
);
511 uptr
internal_lseek(fd_t fd
, OFF_T offset
, int whence
) {
512 return internal_syscall(SYSCALL(lseek
), fd
, offset
, whence
);
516 uptr
internal_prctl(int option
, uptr arg2
, uptr arg3
, uptr arg4
, uptr arg5
) {
517 return internal_syscall(SYSCALL(prctl
), option
, arg2
, arg3
, arg4
, arg5
);
521 uptr
internal_sigaltstack(const struct sigaltstack
*ss
,
522 struct sigaltstack
*oss
) {
523 return internal_syscall(SYSCALL(sigaltstack
), (uptr
)ss
, (uptr
)oss
);
526 int internal_fork() {
527 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
528 return internal_syscall(SYSCALL(clone
), SIGCHLD
, 0);
530 return internal_syscall(SYSCALL(fork
));
535 // Doesn't set sa_restorer, use with caution (see below).
536 int internal_sigaction_norestorer(int signum
, const void *act
, void *oldact
) {
537 __sanitizer_kernel_sigaction_t k_act
, k_oldact
;
538 internal_memset(&k_act
, 0, sizeof(__sanitizer_kernel_sigaction_t
));
539 internal_memset(&k_oldact
, 0, sizeof(__sanitizer_kernel_sigaction_t
));
540 const __sanitizer_sigaction
*u_act
= (__sanitizer_sigaction
*)act
;
541 __sanitizer_sigaction
*u_oldact
= (__sanitizer_sigaction
*)oldact
;
543 k_act
.handler
= u_act
->handler
;
544 k_act
.sigaction
= u_act
->sigaction
;
545 internal_memcpy(&k_act
.sa_mask
, &u_act
->sa_mask
,
546 sizeof(__sanitizer_kernel_sigset_t
));
547 k_act
.sa_flags
= u_act
->sa_flags
;
548 // FIXME: most often sa_restorer is unset, however the kernel requires it
549 // to point to a valid signal restorer that calls the rt_sigreturn syscall.
550 // If sa_restorer passed to the kernel is NULL, the program may crash upon
551 // signal delivery or fail to unwind the stack in the signal handler.
552 // libc implementation of sigaction() passes its own restorer to
553 // rt_sigaction, so we need to do the same (we'll need to reimplement the
554 // restorers; for x86_64 the restorer address can be obtained from
555 // oldact->sa_restorer upon a call to sigaction(xxx, NULL, oldact).
556 k_act
.sa_restorer
= u_act
->sa_restorer
;
559 uptr result
= internal_syscall(SYSCALL(rt_sigaction
), (uptr
)signum
,
560 (uptr
)(u_act
? &k_act
: NULL
),
561 (uptr
)(u_oldact
? &k_oldact
: NULL
),
562 (uptr
)sizeof(__sanitizer_kernel_sigset_t
));
564 if ((result
== 0) && u_oldact
) {
565 u_oldact
->handler
= k_oldact
.handler
;
566 u_oldact
->sigaction
= k_oldact
.sigaction
;
567 internal_memcpy(&u_oldact
->sa_mask
, &k_oldact
.sa_mask
,
568 sizeof(__sanitizer_kernel_sigset_t
));
569 u_oldact
->sa_flags
= k_oldact
.sa_flags
;
570 u_oldact
->sa_restorer
= k_oldact
.sa_restorer
;
574 #endif // SANITIZER_LINUX
576 uptr
internal_sigprocmask(int how
, __sanitizer_sigset_t
*set
,
577 __sanitizer_sigset_t
*oldset
) {
578 #if SANITIZER_FREEBSD
579 return internal_syscall(SYSCALL(sigprocmask
), how
, set
, oldset
);
581 __sanitizer_kernel_sigset_t
*k_set
= (__sanitizer_kernel_sigset_t
*)set
;
582 __sanitizer_kernel_sigset_t
*k_oldset
= (__sanitizer_kernel_sigset_t
*)oldset
;
583 return internal_syscall(SYSCALL(rt_sigprocmask
), (uptr
)how
,
584 (uptr
)&k_set
->sig
[0], (uptr
)&k_oldset
->sig
[0],
585 sizeof(__sanitizer_kernel_sigset_t
));
589 void internal_sigfillset(__sanitizer_sigset_t
*set
) {
590 internal_memset(set
, 0xff, sizeof(*set
));
594 void internal_sigdelset(__sanitizer_sigset_t
*set
, int signum
) {
597 CHECK_LT(signum
, sizeof(*set
) * 8);
598 __sanitizer_kernel_sigset_t
*k_set
= (__sanitizer_kernel_sigset_t
*)set
;
599 const uptr idx
= signum
/ (sizeof(k_set
->sig
[0]) * 8);
600 const uptr bit
= signum
% (sizeof(k_set
->sig
[0]) * 8);
601 k_set
->sig
[idx
] &= ~(1 << bit
);
603 #endif // SANITIZER_LINUX
605 // ThreadLister implementation.
606 ThreadLister::ThreadLister(int pid
)
611 entry_((struct linux_dirent
*)buffer_
.data()),
613 char task_directory_path
[80];
614 internal_snprintf(task_directory_path
, sizeof(task_directory_path
),
615 "/proc/%d/task/", pid
);
616 uptr openrv
= internal_open(task_directory_path
, O_RDONLY
| O_DIRECTORY
);
617 if (internal_iserror(openrv
)) {
619 Report("Can't open /proc/%d/task for reading.\n", pid
);
622 descriptor_
= openrv
;
626 int ThreadLister::GetNextTID() {
631 if ((char *)entry_
>= &buffer_
[bytes_read_
] && !GetDirectoryEntries())
633 if (entry_
->d_ino
!= 0 && entry_
->d_name
[0] >= '0' &&
634 entry_
->d_name
[0] <= '9') {
635 // Found a valid tid.
636 tid
= (int)internal_atoll(entry_
->d_name
);
638 entry_
= (struct linux_dirent
*)(((char *)entry_
) + entry_
->d_reclen
);
643 void ThreadLister::Reset() {
644 if (error_
|| descriptor_
< 0)
646 internal_lseek(descriptor_
, 0, SEEK_SET
);
649 ThreadLister::~ThreadLister() {
650 if (descriptor_
>= 0)
651 internal_close(descriptor_
);
654 bool ThreadLister::error() { return error_
; }
656 bool ThreadLister::GetDirectoryEntries() {
657 CHECK_GE(descriptor_
, 0);
658 CHECK_NE(error_
, true);
659 bytes_read_
= internal_getdents(descriptor_
,
660 (struct linux_dirent
*)buffer_
.data(),
662 if (internal_iserror(bytes_read_
)) {
663 Report("Can't read directory entries from /proc/%d/task.\n", pid_
);
666 } else if (bytes_read_
== 0) {
669 entry_
= (struct linux_dirent
*)buffer_
.data();
674 #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__))
675 return EXEC_PAGESIZE
;
677 return sysconf(_SC_PAGESIZE
); // EXEC_PAGESIZE may not be trustworthy.
681 static char proc_self_exe_cache_str
[kMaxPathLength
];
682 static uptr proc_self_exe_cache_len
= 0;
684 uptr
ReadBinaryName(/*out*/char *buf
, uptr buf_len
) {
685 if (proc_self_exe_cache_len
> 0) {
686 // If available, use the cached module name.
687 uptr module_name_len
=
688 internal_snprintf(buf
, buf_len
, "%s", proc_self_exe_cache_str
);
689 CHECK_LT(module_name_len
, buf_len
);
690 return module_name_len
;
692 #if SANITIZER_FREEBSD
693 const int Mib
[4] = { CTL_KERN
, KERN_PROC
, KERN_PROC_PATHNAME
, -1 };
694 size_t Size
= buf_len
;
695 bool IsErr
= (sysctl(Mib
, 4, buf
, &Size
, NULL
, 0) != 0);
696 int readlink_error
= IsErr
? errno
: 0;
697 uptr module_name_len
= Size
;
699 uptr module_name_len
= internal_readlink(
700 "/proc/self/exe", buf
, buf_len
);
702 bool IsErr
= internal_iserror(module_name_len
, &readlink_error
);
705 // We can't read /proc/self/exe for some reason, assume the name of the
706 // binary is unknown.
707 Report("WARNING: readlink(\"/proc/self/exe\") failed with errno %d, "
708 "some stack frames may not be symbolized\n", readlink_error
);
709 module_name_len
= internal_snprintf(buf
, buf_len
, "/proc/self/exe");
710 CHECK_LT(module_name_len
, buf_len
);
712 return module_name_len
;
715 void CacheBinaryName() {
716 if (!proc_self_exe_cache_len
) {
717 proc_self_exe_cache_len
=
718 ReadBinaryName(proc_self_exe_cache_str
, kMaxPathLength
);
722 // Match full names of the form /path/to/base_name{-,.}*
723 bool LibraryNameIs(const char *full_name
, const char *base_name
) {
724 const char *name
= full_name
;
726 while (*name
!= '\0') name
++;
727 while (name
> full_name
&& *name
!= '/') name
--;
728 if (*name
== '/') name
++;
729 uptr base_name_length
= internal_strlen(base_name
);
730 if (internal_strncmp(name
, base_name
, base_name_length
)) return false;
731 return (name
[base_name_length
] == '-' || name
[base_name_length
] == '.');
734 #if !SANITIZER_ANDROID
735 // Call cb for each region mapped by map.
736 void ForEachMappedRegion(link_map
*map
, void (*cb
)(const void *, uptr
)) {
737 #if !SANITIZER_FREEBSD
738 typedef ElfW(Phdr
) Elf_Phdr
;
739 typedef ElfW(Ehdr
) Elf_Ehdr
;
740 #endif // !SANITIZER_FREEBSD
741 char *base
= (char *)map
->l_addr
;
742 Elf_Ehdr
*ehdr
= (Elf_Ehdr
*)base
;
743 char *phdrs
= base
+ ehdr
->e_phoff
;
744 char *phdrs_end
= phdrs
+ ehdr
->e_phnum
* ehdr
->e_phentsize
;
746 // Find the segment with the minimum base so we can "relocate" the p_vaddr
747 // fields. Typically ET_DYN objects (DSOs) have base of zero and ET_EXEC
748 // objects have a non-zero base.
749 uptr preferred_base
= (uptr
)-1;
750 for (char *iter
= phdrs
; iter
!= phdrs_end
; iter
+= ehdr
->e_phentsize
) {
751 Elf_Phdr
*phdr
= (Elf_Phdr
*)iter
;
752 if (phdr
->p_type
== PT_LOAD
&& preferred_base
> (uptr
)phdr
->p_vaddr
)
753 preferred_base
= (uptr
)phdr
->p_vaddr
;
756 // Compute the delta from the real base to get a relocation delta.
757 sptr delta
= (uptr
)base
- preferred_base
;
758 // Now we can figure out what the loader really mapped.
759 for (char *iter
= phdrs
; iter
!= phdrs_end
; iter
+= ehdr
->e_phentsize
) {
760 Elf_Phdr
*phdr
= (Elf_Phdr
*)iter
;
761 if (phdr
->p_type
== PT_LOAD
) {
762 uptr seg_start
= phdr
->p_vaddr
+ delta
;
763 uptr seg_end
= seg_start
+ phdr
->p_memsz
;
764 // None of these values are aligned. We consider the ragged edges of the
765 // load command as defined, since they are mapped from the file.
766 seg_start
= RoundDownTo(seg_start
, GetPageSizeCached());
767 seg_end
= RoundUpTo(seg_end
, GetPageSizeCached());
768 cb((void *)seg_start
, seg_end
- seg_start
);
774 #if defined(__x86_64__) && SANITIZER_LINUX
775 // We cannot use glibc's clone wrapper, because it messes with the child
776 // task's TLS. It writes the PID and TID of the child task to its thread
777 // descriptor, but in our case the child task shares the thread descriptor with
778 // the parent (because we don't know how to allocate a new thread
779 // descriptor to keep glibc happy). So the stock version of clone(), when
780 // used with CLONE_VM, would end up corrupting the parent's thread descriptor.
781 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
782 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
784 if (!fn
|| !child_stack
)
786 CHECK_EQ(0, (uptr
)child_stack
% 16);
787 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned long long);
788 ((unsigned long long *)child_stack
)[0] = (uptr
)fn
;
789 ((unsigned long long *)child_stack
)[1] = (uptr
)arg
;
790 register void *r8
__asm__("r8") = newtls
;
791 register int *r10
__asm__("r10") = child_tidptr
;
792 __asm__
__volatile__(
793 /* %rax = syscall(%rax = SYSCALL(clone),
795 * %rsi = child_stack,
796 * %rdx = parent_tidptr,
798 * %r10 = child_tidptr)
805 "testq %%rax,%%rax\n"
808 /* In the child. Terminate unwind chain. */
809 // XXX: We should also terminate the CFI unwind chain
810 // here. Unfortunately clang 3.2 doesn't support the
811 // necessary CFI directives, so we skip that part.
814 /* Call "fn(arg)". */
819 /* Call _exit(%rax). */
824 /* Return to parent. */
827 : "a"(SYSCALL(clone
)), "i"(SYSCALL(exit
)),
833 : "rsp", "memory", "r11", "rcx");
836 #endif // defined(__x86_64__) && SANITIZER_LINUX
838 #if SANITIZER_ANDROID
839 // This thing is not, strictly speaking, async signal safe, but it does not seem
840 // to cause any issues. Alternative is writing to log devices directly, but
841 // their location and message format might change in the future, so we'd really
842 // like to avoid that.
843 void AndroidLogWrite(const char *buffer
) {
844 char *copy
= internal_strdup(buffer
);
847 // __android_log_write has an implicit message length limit.
848 // Print one line at a time.
850 q
= internal_strchr(p
, '\n');
852 __android_log_write(ANDROID_LOG_INFO
, NULL
, p
);
858 void GetExtraActivationFlags(char *buf
, uptr size
) {
859 CHECK(size
> PROP_VALUE_MAX
);
860 __system_property_get("asan.options", buf
);
864 bool IsDeadlySignal(int signum
) {
865 return (signum
== SIGSEGV
) && common_flags()->handle_segv
;
868 } // namespace __sanitizer
870 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX