lib/scudo/standalone/linux.cpp - llvm-project/compiler-rt - Git at Google

 //===-- 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);
   }
 }

 void HybridMutex::unlock() {
   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;
 #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
	//===-- 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);
	}
	}

	void HybridMutex::unlock() {
	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;
	#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