1 //===-- sanitizer_linux_libcdep.cpp ---------------------------------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file is shared between AddressSanitizer and ThreadSanitizer
10 // run-time libraries and implements linux-specific functions from
12 //===----------------------------------------------------------------------===//
14 #include "sanitizer_platform.h"
16 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
19 #include "sanitizer_allocator_internal.h"
20 #include "sanitizer_atomic.h"
21 #include "sanitizer_common.h"
22 #include "sanitizer_file.h"
23 #include "sanitizer_flags.h"
24 #include "sanitizer_freebsd.h"
25 #include "sanitizer_getauxval.h"
26 #include "sanitizer_glibc_version.h"
27 #include "sanitizer_linux.h"
28 #include "sanitizer_placement_new.h"
29 #include "sanitizer_procmaps.h"
30 #include "sanitizer_solaris.h"
33 #define _RTLD_SOURCE // for __lwp_gettcb_fast() / __lwp_getprivate_fast()
36 #include <dlfcn.h> // for dlsym()
41 #include <sys/resource.h>
45 #define ElfW(type) Elf_##type
49 #include <pthread_np.h>
50 #include <osreldate.h>
51 #include <sys/sysctl.h>
52 #define pthread_getattr_np pthread_attr_get_np
53 // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
54 // that, it was never implemented. So just define it to zero.
56 #define MAP_NORESERVE 0
60 #include <sys/sysctl.h>
72 #include <android/api-level.h>
73 #if !defined(CPU_COUNT) && !defined(__aarch64__)
76 struct __sanitizer::linux_dirent
{
79 unsigned short d_reclen
;
85 #if !SANITIZER_ANDROID
90 namespace __sanitizer
{
92 SANITIZER_WEAK_ATTRIBUTE
int
93 real_sigaction(int signum
, const void *act
, void *oldact
);
95 int internal_sigaction(int signum
, const void *act
, void *oldact
) {
98 return real_sigaction(signum
, act
, oldact
);
100 return sigaction(signum
, (const struct sigaction
*)act
,
101 (struct sigaction
*)oldact
);
104 void GetThreadStackTopAndBottom(bool at_initialization
, uptr
*stack_top
,
105 uptr
*stack_bottom
) {
108 if (at_initialization
) {
109 // This is the main thread. Libpthread may not be initialized yet.
111 CHECK_EQ(getrlimit(RLIMIT_STACK
, &rl
), 0);
113 // Find the mapping that contains a stack variable.
114 MemoryMappingLayout
proc_maps(/*cache_enabled*/true);
115 if (proc_maps
.Error()) {
116 *stack_top
= *stack_bottom
= 0;
119 MemoryMappedSegment segment
;
121 while (proc_maps
.Next(&segment
)) {
122 if ((uptr
)&rl
< segment
.end
) break;
123 prev_end
= segment
.end
;
125 CHECK((uptr
)&rl
>= segment
.start
&& (uptr
)&rl
< segment
.end
);
127 // Get stacksize from rlimit, but clip it so that it does not overlap
128 // with other mappings.
129 uptr stacksize
= rl
.rlim_cur
;
130 if (stacksize
> segment
.end
- prev_end
) stacksize
= segment
.end
- prev_end
;
131 // When running with unlimited stack size, we still want to set some limit.
132 // The unlimited stack size is caused by 'ulimit -s unlimited'.
133 // Also, for some reason, GNU make spawns subprocesses with unlimited stack.
134 if (stacksize
> kMaxThreadStackSize
)
135 stacksize
= kMaxThreadStackSize
;
136 *stack_top
= segment
.end
;
137 *stack_bottom
= segment
.end
- stacksize
;
141 void *stackaddr
= nullptr;
142 #if SANITIZER_SOLARIS
144 CHECK_EQ(thr_stksegment(&ss
), 0);
145 stacksize
= ss
.ss_size
;
146 stackaddr
= (char *)ss
.ss_sp
- stacksize
;
147 #else // !SANITIZER_SOLARIS
149 pthread_attr_init(&attr
);
150 CHECK_EQ(pthread_getattr_np(pthread_self(), &attr
), 0);
151 internal_pthread_attr_getstack(&attr
, &stackaddr
, &stacksize
);
152 pthread_attr_destroy(&attr
);
153 #endif // SANITIZER_SOLARIS
155 *stack_top
= (uptr
)stackaddr
+ stacksize
;
156 *stack_bottom
= (uptr
)stackaddr
;
160 bool SetEnv(const char *name
, const char *value
) {
161 void *f
= dlsym(RTLD_NEXT
, "setenv");
164 typedef int(*setenv_ft
)(const char *name
, const char *value
, int overwrite
);
166 CHECK_EQ(sizeof(setenv_f
), sizeof(f
));
167 internal_memcpy(&setenv_f
, &f
, sizeof(f
));
168 return setenv_f(name
, value
, 1) == 0;
172 __attribute__((unused
)) static bool GetLibcVersion(int *major
, int *minor
,
174 #ifdef _CS_GNU_LIBC_VERSION
176 uptr len
= confstr(_CS_GNU_LIBC_VERSION
, buf
, sizeof(buf
));
177 if (len
>= sizeof(buf
))
180 static const char kGLibC
[] = "glibc ";
181 if (internal_strncmp(buf
, kGLibC
, sizeof(kGLibC
) - 1) != 0)
183 const char *p
= buf
+ sizeof(kGLibC
) - 1;
184 *major
= internal_simple_strtoll(p
, &p
, 10);
185 *minor
= (*p
== '.') ? internal_simple_strtoll(p
+ 1, &p
, 10) : 0;
186 *patch
= (*p
== '.') ? internal_simple_strtoll(p
+ 1, &p
, 10) : 0;
193 // True if we can use dlpi_tls_data. glibc before 2.25 may leave NULL (BZ
194 // #19826) so dlpi_tls_data cannot be used.
196 // musl before 1.2.3 and FreeBSD as of 12.2 incorrectly set dlpi_tls_data to
197 // the TLS initialization image
198 // https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=254774
199 __attribute__((unused
)) static int g_use_dlpi_tls_data
;
201 #if SANITIZER_GLIBC && !SANITIZER_GO
202 __attribute__((unused
)) static size_t g_tls_size
;
204 int major
, minor
, patch
;
205 g_use_dlpi_tls_data
=
206 GetLibcVersion(&major
, &minor
, &patch
) && major
== 2 && minor
>= 25;
208 #if defined(__aarch64__) || defined(__x86_64__) || defined(__powerpc64__) || \
209 defined(__loongarch__)
210 void *get_tls_static_info
= dlsym(RTLD_NEXT
, "_dl_get_tls_static_info");
212 ((void (*)(size_t *, size_t *))get_tls_static_info
)(&g_tls_size
, &tls_align
);
216 void InitTlsSize() { }
217 #endif // SANITIZER_GLIBC && !SANITIZER_GO
219 // On glibc x86_64, ThreadDescriptorSize() needs to be precise due to the usage
220 // of g_tls_size. On other targets, ThreadDescriptorSize() is only used by lsan
221 // to get the pointer to thread-specific data keys in the thread control block.
222 #if (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_SOLARIS) && \
223 !SANITIZER_ANDROID && !SANITIZER_GO
224 // sizeof(struct pthread) from glibc.
225 static atomic_uintptr_t thread_descriptor_size
;
227 static uptr
ThreadDescriptorSizeFallback() {
229 #if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
233 if (GetLibcVersion(&major
, &minor
, &patch
) && major
== 2) {
234 /* sizeof(struct pthread) values from various glibc versions. */
236 val
= 1728; // Assume only one particular version for x32.
237 // For ARM sizeof(struct pthread) changed in Glibc 2.23.
238 else if (SANITIZER_ARM
)
239 val
= minor
<= 22 ? 1120 : 1216;
241 val
= FIRST_32_SECOND_64(1104, 1696);
243 val
= FIRST_32_SECOND_64(1120, 1728);
245 val
= FIRST_32_SECOND_64(1136, 1728);
247 val
= FIRST_32_SECOND_64(1136, 1712);
248 else if (minor
== 10)
249 val
= FIRST_32_SECOND_64(1168, 1776);
250 else if (minor
== 11 || (minor
== 12 && patch
== 1))
251 val
= FIRST_32_SECOND_64(1168, 2288);
252 else if (minor
<= 14)
253 val
= FIRST_32_SECOND_64(1168, 2304);
254 else if (minor
< 32) // Unknown version
255 val
= FIRST_32_SECOND_64(1216, 2304);
257 val
= FIRST_32_SECOND_64(1344, 2496);
259 #elif defined(__s390__) || defined(__sparc__)
260 // The size of a prefix of TCB including pthread::{specific_1stblock,specific}
261 // suffices. Just return offsetof(struct pthread, specific_used), which hasn't
262 // changed since 2007-05. Technically this applies to i386/x86_64 as well but
263 // we call _dl_get_tls_static_info and need the precise size of struct
265 return FIRST_32_SECOND_64(524, 1552);
266 #elif defined(__mips__)
267 // TODO(sagarthakur): add more values as per different glibc versions.
268 val
= FIRST_32_SECOND_64(1152, 1776);
269 #elif SANITIZER_LOONGARCH64
270 val
= 1856; // from glibc 2.36
271 #elif SANITIZER_RISCV64
275 if (GetLibcVersion(&major
, &minor
, &patch
) && major
== 2) {
276 // TODO: consider adding an optional runtime check for an unknown (untested)
278 if (minor
<= 28) // WARNING: the highest tested version is 2.29
279 val
= 1772; // no guarantees for this one
280 else if (minor
<= 31)
281 val
= 1772; // tested against glibc 2.29, 2.31
283 val
= 1936; // tested against glibc 2.32
286 #elif defined(__aarch64__)
287 // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
289 #elif defined(__powerpc64__)
290 val
= 1776; // from glibc.ppc64le 2.20-8.fc21
295 uptr
ThreadDescriptorSize() {
296 uptr val
= atomic_load_relaxed(&thread_descriptor_size
);
299 // _thread_db_sizeof_pthread is a GLIBC_PRIVATE symbol that is exported in
300 // glibc 2.34 and later.
301 if (unsigned *psizeof
= static_cast<unsigned *>(
302 dlsym(RTLD_DEFAULT
, "_thread_db_sizeof_pthread")))
305 val
= ThreadDescriptorSizeFallback();
306 atomic_store_relaxed(&thread_descriptor_size
, val
);
310 #if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64 || \
311 SANITIZER_LOONGARCH64
312 // TlsPreTcbSize includes size of struct pthread_descr and size of tcb
313 // head structure. It lies before the static tls blocks.
314 static uptr
TlsPreTcbSize() {
315 #if defined(__mips__)
316 const uptr kTcbHead
= 16; // sizeof (tcbhead_t)
317 #elif defined(__powerpc64__)
318 const uptr kTcbHead
= 88; // sizeof (tcbhead_t)
319 #elif SANITIZER_RISCV64
320 const uptr kTcbHead
= 16; // sizeof (tcbhead_t)
321 #elif SANITIZER_LOONGARCH64
322 const uptr kTcbHead
= 16; // sizeof (tcbhead_t)
324 const uptr kTlsAlign
= 16;
325 const uptr kTlsPreTcbSize
=
326 RoundUpTo(ThreadDescriptorSize() + kTcbHead
, kTlsAlign
);
327 return kTlsPreTcbSize
;
333 uptr begin
, end
, align
;
335 bool operator<(const TlsBlock
&rhs
) const { return begin
< rhs
.begin
; }
340 extern "C" uptr
__tls_get_offset(void *arg
);
342 static uptr
TlsGetOffset(uptr ti_module
, uptr ti_offset
) {
343 // The __tls_get_offset ABI requires %r12 to point to GOT and %r2 to be an
344 // offset of a struct tls_index inside GOT. We don't possess either of the
345 // two, so violate the letter of the "ELF Handling For Thread-Local
346 // Storage" document and assume that the implementation just dereferences
348 uptr tls_index
[2] = {ti_module
, ti_offset
};
349 register uptr r2
asm("2") = 0;
350 register void *r12
asm("12") = tls_index
;
351 asm("basr %%r14, %[__tls_get_offset]"
353 : [__tls_get_offset
] "r"(__tls_get_offset
), "r"(r12
)
354 : "memory", "cc", "0", "1", "3", "4", "5", "14");
358 extern "C" void *__tls_get_addr(size_t *);
361 static size_t main_tls_modid
;
363 static int CollectStaticTlsBlocks(struct dl_phdr_info
*info
, size_t size
,
366 #if SANITIZER_SOLARIS
367 // dlpi_tls_modid is only available since Solaris 11.4 SRU 10. Use
368 // dlinfo(RTLD_DI_LINKMAP) instead which works on all of Solaris 11.3,
369 // 11.4, and Illumos. The tlsmodid of the executable was changed to 1 in
370 // 11.4 to match other implementations.
371 if (size
>= offsetof(dl_phdr_info_test
, dlpi_tls_modid
))
375 g_use_dlpi_tls_data
= 0;
377 dlinfo(RTLD_SELF
, RTLD_DI_LINKMAP
, &map
);
378 tls_modid
= map
->rt_tlsmodid
;
381 tls_modid
= info
->dlpi_tls_modid
;
384 if (tls_modid
< main_tls_modid
)
387 #if !SANITIZER_SOLARIS
388 begin
= (uptr
)info
->dlpi_tls_data
;
390 if (!g_use_dlpi_tls_data
) {
391 // Call __tls_get_addr as a fallback. This forces TLS allocation on glibc
394 begin
= (uptr
)__builtin_thread_pointer() +
395 TlsGetOffset(tls_modid
, 0);
397 size_t mod_and_off
[2] = {tls_modid
, 0};
398 begin
= (uptr
)__tls_get_addr(mod_and_off
);
401 for (unsigned i
= 0; i
!= info
->dlpi_phnum
; ++i
)
402 if (info
->dlpi_phdr
[i
].p_type
== PT_TLS
) {
403 static_cast<InternalMmapVector
<TlsBlock
> *>(data
)->push_back(
404 TlsBlock
{begin
, begin
+ info
->dlpi_phdr
[i
].p_memsz
,
405 info
->dlpi_phdr
[i
].p_align
, tls_modid
});
411 __attribute__((unused
)) static void GetStaticTlsBoundary(uptr
*addr
, uptr
*size
,
413 InternalMmapVector
<TlsBlock
> ranges
;
414 dl_iterate_phdr(CollectStaticTlsBlocks
, &ranges
);
415 uptr len
= ranges
.size();
416 Sort(ranges
.begin(), len
);
417 // Find the range with tls_modid == main_tls_modid. For glibc, because
418 // libc.so uses PT_TLS, this module is guaranteed to exist and is one of
419 // the initially loaded modules.
421 while (one
!= len
&& ranges
[one
].tls_modid
!= main_tls_modid
) ++one
;
423 // This may happen with musl if no module uses PT_TLS.
429 // Find the maximum consecutive ranges. We consider two modules consecutive if
430 // the gap is smaller than the alignment of the latter range. The dynamic
431 // loader places static TLS blocks this way not to waste space.
433 *align
= ranges
[l
].align
;
434 while (l
!= 0 && ranges
[l
].begin
< ranges
[l
- 1].end
+ ranges
[l
].align
)
435 *align
= Max(*align
, ranges
[--l
].align
);
437 while (r
!= len
&& ranges
[r
].begin
< ranges
[r
- 1].end
+ ranges
[r
].align
)
438 *align
= Max(*align
, ranges
[r
++].align
);
439 *addr
= ranges
[l
].begin
;
440 *size
= ranges
[r
- 1].end
- ranges
[l
].begin
;
442 #endif // (x86_64 || i386 || mips || ...) && (SANITIZER_FREEBSD ||
443 // SANITIZER_LINUX) && !SANITIZER_ANDROID && !SANITIZER_GO
446 static struct tls_tcb
* ThreadSelfTlsTcb() {
447 struct tls_tcb
*tcb
= nullptr;
448 #ifdef __HAVE___LWP_GETTCB_FAST
449 tcb
= (struct tls_tcb
*)__lwp_gettcb_fast();
450 #elif defined(__HAVE___LWP_GETPRIVATE_FAST)
451 tcb
= (struct tls_tcb
*)__lwp_getprivate_fast();
457 return (uptr
)ThreadSelfTlsTcb()->tcb_pthread
;
460 int GetSizeFromHdr(struct dl_phdr_info
*info
, size_t size
, void *data
) {
461 const Elf_Phdr
*hdr
= info
->dlpi_phdr
;
462 const Elf_Phdr
*last_hdr
= hdr
+ info
->dlpi_phnum
;
464 for (; hdr
!= last_hdr
; ++hdr
) {
465 if (hdr
->p_type
== PT_TLS
&& info
->dlpi_tls_modid
== 1) {
466 *(uptr
*)data
= hdr
->p_memsz
;
472 #endif // SANITIZER_NETBSD
474 #if SANITIZER_ANDROID
475 // Bionic provides this API since S.
476 extern "C" SANITIZER_WEAK_ATTRIBUTE
void __libc_get_static_tls_bounds(void **,
481 static void GetTls(uptr
*addr
, uptr
*size
) {
482 #if SANITIZER_ANDROID
483 if (&__libc_get_static_tls_bounds
) {
486 __libc_get_static_tls_bounds(&start_addr
, &end_addr
);
487 *addr
= reinterpret_cast<uptr
>(start_addr
);
489 reinterpret_cast<uptr
>(end_addr
) - reinterpret_cast<uptr
>(start_addr
);
494 #elif SANITIZER_GLIBC && defined(__x86_64__)
495 // For aarch64 and x86-64, use an O(1) approach which requires relatively
496 // precise ThreadDescriptorSize. g_tls_size was initialized in InitTlsSize.
498 asm("mov %%fs:8,%0" : "=r"(*addr
));
500 asm("mov %%fs:16,%0" : "=r"(*addr
));
504 *addr
+= ThreadDescriptorSize();
505 #elif SANITIZER_GLIBC && defined(__aarch64__)
506 *addr
= reinterpret_cast<uptr
>(__builtin_thread_pointer()) -
507 ThreadDescriptorSize();
508 *size
= g_tls_size
+ ThreadDescriptorSize();
509 #elif SANITIZER_GLIBC && defined(__loongarch__)
511 *addr
= reinterpret_cast<uptr
>(__builtin_thread_pointer()) -
512 ThreadDescriptorSize();
514 asm("or %0,$tp,$zero" : "=r"(*addr
));
515 *addr
-= ThreadDescriptorSize();
517 *size
= g_tls_size
+ ThreadDescriptorSize();
518 #elif SANITIZER_GLIBC && defined(__powerpc64__)
519 // Workaround for glibc<2.25(?). 2.27 is known to not need this.
521 asm("addi %0,13,-0x7000" : "=r"(tp
));
522 const uptr pre_tcb_size
= TlsPreTcbSize();
523 *addr
= tp
- pre_tcb_size
;
524 *size
= g_tls_size
+ pre_tcb_size
;
525 #elif SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_SOLARIS
527 GetStaticTlsBoundary(addr
, size
, &align
);
528 #if defined(__x86_64__) || defined(__i386__) || defined(__s390__) || \
530 if (SANITIZER_GLIBC
) {
531 #if defined(__x86_64__) || defined(__i386__)
532 align
= Max
<uptr
>(align
, 64);
534 align
= Max
<uptr
>(align
, 16);
537 const uptr tp
= RoundUpTo(*addr
+ *size
, align
);
539 // lsan requires the range to additionally cover the static TLS surplus
540 // (elf/dl-tls.c defines 1664). Otherwise there may be false positives for
541 // allocations only referenced by tls in dynamically loaded modules.
544 else if (SANITIZER_FREEBSD
)
545 *size
+= 128; // RTLD_STATIC_TLS_EXTRA
547 // Extend the range to include the thread control block. On glibc, lsan needs
548 // the range to include pthread::{specific_1stblock,specific} so that
549 // allocations only referenced by pthread_setspecific can be scanned. This may
550 // underestimate by at most TLS_TCB_ALIGN-1 bytes but it should be fine
551 // because the number of bytes after pthread::specific is larger.
552 *addr
= tp
- RoundUpTo(*size
, align
);
553 *size
= tp
- *addr
+ ThreadDescriptorSize();
557 else if (SANITIZER_FREEBSD
)
558 *size
+= 128; // RTLD_STATIC_TLS_EXTRA
559 #if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
560 const uptr pre_tcb_size
= TlsPreTcbSize();
561 *addr
-= pre_tcb_size
;
562 *size
+= pre_tcb_size
;
564 // arm and aarch64 reserve two words at TP, so this underestimates the range.
565 // However, this is sufficient for the purpose of finding the pointers to
566 // thread-specific data keys.
567 const uptr tcb_size
= ThreadDescriptorSize();
572 #elif SANITIZER_NETBSD
573 struct tls_tcb
* const tcb
= ThreadSelfTlsTcb();
577 // Find size (p_memsz) of dlpi_tls_modid 1 (TLS block of the main program).
578 // ld.elf_so hardcodes the index 1.
579 dl_iterate_phdr(GetSizeFromHdr
, size
);
582 // The block has been found and tcb_dtv[1] contains the base address
583 *addr
= (uptr
)tcb
->tcb_dtv
[1];
594 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
597 GetTls(&addr
, &size
);
605 void GetThreadStackAndTls(bool main
, uptr
*stk_addr
, uptr
*stk_size
,
606 uptr
*tls_addr
, uptr
*tls_size
) {
608 // Stub implementation for Go.
609 *stk_addr
= *stk_size
= *tls_addr
= *tls_size
= 0;
611 GetTls(tls_addr
, tls_size
);
613 uptr stack_top
, stack_bottom
;
614 GetThreadStackTopAndBottom(main
, &stack_top
, &stack_bottom
);
615 *stk_addr
= stack_bottom
;
616 *stk_size
= stack_top
- stack_bottom
;
619 // If stack and tls intersect, make them non-intersecting.
620 if (*tls_addr
> *stk_addr
&& *tls_addr
< *stk_addr
+ *stk_size
) {
621 if (*stk_addr
+ *stk_size
< *tls_addr
+ *tls_size
)
622 *tls_size
= *stk_addr
+ *stk_size
- *tls_addr
;
623 *stk_size
= *tls_addr
- *stk_addr
;
629 #if !SANITIZER_FREEBSD
630 typedef ElfW(Phdr
) Elf_Phdr
;
631 #elif SANITIZER_WORDSIZE == 32 && __FreeBSD_version <= 902001 // v9.2
632 #define Elf_Phdr XElf32_Phdr
633 #define dl_phdr_info xdl_phdr_info
634 #define dl_iterate_phdr(c, b) xdl_iterate_phdr((c), (b))
635 #endif // !SANITIZER_FREEBSD
637 struct DlIteratePhdrData
{
638 InternalMmapVectorNoCtor
<LoadedModule
> *modules
;
642 static int AddModuleSegments(const char *module_name
, dl_phdr_info
*info
,
643 InternalMmapVectorNoCtor
<LoadedModule
> *modules
) {
644 if (module_name
[0] == '\0')
646 LoadedModule cur_module
;
647 cur_module
.set(module_name
, info
->dlpi_addr
);
648 for (int i
= 0; i
< (int)info
->dlpi_phnum
; i
++) {
649 const Elf_Phdr
*phdr
= &info
->dlpi_phdr
[i
];
650 if (phdr
->p_type
== PT_LOAD
) {
651 uptr cur_beg
= info
->dlpi_addr
+ phdr
->p_vaddr
;
652 uptr cur_end
= cur_beg
+ phdr
->p_memsz
;
653 bool executable
= phdr
->p_flags
& PF_X
;
654 bool writable
= phdr
->p_flags
& PF_W
;
655 cur_module
.addAddressRange(cur_beg
, cur_end
, executable
,
657 } else if (phdr
->p_type
== PT_NOTE
) {
658 # ifdef NT_GNU_BUILD_ID
660 while (off
+ sizeof(ElfW(Nhdr
)) < phdr
->p_memsz
) {
661 auto *nhdr
= reinterpret_cast<const ElfW(Nhdr
) *>(info
->dlpi_addr
+
662 phdr
->p_vaddr
+ off
);
663 constexpr auto kGnuNamesz
= 4; // "GNU" with NUL-byte.
664 static_assert(kGnuNamesz
% 4 == 0, "kGnuNameSize is aligned to 4.");
665 if (nhdr
->n_type
== NT_GNU_BUILD_ID
&& nhdr
->n_namesz
== kGnuNamesz
) {
666 if (off
+ sizeof(ElfW(Nhdr
)) + nhdr
->n_namesz
+ nhdr
->n_descsz
>
668 // Something is very wrong, bail out instead of reading potentially
673 reinterpret_cast<const char *>(nhdr
) + sizeof(*nhdr
);
674 if (internal_memcmp(name
, "GNU", 3) == 0) {
675 const char *value
= reinterpret_cast<const char *>(nhdr
) +
676 sizeof(*nhdr
) + kGnuNamesz
;
677 cur_module
.setUuid(value
, nhdr
->n_descsz
);
681 off
+= sizeof(*nhdr
) + RoundUpTo(nhdr
->n_namesz
, 4) +
682 RoundUpTo(nhdr
->n_descsz
, 4);
687 modules
->push_back(cur_module
);
691 static int dl_iterate_phdr_cb(dl_phdr_info
*info
, size_t size
, void *arg
) {
692 DlIteratePhdrData
*data
= (DlIteratePhdrData
*)arg
;
694 InternalMmapVector
<char> module_name(kMaxPathLength
);
696 // First module is the binary itself.
697 ReadBinaryNameCached(module_name
.data(), module_name
.size());
698 return AddModuleSegments(module_name
.data(), info
, data
->modules
);
702 return AddModuleSegments(info
->dlpi_name
, info
, data
->modules
);
707 #if SANITIZER_ANDROID && __ANDROID_API__ < 21
708 extern "C" __attribute__((weak
)) int dl_iterate_phdr(
709 int (*)(struct dl_phdr_info
*, size_t, void *), void *);
712 static bool requiresProcmaps() {
713 #if SANITIZER_ANDROID && __ANDROID_API__ <= 22
714 // Fall back to /proc/maps if dl_iterate_phdr is unavailable or broken.
715 // The runtime check allows the same library to work with
716 // both K and L (and future) Android releases.
717 return AndroidGetApiLevel() <= ANDROID_LOLLIPOP_MR1
;
723 static void procmapsInit(InternalMmapVectorNoCtor
<LoadedModule
> *modules
) {
724 MemoryMappingLayout
memory_mapping(/*cache_enabled*/true);
725 memory_mapping
.DumpListOfModules(modules
);
728 void ListOfModules::init() {
730 if (requiresProcmaps()) {
731 procmapsInit(&modules_
);
733 DlIteratePhdrData data
= {&modules_
, true};
734 dl_iterate_phdr(dl_iterate_phdr_cb
, &data
);
738 // When a custom loader is used, dl_iterate_phdr may not contain the full
739 // list of modules. Allow callers to fall back to using procmaps.
740 void ListOfModules::fallbackInit() {
741 if (!requiresProcmaps()) {
743 procmapsInit(&modules_
);
749 // getrusage does not give us the current RSS, only the max RSS.
750 // Still, this is better than nothing if /proc/self/statm is not available
751 // for some reason, e.g. due to a sandbox.
752 static uptr
GetRSSFromGetrusage() {
754 if (getrusage(RUSAGE_SELF
, &usage
)) // Failed, probably due to a sandbox.
756 return usage
.ru_maxrss
<< 10; // ru_maxrss is in Kb.
760 if (!common_flags()->can_use_proc_maps_statm
)
761 return GetRSSFromGetrusage();
762 fd_t fd
= OpenFile("/proc/self/statm", RdOnly
);
763 if (fd
== kInvalidFd
)
764 return GetRSSFromGetrusage();
766 uptr len
= internal_read(fd
, buf
, sizeof(buf
) - 1);
771 // The format of the file is:
772 // 1084 89 69 11 0 79 0
773 // We need the second number which is RSS in pages.
775 // Skip the first number.
776 while (*pos
>= '0' && *pos
<= '9')
779 while (!(*pos
>= '0' && *pos
<= '9') && *pos
!= 0)
783 while (*pos
>= '0' && *pos
<= '9')
784 rss
= rss
* 10 + *pos
++ - '0';
785 return rss
* GetPageSizeCached();
788 // sysconf(_SC_NPROCESSORS_{CONF,ONLN}) cannot be used on most platforms as
789 // they allocate memory.
790 u32
GetNumberOfCPUs() {
791 #if SANITIZER_FREEBSD || SANITIZER_NETBSD
794 uptr len
= sizeof(ncpu
);
797 CHECK_EQ(internal_sysctl(req
, 2, &ncpu
, &len
, NULL
, 0), 0);
799 #elif SANITIZER_ANDROID && !defined(CPU_COUNT) && !defined(__aarch64__)
800 // Fall back to /sys/devices/system/cpu on Android when cpu_set_t doesn't
801 // exist in sched.h. That is the case for toolchains generated with older
803 // This code doesn't work on AArch64 because internal_getdents makes use of
804 // the 64bit getdents syscall, but cpu_set_t seems to always exist on AArch64.
805 uptr fd
= internal_open("/sys/devices/system/cpu", O_RDONLY
| O_DIRECTORY
);
806 if (internal_iserror(fd
))
808 InternalMmapVector
<u8
> buffer(4096);
809 uptr bytes_read
= buffer
.size();
812 struct linux_dirent
*entry
= (struct linux_dirent
*)&buffer
[bytes_read
];
814 if ((u8
*)entry
>= &buffer
[bytes_read
]) {
815 bytes_read
= internal_getdents(fd
, (struct linux_dirent
*)buffer
.data(),
817 if (internal_iserror(bytes_read
) || !bytes_read
)
819 entry
= (struct linux_dirent
*)buffer
.data();
821 d_type
= (u8
*)entry
+ entry
->d_reclen
- 1;
822 if (d_type
>= &buffer
[bytes_read
] ||
823 (u8
*)&entry
->d_name
[3] >= &buffer
[bytes_read
])
825 if (entry
->d_ino
!= 0 && *d_type
== DT_DIR
) {
826 if (entry
->d_name
[0] == 'c' && entry
->d_name
[1] == 'p' &&
827 entry
->d_name
[2] == 'u' &&
828 entry
->d_name
[3] >= '0' && entry
->d_name
[3] <= '9')
831 entry
= (struct linux_dirent
*)(((u8
*)entry
) + entry
->d_reclen
);
835 #elif SANITIZER_SOLARIS
836 return sysconf(_SC_NPROCESSORS_ONLN
);
838 #if defined(CPU_COUNT)
840 CHECK_EQ(sched_getaffinity(0, sizeof(cpu_set_t
), &CPUs
), 0);
841 return CPU_COUNT(&CPUs
);
850 #if SANITIZER_ANDROID
851 static atomic_uint8_t android_log_initialized
;
853 void AndroidLogInit() {
854 openlog(GetProcessName(), 0, LOG_USER
);
855 atomic_store(&android_log_initialized
, 1, memory_order_release
);
858 static bool ShouldLogAfterPrintf() {
859 return atomic_load(&android_log_initialized
, memory_order_acquire
);
862 extern "C" SANITIZER_WEAK_ATTRIBUTE
863 int async_safe_write_log(int pri
, const char* tag
, const char* msg
);
864 extern "C" SANITIZER_WEAK_ATTRIBUTE
865 int __android_log_write(int prio
, const char* tag
, const char* msg
);
867 // ANDROID_LOG_INFO is 4, but can't be resolved at runtime.
868 #define SANITIZER_ANDROID_LOG_INFO 4
870 // async_safe_write_log is a new public version of __libc_write_log that is
871 // used behind syslog. It is preferable to syslog as it will not do any dynamic
872 // memory allocation or formatting.
873 // If the function is not available, syslog is preferred for L+ (it was broken
874 // pre-L) as __android_log_write triggers a racey behavior with the strncpy
875 // interceptor. Fallback to __android_log_write pre-L.
876 void WriteOneLineToSyslog(const char *s
) {
877 if (&async_safe_write_log
) {
878 async_safe_write_log(SANITIZER_ANDROID_LOG_INFO
, GetProcessName(), s
);
879 } else if (AndroidGetApiLevel() > ANDROID_KITKAT
) {
880 syslog(LOG_INFO
, "%s", s
);
882 CHECK(&__android_log_write
);
883 __android_log_write(SANITIZER_ANDROID_LOG_INFO
, nullptr, s
);
887 extern "C" SANITIZER_WEAK_ATTRIBUTE
888 void android_set_abort_message(const char *);
890 void SetAbortMessage(const char *str
) {
891 if (&android_set_abort_message
)
892 android_set_abort_message(str
);
895 void AndroidLogInit() {}
897 static bool ShouldLogAfterPrintf() { return true; }
899 void WriteOneLineToSyslog(const char *s
) { syslog(LOG_INFO
, "%s", s
); }
901 void SetAbortMessage(const char *str
) {}
902 #endif // SANITIZER_ANDROID
904 void LogMessageOnPrintf(const char *str
) {
905 if (common_flags()->log_to_syslog
&& ShouldLogAfterPrintf())
909 #endif // SANITIZER_LINUX
911 #if SANITIZER_GLIBC && !SANITIZER_GO
912 // glibc crashes when using clock_gettime from a preinit_array function as the
913 // vDSO function pointers haven't been initialized yet. __progname is
914 // initialized after the vDSO function pointers, so if it exists, is not null
915 // and is not empty, we can use clock_gettime.
916 extern "C" SANITIZER_WEAK_ATTRIBUTE
char *__progname
;
917 inline bool CanUseVDSO() { return &__progname
&& __progname
&& *__progname
; }
919 // MonotonicNanoTime is a timing function that can leverage the vDSO by calling
920 // clock_gettime. real_clock_gettime only exists if clock_gettime is
921 // intercepted, so define it weakly and use it if available.
922 extern "C" SANITIZER_WEAK_ATTRIBUTE
923 int real_clock_gettime(u32 clk_id
, void *tp
);
924 u64
MonotonicNanoTime() {
927 if (&real_clock_gettime
)
928 real_clock_gettime(CLOCK_MONOTONIC
, &ts
);
930 clock_gettime(CLOCK_MONOTONIC
, &ts
);
932 internal_clock_gettime(CLOCK_MONOTONIC
, &ts
);
934 return (u64
)ts
.tv_sec
* (1000ULL * 1000 * 1000) + ts
.tv_nsec
;
937 // Non-glibc & Go always use the regular function.
938 u64
MonotonicNanoTime() {
940 clock_gettime(CLOCK_MONOTONIC
, &ts
);
941 return (u64
)ts
.tv_sec
* (1000ULL * 1000 * 1000) + ts
.tv_nsec
;
943 #endif // SANITIZER_GLIBC && !SANITIZER_GO
946 const char *pathname
= "/proc/self/exe";
949 static const int name
[] = {
959 if (internal_sysctl(name
, ARRAY_SIZE(name
), path
, &len
, NULL
, 0) != -1)
961 #elif SANITIZER_SOLARIS
962 pathname
= getexecname();
963 CHECK_NE(pathname
, NULL
);
964 #elif SANITIZER_USE_GETAUXVAL
965 // Calling execve with /proc/self/exe sets that as $EXEC_ORIGIN. Binaries that
966 // rely on that will fail to load shared libraries. Query AT_EXECFN instead.
967 pathname
= reinterpret_cast<const char *>(getauxval(AT_EXECFN
));
970 uptr rv
= internal_execve(pathname
, GetArgv(), GetEnviron());
972 CHECK_EQ(internal_iserror(rv
, &rverrno
), true);
973 Printf("execve failed, errno %d\n", rverrno
);
977 void UnmapFromTo(uptr from
, uptr to
) {
981 uptr res
= internal_munmap(reinterpret_cast<void *>(from
), to
- from
);
982 if (UNLIKELY(internal_iserror(res
))) {
983 Report("ERROR: %s failed to unmap 0x%zx (%zd) bytes at address %p\n",
984 SanitizerToolName
, to
- from
, to
- from
, (void *)from
);
985 CHECK("unable to unmap" && 0);
989 uptr
MapDynamicShadow(uptr shadow_size_bytes
, uptr shadow_scale
,
990 uptr min_shadow_base_alignment
,
991 UNUSED uptr
&high_mem_end
) {
992 const uptr granularity
= GetMmapGranularity();
993 const uptr alignment
=
994 Max
<uptr
>(granularity
<< shadow_scale
, 1ULL << min_shadow_base_alignment
);
995 const uptr left_padding
=
996 Max
<uptr
>(granularity
, 1ULL << min_shadow_base_alignment
);
998 const uptr shadow_size
= RoundUpTo(shadow_size_bytes
, granularity
);
999 const uptr map_size
= shadow_size
+ left_padding
+ alignment
;
1001 const uptr map_start
= (uptr
)MmapNoAccess(map_size
);
1002 CHECK_NE(map_start
, ~(uptr
)0);
1004 const uptr shadow_start
= RoundUpTo(map_start
+ left_padding
, alignment
);
1006 UnmapFromTo(map_start
, shadow_start
- left_padding
);
1007 UnmapFromTo(shadow_start
+ shadow_size
, map_start
+ map_size
);
1009 return shadow_start
;
1012 static uptr
MmapSharedNoReserve(uptr addr
, uptr size
) {
1013 return internal_mmap(
1014 reinterpret_cast<void *>(addr
), size
, PROT_READ
| PROT_WRITE
,
1015 MAP_FIXED
| MAP_SHARED
| MAP_ANONYMOUS
| MAP_NORESERVE
, -1, 0);
1018 static uptr
MremapCreateAlias(uptr base_addr
, uptr alias_addr
,
1021 return internal_mremap(reinterpret_cast<void *>(base_addr
), 0, alias_size
,
1022 MREMAP_MAYMOVE
| MREMAP_FIXED
,
1023 reinterpret_cast<void *>(alias_addr
));
1025 CHECK(false && "mremap is not supported outside of Linux");
1030 static void CreateAliases(uptr start_addr
, uptr alias_size
, uptr num_aliases
) {
1031 uptr total_size
= alias_size
* num_aliases
;
1032 uptr mapped
= MmapSharedNoReserve(start_addr
, total_size
);
1033 CHECK_EQ(mapped
, start_addr
);
1035 for (uptr i
= 1; i
< num_aliases
; ++i
) {
1036 uptr alias_addr
= start_addr
+ i
* alias_size
;
1037 CHECK_EQ(MremapCreateAlias(start_addr
, alias_addr
, alias_size
), alias_addr
);
1041 uptr
MapDynamicShadowAndAliases(uptr shadow_size
, uptr alias_size
,
1042 uptr num_aliases
, uptr ring_buffer_size
) {
1043 CHECK_EQ(alias_size
& (alias_size
- 1), 0);
1044 CHECK_EQ(num_aliases
& (num_aliases
- 1), 0);
1045 CHECK_EQ(ring_buffer_size
& (ring_buffer_size
- 1), 0);
1047 const uptr granularity
= GetMmapGranularity();
1048 shadow_size
= RoundUpTo(shadow_size
, granularity
);
1049 CHECK_EQ(shadow_size
& (shadow_size
- 1), 0);
1051 const uptr alias_region_size
= alias_size
* num_aliases
;
1052 const uptr alignment
=
1053 2 * Max(Max(shadow_size
, alias_region_size
), ring_buffer_size
);
1054 const uptr left_padding
= ring_buffer_size
;
1056 const uptr right_size
= alignment
;
1057 const uptr map_size
= left_padding
+ 2 * alignment
;
1059 const uptr map_start
= reinterpret_cast<uptr
>(MmapNoAccess(map_size
));
1060 CHECK_NE(map_start
, static_cast<uptr
>(-1));
1061 const uptr right_start
= RoundUpTo(map_start
+ left_padding
, alignment
);
1063 UnmapFromTo(map_start
, right_start
- left_padding
);
1064 UnmapFromTo(right_start
+ right_size
, map_start
+ map_size
);
1066 CreateAliases(right_start
+ right_size
/ 2, alias_size
, num_aliases
);
1071 void InitializePlatformCommonFlags(CommonFlags
*cf
) {
1072 #if SANITIZER_ANDROID
1073 if (&__libc_get_static_tls_bounds
== nullptr)
1074 cf
->detect_leaks
= false;
1078 } // namespace __sanitizer