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
17 #include "sanitizer_allocator_internal.h"
18 #include "sanitizer_atomic.h"
19 #include "sanitizer_common.h"
20 #include "sanitizer_flags.h"
21 #include "sanitizer_freebsd.h"
22 #include "sanitizer_linux.h"
23 #include "sanitizer_placement_new.h"
24 #include "sanitizer_procmaps.h"
25 #include "sanitizer_stacktrace.h"
27 #if SANITIZER_ANDROID || SANITIZER_FREEBSD
28 #include <dlfcn.h> // for dlsym()
34 #include <sys/resource.h>
38 #include <pthread_np.h>
39 #include <osreldate.h>
40 #define pthread_getattr_np pthread_attr_get_np
44 #include <sys/prctl.h>
48 #include <android/api-level.h>
51 #if SANITIZER_ANDROID && __ANDROID_API__ < 21
52 #include <android/log.h>
55 #if !SANITIZER_ANDROID
60 namespace __sanitizer
{
62 SANITIZER_WEAK_ATTRIBUTE
int
63 real_sigaction(int signum
, const void *act
, void *oldact
);
65 int internal_sigaction(int signum
, const void *act
, void *oldact
) {
68 return real_sigaction(signum
, act
, oldact
);
70 return sigaction(signum
, (const struct sigaction
*)act
,
71 (struct sigaction
*)oldact
);
74 void GetThreadStackTopAndBottom(bool at_initialization
, uptr
*stack_top
,
78 if (at_initialization
) {
79 // This is the main thread. Libpthread may not be initialized yet.
81 CHECK_EQ(getrlimit(RLIMIT_STACK
, &rl
), 0);
83 // Find the mapping that contains a stack variable.
84 MemoryMappingLayout
proc_maps(/*cache_enabled*/true);
85 uptr start
, end
, offset
;
87 while (proc_maps
.Next(&start
, &end
, &offset
, nullptr, 0,
88 /* protection */nullptr)) {
93 CHECK((uptr
)&rl
>= start
&& (uptr
)&rl
< end
);
95 // Get stacksize from rlimit, but clip it so that it does not overlap
96 // with other mappings.
97 uptr stacksize
= rl
.rlim_cur
;
98 if (stacksize
> end
- prev_end
)
99 stacksize
= end
- prev_end
;
100 // When running with unlimited stack size, we still want to set some limit.
101 // The unlimited stack size is caused by 'ulimit -s unlimited'.
102 // Also, for some reason, GNU make spawns subprocesses with unlimited stack.
103 if (stacksize
> kMaxThreadStackSize
)
104 stacksize
= kMaxThreadStackSize
;
106 *stack_bottom
= end
- stacksize
;
110 pthread_attr_init(&attr
);
111 CHECK_EQ(pthread_getattr_np(pthread_self(), &attr
), 0);
113 void *stackaddr
= nullptr;
114 my_pthread_attr_getstack(&attr
, &stackaddr
, &stacksize
);
115 pthread_attr_destroy(&attr
);
117 CHECK_LE(stacksize
, kMaxThreadStackSize
); // Sanity check.
118 *stack_top
= (uptr
)stackaddr
+ stacksize
;
119 *stack_bottom
= (uptr
)stackaddr
;
123 bool SetEnv(const char *name
, const char *value
) {
124 void *f
= dlsym(RTLD_NEXT
, "setenv");
127 typedef int(*setenv_ft
)(const char *name
, const char *value
, int overwrite
);
129 CHECK_EQ(sizeof(setenv_f
), sizeof(f
));
130 internal_memcpy(&setenv_f
, &f
, sizeof(f
));
131 return setenv_f(name
, value
, 1) == 0;
135 bool SanitizerSetThreadName(const char *name
) {
137 return 0 == prctl(PR_SET_NAME
, (unsigned long)name
, 0, 0, 0); // NOLINT
143 bool SanitizerGetThreadName(char *name
, int max_len
) {
146 if (prctl(PR_GET_NAME
, (unsigned long)buff
, 0, 0, 0)) // NOLINT
148 internal_strncpy(name
, buff
, max_len
);
156 #if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
157 static uptr g_tls_size
;
160 # define DL_INTERNAL_FUNCTION __attribute__((regparm(3), stdcall))
162 # define DL_INTERNAL_FUNCTION
166 // all current supported platforms have 16 bytes stack alignment
167 const size_t kStackAlign
= 16;
168 typedef void (*get_tls_func
)(size_t*, size_t*) DL_INTERNAL_FUNCTION
;
169 get_tls_func get_tls
;
170 void *get_tls_static_info_ptr
= dlsym(RTLD_NEXT
, "_dl_get_tls_static_info");
171 CHECK_EQ(sizeof(get_tls
), sizeof(get_tls_static_info_ptr
));
172 internal_memcpy(&get_tls
, &get_tls_static_info_ptr
,
173 sizeof(get_tls_static_info_ptr
));
174 CHECK_NE(get_tls
, 0);
176 size_t tls_align
= 0;
177 get_tls(&tls_size
, &tls_align
);
178 if (tls_align
< kStackAlign
)
179 tls_align
= kStackAlign
;
180 g_tls_size
= RoundUpTo(tls_size
, tls_align
);
183 void InitTlsSize() { }
184 #endif // !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
186 #if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) \
187 || defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__)) \
188 && SANITIZER_LINUX && !SANITIZER_ANDROID
189 // sizeof(struct pthread) from glibc.
190 static atomic_uintptr_t kThreadDescriptorSize
;
192 uptr
ThreadDescriptorSize() {
193 uptr val
= atomic_load(&kThreadDescriptorSize
, memory_order_relaxed
);
196 #if defined(__x86_64__) || defined(__i386__)
197 #ifdef _CS_GNU_LIBC_VERSION
199 uptr len
= confstr(_CS_GNU_LIBC_VERSION
, buf
, sizeof(buf
));
200 if (len
< sizeof(buf
) && internal_strncmp(buf
, "glibc 2.", 8) == 0) {
202 int minor
= internal_simple_strtoll(buf
+ 8, &end
, 10);
203 if (end
!= buf
+ 8 && (*end
== '\0' || *end
== '.')) {
206 // strtoll will return 0 if no valid conversion could be performed
207 patch
= internal_simple_strtoll(end
+ 1, nullptr, 10);
209 /* sizeof(struct pthread) values from various glibc versions. */
211 val
= 1728; // Assume only one particular version for x32.
213 val
= FIRST_32_SECOND_64(1104, 1696);
215 val
= FIRST_32_SECOND_64(1120, 1728);
217 val
= FIRST_32_SECOND_64(1136, 1728);
219 val
= FIRST_32_SECOND_64(1136, 1712);
220 else if (minor
== 10)
221 val
= FIRST_32_SECOND_64(1168, 1776);
222 else if (minor
== 11 || (minor
== 12 && patch
== 1))
223 val
= FIRST_32_SECOND_64(1168, 2288);
224 else if (minor
<= 13)
225 val
= FIRST_32_SECOND_64(1168, 2304);
227 val
= FIRST_32_SECOND_64(1216, 2304);
230 atomic_store(&kThreadDescriptorSize
, val
, memory_order_relaxed
);
234 #elif defined(__mips__)
235 // TODO(sagarthakur): add more values as per different glibc versions.
236 val
= FIRST_32_SECOND_64(1152, 1776);
238 atomic_store(&kThreadDescriptorSize
, val
, memory_order_relaxed
);
240 #elif defined(__aarch64__)
241 // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
243 atomic_store(&kThreadDescriptorSize
, val
, memory_order_relaxed
);
245 #elif defined(__powerpc64__)
246 val
= 1776; // from glibc.ppc64le 2.20-8.fc21
247 atomic_store(&kThreadDescriptorSize
, val
, memory_order_relaxed
);
249 #elif defined(__s390__)
250 val
= FIRST_32_SECOND_64(1152, 1776); // valid for glibc 2.22
251 atomic_store(&kThreadDescriptorSize
, val
, memory_order_relaxed
);
256 // The offset at which pointer to self is located in the thread descriptor.
257 const uptr kThreadSelfOffset
= FIRST_32_SECOND_64(8, 16);
259 uptr
ThreadSelfOffset() {
260 return kThreadSelfOffset
;
263 #if defined(__mips__) || defined(__powerpc64__)
264 // TlsPreTcbSize includes size of struct pthread_descr and size of tcb
265 // head structure. It lies before the static tls blocks.
266 static uptr
TlsPreTcbSize() {
267 # if defined(__mips__)
268 const uptr kTcbHead
= 16; // sizeof (tcbhead_t)
269 # elif defined(__powerpc64__)
270 const uptr kTcbHead
= 88; // sizeof (tcbhead_t)
272 const uptr kTlsAlign
= 16;
273 const uptr kTlsPreTcbSize
=
274 (ThreadDescriptorSize() + kTcbHead
+ kTlsAlign
- 1) & ~(kTlsAlign
- 1);
276 g_tls_size
= (g_tls_size
+ kTlsPreTcbSize
+ kTlsAlign
-1) & ~(kTlsAlign
- 1);
277 return kTlsPreTcbSize
;
283 # if defined(__i386__)
284 asm("mov %%gs:%c1,%0" : "=r"(descr_addr
) : "i"(kThreadSelfOffset
));
285 # elif defined(__x86_64__)
286 asm("mov %%fs:%c1,%0" : "=r"(descr_addr
) : "i"(kThreadSelfOffset
));
287 # elif defined(__mips__)
288 // MIPS uses TLS variant I. The thread pointer (in hardware register $29)
289 // points to the end of the TCB + 0x7000. The pthread_descr structure is
290 // immediately in front of the TCB. TlsPreTcbSize() includes the size of the
291 // TCB and the size of pthread_descr.
292 const uptr kTlsTcbOffset
= 0x7000;
294 asm volatile(".set push;\
297 .set pop" : "=r" (thread_pointer
));
298 descr_addr
= thread_pointer
- kTlsTcbOffset
- TlsPreTcbSize();
299 # elif defined(__aarch64__)
300 descr_addr
= reinterpret_cast<uptr
>(__builtin_thread_pointer()) -
301 ThreadDescriptorSize();
302 # elif defined(__s390__)
303 descr_addr
= reinterpret_cast<uptr
>(__builtin_thread_pointer());
304 # elif defined(__powerpc64__)
305 // PPC64LE uses TLS variant I. The thread pointer (in GPR 13)
306 // points to the end of the TCB + 0x7000. The pthread_descr structure is
307 // immediately in front of the TCB. TlsPreTcbSize() includes the size of the
308 // TCB and the size of pthread_descr.
309 const uptr kTlsTcbOffset
= 0x7000;
311 asm("addi %0,13,%1" : "=r"(thread_pointer
) : "I"(-kTlsTcbOffset
));
312 descr_addr
= thread_pointer
- TlsPreTcbSize();
314 # error "unsupported CPU arch"
318 #endif // (x86_64 || i386 || MIPS) && SANITIZER_LINUX
320 #if SANITIZER_FREEBSD
321 static void **ThreadSelfSegbase() {
323 # if defined(__i386__)
324 // sysarch(I386_GET_GSBASE, segbase);
325 __asm
__volatile("mov %%gs:0, %0" : "=r" (segbase
));
326 # elif defined(__x86_64__)
327 // sysarch(AMD64_GET_FSBASE, segbase);
328 __asm
__volatile("movq %%fs:0, %0" : "=r" (segbase
));
330 # error "unsupported CPU arch for FreeBSD platform"
336 return (uptr
)ThreadSelfSegbase()[2];
338 #endif // SANITIZER_FREEBSD
341 static void GetTls(uptr
*addr
, uptr
*size
) {
342 #if SANITIZER_LINUX && !SANITIZER_ANDROID
343 # if defined(__x86_64__) || defined(__i386__) || defined(__s390__)
344 *addr
= ThreadSelf();
345 *size
= GetTlsSize();
347 *addr
+= ThreadDescriptorSize();
348 # elif defined(__mips__) || defined(__aarch64__) || defined(__powerpc64__)
349 *addr
= ThreadSelf();
350 *size
= GetTlsSize();
355 #elif SANITIZER_FREEBSD
356 void** segbase
= ThreadSelfSegbase();
361 // tls_size = round(tls_static_space, tcbalign);
363 // dtv[2] = segbase - tls_static_space;
364 void **dtv
= (void**) segbase
[1];
365 *addr
= (uptr
) dtv
[2];
366 *size
= (*addr
== 0) ? 0 : ((uptr
) segbase
[0] - (uptr
) dtv
[2]);
368 #elif SANITIZER_ANDROID
379 #if SANITIZER_FREEBSD || SANITIZER_ANDROID
381 GetTls(&addr
, &size
);
389 void GetThreadStackAndTls(bool main
, uptr
*stk_addr
, uptr
*stk_size
,
390 uptr
*tls_addr
, uptr
*tls_size
) {
392 // Stub implementation for Go.
393 *stk_addr
= *stk_size
= *tls_addr
= *tls_size
= 0;
395 GetTls(tls_addr
, tls_size
);
397 uptr stack_top
, stack_bottom
;
398 GetThreadStackTopAndBottom(main
, &stack_top
, &stack_bottom
);
399 *stk_addr
= stack_bottom
;
400 *stk_size
= stack_top
- stack_bottom
;
403 // If stack and tls intersect, make them non-intersecting.
404 if (*tls_addr
> *stk_addr
&& *tls_addr
< *stk_addr
+ *stk_size
) {
405 CHECK_GT(*tls_addr
+ *tls_size
, *stk_addr
);
406 CHECK_LE(*tls_addr
+ *tls_size
, *stk_addr
+ *stk_size
);
407 *stk_size
-= *tls_size
;
408 *tls_addr
= *stk_addr
+ *stk_size
;
414 # if !SANITIZER_FREEBSD
415 typedef ElfW(Phdr
) Elf_Phdr
;
416 # elif SANITIZER_WORDSIZE == 32 && __FreeBSD_version <= 902001 // v9.2
417 # define Elf_Phdr XElf32_Phdr
418 # define dl_phdr_info xdl_phdr_info
419 # define dl_iterate_phdr(c, b) xdl_iterate_phdr((c), (b))
422 struct DlIteratePhdrData
{
423 InternalMmapVector
<LoadedModule
> *modules
;
427 static int dl_iterate_phdr_cb(dl_phdr_info
*info
, size_t size
, void *arg
) {
428 DlIteratePhdrData
*data
= (DlIteratePhdrData
*)arg
;
429 InternalScopedString
module_name(kMaxPathLength
);
432 // First module is the binary itself.
433 ReadBinaryNameCached(module_name
.data(), module_name
.size());
434 } else if (info
->dlpi_name
) {
435 module_name
.append("%s", info
->dlpi_name
);
437 if (module_name
[0] == '\0')
439 LoadedModule cur_module
;
440 cur_module
.set(module_name
.data(), info
->dlpi_addr
);
441 for (int i
= 0; i
< info
->dlpi_phnum
; i
++) {
442 const Elf_Phdr
*phdr
= &info
->dlpi_phdr
[i
];
443 if (phdr
->p_type
== PT_LOAD
) {
444 uptr cur_beg
= info
->dlpi_addr
+ phdr
->p_vaddr
;
445 uptr cur_end
= cur_beg
+ phdr
->p_memsz
;
446 bool executable
= phdr
->p_flags
& PF_X
;
447 cur_module
.addAddressRange(cur_beg
, cur_end
, executable
);
450 data
->modules
->push_back(cur_module
);
454 #if SANITIZER_ANDROID && __ANDROID_API__ < 21
455 extern "C" __attribute__((weak
)) int dl_iterate_phdr(
456 int (*)(struct dl_phdr_info
*, size_t, void *), void *);
459 void ListOfModules::init() {
461 #if SANITIZER_ANDROID && __ANDROID_API__ <= 22
462 u32 api_level
= AndroidGetApiLevel();
463 // Fall back to /proc/maps if dl_iterate_phdr is unavailable or broken.
464 // The runtime check allows the same library to work with
465 // both K and L (and future) Android releases.
466 if (api_level
<= ANDROID_LOLLIPOP_MR1
) { // L or earlier
467 MemoryMappingLayout
memory_mapping(false);
468 memory_mapping
.DumpListOfModules(&modules_
);
472 DlIteratePhdrData data
= {&modules_
, true};
473 dl_iterate_phdr(dl_iterate_phdr_cb
, &data
);
476 // getrusage does not give us the current RSS, only the max RSS.
477 // Still, this is better than nothing if /proc/self/statm is not available
478 // for some reason, e.g. due to a sandbox.
479 static uptr
GetRSSFromGetrusage() {
481 if (getrusage(RUSAGE_SELF
, &usage
)) // Failed, probably due to a sandbox.
483 return usage
.ru_maxrss
<< 10; // ru_maxrss is in Kb.
487 if (!common_flags()->can_use_proc_maps_statm
)
488 return GetRSSFromGetrusage();
489 fd_t fd
= OpenFile("/proc/self/statm", RdOnly
);
490 if (fd
== kInvalidFd
)
491 return GetRSSFromGetrusage();
493 uptr len
= internal_read(fd
, buf
, sizeof(buf
) - 1);
498 // The format of the file is:
499 // 1084 89 69 11 0 79 0
500 // We need the second number which is RSS in pages.
502 // Skip the first number.
503 while (*pos
>= '0' && *pos
<= '9')
506 while (!(*pos
>= '0' && *pos
<= '9') && *pos
!= 0)
510 while (*pos
>= '0' && *pos
<= '9')
511 rss
= rss
* 10 + *pos
++ - '0';
512 return rss
* GetPageSizeCached();
515 // 64-bit Android targets don't provide the deprecated __android_log_write.
516 // Starting with the L release, syslog() works and is preferable to
517 // __android_log_write.
520 #if SANITIZER_ANDROID
521 static atomic_uint8_t android_log_initialized
;
523 void AndroidLogInit() {
524 openlog(GetProcessName(), 0, LOG_USER
);
525 atomic_store(&android_log_initialized
, 1, memory_order_release
);
528 static bool ShouldLogAfterPrintf() {
529 return atomic_load(&android_log_initialized
, memory_order_acquire
);
532 void AndroidLogInit() {}
534 static bool ShouldLogAfterPrintf() { return true; }
535 #endif // SANITIZER_ANDROID
537 void WriteOneLineToSyslog(const char *s
) {
538 #if SANITIZER_ANDROID &&__ANDROID_API__ < 21
539 __android_log_write(ANDROID_LOG_INFO
, NULL
, s
);
541 syslog(LOG_INFO
, "%s", s
);
545 void LogMessageOnPrintf(const char *str
) {
546 if (common_flags()->log_to_syslog
&& ShouldLogAfterPrintf())
550 #endif // SANITIZER_LINUX
552 } // namespace __sanitizer
554 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX