1//===-- sanitizer_posix.cpp -----------------------------------------------===//
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// This file is shared between AddressSanitizer and ThreadSanitizer
10// run-time libraries and implements POSIX-specific functions from
11// sanitizer_posix.h.
12//===----------------------------------------------------------------------===//
13
14#include "sanitizer_platform.h"
15
16#if SANITIZER_POSIX
17
18#include "sanitizer_common.h"
19#include "sanitizer_file.h"
20#include "sanitizer_flags.h"
21#include "sanitizer_libc.h"
22#include "sanitizer_posix.h"
23#include "sanitizer_procmaps.h"
24
25#include <errno.h>
26#include <fcntl.h>
27#include <signal.h>
28#include <sys/mman.h>
29
30# if SANITIZER_FREEBSD || SANITIZER_AIX
31// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
32// that, it was never implemented. So just define it to zero.
33// Similarly, AIX does not define MAP_NORESERVE.
34# undef MAP_NORESERVE
35# define MAP_NORESERVE 0
36# endif
37
38namespace __sanitizer {
39
40// ------------- sanitizer_common.h
41uptr GetMmapGranularity() {
42 return GetPageSize();
43}
44
45bool ErrorIsOOM(error_t err) { return err == ENOMEM; }
46
47void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
48 size = RoundUpTo(size, boundary: GetPageSizeCached());
49 uptr res = MmapNamed(addr: nullptr, length: size, PROT_READ | PROT_WRITE,
50 MAP_PRIVATE | MAP_ANON, name: mem_type);
51 int reserrno;
52 if (UNLIKELY(internal_iserror(res, &reserrno)))
53 ReportMmapFailureAndDie(size, mem_type, mmap_type: "allocate", err: reserrno, raw_report);
54 IncreaseTotalMmap(size);
55 return (void *)res;
56}
57
58void UnmapOrDie(void *addr, uptr size, bool raw_report) {
59 if (!addr || !size) return;
60 uptr res = internal_munmap(addr, length: size);
61 int reserrno;
62 if (UNLIKELY(internal_iserror(res, &reserrno)))
63 ReportMunmapFailureAndDie(ptr: addr, size, err: reserrno, raw_report);
64 DecreaseTotalMmap(size);
65}
66
67void *MmapOrDieOnFatalError(uptr size, const char *mem_type) {
68 size = RoundUpTo(size, boundary: GetPageSizeCached());
69 uptr res = MmapNamed(addr: nullptr, length: size, PROT_READ | PROT_WRITE,
70 MAP_PRIVATE | MAP_ANON, name: mem_type);
71 int reserrno;
72 if (UNLIKELY(internal_iserror(res, &reserrno))) {
73 if (reserrno == ENOMEM)
74 return nullptr;
75 ReportMmapFailureAndDie(size, mem_type, mmap_type: "allocate", err: reserrno);
76 }
77 IncreaseTotalMmap(size);
78 return (void *)res;
79}
80
81// We want to map a chunk of address space aligned to 'alignment'.
82// We do it by mapping a bit more and then unmapping redundant pieces.
83// We probably can do it with fewer syscalls in some OS-dependent way.
84void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
85 const char *mem_type) {
86 CHECK(IsPowerOfTwo(size));
87 CHECK(IsPowerOfTwo(alignment));
88 uptr map_size = size + alignment;
89 // mmap maps entire pages and rounds up map_size needs to be a an integral
90 // number of pages.
91 // We need to be aware of this size for calculating end and for unmapping
92 // fragments before and after the alignment region.
93 map_size = RoundUpTo(size: map_size, boundary: GetPageSizeCached());
94 uptr map_res = (uptr)MmapOrDieOnFatalError(size: map_size, mem_type);
95 if (UNLIKELY(!map_res))
96 return nullptr;
97 uptr res = map_res;
98 if (!IsAligned(a: res, alignment)) {
99 res = (map_res + alignment - 1) & ~(alignment - 1);
100 UnmapOrDie(addr: (void*)map_res, size: res - map_res);
101 }
102 uptr map_end = map_res + map_size;
103 uptr end = res + size;
104 end = RoundUpTo(size: end, boundary: GetPageSizeCached());
105 if (end != map_end) {
106 CHECK_LT(end, map_end);
107 UnmapOrDie(addr: (void*)end, size: map_end - end);
108 }
109 return (void*)res;
110}
111
112void *MmapNoReserveOrDie(uptr size, const char *mem_type) {
113 size = RoundUpTo(size, boundary: GetPageSizeCached());
114 uptr p = MmapNamed(addr: nullptr, length: size, PROT_READ | PROT_WRITE,
115 MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, name: mem_type);
116 int reserrno;
117 if (UNLIKELY(internal_iserror(p, &reserrno)))
118 ReportMmapFailureAndDie(size, mem_type, mmap_type: "allocate noreserve", err: reserrno);
119 IncreaseTotalMmap(size);
120 return (void *)p;
121}
122
123static void *MmapFixedImpl(uptr fixed_addr, uptr size, bool tolerate_enomem,
124 const char *name) {
125 size = RoundUpTo(size, boundary: GetPageSizeCached());
126 fixed_addr = RoundDownTo(x: fixed_addr, boundary: GetPageSizeCached());
127 uptr p = MmapNamed(addr: (void *)fixed_addr, length: size, PROT_READ | PROT_WRITE,
128 MAP_PRIVATE | MAP_ANON | MAP_FIXED, name);
129 int reserrno;
130 if (UNLIKELY(internal_iserror(p, &reserrno))) {
131 if (tolerate_enomem && reserrno == ENOMEM)
132 return nullptr;
133 char mem_type[40];
134 internal_snprintf(buffer: mem_type, length: sizeof(mem_type), format: "memory at address %p",
135 (void *)fixed_addr);
136 ReportMmapFailureAndDie(size, mem_type, mmap_type: "allocate", err: reserrno);
137 }
138 IncreaseTotalMmap(size);
139 return (void *)p;
140}
141
142void *MmapFixedOrDie(uptr fixed_addr, uptr size, const char *name) {
143 return MmapFixedImpl(fixed_addr, size, tolerate_enomem: false /*tolerate_enomem*/, name);
144}
145
146void *MmapFixedOrDieOnFatalError(uptr fixed_addr, uptr size, const char *name) {
147 return MmapFixedImpl(fixed_addr, size, tolerate_enomem: true /*tolerate_enomem*/, name);
148}
149
150bool MprotectNoAccess(uptr addr, uptr size) {
151 return 0 == internal_mprotect(addr: (void*)addr, length: size, PROT_NONE);
152}
153
154bool MprotectReadOnly(uptr addr, uptr size) {
155 return 0 == internal_mprotect(addr: (void *)addr, length: size, PROT_READ);
156}
157
158bool MprotectReadWrite(uptr addr, uptr size) {
159 return 0 == internal_mprotect(addr: (void *)addr, length: size, PROT_READ | PROT_WRITE);
160}
161
162#if !SANITIZER_APPLE
163void MprotectMallocZones(void *addr, int prot) {}
164#endif
165
166fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *errno_p) {
167 if (ShouldMockFailureToOpen(path: filename))
168 return kInvalidFd;
169 int flags;
170 switch (mode) {
171 case RdOnly: flags = O_RDONLY; break;
172 case WrOnly: flags = O_WRONLY | O_CREAT | O_TRUNC; break;
173 case RdWr: flags = O_RDWR | O_CREAT; break;
174 }
175 fd_t res = internal_open(filename, flags, mode: 0660);
176 if (internal_iserror(retval: res, rverrno: errno_p))
177 return kInvalidFd;
178 return ReserveStandardFds(fd: res);
179}
180
181void CloseFile(fd_t fd) {
182 internal_close(fd);
183}
184
185bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read,
186 error_t *error_p) {
187 uptr res = internal_read(fd, buf: buff, count: buff_size);
188 if (internal_iserror(retval: res, rverrno: error_p))
189 return false;
190 if (bytes_read)
191 *bytes_read = res;
192 return true;
193}
194
195bool WriteToFile(fd_t fd, const void *buff, uptr buff_size, uptr *bytes_written,
196 error_t *error_p) {
197 uptr res = internal_write(fd, buf: buff, count: buff_size);
198 if (internal_iserror(retval: res, rverrno: error_p))
199 return false;
200 if (bytes_written)
201 *bytes_written = res;
202 return true;
203}
204
205void *MapFileToMemory(const char *file_name, uptr *buff_size) {
206 fd_t fd = OpenFile(filename: file_name, mode: RdOnly);
207 CHECK(fd != kInvalidFd);
208 uptr fsize = internal_filesize(fd);
209 CHECK_NE(fsize, (uptr)-1);
210 CHECK_GT(fsize, 0);
211 *buff_size = RoundUpTo(size: fsize, boundary: GetPageSizeCached());
212 uptr map = internal_mmap(addr: nullptr, length: *buff_size, PROT_READ, MAP_PRIVATE, fd, offset: 0);
213 return internal_iserror(retval: map) ? nullptr : (void *)map;
214}
215
216void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {
217 uptr flags = MAP_SHARED;
218 if (addr) flags |= MAP_FIXED;
219 uptr p = internal_mmap(addr, length: size, PROT_READ | PROT_WRITE, flags, fd, offset);
220 int mmap_errno = 0;
221 if (internal_iserror(retval: p, rverrno: &mmap_errno)) {
222 Printf(format: "could not map writable file (%d, %lld, %zu): %zd, errno: %d\n",
223 fd, (long long)offset, size, p, mmap_errno);
224 return nullptr;
225 }
226 return (void *)p;
227}
228
229# if !SANITIZER_APPLE
230// FIXME: this is thread-unsafe, but should not cause problems most of the time.
231// When the shadow is mapped only a single thread usually exists
232bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
233 MemoryMappingLayout proc_maps(/*cache_enabled*/true);
234 if (proc_maps.Error())
235 return true; // and hope for the best
236 MemoryMappedSegment segment;
237 while (proc_maps.Next(segment: &segment)) {
238 if (segment.start == segment.end) continue; // Empty range.
239 CHECK_NE(0, segment.end);
240 if (!IntervalsAreSeparate(start1: segment.start, end1: segment.end - 1, start2: range_start,
241 end2: range_end))
242 return false;
243 }
244 return true;
245}
246
247void DumpProcessMap() {
248 MemoryMappingLayout proc_maps(/*cache_enabled*/true);
249 const sptr kBufSize = 4095;
250 char *filename = (char*)MmapOrDie(size: kBufSize, mem_type: __func__);
251 MemoryMappedSegment segment(filename, kBufSize);
252 Report(format: "Process memory map follows:\n");
253 while (proc_maps.Next(segment: &segment)) {
254 Printf(format: "\t%p-%p\t%s\n", (void *)segment.start, (void *)segment.end,
255 segment.filename);
256 }
257 Report(format: "End of process memory map.\n");
258 UnmapOrDie(addr: filename, size: kBufSize);
259}
260# endif
261
262const char *GetPwd() {
263 return GetEnv(name: "PWD");
264}
265
266bool IsPathSeparator(const char c) {
267 return c == '/';
268}
269
270bool IsAbsolutePath(const char *path) {
271 return path != nullptr && IsPathSeparator(c: path[0]);
272}
273
274void ReportFile::Write(const char *buffer, uptr length) {
275 SpinMutexLock l(mu);
276 ReopenIfNecessary();
277 internal_write(fd, buf: buffer, count: length);
278}
279
280bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end) {
281 MemoryMappingLayout proc_maps(/*cache_enabled*/false);
282 InternalMmapVector<char> buff(kMaxPathLength);
283 MemoryMappedSegment segment(buff.data(), buff.size());
284 while (proc_maps.Next(segment: &segment)) {
285 if (segment.IsExecutable() &&
286 internal_strcmp(s1: module, s2: segment.filename) == 0) {
287 *start = segment.start;
288 *end = segment.end;
289 return true;
290 }
291 }
292 return false;
293}
294
295uptr SignalContext::GetAddress() const {
296 auto si = static_cast<const siginfo_t *>(siginfo);
297 return (uptr)si->si_addr;
298}
299
300bool SignalContext::IsMemoryAccess() const {
301 auto si = static_cast<const siginfo_t *>(siginfo);
302 return si->si_signo == SIGSEGV || si->si_signo == SIGBUS;
303}
304
305int SignalContext::GetType() const {
306 return static_cast<const siginfo_t *>(siginfo)->si_signo;
307}
308
309const char *SignalContext::Describe() const {
310 switch (GetType()) {
311 case SIGFPE:
312 return "FPE";
313 case SIGILL:
314 return "ILL";
315 case SIGABRT:
316 return "ABRT";
317 case SIGSEGV:
318 return "SEGV";
319 case SIGBUS:
320 return "BUS";
321 case SIGTRAP:
322 return "TRAP";
323 }
324 return "UNKNOWN SIGNAL";
325}
326
327fd_t ReserveStandardFds(fd_t fd) {
328 CHECK_GE(fd, 0);
329 if (fd > 2)
330 return fd;
331 bool used[3];
332 internal_memset(s: used, c: 0, n: sizeof(used));
333 while (fd <= 2) {
334 used[fd] = true;
335 fd = internal_dup(oldfd: fd);
336 }
337 for (int i = 0; i <= 2; ++i)
338 if (used[i])
339 internal_close(fd: i);
340 return fd;
341}
342
343bool ShouldMockFailureToOpen(const char *path) {
344 return common_flags()->test_only_emulate_no_memorymap &&
345 internal_strncmp(s1: path, s2: "/proc/", n: 6) == 0;
346}
347
348bool OpenReadsVaArgs(int oflag) {
349# ifdef O_TMPFILE
350 return (oflag & (O_CREAT | O_TMPFILE)) != 0;
351# else
352 return (oflag & O_CREAT) != 0;
353# endif
354}
355
356# if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_GO
357int GetNamedMappingFd(const char *name, uptr size, int *flags) {
358 if (!common_flags()->decorate_proc_maps || !name)
359 return -1;
360 char shmname[200];
361 int len =
362 internal_snprintf(buffer: shmname, length: sizeof(shmname), format: "/dev/shm/%zu.%llu [%s]",
363 internal_getpid(), GetTid(), name);
364 CHECK_LT(len, sizeof(shmname));
365 int o_cloexec = 0;
366#if defined(O_CLOEXEC)
367 o_cloexec = O_CLOEXEC;
368#endif
369 int fd = ReserveStandardFds(
370 fd: internal_open(filename: shmname, O_RDWR | O_CREAT | O_TRUNC | o_cloexec, S_IRWXU));
371 CHECK_GE(fd, 0);
372 int res = internal_ftruncate(fd, size);
373#if !defined(O_CLOEXEC)
374 res = fcntl(fd, F_SETFD, FD_CLOEXEC);
375 CHECK_EQ(0, res);
376#endif
377 CHECK_EQ(0, res);
378 res = internal_unlink(path: shmname);
379 CHECK_EQ(0, res);
380 *flags &= ~(MAP_ANON | MAP_ANONYMOUS);
381 return fd;
382}
383#else
384int GetNamedMappingFd(const char *name, uptr size, int *flags) {
385 return -1;
386}
387#endif
388
389#if SANITIZER_ANDROID
390#define PR_SET_VMA 0x53564d41
391#define PR_SET_VMA_ANON_NAME 0
392void DecorateMapping(uptr addr, uptr size, const char *name) {
393 if (!common_flags()->decorate_proc_maps || !name)
394 return;
395 internal_prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, addr, size, (uptr)name);
396}
397#else
398void DecorateMapping(uptr addr, uptr size, const char *name) {
399}
400#endif
401
402uptr MmapNamed(void *addr, uptr length, int prot, int flags, const char *name) {
403 int fd = GetNamedMappingFd(name, size: length, flags: &flags);
404 uptr res = internal_mmap(addr, length, prot, flags, fd, offset: 0);
405 if (!internal_iserror(retval: res))
406 DecorateMapping(addr: res, size: length, name);
407 return res;
408}
409
410
411} // namespace __sanitizer
412
413#endif // SANITIZER_POSIX
414