1 //===-- sanitizer_posix_libcdep.cc ----------------------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is shared between AddressSanitizer and ThreadSanitizer
9 // run-time libraries and implements libc-dependent POSIX-specific functions
10 // from sanitizer_libc.h.
11 //===----------------------------------------------------------------------===//
13 #include "sanitizer_platform.h"
17 #include "sanitizer_common.h"
18 #include "sanitizer_flags.h"
19 #include "sanitizer_platform_limits_netbsd.h"
20 #include "sanitizer_platform_limits_openbsd.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"
32 #include <sys/resource.h>
35 #include <sys/types.h>
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.
43 #define MAP_NORESERVE 0
46 typedef void (*sa_sigaction_t
)(int, siginfo_t
*, void *);
48 namespace __sanitizer
{
54 uptr
GetThreadSelf() {
55 return (uptr
)pthread_self();
58 void 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 // In the default Solaris compilation environment, madvise() is declared
64 // to take a caddr_t arg; casting it to void * results in an invalid
65 // conversion error, so use char * instead.
66 madvise((char *)beg_aligned
, end_aligned
- beg_aligned
,
67 SANITIZER_MADVISE_DONTNEED
);
70 bool NoHugePagesInRegion(uptr addr
, uptr size
) {
71 #ifdef MADV_NOHUGEPAGE // May not be defined on old systems.
72 return madvise((void *)addr
, size
, MADV_NOHUGEPAGE
) == 0;
75 #endif // MADV_NOHUGEPAGE
78 bool DontDumpShadowMemory(uptr addr
, uptr length
) {
79 #if defined(MADV_DONTDUMP)
80 return madvise((void *)addr
, length
, MADV_DONTDUMP
) == 0;
81 #elif defined(MADV_NOCORE)
82 return madvise((void *)addr
, length
, MADV_NOCORE
) == 0;
85 #endif // MADV_DONTDUMP
88 static rlim_t
getlim(int res
) {
90 CHECK_EQ(0, getrlimit(res
, &rlim
));
94 static void setlim(int res
, rlim_t lim
) {
95 // The following magic is to prevent clang from replacing it with memset.
96 volatile struct rlimit rlim
;
99 if (setrlimit(res
, const_cast<struct rlimit
*>(&rlim
))) {
100 Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName
, errno
);
105 void DisableCoreDumperIfNecessary() {
106 if (common_flags()->disable_coredump
) {
107 setlim(RLIMIT_CORE
, 0);
111 bool StackSizeIsUnlimited() {
112 rlim_t stack_size
= getlim(RLIMIT_STACK
);
113 return (stack_size
== RLIM_INFINITY
);
116 uptr
GetStackSizeLimitInBytes() {
117 return (uptr
)getlim(RLIMIT_STACK
);
120 void SetStackSizeLimitInBytes(uptr limit
) {
121 setlim(RLIMIT_STACK
, (rlim_t
)limit
);
122 CHECK(!StackSizeIsUnlimited());
125 bool AddressSpaceIsUnlimited() {
126 rlim_t as_size
= getlim(RLIMIT_AS
);
127 return (as_size
== RLIM_INFINITY
);
130 void SetAddressSpaceUnlimited() {
131 setlim(RLIMIT_AS
, RLIM_INFINITY
);
132 CHECK(AddressSpaceIsUnlimited());
135 void SleepForSeconds(int seconds
) {
139 void SleepForMillis(int millis
) {
140 usleep(millis
* 1000);
145 // If we are handling SIGABRT, unhandle it first.
146 // TODO(vitalybuka): Check if handler belongs to sanitizer.
147 if (GetHandleSignalMode(SIGABRT
) != kHandleSignalNo
) {
148 struct sigaction sigact
;
149 internal_memset(&sigact
, 0, sizeof(sigact
));
150 sigact
.sa_sigaction
= (sa_sigaction_t
)SIG_DFL
;
151 internal_sigaction(SIGABRT
, &sigact
, nullptr);
158 int Atexit(void (*function
)(void)) {
160 return atexit(function
);
166 bool SupportsColoredOutput(fd_t fd
) {
167 return isatty(fd
) != 0;
171 // TODO(glider): different tools may require different altstack size.
172 static const uptr kAltStackSize
= SIGSTKSZ
* 4; // SIGSTKSZ is not enough.
174 void SetAlternateSignalStack() {
175 stack_t altstack
, oldstack
;
176 CHECK_EQ(0, sigaltstack(nullptr, &oldstack
));
177 // If the alternate stack is already in place, do nothing.
178 // Android always sets an alternate stack, but it's too small for us.
179 if (!SANITIZER_ANDROID
&& !(oldstack
.ss_flags
& SS_DISABLE
)) return;
180 // TODO(glider): the mapped stack should have the MAP_STACK flag in the
181 // future. It is not required by man 2 sigaltstack now (they're using
183 void* base
= MmapOrDie(kAltStackSize
, __func__
);
184 altstack
.ss_sp
= (char*) base
;
185 altstack
.ss_flags
= 0;
186 altstack
.ss_size
= kAltStackSize
;
187 CHECK_EQ(0, sigaltstack(&altstack
, nullptr));
190 void UnsetAlternateSignalStack() {
191 stack_t altstack
, oldstack
;
192 altstack
.ss_sp
= nullptr;
193 altstack
.ss_flags
= SS_DISABLE
;
194 altstack
.ss_size
= kAltStackSize
; // Some sane value required on Darwin.
195 CHECK_EQ(0, sigaltstack(&altstack
, &oldstack
));
196 UnmapOrDie(oldstack
.ss_sp
, oldstack
.ss_size
);
199 static void MaybeInstallSigaction(int signum
,
200 SignalHandlerType handler
) {
201 if (GetHandleSignalMode(signum
) == kHandleSignalNo
) return;
203 struct sigaction sigact
;
204 internal_memset(&sigact
, 0, sizeof(sigact
));
205 sigact
.sa_sigaction
= (sa_sigaction_t
)handler
;
206 // Do not block the signal from being received in that signal's handler.
207 // Clients are responsible for handling this correctly.
208 sigact
.sa_flags
= SA_SIGINFO
| SA_NODEFER
;
209 if (common_flags()->use_sigaltstack
) sigact
.sa_flags
|= SA_ONSTACK
;
210 CHECK_EQ(0, internal_sigaction(signum
, &sigact
, nullptr));
211 VReport(1, "Installed the sigaction for signal %d\n", signum
);
214 void InstallDeadlySignalHandlers(SignalHandlerType handler
) {
215 // Set the alternate signal stack for the main thread.
216 // This will cause SetAlternateSignalStack to be called twice, but the stack
217 // will be actually set only once.
218 if (common_flags()->use_sigaltstack
) SetAlternateSignalStack();
219 MaybeInstallSigaction(SIGSEGV
, handler
);
220 MaybeInstallSigaction(SIGBUS
, handler
);
221 MaybeInstallSigaction(SIGABRT
, handler
);
222 MaybeInstallSigaction(SIGFPE
, handler
);
223 MaybeInstallSigaction(SIGILL
, handler
);
224 MaybeInstallSigaction(SIGTRAP
, handler
);
227 bool SignalContext::IsStackOverflow() const {
228 // Access at a reasonable offset above SP, or slightly below it (to account
229 // for x86_64 or PowerPC redzone, ARM push of multiple registers, etc) is
230 // probably a stack overflow.
232 // On s390, the fault address in siginfo points to start of the page, not
233 // to the precise word that was accessed. Mask off the low bits of sp to
234 // take it into account.
235 bool IsStackAccess
= addr
>= (sp
& ~0xFFF) && addr
< sp
+ 0xFFFF;
237 // Let's accept up to a page size away from top of stack. Things like stack
238 // probing can trigger accesses with such large offsets.
239 bool IsStackAccess
= addr
+ GetPageSizeCached() > sp
&& addr
< sp
+ 0xFFFF;
243 // Large stack frames can be allocated with e.g.
245 // stdux r1,r1,r0 # store sp to [sp-10000] and update sp by -10000
246 // If the store faults then sp will not have been updated, so test above
247 // will not work, because the fault address will be more than just "slightly"
249 if (!IsStackAccess
&& IsAccessibleMemoryRange(pc
, 4)) {
250 u32 inst
= *(unsigned *)pc
;
251 u32 ra
= (inst
>> 16) & 0x1F;
252 u32 opcd
= inst
>> 26;
253 u32 xo
= (inst
>> 1) & 0x3FF;
254 // Check for store-with-update to sp. The instructions we accept are:
255 // stbu rs,d(ra) stbux rs,ra,rb
256 // sthu rs,d(ra) sthux rs,ra,rb
257 // stwu rs,d(ra) stwux rs,ra,rb
258 // stdu rs,ds(ra) stdux rs,ra,rb
259 // where ra is r1 (the stack pointer).
261 (opcd
== 39 || opcd
== 45 || opcd
== 37 || opcd
== 62 ||
262 (opcd
== 31 && (xo
== 247 || xo
== 439 || xo
== 183 || xo
== 181))))
263 IsStackAccess
= true;
265 #endif // __powerpc__
267 // We also check si_code to filter out SEGV caused by something else other
268 // then hitting the guard page or unmapped memory, like, for example,
269 // unaligned memory access.
270 auto si
= static_cast<const siginfo_t
*>(siginfo
);
271 return IsStackAccess
&&
272 (si
->si_code
== si_SEGV_MAPERR
|| si
->si_code
== si_SEGV_ACCERR
);
275 #endif // SANITIZER_GO
277 bool IsAccessibleMemoryRange(uptr beg
, uptr size
) {
278 uptr page_size
= GetPageSizeCached();
279 // Checking too large memory ranges is slow.
280 CHECK_LT(size
, page_size
* 10);
285 internal_write(sock_pair
[1], reinterpret_cast<void *>(beg
), size
);
288 if (internal_iserror(bytes_written
, &write_errno
)) {
289 CHECK_EQ(EFAULT
, write_errno
);
292 result
= (bytes_written
== size
);
294 internal_close(sock_pair
[0]);
295 internal_close(sock_pair
[1]);
299 void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments
*args
) {
300 // Some kinds of sandboxes may forbid filesystem access, so we won't be able
301 // to read the file mappings from /proc/self/maps. Luckily, neither the
302 // process will be able to load additional libraries, so it's fine to use the
304 MemoryMappingLayout::CacheMemoryMappings();
307 #if SANITIZER_ANDROID || SANITIZER_GO
308 int GetNamedMappingFd(const char *name
, uptr size
) {
312 int GetNamedMappingFd(const char *name
, uptr size
) {
313 if (!common_flags()->decorate_proc_maps
)
316 CHECK(internal_strlen(name
) < sizeof(shmname
) - 10);
317 internal_snprintf(shmname
, sizeof(shmname
), "%zu [%s]", internal_getpid(),
319 int fd
= shm_open(shmname
, O_RDWR
| O_CREAT
| O_TRUNC
, S_IRWXU
);
321 int res
= internal_ftruncate(fd
, size
);
323 res
= shm_unlink(shmname
);
329 bool MmapFixedNoReserve(uptr fixed_addr
, uptr size
, const char *name
) {
330 int fd
= name
? GetNamedMappingFd(name
, size
) : -1;
331 unsigned flags
= MAP_PRIVATE
| MAP_FIXED
| MAP_NORESERVE
;
332 if (fd
== -1) flags
|= MAP_ANON
;
334 uptr PageSize
= GetPageSizeCached();
335 uptr p
= internal_mmap((void *)(fixed_addr
& ~(PageSize
- 1)),
336 RoundUpTo(size
, PageSize
), PROT_READ
| PROT_WRITE
,
339 if (internal_iserror(p
, &reserrno
)) {
340 Report("ERROR: %s failed to "
341 "allocate 0x%zx (%zd) bytes at address %zx (errno: %d)\n",
342 SanitizerToolName
, size
, size
, fixed_addr
, reserrno
);
345 IncreaseTotalMmap(size
);
349 uptr
ReservedAddressRange::Init(uptr size
, const char *name
, uptr fixed_addr
) {
350 // We don't pass `name` along because, when you enable `decorate_proc_maps`
351 // AND actually use a named mapping AND are using a sanitizer intercepting
352 // `open` (e.g. TSAN, ESAN), then you'll get a failure during initialization.
353 // TODO(flowerhack): Fix the implementation of GetNamedMappingFd to solve
355 base_
= fixed_addr
? MmapFixedNoAccess(fixed_addr
, size
) : MmapNoAccess(size
);
358 (void)os_handle_
; // unsupported
359 return reinterpret_cast<uptr
>(base_
);
362 // Uses fixed_addr for now.
363 // Will use offset instead once we've implemented this function for real.
364 uptr
ReservedAddressRange::Map(uptr fixed_addr
, uptr size
) {
365 return reinterpret_cast<uptr
>(MmapFixedOrDieOnFatalError(fixed_addr
, size
));
368 uptr
ReservedAddressRange::MapOrDie(uptr fixed_addr
, uptr size
) {
369 return reinterpret_cast<uptr
>(MmapFixedOrDie(fixed_addr
, size
));
372 void ReservedAddressRange::Unmap(uptr addr
, uptr size
) {
373 CHECK_LE(size
, size_
);
374 if (addr
== reinterpret_cast<uptr
>(base_
))
375 // If we unmap the whole range, just null out the base.
376 base_
= (size
== size_
) ? nullptr : reinterpret_cast<void*>(addr
+ size
);
378 CHECK_EQ(addr
+ size
, reinterpret_cast<uptr
>(base_
) + size_
);
380 UnmapOrDie(reinterpret_cast<void*>(addr
), size
);
383 void *MmapFixedNoAccess(uptr fixed_addr
, uptr size
, const char *name
) {
384 int fd
= name
? GetNamedMappingFd(name
, size
) : -1;
385 unsigned flags
= MAP_PRIVATE
| MAP_FIXED
| MAP_NORESERVE
;
386 if (fd
== -1) flags
|= MAP_ANON
;
388 return (void *)internal_mmap((void *)fixed_addr
, size
, PROT_NONE
, flags
, fd
,
392 void *MmapNoAccess(uptr size
) {
393 unsigned flags
= MAP_PRIVATE
| MAP_ANON
| MAP_NORESERVE
;
394 return (void *)internal_mmap(nullptr, size
, PROT_NONE
, flags
, -1, 0);
397 // This function is defined elsewhere if we intercepted pthread_attr_getstack.
399 SANITIZER_WEAK_ATTRIBUTE
int
400 real_pthread_attr_getstack(void *attr
, void **addr
, size_t *size
);
403 int my_pthread_attr_getstack(void *attr
, void **addr
, uptr
*size
) {
404 #if !SANITIZER_GO && !SANITIZER_MAC
405 if (&real_pthread_attr_getstack
)
406 return real_pthread_attr_getstack((pthread_attr_t
*)attr
, addr
,
409 return pthread_attr_getstack((pthread_attr_t
*)attr
, addr
, (size_t *)size
);
413 void AdjustStackSize(void *attr_
) {
414 pthread_attr_t
*attr
= (pthread_attr_t
*)attr_
;
417 my_pthread_attr_getstack(attr
, (void**)&stackaddr
, &stacksize
);
418 // GLibC will return (0 - stacksize) as the stack address in the case when
419 // stacksize is set, but stackaddr is not.
420 bool stack_set
= (stackaddr
!= 0) && (stackaddr
+ stacksize
!= 0);
421 // We place a lot of tool data into TLS, account for that.
422 const uptr minstacksize
= GetTlsSize() + 128*1024;
423 if (stacksize
< minstacksize
) {
425 if (stacksize
!= 0) {
426 VPrintf(1, "Sanitizer: increasing stacksize %zu->%zu\n", stacksize
,
428 pthread_attr_setstacksize(attr
, minstacksize
);
431 Printf("Sanitizer: pre-allocated stack size is insufficient: "
432 "%zu < %zu\n", stacksize
, minstacksize
);
433 Printf("Sanitizer: pthread_create is likely to fail.\n");
437 #endif // !SANITIZER_GO
439 pid_t
StartSubprocess(const char *program
, const char *const argv
[],
440 fd_t stdin_fd
, fd_t stdout_fd
, fd_t stderr_fd
) {
441 auto file_closer
= at_scope_exit([&] {
442 if (stdin_fd
!= kInvalidFd
) {
443 internal_close(stdin_fd
);
445 if (stdout_fd
!= kInvalidFd
) {
446 internal_close(stdout_fd
);
448 if (stderr_fd
!= kInvalidFd
) {
449 internal_close(stderr_fd
);
453 int pid
= internal_fork();
457 if (internal_iserror(pid
, &rverrno
)) {
458 Report("WARNING: failed to fork (errno %d)\n", rverrno
);
465 if (stdin_fd
!= kInvalidFd
) {
466 internal_close(STDIN_FILENO
);
467 internal_dup2(stdin_fd
, STDIN_FILENO
);
468 internal_close(stdin_fd
);
470 if (stdout_fd
!= kInvalidFd
) {
471 internal_close(STDOUT_FILENO
);
472 internal_dup2(stdout_fd
, STDOUT_FILENO
);
473 internal_close(stdout_fd
);
475 if (stderr_fd
!= kInvalidFd
) {
476 internal_close(STDERR_FILENO
);
477 internal_dup2(stderr_fd
, STDERR_FILENO
);
478 internal_close(stderr_fd
);
481 for (int fd
= sysconf(_SC_OPEN_MAX
); fd
> 2; fd
--) internal_close(fd
);
483 execv(program
, const_cast<char **>(&argv
[0]));
490 bool IsProcessRunning(pid_t pid
) {
492 uptr waitpid_status
= internal_waitpid(pid
, &process_status
, WNOHANG
);
494 if (internal_iserror(waitpid_status
, &local_errno
)) {
495 VReport(1, "Waiting on the process failed (errno %d).\n", local_errno
);
498 return waitpid_status
== 0;
501 int WaitForProcess(pid_t pid
) {
503 uptr waitpid_status
= internal_waitpid(pid
, &process_status
, 0);
505 if (internal_iserror(waitpid_status
, &local_errno
)) {
506 VReport(1, "Waiting on the process failed (errno %d).\n", local_errno
);
509 return process_status
;
512 bool IsStateDetached(int state
) {
513 return state
== PTHREAD_CREATE_DETACHED
;
516 } // namespace __sanitizer
518 #endif // SANITIZER_POSIX