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