1//===-- sanitizer_posix_libcdep.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 libc-dependent POSIX-specific functions
11// from sanitizer_libc.h.
12//===----------------------------------------------------------------------===//
13
14#include "sanitizer_platform.h"
15
16#if SANITIZER_POSIX
17
18#include "sanitizer_common.h"
19#include "sanitizer_flags.h"
20#include "sanitizer_platform_limits_netbsd.h"
21#include "sanitizer_platform_limits_posix.h"
22#include "sanitizer_platform_limits_solaris.h"
23#include "sanitizer_posix.h"
24#include "sanitizer_procmaps.h"
25
26#include <errno.h>
27#include <fcntl.h>
28#include <pthread.h>
29#include <signal.h>
30#include <stdlib.h>
31#include <sys/mman.h>
32#include <sys/resource.h>
33#include <sys/stat.h>
34#include <sys/time.h>
35#include <sys/types.h>
36#include <sys/wait.h>
37#include <unistd.h>
38
39#if SANITIZER_FREEBSD
40// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
41// that, it was never implemented.  So just define it to zero.
42#undef MAP_NORESERVE
43#define MAP_NORESERVE 0
44#endif
45
46typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
47
48namespace __sanitizer {
49
50u32 GetUid() {
51  return getuid();
52}
53
54uptr GetThreadSelf() {
55  return (uptr)pthread_self();
56}
57
58void ReleaseMemoryPagesToOS(uptr beg, uptr end) {
59  uptr page_size = GetPageSizeCached();
60  uptr beg_aligned = RoundUpTo(beg, page_size);
61  uptr end_aligned = RoundDownTo(end, page_size);
62  if (beg_aligned < end_aligned)
63    internal_madvise(beg_aligned, end_aligned - beg_aligned,
64                     SANITIZER_MADVISE_DONTNEED);
65}
66
67void SetShadowRegionHugePageMode(uptr addr, uptr size) {
68#ifdef MADV_NOHUGEPAGE  // May not be defined on old systems.
69  if (common_flags()->no_huge_pages_for_shadow)
70    internal_madvise(addr, size, MADV_NOHUGEPAGE);
71  else
72    internal_madvise(addr, size, MADV_HUGEPAGE);
73#endif  // MADV_NOHUGEPAGE
74}
75
76bool DontDumpShadowMemory(uptr addr, uptr length) {
77#if defined(MADV_DONTDUMP)
78  return internal_madvise(addr, length, MADV_DONTDUMP) == 0;
79#elif defined(MADV_NOCORE)
80  return internal_madvise(addr, length, MADV_NOCORE) == 0;
81#else
82  return true;
83#endif  // MADV_DONTDUMP
84}
85
86static rlim_t getlim(int res) {
87  rlimit rlim;
88  CHECK_EQ(0, getrlimit(res, &rlim));
89  return rlim.rlim_cur;
90}
91
92static void setlim(int res, rlim_t lim) {
93  struct rlimit rlim;
94  if (getrlimit(res, const_cast<struct rlimit *>(&rlim))) {
95    Report("ERROR: %s getrlimit() failed %d\n", SanitizerToolName, errno);
96    Die();
97  }
98  rlim.rlim_cur = lim;
99  if (setrlimit(res, const_cast<struct rlimit *>(&rlim))) {
100    Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName, errno);
101    Die();
102  }
103}
104
105void DisableCoreDumperIfNecessary() {
106  if (common_flags()->disable_coredump) {
107    setlim(RLIMIT_CORE, 0);
108  }
109}
110
111bool StackSizeIsUnlimited() {
112  rlim_t stack_size = getlim(RLIMIT_STACK);
113  return (stack_size == RLIM_INFINITY);
114}
115
116void SetStackSizeLimitInBytes(uptr limit) {
117  setlim(RLIMIT_STACK, (rlim_t)limit);
118  CHECK(!StackSizeIsUnlimited());
119}
120
121bool AddressSpaceIsUnlimited() {
122  rlim_t as_size = getlim(RLIMIT_AS);
123  return (as_size == RLIM_INFINITY);
124}
125
126void SetAddressSpaceUnlimited() {
127  setlim(RLIMIT_AS, RLIM_INFINITY);
128  CHECK(AddressSpaceIsUnlimited());
129}
130
131void Abort() {
132#if !SANITIZER_GO
133  // If we are handling SIGABRT, unhandle it first.
134  // TODO(vitalybuka): Check if handler belongs to sanitizer.
135  if (GetHandleSignalMode(SIGABRT) != kHandleSignalNo) {
136    struct sigaction sigact;
137    internal_memset(&sigact, 0, sizeof(sigact));
138    sigact.sa_handler = SIG_DFL;
139    internal_sigaction(SIGABRT, &sigact, nullptr);
140  }
141#endif
142
143  abort();
144}
145
146int Atexit(void (*function)(void)) {
147#if !SANITIZER_GO
148  return atexit(function);
149#else
150  return 0;
151#endif
152}
153
154bool CreateDir(const char *pathname) { return mkdir(pathname, 0755) == 0; }
155
156bool SupportsColoredOutput(fd_t fd) {
157  return isatty(fd) != 0;
158}
159
160#if !SANITIZER_GO
161// TODO(glider): different tools may require different altstack size.
162static uptr GetAltStackSize() {
163  // Note: since GLIBC_2.31, SIGSTKSZ may be a function call, so this may be
164  // more costly that you think. However GetAltStackSize is only call 2-3 times
165  // per thread so don't cache the evaluation.
166  return SIGSTKSZ * 4;
167}
168
169void SetAlternateSignalStack() {
170  stack_t altstack, oldstack;
171  CHECK_EQ(0, sigaltstack(nullptr, &oldstack));
172  // If the alternate stack is already in place, do nothing.
173  // Android always sets an alternate stack, but it's too small for us.
174  if (!SANITIZER_ANDROID && !(oldstack.ss_flags & SS_DISABLE)) return;
175  // TODO(glider): the mapped stack should have the MAP_STACK flag in the
176  // future. It is not required by man 2 sigaltstack now (they're using
177  // malloc()).
178  altstack.ss_size = GetAltStackSize();
179  altstack.ss_sp = (char *)MmapOrDie(altstack.ss_size, __func__);
180  altstack.ss_flags = 0;
181  CHECK_EQ(0, sigaltstack(&altstack, nullptr));
182}
183
184void UnsetAlternateSignalStack() {
185  stack_t altstack, oldstack;
186  altstack.ss_sp = nullptr;
187  altstack.ss_flags = SS_DISABLE;
188  altstack.ss_size = GetAltStackSize();  // Some sane value required on Darwin.
189  CHECK_EQ(0, sigaltstack(&altstack, &oldstack));
190  UnmapOrDie(oldstack.ss_sp, oldstack.ss_size);
191}
192
193static void MaybeInstallSigaction(int signum,
194                                  SignalHandlerType handler) {
195  if (GetHandleSignalMode(signum) == kHandleSignalNo) return;
196
197  struct sigaction sigact;
198  internal_memset(&sigact, 0, sizeof(sigact));
199  sigact.sa_sigaction = (sa_sigaction_t)handler;
200  // Do not block the signal from being received in that signal's handler.
201  // Clients are responsible for handling this correctly.
202  sigact.sa_flags = SA_SIGINFO | SA_NODEFER;
203  if (common_flags()->use_sigaltstack) sigact.sa_flags |= SA_ONSTACK;
204  CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr));
205  VReport(1, "Installed the sigaction for signal %d\n", signum);
206}
207
208void InstallDeadlySignalHandlers(SignalHandlerType handler) {
209  // Set the alternate signal stack for the main thread.
210  // This will cause SetAlternateSignalStack to be called twice, but the stack
211  // will be actually set only once.
212  if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
213  MaybeInstallSigaction(SIGSEGV, handler);
214  MaybeInstallSigaction(SIGBUS, handler);
215  MaybeInstallSigaction(SIGABRT, handler);
216  MaybeInstallSigaction(SIGFPE, handler);
217  MaybeInstallSigaction(SIGILL, handler);
218  MaybeInstallSigaction(SIGTRAP, handler);
219}
220
221bool SignalContext::IsStackOverflow() const {
222  // Access at a reasonable offset above SP, or slightly below it (to account
223  // for x86_64 or PowerPC redzone, ARM push of multiple registers, etc) is
224  // probably a stack overflow.
225#ifdef __s390__
226  // On s390, the fault address in siginfo points to start of the page, not
227  // to the precise word that was accessed.  Mask off the low bits of sp to
228  // take it into account.
229  bool IsStackAccess = addr >= (sp & ~0xFFF) && addr < sp + 0xFFFF;
230#else
231  // Let's accept up to a page size away from top of stack. Things like stack
232  // probing can trigger accesses with such large offsets.
233  bool IsStackAccess = addr + GetPageSizeCached() > sp && addr < sp + 0xFFFF;
234#endif
235
236#if __powerpc__
237  // Large stack frames can be allocated with e.g.
238  //   lis r0,-10000
239  //   stdux r1,r1,r0 # store sp to [sp-10000] and update sp by -10000
240  // If the store faults then sp will not have been updated, so test above
241  // will not work, because the fault address will be more than just "slightly"
242  // below sp.
243  if (!IsStackAccess && IsAccessibleMemoryRange(pc, 4)) {
244    u32 inst = *(unsigned *)pc;
245    u32 ra = (inst >> 16) & 0x1F;
246    u32 opcd = inst >> 26;
247    u32 xo = (inst >> 1) & 0x3FF;
248    // Check for store-with-update to sp. The instructions we accept are:
249    //   stbu rs,d(ra)          stbux rs,ra,rb
250    //   sthu rs,d(ra)          sthux rs,ra,rb
251    //   stwu rs,d(ra)          stwux rs,ra,rb
252    //   stdu rs,ds(ra)         stdux rs,ra,rb
253    // where ra is r1 (the stack pointer).
254    if (ra == 1 &&
255        (opcd == 39 || opcd == 45 || opcd == 37 || opcd == 62 ||
256         (opcd == 31 && (xo == 247 || xo == 439 || xo == 183 || xo == 181))))
257      IsStackAccess = true;
258  }
259#endif  // __powerpc__
260
261  // We also check si_code to filter out SEGV caused by something else other
262  // then hitting the guard page or unmapped memory, like, for example,
263  // unaligned memory access.
264  auto si = static_cast<const siginfo_t *>(siginfo);
265  return IsStackAccess &&
266         (si->si_code == si_SEGV_MAPERR || si->si_code == si_SEGV_ACCERR);
267}
268
269#endif  // SANITIZER_GO
270
271bool IsAccessibleMemoryRange(uptr beg, uptr size) {
272  uptr page_size = GetPageSizeCached();
273  // Checking too large memory ranges is slow.
274  CHECK_LT(size, page_size * 10);
275  int sock_pair[2];
276  if (pipe(sock_pair))
277    return false;
278  uptr bytes_written =
279      internal_write(sock_pair[1], reinterpret_cast<void *>(beg), size);
280  int write_errno;
281  bool result;
282  if (internal_iserror(bytes_written, &write_errno)) {
283    CHECK_EQ(EFAULT, write_errno);
284    result = false;
285  } else {
286    result = (bytes_written == size);
287  }
288  internal_close(sock_pair[0]);
289  internal_close(sock_pair[1]);
290  return result;
291}
292
293void PlatformPrepareForSandboxing(void *args) {
294  // Some kinds of sandboxes may forbid filesystem access, so we won't be able
295  // to read the file mappings from /proc/self/maps. Luckily, neither the
296  // process will be able to load additional libraries, so it's fine to use the
297  // cached mappings.
298  MemoryMappingLayout::CacheMemoryMappings();
299}
300
301static bool MmapFixed(uptr fixed_addr, uptr size, int additional_flags,
302                      const char *name) {
303  size = RoundUpTo(size, GetPageSizeCached());
304  fixed_addr = RoundDownTo(fixed_addr, GetPageSizeCached());
305  uptr p =
306      MmapNamed((void *)fixed_addr, size, PROT_READ | PROT_WRITE,
307                MAP_PRIVATE | MAP_FIXED | additional_flags | MAP_ANON, name);
308  int reserrno;
309  if (internal_iserror(p, &reserrno)) {
310    Report("ERROR: %s failed to "
311           "allocate 0x%zx (%zd) bytes at address %zx (errno: %d)\n",
312           SanitizerToolName, size, size, fixed_addr, reserrno);
313    return false;
314  }
315  IncreaseTotalMmap(size);
316  return true;
317}
318
319bool MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) {
320  return MmapFixed(fixed_addr, size, MAP_NORESERVE, name);
321}
322
323bool MmapFixedSuperNoReserve(uptr fixed_addr, uptr size, const char *name) {
324#if SANITIZER_FREEBSD
325  if (common_flags()->no_huge_pages_for_shadow)
326    return MmapFixedNoReserve(fixed_addr, size, name);
327  // MAP_NORESERVE is implicit with FreeBSD
328  return MmapFixed(fixed_addr, size, MAP_ALIGNED_SUPER, name);
329#else
330  bool r = MmapFixedNoReserve(fixed_addr, size, name);
331  if (r)
332    SetShadowRegionHugePageMode(fixed_addr, size);
333  return r;
334#endif
335}
336
337uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) {
338  base_ = fixed_addr ? MmapFixedNoAccess(fixed_addr, size, name)
339                     : MmapNoAccess(size);
340  size_ = size;
341  name_ = name;
342  (void)os_handle_;  // unsupported
343  return reinterpret_cast<uptr>(base_);
344}
345
346// Uses fixed_addr for now.
347// Will use offset instead once we've implemented this function for real.
348uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size, const char *name) {
349  return reinterpret_cast<uptr>(
350      MmapFixedOrDieOnFatalError(fixed_addr, size, name));
351}
352
353uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr size,
354                                    const char *name) {
355  return reinterpret_cast<uptr>(MmapFixedOrDie(fixed_addr, size, name));
356}
357
358void ReservedAddressRange::Unmap(uptr addr, uptr size) {
359  CHECK_LE(size, size_);
360  if (addr == reinterpret_cast<uptr>(base_))
361    // If we unmap the whole range, just null out the base.
362    base_ = (size == size_) ? nullptr : reinterpret_cast<void*>(addr + size);
363  else
364    CHECK_EQ(addr + size, reinterpret_cast<uptr>(base_) + size_);
365  size_ -= size;
366  UnmapOrDie(reinterpret_cast<void*>(addr), size);
367}
368
369void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) {
370  return (void *)MmapNamed((void *)fixed_addr, size, PROT_NONE,
371                           MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE | MAP_ANON,
372                           name);
373}
374
375void *MmapNoAccess(uptr size) {
376  unsigned flags = MAP_PRIVATE | MAP_ANON | MAP_NORESERVE;
377  return (void *)internal_mmap(nullptr, size, PROT_NONE, flags, -1, 0);
378}
379
380// This function is defined elsewhere if we intercepted pthread_attr_getstack.
381extern "C" {
382SANITIZER_WEAK_ATTRIBUTE int
383real_pthread_attr_getstack(void *attr, void **addr, size_t *size);
384} // extern "C"
385
386int my_pthread_attr_getstack(void *attr, void **addr, uptr *size) {
387#if !SANITIZER_GO && !SANITIZER_APPLE
388  if (&real_pthread_attr_getstack)
389    return real_pthread_attr_getstack((pthread_attr_t *)attr, addr,
390                                      (size_t *)size);
391#endif
392  return pthread_attr_getstack((pthread_attr_t *)attr, addr, (size_t *)size);
393}
394
395#if !SANITIZER_GO
396void AdjustStackSize(void *attr_) {
397  pthread_attr_t *attr = (pthread_attr_t *)attr_;
398  uptr stackaddr = 0;
399  uptr stacksize = 0;
400  my_pthread_attr_getstack(attr, (void**)&stackaddr, &stacksize);
401  // GLibC will return (0 - stacksize) as the stack address in the case when
402  // stacksize is set, but stackaddr is not.
403  bool stack_set = (stackaddr != 0) && (stackaddr + stacksize != 0);
404  // We place a lot of tool data into TLS, account for that.
405  const uptr minstacksize = GetTlsSize() + 128*1024;
406  if (stacksize < minstacksize) {
407    if (!stack_set) {
408      if (stacksize != 0) {
409        VPrintf(1, "Sanitizer: increasing stacksize %zu->%zu\n", stacksize,
410                minstacksize);
411        pthread_attr_setstacksize(attr, minstacksize);
412      }
413    } else {
414      Printf("Sanitizer: pre-allocated stack size is insufficient: "
415             "%zu < %zu\n", stacksize, minstacksize);
416      Printf("Sanitizer: pthread_create is likely to fail.\n");
417    }
418  }
419}
420#endif // !SANITIZER_GO
421
422pid_t StartSubprocess(const char *program, const char *const argv[],
423                      const char *const envp[], fd_t stdin_fd, fd_t stdout_fd,
424                      fd_t stderr_fd) {
425  auto file_closer = at_scope_exit([&] {
426    if (stdin_fd != kInvalidFd) {
427      internal_close(stdin_fd);
428    }
429    if (stdout_fd != kInvalidFd) {
430      internal_close(stdout_fd);
431    }
432    if (stderr_fd != kInvalidFd) {
433      internal_close(stderr_fd);
434    }
435  });
436
437  int pid = internal_fork();
438
439  if (pid < 0) {
440    int rverrno;
441    if (internal_iserror(pid, &rverrno)) {
442      Report("WARNING: failed to fork (errno %d)\n", rverrno);
443    }
444    return pid;
445  }
446
447  if (pid == 0) {
448    // Child subprocess
449    if (stdin_fd != kInvalidFd) {
450      internal_close(STDIN_FILENO);
451      internal_dup2(stdin_fd, STDIN_FILENO);
452      internal_close(stdin_fd);
453    }
454    if (stdout_fd != kInvalidFd) {
455      internal_close(STDOUT_FILENO);
456      internal_dup2(stdout_fd, STDOUT_FILENO);
457      internal_close(stdout_fd);
458    }
459    if (stderr_fd != kInvalidFd) {
460      internal_close(STDERR_FILENO);
461      internal_dup2(stderr_fd, STDERR_FILENO);
462      internal_close(stderr_fd);
463    }
464
465    for (int fd = sysconf(_SC_OPEN_MAX); fd > 2; fd--) internal_close(fd);
466
467    internal_execve(program, const_cast<char **>(&argv[0]),
468                    const_cast<char *const *>(envp));
469    internal__exit(1);
470  }
471
472  return pid;
473}
474
475bool IsProcessRunning(pid_t pid) {
476  int process_status;
477  uptr waitpid_status = internal_waitpid(pid, &process_status, WNOHANG);
478  int local_errno;
479  if (internal_iserror(waitpid_status, &local_errno)) {
480    VReport(1, "Waiting on the process failed (errno %d).\n", local_errno);
481    return false;
482  }
483  return waitpid_status == 0;
484}
485
486int WaitForProcess(pid_t pid) {
487  int process_status;
488  uptr waitpid_status = internal_waitpid(pid, &process_status, 0);
489  int local_errno;
490  if (internal_iserror(waitpid_status, &local_errno)) {
491    VReport(1, "Waiting on the process failed (errno %d).\n", local_errno);
492    return -1;
493  }
494  return process_status;
495}
496
497bool IsStateDetached(int state) {
498  return state == PTHREAD_CREATE_DETACHED;
499}
500
501} // namespace __sanitizer
502
503#endif // SANITIZER_POSIX
504