1 //===-- sanitizer_linux_libcdep.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_allocator_internal.h"
19 #include "sanitizer_atomic.h"
20 #include "sanitizer_common.h"
21 #include "sanitizer_file.h"
22 #include "sanitizer_flags.h"
23 #include "sanitizer_freebsd.h"
24 #include "sanitizer_linux.h"
25 #include "sanitizer_placement_new.h"
26 #include "sanitizer_procmaps.h"
28 #include <dlfcn.h> // for dlsym()
32 #include <sys/resource.h>
36 #include <pthread_np.h>
37 #include <osreldate.h>
38 #include <sys/sysctl.h>
39 #define pthread_getattr_np pthread_attr_get_np
43 #include <pthread_np.h>
44 #include <sys/sysctl.h>
48 #include <sys/sysctl.h>
57 #include <android/api-level.h>
58 #if !defined(CPU_COUNT) && !defined(__aarch64__)
61 struct __sanitizer::linux_dirent
{
64 unsigned short d_reclen
;
70 #if !SANITIZER_ANDROID
75 namespace __sanitizer
{
77 SANITIZER_WEAK_ATTRIBUTE
int
78 real_sigaction(int signum
, const void *act
, void *oldact
);
80 int internal_sigaction(int signum
, const void *act
, void *oldact
) {
83 return real_sigaction(signum
, act
, oldact
);
85 return sigaction(signum
, (const struct sigaction
*)act
,
86 (struct sigaction
*)oldact
);
89 void GetThreadStackTopAndBottom(bool at_initialization
, uptr
*stack_top
,
93 if (at_initialization
) {
94 // This is the main thread. Libpthread may not be initialized yet.
96 CHECK_EQ(getrlimit(RLIMIT_STACK
, &rl
), 0);
98 // Find the mapping that contains a stack variable.
99 MemoryMappingLayout
proc_maps(/*cache_enabled*/true);
100 MemoryMappedSegment segment
;
102 while (proc_maps
.Next(&segment
)) {
103 if ((uptr
)&rl
< segment
.end
) break;
104 prev_end
= segment
.end
;
106 CHECK((uptr
)&rl
>= segment
.start
&& (uptr
)&rl
< segment
.end
);
108 // Get stacksize from rlimit, but clip it so that it does not overlap
109 // with other mappings.
110 uptr stacksize
= rl
.rlim_cur
;
111 if (stacksize
> segment
.end
- prev_end
) stacksize
= segment
.end
- prev_end
;
112 // When running with unlimited stack size, we still want to set some limit.
113 // The unlimited stack size is caused by 'ulimit -s unlimited'.
114 // Also, for some reason, GNU make spawns subprocesses with unlimited stack.
115 if (stacksize
> kMaxThreadStackSize
)
116 stacksize
= kMaxThreadStackSize
;
117 *stack_top
= segment
.end
;
118 *stack_bottom
= segment
.end
- stacksize
;
122 void *stackaddr
= nullptr;
123 #if SANITIZER_SOLARIS
125 CHECK_EQ(thr_stksegment(&ss
), 0);
126 stacksize
= ss
.ss_size
;
127 stackaddr
= (char *)ss
.ss_sp
- stacksize
;
128 #elif SANITIZER_OPENBSD
130 CHECK_EQ(pthread_stackseg_np(pthread_self(), &sattr
), 0);
131 stackaddr
= sattr
.ss_sp
;
132 stacksize
= sattr
.ss_size
;
133 #else // !SANITIZER_SOLARIS
135 pthread_attr_init(&attr
);
136 CHECK_EQ(pthread_getattr_np(pthread_self(), &attr
), 0);
137 my_pthread_attr_getstack(&attr
, &stackaddr
, &stacksize
);
138 pthread_attr_destroy(&attr
);
139 #endif // SANITIZER_SOLARIS
141 *stack_top
= (uptr
)stackaddr
+ stacksize
;
142 *stack_bottom
= (uptr
)stackaddr
;
146 bool SetEnv(const char *name
, const char *value
) {
147 void *f
= dlsym(RTLD_NEXT
, "setenv");
150 typedef int(*setenv_ft
)(const char *name
, const char *value
, int overwrite
);
152 CHECK_EQ(sizeof(setenv_f
), sizeof(f
));
153 internal_memcpy(&setenv_f
, &f
, sizeof(f
));
154 return setenv_f(name
, value
, 1) == 0;
158 __attribute__((unused
)) static bool GetLibcVersion(int *major
, int *minor
,
160 #ifdef _CS_GNU_LIBC_VERSION
162 uptr len
= confstr(_CS_GNU_LIBC_VERSION
, buf
, sizeof(buf
));
163 if (len
>= sizeof(buf
))
166 static const char kGLibC
[] = "glibc ";
167 if (internal_strncmp(buf
, kGLibC
, sizeof(kGLibC
) - 1) != 0)
169 const char *p
= buf
+ sizeof(kGLibC
) - 1;
170 *major
= internal_simple_strtoll(p
, &p
, 10);
171 *minor
= (*p
== '.') ? internal_simple_strtoll(p
+ 1, &p
, 10) : 0;
172 *patch
= (*p
== '.') ? internal_simple_strtoll(p
+ 1, &p
, 10) : 0;
179 #if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO && \
180 !SANITIZER_NETBSD && !SANITIZER_OPENBSD && !SANITIZER_SOLARIS
181 static uptr g_tls_size
;
184 # ifndef __GLIBC_PREREQ
185 # define CHECK_GET_TLS_STATIC_INFO_VERSION 1
187 # define CHECK_GET_TLS_STATIC_INFO_VERSION (!__GLIBC_PREREQ(2, 27))
190 # define CHECK_GET_TLS_STATIC_INFO_VERSION 0
193 #if CHECK_GET_TLS_STATIC_INFO_VERSION
194 # define DL_INTERNAL_FUNCTION __attribute__((regparm(3), stdcall))
196 # define DL_INTERNAL_FUNCTION
200 struct GetTlsStaticInfoCall
{
201 typedef void (*get_tls_func
)(size_t*, size_t*);
203 struct GetTlsStaticInfoRegparmCall
{
204 typedef void (*get_tls_func
)(size_t*, size_t*) DL_INTERNAL_FUNCTION
;
207 template <typename T
>
208 void CallGetTls(void* ptr
, size_t* size
, size_t* align
) {
209 typename
T::get_tls_func get_tls
;
210 CHECK_EQ(sizeof(get_tls
), sizeof(ptr
));
211 internal_memcpy(&get_tls
, &ptr
, sizeof(ptr
));
212 CHECK_NE(get_tls
, 0);
213 get_tls(size
, align
);
216 bool CmpLibcVersion(int major
, int minor
, int patch
) {
220 if (!GetLibcVersion(&ma
, &mi
, &pa
))
236 // all current supported platforms have 16 bytes stack alignment
237 const size_t kStackAlign
= 16;
238 void *get_tls_static_info_ptr
= dlsym(RTLD_NEXT
, "_dl_get_tls_static_info");
240 size_t tls_align
= 0;
241 // On i?86, _dl_get_tls_static_info used to be internal_function, i.e.
242 // __attribute__((regparm(3), stdcall)) before glibc 2.27 and is normal
243 // function in 2.27 and later.
244 if (CHECK_GET_TLS_STATIC_INFO_VERSION
&& !CmpLibcVersion(2, 27, 0))
245 CallGetTls
<GetTlsStaticInfoRegparmCall
>(get_tls_static_info_ptr
,
246 &tls_size
, &tls_align
);
248 CallGetTls
<GetTlsStaticInfoCall
>(get_tls_static_info_ptr
,
249 &tls_size
, &tls_align
);
250 if (tls_align
< kStackAlign
)
251 tls_align
= kStackAlign
;
252 g_tls_size
= RoundUpTo(tls_size
, tls_align
);
255 void InitTlsSize() { }
256 #endif // !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO &&
257 // !SANITIZER_NETBSD && !SANITIZER_SOLARIS
259 #if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) || \
260 defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__) || \
261 defined(__arm__)) && \
262 SANITIZER_LINUX && !SANITIZER_ANDROID
263 // sizeof(struct pthread) from glibc.
264 static atomic_uintptr_t thread_descriptor_size
;
266 uptr
ThreadDescriptorSize() {
267 uptr val
= atomic_load_relaxed(&thread_descriptor_size
);
270 #if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
274 if (GetLibcVersion(&major
, &minor
, &patch
) && major
== 2) {
275 /* sizeof(struct pthread) values from various glibc versions. */
277 val
= 1728; // Assume only one particular version for x32.
278 // For ARM sizeof(struct pthread) changed in Glibc 2.23.
279 else if (SANITIZER_ARM
)
280 val
= minor
<= 22 ? 1120 : 1216;
282 val
= FIRST_32_SECOND_64(1104, 1696);
284 val
= FIRST_32_SECOND_64(1120, 1728);
286 val
= FIRST_32_SECOND_64(1136, 1728);
288 val
= FIRST_32_SECOND_64(1136, 1712);
289 else if (minor
== 10)
290 val
= FIRST_32_SECOND_64(1168, 1776);
291 else if (minor
== 11 || (minor
== 12 && patch
== 1))
292 val
= FIRST_32_SECOND_64(1168, 2288);
293 else if (minor
<= 14)
294 val
= FIRST_32_SECOND_64(1168, 2304);
296 val
= FIRST_32_SECOND_64(1216, 2304);
298 #elif defined(__mips__)
299 // TODO(sagarthakur): add more values as per different glibc versions.
300 val
= FIRST_32_SECOND_64(1152, 1776);
301 #elif defined(__aarch64__)
302 // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
304 #elif defined(__powerpc64__)
305 val
= 1776; // from glibc.ppc64le 2.20-8.fc21
306 #elif defined(__s390__)
307 val
= FIRST_32_SECOND_64(1152, 1776); // valid for glibc 2.22
310 atomic_store_relaxed(&thread_descriptor_size
, val
);
314 // The offset at which pointer to self is located in the thread descriptor.
315 const uptr kThreadSelfOffset
= FIRST_32_SECOND_64(8, 16);
317 uptr
ThreadSelfOffset() {
318 return kThreadSelfOffset
;
321 #if defined(__mips__) || defined(__powerpc64__)
322 // TlsPreTcbSize includes size of struct pthread_descr and size of tcb
323 // head structure. It lies before the static tls blocks.
324 static uptr
TlsPreTcbSize() {
325 # if defined(__mips__)
326 const uptr kTcbHead
= 16; // sizeof (tcbhead_t)
327 # elif defined(__powerpc64__)
328 const uptr kTcbHead
= 88; // sizeof (tcbhead_t)
330 const uptr kTlsAlign
= 16;
331 const uptr kTlsPreTcbSize
=
332 RoundUpTo(ThreadDescriptorSize() + kTcbHead
, kTlsAlign
);
333 return kTlsPreTcbSize
;
339 # if defined(__i386__)
340 asm("mov %%gs:%c1,%0" : "=r"(descr_addr
) : "i"(kThreadSelfOffset
));
341 # elif defined(__x86_64__)
342 asm("mov %%fs:%c1,%0" : "=r"(descr_addr
) : "i"(kThreadSelfOffset
));
343 # elif defined(__mips__)
344 // MIPS uses TLS variant I. The thread pointer (in hardware register $29)
345 // points to the end of the TCB + 0x7000. The pthread_descr structure is
346 // immediately in front of the TCB. TlsPreTcbSize() includes the size of the
347 // TCB and the size of pthread_descr.
348 const uptr kTlsTcbOffset
= 0x7000;
350 asm volatile(".set push;\
353 .set pop" : "=r" (thread_pointer
));
354 descr_addr
= thread_pointer
- kTlsTcbOffset
- TlsPreTcbSize();
355 # elif defined(__aarch64__) || defined(__arm__)
356 descr_addr
= reinterpret_cast<uptr
>(__builtin_thread_pointer()) -
357 ThreadDescriptorSize();
358 # elif defined(__s390__)
359 descr_addr
= reinterpret_cast<uptr
>(__builtin_thread_pointer());
360 # elif defined(__powerpc64__)
361 // PPC64LE uses TLS variant I. The thread pointer (in GPR 13)
362 // points to the end of the TCB + 0x7000. The pthread_descr structure is
363 // immediately in front of the TCB. TlsPreTcbSize() includes the size of the
364 // TCB and the size of pthread_descr.
365 const uptr kTlsTcbOffset
= 0x7000;
367 asm("addi %0,13,%1" : "=r"(thread_pointer
) : "I"(-kTlsTcbOffset
));
368 descr_addr
= thread_pointer
- TlsPreTcbSize();
370 # error "unsupported CPU arch"
374 #endif // (x86_64 || i386 || MIPS) && SANITIZER_LINUX
376 #if SANITIZER_FREEBSD
377 static void **ThreadSelfSegbase() {
379 # if defined(__i386__)
380 // sysarch(I386_GET_GSBASE, segbase);
381 __asm
__volatile("mov %%gs:0, %0" : "=r" (segbase
));
382 # elif defined(__x86_64__)
383 // sysarch(AMD64_GET_FSBASE, segbase);
384 __asm
__volatile("movq %%fs:0, %0" : "=r" (segbase
));
386 # error "unsupported CPU arch"
392 return (uptr
)ThreadSelfSegbase()[2];
394 #endif // SANITIZER_FREEBSD
397 static struct tls_tcb
* ThreadSelfTlsTcb() {
398 struct tls_tcb
* tcb
;
399 # ifdef __HAVE___LWP_GETTCB_FAST
400 tcb
= (struct tls_tcb
*)__lwp_gettcb_fast();
401 # elif defined(__HAVE___LWP_GETPRIVATE_FAST)
402 tcb
= (struct tls_tcb
*)__lwp_getprivate_fast();
408 return (uptr
)ThreadSelfTlsTcb()->tcb_pthread
;
411 int GetSizeFromHdr(struct dl_phdr_info
*info
, size_t size
, void *data
) {
412 const Elf_Phdr
*hdr
= info
->dlpi_phdr
;
413 const Elf_Phdr
*last_hdr
= hdr
+ info
->dlpi_phnum
;
415 for (; hdr
!= last_hdr
; ++hdr
) {
416 if (hdr
->p_type
== PT_TLS
&& info
->dlpi_tls_modid
== 1) {
417 *(uptr
*)data
= hdr
->p_memsz
;
423 #endif // SANITIZER_NETBSD
426 static void GetTls(uptr
*addr
, uptr
*size
) {
427 #if SANITIZER_LINUX && !SANITIZER_ANDROID
428 # if defined(__x86_64__) || defined(__i386__) || defined(__s390__)
429 *addr
= ThreadSelf();
430 *size
= GetTlsSize();
432 *addr
+= ThreadDescriptorSize();
433 # elif defined(__mips__) || defined(__aarch64__) || defined(__powerpc64__) \
435 *addr
= ThreadSelf();
436 *size
= GetTlsSize();
441 #elif SANITIZER_FREEBSD
442 void** segbase
= ThreadSelfSegbase();
447 // tls_size = round(tls_static_space, tcbalign);
449 // dtv[2] = segbase - tls_static_space;
450 void **dtv
= (void**) segbase
[1];
451 *addr
= (uptr
) dtv
[2];
452 *size
= (*addr
== 0) ? 0 : ((uptr
) segbase
[0] - (uptr
) dtv
[2]);
454 #elif SANITIZER_NETBSD
455 struct tls_tcb
* const tcb
= ThreadSelfTlsTcb();
459 // Find size (p_memsz) of dlpi_tls_modid 1 (TLS block of the main program).
460 // ld.elf_so hardcodes the index 1.
461 dl_iterate_phdr(GetSizeFromHdr
, size
);
464 // The block has been found and tcb_dtv[1] contains the base address
465 *addr
= (uptr
)tcb
->tcb_dtv
[1];
468 #elif SANITIZER_OPENBSD
471 #elif SANITIZER_ANDROID
474 #elif SANITIZER_SOLARIS
486 #if SANITIZER_FREEBSD || SANITIZER_ANDROID || SANITIZER_NETBSD || \
487 SANITIZER_OPENBSD || SANITIZER_SOLARIS
489 GetTls(&addr
, &size
);
491 #elif defined(__mips__) || defined(__powerpc64__)
492 return RoundUpTo(g_tls_size
+ TlsPreTcbSize(), 16);
499 void GetThreadStackAndTls(bool main
, uptr
*stk_addr
, uptr
*stk_size
,
500 uptr
*tls_addr
, uptr
*tls_size
) {
502 // Stub implementation for Go.
503 *stk_addr
= *stk_size
= *tls_addr
= *tls_size
= 0;
505 GetTls(tls_addr
, tls_size
);
507 uptr stack_top
, stack_bottom
;
508 GetThreadStackTopAndBottom(main
, &stack_top
, &stack_bottom
);
509 *stk_addr
= stack_bottom
;
510 *stk_size
= stack_top
- stack_bottom
;
513 // If stack and tls intersect, make them non-intersecting.
514 if (*tls_addr
> *stk_addr
&& *tls_addr
< *stk_addr
+ *stk_size
) {
515 CHECK_GT(*tls_addr
+ *tls_size
, *stk_addr
);
516 CHECK_LE(*tls_addr
+ *tls_size
, *stk_addr
+ *stk_size
);
517 *stk_size
-= *tls_size
;
518 *tls_addr
= *stk_addr
+ *stk_size
;
524 #if !SANITIZER_FREEBSD && !SANITIZER_OPENBSD
525 typedef ElfW(Phdr
) Elf_Phdr
;
526 #elif SANITIZER_WORDSIZE == 32 && __FreeBSD_version <= 902001 // v9.2
527 #define Elf_Phdr XElf32_Phdr
528 #define dl_phdr_info xdl_phdr_info
529 #define dl_iterate_phdr(c, b) xdl_iterate_phdr((c), (b))
530 #endif // !SANITIZER_FREEBSD && !SANITIZER_OPENBSD
532 struct DlIteratePhdrData
{
533 InternalMmapVectorNoCtor
<LoadedModule
> *modules
;
537 static int dl_iterate_phdr_cb(dl_phdr_info
*info
, size_t size
, void *arg
) {
538 DlIteratePhdrData
*data
= (DlIteratePhdrData
*)arg
;
539 InternalScopedString
module_name(kMaxPathLength
);
542 // First module is the binary itself.
543 ReadBinaryNameCached(module_name
.data(), module_name
.size());
544 } else if (info
->dlpi_name
) {
545 module_name
.append("%s", info
->dlpi_name
);
547 if (module_name
[0] == '\0')
549 LoadedModule cur_module
;
550 cur_module
.set(module_name
.data(), info
->dlpi_addr
);
551 for (int i
= 0; i
< (int)info
->dlpi_phnum
; i
++) {
552 const Elf_Phdr
*phdr
= &info
->dlpi_phdr
[i
];
553 if (phdr
->p_type
== PT_LOAD
) {
554 uptr cur_beg
= info
->dlpi_addr
+ phdr
->p_vaddr
;
555 uptr cur_end
= cur_beg
+ phdr
->p_memsz
;
556 bool executable
= phdr
->p_flags
& PF_X
;
557 bool writable
= phdr
->p_flags
& PF_W
;
558 cur_module
.addAddressRange(cur_beg
, cur_end
, executable
,
562 data
->modules
->push_back(cur_module
);
566 #if SANITIZER_ANDROID && __ANDROID_API__ < 21
567 extern "C" __attribute__((weak
)) int dl_iterate_phdr(
568 int (*)(struct dl_phdr_info
*, size_t, void *), void *);
571 static bool requiresProcmaps() {
572 #if SANITIZER_ANDROID && __ANDROID_API__ <= 22
573 // Fall back to /proc/maps if dl_iterate_phdr is unavailable or broken.
574 // The runtime check allows the same library to work with
575 // both K and L (and future) Android releases.
576 return AndroidGetApiLevel() <= ANDROID_LOLLIPOP_MR1
;
582 static void procmapsInit(InternalMmapVectorNoCtor
<LoadedModule
> *modules
) {
583 MemoryMappingLayout
memory_mapping(/*cache_enabled*/true);
584 memory_mapping
.DumpListOfModules(modules
);
587 void ListOfModules::init() {
589 if (requiresProcmaps()) {
590 procmapsInit(&modules_
);
592 DlIteratePhdrData data
= {&modules_
, true};
593 dl_iterate_phdr(dl_iterate_phdr_cb
, &data
);
597 // When a custom loader is used, dl_iterate_phdr may not contain the full
598 // list of modules. Allow callers to fall back to using procmaps.
599 void ListOfModules::fallbackInit() {
600 if (!requiresProcmaps()) {
602 procmapsInit(&modules_
);
608 // getrusage does not give us the current RSS, only the max RSS.
609 // Still, this is better than nothing if /proc/self/statm is not available
610 // for some reason, e.g. due to a sandbox.
611 static uptr
GetRSSFromGetrusage() {
613 if (getrusage(RUSAGE_SELF
, &usage
)) // Failed, probably due to a sandbox.
615 return usage
.ru_maxrss
<< 10; // ru_maxrss is in Kb.
619 if (!common_flags()->can_use_proc_maps_statm
)
620 return GetRSSFromGetrusage();
621 fd_t fd
= OpenFile("/proc/self/statm", RdOnly
);
622 if (fd
== kInvalidFd
)
623 return GetRSSFromGetrusage();
625 uptr len
= internal_read(fd
, buf
, sizeof(buf
) - 1);
630 // The format of the file is:
631 // 1084 89 69 11 0 79 0
632 // We need the second number which is RSS in pages.
634 // Skip the first number.
635 while (*pos
>= '0' && *pos
<= '9')
638 while (!(*pos
>= '0' && *pos
<= '9') && *pos
!= 0)
642 while (*pos
>= '0' && *pos
<= '9')
643 rss
= rss
* 10 + *pos
++ - '0';
644 return rss
* GetPageSizeCached();
647 // sysconf(_SC_NPROCESSORS_{CONF,ONLN}) cannot be used on most platforms as
648 // they allocate memory.
649 u32
GetNumberOfCPUs() {
650 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD
653 uptr len
= sizeof(ncpu
);
656 CHECK_EQ(internal_sysctl(req
, 2, &ncpu
, &len
, NULL
, 0), 0);
658 #elif SANITIZER_ANDROID && !defined(CPU_COUNT) && !defined(__aarch64__)
659 // Fall back to /sys/devices/system/cpu on Android when cpu_set_t doesn't
660 // exist in sched.h. That is the case for toolchains generated with older
662 // This code doesn't work on AArch64 because internal_getdents makes use of
663 // the 64bit getdents syscall, but cpu_set_t seems to always exist on AArch64.
664 uptr fd
= internal_open("/sys/devices/system/cpu", O_RDONLY
| O_DIRECTORY
);
665 if (internal_iserror(fd
))
667 InternalMmapVector
<u8
> buffer(4096);
668 uptr bytes_read
= buffer
.size();
671 struct linux_dirent
*entry
= (struct linux_dirent
*)&buffer
[bytes_read
];
673 if ((u8
*)entry
>= &buffer
[bytes_read
]) {
674 bytes_read
= internal_getdents(fd
, (struct linux_dirent
*)buffer
.data(),
676 if (internal_iserror(bytes_read
) || !bytes_read
)
678 entry
= (struct linux_dirent
*)buffer
.data();
680 d_type
= (u8
*)entry
+ entry
->d_reclen
- 1;
681 if (d_type
>= &buffer
[bytes_read
] ||
682 (u8
*)&entry
->d_name
[3] >= &buffer
[bytes_read
])
684 if (entry
->d_ino
!= 0 && *d_type
== DT_DIR
) {
685 if (entry
->d_name
[0] == 'c' && entry
->d_name
[1] == 'p' &&
686 entry
->d_name
[2] == 'u' &&
687 entry
->d_name
[3] >= '0' && entry
->d_name
[3] <= '9')
690 entry
= (struct linux_dirent
*)(((u8
*)entry
) + entry
->d_reclen
);
694 #elif SANITIZER_SOLARIS
695 return sysconf(_SC_NPROCESSORS_ONLN
);
697 #if defined(CPU_COUNT)
699 CHECK_EQ(sched_getaffinity(0, sizeof(cpu_set_t
), &CPUs
), 0);
700 return CPU_COUNT(&CPUs
);
709 # if SANITIZER_ANDROID
710 static atomic_uint8_t android_log_initialized
;
712 void AndroidLogInit() {
713 openlog(GetProcessName(), 0, LOG_USER
);
714 atomic_store(&android_log_initialized
, 1, memory_order_release
);
717 static bool ShouldLogAfterPrintf() {
718 return atomic_load(&android_log_initialized
, memory_order_acquire
);
721 extern "C" SANITIZER_WEAK_ATTRIBUTE
722 int async_safe_write_log(int pri
, const char* tag
, const char* msg
);
723 extern "C" SANITIZER_WEAK_ATTRIBUTE
724 int __android_log_write(int prio
, const char* tag
, const char* msg
);
726 // ANDROID_LOG_INFO is 4, but can't be resolved at runtime.
727 #define SANITIZER_ANDROID_LOG_INFO 4
729 // async_safe_write_log is a new public version of __libc_write_log that is
730 // used behind syslog. It is preferable to syslog as it will not do any dynamic
731 // memory allocation or formatting.
732 // If the function is not available, syslog is preferred for L+ (it was broken
733 // pre-L) as __android_log_write triggers a racey behavior with the strncpy
734 // interceptor. Fallback to __android_log_write pre-L.
735 void WriteOneLineToSyslog(const char *s
) {
736 if (&async_safe_write_log
) {
737 async_safe_write_log(SANITIZER_ANDROID_LOG_INFO
, GetProcessName(), s
);
738 } else if (AndroidGetApiLevel() > ANDROID_KITKAT
) {
739 syslog(LOG_INFO
, "%s", s
);
741 CHECK(&__android_log_write
);
742 __android_log_write(SANITIZER_ANDROID_LOG_INFO
, nullptr, s
);
746 extern "C" SANITIZER_WEAK_ATTRIBUTE
747 void android_set_abort_message(const char *);
749 void SetAbortMessage(const char *str
) {
750 if (&android_set_abort_message
)
751 android_set_abort_message(str
);
754 void AndroidLogInit() {}
756 static bool ShouldLogAfterPrintf() { return true; }
758 void WriteOneLineToSyslog(const char *s
) { syslog(LOG_INFO
, "%s", s
); }
760 void SetAbortMessage(const char *str
) {}
761 # endif // SANITIZER_ANDROID
763 void LogMessageOnPrintf(const char *str
) {
764 if (common_flags()->log_to_syslog
&& ShouldLogAfterPrintf())
768 #endif // SANITIZER_LINUX
770 #if SANITIZER_LINUX && !SANITIZER_GO
771 // glibc crashes when using clock_gettime from a preinit_array function as the
772 // vDSO function pointers haven't been initialized yet. __progname is
773 // initialized after the vDSO function pointers, so if it exists, is not null
774 // and is not empty, we can use clock_gettime.
775 extern "C" SANITIZER_WEAK_ATTRIBUTE
char *__progname
;
776 INLINE
bool CanUseVDSO() {
777 // Bionic is safe, it checks for the vDSO function pointers to be initialized.
778 if (SANITIZER_ANDROID
)
780 if (&__progname
&& __progname
&& *__progname
)
785 // MonotonicNanoTime is a timing function that can leverage the vDSO by calling
786 // clock_gettime. real_clock_gettime only exists if clock_gettime is
787 // intercepted, so define it weakly and use it if available.
788 extern "C" SANITIZER_WEAK_ATTRIBUTE
789 int real_clock_gettime(u32 clk_id
, void *tp
);
790 u64
MonotonicNanoTime() {
793 if (&real_clock_gettime
)
794 real_clock_gettime(CLOCK_MONOTONIC
, &ts
);
796 clock_gettime(CLOCK_MONOTONIC
, &ts
);
798 internal_clock_gettime(CLOCK_MONOTONIC
, &ts
);
800 return (u64
)ts
.tv_sec
* (1000ULL * 1000 * 1000) + ts
.tv_nsec
;
803 // Non-Linux & Go always use the syscall.
804 u64
MonotonicNanoTime() {
806 internal_clock_gettime(CLOCK_MONOTONIC
, &ts
);
807 return (u64
)ts
.tv_sec
* (1000ULL * 1000 * 1000) + ts
.tv_nsec
;
809 #endif // SANITIZER_LINUX && !SANITIZER_GO
811 } // namespace __sanitizer