1 //===-- sanitizer_linux.cc ------------------------------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is shared between AddressSanitizer and ThreadSanitizer
9 // run-time libraries and implements linux-specific functions from
11 //===----------------------------------------------------------------------===//
13 #include "sanitizer_platform.h"
15 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
16 SANITIZER_OPENBSD || SANITIZER_SOLARIS
18 #include "sanitizer_common.h"
19 #include "sanitizer_flags.h"
20 #include "sanitizer_getauxval.h"
21 #include "sanitizer_internal_defs.h"
22 #include "sanitizer_libc.h"
23 #include "sanitizer_linux.h"
24 #include "sanitizer_mutex.h"
25 #include "sanitizer_placement_new.h"
26 #include "sanitizer_procmaps.h"
29 #include <asm/param.h>
32 // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
33 // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To
34 // access stat from asm/stat.h, without conflicting with definition in
35 // sys/stat.h, we use this trick.
37 #include <asm/unistd.h>
38 #include <sys/types.h>
39 #define stat kernel_stat
52 #include <sys/param.h>
53 #if !SANITIZER_SOLARIS
54 #include <sys/ptrace.h>
56 #include <sys/resource.h>
58 #include <sys/syscall.h>
60 #include <sys/types.h>
61 #if !SANITIZER_OPENBSD
65 #include <sys/futex.h>
66 #include <sys/sysctl.h>
71 #include <sys/utsname.h>
74 #if SANITIZER_LINUX && !SANITIZER_ANDROID
75 #include <sys/personality.h>
80 #include <sys/sysctl.h>
81 #include <machine/atomic.h>
83 // <sys/umtx.h> must be included after <errno.h> and <sys/types.h> on
84 // FreeBSD 9.2 and 10.0.
88 #endif // SANITIZER_FREEBSD
91 #include <limits.h> // For NAME_MAX
92 #include <sys/sysctl.h>
94 extern struct ps_strings
*__ps_strings
;
95 #endif // SANITIZER_NETBSD
100 #define environ _environ
103 extern char **environ
;
107 struct kernel_timeval
{
112 // <linux/futex.h> is broken on some linux distributions.
113 const int FUTEX_WAIT
= 0;
114 const int FUTEX_WAKE
= 1;
115 const int FUTEX_PRIVATE_FLAG
= 128;
116 const int FUTEX_WAIT_PRIVATE
= FUTEX_WAIT
| FUTEX_PRIVATE_FLAG
;
117 const int FUTEX_WAKE_PRIVATE
= FUTEX_WAKE
| FUTEX_PRIVATE_FLAG
;
118 #endif // SANITIZER_LINUX
120 // Are we using 32-bit or 64-bit Linux syscalls?
121 // x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32
122 // but it still needs to use 64-bit syscalls.
123 #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \
124 SANITIZER_WORDSIZE == 64)
125 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
127 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
130 #if defined(__x86_64__) || SANITIZER_MIPS64
132 extern void internal_sigreturn();
136 // Note : FreeBSD had implemented both
137 // Linux and OpenBSD apis, available from
138 // future 12.x version most likely
139 #if SANITIZER_LINUX && defined(__NR_getrandom)
140 # if !defined(GRND_NONBLOCK)
141 # define GRND_NONBLOCK 1
143 # define SANITIZER_USE_GETRANDOM 1
145 # define SANITIZER_USE_GETRANDOM 0
146 #endif // SANITIZER_LINUX && defined(__NR_getrandom)
148 #if SANITIZER_OPENBSD
149 # define SANITIZER_USE_GETENTROPY 1
151 # if SANITIZER_FREEBSD && __FreeBSD_version >= 1200000
152 # define SANITIZER_USE_GETENTROPY 1
154 # define SANITIZER_USE_GETENTROPY 0
156 #endif // SANITIZER_USE_GETENTROPY
158 namespace __sanitizer
{
160 #if SANITIZER_LINUX && defined(__x86_64__)
161 #include "sanitizer_syscall_linux_x86_64.inc"
162 #elif SANITIZER_LINUX && defined(__aarch64__)
163 #include "sanitizer_syscall_linux_aarch64.inc"
164 #elif SANITIZER_LINUX && defined(__arm__)
165 #include "sanitizer_syscall_linux_arm.inc"
167 #include "sanitizer_syscall_generic.inc"
170 // --------------- sanitizer_libc.h
171 #if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
172 #if !SANITIZER_S390 && !SANITIZER_OPENBSD
173 uptr
internal_mmap(void *addr
, uptr length
, int prot
, int flags
, int fd
,
175 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
176 return internal_syscall(SYSCALL(mmap
), (uptr
)addr
, length
, prot
, flags
, fd
,
179 // mmap2 specifies file offset in 4096-byte units.
180 CHECK(IsAligned(offset
, 4096));
181 return internal_syscall(SYSCALL(mmap2
), addr
, length
, prot
, flags
, fd
,
185 #endif // !SANITIZER_S390 && !SANITIZER_OPENBSD
187 #if !SANITIZER_OPENBSD
188 uptr
internal_munmap(void *addr
, uptr length
) {
189 return internal_syscall(SYSCALL(munmap
), (uptr
)addr
, length
);
192 int internal_mprotect(void *addr
, uptr length
, int prot
) {
193 return internal_syscall(SYSCALL(mprotect
), (uptr
)addr
, length
, prot
);
197 uptr
internal_close(fd_t fd
) {
198 return internal_syscall(SYSCALL(close
), fd
);
201 uptr
internal_open(const char *filename
, int flags
) {
202 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
203 return internal_syscall(SYSCALL(openat
), AT_FDCWD
, (uptr
)filename
, flags
);
205 return internal_syscall(SYSCALL(open
), (uptr
)filename
, flags
);
209 uptr
internal_open(const char *filename
, int flags
, u32 mode
) {
210 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
211 return internal_syscall(SYSCALL(openat
), AT_FDCWD
, (uptr
)filename
, flags
,
214 return internal_syscall(SYSCALL(open
), (uptr
)filename
, flags
, mode
);
218 uptr
internal_read(fd_t fd
, void *buf
, uptr count
) {
221 (sptr
)internal_syscall(SYSCALL(read
), fd
, (uptr
)buf
, count
));
225 uptr
internal_write(fd_t fd
, const void *buf
, uptr count
) {
228 (sptr
)internal_syscall(SYSCALL(write
), fd
, (uptr
)buf
, count
));
232 uptr
internal_ftruncate(fd_t fd
, uptr size
) {
234 HANDLE_EINTR(res
, (sptr
)internal_syscall(SYSCALL(ftruncate
), fd
,
239 #if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && SANITIZER_LINUX
240 static void stat64_to_stat(struct stat64
*in
, struct stat
*out
) {
241 internal_memset(out
, 0, sizeof(*out
));
242 out
->st_dev
= in
->st_dev
;
243 out
->st_ino
= in
->st_ino
;
244 out
->st_mode
= in
->st_mode
;
245 out
->st_nlink
= in
->st_nlink
;
246 out
->st_uid
= in
->st_uid
;
247 out
->st_gid
= in
->st_gid
;
248 out
->st_rdev
= in
->st_rdev
;
249 out
->st_size
= in
->st_size
;
250 out
->st_blksize
= in
->st_blksize
;
251 out
->st_blocks
= in
->st_blocks
;
252 out
->st_atime
= in
->st_atime
;
253 out
->st_mtime
= in
->st_mtime
;
254 out
->st_ctime
= in
->st_ctime
;
258 #if defined(__mips64)
259 // Undefine compatibility macros from <sys/stat.h>
260 // so that they would not clash with the kernel_stat
261 // st_[a|m|c]time fields
265 #if defined(SANITIZER_ANDROID)
266 // Bionic sys/stat.h defines additional macros
267 // for compatibility with the old NDKs and
268 // they clash with the kernel_stat structure
269 // st_[a|m|c]time_nsec fields.
274 static void kernel_stat_to_stat(struct kernel_stat
*in
, struct stat
*out
) {
275 internal_memset(out
, 0, sizeof(*out
));
276 out
->st_dev
= in
->st_dev
;
277 out
->st_ino
= in
->st_ino
;
278 out
->st_mode
= in
->st_mode
;
279 out
->st_nlink
= in
->st_nlink
;
280 out
->st_uid
= in
->st_uid
;
281 out
->st_gid
= in
->st_gid
;
282 out
->st_rdev
= in
->st_rdev
;
283 out
->st_size
= in
->st_size
;
284 out
->st_blksize
= in
->st_blksize
;
285 out
->st_blocks
= in
->st_blocks
;
286 #if defined(__USE_MISC) || \
287 defined(__USE_XOPEN2K8) || \
288 defined(SANITIZER_ANDROID)
289 out
->st_atim
.tv_sec
= in
->st_atime
;
290 out
->st_atim
.tv_nsec
= in
->st_atime_nsec
;
291 out
->st_mtim
.tv_sec
= in
->st_mtime
;
292 out
->st_mtim
.tv_nsec
= in
->st_mtime_nsec
;
293 out
->st_ctim
.tv_sec
= in
->st_ctime
;
294 out
->st_ctim
.tv_nsec
= in
->st_ctime_nsec
;
296 out
->st_atime
= in
->st_atime
;
297 out
->st_atimensec
= in
->st_atime_nsec
;
298 out
->st_mtime
= in
->st_mtime
;
299 out
->st_mtimensec
= in
->st_mtime_nsec
;
300 out
->st_ctime
= in
->st_ctime
;
301 out
->st_atimensec
= in
->st_ctime_nsec
;
306 uptr
internal_stat(const char *path
, void *buf
) {
307 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD
308 return internal_syscall(SYSCALL(fstatat
), AT_FDCWD
, (uptr
)path
, (uptr
)buf
, 0);
309 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
310 return internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, (uptr
)path
, (uptr
)buf
,
312 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
313 # if defined(__mips64)
314 // For mips64, stat syscall fills buffer in the format of kernel_stat
315 struct kernel_stat kbuf
;
316 int res
= internal_syscall(SYSCALL(stat
), path
, &kbuf
);
317 kernel_stat_to_stat(&kbuf
, (struct stat
*)buf
);
320 return internal_syscall(SYSCALL(stat
), (uptr
)path
, (uptr
)buf
);
324 int res
= internal_syscall(SYSCALL(stat64
), path
, &buf64
);
325 stat64_to_stat(&buf64
, (struct stat
*)buf
);
330 uptr
internal_lstat(const char *path
, void *buf
) {
331 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD
332 return internal_syscall(SYSCALL(fstatat
), AT_FDCWD
, (uptr
)path
, (uptr
)buf
,
333 AT_SYMLINK_NOFOLLOW
);
334 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
335 return internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, (uptr
)path
, (uptr
)buf
,
336 AT_SYMLINK_NOFOLLOW
);
337 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
338 # if SANITIZER_MIPS64
339 // For mips64, lstat syscall fills buffer in the format of kernel_stat
340 struct kernel_stat kbuf
;
341 int res
= internal_syscall(SYSCALL(lstat
), path
, &kbuf
);
342 kernel_stat_to_stat(&kbuf
, (struct stat
*)buf
);
345 return internal_syscall(SYSCALL(lstat
), (uptr
)path
, (uptr
)buf
);
349 int res
= internal_syscall(SYSCALL(lstat64
), path
, &buf64
);
350 stat64_to_stat(&buf64
, (struct stat
*)buf
);
355 uptr
internal_fstat(fd_t fd
, void *buf
) {
356 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD || \
357 SANITIZER_LINUX_USES_64BIT_SYSCALLS
358 #if SANITIZER_MIPS64 && !SANITIZER_OPENBSD
359 // For mips64, fstat syscall fills buffer in the format of kernel_stat
360 struct kernel_stat kbuf
;
361 int res
= internal_syscall(SYSCALL(fstat
), fd
, &kbuf
);
362 kernel_stat_to_stat(&kbuf
, (struct stat
*)buf
);
365 return internal_syscall(SYSCALL(fstat
), fd
, (uptr
)buf
);
369 int res
= internal_syscall(SYSCALL(fstat64
), fd
, &buf64
);
370 stat64_to_stat(&buf64
, (struct stat
*)buf
);
375 uptr
internal_filesize(fd_t fd
) {
377 if (internal_fstat(fd
, &st
))
379 return (uptr
)st
.st_size
;
382 uptr
internal_dup2(int oldfd
, int newfd
) {
383 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
384 return internal_syscall(SYSCALL(dup3
), oldfd
, newfd
, 0);
386 return internal_syscall(SYSCALL(dup2
), oldfd
, newfd
);
390 uptr
internal_readlink(const char *path
, char *buf
, uptr bufsize
) {
391 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
392 return internal_syscall(SYSCALL(readlinkat
), AT_FDCWD
, (uptr
)path
, (uptr
)buf
,
394 #elif SANITIZER_OPENBSD
395 return internal_syscall(SYSCALL(readlinkat
), AT_FDCWD
, (uptr
)path
, (uptr
)buf
,
398 return internal_syscall(SYSCALL(readlink
), path
, buf
, bufsize
);
402 uptr
internal_unlink(const char *path
) {
403 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
404 return internal_syscall(SYSCALL(unlinkat
), AT_FDCWD
, (uptr
)path
, 0);
406 return internal_syscall(SYSCALL(unlink
), (uptr
)path
);
410 uptr
internal_rename(const char *oldpath
, const char *newpath
) {
411 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
412 return internal_syscall(SYSCALL(renameat
), AT_FDCWD
, (uptr
)oldpath
, AT_FDCWD
,
415 return internal_syscall(SYSCALL(rename
), (uptr
)oldpath
, (uptr
)newpath
);
419 uptr
internal_sched_yield() {
420 return internal_syscall(SYSCALL(sched_yield
));
423 void internal__exit(int exitcode
) {
424 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD
425 internal_syscall(SYSCALL(exit
), exitcode
);
427 internal_syscall(SYSCALL(exit_group
), exitcode
);
429 Die(); // Unreachable.
432 unsigned int internal_sleep(unsigned int seconds
) {
436 int res
= internal_syscall(SYSCALL(nanosleep
), &ts
, &ts
);
437 if (res
) return ts
.tv_sec
;
441 uptr
internal_execve(const char *filename
, char *const argv
[],
442 char *const envp
[]) {
443 return internal_syscall(SYSCALL(execve
), (uptr
)filename
, (uptr
)argv
,
446 #endif // !SANITIZER_SOLARIS && !SANITIZER_NETBSD
448 // ----------------- sanitizer_common.h
449 bool FileExists(const char *filename
) {
451 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
452 if (internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, filename
, &st
, 0))
454 if (internal_stat(filename
, &st
))
457 // Sanity check: filename is a regular file.
458 return S_ISREG(st
.st_mode
);
461 #if !SANITIZER_NETBSD
463 #if SANITIZER_FREEBSD
467 #elif SANITIZER_OPENBSD
468 return internal_syscall(SYSCALL(getthrid
));
469 #elif SANITIZER_SOLARIS
472 return internal_syscall(SYSCALL(gettid
));
476 int TgKill(pid_t pid
, tid_t tid
, int sig
) {
478 return internal_syscall(SYSCALL(tgkill
), pid
, tid
, sig
);
479 #elif SANITIZER_FREEBSD
480 return internal_syscall(SYSCALL(thr_kill2
), pid
, tid
, sig
);
481 #elif SANITIZER_OPENBSD
483 return internal_syscall(SYSCALL(thrkill
), tid
, sig
, nullptr);
484 #elif SANITIZER_SOLARIS
486 return thr_kill(tid
, sig
);
491 #if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
493 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD
498 internal_memset(&tv
, 0, sizeof(tv
));
499 internal_syscall(SYSCALL(gettimeofday
), &tv
, 0);
500 return (u64
)tv
.tv_sec
* 1000*1000*1000 + tv
.tv_usec
* 1000;
503 uptr
internal_clock_gettime(__sanitizer_clockid_t clk_id
, void *tp
) {
504 return internal_syscall(SYSCALL(clock_gettime
), clk_id
, tp
);
506 #endif // !SANITIZER_SOLARIS && !SANITIZER_NETBSD
508 // Like getenv, but reads env directly from /proc (on Linux) or parses the
509 // 'environ' array (on some others) and does not use libc. This function
510 // should be called first inside __asan_init.
511 const char *GetEnv(const char *name
) {
512 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD || \
514 if (::environ
!= 0) {
515 uptr NameLen
= internal_strlen(name
);
516 for (char **Env
= ::environ
; *Env
!= 0; Env
++) {
517 if (internal_strncmp(*Env
, name
, NameLen
) == 0 && (*Env
)[NameLen
] == '=')
518 return (*Env
) + NameLen
+ 1;
521 return 0; // Not found.
522 #elif SANITIZER_LINUX
523 static char *environ
;
529 if (!ReadFileToBuffer("/proc/self/environ", &environ
, &environ_size
, &len
))
532 if (!environ
|| len
== 0) return nullptr;
533 uptr namelen
= internal_strlen(name
);
534 const char *p
= environ
;
535 while (*p
!= '\0') { // will happen at the \0\0 that terminates the buffer
536 // proc file has the format NAME=value\0NAME=value\0NAME=value\0...
538 (char*)internal_memchr(p
, '\0', len
- (p
- environ
));
539 if (!endp
) // this entry isn't NUL terminated
541 else if (!internal_memcmp(p
, name
, namelen
) && p
[namelen
] == '=') // Match.
542 return p
+ namelen
+ 1; // point after =
545 return nullptr; // Not found.
547 #error "Unsupported platform"
551 #if !SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_OPENBSD
553 SANITIZER_WEAK_ATTRIBUTE
extern void *__libc_stack_end
;
557 #if !SANITIZER_GO && !SANITIZER_FREEBSD && !SANITIZER_NETBSD && \
559 static void ReadNullSepFileToArray(const char *path
, char ***arr
,
564 *arr
= (char **)MmapOrDie(arr_size
* sizeof(char *), "NullSepFileArray");
565 if (!ReadFileToBuffer(path
, &buff
, &buff_size
, &buff_len
, 1024 * 1024)) {
571 for (count
= 1, i
= 1; ; i
++) {
573 if (buff
[i
+1] == 0) break;
574 (*arr
)[count
] = &buff
[i
+1];
575 CHECK_LE(count
, arr_size
- 1); // FIXME: make this more flexible.
579 (*arr
)[count
] = nullptr;
583 #if !SANITIZER_OPENBSD
584 static void GetArgsAndEnv(char ***argv
, char ***envp
) {
585 #if SANITIZER_FREEBSD
586 // On FreeBSD, retrieving the argument and environment arrays is done via the
587 // kern.ps_strings sysctl, which returns a pointer to a structure containing
588 // this information. See also <sys/exec.h>.
590 uptr sz
= sizeof(pss
);
591 if (internal_sysctlbyname("kern.ps_strings", &pss
, &sz
, NULL
, 0) == -1) {
592 Printf("sysctl kern.ps_strings failed\n");
595 *argv
= pss
->ps_argvstr
;
596 *envp
= pss
->ps_envstr
;
597 #elif SANITIZER_NETBSD
598 *argv
= __ps_strings
->ps_argvstr
;
599 *envp
= __ps_strings
->ps_envstr
;
600 #else // SANITIZER_FREEBSD
602 if (&__libc_stack_end
) {
603 #endif // !SANITIZER_GO
604 uptr
* stack_end
= (uptr
*)__libc_stack_end
;
605 int argc
= *stack_end
;
606 *argv
= (char**)(stack_end
+ 1);
607 *envp
= (char**)(stack_end
+ argc
+ 2);
610 static const int kMaxArgv
= 2000, kMaxEnvp
= 2000;
611 ReadNullSepFileToArray("/proc/self/cmdline", argv
, kMaxArgv
);
612 ReadNullSepFileToArray("/proc/self/environ", envp
, kMaxEnvp
);
614 #endif // !SANITIZER_GO
615 #endif // SANITIZER_FREEBSD
620 GetArgsAndEnv(&argv
, &envp
);
626 const char *pathname
= "/proc/self/exe";
629 static const int name
[] = {
630 CTL_KERN
, KERN_PROC_ARGS
, -1, KERN_PROC_PATHNAME
,
636 if (internal_sysctl(name
, ARRAY_SIZE(name
), path
, &len
, NULL
, 0) != -1)
638 #elif SANITIZER_SOLARIS
639 pathname
= getexecname();
640 CHECK_NE(pathname
, NULL
);
643 GetArgsAndEnv(&argv
, &envp
);
644 uptr rv
= internal_execve(pathname
, argv
, envp
);
646 CHECK_EQ(internal_iserror(rv
, &rverrno
), true);
647 Printf("execve failed, errno %d\n", rverrno
);
652 #if !SANITIZER_SOLARIS
659 BlockingMutex::BlockingMutex() {
660 internal_memset(this, 0, sizeof(*this));
663 void BlockingMutex::Lock() {
665 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
666 if (atomic_exchange(m
, MtxLocked
, memory_order_acquire
) == MtxUnlocked
)
668 while (atomic_exchange(m
, MtxSleeping
, memory_order_acquire
) != MtxUnlocked
) {
669 #if SANITIZER_FREEBSD
670 _umtx_op(m
, UMTX_OP_WAIT_UINT
, MtxSleeping
, 0, 0);
671 #elif SANITIZER_NETBSD
672 sched_yield(); /* No userspace futex-like synchronization */
674 internal_syscall(SYSCALL(futex
), (uptr
)m
, FUTEX_WAIT_PRIVATE
, MtxSleeping
,
680 void BlockingMutex::Unlock() {
681 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
682 u32 v
= atomic_exchange(m
, MtxUnlocked
, memory_order_release
);
683 CHECK_NE(v
, MtxUnlocked
);
684 if (v
== MtxSleeping
) {
685 #if SANITIZER_FREEBSD
686 _umtx_op(m
, UMTX_OP_WAKE
, 1, 0, 0);
687 #elif SANITIZER_NETBSD
688 /* No userspace futex-like synchronization */
690 internal_syscall(SYSCALL(futex
), (uptr
)m
, FUTEX_WAKE_PRIVATE
, 1, 0, 0, 0);
695 void BlockingMutex::CheckLocked() {
696 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
697 CHECK_NE(MtxUnlocked
, atomic_load(m
, memory_order_relaxed
));
699 #endif // !SANITIZER_SOLARIS
701 // ----------------- sanitizer_linux.h
702 // The actual size of this structure is specified by d_reclen.
703 // Note that getdents64 uses a different structure format. We only provide the
704 // 32-bit syscall here.
707 #elif SANITIZER_OPENBSD
708 // struct dirent is different for Linux and us. At this moment, we use only
709 // d_fileno (Linux call this d_ino), d_reclen, and d_name.
710 struct linux_dirent
{
711 u64 d_ino
; // d_fileno
713 u16 d_namlen
; // not used
714 u8 d_type
; // not used
715 char d_name
[NAME_MAX
+ 1];
718 struct linux_dirent
{
719 #if SANITIZER_X32 || defined(__aarch64__)
726 unsigned short d_reclen
;
728 unsigned char d_type
;
734 #if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
736 uptr
internal_ptrace(int request
, int pid
, void *addr
, void *data
) {
737 return internal_syscall(SYSCALL(ptrace
), request
, pid
, (uptr
)addr
,
741 uptr
internal_waitpid(int pid
, int *status
, int options
) {
742 return internal_syscall(SYSCALL(wait4
), pid
, (uptr
)status
, options
,
746 uptr
internal_getpid() {
747 return internal_syscall(SYSCALL(getpid
));
750 uptr
internal_getppid() {
751 return internal_syscall(SYSCALL(getppid
));
754 uptr
internal_getdents(fd_t fd
, struct linux_dirent
*dirp
, unsigned int count
) {
755 #if SANITIZER_FREEBSD
756 return internal_syscall(SYSCALL(getdirentries
), fd
, (uptr
)dirp
, count
, NULL
);
757 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
758 return internal_syscall(SYSCALL(getdents64
), fd
, (uptr
)dirp
, count
);
760 return internal_syscall(SYSCALL(getdents
), fd
, (uptr
)dirp
, count
);
764 uptr
internal_lseek(fd_t fd
, OFF_T offset
, int whence
) {
765 return internal_syscall(SYSCALL(lseek
), fd
, offset
, whence
);
769 uptr
internal_prctl(int option
, uptr arg2
, uptr arg3
, uptr arg4
, uptr arg5
) {
770 return internal_syscall(SYSCALL(prctl
), option
, arg2
, arg3
, arg4
, arg5
);
774 uptr
internal_sigaltstack(const void *ss
, void *oss
) {
775 return internal_syscall(SYSCALL(sigaltstack
), (uptr
)ss
, (uptr
)oss
);
778 int internal_fork() {
779 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
780 return internal_syscall(SYSCALL(clone
), SIGCHLD
, 0);
782 return internal_syscall(SYSCALL(fork
));
786 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD
787 int internal_sysctl(const int *name
, unsigned int namelen
, void *oldp
,
788 uptr
*oldlenp
, const void *newp
, uptr newlen
) {
789 #if SANITIZER_OPENBSD
790 return sysctl(name
, namelen
, oldp
, (size_t *)oldlenp
, (void *)newp
,
793 return sysctl(name
, namelen
, oldp
, (size_t *)oldlenp
, newp
, (size_t)newlen
);
797 #if SANITIZER_FREEBSD
798 int internal_sysctlbyname(const char *sname
, void *oldp
, uptr
*oldlenp
,
799 const void *newp
, uptr newlen
) {
800 return sysctlbyname(sname
, oldp
, (size_t *)oldlenp
, newp
, (size_t)newlen
);
806 #define SA_RESTORER 0x04000000
807 // Doesn't set sa_restorer if the caller did not set it, so use with caution
809 int internal_sigaction_norestorer(int signum
, const void *act
, void *oldact
) {
810 __sanitizer_kernel_sigaction_t k_act
, k_oldact
;
811 internal_memset(&k_act
, 0, sizeof(__sanitizer_kernel_sigaction_t
));
812 internal_memset(&k_oldact
, 0, sizeof(__sanitizer_kernel_sigaction_t
));
813 const __sanitizer_sigaction
*u_act
= (const __sanitizer_sigaction
*)act
;
814 __sanitizer_sigaction
*u_oldact
= (__sanitizer_sigaction
*)oldact
;
816 k_act
.handler
= u_act
->handler
;
817 k_act
.sigaction
= u_act
->sigaction
;
818 internal_memcpy(&k_act
.sa_mask
, &u_act
->sa_mask
,
819 sizeof(__sanitizer_kernel_sigset_t
));
820 // Without SA_RESTORER kernel ignores the calls (probably returns EINVAL).
821 k_act
.sa_flags
= u_act
->sa_flags
| SA_RESTORER
;
822 // FIXME: most often sa_restorer is unset, however the kernel requires it
823 // to point to a valid signal restorer that calls the rt_sigreturn syscall.
824 // If sa_restorer passed to the kernel is NULL, the program may crash upon
825 // signal delivery or fail to unwind the stack in the signal handler.
826 // libc implementation of sigaction() passes its own restorer to
827 // rt_sigaction, so we need to do the same (we'll need to reimplement the
828 // restorers; for x86_64 the restorer address can be obtained from
829 // oldact->sa_restorer upon a call to sigaction(xxx, NULL, oldact).
830 #if !SANITIZER_ANDROID || !SANITIZER_MIPS32
831 k_act
.sa_restorer
= u_act
->sa_restorer
;
835 uptr result
= internal_syscall(SYSCALL(rt_sigaction
), (uptr
)signum
,
836 (uptr
)(u_act
? &k_act
: nullptr),
837 (uptr
)(u_oldact
? &k_oldact
: nullptr),
838 (uptr
)sizeof(__sanitizer_kernel_sigset_t
));
840 if ((result
== 0) && u_oldact
) {
841 u_oldact
->handler
= k_oldact
.handler
;
842 u_oldact
->sigaction
= k_oldact
.sigaction
;
843 internal_memcpy(&u_oldact
->sa_mask
, &k_oldact
.sa_mask
,
844 sizeof(__sanitizer_kernel_sigset_t
));
845 u_oldact
->sa_flags
= k_oldact
.sa_flags
;
846 #if !SANITIZER_ANDROID || !SANITIZER_MIPS32
847 u_oldact
->sa_restorer
= k_oldact
.sa_restorer
;
853 // Invokes sigaction via a raw syscall with a restorer, but does not support
854 // all platforms yet.
855 // We disable for Go simply because we have not yet added to buildgo.sh.
856 #if (defined(__x86_64__) || SANITIZER_MIPS64) && !SANITIZER_GO
857 int internal_sigaction_syscall(int signum
, const void *act
, void *oldact
) {
859 return internal_sigaction_norestorer(signum
, act
, oldact
);
860 __sanitizer_sigaction u_adjust
;
861 internal_memcpy(&u_adjust
, act
, sizeof(u_adjust
));
862 #if !SANITIZER_ANDROID || !SANITIZER_MIPS32
863 if (u_adjust
.sa_restorer
== nullptr) {
864 u_adjust
.sa_restorer
= internal_sigreturn
;
867 return internal_sigaction_norestorer(signum
, (const void *)&u_adjust
, oldact
);
869 #endif // defined(__x86_64__) && !SANITIZER_GO
870 #endif // SANITIZER_LINUX
872 uptr
internal_sigprocmask(int how
, __sanitizer_sigset_t
*set
,
873 __sanitizer_sigset_t
*oldset
) {
874 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD
875 return internal_syscall(SYSCALL(sigprocmask
), how
, set
, oldset
);
877 __sanitizer_kernel_sigset_t
*k_set
= (__sanitizer_kernel_sigset_t
*)set
;
878 __sanitizer_kernel_sigset_t
*k_oldset
= (__sanitizer_kernel_sigset_t
*)oldset
;
879 return internal_syscall(SYSCALL(rt_sigprocmask
), (uptr
)how
,
880 (uptr
)&k_set
->sig
[0], (uptr
)&k_oldset
->sig
[0],
881 sizeof(__sanitizer_kernel_sigset_t
));
885 void internal_sigfillset(__sanitizer_sigset_t
*set
) {
886 internal_memset(set
, 0xff, sizeof(*set
));
889 void internal_sigemptyset(__sanitizer_sigset_t
*set
) {
890 internal_memset(set
, 0, sizeof(*set
));
894 void internal_sigdelset(__sanitizer_sigset_t
*set
, int signum
) {
897 CHECK_LT(signum
, sizeof(*set
) * 8);
898 __sanitizer_kernel_sigset_t
*k_set
= (__sanitizer_kernel_sigset_t
*)set
;
899 const uptr idx
= signum
/ (sizeof(k_set
->sig
[0]) * 8);
900 const uptr bit
= signum
% (sizeof(k_set
->sig
[0]) * 8);
901 k_set
->sig
[idx
] &= ~(1 << bit
);
904 bool internal_sigismember(__sanitizer_sigset_t
*set
, int signum
) {
907 CHECK_LT(signum
, sizeof(*set
) * 8);
908 __sanitizer_kernel_sigset_t
*k_set
= (__sanitizer_kernel_sigset_t
*)set
;
909 const uptr idx
= signum
/ (sizeof(k_set
->sig
[0]) * 8);
910 const uptr bit
= signum
% (sizeof(k_set
->sig
[0]) * 8);
911 return k_set
->sig
[idx
] & (1 << bit
);
913 #elif SANITIZER_FREEBSD
914 void internal_sigdelset(__sanitizer_sigset_t
*set
, int signum
) {
915 sigset_t
*rset
= reinterpret_cast<sigset_t
*>(set
);
916 sigdelset(rset
, signum
);
919 bool internal_sigismember(__sanitizer_sigset_t
*set
, int signum
) {
920 sigset_t
*rset
= reinterpret_cast<sigset_t
*>(set
);
921 return sigismember(rset
, signum
);
924 #endif // !SANITIZER_SOLARIS
926 #if !SANITIZER_NETBSD
927 // ThreadLister implementation.
928 ThreadLister::ThreadLister(pid_t pid
) : pid_(pid
), buffer_(4096) {
929 char task_directory_path
[80];
930 internal_snprintf(task_directory_path
, sizeof(task_directory_path
),
931 "/proc/%d/task/", pid
);
932 descriptor_
= internal_open(task_directory_path
, O_RDONLY
| O_DIRECTORY
);
933 if (internal_iserror(descriptor_
)) {
934 Report("Can't open /proc/%d/task for reading.\n", pid
);
938 ThreadLister::Result
ThreadLister::ListThreads(
939 InternalMmapVector
<tid_t
> *threads
) {
940 if (internal_iserror(descriptor_
))
942 internal_lseek(descriptor_
, 0, SEEK_SET
);
946 for (bool first_read
= true;; first_read
= false) {
947 // Resize to max capacity if it was downsized by IsAlive.
948 buffer_
.resize(buffer_
.capacity());
949 CHECK_GE(buffer_
.size(), 4096);
950 uptr read
= internal_getdents(
951 descriptor_
, (struct linux_dirent
*)buffer_
.data(), buffer_
.size());
954 if (internal_iserror(read
)) {
955 Report("Can't read directory entries from /proc/%d/task.\n", pid_
);
959 for (uptr begin
= (uptr
)buffer_
.data(), end
= begin
+ read
; begin
< end
;) {
960 struct linux_dirent
*entry
= (struct linux_dirent
*)begin
;
961 begin
+= entry
->d_reclen
;
962 if (entry
->d_ino
== 1) {
963 // Inode 1 is for bad blocks and also can be a reason for early return.
964 // Should be emitted if kernel tried to output terminating thread.
965 // See proc_task_readdir implementation in Linux.
968 if (entry
->d_ino
&& *entry
->d_name
>= '0' && *entry
->d_name
<= '9')
969 threads
->push_back(internal_atoll(entry
->d_name
));
972 // Now we are going to detect short-read or early EOF. In such cases Linux
973 // can return inconsistent list with missing alive threads.
974 // Code will just remember that the list can be incomplete but it will
975 // continue reads to return as much as possible.
977 // The first one was a short-read by definition.
979 } else if (read
> buffer_
.size() - 1024) {
980 // Read was close to the buffer size. So double the size and assume the
982 buffer_
.resize(buffer_
.size() * 2);
984 } else if (!threads
->empty() && !IsAlive(threads
->back())) {
985 // Maybe Linux early returned from read on terminated thread (!pid_alive)
986 // and failed to restore read position.
987 // See next_tid and proc_task_instantiate in Linux.
993 bool ThreadLister::IsAlive(int tid
) {
994 // /proc/%d/task/%d/status uses same call to detect alive threads as
995 // proc_task_readdir. See task_state implementation in Linux.
997 internal_snprintf(path
, sizeof(path
), "/proc/%d/task/%d/status", pid_
, tid
);
998 if (!ReadFileToVector(path
, &buffer_
) || buffer_
.empty())
1000 buffer_
.push_back(0);
1001 static const char kPrefix
[] = "\nPPid:";
1002 const char *field
= internal_strstr(buffer_
.data(), kPrefix
);
1005 field
+= internal_strlen(kPrefix
);
1006 return (int)internal_atoll(field
) != 0;
1009 ThreadLister::~ThreadLister() {
1010 if (!internal_iserror(descriptor_
))
1011 internal_close(descriptor_
);
1015 #if SANITIZER_WORDSIZE == 32
1016 // Take care of unusable kernel area in top gigabyte.
1017 static uptr
GetKernelAreaSize() {
1018 #if SANITIZER_LINUX && !SANITIZER_X32
1019 const uptr gbyte
= 1UL << 30;
1021 // Firstly check if there are writable segments
1022 // mapped to top gigabyte (e.g. stack).
1023 MemoryMappingLayout
proc_maps(/*cache_enabled*/true);
1024 MemoryMappedSegment segment
;
1025 while (proc_maps
.Next(&segment
)) {
1026 if ((segment
.end
>= 3 * gbyte
) && segment
.IsWritable()) return 0;
1029 #if !SANITIZER_ANDROID
1030 // Even if nothing is mapped, top Gb may still be accessible
1031 // if we are running on 64-bit kernel.
1032 // Uname may report misleading results if personality type
1033 // is modified (e.g. under schroot) so check this as well.
1034 struct utsname uname_info
;
1035 int pers
= personality(0xffffffffUL
);
1036 if (!(pers
& PER_MASK
)
1037 && uname(&uname_info
) == 0
1038 && internal_strstr(uname_info
.machine
, "64"))
1040 #endif // SANITIZER_ANDROID
1042 // Top gigabyte is reserved for kernel.
1046 #endif // SANITIZER_LINUX && !SANITIZER_X32
1048 #endif // SANITIZER_WORDSIZE == 32
1050 uptr
GetMaxVirtualAddress() {
1051 #if (SANITIZER_NETBSD || SANITIZER_OPENBSD) && defined(__x86_64__)
1052 return 0x7f7ffffff000ULL
; // (0x00007f8000000000 - PAGE_SIZE)
1053 #elif SANITIZER_WORDSIZE == 64
1054 # if defined(__powerpc64__) || defined(__aarch64__)
1055 // On PowerPC64 we have two different address space layouts: 44- and 46-bit.
1056 // We somehow need to figure out which one we are using now and choose
1057 // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL.
1058 // Note that with 'ulimit -s unlimited' the stack is moved away from the top
1059 // of the address space, so simply checking the stack address is not enough.
1060 // This should (does) work for both PowerPC64 Endian modes.
1061 // Similarly, aarch64 has multiple address space layouts: 39, 42 and 47-bit.
1062 return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1;
1063 # elif defined(__mips64)
1064 return (1ULL << 40) - 1; // 0x000000ffffffffffUL;
1065 # elif defined(__s390x__)
1066 return (1ULL << 53) - 1; // 0x001fffffffffffffUL;
1068 return (1ULL << 47) - 1; // 0x00007fffffffffffUL;
1070 #else // SANITIZER_WORDSIZE == 32
1071 # if defined(__s390__)
1072 return (1ULL << 31) - 1; // 0x7fffffff;
1074 return (1ULL << 32) - 1; // 0xffffffff;
1076 #endif // SANITIZER_WORDSIZE
1079 uptr
GetMaxUserVirtualAddress() {
1080 uptr addr
= GetMaxVirtualAddress();
1081 #if SANITIZER_WORDSIZE == 32 && !defined(__s390__)
1082 if (!common_flags()->full_address_space
)
1083 addr
-= GetKernelAreaSize();
1084 CHECK_LT(reinterpret_cast<uptr
>(&addr
), addr
);
1089 uptr
GetPageSize() {
1090 // Android post-M sysconf(_SC_PAGESIZE) crashes if called from .preinit_array.
1091 #if SANITIZER_ANDROID
1093 #elif SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__))
1094 return EXEC_PAGESIZE
;
1095 #elif SANITIZER_USE_GETAUXVAL
1096 return getauxval(AT_PAGESZ
);
1098 return sysconf(_SC_PAGESIZE
); // EXEC_PAGESIZE may not be trustworthy.
1102 #if !SANITIZER_OPENBSD
1103 uptr
ReadBinaryName(/*out*/char *buf
, uptr buf_len
) {
1104 #if SANITIZER_SOLARIS
1105 const char *default_module_name
= getexecname();
1106 CHECK_NE(default_module_name
, NULL
);
1107 return internal_snprintf(buf
, buf_len
, "%s", default_module_name
);
1109 #if SANITIZER_FREEBSD || SANITIZER_NETBSD
1110 #if SANITIZER_FREEBSD
1111 const int Mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PATHNAME
, -1};
1113 const int Mib
[4] = {CTL_KERN
, KERN_PROC_ARGS
, -1, KERN_PROC_PATHNAME
};
1115 const char *default_module_name
= "kern.proc.pathname";
1116 uptr Size
= buf_len
;
1118 (internal_sysctl(Mib
, ARRAY_SIZE(Mib
), buf
, &Size
, NULL
, 0) != 0);
1119 int readlink_error
= IsErr
? errno
: 0;
1120 uptr module_name_len
= Size
;
1122 const char *default_module_name
= "/proc/self/exe";
1123 uptr module_name_len
= internal_readlink(
1124 default_module_name
, buf
, buf_len
);
1126 bool IsErr
= internal_iserror(module_name_len
, &readlink_error
);
1127 #endif // SANITIZER_SOLARIS
1129 // We can't read binary name for some reason, assume it's unknown.
1130 Report("WARNING: reading executable name failed with errno %d, "
1131 "some stack frames may not be symbolized\n", readlink_error
);
1132 module_name_len
= internal_snprintf(buf
, buf_len
, "%s",
1133 default_module_name
);
1134 CHECK_LT(module_name_len
, buf_len
);
1136 return module_name_len
;
1139 #endif // !SANITIZER_OPENBSD
1141 uptr
ReadLongProcessName(/*out*/ char *buf
, uptr buf_len
) {
1146 if (ReadFileToBuffer("/proc/self/cmdline", &tmpbuf
, &tmpsize
, &tmplen
,
1148 internal_strncpy(buf
, tmpbuf
, buf_len
);
1149 UnmapOrDie(tmpbuf
, tmpsize
);
1150 return internal_strlen(buf
);
1153 return ReadBinaryName(buf
, buf_len
);
1156 // Match full names of the form /path/to/base_name{-,.}*
1157 bool LibraryNameIs(const char *full_name
, const char *base_name
) {
1158 const char *name
= full_name
;
1160 while (*name
!= '\0') name
++;
1161 while (name
> full_name
&& *name
!= '/') name
--;
1162 if (*name
== '/') name
++;
1163 uptr base_name_length
= internal_strlen(base_name
);
1164 if (internal_strncmp(name
, base_name
, base_name_length
)) return false;
1165 return (name
[base_name_length
] == '-' || name
[base_name_length
] == '.');
1168 #if !SANITIZER_ANDROID
1169 // Call cb for each region mapped by map.
1170 void ForEachMappedRegion(link_map
*map
, void (*cb
)(const void *, uptr
)) {
1171 CHECK_NE(map
, nullptr);
1172 #if !SANITIZER_FREEBSD && !SANITIZER_OPENBSD
1173 typedef ElfW(Phdr
) Elf_Phdr
;
1174 typedef ElfW(Ehdr
) Elf_Ehdr
;
1175 #endif // !SANITIZER_FREEBSD && !SANITIZER_OPENBSD
1176 char *base
= (char *)map
->l_addr
;
1177 Elf_Ehdr
*ehdr
= (Elf_Ehdr
*)base
;
1178 char *phdrs
= base
+ ehdr
->e_phoff
;
1179 char *phdrs_end
= phdrs
+ ehdr
->e_phnum
* ehdr
->e_phentsize
;
1181 // Find the segment with the minimum base so we can "relocate" the p_vaddr
1182 // fields. Typically ET_DYN objects (DSOs) have base of zero and ET_EXEC
1183 // objects have a non-zero base.
1184 uptr preferred_base
= (uptr
)-1;
1185 for (char *iter
= phdrs
; iter
!= phdrs_end
; iter
+= ehdr
->e_phentsize
) {
1186 Elf_Phdr
*phdr
= (Elf_Phdr
*)iter
;
1187 if (phdr
->p_type
== PT_LOAD
&& preferred_base
> (uptr
)phdr
->p_vaddr
)
1188 preferred_base
= (uptr
)phdr
->p_vaddr
;
1191 // Compute the delta from the real base to get a relocation delta.
1192 sptr delta
= (uptr
)base
- preferred_base
;
1193 // Now we can figure out what the loader really mapped.
1194 for (char *iter
= phdrs
; iter
!= phdrs_end
; iter
+= ehdr
->e_phentsize
) {
1195 Elf_Phdr
*phdr
= (Elf_Phdr
*)iter
;
1196 if (phdr
->p_type
== PT_LOAD
) {
1197 uptr seg_start
= phdr
->p_vaddr
+ delta
;
1198 uptr seg_end
= seg_start
+ phdr
->p_memsz
;
1199 // None of these values are aligned. We consider the ragged edges of the
1200 // load command as defined, since they are mapped from the file.
1201 seg_start
= RoundDownTo(seg_start
, GetPageSizeCached());
1202 seg_end
= RoundUpTo(seg_end
, GetPageSizeCached());
1203 cb((void *)seg_start
, seg_end
- seg_start
);
1209 #if defined(__x86_64__) && SANITIZER_LINUX
1210 // We cannot use glibc's clone wrapper, because it messes with the child
1211 // task's TLS. It writes the PID and TID of the child task to its thread
1212 // descriptor, but in our case the child task shares the thread descriptor with
1213 // the parent (because we don't know how to allocate a new thread
1214 // descriptor to keep glibc happy). So the stock version of clone(), when
1215 // used with CLONE_VM, would end up corrupting the parent's thread descriptor.
1216 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
1217 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
1219 if (!fn
|| !child_stack
)
1221 CHECK_EQ(0, (uptr
)child_stack
% 16);
1222 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned long long);
1223 ((unsigned long long *)child_stack
)[0] = (uptr
)fn
;
1224 ((unsigned long long *)child_stack
)[1] = (uptr
)arg
;
1225 register void *r8
__asm__("r8") = newtls
;
1226 register int *r10
__asm__("r10") = child_tidptr
;
1227 __asm__
__volatile__(
1228 /* %rax = syscall(%rax = SYSCALL(clone),
1230 * %rsi = child_stack,
1231 * %rdx = parent_tidptr,
1233 * %r10 = child_tidptr)
1240 "testq %%rax,%%rax\n"
1243 /* In the child. Terminate unwind chain. */
1244 // XXX: We should also terminate the CFI unwind chain
1245 // here. Unfortunately clang 3.2 doesn't support the
1246 // necessary CFI directives, so we skip that part.
1247 "xorq %%rbp,%%rbp\n"
1249 /* Call "fn(arg)". */
1254 /* Call _exit(%rax). */
1255 "movq %%rax,%%rdi\n"
1259 /* Return to parent. */
1262 : "a"(SYSCALL(clone
)), "i"(SYSCALL(exit
)),
1268 : "memory", "r11", "rcx");
1271 #elif defined(__mips__)
1272 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
1273 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
1275 if (!fn
|| !child_stack
)
1277 CHECK_EQ(0, (uptr
)child_stack
% 16);
1278 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned long long);
1279 ((unsigned long long *)child_stack
)[0] = (uptr
)fn
;
1280 ((unsigned long long *)child_stack
)[1] = (uptr
)arg
;
1281 register void *a3
__asm__("$7") = newtls
;
1282 register int *a4
__asm__("$8") = child_tidptr
;
1283 // We don't have proper CFI directives here because it requires alot of code
1284 // for very marginal benefits.
1285 __asm__
__volatile__(
1286 /* $v0 = syscall($v0 = __NR_clone,
1288 * $a1 = child_stack,
1289 * $a2 = parent_tidptr,
1291 * $a4 = child_tidptr)
1298 /* Store the fifth argument on stack
1299 * if we are using 32-bit abi.
1301 #if SANITIZER_WORDSIZE == 32
1314 /* Call "fn(arg)". */
1315 #if SANITIZER_WORDSIZE == 32
1316 #ifdef __BIG_ENDIAN__
1329 /* Call _exit($v0). */
1334 /* Return to parent. */
1344 : "memory", "$29" );
1347 #elif defined(__aarch64__)
1348 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
1349 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
1351 if (!fn
|| !child_stack
)
1353 CHECK_EQ(0, (uptr
)child_stack
% 16);
1354 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned long long);
1355 ((unsigned long long *)child_stack
)[0] = (uptr
)fn
;
1356 ((unsigned long long *)child_stack
)[1] = (uptr
)arg
;
1358 register int (*__fn
)(void *) __asm__("x0") = fn
;
1359 register void *__stack
__asm__("x1") = child_stack
;
1360 register int __flags
__asm__("x2") = flags
;
1361 register void *__arg
__asm__("x3") = arg
;
1362 register int *__ptid
__asm__("x4") = parent_tidptr
;
1363 register void *__tls
__asm__("x5") = newtls
;
1364 register int *__ctid
__asm__("x6") = child_tidptr
;
1366 __asm__
__volatile__(
1367 "mov x0,x2\n" /* flags */
1368 "mov x2,x4\n" /* ptid */
1369 "mov x3,x5\n" /* tls */
1370 "mov x4,x6\n" /* ctid */
1371 "mov x8,%9\n" /* clone */
1381 /* In the child, now. Call "fn(arg)". */
1382 "ldp x1, x0, [sp], #16\n"
1385 /* Call _exit(%r0). */
1392 "r"(__fn
), "r"(__stack
), "r"(__flags
), "r"(__arg
),
1393 "r"(__ptid
), "r"(__tls
), "r"(__ctid
),
1394 "i"(__NR_clone
), "i"(__NR_exit
)
1398 #elif defined(__powerpc64__)
1399 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
1400 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
1402 // Stack frame structure.
1403 #if SANITIZER_PPC64V1
1404 // Back chain == 0 (SP + 112)
1405 // Frame (112 bytes):
1406 // Parameter save area (SP + 48), 8 doublewords
1407 // TOC save area (SP + 40)
1408 // Link editor doubleword (SP + 32)
1409 // Compiler doubleword (SP + 24)
1410 // LR save area (SP + 16)
1411 // CR save area (SP + 8)
1412 // Back chain (SP + 0)
1413 # define FRAME_SIZE 112
1414 # define FRAME_TOC_SAVE_OFFSET 40
1415 #elif SANITIZER_PPC64V2
1416 // Back chain == 0 (SP + 32)
1417 // Frame (32 bytes):
1418 // TOC save area (SP + 24)
1419 // LR save area (SP + 16)
1420 // CR save area (SP + 8)
1421 // Back chain (SP + 0)
1422 # define FRAME_SIZE 32
1423 # define FRAME_TOC_SAVE_OFFSET 24
1425 # error "Unsupported PPC64 ABI"
1427 if (!fn
|| !child_stack
)
1429 CHECK_EQ(0, (uptr
)child_stack
% 16);
1431 register int (*__fn
)(void *) __asm__("r3") = fn
;
1432 register void *__cstack
__asm__("r4") = child_stack
;
1433 register int __flags
__asm__("r5") = flags
;
1434 register void *__arg
__asm__("r6") = arg
;
1435 register int *__ptidptr
__asm__("r7") = parent_tidptr
;
1436 register void *__newtls
__asm__("r8") = newtls
;
1437 register int *__ctidptr
__asm__("r9") = child_tidptr
;
1439 __asm__
__volatile__(
1440 /* fn and arg are saved across the syscall */
1450 r7 == child_tidptr */
1458 /* Test if syscall was successful */
1459 "cmpdi cr1, 3, 0\n\t"
1460 "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t"
1463 /* Set up stack frame */
1465 "stdu 29, -8(1)\n\t"
1466 "stdu 1, -%12(1)\n\t"
1467 /* Do the function call */
1469 #if SANITIZER_PPC64V1
1473 #elif SANITIZER_PPC64V2
1477 # error "Unsupported PPC64 ABI"
1483 /* Call _exit(r3) */
1487 /* Return to parent */
1503 "i" (FRAME_TOC_SAVE_OFFSET
)
1504 : "cr0", "cr1", "memory", "ctr", "r0", "r27", "r28", "r29");
1507 #elif defined(__i386__) && SANITIZER_LINUX
1508 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
1509 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
1511 if (!fn
|| !child_stack
)
1513 CHECK_EQ(0, (uptr
)child_stack
% 16);
1514 child_stack
= (char *)child_stack
- 7 * sizeof(unsigned int);
1515 ((unsigned int *)child_stack
)[0] = (uptr
)flags
;
1516 ((unsigned int *)child_stack
)[1] = (uptr
)0;
1517 ((unsigned int *)child_stack
)[2] = (uptr
)fn
;
1518 ((unsigned int *)child_stack
)[3] = (uptr
)arg
;
1519 __asm__
__volatile__(
1520 /* %eax = syscall(%eax = SYSCALL(clone),
1522 * %ecx = child_stack,
1523 * %edx = parent_tidptr,
1525 * %edi = child_tidptr)
1529 "movl (%%ecx), %%ebx\n"
1530 /* Do the system call */
1534 /* Remember the flag value. */
1535 "movl %%ebx, (%%ecx)\n"
1545 "test %%eax,%%eax\n"
1548 /* terminate the stack frame */
1549 "xorl %%ebp,%%ebp\n"
1556 "addl $_GLOBAL_OFFSET_TABLE_+[.-here], %%ebx\n"
1559 "movl %%eax, %%ebx\n"
1564 : "a"(SYSCALL(clone
)), "i"(SYSCALL(exit
)),
1572 #elif defined(__arm__) && SANITIZER_LINUX
1573 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
1574 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
1576 if (!fn
|| !child_stack
)
1578 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned int);
1579 ((unsigned int *)child_stack
)[0] = (uptr
)fn
;
1580 ((unsigned int *)child_stack
)[1] = (uptr
)arg
;
1581 register int r0
__asm__("r0") = flags
;
1582 register void *r1
__asm__("r1") = child_stack
;
1583 register int *r2
__asm__("r2") = parent_tidptr
;
1584 register void *r3
__asm__("r3") = newtls
;
1585 register int *r4
__asm__("r4") = child_tidptr
;
1586 register int r7
__asm__("r7") = __NR_clone
;
1588 #if __ARM_ARCH > 4 || defined (__ARM_ARCH_4T__)
1589 # define ARCH_HAS_BX
1592 # define ARCH_HAS_BLX
1596 # ifdef ARCH_HAS_BLX
1597 # define BLX(R) "blx " #R "\n"
1599 # define BLX(R) "mov lr, pc; bx " #R "\n"
1602 # define BLX(R) "mov lr, pc; mov pc," #R "\n"
1605 __asm__
__volatile__(
1606 /* %r0 = syscall(%r7 = SYSCALL(clone),
1608 * %r1 = child_stack,
1609 * %r2 = parent_tidptr,
1611 * %r4 = child_tidptr)
1614 /* Do the system call */
1623 /* In the child, now. Call "fn(arg)". */
1624 "ldr r0, [sp, #4]\n"
1625 "ldr ip, [sp], #8\n"
1627 /* Call _exit(%r0). */
1633 : "r"(r0
), "r"(r1
), "r"(r2
), "r"(r3
), "r"(r4
), "r"(r7
),
1638 #endif // defined(__x86_64__) && SANITIZER_LINUX
1640 #if SANITIZER_ANDROID
1641 #if __ANDROID_API__ < 21
1642 extern "C" __attribute__((weak
)) int dl_iterate_phdr(
1643 int (*)(struct dl_phdr_info
*, size_t, void *), void *);
1646 static int dl_iterate_phdr_test_cb(struct dl_phdr_info
*info
, size_t size
,
1648 // Any name starting with "lib" indicates a bug in L where library base names
1649 // are returned instead of paths.
1650 if (info
->dlpi_name
&& info
->dlpi_name
[0] == 'l' &&
1651 info
->dlpi_name
[1] == 'i' && info
->dlpi_name
[2] == 'b') {
1652 *(bool *)data
= true;
1658 static atomic_uint32_t android_api_level
;
1660 static AndroidApiLevel
AndroidDetectApiLevelStatic() {
1661 #if __ANDROID_API__ <= 19
1662 return ANDROID_KITKAT
;
1663 #elif __ANDROID_API__ <= 22
1664 return ANDROID_LOLLIPOP_MR1
;
1666 return ANDROID_POST_LOLLIPOP
;
1670 static AndroidApiLevel
AndroidDetectApiLevel() {
1671 if (!&dl_iterate_phdr
)
1672 return ANDROID_KITKAT
; // K or lower
1673 bool base_name_seen
= false;
1674 dl_iterate_phdr(dl_iterate_phdr_test_cb
, &base_name_seen
);
1676 return ANDROID_LOLLIPOP_MR1
; // L MR1
1677 return ANDROID_POST_LOLLIPOP
; // post-L
1678 // Plain L (API level 21) is completely broken wrt ASan and not very
1679 // interesting to detect.
1682 extern "C" __attribute__((weak
)) void* _DYNAMIC
;
1684 AndroidApiLevel
AndroidGetApiLevel() {
1685 AndroidApiLevel level
=
1686 (AndroidApiLevel
)atomic_load(&android_api_level
, memory_order_relaxed
);
1687 if (level
) return level
;
1688 level
= &_DYNAMIC
== nullptr ? AndroidDetectApiLevelStatic()
1689 : AndroidDetectApiLevel();
1690 atomic_store(&android_api_level
, level
, memory_order_relaxed
);
1696 static HandleSignalMode
GetHandleSignalModeImpl(int signum
) {
1699 return common_flags()->handle_abort
;
1701 return common_flags()->handle_sigill
;
1703 return common_flags()->handle_sigtrap
;
1705 return common_flags()->handle_sigfpe
;
1707 return common_flags()->handle_segv
;
1709 return common_flags()->handle_sigbus
;
1711 return kHandleSignalNo
;
1714 HandleSignalMode
GetHandleSignalMode(int signum
) {
1715 HandleSignalMode result
= GetHandleSignalModeImpl(signum
);
1716 if (result
== kHandleSignalYes
&& !common_flags()->allow_user_segv_handler
)
1717 return kHandleSignalExclusive
;
1722 void *internal_start_thread(void(*func
)(void *arg
), void *arg
) {
1723 // Start the thread with signals blocked, otherwise it can steal user signals.
1724 __sanitizer_sigset_t set
, old
;
1725 internal_sigfillset(&set
);
1726 #if SANITIZER_LINUX && !SANITIZER_ANDROID
1727 // Glibc uses SIGSETXID signal during setuid call. If this signal is blocked
1728 // on any thread, setuid call hangs (see test/tsan/setuid.c).
1729 internal_sigdelset(&set
, 33);
1731 internal_sigprocmask(SIG_SETMASK
, &set
, &old
);
1733 real_pthread_create(&th
, nullptr, (void*(*)(void *arg
))func
, arg
);
1734 internal_sigprocmask(SIG_SETMASK
, &old
, nullptr);
1738 void internal_join_thread(void *th
) {
1739 real_pthread_join(th
, nullptr);
1742 void *internal_start_thread(void (*func
)(void *), void *arg
) { return 0; }
1744 void internal_join_thread(void *th
) {}
1747 #if defined(__aarch64__)
1748 // Android headers in the older NDK releases miss this definition.
1749 struct __sanitizer_esr_context
{
1750 struct _aarch64_ctx head
;
1754 static bool Aarch64GetESR(ucontext_t
*ucontext
, u64
*esr
) {
1755 static const u32 kEsrMagic
= 0x45535201;
1756 u8
*aux
= ucontext
->uc_mcontext
.__reserved
;
1758 _aarch64_ctx
*ctx
= (_aarch64_ctx
*)aux
;
1759 if (ctx
->size
== 0) break;
1760 if (ctx
->magic
== kEsrMagic
) {
1761 *esr
= ((__sanitizer_esr_context
*)ctx
)->esr
;
1770 #if SANITIZER_OPENBSD
1771 using Context
= sigcontext
;
1773 using Context
= ucontext_t
;
1776 SignalContext::WriteFlag
SignalContext::GetWriteFlag() const {
1777 Context
*ucontext
= (Context
*)context
;
1778 #if defined(__x86_64__) || defined(__i386__)
1779 static const uptr PF_WRITE
= 1U << 1;
1780 #if SANITIZER_FREEBSD
1781 uptr err
= ucontext
->uc_mcontext
.mc_err
;
1782 #elif SANITIZER_NETBSD
1783 uptr err
= ucontext
->uc_mcontext
.__gregs
[_REG_ERR
];
1784 #elif SANITIZER_OPENBSD
1785 uptr err
= ucontext
->sc_err
;
1786 #elif SANITIZER_SOLARIS && defined(__i386__)
1788 uptr err
= ucontext
->uc_mcontext
.gregs
[Err
];
1790 uptr err
= ucontext
->uc_mcontext
.gregs
[REG_ERR
];
1791 #endif // SANITIZER_FREEBSD
1792 return err
& PF_WRITE
? WRITE
: READ
;
1793 #elif defined(__mips__)
1794 uint32_t *exception_source
;
1795 uint32_t faulty_instruction
;
1798 exception_source
= (uint32_t *)ucontext
->uc_mcontext
.pc
;
1799 faulty_instruction
= (uint32_t)(*exception_source
);
1801 op_code
= (faulty_instruction
>> 26) & 0x3f;
1803 // FIXME: Add support for FPU, microMIPS, DSP, MSA memory instructions.
1809 #if __mips_isa_rev < 6
1815 return SignalContext::WRITE
;
1824 #if __mips_isa_rev < 6
1830 return SignalContext::READ
;
1831 #if __mips_isa_rev == 6
1833 op_code
= (faulty_instruction
>> 19) & 0x3;
1837 return SignalContext::READ
;
1841 return SignalContext::UNKNOWN
;
1842 #elif defined(__arm__)
1843 static const uptr FSR_WRITE
= 1U << 11;
1844 uptr fsr
= ucontext
->uc_mcontext
.error_code
;
1845 return fsr
& FSR_WRITE
? WRITE
: READ
;
1846 #elif defined(__aarch64__)
1847 static const u64 ESR_ELx_WNR
= 1U << 6;
1849 if (!Aarch64GetESR(ucontext
, &esr
)) return UNKNOWN
;
1850 return esr
& ESR_ELx_WNR
? WRITE
: READ
;
1851 #elif SANITIZER_SOLARIS && defined(__sparc__)
1852 // Decode the instruction to determine the access type.
1853 // From OpenSolaris $SRC/uts/sun4/os/trap.c (get_accesstype).
1854 uptr pc
= ucontext
->uc_mcontext
.gregs
[REG_PC
];
1855 u32 instr
= *(u32
*)pc
;
1856 return (instr
>> 21) & 1 ? WRITE
: READ
;
1859 return UNKNOWN
; // FIXME: Implement.
1863 void SignalContext::DumpAllRegisters(void *context
) {
1864 // FIXME: Implement this.
1867 static void GetPcSpBp(void *context
, uptr
*pc
, uptr
*sp
, uptr
*bp
) {
1868 #if SANITIZER_NETBSD
1869 // This covers all NetBSD architectures
1870 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1871 *pc
= _UC_MACHINE_PC(ucontext
);
1872 *bp
= _UC_MACHINE_FP(ucontext
);
1873 *sp
= _UC_MACHINE_SP(ucontext
);
1874 #elif defined(__arm__)
1875 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1876 *pc
= ucontext
->uc_mcontext
.arm_pc
;
1877 *bp
= ucontext
->uc_mcontext
.arm_fp
;
1878 *sp
= ucontext
->uc_mcontext
.arm_sp
;
1879 #elif defined(__aarch64__)
1880 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1881 *pc
= ucontext
->uc_mcontext
.pc
;
1882 *bp
= ucontext
->uc_mcontext
.regs
[29];
1883 *sp
= ucontext
->uc_mcontext
.sp
;
1884 #elif defined(__hppa__)
1885 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1886 *pc
= ucontext
->uc_mcontext
.sc_iaoq
[0];
1887 /* GCC uses %r3 whenever a frame pointer is needed. */
1888 *bp
= ucontext
->uc_mcontext
.sc_gr
[3];
1889 *sp
= ucontext
->uc_mcontext
.sc_gr
[30];
1890 #elif defined(__x86_64__)
1891 # if SANITIZER_FREEBSD
1892 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1893 *pc
= ucontext
->uc_mcontext
.mc_rip
;
1894 *bp
= ucontext
->uc_mcontext
.mc_rbp
;
1895 *sp
= ucontext
->uc_mcontext
.mc_rsp
;
1896 #elif SANITIZER_OPENBSD
1897 sigcontext
*ucontext
= (sigcontext
*)context
;
1898 *pc
= ucontext
->sc_rip
;
1899 *bp
= ucontext
->sc_rbp
;
1900 *sp
= ucontext
->sc_rsp
;
1902 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1903 *pc
= ucontext
->uc_mcontext
.gregs
[REG_RIP
];
1904 *bp
= ucontext
->uc_mcontext
.gregs
[REG_RBP
];
1905 *sp
= ucontext
->uc_mcontext
.gregs
[REG_RSP
];
1907 #elif defined(__i386__)
1908 # if SANITIZER_FREEBSD
1909 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1910 *pc
= ucontext
->uc_mcontext
.mc_eip
;
1911 *bp
= ucontext
->uc_mcontext
.mc_ebp
;
1912 *sp
= ucontext
->uc_mcontext
.mc_esp
;
1913 #elif SANITIZER_OPENBSD
1914 sigcontext
*ucontext
= (sigcontext
*)context
;
1915 *pc
= ucontext
->sc_eip
;
1916 *bp
= ucontext
->sc_ebp
;
1917 *sp
= ucontext
->sc_esp
;
1919 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1920 # if SANITIZER_SOLARIS
1921 /* Use the numeric values: the symbolic ones are undefined by llvm
1922 include/llvm/Support/Solaris.h. */
1924 # define REG_EIP 14 // REG_PC
1927 # define REG_EBP 6 // REG_FP
1930 # define REG_ESP 17 // REG_SP
1933 *pc
= ucontext
->uc_mcontext
.gregs
[REG_EIP
];
1934 *bp
= ucontext
->uc_mcontext
.gregs
[REG_EBP
];
1935 *sp
= ucontext
->uc_mcontext
.gregs
[REG_ESP
];
1937 #elif defined(__powerpc__) || defined(__powerpc64__)
1938 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1939 *pc
= ucontext
->uc_mcontext
.regs
->nip
;
1940 *sp
= ucontext
->uc_mcontext
.regs
->gpr
[PT_R1
];
1941 // The powerpc{,64}-linux ABIs do not specify r31 as the frame
1942 // pointer, but GCC always uses r31 when we need a frame pointer.
1943 *bp
= ucontext
->uc_mcontext
.regs
->gpr
[PT_R31
];
1944 #elif defined(__sparc__)
1945 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1947 # if defined(__sparcv9) || defined (__arch64__)
1949 # define MC_PC REG_PC
1952 # define MC_O6 REG_O6
1954 # if SANITIZER_SOLARIS
1955 # define mc_gregs gregs
1957 *pc
= ucontext
->uc_mcontext
.mc_gregs
[MC_PC
];
1958 *sp
= ucontext
->uc_mcontext
.mc_gregs
[MC_O6
];
1959 stk_ptr
= (uptr
*) (*sp
+ 2047);
1962 *pc
= ucontext
->uc_mcontext
.gregs
[REG_PC
];
1963 *sp
= ucontext
->uc_mcontext
.gregs
[REG_O6
];
1964 stk_ptr
= (uptr
*) *sp
;
1967 #elif defined(__mips__)
1968 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1969 *pc
= ucontext
->uc_mcontext
.pc
;
1970 *bp
= ucontext
->uc_mcontext
.gregs
[30];
1971 *sp
= ucontext
->uc_mcontext
.gregs
[29];
1972 #elif defined(__s390__)
1973 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1974 # if defined(__s390x__)
1975 *pc
= ucontext
->uc_mcontext
.psw
.addr
;
1977 *pc
= ucontext
->uc_mcontext
.psw
.addr
& 0x7fffffff;
1979 *bp
= ucontext
->uc_mcontext
.gregs
[11];
1980 *sp
= ucontext
->uc_mcontext
.gregs
[15];
1982 # error "Unsupported arch"
1986 void SignalContext::InitPcSpBp() { GetPcSpBp(context
, &pc
, &sp
, &bp
); }
1988 void MaybeReexec() {
1989 // No need to re-exec on Linux.
1993 #if SANITIZER_NETBSD
1996 uptr len
= sizeof(paxflags
);
1999 mib
[1] = internal_getpid();
2000 mib
[2] = PROC_PID_PAXFLAGS
;
2002 if (UNLIKELY(internal_sysctl(mib
, 3, &paxflags
, &len
, NULL
, 0) == -1)) {
2003 Printf("sysctl failed\n");
2007 if (UNLIKELY(paxflags
& CTL_PROC_PAXFLAGS_ASLR
)) {
2008 Printf("This sanitizer is not compatible with enabled ASLR\n");
2011 #elif SANITIZER_PPC64V2
2012 // Disable ASLR for Linux PPC64LE.
2013 int old_personality
= personality(0xffffffff);
2014 if (old_personality
!= -1 && (old_personality
& ADDR_NO_RANDOMIZE
) == 0) {
2015 VReport(1, "WARNING: Program is being run with address space layout "
2016 "randomization (ASLR) enabled which prevents the thread and "
2017 "memory sanitizers from working on powerpc64le.\n"
2018 "ASLR will be disabled and the program re-executed.\n");
2019 CHECK_NE(personality(old_personality
| ADDR_NO_RANDOMIZE
), -1);
2027 void PrintModuleMap() { }
2029 void CheckNoDeepBind(const char *filename
, int flag
) {
2030 #ifdef RTLD_DEEPBIND
2031 if (flag
& RTLD_DEEPBIND
) {
2033 "You are trying to dlopen a %s shared library with RTLD_DEEPBIND flag"
2034 " which is incompatibe with sanitizer runtime "
2035 "(see https://github.com/google/sanitizers/issues/611 for details"
2036 "). If you want to run %s library under sanitizers please remove "
2037 "RTLD_DEEPBIND from dlopen flags.\n",
2038 filename
, filename
);
2044 uptr
FindAvailableMemoryRange(uptr size
, uptr alignment
, uptr left_padding
,
2045 uptr
*largest_gap_found
,
2046 uptr
*max_occupied_addr
) {
2047 UNREACHABLE("FindAvailableMemoryRange is not available");
2051 bool GetRandom(void *buffer
, uptr length
, bool blocking
) {
2052 if (!buffer
|| !length
|| length
> 256)
2054 #if SANITIZER_USE_GETENTROPY
2055 uptr rnd
= getentropy(buffer
, length
);
2057 if (internal_iserror(rnd
, &rverrno
) && rverrno
== EFAULT
)
2061 #endif // SANITIZER_USE_GETENTROPY
2063 #if SANITIZER_USE_GETRANDOM
2064 static atomic_uint8_t skip_getrandom_syscall
;
2065 if (!atomic_load_relaxed(&skip_getrandom_syscall
)) {
2066 // Up to 256 bytes, getrandom will not be interrupted.
2067 uptr res
= internal_syscall(SYSCALL(getrandom
), buffer
, length
,
2068 blocking
? 0 : GRND_NONBLOCK
);
2070 if (internal_iserror(res
, &rverrno
) && rverrno
== ENOSYS
)
2071 atomic_store_relaxed(&skip_getrandom_syscall
, 1);
2072 else if (res
== length
)
2075 #endif // SANITIZER_USE_GETRANDOM
2076 // Up to 256 bytes, a read off /dev/urandom will not be interrupted.
2077 // blocking is moot here, O_NONBLOCK has no effect when opening /dev/urandom.
2078 uptr fd
= internal_open("/dev/urandom", O_RDONLY
);
2079 if (internal_iserror(fd
))
2081 uptr res
= internal_read(fd
, buffer
, length
);
2082 if (internal_iserror(res
))
2088 } // namespace __sanitizer