| //===-- sanitizer_posix_libcdep.cpp ---------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file is shared between AddressSanitizer and ThreadSanitizer |
| // run-time libraries and implements libc-dependent POSIX-specific functions |
| // from sanitizer_libc.h. |
| //===----------------------------------------------------------------------===// |
| |
| #include "sanitizer_platform.h" |
| |
| #if SANITIZER_POSIX |
| |
| #include "sanitizer_common.h" |
| #include "sanitizer_flags.h" |
| #include "sanitizer_platform_limits_netbsd.h" |
| #include "sanitizer_platform_limits_posix.h" |
| #include "sanitizer_platform_limits_solaris.h" |
| #include "sanitizer_posix.h" |
| #include "sanitizer_procmaps.h" |
| |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <pthread.h> |
| #include <signal.h> |
| #include <stdlib.h> |
| #include <sys/mman.h> |
| #include <sys/resource.h> |
| #include <sys/stat.h> |
| #include <sys/time.h> |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #include <unistd.h> |
| |
| #if SANITIZER_FREEBSD |
| // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before |
| // that, it was never implemented. So just define it to zero. |
| #undef MAP_NORESERVE |
| #define MAP_NORESERVE 0 |
| #endif |
| |
| typedef void (*sa_sigaction_t)(int, siginfo_t *, void *); |
| |
| namespace __sanitizer { |
| |
| u32 GetUid() { |
| return getuid(); |
| } |
| |
| uptr GetThreadSelf() { |
| return (uptr)pthread_self(); |
| } |
| |
| void ReleaseMemoryPagesToOS(uptr beg, uptr end) { |
| uptr page_size = GetPageSizeCached(); |
| uptr beg_aligned = RoundUpTo(beg, page_size); |
| uptr end_aligned = RoundDownTo(end, page_size); |
| if (beg_aligned < end_aligned) |
| internal_madvise(beg_aligned, end_aligned - beg_aligned, |
| SANITIZER_MADVISE_DONTNEED); |
| } |
| |
| void SetShadowRegionHugePageMode(uptr addr, uptr size) { |
| #ifdef MADV_NOHUGEPAGE // May not be defined on old systems. |
| if (common_flags()->no_huge_pages_for_shadow) |
| internal_madvise(addr, size, MADV_NOHUGEPAGE); |
| else |
| internal_madvise(addr, size, MADV_HUGEPAGE); |
| #endif // MADV_NOHUGEPAGE |
| } |
| |
| bool DontDumpShadowMemory(uptr addr, uptr length) { |
| #if defined(MADV_DONTDUMP) |
| return internal_madvise(addr, length, MADV_DONTDUMP) == 0; |
| #elif defined(MADV_NOCORE) |
| return internal_madvise(addr, length, MADV_NOCORE) == 0; |
| #else |
| return true; |
| #endif // MADV_DONTDUMP |
| } |
| |
| static rlim_t getlim(int res) { |
| rlimit rlim; |
| CHECK_EQ(0, getrlimit(res, &rlim)); |
| return rlim.rlim_cur; |
| } |
| |
| static void setlim(int res, rlim_t lim) { |
| struct rlimit rlim; |
| if (getrlimit(res, const_cast<struct rlimit *>(&rlim))) { |
| Report("ERROR: %s getrlimit() failed %d\n", SanitizerToolName, errno); |
| Die(); |
| } |
| rlim.rlim_cur = lim; |
| if (setrlimit(res, const_cast<struct rlimit *>(&rlim))) { |
| Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName, errno); |
| Die(); |
| } |
| } |
| |
| void DisableCoreDumperIfNecessary() { |
| if (common_flags()->disable_coredump) { |
| setlim(RLIMIT_CORE, 0); |
| } |
| } |
| |
| bool StackSizeIsUnlimited() { |
| rlim_t stack_size = getlim(RLIMIT_STACK); |
| return (stack_size == RLIM_INFINITY); |
| } |
| |
| void SetStackSizeLimitInBytes(uptr limit) { |
| setlim(RLIMIT_STACK, (rlim_t)limit); |
| CHECK(!StackSizeIsUnlimited()); |
| } |
| |
| bool AddressSpaceIsUnlimited() { |
| rlim_t as_size = getlim(RLIMIT_AS); |
| return (as_size == RLIM_INFINITY); |
| } |
| |
| void SetAddressSpaceUnlimited() { |
| setlim(RLIMIT_AS, RLIM_INFINITY); |
| CHECK(AddressSpaceIsUnlimited()); |
| } |
| |
| void SleepForSeconds(int seconds) { |
| sleep(seconds); |
| } |
| |
| void SleepForMillis(int millis) { |
| usleep(millis * 1000); |
| } |
| |
| void Abort() { |
| #if !SANITIZER_GO |
| // If we are handling SIGABRT, unhandle it first. |
| // TODO(vitalybuka): Check if handler belongs to sanitizer. |
| if (GetHandleSignalMode(SIGABRT) != kHandleSignalNo) { |
| struct sigaction sigact; |
| internal_memset(&sigact, 0, sizeof(sigact)); |
| sigact.sa_sigaction = (sa_sigaction_t)SIG_DFL; |
| internal_sigaction(SIGABRT, &sigact, nullptr); |
| } |
| #endif |
| |
| abort(); |
| } |
| |
| int Atexit(void (*function)(void)) { |
| #if !SANITIZER_GO |
| return atexit(function); |
| #else |
| return 0; |
| #endif |
| } |
| |
| bool SupportsColoredOutput(fd_t fd) { |
| return isatty(fd) != 0; |
| } |
| |
| #if !SANITIZER_GO |
| // TODO(glider): different tools may require different altstack size. |
| static const uptr kAltStackSize = SIGSTKSZ * 4; // SIGSTKSZ is not enough. |
| |
| void SetAlternateSignalStack() { |
| stack_t altstack, oldstack; |
| CHECK_EQ(0, sigaltstack(nullptr, &oldstack)); |
| // If the alternate stack is already in place, do nothing. |
| // Android always sets an alternate stack, but it's too small for us. |
| if (!SANITIZER_ANDROID && !(oldstack.ss_flags & SS_DISABLE)) return; |
| // TODO(glider): the mapped stack should have the MAP_STACK flag in the |
| // future. It is not required by man 2 sigaltstack now (they're using |
| // malloc()). |
| void* base = MmapOrDie(kAltStackSize, __func__); |
| altstack.ss_sp = (char*) base; |
| altstack.ss_flags = 0; |
| altstack.ss_size = kAltStackSize; |
| CHECK_EQ(0, sigaltstack(&altstack, nullptr)); |
| } |
| |
| void UnsetAlternateSignalStack() { |
| stack_t altstack, oldstack; |
| altstack.ss_sp = nullptr; |
| altstack.ss_flags = SS_DISABLE; |
| altstack.ss_size = kAltStackSize; // Some sane value required on Darwin. |
| CHECK_EQ(0, sigaltstack(&altstack, &oldstack)); |
| UnmapOrDie(oldstack.ss_sp, oldstack.ss_size); |
| } |
| |
| static void MaybeInstallSigaction(int signum, |
| SignalHandlerType handler) { |
| if (GetHandleSignalMode(signum) == kHandleSignalNo) return; |
| |
| struct sigaction sigact; |
| internal_memset(&sigact, 0, sizeof(sigact)); |
| sigact.sa_sigaction = (sa_sigaction_t)handler; |
| // Do not block the signal from being received in that signal's handler. |
| // Clients are responsible for handling this correctly. |
| sigact.sa_flags = SA_SIGINFO | SA_NODEFER; |
| if (common_flags()->use_sigaltstack) sigact.sa_flags |= SA_ONSTACK; |
| CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr)); |
| VReport(1, "Installed the sigaction for signal %d\n", signum); |
| } |
| |
| void InstallDeadlySignalHandlers(SignalHandlerType handler) { |
| // Set the alternate signal stack for the main thread. |
| // This will cause SetAlternateSignalStack to be called twice, but the stack |
| // will be actually set only once. |
| if (common_flags()->use_sigaltstack) SetAlternateSignalStack(); |
| MaybeInstallSigaction(SIGSEGV, handler); |
| MaybeInstallSigaction(SIGBUS, handler); |
| MaybeInstallSigaction(SIGABRT, handler); |
| MaybeInstallSigaction(SIGFPE, handler); |
| MaybeInstallSigaction(SIGILL, handler); |
| MaybeInstallSigaction(SIGTRAP, handler); |
| } |
| |
| bool SignalContext::IsStackOverflow() const { |
| // Access at a reasonable offset above SP, or slightly below it (to account |
| // for x86_64 or PowerPC redzone, ARM push of multiple registers, etc) is |
| // probably a stack overflow. |
| #ifdef __s390__ |
| // On s390, the fault address in siginfo points to start of the page, not |
| // to the precise word that was accessed. Mask off the low bits of sp to |
| // take it into account. |
| bool IsStackAccess = addr >= (sp & ~0xFFF) && addr < sp + 0xFFFF; |
| #else |
| // Let's accept up to a page size away from top of stack. Things like stack |
| // probing can trigger accesses with such large offsets. |
| bool IsStackAccess = addr + GetPageSizeCached() > sp && addr < sp + 0xFFFF; |
| #endif |
| |
| #if __powerpc__ |
| // Large stack frames can be allocated with e.g. |
| // lis r0,-10000 |
| // stdux r1,r1,r0 # store sp to [sp-10000] and update sp by -10000 |
| // If the store faults then sp will not have been updated, so test above |
| // will not work, because the fault address will be more than just "slightly" |
| // below sp. |
| if (!IsStackAccess && IsAccessibleMemoryRange(pc, 4)) { |
| u32 inst = *(unsigned *)pc; |
| u32 ra = (inst >> 16) & 0x1F; |
| u32 opcd = inst >> 26; |
| u32 xo = (inst >> 1) & 0x3FF; |
| // Check for store-with-update to sp. The instructions we accept are: |
| // stbu rs,d(ra) stbux rs,ra,rb |
| // sthu rs,d(ra) sthux rs,ra,rb |
| // stwu rs,d(ra) stwux rs,ra,rb |
| // stdu rs,ds(ra) stdux rs,ra,rb |
| // where ra is r1 (the stack pointer). |
| if (ra == 1 && |
| (opcd == 39 || opcd == 45 || opcd == 37 || opcd == 62 || |
| (opcd == 31 && (xo == 247 || xo == 439 || xo == 183 || xo == 181)))) |
| IsStackAccess = true; |
| } |
| #endif // __powerpc__ |
| |
| // We also check si_code to filter out SEGV caused by something else other |
| // then hitting the guard page or unmapped memory, like, for example, |
| // unaligned memory access. |
| auto si = static_cast<const siginfo_t *>(siginfo); |
| return IsStackAccess && |
| (si->si_code == si_SEGV_MAPERR || si->si_code == si_SEGV_ACCERR); |
| } |
| |
| #endif // SANITIZER_GO |
| |
| bool IsAccessibleMemoryRange(uptr beg, uptr size) { |
| uptr page_size = GetPageSizeCached(); |
| // Checking too large memory ranges is slow. |
| CHECK_LT(size, page_size * 10); |
| int sock_pair[2]; |
| if (pipe(sock_pair)) |
| return false; |
| uptr bytes_written = |
| internal_write(sock_pair[1], reinterpret_cast<void *>(beg), size); |
| int write_errno; |
| bool result; |
| if (internal_iserror(bytes_written, &write_errno)) { |
| CHECK_EQ(EFAULT, write_errno); |
| result = false; |
| } else { |
| result = (bytes_written == size); |
| } |
| internal_close(sock_pair[0]); |
| internal_close(sock_pair[1]); |
| return result; |
| } |
| |
| void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args) { |
| // Some kinds of sandboxes may forbid filesystem access, so we won't be able |
| // to read the file mappings from /proc/self/maps. Luckily, neither the |
| // process will be able to load additional libraries, so it's fine to use the |
| // cached mappings. |
| MemoryMappingLayout::CacheMemoryMappings(); |
| } |
| |
| static bool MmapFixed(uptr fixed_addr, uptr size, int additional_flags, |
| const char *name) { |
| size = RoundUpTo(size, GetPageSizeCached()); |
| fixed_addr = RoundDownTo(fixed_addr, GetPageSizeCached()); |
| uptr p = |
| MmapNamed((void *)fixed_addr, size, PROT_READ | PROT_WRITE, |
| MAP_PRIVATE | MAP_FIXED | additional_flags | MAP_ANON, name); |
| int reserrno; |
| if (internal_iserror(p, &reserrno)) { |
| Report("ERROR: %s failed to " |
| "allocate 0x%zx (%zd) bytes at address %zx (errno: %d)\n", |
| SanitizerToolName, size, size, fixed_addr, reserrno); |
| return false; |
| } |
| IncreaseTotalMmap(size); |
| return true; |
| } |
| |
| bool MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) { |
| return MmapFixed(fixed_addr, size, MAP_NORESERVE, name); |
| } |
| |
| bool MmapFixedSuperNoReserve(uptr fixed_addr, uptr size, const char *name) { |
| #if SANITIZER_FREEBSD |
| if (common_flags()->no_huge_pages_for_shadow) |
| return MmapFixedNoReserve(fixed_addr, size, name); |
| // MAP_NORESERVE is implicit with FreeBSD |
| return MmapFixed(fixed_addr, size, MAP_ALIGNED_SUPER, name); |
| #else |
| bool r = MmapFixedNoReserve(fixed_addr, size, name); |
| if (r) |
| SetShadowRegionHugePageMode(fixed_addr, size); |
| return r; |
| #endif |
| } |
| |
| uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) { |
| base_ = fixed_addr ? MmapFixedNoAccess(fixed_addr, size, name) |
| : MmapNoAccess(size); |
| size_ = size; |
| name_ = name; |
| (void)os_handle_; // unsupported |
| return reinterpret_cast<uptr>(base_); |
| } |
| |
| // Uses fixed_addr for now. |
| // Will use offset instead once we've implemented this function for real. |
| uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size, const char *name) { |
| return reinterpret_cast<uptr>( |
| MmapFixedOrDieOnFatalError(fixed_addr, size, name)); |
| } |
| |
| uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr size, |
| const char *name) { |
| return reinterpret_cast<uptr>(MmapFixedOrDie(fixed_addr, size, name)); |
| } |
| |
| void ReservedAddressRange::Unmap(uptr addr, uptr size) { |
| CHECK_LE(size, size_); |
| if (addr == reinterpret_cast<uptr>(base_)) |
| // If we unmap the whole range, just null out the base. |
| base_ = (size == size_) ? nullptr : reinterpret_cast<void*>(addr + size); |
| else |
| CHECK_EQ(addr + size, reinterpret_cast<uptr>(base_) + size_); |
| size_ -= size; |
| UnmapOrDie(reinterpret_cast<void*>(addr), size); |
| } |
| |
| void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) { |
| return (void *)MmapNamed((void *)fixed_addr, size, PROT_NONE, |
| MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE | MAP_ANON, |
| name); |
| } |
| |
| void *MmapNoAccess(uptr size) { |
| unsigned flags = MAP_PRIVATE | MAP_ANON | MAP_NORESERVE; |
| return (void *)internal_mmap(nullptr, size, PROT_NONE, flags, -1, 0); |
| } |
| |
| // This function is defined elsewhere if we intercepted pthread_attr_getstack. |
| extern "C" { |
| SANITIZER_WEAK_ATTRIBUTE int |
| real_pthread_attr_getstack(void *attr, void **addr, size_t *size); |
| } // extern "C" |
| |
| int my_pthread_attr_getstack(void *attr, void **addr, uptr *size) { |
| #if !SANITIZER_GO && !SANITIZER_MAC |
| if (&real_pthread_attr_getstack) |
| return real_pthread_attr_getstack((pthread_attr_t *)attr, addr, |
| (size_t *)size); |
| #endif |
| return pthread_attr_getstack((pthread_attr_t *)attr, addr, (size_t *)size); |
| } |
| |
| #if !SANITIZER_GO |
| void AdjustStackSize(void *attr_) { |
| pthread_attr_t *attr = (pthread_attr_t *)attr_; |
| uptr stackaddr = 0; |
| uptr stacksize = 0; |
| my_pthread_attr_getstack(attr, (void**)&stackaddr, &stacksize); |
| // GLibC will return (0 - stacksize) as the stack address in the case when |
| // stacksize is set, but stackaddr is not. |
| bool stack_set = (stackaddr != 0) && (stackaddr + stacksize != 0); |
| // We place a lot of tool data into TLS, account for that. |
| const uptr minstacksize = GetTlsSize() + 128*1024; |
| if (stacksize < minstacksize) { |
| if (!stack_set) { |
| if (stacksize != 0) { |
| VPrintf(1, "Sanitizer: increasing stacksize %zu->%zu\n", stacksize, |
| minstacksize); |
| pthread_attr_setstacksize(attr, minstacksize); |
| } |
| } else { |
| Printf("Sanitizer: pre-allocated stack size is insufficient: " |
| "%zu < %zu\n", stacksize, minstacksize); |
| Printf("Sanitizer: pthread_create is likely to fail.\n"); |
| } |
| } |
| } |
| #endif // !SANITIZER_GO |
| |
| pid_t StartSubprocess(const char *program, const char *const argv[], |
| const char *const envp[], fd_t stdin_fd, fd_t stdout_fd, |
| fd_t stderr_fd) { |
| auto file_closer = at_scope_exit([&] { |
| if (stdin_fd != kInvalidFd) { |
| internal_close(stdin_fd); |
| } |
| if (stdout_fd != kInvalidFd) { |
| internal_close(stdout_fd); |
| } |
| if (stderr_fd != kInvalidFd) { |
| internal_close(stderr_fd); |
| } |
| }); |
| |
| int pid = internal_fork(); |
| |
| if (pid < 0) { |
| int rverrno; |
| if (internal_iserror(pid, &rverrno)) { |
| Report("WARNING: failed to fork (errno %d)\n", rverrno); |
| } |
| return pid; |
| } |
| |
| if (pid == 0) { |
| // Child subprocess |
| if (stdin_fd != kInvalidFd) { |
| internal_close(STDIN_FILENO); |
| internal_dup2(stdin_fd, STDIN_FILENO); |
| internal_close(stdin_fd); |
| } |
| if (stdout_fd != kInvalidFd) { |
| internal_close(STDOUT_FILENO); |
| internal_dup2(stdout_fd, STDOUT_FILENO); |
| internal_close(stdout_fd); |
| } |
| if (stderr_fd != kInvalidFd) { |
| internal_close(STDERR_FILENO); |
| internal_dup2(stderr_fd, STDERR_FILENO); |
| internal_close(stderr_fd); |
| } |
| |
| for (int fd = sysconf(_SC_OPEN_MAX); fd > 2; fd--) internal_close(fd); |
| |
| internal_execve(program, const_cast<char **>(&argv[0]), |
| const_cast<char *const *>(envp)); |
| internal__exit(1); |
| } |
| |
| return pid; |
| } |
| |
| bool IsProcessRunning(pid_t pid) { |
| int process_status; |
| uptr waitpid_status = internal_waitpid(pid, &process_status, WNOHANG); |
| int local_errno; |
| if (internal_iserror(waitpid_status, &local_errno)) { |
| VReport(1, "Waiting on the process failed (errno %d).\n", local_errno); |
| return false; |
| } |
| return waitpid_status == 0; |
| } |
| |
| int WaitForProcess(pid_t pid) { |
| int process_status; |
| uptr waitpid_status = internal_waitpid(pid, &process_status, 0); |
| int local_errno; |
| if (internal_iserror(waitpid_status, &local_errno)) { |
| VReport(1, "Waiting on the process failed (errno %d).\n", local_errno); |
| return -1; |
| } |
| return process_status; |
| } |
| |
| bool IsStateDetached(int state) { |
| return state == PTHREAD_CREATE_DETACHED; |
| } |
| |
| } // namespace __sanitizer |
| |
| #endif // SANITIZER_POSIX |