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
getPageSize()41 uptr getPageSize() { return static_cast<uptr>(sysconf(_SC_PAGESIZE)); }
42
die()43 void NORETURN die() { abort(); }
44
map(void * Addr,uptr Size,UNUSED const char * Name,uptr Flags,UNUSED MapPlatformData * Data)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
unmap(void * Addr,uptr Size,UNUSED uptr Flags,UNUSED MapPlatformData * Data)77 void unmap(void *Addr, uptr Size, UNUSED uptr Flags,
78 UNUSED MapPlatformData *Data) {
79 if (munmap(Addr, Size) != 0)
80 dieOnMapUnmapError();
81 }
82
setMemoryPermission(uptr Addr,uptr Size,uptr Flags,UNUSED MapPlatformData * Data)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
releasePagesToOS(uptr BaseAddress,uptr Offset,uptr Size,UNUSED MapPlatformData * Data)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.
getEnv(const char * Name)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
tryLock()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.
lockSlow()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
unlock()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
getMonotonicTime()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
getNumberOfCPUs()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
getThreadID()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.
getRandom(void * Buffer,uptr Length,UNUSED bool Blocking)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
GetRSSFromBuffer(const char * Buf)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
GetRSS()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
outputRaw(const char * Buffer)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
setAbortMessage(const char * Message)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