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 void *MmapOrDie(uptr size
, const char *mem_type
, bool raw_report
) {
45 size
= RoundUpTo(size
, GetPageSizeCached());
46 uptr res
= MmapNamed(nullptr, size
, PROT_READ
| PROT_WRITE
,
47 MAP_PRIVATE
| MAP_ANON
, mem_type
);
49 if (UNLIKELY(internal_iserror(res
, &reserrno
)))
50 ReportMmapFailureAndDie(size
, mem_type
, "allocate", reserrno
, raw_report
);
51 IncreaseTotalMmap(size
);
55 void UnmapOrDie(void *addr
, uptr size
) {
56 if (!addr
|| !size
) return;
57 uptr res
= internal_munmap(addr
, size
);
58 if (UNLIKELY(internal_iserror(res
))) {
59 Report("ERROR: %s failed to deallocate 0x%zx (%zd) bytes at address %p\n",
60 SanitizerToolName
, size
, size
, addr
);
61 CHECK("unable to unmap" && 0);
63 DecreaseTotalMmap(size
);
66 void *MmapOrDieOnFatalError(uptr size
, const char *mem_type
) {
67 size
= RoundUpTo(size
, GetPageSizeCached());
68 uptr res
= MmapNamed(nullptr, size
, PROT_READ
| PROT_WRITE
,
69 MAP_PRIVATE
| MAP_ANON
, mem_type
);
71 if (UNLIKELY(internal_iserror(res
, &reserrno
))) {
72 if (reserrno
== ENOMEM
)
74 ReportMmapFailureAndDie(size
, mem_type
, "allocate", reserrno
);
76 IncreaseTotalMmap(size
);
80 // We want to map a chunk of address space aligned to 'alignment'.
81 // We do it by mapping a bit more and then unmapping redundant pieces.
82 // We probably can do it with fewer syscalls in some OS-dependent way.
83 void *MmapAlignedOrDieOnFatalError(uptr size
, uptr alignment
,
84 const char *mem_type
) {
85 CHECK(IsPowerOfTwo(size
));
86 CHECK(IsPowerOfTwo(alignment
));
87 uptr map_size
= size
+ alignment
;
88 uptr map_res
= (uptr
)MmapOrDieOnFatalError(map_size
, mem_type
);
89 if (UNLIKELY(!map_res
))
91 uptr map_end
= map_res
+ map_size
;
93 if (!IsAligned(res
, alignment
)) {
94 res
= (map_res
+ alignment
- 1) & ~(alignment
- 1);
95 UnmapOrDie((void*)map_res
, res
- map_res
);
97 uptr end
= res
+ size
;
99 UnmapOrDie((void*)end
, map_end
- end
);
103 void *MmapNoReserveOrDie(uptr size
, const char *mem_type
) {
104 size
= RoundUpTo(size
, GetPageSizeCached());
105 uptr p
= MmapNamed(nullptr, size
, PROT_READ
| PROT_WRITE
,
106 MAP_PRIVATE
| MAP_ANON
| MAP_NORESERVE
, mem_type
);
108 if (UNLIKELY(internal_iserror(p
, &reserrno
)))
109 ReportMmapFailureAndDie(size
, mem_type
, "allocate noreserve", reserrno
);
110 IncreaseTotalMmap(size
);
114 static void *MmapFixedImpl(uptr fixed_addr
, uptr size
, bool tolerate_enomem
,
116 size
= RoundUpTo(size
, GetPageSizeCached());
117 fixed_addr
= RoundDownTo(fixed_addr
, GetPageSizeCached());
118 uptr p
= MmapNamed((void *)fixed_addr
, size
, PROT_READ
| PROT_WRITE
,
119 MAP_PRIVATE
| MAP_ANON
| MAP_FIXED
, name
);
121 if (UNLIKELY(internal_iserror(p
, &reserrno
))) {
122 if (tolerate_enomem
&& reserrno
== ENOMEM
)
125 internal_snprintf(mem_type
, sizeof(mem_type
), "memory at address 0x%zx",
127 ReportMmapFailureAndDie(size
, mem_type
, "allocate", reserrno
);
129 IncreaseTotalMmap(size
);
133 void *MmapFixedOrDie(uptr fixed_addr
, uptr size
, const char *name
) {
134 return MmapFixedImpl(fixed_addr
, size
, false /*tolerate_enomem*/, name
);
137 void *MmapFixedOrDieOnFatalError(uptr fixed_addr
, uptr size
, const char *name
) {
138 return MmapFixedImpl(fixed_addr
, size
, true /*tolerate_enomem*/, name
);
141 bool MprotectNoAccess(uptr addr
, uptr size
) {
142 return 0 == internal_mprotect((void*)addr
, size
, PROT_NONE
);
145 bool MprotectReadOnly(uptr addr
, uptr size
) {
146 return 0 == internal_mprotect((void *)addr
, size
, PROT_READ
);
150 void MprotectMallocZones(void *addr
, int prot
) {}
153 fd_t
OpenFile(const char *filename
, FileAccessMode mode
, error_t
*errno_p
) {
154 if (ShouldMockFailureToOpen(filename
))
158 case RdOnly
: flags
= O_RDONLY
; break;
159 case WrOnly
: flags
= O_WRONLY
| O_CREAT
| O_TRUNC
; break;
160 case RdWr
: flags
= O_RDWR
| O_CREAT
; break;
162 fd_t res
= internal_open(filename
, flags
, 0660);
163 if (internal_iserror(res
, errno_p
))
165 return ReserveStandardFds(res
);
168 void CloseFile(fd_t fd
) {
172 bool ReadFromFile(fd_t fd
, void *buff
, uptr buff_size
, uptr
*bytes_read
,
174 uptr res
= internal_read(fd
, buff
, buff_size
);
175 if (internal_iserror(res
, error_p
))
182 bool WriteToFile(fd_t fd
, const void *buff
, uptr buff_size
, uptr
*bytes_written
,
184 uptr res
= internal_write(fd
, buff
, buff_size
);
185 if (internal_iserror(res
, error_p
))
188 *bytes_written
= res
;
192 void *MapFileToMemory(const char *file_name
, uptr
*buff_size
) {
193 fd_t fd
= OpenFile(file_name
, RdOnly
);
194 CHECK(fd
!= kInvalidFd
);
195 uptr fsize
= internal_filesize(fd
);
196 CHECK_NE(fsize
, (uptr
)-1);
198 *buff_size
= RoundUpTo(fsize
, GetPageSizeCached());
199 uptr map
= internal_mmap(nullptr, *buff_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
200 return internal_iserror(map
) ? nullptr : (void *)map
;
203 void *MapWritableFileToMemory(void *addr
, uptr size
, fd_t fd
, OFF_T offset
) {
204 uptr flags
= MAP_SHARED
;
205 if (addr
) flags
|= MAP_FIXED
;
206 uptr p
= internal_mmap(addr
, size
, PROT_READ
| PROT_WRITE
, flags
, fd
, offset
);
208 if (internal_iserror(p
, &mmap_errno
)) {
209 Printf("could not map writable file (%d, %lld, %zu): %zd, errno: %d\n",
210 fd
, (long long)offset
, size
, p
, mmap_errno
);
216 static inline bool IntervalsAreSeparate(uptr start1
, uptr end1
,
217 uptr start2
, uptr end2
) {
218 CHECK(start1
<= end1
);
219 CHECK(start2
<= end2
);
220 return (end1
< start2
) || (end2
< start1
);
223 // FIXME: this is thread-unsafe, but should not cause problems most of the time.
224 // When the shadow is mapped only a single thread usually exists (plus maybe
225 // several worker threads on Mac, which aren't expected to map big chunks of
227 bool MemoryRangeIsAvailable(uptr range_start
, uptr range_end
) {
228 MemoryMappingLayout
proc_maps(/*cache_enabled*/true);
229 if (proc_maps
.Error())
230 return true; // and hope for the best
231 MemoryMappedSegment segment
;
232 while (proc_maps
.Next(&segment
)) {
233 if (segment
.start
== segment
.end
) continue; // Empty range.
234 CHECK_NE(0, segment
.end
);
235 if (!IntervalsAreSeparate(segment
.start
, segment
.end
- 1, range_start
,
243 void DumpProcessMap() {
244 MemoryMappingLayout
proc_maps(/*cache_enabled*/true);
245 const sptr kBufSize
= 4095;
246 char *filename
= (char*)MmapOrDie(kBufSize
, __func__
);
247 MemoryMappedSegment
segment(filename
, kBufSize
);
248 Report("Process memory map follows:\n");
249 while (proc_maps
.Next(&segment
)) {
250 Printf("\t%p-%p\t%s\n", (void *)segment
.start
, (void *)segment
.end
,
253 Report("End of process memory map.\n");
254 UnmapOrDie(filename
, kBufSize
);
258 const char *GetPwd() {
259 return GetEnv("PWD");
262 bool IsPathSeparator(const char c
) {
266 bool IsAbsolutePath(const char *path
) {
267 return path
!= nullptr && IsPathSeparator(path
[0]);
270 void ReportFile::Write(const char *buffer
, uptr length
) {
273 internal_write(fd
, buffer
, length
);
276 bool GetCodeRangeForFile(const char *module
, uptr
*start
, uptr
*end
) {
277 MemoryMappingLayout
proc_maps(/*cache_enabled*/false);
278 InternalMmapVector
<char> buff(kMaxPathLength
);
279 MemoryMappedSegment
segment(buff
.data(), buff
.size());
280 while (proc_maps
.Next(&segment
)) {
281 if (segment
.IsExecutable() &&
282 internal_strcmp(module
, segment
.filename
) == 0) {
283 *start
= segment
.start
;
291 uptr
SignalContext::GetAddress() const {
292 auto si
= static_cast<const siginfo_t
*>(siginfo
);
293 return (uptr
)si
->si_addr
;
296 bool SignalContext::IsMemoryAccess() const {
297 auto si
= static_cast<const siginfo_t
*>(siginfo
);
298 return si
->si_signo
== SIGSEGV
|| si
->si_signo
== SIGBUS
;
301 int SignalContext::GetType() const {
302 return static_cast<const siginfo_t
*>(siginfo
)->si_signo
;
305 const char *SignalContext::Describe() const {
320 return "UNKNOWN SIGNAL";
323 fd_t
ReserveStandardFds(fd_t fd
) {
328 internal_memset(used
, 0, sizeof(used
));
331 fd
= internal_dup(fd
);
333 for (int i
= 0; i
<= 2; ++i
)
339 bool ShouldMockFailureToOpen(const char *path
) {
340 return common_flags()->test_only_emulate_no_memorymap
&&
341 internal_strncmp(path
, "/proc/", 6) == 0;
344 #if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_GO
345 int GetNamedMappingFd(const char *name
, uptr size
, int *flags
) {
346 if (!common_flags()->decorate_proc_maps
|| !name
)
349 CHECK(internal_strlen(name
) < sizeof(shmname
) - 10);
350 internal_snprintf(shmname
, sizeof(shmname
), "/dev/shm/%zu [%s]",
351 internal_getpid(), name
);
353 #if defined(O_CLOEXEC)
354 o_cloexec
= O_CLOEXEC
;
356 int fd
= ReserveStandardFds(
357 internal_open(shmname
, O_RDWR
| O_CREAT
| O_TRUNC
| o_cloexec
, S_IRWXU
));
359 int res
= internal_ftruncate(fd
, size
);
360 #if !defined(O_CLOEXEC)
361 res
= fcntl(fd
, F_SETFD
, FD_CLOEXEC
);
365 res
= internal_unlink(shmname
);
367 *flags
&= ~(MAP_ANON
| MAP_ANONYMOUS
);
371 int GetNamedMappingFd(const char *name
, uptr size
, int *flags
) {
376 #if SANITIZER_ANDROID
377 #define PR_SET_VMA 0x53564d41
378 #define PR_SET_VMA_ANON_NAME 0
379 void DecorateMapping(uptr addr
, uptr size
, const char *name
) {
380 if (!common_flags()->decorate_proc_maps
|| !name
)
382 internal_prctl(PR_SET_VMA
, PR_SET_VMA_ANON_NAME
, addr
, size
, (uptr
)name
);
385 void DecorateMapping(uptr addr
, uptr size
, const char *name
) {
389 uptr
MmapNamed(void *addr
, uptr length
, int prot
, int flags
, const char *name
) {
390 int fd
= GetNamedMappingFd(name
, length
, &flags
);
391 uptr res
= internal_mmap(addr
, length
, prot
, flags
, fd
, 0);
392 if (!internal_iserror(res
))
393 DecorateMapping(res
, length
, name
);
398 } // namespace __sanitizer
400 #endif // SANITIZER_POSIX