Lines Matching defs:thr
241 static ThreadSignalContext *SigCtx(ThreadState *thr) {
242 ThreadSignalContext *ctx = (ThreadSignalContext*)thr->signal_ctx;
243 if (ctx == 0 && !thr->is_dead) {
245 MemoryResetRange(thr, (uptr)&SigCtx, (uptr)ctx, sizeof(*ctx));
246 thr->signal_ctx = ctx;
255 ScopedInterceptor::ScopedInterceptor(ThreadState *thr, const char *fname,
257 : thr_(thr)
260 Initialize(thr);
264 FuncEntry(thr, pc);
312 #define READ_STRING_OF_LEN(thr, pc, s, len, n) \
313 MemoryAccessRange((thr), (pc), (uptr)(s), \
316 #define READ_STRING(thr, pc, s, n) \
317 READ_STRING_OF_LEN((thr), (pc), (s), internal_strlen(s), (n))
319 #define BLOCK_REAL(name) (BlockingCall(thr), REAL(name))
322 explicit BlockingCall(ThreadState *thr)
323 : thr(thr)
324 , ctx(SigCtx(thr)) {
330 ProcessPendingSignals(thr);
337 thr->ignore_interceptors++;
341 thr->ignore_interceptors--;
345 ThreadState *thr;
352 AfterSleep(thr, pc);
359 AfterSleep(thr, pc);
366 AfterSleep(thr, pc);
378 ThreadState *thr = cur_thread();
380 Acquire(thr, pc, (uptr)arg);
386 static int setup_at_exit_wrapper(ThreadState *thr, uptr pc, void(*f)(),
396 return setup_at_exit_wrapper(thr, pc, (void(*)())f, 0, 0);
404 return setup_at_exit_wrapper(thr, pc, (void(*)())f, arg, dso);
407 static int setup_at_exit_wrapper(ThreadState *thr, uptr pc, void(*f)(),
412 Release(thr, pc, (uptr)ctx);
415 ThreadIgnoreBegin(thr, pc);
417 ThreadIgnoreEnd(thr, pc);
423 ThreadState *thr = cur_thread();
425 Acquire(thr, pc, (uptr)arg);
438 Release(thr, pc, (uptr)ctx);
441 ThreadIgnoreBegin(thr, pc);
443 ThreadIgnoreEnd(thr, pc);
449 static void JmpBufGarbageCollect(ThreadState *thr, uptr sp) {
450 for (uptr i = 0; i < thr->jmp_bufs.Size(); i++) {
451 JmpBuf *buf = &thr->jmp_bufs[i];
453 uptr sz = thr->jmp_bufs.Size();
454 internal_memcpy(buf, &thr->jmp_bufs[sz - 1], sizeof(*buf));
455 thr->jmp_bufs.PopBack();
461 static void SetJmp(ThreadState *thr, uptr sp, uptr mangled_sp) {
462 if (!thr->is_inited) // called from libc guts during bootstrap
465 JmpBufGarbageCollect(thr, sp);
467 JmpBuf *buf = thr->jmp_bufs.PushBack();
470 buf->shadow_stack_pos = thr->shadow_stack_pos;
471 ThreadSignalContext *sctx = SigCtx(thr);
476 buf->in_signal_handler = atomic_load(&thr->in_signal_handler,
480 static void LongJmp(ThreadState *thr, uptr *env) {
493 for (uptr i = 0; i < thr->jmp_bufs.Size(); i++) {
494 JmpBuf *buf = &thr->jmp_bufs[i];
496 CHECK_GE(thr->shadow_stack_pos, buf->shadow_stack_pos);
498 while (thr->shadow_stack_pos > buf->shadow_stack_pos)
499 FuncExit(thr);
500 ThreadSignalContext *sctx = SigCtx(thr);
506 atomic_store(&thr->in_signal_handler, buf->in_signal_handler,
508 JmpBufGarbageCollect(thr, buf->sp - 1); // do not collect buf->sp
569 // leave thr->in_ignored_lib set.
592 p = user_alloc(thr, pc, size);
600 return user_alloc(thr, pc, sz, align);
609 p = user_calloc(thr, pc, size, n);
622 p = user_realloc(thr, pc, p, size);
635 user_free(thr, pc, p);
645 user_free(thr, pc, p);
657 MemoryAccessRange(thr, pc, (uptr)dst, srclen + 1, true);
658 MemoryAccessRange(thr, pc, (uptr)src, srclen + 1, false);
665 MemoryAccessRange(thr, pc, (uptr)dst, n, true);
666 MemoryAccessRange(thr, pc, (uptr)src, min(srclen + 1, n), false);
698 FdAccess(thr, pc, fd);
700 if (thr->ignore_reads_and_writes == 0)
701 MemoryRangeImitateWrite(thr, pc, (uptr)res, sz);
703 MemoryResetRange(thr, pc, (uptr)res, sz);
717 FdAccess(thr, pc, fd);
719 if (thr->ignore_reads_and_writes == 0)
720 MemoryRangeImitateWrite(thr, pc, (uptr)res, sz);
722 MemoryResetRange(thr, pc, (uptr)res, sz);
737 ctx->metamap.ResetRange(thr->proc(), (uptr)addr, (uptr)sz);
746 return user_alloc(thr, pc, sz, align);
756 return user_alloc(thr, pc, sz, align);
761 return user_alloc(thr, pc, sz, GetPageSizeCached());
769 return user_alloc(thr, pc, sz, GetPageSizeCached());
779 *memptr = user_alloc(thr, pc, sz, align);
810 Acquire(thr, pc, (uptr)g);
820 Release(thr, pc, (uptr)g);
831 ThreadState *thr = cur_thread();
832 Processor *proc = thr->proc();
833 ThreadFinish(thr);
834 ProcUnwire(proc, thr);
836 ThreadSignalContext *sctx = thr->signal_ctx;
838 thr->signal_ctx = 0;
873 ThreadState *thr = cur_thread();
877 ThreadIgnoreBegin(thr, 0);
883 ThreadIgnoreEnd(thr, 0);
888 ProcWire(proc, thr);
889 ThreadStart(thr, tid, GetTid());
931 ThreadIgnoreBegin(thr, pc);
933 ThreadIgnoreEnd(thr, pc);
936 int tid = ThreadCreate(thr, pc, *(uptr*)th,
944 // Otherwise, this thread can call pthread_detach and reset thr->sync
957 int tid = ThreadTid(thr, pc, (uptr)th);
958 ThreadIgnoreBegin(thr, pc);
960 ThreadIgnoreEnd(thr, pc);
962 ThreadJoin(thr, pc, tid);
971 int tid = ThreadTid(thr, pc, (uptr)th);
974 ThreadDetach(thr, pc, tid);
1019 ThreadState *thr;
1030 ThreadSignalContext *ctx = SigCtx(arg->thr);
1033 MutexLock(arg->thr, arg->pc, (uptr)arg->m);
1035 arg->thr->ignore_interceptors--;
1042 MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), true);
1046 static int cond_wait(ThreadState *thr, uptr pc, ScopedInterceptor *si,
1049 MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
1050 MutexUnlock(thr, pc, (uptr)m);
1051 CondMutexUnlockCtx arg = {si, thr, pc, m};
1057 BlockingCall bc(thr);
1061 if (res == errno_EOWNERDEAD) MutexRepair(thr, pc, (uptr)m);
1062 MutexLock(thr, pc, (uptr)m);
1069 return cond_wait(thr, pc, &si, (int (*)(void *c, void *m, void *abstime))REAL(
1077 return cond_wait(thr, pc, &si, REAL(pthread_cond_timedwait), cond, m,
1086 return cond_wait(thr, pc, &si, REAL(pthread_cond_timedwait_relative_np), cond,
1094 MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
1101 MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false);
1108 MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), true);
1129 MutexCreate(thr, pc, (uptr)m, false, recursive, false);
1138 MutexDestroy(thr, pc, (uptr)m);
1147 MutexRepair(thr, pc, (uptr)m);
1149 MutexLock(thr, pc, (uptr)m, /*rec=*/1, /*try_lock=*/true);
1158 MutexLock(thr, pc, (uptr)m);
1169 MutexCreate(thr, pc, (uptr)m, false, false, false);
1178 MutexDestroy(thr, pc, (uptr)m);
1187 MutexLock(thr, pc, (uptr)m);
1196 MutexLock(thr, pc, (uptr)m, /*rec=*/1, /*try_lock=*/true);
1203 MutexUnlock(thr, pc, (uptr)m);
1213 MutexCreate(thr, pc, (uptr)m, true, false, false);
1222 MutexDestroy(thr, pc, (uptr)m);
1231 MutexReadLock(thr, pc, (uptr)m);
1240 MutexReadLock(thr, pc, (uptr)m, /*try_lock=*/true);
1250 MutexReadLock(thr, pc, (uptr)m);
1260 MutexLock(thr, pc, (uptr)m);
1269 MutexLock(thr, pc, (uptr)m, /*rec=*/1, /*try_lock=*/true);
1279 MutexLock(thr, pc, (uptr)m);
1287 MutexReadOrWriteUnlock(thr, pc, (uptr)m);
1295 MemoryWrite(thr, pc, (uptr)b, kSizeLog1);
1302 MemoryWrite(thr, pc, (uptr)b, kSizeLog1);
1309 Release(thr, pc, (uptr)b);
1310 MemoryRead(thr, pc, (uptr)b, kSizeLog1);
1312 MemoryRead(thr, pc, (uptr)b, kSizeLog1);
1314 Acquire(thr, pc, (uptr)b);
1333 if (!thr->in_ignored_lib)
1334 Release(thr, pc, (uptr)o);
1341 if (!thr->in_ignored_lib)
1342 Acquire(thr, pc, (uptr)o);
1351 FdAccess(thr, pc, fd);
1363 FdAccess(thr, pc, fd);
1368 FdAccess(thr, pc, fd);
1377 FdAccess(thr, pc, fd);
1389 FdAccess(thr, pc, fd);
1399 READ_STRING(thr, pc, name, 0);
1402 FdFileCreate(thr, pc, fd);
1409 READ_STRING(thr, pc, name, 0);
1412 FdFileCreate(thr, pc, fd);
1422 READ_STRING(thr, pc, name, 0);
1425 FdFileCreate(thr, pc, fd);
1432 READ_STRING(thr, pc, name, 0);
1435 FdFileCreate(thr, pc, fd);
1447 FdDup(thr, pc, oldfd, newfd, true);
1455 FdDup(thr, pc, oldfd, newfd2, false);
1464 FdDup(thr, pc, oldfd, newfd2, false);
1474 FdEventCreate(thr, pc, fd);
1486 FdClose(thr, pc, fd);
1489 FdSignalCreate(thr, pc, fd);
1502 FdInotifyCreate(thr, pc, fd);
1515 FdInotifyCreate(thr, pc, fd);
1527 FdSocketCreate(thr, pc, fd);
1535 FdPipeCreate(thr, pc, fd[0], fd[1]);
1541 FdSocketConnecting(thr, pc, fd);
1544 FdSocketConnect(thr, pc, fd);
1552 FdAccess(thr, pc, fd);
1560 FdAccess(thr, pc, fd);
1567 FdClose(thr, pc, fd);
1575 FdClose(thr, pc, fd);
1591 FdClose(thr, pc, fds[i]);
1604 FdPipeCreate(thr, pc, pipefd[0], pipefd[1]);
1613 FdPipeCreate(thr, pc, pipefd[0], pipefd[1]);
1620 Release(thr, pc, File2addr(path));
1631 FdFileCreate(thr, pc, fd);
1643 FdFileCreate(thr, pc, fd);
1656 MemoryAccessRange(thr, pc, (uptr)ptr, size * nmemb, true);
1665 MemoryAccessRange(thr, pc, (uptr)p, size * nmemb, false);
1685 MemoryAccessRange(thr, pc, (uptr)s, internal_strlen(s), false);
1691 Release(thr, pc, Dir2addr(path));
1700 FdClose(thr, pc, fd);
1710 FdPollCreate(thr, pc, fd);
1718 FdPollCreate(thr, pc, fd);
1725 FdAccess(thr, pc, epfd);
1727 FdAccess(thr, pc, fd);
1729 FdRelease(thr, pc, epfd);
1737 FdAccess(thr, pc, epfd);
1740 FdAcquire(thr, pc, epfd);
1748 FdAccess(thr, pc, epfd);
1751 FdAcquire(thr, pc, epfd);
1767 static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
1770 Acquire(thr, 0, (uptr)&sigactions[sig]);
1775 int ignore_reads_and_writes = thr->ignore_reads_and_writes;
1776 int ignore_interceptors = thr->ignore_interceptors;
1777 int ignore_sync = thr->ignore_sync;
1779 thr->ignore_reads_and_writes = 0;
1780 thr->fast_state.ClearIgnoreBit();
1781 thr->ignore_interceptors = 0;
1782 thr->ignore_sync = 0;
1800 thr->ignore_reads_and_writes = ignore_reads_and_writes;
1802 thr->fast_state.SetIgnoreBit();
1803 thr->ignore_interceptors = ignore_interceptors;
1804 thr->ignore_sync = ignore_sync;
1817 ObtainCurrentStack(thr, StackTrace::GetNextInstructionPc(pc), &stack);
1822 OutputReport(thr, rep);
1828 void ProcessPendingSignals(ThreadState *thr) {
1829 ThreadSignalContext *sctx = SigCtx(thr);
1834 atomic_fetch_add(&thr->in_signal_handler, 1, memory_order_relaxed);
1841 CallUserSignalHandler(thr, false, true, signal->sigaction, sig,
1846 atomic_fetch_add(&thr->in_signal_handler, -1, memory_order_relaxed);
1860 ThreadState *thr = cur_thread();
1861 ThreadSignalContext *sctx = SigCtx(thr);
1873 atomic_fetch_add(&thr->in_signal_handler, 1, memory_order_relaxed);
1876 CallUserSignalHandler(thr, sync, true, sigact, sig, info, ctx);
1885 CallUserSignalHandler(thr, sync, acq, sigact, sig, info, ctx);
1887 atomic_fetch_add(&thr->in_signal_handler, -1, memory_order_relaxed);
1944 ReleaseStore(thr, pc, (uptr)&sigactions[sig]);
1968 ThreadSignalContext *sctx = SigCtx(thr);
1980 ThreadSignalContext *sctx = SigCtx(thr);
1996 ThreadSignalContext *sctx = SigCtx(thr);
2022 ThreadIgnoreBegin(thr, pc);
2024 ThreadIgnoreEnd(thr, pc);
2032 ForkBefore(thr, pc);
2042 ForkChildAfter(thr, pc);
2043 FdOnFork(thr, pc);
2046 ForkParentAfter(thr, pc);
2049 ForkParentAfter(thr, pc);
2075 ThreadState *thr;
2094 MemoryResetRange(cbdata->thr, cbdata->pc, (uptr)info->dlpi_name,
2100 MemoryResetRange(cbdata->thr, cbdata->pc, (uptr)info->dlpi_name,
2108 cbdata.thr = thr;
2117 static int OnExit(ThreadState *thr) {
2118 int status = Finalize(thr);
2124 ThreadState *thr;
2130 static void HandleRecvmsg(ThreadState *thr, uptr pc,
2135 FdEventCreate(thr, pc, fds[i]);
2165 MemoryAccessRange(((TsanInterceptorContext *)ctx)->thr, \
2170 MemoryAccessRange(((TsanInterceptorContext *) ctx)->thr, \
2176 TsanInterceptorContext _ctx = {thr, caller_pc, pc}; \
2182 TsanInterceptorContext _ctx = {thr, caller_pc, pc}; \
2187 Acquire(thr, pc, File2addr(path)); \
2190 if (fd >= 0) FdFileCreate(thr, pc, fd); \
2196 if (fd >= 0) FdClose(thr, pc, fd); \
2206 Acquire(((TsanInterceptorContext *) ctx)->thr, pc, u)
2209 Release(((TsanInterceptorContext *) ctx)->thr, pc, u)
2212 Acquire(((TsanInterceptorContext *) ctx)->thr, pc, Dir2addr(path))
2215 FdAcquire(((TsanInterceptorContext *) ctx)->thr, pc, fd)
2218 FdRelease(((TsanInterceptorContext *) ctx)->thr, pc, fd)
2221 FdAccess(((TsanInterceptorContext *) ctx)->thr, pc, fd)
2224 FdSocketAccept(((TsanInterceptorContext *) ctx)->thr, pc, fd, newfd)
2227 ThreadSetName(((TsanInterceptorContext *) ctx)->thr, name)
2235 OnExit(((TsanInterceptorContext *) ctx)->thr)
2238 MutexLock(((TsanInterceptorContext *)ctx)->thr, \
2242 MutexUnlock(((TsanInterceptorContext *)ctx)->thr, \
2246 MutexRepair(((TsanInterceptorContext *)ctx)->thr, \
2250 MutexInvalidAccess(((TsanInterceptorContext *)ctx)->thr, \
2255 HandleRecvmsg(((TsanInterceptorContext *)ctx)->thr, \
2276 ThreadState *thr = cur_thread(); \
2277 if (thr->ignore_interceptors) \
2279 ScopedSyscall scoped_syscall(thr) \
2283 ThreadState *thr;
2285 explicit ScopedSyscall(ThreadState *thr)
2286 : thr(thr) {
2287 Initialize(thr);
2291 ProcessPendingSignals(thr);
2298 MemoryAccessRange(thr, pc, p, s, write);
2303 Acquire(thr, pc, addr);
2310 Release(thr, pc, addr);
2315 FdClose(thr, pc, fd);
2320 FdAcquire(thr, pc, fd);
2327 FdRelease(thr, pc, fd);
2332 ForkBefore(thr, pc);
2339 ForkChildAfter(thr, pc);
2340 FdOnFork(thr, pc);
2343 ForkParentAfter(thr, pc);
2346 ForkParentAfter(thr, pc);
2402 ThreadState *thr = cur_thread();
2403 if (!thr)
2405 DTLS::DTV *dtv = DTLS_on_tls_get_addr(arg, res, thr->tls_addr, thr->tls_size);
2409 MemoryResetRange(thr, 0, dtv->beg, dtv->size);
2417 ThreadState *thr = cur_thread();
2418 int status = Finalize(thr);
