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