/* * Copyright (c) 1994 by Xerox Corporation. All rights reserved. * Copyright (c) 1996 by Silicon Graphics. All rights reserved. * Copyright (c) 1998 by Fergus Henderson. All rights reserved. * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. * All rights reserved. * Copyright (c) 2008-2022 Ivan Maidanski * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. * * Permission is hereby granted to use or copy this program * for any purpose, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ #include "private/pthread_support.h" #ifdef PTHREAD_STOP_WORLD_IMPL #ifdef NACL # include # include #else # include # include # include # include /* for nanosleep() */ # include #endif /* !NACL */ GC_INLINE void GC_usleep(unsigned us) { # if defined(LINT2) || defined(THREAD_SANITIZER) /* Workaround "waiting while holding a lock" static analyzer warning. */ /* Workaround a rare hang in usleep() trying to acquire TSan Lock. */ while (us-- > 0) sched_yield(); /* pretending it takes 1us */ # elif defined(CPPCHECK) /* || _POSIX_C_SOURCE >= 199309L */ struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = us * 1000; /* This requires _POSIX_TIMERS feature. */ (void)nanosleep(&ts, NULL); # else usleep(us); # endif } #ifdef NACL STATIC int GC_nacl_num_gc_threads = 0; STATIC volatile int GC_nacl_park_threads_now = 0; STATIC volatile pthread_t GC_nacl_thread_parker = -1; STATIC __thread int GC_nacl_thread_idx = -1; STATIC __thread GC_thread GC_nacl_gc_thread_self = NULL; /* TODO: Use GC_get_tlfs() instead. */ volatile int GC_nacl_thread_parked[MAX_NACL_GC_THREADS]; int GC_nacl_thread_used[MAX_NACL_GC_THREADS]; #else #if (!defined(AO_HAVE_load_acquire) || !defined(AO_HAVE_store_release)) \ && !defined(CPPCHECK) # error AO_load_acquire and/or AO_store_release are missing; # error please define AO_REQUIRE_CAS manually #endif /* It's safe to call original pthread_sigmask() here. */ #undef pthread_sigmask #ifdef DEBUG_THREADS # ifndef NSIG # ifdef CPPCHECK # define NSIG 32 # elif defined(MAXSIG) # define NSIG (MAXSIG+1) # elif defined(_NSIG) # define NSIG _NSIG # elif defined(__SIGRTMAX) # define NSIG (__SIGRTMAX+1) # else # error define NSIG # endif # endif /* !NSIG */ void GC_print_sig_mask(void) { sigset_t blocked; int i; if (pthread_sigmask(SIG_BLOCK, NULL, &blocked) != 0) ABORT("pthread_sigmask failed"); for (i = 1; i < NSIG; i++) { if (sigismember(&blocked, i)) GC_printf("Signal blocked: %d\n", i); } } #endif /* DEBUG_THREADS */ /* Remove the signals that we want to allow in thread stopping */ /* handler from a set. */ STATIC void GC_remove_allowed_signals(sigset_t *set) { if (sigdelset(set, SIGINT) != 0 || sigdelset(set, SIGQUIT) != 0 || sigdelset(set, SIGABRT) != 0 || sigdelset(set, SIGTERM) != 0) { ABORT("sigdelset failed"); } # ifdef MPROTECT_VDB /* Handlers write to the thread structure, which is in the heap, */ /* and hence can trigger a protection fault. */ if (sigdelset(set, SIGSEGV) != 0 # ifdef HAVE_SIGBUS || sigdelset(set, SIGBUS) != 0 # endif ) { ABORT("sigdelset failed"); } # endif } static sigset_t suspend_handler_mask; #define THREAD_RESTARTED 0x1 STATIC volatile AO_t GC_stop_count; /* Incremented (to the nearest even value) at */ /* the beginning of GC_stop_world() (or when */ /* a thread is requested to be suspended by */ /* GC_suspend_thread) and once more (to an odd */ /* value) at the beginning of GC_start_world(). */ /* The lowest bit is THREAD_RESTARTED one */ /* which, if set, means it is safe for threads */ /* to restart, i.e. they will see another */ /* suspend signal before they are expected to */ /* stop (unless they have stopped voluntarily). */ STATIC GC_bool GC_retry_signals = FALSE; /* * We use signals to stop threads during GC. * * Suspended threads wait in signal handler for SIG_THR_RESTART. * That's more portable than semaphores or condition variables. * (We do use sem_post from a signal handler, but that should be portable.) * * The thread suspension signal SIG_SUSPEND is now defined in gc_priv.h. * Note that we can't just stop a thread; we need it to save its stack * pointer(s) and acknowledge. */ #ifndef SIG_THR_RESTART # ifdef SUSPEND_HANDLER_NO_CONTEXT /* Reuse the suspend signal. */ # define SIG_THR_RESTART SIG_SUSPEND # elif defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS) \ || defined(GC_NETBSD_THREADS) || defined(GC_USESIGRT_SIGNALS) # if defined(_SIGRTMIN) && !defined(CPPCHECK) # define SIG_THR_RESTART _SIGRTMIN + 5 # else # define SIG_THR_RESTART SIGRTMIN + 5 # endif # elif defined(GC_FREEBSD_THREADS) && defined(__GLIBC__) # define SIG_THR_RESTART (32+5) # elif defined(GC_FREEBSD_THREADS) || defined(HURD) || defined(RTEMS) # define SIG_THR_RESTART SIGUSR2 # else # define SIG_THR_RESTART SIGXCPU # endif #endif /* !SIG_THR_RESTART */ #define SIGNAL_UNSET (-1) /* Since SIG_SUSPEND and/or SIG_THR_RESTART could represent */ /* a non-constant expression (e.g., in case of SIGRTMIN), */ /* actual signal numbers are determined by GC_stop_init() */ /* unless manually set (before GC initialization). */ /* Might be set to the same signal number. */ STATIC int GC_sig_suspend = SIGNAL_UNSET; STATIC int GC_sig_thr_restart = SIGNAL_UNSET; GC_API void GC_CALL GC_set_suspend_signal(int sig) { if (GC_is_initialized) return; GC_sig_suspend = sig; } GC_API void GC_CALL GC_set_thr_restart_signal(int sig) { if (GC_is_initialized) return; GC_sig_thr_restart = sig; } GC_API int GC_CALL GC_get_suspend_signal(void) { return GC_sig_suspend != SIGNAL_UNSET ? GC_sig_suspend : SIG_SUSPEND; } GC_API int GC_CALL GC_get_thr_restart_signal(void) { return GC_sig_thr_restart != SIGNAL_UNSET ? GC_sig_thr_restart : SIG_THR_RESTART; } #if defined(GC_EXPLICIT_SIGNALS_UNBLOCK) \ || !defined(NO_SIGNALS_UNBLOCK_IN_MAIN) /* Some targets (e.g., Solaris) might require this to be called when */ /* doing thread registering from the thread destructor. */ GC_INNER void GC_unblock_gc_signals(void) { sigset_t set; sigemptyset(&set); GC_ASSERT(GC_sig_suspend != SIGNAL_UNSET); GC_ASSERT(GC_sig_thr_restart != SIGNAL_UNSET); sigaddset(&set, GC_sig_suspend); sigaddset(&set, GC_sig_thr_restart); if (pthread_sigmask(SIG_UNBLOCK, &set, NULL) != 0) ABORT("pthread_sigmask failed"); } #endif /* GC_EXPLICIT_SIGNALS_UNBLOCK */ #ifdef BASE_ATOMIC_OPS_EMULATED /* The AO primitives emulated with locks cannot be used inside signal */ /* handlers as this could cause a deadlock or a double lock. */ /* The following "async" macro definitions are correct only for */ /* an uniprocessor case and are provided for a test purpose. */ # define ao_load_acquire_async(p) (*(p)) # define ao_load_async(p) ao_load_acquire_async(p) # define ao_store_release_async(p, v) (void)(*(p) = (v)) # define ao_store_async(p, v) ao_store_release_async(p, v) #else # define ao_load_acquire_async(p) AO_load_acquire(p) # define ao_load_async(p) AO_load(p) # define ao_store_release_async(p, v) AO_store_release(p, v) # define ao_store_async(p, v) AO_store(p, v) #endif /* !BASE_ATOMIC_OPS_EMULATED */ STATIC sem_t GC_suspend_ack_sem; /* also used to acknowledge restart */ STATIC void GC_suspend_handler_inner(ptr_t dummy, void *context); #ifdef SUSPEND_HANDLER_NO_CONTEXT STATIC void GC_suspend_handler(int sig) #else STATIC void GC_suspend_sigaction(int sig, siginfo_t *info, void *context) #endif { int old_errno = errno; if (sig != GC_sig_suspend) { # if defined(GC_FREEBSD_THREADS) /* Workaround "deferred signal handling" bug in FreeBSD 9.2. */ if (0 == sig) return; # endif ABORT("Bad signal in suspend_handler"); } # ifdef SUSPEND_HANDLER_NO_CONTEXT /* A quick check if the signal is called to restart the world. */ if ((ao_load_async(&GC_stop_count) & THREAD_RESTARTED) != 0) return; GC_with_callee_saves_pushed(GC_suspend_handler_inner, NULL); # else UNUSED_ARG(info); /* We believe that in this case the full context is already */ /* in the signal handler frame. */ GC_suspend_handler_inner(NULL, context); # endif errno = old_errno; } /* The lookup here is safe, since this is done on behalf */ /* of a thread which holds the allocation lock in order */ /* to stop the world. Thus concurrent modification of the */ /* data structure is impossible. Unfortunately, we have to */ /* instruct TSan that the lookup is safe. */ #ifdef THREAD_SANITIZER /* Almost same as GC_self_thread_inner() except for the */ /* no-sanitize attribute added and the result is never NULL. */ GC_ATTR_NO_SANITIZE_THREAD static GC_thread GC_lookup_self_thread_async(void) { thread_id_t self_id = thread_id_self(); GC_thread p = GC_threads[THREAD_TABLE_INDEX(self_id)]; for (;; p = p -> tm.next) { if (THREAD_EQUAL(p -> id, self_id)) break; } return p; } #else # define GC_lookup_self_thread_async() GC_self_thread_inner() #endif GC_INLINE void GC_store_stack_ptr(GC_stack_context_t crtn) { /* There is no data race between the suspend handler (storing */ /* stack_ptr) and GC_push_all_stacks (fetching stack_ptr) because */ /* GC_push_all_stacks is executed after GC_stop_world exits and the */ /* latter runs sem_wait repeatedly waiting for all the suspended */ /* threads to call sem_post. Nonetheless, stack_ptr is stored (here) */ /* and fetched (by GC_push_all_stacks) using the atomic primitives to */ /* avoid the related TSan warning. */ # ifdef SPARC ao_store_async((volatile AO_t *)&(crtn -> stack_ptr), (AO_t)GC_save_regs_in_stack()); /* TODO: regs saving already done by GC_with_callee_saves_pushed */ # else # ifdef IA64 crtn -> backing_store_ptr = GC_save_regs_in_stack(); # endif ao_store_async((volatile AO_t *)&(crtn -> stack_ptr), (AO_t)GC_approx_sp()); # endif } STATIC void GC_suspend_handler_inner(ptr_t dummy, void *context) { GC_thread me; GC_stack_context_t crtn; # ifdef E2K ptr_t bs_lo; size_t stack_size; # endif IF_CANCEL(int cancel_state;) # ifdef GC_ENABLE_SUSPEND_THREAD word suspend_cnt; # endif AO_t my_stop_count = ao_load_acquire_async(&GC_stop_count); /* After the barrier, this thread should see */ /* the actual content of GC_threads. */ UNUSED_ARG(dummy); UNUSED_ARG(context); if ((my_stop_count & THREAD_RESTARTED) != 0) return; /* Restarting the world. */ DISABLE_CANCEL(cancel_state); /* pthread_setcancelstate is not defined to be async-signal-safe. */ /* But the glibc version appears to be in the absence of */ /* asynchronous cancellation. And since this signal handler */ /* to block on sigsuspend, which is both async-signal-safe */ /* and a cancellation point, there seems to be no obvious way */ /* out of it. In fact, it looks to me like an async-signal-safe */ /* cancellation point is inherently a problem, unless there is */ /* some way to disable cancellation in the handler. */ # ifdef DEBUG_THREADS GC_log_printf("Suspending %p\n", (void *)pthread_self()); # endif me = GC_lookup_self_thread_async(); if ((me -> last_stop_count & ~(word)THREAD_RESTARTED) == my_stop_count) { /* Duplicate signal. OK if we are retrying. */ if (!GC_retry_signals) { WARN("Duplicate suspend signal in thread %p\n", pthread_self()); } RESTORE_CANCEL(cancel_state); return; } crtn = me -> crtn; GC_store_stack_ptr(crtn); # ifdef E2K GC_ASSERT(NULL == crtn -> backing_store_end); GET_PROCEDURE_STACK_LOCAL(&bs_lo, &stack_size); crtn -> backing_store_end = bs_lo; crtn -> backing_store_ptr = bs_lo + stack_size; # endif # ifdef GC_ENABLE_SUSPEND_THREAD suspend_cnt = (word)ao_load_async(&(me -> ext_suspend_cnt)); # endif /* Tell the thread that wants to stop the world that this */ /* thread has been stopped. Note that sem_post() is */ /* the only async-signal-safe primitive in LinuxThreads. */ sem_post(&GC_suspend_ack_sem); ao_store_release_async(&(me -> last_stop_count), my_stop_count); /* Wait until that thread tells us to restart by sending */ /* this thread a GC_sig_thr_restart signal (should be masked */ /* at this point thus there is no race). */ /* We do not continue until we receive that signal, */ /* but we do not take that as authoritative. (We may be */ /* accidentally restarted by one of the user signals we */ /* don't block.) After we receive the signal, we use a */ /* primitive and expensive mechanism to wait until it's */ /* really safe to proceed. Under normal circumstances, */ /* this code should not be executed. */ do { sigsuspend(&suspend_handler_mask); /* Iterate while not restarting the world or thread is suspended. */ } while (ao_load_acquire_async(&GC_stop_count) == my_stop_count # ifdef GC_ENABLE_SUSPEND_THREAD || ((suspend_cnt & 1) != 0 && (word)ao_load_async(&(me -> ext_suspend_cnt)) == suspend_cnt) # endif ); # ifdef DEBUG_THREADS GC_log_printf("Resuming %p\n", (void *)pthread_self()); # endif # ifdef E2K GC_ASSERT(crtn -> backing_store_end == bs_lo); FREE_PROCEDURE_STACK_LOCAL(bs_lo, stack_size); crtn -> backing_store_ptr = NULL; crtn -> backing_store_end = NULL; # endif # ifndef GC_NETBSD_THREADS_WORKAROUND if (GC_retry_signals || GC_sig_suspend == GC_sig_thr_restart) # endif { /* If the RESTART signal loss is possible (though it should be */ /* less likely than losing the SUSPEND signal as we do not do */ /* much between the first sem_post and sigsuspend calls), more */ /* handshaking is provided to work around it. */ sem_post(&GC_suspend_ack_sem); /* Set the flag that the thread has been restarted. */ if (GC_retry_signals) ao_store_release_async(&(me -> last_stop_count), my_stop_count | THREAD_RESTARTED); } RESTORE_CANCEL(cancel_state); } static void suspend_restart_barrier(int n_live_threads) { int i; for (i = 0; i < n_live_threads; i++) { while (0 != sem_wait(&GC_suspend_ack_sem)) { /* On Linux, sem_wait is documented to always return zero. */ /* But the documentation appears to be incorrect. */ /* EINTR seems to happen with some versions of gdb. */ if (errno != EINTR) ABORT("sem_wait failed"); } } # ifdef GC_ASSERTIONS sem_getvalue(&GC_suspend_ack_sem, &i); GC_ASSERT(0 == i); # endif } # define WAIT_UNIT 3000 /* us */ static int resend_lost_signals(int n_live_threads, int (*suspend_restart_all)(void)) { # define RETRY_INTERVAL 100000 /* us */ # define RESEND_SIGNALS_LIMIT 150 if (n_live_threads > 0) { unsigned long wait_usecs = 0; /* Total wait since retry. */ int retry = 0; int prev_sent = 0; for (;;) { int ack_count; sem_getvalue(&GC_suspend_ack_sem, &ack_count); if (ack_count == n_live_threads) break; if (wait_usecs > RETRY_INTERVAL) { int newly_sent = suspend_restart_all(); if (newly_sent != prev_sent) { retry = 0; /* restart the counter */ } else if (++retry >= RESEND_SIGNALS_LIMIT) /* no progress */ ABORT_ARG1("Signals delivery fails constantly", " at GC #%lu", (unsigned long)GC_gc_no); GC_COND_LOG_PRINTF("Resent %d signals after timeout, retry: %d\n", newly_sent, retry); sem_getvalue(&GC_suspend_ack_sem, &ack_count); if (newly_sent < n_live_threads - ack_count) { WARN("Lost some threads while stopping or starting world?!\n", 0); n_live_threads = ack_count + newly_sent; } prev_sent = newly_sent; wait_usecs = 0; } GC_usleep(WAIT_UNIT); wait_usecs += WAIT_UNIT; } } return n_live_threads; } #ifdef HAVE_CLOCK_GETTIME # define TS_NSEC_ADD(ts, ns) \ (ts.tv_nsec += (ns), \ (void)(ts.tv_nsec >= 1000000L*1000 ? \ (ts.tv_nsec -= 1000000L*1000, ts.tv_sec++, 0) : 0)) #endif static void resend_lost_signals_retry(int n_live_threads, int (*suspend_restart_all)(void)) { # if defined(HAVE_CLOCK_GETTIME) && !defined(DONT_TIMEDWAIT_ACK_SEM) # define TIMEOUT_BEFORE_RESEND 10000 /* us */ struct timespec ts; if (n_live_threads > 0 && clock_gettime(CLOCK_REALTIME, &ts) == 0) { int i; TS_NSEC_ADD(ts, TIMEOUT_BEFORE_RESEND * 1000); /* First, try to wait for the semaphore with some timeout. */ /* On failure, fallback to WAIT_UNIT pause and resend of the signal. */ for (i = 0; i < n_live_threads; i++) { if (0 != sem_timedwait(&GC_suspend_ack_sem, &ts)) break; /* Wait timed out or any other error. */ } /* Update the count of threads to wait the ack from. */ n_live_threads -= i; } # endif n_live_threads = resend_lost_signals(n_live_threads, suspend_restart_all); suspend_restart_barrier(n_live_threads); } STATIC void GC_restart_handler(int sig) { # if defined(DEBUG_THREADS) int old_errno = errno; /* Preserve errno value. */ # endif if (sig != GC_sig_thr_restart) ABORT("Bad signal in restart handler"); /* Note: even if we do not do anything useful here, it would still */ /* be necessary to have a signal handler, rather than ignoring the */ /* signals, otherwise the signals will not be delivered at all, */ /* and will thus not interrupt the sigsuspend() above. */ # ifdef DEBUG_THREADS GC_log_printf("In GC_restart_handler for %p\n", (void *)pthread_self()); errno = old_errno; # endif } # ifdef USE_TKILL_ON_ANDROID EXTERN_C_BEGIN extern int tkill(pid_t tid, int sig); /* from sys/linux-unistd.h */ EXTERN_C_END # define THREAD_SYSTEM_ID(t) (t)->kernel_id # else # define THREAD_SYSTEM_ID(t) (t)->id # endif # ifndef RETRY_TKILL_EAGAIN_LIMIT # define RETRY_TKILL_EAGAIN_LIMIT 16 # endif static int raise_signal(GC_thread p, int sig) { int res; # ifdef RETRY_TKILL_ON_EAGAIN int retry; # endif # if defined(SIMULATE_LOST_SIGNALS) && !defined(GC_ENABLE_SUSPEND_THREAD) # ifndef LOST_SIGNALS_RATIO # define LOST_SIGNALS_RATIO 25 # endif static int signal_cnt; /* race is OK, it is for test purpose only */ if (GC_retry_signals && (++signal_cnt) % LOST_SIGNALS_RATIO == 0) return 0; /* simulate the signal is sent but lost */ # endif # ifdef RETRY_TKILL_ON_EAGAIN for (retry = 0; ; retry++) # endif { # ifdef USE_TKILL_ON_ANDROID int old_errno = errno; res = tkill(THREAD_SYSTEM_ID(p), sig); if (res < 0) { res = errno; errno = old_errno; } # else res = pthread_kill(THREAD_SYSTEM_ID(p), sig); # endif # ifdef RETRY_TKILL_ON_EAGAIN if (res != EAGAIN || retry >= RETRY_TKILL_EAGAIN_LIMIT) break; /* A temporal overflow of the real-time signal queue. */ GC_usleep(WAIT_UNIT); # endif } return res; } # ifdef GC_ENABLE_SUSPEND_THREAD # include # include "gc/javaxfc.h" /* to get the prototypes as extern "C" */ STATIC void GC_brief_async_signal_safe_sleep(void) { struct timeval tv; tv.tv_sec = 0; # if defined(GC_TIME_LIMIT) && !defined(CPPCHECK) tv.tv_usec = 1000 * GC_TIME_LIMIT / 2; # else tv.tv_usec = 1000 * 15 / 2; # endif (void)select(0, 0, 0, 0, &tv); } GC_INNER void GC_suspend_self_inner(GC_thread me, word suspend_cnt) { IF_CANCEL(int cancel_state;) GC_ASSERT((suspend_cnt & 1) != 0); DISABLE_CANCEL(cancel_state); # ifdef DEBUG_THREADS GC_log_printf("Suspend self: %p\n", (void *)(me -> id)); # endif while ((word)ao_load_acquire_async(&(me -> ext_suspend_cnt)) == suspend_cnt) { /* TODO: Use sigsuspend() even for self-suspended threads. */ GC_brief_async_signal_safe_sleep(); } # ifdef DEBUG_THREADS GC_log_printf("Resume self: %p\n", (void *)(me -> id)); # endif RESTORE_CANCEL(cancel_state); } GC_API void GC_CALL GC_suspend_thread(GC_SUSPEND_THREAD_ID thread) { GC_thread t; AO_t next_stop_count; word suspend_cnt; IF_CANCEL(int cancel_state;) LOCK(); t = GC_lookup_by_pthread((pthread_t)thread); if (NULL == t) { UNLOCK(); return; } suspend_cnt = (word)(t -> ext_suspend_cnt); if ((suspend_cnt & 1) != 0) /* already suspended? */ { GC_ASSERT(!THREAD_EQUAL((pthread_t)thread, pthread_self())); UNLOCK(); return; } if ((t -> flags & (FINISHED | DO_BLOCKING)) != 0) { t -> ext_suspend_cnt = (AO_t)(suspend_cnt | 1); /* suspend */ /* Terminated but not joined yet, or in do-blocking state. */ UNLOCK(); return; } if (THREAD_EQUAL((pthread_t)thread, pthread_self())) { t -> ext_suspend_cnt = (AO_t)(suspend_cnt | 1); GC_with_callee_saves_pushed(GC_suspend_self_blocked, (ptr_t)t); UNLOCK(); return; } DISABLE_CANCEL(cancel_state); /* GC_suspend_thread is not a cancellation point. */ # ifdef PARALLEL_MARK /* Ensure we do not suspend a thread while it is rebuilding */ /* a free list, otherwise such a dead-lock is possible: */ /* thread 1 is blocked in GC_wait_for_reclaim holding */ /* the allocation lock, thread 2 is suspended in */ /* GC_reclaim_generic invoked from GC_generic_malloc_many */ /* (with GC_fl_builder_count > 0), and thread 3 is blocked */ /* acquiring the allocation lock in GC_resume_thread. */ if (GC_parallel) GC_wait_for_reclaim(); # endif if (GC_manual_vdb) { /* See the relevant comment in GC_stop_world. */ GC_acquire_dirty_lock(); } /* Else do not acquire the lock as the write fault handler might */ /* be trying to acquire this lock too, and the suspend handler */ /* execution is deferred until the write fault handler completes. */ next_stop_count = GC_stop_count + THREAD_RESTARTED; GC_ASSERT((next_stop_count & THREAD_RESTARTED) == 0); AO_store(&GC_stop_count, next_stop_count); /* Set the flag making the change visible to the signal handler. */ AO_store_release(&(t -> ext_suspend_cnt), (AO_t)(suspend_cnt | 1)); /* TODO: Support GC_retry_signals (not needed for TSan) */ switch (raise_signal(t, GC_sig_suspend)) { /* ESRCH cannot happen as terminated threads are handled above. */ case 0: break; default: ABORT("pthread_kill failed"); } /* Wait for the thread to complete threads table lookup and */ /* stack_ptr assignment. */ GC_ASSERT(GC_thr_initialized); suspend_restart_barrier(1); if (GC_manual_vdb) GC_release_dirty_lock(); AO_store(&GC_stop_count, next_stop_count | THREAD_RESTARTED); RESTORE_CANCEL(cancel_state); UNLOCK(); } GC_API void GC_CALL GC_resume_thread(GC_SUSPEND_THREAD_ID thread) { GC_thread t; LOCK(); t = GC_lookup_by_pthread((pthread_t)thread); if (t != NULL) { word suspend_cnt = (word)(t -> ext_suspend_cnt); if ((suspend_cnt & 1) != 0) /* is suspended? */ { GC_ASSERT((GC_stop_count & THREAD_RESTARTED) != 0); /* Mark the thread as not suspended - it will be resumed shortly. */ AO_store(&(t -> ext_suspend_cnt), (AO_t)(suspend_cnt + 1)); if ((t -> flags & (FINISHED | DO_BLOCKING)) == 0) { int result = raise_signal(t, GC_sig_thr_restart); /* TODO: Support signal resending on GC_retry_signals */ if (result != 0) ABORT_ARG1("pthread_kill failed in GC_resume_thread", ": errcode= %d", result); # ifndef GC_NETBSD_THREADS_WORKAROUND if (GC_retry_signals || GC_sig_suspend == GC_sig_thr_restart) # endif { IF_CANCEL(int cancel_state;) DISABLE_CANCEL(cancel_state); suspend_restart_barrier(1); RESTORE_CANCEL(cancel_state); } } } } UNLOCK(); } GC_API int GC_CALL GC_is_thread_suspended(GC_SUSPEND_THREAD_ID thread) { GC_thread t; int is_suspended = 0; LOCK(); t = GC_lookup_by_pthread((pthread_t)thread); if (t != NULL && (t -> ext_suspend_cnt & 1) != 0) is_suspended = (int)TRUE; UNLOCK(); return is_suspended; } # endif /* GC_ENABLE_SUSPEND_THREAD */ # undef ao_load_acquire_async # undef ao_load_async # undef ao_store_async # undef ao_store_release_async #endif /* !NACL */ /* Should do exactly the right thing if the world is stopped; should */ /* not fail if it is not. */ GC_INNER void GC_push_all_stacks(void) { GC_bool found_me = FALSE; size_t nthreads = 0; int i; GC_thread p; ptr_t lo, hi; # if defined(E2K) || defined(IA64) /* We also need to scan the register backing store. */ ptr_t bs_lo, bs_hi; # endif struct GC_traced_stack_sect_s *traced_stack_sect; pthread_t self = pthread_self(); word total_size = 0; GC_ASSERT(I_HOLD_LOCK()); GC_ASSERT(GC_thr_initialized); # ifdef DEBUG_THREADS GC_log_printf("Pushing stacks from thread %p\n", (void *)self); # endif for (i = 0; i < THREAD_TABLE_SZ; i++) { for (p = GC_threads[i]; p != NULL; p = p -> tm.next) { # if defined(E2K) || defined(IA64) GC_bool is_self = FALSE; # endif GC_stack_context_t crtn = p -> crtn; GC_ASSERT(THREAD_TABLE_INDEX(p -> id) == i); if (KNOWN_FINISHED(p)) continue; ++nthreads; traced_stack_sect = crtn -> traced_stack_sect; if (THREAD_EQUAL(p -> id, self)) { GC_ASSERT((p -> flags & DO_BLOCKING) == 0); # ifdef SPARC lo = GC_save_regs_in_stack(); # else lo = GC_approx_sp(); # ifdef IA64 bs_hi = GC_save_regs_in_stack(); # elif defined(E2K) GC_ASSERT(NULL == crtn -> backing_store_end); (void)GC_save_regs_in_stack(); { size_t stack_size; GET_PROCEDURE_STACK_LOCAL(&bs_lo, &stack_size); bs_hi = bs_lo + stack_size; } # endif # endif found_me = TRUE; # if defined(E2K) || defined(IA64) is_self = TRUE; # endif } else { lo = (ptr_t)AO_load((volatile AO_t *)&(crtn -> stack_ptr)); # ifdef IA64 bs_hi = crtn -> backing_store_ptr; # elif defined(E2K) bs_lo = crtn -> backing_store_end; bs_hi = crtn -> backing_store_ptr; # endif if (traced_stack_sect != NULL && traced_stack_sect -> saved_stack_ptr == lo) { /* If the thread has never been stopped since the recent */ /* GC_call_with_gc_active invocation then skip the top */ /* "stack section" as stack_ptr already points to. */ traced_stack_sect = traced_stack_sect -> prev; } } hi = crtn -> stack_end; # ifdef IA64 bs_lo = crtn -> backing_store_end; # endif # ifdef DEBUG_THREADS GC_log_printf("Stack for thread %p is [%p,%p)\n", (void *)p->id, (void *)lo, (void *)hi); # endif if (NULL == lo) ABORT("GC_push_all_stacks: sp not set!"); if (crtn -> altstack != NULL && (word)(crtn -> altstack) <= (word)lo && (word)lo <= (word)(crtn -> altstack) + crtn -> altstack_size) { hi = crtn -> altstack + crtn -> altstack_size; /* FIXME: Need to scan the normal stack too, but how ? */ /* FIXME: Assume stack grows down */ } GC_push_all_stack_sections(lo, hi, traced_stack_sect); # ifdef STACK_GROWS_UP total_size += lo - hi; # else total_size += hi - lo; /* lo <= hi */ # endif # ifdef NACL /* Push reg_storage as roots, this will cover the reg context. */ GC_push_all_stack((ptr_t)p -> reg_storage, (ptr_t)(p -> reg_storage + NACL_GC_REG_STORAGE_SIZE)); total_size += NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t); # endif # ifdef E2K if ((GC_stop_count & THREAD_RESTARTED) != 0 # ifdef GC_ENABLE_SUSPEND_THREAD && (p -> ext_suspend_cnt & 1) == 0 # endif && !is_self && (p -> flags & DO_BLOCKING) == 0) continue; /* procedure stack buffer has already been freed */ # endif # if defined(E2K) || defined(IA64) # ifdef DEBUG_THREADS GC_log_printf("Reg stack for thread %p is [%p,%p)\n", (void *)p->id, (void *)bs_lo, (void *)bs_hi); # endif GC_ASSERT(bs_lo != NULL && bs_hi != NULL); /* FIXME: This (if is_self) may add an unbounded number of */ /* entries, and hence overflow the mark stack, which is bad. */ GC_push_all_register_sections(bs_lo, bs_hi, is_self, traced_stack_sect); total_size += bs_hi - bs_lo; /* bs_lo <= bs_hi */ # endif # ifdef E2K if (is_self) FREE_PROCEDURE_STACK_LOCAL(bs_lo, (size_t)(bs_hi - bs_lo)); # endif } } GC_VERBOSE_LOG_PRINTF("Pushed %d thread stacks\n", (int)nthreads); if (!found_me && !GC_in_thread_creation) ABORT("Collecting from unknown thread"); GC_total_stacksize = total_size; } #ifdef DEBUG_THREADS /* There seems to be a very rare thread stopping problem. To help us */ /* debug that, we save the ids of the stopping thread. */ pthread_t GC_stopping_thread; int GC_stopping_pid = 0; #endif /* Suspend all threads that might still be running. Return the number */ /* of suspend signals that were sent. */ STATIC int GC_suspend_all(void) { int n_live_threads = 0; int i; # ifndef NACL GC_thread p; pthread_t self = pthread_self(); int result; GC_ASSERT((GC_stop_count & THREAD_RESTARTED) == 0); GC_ASSERT(I_HOLD_LOCK()); for (i = 0; i < THREAD_TABLE_SZ; i++) { for (p = GC_threads[i]; p != NULL; p = p -> tm.next) { if (!THREAD_EQUAL(p -> id, self)) { if ((p -> flags & (FINISHED | DO_BLOCKING)) != 0) continue; # ifdef GC_ENABLE_SUSPEND_THREAD if ((p -> ext_suspend_cnt & 1) != 0) continue; # endif if (AO_load(&(p -> last_stop_count)) == GC_stop_count) continue; /* matters only if GC_retry_signals */ n_live_threads++; # ifdef DEBUG_THREADS GC_log_printf("Sending suspend signal to %p\n", (void *)p->id); # endif /* The synchronization between GC_dirty (based on */ /* test-and-set) and the signal-based thread suspension */ /* is performed in GC_stop_world because */ /* GC_release_dirty_lock cannot be called before */ /* acknowledging the thread is really suspended. */ result = raise_signal(p, GC_sig_suspend); switch (result) { case ESRCH: /* Not really there anymore. Possible? */ n_live_threads--; break; case 0: if (GC_on_thread_event) GC_on_thread_event(GC_EVENT_THREAD_SUSPENDED, (void *)(word)THREAD_SYSTEM_ID(p)); /* Note: thread id might be truncated. */ break; default: ABORT_ARG1("pthread_kill failed at suspend", ": errcode= %d", result); } } } } # else /* NACL */ # ifndef NACL_PARK_WAIT_USEC # define NACL_PARK_WAIT_USEC 100 /* us */ # endif unsigned long num_sleeps = 0; GC_ASSERT(I_HOLD_LOCK()); # ifdef DEBUG_THREADS GC_log_printf("pthread_stop_world: number of threads: %d\n", GC_nacl_num_gc_threads - 1); # endif GC_nacl_thread_parker = pthread_self(); GC_nacl_park_threads_now = 1; if (GC_manual_vdb) GC_acquire_dirty_lock(); for (;;) { int num_threads_parked = 0; int num_used = 0; /* Check the 'parked' flag for each thread the GC knows about. */ for (i = 0; i < MAX_NACL_GC_THREADS && num_used < GC_nacl_num_gc_threads; i++) { if (GC_nacl_thread_used[i] == 1) { num_used++; if (GC_nacl_thread_parked[i] == 1) { num_threads_parked++; if (GC_on_thread_event) GC_on_thread_event(GC_EVENT_THREAD_SUSPENDED, (void *)(word)i); } } } /* -1 for the current thread. */ if (num_threads_parked >= GC_nacl_num_gc_threads - 1) break; # ifdef DEBUG_THREADS GC_log_printf("Sleep waiting for %d threads to park...\n", GC_nacl_num_gc_threads - num_threads_parked - 1); # endif GC_usleep(NACL_PARK_WAIT_USEC); if (++num_sleeps > (1000 * 1000) / NACL_PARK_WAIT_USEC) { WARN("GC appears stalled waiting for %" WARN_PRIdPTR " threads to park...\n", GC_nacl_num_gc_threads - num_threads_parked - 1); num_sleeps = 0; } } if (GC_manual_vdb) GC_release_dirty_lock(); # endif /* NACL */ return n_live_threads; } GC_INNER void GC_stop_world(void) { # if !defined(NACL) int n_live_threads; # endif GC_ASSERT(I_HOLD_LOCK()); GC_ASSERT(GC_thr_initialized); # ifdef DEBUG_THREADS GC_stopping_thread = pthread_self(); GC_stopping_pid = getpid(); GC_log_printf("Stopping the world from %p\n", (void *)GC_stopping_thread); # endif /* Make sure all free list construction has stopped before we start. */ /* No new construction can start, since free list construction is */ /* required to acquire and release the GC lock before it starts, */ /* and we have the lock. */ # ifdef PARALLEL_MARK if (GC_parallel) { GC_acquire_mark_lock(); GC_ASSERT(GC_fl_builder_count == 0); /* We should have previously waited for it to become zero. */ } # endif /* PARALLEL_MARK */ # if defined(NACL) (void)GC_suspend_all(); # else AO_store(&GC_stop_count, GC_stop_count + THREAD_RESTARTED); /* Only concurrent reads are possible. */ if (GC_manual_vdb) { GC_acquire_dirty_lock(); /* The write fault handler cannot be called if GC_manual_vdb */ /* (thus double-locking should not occur in */ /* async_set_pht_entry_from_index based on test-and-set). */ } n_live_threads = GC_suspend_all(); if (GC_retry_signals) { resend_lost_signals_retry(n_live_threads, GC_suspend_all); } else { suspend_restart_barrier(n_live_threads); } if (GC_manual_vdb) GC_release_dirty_lock(); /* cannot be done in GC_suspend_all */ # endif # ifdef PARALLEL_MARK if (GC_parallel) GC_release_mark_lock(); # endif # ifdef DEBUG_THREADS GC_log_printf("World stopped from %p\n", (void *)pthread_self()); GC_stopping_thread = 0; # endif } #ifdef NACL # if defined(__x86_64__) # define NACL_STORE_REGS() \ do { \ __asm__ __volatile__ ("push %rbx"); \ __asm__ __volatile__ ("push %rbp"); \ __asm__ __volatile__ ("push %r12"); \ __asm__ __volatile__ ("push %r13"); \ __asm__ __volatile__ ("push %r14"); \ __asm__ __volatile__ ("push %r15"); \ __asm__ __volatile__ ("mov %%esp, %0" \ : "=m" (GC_nacl_gc_thread_self -> crtn -> stack_ptr)); \ BCOPY(GC_nacl_gc_thread_self -> crtn -> stack_ptr, \ GC_nacl_gc_thread_self -> reg_storage, \ NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t)); \ __asm__ __volatile__ ("naclasp $48, %r15"); \ } while (0) # elif defined(__i386__) # define NACL_STORE_REGS() \ do { \ __asm__ __volatile__ ("push %ebx"); \ __asm__ __volatile__ ("push %ebp"); \ __asm__ __volatile__ ("push %esi"); \ __asm__ __volatile__ ("push %edi"); \ __asm__ __volatile__ ("mov %%esp, %0" \ : "=m" (GC_nacl_gc_thread_self -> crtn -> stack_ptr)); \ BCOPY(GC_nacl_gc_thread_self -> crtn -> stack_ptr, \ GC_nacl_gc_thread_self -> reg_storage, \ NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t));\ __asm__ __volatile__ ("add $16, %esp"); \ } while (0) # elif defined(__arm__) # define NACL_STORE_REGS() \ do { \ __asm__ __volatile__ ("push {r4-r8,r10-r12,lr}"); \ __asm__ __volatile__ ("mov r0, %0" \ : : "r" (&GC_nacl_gc_thread_self -> crtn -> stack_ptr)); \ __asm__ __volatile__ ("bic r0, r0, #0xc0000000"); \ __asm__ __volatile__ ("str sp, [r0]"); \ BCOPY(GC_nacl_gc_thread_self -> crtn -> stack_ptr, \ GC_nacl_gc_thread_self -> reg_storage, \ NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t)); \ __asm__ __volatile__ ("add sp, sp, #40"); \ __asm__ __volatile__ ("bic sp, sp, #0xc0000000"); \ } while (0) # else # error TODO Please port NACL_STORE_REGS # endif GC_API_OSCALL void nacl_pre_syscall_hook(void) { if (GC_nacl_thread_idx != -1) { NACL_STORE_REGS(); GC_nacl_gc_thread_self -> crtn -> stack_ptr = GC_approx_sp(); GC_nacl_thread_parked[GC_nacl_thread_idx] = 1; } } GC_API_OSCALL void __nacl_suspend_thread_if_needed(void) { if (!GC_nacl_park_threads_now) return; /* Don't try to park the thread parker. */ if (GC_nacl_thread_parker == pthread_self()) return; /* This can happen when a thread is created outside of the GC */ /* system (wthread mostly). */ if (GC_nacl_thread_idx < 0) return; /* If it was already 'parked', we're returning from a syscall, */ /* so don't bother storing registers again, the GC has a set. */ if (!GC_nacl_thread_parked[GC_nacl_thread_idx]) { NACL_STORE_REGS(); GC_nacl_gc_thread_self -> crtn -> stack_ptr = GC_approx_sp(); } GC_nacl_thread_parked[GC_nacl_thread_idx] = 1; while (GC_nacl_park_threads_now) { /* Just spin. */ } GC_nacl_thread_parked[GC_nacl_thread_idx] = 0; /* Clear out the reg storage for next suspend. */ BZERO(GC_nacl_gc_thread_self -> reg_storage, NACL_GC_REG_STORAGE_SIZE * sizeof(ptr_t)); } GC_API_OSCALL void nacl_post_syscall_hook(void) { /* Calling __nacl_suspend_thread_if_needed right away should */ /* guarantee we don't mutate the GC set. */ __nacl_suspend_thread_if_needed(); if (GC_nacl_thread_idx != -1) { GC_nacl_thread_parked[GC_nacl_thread_idx] = 0; } } STATIC GC_bool GC_nacl_thread_parking_inited = FALSE; STATIC pthread_mutex_t GC_nacl_thread_alloc_lock = PTHREAD_MUTEX_INITIALIZER; struct nacl_irt_blockhook { int (*register_block_hooks)(void (*pre)(void), void (*post)(void)); }; EXTERN_C_BEGIN extern size_t nacl_interface_query(const char *interface_ident, void *table, size_t tablesize); EXTERN_C_END GC_INNER void GC_nacl_initialize_gc_thread(GC_thread me) { int i; static struct nacl_irt_blockhook gc_hook; GC_ASSERT(NULL == GC_nacl_gc_thread_self); GC_nacl_gc_thread_self = me; pthread_mutex_lock(&GC_nacl_thread_alloc_lock); if (!EXPECT(GC_nacl_thread_parking_inited, TRUE)) { BZERO(GC_nacl_thread_parked, sizeof(GC_nacl_thread_parked)); BZERO(GC_nacl_thread_used, sizeof(GC_nacl_thread_used)); /* TODO: replace with public 'register hook' function when */ /* available from glibc. */ nacl_interface_query("nacl-irt-blockhook-0.1", &gc_hook, sizeof(gc_hook)); gc_hook.register_block_hooks(nacl_pre_syscall_hook, nacl_post_syscall_hook); GC_nacl_thread_parking_inited = TRUE; } GC_ASSERT(GC_nacl_num_gc_threads <= MAX_NACL_GC_THREADS); for (i = 0; i < MAX_NACL_GC_THREADS; i++) { if (GC_nacl_thread_used[i] == 0) { GC_nacl_thread_used[i] = 1; GC_nacl_thread_idx = i; GC_nacl_num_gc_threads++; break; } } pthread_mutex_unlock(&GC_nacl_thread_alloc_lock); } GC_INNER void GC_nacl_shutdown_gc_thread(void) { GC_ASSERT(GC_nacl_gc_thread_self != NULL); pthread_mutex_lock(&GC_nacl_thread_alloc_lock); GC_ASSERT(GC_nacl_thread_idx >= 0); GC_ASSERT(GC_nacl_thread_idx < MAX_NACL_GC_THREADS); GC_ASSERT(GC_nacl_thread_used[GC_nacl_thread_idx] != 0); GC_nacl_thread_used[GC_nacl_thread_idx] = 0; GC_nacl_thread_idx = -1; GC_nacl_num_gc_threads--; pthread_mutex_unlock(&GC_nacl_thread_alloc_lock); GC_nacl_gc_thread_self = NULL; } #else /* !NACL */ /* Restart all threads that were suspended by the collector. */ /* Return the number of restart signals that were sent. */ STATIC int GC_restart_all(void) { int n_live_threads = 0; int i; pthread_t self = pthread_self(); GC_thread p; int result; GC_ASSERT((GC_stop_count & THREAD_RESTARTED) != 0); for (i = 0; i < THREAD_TABLE_SZ; i++) { for (p = GC_threads[i]; p != NULL; p = p -> tm.next) { if (!THREAD_EQUAL(p -> id, self)) { if ((p -> flags & (FINISHED | DO_BLOCKING)) != 0) continue; # ifdef GC_ENABLE_SUSPEND_THREAD if ((p -> ext_suspend_cnt & 1) != 0) continue; # endif if (GC_retry_signals && AO_load(&(p -> last_stop_count)) == GC_stop_count) continue; /* The thread has been restarted. */ n_live_threads++; # ifdef DEBUG_THREADS GC_log_printf("Sending restart signal to %p\n", (void *)p->id); # endif result = raise_signal(p, GC_sig_thr_restart); switch (result) { case ESRCH: /* Not really there anymore. Possible? */ n_live_threads--; break; case 0: if (GC_on_thread_event) GC_on_thread_event(GC_EVENT_THREAD_UNSUSPENDED, (void *)(word)THREAD_SYSTEM_ID(p)); break; default: ABORT_ARG1("pthread_kill failed at resume", ": errcode= %d", result); } } } } return n_live_threads; } #endif /* !NACL */ GC_INNER void GC_start_world(void) { # ifndef NACL int n_live_threads; GC_ASSERT(I_HOLD_LOCK()); /* held continuously since the world stopped */ # ifdef DEBUG_THREADS GC_log_printf("World starting\n"); # endif AO_store_release(&GC_stop_count, GC_stop_count + THREAD_RESTARTED); /* The updated value should now be visible to the */ /* signal handler (note that pthread_kill is not on */ /* the list of functions which synchronize memory). */ n_live_threads = GC_restart_all(); if (GC_retry_signals) { resend_lost_signals_retry(n_live_threads, GC_restart_all); } else { # ifndef GC_NETBSD_THREADS_WORKAROUND if (GC_sig_suspend == GC_sig_thr_restart) # endif { suspend_restart_barrier(n_live_threads); } } # ifdef DEBUG_THREADS GC_log_printf("World started\n"); # endif # else /* NACL */ # ifdef DEBUG_THREADS GC_log_printf("World starting...\n"); # endif GC_nacl_park_threads_now = 0; if (GC_on_thread_event) GC_on_thread_event(GC_EVENT_THREAD_UNSUSPENDED, NULL); /* TODO: Send event for every unsuspended thread. */ # endif } GC_INNER void GC_stop_init(void) { # if !defined(NACL) struct sigaction act; char *str; if (SIGNAL_UNSET == GC_sig_suspend) GC_sig_suspend = SIG_SUSPEND; if (SIGNAL_UNSET == GC_sig_thr_restart) GC_sig_thr_restart = SIG_THR_RESTART; if (sem_init(&GC_suspend_ack_sem, GC_SEM_INIT_PSHARED, 0) != 0) ABORT("sem_init failed"); GC_stop_count = THREAD_RESTARTED; /* i.e. the world is not stopped */ if (sigfillset(&act.sa_mask) != 0) { ABORT("sigfillset failed"); } # ifdef GC_RTEMS_PTHREADS if(sigprocmask(SIG_UNBLOCK, &act.sa_mask, NULL) != 0) { ABORT("sigprocmask failed"); } # endif GC_remove_allowed_signals(&act.sa_mask); /* GC_sig_thr_restart is set in the resulting mask. */ /* It is unmasked by the handler when necessary. */ # ifdef SA_RESTART act.sa_flags = SA_RESTART; # else act.sa_flags = 0; # endif # ifdef SUSPEND_HANDLER_NO_CONTEXT act.sa_handler = GC_suspend_handler; # else act.sa_flags |= SA_SIGINFO; act.sa_sigaction = GC_suspend_sigaction; # endif /* act.sa_restorer is deprecated and should not be initialized. */ if (sigaction(GC_sig_suspend, &act, NULL) != 0) { ABORT("Cannot set SIG_SUSPEND handler"); } if (GC_sig_suspend != GC_sig_thr_restart) { # ifndef SUSPEND_HANDLER_NO_CONTEXT act.sa_flags &= ~SA_SIGINFO; # endif act.sa_handler = GC_restart_handler; if (sigaction(GC_sig_thr_restart, &act, NULL) != 0) ABORT("Cannot set SIG_THR_RESTART handler"); } else { GC_COND_LOG_PRINTF("Using same signal for suspend and restart\n"); } /* Initialize suspend_handler_mask (excluding GC_sig_thr_restart). */ if (sigfillset(&suspend_handler_mask) != 0) ABORT("sigfillset failed"); GC_remove_allowed_signals(&suspend_handler_mask); if (sigdelset(&suspend_handler_mask, GC_sig_thr_restart) != 0) ABORT("sigdelset failed"); # ifndef NO_RETRY_SIGNALS /* Any platform could lose signals, so let's be conservative and */ /* always enable signals retry logic. */ GC_retry_signals = TRUE; # endif /* Override the default value of GC_retry_signals. */ str = GETENV("GC_RETRY_SIGNALS"); if (str != NULL) { GC_retry_signals = *str != '0' || *(str + 1) != '\0'; /* Do not retry if the environment variable is set to "0". */ } if (GC_retry_signals) { GC_COND_LOG_PRINTF( "Will retry suspend and restart signals if necessary\n"); } # ifndef NO_SIGNALS_UNBLOCK_IN_MAIN /* Explicitly unblock the signals once before new threads creation. */ GC_unblock_gc_signals(); # endif # endif /* !NACL */ } #endif /* PTHREAD_STOP_WORLD_IMPL */