summaryrefslogtreecommitdiff
path: root/pthread_stop_world.c
diff options
context:
space:
mode:
authorivmai <ivmai>2009-09-19 13:23:29 +0200
committerIvan Maidanski <ivmai@mail.ru>2011-07-26 19:06:47 +0200
commitfa40c00794cf621101182ffe60e56449fb580e8a (patch)
treee27b5f5b9e2759b99889010af3a072ccb516427c /pthread_stop_world.c
parentd1d1fc8d9e51ffa49da97f99ad6158c090fb7e80 (diff)
2009-09-19 Ivan Maidanski <ivmai@mail.ru>
* allchblk.c: Expand all tabs to spaces; remove trailing spaces at EOLn; remove multiple trailing blank lines. * mark.c: Ditto. * mark_rts.c: Ditto. * pthread_stop_world.c: Ditto. * win32_threads.c: Ditto. * include/gc.h: Ditto. * include/private/gc_priv.h: Ditto. * pthread_stop_world.c: Add copyright header. * include/gc.h: Reformat some comments.
Diffstat (limited to 'pthread_stop_world.c')
-rw-r--r--pthread_stop_world.c343
1 files changed, 180 insertions, 163 deletions
diff --git a/pthread_stop_world.c b/pthread_stop_world.c
index e50a13e..694a381 100644
--- a/pthread_stop_world.c
+++ b/pthread_stop_world.c
@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ * 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"
#if defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) && \
@@ -29,7 +46,7 @@ void GC_print_sig_mask(void)
int i;
if (pthread_sigmask(SIG_BLOCK, NULL, &blocked) != 0)
- ABORT("pthread_sigmask");
+ ABORT("pthread_sigmask");
GC_printf("Blocked: ");
for (i = 1; i < NSIG; i++) {
if (sigismember(&blocked, i)) { GC_printf("%d ", i); }
@@ -39,25 +56,25 @@ void GC_print_sig_mask(void)
#endif
-/* Remove the signals that we want to allow in thread stopping */
-/* handler from a set. */
+/* 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) {
+ || 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. */
+ /* Handlers write to the thread structure, which is in the heap, */
+ /* and hence can trigger a protection fault. */
if (sigdelset(set, SIGSEGV) != 0
-# ifdef SIGBUS
- || sigdelset(set, SIGBUS) != 0
-# endif
- ) {
+# ifdef SIGBUS
+ || sigdelset(set, SIGBUS) != 0
+# endif
+ ) {
ABORT("sigdelset() failed");
}
# endif
@@ -66,13 +83,13 @@ STATIC void GC_remove_allowed_signals(sigset_t *set)
static sigset_t suspend_handler_mask;
volatile AO_t GC_stop_count;
- /* Incremented at the beginning of GC_stop_world. */
+ /* Incremented at the beginning of GC_stop_world. */
volatile AO_t GC_world_is_stopped = FALSE;
- /* FALSE ==> it is safe for threads to restart, i.e. */
- /* they will see another suspend signal before they */
- /* are expected to stop (unless they have voluntarily */
- /* stopped). */
+ /* FALSE ==> it is safe for threads to restart, i.e. */
+ /* they will see another suspend signal before they */
+ /* are expected to stop (unless they have voluntarily */
+ /* stopped). */
#ifdef GC_OSF1_THREADS
STATIC GC_bool GC_retry_signals = TRUE;
@@ -82,7 +99,7 @@ volatile AO_t GC_world_is_stopped = 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.)
@@ -108,8 +125,8 @@ STATIC sem_t GC_suspend_ack_sem;
#ifdef GC_NETBSD_THREADS
# define GC_NETBSD_THREADS_WORKAROUND
- /* It seems to be necessary to wait until threads have restarted. */
- /* But it is unclear why that is the case. */
+ /* It seems to be necessary to wait until threads have restarted. */
+ /* But it is unclear why that is the case. */
STATIC sem_t GC_restart_ack_sem;
#endif
@@ -128,8 +145,8 @@ STATIC void GC_suspend_handler(int sig)
errno = old_errno;
}
#else
-/* We believe that in all other cases the full context is already */
-/* in the signal handler frame. */
+/* We believe that in all other cases the full context is already */
+/* in the signal handler frame. */
#ifdef SA_SIGINFO
STATIC void GC_suspend_handler(int sig, siginfo_t *info, void *context)
#else
@@ -163,52 +180,52 @@ STATIC void GC_suspend_handler_inner(ptr_t sig_arg, void *context)
me = GC_lookup_thread(my_thread);
/* The lookup here is safe, since I'm doing this 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. */
+ /* of a thread which holds the allocation lock in order */
+ /* to stop the world. Thus concurrent modification of the */
+ /* data structure is impossible. */
if (me -> stop_info.last_stop_count == my_stop_count) {
- /* Duplicate signal. OK if we are retrying. */
- if (!GC_retry_signals) {
- WARN("Duplicate suspend signal in thread %p\n", pthread_self());
- }
- return;
+ /* Duplicate signal. OK if we are retrying. */
+ if (!GC_retry_signals) {
+ WARN("Duplicate suspend signal in thread %p\n", pthread_self());
+ }
+ return;
}
# ifdef SPARC
- me -> stop_info.stack_ptr = GC_save_regs_in_stack();
+ me -> stop_info.stack_ptr = GC_save_regs_in_stack();
# else
- me -> stop_info.stack_ptr = (ptr_t)(&dummy);
+ me -> stop_info.stack_ptr = (ptr_t)(&dummy);
# endif
# ifdef IA64
- me -> backing_store_ptr = GC_save_regs_in_stack();
+ me -> backing_store_ptr = GC_save_regs_in_stack();
# endif
/* Tell the thread that wants to stop the world that this */
- /* thread has been stopped. Note that sem_post() is */
+ /* thread has been stopped. Note that sem_post() is */
/* the only async-signal-safe primitive in LinuxThreads. */
sem_post(&GC_suspend_ack_sem);
me -> stop_info.last_stop_count = my_stop_count;
/* Wait until that thread tells us to restart by sending */
- /* this thread a SIG_THR_RESTART signal. */
- /* SIG_THR_RESTART should be masked at this point. Thus there */
- /* is no race. */
- /* We do not continue until we receive a SIG_THR_RESTART, */
- /* 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. */
+ /* this thread a SIG_THR_RESTART signal. */
+ /* SIG_THR_RESTART should be masked at this point. Thus there */
+ /* is no race. */
+ /* We do not continue until we receive a SIG_THR_RESTART, */
+ /* 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);
+ sigsuspend (&suspend_handler_mask);
} while (AO_load_acquire(&GC_world_is_stopped)
- && AO_load(&GC_stop_count) == my_stop_count);
+ && AO_load(&GC_stop_count) == my_stop_count);
/* If the RESTART signal gets lost, we can still lose. That should be */
/* less likely than losing the SUSPEND signal, since we don't do much */
- /* between the sem_post and sigsuspend. */
- /* We'd need more handshaking to work around that. */
+ /* between the sem_post and sigsuspend. */
+ /* We'd need more handshaking to work around that. */
/* Simply dropping the sigsuspend call should be safe, but is unlikely */
- /* to be efficient. */
+ /* to be efficient. */
# if DEBUG_THREADS
GC_printf("Continuing 0x%x\n", (unsigned)my_thread);
@@ -243,8 +260,8 @@ void GC_thr_init(void);
# else
# define IF_IA64(x)
# endif
-/* We hold allocation lock. Should do exactly the right thing if the */
-/* world is stopped. Should not fail if it isn't. */
+/* We hold allocation lock. Should do exactly the right thing if the */
+/* world is stopped. Should not fail if it isn't. */
void GC_push_all_stacks(void)
{
GC_bool found_me = FALSE;
@@ -255,7 +272,7 @@ void GC_push_all_stacks(void)
/* On IA64, we also need to scan the register backing store. */
IF_IA64(ptr_t bs_lo; ptr_t bs_hi;)
pthread_t me = pthread_self();
-
+
if (!GC_thr_initialized) GC_thr_init();
# if DEBUG_THREADS
GC_printf("Pushing stacks from thread 0x%x\n", (unsigned) me);
@@ -263,48 +280,48 @@ void GC_push_all_stacks(void)
for (i = 0; i < THREAD_TABLE_SZ; i++) {
for (p = GC_threads[i]; p != 0; p = p -> next) {
if (p -> flags & FINISHED) continue;
- ++nthreads;
+ ++nthreads;
if (THREAD_EQUAL(p -> id, me)) {
- GC_ASSERT(!p->thread_blocked);
-# ifdef SPARC
- lo = (ptr_t)GC_save_regs_in_stack();
-# else
- lo = GC_approx_sp();
+ GC_ASSERT(!p->thread_blocked);
+# ifdef SPARC
+ lo = (ptr_t)GC_save_regs_in_stack();
+# else
+ lo = GC_approx_sp();
# endif
- found_me = TRUE;
- IF_IA64(bs_hi = (ptr_t)GC_save_regs_in_stack();)
- } else {
- lo = p -> stop_info.stack_ptr;
- IF_IA64(bs_hi = p -> backing_store_ptr;)
- }
+ found_me = TRUE;
+ IF_IA64(bs_hi = (ptr_t)GC_save_regs_in_stack();)
+ } else {
+ lo = p -> stop_info.stack_ptr;
+ IF_IA64(bs_hi = p -> backing_store_ptr;)
+ }
if ((p -> flags & MAIN_THREAD) == 0) {
- hi = p -> stack_end;
- IF_IA64(bs_lo = p -> backing_store_end);
+ hi = p -> stack_end;
+ IF_IA64(bs_lo = p -> backing_store_end);
} else {
/* The original stack. */
hi = GC_stackbottom;
- IF_IA64(bs_lo = BACKING_STORE_BASE;)
+ IF_IA64(bs_lo = BACKING_STORE_BASE;)
}
-# if DEBUG_THREADS
+# if DEBUG_THREADS
GC_printf("Stack for thread 0x%x = [%p,%p)\n",
- (unsigned)(p -> id), lo, hi);
-# endif
- if (0 == lo) ABORT("GC_push_all_stacks: sp not set!\n");
- GC_push_all_stack_frames(lo, hi, p -> activation_frame);
-# ifdef IA64
+ (unsigned)(p -> id), lo, hi);
+# endif
+ if (0 == lo) ABORT("GC_push_all_stacks: sp not set!\n");
+ GC_push_all_stack_frames(lo, hi, p -> activation_frame);
+# ifdef IA64
# if DEBUG_THREADS
GC_printf("Reg stack for thread 0x%x = [%p,%p)\n",
- (unsigned)p -> id, bs_lo, bs_hi);
-# endif
- /* FIXME: This (if p->id==me) may add an unbounded number of */
- /* entries, and hence overflow the mark stack, which is bad. */
- GC_push_all_register_frames(bs_lo, bs_hi,
- THREAD_EQUAL(p -> id, me), p -> activation_frame);
-# endif
+ (unsigned)p -> id, bs_lo, bs_hi);
+# endif
+ /* FIXME: This (if p->id==me) may add an unbounded number of */
+ /* entries, and hence overflow the mark stack, which is bad. */
+ GC_push_all_register_frames(bs_lo, bs_hi,
+ THREAD_EQUAL(p -> id, me), p -> activation_frame);
+# endif
}
}
if (GC_print_stats == VERBOSE) {
- GC_log_printf("Pushed %d thread stacks\n", (int)nthreads);
+ GC_log_printf("Pushed %d thread stacks\n", (int)nthreads);
}
if (!found_me && !GC_in_thread_creation)
ABORT("Collecting from unknown thread.");
@@ -317,8 +334,8 @@ pthread_t GC_stopping_thread;
int GC_stopping_pid;
#endif
-/* We hold the allocation lock. Suspend all threads that might */
-/* still be running. Return the number of suspend signals that */
+/* We hold the allocation lock. Suspend all threads that might */
+/* still be running. Return the number of suspend signals that */
/* were sent. */
STATIC int GC_suspend_all(void)
{
@@ -327,7 +344,7 @@ STATIC int GC_suspend_all(void)
GC_thread p;
int result;
pthread_t my_thread = pthread_self();
-
+
# if DEBUG_THREADS
GC_stopping_thread = my_thread;
GC_stopping_pid = getpid();
@@ -337,15 +354,15 @@ STATIC int GC_suspend_all(void)
if (!THREAD_EQUAL(p -> id, my_thread)) {
if (p -> flags & FINISHED) continue;
if (p -> stop_info.last_stop_count == GC_stop_count) continue;
- if (p -> thread_blocked) /* Will wait */ continue;
+ if (p -> thread_blocked) /* Will wait */ continue;
n_live_threads++;
-# if DEBUG_THREADS
- GC_printf("Sending suspend signal to 0x%x\n",
- (unsigned)(p -> id));
-# endif
-
+# if DEBUG_THREADS
+ GC_printf("Sending suspend signal to 0x%x\n",
+ (unsigned)(p -> id));
+# endif
+
result = pthread_kill(p -> id, SIG_SUSPEND);
- switch(result) {
+ switch(result) {
case ESRCH:
/* Not really there anymore. Possible? */
n_live_threads--;
@@ -371,65 +388,65 @@ void GC_stop_world(void)
# if DEBUG_THREADS
GC_printf("Stopping the world from 0x%x\n", (unsigned)pthread_self());
# 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. */
+ /* 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. */
+ GC_acquire_mark_lock();
+ GC_ASSERT(GC_fl_builder_count == 0);
+ /* We should have previously waited for it to become zero. */
}
# endif /* PARALLEL_MARK */
AO_store(&GC_stop_count, GC_stop_count+1);
- /* Only concurrent reads are possible. */
+ /* Only concurrent reads are possible. */
AO_store_release(&GC_world_is_stopped, TRUE);
n_live_threads = GC_suspend_all();
if (GC_retry_signals) {
- unsigned long wait_usecs = 0; /* Total wait since retry. */
-# define WAIT_UNIT 3000
-# define RETRY_INTERVAL 100000
- 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 = GC_suspend_all();
-
- if (GC_print_stats) {
- GC_log_printf("Resent %d signals after timeout\n",
- newly_sent);
- }
- sem_getvalue(&GC_suspend_ack_sem, &ack_count);
- if (newly_sent < n_live_threads - ack_count) {
- WARN("Lost some threads during GC_stop_world?!\n",0);
- n_live_threads = ack_count + newly_sent;
- }
- wait_usecs = 0;
- }
- usleep(WAIT_UNIT);
- wait_usecs += WAIT_UNIT;
- }
+ unsigned long wait_usecs = 0; /* Total wait since retry. */
+# define WAIT_UNIT 3000
+# define RETRY_INTERVAL 100000
+ 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 = GC_suspend_all();
+
+ if (GC_print_stats) {
+ GC_log_printf("Resent %d signals after timeout\n",
+ newly_sent);
+ }
+ sem_getvalue(&GC_suspend_ack_sem, &ack_count);
+ if (newly_sent < n_live_threads - ack_count) {
+ WARN("Lost some threads during GC_stop_world?!\n",0);
+ n_live_threads = ack_count + newly_sent;
+ }
+ wait_usecs = 0;
+ }
+ usleep(WAIT_UNIT);
+ wait_usecs += WAIT_UNIT;
+ }
}
for (i = 0; i < n_live_threads; i++) {
- retry:
- if (0 != (code = sem_wait(&GC_suspend_ack_sem))) {
- /* On Linux, sem_wait is documented to always return zero.*/
- /* But the documentation appears to be incorrect. */
- if (errno == EINTR) {
- /* Seems to happen with some versions of gdb. */
- goto retry;
- }
- ABORT("sem_wait for handler failed");
- }
+ retry:
+ if (0 != (code = sem_wait(&GC_suspend_ack_sem))) {
+ /* On Linux, sem_wait is documented to always return zero.*/
+ /* But the documentation appears to be incorrect. */
+ if (errno == EINTR) {
+ /* Seems to happen with some versions of gdb. */
+ goto retry;
+ }
+ ABORT("sem_wait for handler failed");
+ }
}
# ifdef PARALLEL_MARK
if (GC_parallel)
- GC_release_mark_lock();
+ GC_release_mark_lock();
# endif
# if DEBUG_THREADS
GC_printf("World stopped from 0x%x\n", (unsigned)pthread_self());
@@ -437,8 +454,8 @@ void GC_stop_world(void)
# endif
}
-/* Caller holds allocation lock, and has held it continuously since */
-/* the world stopped. */
+/* Caller holds allocation lock, and has held it continuously since */
+/* the world stopped. */
void GC_start_world(void)
{
pthread_t my_thread = pthread_self();
@@ -459,15 +476,15 @@ void GC_start_world(void)
for (p = GC_threads[i]; p != 0; p = p -> next) {
if (!THREAD_EQUAL(p -> id, my_thread)) {
if (p -> flags & FINISHED) continue;
- if (p -> thread_blocked) continue;
+ if (p -> thread_blocked) continue;
n_live_threads++;
-# if DEBUG_THREADS
- GC_printf("Sending restart signal to 0x%x\n",
- (unsigned)(p -> id));
-# endif
-
+# if DEBUG_THREADS
+ GC_printf("Sending restart signal to 0x%x\n",
+ (unsigned)(p -> id));
+# endif
+
result = pthread_kill(p -> id, SIG_THR_RESTART);
- switch(result) {
+ switch(result) {
case ESRCH:
/* Not really there anymore. Possible? */
n_live_threads--;
@@ -482,12 +499,12 @@ void GC_start_world(void)
}
# ifdef GC_NETBSD_THREADS_WORKAROUND
for (i = 0; i < n_live_threads; i++)
- while (0 != (code = sem_wait(&GC_restart_ack_sem)))
- if (errno != EINTR) {
- GC_err_printf("sem_wait() returned %d\n",
- code);
- ABORT("sem_wait() for restart handler failed");
- }
+ while (0 != (code = sem_wait(&GC_restart_ack_sem)))
+ if (errno != EINTR) {
+ GC_err_printf("sem_wait() returned %d\n",
+ code);
+ ABORT("sem_wait() for restart handler failed");
+ }
# endif
# if DEBUG_THREADS
GC_printf("World started\n");
@@ -496,32 +513,32 @@ void GC_start_world(void)
void GC_stop_init(void) {
struct sigaction act;
-
+
if (sem_init(&GC_suspend_ack_sem, 0, 0) != 0)
ABORT("sem_init failed");
# ifdef GC_NETBSD_THREADS_WORKAROUND
if (sem_init(&GC_restart_ack_sem, 0, 0) != 0)
- ABORT("sem_init failed");
+ ABORT("sem_init failed");
# endif
act.sa_flags = SA_RESTART
# ifdef SA_SIGINFO
- | SA_SIGINFO
+ | SA_SIGINFO
# endif
- ;
+ ;
if (sigfillset(&act.sa_mask) != 0) {
- ABORT("sigfillset() failed");
+ ABORT("sigfillset() failed");
}
GC_remove_allowed_signals(&act.sa_mask);
- /* SIG_THR_RESTART is set in the resulting mask. */
- /* It is unmasked by the handler when necessary. */
+ /* SIG_THR_RESTART is set in the resulting mask. */
+ /* It is unmasked by the handler when necessary. */
# ifdef SA_SIGINFO
act.sa_sigaction = GC_suspend_handler;
# else
act.sa_handler = GC_suspend_handler;
# endif
if (sigaction(SIG_SUSPEND, &act, NULL) != 0) {
- ABORT("Cannot set SIG_SUSPEND handler");
+ ABORT("Cannot set SIG_SUSPEND handler");
}
# ifdef SA_SIGINFO
@@ -529,21 +546,21 @@ void GC_stop_init(void) {
# endif
act.sa_handler = GC_restart_handler;
if (sigaction(SIG_THR_RESTART, &act, NULL) != 0) {
- ABORT("Cannot set SIG_THR_RESTART handler");
+ ABORT("Cannot set SIG_THR_RESTART handler");
}
/* Initialize suspend_handler_mask. It excludes SIG_THR_RESTART. */
if (sigfillset(&suspend_handler_mask) != 0) ABORT("sigfillset() failed");
GC_remove_allowed_signals(&suspend_handler_mask);
if (sigdelset(&suspend_handler_mask, SIG_THR_RESTART) != 0)
- ABORT("sigdelset() failed");
+ ABORT("sigdelset() failed");
- /* Check for GC_RETRY_SIGNALS. */
+ /* Check for GC_RETRY_SIGNALS. */
if (0 != GETENV("GC_RETRY_SIGNALS")) {
- GC_retry_signals = TRUE;
+ GC_retry_signals = TRUE;
}
if (0 != GETENV("GC_NO_RETRY_SIGNALS")) {
- GC_retry_signals = FALSE;
+ GC_retry_signals = FALSE;
}
if (GC_print_stats && GC_retry_signals) {
GC_log_printf("Will retry suspend signal if necessary.\n");