diff options
Diffstat (limited to 'boehm-gc/darwin_stop_world.c')
| -rw-r--r-- | boehm-gc/darwin_stop_world.c | 445 |
1 files changed, 308 insertions, 137 deletions
diff --git a/boehm-gc/darwin_stop_world.c b/boehm-gc/darwin_stop_world.c index bc2247fa4e7..36378cbbce0 100644 --- a/boehm-gc/darwin_stop_world.c +++ b/boehm-gc/darwin_stop_world.c @@ -2,8 +2,6 @@ # if defined(GC_DARWIN_THREADS) -#define DEBUG_THREADS 0 - /* From "Inside Mac OS X - Mach-O Runtime Architecture" published by Apple Page 49: "The space beneath the stack pointer, where a new stack frame would normally @@ -16,101 +14,258 @@ */ #define PPC_RED_ZONE_SIZE 224 +/* Not 64-bit clean. Wait until Apple defines their 64-bit ABI */ +typedef struct StackFrame { + unsigned int savedSP; + unsigned int savedCR; + unsigned int savedLR; + unsigned int reserved[2]; + unsigned int savedRTOC; +} StackFrame; + + +unsigned int FindTopOfStack(unsigned int stack_start) { + StackFrame *frame; + + if (stack_start == 0) { + __asm__ volatile("lwz %0,0(r1)" : "=r" (frame)); + } else { + frame = (StackFrame *)stack_start; + } + +# ifdef DEBUG_THREADS + /* GC_printf1("FindTopOfStack start at sp = %p\n", frame); */ +# endif + do { + if (frame->savedSP == NULL) break; + /* if there are no more stack frames, stop */ + + frame = (StackFrame*)frame->savedSP; + + /* we do these next two checks after going to the next frame + because the LR for the first stack frame in the loop + is not set up on purpose, so we shouldn't check it. */ + if ((frame->savedLR & ~3) == 0) break; /* if the next LR is bogus, stop */ + if ((~(frame->savedLR) & ~3) == 0) break; /* ditto */ + } while (1); + +# ifdef DEBUG_THREADS + /* GC_printf1("FindTopOfStack finish at sp = %p\n", frame); */ +# endif + + return (unsigned int)frame; +} + void GC_push_all_stacks() { int i; kern_return_t r; - GC_thread p; - pthread_t me; + mach_port_t me; ptr_t lo, hi; -# if defined(POWERPC) - ppc_thread_state_t state; -# else -# error FIXME for non-ppc OS X -# endif - mach_msg_type_number_t thread_state_count = MACHINE_THREAD_STATE_COUNT; - - me = pthread_self(); + thread_act_array_t act_list = 0; + mach_msg_type_number_t listcount = 0; + + me = mach_thread_self(); if (!GC_thr_initialized) GC_thr_init(); - for(i=0;i<THREAD_TABLE_SZ;i++) { - for(p=GC_threads[i];p!=0;p=p->next) { - if(p -> flags & FINISHED) continue; - if(pthread_equal(p->id,me)) { - lo = GC_approx_sp(); - } else { - /* Get the thread state (registers, etc) */ - r = thread_get_state( - p->stop_info.mach_thread, - MACHINE_THREAD_STATE, - (natural_t*)&state, - &thread_state_count); - if(r != KERN_SUCCESS) ABORT("thread_get_state failed"); - - #ifdef POWERPC - lo = (void*)(state.r1 - PPC_RED_ZONE_SIZE); - - GC_push_one(state.r0); - GC_push_one(state.r2); - GC_push_one(state.r3); - GC_push_one(state.r4); - GC_push_one(state.r5); - GC_push_one(state.r6); - GC_push_one(state.r7); - GC_push_one(state.r8); - GC_push_one(state.r9); - GC_push_one(state.r10); - GC_push_one(state.r11); - GC_push_one(state.r12); - GC_push_one(state.r13); - GC_push_one(state.r14); - GC_push_one(state.r15); - GC_push_one(state.r16); - GC_push_one(state.r17); - GC_push_one(state.r18); - GC_push_one(state.r19); - GC_push_one(state.r20); - GC_push_one(state.r21); - GC_push_one(state.r22); - GC_push_one(state.r23); - GC_push_one(state.r24); - GC_push_one(state.r25); - GC_push_one(state.r26); - GC_push_one(state.r27); - GC_push_one(state.r28); - GC_push_one(state.r29); - GC_push_one(state.r30); - GC_push_one(state.r31); - #else - # error FIXME for non-PPC darwin - #endif /* !POWERPC */ - } /* p != me */ - if(p->flags & MAIN_THREAD) - hi = GC_stackbottom; - else - hi = p->stack_end; - #if DEBUG_THREADS - GC_printf3("Darwin: Stack for thread 0x%lx = [%lx,%lx)\n", - (unsigned long) p -> id, - (unsigned long) lo, - (unsigned long) hi - ); - #endif - GC_push_all_stack(lo,hi); - } /* for(p=GC_threads[i]...) */ - } /* for(i=0;i<THREAD_TABLE_SZ...) */ + r = task_threads(current_task(), &act_list, &listcount); + if(r != KERN_SUCCESS) ABORT("task_threads failed"); + for(i = 0; i < listcount; i++) { + thread_act_t thread = act_list[i]; + if (thread == me) { + lo = GC_approx_sp(); + hi = (ptr_t)FindTopOfStack(0); + } else { +# ifdef POWERPC + ppc_thread_state_t info; + mach_msg_type_number_t outCount = THREAD_STATE_MAX; + r = thread_get_state(thread, MACHINE_THREAD_STATE, + (natural_t *)&info, &outCount); + if(r != KERN_SUCCESS) ABORT("task_get_state failed"); + + lo = (void*)(info.r1 - PPC_RED_ZONE_SIZE); + hi = (ptr_t)FindTopOfStack(info.r1); + + GC_push_one(info.r0); + GC_push_one(info.r2); + GC_push_one(info.r3); + GC_push_one(info.r4); + GC_push_one(info.r5); + GC_push_one(info.r6); + GC_push_one(info.r7); + GC_push_one(info.r8); + GC_push_one(info.r9); + GC_push_one(info.r10); + GC_push_one(info.r11); + GC_push_one(info.r12); + GC_push_one(info.r13); + GC_push_one(info.r14); + GC_push_one(info.r15); + GC_push_one(info.r16); + GC_push_one(info.r17); + GC_push_one(info.r18); + GC_push_one(info.r19); + GC_push_one(info.r20); + GC_push_one(info.r21); + GC_push_one(info.r22); + GC_push_one(info.r23); + GC_push_one(info.r24); + GC_push_one(info.r25); + GC_push_one(info.r26); + GC_push_one(info.r27); + GC_push_one(info.r28); + GC_push_one(info.r29); + GC_push_one(info.r30); + GC_push_one(info.r31); +# else + /* FIXME: Remove after testing: */ + WARN("This is completely untested and likely will not work\n", 0); + i386_thread_state_t info; + mach_msg_type_number_t outCount = THREAD_STATE_MAX; + r = thread_get_state(thread, MACHINE_THREAD_STATE, + (natural_t *)&info, &outCount); + if(r != KERN_SUCCESS) ABORT("task_get_state failed"); + + lo = (void*)info.esp; + hi = (ptr_t)FindTopOfStack(info.esp); + + GC_push_one(info.eax); + GC_push_one(info.ebx); + GC_push_one(info.ecx); + GC_push_one(info.edx); + GC_push_one(info.edi); + GC_push_one(info.esi); + /* GC_push_one(info.ebp); */ + /* GC_push_one(info.esp); */ + GC_push_one(info.ss); + GC_push_one(info.eip); + GC_push_one(info.cs); + GC_push_one(info.ds); + GC_push_one(info.es); + GC_push_one(info.fs); + GC_push_one(info.gs); +# endif /* !POWERPC */ + } +# if DEBUG_THREADS + GC_printf3("Darwin: Stack for thread 0x%lx = [%lx,%lx)\n", + (unsigned long) thread, + (unsigned long) lo, + (unsigned long) hi + ); +# endif + GC_push_all_stack(lo, hi); + } /* for(p=GC_threads[i]...) */ +} + +static mach_port_t GC_mach_handler_thread; +static int GC_use_mach_handler_thread = 0; + +static struct GC_mach_thread GC_mach_threads[THREAD_TABLE_SZ]; +static int GC_mach_threads_count; + +void GC_stop_init() { + int i; + + for (i = 0; i < THREAD_TABLE_SZ; i++) { + GC_mach_threads[i].thread = 0; + GC_mach_threads[i].already_suspended = 0; + } + GC_mach_threads_count = 0; +} + +/* returns true if there's a thread in act_list that wasn't in old_list */ +int GC_suspend_thread_list(thread_act_array_t act_list, int count, + thread_act_array_t old_list, int old_count) { + mach_port_t my_thread = mach_thread_self(); + int i, j; + + int changed = 0; + + for(i = 0; i < count; i++) { + thread_act_t thread = act_list[i]; +# if DEBUG_THREADS + GC_printf1("Attempting to suspend thread %p\n", thread); +# endif + /* find the current thread in the old list */ + int found = 0; + for(j = 0; j < old_count; j++) { + thread_act_t old_thread = old_list[j]; + if (old_thread == thread) { + found = 1; + break; + } + } + if (!found) { + /* add it to the GC_mach_threads list */ + GC_mach_threads[GC_mach_threads_count].thread = thread; + /* default is not suspended */ + GC_mach_threads[GC_mach_threads_count].already_suspended = 0; + changed = 1; + } + + if (thread != my_thread && + (!GC_use_mach_handler_thread + || (GC_use_mach_handler_thread + && GC_mach_handler_thread != thread))) { + struct thread_basic_info info; + mach_msg_type_number_t outCount = THREAD_INFO_MAX; + kern_return_t kern_result = thread_info(thread, THREAD_BASIC_INFO, + (thread_info_t)&info, &outCount); + if(kern_result != KERN_SUCCESS) { + /* the thread may have quit since the thread_threads () call + * we mark already_suspended so it's not dealt with anymore later + */ + if (!found) { + GC_mach_threads[GC_mach_threads_count].already_suspended = TRUE; + GC_mach_threads_count++; + } + continue; + } +# if DEBUG_THREADS + GC_printf2("Thread state for 0x%lx = %d\n", thread, info.run_state); +# endif + if (!found) { + GC_mach_threads[GC_mach_threads_count].already_suspended = info.suspend_count; + } + if (info.suspend_count) continue; + +# if DEBUG_THREADS + GC_printf1("Suspending 0x%lx\n", thread); +# endif + /* Suspend the thread */ + kern_result = thread_suspend(thread); + if(kern_result != KERN_SUCCESS) { + /* the thread may have quit since the thread_threads () call + * we mark already_suspended so it's not dealt with anymore later + */ + if (!found) { + GC_mach_threads[GC_mach_threads_count].already_suspended = TRUE; + GC_mach_threads_count++; + } + continue; + } + } + if (!found) GC_mach_threads_count++; + } + return changed; } + /* Caller holds allocation lock. */ void GC_stop_world() { - int i; + int i, changes; GC_thread p; - pthread_t my_thread = pthread_self(); + mach_port_t my_thread = mach_thread_self(); kern_return_t kern_result; + thread_act_array_t act_list, prev_list; + mach_msg_type_number_t listcount, prevcount; - #if DEBUG_THREADS - GC_printf1("Stopping the world from 0x%lx\n", pthread_self()); - #endif +# if DEBUG_THREADS + GC_printf1("Stopping the world from 0x%lx\n", mach_thread_self()); +# endif + + /* clear out the mach threads list table */ + GC_stop_init(); /* Make sure all free list construction has stopped before we start. */ /* No new construction can start, since free list construction is */ @@ -122,43 +277,40 @@ void GC_stop_world() /* We should have previously waited for it to become zero. */ # endif /* PARALLEL_MARK */ - for (i = 0; i < THREAD_TABLE_SZ; i++) { - for (p = GC_threads[i]; p != 0; p = p -> next) { - if (p -> id == my_thread) continue; - if (p -> flags & FINISHED) continue; - if (p -> thread_blocked) /* Will wait */ continue; - - #if DEBUG_THREADS - GC_printf1("Suspending thread 0x%lx\n", p -> id); - #endif - - /* Suspend the thread */ - kern_result = thread_suspend(p->stop_info.mach_thread); - if(kern_result != KERN_SUCCESS) ABORT("thread_suspend failed"); - - /* This is only needed if we are modifying the threads - state. thread_abort_safely should also be used - if this code is ever added in again. - - kern_result = thread_abort(p->stop_info.mach_thread); - if(kern_result != KERN_SUCCESS) - ABORT("thread_abort failed (%ul)",kern_result); - */ - } - } - + /* Loop stopping threads until you have gone over the whole list + twice without a new one appearing. thread_create() won't + return (and thus the thread stop) until the new thread + exists, so there is no window whereby you could stop a + thread, recognise it is stopped, but then have a new thread + it created before stopping show up later. + */ + + changes = 1; + prev_list = NULL; + prevcount = 0; + do { + int result; + kern_result = task_threads(current_task(), &act_list, &listcount); + result = GC_suspend_thread_list(act_list, listcount, + prev_list, prevcount); + changes = result; + prev_list = act_list; + prevcount = listcount; + } while (changes); + + # ifdef MPROTECT_VDB - if(GC_incremental) { + if(GC_incremental) { extern void GC_mprotect_stop(); GC_mprotect_stop(); - } + } # endif # ifdef PARALLEL_MARK GC_release_mark_lock(); # endif #if DEBUG_THREADS - GC_printf1("World stopped from 0x%lx\n", pthread_self()); + GC_printf1("World stopped from 0x%lx\n", my_thread); #endif } @@ -166,44 +318,63 @@ void GC_stop_world() /* the world stopped. */ void GC_start_world() { - pthread_t my_thread = pthread_self(); - int i; - GC_thread p; - kern_return_t kern_result; - + mach_port_t my_thread = mach_thread_self(); + int i, j; + GC_thread p; + kern_return_t kern_result; + thread_act_array_t act_list; + mach_msg_type_number_t listcount; + # if DEBUG_THREADS GC_printf0("World starting\n"); # endif # ifdef MPROTECT_VDB - if(GC_incremental) { + if(GC_incremental) { extern void GC_mprotect_resume(); GC_mprotect_resume(); - } + } # endif - for (i = 0; i < THREAD_TABLE_SZ; i++) { - for (p = GC_threads[i]; p != 0; p = p -> next) { - if (p -> id == my_thread) continue; - if (p -> flags & FINISHED) continue; - if (p -> thread_blocked) continue; - - #if DEBUG_THREADS - GC_printf1("Resuming 0x%lx\n", p -> id); - #endif - - /* Resume the thread */ - kern_result = thread_resume(p->stop_info.mach_thread); - if(kern_result != KERN_SUCCESS) ABORT("thread_resume failed"); - } + kern_result = task_threads(current_task(), &act_list, &listcount); + for(i = 0; i < listcount; i++) { + thread_act_t thread = act_list[i]; + if (thread != my_thread && + (!GC_use_mach_handler_thread || + (GC_use_mach_handler_thread && GC_mach_handler_thread != thread))) { + for(j = 0; j < GC_mach_threads_count; j++) { + if (thread == GC_mach_threads[j].thread) { + if (GC_mach_threads[j].already_suspended) { +# if DEBUG_THREADS + GC_printf1("Not resuming already suspended thread %p\n", thread); +# endif + continue; + } + struct thread_basic_info info; + mach_msg_type_number_t outCount = THREAD_INFO_MAX; + kern_result = thread_info(thread, THREAD_BASIC_INFO, + (thread_info_t)&info, &outCount); + if(kern_result != KERN_SUCCESS) ABORT("thread_info failed"); +# if DEBUG_THREADS + GC_printf2("Thread state for 0x%lx = %d\n", thread, + info.run_state); + GC_printf1("Resuming 0x%lx\n", thread); +# endif + /* Resume the thread */ + kern_result = thread_resume(thread); + if(kern_result != KERN_SUCCESS) ABORT("thread_resume failed"); + } + } + } } - #if DEBUG_THREADS - GC_printf0("World started\n"); - #endif +# if DEBUG_THREADS + GC_printf0("World started\n"); +# endif } -void GC_stop_init() { - +void GC_darwin_register_mach_handler_thread(mach_port_t thread) { + GC_mach_handler_thread = thread; + GC_use_mach_handler_thread = 1; } #endif |