1 //===-- sanitizer_posix.cpp -----------------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file is shared between AddressSanitizer and ThreadSanitizer
10 // run-time libraries and implements POSIX-specific functions from
12 //===----------------------------------------------------------------------===//
14 #include "sanitizer_platform.h"
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"
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.
34 #define MAP_NORESERVE 0
37 namespace __sanitizer
{
39 // ------------- sanitizer_common.h
40 uptr
GetMmapGranularity() {
44 bool ErrorIsOOM(error_t err
) { return err
== ENOMEM
; }
46 void *MmapOrDie(uptr size
, const char *mem_type
, bool raw_report
) {
47 size
= RoundUpTo(size
, GetPageSizeCached());
48 uptr res
= MmapNamed(nullptr, size
, PROT_READ
| PROT_WRITE
,
49 MAP_PRIVATE
| MAP_ANON
, mem_type
);
51 if (UNLIKELY(internal_iserror(res
, &reserrno
)))
52 ReportMmapFailureAndDie(size
, mem_type
, "allocate", reserrno
, raw_report
);
53 IncreaseTotalMmap(size
);
57 void UnmapOrDie(void *addr
, uptr size
) {
58 if (!addr
|| !size
) return;
59 uptr res
= internal_munmap(addr
, size
);
60 if (UNLIKELY(internal_iserror(res
))) {
61 Report("ERROR: %s failed to deallocate 0x%zx (%zd) bytes at address %p\n",
62 SanitizerToolName
, size
, size
, addr
);
63 CHECK("unable to unmap" && 0);
65 DecreaseTotalMmap(size
);
68 void *MmapOrDieOnFatalError(uptr size
, const char *mem_type
) {
69 size
= RoundUpTo(size
, GetPageSizeCached());
70 uptr res
= MmapNamed(nullptr, size
, PROT_READ
| PROT_WRITE
,
71 MAP_PRIVATE
| MAP_ANON
, mem_type
);
73 if (UNLIKELY(internal_iserror(res
, &reserrno
))) {
74 if (reserrno
== ENOMEM
)
76 ReportMmapFailureAndDie(size
, mem_type
, "allocate", reserrno
);
78 IncreaseTotalMmap(size
);
82 // We want to map a chunk of address space aligned to 'alignment'.
83 // We do it by mapping a bit more and then unmapping redundant pieces.
84 // We probably can do it with fewer syscalls in some OS-dependent way.
85 void *MmapAlignedOrDieOnFatalError(uptr size
, uptr alignment
,
86 const char *mem_type
) {
87 CHECK(IsPowerOfTwo(size
));
88 CHECK(IsPowerOfTwo(alignment
));
89 uptr map_size
= size
+ alignment
;
90 uptr map_res
= (uptr
)MmapOrDieOnFatalError(map_size
, mem_type
);
91 if (UNLIKELY(!map_res
))
93 uptr map_end
= map_res
+ map_size
;
95 if (!IsAligned(res
, alignment
)) {
96 res
= (map_res
+ alignment
- 1) & ~(alignment
- 1);
97 UnmapOrDie((void*)map_res
, res
- map_res
);
99 uptr end
= res
+ size
;
100 end
= RoundUpTo(end
, GetPageSizeCached());
102 UnmapOrDie((void*)end
, map_end
- end
);
106 void *MmapNoReserveOrDie(uptr size
, const char *mem_type
) {
107 size
= RoundUpTo(size
, GetPageSizeCached());
108 uptr p
= MmapNamed(nullptr, size
, PROT_READ
| PROT_WRITE
,
109 MAP_PRIVATE
| MAP_ANON
| MAP_NORESERVE
, mem_type
);
111 if (UNLIKELY(internal_iserror(p
, &reserrno
)))
112 ReportMmapFailureAndDie(size
, mem_type
, "allocate noreserve", reserrno
);
113 IncreaseTotalMmap(size
);
117 static void *MmapFixedImpl(uptr fixed_addr
, uptr size
, bool tolerate_enomem
,
119 size
= RoundUpTo(size
, GetPageSizeCached());
120 fixed_addr
= RoundDownTo(fixed_addr
, GetPageSizeCached());
121 uptr p
= MmapNamed((void *)fixed_addr
, size
, PROT_READ
| PROT_WRITE
,
122 MAP_PRIVATE
| MAP_ANON
| MAP_FIXED
, name
);
124 if (UNLIKELY(internal_iserror(p
, &reserrno
))) {
125 if (tolerate_enomem
&& reserrno
== ENOMEM
)
128 internal_snprintf(mem_type
, sizeof(mem_type
), "memory at address 0x%zx",
130 ReportMmapFailureAndDie(size
, mem_type
, "allocate", reserrno
);
132 IncreaseTotalMmap(size
);
136 void *MmapFixedOrDie(uptr fixed_addr
, uptr size
, const char *name
) {
137 return MmapFixedImpl(fixed_addr
, size
, false /*tolerate_enomem*/, name
);
140 void *MmapFixedOrDieOnFatalError(uptr fixed_addr
, uptr size
, const char *name
) {
141 return MmapFixedImpl(fixed_addr
, size
, true /*tolerate_enomem*/, name
);
144 bool MprotectNoAccess(uptr addr
, uptr size
) {
145 return 0 == internal_mprotect((void*)addr
, size
, PROT_NONE
);
148 bool MprotectReadOnly(uptr addr
, uptr size
) {
149 return 0 == internal_mprotect((void *)addr
, size
, PROT_READ
);
153 void MprotectMallocZones(void *addr
, int prot
) {}
156 fd_t
OpenFile(const char *filename
, FileAccessMode mode
, error_t
*errno_p
) {
157 if (ShouldMockFailureToOpen(filename
))
161 case RdOnly
: flags
= O_RDONLY
; break;
162 case WrOnly
: flags
= O_WRONLY
| O_CREAT
| O_TRUNC
; break;
163 case RdWr
: flags
= O_RDWR
| O_CREAT
; break;
165 fd_t res
= internal_open(filename
, flags
, 0660);
166 if (internal_iserror(res
, errno_p
))
168 return ReserveStandardFds(res
);
171 void CloseFile(fd_t fd
) {
175 bool ReadFromFile(fd_t fd
, void *buff
, uptr buff_size
, uptr
*bytes_read
,
177 uptr res
= internal_read(fd
, buff
, buff_size
);
178 if (internal_iserror(res
, error_p
))
185 bool WriteToFile(fd_t fd
, const void *buff
, uptr buff_size
, uptr
*bytes_written
,
187 uptr res
= internal_write(fd
, buff
, buff_size
);
188 if (internal_iserror(res
, error_p
))
191 *bytes_written
= res
;
195 void *MapFileToMemory(const char *file_name
, uptr
*buff_size
) {
196 fd_t fd
= OpenFile(file_name
, RdOnly
);
197 CHECK(fd
!= kInvalidFd
);
198 uptr fsize
= internal_filesize(fd
);
199 CHECK_NE(fsize
, (uptr
)-1);
201 *buff_size
= RoundUpTo(fsize
, GetPageSizeCached());
202 uptr map
= internal_mmap(nullptr, *buff_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
203 return internal_iserror(map
) ? nullptr : (void *)map
;
206 void *MapWritableFileToMemory(void *addr
, uptr size
, fd_t fd
, OFF_T offset
) {
207 uptr flags
= MAP_SHARED
;
208 if (addr
) flags
|= MAP_FIXED
;
209 uptr p
= internal_mmap(addr
, size
, PROT_READ
| PROT_WRITE
, flags
, fd
, offset
);
211 if (internal_iserror(p
, &mmap_errno
)) {
212 Printf("could not map writable file (%d, %lld, %zu): %zd, errno: %d\n",
213 fd
, (long long)offset
, size
, p
, mmap_errno
);
219 static inline bool IntervalsAreSeparate(uptr start1
, uptr end1
,
220 uptr start2
, uptr end2
) {
221 CHECK(start1
<= end1
);
222 CHECK(start2
<= end2
);
223 return (end1
< start2
) || (end2
< start1
);
226 // FIXME: this is thread-unsafe, but should not cause problems most of the time.
227 // When the shadow is mapped only a single thread usually exists (plus maybe
228 // several worker threads on Mac, which aren't expected to map big chunks of
230 bool MemoryRangeIsAvailable(uptr range_start
, uptr range_end
) {
231 MemoryMappingLayout
proc_maps(/*cache_enabled*/true);
232 if (proc_maps
.Error())
233 return true; // and hope for the best
234 MemoryMappedSegment segment
;
235 while (proc_maps
.Next(&segment
)) {
236 if (segment
.start
== segment
.end
) continue; // Empty range.
237 CHECK_NE(0, segment
.end
);
238 if (!IntervalsAreSeparate(segment
.start
, segment
.end
- 1, range_start
,
246 void DumpProcessMap() {
247 MemoryMappingLayout
proc_maps(/*cache_enabled*/true);
248 const sptr kBufSize
= 4095;
249 char *filename
= (char*)MmapOrDie(kBufSize
, __func__
);
250 MemoryMappedSegment
segment(filename
, kBufSize
);
251 Report("Process memory map follows:\n");
252 while (proc_maps
.Next(&segment
)) {
253 Printf("\t%p-%p\t%s\n", (void *)segment
.start
, (void *)segment
.end
,
256 Report("End of process memory map.\n");
257 UnmapOrDie(filename
, kBufSize
);
261 const char *GetPwd() {
262 return GetEnv("PWD");
265 bool IsPathSeparator(const char c
) {
269 bool IsAbsolutePath(const char *path
) {
270 return path
!= nullptr && IsPathSeparator(path
[0]);
273 void ReportFile::Write(const char *buffer
, uptr length
) {
276 internal_write(fd
, buffer
, length
);
279 bool GetCodeRangeForFile(const char *module
, uptr
*start
, uptr
*end
) {
280 MemoryMappingLayout
proc_maps(/*cache_enabled*/false);
281 InternalMmapVector
<char> buff(kMaxPathLength
);
282 MemoryMappedSegment
segment(buff
.data(), buff
.size());
283 while (proc_maps
.Next(&segment
)) {
284 if (segment
.IsExecutable() &&
285 internal_strcmp(module
, segment
.filename
) == 0) {
286 *start
= segment
.start
;
294 uptr
SignalContext::GetAddress() const {
295 auto si
= static_cast<const siginfo_t
*>(siginfo
);
296 return (uptr
)si
->si_addr
;
299 bool SignalContext::IsMemoryAccess() const {
300 auto si
= static_cast<const siginfo_t
*>(siginfo
);
301 return si
->si_signo
== SIGSEGV
|| si
->si_signo
== SIGBUS
;
304 int SignalContext::GetType() const {
305 return static_cast<const siginfo_t
*>(siginfo
)->si_signo
;
308 const char *SignalContext::Describe() const {
323 return "UNKNOWN SIGNAL";
326 fd_t
ReserveStandardFds(fd_t fd
) {
331 internal_memset(used
, 0, sizeof(used
));
334 fd
= internal_dup(fd
);
336 for (int i
= 0; i
<= 2; ++i
)
342 bool ShouldMockFailureToOpen(const char *path
) {
343 return common_flags()->test_only_emulate_no_memorymap
&&
344 internal_strncmp(path
, "/proc/", 6) == 0;
347 #if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_GO
348 int GetNamedMappingFd(const char *name
, uptr size
, int *flags
) {
349 if (!common_flags()->decorate_proc_maps
|| !name
)
352 CHECK(internal_strlen(name
) < sizeof(shmname
) - 10);
353 internal_snprintf(shmname
, sizeof(shmname
), "/dev/shm/%zu [%s]",
354 internal_getpid(), name
);
356 #if defined(O_CLOEXEC)
357 o_cloexec
= O_CLOEXEC
;
359 int fd
= ReserveStandardFds(
360 internal_open(shmname
, O_RDWR
| O_CREAT
| O_TRUNC
| o_cloexec
, S_IRWXU
));
362 int res
= internal_ftruncate(fd
, size
);
363 #if !defined(O_CLOEXEC)
364 res
= fcntl(fd
, F_SETFD
, FD_CLOEXEC
);
368 res
= internal_unlink(shmname
);
370 *flags
&= ~(MAP_ANON
| MAP_ANONYMOUS
);
374 int GetNamedMappingFd(const char *name
, uptr size
, int *flags
) {
379 #if SANITIZER_ANDROID
380 #define PR_SET_VMA 0x53564d41
381 #define PR_SET_VMA_ANON_NAME 0
382 void DecorateMapping(uptr addr
, uptr size
, const char *name
) {
383 if (!common_flags()->decorate_proc_maps
|| !name
)
385 internal_prctl(PR_SET_VMA
, PR_SET_VMA_ANON_NAME
, addr
, size
, (uptr
)name
);
388 void DecorateMapping(uptr addr
, uptr size
, const char *name
) {
392 uptr
MmapNamed(void *addr
, uptr length
, int prot
, int flags
, const char *name
) {
393 int fd
= GetNamedMappingFd(name
, length
, &flags
);
394 uptr res
= internal_mmap(addr
, length
, prot
, flags
, fd
, 0);
395 if (!internal_iserror(res
))
396 DecorateMapping(res
, length
, name
);
401 } // namespace __sanitizer
403 #endif // SANITIZER_POSIX