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