boehm-gc/darwin_stop_world.c

   1 #include "private/pthread_support.h"
   2
   3 # if defined(GC_DARWIN_THREADS)
   4
   5 /* From "Inside Mac OS X - Mach-O Runtime Architecture" published by Apple
   6    Page 49:
   7    "The space beneath the stack pointer, where a new stack frame would normally
   8    be allocated, is called the red zone. This area as shown in Figure 3-2 may
   9    be used for any purpose as long as a new stack frame does not need to be
  10    added to the stack."
  11
  12    Page 50: "If a leaf procedure's red zone usage would exceed 224 bytes, then
  13    it must set up a stack frame just like routines that call other routines."
  14 */
  15 #define PPC_RED_ZONE_SIZE 224
  16
  17 /* Not 64-bit clean. Wait until Apple defines their 64-bit ABI */
  18 typedef struct StackFrame {
  19   unsigned int  savedSP;
  20   unsigned int  savedCR;
  21   unsigned int  savedLR;
  22   unsigned int  reserved[2];
  23   unsigned int  savedRTOC;
  24 } StackFrame;
  25
  26
  27 unsigned int FindTopOfStack(unsigned int stack_start) {
  28   StackFrame    *frame;
  29
  30   if (stack_start == 0) {
  31     __asm__ volatile("lwz       %0,0(r1)" : "=r" (frame));
  32   } else {
  33     frame = (StackFrame *)stack_start;
  34   }
  35
  36 # ifdef DEBUG_THREADS
  37     /* GC_printf1("FindTopOfStack start at sp = %p\n", frame); */
  38 # endif
  39   do {
  40     if (frame->savedSP == NULL) break;
  41                 /* if there are no more stack frames, stop */
  42
  43     frame = (StackFrame*)frame->savedSP;
  44
  45     /* we do these next two checks after going to the next frame
  46        because the LR for the first stack frame in the loop
  47        is not set up on purpose, so we shouldn't check it. */
  48     if ((frame->savedLR & ~3) == 0) break; /* if the next LR is bogus, stop */
  49     if ((~(frame->savedLR) & ~3) == 0) break; /* ditto */
  50   } while (1);
  51
  52 # ifdef DEBUG_THREADS
  53     /* GC_printf1("FindTopOfStack finish at sp = %p\n", frame); */
  54 # endif
  55
  56   return (unsigned int)frame;
  57 }
  58
  59 void GC_push_all_stacks() {
  60     int i;
  61     kern_return_t r;
  62     mach_port_t me;
  63     ptr_t lo, hi;
  64     thread_act_array_t act_list = 0;
  65     mach_msg_type_number_t listcount = 0;
  66
  67     me = mach_thread_self();
  68     if (!GC_thr_initialized) GC_thr_init();
  69
  70     r = task_threads(current_task(), &act_list, &listcount);
  71     if(r != KERN_SUCCESS) ABORT("task_threads failed");
  72     for(i = 0; i < listcount; i++) {
  73       thread_act_t thread = act_list[i];
  74       if (thread == me) {
  75         lo = GC_approx_sp();
  76         hi = (ptr_t)FindTopOfStack(0);
  77       } else {
  78 #      ifdef POWERPC
  79         ppc_thread_state_t info;
  80         mach_msg_type_number_t outCount = THREAD_STATE_MAX;
  81         r = thread_get_state(thread, MACHINE_THREAD_STATE,
  82                              (natural_t *)&info, &outCount);
  83         if(r != KERN_SUCCESS) ABORT("task_get_state failed");
  84
  85         lo = (void*)(info.r1 - PPC_RED_ZONE_SIZE);
  86         hi = (ptr_t)FindTopOfStack(info.r1);
  87
  88         GC_push_one(info.r0);
  89         GC_push_one(info.r2);
  90         GC_push_one(info.r3);
  91         GC_push_one(info.r4);
  92         GC_push_one(info.r5);
  93         GC_push_one(info.r6);
  94         GC_push_one(info.r7);
  95         GC_push_one(info.r8);
  96         GC_push_one(info.r9);
  97         GC_push_one(info.r10);
  98         GC_push_one(info.r11);
  99         GC_push_one(info.r12);
 100         GC_push_one(info.r13);
 101         GC_push_one(info.r14);
 102         GC_push_one(info.r15);
 103         GC_push_one(info.r16);
 104         GC_push_one(info.r17);
 105         GC_push_one(info.r18);
 106         GC_push_one(info.r19);
 107         GC_push_one(info.r20);
 108         GC_push_one(info.r21);
 109         GC_push_one(info.r22);
 110         GC_push_one(info.r23);
 111         GC_push_one(info.r24);
 112         GC_push_one(info.r25);
 113         GC_push_one(info.r26);
 114         GC_push_one(info.r27);
 115         GC_push_one(info.r28);
 116         GC_push_one(info.r29);
 117         GC_push_one(info.r30);
 118         GC_push_one(info.r31);
 119 #      else
 120         /* FIXME: Remove after testing: */
 121         WARN("This is completely untested and likely will not work\n", 0);
 122         i386_thread_state_t info;
 123         mach_msg_type_number_t outCount = THREAD_STATE_MAX;
 124         r = thread_get_state(thread, MACHINE_THREAD_STATE,
 125                              (natural_t *)&info, &outCount);
 126         if(r != KERN_SUCCESS) ABORT("task_get_state failed");
 127
 128         lo = (void*)info.esp;
 129         hi = (ptr_t)FindTopOfStack(info.esp);
 130
 131         GC_push_one(info.eax);
 132         GC_push_one(info.ebx);
 133         GC_push_one(info.ecx);
 134         GC_push_one(info.edx);
 135         GC_push_one(info.edi);
 136         GC_push_one(info.esi);
 137         /* GC_push_one(info.ebp);  */
 138         /* GC_push_one(info.esp);  */
 139         GC_push_one(info.ss);
 140         GC_push_one(info.eip);
 141         GC_push_one(info.cs);
 142         GC_push_one(info.ds);
 143         GC_push_one(info.es);
 144         GC_push_one(info.fs);
 145         GC_push_one(info.gs);
 146 #      endif /* !POWERPC */
 147       }
 148 #     if DEBUG_THREADS
 149        GC_printf3("Darwin: Stack for thread 0x%lx = [%lx,%lx)\n",
 150                   (unsigned long) thread,
 151                   (unsigned long) lo,
 152                   (unsigned long) hi
 153                  );
 154 #     endif
 155       GC_push_all_stack(lo, hi);
 156     } /* for(p=GC_threads[i]...) */
 157 }
 158
 159 static mach_port_t GC_mach_handler_thread;
 160 static int GC_use_mach_handler_thread = 0;
 161
 162 static struct GC_mach_thread GC_mach_threads[THREAD_TABLE_SZ];
 163 static int GC_mach_threads_count;
 164
 165 void GC_stop_init() {
 166   int i;
 167
 168   for (i = 0; i < THREAD_TABLE_SZ; i++) {
 169     GC_mach_threads[i].thread = 0;
 170     GC_mach_threads[i].already_suspended = 0;
 171   }
 172   GC_mach_threads_count = 0;
 173 }
 174
 175 /* returns true if there's a thread in act_list that wasn't in old_list */
 176 int GC_suspend_thread_list(thread_act_array_t act_list, int count,
 177                            thread_act_array_t old_list, int old_count) {
 178   mach_port_t my_thread = mach_thread_self();
 179   int i, j;
 180
 181   int changed = 0;
 182
 183   for(i = 0; i < count; i++) {
 184     thread_act_t thread = act_list[i];
 185 #   if DEBUG_THREADS
 186       GC_printf1("Attempting to suspend thread %p\n", thread);
 187 #   endif
 188     /* find the current thread in the old list */
 189     int found = 0;
 190     for(j = 0; j < old_count; j++) {
 191       thread_act_t old_thread = old_list[j];
 192       if (old_thread == thread) {
 193         found = 1;
 194         break;
 195       }
 196     }
 197     if (!found) {
 198       /* add it to the GC_mach_threads list */
 199       GC_mach_threads[GC_mach_threads_count].thread = thread;
 200       /* default is not suspended */
 201       GC_mach_threads[GC_mach_threads_count].already_suspended = 0;
 202       changed = 1;
 203     }
 204
 205     if (thread != my_thread &&
 206         (!GC_use_mach_handler_thread
 207          || (GC_use_mach_handler_thread
 208              && GC_mach_handler_thread != thread))) {
 209       struct thread_basic_info info;
 210       mach_msg_type_number_t outCount = THREAD_INFO_MAX;
 211       kern_return_t kern_result = thread_info(thread, THREAD_BASIC_INFO,
 212                                 (thread_info_t)&info, &outCount);
 213       if(kern_result != KERN_SUCCESS) {
 214         /* the thread may have quit since the thread_threads () call
 215          * we mark already_suspended so it's not dealt with anymore later
 216          */
 217         if (!found) {
 218           GC_mach_threads[GC_mach_threads_count].already_suspended = TRUE;
 219           GC_mach_threads_count++;
 220         }
 221         continue;
 222       }
 223 #     if DEBUG_THREADS
 224         GC_printf2("Thread state for 0x%lx = %d\n", thread, info.run_state);
 225 #     endif
 226       if (!found) {
 227         GC_mach_threads[GC_mach_threads_count].already_suspended = info.suspend_count;
 228       }
 229       if (info.suspend_count) continue;
 230
 231 #     if DEBUG_THREADS
 232         GC_printf1("Suspending 0x%lx\n", thread);
 233 #     endif
 234       /* Suspend the thread */
 235       kern_result = thread_suspend(thread);
 236       if(kern_result != KERN_SUCCESS) {
 237         /* the thread may have quit since the thread_threads () call
 238          * we mark already_suspended so it's not dealt with anymore later
 239          */
 240         if (!found) {
 241           GC_mach_threads[GC_mach_threads_count].already_suspended = TRUE;
 242           GC_mach_threads_count++;
 243         }
 244         continue;
 245       }
 246     }
 247     if (!found) GC_mach_threads_count++;
 248   }
 249   return changed;
 250 }
 251
 252
 253 /* Caller holds allocation lock.        */
 254 void GC_stop_world()
 255 {
 256   int i, changes;
 257     GC_thread p;
 258     mach_port_t my_thread = mach_thread_self();
 259     kern_return_t kern_result;
 260     thread_act_array_t act_list, prev_list;
 261     mach_msg_type_number_t listcount, prevcount;
 262
 263 #   if DEBUG_THREADS
 264       GC_printf1("Stopping the world from 0x%lx\n", mach_thread_self());
 265 #   endif
 266
 267     /* clear out the mach threads list table */
 268     GC_stop_init();
 269
 270     /* Make sure all free list construction has stopped before we start. */
 271     /* No new construction can start, since free list construction is   */
 272     /* required to acquire and release the GC lock before it starts,    */
 273     /* and we have the lock.                                            */
 274 #   ifdef PARALLEL_MARK
 275       GC_acquire_mark_lock();
 276       GC_ASSERT(GC_fl_builder_count == 0);
 277       /* We should have previously waited for it to become zero. */
 278 #   endif /* PARALLEL_MARK */
 279
 280       /* Loop stopping threads until you have gone over the whole list
 281          twice without a new one appearing. thread_create() won't
 282          return (and thus the thread stop) until the new thread
 283          exists, so there is no window whereby you could stop a
 284          thread, recognise it is stopped, but then have a new thread
 285          it created before stopping show up later.
 286       */
 287
 288       changes = 1;
 289       prev_list = NULL;
 290       prevcount = 0;
 291       do {
 292         int result;
 293         kern_result = task_threads(current_task(), &act_list, &listcount);
 294         result = GC_suspend_thread_list(act_list, listcount,
 295                                         prev_list, prevcount);
 296         changes = result;
 297         prev_list = act_list;
 298         prevcount = listcount;
 299       } while (changes);
 300
 301
 302 #   ifdef MPROTECT_VDB
 303       if(GC_incremental) {
 304         extern void GC_mprotect_stop();
 305         GC_mprotect_stop();
 306       }
 307 #   endif
 308
 309 #   ifdef PARALLEL_MARK
 310       GC_release_mark_lock();
 311 #   endif
 312     #if DEBUG_THREADS
 313       GC_printf1("World stopped from 0x%lx\n", my_thread);
 314     #endif
 315 }
 316
 317 /* Caller holds allocation lock, and has held it continuously since     */
 318 /* the world stopped.                                                   */
 319 void GC_start_world()
 320 {
 321   mach_port_t my_thread = mach_thread_self();
 322   int i, j;
 323   GC_thread p;
 324   kern_return_t kern_result;
 325   thread_act_array_t act_list;
 326   mach_msg_type_number_t listcount;
 327
 328 #   if DEBUG_THREADS
 329       GC_printf0("World starting\n");
 330 #   endif
 331
 332 #   ifdef MPROTECT_VDB
 333       if(GC_incremental) {
 334         extern void GC_mprotect_resume();
 335         GC_mprotect_resume();
 336       }
 337 #   endif
 338
 339     kern_result = task_threads(current_task(), &act_list, &listcount);
 340     for(i = 0; i < listcount; i++) {
 341       thread_act_t thread = act_list[i];
 342       if (thread != my_thread &&
 343           (!GC_use_mach_handler_thread ||
 344            (GC_use_mach_handler_thread && GC_mach_handler_thread != thread))) {
 345         for(j = 0; j < GC_mach_threads_count; j++) {
 346           if (thread == GC_mach_threads[j].thread) {
 347             if (GC_mach_threads[j].already_suspended) {
 348 #             if DEBUG_THREADS
 349                 GC_printf1("Not resuming already suspended thread %p\n", thread);
 350 #             endif
 351               continue;
 352             }
 353             struct thread_basic_info info;
 354             mach_msg_type_number_t outCount = THREAD_INFO_MAX;
 355             kern_result = thread_info(thread, THREAD_BASIC_INFO,
 356                                       (thread_info_t)&info, &outCount);
 357             if(kern_result != KERN_SUCCESS) ABORT("thread_info failed");
 358 #           if DEBUG_THREADS
 359               GC_printf2("Thread state for 0x%lx = %d\n", thread,
 360                          info.run_state);
 361               GC_printf1("Resuming 0x%lx\n", thread);
 362 #           endif
 363             /* Resume the thread */
 364             kern_result = thread_resume(thread);
 365             if(kern_result != KERN_SUCCESS) ABORT("thread_resume failed");
 366           }
 367         }
 368       }
 369     }
 370 #   if DEBUG_THREADS
 371      GC_printf0("World started\n");
 372 #   endif
 373 }
 374
 375 void GC_darwin_register_mach_handler_thread(mach_port_t thread) {
 376   GC_mach_handler_thread = thread;
 377   GC_use_mach_handler_thread = 1;
 378 }
 379
 380 #endif