| //===-- linux.cpp -----------------------------------------------*- C++ -*-===// | |
| // | |
| // 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 | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "platform.h" | |
| #if SCUDO_LINUX | |
| #include "common.h" | |
| #include "internal_defs.h" | |
| #include "linux.h" | |
| #include "mutex.h" | |
| #include "report_linux.h" | |
| #include "string_utils.h" | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <linux/futex.h> | |
| #include <sched.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <sys/mman.h> | |
| #include <sys/stat.h> | |
| #include <sys/syscall.h> | |
| #include <sys/time.h> | |
| #include <time.h> | |
| #include <unistd.h> | |
| #if SCUDO_ANDROID | |
| #include <sys/prctl.h> | |
| // Definitions of prctl arguments to set a vma name in Android kernels. | |
| #define ANDROID_PR_SET_VMA 0x53564d41 | |
| #define ANDROID_PR_SET_VMA_ANON_NAME 0 | |
| #endif | |
| namespace scudo { | |
| #if !defined(SCUDO_PAGE_SIZE) | |
| // This function is only used when page size is not hard-coded. | |
| uptr getPageSize() { return static_cast<uptr>(sysconf(_SC_PAGESIZE)); } | |
| #endif | |
| void NORETURN die() { abort(); } | |
| // TODO: Will be deprecated. Use the interfaces in MemMapLinux instead. | |
| void *map(void *Addr, uptr Size, UNUSED const char *Name, uptr Flags, | |
| UNUSED MapPlatformData *Data) { | |
| int MmapFlags = MAP_PRIVATE | MAP_ANONYMOUS; | |
| int MmapProt; | |
| if (Flags & MAP_NOACCESS) { | |
| MmapFlags |= MAP_NORESERVE; | |
| MmapProt = PROT_NONE; | |
| } else { | |
| MmapProt = PROT_READ | PROT_WRITE; | |
| } | |
| #if defined(__aarch64__) | |
| #ifndef PROT_MTE | |
| #define PROT_MTE 0x20 | |
| #endif | |
| if (Flags & MAP_MEMTAG) | |
| MmapProt |= PROT_MTE; | |
| #endif | |
| if (Addr) | |
| MmapFlags |= MAP_FIXED; | |
| void *P = mmap(Addr, Size, MmapProt, MmapFlags, -1, 0); | |
| if (P == MAP_FAILED) { | |
| if (!(Flags & MAP_ALLOWNOMEM) || errno != ENOMEM) | |
| reportMapError(errno == ENOMEM ? Size : 0); | |
| return nullptr; | |
| } | |
| #if SCUDO_ANDROID | |
| if (Name) | |
| prctl(ANDROID_PR_SET_VMA, ANDROID_PR_SET_VMA_ANON_NAME, P, Size, Name); | |
| #endif | |
| return P; | |
| } | |
| // TODO: Will be deprecated. Use the interfaces in MemMapLinux instead. | |
| void unmap(void *Addr, uptr Size, UNUSED uptr Flags, | |
| UNUSED MapPlatformData *Data) { | |
| if (munmap(Addr, Size) != 0) | |
| reportUnmapError(reinterpret_cast<uptr>(Addr), Size); | |
| } | |
| // TODO: Will be deprecated. Use the interfaces in MemMapLinux instead. | |
| void setMemoryPermission(uptr Addr, uptr Size, uptr Flags, | |
| UNUSED MapPlatformData *Data) { | |
| int Prot = (Flags & MAP_NOACCESS) ? PROT_NONE : (PROT_READ | PROT_WRITE); | |
| if (mprotect(reinterpret_cast<void *>(Addr), Size, Prot) != 0) | |
| reportProtectError(Addr, Size, Prot); | |
| } | |
| // TODO: Will be deprecated. Use the interfaces in MemMapLinux instead. | |
| void releasePagesToOS(uptr BaseAddress, uptr Offset, uptr Size, | |
| UNUSED MapPlatformData *Data) { | |
| void *Addr = reinterpret_cast<void *>(BaseAddress + Offset); | |
| while (madvise(Addr, Size, MADV_DONTNEED) == -1 && errno == EAGAIN) { | |
| } | |
| } | |
| // Calling getenv should be fine (c)(tm) at any time. | |
| const char *getEnv(const char *Name) { return getenv(Name); } | |
| namespace { | |
| enum State : u32 { Unlocked = 0, Locked = 1, Sleeping = 2 }; | |
| } | |
| bool HybridMutex::tryLock() { | |
| return atomic_compare_exchange_strong(&M, Unlocked, Locked, | |
| memory_order_acquire) == Unlocked; | |
| } | |
| // The following is based on https://akkadia.org/drepper/futex.pdf. | |
| void HybridMutex::lockSlow() { | |
| u32 V = atomic_compare_exchange_strong(&M, Unlocked, Locked, | |
| memory_order_acquire); | |
| if (V == Unlocked) | |
| return; | |
| if (V != Sleeping) | |
| V = atomic_exchange(&M, Sleeping, memory_order_acquire); | |
| while (V != Unlocked) { | |
| syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAIT_PRIVATE, Sleeping, | |
| nullptr, nullptr, 0); | |
| V = atomic_exchange(&M, Sleeping, memory_order_acquire); | |
| } | |
| if (SCUDO_DEBUG) | |
| assertHeldImpl(); | |
| } | |
| void HybridMutex::unlock() { | |
| if (SCUDO_DEBUG) | |
| assertHeldImpl(); | |
| if (atomic_fetch_sub(&M, 1U, memory_order_release) != Locked) { | |
| atomic_store(&M, Unlocked, memory_order_release); | |
| syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAKE_PRIVATE, 1, | |
| nullptr, nullptr, 0); | |
| } | |
| } | |
| void HybridMutex::assertHeldImpl() { | |
| CHECK(atomic_load(&M, memory_order_acquire) != Unlocked); | |
| } | |
| u64 getMonotonicTime() { | |
| timespec TS; | |
| clock_gettime(CLOCK_MONOTONIC, &TS); | |
| return static_cast<u64>(TS.tv_sec) * (1000ULL * 1000 * 1000) + | |
| static_cast<u64>(TS.tv_nsec); | |
| } | |
| u64 getMonotonicTimeFast() { | |
| #if defined(CLOCK_MONOTONIC_COARSE) | |
| timespec TS; | |
| clock_gettime(CLOCK_MONOTONIC_COARSE, &TS); | |
| return static_cast<u64>(TS.tv_sec) * (1000ULL * 1000 * 1000) + | |
| static_cast<u64>(TS.tv_nsec); | |
| #else | |
| return getMonotonicTime(); | |
| #endif | |
| } | |
| u32 getNumberOfCPUs() { | |
| cpu_set_t CPUs; | |
| // sched_getaffinity can fail for a variety of legitimate reasons (lack of | |
| // CAP_SYS_NICE, syscall filtering, etc), in which case we shall return 0. | |
| if (sched_getaffinity(0, sizeof(cpu_set_t), &CPUs) != 0) | |
| return 0; | |
| return static_cast<u32>(CPU_COUNT(&CPUs)); | |
| } | |
| u32 getThreadID() { | |
| #if SCUDO_ANDROID | |
| return static_cast<u32>(gettid()); | |
| #else | |
| return static_cast<u32>(syscall(SYS_gettid)); | |
| #endif | |
| } | |
| // Blocking is possibly unused if the getrandom block is not compiled in. | |
| bool getRandom(void *Buffer, uptr Length, UNUSED bool Blocking) { | |
| if (!Buffer || !Length || Length > MaxRandomLength) | |
| return false; | |
| ssize_t ReadBytes; | |
| #if defined(SYS_getrandom) | |
| #if !defined(GRND_NONBLOCK) | |
| #define GRND_NONBLOCK 1 | |
| #endif | |
| // Up to 256 bytes, getrandom will not be interrupted. | |
| ReadBytes = | |
| syscall(SYS_getrandom, Buffer, Length, Blocking ? 0 : GRND_NONBLOCK); | |
| if (ReadBytes == static_cast<ssize_t>(Length)) | |
| return true; | |
| // If this system call is not implemented in the kernel, then we will try | |
| // and use /dev/urandom. Otherwise, if the syscall fails, return false | |
| // assuming that trying to read /dev/urandom will cause a delay waiting for | |
| // the random data to be usable. | |
| if (errno != ENOSYS) | |
| return false; | |
| #endif // defined(SYS_getrandom) | |
| // Up to 256 bytes, a read off /dev/urandom will not be interrupted. | |
| // Blocking is moot here, O_NONBLOCK has no effect when opening /dev/urandom. | |
| const int FileDesc = open("/dev/urandom", O_RDONLY); | |
| if (FileDesc == -1) | |
| return false; | |
| ReadBytes = read(FileDesc, Buffer, Length); | |
| close(FileDesc); | |
| return (ReadBytes == static_cast<ssize_t>(Length)); | |
| } | |
| // Allocation free syslog-like API. | |
| extern "C" WEAK int async_safe_write_log(int pri, const char *tag, | |
| const char *msg); | |
| void outputRaw(const char *Buffer) { | |
| if (&async_safe_write_log) { | |
| constexpr s32 AndroidLogInfo = 4; | |
| constexpr uptr MaxLength = 1024U; | |
| char LocalBuffer[MaxLength]; | |
| while (strlen(Buffer) > MaxLength) { | |
| uptr P; | |
| for (P = MaxLength - 1; P > 0; P--) { | |
| if (Buffer[P] == '\n') { | |
| memcpy(LocalBuffer, Buffer, P); | |
| LocalBuffer[P] = '\0'; | |
| async_safe_write_log(AndroidLogInfo, "scudo", LocalBuffer); | |
| Buffer = &Buffer[P + 1]; | |
| break; | |
| } | |
| } | |
| // If no newline was found, just log the buffer. | |
| if (P == 0) | |
| break; | |
| } | |
| async_safe_write_log(AndroidLogInfo, "scudo", Buffer); | |
| } else { | |
| (void)write(2, Buffer, strlen(Buffer)); | |
| } | |
| } | |
| extern "C" WEAK void android_set_abort_message(const char *); | |
| void setAbortMessage(const char *Message) { | |
| if (&android_set_abort_message) | |
| android_set_abort_message(Message); | |
| } | |
| } // namespace scudo | |
| #endif // SCUDO_LINUX |