412 lines · cpp
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-exception6//7//===----------------------------------------------------------------------===//8//9// This file is shared between AddressSanitizer and ThreadSanitizer10// run-time libraries and implements POSIX-specific functions from11// sanitizer_posix.h.12//===----------------------------------------------------------------------===//13 14#include "sanitizer_platform.h"15 16#if SANITIZER_POSIX17 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_FREEBSD31// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before32// that, it was never implemented. So just define it to zero.33#undef MAP_NORESERVE34#define MAP_NORESERVE 035#endif36 37namespace __sanitizer {38 39// ------------- sanitizer_common.h40uptr GetMmapGranularity() {41 return GetPageSize();42}43 44bool ErrorIsOOM(error_t err) { return err == ENOMEM; }45 46void *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);50 int reserrno;51 if (UNLIKELY(internal_iserror(res, &reserrno)))52 ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno, raw_report);53 IncreaseTotalMmap(size);54 return (void *)res;55}56 57void UnmapOrDie(void *addr, uptr size, bool raw_report) {58 if (!addr || !size) return;59 uptr res = internal_munmap(addr, size);60 int reserrno;61 if (UNLIKELY(internal_iserror(res, &reserrno)))62 ReportMunmapFailureAndDie(addr, size, reserrno, raw_report);63 DecreaseTotalMmap(size);64}65 66void *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);70 int reserrno;71 if (UNLIKELY(internal_iserror(res, &reserrno))) {72 if (reserrno == ENOMEM)73 return nullptr;74 ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno);75 }76 IncreaseTotalMmap(size);77 return (void *)res;78}79 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.83void *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 // mmap maps entire pages and rounds up map_size needs to be a an integral89 // number of pages.90 // We need to be aware of this size for calculating end and for unmapping91 // fragments before and after the alignment region.92 map_size = RoundUpTo(map_size, GetPageSizeCached());93 uptr map_res = (uptr)MmapOrDieOnFatalError(map_size, mem_type);94 if (UNLIKELY(!map_res))95 return nullptr;96 uptr res = map_res;97 if (!IsAligned(res, alignment)) {98 res = (map_res + alignment - 1) & ~(alignment - 1);99 UnmapOrDie((void*)map_res, res - map_res);100 }101 uptr map_end = map_res + map_size;102 uptr end = res + size;103 end = RoundUpTo(end, GetPageSizeCached());104 if (end != map_end) {105 CHECK_LT(end, map_end);106 UnmapOrDie((void*)end, map_end - end);107 }108 return (void*)res;109}110 111void *MmapNoReserveOrDie(uptr size, const char *mem_type) {112 size = RoundUpTo(size, GetPageSizeCached());113 uptr p = MmapNamed(nullptr, size, PROT_READ | PROT_WRITE,114 MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, mem_type);115 int reserrno;116 if (UNLIKELY(internal_iserror(p, &reserrno)))117 ReportMmapFailureAndDie(size, mem_type, "allocate noreserve", reserrno);118 IncreaseTotalMmap(size);119 return (void *)p;120}121 122static void *MmapFixedImpl(uptr fixed_addr, uptr size, bool tolerate_enomem,123 const char *name) {124 size = RoundUpTo(size, GetPageSizeCached());125 fixed_addr = RoundDownTo(fixed_addr, GetPageSizeCached());126 uptr p = MmapNamed((void *)fixed_addr, size, PROT_READ | PROT_WRITE,127 MAP_PRIVATE | MAP_ANON | MAP_FIXED, name);128 int reserrno;129 if (UNLIKELY(internal_iserror(p, &reserrno))) {130 if (tolerate_enomem && reserrno == ENOMEM)131 return nullptr;132 char mem_type[40];133 internal_snprintf(mem_type, sizeof(mem_type), "memory at address %p",134 (void *)fixed_addr);135 ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno);136 }137 IncreaseTotalMmap(size);138 return (void *)p;139}140 141void *MmapFixedOrDie(uptr fixed_addr, uptr size, const char *name) {142 return MmapFixedImpl(fixed_addr, size, false /*tolerate_enomem*/, name);143}144 145void *MmapFixedOrDieOnFatalError(uptr fixed_addr, uptr size, const char *name) {146 return MmapFixedImpl(fixed_addr, size, true /*tolerate_enomem*/, name);147}148 149bool MprotectNoAccess(uptr addr, uptr size) {150 return 0 == internal_mprotect((void*)addr, size, PROT_NONE);151}152 153bool MprotectReadOnly(uptr addr, uptr size) {154 return 0 == internal_mprotect((void *)addr, size, PROT_READ);155}156 157bool MprotectReadWrite(uptr addr, uptr size) {158 return 0 == internal_mprotect((void *)addr, size, PROT_READ | PROT_WRITE);159}160 161#if !SANITIZER_APPLE162void MprotectMallocZones(void *addr, int prot) {}163#endif164 165fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *errno_p) {166 if (ShouldMockFailureToOpen(filename))167 return kInvalidFd;168 int flags;169 switch (mode) {170 case RdOnly: flags = O_RDONLY; break;171 case WrOnly: flags = O_WRONLY | O_CREAT | O_TRUNC; break;172 case RdWr: flags = O_RDWR | O_CREAT; break;173 }174 fd_t res = internal_open(filename, flags, 0660);175 if (internal_iserror(res, errno_p))176 return kInvalidFd;177 return ReserveStandardFds(res);178}179 180void CloseFile(fd_t fd) {181 internal_close(fd);182}183 184bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read,185 error_t *error_p) {186 uptr res = internal_read(fd, buff, buff_size);187 if (internal_iserror(res, error_p))188 return false;189 if (bytes_read)190 *bytes_read = res;191 return true;192}193 194bool WriteToFile(fd_t fd, const void *buff, uptr buff_size, uptr *bytes_written,195 error_t *error_p) {196 uptr res = internal_write(fd, buff, buff_size);197 if (internal_iserror(res, error_p))198 return false;199 if (bytes_written)200 *bytes_written = res;201 return true;202}203 204void *MapFileToMemory(const char *file_name, uptr *buff_size) {205 fd_t fd = OpenFile(file_name, RdOnly);206 CHECK(fd != kInvalidFd);207 uptr fsize = internal_filesize(fd);208 CHECK_NE(fsize, (uptr)-1);209 CHECK_GT(fsize, 0);210 *buff_size = RoundUpTo(fsize, GetPageSizeCached());211 uptr map = internal_mmap(nullptr, *buff_size, PROT_READ, MAP_PRIVATE, fd, 0);212 return internal_iserror(map) ? nullptr : (void *)map;213}214 215void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {216 uptr flags = MAP_SHARED;217 if (addr) flags |= MAP_FIXED;218 uptr p = internal_mmap(addr, size, PROT_READ | PROT_WRITE, flags, fd, offset);219 int mmap_errno = 0;220 if (internal_iserror(p, &mmap_errno)) {221 Printf("could not map writable file (%d, %lld, %zu): %zd, errno: %d\n",222 fd, (long long)offset, size, p, mmap_errno);223 return nullptr;224 }225 return (void *)p;226}227 228# if !SANITIZER_APPLE229// FIXME: this is thread-unsafe, but should not cause problems most of the time.230// When the shadow is mapped only a single thread usually exists231bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {232 MemoryMappingLayout proc_maps(/*cache_enabled*/true);233 if (proc_maps.Error())234 return true; // and hope for the best235 MemoryMappedSegment segment;236 while (proc_maps.Next(&segment)) {237 if (segment.start == segment.end) continue; // Empty range.238 CHECK_NE(0, segment.end);239 if (!IntervalsAreSeparate(segment.start, segment.end - 1, range_start,240 range_end))241 return false;242 }243 return true;244}245 246void 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,254 segment.filename);255 }256 Report("End of process memory map.\n");257 UnmapOrDie(filename, kBufSize);258}259# endif260 261const char *GetPwd() {262 return GetEnv("PWD");263}264 265bool IsPathSeparator(const char c) {266 return c == '/';267}268 269bool IsAbsolutePath(const char *path) {270 return path != nullptr && IsPathSeparator(path[0]);271}272 273void ReportFile::Write(const char *buffer, uptr length) {274 SpinMutexLock l(mu);275 ReopenIfNecessary();276 internal_write(fd, buffer, length);277}278 279bool 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;287 *end = segment.end;288 return true;289 }290 }291 return false;292}293 294uptr SignalContext::GetAddress() const {295 auto si = static_cast<const siginfo_t *>(siginfo);296 return (uptr)si->si_addr;297}298 299bool SignalContext::IsMemoryAccess() const {300 auto si = static_cast<const siginfo_t *>(siginfo);301 return si->si_signo == SIGSEGV || si->si_signo == SIGBUS;302}303 304int SignalContext::GetType() const {305 return static_cast<const siginfo_t *>(siginfo)->si_signo;306}307 308const char *SignalContext::Describe() const {309 switch (GetType()) {310 case SIGFPE:311 return "FPE";312 case SIGILL:313 return "ILL";314 case SIGABRT:315 return "ABRT";316 case SIGSEGV:317 return "SEGV";318 case SIGBUS:319 return "BUS";320 case SIGTRAP:321 return "TRAP";322 }323 return "UNKNOWN SIGNAL";324}325 326fd_t ReserveStandardFds(fd_t fd) {327 CHECK_GE(fd, 0);328 if (fd > 2)329 return fd;330 bool used[3];331 internal_memset(used, 0, sizeof(used));332 while (fd <= 2) {333 used[fd] = true;334 fd = internal_dup(fd);335 }336 for (int i = 0; i <= 2; ++i)337 if (used[i])338 internal_close(i);339 return fd;340}341 342bool ShouldMockFailureToOpen(const char *path) {343 return common_flags()->test_only_emulate_no_memorymap &&344 internal_strncmp(path, "/proc/", 6) == 0;345}346 347bool OpenReadsVaArgs(int oflag) {348# ifdef O_TMPFILE349 return (oflag & (O_CREAT | O_TMPFILE)) != 0;350# else351 return (oflag & O_CREAT) != 0;352# endif353}354 355# if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_GO356int GetNamedMappingFd(const char *name, uptr size, int *flags) {357 if (!common_flags()->decorate_proc_maps || !name)358 return -1;359 char shmname[200];360 CHECK(internal_strlen(name) < sizeof(shmname) - 10);361 internal_snprintf(shmname, sizeof(shmname), "/dev/shm/%zu [%s]",362 internal_getpid(), name);363 int o_cloexec = 0;364#if defined(O_CLOEXEC)365 o_cloexec = O_CLOEXEC;366#endif367 int fd = ReserveStandardFds(368 internal_open(shmname, O_RDWR | O_CREAT | O_TRUNC | o_cloexec, S_IRWXU));369 CHECK_GE(fd, 0);370 int res = internal_ftruncate(fd, size);371#if !defined(O_CLOEXEC)372 res = fcntl(fd, F_SETFD, FD_CLOEXEC);373 CHECK_EQ(0, res);374#endif375 CHECK_EQ(0, res);376 res = internal_unlink(shmname);377 CHECK_EQ(0, res);378 *flags &= ~(MAP_ANON | MAP_ANONYMOUS);379 return fd;380}381#else382int GetNamedMappingFd(const char *name, uptr size, int *flags) {383 return -1;384}385#endif386 387#if SANITIZER_ANDROID388#define PR_SET_VMA 0x53564d41389#define PR_SET_VMA_ANON_NAME 0390void DecorateMapping(uptr addr, uptr size, const char *name) {391 if (!common_flags()->decorate_proc_maps || !name)392 return;393 internal_prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, addr, size, (uptr)name);394}395#else396void DecorateMapping(uptr addr, uptr size, const char *name) {397}398#endif399 400uptr MmapNamed(void *addr, uptr length, int prot, int flags, const char *name) {401 int fd = GetNamedMappingFd(name, length, &flags);402 uptr res = internal_mmap(addr, length, prot, flags, fd, 0);403 if (!internal_iserror(res))404 DecorateMapping(res, length, name);405 return res;406}407 408 409} // namespace __sanitizer410 411#endif // SANITIZER_POSIX412