libgc/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) continue;
  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) continue;
 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     vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
 158 }
 159
 160 static mach_port_t GC_mach_handler_thread;
 161 static int GC_use_mach_handler_thread = 0;
 162
 163 static struct GC_mach_thread GC_mach_threads[THREAD_TABLE_SZ];
 164 static int GC_mach_threads_count;
 165
 166 void GC_stop_init() {
 167   int i;
 168
 169   for (i = 0; i < THREAD_TABLE_SZ; i++) {
 170     GC_mach_threads[i].thread = 0;
 171     GC_mach_threads[i].already_suspended = 0;
 172   }
 173   GC_mach_threads_count = 0;
 174 }
 175
 176 /* returns true if there's a thread in act_list that wasn't in old_list */
 177 int GC_suspend_thread_list(thread_act_array_t act_list, int count,
 178                            thread_act_array_t old_list, int old_count) {
 179   mach_port_t my_thread = mach_thread_self();
 180   int i, j;
 181
 182   int changed = 0;
 183
 184   for(i = 0; i < count; i++) {
 185     thread_act_t thread = act_list[i];
 186 #   if DEBUG_THREADS
 187       GC_printf1("Attempting to suspend thread %p\n", thread);
 188 #   endif
 189     /* find the current thread in the old list */
 190     int found = 0;
 191     for(j = 0; j < old_count; j++) {
 192       thread_act_t old_thread = old_list[j];
 193       if (old_thread == thread) {
 194         found = 1;
 195         break;
 196       }
 197     }
 198     if (!found) {
 199       /* add it to the GC_mach_threads list */
 200       GC_mach_threads[GC_mach_threads_count].thread = thread;
 201       /* default is not suspended */
 202       GC_mach_threads[GC_mach_threads_count].already_suspended = 0;
 203       changed = 1;
 204     }
 205
 206     if (thread != my_thread &&
 207         (!GC_use_mach_handler_thread
 208          || (GC_use_mach_handler_thread
 209              && GC_mach_handler_thread != thread))) {
 210       struct thread_basic_info info;
 211       mach_msg_type_number_t outCount = THREAD_INFO_MAX;
 212       kern_return_t kern_result = thread_info(thread, THREAD_BASIC_INFO,
 213                                 (thread_info_t)&info, &outCount);
 214       if(kern_result != KERN_SUCCESS) {
 215         /* the thread may have quit since the thread_threads () call
 216          * we mark already_suspended so it's not dealt with anymore later
 217          */
 218         if (!found) {
 219           GC_mach_threads[GC_mach_threads_count].already_suspended = TRUE;
 220           GC_mach_threads_count++;
 221         }
 222         continue;
 223       }
 224 #     if DEBUG_THREADS
 225         GC_printf2("Thread state for 0x%lx = %d\n", thread, info.run_state);
 226 #     endif
 227       if (!found) {
 228         GC_mach_threads[GC_mach_threads_count].already_suspended = info.suspend_count;
 229       }
 230       if (info.suspend_count) continue;
 231
 232 #     if DEBUG_THREADS
 233         GC_printf1("Suspending 0x%lx\n", thread);
 234 #     endif
 235       /* Suspend the thread */
 236       kern_result = thread_suspend(thread);
 237       if(kern_result != KERN_SUCCESS) {
 238         /* the thread may have quit since the thread_threads () call
 239          * we mark already_suspended so it's not dealt with anymore later
 240          */
 241         if (!found) {
 242           GC_mach_threads[GC_mach_threads_count].already_suspended = TRUE;
 243           GC_mach_threads_count++;
 244         }
 245         continue;
 246       }
 247     }
 248     if (!found) GC_mach_threads_count++;
 249   }
 250   return changed;
 251 }
 252
 253
 254 /* Caller holds allocation lock.        */
 255 void GC_stop_world()
 256 {
 257   int i, changes;
 258     GC_thread p;
 259     mach_port_t my_thread = mach_thread_self();
 260     kern_return_t kern_result;
 261     thread_act_array_t act_list, prev_list;
 262     mach_msg_type_number_t listcount, prevcount;
 263
 264 #   if DEBUG_THREADS
 265       GC_printf1("Stopping the world from 0x%lx\n", mach_thread_self());
 266 #   endif
 267
 268     /* clear out the mach threads list table */
 269     GC_stop_init();
 270
 271     /* Make sure all free list construction has stopped before we start. */
 272     /* No new construction can start, since free list construction is   */
 273     /* required to acquire and release the GC lock before it starts,    */
 274     /* and we have the lock.                                            */
 275 #   ifdef PARALLEL_MARK
 276       GC_acquire_mark_lock();
 277       GC_ASSERT(GC_fl_builder_count == 0);
 278       /* We should have previously waited for it to become zero. */
 279 #   endif /* PARALLEL_MARK */
 280
 281       /* Loop stopping threads until you have gone over the whole list
 282          twice without a new one appearing. thread_create() won't
 283          return (and thus the thread stop) until the new thread
 284          exists, so there is no window whereby you could stop a
 285          thread, recognise it is stopped, but then have a new thread
 286          it created before stopping show up later.
 287       */
 288
 289       changes = 1;
 290       prev_list = NULL;
 291       prevcount = 0;
 292       do {
 293         int result;
 294         kern_result = task_threads(current_task(), &act_list, &listcount);
 295         result = GC_suspend_thread_list(act_list, listcount,
 296                                         prev_list, prevcount);
 297         changes = result;
 298         prev_list = act_list;
 299         prevcount = listcount;
 300         vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
 301       } while (changes);
 302
 303
 304 #   ifdef MPROTECT_VDB
 305       if(GC_incremental) {
 306         extern void GC_mprotect_stop();
 307         GC_mprotect_stop();
 308       }
 309 #   endif
 310
 311 #   ifdef PARALLEL_MARK
 312       GC_release_mark_lock();
 313 #   endif
 314     #if DEBUG_THREADS
 315       GC_printf1("World stopped from 0x%lx\n", my_thread);
 316     #endif
 317 }
 318
 319 /* Caller holds allocation lock, and has held it continuously since     */
 320 /* the world stopped.                                                   */
 321 void GC_start_world()
 322 {
 323   mach_port_t my_thread = mach_thread_self();
 324   int i, j;
 325   GC_thread p;
 326   kern_return_t kern_result;
 327   thread_act_array_t act_list;
 328   mach_msg_type_number_t listcount;
 329
 330 #   if DEBUG_THREADS
 331       GC_printf0("World starting\n");
 332 #   endif
 333
 334 #   ifdef MPROTECT_VDB
 335       if(GC_incremental) {
 336         extern void GC_mprotect_resume();
 337         GC_mprotect_resume();
 338       }
 339 #   endif
 340
 341     kern_result = task_threads(current_task(), &act_list, &listcount);
 342     for(i = 0; i < listcount; i++) {
 343       thread_act_t thread = act_list[i];
 344       if (thread != my_thread &&
 345           (!GC_use_mach_handler_thread ||
 346            (GC_use_mach_handler_thread && GC_mach_handler_thread != thread))) {
 347         for(j = 0; j < GC_mach_threads_count; j++) {
 348           if (thread == GC_mach_threads[j].thread) {
 349             if (GC_mach_threads[j].already_suspended) {
 350 #             if DEBUG_THREADS
 351                 GC_printf1("Not resuming already suspended thread %p\n", thread);
 352 #             endif
 353               continue;
 354             }
 355             struct thread_basic_info info;
 356             mach_msg_type_number_t outCount = THREAD_INFO_MAX;
 357             kern_result = thread_info(thread, THREAD_BASIC_INFO,
 358                                       (thread_info_t)&info, &outCount);
 359             if(kern_result != KERN_SUCCESS) continue;
 360 #           if DEBUG_THREADS
 361               GC_printf2("Thread state for 0x%lx = %d\n", thread,
 362                          info.run_state);
 363               GC_printf1("Resuming 0x%lx\n", thread);
 364 #           endif
 365             /* Resume the thread */
 366             kern_result = thread_resume(thread);
 367             if(kern_result != KERN_SUCCESS) continue;
 368           }
 369         }
 370       }
 371     }
 372     vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
 373 #   if DEBUG_THREADS
 374      GC_printf0("World started\n");
 375 #   endif
 376 }
 377
 378 void GC_darwin_register_mach_handler_thread(mach_port_t thread) {
 379   GC_mach_handler_thread = thread;
 380   GC_use_mach_handler_thread = 1;
 381 }
 382
 383 #endif