1 //===-- linux.cpp -----------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "platform.h" 10 11 #if SCUDO_LINUX 12 13 #include "common.h" 14 #include "linux.h" 15 #include "mutex.h" 16 #include "string_utils.h" 17 18 #include <errno.h> 19 #include <fcntl.h> 20 #include <linux/futex.h> 21 #include <sched.h> 22 #include <stdio.h> 23 #include <stdlib.h> 24 #include <string.h> 25 #include <sys/mman.h> 26 #include <sys/stat.h> 27 #include <sys/syscall.h> 28 #include <sys/time.h> 29 #include <time.h> 30 #include <unistd.h> 31 32 #if SCUDO_ANDROID 33 #include <sys/prctl.h> 34 // Definitions of prctl arguments to set a vma name in Android kernels. 35 #define ANDROID_PR_SET_VMA 0x53564d41 36 #define ANDROID_PR_SET_VMA_ANON_NAME 0 37 #endif 38 39 namespace scudo { 40 41 uptr getPageSize() { return static_cast<uptr>(sysconf(_SC_PAGESIZE)); } 42 43 void NORETURN die() { abort(); } 44 45 void *map(void *Addr, uptr Size, UNUSED const char *Name, uptr Flags, 46 UNUSED MapPlatformData *Data) { 47 int MmapFlags = MAP_PRIVATE | MAP_ANONYMOUS; 48 int MmapProt; 49 if (Flags & MAP_NOACCESS) { 50 MmapFlags |= MAP_NORESERVE; 51 MmapProt = PROT_NONE; 52 } else { 53 MmapProt = PROT_READ | PROT_WRITE; 54 } 55 #if defined(__aarch64__) 56 #ifndef PROT_MTE 57 #define PROT_MTE 0x20 58 #endif 59 if (Flags & MAP_MEMTAG) 60 MmapProt |= PROT_MTE; 61 #endif 62 if (Addr) 63 MmapFlags |= MAP_FIXED; 64 void *P = mmap(Addr, Size, MmapProt, MmapFlags, -1, 0); 65 if (P == MAP_FAILED) { 66 if (!(Flags & MAP_ALLOWNOMEM) || errno != ENOMEM) 67 dieOnMapUnmapError(errno == ENOMEM ? Size : 0); 68 return nullptr; 69 } 70 #if SCUDO_ANDROID 71 if (Name) 72 prctl(ANDROID_PR_SET_VMA, ANDROID_PR_SET_VMA_ANON_NAME, P, Size, Name); 73 #endif 74 return P; 75 } 76 77 void unmap(void *Addr, uptr Size, UNUSED uptr Flags, 78 UNUSED MapPlatformData *Data) { 79 if (munmap(Addr, Size) != 0) 80 dieOnMapUnmapError(); 81 } 82 83 void setMemoryPermission(uptr Addr, uptr Size, uptr Flags, 84 UNUSED MapPlatformData *Data) { 85 int Prot = (Flags & MAP_NOACCESS) ? PROT_NONE : (PROT_READ | PROT_WRITE); 86 if (mprotect(reinterpret_cast<void *>(Addr), Size, Prot) != 0) 87 dieOnMapUnmapError(); 88 } 89 90 void releasePagesToOS(uptr BaseAddress, uptr Offset, uptr Size, 91 UNUSED MapPlatformData *Data) { 92 void *Addr = reinterpret_cast<void *>(BaseAddress + Offset); 93 94 while (madvise(Addr, Size, MADV_DONTNEED) == -1 && errno == EAGAIN) { 95 } 96 } 97 98 // Calling getenv should be fine (c)(tm) at any time. 99 const char *getEnv(const char *Name) { return getenv(Name); } 100 101 namespace { 102 enum State : u32 { Unlocked = 0, Locked = 1, Sleeping = 2 }; 103 } 104 105 bool HybridMutex::tryLock() { 106 return atomic_compare_exchange(&M, Unlocked, Locked) == Unlocked; 107 } 108 109 // The following is based on https://akkadia.org/drepper/futex.pdf. 110 void HybridMutex::lockSlow() { 111 u32 V = atomic_compare_exchange(&M, Unlocked, Locked); 112 if (V == Unlocked) 113 return; 114 if (V != Sleeping) 115 V = atomic_exchange(&M, Sleeping, memory_order_acquire); 116 while (V != Unlocked) { 117 syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAIT_PRIVATE, Sleeping, 118 nullptr, nullptr, 0); 119 V = atomic_exchange(&M, Sleeping, memory_order_acquire); 120 } 121 } 122 123 void HybridMutex::unlock() { 124 if (atomic_fetch_sub(&M, 1U, memory_order_release) != Locked) { 125 atomic_store(&M, Unlocked, memory_order_release); 126 syscall(SYS_futex, reinterpret_cast<uptr>(&M), FUTEX_WAKE_PRIVATE, 1, 127 nullptr, nullptr, 0); 128 } 129 } 130 131 u64 getMonotonicTime() { 132 timespec TS; 133 clock_gettime(CLOCK_MONOTONIC, &TS); 134 return static_cast<u64>(TS.tv_sec) * (1000ULL * 1000 * 1000) + 135 static_cast<u64>(TS.tv_nsec); 136 } 137 138 u32 getNumberOfCPUs() { 139 cpu_set_t CPUs; 140 // sched_getaffinity can fail for a variety of legitimate reasons (lack of 141 // CAP_SYS_NICE, syscall filtering, etc), in which case we shall return 0. 142 if (sched_getaffinity(0, sizeof(cpu_set_t), &CPUs) != 0) 143 return 0; 144 return static_cast<u32>(CPU_COUNT(&CPUs)); 145 } 146 147 u32 getThreadID() { 148 #if SCUDO_ANDROID 149 return static_cast<u32>(gettid()); 150 #else 151 return static_cast<u32>(syscall(SYS_gettid)); 152 #endif 153 } 154 155 // Blocking is possibly unused if the getrandom block is not compiled in. 156 bool getRandom(void *Buffer, uptr Length, UNUSED bool Blocking) { 157 if (!Buffer || !Length || Length > MaxRandomLength) 158 return false; 159 ssize_t ReadBytes; 160 #if defined(SYS_getrandom) 161 #if !defined(GRND_NONBLOCK) 162 #define GRND_NONBLOCK 1 163 #endif 164 // Up to 256 bytes, getrandom will not be interrupted. 165 ReadBytes = 166 syscall(SYS_getrandom, Buffer, Length, Blocking ? 0 : GRND_NONBLOCK); 167 if (ReadBytes == static_cast<ssize_t>(Length)) 168 return true; 169 #endif // defined(SYS_getrandom) 170 // Up to 256 bytes, a read off /dev/urandom will not be interrupted. 171 // Blocking is moot here, O_NONBLOCK has no effect when opening /dev/urandom. 172 const int FileDesc = open("/dev/urandom", O_RDONLY); 173 if (FileDesc == -1) 174 return false; 175 ReadBytes = read(FileDesc, Buffer, Length); 176 close(FileDesc); 177 return (ReadBytes == static_cast<ssize_t>(Length)); 178 } 179 180 // Allocation free syslog-like API. 181 extern "C" WEAK int async_safe_write_log(int pri, const char *tag, 182 const char *msg); 183 184 static uptr GetRSSFromBuffer(const char *Buf) { 185 // The format of the file is: 186 // 1084 89 69 11 0 79 0 187 // We need the second number which is RSS in pages. 188 const char *Pos = Buf; 189 // Skip the first number. 190 while (*Pos >= '0' && *Pos <= '9') 191 Pos++; 192 // Skip whitespaces. 193 while (!(*Pos >= '0' && *Pos <= '9') && *Pos != 0) 194 Pos++; 195 // Read the number. 196 u64 Rss = 0; 197 for (; *Pos >= '0' && *Pos <= '9'; Pos++) 198 Rss = Rss * 10 + static_cast<u64>(*Pos) - '0'; 199 return static_cast<uptr>(Rss * getPageSizeCached()); 200 } 201 202 uptr GetRSS() { 203 // TODO: We currently use sanitizer_common's GetRSS which reads the 204 // RSS from /proc/self/statm by default. We might want to 205 // call getrusage directly, even if it's less accurate. 206 auto Fd = open("/proc/self/statm", O_RDONLY); 207 char Buf[64]; 208 s64 Len = read(Fd, Buf, sizeof(Buf) - 1); 209 close(Fd); 210 if (Len <= 0) 211 return 0; 212 Buf[Len] = 0; 213 214 return GetRSSFromBuffer(Buf); 215 } 216 217 void outputRaw(const char *Buffer) { 218 if (&async_safe_write_log) { 219 constexpr s32 AndroidLogInfo = 4; 220 constexpr uptr MaxLength = 1024U; 221 char LocalBuffer[MaxLength]; 222 while (strlen(Buffer) > MaxLength) { 223 uptr P; 224 for (P = MaxLength - 1; P > 0; P--) { 225 if (Buffer[P] == '\n') { 226 memcpy(LocalBuffer, Buffer, P); 227 LocalBuffer[P] = '\0'; 228 async_safe_write_log(AndroidLogInfo, "scudo", LocalBuffer); 229 Buffer = &Buffer[P + 1]; 230 break; 231 } 232 } 233 // If no newline was found, just log the buffer. 234 if (P == 0) 235 break; 236 } 237 async_safe_write_log(AndroidLogInfo, "scudo", Buffer); 238 } else { 239 (void)write(2, Buffer, strlen(Buffer)); 240 } 241 } 242 243 extern "C" WEAK void android_set_abort_message(const char *); 244 245 void setAbortMessage(const char *Message) { 246 if (&android_set_abort_message) 247 android_set_abort_message(Message); 248 } 249 250 } // namespace scudo 251 252 #endif // SCUDO_LINUX 253