sanitizer_linux.cc revision 5e7ba22755b994e4f6aaf8cc00773c4d1b8dbf07
1//===-- sanitizer_linux.cc ------------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file is shared between AddressSanitizer and ThreadSanitizer 11// run-time libraries and implements linux-specific functions from 12// sanitizer_libc.h. 13//===----------------------------------------------------------------------===// 14 15#include "sanitizer_platform.h" 16#if SANITIZER_LINUX 17 18#include "sanitizer_common.h" 19#include "sanitizer_internal_defs.h" 20#include "sanitizer_libc.h" 21#include "sanitizer_linux.h" 22#include "sanitizer_mutex.h" 23#include "sanitizer_placement_new.h" 24#include "sanitizer_procmaps.h" 25#include "sanitizer_stacktrace.h" 26#include "sanitizer_symbolizer.h" 27 28#include <asm/param.h> 29#include <dlfcn.h> 30#include <errno.h> 31#include <fcntl.h> 32#if !SANITIZER_ANDROID 33#include <link.h> 34#endif 35#include <pthread.h> 36#include <sched.h> 37#include <sys/mman.h> 38#include <sys/ptrace.h> 39#include <sys/resource.h> 40#include <sys/stat.h> 41#include <sys/syscall.h> 42#include <sys/time.h> 43#include <sys/types.h> 44#include <unistd.h> 45#include <unwind.h> 46 47#if !SANITIZER_ANDROID 48#include <sys/signal.h> 49#endif 50 51// <linux/time.h> 52struct kernel_timeval { 53 long tv_sec; 54 long tv_usec; 55}; 56 57// <linux/futex.h> is broken on some linux distributions. 58const int FUTEX_WAIT = 0; 59const int FUTEX_WAKE = 1; 60 61// Are we using 32-bit or 64-bit syscalls? 62// x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32 63// but it still needs to use 64-bit syscalls. 64#if defined(__x86_64__) || SANITIZER_WORDSIZE == 64 65# define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1 66#else 67# define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0 68#endif 69 70namespace __sanitizer { 71 72#ifdef __x86_64__ 73#include "sanitizer_syscall_linux_x86_64.inc" 74#else 75#include "sanitizer_syscall_generic.inc" 76#endif 77 78// --------------- sanitizer_libc.h 79uptr internal_mmap(void *addr, uptr length, int prot, int flags, 80 int fd, u64 offset) { 81#if SANITIZER_LINUX_USES_64BIT_SYSCALLS 82 return internal_syscall(__NR_mmap, addr, length, prot, flags, fd, offset); 83#else 84 return internal_syscall(__NR_mmap2, addr, length, prot, flags, fd, offset); 85#endif 86} 87 88uptr internal_munmap(void *addr, uptr length) { 89 return internal_syscall(__NR_munmap, addr, length); 90} 91 92uptr internal_close(fd_t fd) { 93 return internal_syscall(__NR_close, fd); 94} 95 96uptr internal_open(const char *filename, int flags) { 97 return internal_syscall(__NR_open, filename, flags); 98} 99 100uptr internal_open(const char *filename, int flags, u32 mode) { 101 return internal_syscall(__NR_open, filename, flags, mode); 102} 103 104uptr OpenFile(const char *filename, bool write) { 105 return internal_open(filename, 106 write ? O_WRONLY | O_CREAT /*| O_CLOEXEC*/ : O_RDONLY, 0660); 107} 108 109uptr internal_read(fd_t fd, void *buf, uptr count) { 110 sptr res; 111 HANDLE_EINTR(res, (sptr)internal_syscall(__NR_read, fd, buf, count)); 112 return res; 113} 114 115uptr internal_write(fd_t fd, const void *buf, uptr count) { 116 sptr res; 117 HANDLE_EINTR(res, (sptr)internal_syscall(__NR_write, fd, buf, count)); 118 return res; 119} 120 121#if !SANITIZER_LINUX_USES_64BIT_SYSCALLS 122static void stat64_to_stat(struct stat64 *in, struct stat *out) { 123 internal_memset(out, 0, sizeof(*out)); 124 out->st_dev = in->st_dev; 125 out->st_ino = in->st_ino; 126 out->st_mode = in->st_mode; 127 out->st_nlink = in->st_nlink; 128 out->st_uid = in->st_uid; 129 out->st_gid = in->st_gid; 130 out->st_rdev = in->st_rdev; 131 out->st_size = in->st_size; 132 out->st_blksize = in->st_blksize; 133 out->st_blocks = in->st_blocks; 134 out->st_atime = in->st_atime; 135 out->st_mtime = in->st_mtime; 136 out->st_ctime = in->st_ctime; 137 out->st_ino = in->st_ino; 138} 139#endif 140 141uptr internal_stat(const char *path, void *buf) { 142#if SANITIZER_LINUX_USES_64BIT_SYSCALLS 143 return internal_syscall(__NR_stat, path, buf); 144#else 145 struct stat64 buf64; 146 int res = internal_syscall(__NR_stat64, path, &buf64); 147 stat64_to_stat(&buf64, (struct stat *)buf); 148 return res; 149#endif 150} 151 152uptr internal_lstat(const char *path, void *buf) { 153#if SANITIZER_LINUX_USES_64BIT_SYSCALLS 154 return internal_syscall(__NR_lstat, path, buf); 155#else 156 struct stat64 buf64; 157 int res = internal_syscall(__NR_lstat64, path, &buf64); 158 stat64_to_stat(&buf64, (struct stat *)buf); 159 return res; 160#endif 161} 162 163uptr internal_fstat(fd_t fd, void *buf) { 164#if SANITIZER_LINUX_USES_64BIT_SYSCALLS 165 return internal_syscall(__NR_fstat, fd, buf); 166#else 167 struct stat64 buf64; 168 int res = internal_syscall(__NR_fstat64, fd, &buf64); 169 stat64_to_stat(&buf64, (struct stat *)buf); 170 return res; 171#endif 172} 173 174uptr internal_filesize(fd_t fd) { 175 struct stat st; 176 if (internal_fstat(fd, &st)) 177 return -1; 178 return (uptr)st.st_size; 179} 180 181uptr internal_dup2(int oldfd, int newfd) { 182 return internal_syscall(__NR_dup2, oldfd, newfd); 183} 184 185uptr internal_readlink(const char *path, char *buf, uptr bufsize) { 186 return internal_syscall(__NR_readlink, path, buf, bufsize); 187} 188 189uptr internal_unlink(const char *path) { 190 return internal_syscall(__NR_unlink, path); 191} 192 193uptr internal_sched_yield() { 194 return internal_syscall(__NR_sched_yield); 195} 196 197void internal__exit(int exitcode) { 198 internal_syscall(__NR_exit_group, exitcode); 199 Die(); // Unreachable. 200} 201 202uptr internal_execve(const char *filename, char *const argv[], 203 char *const envp[]) { 204 return internal_syscall(__NR_execve, filename, argv, envp); 205} 206 207// ----------------- sanitizer_common.h 208bool FileExists(const char *filename) { 209 struct stat st; 210 if (internal_stat(filename, &st)) 211 return false; 212 // Sanity check: filename is a regular file. 213 return S_ISREG(st.st_mode); 214} 215 216uptr GetTid() { 217 return internal_syscall(__NR_gettid); 218} 219 220u64 NanoTime() { 221 kernel_timeval tv; 222 internal_memset(&tv, 0, sizeof(tv)); 223 internal_syscall(__NR_gettimeofday, &tv, 0); 224 return (u64)tv.tv_sec * 1000*1000*1000 + tv.tv_usec * 1000; 225} 226 227// Like getenv, but reads env directly from /proc and does not use libc. 228// This function should be called first inside __asan_init. 229const char *GetEnv(const char *name) { 230 static char *environ; 231 static uptr len; 232 static bool inited; 233 if (!inited) { 234 inited = true; 235 uptr environ_size; 236 len = ReadFileToBuffer("/proc/self/environ", 237 &environ, &environ_size, 1 << 26); 238 } 239 if (!environ || len == 0) return 0; 240 uptr namelen = internal_strlen(name); 241 const char *p = environ; 242 while (*p != '\0') { // will happen at the \0\0 that terminates the buffer 243 // proc file has the format NAME=value\0NAME=value\0NAME=value\0... 244 const char* endp = 245 (char*)internal_memchr(p, '\0', len - (p - environ)); 246 if (endp == 0) // this entry isn't NUL terminated 247 return 0; 248 else if (!internal_memcmp(p, name, namelen) && p[namelen] == '=') // Match. 249 return p + namelen + 1; // point after = 250 p = endp + 1; 251 } 252 return 0; // Not found. 253} 254 255extern "C" { 256 SANITIZER_WEAK_ATTRIBUTE extern void *__libc_stack_end; 257} 258 259#if !SANITIZER_GO 260static void ReadNullSepFileToArray(const char *path, char ***arr, 261 int arr_size) { 262 char *buff; 263 uptr buff_size = 0; 264 *arr = (char **)MmapOrDie(arr_size * sizeof(char *), "NullSepFileArray"); 265 ReadFileToBuffer(path, &buff, &buff_size, 1024 * 1024); 266 (*arr)[0] = buff; 267 int count, i; 268 for (count = 1, i = 1; ; i++) { 269 if (buff[i] == 0) { 270 if (buff[i+1] == 0) break; 271 (*arr)[count] = &buff[i+1]; 272 CHECK_LE(count, arr_size - 1); // FIXME: make this more flexible. 273 count++; 274 } 275 } 276 (*arr)[count] = 0; 277} 278#endif 279 280static void GetArgsAndEnv(char*** argv, char*** envp) { 281#if !SANITIZER_GO 282 if (&__libc_stack_end) { 283#endif 284 uptr* stack_end = (uptr*)__libc_stack_end; 285 int argc = *stack_end; 286 *argv = (char**)(stack_end + 1); 287 *envp = (char**)(stack_end + argc + 2); 288#if !SANITIZER_GO 289 } else { 290 static const int kMaxArgv = 2000, kMaxEnvp = 2000; 291 ReadNullSepFileToArray("/proc/self/cmdline", argv, kMaxArgv); 292 ReadNullSepFileToArray("/proc/self/environ", envp, kMaxEnvp); 293 } 294#endif 295} 296 297void ReExec() { 298 char **argv, **envp; 299 GetArgsAndEnv(&argv, &envp); 300 uptr rv = internal_execve("/proc/self/exe", argv, envp); 301 int rverrno; 302 CHECK_EQ(internal_iserror(rv, &rverrno), true); 303 Printf("execve failed, errno %d\n", rverrno); 304 Die(); 305} 306 307void PrepareForSandboxing() { 308 // Some kinds of sandboxes may forbid filesystem access, so we won't be able 309 // to read the file mappings from /proc/self/maps. Luckily, neither the 310 // process will be able to load additional libraries, so it's fine to use the 311 // cached mappings. 312 MemoryMappingLayout::CacheMemoryMappings(); 313 // Same for /proc/self/exe in the symbolizer. 314#if !SANITIZER_GO 315 getSymbolizer()->PrepareForSandboxing(); 316#endif 317} 318 319// ----------------- sanitizer_procmaps.h 320// Linker initialized. 321ProcSelfMapsBuff MemoryMappingLayout::cached_proc_self_maps_; 322StaticSpinMutex MemoryMappingLayout::cache_lock_; // Linker initialized. 323 324MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) { 325 proc_self_maps_.len = 326 ReadFileToBuffer("/proc/self/maps", &proc_self_maps_.data, 327 &proc_self_maps_.mmaped_size, 1 << 26); 328 if (cache_enabled) { 329 if (proc_self_maps_.mmaped_size == 0) { 330 LoadFromCache(); 331 CHECK_GT(proc_self_maps_.len, 0); 332 } 333 } else { 334 CHECK_GT(proc_self_maps_.mmaped_size, 0); 335 } 336 Reset(); 337 // FIXME: in the future we may want to cache the mappings on demand only. 338 if (cache_enabled) 339 CacheMemoryMappings(); 340} 341 342MemoryMappingLayout::~MemoryMappingLayout() { 343 // Only unmap the buffer if it is different from the cached one. Otherwise 344 // it will be unmapped when the cache is refreshed. 345 if (proc_self_maps_.data != cached_proc_self_maps_.data) { 346 UnmapOrDie(proc_self_maps_.data, proc_self_maps_.mmaped_size); 347 } 348} 349 350void MemoryMappingLayout::Reset() { 351 current_ = proc_self_maps_.data; 352} 353 354// static 355void MemoryMappingLayout::CacheMemoryMappings() { 356 SpinMutexLock l(&cache_lock_); 357 // Don't invalidate the cache if the mappings are unavailable. 358 ProcSelfMapsBuff old_proc_self_maps; 359 old_proc_self_maps = cached_proc_self_maps_; 360 cached_proc_self_maps_.len = 361 ReadFileToBuffer("/proc/self/maps", &cached_proc_self_maps_.data, 362 &cached_proc_self_maps_.mmaped_size, 1 << 26); 363 if (cached_proc_self_maps_.mmaped_size == 0) { 364 cached_proc_self_maps_ = old_proc_self_maps; 365 } else { 366 if (old_proc_self_maps.mmaped_size) { 367 UnmapOrDie(old_proc_self_maps.data, 368 old_proc_self_maps.mmaped_size); 369 } 370 } 371} 372 373void MemoryMappingLayout::LoadFromCache() { 374 SpinMutexLock l(&cache_lock_); 375 if (cached_proc_self_maps_.data) { 376 proc_self_maps_ = cached_proc_self_maps_; 377 } 378} 379 380// Parse a hex value in str and update str. 381static uptr ParseHex(char **str) { 382 uptr x = 0; 383 char *s; 384 for (s = *str; ; s++) { 385 char c = *s; 386 uptr v = 0; 387 if (c >= '0' && c <= '9') 388 v = c - '0'; 389 else if (c >= 'a' && c <= 'f') 390 v = c - 'a' + 10; 391 else if (c >= 'A' && c <= 'F') 392 v = c - 'A' + 10; 393 else 394 break; 395 x = x * 16 + v; 396 } 397 *str = s; 398 return x; 399} 400 401static bool IsOneOf(char c, char c1, char c2) { 402 return c == c1 || c == c2; 403} 404 405static bool IsDecimal(char c) { 406 return c >= '0' && c <= '9'; 407} 408 409static bool IsHex(char c) { 410 return (c >= '0' && c <= '9') 411 || (c >= 'a' && c <= 'f'); 412} 413 414static uptr ReadHex(const char *p) { 415 uptr v = 0; 416 for (; IsHex(p[0]); p++) { 417 if (p[0] >= '0' && p[0] <= '9') 418 v = v * 16 + p[0] - '0'; 419 else 420 v = v * 16 + p[0] - 'a' + 10; 421 } 422 return v; 423} 424 425static uptr ReadDecimal(const char *p) { 426 uptr v = 0; 427 for (; IsDecimal(p[0]); p++) 428 v = v * 10 + p[0] - '0'; 429 return v; 430} 431 432 433bool MemoryMappingLayout::Next(uptr *start, uptr *end, uptr *offset, 434 char filename[], uptr filename_size, 435 uptr *protection) { 436 char *last = proc_self_maps_.data + proc_self_maps_.len; 437 if (current_ >= last) return false; 438 uptr dummy; 439 if (!start) start = &dummy; 440 if (!end) end = &dummy; 441 if (!offset) offset = &dummy; 442 char *next_line = (char*)internal_memchr(current_, '\n', last - current_); 443 if (next_line == 0) 444 next_line = last; 445 // Example: 08048000-08056000 r-xp 00000000 03:0c 64593 /foo/bar 446 *start = ParseHex(¤t_); 447 CHECK_EQ(*current_++, '-'); 448 *end = ParseHex(¤t_); 449 CHECK_EQ(*current_++, ' '); 450 uptr local_protection = 0; 451 CHECK(IsOneOf(*current_, '-', 'r')); 452 if (*current_++ == 'r') 453 local_protection |= kProtectionRead; 454 CHECK(IsOneOf(*current_, '-', 'w')); 455 if (*current_++ == 'w') 456 local_protection |= kProtectionWrite; 457 CHECK(IsOneOf(*current_, '-', 'x')); 458 if (*current_++ == 'x') 459 local_protection |= kProtectionExecute; 460 CHECK(IsOneOf(*current_, 's', 'p')); 461 if (*current_++ == 's') 462 local_protection |= kProtectionShared; 463 if (protection) { 464 *protection = local_protection; 465 } 466 CHECK_EQ(*current_++, ' '); 467 *offset = ParseHex(¤t_); 468 CHECK_EQ(*current_++, ' '); 469 ParseHex(¤t_); 470 CHECK_EQ(*current_++, ':'); 471 ParseHex(¤t_); 472 CHECK_EQ(*current_++, ' '); 473 while (IsDecimal(*current_)) 474 current_++; 475 // Qemu may lack the trailing space. 476 // http://code.google.com/p/address-sanitizer/issues/detail?id=160 477 // CHECK_EQ(*current_++, ' '); 478 // Skip spaces. 479 while (current_ < next_line && *current_ == ' ') 480 current_++; 481 // Fill in the filename. 482 uptr i = 0; 483 while (current_ < next_line) { 484 if (filename && i < filename_size - 1) 485 filename[i++] = *current_; 486 current_++; 487 } 488 if (filename && i < filename_size) 489 filename[i] = 0; 490 current_ = next_line + 1; 491 return true; 492} 493 494// Gets the object name and the offset by walking MemoryMappingLayout. 495bool MemoryMappingLayout::GetObjectNameAndOffset(uptr addr, uptr *offset, 496 char filename[], 497 uptr filename_size, 498 uptr *protection) { 499 return IterateForObjectNameAndOffset(addr, offset, filename, filename_size, 500 protection); 501} 502 503void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) { 504 char *smaps = 0; 505 uptr smaps_cap = 0; 506 uptr smaps_len = ReadFileToBuffer("/proc/self/smaps", 507 &smaps, &smaps_cap, 64<<20); 508 uptr start = 0; 509 bool file = false; 510 const char *pos = smaps; 511 while (pos < smaps + smaps_len) { 512 if (IsHex(pos[0])) { 513 start = ReadHex(pos); 514 for (; *pos != '/' && *pos > '\n'; pos++) {} 515 file = *pos == '/'; 516 } else if (internal_strncmp(pos, "Rss:", 4) == 0) { 517 for (; *pos < '0' || *pos > '9'; pos++) {} 518 uptr rss = ReadDecimal(pos) * 1024; 519 cb(start, rss, file, stats, stats_size); 520 } 521 while (*pos++ != '\n') {} 522 } 523 UnmapOrDie(smaps, smaps_cap); 524} 525 526enum MutexState { 527 MtxUnlocked = 0, 528 MtxLocked = 1, 529 MtxSleeping = 2 530}; 531 532BlockingMutex::BlockingMutex(LinkerInitialized) { 533 CHECK_EQ(owner_, 0); 534} 535 536BlockingMutex::BlockingMutex() { 537 internal_memset(this, 0, sizeof(*this)); 538} 539 540void BlockingMutex::Lock() { 541 atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_); 542 if (atomic_exchange(m, MtxLocked, memory_order_acquire) == MtxUnlocked) 543 return; 544 while (atomic_exchange(m, MtxSleeping, memory_order_acquire) != MtxUnlocked) 545 internal_syscall(__NR_futex, m, FUTEX_WAIT, MtxSleeping, 0, 0, 0); 546} 547 548void BlockingMutex::Unlock() { 549 atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_); 550 u32 v = atomic_exchange(m, MtxUnlocked, memory_order_relaxed); 551 CHECK_NE(v, MtxUnlocked); 552 if (v == MtxSleeping) 553 internal_syscall(__NR_futex, m, FUTEX_WAKE, 1, 0, 0, 0); 554} 555 556void BlockingMutex::CheckLocked() { 557 atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_); 558 CHECK_NE(MtxUnlocked, atomic_load(m, memory_order_relaxed)); 559} 560 561// ----------------- sanitizer_linux.h 562// The actual size of this structure is specified by d_reclen. 563// Note that getdents64 uses a different structure format. We only provide the 564// 32-bit syscall here. 565struct linux_dirent { 566 unsigned long d_ino; 567 unsigned long d_off; 568 unsigned short d_reclen; 569 char d_name[256]; 570}; 571 572// Syscall wrappers. 573uptr internal_ptrace(int request, int pid, void *addr, void *data) { 574 return internal_syscall(__NR_ptrace, request, pid, addr, data); 575} 576 577uptr internal_waitpid(int pid, int *status, int options) { 578 return internal_syscall(__NR_wait4, pid, status, options, 0 /* rusage */); 579} 580 581uptr internal_getpid() { 582 return internal_syscall(__NR_getpid); 583} 584 585uptr internal_getppid() { 586 return internal_syscall(__NR_getppid); 587} 588 589uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) { 590 return internal_syscall(__NR_getdents, fd, dirp, count); 591} 592 593uptr internal_lseek(fd_t fd, OFF_T offset, int whence) { 594 return internal_syscall(__NR_lseek, fd, offset, whence); 595} 596 597uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) { 598 return internal_syscall(__NR_prctl, option, arg2, arg3, arg4, arg5); 599} 600 601uptr internal_sigaltstack(const struct sigaltstack *ss, 602 struct sigaltstack *oss) { 603 return internal_syscall(__NR_sigaltstack, ss, oss); 604} 605 606uptr internal_sigaction(int signum, const __sanitizer_kernel_sigaction_t *act, 607 __sanitizer_kernel_sigaction_t *oldact) { 608 return internal_syscall(__NR_rt_sigaction, signum, act, oldact, 609 sizeof(__sanitizer_kernel_sigset_t)); 610} 611 612uptr internal_sigprocmask(int how, __sanitizer_kernel_sigset_t *set, 613 __sanitizer_kernel_sigset_t *oldset) { 614 return internal_syscall(__NR_rt_sigprocmask, (uptr)how, &set->sig[0], 615 &oldset->sig[0], sizeof(__sanitizer_kernel_sigset_t)); 616} 617 618void internal_sigfillset(__sanitizer_kernel_sigset_t *set) { 619 internal_memset(set, 0xff, sizeof(*set)); 620} 621 622void internal_sigdelset(__sanitizer_kernel_sigset_t *set, int signum) { 623 signum -= 1; 624 CHECK_GE(signum, 0); 625 CHECK_LT(signum, sizeof(*set) * 8); 626 const uptr idx = signum / (sizeof(set->sig[0]) * 8); 627 const uptr bit = signum % (sizeof(set->sig[0]) * 8); 628 set->sig[idx] &= ~(1 << bit); 629} 630 631// ThreadLister implementation. 632ThreadLister::ThreadLister(int pid) 633 : pid_(pid), 634 descriptor_(-1), 635 buffer_(4096), 636 error_(true), 637 entry_((struct linux_dirent *)buffer_.data()), 638 bytes_read_(0) { 639 char task_directory_path[80]; 640 internal_snprintf(task_directory_path, sizeof(task_directory_path), 641 "/proc/%d/task/", pid); 642 uptr openrv = internal_open(task_directory_path, O_RDONLY | O_DIRECTORY); 643 if (internal_iserror(openrv)) { 644 error_ = true; 645 Report("Can't open /proc/%d/task for reading.\n", pid); 646 } else { 647 error_ = false; 648 descriptor_ = openrv; 649 } 650} 651 652int ThreadLister::GetNextTID() { 653 int tid = -1; 654 do { 655 if (error_) 656 return -1; 657 if ((char *)entry_ >= &buffer_[bytes_read_] && !GetDirectoryEntries()) 658 return -1; 659 if (entry_->d_ino != 0 && entry_->d_name[0] >= '0' && 660 entry_->d_name[0] <= '9') { 661 // Found a valid tid. 662 tid = (int)internal_atoll(entry_->d_name); 663 } 664 entry_ = (struct linux_dirent *)(((char *)entry_) + entry_->d_reclen); 665 } while (tid < 0); 666 return tid; 667} 668 669void ThreadLister::Reset() { 670 if (error_ || descriptor_ < 0) 671 return; 672 internal_lseek(descriptor_, 0, SEEK_SET); 673} 674 675ThreadLister::~ThreadLister() { 676 if (descriptor_ >= 0) 677 internal_close(descriptor_); 678} 679 680bool ThreadLister::error() { return error_; } 681 682bool ThreadLister::GetDirectoryEntries() { 683 CHECK_GE(descriptor_, 0); 684 CHECK_NE(error_, true); 685 bytes_read_ = internal_getdents(descriptor_, 686 (struct linux_dirent *)buffer_.data(), 687 buffer_.size()); 688 if (internal_iserror(bytes_read_)) { 689 Report("Can't read directory entries from /proc/%d/task.\n", pid_); 690 error_ = true; 691 return false; 692 } else if (bytes_read_ == 0) { 693 return false; 694 } 695 entry_ = (struct linux_dirent *)buffer_.data(); 696 return true; 697} 698 699uptr GetPageSize() { 700#if defined(__x86_64__) || defined(__i386__) 701 return EXEC_PAGESIZE; 702#else 703 return sysconf(_SC_PAGESIZE); // EXEC_PAGESIZE may not be trustworthy. 704#endif 705} 706 707static char proc_self_exe_cache_str[kMaxPathLength]; 708static uptr proc_self_exe_cache_len = 0; 709 710uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) { 711 uptr module_name_len = internal_readlink( 712 "/proc/self/exe", buf, buf_len); 713 int readlink_error; 714 if (internal_iserror(module_name_len, &readlink_error)) { 715 if (proc_self_exe_cache_len) { 716 // If available, use the cached module name. 717 CHECK_LE(proc_self_exe_cache_len, buf_len); 718 internal_strncpy(buf, proc_self_exe_cache_str, buf_len); 719 module_name_len = internal_strlen(proc_self_exe_cache_str); 720 } else { 721 // We can't read /proc/self/exe for some reason, assume the name of the 722 // binary is unknown. 723 Report("WARNING: readlink(\"/proc/self/exe\") failed with errno %d, " 724 "some stack frames may not be symbolized\n", readlink_error); 725 module_name_len = internal_snprintf(buf, buf_len, "/proc/self/exe"); 726 } 727 CHECK_LT(module_name_len, buf_len); 728 buf[module_name_len] = '\0'; 729 } 730 return module_name_len; 731} 732 733void CacheBinaryName() { 734 if (!proc_self_exe_cache_len) { 735 proc_self_exe_cache_len = 736 ReadBinaryName(proc_self_exe_cache_str, kMaxPathLength); 737 } 738} 739 740// Match full names of the form /path/to/base_name{-,.}* 741bool LibraryNameIs(const char *full_name, const char *base_name) { 742 const char *name = full_name; 743 // Strip path. 744 while (*name != '\0') name++; 745 while (name > full_name && *name != '/') name--; 746 if (*name == '/') name++; 747 uptr base_name_length = internal_strlen(base_name); 748 if (internal_strncmp(name, base_name, base_name_length)) return false; 749 return (name[base_name_length] == '-' || name[base_name_length] == '.'); 750} 751 752#if !SANITIZER_ANDROID 753// Call cb for each region mapped by map. 754void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr)) { 755 typedef ElfW(Phdr) Elf_Phdr; 756 typedef ElfW(Ehdr) Elf_Ehdr; 757 char *base = (char *)map->l_addr; 758 Elf_Ehdr *ehdr = (Elf_Ehdr *)base; 759 char *phdrs = base + ehdr->e_phoff; 760 char *phdrs_end = phdrs + ehdr->e_phnum * ehdr->e_phentsize; 761 762 // Find the segment with the minimum base so we can "relocate" the p_vaddr 763 // fields. Typically ET_DYN objects (DSOs) have base of zero and ET_EXEC 764 // objects have a non-zero base. 765 uptr preferred_base = (uptr)-1; 766 for (char *iter = phdrs; iter != phdrs_end; iter += ehdr->e_phentsize) { 767 Elf_Phdr *phdr = (Elf_Phdr *)iter; 768 if (phdr->p_type == PT_LOAD && preferred_base > (uptr)phdr->p_vaddr) 769 preferred_base = (uptr)phdr->p_vaddr; 770 } 771 772 // Compute the delta from the real base to get a relocation delta. 773 sptr delta = (uptr)base - preferred_base; 774 // Now we can figure out what the loader really mapped. 775 for (char *iter = phdrs; iter != phdrs_end; iter += ehdr->e_phentsize) { 776 Elf_Phdr *phdr = (Elf_Phdr *)iter; 777 if (phdr->p_type == PT_LOAD) { 778 uptr seg_start = phdr->p_vaddr + delta; 779 uptr seg_end = seg_start + phdr->p_memsz; 780 // None of these values are aligned. We consider the ragged edges of the 781 // load command as defined, since they are mapped from the file. 782 seg_start = RoundDownTo(seg_start, GetPageSizeCached()); 783 seg_end = RoundUpTo(seg_end, GetPageSizeCached()); 784 cb((void *)seg_start, seg_end - seg_start); 785 } 786 } 787} 788#endif 789 790#if defined(__x86_64__) 791// We cannot use glibc's clone wrapper, because it messes with the child 792// task's TLS. It writes the PID and TID of the child task to its thread 793// descriptor, but in our case the child task shares the thread descriptor with 794// the parent (because we don't know how to allocate a new thread 795// descriptor to keep glibc happy). So the stock version of clone(), when 796// used with CLONE_VM, would end up corrupting the parent's thread descriptor. 797uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, 798 int *parent_tidptr, void *newtls, int *child_tidptr) { 799 long long res; 800 if (!fn || !child_stack) 801 return -EINVAL; 802 CHECK_EQ(0, (uptr)child_stack % 16); 803 child_stack = (char *)child_stack - 2 * sizeof(void *); 804 ((void **)child_stack)[0] = (void *)(uptr)fn; 805 ((void **)child_stack)[1] = arg; 806 __asm__ __volatile__( 807 /* %rax = syscall(%rax = __NR_clone, 808 * %rdi = flags, 809 * %rsi = child_stack, 810 * %rdx = parent_tidptr, 811 * %r8 = new_tls, 812 * %r10 = child_tidptr) 813 */ 814 "movq %6,%%r8\n" 815 "movq %7,%%r10\n" 816 "syscall\n" 817 818 /* if (%rax != 0) 819 * return; 820 */ 821 "testq %%rax,%%rax\n" 822 "jnz 1f\n" 823 824 /* In the child. Terminate unwind chain. */ 825 // XXX: We should also terminate the CFI unwind chain 826 // here. Unfortunately clang 3.2 doesn't support the 827 // necessary CFI directives, so we skip that part. 828 "xorq %%rbp,%%rbp\n" 829 830 /* Call "fn(arg)". */ 831 "popq %%rax\n" 832 "popq %%rdi\n" 833 "call *%%rax\n" 834 835 /* Call _exit(%rax). */ 836 "movq %%rax,%%rdi\n" 837 "movq %2,%%rax\n" 838 "syscall\n" 839 840 /* Return to parent. */ 841 "1:\n" 842 : "=a" (res) 843 : "a"(__NR_clone), "i"(__NR_exit), 844 "S"(child_stack), 845 "D"(flags), 846 "d"(parent_tidptr), 847 "r"(newtls), 848 "r"(child_tidptr) 849 : "rsp", "memory", "r8", "r10", "r11", "rcx"); 850 return res; 851} 852#endif // defined(__x86_64__) 853} // namespace __sanitizer 854 855#endif // SANITIZER_LINUX 856