1 #include "private/pthread_support.h"
2
3 #if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \
4 && !defined(GC_IRIX_THREADS) && !defined(GC_WIN32_THREADS) \
5 && !defined(GC_DARWIN_THREADS) && !defined(GC_AIX_THREADS)
6
7 #include <signal.h>
8 #include <semaphore.h>
9 #include <errno.h>
10 #include <unistd.h>
11
12 #if DEBUG_THREADS
13
14 #ifndef NSIG
15 # if defined(MAXSIG)
16 # define NSIG (MAXSIG+1)
17 # elif defined(_NSIG)
18 # define NSIG _NSIG
19 # elif defined(__SIGRTMAX)
20 # define NSIG (__SIGRTMAX+1)
21 # else
22 --> please fix it
23 # endif
24 #endif
25
26 void GC_print_sig_mask()
27 {
28 sigset_t blocked;
29 int i;
30
31 if (pthread_sigmask(SIG_BLOCK, NULL, &blocked) != 0)
32 ABORT("pthread_sigmask");
33 GC_printf0("Blocked: ");
34 for (i = 1; i < NSIG; i++) {
35 if (sigismember(&blocked, i)) { GC_printf1("%ld ",(long) i); }
36 }
37 GC_printf0("\n");
38 }
39
40 #endif
41
42 word GC_stop_count; /* Incremented at the beginning of GC_stop_world. */
43
44 #ifdef GC_OSF1_THREADS
45 GC_bool GC_retry_signals = TRUE;
46 #else
47 GC_bool GC_retry_signals = FALSE;
48 #endif
49
50 /*
51 * We use signals to stop threads during GC.
52 *
53 * Suspended threads wait in signal handler for SIG_THR_RESTART.
54 * That's more portable than semaphores or condition variables.
55 * (We do use sem_post from a signal handler, but that should be portable.)
56 *
57 * The thread suspension signal SIG_SUSPEND is now defined in gc_priv.h.
58 * Note that we can't just stop a thread; we need it to save its stack
59 * pointer(s) and acknowledge.
60 */
61
62 #ifndef SIG_THR_RESTART
63 # if defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS)
64 # ifdef _SIGRTMIN
65 # define SIG_THR_RESTART _SIGRTMIN + 5
66 # else
67 # define SIG_THR_RESTART SIGRTMIN + 5
68 # endif
69 # else
70 # define SIG_THR_RESTART SIGXCPU
71 # endif
72 #endif
73
74 sem_t GC_suspend_ack_sem;
75
GC_suspend_handler(int sig)76 void GC_suspend_handler(int sig)
77 {
78 int dummy;
79 pthread_t my_thread = pthread_self();
80 GC_thread me;
81 sigset_t mask;
82 # ifdef PARALLEL_MARK
83 word my_mark_no = GC_mark_no;
84 /* Marker can't proceed until we acknowledge. Thus this is */
85 /* guaranteed to be the mark_no correspending to our */
86 /* suspension, i.e. the marker can't have incremented it yet. */
87 # endif
88 word my_stop_count = GC_stop_count;
89
90 if (sig != SIG_SUSPEND) ABORT("Bad signal in suspend_handler");
91
92 #if DEBUG_THREADS
93 GC_printf1("Suspending 0x%lx\n", my_thread);
94 #endif
95
96 me = GC_lookup_thread(my_thread);
97 /* The lookup here is safe, since I'm doing this on behalf */
98 /* of a thread which holds the allocation lock in order */
99 /* to stop the world. Thus concurrent modification of the */
100 /* data structure is impossible. */
101 if (me -> stop_info.last_stop_count == my_stop_count) {
102 /* Duplicate signal. OK if we are retrying. */
103 if (!GC_retry_signals) {
104 WARN("Duplicate suspend signal in thread %lx\n",
105 pthread_self());
106 }
107 return;
108 }
109 # ifdef SPARC
110 me -> stop_info.stack_ptr = (ptr_t)GC_save_regs_in_stack();
111 # else
112 me -> stop_info.stack_ptr = (ptr_t)(&dummy);
113 # endif
114 # ifdef IA64
115 me -> backing_store_ptr = (ptr_t)GC_save_regs_in_stack();
116 # endif
117
118 /* Tell the thread that wants to stop the world that this */
119 /* thread has been stopped. Note that sem_post() is */
120 /* the only async-signal-safe primitive in LinuxThreads. */
121 sem_post(&GC_suspend_ack_sem);
122 me -> stop_info.last_stop_count = my_stop_count;
123
124 /* Wait until that thread tells us to restart by sending */
125 /* this thread a SIG_THR_RESTART signal. */
126 /* SIG_THR_RESTART should be masked at this point. Thus there */
127 /* is no race. */
128 if (sigfillset(&mask) != 0) ABORT("sigfillset() failed");
129 if (sigdelset(&mask, SIG_THR_RESTART) != 0) ABORT("sigdelset() failed");
130 # ifdef NO_SIGNALS
131 if (sigdelset(&mask, SIGINT) != 0) ABORT("sigdelset() failed");
132 if (sigdelset(&mask, SIGQUIT) != 0) ABORT("sigdelset() failed");
133 if (sigdelset(&mask, SIGTERM) != 0) ABORT("sigdelset() failed");
134 if (sigdelset(&mask, SIGABRT) != 0) ABORT("sigdelset() failed");
135 # endif
136 do {
137 me->stop_info.signal = 0;
138 sigsuspend(&mask); /* Wait for signal */
139 } while (me->stop_info.signal != SIG_THR_RESTART);
140 /* If the RESTART signal gets lost, we can still lose. That should be */
141 /* less likely than losing the SUSPEND signal, since we don't do much */
142 /* between the sem_post and sigsuspend. */
143 /* We'd need more handshaking to work around that, since we don't want */
144 /* to accidentally leave a RESTART signal pending, thus causing us to */
145 /* continue prematurely in a future round. */
146
147 #if DEBUG_THREADS
148 GC_printf1("Continuing 0x%lx\n", my_thread);
149 #endif
150 }
151
GC_restart_handler(int sig)152 void GC_restart_handler(int sig)
153 {
154 pthread_t my_thread = pthread_self();
155 GC_thread me;
156
157 if (sig != SIG_THR_RESTART) ABORT("Bad signal in suspend_handler");
158
159 /* Let the GC_suspend_handler() know that we got a SIG_THR_RESTART. */
160 /* The lookup here is safe, since I'm doing this on behalf */
161 /* of a thread which holds the allocation lock in order */
162 /* to stop the world. Thus concurrent modification of the */
163 /* data structure is impossible. */
164 me = GC_lookup_thread(my_thread);
165 me->stop_info.signal = SIG_THR_RESTART;
166
167 /*
168 ** Note: even if we didn't do anything useful here,
169 ** it would still be necessary to have a signal handler,
170 ** rather than ignoring the signals, otherwise
171 ** the signals will not be delivered at all, and
172 ** will thus not interrupt the sigsuspend() above.
173 */
174
175 #if DEBUG_THREADS
176 GC_printf1("In GC_restart_handler for 0x%lx\n", pthread_self());
177 #endif
178 }
179
180 # ifdef IA64
181 # define IF_IA64(x) x
182 # else
183 # define IF_IA64(x)
184 # endif
185 /* We hold allocation lock. Should do exactly the right thing if the */
186 /* world is stopped. Should not fail if it isn't. */
GC_push_all_stacks()187 void GC_push_all_stacks()
188 {
189 int i;
190 GC_thread p;
191 ptr_t lo, hi;
192 /* On IA64, we also need to scan the register backing store. */
193 IF_IA64(ptr_t bs_lo; ptr_t bs_hi;)
194 pthread_t me = pthread_self();
195
196 if (!GC_thr_initialized) GC_thr_init();
197 #if DEBUG_THREADS
198 GC_printf1("Pushing stacks from thread 0x%lx\n", (unsigned long) me);
199 #endif
200 for (i = 0; i < THREAD_TABLE_SZ; i++) {
201 for (p = GC_threads[i]; p != 0; p = p -> next) {
202 if (p -> flags & FINISHED) continue;
203 if (pthread_equal(p -> id, me)) {
204 # ifdef SPARC
205 lo = (ptr_t)GC_save_regs_in_stack();
206 # else
207 lo = GC_approx_sp();
208 # endif
209 IF_IA64(bs_hi = (ptr_t)GC_save_regs_in_stack();)
210 } else {
211 lo = p -> stop_info.stack_ptr;
212 IF_IA64(bs_hi = p -> backing_store_ptr;)
213 }
214 if ((p -> flags & MAIN_THREAD) == 0) {
215 hi = p -> stack_end;
216 IF_IA64(bs_lo = p -> backing_store_end);
217 } else {
218 /* The original stack. */
219 hi = GC_stackbottom;
220 IF_IA64(bs_lo = BACKING_STORE_BASE;)
221 }
222 #if DEBUG_THREADS
223 GC_printf3("Stack for thread 0x%lx = [%lx,%lx)\n",
224 (unsigned long) p -> id,
225 (unsigned long) lo, (unsigned long) hi);
226 #endif
227 if (0 == lo) ABORT("GC_push_all_stacks: sp not set!\n");
228 # ifdef STACK_GROWS_UP
229 /* We got them backwards! */
230 GC_push_all_stack(hi, lo);
231 # else
232 GC_push_all_stack(lo, hi);
233 # endif
234 # ifdef IA64
235 if (pthread_equal(p -> id, me)) {
236 GC_push_all_eager(bs_lo, bs_hi);
237 } else {
238 GC_push_all_stack(bs_lo, bs_hi);
239 }
240 # endif
241 }
242 }
243 }
244
245 /* There seems to be a very rare thread stopping problem. To help us */
246 /* debug that, we save the ids of the stopping thread. */
247 pthread_t GC_stopping_thread;
248 int GC_stopping_pid;
249
250 /* We hold the allocation lock. Suspend all threads that might */
251 /* still be running. Return the number of suspend signals that */
252 /* were sent. */
GC_suspend_all()253 int GC_suspend_all()
254 {
255 int n_live_threads = 0;
256 int i;
257 GC_thread p;
258 int result;
259 pthread_t my_thread = pthread_self();
260
261 GC_stopping_thread = my_thread; /* debugging only. */
262 GC_stopping_pid = getpid(); /* debugging only. */
263 for (i = 0; i < THREAD_TABLE_SZ; i++) {
264 for (p = GC_threads[i]; p != 0; p = p -> next) {
265 if (p -> id != my_thread) {
266 if (p -> flags & FINISHED) continue;
267 if (p -> stop_info.last_stop_count == GC_stop_count) continue;
268 if (p -> thread_blocked) /* Will wait */ continue;
269 n_live_threads++;
270 #if DEBUG_THREADS
271 GC_printf1("Sending suspend signal to 0x%lx\n", p -> id);
272 #endif
273
274 result = pthread_kill(p -> id, SIG_SUSPEND);
275 switch(result) {
276 case ESRCH:
277 /* Not really there anymore. Possible? */
278 n_live_threads--;
279 break;
280 case 0:
281 break;
282 default:
283 ABORT("pthread_kill failed");
284 }
285 }
286 }
287 }
288 return n_live_threads;
289 }
290
291 /* Caller holds allocation lock. */
GC_stop_world()292 void GC_stop_world()
293 {
294 int i;
295 int n_live_threads;
296 int code;
297
298 #if DEBUG_THREADS
299 GC_printf1("Stopping the world from 0x%lx\n", pthread_self());
300 #endif
301
302 /* Make sure all free list construction has stopped before we start. */
303 /* No new construction can start, since free list construction is */
304 /* required to acquire and release the GC lock before it starts, */
305 /* and we have the lock. */
306 # ifdef PARALLEL_MARK
307 GC_acquire_mark_lock();
308 GC_ASSERT(GC_fl_builder_count == 0);
309 /* We should have previously waited for it to become zero. */
310 # endif /* PARALLEL_MARK */
311 ++GC_stop_count;
312 n_live_threads = GC_suspend_all();
313
314 if (GC_retry_signals) {
315 unsigned long wait_usecs = 0; /* Total wait since retry. */
316 # define WAIT_UNIT 3000
317 # define RETRY_INTERVAL 100000
318 for (;;) {
319 int ack_count;
320
321 sem_getvalue(&GC_suspend_ack_sem, &ack_count);
322 if (ack_count == n_live_threads) break;
323 if (wait_usecs > RETRY_INTERVAL) {
324 int newly_sent = GC_suspend_all();
325
326 # ifdef CONDPRINT
327 if (GC_print_stats) {
328 GC_printf1("Resent %ld signals after timeout\n",
329 newly_sent);
330 }
331 # endif
332 sem_getvalue(&GC_suspend_ack_sem, &ack_count);
333 if (newly_sent < n_live_threads - ack_count) {
334 WARN("Lost some threads during GC_stop_world?!\n",0);
335 n_live_threads = ack_count + newly_sent;
336 }
337 wait_usecs = 0;
338 }
339 usleep(WAIT_UNIT);
340 wait_usecs += WAIT_UNIT;
341 }
342 }
343 for (i = 0; i < n_live_threads; i++) {
344 if (0 != (code = sem_wait(&GC_suspend_ack_sem))) {
345 GC_err_printf1("Sem_wait returned %ld\n", (unsigned long)code);
346 ABORT("sem_wait for handler failed");
347 }
348 }
349 # ifdef PARALLEL_MARK
350 GC_release_mark_lock();
351 # endif
352 #if DEBUG_THREADS
353 GC_printf1("World stopped from 0x%lx\n", pthread_self());
354 #endif
355 GC_stopping_thread = 0; /* debugging only */
356 }
357
358 /* Caller holds allocation lock, and has held it continuously since */
359 /* the world stopped. */
GC_start_world()360 void GC_start_world()
361 {
362 pthread_t my_thread = pthread_self();
363 register int i;
364 register GC_thread p;
365 register int n_live_threads = 0;
366 register int result;
367
368 # if DEBUG_THREADS
369 GC_printf0("World starting\n");
370 # endif
371
372 for (i = 0; i < THREAD_TABLE_SZ; i++) {
373 for (p = GC_threads[i]; p != 0; p = p -> next) {
374 if (p -> id != my_thread) {
375 if (p -> flags & FINISHED) continue;
376 if (p -> thread_blocked) continue;
377 n_live_threads++;
378 #if DEBUG_THREADS
379 GC_printf1("Sending restart signal to 0x%lx\n", p -> id);
380 #endif
381
382 result = pthread_kill(p -> id, SIG_THR_RESTART);
383 switch(result) {
384 case ESRCH:
385 /* Not really there anymore. Possible? */
386 n_live_threads--;
387 break;
388 case 0:
389 break;
390 default:
391 ABORT("pthread_kill failed");
392 }
393 }
394 }
395 }
396 #if DEBUG_THREADS
397 GC_printf0("World started\n");
398 #endif
399 }
400
GC_stop_init()401 void GC_stop_init() {
402 struct sigaction act;
403
404 if (sem_init(&GC_suspend_ack_sem, 0, 0) != 0)
405 ABORT("sem_init failed");
406
407 act.sa_flags = SA_RESTART;
408 if (sigfillset(&act.sa_mask) != 0) {
409 ABORT("sigfillset() failed");
410 }
411 # ifdef NO_SIGNALS
412 if (sigdelset(&act.sa_mask, SIGINT) != 0
413 || sigdelset(&act.sa_mask, SIGQUIT != 0)
414 || sigdelset(&act.sa_mask, SIGABRT != 0)
415 || sigdelset(&act.sa_mask, SIGTERM != 0)) {
416 ABORT("sigdelset() failed");
417 }
418 # endif
419
420 /* SIG_THR_RESTART is unmasked by the handler when necessary. */
421 act.sa_handler = GC_suspend_handler;
422 if (sigaction(SIG_SUSPEND, &act, NULL) != 0) {
423 ABORT("Cannot set SIG_SUSPEND handler");
424 }
425
426 act.sa_handler = GC_restart_handler;
427 if (sigaction(SIG_THR_RESTART, &act, NULL) != 0) {
428 ABORT("Cannot set SIG_THR_RESTART handler");
429 }
430
431 /* Check for GC_RETRY_SIGNALS. */
432 if (0 != GETENV("GC_RETRY_SIGNALS")) {
433 GC_retry_signals = TRUE;
434 }
435 if (0 != GETENV("GC_NO_RETRY_SIGNALS")) {
436 GC_retry_signals = FALSE;
437 }
438 # ifdef CONDPRINT
439 if (GC_print_stats && GC_retry_signals) {
440 GC_printf0("Will retry suspend signal if necessary.\n");
441 }
442 # endif
443 }
444
445 #endif
446