1//===-- sanitizer_posix_libcdep.cc ----------------------------------------===// 2// 3// This file is distributed under the University of Illinois Open Source 4// License. See LICENSE.TXT for details. 5// 6//===----------------------------------------------------------------------===// 7// 8// This file is shared between AddressSanitizer and ThreadSanitizer 9// run-time libraries and implements libc-dependent POSIX-specific functions 10// from sanitizer_libc.h. 11//===----------------------------------------------------------------------===// 12 13#include "sanitizer_platform.h" 14 15#if SANITIZER_POSIX 16 17#include "sanitizer_common.h" 18#include "sanitizer_flags.h" 19#include "sanitizer_platform_limits_netbsd.h" 20#include "sanitizer_platform_limits_openbsd.h" 21#include "sanitizer_platform_limits_posix.h" 22#include "sanitizer_platform_limits_solaris.h" 23#include "sanitizer_posix.h" 24#include "sanitizer_procmaps.h" 25 26#include <errno.h> 27#include <fcntl.h> 28#include <pthread.h> 29#include <signal.h> 30#include <stdlib.h> 31#include <sys/mman.h> 32#include <sys/resource.h> 33#include <sys/stat.h> 34#include <sys/time.h> 35#include <sys/types.h> 36#include <sys/wait.h> 37#include <unistd.h> 38 39#if SANITIZER_FREEBSD 40// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before 41// that, it was never implemented. So just define it to zero. 42#undef MAP_NORESERVE 43#define MAP_NORESERVE 0 44#endif 45 46typedef void (*sa_sigaction_t)(int, siginfo_t *, void *); 47 48namespace __sanitizer { 49 50u32 GetUid() { 51 return getuid(); 52} 53 54uptr GetThreadSelf() { 55 return (uptr)pthread_self(); 56} 57 58void ReleaseMemoryPagesToOS(uptr beg, uptr end) { 59 uptr page_size = GetPageSizeCached(); 60 uptr beg_aligned = RoundUpTo(beg, page_size); 61 uptr end_aligned = RoundDownTo(end, page_size); 62 if (beg_aligned < end_aligned) 63 // In the default Solaris compilation environment, madvise() is declared 64 // to take a caddr_t arg; casting it to void * results in an invalid 65 // conversion error, so use char * instead. 66 madvise((char *)beg_aligned, end_aligned - beg_aligned, 67 SANITIZER_MADVISE_DONTNEED); 68} 69 70bool NoHugePagesInRegion(uptr addr, uptr size) { 71#ifdef MADV_NOHUGEPAGE // May not be defined on old systems. 72 return madvise((char *)addr, size, MADV_NOHUGEPAGE) == 0; 73#else 74 return true; 75#endif // MADV_NOHUGEPAGE 76} 77 78bool DontDumpShadowMemory(uptr addr, uptr length) { 79#if defined(MADV_DONTDUMP) 80 return madvise((char *)addr, length, MADV_DONTDUMP) == 0; 81#elif defined(MADV_NOCORE) 82 return madvise((char *)addr, length, MADV_NOCORE) == 0; 83#else 84 return true; 85#endif // MADV_DONTDUMP 86} 87 88static rlim_t getlim(int res) { 89 rlimit rlim; 90 CHECK_EQ(0, getrlimit(res, &rlim)); 91 return rlim.rlim_cur; 92} 93 94static void setlim(int res, rlim_t lim) { 95 // The following magic is to prevent clang from replacing it with memset. 96 volatile struct rlimit rlim; 97 rlim.rlim_cur = lim; 98 rlim.rlim_max = lim; 99 if (setrlimit(res, const_cast<struct rlimit *>(&rlim))) { 100 Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName, errno); 101 Die(); 102 } 103} 104 105void DisableCoreDumperIfNecessary() { 106 if (common_flags()->disable_coredump) { 107 setlim(RLIMIT_CORE, 0); 108 } 109} 110 111bool StackSizeIsUnlimited() { 112 rlim_t stack_size = getlim(RLIMIT_STACK); 113 return (stack_size == RLIM_INFINITY); 114} 115 116uptr GetStackSizeLimitInBytes() { 117 return (uptr)getlim(RLIMIT_STACK); 118} 119 120void SetStackSizeLimitInBytes(uptr limit) { 121 setlim(RLIMIT_STACK, (rlim_t)limit); 122 CHECK(!StackSizeIsUnlimited()); 123} 124 125bool AddressSpaceIsUnlimited() { 126 rlim_t as_size = getlim(RLIMIT_AS); 127 return (as_size == RLIM_INFINITY); 128} 129 130void SetAddressSpaceUnlimited() { 131 setlim(RLIMIT_AS, RLIM_INFINITY); 132 CHECK(AddressSpaceIsUnlimited()); 133} 134 135void SleepForSeconds(int seconds) { 136 sleep(seconds); 137} 138 139void SleepForMillis(int millis) { 140 usleep(millis * 1000); 141} 142 143void Abort() { 144#if !SANITIZER_GO 145 // If we are handling SIGABRT, unhandle it first. 146 // TODO(vitalybuka): Check if handler belongs to sanitizer. 147 if (GetHandleSignalMode(SIGABRT) != kHandleSignalNo) { 148 struct sigaction sigact; 149 internal_memset(&sigact, 0, sizeof(sigact)); 150 sigact.sa_sigaction = (sa_sigaction_t)SIG_DFL; 151 internal_sigaction(SIGABRT, &sigact, nullptr); 152 } 153#endif 154 155 abort(); 156} 157 158int Atexit(void (*function)(void)) { 159#if !SANITIZER_GO 160 return atexit(function); 161#else 162 return 0; 163#endif 164} 165 166bool SupportsColoredOutput(fd_t fd) { 167 return isatty(fd) != 0; 168} 169 170#if !SANITIZER_GO 171// TODO(glider): different tools may require different altstack size. 172static const uptr kAltStackSize = SIGSTKSZ * 4; // SIGSTKSZ is not enough. 173 174void SetAlternateSignalStack() { 175 stack_t altstack, oldstack; 176 CHECK_EQ(0, sigaltstack(nullptr, &oldstack)); 177 // If the alternate stack is already in place, do nothing. 178 // Android always sets an alternate stack, but it's too small for us. 179 if (!SANITIZER_ANDROID && !(oldstack.ss_flags & SS_DISABLE)) return; 180 // TODO(glider): the mapped stack should have the MAP_STACK flag in the 181 // future. It is not required by man 2 sigaltstack now (they're using 182 // malloc()). 183 void* base = MmapOrDie(kAltStackSize, __func__); 184 altstack.ss_sp = (char*) base; 185 altstack.ss_flags = 0; 186 altstack.ss_size = kAltStackSize; 187 CHECK_EQ(0, sigaltstack(&altstack, nullptr)); 188} 189 190void UnsetAlternateSignalStack() { 191 stack_t altstack, oldstack; 192 altstack.ss_sp = nullptr; 193 altstack.ss_flags = SS_DISABLE; 194 altstack.ss_size = kAltStackSize; // Some sane value required on Darwin. 195 CHECK_EQ(0, sigaltstack(&altstack, &oldstack)); 196 UnmapOrDie(oldstack.ss_sp, oldstack.ss_size); 197} 198 199static void MaybeInstallSigaction(int signum, 200 SignalHandlerType handler) { 201 if (GetHandleSignalMode(signum) == kHandleSignalNo) return; 202 203 struct sigaction sigact; 204 internal_memset(&sigact, 0, sizeof(sigact)); 205 sigact.sa_sigaction = (sa_sigaction_t)handler; 206 // Do not block the signal from being received in that signal's handler. 207 // Clients are responsible for handling this correctly. 208 sigact.sa_flags = SA_SIGINFO | SA_NODEFER; 209 if (common_flags()->use_sigaltstack) sigact.sa_flags |= SA_ONSTACK; 210 CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr)); 211 VReport(1, "Installed the sigaction for signal %d\n", signum); 212} 213 214void InstallDeadlySignalHandlers(SignalHandlerType handler) { 215 // Set the alternate signal stack for the main thread. 216 // This will cause SetAlternateSignalStack to be called twice, but the stack 217 // will be actually set only once. 218 if (common_flags()->use_sigaltstack) SetAlternateSignalStack(); 219 MaybeInstallSigaction(SIGSEGV, handler); 220 MaybeInstallSigaction(SIGBUS, handler); 221 MaybeInstallSigaction(SIGABRT, handler); 222 MaybeInstallSigaction(SIGFPE, handler); 223 MaybeInstallSigaction(SIGILL, handler); 224 MaybeInstallSigaction(SIGTRAP, handler); 225} 226 227bool SignalContext::IsStackOverflow() const { 228 // Access at a reasonable offset above SP, or slightly below it (to account 229 // for x86_64 or PowerPC redzone, ARM push of multiple registers, etc) is 230 // probably a stack overflow. 231#ifdef __s390__ 232 // On s390, the fault address in siginfo points to start of the page, not 233 // to the precise word that was accessed. Mask off the low bits of sp to 234 // take it into account. 235 bool IsStackAccess = addr >= (sp & ~0xFFF) && addr < sp + 0xFFFF; 236#else 237 // Let's accept up to a page size away from top of stack. Things like stack 238 // probing can trigger accesses with such large offsets. 239 bool IsStackAccess = addr + GetPageSizeCached() > sp && addr < sp + 0xFFFF; 240#endif 241 242#if __powerpc__ 243 // Large stack frames can be allocated with e.g. 244 // lis r0,-10000 245 // stdux r1,r1,r0 # store sp to [sp-10000] and update sp by -10000 246 // If the store faults then sp will not have been updated, so test above 247 // will not work, because the fault address will be more than just "slightly" 248 // below sp. 249 if (!IsStackAccess && IsAccessibleMemoryRange(pc, 4)) { 250 u32 inst = *(unsigned *)pc; 251 u32 ra = (inst >> 16) & 0x1F; 252 u32 opcd = inst >> 26; 253 u32 xo = (inst >> 1) & 0x3FF; 254 // Check for store-with-update to sp. The instructions we accept are: 255 // stbu rs,d(ra) stbux rs,ra,rb 256 // sthu rs,d(ra) sthux rs,ra,rb 257 // stwu rs,d(ra) stwux rs,ra,rb 258 // stdu rs,ds(ra) stdux rs,ra,rb 259 // where ra is r1 (the stack pointer). 260 if (ra == 1 && 261 (opcd == 39 || opcd == 45 || opcd == 37 || opcd == 62 || 262 (opcd == 31 && (xo == 247 || xo == 439 || xo == 183 || xo == 181)))) 263 IsStackAccess = true; 264 } 265#endif // __powerpc__ 266 267 // We also check si_code to filter out SEGV caused by something else other 268 // then hitting the guard page or unmapped memory, like, for example, 269 // unaligned memory access. 270 auto si = static_cast<const siginfo_t *>(siginfo); 271 return IsStackAccess && 272 (si->si_code == si_SEGV_MAPERR || si->si_code == si_SEGV_ACCERR); 273} 274 275#endif // SANITIZER_GO 276 277bool IsAccessibleMemoryRange(uptr beg, uptr size) { 278 uptr page_size = GetPageSizeCached(); 279 // Checking too large memory ranges is slow. 280 CHECK_LT(size, page_size * 10); 281 int sock_pair[2]; 282 if (pipe(sock_pair)) 283 return false; 284 uptr bytes_written = 285 internal_write(sock_pair[1], reinterpret_cast<void *>(beg), size); 286 int write_errno; 287 bool result; 288 if (internal_iserror(bytes_written, &write_errno)) { 289 CHECK_EQ(EFAULT, write_errno); 290 result = false; 291 } else { 292 result = (bytes_written == size); 293 } 294 internal_close(sock_pair[0]); 295 internal_close(sock_pair[1]); 296 return result; 297} 298 299void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args) { 300 // Some kinds of sandboxes may forbid filesystem access, so we won't be able 301 // to read the file mappings from /proc/self/maps. Luckily, neither the 302 // process will be able to load additional libraries, so it's fine to use the 303 // cached mappings. 304 MemoryMappingLayout::CacheMemoryMappings(); 305} 306 307#if SANITIZER_ANDROID || SANITIZER_GO || SANITIZER_NETBSD 308int GetNamedMappingFd(const char *name, uptr size) { 309 return -1; 310} 311#else 312int GetNamedMappingFd(const char *name, uptr size) { 313 if (!common_flags()->decorate_proc_maps) 314 return -1; 315 char shmname[200]; 316 CHECK(internal_strlen(name) < sizeof(shmname) - 10); 317 internal_snprintf(shmname, sizeof(shmname), "%zu [%s]", internal_getpid(), 318 name); 319 int fd = shm_open(shmname, O_RDWR | O_CREAT | O_TRUNC, S_IRWXU); 320 CHECK_GE(fd, 0); 321 int res = internal_ftruncate(fd, size); 322 CHECK_EQ(0, res); 323 res = shm_unlink(shmname); 324 CHECK_EQ(0, res); 325 return fd; 326} 327#endif 328 329bool MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) { 330 int fd = name ? GetNamedMappingFd(name, size) : -1; 331 unsigned flags = MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE; 332 if (fd == -1) flags |= MAP_ANON; 333 334 uptr PageSize = GetPageSizeCached(); 335 uptr p = internal_mmap((void *)(fixed_addr & ~(PageSize - 1)), 336 RoundUpTo(size, PageSize), PROT_READ | PROT_WRITE, 337 flags, fd, 0); 338 int reserrno; 339 if (internal_iserror(p, &reserrno)) { 340 Report("ERROR: %s failed to " 341 "allocate 0x%zx (%zd) bytes at address %zx (errno: %d)\n", 342 SanitizerToolName, size, size, fixed_addr, reserrno); 343 return false; 344 } 345 IncreaseTotalMmap(size); 346 return true; 347} 348 349uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) { 350 // We don't pass `name` along because, when you enable `decorate_proc_maps` 351 // AND actually use a named mapping AND are using a sanitizer intercepting 352 // `open` (e.g. TSAN, ESAN), then you'll get a failure during initialization. 353 // TODO(flowerhack): Fix the implementation of GetNamedMappingFd to solve 354 // this problem. 355 base_ = fixed_addr ? MmapFixedNoAccess(fixed_addr, size) : MmapNoAccess(size); 356 size_ = size; 357 name_ = name; 358 (void)os_handle_; // unsupported 359 return reinterpret_cast<uptr>(base_); 360} 361 362// Uses fixed_addr for now. 363// Will use offset instead once we've implemented this function for real. 364uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size) { 365 return reinterpret_cast<uptr>(MmapFixedOrDieOnFatalError(fixed_addr, size)); 366} 367 368uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr size) { 369 return reinterpret_cast<uptr>(MmapFixedOrDie(fixed_addr, size)); 370} 371 372void ReservedAddressRange::Unmap(uptr addr, uptr size) { 373 CHECK_LE(size, size_); 374 if (addr == reinterpret_cast<uptr>(base_)) 375 // If we unmap the whole range, just null out the base. 376 base_ = (size == size_) ? nullptr : reinterpret_cast<void*>(addr + size); 377 else 378 CHECK_EQ(addr + size, reinterpret_cast<uptr>(base_) + size_); 379 size_ -= size; 380 UnmapOrDie(reinterpret_cast<void*>(addr), size); 381} 382 383void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) { 384 int fd = name ? GetNamedMappingFd(name, size) : -1; 385 unsigned flags = MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE; 386 if (fd == -1) flags |= MAP_ANON; 387 388 return (void *)internal_mmap((void *)fixed_addr, size, PROT_NONE, flags, fd, 389 0); 390} 391 392void *MmapNoAccess(uptr size) { 393 unsigned flags = MAP_PRIVATE | MAP_ANON | MAP_NORESERVE; 394 return (void *)internal_mmap(nullptr, size, PROT_NONE, flags, -1, 0); 395} 396 397// This function is defined elsewhere if we intercepted pthread_attr_getstack. 398extern "C" { 399SANITIZER_WEAK_ATTRIBUTE int 400real_pthread_attr_getstack(void *attr, void **addr, size_t *size); 401} // extern "C" 402 403int my_pthread_attr_getstack(void *attr, void **addr, uptr *size) { 404#if !SANITIZER_GO && !SANITIZER_MAC 405 if (&real_pthread_attr_getstack) 406 return real_pthread_attr_getstack((pthread_attr_t *)attr, addr, 407 (size_t *)size); 408#endif 409 return pthread_attr_getstack((pthread_attr_t *)attr, addr, (size_t *)size); 410} 411 412#if !SANITIZER_GO 413void AdjustStackSize(void *attr_) { 414 pthread_attr_t *attr = (pthread_attr_t *)attr_; 415 uptr stackaddr = 0; 416 uptr stacksize = 0; 417 my_pthread_attr_getstack(attr, (void**)&stackaddr, &stacksize); 418 // GLibC will return (0 - stacksize) as the stack address in the case when 419 // stacksize is set, but stackaddr is not. 420 bool stack_set = (stackaddr != 0) && (stackaddr + stacksize != 0); 421 // We place a lot of tool data into TLS, account for that. 422 const uptr minstacksize = GetTlsSize() + 128*1024; 423 if (stacksize < minstacksize) { 424 if (!stack_set) { 425 if (stacksize != 0) { 426 VPrintf(1, "Sanitizer: increasing stacksize %zu->%zu\n", stacksize, 427 minstacksize); 428 pthread_attr_setstacksize(attr, minstacksize); 429 } 430 } else { 431 Printf("Sanitizer: pre-allocated stack size is insufficient: " 432 "%zu < %zu\n", stacksize, minstacksize); 433 Printf("Sanitizer: pthread_create is likely to fail.\n"); 434 } 435 } 436} 437#endif // !SANITIZER_GO 438 439pid_t StartSubprocess(const char *program, const char *const argv[], 440 fd_t stdin_fd, fd_t stdout_fd, fd_t stderr_fd) { 441 auto file_closer = at_scope_exit([&] { 442 if (stdin_fd != kInvalidFd) { 443 internal_close(stdin_fd); 444 } 445 if (stdout_fd != kInvalidFd) { 446 internal_close(stdout_fd); 447 } 448 if (stderr_fd != kInvalidFd) { 449 internal_close(stderr_fd); 450 } 451 }); 452 453 int pid = internal_fork(); 454 455 if (pid < 0) { 456 int rverrno; 457 if (internal_iserror(pid, &rverrno)) { 458 Report("WARNING: failed to fork (errno %d)\n", rverrno); 459 } 460 return pid; 461 } 462 463 if (pid == 0) { 464 // Child subprocess 465 if (stdin_fd != kInvalidFd) { 466 internal_close(STDIN_FILENO); 467 internal_dup2(stdin_fd, STDIN_FILENO); 468 internal_close(stdin_fd); 469 } 470 if (stdout_fd != kInvalidFd) { 471 internal_close(STDOUT_FILENO); 472 internal_dup2(stdout_fd, STDOUT_FILENO); 473 internal_close(stdout_fd); 474 } 475 if (stderr_fd != kInvalidFd) { 476 internal_close(STDERR_FILENO); 477 internal_dup2(stderr_fd, STDERR_FILENO); 478 internal_close(stderr_fd); 479 } 480 481 for (int fd = sysconf(_SC_OPEN_MAX); fd > 2; fd--) internal_close(fd); 482 483 execv(program, const_cast<char **>(&argv[0])); 484 internal__exit(1); 485 } 486 487 return pid; 488} 489 490bool IsProcessRunning(pid_t pid) { 491 int process_status; 492 uptr waitpid_status = internal_waitpid(pid, &process_status, WNOHANG); 493 int local_errno; 494 if (internal_iserror(waitpid_status, &local_errno)) { 495 VReport(1, "Waiting on the process failed (errno %d).\n", local_errno); 496 return false; 497 } 498 return waitpid_status == 0; 499} 500 501int WaitForProcess(pid_t pid) { 502 int process_status; 503 uptr waitpid_status = internal_waitpid(pid, &process_status, 0); 504 int local_errno; 505 if (internal_iserror(waitpid_status, &local_errno)) { 506 VReport(1, "Waiting on the process failed (errno %d).\n", local_errno); 507 return -1; 508 } 509 return process_status; 510} 511 512bool IsStateDetached(int state) { 513 return state == PTHREAD_CREATE_DETACHED; 514} 515 516} // namespace __sanitizer 517 518#endif // SANITIZER_POSIX 519