mono/metadata/threads.c

   1 /**
   2  * \file
   3  * Thread support internal calls
   4  *
   5  * Author:
   6  *      Dick Porter (dick@ximian.com)
   7  *      Paolo Molaro (lupus@ximian.com)
   8  *      Patrik Torstensson (patrik.torstensson@labs2.com)
   9  *
  10  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  11  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  12  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
  13  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  14  */
  15
  16 #include <config.h>
  17
  18 #include <glib.h>
  19 #include <string.h>
  20
  21 #include <mono/metadata/object.h>
  22 #include <mono/metadata/domain-internals.h>
  23 #include <mono/metadata/profiler-private.h>
  24 #include <mono/metadata/threads.h>
  25 #include <mono/metadata/threads-types.h>
  26 #include <mono/metadata/exception.h>
  27 #include <mono/metadata/environment.h>
  28 #include <mono/metadata/monitor.h>
  29 #include <mono/metadata/gc-internals.h>
  30 #include <mono/metadata/marshal.h>
  31 #include <mono/metadata/runtime.h>
  32 #include <mono/metadata/object-internals.h>
  33 #include <mono/metadata/debug-internals.h>
  34 #include <mono/utils/monobitset.h>
  35 #include <mono/utils/mono-compiler.h>
  36 #include <mono/utils/mono-mmap.h>
  37 #include <mono/utils/mono-membar.h>
  38 #include <mono/utils/mono-time.h>
  39 #include <mono/utils/mono-threads.h>
  40 #include <mono/utils/mono-threads-coop.h>
  41 #include <mono/utils/hazard-pointer.h>
  42 #include <mono/utils/mono-tls.h>
  43 #include <mono/utils/atomic.h>
  44 #include <mono/utils/mono-memory-model.h>
  45 #include <mono/utils/mono-error-internals.h>
  46 #include <mono/utils/os-event.h>
  47 #include <mono/utils/mono-threads-debug.h>
  48 #include <mono/utils/unlocked.h>
  49 #include <mono/metadata/w32handle.h>
  50 #include <mono/metadata/w32event.h>
  51 #include <mono/metadata/w32mutex.h>
  52
  53 #include <mono/metadata/reflection-internals.h>
  54 #include <mono/metadata/abi-details.h>
  55 #include <mono/metadata/w32error.h>
  56 #include <mono/utils/w32api.h>
  57
  58 #ifdef HAVE_SIGNAL_H
  59 #include <signal.h>
  60 #endif
  61
  62 #if defined(HOST_WIN32)
  63 #include <objbase.h>
  64 #endif
  65
  66 #if defined(HOST_ANDROID) && !defined(TARGET_ARM64) && !defined(TARGET_AMD64)
  67 #define USE_TKILL_ON_ANDROID 1
  68 #endif
  69
  70 #ifdef HOST_ANDROID
  71 #include <errno.h>
  72
  73 #ifdef USE_TKILL_ON_ANDROID
  74 extern int tkill (pid_t tid, int signal);
  75 #endif
  76 #endif
  77
  78 /*#define THREAD_DEBUG(a) do { a; } while (0)*/
  79 #define THREAD_DEBUG(a)
  80 /*#define THREAD_WAIT_DEBUG(a) do { a; } while (0)*/
  81 #define THREAD_WAIT_DEBUG(a)
  82 /*#define LIBGC_DEBUG(a) do { a; } while (0)*/
  83 #define LIBGC_DEBUG(a)
  84
  85 #define SPIN_TRYLOCK(i) (InterlockedCompareExchange (&(i), 1, 0) == 0)
  86 #define SPIN_LOCK(i) do { \
  87                                 if (SPIN_TRYLOCK (i)) \
  88                                         break; \
  89                         } while (1)
  90
  91 #define SPIN_UNLOCK(i) i = 0
  92
  93 #define LOCK_THREAD(thread) lock_thread((thread))
  94 #define UNLOCK_THREAD(thread) unlock_thread((thread))
  95
  96 typedef union {
  97         gint32 ival;
  98         gfloat fval;
  99 } IntFloatUnion;
 100
 101 typedef union {
 102         gint64 ival;
 103         gdouble fval;
 104 } LongDoubleUnion;
 105
 106 typedef struct _StaticDataFreeList StaticDataFreeList;
 107 struct _StaticDataFreeList {
 108         StaticDataFreeList *next;
 109         guint32 offset;
 110         guint32 size;
 111 };
 112
 113 typedef struct {
 114         int idx;
 115         int offset;
 116         StaticDataFreeList *freelist;
 117 } StaticDataInfo;
 118
 119 /* Controls access to the 'threads' hash table */
 120 static void mono_threads_lock (void);
 121 static void mono_threads_unlock (void);
 122 static MonoCoopMutex threads_mutex;
 123
 124 /* Controls access to the 'joinable_threads' hash table */
 125 #define joinable_threads_lock() mono_os_mutex_lock (&joinable_threads_mutex)
 126 #define joinable_threads_unlock() mono_os_mutex_unlock (&joinable_threads_mutex)
 127 static mono_mutex_t joinable_threads_mutex;
 128
 129 /* Holds current status of static data heap */
 130 static StaticDataInfo thread_static_info;
 131 static StaticDataInfo context_static_info;
 132
 133 /* The hash of existing threads (key is thread ID, value is
 134  * MonoInternalThread*) that need joining before exit
 135  */
 136 static MonoGHashTable *threads=NULL;
 137
 138 /* List of app context GC handles.
 139  * Added to from mono_threads_register_app_context ().
 140  */
 141 static GHashTable *contexts = NULL;
 142
 143 /* Cleanup queue for contexts. */
 144 static MonoReferenceQueue *context_queue;
 145
 146 /*
 147  * Threads which are starting up and they are not in the 'threads' hash yet.
 148  * When mono_thread_attach_internal is called for a thread, it will be removed from this hash table.
 149  * Protected by mono_threads_lock ().
 150  */
 151 static MonoGHashTable *threads_starting_up = NULL;
 152
 153 /* Contains tids */
 154 /* Protected by the threads lock */
 155 static GHashTable *joinable_threads;
 156 static gint32 joinable_thread_count;
 157
 158 #define SET_CURRENT_OBJECT(x) mono_tls_set_thread (x)
 159 #define GET_CURRENT_OBJECT() (MonoInternalThread*) mono_tls_get_thread ()
 160
 161 /* function called at thread start */
 162 static MonoThreadStartCB mono_thread_start_cb = NULL;
 163
 164 /* function called at thread attach */
 165 static MonoThreadAttachCB mono_thread_attach_cb = NULL;
 166
 167 /* function called at thread cleanup */
 168 static MonoThreadCleanupFunc mono_thread_cleanup_fn = NULL;
 169
 170 /* The default stack size for each thread */
 171 static guint32 default_stacksize = 0;
 172 #define default_stacksize_for_thread(thread) ((thread)->stack_size? (thread)->stack_size: default_stacksize)
 173
 174 static void context_adjust_static_data (MonoAppContext *ctx);
 175 static void mono_free_static_data (gpointer* static_data);
 176 static void mono_init_static_data_info (StaticDataInfo *static_data);
 177 static guint32 mono_alloc_static_data_slot (StaticDataInfo *static_data, guint32 size, guint32 align);
 178 static gboolean mono_thread_resume (MonoInternalThread* thread);
 179 static void async_abort_internal (MonoInternalThread *thread, gboolean install_async_abort);
 180 static void self_abort_internal (MonoError *error);
 181 static void async_suspend_internal (MonoInternalThread *thread, gboolean interrupt);
 182 static void self_suspend_internal (void);
 183
 184 static MonoException* mono_thread_execute_interruption (void);
 185 static void ref_stack_destroy (gpointer rs);
 186
 187 /* Spin lock for InterlockedXXX 64 bit functions */
 188 #define mono_interlocked_lock() mono_os_mutex_lock (&interlocked_mutex)
 189 #define mono_interlocked_unlock() mono_os_mutex_unlock (&interlocked_mutex)
 190 static mono_mutex_t interlocked_mutex;
 191
 192 /* global count of thread interruptions requested */
 193 static gint32 thread_interruption_requested = 0;
 194
 195 /* Event signaled when a thread changes its background mode */
 196 static MonoOSEvent background_change_event;
 197
 198 static gboolean shutting_down = FALSE;
 199
 200 static gint32 managed_thread_id_counter = 0;
 201
 202 static void
 203 mono_threads_lock (void)
 204 {
 205         mono_locks_coop_acquire (&threads_mutex, ThreadsLock);
 206 }
 207
 208 static void
 209 mono_threads_unlock (void)
 210 {
 211         mono_locks_coop_release (&threads_mutex, ThreadsLock);
 212 }
 213
 214
 215 static guint32
 216 get_next_managed_thread_id (void)
 217 {
 218         return InterlockedIncrement (&managed_thread_id_counter);
 219 }
 220
 221 /*
 222  * We separate interruptions/exceptions into either sync (they can be processed anytime,
 223  * normally as soon as they are set, and are set by the same thread) and async (they can't
 224  * be processed inside abort protected blocks and are normally set by other threads). We
 225  * can have both a pending sync and async interruption. In this case, the sync exception is
 226  * processed first. Since we clean sync flag first, mono_thread_execute_interruption must
 227  * also handle all sync type exceptions before the async type exceptions.
 228  */
 229 enum {
 230         INTERRUPT_SYNC_REQUESTED_BIT = 0x1,
 231         INTERRUPT_ASYNC_REQUESTED_BIT = 0x2,
 232         INTERRUPT_REQUESTED_MASK = 0x3,
 233         ABORT_PROT_BLOCK_SHIFT = 2,
 234         ABORT_PROT_BLOCK_BITS = 8,
 235         ABORT_PROT_BLOCK_MASK = (((1 << ABORT_PROT_BLOCK_BITS) - 1) << ABORT_PROT_BLOCK_SHIFT)
 236 };
 237
 238 static int
 239 mono_thread_get_abort_prot_block_count (MonoInternalThread *thread)
 240 {
 241         gsize state = thread->thread_state;
 242         return (state & ABORT_PROT_BLOCK_MASK) >> ABORT_PROT_BLOCK_SHIFT;
 243 }
 244
 245 void
 246 mono_threads_begin_abort_protected_block (void)
 247 {
 248         MonoInternalThread *thread = mono_thread_internal_current ();
 249         gsize old_state, new_state;
 250         int new_val;
 251         do {
 252                 old_state = thread->thread_state;
 253
 254                 new_val = ((old_state & ABORT_PROT_BLOCK_MASK) >> ABORT_PROT_BLOCK_SHIFT) + 1;
 255                 //bounds check abort_prot_count
 256                 g_assert (new_val > 0);
 257                 g_assert (new_val < (1 << ABORT_PROT_BLOCK_BITS));
 258
 259                 new_state = old_state + (1 << ABORT_PROT_BLOCK_SHIFT);
 260         } while (InterlockedCompareExchangePointer ((volatile gpointer)&thread->thread_state, (gpointer)new_state, (gpointer)old_state) != (gpointer)old_state);
 261
 262         /* Defer async request since we won't be able to process until exiting the block */
 263         if (new_val == 1 && (new_state & INTERRUPT_ASYNC_REQUESTED_BIT)) {
 264                 InterlockedDecrement (&thread_interruption_requested);
 265                 THREADS_INTERRUPT_DEBUG ("[%d] begin abort protected block old_state %ld new_state %ld, defer tir %d\n", thread->small_id, old_state, new_state, thread_interruption_requested);
 266                 if (thread_interruption_requested < 0)
 267                         g_warning ("bad thread_interruption_requested state");
 268         } else {
 269                 THREADS_INTERRUPT_DEBUG ("[%d] begin abort protected block old_state %ld new_state %ld, tir %d\n", thread->small_id, old_state, new_state, thread_interruption_requested);
 270         }
 271 }
 272
 273 static gboolean
 274 mono_thread_state_has_interruption (gsize state)
 275 {
 276         /* pending exception, self abort */
 277         if (state & INTERRUPT_SYNC_REQUESTED_BIT)
 278                 return TRUE;
 279
 280         /* abort, interruption, suspend */
 281         if ((state & INTERRUPT_ASYNC_REQUESTED_BIT) && !(state & ABORT_PROT_BLOCK_MASK))
 282                 return TRUE;
 283
 284         return FALSE;
 285 }
 286
 287 gboolean
 288 mono_threads_end_abort_protected_block (void)
 289 {
 290         MonoInternalThread *thread = mono_thread_internal_current ();
 291         gsize old_state, new_state;
 292         int new_val;
 293         do {
 294                 old_state = thread->thread_state;
 295
 296                 //bounds check abort_prot_count
 297                 new_val = ((old_state & ABORT_PROT_BLOCK_MASK) >> ABORT_PROT_BLOCK_SHIFT) - 1;
 298                 g_assert (new_val >= 0);
 299                 g_assert (new_val < (1 << ABORT_PROT_BLOCK_BITS));
 300
 301                 new_state = old_state - (1 << ABORT_PROT_BLOCK_SHIFT);
 302         } while (InterlockedCompareExchangePointer ((volatile gpointer)&thread->thread_state, (gpointer)new_state, (gpointer)old_state) != (gpointer)old_state);
 303
 304         if (new_val == 0 && (new_state & INTERRUPT_ASYNC_REQUESTED_BIT)) {
 305                 InterlockedIncrement (&thread_interruption_requested);
 306                 THREADS_INTERRUPT_DEBUG ("[%d] end abort protected block old_state %ld new_state %ld, restore tir %d\n", thread->small_id, old_state, new_state, thread_interruption_requested);
 307         } else {
 308                 THREADS_INTERRUPT_DEBUG ("[%d] end abort protected block old_state %ld new_state %ld, tir %d\n", thread->small_id, old_state, new_state, thread_interruption_requested);
 309         }
 310
 311         return mono_thread_state_has_interruption (new_state);
 312 }
 313
 314 static gboolean
 315 mono_thread_get_interruption_requested (MonoInternalThread *thread)
 316 {
 317         gsize state = thread->thread_state;
 318
 319         return mono_thread_state_has_interruption (state);
 320 }
 321
 322 /*
 323  * Returns TRUE is there was a state change
 324  * We clear a single interruption request, sync has priority.
 325  */
 326 static gboolean
 327 mono_thread_clear_interruption_requested (MonoInternalThread *thread)
 328 {
 329         gsize old_state, new_state;
 330         do {
 331                 old_state = thread->thread_state;
 332
 333                 // no interruption to process
 334                 if (!(old_state & INTERRUPT_SYNC_REQUESTED_BIT) &&
 335                                 (!(old_state & INTERRUPT_ASYNC_REQUESTED_BIT) || (old_state & ABORT_PROT_BLOCK_MASK)))
 336                         return FALSE;
 337
 338                 if (old_state & INTERRUPT_SYNC_REQUESTED_BIT)
 339                         new_state = old_state & ~INTERRUPT_SYNC_REQUESTED_BIT;
 340                 else
 341                         new_state = old_state & ~INTERRUPT_ASYNC_REQUESTED_BIT;
 342         } while (InterlockedCompareExchangePointer ((volatile gpointer)&thread->thread_state, (gpointer)new_state, (gpointer)old_state) != (gpointer)old_state);
 343
 344         InterlockedDecrement (&thread_interruption_requested);
 345         THREADS_INTERRUPT_DEBUG ("[%d] clear interruption old_state %ld new_state %ld, tir %d\n", thread->small_id, old_state, new_state, thread_interruption_requested);
 346         if (thread_interruption_requested < 0)
 347                 g_warning ("bad thread_interruption_requested state");
 348         return TRUE;
 349 }
 350
 351 /* Returns TRUE is there was a state change and the interruption can be processed */
 352 static gboolean
 353 mono_thread_set_interruption_requested (MonoInternalThread *thread)
 354 {
 355         //always force when the current thread is doing it to itself.
 356         gboolean sync = thread == mono_thread_internal_current ();
 357         gsize old_state, new_state;
 358         do {
 359                 old_state = thread->thread_state;
 360
 361                 //Already set
 362                 if ((sync && (old_state & INTERRUPT_SYNC_REQUESTED_BIT)) ||
 363                                 (!sync && (old_state & INTERRUPT_ASYNC_REQUESTED_BIT)))
 364                         return FALSE;
 365
 366                 if (sync)
 367                         new_state = old_state | INTERRUPT_SYNC_REQUESTED_BIT;
 368                 else
 369                         new_state = old_state | INTERRUPT_ASYNC_REQUESTED_BIT;
 370         } while (InterlockedCompareExchangePointer ((volatile gpointer)&thread->thread_state, (gpointer)new_state, (gpointer)old_state) != (gpointer)old_state);
 371
 372         if (sync || !(new_state & ABORT_PROT_BLOCK_MASK)) {
 373                 InterlockedIncrement (&thread_interruption_requested);
 374                 THREADS_INTERRUPT_DEBUG ("[%d] set interruption on [%d] old_state %ld new_state %ld, tir %d\n", mono_thread_internal_current ()->small_id, thread->small_id, old_state, new_state, thread_interruption_requested);
 375         } else {
 376                 THREADS_INTERRUPT_DEBUG ("[%d] set interruption on [%d] old_state %ld new_state %ld, tir deferred %d\n", mono_thread_internal_current ()->small_id, thread->small_id, old_state, new_state, thread_interruption_requested);
 377         }
 378
 379         return sync || !(new_state & ABORT_PROT_BLOCK_MASK);
 380 }
 381
 382 static inline MonoNativeThreadId
 383 thread_get_tid (MonoInternalThread *thread)
 384 {
 385         /* We store the tid as a guint64 to keep the object layout constant between platforms */
 386         return MONO_UINT_TO_NATIVE_THREAD_ID (thread->tid);
 387 }
 388
 389 static void ensure_synch_cs_set (MonoInternalThread *thread)
 390 {
 391         MonoCoopMutex *synch_cs;
 392
 393         if (thread->synch_cs != NULL) {
 394                 return;
 395         }
 396
 397         synch_cs = g_new0 (MonoCoopMutex, 1);
 398         mono_coop_mutex_init_recursive (synch_cs);
 399
 400         if (InterlockedCompareExchangePointer ((gpointer *)&thread->synch_cs,
 401                                                synch_cs, NULL) != NULL) {
 402                 /* Another thread must have installed this CS */
 403                 mono_coop_mutex_destroy (synch_cs);
 404                 g_free (synch_cs);
 405         }
 406 }
 407
 408 static inline void
 409 lock_thread (MonoInternalThread *thread)
 410 {
 411         if (!thread->synch_cs)
 412                 ensure_synch_cs_set (thread);
 413
 414         g_assert (thread->synch_cs);
 415
 416         mono_coop_mutex_lock (thread->synch_cs);
 417 }
 418
 419 static inline void
 420 unlock_thread (MonoInternalThread *thread)
 421 {
 422         mono_coop_mutex_unlock (thread->synch_cs);
 423 }
 424
 425 static inline gboolean
 426 is_appdomainunloaded_exception (MonoClass *klass)
 427 {
 428         return klass == mono_class_get_appdomain_unloaded_exception_class ();
 429 }
 430
 431 static inline gboolean
 432 is_threadabort_exception (MonoClass *klass)
 433 {
 434         return klass == mono_defaults.threadabortexception_class;
 435 }
 436
 437 /*
 438  * A special static data offset (guint32) consists of 3 parts:
 439  *
 440  * [0]   6-bit index into the array of chunks.
 441  * [6]   25-bit offset into the array.
 442  * [31]  Bit indicating thread or context static.
 443  */
 444
 445 typedef union {
 446         struct {
 447 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 448                 guint32 type : 1;
 449                 guint32 offset : 25;
 450                 guint32 index : 6;
 451 #else
 452                 guint32 index : 6;
 453                 guint32 offset : 25;
 454                 guint32 type : 1;
 455 #endif
 456         } fields;
 457         guint32 raw;
 458 } SpecialStaticOffset;
 459
 460 #define SPECIAL_STATIC_OFFSET_TYPE_THREAD 0
 461 #define SPECIAL_STATIC_OFFSET_TYPE_CONTEXT 1
 462
 463 #define MAKE_SPECIAL_STATIC_OFFSET(idx, off, ty) \
 464         ((SpecialStaticOffset) { .fields = { .index = (idx), .offset = (off), .type = (ty) } }.raw)
 465 #define ACCESS_SPECIAL_STATIC_OFFSET(x,f) \
 466         (((SpecialStaticOffset *) &(x))->fields.f)
 467
 468 static gpointer
 469 get_thread_static_data (MonoInternalThread *thread, guint32 offset)
 470 {
 471         g_assert (ACCESS_SPECIAL_STATIC_OFFSET (offset, type) == SPECIAL_STATIC_OFFSET_TYPE_THREAD);
 472
 473         int idx = ACCESS_SPECIAL_STATIC_OFFSET (offset, index);
 474         int off = ACCESS_SPECIAL_STATIC_OFFSET (offset, offset);
 475
 476         return ((char *) thread->static_data [idx]) + off;
 477 }
 478
 479 static gpointer
 480 get_context_static_data (MonoAppContext *ctx, guint32 offset)
 481 {
 482         g_assert (ACCESS_SPECIAL_STATIC_OFFSET (offset, type) == SPECIAL_STATIC_OFFSET_TYPE_CONTEXT);
 483
 484         int idx = ACCESS_SPECIAL_STATIC_OFFSET (offset, index);
 485         int off = ACCESS_SPECIAL_STATIC_OFFSET (offset, offset);
 486
 487         return ((char *) ctx->static_data [idx]) + off;
 488 }
 489
 490 static MonoThread**
 491 get_current_thread_ptr_for_domain (MonoDomain *domain, MonoInternalThread *thread)
 492 {
 493         static MonoClassField *current_thread_field = NULL;
 494
 495         guint32 offset;
 496
 497         if (!current_thread_field) {
 498                 current_thread_field = mono_class_get_field_from_name (mono_defaults.thread_class, "current_thread");
 499                 g_assert (current_thread_field);
 500         }
 501
 502         mono_class_vtable (domain, mono_defaults.thread_class);
 503         mono_domain_lock (domain);
 504         offset = GPOINTER_TO_UINT (g_hash_table_lookup (domain->special_static_fields, current_thread_field));
 505         mono_domain_unlock (domain);
 506         g_assert (offset);
 507
 508         return (MonoThread **)get_thread_static_data (thread, offset);
 509 }
 510
 511 static void
 512 set_current_thread_for_domain (MonoDomain *domain, MonoInternalThread *thread, MonoThread *current)
 513 {
 514         MonoThread **current_thread_ptr = get_current_thread_ptr_for_domain (domain, thread);
 515
 516         g_assert (current->obj.vtable->domain == domain);
 517
 518         g_assert (!*current_thread_ptr);
 519         *current_thread_ptr = current;
 520 }
 521
 522 static MonoThread*
 523 create_thread_object (MonoDomain *domain, MonoInternalThread *internal)
 524 {
 525         MonoThread *thread;
 526         MonoVTable *vtable;
 527         MonoError error;
 528
 529         vtable = mono_class_vtable (domain, mono_defaults.thread_class);
 530         g_assert (vtable);
 531
 532         thread = (MonoThread*)mono_object_new_mature (vtable, &error);
 533         /* only possible failure mode is OOM, from which we don't expect to recover. */
 534         mono_error_assert_ok (&error);
 535
 536         MONO_OBJECT_SETREF (thread, internal_thread, internal);
 537
 538         return thread;
 539 }
 540
 541 static MonoInternalThread*
 542 create_internal_thread_object (void)
 543 {
 544         MonoError error;
 545         MonoInternalThread *thread;
 546         MonoVTable *vt;
 547
 548         vt = mono_class_vtable (mono_get_root_domain (), mono_defaults.internal_thread_class);
 549         thread = (MonoInternalThread*) mono_object_new_mature (vt, &error);
 550         /* only possible failure mode is OOM, from which we don't exect to recover */
 551         mono_error_assert_ok (&error);
 552
 553         thread->synch_cs = g_new0 (MonoCoopMutex, 1);
 554         mono_coop_mutex_init_recursive (thread->synch_cs);
 555
 556         thread->apartment_state = ThreadApartmentState_Unknown;
 557         thread->managed_id = get_next_managed_thread_id ();
 558         if (mono_gc_is_moving ()) {
 559                 thread->thread_pinning_ref = thread;
 560                 MONO_GC_REGISTER_ROOT_PINNING (thread->thread_pinning_ref, MONO_ROOT_SOURCE_THREADING, "thread pinning reference");
 561         }
 562
 563         thread->priority = MONO_THREAD_PRIORITY_NORMAL;
 564
 565         thread->suspended = g_new0 (MonoOSEvent, 1);
 566         mono_os_event_init (thread->suspended, TRUE);
 567
 568         return thread;
 569 }
 570
 571 static void
 572 mono_thread_internal_set_priority (MonoInternalThread *internal, MonoThreadPriority priority)
 573 {
 574         g_assert (internal);
 575
 576         g_assert (priority >= MONO_THREAD_PRIORITY_LOWEST);
 577         g_assert (priority <= MONO_THREAD_PRIORITY_HIGHEST);
 578         g_assert (MONO_THREAD_PRIORITY_LOWEST < MONO_THREAD_PRIORITY_HIGHEST);
 579
 580 #ifdef HOST_WIN32
 581         BOOL res;
 582
 583         g_assert (internal->native_handle);
 584
 585         res = SetThreadPriority (internal->native_handle, priority - 2);
 586         if (!res)
 587                 g_error ("%s: SetThreadPriority failed, error %d", __func__, GetLastError ());
 588 #else /* HOST_WIN32 */
 589         pthread_t tid;
 590         int policy;
 591         struct sched_param param;
 592         gint res;
 593
 594         tid = thread_get_tid (internal);
 595
 596         res = pthread_getschedparam (tid, &policy, &param);
 597         if (res != 0)
 598                 g_error ("%s: pthread_getschedparam failed, error: \"%s\" (%d)", __func__, g_strerror (res), res);
 599
 600 #ifdef _POSIX_PRIORITY_SCHEDULING
 601         int max, min;
 602
 603         /* Necessary to get valid priority range */
 604
 605         min = sched_get_priority_min (policy);
 606         max = sched_get_priority_max (policy);
 607
 608         if (max > 0 && min >= 0 && max > min) {
 609                 double srange, drange, sposition, dposition;
 610                 srange = MONO_THREAD_PRIORITY_HIGHEST - MONO_THREAD_PRIORITY_LOWEST;
 611                 drange = max - min;
 612                 sposition = priority - MONO_THREAD_PRIORITY_LOWEST;
 613                 dposition = (sposition / srange) * drange;
 614                 param.sched_priority = (int)(dposition + min);
 615         } else
 616 #endif
 617         {
 618                 switch (policy) {
 619                 case SCHED_FIFO:
 620                 case SCHED_RR:
 621                         param.sched_priority = 50;
 622                         break;
 623 #ifdef SCHED_BATCH
 624                 case SCHED_BATCH:
 625 #endif
 626                 case SCHED_OTHER:
 627                         param.sched_priority = 0;
 628                         break;
 629                 default:
 630                         g_warning ("%s: unknown policy %d", __func__, policy);
 631                         return;
 632                 }
 633         }
 634
 635         res = pthread_setschedparam (tid, policy, &param);
 636         if (res != 0) {
 637                 if (res == EPERM) {
 638                         g_warning ("%s: pthread_setschedparam failed, error: \"%s\" (%d)", __func__, g_strerror (res), res);
 639                         return;
 640                 }
 641                 g_error ("%s: pthread_setschedparam failed, error: \"%s\" (%d)", __func__, g_strerror (res), res);
 642         }
 643 #endif /* HOST_WIN32 */
 644 }
 645
 646 static void
 647 mono_alloc_static_data (gpointer **static_data_ptr, guint32 offset, gboolean threadlocal);
 648
 649 static gboolean
 650 mono_thread_attach_internal (MonoThread *thread, gboolean force_attach, gboolean force_domain)
 651 {
 652         MonoThreadInfo *info;
 653         MonoInternalThread *internal;
 654         MonoDomain *domain, *root_domain;
 655
 656         g_assert (thread);
 657
 658         info = mono_thread_info_current ();
 659         g_assert (info);
 660
 661         internal = thread->internal_thread;
 662         g_assert (internal);
 663
 664         /* It is needed to store the MonoInternalThread on the MonoThreadInfo, because of the following case:
 665          *  - the MonoInternalThread TLS key is destroyed: set it to NULL
 666          *  - the MonoThreadInfo TLS key is destroyed: calls mono_thread_info_detach
 667          *    - it calls MonoThreadInfoCallbacks.thread_detach
 668          *      - mono_thread_internal_current returns NULL -> fails to detach the MonoInternalThread. */
 669         mono_thread_info_set_internal_thread_gchandle (info, mono_gchandle_new ((MonoObject*) internal, FALSE));
 670
 671         internal->handle = mono_threads_open_thread_handle (info->handle);
 672 #ifdef HOST_WIN32
 673         internal->native_handle = OpenThread (THREAD_ALL_ACCESS, FALSE, GetCurrentThreadId ());
 674 #endif
 675         internal->tid = MONO_NATIVE_THREAD_ID_TO_UINT (mono_native_thread_id_get ());
 676         internal->thread_info = info;
 677         internal->small_id = info->small_id;
 678
 679         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Setting current_object_key to %p", __func__, mono_native_thread_id_get (), internal));
 680
 681         SET_CURRENT_OBJECT (internal);
 682
 683         domain = mono_object_domain (thread);
 684
 685         mono_thread_push_appdomain_ref (domain);
 686         if (!mono_domain_set (domain, force_domain)) {
 687                 mono_thread_pop_appdomain_ref ();
 688                 return FALSE;
 689         }
 690
 691         mono_threads_lock ();
 692
 693         if (threads_starting_up)
 694                 mono_g_hash_table_remove (threads_starting_up, thread);
 695
 696         if (shutting_down && !force_attach) {
 697                 mono_threads_unlock ();
 698                 mono_thread_pop_appdomain_ref ();
 699                 return FALSE;
 700         }
 701
 702         if (!threads) {
 703                 threads = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_THREADING, "threads table");
 704         }
 705
 706         /* We don't need to duplicate thread->handle, because it is
 707          * only closed when the thread object is finalized by the GC. */
 708         mono_g_hash_table_insert (threads, (gpointer)(gsize)(internal->tid), internal);
 709
 710         /* We have to do this here because mono_thread_start_cb
 711          * requires that root_domain_thread is set up. */
 712         if (thread_static_info.offset || thread_static_info.idx > 0) {
 713                 /* get the current allocated size */
 714                 guint32 offset = MAKE_SPECIAL_STATIC_OFFSET (thread_static_info.idx, thread_static_info.offset, 0);
 715                 mono_alloc_static_data (&internal->static_data, offset, TRUE);
 716         }
 717
 718         mono_threads_unlock ();
 719
 720         root_domain = mono_get_root_domain ();
 721
 722         g_assert (!internal->root_domain_thread);
 723         if (domain != root_domain)
 724                 MONO_OBJECT_SETREF (internal, root_domain_thread, create_thread_object (root_domain, internal));
 725         else
 726                 MONO_OBJECT_SETREF (internal, root_domain_thread, thread);
 727
 728         if (domain != root_domain)
 729                 set_current_thread_for_domain (root_domain, internal, internal->root_domain_thread);
 730
 731         set_current_thread_for_domain (domain, internal, thread);
 732
 733         THREAD_DEBUG (g_message ("%s: Attached thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, internal->tid, internal->handle));
 734
 735         return TRUE;
 736 }
 737
 738 static void
 739 mono_thread_detach_internal (MonoInternalThread *thread)
 740 {
 741         gboolean removed;
 742
 743         g_assert (thread != NULL);
 744         SET_CURRENT_OBJECT (thread);
 745
 746         THREAD_DEBUG (g_message ("%s: mono_thread_detach for %p (%"G_GSIZE_FORMAT")", __func__, thread, (gsize)thread->tid));
 747
 748 #ifndef HOST_WIN32
 749         mono_w32mutex_abandon ();
 750 #endif
 751
 752         if (thread->abort_state_handle) {
 753                 mono_gchandle_free (thread->abort_state_handle);
 754                 thread->abort_state_handle = 0;
 755         }
 756
 757         thread->abort_exc = NULL;
 758         thread->current_appcontext = NULL;
 759
 760         /*
 761          * thread->synch_cs can be NULL if this was called after
 762          * ves_icall_System_Threading_InternalThread_Thread_free_internal.
 763          * This can happen only during shutdown.
 764          * The shutting_down flag is not always set, so we can't assert on it.
 765          */
 766         if (thread->synch_cs)
 767                 LOCK_THREAD (thread);
 768
 769         thread->state |= ThreadState_Stopped;
 770         thread->state &= ~ThreadState_Background;
 771
 772         if (thread->synch_cs)
 773                 UNLOCK_THREAD (thread);
 774
 775         /*
 776         An interruption request has leaked to cleanup. Adjust the global counter.
 777
 778         This can happen is the abort source thread finds the abortee (this) thread
 779         in unmanaged code. If this thread never trips back to managed code or check
 780         the local flag it will be left set and positively unbalance the global counter.
 781
 782         Leaving the counter unbalanced will cause a performance degradation since all threads
 783         will now keep checking their local flags all the time.
 784         */
 785         mono_thread_clear_interruption_requested (thread);
 786
 787         mono_threads_lock ();
 788
 789         if (!threads) {
 790                 removed = FALSE;
 791         } else if (mono_g_hash_table_lookup (threads, (gpointer)thread->tid) != thread) {
 792                 /* We have to check whether the thread object for the
 793                  * tid is still the same in the table because the
 794                  * thread might have been destroyed and the tid reused
 795                  * in the meantime, in which case the tid would be in
 796                  * the table, but with another thread object.
 797                  */
 798                 removed = FALSE;
 799         } else {
 800                 mono_g_hash_table_remove (threads, (gpointer)thread->tid);
 801                 removed = TRUE;
 802         }
 803
 804         mono_threads_unlock ();
 805
 806         /* Don't close the handle here, wait for the object finalizer
 807          * to do it. Otherwise, the following race condition applies:
 808          *
 809          * 1) Thread exits (and mono_thread_detach_internal() closes the handle)
 810          *
 811          * 2) Some other handle is reassigned the same slot
 812          *
 813          * 3) Another thread tries to join the first thread, and
 814          * blocks waiting for the reassigned handle to be signalled
 815          * (which might never happen).  This is possible, because the
 816          * thread calling Join() still has a reference to the first
 817          * thread's object.
 818          */
 819
 820         /* if the thread is not in the hash it has been removed already */
 821         if (!removed) {
 822                 mono_domain_unset ();
 823                 mono_memory_barrier ();
 824
 825                 if (mono_thread_cleanup_fn)
 826                         mono_thread_cleanup_fn (thread_get_tid (thread));
 827
 828                 goto done;
 829         }
 830
 831         mono_release_type_locks (thread);
 832
 833         /* Can happen when we attach the profiler helper thread in order to heapshot. */
 834         if (!mono_thread_info_lookup (MONO_UINT_TO_NATIVE_THREAD_ID (thread->tid))->tools_thread)
 835                 MONO_PROFILER_RAISE (thread_stopped, (thread->tid));
 836
 837         mono_hazard_pointer_clear (mono_hazard_pointer_get (), 1);
 838
 839         /*
 840          * This will signal async signal handlers that the thread has exited.
 841          * The profiler callback needs this to be set, so it cannot be done earlier.
 842          */
 843         mono_domain_unset ();
 844         mono_memory_barrier ();
 845
 846         if (thread == mono_thread_internal_current ())
 847                 mono_thread_pop_appdomain_ref ();
 848
 849         mono_free_static_data (thread->static_data);
 850         thread->static_data = NULL;
 851         ref_stack_destroy (thread->appdomain_refs);
 852         thread->appdomain_refs = NULL;
 853
 854         g_assert (thread->suspended);
 855         mono_os_event_destroy (thread->suspended);
 856         g_free (thread->suspended);
 857         thread->suspended = NULL;
 858
 859         if (mono_thread_cleanup_fn)
 860                 mono_thread_cleanup_fn (thread_get_tid (thread));
 861
 862         mono_memory_barrier ();
 863
 864         if (mono_gc_is_moving ()) {
 865                 MONO_GC_UNREGISTER_ROOT (thread->thread_pinning_ref);
 866                 thread->thread_pinning_ref = NULL;
 867         }
 868
 869 done:
 870         SET_CURRENT_OBJECT (NULL);
 871         mono_domain_unset ();
 872
 873         mono_thread_info_unset_internal_thread_gchandle ((MonoThreadInfo*) thread->thread_info);
 874
 875         /* Don't need to close the handle to this thread, even though we took a
 876          * reference in mono_thread_attach (), because the GC will do it
 877          * when the Thread object is finalised.
 878          */
 879 }
 880
 881 typedef struct {
 882         gint32 ref;
 883         MonoThread *thread;
 884         MonoObject *start_delegate;
 885         MonoObject *start_delegate_arg;
 886         MonoThreadStart start_func;
 887         gpointer start_func_arg;
 888         gboolean force_attach;
 889         gboolean failed;
 890         MonoCoopSem registered;
 891 } StartInfo;
 892
 893 static guint32 WINAPI start_wrapper_internal(StartInfo *start_info, gsize *stack_ptr)
 894 {
 895         MonoError error;
 896         MonoThreadStart start_func;
 897         void *start_func_arg;
 898         gsize tid;
 899         /*
 900          * We don't create a local to hold start_info->thread, so hopefully it won't get pinned during a
 901          * GC stack walk.
 902          */
 903         MonoThread *thread;
 904         MonoInternalThread *internal;
 905         MonoObject *start_delegate;
 906         MonoObject *start_delegate_arg;
 907         MonoDomain *domain;
 908
 909         thread = start_info->thread;
 910         internal = thread->internal_thread;
 911         domain = mono_object_domain (start_info->thread);
 912
 913         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Start wrapper", __func__, mono_native_thread_id_get ()));
 914
 915         if (!mono_thread_attach_internal (thread, start_info->force_attach, FALSE)) {
 916                 start_info->failed = TRUE;
 917
 918                 mono_coop_sem_post (&start_info->registered);
 919
 920                 if (InterlockedDecrement (&start_info->ref) == 0) {
 921                         mono_coop_sem_destroy (&start_info->registered);
 922                         g_free (start_info);
 923                 }
 924
 925                 return 0;
 926         }
 927
 928         mono_thread_internal_set_priority (internal, internal->priority);
 929
 930         tid = internal->tid;
 931
 932         start_delegate = start_info->start_delegate;
 933         start_delegate_arg = start_info->start_delegate_arg;
 934         start_func = start_info->start_func;
 935         start_func_arg = start_info->start_func_arg;
 936
 937         /* This MUST be called before any managed code can be
 938          * executed, as it calls the callback function that (for the
 939          * jit) sets the lmf marker.
 940          */
 941
 942         if (mono_thread_start_cb)
 943                 mono_thread_start_cb (tid, stack_ptr, start_func);
 944
 945         /* On 2.0 profile (and higher), set explicitly since state might have been
 946            Unknown */
 947         if (internal->apartment_state == ThreadApartmentState_Unknown)
 948                 internal->apartment_state = ThreadApartmentState_MTA;
 949
 950         mono_thread_init_apartment_state ();
 951
 952         /* Let the thread that called Start() know we're ready */
 953         mono_coop_sem_post (&start_info->registered);
 954
 955         if (InterlockedDecrement (&start_info->ref) == 0) {
 956                 mono_coop_sem_destroy (&start_info->registered);
 957                 g_free (start_info);
 958         }
 959
 960         /* start_info is not valid anymore */
 961         start_info = NULL;
 962
 963         /*
 964          * Call this after calling start_notify, since the profiler callback might want
 965          * to lock the thread, and the lock is held by thread_start () which waits for
 966          * start_notify.
 967          */
 968         MONO_PROFILER_RAISE (thread_started, (tid));
 969
 970         /* if the name was set before starting, we didn't invoke the profiler callback */
 971         if (internal->name) {
 972                 char *tname = g_utf16_to_utf8 (internal->name, internal->name_len, NULL, NULL, NULL);
 973                 MONO_PROFILER_RAISE (thread_name, (internal->tid, tname));
 974                 mono_native_thread_set_name (MONO_UINT_TO_NATIVE_THREAD_ID (internal->tid), tname);
 975                 g_free (tname);
 976         }
 977
 978         /* start_func is set only for unmanaged start functions */
 979         if (start_func) {
 980                 start_func (start_func_arg);
 981         } else {
 982                 void *args [1];
 983
 984                 g_assert (start_delegate != NULL);
 985
 986                 /* we may want to handle the exception here. See comment below on unhandled exceptions */
 987                 args [0] = (gpointer) start_delegate_arg;
 988                 mono_runtime_delegate_invoke_checked (start_delegate, args, &error);
 989
 990                 if (!mono_error_ok (&error)) {
 991                         MonoException *ex = mono_error_convert_to_exception (&error);
 992
 993                         g_assert (ex != NULL);
 994                         MonoClass *klass = mono_object_get_class (&ex->object);
 995                         if ((mono_runtime_unhandled_exception_policy_get () != MONO_UNHANDLED_POLICY_LEGACY) &&
 996                             !is_threadabort_exception (klass)) {
 997                                 mono_unhandled_exception (&ex->object);
 998                                 mono_invoke_unhandled_exception_hook (&ex->object);
 999                                 g_assert_not_reached ();
1000                         }
1001                 } else {
1002                         mono_error_cleanup (&error);
1003                 }
1004         }
1005
1006         /* If the thread calls ExitThread at all, this remaining code
1007          * will not be executed, but the main thread will eventually
1008          * call mono_thread_detach_internal() on this thread's behalf.
1009          */
1010
1011         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Start wrapper terminating", __func__, mono_native_thread_id_get ()));
1012
1013         /* Do any cleanup needed for apartment state. This
1014          * cannot be done in mono_thread_detach_internal since
1015          * mono_thread_detach_internal could be  called for a
1016          * thread other than the current thread.
1017          * mono_thread_cleanup_apartment_state cleans up apartment
1018          * for the current thead */
1019         mono_thread_cleanup_apartment_state ();
1020
1021         mono_thread_detach_internal (internal);
1022
1023         return(0);
1024 }
1025
1026 static gsize WINAPI
1027 start_wrapper (gpointer data)
1028 {
1029         StartInfo *start_info;
1030         MonoThreadInfo *info;
1031         gsize res;
1032
1033         start_info = (StartInfo*) data;
1034         g_assert (start_info);
1035
1036         info = mono_thread_info_attach ();
1037         info->runtime_thread = TRUE;
1038
1039         /* Run the actual main function of the thread */
1040         res = start_wrapper_internal (start_info, info->stack_end);
1041
1042         mono_thread_info_exit (res);
1043
1044         g_assert_not_reached ();
1045 }
1046
1047 /*
1048  * create_thread:
1049  *
1050  *   Common thread creation code.
1051  * LOCKING: Acquires the threads lock.
1052  */
1053 static gboolean
1054 create_thread (MonoThread *thread, MonoInternalThread *internal, MonoObject *start_delegate, MonoThreadStart start_func, gpointer start_func_arg,
1055         MonoThreadCreateFlags flags, MonoError *error)
1056 {
1057         StartInfo *start_info = NULL;
1058         MonoNativeThreadId tid;
1059         gboolean ret;
1060         gsize stack_set_size;
1061
1062         if (start_delegate)
1063                 g_assert (!start_func && !start_func_arg);
1064         if (start_func)
1065                 g_assert (!start_delegate);
1066
1067         if (flags & MONO_THREAD_CREATE_FLAGS_THREADPOOL) {
1068                 g_assert (!(flags & MONO_THREAD_CREATE_FLAGS_DEBUGGER));
1069                 g_assert (!(flags & MONO_THREAD_CREATE_FLAGS_FORCE_CREATE));
1070         }
1071         if (flags & MONO_THREAD_CREATE_FLAGS_DEBUGGER) {
1072                 g_assert (!(flags & MONO_THREAD_CREATE_FLAGS_THREADPOOL));
1073                 g_assert (!(flags & MONO_THREAD_CREATE_FLAGS_FORCE_CREATE));
1074         }
1075
1076         /*
1077          * Join joinable threads to prevent running out of threads since the finalizer
1078          * thread might be blocked/backlogged.
1079          */
1080         mono_threads_join_threads ();
1081
1082         error_init (error);
1083
1084         mono_threads_lock ();
1085         if (shutting_down && !(flags & MONO_THREAD_CREATE_FLAGS_FORCE_CREATE)) {
1086                 mono_threads_unlock ();
1087                 return FALSE;
1088         }
1089         if (threads_starting_up == NULL) {
1090                 threads_starting_up = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_KEY_VALUE_GC, MONO_ROOT_SOURCE_THREADING, "starting threads table");
1091         }
1092         mono_g_hash_table_insert (threads_starting_up, thread, thread);
1093         mono_threads_unlock ();
1094
1095         internal->threadpool_thread = flags & MONO_THREAD_CREATE_FLAGS_THREADPOOL;
1096         if (internal->threadpool_thread)
1097                 mono_thread_set_state (internal, ThreadState_Background);
1098
1099         internal->debugger_thread = flags & MONO_THREAD_CREATE_FLAGS_DEBUGGER;
1100
1101         start_info = g_new0 (StartInfo, 1);
1102         start_info->ref = 2;
1103         start_info->thread = thread;
1104         start_info->start_delegate = start_delegate;
1105         start_info->start_delegate_arg = thread->start_obj;
1106         start_info->start_func = start_func;
1107         start_info->start_func_arg = start_func_arg;
1108         start_info->force_attach = flags & MONO_THREAD_CREATE_FLAGS_FORCE_CREATE;
1109         start_info->failed = FALSE;
1110         mono_coop_sem_init (&start_info->registered, 0);
1111
1112         if (flags != MONO_THREAD_CREATE_FLAGS_SMALL_STACK)
1113                 stack_set_size = default_stacksize_for_thread (internal);
1114         else
1115                 stack_set_size = 0;
1116
1117         if (!mono_thread_platform_create_thread (start_wrapper, start_info, &stack_set_size, &tid)) {
1118                 /* The thread couldn't be created, so set an exception */
1119                 mono_threads_lock ();
1120                 mono_g_hash_table_remove (threads_starting_up, thread);
1121                 mono_threads_unlock ();
1122                 mono_error_set_execution_engine (error, "Couldn't create thread. Error 0x%x", mono_w32error_get_last());
1123                 /* ref is not going to be decremented in start_wrapper_internal */
1124                 InterlockedDecrement (&start_info->ref);
1125                 ret = FALSE;
1126                 goto done;
1127         }
1128
1129         internal->stack_size = (int) stack_set_size;
1130
1131         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Launching thread %p (%"G_GSIZE_FORMAT")", __func__, mono_native_thread_id_get (), internal, (gsize)internal->tid));
1132
1133         /*
1134          * Wait for the thread to set up its TLS data etc, so
1135          * theres no potential race condition if someone tries
1136          * to look up the data believing the thread has
1137          * started
1138          */
1139
1140         mono_coop_sem_wait (&start_info->registered, MONO_SEM_FLAGS_NONE);
1141
1142         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Done launching thread %p (%"G_GSIZE_FORMAT")", __func__, mono_native_thread_id_get (), internal, (gsize)internal->tid));
1143
1144         ret = !start_info->failed;
1145
1146 done:
1147         if (InterlockedDecrement (&start_info->ref) == 0) {
1148                 mono_coop_sem_destroy (&start_info->registered);
1149                 g_free (start_info);
1150         }
1151
1152         return ret;
1153 }
1154
1155 /**
1156  * mono_thread_new_init:
1157  */
1158 void
1159 mono_thread_new_init (intptr_t tid, gpointer stack_start, gpointer func)
1160 {
1161         if (mono_thread_start_cb) {
1162                 mono_thread_start_cb (tid, stack_start, func);
1163         }
1164 }
1165
1166 /**
1167  * mono_threads_set_default_stacksize:
1168  */
1169 void
1170 mono_threads_set_default_stacksize (guint32 stacksize)
1171 {
1172         default_stacksize = stacksize;
1173 }
1174
1175 /**
1176  * mono_threads_get_default_stacksize:
1177  */
1178 guint32
1179 mono_threads_get_default_stacksize (void)
1180 {
1181         return default_stacksize;
1182 }
1183
1184 /*
1185  * mono_thread_create_internal:
1186  *
1187  *   ARG should not be a GC reference.
1188  */
1189 MonoInternalThread*
1190 mono_thread_create_internal (MonoDomain *domain, gpointer func, gpointer arg, MonoThreadCreateFlags flags, MonoError *error)
1191 {
1192         MonoThread *thread;
1193         MonoInternalThread *internal;
1194         gboolean res;
1195
1196         error_init (error);
1197
1198         internal = create_internal_thread_object ();
1199
1200         thread = create_thread_object (domain, internal);
1201
1202         LOCK_THREAD (internal);
1203
1204         res = create_thread (thread, internal, NULL, (MonoThreadStart) func, arg, flags, error);
1205
1206         UNLOCK_THREAD (internal);
1207
1208         return_val_if_nok (error, NULL);
1209         return internal;
1210 }
1211
1212 /**
1213  * mono_thread_create:
1214  */
1215 void
1216 mono_thread_create (MonoDomain *domain, gpointer func, gpointer arg)
1217 {
1218         MonoError error;
1219         if (!mono_thread_create_checked (domain, func, arg, &error))
1220                 mono_error_cleanup (&error);
1221 }
1222
1223 gboolean
1224 mono_thread_create_checked (MonoDomain *domain, gpointer func, gpointer arg, MonoError *error)
1225 {
1226         return (NULL != mono_thread_create_internal (domain, func, arg, MONO_THREAD_CREATE_FLAGS_NONE, error));
1227 }
1228
1229 static MonoThread *
1230 mono_thread_attach_full (MonoDomain *domain, gboolean force_attach)
1231 {
1232         MonoInternalThread *internal;
1233         MonoThread *thread;
1234         MonoThreadInfo *info;
1235         MonoNativeThreadId tid;
1236
1237         if (mono_thread_internal_current_is_attached ()) {
1238                 if (domain != mono_domain_get ())
1239                         mono_domain_set (domain, TRUE);
1240                 /* Already attached */
1241                 return mono_thread_current ();
1242         }
1243
1244         info = mono_thread_info_attach ();
1245         g_assert (info);
1246
1247         tid=mono_native_thread_id_get ();
1248
1249         internal = create_internal_thread_object ();
1250
1251         thread = create_thread_object (domain, internal);
1252
1253         if (!mono_thread_attach_internal (thread, force_attach, TRUE)) {
1254                 /* Mono is shutting down, so just wait for the end */
1255                 for (;;)
1256                         mono_thread_info_sleep (10000, NULL);
1257         }
1258
1259         THREAD_DEBUG (g_message ("%s: Attached thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, tid, internal->handle));
1260
1261         if (mono_thread_attach_cb)
1262                 mono_thread_attach_cb (MONO_NATIVE_THREAD_ID_TO_UINT (tid), info->stack_end);
1263
1264         /* Can happen when we attach the profiler helper thread in order to heapshot. */
1265         if (!mono_thread_info_current ()->tools_thread)
1266                 MONO_PROFILER_RAISE (thread_started, (MONO_NATIVE_THREAD_ID_TO_UINT (tid)));
1267
1268         return thread;
1269 }
1270
1271 /**
1272  * mono_thread_attach:
1273  */
1274 MonoThread *
1275 mono_thread_attach (MonoDomain *domain)
1276 {
1277         return mono_thread_attach_full (domain, FALSE);
1278 }
1279
1280 /**
1281  * mono_thread_detach:
1282  */
1283 void
1284 mono_thread_detach (MonoThread *thread)
1285 {
1286         if (thread)
1287                 mono_thread_detach_internal (thread->internal_thread);
1288 }
1289
1290 /**
1291  * mono_thread_detach_if_exiting:
1292  *
1293  * Detach the current thread from the runtime if it is exiting, i.e. it is running pthread dtors.
1294  * This should be used at the end of embedding code which calls into managed code, and which
1295  * can be called from pthread dtors, like <code>dealloc:</code> implementations in Objective-C.
1296  */
1297 mono_bool
1298 mono_thread_detach_if_exiting (void)
1299 {
1300         if (mono_thread_info_is_exiting ()) {
1301                 MonoInternalThread *thread;
1302
1303                 thread = mono_thread_internal_current ();
1304                 if (thread) {
1305                         mono_thread_detach_internal (thread);
1306                         mono_thread_info_detach ();
1307                         return TRUE;
1308                 }
1309         }
1310         return FALSE;
1311 }
1312
1313 gboolean
1314 mono_thread_internal_current_is_attached (void)
1315 {
1316         MonoInternalThread *internal;
1317
1318         internal = GET_CURRENT_OBJECT ();
1319         if (!internal)
1320                 return FALSE;
1321
1322         return TRUE;
1323 }
1324
1325 /**
1326  * mono_thread_exit:
1327  */
1328 void
1329 mono_thread_exit (void)
1330 {
1331         MonoInternalThread *thread = mono_thread_internal_current ();
1332
1333         THREAD_DEBUG (g_message ("%s: mono_thread_exit for %p (%"G_GSIZE_FORMAT")", __func__, thread, (gsize)thread->tid));
1334
1335         mono_thread_detach_internal (thread);
1336
1337         /* we could add a callback here for embedders to use. */
1338         if (mono_thread_get_main () && (thread == mono_thread_get_main ()->internal_thread))
1339                 exit (mono_environment_exitcode_get ());
1340
1341         mono_thread_info_exit (0);
1342 }
1343
1344 void
1345 ves_icall_System_Threading_Thread_ConstructInternalThread (MonoThread *this_obj)
1346 {
1347         MonoInternalThread *internal;
1348
1349         internal = create_internal_thread_object ();
1350
1351         internal->state = ThreadState_Unstarted;
1352
1353         InterlockedCompareExchangePointer ((volatile gpointer *)&this_obj->internal_thread, internal, NULL);
1354 }
1355
1356 MonoThread *
1357 ves_icall_System_Threading_Thread_GetCurrentThread (void)
1358 {
1359         return mono_thread_current ();
1360 }
1361
1362 HANDLE
1363 ves_icall_System_Threading_Thread_Thread_internal (MonoThread *this_obj,
1364                                                                                                    MonoObject *start)
1365 {
1366         MonoError error;
1367         MonoInternalThread *internal;
1368         gboolean res;
1369
1370         THREAD_DEBUG (g_message("%s: Trying to start a new thread: this (%p) start (%p)", __func__, this_obj, start));
1371
1372         if (!this_obj->internal_thread)
1373                 ves_icall_System_Threading_Thread_ConstructInternalThread (this_obj);
1374         internal = this_obj->internal_thread;
1375
1376         LOCK_THREAD (internal);
1377
1378         if ((internal->state & ThreadState_Unstarted) == 0) {
1379                 UNLOCK_THREAD (internal);
1380                 mono_set_pending_exception (mono_get_exception_thread_state ("Thread has already been started."));
1381                 return NULL;
1382         }
1383
1384         if ((internal->state & ThreadState_Aborted) != 0) {
1385                 UNLOCK_THREAD (internal);
1386                 return this_obj;
1387         }
1388
1389         res = create_thread (this_obj, internal, start, NULL, NULL, MONO_THREAD_CREATE_FLAGS_NONE, &error);
1390         if (!res) {
1391                 mono_error_cleanup (&error);
1392                 UNLOCK_THREAD (internal);
1393                 return NULL;
1394         }
1395
1396         internal->state &= ~ThreadState_Unstarted;
1397
1398         THREAD_DEBUG (g_message ("%s: Started thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, tid, thread));
1399
1400         UNLOCK_THREAD (internal);
1401         return internal->handle;
1402 }
1403
1404 /*
1405  * This is called from the finalizer of the internal thread object.
1406  */
1407 void
1408 ves_icall_System_Threading_InternalThread_Thread_free_internal (MonoInternalThread *this_obj)
1409 {
1410         THREAD_DEBUG (g_message ("%s: Closing thread %p, handle %p", __func__, this, this_obj->handle));
1411
1412         /*
1413          * Since threads keep a reference to their thread object while running, by
1414          * the time this function is called, the thread has already exited/detached,
1415          * i.e. mono_thread_detach_internal () has ran. The exception is during
1416          * shutdown, when mono_thread_detach_internal () can be called after this.
1417          */
1418         if (this_obj->handle) {
1419                 mono_threads_close_thread_handle (this_obj->handle);
1420                 this_obj->handle = NULL;
1421         }
1422
1423 #if HOST_WIN32
1424         CloseHandle (this_obj->native_handle);
1425 #endif
1426
1427         if (this_obj->synch_cs) {
1428                 MonoCoopMutex *synch_cs = this_obj->synch_cs;
1429                 this_obj->synch_cs = NULL;
1430                 mono_coop_mutex_destroy (synch_cs);
1431                 g_free (synch_cs);
1432         }
1433
1434         if (this_obj->name) {
1435                 void *name = this_obj->name;
1436                 this_obj->name = NULL;
1437                 g_free (name);
1438         }
1439 }
1440
1441 void
1442 ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms)
1443 {
1444         guint32 res;
1445         MonoInternalThread *thread = mono_thread_internal_current ();
1446
1447         THREAD_DEBUG (g_message ("%s: Sleeping for %d ms", __func__, ms));
1448
1449         if (mono_thread_current_check_pending_interrupt ())
1450                 return;
1451
1452         while (TRUE) {
1453                 gboolean alerted = FALSE;
1454
1455                 mono_thread_set_state (thread, ThreadState_WaitSleepJoin);
1456
1457                 res = mono_thread_info_sleep (ms, &alerted);
1458
1459                 mono_thread_clr_state (thread, ThreadState_WaitSleepJoin);
1460
1461                 if (alerted) {
1462                         MonoException* exc = mono_thread_execute_interruption ();
1463                         if (exc) {
1464                                 mono_raise_exception (exc);
1465                         } else {
1466                                 // FIXME: !MONO_INFINITE_WAIT
1467                                 if (ms != MONO_INFINITE_WAIT)
1468                                         break;
1469                         }
1470                 } else {
1471                         break;
1472                 }
1473         }
1474 }
1475
1476 void ves_icall_System_Threading_Thread_SpinWait_nop (void)
1477 {
1478 }
1479
1480 gint32
1481 ves_icall_System_Threading_Thread_GetDomainID (void)
1482 {
1483         return mono_domain_get()->domain_id;
1484 }
1485
1486 gboolean
1487 ves_icall_System_Threading_Thread_Yield (void)
1488 {
1489         return mono_thread_info_yield ();
1490 }
1491
1492 /*
1493  * mono_thread_get_name:
1494  *
1495  *   Return the name of the thread. NAME_LEN is set to the length of the name.
1496  * Return NULL if the thread has no name. The returned memory is owned by the
1497  * caller.
1498  */
1499 gunichar2*
1500 mono_thread_get_name (MonoInternalThread *this_obj, guint32 *name_len)
1501 {
1502         gunichar2 *res;
1503
1504         LOCK_THREAD (this_obj);
1505
1506         if (!this_obj->name) {
1507                 *name_len = 0;
1508                 res = NULL;
1509         } else {
1510                 *name_len = this_obj->name_len;
1511                 res = g_new (gunichar2, this_obj->name_len);
1512                 memcpy (res, this_obj->name, sizeof (gunichar2) * this_obj->name_len);
1513         }
1514
1515         UNLOCK_THREAD (this_obj);
1516
1517         return res;
1518 }
1519
1520 /**
1521  * mono_thread_get_name_utf8:
1522  * \returns the name of the thread in UTF-8.
1523  * Return NULL if the thread has no name.
1524  * The returned memory is owned by the caller.
1525  */
1526 char *
1527 mono_thread_get_name_utf8 (MonoThread *thread)
1528 {
1529         if (thread == NULL)
1530                 return NULL;
1531
1532         MonoInternalThread *internal = thread->internal_thread;
1533         if (internal == NULL)
1534                 return NULL;
1535
1536         LOCK_THREAD (internal);
1537
1538         char *tname = g_utf16_to_utf8 (internal->name, internal->name_len, NULL, NULL, NULL);
1539
1540         UNLOCK_THREAD (internal);
1541
1542         return tname;
1543 }
1544
1545 /**
1546  * mono_thread_get_managed_id:
1547  * \returns the \c Thread.ManagedThreadId value of \p thread.
1548  * Returns \c -1 if \p thread is NULL.
1549  */
1550 int32_t
1551 mono_thread_get_managed_id (MonoThread *thread)
1552 {
1553         if (thread == NULL)
1554                 return -1;
1555
1556         MonoInternalThread *internal = thread->internal_thread;
1557         if (internal == NULL)
1558                 return -1;
1559
1560         int32_t id = internal->managed_id;
1561
1562         return id;
1563 }
1564
1565 MonoString*
1566 ves_icall_System_Threading_Thread_GetName_internal (MonoInternalThread *this_obj)
1567 {
1568         MonoError error;
1569         MonoString* str;
1570
1571         error_init (&error);
1572
1573         LOCK_THREAD (this_obj);
1574
1575         if (!this_obj->name)
1576                 str = NULL;
1577         else
1578                 str = mono_string_new_utf16_checked (mono_domain_get (), this_obj->name, this_obj->name_len, &error);
1579
1580         UNLOCK_THREAD (this_obj);
1581
1582         if (mono_error_set_pending_exception (&error))
1583                 return NULL;
1584
1585         return str;
1586 }
1587
1588 void
1589 mono_thread_set_name_internal (MonoInternalThread *this_obj, MonoString *name, gboolean permanent, gboolean reset, MonoError *error)
1590 {
1591         LOCK_THREAD (this_obj);
1592
1593         error_init (error);
1594
1595         if (reset) {
1596                 this_obj->flags &= ~MONO_THREAD_FLAG_NAME_SET;
1597         } else if (this_obj->flags & MONO_THREAD_FLAG_NAME_SET) {
1598                 UNLOCK_THREAD (this_obj);
1599
1600                 mono_error_set_invalid_operation (error, "Thread.Name can only be set once.");
1601                 return;
1602         }
1603         if (this_obj->name) {
1604                 g_free (this_obj->name);
1605                 this_obj->name_len = 0;
1606         }
1607         if (name) {
1608                 this_obj->name = g_memdup (mono_string_chars (name), mono_string_length (name) * sizeof (gunichar2));
1609                 this_obj->name_len = mono_string_length (name);
1610
1611                 if (permanent)
1612                         this_obj->flags |= MONO_THREAD_FLAG_NAME_SET;
1613         }
1614         else
1615                 this_obj->name = NULL;
1616
1617
1618         UNLOCK_THREAD (this_obj);
1619
1620         if (this_obj->name && this_obj->tid) {
1621                 char *tname = mono_string_to_utf8_checked (name, error);
1622                 return_if_nok (error);
1623                 MONO_PROFILER_RAISE (thread_name, (this_obj->tid, tname));
1624                 mono_native_thread_set_name (thread_get_tid (this_obj), tname);
1625                 mono_free (tname);
1626         }
1627 }
1628
1629 void
1630 ves_icall_System_Threading_Thread_SetName_internal (MonoInternalThread *this_obj, MonoString *name)
1631 {
1632         MonoError error;
1633         mono_thread_set_name_internal (this_obj, name, TRUE, FALSE, &error);
1634         mono_error_set_pending_exception (&error);
1635 }
1636
1637 /*
1638  * ves_icall_System_Threading_Thread_GetPriority_internal:
1639  * @param this_obj: The MonoInternalThread on which to operate.
1640  *
1641  * Gets the priority of the given thread.
1642  * @return: The priority of the given thread.
1643  */
1644 int
1645 ves_icall_System_Threading_Thread_GetPriority (MonoThread *this_obj)
1646 {
1647         gint32 priority;
1648         MonoInternalThread *internal = this_obj->internal_thread;
1649
1650         LOCK_THREAD (internal);
1651         priority = internal->priority;
1652         UNLOCK_THREAD (internal);
1653
1654         return priority;
1655 }
1656
1657 /*
1658  * ves_icall_System_Threading_Thread_SetPriority_internal:
1659  * @param this_obj: The MonoInternalThread on which to operate.
1660  * @param priority: The priority to set.
1661  *
1662  * Sets the priority of the given thread.
1663  */
1664 void
1665 ves_icall_System_Threading_Thread_SetPriority (MonoThread *this_obj, int priority)
1666 {
1667         MonoInternalThread *internal = this_obj->internal_thread;
1668
1669         LOCK_THREAD (internal);
1670         internal->priority = priority;
1671         if (internal->thread_info != NULL)
1672                 mono_thread_internal_set_priority (internal, priority);
1673         UNLOCK_THREAD (internal);
1674 }
1675
1676 /* If the array is already in the requested domain, we just return it,
1677    otherwise we return a copy in that domain. */
1678 static MonoArray*
1679 byte_array_to_domain (MonoArray *arr, MonoDomain *domain, MonoError *error)
1680 {
1681         MonoArray *copy;
1682
1683         error_init (error);
1684         if (!arr)
1685                 return NULL;
1686
1687         if (mono_object_domain (arr) == domain)
1688                 return arr;
1689
1690         copy = mono_array_new_checked (domain, mono_defaults.byte_class, arr->max_length, error);
1691         memmove (mono_array_addr (copy, guint8, 0), mono_array_addr (arr, guint8, 0), arr->max_length);
1692         return copy;
1693 }
1694
1695 MonoArray*
1696 ves_icall_System_Threading_Thread_ByteArrayToRootDomain (MonoArray *arr)
1697 {
1698         MonoError error;
1699         MonoArray *result = byte_array_to_domain (arr, mono_get_root_domain (), &error);
1700         mono_error_set_pending_exception (&error);
1701         return result;
1702 }
1703
1704 MonoArray*
1705 ves_icall_System_Threading_Thread_ByteArrayToCurrentDomain (MonoArray *arr)
1706 {
1707         MonoError error;
1708         MonoArray *result = byte_array_to_domain (arr, mono_domain_get (), &error);
1709         mono_error_set_pending_exception (&error);
1710         return result;
1711 }
1712
1713 /**
1714  * mono_thread_current:
1715  */
1716 MonoThread *
1717 mono_thread_current (void)
1718 {
1719         MonoDomain *domain = mono_domain_get ();
1720         MonoInternalThread *internal = mono_thread_internal_current ();
1721         MonoThread **current_thread_ptr;
1722
1723         g_assert (internal);
1724         current_thread_ptr = get_current_thread_ptr_for_domain (domain, internal);
1725
1726         if (!*current_thread_ptr) {
1727                 g_assert (domain != mono_get_root_domain ());
1728                 *current_thread_ptr = create_thread_object (domain, internal);
1729         }
1730         return *current_thread_ptr;
1731 }
1732
1733 /* Return the thread object belonging to INTERNAL in the current domain */
1734 static MonoThread *
1735 mono_thread_current_for_thread (MonoInternalThread *internal)
1736 {
1737         MonoDomain *domain = mono_domain_get ();
1738         MonoThread **current_thread_ptr;
1739
1740         g_assert (internal);
1741         current_thread_ptr = get_current_thread_ptr_for_domain (domain, internal);
1742
1743         if (!*current_thread_ptr) {
1744                 g_assert (domain != mono_get_root_domain ());
1745                 *current_thread_ptr = create_thread_object (domain, internal);
1746         }
1747         return *current_thread_ptr;
1748 }
1749
1750 MonoInternalThread*
1751 mono_thread_internal_current (void)
1752 {
1753         MonoInternalThread *res = GET_CURRENT_OBJECT ();
1754         THREAD_DEBUG (g_message ("%s: returning %p", __func__, res));
1755         return res;
1756 }
1757
1758 static MonoThreadInfoWaitRet
1759 mono_join_uninterrupted (MonoThreadHandle* thread_to_join, gint32 ms, MonoError *error)
1760 {
1761         MonoException *exc;
1762         MonoThreadInfoWaitRet ret;
1763         gint64 start;
1764         gint32 diff_ms;
1765         gint32 wait = ms;
1766
1767         error_init (error);
1768
1769         start = (ms == -1) ? 0 : mono_msec_ticks ();
1770         for (;;) {
1771                 MONO_ENTER_GC_SAFE;
1772                 ret = mono_thread_info_wait_one_handle (thread_to_join, ms, TRUE);
1773                 MONO_EXIT_GC_SAFE;
1774
1775                 if (ret != MONO_THREAD_INFO_WAIT_RET_ALERTED)
1776                         return ret;
1777
1778                 exc = mono_thread_execute_interruption ();
1779                 if (exc) {
1780                         mono_error_set_exception_instance (error, exc);
1781                         return ret;
1782                 }
1783
1784                 if (ms == -1)
1785                         continue;
1786
1787                 /* Re-calculate ms according to the time passed */
1788                 diff_ms = (gint32)(mono_msec_ticks () - start);
1789                 if (diff_ms >= ms) {
1790                         ret = MONO_THREAD_INFO_WAIT_RET_TIMEOUT;
1791                         return ret;
1792                 }
1793                 wait = ms - diff_ms;
1794         }
1795
1796         return ret;
1797 }
1798
1799 gboolean
1800 ves_icall_System_Threading_Thread_Join_internal (MonoThread *this_obj, int ms)
1801 {
1802         MonoInternalThread *thread = this_obj->internal_thread;
1803         MonoThreadHandle *handle = thread->handle;
1804         MonoInternalThread *cur_thread = mono_thread_internal_current ();
1805         gboolean ret;
1806         MonoError error;
1807
1808         if (mono_thread_current_check_pending_interrupt ())
1809                 return FALSE;
1810
1811         LOCK_THREAD (thread);
1812
1813         if ((thread->state & ThreadState_Unstarted) != 0) {
1814                 UNLOCK_THREAD (thread);
1815
1816                 mono_set_pending_exception (mono_get_exception_thread_state ("Thread has not been started."));
1817                 return FALSE;
1818         }
1819
1820         MonoNativeThreadId tid = thread_get_tid (thread);
1821
1822         UNLOCK_THREAD (thread);
1823
1824         if (ms == -1)
1825                 ms = MONO_INFINITE_WAIT;
1826         THREAD_DEBUG (g_message ("%s: joining thread handle %p, %d ms", __func__, handle, ms));
1827
1828         mono_thread_set_state (cur_thread, ThreadState_WaitSleepJoin);
1829
1830         ret = mono_join_uninterrupted (handle, ms, &error);
1831
1832         mono_thread_clr_state (cur_thread, ThreadState_WaitSleepJoin);
1833
1834         mono_error_set_pending_exception (&error);
1835
1836         if (ret == MONO_THREAD_INFO_WAIT_RET_SUCCESS_0) {
1837                 THREAD_DEBUG (g_message ("%s: join successful", __func__));
1838
1839 #ifdef HOST_WIN32
1840                 /* TODO: Do this on Unix platforms as well. See PR #5454 for context.  */
1841                 /* Wait for the thread to really exit */
1842                 MONO_ENTER_GC_SAFE;
1843                 /* This shouldn't block */
1844                 mono_threads_join_lock ();
1845                 mono_native_thread_join (tid);
1846                 mono_threads_join_unlock ();
1847                 MONO_EXIT_GC_SAFE;
1848 #endif
1849
1850                 return TRUE;
1851         }
1852
1853         THREAD_DEBUG (g_message ("%s: join failed", __func__));
1854
1855         return FALSE;
1856 }
1857
1858 #define MANAGED_WAIT_FAILED 0x7fffffff
1859
1860 static gint32
1861 map_native_wait_result_to_managed (MonoW32HandleWaitRet val, gsize numobjects)
1862 {
1863         if (val >= MONO_W32HANDLE_WAIT_RET_SUCCESS_0 && val < MONO_W32HANDLE_WAIT_RET_SUCCESS_0 + numobjects) {
1864                 return WAIT_OBJECT_0 + (val - MONO_W32HANDLE_WAIT_RET_SUCCESS_0);
1865         } else if (val >= MONO_W32HANDLE_WAIT_RET_ABANDONED_0 && val < MONO_W32HANDLE_WAIT_RET_ABANDONED_0 + numobjects) {
1866                 return WAIT_ABANDONED_0 + (val - MONO_W32HANDLE_WAIT_RET_ABANDONED_0);
1867         } else if (val == MONO_W32HANDLE_WAIT_RET_ALERTED) {
1868                 return WAIT_IO_COMPLETION;
1869         } else if (val == MONO_W32HANDLE_WAIT_RET_TIMEOUT) {
1870                 return WAIT_TIMEOUT;
1871         } else if (val == MONO_W32HANDLE_WAIT_RET_FAILED) {
1872                 /* WAIT_FAILED in waithandle.cs is different from WAIT_FAILED in Win32 API */
1873                 return MANAGED_WAIT_FAILED;
1874         } else {
1875                 g_error ("%s: unknown val value %d", __func__, val);
1876         }
1877 }
1878
1879 gint32
1880 ves_icall_System_Threading_WaitHandle_Wait_internal (gpointer *handles, gint32 numhandles, MonoBoolean waitall, gint32 timeout, MonoError *error)
1881 {
1882         MonoW32HandleWaitRet ret;
1883         MonoInternalThread *thread;
1884         MonoException *exc;
1885         gint64 start;
1886         guint32 timeoutLeft;
1887
1888         /* Do this WaitSleepJoin check before creating objects */
1889         if (mono_thread_current_check_pending_interrupt ())
1890                 return map_native_wait_result_to_managed (MONO_W32HANDLE_WAIT_RET_FAILED, 0);
1891
1892         thread = mono_thread_internal_current ();
1893
1894         mono_thread_set_state (thread, ThreadState_WaitSleepJoin);
1895
1896         if (timeout == -1)
1897                 timeout = MONO_INFINITE_WAIT;
1898         if (timeout != MONO_INFINITE_WAIT)
1899                 start = mono_msec_ticks ();
1900
1901         timeoutLeft = timeout;
1902
1903         for (;;) {
1904                 MONO_ENTER_GC_SAFE;
1905 #ifdef HOST_WIN32
1906                 if (numhandles != 1)
1907                         ret = mono_w32handle_convert_wait_ret (WaitForMultipleObjectsEx (numhandles, handles, waitall, timeoutLeft, TRUE), numhandles);
1908                 else
1909                         ret = mono_w32handle_convert_wait_ret (WaitForSingleObjectEx (handles [0], timeoutLeft, TRUE), 1);
1910 #else
1911                 /* mono_w32handle_wait_multiple optimizes the case for numhandles == 1 */
1912                 ret = mono_w32handle_wait_multiple (handles, numhandles, waitall, timeoutLeft, TRUE);
1913 #endif /* HOST_WIN32 */
1914                 MONO_EXIT_GC_SAFE;
1915
1916                 if (ret != MONO_W32HANDLE_WAIT_RET_ALERTED)
1917                         break;
1918
1919                 exc = mono_thread_execute_interruption ();
1920                 if (exc) {
1921                         mono_error_set_exception_instance (error, exc);
1922                         break;
1923                 }
1924
1925                 if (timeout != MONO_INFINITE_WAIT) {
1926                         gint64 elapsed;
1927
1928                         elapsed = mono_msec_ticks () - start;
1929                         if (elapsed >= timeout) {
1930                                 ret = MONO_W32HANDLE_WAIT_RET_TIMEOUT;
1931                                 break;
1932                         }
1933
1934                         timeoutLeft = timeout - elapsed;
1935                 }
1936         }
1937
1938         mono_thread_clr_state (thread, ThreadState_WaitSleepJoin);
1939
1940         return map_native_wait_result_to_managed (ret, numhandles);
1941 }
1942
1943 gint32
1944 ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (gpointer toSignal, gpointer toWait, gint32 ms, MonoError *error)
1945 {
1946         MonoW32HandleWaitRet ret;
1947         MonoInternalThread *thread = mono_thread_internal_current ();
1948
1949         if (ms == -1)
1950                 ms = MONO_INFINITE_WAIT;
1951
1952         if (mono_thread_current_check_pending_interrupt ())
1953                 return map_native_wait_result_to_managed (MONO_W32HANDLE_WAIT_RET_FAILED, 0);
1954
1955         mono_thread_set_state (thread, ThreadState_WaitSleepJoin);
1956
1957         MONO_ENTER_GC_SAFE;
1958 #ifdef HOST_WIN32
1959         ret = mono_w32handle_convert_wait_ret (SignalObjectAndWait (toSignal, toWait, ms, TRUE), 1);
1960 #else
1961         ret = mono_w32handle_signal_and_wait (toSignal, toWait, ms, TRUE);
1962 #endif
1963         MONO_EXIT_GC_SAFE;
1964
1965         mono_thread_clr_state (thread, ThreadState_WaitSleepJoin);
1966
1967         return map_native_wait_result_to_managed (ret, 1);
1968 }
1969
1970 gint32 ves_icall_System_Threading_Interlocked_Increment_Int (gint32 *location)
1971 {
1972         return InterlockedIncrement (location);
1973 }
1974
1975 gint64 ves_icall_System_Threading_Interlocked_Increment_Long (gint64 *location)
1976 {
1977 #if SIZEOF_VOID_P == 4
1978         if (G_UNLIKELY ((size_t)location & 0x7)) {
1979                 gint64 ret;
1980                 mono_interlocked_lock ();
1981                 (*location)++;
1982                 ret = *location;
1983                 mono_interlocked_unlock ();
1984                 return ret;
1985         }
1986 #endif
1987         return InterlockedIncrement64 (location);
1988 }
1989
1990 gint32 ves_icall_System_Threading_Interlocked_Decrement_Int (gint32 *location)
1991 {
1992         return InterlockedDecrement(location);
1993 }
1994
1995 gint64 ves_icall_System_Threading_Interlocked_Decrement_Long (gint64 * location)
1996 {
1997 #if SIZEOF_VOID_P == 4
1998         if (G_UNLIKELY ((size_t)location & 0x7)) {
1999                 gint64 ret;
2000                 mono_interlocked_lock ();
2001                 (*location)--;
2002                 ret = *location;
2003                 mono_interlocked_unlock ();
2004                 return ret;
2005         }
2006 #endif
2007         return InterlockedDecrement64 (location);
2008 }
2009
2010 gint32 ves_icall_System_Threading_Interlocked_Exchange_Int (gint32 *location, gint32 value)
2011 {
2012         return InterlockedExchange(location, value);
2013 }
2014
2015 MonoObject * ves_icall_System_Threading_Interlocked_Exchange_Object (MonoObject **location, MonoObject *value)
2016 {
2017         MonoObject *res;
2018         res = (MonoObject *) InterlockedExchangePointer((gpointer *) location, value);
2019         mono_gc_wbarrier_generic_nostore (location);
2020         return res;
2021 }
2022
2023 gpointer ves_icall_System_Threading_Interlocked_Exchange_IntPtr (gpointer *location, gpointer value)
2024 {
2025         return InterlockedExchangePointer(location, value);
2026 }
2027
2028 gfloat ves_icall_System_Threading_Interlocked_Exchange_Single (gfloat *location, gfloat value)
2029 {
2030         IntFloatUnion val, ret;
2031
2032         val.fval = value;
2033         ret.ival = InterlockedExchange((gint32 *) location, val.ival);
2034
2035         return ret.fval;
2036 }
2037
2038 gint64
2039 ves_icall_System_Threading_Interlocked_Exchange_Long (gint64 *location, gint64 value)
2040 {
2041 #if SIZEOF_VOID_P == 4
2042         if (G_UNLIKELY ((size_t)location & 0x7)) {
2043                 gint64 ret;
2044                 mono_interlocked_lock ();
2045                 ret = *location;
2046                 *location = value;
2047                 mono_interlocked_unlock ();
2048                 return ret;
2049         }
2050 #endif
2051         return InterlockedExchange64 (location, value);
2052 }
2053
2054 gdouble
2055 ves_icall_System_Threading_Interlocked_Exchange_Double (gdouble *location, gdouble value)
2056 {
2057         LongDoubleUnion val, ret;
2058
2059         val.fval = value;
2060         ret.ival = (gint64)InterlockedExchange64((gint64 *) location, val.ival);
2061
2062         return ret.fval;
2063 }
2064
2065 gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *location, gint32 value, gint32 comparand)
2066 {
2067         return InterlockedCompareExchange(location, value, comparand);
2068 }
2069
2070 gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int_Success(gint32 *location, gint32 value, gint32 comparand, MonoBoolean *success)
2071 {
2072         gint32 r = InterlockedCompareExchange(location, value, comparand);
2073         *success = r == comparand;
2074         return r;
2075 }
2076
2077 MonoObject * ves_icall_System_Threading_Interlocked_CompareExchange_Object (MonoObject **location, MonoObject *value, MonoObject *comparand)
2078 {
2079         MonoObject *res;
2080         res = (MonoObject *) InterlockedCompareExchangePointer((gpointer *) location, value, comparand);
2081         mono_gc_wbarrier_generic_nostore (location);
2082         return res;
2083 }
2084
2085 gpointer ves_icall_System_Threading_Interlocked_CompareExchange_IntPtr(gpointer *location, gpointer value, gpointer comparand)
2086 {
2087         return InterlockedCompareExchangePointer(location, value, comparand);
2088 }
2089
2090 gfloat ves_icall_System_Threading_Interlocked_CompareExchange_Single (gfloat *location, gfloat value, gfloat comparand)
2091 {
2092         IntFloatUnion val, ret, cmp;
2093
2094         val.fval = value;
2095         cmp.fval = comparand;
2096         ret.ival = InterlockedCompareExchange((gint32 *) location, val.ival, cmp.ival);
2097
2098         return ret.fval;
2099 }
2100
2101 gdouble
2102 ves_icall_System_Threading_Interlocked_CompareExchange_Double (gdouble *location, gdouble value, gdouble comparand)
2103 {
2104 #if SIZEOF_VOID_P == 8
2105         LongDoubleUnion val, comp, ret;
2106
2107         val.fval = value;
2108         comp.fval = comparand;
2109         ret.ival = (gint64)InterlockedCompareExchangePointer((gpointer *) location, (gpointer)val.ival, (gpointer)comp.ival);
2110
2111         return ret.fval;
2112 #else
2113         gdouble old;
2114
2115         mono_interlocked_lock ();
2116         old = *location;
2117         if (old == comparand)
2118                 *location = value;
2119         mono_interlocked_unlock ();
2120
2121         return old;
2122 #endif
2123 }
2124
2125 gint64
2126 ves_icall_System_Threading_Interlocked_CompareExchange_Long (gint64 *location, gint64 value, gint64 comparand)
2127 {
2128 #if SIZEOF_VOID_P == 4
2129         if (G_UNLIKELY ((size_t)location & 0x7)) {
2130                 gint64 old;
2131                 mono_interlocked_lock ();
2132                 old = *location;
2133                 if (old == comparand)
2134                         *location = value;
2135                 mono_interlocked_unlock ();
2136                 return old;
2137         }
2138 #endif
2139         return InterlockedCompareExchange64 (location, value, comparand);
2140 }
2141
2142 MonoObject*
2143 ves_icall_System_Threading_Interlocked_CompareExchange_T (MonoObject **location, MonoObject *value, MonoObject *comparand)
2144 {
2145         MonoObject *res;
2146         res = (MonoObject *)InterlockedCompareExchangePointer ((volatile gpointer *)location, value, comparand);
2147         mono_gc_wbarrier_generic_nostore (location);
2148         return res;
2149 }
2150
2151 MonoObject*
2152 ves_icall_System_Threading_Interlocked_Exchange_T (MonoObject **location, MonoObject *value)
2153 {
2154         MonoObject *res;
2155         MONO_CHECK_NULL (location, NULL);
2156         res = (MonoObject *)InterlockedExchangePointer ((volatile gpointer *)location, value);
2157         mono_gc_wbarrier_generic_nostore (location);
2158         return res;
2159 }
2160
2161 gint32
2162 ves_icall_System_Threading_Interlocked_Add_Int (gint32 *location, gint32 value)
2163 {
2164         return InterlockedAdd (location, value);
2165 }
2166
2167 gint64
2168 ves_icall_System_Threading_Interlocked_Add_Long (gint64 *location, gint64 value)
2169 {
2170 #if SIZEOF_VOID_P == 4
2171         if (G_UNLIKELY ((size_t)location & 0x7)) {
2172                 gint64 ret;
2173                 mono_interlocked_lock ();
2174                 *location += value;
2175                 ret = *location;
2176                 mono_interlocked_unlock ();
2177                 return ret;
2178         }
2179 #endif
2180         return InterlockedAdd64 (location, value);
2181 }
2182
2183 gint64
2184 ves_icall_System_Threading_Interlocked_Read_Long (gint64 *location)
2185 {
2186 #if SIZEOF_VOID_P == 4
2187         if (G_UNLIKELY ((size_t)location & 0x7)) {
2188                 gint64 ret;
2189                 mono_interlocked_lock ();
2190                 ret = *location;
2191                 mono_interlocked_unlock ();
2192                 return ret;
2193         }
2194 #endif
2195         return InterlockedRead64 (location);
2196 }
2197
2198 void
2199 ves_icall_System_Threading_Thread_MemoryBarrier (void)
2200 {
2201         mono_memory_barrier ();
2202 }
2203
2204 void
2205 ves_icall_System_Threading_Thread_ClrState (MonoInternalThread* this_obj, guint32 state)
2206 {
2207         mono_thread_clr_state (this_obj, (MonoThreadState)state);
2208
2209         if (state & ThreadState_Background) {
2210                 /* If the thread changes the background mode, the main thread has to
2211                  * be notified, since it has to rebuild the list of threads to
2212                  * wait for.
2213                  */
2214                 mono_os_event_set (&background_change_event);
2215         }
2216 }
2217
2218 void
2219 ves_icall_System_Threading_Thread_SetState (MonoInternalThread* this_obj, guint32 state)
2220 {
2221         mono_thread_set_state (this_obj, (MonoThreadState)state);
2222
2223         if (state & ThreadState_Background) {
2224                 /* If the thread changes the background mode, the main thread has to
2225                  * be notified, since it has to rebuild the list of threads to
2226                  * wait for.
2227                  */
2228                 mono_os_event_set (&background_change_event);
2229         }
2230 }
2231
2232 guint32
2233 ves_icall_System_Threading_Thread_GetState (MonoInternalThread* this_obj)
2234 {
2235         guint32 state;
2236
2237         LOCK_THREAD (this_obj);
2238
2239         state = this_obj->state;
2240
2241         UNLOCK_THREAD (this_obj);
2242
2243         return state;
2244 }
2245
2246 void ves_icall_System_Threading_Thread_Interrupt_internal (MonoThread *this_obj)
2247 {
2248         MonoInternalThread *current;
2249         gboolean throw_;
2250         MonoInternalThread *thread = this_obj->internal_thread;
2251
2252         LOCK_THREAD (thread);
2253
2254         current = mono_thread_internal_current ();
2255
2256         thread->thread_interrupt_requested = TRUE;
2257         throw_ = current != thread && (thread->state & ThreadState_WaitSleepJoin);
2258
2259         UNLOCK_THREAD (thread);
2260
2261         if (throw_) {
2262                 async_abort_internal (thread, FALSE);
2263         }
2264 }
2265
2266 /**
2267  * mono_thread_current_check_pending_interrupt:
2268  * Checks if there's a interruption request and set the pending exception if so.
2269  * \returns true if a pending exception was set
2270  */
2271 gboolean
2272 mono_thread_current_check_pending_interrupt (void)
2273 {
2274         MonoInternalThread *thread = mono_thread_internal_current ();
2275         gboolean throw_ = FALSE;
2276
2277         LOCK_THREAD (thread);
2278
2279         if (thread->thread_interrupt_requested) {
2280                 throw_ = TRUE;
2281                 thread->thread_interrupt_requested = FALSE;
2282         }
2283
2284         UNLOCK_THREAD (thread);
2285
2286         if (throw_)
2287                 mono_set_pending_exception (mono_get_exception_thread_interrupted ());
2288         return throw_;
2289 }
2290
2291 static gboolean
2292 request_thread_abort (MonoInternalThread *thread, MonoObject *state, gboolean appdomain_unload)
2293 {
2294         LOCK_THREAD (thread);
2295
2296         if (thread->state & (ThreadState_AbortRequested | ThreadState_Stopped))
2297         {
2298                 UNLOCK_THREAD (thread);
2299                 return FALSE;
2300         }
2301
2302         if ((thread->state & ThreadState_Unstarted) != 0) {
2303                 thread->state |= ThreadState_Aborted;
2304                 UNLOCK_THREAD (thread);
2305                 return FALSE;
2306         }
2307
2308         thread->state |= ThreadState_AbortRequested;
2309         if (appdomain_unload)
2310                 thread->flags |= MONO_THREAD_FLAG_APPDOMAIN_ABORT;
2311         else
2312                 thread->flags &= ~MONO_THREAD_FLAG_APPDOMAIN_ABORT;
2313
2314         if (thread->abort_state_handle)
2315                 mono_gchandle_free (thread->abort_state_handle);
2316         if (state) {
2317                 thread->abort_state_handle = mono_gchandle_new (state, FALSE);
2318                 g_assert (thread->abort_state_handle);
2319         } else {
2320                 thread->abort_state_handle = 0;
2321         }
2322         thread->abort_exc = NULL;
2323
2324         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Abort requested for %p (%"G_GSIZE_FORMAT")", __func__, mono_native_thread_id_get (), thread, (gsize)thread->tid));
2325
2326         /* During shutdown, we can't wait for other threads */
2327         if (!shutting_down)
2328                 /* Make sure the thread is awake */
2329                 mono_thread_resume (thread);
2330
2331         UNLOCK_THREAD (thread);
2332         return TRUE;
2333 }
2334
2335 void
2336 ves_icall_System_Threading_Thread_Abort (MonoInternalThread *thread, MonoObject *state)
2337 {
2338         if (!request_thread_abort (thread, state, FALSE))
2339                 return;
2340
2341         if (thread == mono_thread_internal_current ()) {
2342                 MonoError error;
2343                 self_abort_internal (&error);
2344                 mono_error_set_pending_exception (&error);
2345         } else {
2346                 async_abort_internal (thread, TRUE);
2347         }
2348 }
2349
2350 /**
2351  * mono_thread_internal_abort:
2352  * Request thread \p thread to be aborted.
2353  * \p thread MUST NOT be the current thread.
2354  */
2355 void
2356 mono_thread_internal_abort (MonoInternalThread *thread, gboolean appdomain_unload)
2357 {
2358         g_assert (thread != mono_thread_internal_current ());
2359
2360         if (!request_thread_abort (thread, NULL, appdomain_unload))
2361                 return;
2362         async_abort_internal (thread, TRUE);
2363 }
2364
2365 void
2366 ves_icall_System_Threading_Thread_ResetAbort (MonoThread *this_obj)
2367 {
2368         MonoInternalThread *thread = mono_thread_internal_current ();
2369         gboolean was_aborting, is_domain_abort;
2370
2371         LOCK_THREAD (thread);
2372         was_aborting = thread->state & ThreadState_AbortRequested;
2373         is_domain_abort = thread->flags & MONO_THREAD_FLAG_APPDOMAIN_ABORT;
2374
2375         if (was_aborting && !is_domain_abort)
2376                 thread->state &= ~ThreadState_AbortRequested;
2377         UNLOCK_THREAD (thread);
2378
2379         if (!was_aborting) {
2380                 const char *msg = "Unable to reset abort because no abort was requested";
2381                 mono_set_pending_exception (mono_get_exception_thread_state (msg));
2382                 return;
2383         } else if (is_domain_abort) {
2384                 /* Silently ignore abort resets in unloading appdomains */
2385                 return;
2386         }
2387
2388         mono_get_eh_callbacks ()->mono_clear_abort_threshold ();
2389         thread->abort_exc = NULL;
2390         if (thread->abort_state_handle) {
2391                 mono_gchandle_free (thread->abort_state_handle);
2392                 /* This is actually not necessary - the handle
2393                    only counts if the exception is set */
2394                 thread->abort_state_handle = 0;
2395         }
2396 }
2397
2398 void
2399 mono_thread_internal_reset_abort (MonoInternalThread *thread)
2400 {
2401         LOCK_THREAD (thread);
2402
2403         thread->state &= ~ThreadState_AbortRequested;
2404
2405         if (thread->abort_exc) {
2406                 mono_get_eh_callbacks ()->mono_clear_abort_threshold ();
2407                 thread->abort_exc = NULL;
2408                 if (thread->abort_state_handle) {
2409                         mono_gchandle_free (thread->abort_state_handle);
2410                         /* This is actually not necessary - the handle
2411                            only counts if the exception is set */
2412                         thread->abort_state_handle = 0;
2413                 }
2414         }
2415
2416         UNLOCK_THREAD (thread);
2417 }
2418
2419 MonoObject*
2420 ves_icall_System_Threading_Thread_GetAbortExceptionState (MonoThread *this_obj)
2421 {
2422         MonoError error;
2423         MonoInternalThread *thread = this_obj->internal_thread;
2424         MonoObject *state, *deserialized = NULL;
2425         MonoDomain *domain;
2426
2427         if (!thread->abort_state_handle)
2428                 return NULL;
2429
2430         state = mono_gchandle_get_target (thread->abort_state_handle);
2431         g_assert (state);
2432
2433         domain = mono_domain_get ();
2434         if (mono_object_domain (state) == domain)
2435                 return state;
2436
2437         deserialized = mono_object_xdomain_representation (state, domain, &error);
2438
2439         if (!deserialized) {
2440                 MonoException *invalid_op_exc = mono_get_exception_invalid_operation ("Thread.ExceptionState cannot access an ExceptionState from a different AppDomain");
2441                 if (!is_ok (&error)) {
2442                         MonoObject *exc = (MonoObject*)mono_error_convert_to_exception (&error);
2443                         MONO_OBJECT_SETREF (invalid_op_exc, inner_ex, exc);
2444                 }
2445                 mono_set_pending_exception (invalid_op_exc);
2446                 return NULL;
2447         }
2448
2449         return deserialized;
2450 }
2451
2452 static gboolean
2453 mono_thread_suspend (MonoInternalThread *thread)
2454 {
2455         LOCK_THREAD (thread);
2456
2457         if (thread->state & (ThreadState_Unstarted | ThreadState_Aborted | ThreadState_Stopped))
2458         {
2459                 UNLOCK_THREAD (thread);
2460                 return FALSE;
2461         }
2462
2463         if (thread->state & (ThreadState_Suspended | ThreadState_SuspendRequested | ThreadState_AbortRequested))
2464         {
2465                 UNLOCK_THREAD (thread);
2466                 return TRUE;
2467         }
2468
2469         thread->state |= ThreadState_SuspendRequested;
2470         mono_os_event_reset (thread->suspended);
2471
2472         if (thread == mono_thread_internal_current ()) {
2473                 /* calls UNLOCK_THREAD (thread) */
2474                 self_suspend_internal ();
2475         } else {
2476                 /* calls UNLOCK_THREAD (thread) */
2477                 async_suspend_internal (thread, FALSE);
2478         }
2479
2480         return TRUE;
2481 }
2482
2483 void
2484 ves_icall_System_Threading_Thread_Suspend (MonoThread *this_obj)
2485 {
2486         if (!mono_thread_suspend (this_obj->internal_thread)) {
2487                 mono_set_pending_exception (mono_get_exception_thread_state ("Thread has not been started, or is dead."));
2488                 return;
2489         }
2490 }
2491
2492 /* LOCKING: LOCK_THREAD(thread) must be held */
2493 static gboolean
2494 mono_thread_resume (MonoInternalThread *thread)
2495 {
2496         if ((thread->state & ThreadState_SuspendRequested) != 0) {
2497                 // MOSTLY_ASYNC_SAFE_PRINTF ("RESUME (1) thread %p\n", thread_get_tid (thread));
2498                 thread->state &= ~ThreadState_SuspendRequested;
2499                 mono_os_event_set (thread->suspended);
2500                 return TRUE;
2501         }
2502
2503         if ((thread->state & ThreadState_Suspended) == 0 ||
2504                 (thread->state & ThreadState_Unstarted) != 0 ||
2505                 (thread->state & ThreadState_Aborted) != 0 ||
2506                 (thread->state & ThreadState_Stopped) != 0)
2507         {
2508                 // MOSTLY_ASYNC_SAFE_PRINTF ("RESUME (2) thread %p\n", thread_get_tid (thread));
2509                 return FALSE;
2510         }
2511
2512         // MOSTLY_ASYNC_SAFE_PRINTF ("RESUME (3) thread %p\n", thread_get_tid (thread));
2513
2514         mono_os_event_set (thread->suspended);
2515
2516         if (!thread->self_suspended) {
2517                 UNLOCK_THREAD (thread);
2518
2519                 /* Awake the thread */
2520                 if (!mono_thread_info_resume (thread_get_tid (thread)))
2521                         return FALSE;
2522
2523                 LOCK_THREAD (thread);
2524         }
2525
2526         thread->state &= ~ThreadState_Suspended;
2527
2528         return TRUE;
2529 }
2530
2531 void
2532 ves_icall_System_Threading_Thread_Resume (MonoThread *thread)
2533 {
2534         if (!thread->internal_thread) {
2535                 mono_set_pending_exception (mono_get_exception_thread_state ("Thread has not been started, or is dead."));
2536         } else {
2537                 LOCK_THREAD (thread->internal_thread);
2538                 if (!mono_thread_resume (thread->internal_thread))
2539                         mono_set_pending_exception (mono_get_exception_thread_state ("Thread has not been started, or is dead."));
2540                 UNLOCK_THREAD (thread->internal_thread);
2541         }
2542 }
2543
2544 static gboolean
2545 mono_threads_is_critical_method (MonoMethod *method)
2546 {
2547         switch (method->wrapper_type) {
2548         case MONO_WRAPPER_RUNTIME_INVOKE:
2549         case MONO_WRAPPER_XDOMAIN_INVOKE:
2550         case MONO_WRAPPER_XDOMAIN_DISPATCH:
2551                 return TRUE;
2552         }
2553         return FALSE;
2554 }
2555
2556 static gboolean
2557 find_wrapper (MonoMethod *m, gint no, gint ilo, gboolean managed, gpointer data)
2558 {
2559         if (managed)
2560                 return TRUE;
2561
2562         if (mono_threads_is_critical_method (m)) {
2563                 *((gboolean*)data) = TRUE;
2564                 return TRUE;
2565         }
2566         return FALSE;
2567 }
2568
2569 static gboolean
2570 is_running_protected_wrapper (void)
2571 {
2572         gboolean found = FALSE;
2573         mono_stack_walk (find_wrapper, &found);
2574         return found;
2575 }
2576
2577 /**
2578  * mono_thread_stop:
2579  */
2580 void
2581 mono_thread_stop (MonoThread *thread)
2582 {
2583         MonoInternalThread *internal = thread->internal_thread;
2584
2585         if (!request_thread_abort (internal, NULL, FALSE))
2586                 return;
2587
2588         if (internal == mono_thread_internal_current ()) {
2589                 MonoError error;
2590                 self_abort_internal (&error);
2591                 /*
2592                 This function is part of the embeding API and has no way to return the exception
2593                 to be thrown. So what we do is keep the old behavior and raise the exception.
2594                 */
2595                 mono_error_raise_exception (&error); /* OK to throw, see note */
2596         } else {
2597                 async_abort_internal (internal, TRUE);
2598         }
2599 }
2600
2601 gint8
2602 ves_icall_System_Threading_Thread_VolatileRead1 (void *ptr)
2603 {
2604         gint8 tmp = *(volatile gint8 *)ptr;
2605         mono_memory_barrier ();
2606         return tmp;
2607 }
2608
2609 gint16
2610 ves_icall_System_Threading_Thread_VolatileRead2 (void *ptr)
2611 {
2612         gint16 tmp = *(volatile gint16 *)ptr;
2613         mono_memory_barrier ();
2614         return tmp;
2615 }
2616
2617 gint32
2618 ves_icall_System_Threading_Thread_VolatileRead4 (void *ptr)
2619 {
2620         gint32 tmp = *(volatile gint32 *)ptr;
2621         mono_memory_barrier ();
2622         return tmp;
2623 }
2624
2625 gint64
2626 ves_icall_System_Threading_Thread_VolatileRead8 (void *ptr)
2627 {
2628         gint64 tmp = *(volatile gint64 *)ptr;
2629         mono_memory_barrier ();
2630         return tmp;
2631 }
2632
2633 void *
2634 ves_icall_System_Threading_Thread_VolatileReadIntPtr (void *ptr)
2635 {
2636         volatile void *tmp = *(volatile void **)ptr;
2637         mono_memory_barrier ();
2638         return (void *) tmp;
2639 }
2640
2641 void *
2642 ves_icall_System_Threading_Thread_VolatileReadObject (void *ptr)
2643 {
2644         volatile MonoObject *tmp = *(volatile MonoObject **)ptr;
2645         mono_memory_barrier ();
2646         return (MonoObject *) tmp;
2647 }
2648
2649 double
2650 ves_icall_System_Threading_Thread_VolatileReadDouble (void *ptr)
2651 {
2652         double tmp = *(volatile double *)ptr;
2653         mono_memory_barrier ();
2654         return tmp;
2655 }
2656
2657 float
2658 ves_icall_System_Threading_Thread_VolatileReadFloat (void *ptr)
2659 {
2660         float tmp = *(volatile float *)ptr;
2661         mono_memory_barrier ();
2662         return tmp;
2663 }
2664
2665 gint8
2666 ves_icall_System_Threading_Volatile_Read1 (void *ptr)
2667 {
2668         return InterlockedRead8 ((volatile gint8 *)ptr);
2669 }
2670
2671 gint16
2672 ves_icall_System_Threading_Volatile_Read2 (void *ptr)
2673 {
2674         return InterlockedRead16 ((volatile gint16 *)ptr);
2675 }
2676
2677 gint32
2678 ves_icall_System_Threading_Volatile_Read4 (void *ptr)
2679 {
2680         return InterlockedRead ((volatile gint32 *)ptr);
2681 }
2682
2683 gint64
2684 ves_icall_System_Threading_Volatile_Read8 (void *ptr)
2685 {
2686 #if SIZEOF_VOID_P == 4
2687         if (G_UNLIKELY ((size_t)ptr & 0x7)) {
2688                 gint64 val;
2689                 mono_interlocked_lock ();
2690                 val = *(gint64*)ptr;
2691                 mono_interlocked_unlock ();
2692                 return val;
2693         }
2694 #endif
2695         return InterlockedRead64 ((volatile gint64 *)ptr);
2696 }
2697
2698 void *
2699 ves_icall_System_Threading_Volatile_ReadIntPtr (void *ptr)
2700 {
2701         return InterlockedReadPointer ((volatile gpointer *)ptr);
2702 }
2703
2704 double
2705 ves_icall_System_Threading_Volatile_ReadDouble (void *ptr)
2706 {
2707         LongDoubleUnion u;
2708
2709 #if SIZEOF_VOID_P == 4
2710         if (G_UNLIKELY ((size_t)ptr & 0x7)) {
2711                 double val;
2712                 mono_interlocked_lock ();
2713                 val = *(double*)ptr;
2714                 mono_interlocked_unlock ();
2715                 return val;
2716         }
2717 #endif
2718
2719         u.ival = InterlockedRead64 ((volatile gint64 *)ptr);
2720
2721         return u.fval;
2722 }
2723
2724 float
2725 ves_icall_System_Threading_Volatile_ReadFloat (void *ptr)
2726 {
2727         IntFloatUnion u;
2728
2729         u.ival = InterlockedRead ((volatile gint32 *)ptr);
2730
2731         return u.fval;
2732 }
2733
2734 MonoObject*
2735 ves_icall_System_Threading_Volatile_Read_T (void *ptr)
2736 {
2737         return (MonoObject *)InterlockedReadPointer ((volatile gpointer *)ptr);
2738 }
2739
2740 void
2741 ves_icall_System_Threading_Thread_VolatileWrite1 (void *ptr, gint8 value)
2742 {
2743         mono_memory_barrier ();
2744         *(volatile gint8 *)ptr = value;
2745 }
2746
2747 void
2748 ves_icall_System_Threading_Thread_VolatileWrite2 (void *ptr, gint16 value)
2749 {
2750         mono_memory_barrier ();
2751         *(volatile gint16 *)ptr = value;
2752 }
2753
2754 void
2755 ves_icall_System_Threading_Thread_VolatileWrite4 (void *ptr, gint32 value)
2756 {
2757         mono_memory_barrier ();
2758         *(volatile gint32 *)ptr = value;
2759 }
2760
2761 void
2762 ves_icall_System_Threading_Thread_VolatileWrite8 (void *ptr, gint64 value)
2763 {
2764         mono_memory_barrier ();
2765         *(volatile gint64 *)ptr = value;
2766 }
2767
2768 void
2769 ves_icall_System_Threading_Thread_VolatileWriteIntPtr (void *ptr, void *value)
2770 {
2771         mono_memory_barrier ();
2772         *(volatile void **)ptr = value;
2773 }
2774
2775 void
2776 ves_icall_System_Threading_Thread_VolatileWriteObject (void *ptr, MonoObject *value)
2777 {
2778         mono_memory_barrier ();
2779         mono_gc_wbarrier_generic_store (ptr, value);
2780 }
2781
2782 void
2783 ves_icall_System_Threading_Thread_VolatileWriteDouble (void *ptr, double value)
2784 {
2785         mono_memory_barrier ();
2786         *(volatile double *)ptr = value;
2787 }
2788
2789 void
2790 ves_icall_System_Threading_Thread_VolatileWriteFloat (void *ptr, float value)
2791 {
2792         mono_memory_barrier ();
2793         *(volatile float *)ptr = value;
2794 }
2795
2796 void
2797 ves_icall_System_Threading_Volatile_Write1 (void *ptr, gint8 value)
2798 {
2799         InterlockedWrite8 ((volatile gint8 *)ptr, value);
2800 }
2801
2802 void
2803 ves_icall_System_Threading_Volatile_Write2 (void *ptr, gint16 value)
2804 {
2805         InterlockedWrite16 ((volatile gint16 *)ptr, value);
2806 }
2807
2808 void
2809 ves_icall_System_Threading_Volatile_Write4 (void *ptr, gint32 value)
2810 {
2811         InterlockedWrite ((volatile gint32 *)ptr, value);
2812 }
2813
2814 void
2815 ves_icall_System_Threading_Volatile_Write8 (void *ptr, gint64 value)
2816 {
2817 #if SIZEOF_VOID_P == 4
2818         if (G_UNLIKELY ((size_t)ptr & 0x7)) {
2819                 mono_interlocked_lock ();
2820                 *(gint64*)ptr = value;
2821                 mono_interlocked_unlock ();
2822                 return;
2823         }
2824 #endif
2825
2826         InterlockedWrite64 ((volatile gint64 *)ptr, value);
2827 }
2828
2829 void
2830 ves_icall_System_Threading_Volatile_WriteIntPtr (void *ptr, void *value)
2831 {
2832         InterlockedWritePointer ((volatile gpointer *)ptr, value);
2833 }
2834
2835 void
2836 ves_icall_System_Threading_Volatile_WriteDouble (void *ptr, double value)
2837 {
2838         LongDoubleUnion u;
2839
2840 #if SIZEOF_VOID_P == 4
2841         if (G_UNLIKELY ((size_t)ptr & 0x7)) {
2842                 mono_interlocked_lock ();
2843                 *(double*)ptr = value;
2844                 mono_interlocked_unlock ();
2845                 return;
2846         }
2847 #endif
2848
2849         u.fval = value;
2850
2851         InterlockedWrite64 ((volatile gint64 *)ptr, u.ival);
2852 }
2853
2854 void
2855 ves_icall_System_Threading_Volatile_WriteFloat (void *ptr, float value)
2856 {
2857         IntFloatUnion u;
2858
2859         u.fval = value;
2860
2861         InterlockedWrite ((volatile gint32 *)ptr, u.ival);
2862 }
2863
2864 void
2865 ves_icall_System_Threading_Volatile_Write_T (void *ptr, MonoObject *value)
2866 {
2867         mono_gc_wbarrier_generic_store_atomic (ptr, value);
2868 }
2869
2870 static void
2871 free_context (void *user_data)
2872 {
2873         ContextStaticData *data = user_data;
2874
2875         mono_threads_lock ();
2876
2877         /*
2878          * There is no guarantee that, by the point this reference queue callback
2879          * has been invoked, the GC handle associated with the object will fail to
2880          * resolve as one might expect. So if we don't free and remove the GC
2881          * handle here, free_context_static_data_helper () could end up resolving
2882          * a GC handle to an actually-dead context which would contain a pointer
2883          * to an already-freed static data segment, resulting in a crash when
2884          * accessing it.
2885          */
2886         g_hash_table_remove (contexts, GUINT_TO_POINTER (data->gc_handle));
2887
2888         mono_threads_unlock ();
2889
2890         mono_gchandle_free (data->gc_handle);
2891         mono_free_static_data (data->static_data);
2892         g_free (data);
2893 }
2894
2895 void
2896 mono_threads_register_app_context (MonoAppContext *ctx, MonoError *error)
2897 {
2898         error_init (error);
2899         mono_threads_lock ();
2900
2901         //g_print ("Registering context %d in domain %d\n", ctx->context_id, ctx->domain_id);
2902
2903         if (!contexts)
2904                 contexts = g_hash_table_new (NULL, NULL);
2905
2906         if (!context_queue)
2907                 context_queue = mono_gc_reference_queue_new (free_context);
2908
2909         gpointer gch = GUINT_TO_POINTER (mono_gchandle_new_weakref (&ctx->obj, FALSE));
2910         g_hash_table_insert (contexts, gch, gch);
2911
2912         /*
2913          * We use this intermediate structure to contain a duplicate pointer to
2914          * the static data because we can't rely on being able to resolve the GC
2915          * handle in the reference queue callback.
2916          */
2917         ContextStaticData *data = g_new0 (ContextStaticData, 1);
2918         data->gc_handle = GPOINTER_TO_UINT (gch);
2919         ctx->data = data;
2920
2921         context_adjust_static_data (ctx);
2922         mono_gc_reference_queue_add (context_queue, &ctx->obj, data);
2923
2924         mono_threads_unlock ();
2925
2926         MONO_PROFILER_RAISE (context_loaded, (ctx));
2927 }
2928
2929 void
2930 ves_icall_System_Runtime_Remoting_Contexts_Context_RegisterContext (MonoAppContextHandle ctx, MonoError *error)
2931 {
2932         error_init (error);
2933         mono_threads_register_app_context (MONO_HANDLE_RAW (ctx), error); /* FIXME use handles in mono_threads_register_app_context */
2934 }
2935
2936 void
2937 mono_threads_release_app_context (MonoAppContext* ctx, MonoError *error)
2938 {
2939         /*
2940          * NOTE: Since finalizers are unreliable for the purposes of ensuring
2941          * cleanup in exceptional circumstances, we don't actually do any
2942          * cleanup work here. We instead do this via a reference queue.
2943          */
2944
2945         //g_print ("Releasing context %d in domain %d\n", ctx->context_id, ctx->domain_id);
2946
2947         MONO_PROFILER_RAISE (context_unloaded, (ctx));
2948 }
2949
2950 void
2951 ves_icall_System_Runtime_Remoting_Contexts_Context_ReleaseContext (MonoAppContextHandle ctx, MonoError *error)
2952 {
2953         error_init (error);
2954         mono_threads_release_app_context (MONO_HANDLE_RAW (ctx), error); /* FIXME use handles in mono_threads_release_app_context */
2955 }
2956
2957 void mono_thread_init (MonoThreadStartCB start_cb,
2958                        MonoThreadAttachCB attach_cb)
2959 {
2960         mono_coop_mutex_init_recursive (&threads_mutex);
2961
2962         mono_os_mutex_init_recursive(&interlocked_mutex);
2963         mono_os_mutex_init_recursive(&joinable_threads_mutex);
2964
2965         mono_os_event_init (&background_change_event, FALSE);
2966
2967         mono_init_static_data_info (&thread_static_info);
2968         mono_init_static_data_info (&context_static_info);
2969
2970         mono_thread_start_cb = start_cb;
2971         mono_thread_attach_cb = attach_cb;
2972 }
2973
2974 static gpointer
2975 thread_attach (MonoThreadInfo *info)
2976 {
2977         return mono_gc_thread_attach (info);
2978 }
2979
2980 static void
2981 thread_detach (MonoThreadInfo *info)
2982 {
2983         MonoInternalThread *internal;
2984         guint32 gchandle;
2985
2986         /* If a delegate is passed to native code and invoked on a thread we dont
2987          * know about, marshal will register it with mono_threads_attach_coop, but
2988          * we have no way of knowing when that thread goes away.  SGen has a TSD
2989          * so we assume that if the domain is still registered, we can detach
2990          * the thread */
2991
2992         g_assert (info);
2993
2994         if (!mono_thread_info_try_get_internal_thread_gchandle (info, &gchandle))
2995                 return;
2996
2997         internal = (MonoInternalThread*) mono_gchandle_get_target (gchandle);
2998         g_assert (internal);
2999
3000         mono_gchandle_free (gchandle);
3001
3002         mono_thread_detach_internal (internal);
3003 }
3004
3005 static void
3006 thread_detach_with_lock (MonoThreadInfo *info)
3007 {
3008         return mono_gc_thread_detach_with_lock (info);
3009 }
3010
3011 static gboolean
3012 thread_in_critical_region (MonoThreadInfo *info)
3013 {
3014         return mono_gc_thread_in_critical_region (info);
3015 }
3016
3017 static gboolean
3018 ip_in_critical_region (MonoDomain *domain, gpointer ip)
3019 {
3020         MonoJitInfo *ji;
3021         MonoMethod *method;
3022
3023         /*
3024          * We pass false for 'try_aot' so this becomes async safe.
3025          * It won't find aot methods whose jit info is not yet loaded,
3026          * so we preload their jit info in the JIT.
3027          */
3028         ji = mono_jit_info_table_find_internal (domain, ip, FALSE, FALSE);
3029         if (!ji)
3030                 return FALSE;
3031
3032         method = mono_jit_info_get_method (ji);
3033         g_assert (method);
3034
3035         return mono_gc_is_critical_method (method);
3036 }
3037
3038 void
3039 mono_thread_callbacks_init (void)
3040 {
3041         MonoThreadInfoCallbacks cb;
3042
3043         memset (&cb, 0, sizeof(cb));
3044         cb.thread_attach = thread_attach;
3045         cb.thread_detach = thread_detach;
3046         cb.thread_detach_with_lock = thread_detach_with_lock;
3047         cb.ip_in_critical_region = ip_in_critical_region;
3048         cb.thread_in_critical_region = thread_in_critical_region;
3049         mono_thread_info_callbacks_init (&cb);
3050 }
3051
3052 /**
3053  * mono_thread_cleanup:
3054  */
3055 void
3056 mono_thread_cleanup (void)
3057 {
3058         mono_threads_join_threads ();
3059
3060 #if !defined(RUN_IN_SUBTHREAD) && !defined(HOST_WIN32)
3061         /* The main thread must abandon any held mutexes (particularly
3062          * important for named mutexes as they are shared across
3063          * processes, see bug 74680.)  This will happen when the
3064          * thread exits, but if it's not running in a subthread it
3065          * won't exit in time.
3066          */
3067         mono_w32mutex_abandon ();
3068 #endif
3069
3070 #if 0
3071         /* This stuff needs more testing, it seems one of these
3072          * critical sections can be locked when mono_thread_cleanup is
3073          * called.
3074          */
3075         mono_coop_mutex_destroy (&threads_mutex);
3076         mono_os_mutex_destroy (&interlocked_mutex);
3077         mono_os_mutex_destroy (&delayed_free_table_mutex);
3078         mono_os_mutex_destroy (&small_id_mutex);
3079         mono_os_event_destroy (&background_change_event);
3080 #endif
3081 }
3082
3083 void
3084 mono_threads_install_cleanup (MonoThreadCleanupFunc func)
3085 {
3086         mono_thread_cleanup_fn = func;
3087 }
3088
3089 /**
3090  * mono_thread_set_manage_callback:
3091  */
3092 void
3093 mono_thread_set_manage_callback (MonoThread *thread, MonoThreadManageCallback func)
3094 {
3095         thread->internal_thread->manage_callback = func;
3096 }
3097
3098 G_GNUC_UNUSED
3099 static void print_tids (gpointer key, gpointer value, gpointer user)
3100 {
3101         /* GPOINTER_TO_UINT breaks horribly if sizeof(void *) >
3102          * sizeof(uint) and a cast to uint would overflow
3103          */
3104         /* Older versions of glib don't have G_GSIZE_FORMAT, so just
3105          * print this as a pointer.
3106          */
3107         g_message ("Waiting for: %p", key);
3108 }
3109
3110 struct wait_data
3111 {
3112         MonoThreadHandle *handles[MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS];
3113         MonoInternalThread *threads[MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS];
3114         guint32 num;
3115 };
3116
3117 static void
3118 wait_for_tids (struct wait_data *wait, guint32 timeout, gboolean check_state_change)
3119 {
3120         guint32 i;
3121         MonoThreadInfoWaitRet ret;
3122
3123         THREAD_DEBUG (g_message("%s: %d threads to wait for in this batch", __func__, wait->num));
3124
3125         /* Add the thread state change event, so it wakes
3126          * up if a thread changes to background mode. */
3127
3128         MONO_ENTER_GC_SAFE;
3129         if (check_state_change)
3130                 ret = mono_thread_info_wait_multiple_handle (wait->handles, wait->num, &background_change_event, FALSE, timeout, TRUE);
3131         else
3132                 ret = mono_thread_info_wait_multiple_handle (wait->handles, wait->num, NULL, TRUE, timeout, TRUE);
3133         MONO_EXIT_GC_SAFE;
3134
3135         if (ret == MONO_THREAD_INFO_WAIT_RET_FAILED) {
3136                 /* See the comment in build_wait_tids() */
3137                 THREAD_DEBUG (g_message ("%s: Wait failed", __func__));
3138                 return;
3139         }
3140
3141         for( i = 0; i < wait->num; i++)
3142                 mono_threads_close_thread_handle (wait->handles [i]);
3143
3144         if (ret == MONO_THREAD_INFO_WAIT_RET_TIMEOUT)
3145                 return;
3146
3147         if (ret < wait->num) {
3148                 MonoInternalThread *internal;
3149
3150                 internal = wait->threads [ret];
3151
3152                 mono_threads_lock ();
3153                 if (mono_g_hash_table_lookup (threads, (gpointer) internal->tid) == internal)
3154                         g_error ("%s: failed to call mono_thread_detach_internal on thread %p, InternalThread: %p", __func__, internal->tid, internal);
3155                 mono_threads_unlock ();
3156         }
3157 }
3158
3159 static void build_wait_tids (gpointer key, gpointer value, gpointer user)
3160 {
3161         struct wait_data *wait=(struct wait_data *)user;
3162
3163         if(wait->num<MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS - 1) {
3164                 MonoInternalThread *thread=(MonoInternalThread *)value;
3165
3166                 /* Ignore background threads, we abort them later */
3167                 /* Do not lock here since it is not needed and the caller holds threads_lock */
3168                 if (thread->state & ThreadState_Background) {
3169                         THREAD_DEBUG (g_message ("%s: ignoring background thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3170                         return; /* just leave, ignore */
3171                 }
3172
3173                 if (mono_gc_is_finalizer_internal_thread (thread)) {
3174                         THREAD_DEBUG (g_message ("%s: ignoring finalizer thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3175                         return;
3176                 }
3177
3178                 if (thread == mono_thread_internal_current ()) {
3179                         THREAD_DEBUG (g_message ("%s: ignoring current thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3180                         return;
3181                 }
3182
3183                 if (mono_thread_get_main () && (thread == mono_thread_get_main ()->internal_thread)) {
3184                         THREAD_DEBUG (g_message ("%s: ignoring main thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3185                         return;
3186                 }
3187
3188                 if (thread->flags & MONO_THREAD_FLAG_DONT_MANAGE) {
3189                         THREAD_DEBUG (g_message ("%s: ignoring thread %" G_GSIZE_FORMAT "with DONT_MANAGE flag set.", __func__, (gsize)thread->tid));
3190                         return;
3191                 }
3192
3193                 THREAD_DEBUG (g_message ("%s: Invoking mono_thread_manage callback on thread %p", __func__, thread));
3194                 if ((thread->manage_callback == NULL) || (thread->manage_callback (thread->root_domain_thread) == TRUE)) {
3195                         wait->handles[wait->num]=mono_threads_open_thread_handle (thread->handle);
3196                         wait->threads[wait->num]=thread;
3197                         wait->num++;
3198
3199                         THREAD_DEBUG (g_message ("%s: adding thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3200                 } else {
3201                         THREAD_DEBUG (g_message ("%s: ignoring (because of callback) thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3202                 }
3203
3204
3205         } else {
3206                 /* Just ignore the rest, we can't do anything with
3207                  * them yet
3208                  */
3209         }
3210 }
3211
3212 static gboolean
3213 remove_and_abort_threads (gpointer key, gpointer value, gpointer user)
3214 {
3215         struct wait_data *wait=(struct wait_data *)user;
3216         MonoNativeThreadId self = mono_native_thread_id_get ();
3217         MonoInternalThread *thread = (MonoInternalThread *)value;
3218
3219         if (wait->num >= MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS)
3220                 return FALSE;
3221
3222         if (mono_native_thread_id_equals (thread_get_tid (thread), self))
3223                 return FALSE;
3224         if (mono_gc_is_finalizer_internal_thread (thread))
3225                 return FALSE;
3226
3227         if ((thread->state & ThreadState_Background) && !(thread->flags & MONO_THREAD_FLAG_DONT_MANAGE)) {
3228                 wait->handles[wait->num] = mono_threads_open_thread_handle (thread->handle);
3229                 wait->threads[wait->num] = thread;
3230                 wait->num++;
3231
3232                 THREAD_DEBUG (g_print ("%s: Aborting id: %"G_GSIZE_FORMAT"\n", __func__, (gsize)thread->tid));
3233                 mono_thread_internal_abort (thread, FALSE);
3234         }
3235
3236         return TRUE;
3237 }
3238
3239 /**
3240  * mono_threads_set_shutting_down:
3241  *
3242  * Is called by a thread that wants to shut down Mono. If the runtime is already
3243  * shutting down, the calling thread is suspended/stopped, and this function never
3244  * returns.
3245  */
3246 void
3247 mono_threads_set_shutting_down (void)
3248 {
3249         MonoInternalThread *current_thread = mono_thread_internal_current ();
3250
3251         mono_threads_lock ();
3252
3253         if (shutting_down) {
3254                 mono_threads_unlock ();
3255
3256                 /* Make sure we're properly suspended/stopped */
3257
3258                 LOCK_THREAD (current_thread);
3259
3260                 if (current_thread->state & (ThreadState_SuspendRequested | ThreadState_AbortRequested)) {
3261                         UNLOCK_THREAD (current_thread);
3262                         mono_thread_execute_interruption ();
3263                 } else {
3264                         UNLOCK_THREAD (current_thread);
3265                 }
3266
3267                 /*since we're killing the thread, detach it.*/
3268                 mono_thread_detach_internal (current_thread);
3269
3270                 /* Wake up other threads potentially waiting for us */
3271                 mono_thread_info_exit (0);
3272         } else {
3273                 shutting_down = TRUE;
3274
3275                 /* Not really a background state change, but this will
3276                  * interrupt the main thread if it is waiting for all
3277                  * the other threads.
3278                  */
3279                 mono_os_event_set (&background_change_event);
3280
3281                 mono_threads_unlock ();
3282         }
3283 }
3284
3285 /**
3286  * mono_thread_manage:
3287  */
3288 void
3289 mono_thread_manage (void)
3290 {
3291         struct wait_data wait_data;
3292         struct wait_data *wait = &wait_data;
3293
3294         memset (wait, 0, sizeof (struct wait_data));
3295         /* join each thread that's still running */
3296         THREAD_DEBUG (g_message ("%s: Joining each running thread...", __func__));
3297
3298         mono_threads_lock ();
3299         if(threads==NULL) {
3300                 THREAD_DEBUG (g_message("%s: No threads", __func__));
3301                 mono_threads_unlock ();
3302                 return;
3303         }
3304         mono_threads_unlock ();
3305
3306         do {
3307                 mono_threads_lock ();
3308                 if (shutting_down) {
3309                         /* somebody else is shutting down */
3310                         mono_threads_unlock ();
3311                         break;
3312                 }
3313                 THREAD_DEBUG (g_message ("%s: There are %d threads to join", __func__, mono_g_hash_table_size (threads));
3314                         mono_g_hash_table_foreach (threads, print_tids, NULL));
3315
3316                 mono_os_event_reset (&background_change_event);
3317                 wait->num=0;
3318                 /* We must zero all InternalThread pointers to avoid making the GC unhappy. */
3319                 memset (wait->threads, 0, MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS * SIZEOF_VOID_P);
3320                 mono_g_hash_table_foreach (threads, build_wait_tids, wait);
3321                 mono_threads_unlock ();
3322                 if (wait->num > 0)
3323                         /* Something to wait for */
3324                         wait_for_tids (wait, MONO_INFINITE_WAIT, TRUE);
3325                 THREAD_DEBUG (g_message ("%s: I have %d threads after waiting.", __func__, wait->num));
3326         } while(wait->num>0);
3327
3328         /* Mono is shutting down, so just wait for the end */
3329         if (!mono_runtime_try_shutdown ()) {
3330                 /*FIXME mono_thread_suspend probably should call mono_thread_execute_interruption when self interrupting. */
3331                 mono_thread_suspend (mono_thread_internal_current ());
3332                 mono_thread_execute_interruption ();
3333         }
3334
3335         /*
3336          * Remove everything but the finalizer thread and self.
3337          * Also abort all the background threads
3338          * */
3339         do {
3340                 mono_threads_lock ();
3341
3342                 wait->num = 0;
3343                 /*We must zero all InternalThread pointers to avoid making the GC unhappy.*/
3344                 memset (wait->threads, 0, MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS * SIZEOF_VOID_P);
3345                 mono_g_hash_table_foreach_remove (threads, remove_and_abort_threads, wait);
3346
3347                 mono_threads_unlock ();
3348
3349                 THREAD_DEBUG (g_message ("%s: wait->num is now %d", __func__, wait->num));
3350                 if (wait->num > 0) {
3351                         /* Something to wait for */
3352                         wait_for_tids (wait, MONO_INFINITE_WAIT, FALSE);
3353                 }
3354         } while (wait->num > 0);
3355
3356         /*
3357          * give the subthreads a chance to really quit (this is mainly needed
3358          * to get correct user and system times from getrusage/wait/time(1)).
3359          * This could be removed if we avoid pthread_detach() and use pthread_join().
3360          */
3361         mono_thread_info_yield ();
3362 }
3363
3364 static void
3365 collect_threads_for_suspend (gpointer key, gpointer value, gpointer user_data)
3366 {
3367         MonoInternalThread *thread = (MonoInternalThread*)value;
3368         struct wait_data *wait = (struct wait_data*)user_data;
3369
3370         /*
3371          * We try to exclude threads early, to avoid running into the MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS
3372          * limitation.
3373          * This needs no locking.
3374          */
3375         if ((thread->state & ThreadState_Suspended) != 0 ||
3376                 (thread->state & ThreadState_Stopped) != 0)
3377                 return;
3378
3379         if (wait->num<MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS) {
3380                 wait->handles [wait->num] = mono_threads_open_thread_handle (thread->handle);
3381                 wait->threads [wait->num] = thread;
3382                 wait->num++;
3383         }
3384 }
3385
3386 /*
3387  * mono_thread_suspend_all_other_threads:
3388  *
3389  *  Suspend all managed threads except the finalizer thread and this thread. It is
3390  * not possible to resume them later.
3391  */
3392 void mono_thread_suspend_all_other_threads (void)
3393 {
3394         struct wait_data wait_data;
3395         struct wait_data *wait = &wait_data;
3396         int i;
3397         MonoNativeThreadId self = mono_native_thread_id_get ();
3398         guint32 eventidx = 0;
3399         gboolean starting, finished;
3400
3401         memset (wait, 0, sizeof (struct wait_data));
3402         /*
3403          * The other threads could be in an arbitrary state at this point, i.e.
3404          * they could be starting up, shutting down etc. This means that there could be
3405          * threads which are not even in the threads hash table yet.
3406          */
3407
3408         /*
3409          * First we set a barrier which will be checked by all threads before they
3410          * are added to the threads hash table, and they will exit if the flag is set.
3411          * This ensures that no threads could be added to the hash later.
3412          * We will use shutting_down as the barrier for now.
3413          */
3414         g_assert (shutting_down);
3415
3416         /*
3417          * We make multiple calls to WaitForMultipleObjects since:
3418          * - we can only wait for MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS threads
3419          * - some threads could exit without becoming suspended
3420          */
3421         finished = FALSE;
3422         while (!finished) {
3423                 /*
3424                  * Make a copy of the hashtable since we can't do anything with
3425                  * threads while threads_mutex is held.
3426                  */
3427                 wait->num = 0;
3428                 /*We must zero all InternalThread pointers to avoid making the GC unhappy.*/
3429                 memset (wait->threads, 0, MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS * SIZEOF_VOID_P);
3430                 mono_threads_lock ();
3431                 mono_g_hash_table_foreach (threads, collect_threads_for_suspend, wait);
3432                 mono_threads_unlock ();
3433
3434                 eventidx = 0;
3435                 /* Get the suspended events that we'll be waiting for */
3436                 for (i = 0; i < wait->num; ++i) {
3437                         MonoInternalThread *thread = wait->threads [i];
3438
3439                         if (mono_native_thread_id_equals (thread_get_tid (thread), self)
3440                              || mono_gc_is_finalizer_internal_thread (thread)
3441                              || (thread->flags & MONO_THREAD_FLAG_DONT_MANAGE)
3442                         ) {
3443                                 mono_threads_close_thread_handle (wait->handles [i]);
3444                                 wait->threads [i] = NULL;
3445                                 continue;
3446                         }
3447
3448                         LOCK_THREAD (thread);
3449
3450                         if (thread->state & (ThreadState_Suspended | ThreadState_Stopped)) {
3451                                 UNLOCK_THREAD (thread);
3452                                 mono_threads_close_thread_handle (wait->handles [i]);
3453                                 wait->threads [i] = NULL;
3454                                 continue;
3455                         }
3456
3457                         ++eventidx;
3458
3459                         /* Convert abort requests into suspend requests */
3460                         if ((thread->state & ThreadState_AbortRequested) != 0)
3461                                 thread->state &= ~ThreadState_AbortRequested;
3462
3463                         thread->state |= ThreadState_SuspendRequested;
3464                         mono_os_event_reset (thread->suspended);
3465
3466                         /* Signal the thread to suspend + calls UNLOCK_THREAD (thread) */
3467                         async_suspend_internal (thread, TRUE);
3468
3469                         mono_threads_close_thread_handle (wait->handles [i]);
3470                         wait->threads [i] = NULL;
3471                 }
3472                 if (eventidx <= 0) {
3473                         /*
3474                          * If there are threads which are starting up, we wait until they
3475                          * are suspended when they try to register in the threads hash.
3476                          * This is guaranteed to finish, since the threads which can create new
3477                          * threads get suspended after a while.
3478                          * FIXME: The finalizer thread can still create new threads.
3479                          */
3480                         mono_threads_lock ();
3481                         if (threads_starting_up)
3482                                 starting = mono_g_hash_table_size (threads_starting_up) > 0;
3483                         else
3484                                 starting = FALSE;
3485                         mono_threads_unlock ();
3486                         if (starting)
3487                                 mono_thread_info_sleep (100, NULL);
3488                         else
3489                                 finished = TRUE;
3490                 }
3491         }
3492 }
3493
3494 typedef struct {
3495         MonoInternalThread *thread;
3496         MonoStackFrameInfo *frames;
3497         int nframes, max_frames;
3498         int nthreads, max_threads;
3499         MonoInternalThread **threads;
3500 } ThreadDumpUserData;
3501
3502 static gboolean thread_dump_requested;
3503
3504 /* This needs to be async safe */
3505 static gboolean
3506 collect_frame (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
3507 {
3508         ThreadDumpUserData *ud = (ThreadDumpUserData *)data;
3509
3510         if (ud->nframes < ud->max_frames) {
3511                 memcpy (&ud->frames [ud->nframes], frame, sizeof (MonoStackFrameInfo));
3512                 ud->nframes ++;
3513         }
3514
3515         return FALSE;
3516 }
3517
3518 /* This needs to be async safe */
3519 static SuspendThreadResult
3520 get_thread_dump (MonoThreadInfo *info, gpointer ud)
3521 {
3522         ThreadDumpUserData *user_data = (ThreadDumpUserData *)ud;
3523         MonoInternalThread *thread = user_data->thread;
3524
3525 #if 0
3526 /* This no longer works with remote unwinding */
3527         g_string_append_printf (text, " tid=0x%p this=0x%p ", (gpointer)(gsize)thread->tid, thread);
3528         mono_thread_internal_describe (thread, text);
3529         g_string_append (text, "\n");
3530 #endif
3531
3532         if (thread == mono_thread_internal_current ())
3533                 mono_get_eh_callbacks ()->mono_walk_stack_with_ctx (collect_frame, NULL, MONO_UNWIND_SIGNAL_SAFE, ud);
3534         else
3535                 mono_get_eh_callbacks ()->mono_walk_stack_with_state (collect_frame, mono_thread_info_get_suspend_state (info), MONO_UNWIND_SIGNAL_SAFE, ud);
3536
3537         return MonoResumeThread;
3538 }
3539
3540 typedef struct {
3541         int nthreads, max_threads;
3542         MonoInternalThread **threads;
3543 } CollectThreadsUserData;
3544
3545 static void
3546 collect_thread (gpointer key, gpointer value, gpointer user)
3547 {
3548         CollectThreadsUserData *ud = (CollectThreadsUserData *)user;
3549         MonoInternalThread *thread = (MonoInternalThread *)value;
3550
3551         if (ud->nthreads < ud->max_threads)
3552                 ud->threads [ud->nthreads ++] = thread;
3553 }
3554
3555 /*
3556  * Collect running threads into the THREADS array.
3557  * THREADS should be an array allocated on the stack.
3558  */
3559 static int
3560 collect_threads (MonoInternalThread **thread_array, int max_threads)
3561 {
3562         CollectThreadsUserData ud;
3563
3564         memset (&ud, 0, sizeof (ud));
3565         /* This array contains refs, but its on the stack, so its ok */
3566         ud.threads = thread_array;
3567         ud.max_threads = max_threads;
3568
3569         mono_threads_lock ();
3570         mono_g_hash_table_foreach (threads, collect_thread, &ud);
3571         mono_threads_unlock ();
3572
3573         return ud.nthreads;
3574 }
3575
3576 static void
3577 dump_thread (MonoInternalThread *thread, ThreadDumpUserData *ud)
3578 {
3579         GString* text = g_string_new (0);
3580         char *name;
3581         GError *error = NULL;
3582         int i;
3583
3584         ud->thread = thread;
3585         ud->nframes = 0;
3586
3587         /* Collect frames for the thread */
3588         if (thread == mono_thread_internal_current ()) {
3589                 get_thread_dump (mono_thread_info_current (), ud);
3590         } else {
3591                 mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), FALSE, get_thread_dump, ud);
3592         }
3593
3594         /*
3595          * Do all the non async-safe work outside of get_thread_dump.
3596          */
3597         if (thread->name) {
3598                 name = g_utf16_to_utf8 (thread->name, thread->name_len, NULL, NULL, &error);
3599                 g_assert (!error);
3600                 g_string_append_printf (text, "\n\"%s\"", name);
3601                 g_free (name);
3602         }
3603         else if (thread->threadpool_thread) {
3604                 g_string_append (text, "\n\"<threadpool thread>\"");
3605         } else {
3606                 g_string_append (text, "\n\"<unnamed thread>\"");
3607         }
3608
3609         for (i = 0; i < ud->nframes; ++i) {
3610                 MonoStackFrameInfo *frame = &ud->frames [i];
3611                 MonoMethod *method = NULL;
3612
3613                 if (frame->type == FRAME_TYPE_MANAGED)
3614                         method = mono_jit_info_get_method (frame->ji);
3615
3616                 if (method) {
3617                         gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, frame->domain);
3618                         g_string_append_printf (text, "  %s\n", location);
3619                         g_free (location);
3620                 } else {
3621                         g_string_append_printf (text, "  at <unknown> <0x%05x>\n", frame->native_offset);
3622                 }
3623         }
3624
3625         fprintf (stdout, "%s", text->str);
3626
3627 #if PLATFORM_WIN32 && TARGET_WIN32 && _DEBUG
3628         OutputDebugStringA(text->str);
3629 #endif
3630
3631         g_string_free (text, TRUE);
3632         fflush (stdout);
3633 }
3634
3635 void
3636 mono_threads_perform_thread_dump (void)
3637 {
3638         ThreadDumpUserData ud;
3639         MonoInternalThread *thread_array [128];
3640         int tindex, nthreads;
3641
3642         if (!thread_dump_requested)
3643                 return;
3644
3645         printf ("Full thread dump:\n");
3646
3647         /* Make a copy of the threads hash to avoid doing work inside threads_lock () */
3648         nthreads = collect_threads (thread_array, 128);
3649
3650         memset (&ud, 0, sizeof (ud));
3651         ud.frames = g_new0 (MonoStackFrameInfo, 256);
3652         ud.max_frames = 256;
3653
3654         for (tindex = 0; tindex < nthreads; ++tindex)
3655                 dump_thread (thread_array [tindex], &ud);
3656
3657         g_free (ud.frames);
3658
3659         thread_dump_requested = FALSE;
3660 }
3661
3662 /* Obtain the thread dump of all threads */
3663 static gboolean
3664 mono_threads_get_thread_dump (MonoArray **out_threads, MonoArray **out_stack_frames, MonoError *error)
3665 {
3666
3667         ThreadDumpUserData ud;
3668         MonoInternalThread *thread_array [128];
3669         MonoDomain *domain = mono_domain_get ();
3670         MonoDebugSourceLocation *location;
3671         int tindex, nthreads;
3672
3673         error_init (error);
3674
3675         *out_threads = NULL;
3676         *out_stack_frames = NULL;
3677
3678         /* Make a copy of the threads hash to avoid doing work inside threads_lock () */
3679         nthreads = collect_threads (thread_array, 128);
3680
3681         memset (&ud, 0, sizeof (ud));
3682         ud.frames = g_new0 (MonoStackFrameInfo, 256);
3683         ud.max_frames = 256;
3684
3685         *out_threads = mono_array_new_checked (domain, mono_defaults.thread_class, nthreads, error);
3686         if (!is_ok (error))
3687                 goto leave;
3688         *out_stack_frames = mono_array_new_checked (domain, mono_defaults.array_class, nthreads, error);
3689         if (!is_ok (error))
3690                 goto leave;
3691
3692         for (tindex = 0; tindex < nthreads; ++tindex) {
3693                 MonoInternalThread *thread = thread_array [tindex];
3694                 MonoArray *thread_frames;
3695                 int i;
3696
3697                 ud.thread = thread;
3698                 ud.nframes = 0;
3699
3700                 /* Collect frames for the thread */
3701                 if (thread == mono_thread_internal_current ()) {
3702                         get_thread_dump (mono_thread_info_current (), &ud);
3703                 } else {
3704                         mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), FALSE, get_thread_dump, &ud);
3705                 }
3706
3707                 mono_array_setref_fast (*out_threads, tindex, mono_thread_current_for_thread (thread));
3708
3709                 thread_frames = mono_array_new_checked (domain, mono_defaults.stack_frame_class, ud.nframes, error);
3710                 if (!is_ok (error))
3711                         goto leave;
3712                 mono_array_setref_fast (*out_stack_frames, tindex, thread_frames);
3713
3714                 for (i = 0; i < ud.nframes; ++i) {
3715                         MonoStackFrameInfo *frame = &ud.frames [i];
3716                         MonoMethod *method = NULL;
3717                         MonoStackFrame *sf = (MonoStackFrame *)mono_object_new_checked (domain, mono_defaults.stack_frame_class, error);
3718                         if (!is_ok (error))
3719                                 goto leave;
3720
3721                         sf->native_offset = frame->native_offset;
3722
3723                         if (frame->type == FRAME_TYPE_MANAGED)
3724                                 method = mono_jit_info_get_method (frame->ji);
3725
3726                         if (method) {
3727                                 sf->method_address = (gsize) frame->ji->code_start;
3728
3729                                 MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, NULL, error);
3730                                 if (!is_ok (error))
3731                                         goto leave;
3732                                 MONO_OBJECT_SETREF (sf, method, rm);
3733
3734                                 location = mono_debug_lookup_source_location (method, frame->native_offset, domain);
3735                                 if (location) {
3736                                         sf->il_offset = location->il_offset;
3737
3738                                         if (location && location->source_file) {
3739                                                 MonoString *filename = mono_string_new_checked (domain, location->source_file, error);
3740                                                 if (!is_ok (error))
3741                                                         goto leave;
3742                                                 MONO_OBJECT_SETREF (sf, filename, filename);
3743                                                 sf->line = location->row;
3744                                                 sf->column = location->column;
3745                                         }
3746                                         mono_debug_free_source_location (location);
3747                                 } else {
3748                                         sf->il_offset = -1;
3749                                 }
3750                         }
3751                         mono_array_setref (thread_frames, i, sf);
3752                 }
3753         }
3754
3755 leave:
3756         g_free (ud.frames);
3757         return is_ok (error);
3758 }
3759
3760 /**
3761  * mono_threads_request_thread_dump:
3762  *
3763  *   Ask all threads except the current to print their stacktrace to stdout.
3764  */
3765 void
3766 mono_threads_request_thread_dump (void)
3767 {
3768         /*The new thread dump code runs out of the finalizer thread. */
3769         thread_dump_requested = TRUE;
3770         mono_gc_finalize_notify ();
3771 }
3772
3773 struct ref_stack {
3774         gpointer *refs;
3775         gint allocated; /* +1 so that refs [allocated] == NULL */
3776         gint bottom;
3777 };
3778
3779 typedef struct ref_stack RefStack;
3780
3781 static RefStack *
3782 ref_stack_new (gint initial_size)
3783 {
3784         RefStack *rs;
3785
3786         initial_size = MAX (initial_size, 16) + 1;
3787         rs = g_new0 (RefStack, 1);
3788         rs->refs = g_new0 (gpointer, initial_size);
3789         rs->allocated = initial_size;
3790         return rs;
3791 }
3792
3793 static void
3794 ref_stack_destroy (gpointer ptr)
3795 {
3796         RefStack *rs = (RefStack *)ptr;
3797
3798         if (rs != NULL) {
3799                 g_free (rs->refs);
3800                 g_free (rs);
3801         }
3802 }
3803
3804 static void
3805 ref_stack_push (RefStack *rs, gpointer ptr)
3806 {
3807         g_assert (rs != NULL);
3808
3809         if (rs->bottom >= rs->allocated) {
3810                 rs->refs = (void **)g_realloc (rs->refs, rs->allocated * 2 * sizeof (gpointer) + 1);
3811                 rs->allocated <<= 1;
3812                 rs->refs [rs->allocated] = NULL;
3813         }
3814         rs->refs [rs->bottom++] = ptr;
3815 }
3816
3817 static void
3818 ref_stack_pop (RefStack *rs)
3819 {
3820         if (rs == NULL || rs->bottom == 0)
3821                 return;
3822
3823         rs->bottom--;
3824         rs->refs [rs->bottom] = NULL;
3825 }
3826
3827 static gboolean
3828 ref_stack_find (RefStack *rs, gpointer ptr)
3829 {
3830         gpointer *refs;
3831
3832         if (rs == NULL)
3833                 return FALSE;
3834
3835         for (refs = rs->refs; refs && *refs; refs++) {
3836                 if (*refs == ptr)
3837                         return TRUE;
3838         }
3839         return FALSE;
3840 }
3841
3842 /*
3843  * mono_thread_push_appdomain_ref:
3844  *
3845  *   Register that the current thread may have references to objects in domain
3846  * @domain on its stack. Each call to this function should be paired with a
3847  * call to pop_appdomain_ref.
3848  */
3849 void
3850 mono_thread_push_appdomain_ref (MonoDomain *domain)
3851 {
3852         MonoInternalThread *thread = mono_thread_internal_current ();
3853
3854         if (thread) {
3855                 /* printf ("PUSH REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, domain->friendly_name); */
3856                 SPIN_LOCK (thread->lock_thread_id);
3857                 if (thread->appdomain_refs == NULL)
3858                         thread->appdomain_refs = ref_stack_new (16);
3859                 ref_stack_push ((RefStack *)thread->appdomain_refs, domain);
3860                 SPIN_UNLOCK (thread->lock_thread_id);
3861         }
3862 }
3863
3864 void
3865 mono_thread_pop_appdomain_ref (void)
3866 {
3867         MonoInternalThread *thread = mono_thread_internal_current ();
3868
3869         if (thread) {
3870                 /* printf ("POP REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, ((MonoDomain*)(thread->appdomain_refs->data))->friendly_name); */
3871                 SPIN_LOCK (thread->lock_thread_id);
3872                 ref_stack_pop ((RefStack *)thread->appdomain_refs);
3873                 SPIN_UNLOCK (thread->lock_thread_id);
3874         }
3875 }
3876
3877 gboolean
3878 mono_thread_internal_has_appdomain_ref (MonoInternalThread *thread, MonoDomain *domain)
3879 {
3880         gboolean res;
3881         SPIN_LOCK (thread->lock_thread_id);
3882         res = ref_stack_find ((RefStack *)thread->appdomain_refs, domain);
3883         SPIN_UNLOCK (thread->lock_thread_id);
3884         return res;
3885 }
3886
3887 gboolean
3888 mono_thread_has_appdomain_ref (MonoThread *thread, MonoDomain *domain)
3889 {
3890         return mono_thread_internal_has_appdomain_ref (thread->internal_thread, domain);
3891 }
3892
3893 typedef struct abort_appdomain_data {
3894         struct wait_data wait;
3895         MonoDomain *domain;
3896 } abort_appdomain_data;
3897
3898 static void
3899 collect_appdomain_thread (gpointer key, gpointer value, gpointer user_data)
3900 {
3901         MonoInternalThread *thread = (MonoInternalThread*)value;
3902         abort_appdomain_data *data = (abort_appdomain_data*)user_data;
3903         MonoDomain *domain = data->domain;
3904
3905         if (mono_thread_internal_has_appdomain_ref (thread, domain)) {
3906                 /* printf ("ABORTING THREAD %p BECAUSE IT REFERENCES DOMAIN %s.\n", thread->tid, domain->friendly_name); */
3907
3908                 if(data->wait.num<MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS) {
3909                         data->wait.handles [data->wait.num] = mono_threads_open_thread_handle (thread->handle);
3910                         data->wait.threads [data->wait.num] = thread;
3911                         data->wait.num++;
3912                 } else {
3913                         /* Just ignore the rest, we can't do anything with
3914                          * them yet
3915                          */
3916                 }
3917         }
3918 }
3919
3920 /*
3921  * mono_threads_abort_appdomain_threads:
3922  *
3923  *   Abort threads which has references to the given appdomain.
3924  */
3925 gboolean
3926 mono_threads_abort_appdomain_threads (MonoDomain *domain, int timeout)
3927 {
3928         abort_appdomain_data user_data;
3929         gint64 start_time;
3930         int orig_timeout = timeout;
3931         int i;
3932
3933         THREAD_DEBUG (g_message ("%s: starting abort", __func__));
3934
3935         start_time = mono_msec_ticks ();
3936         do {
3937                 mono_threads_lock ();
3938
3939                 user_data.domain = domain;
3940                 user_data.wait.num = 0;
3941                 /* This shouldn't take any locks */
3942                 mono_g_hash_table_foreach (threads, collect_appdomain_thread, &user_data);
3943                 mono_threads_unlock ();
3944
3945                 if (user_data.wait.num > 0) {
3946                         /* Abort the threads outside the threads lock */
3947                         for (i = 0; i < user_data.wait.num; ++i)
3948                                 mono_thread_internal_abort (user_data.wait.threads [i], TRUE);
3949
3950                         /*
3951                          * We should wait for the threads either to abort, or to leave the
3952                          * domain. We can't do the latter, so we wait with a timeout.
3953                          */
3954                         wait_for_tids (&user_data.wait, 100, FALSE);
3955                 }
3956
3957                 /* Update remaining time */
3958                 timeout -= mono_msec_ticks () - start_time;
3959                 start_time = mono_msec_ticks ();
3960
3961                 if (orig_timeout != -1 && timeout < 0)
3962                         return FALSE;
3963         }
3964         while (user_data.wait.num > 0);
3965
3966         THREAD_DEBUG (g_message ("%s: abort done", __func__));
3967
3968         return TRUE;
3969 }
3970
3971 void
3972 mono_thread_self_abort (void)
3973 {
3974         MonoError error;
3975         self_abort_internal (&error);
3976         mono_error_set_pending_exception (&error);
3977 }
3978
3979 /*
3980  * mono_thread_get_undeniable_exception:
3981  *
3982  *   Return an exception which needs to be raised when leaving a catch clause.
3983  * This is used for undeniable exception propagation.
3984  */
3985 MonoException*
3986 mono_thread_get_undeniable_exception (void)
3987 {
3988         MonoInternalThread *thread = mono_thread_internal_current ();
3989
3990         if (!(thread && thread->abort_exc && !is_running_protected_wrapper ()))
3991                 return NULL;
3992
3993         // We don't want to have our exception effect calls made by
3994         // the catching block
3995
3996         if (!mono_get_eh_callbacks ()->mono_above_abort_threshold ())
3997                 return NULL;
3998
3999         /*
4000          * FIXME: Clear the abort exception and return an AppDomainUnloaded
4001          * exception if the thread no longer references a dying appdomain.
4002          */
4003         thread->abort_exc->trace_ips = NULL;
4004         thread->abort_exc->stack_trace = NULL;
4005         return thread->abort_exc;
4006 }
4007
4008 #if MONO_SMALL_CONFIG
4009 #define NUM_STATIC_DATA_IDX 4
4010 static const int static_data_size [NUM_STATIC_DATA_IDX] = {
4011         64, 256, 1024, 4096
4012 };
4013 #else
4014 #define NUM_STATIC_DATA_IDX 8
4015 static const int static_data_size [NUM_STATIC_DATA_IDX] = {
4016         1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216
4017 };
4018 #endif
4019
4020 static MonoBitSet *thread_reference_bitmaps [NUM_STATIC_DATA_IDX];
4021 static MonoBitSet *context_reference_bitmaps [NUM_STATIC_DATA_IDX];
4022
4023 static void
4024 mark_slots (void *addr, MonoBitSet **bitmaps, MonoGCMarkFunc mark_func, void *gc_data)
4025 {
4026         gpointer *static_data = (gpointer *)addr;
4027
4028         for (int i = 0; i < NUM_STATIC_DATA_IDX; ++i) {
4029                 void **ptr = (void **)static_data [i];
4030
4031                 if (!ptr)
4032                         continue;
4033
4034                 MONO_BITSET_FOREACH (bitmaps [i], idx, {
4035                         void **p = ptr + idx;
4036
4037                         if (*p)
4038                                 mark_func ((MonoObject**)p, gc_data);
4039                 });
4040         }
4041 }
4042
4043 static void
4044 mark_tls_slots (void *addr, MonoGCMarkFunc mark_func, void *gc_data)
4045 {
4046         mark_slots (addr, thread_reference_bitmaps, mark_func, gc_data);
4047 }
4048
4049 static void
4050 mark_ctx_slots (void *addr, MonoGCMarkFunc mark_func, void *gc_data)
4051 {
4052         mark_slots (addr, context_reference_bitmaps, mark_func, gc_data);
4053 }
4054
4055 /*
4056  *  mono_alloc_static_data
4057  *
4058  *   Allocate memory blocks for storing threads or context static data
4059  */
4060 static void
4061 mono_alloc_static_data (gpointer **static_data_ptr, guint32 offset, gboolean threadlocal)
4062 {
4063         guint idx = ACCESS_SPECIAL_STATIC_OFFSET (offset, index);
4064         int i;
4065
4066         gpointer* static_data = *static_data_ptr;
4067         if (!static_data) {
4068                 static MonoGCDescriptor tls_desc = MONO_GC_DESCRIPTOR_NULL;
4069                 static MonoGCDescriptor ctx_desc = MONO_GC_DESCRIPTOR_NULL;
4070
4071                 if (mono_gc_user_markers_supported ()) {
4072                         if (tls_desc == MONO_GC_DESCRIPTOR_NULL)
4073                                 tls_desc = mono_gc_make_root_descr_user (mark_tls_slots);
4074
4075                         if (ctx_desc == MONO_GC_DESCRIPTOR_NULL)
4076                                 ctx_desc = mono_gc_make_root_descr_user (mark_ctx_slots);
4077                 }
4078
4079                 static_data = (void **)mono_gc_alloc_fixed (static_data_size [0], threadlocal ? tls_desc : ctx_desc,
4080                         threadlocal ? MONO_ROOT_SOURCE_THREAD_STATIC : MONO_ROOT_SOURCE_CONTEXT_STATIC,
4081                         threadlocal ? "managed thread-static variables" : "managed context-static variables");
4082                 *static_data_ptr = static_data;
4083                 static_data [0] = static_data;
4084         }
4085
4086         for (i = 1; i <= idx; ++i) {
4087                 if (static_data [i])
4088                         continue;
4089
4090                 if (mono_gc_user_markers_supported ())
4091                         static_data [i] = g_malloc0 (static_data_size [i]);
4092                 else
4093                         static_data [i] = mono_gc_alloc_fixed (static_data_size [i], MONO_GC_DESCRIPTOR_NULL,
4094                                 threadlocal ? MONO_ROOT_SOURCE_THREAD_STATIC : MONO_ROOT_SOURCE_CONTEXT_STATIC,
4095                                 threadlocal ? "managed thread-static variables" : "managed context-static variables");
4096         }
4097 }
4098
4099 static void
4100 mono_free_static_data (gpointer* static_data)
4101 {
4102         int i;
4103         for (i = 1; i < NUM_STATIC_DATA_IDX; ++i) {
4104                 gpointer p = static_data [i];
4105                 if (!p)
4106                         continue;
4107                 /*
4108                  * At this point, the static data pointer array is still registered with the
4109                  * GC, so must ensure that mark_tls_slots() will not encounter any invalid
4110                  * data.  Freeing the individual arrays without first nulling their slots
4111                  * would make it possible for mark_tls/ctx_slots() to encounter a pointer to
4112                  * such an already freed array.  See bug #13813.
4113                  */
4114                 static_data [i] = NULL;
4115                 mono_memory_write_barrier ();
4116                 if (mono_gc_user_markers_supported ())
4117                         g_free (p);
4118                 else
4119                         mono_gc_free_fixed (p);
4120         }
4121         mono_gc_free_fixed (static_data);
4122 }
4123
4124 /*
4125  *  mono_init_static_data_info
4126  *
4127  *   Initializes static data counters
4128  */
4129 static void mono_init_static_data_info (StaticDataInfo *static_data)
4130 {
4131         static_data->idx = 0;
4132         static_data->offset = 0;
4133         static_data->freelist = NULL;
4134 }
4135
4136 /*
4137  *  mono_alloc_static_data_slot
4138  *
4139  *   Generates an offset for static data. static_data contains the counters
4140  *  used to generate it.
4141  */
4142 static guint32
4143 mono_alloc_static_data_slot (StaticDataInfo *static_data, guint32 size, guint32 align)
4144 {
4145         if (!static_data->idx && !static_data->offset) {
4146                 /*
4147                  * we use the first chunk of the first allocation also as
4148                  * an array for the rest of the data
4149                  */
4150                 static_data->offset = sizeof (gpointer) * NUM_STATIC_DATA_IDX;
4151         }
4152         static_data->offset += align - 1;
4153         static_data->offset &= ~(align - 1);
4154         if (static_data->offset + size >= static_data_size [static_data->idx]) {
4155                 static_data->idx ++;
4156                 g_assert (size <= static_data_size [static_data->idx]);
4157                 g_assert (static_data->idx < NUM_STATIC_DATA_IDX);
4158                 static_data->offset = 0;
4159         }
4160         guint32 offset = MAKE_SPECIAL_STATIC_OFFSET (static_data->idx, static_data->offset, 0);
4161         static_data->offset += size;
4162         return offset;
4163 }
4164
4165 /*
4166  * LOCKING: requires that threads_mutex is held
4167  */
4168 static void
4169 context_adjust_static_data (MonoAppContext *ctx)
4170 {
4171         if (context_static_info.offset || context_static_info.idx > 0) {
4172                 guint32 offset = MAKE_SPECIAL_STATIC_OFFSET (context_static_info.idx, context_static_info.offset, 0);
4173                 mono_alloc_static_data (&ctx->static_data, offset, FALSE);
4174                 ctx->data->static_data = ctx->static_data;
4175         }
4176 }
4177
4178 /*
4179  * LOCKING: requires that threads_mutex is held
4180  */
4181 static void
4182 alloc_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
4183 {
4184         MonoInternalThread *thread = (MonoInternalThread *)value;
4185         guint32 offset = GPOINTER_TO_UINT (user);
4186
4187         mono_alloc_static_data (&(thread->static_data), offset, TRUE);
4188 }
4189
4190 /*
4191  * LOCKING: requires that threads_mutex is held
4192  */
4193 static void
4194 alloc_context_static_data_helper (gpointer key, gpointer value, gpointer user)
4195 {
4196         MonoAppContext *ctx = (MonoAppContext *) mono_gchandle_get_target (GPOINTER_TO_INT (key));
4197
4198         if (!ctx)
4199                 return;
4200
4201         guint32 offset = GPOINTER_TO_UINT (user);
4202         mono_alloc_static_data (&ctx->static_data, offset, FALSE);
4203         ctx->data->static_data = ctx->static_data;
4204 }
4205
4206 static StaticDataFreeList*
4207 search_slot_in_freelist (StaticDataInfo *static_data, guint32 size, guint32 align)
4208 {
4209         StaticDataFreeList* prev = NULL;
4210         StaticDataFreeList* tmp = static_data->freelist;
4211         while (tmp) {
4212                 if (tmp->size == size) {
4213                         if (prev)
4214                                 prev->next = tmp->next;
4215                         else
4216                                 static_data->freelist = tmp->next;
4217                         return tmp;
4218                 }
4219                 prev = tmp;
4220                 tmp = tmp->next;
4221         }
4222         return NULL;
4223 }
4224
4225 #if SIZEOF_VOID_P == 4
4226 #define ONE_P 1
4227 #else
4228 #define ONE_P 1ll
4229 #endif
4230
4231 static void
4232 update_reference_bitmap (MonoBitSet **sets, guint32 offset, uintptr_t *bitmap, int numbits)
4233 {
4234         int idx = ACCESS_SPECIAL_STATIC_OFFSET (offset, index);
4235         if (!sets [idx])
4236                 sets [idx] = mono_bitset_new (static_data_size [idx] / sizeof (uintptr_t), 0);
4237         MonoBitSet *rb = sets [idx];
4238         offset = ACCESS_SPECIAL_STATIC_OFFSET (offset, offset);
4239         offset /= sizeof (uintptr_t);
4240         /* offset is now the bitmap offset */
4241         for (int i = 0; i < numbits; ++i) {
4242                 if (bitmap [i / sizeof (uintptr_t)] & (ONE_P << (i & (sizeof (uintptr_t) * 8 -1))))
4243                         mono_bitset_set_fast (rb, offset + i);
4244         }
4245 }
4246
4247 static void
4248 clear_reference_bitmap (MonoBitSet **sets, guint32 offset, guint32 size)
4249 {
4250         int idx = ACCESS_SPECIAL_STATIC_OFFSET (offset, index);
4251         MonoBitSet *rb = sets [idx];
4252         offset = ACCESS_SPECIAL_STATIC_OFFSET (offset, offset);
4253         offset /= sizeof (uintptr_t);
4254         /* offset is now the bitmap offset */
4255         for (int i = 0; i < size / sizeof (uintptr_t); i++)
4256                 mono_bitset_clear_fast (rb, offset + i);
4257 }
4258
4259 guint32
4260 mono_alloc_special_static_data (guint32 static_type, guint32 size, guint32 align, uintptr_t *bitmap, int numbits)
4261 {
4262         g_assert (static_type == SPECIAL_STATIC_THREAD || static_type == SPECIAL_STATIC_CONTEXT);
4263
4264         StaticDataInfo *info;
4265         MonoBitSet **sets;
4266
4267         if (static_type == SPECIAL_STATIC_THREAD) {
4268                 info = &thread_static_info;
4269                 sets = thread_reference_bitmaps;
4270         } else {
4271                 info = &context_static_info;
4272                 sets = context_reference_bitmaps;
4273         }
4274
4275         mono_threads_lock ();
4276
4277         StaticDataFreeList *item = search_slot_in_freelist (info, size, align);
4278         guint32 offset;
4279
4280         if (item) {
4281                 offset = item->offset;
4282                 g_free (item);
4283         } else {
4284                 offset = mono_alloc_static_data_slot (info, size, align);
4285         }
4286
4287         update_reference_bitmap (sets, offset, bitmap, numbits);
4288
4289         if (static_type == SPECIAL_STATIC_THREAD) {
4290                 /* This can be called during startup */
4291                 if (threads != NULL)
4292                         mono_g_hash_table_foreach (threads, alloc_thread_static_data_helper, GUINT_TO_POINTER (offset));
4293         } else {
4294                 if (contexts != NULL)
4295                         g_hash_table_foreach (contexts, alloc_context_static_data_helper, GUINT_TO_POINTER (offset));
4296
4297                 ACCESS_SPECIAL_STATIC_OFFSET (offset, type) = SPECIAL_STATIC_OFFSET_TYPE_CONTEXT;
4298         }
4299
4300         mono_threads_unlock ();
4301
4302         return offset;
4303 }
4304
4305 gpointer
4306 mono_get_special_static_data_for_thread (MonoInternalThread *thread, guint32 offset)
4307 {
4308         guint32 static_type = ACCESS_SPECIAL_STATIC_OFFSET (offset, type);
4309
4310         if (static_type == SPECIAL_STATIC_OFFSET_TYPE_THREAD) {
4311                 return get_thread_static_data (thread, offset);
4312         } else {
4313                 return get_context_static_data (thread->current_appcontext, offset);
4314         }
4315 }
4316
4317 gpointer
4318 mono_get_special_static_data (guint32 offset)
4319 {
4320         return mono_get_special_static_data_for_thread (mono_thread_internal_current (), offset);
4321 }
4322
4323 typedef struct {
4324         guint32 offset;
4325         guint32 size;
4326 } OffsetSize;
4327
4328 /*
4329  * LOCKING: requires that threads_mutex is held
4330  */
4331 static void
4332 free_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
4333 {
4334         MonoInternalThread *thread = (MonoInternalThread *)value;
4335         OffsetSize *data = (OffsetSize *)user;
4336         int idx = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, index);
4337         int off = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, offset);
4338         char *ptr;
4339
4340         if (!thread->static_data || !thread->static_data [idx])
4341                 return;
4342         ptr = ((char*) thread->static_data [idx]) + off;
4343         mono_gc_bzero_atomic (ptr, data->size);
4344 }
4345
4346 /*
4347  * LOCKING: requires that threads_mutex is held
4348  */
4349 static void
4350 free_context_static_data_helper (gpointer key, gpointer value, gpointer user)
4351 {
4352         MonoAppContext *ctx = (MonoAppContext *) mono_gchandle_get_target (GPOINTER_TO_INT (key));
4353
4354         if (!ctx)
4355                 return;
4356
4357         OffsetSize *data = (OffsetSize *)user;
4358         int idx = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, index);
4359         int off = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, offset);
4360         char *ptr;
4361
4362         if (!ctx->static_data || !ctx->static_data [idx])
4363                 return;
4364
4365         ptr = ((char*) ctx->static_data [idx]) + off;
4366         mono_gc_bzero_atomic (ptr, data->size);
4367 }
4368
4369 static void
4370 do_free_special_slot (guint32 offset, guint32 size)
4371 {
4372         guint32 static_type = ACCESS_SPECIAL_STATIC_OFFSET (offset, type);
4373         MonoBitSet **sets;
4374         StaticDataInfo *info;
4375
4376         if (static_type == SPECIAL_STATIC_OFFSET_TYPE_THREAD) {
4377                 info = &thread_static_info;
4378                 sets = thread_reference_bitmaps;
4379         } else {
4380                 info = &context_static_info;
4381                 sets = context_reference_bitmaps;
4382         }
4383
4384         guint32 data_offset = offset;
4385         ACCESS_SPECIAL_STATIC_OFFSET (data_offset, type) = 0;
4386         OffsetSize data = { data_offset, size };
4387
4388         clear_reference_bitmap (sets, data.offset, data.size);
4389
4390         if (static_type == SPECIAL_STATIC_OFFSET_TYPE_THREAD) {
4391                 if (threads != NULL)
4392                         mono_g_hash_table_foreach (threads, free_thread_static_data_helper, &data);
4393         } else {
4394                 if (contexts != NULL)
4395                         g_hash_table_foreach (contexts, free_context_static_data_helper, &data);
4396         }
4397
4398         if (!mono_runtime_is_shutting_down ()) {
4399                 StaticDataFreeList *item = g_new0 (StaticDataFreeList, 1);
4400
4401                 item->offset = offset;
4402                 item->size = size;
4403
4404                 item->next = info->freelist;
4405                 info->freelist = item;
4406         }
4407 }
4408
4409 static void
4410 do_free_special (gpointer key, gpointer value, gpointer data)
4411 {
4412         MonoClassField *field = (MonoClassField *)key;
4413         guint32 offset = GPOINTER_TO_UINT (value);
4414         gint32 align;
4415         guint32 size;
4416         size = mono_type_size (field->type, &align);
4417         do_free_special_slot (offset, size);
4418 }
4419
4420 void
4421 mono_alloc_special_static_data_free (GHashTable *special_static_fields)
4422 {
4423         mono_threads_lock ();
4424
4425         g_hash_table_foreach (special_static_fields, do_free_special, NULL);
4426
4427         mono_threads_unlock ();
4428 }
4429
4430 #ifdef HOST_WIN32
4431 static void CALLBACK dummy_apc (ULONG_PTR param)
4432 {
4433 }
4434 #endif
4435
4436 /*
4437  * mono_thread_execute_interruption
4438  *
4439  * Performs the operation that the requested thread state requires (abort,
4440  * suspend or stop)
4441  */
4442 static MonoException*
4443 mono_thread_execute_interruption (void)
4444 {
4445         MonoInternalThread *thread = mono_thread_internal_current ();
4446         MonoThread *sys_thread = mono_thread_current ();
4447
4448         LOCK_THREAD (thread);
4449
4450         /* MonoThread::interruption_requested can only be changed with atomics */
4451         if (!mono_thread_clear_interruption_requested (thread)) {
4452                 UNLOCK_THREAD (thread);
4453                 return NULL;
4454         }
4455
4456         /* this will consume pending APC calls */
4457 #ifdef HOST_WIN32
4458         WaitForSingleObjectEx (GetCurrentThread(), 0, TRUE);
4459 #endif
4460         /* Clear the interrupted flag of the thread so it can wait again */
4461         mono_thread_info_clear_self_interrupt ();
4462
4463         /* If there's a pending exception and an AbortRequested, the pending exception takes precedence */
4464         if (sys_thread->pending_exception) {
4465                 MonoException *exc;
4466
4467                 exc = sys_thread->pending_exception;
4468                 sys_thread->pending_exception = NULL;
4469
4470                 UNLOCK_THREAD (thread);
4471                 return exc;
4472         } else if (thread->state & (ThreadState_AbortRequested)) {
4473                 UNLOCK_THREAD (thread);
4474                 g_assert (sys_thread->pending_exception == NULL);
4475                 if (thread->abort_exc == NULL) {
4476                         /*
4477                          * This might be racy, but it has to be called outside the lock
4478                          * since it calls managed code.
4479                          */
4480                         MONO_OBJECT_SETREF (thread, abort_exc, mono_get_exception_thread_abort ());
4481                 }
4482                 return thread->abort_exc;
4483         } else if (thread->state & (ThreadState_SuspendRequested)) {
4484                 /* calls UNLOCK_THREAD (thread) */
4485                 self_suspend_internal ();
4486                 return NULL;
4487         } else if (thread->thread_interrupt_requested) {
4488
4489                 thread->thread_interrupt_requested = FALSE;
4490                 UNLOCK_THREAD (thread);
4491
4492                 return(mono_get_exception_thread_interrupted ());
4493         }
4494
4495         UNLOCK_THREAD (thread);
4496
4497         return NULL;
4498 }
4499
4500 /*
4501  * mono_thread_request_interruption
4502  *
4503  * A signal handler can call this method to request the interruption of a
4504  * thread. The result of the interruption will depend on the current state of
4505  * the thread. If the result is an exception that needs to be throw, it is
4506  * provided as return value.
4507  */
4508 MonoException*
4509 mono_thread_request_interruption (gboolean running_managed)
4510 {
4511         MonoInternalThread *thread = mono_thread_internal_current ();
4512
4513         /* The thread may already be stopping */
4514         if (thread == NULL)
4515                 return NULL;
4516
4517         if (!mono_thread_set_interruption_requested (thread))
4518                 return NULL;
4519
4520         if (!running_managed || is_running_protected_wrapper ()) {
4521                 /* Can't stop while in unmanaged code. Increase the global interruption
4522                    request count. When exiting the unmanaged method the count will be
4523                    checked and the thread will be interrupted. */
4524
4525                 /* this will awake the thread if it is in WaitForSingleObject
4526                    or similar */
4527                 /* Our implementation of this function ignores the func argument */
4528 #ifdef HOST_WIN32
4529                 QueueUserAPC ((PAPCFUNC)dummy_apc, thread->native_handle, (ULONG_PTR)NULL);
4530 #else
4531                 mono_thread_info_self_interrupt ();
4532 #endif
4533                 return NULL;
4534         }
4535         else {
4536                 return mono_thread_execute_interruption ();
4537         }
4538 }
4539
4540 /*This function should be called by a thread after it has exited all of
4541  * its handle blocks at interruption time.*/
4542 MonoException*
4543 mono_thread_resume_interruption (gboolean exec)
4544 {
4545         MonoInternalThread *thread = mono_thread_internal_current ();
4546         gboolean still_aborting;
4547
4548         /* The thread may already be stopping */
4549         if (thread == NULL)
4550                 return NULL;
4551
4552         LOCK_THREAD (thread);
4553         still_aborting = (thread->state & (ThreadState_AbortRequested)) != 0;
4554         UNLOCK_THREAD (thread);
4555
4556         /*This can happen if the protected block called Thread::ResetAbort*/
4557         if (!still_aborting)
4558                 return NULL;
4559
4560         if (!mono_thread_set_interruption_requested (thread))
4561                 return NULL;
4562
4563         mono_thread_info_self_interrupt ();
4564
4565         if (exec)
4566                 return mono_thread_execute_interruption ();
4567         else
4568                 return NULL;
4569 }
4570
4571 gboolean mono_thread_interruption_requested ()
4572 {
4573         if (thread_interruption_requested) {
4574                 MonoInternalThread *thread = mono_thread_internal_current ();
4575                 /* The thread may already be stopping */
4576                 if (thread != NULL)
4577                         return mono_thread_get_interruption_requested (thread);
4578         }
4579         return FALSE;
4580 }
4581
4582 static MonoException*
4583 mono_thread_interruption_checkpoint_request (gboolean bypass_abort_protection)
4584 {
4585         MonoInternalThread *thread = mono_thread_internal_current ();
4586
4587         /* The thread may already be stopping */
4588         if (!thread)
4589                 return NULL;
4590         if (!mono_thread_get_interruption_requested (thread))
4591                 return NULL;
4592         if (!bypass_abort_protection && is_running_protected_wrapper ())
4593                 return NULL;
4594
4595         return mono_thread_execute_interruption ();
4596 }
4597
4598 /*
4599  * Performs the interruption of the current thread, if one has been requested,
4600  * and the thread is not running a protected wrapper.
4601  * Return the exception which needs to be thrown, if any.
4602  */
4603 MonoException*
4604 mono_thread_interruption_checkpoint (void)
4605 {
4606         return mono_thread_interruption_checkpoint_request (FALSE);
4607 }
4608
4609 /*
4610  * Performs the interruption of the current thread, if one has been requested.
4611  * Return the exception which needs to be thrown, if any.
4612  */
4613 MonoException*
4614 mono_thread_force_interruption_checkpoint_noraise (void)
4615 {
4616         return mono_thread_interruption_checkpoint_request (TRUE);
4617 }
4618
4619 /*
4620  * mono_set_pending_exception:
4621  *
4622  *   Set the pending exception of the current thread to EXC.
4623  * The exception will be thrown when execution returns to managed code.
4624  */
4625 void
4626 mono_set_pending_exception (MonoException *exc)
4627 {
4628         MonoThread *thread = mono_thread_current ();
4629
4630         /* The thread may already be stopping */
4631         if (thread == NULL)
4632                 return;
4633
4634         MONO_OBJECT_SETREF (thread, pending_exception, exc);
4635
4636     mono_thread_request_interruption (FALSE);
4637 }
4638
4639 /**
4640  * mono_thread_interruption_request_flag:
4641  *
4642  * Returns the address of a flag that will be non-zero if an interruption has
4643  * been requested for a thread. The thread to interrupt may not be the current
4644  * thread, so an additional call to mono_thread_interruption_requested() or
4645  * mono_thread_interruption_checkpoint() is allways needed if the flag is not
4646  * zero.
4647  */
4648 gint32* mono_thread_interruption_request_flag ()
4649 {
4650         return &thread_interruption_requested;
4651 }
4652
4653 void
4654 mono_thread_init_apartment_state (void)
4655 {
4656 #ifdef HOST_WIN32
4657         MonoInternalThread* thread = mono_thread_internal_current ();
4658
4659         /* Positive return value indicates success, either
4660          * S_OK if this is first CoInitialize call, or
4661          * S_FALSE if CoInitialize already called, but with same
4662          * threading model. A negative value indicates failure,
4663          * probably due to trying to change the threading model.
4664          */
4665         if (CoInitializeEx(NULL, (thread->apartment_state == ThreadApartmentState_STA)
4666                         ? COINIT_APARTMENTTHREADED
4667                         : COINIT_MULTITHREADED) < 0) {
4668                 thread->apartment_state = ThreadApartmentState_Unknown;
4669         }
4670 #endif
4671 }
4672
4673 void
4674 mono_thread_cleanup_apartment_state (void)
4675 {
4676 #ifdef HOST_WIN32
4677         MonoInternalThread* thread = mono_thread_internal_current ();
4678
4679         if (thread && thread->apartment_state != ThreadApartmentState_Unknown) {
4680                 CoUninitialize ();
4681         }
4682 #endif
4683 }
4684
4685 void
4686 mono_thread_set_state (MonoInternalThread *thread, MonoThreadState state)
4687 {
4688         LOCK_THREAD (thread);
4689         thread->state |= state;
4690         UNLOCK_THREAD (thread);
4691 }
4692
4693 /**
4694  * mono_thread_test_and_set_state:
4695  * Test if current state of \p thread include \p test. If it does not, OR \p set into the state.
4696  * \returns TRUE if \p set was OR'd in.
4697  */
4698 gboolean
4699 mono_thread_test_and_set_state (MonoInternalThread *thread, MonoThreadState test, MonoThreadState set)
4700 {
4701         LOCK_THREAD (thread);
4702
4703         if ((thread->state & test) != 0) {
4704                 UNLOCK_THREAD (thread);
4705                 return FALSE;
4706         }
4707
4708         thread->state |= set;
4709         UNLOCK_THREAD (thread);
4710
4711         return TRUE;
4712 }
4713
4714 void
4715 mono_thread_clr_state (MonoInternalThread *thread, MonoThreadState state)
4716 {
4717         LOCK_THREAD (thread);
4718         thread->state &= ~state;
4719         UNLOCK_THREAD (thread);
4720 }
4721
4722 gboolean
4723 mono_thread_test_state (MonoInternalThread *thread, MonoThreadState test)
4724 {
4725         gboolean ret = FALSE;
4726
4727         LOCK_THREAD (thread);
4728
4729         if ((thread->state & test) != 0) {
4730                 ret = TRUE;
4731         }
4732
4733         UNLOCK_THREAD (thread);
4734
4735         return ret;
4736 }
4737
4738 static void
4739 self_interrupt_thread (void *_unused)
4740 {
4741         MonoException *exc;
4742         MonoThreadInfo *info;
4743
4744         exc = mono_thread_execute_interruption ();
4745         if (!exc) {
4746                 if (mono_threads_is_coop_enabled ()) {
4747                         /* We can return from an async call in coop, as
4748                          * it's simply called when exiting the safepoint */
4749                         return;
4750                 }
4751
4752                 g_error ("%s: we can't resume from an async call", __func__);
4753         }
4754
4755         info = mono_thread_info_current ();
4756
4757         /* We must use _with_context since we didn't trampoline into the runtime */
4758         mono_raise_exception_with_context (exc, &info->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX].ctx); /* FIXME using thread_saved_state [ASYNC_SUSPEND_STATE_INDEX] can race with another suspend coming in. */
4759 }
4760
4761 static gboolean
4762 mono_jit_info_match (MonoJitInfo *ji, gpointer ip)
4763 {
4764         if (!ji)
4765                 return FALSE;
4766         return ji->code_start <= ip && (char*)ip < (char*)ji->code_start + ji->code_size;
4767 }
4768
4769 static gboolean
4770 last_managed (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
4771 {
4772         MonoJitInfo **dest = (MonoJitInfo **)data;
4773         *dest = frame->ji;
4774         return TRUE;
4775 }
4776
4777 static MonoJitInfo*
4778 mono_thread_info_get_last_managed (MonoThreadInfo *info)
4779 {
4780         MonoJitInfo *ji = NULL;
4781         if (!info)
4782                 return NULL;
4783
4784         /*
4785          * The suspended thread might be holding runtime locks. Make sure we don't try taking
4786          * any runtime locks while unwinding. In coop case we shouldn't safepoint in regions
4787          * where we hold runtime locks.
4788          */
4789         if (!mono_threads_is_coop_enabled ())
4790                 mono_thread_info_set_is_async_context (TRUE);
4791         mono_get_eh_callbacks ()->mono_walk_stack_with_state (last_managed, mono_thread_info_get_suspend_state (info), MONO_UNWIND_SIGNAL_SAFE, &ji);
4792         if (!mono_threads_is_coop_enabled ())
4793                 mono_thread_info_set_is_async_context (FALSE);
4794         return ji;
4795 }
4796
4797 typedef struct {
4798         MonoInternalThread *thread;
4799         gboolean install_async_abort;
4800         MonoThreadInfoInterruptToken *interrupt_token;
4801 } AbortThreadData;
4802
4803 static SuspendThreadResult
4804 async_abort_critical (MonoThreadInfo *info, gpointer ud)
4805 {
4806         AbortThreadData *data = (AbortThreadData *)ud;
4807         MonoInternalThread *thread = data->thread;
4808         MonoJitInfo *ji = NULL;
4809         gboolean protected_wrapper;
4810         gboolean running_managed;
4811
4812         if (mono_get_eh_callbacks ()->mono_install_handler_block_guard (mono_thread_info_get_suspend_state (info)))
4813                 return MonoResumeThread;
4814
4815         /*someone is already interrupting it*/
4816         if (!mono_thread_set_interruption_requested (thread))
4817                 return MonoResumeThread;
4818
4819         ji = mono_thread_info_get_last_managed (info);
4820         protected_wrapper = ji && !ji->is_trampoline && !ji->async && mono_threads_is_critical_method (mono_jit_info_get_method (ji));
4821         running_managed = mono_jit_info_match (ji, MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx));
4822
4823         if (!protected_wrapper && running_managed) {
4824                 /*We are in managed code*/
4825                 /*Set the thread to call */
4826                 if (data->install_async_abort)
4827                         mono_thread_info_setup_async_call (info, self_interrupt_thread, NULL);
4828                 return MonoResumeThread;
4829         } else {
4830                 /*
4831                  * This will cause waits to be broken.
4832                  * It will also prevent the thread from entering a wait, so if the thread returns
4833                  * from the wait before it receives the abort signal, it will just spin in the wait
4834                  * functions in the io-layer until the signal handler calls QueueUserAPC which will
4835                  * make it return.
4836                  */
4837                 data->interrupt_token = mono_thread_info_prepare_interrupt (info);
4838
4839                 return MonoResumeThread;
4840         }
4841 }
4842
4843 static void
4844 async_abort_internal (MonoInternalThread *thread, gboolean install_async_abort)
4845 {
4846         AbortThreadData data;
4847
4848         g_assert (thread != mono_thread_internal_current ());
4849
4850         data.thread = thread;
4851         data.install_async_abort = install_async_abort;
4852         data.interrupt_token = NULL;
4853
4854         mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), TRUE, async_abort_critical, &data);
4855         if (data.interrupt_token)
4856                 mono_thread_info_finish_interrupt (data.interrupt_token);
4857         /*FIXME we need to wait for interruption to complete -- figure out how much into interruption we should wait for here*/
4858 }
4859
4860 static void
4861 self_abort_internal (MonoError *error)
4862 {
4863         MonoException *exc;
4864
4865         error_init (error);
4866
4867         /* FIXME this is insanely broken, it doesn't cause interruption to happen synchronously
4868          * since passing FALSE to mono_thread_request_interruption makes sure it returns NULL */
4869
4870         /*
4871         Self aborts ignore the protected block logic and raise the TAE regardless. This is verified by one of the tests in mono/tests/abort-cctor.cs.
4872         */
4873         exc = mono_thread_request_interruption (TRUE);
4874         if (exc)
4875                 mono_error_set_exception_instance (error, exc);
4876         else
4877                 mono_thread_info_self_interrupt ();
4878 }
4879
4880 typedef struct {
4881         MonoInternalThread *thread;
4882         gboolean interrupt;
4883         MonoThreadInfoInterruptToken *interrupt_token;
4884 } SuspendThreadData;
4885
4886 static SuspendThreadResult
4887 async_suspend_critical (MonoThreadInfo *info, gpointer ud)
4888 {
4889         SuspendThreadData *data = (SuspendThreadData *)ud;
4890         MonoInternalThread *thread = data->thread;
4891         MonoJitInfo *ji = NULL;
4892         gboolean protected_wrapper;
4893         gboolean running_managed;
4894
4895         ji = mono_thread_info_get_last_managed (info);
4896         protected_wrapper = ji && !ji->is_trampoline && !ji->async && mono_threads_is_critical_method (mono_jit_info_get_method (ji));
4897         running_managed = mono_jit_info_match (ji, MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx));
4898
4899         if (running_managed && !protected_wrapper) {
4900                 if (mono_threads_is_coop_enabled ()) {
4901                         mono_thread_info_setup_async_call (info, self_interrupt_thread, NULL);
4902                         return MonoResumeThread;
4903                 } else {
4904                         thread->state &= ~ThreadState_SuspendRequested;
4905                         thread->state |= ThreadState_Suspended;
4906                         return KeepSuspended;
4907                 }
4908         } else {
4909                 mono_thread_set_interruption_requested (thread);
4910                 if (data->interrupt)
4911                         data->interrupt_token = mono_thread_info_prepare_interrupt ((MonoThreadInfo *)thread->thread_info);
4912
4913                 return MonoResumeThread;
4914         }
4915 }
4916
4917 /* LOCKING: called with @thread synch_cs held, and releases it */
4918 static void
4919 async_suspend_internal (MonoInternalThread *thread, gboolean interrupt)
4920 {
4921         SuspendThreadData data;
4922
4923         g_assert (thread != mono_thread_internal_current ());
4924
4925         // MOSTLY_ASYNC_SAFE_PRINTF ("ASYNC SUSPEND thread %p\n", thread_get_tid (thread));
4926
4927         thread->self_suspended = FALSE;
4928
4929         data.thread = thread;
4930         data.interrupt = interrupt;
4931         data.interrupt_token = NULL;
4932
4933         mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), interrupt, async_suspend_critical, &data);
4934         if (data.interrupt_token)
4935                 mono_thread_info_finish_interrupt (data.interrupt_token);
4936
4937         UNLOCK_THREAD (thread);
4938 }
4939
4940 /* LOCKING: called with @thread synch_cs held, and releases it */
4941 static void
4942 self_suspend_internal (void)
4943 {
4944         MonoInternalThread *thread;
4945         MonoOSEvent *event;
4946         MonoOSEventWaitRet res;
4947
4948         thread = mono_thread_internal_current ();
4949
4950         // MOSTLY_ASYNC_SAFE_PRINTF ("SELF SUSPEND thread %p\n", thread_get_tid (thread));
4951
4952         thread->self_suspended = TRUE;
4953
4954         thread->state &= ~ThreadState_SuspendRequested;
4955         thread->state |= ThreadState_Suspended;
4956
4957         UNLOCK_THREAD (thread);
4958
4959         event = thread->suspended;
4960
4961         MONO_ENTER_GC_SAFE;
4962         res = mono_os_event_wait_one (event, MONO_INFINITE_WAIT, TRUE);
4963         g_assert (res == MONO_OS_EVENT_WAIT_RET_SUCCESS_0 || res == MONO_OS_EVENT_WAIT_RET_ALERTED);
4964         MONO_EXIT_GC_SAFE;
4965 }
4966
4967 static void
4968 suspend_for_shutdown_async_call (gpointer unused)
4969 {
4970         for (;;)
4971                 mono_thread_info_yield ();
4972 }
4973
4974 static SuspendThreadResult
4975 suspend_for_shutdown_critical (MonoThreadInfo *info, gpointer unused)
4976 {
4977         mono_thread_info_setup_async_call (info, suspend_for_shutdown_async_call, NULL);
4978         return MonoResumeThread;
4979 }
4980
4981 void
4982 mono_thread_internal_suspend_for_shutdown (MonoInternalThread *thread)
4983 {
4984         g_assert (thread != mono_thread_internal_current ());
4985
4986         mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), FALSE, suspend_for_shutdown_critical, NULL);
4987 }
4988
4989 /**
4990  * mono_thread_is_foreign:
4991  * \param thread the thread to query
4992  *
4993  * This function allows one to determine if a thread was created by the mono runtime and has
4994  * a well defined lifecycle or it's a foreign one, created by the native environment.
4995  *
4996  * \returns TRUE if \p thread was not created by the runtime.
4997  */
4998 mono_bool
4999 mono_thread_is_foreign (MonoThread *thread)
5000 {
5001         MonoThreadInfo *info = (MonoThreadInfo *)thread->internal_thread->thread_info;
5002         return info->runtime_thread == FALSE;
5003 }
5004
5005 /*
5006  * mono_add_joinable_thread:
5007  *
5008  *   Add TID to the list of joinable threads.
5009  * LOCKING: Acquires the threads lock.
5010  */
5011 void
5012 mono_threads_add_joinable_thread (gpointer tid)
5013 {
5014 #ifndef HOST_WIN32
5015         /*
5016          * We cannot detach from threads because it causes problems like
5017          * 2fd16f60/r114307. So we collect them and join them when
5018          * we have time (in he finalizer thread).
5019          */
5020         joinable_threads_lock ();
5021         if (!joinable_threads)
5022                 joinable_threads = g_hash_table_new (NULL, NULL);
5023         g_hash_table_insert (joinable_threads, tid, tid);
5024         UnlockedIncrement (&joinable_thread_count);
5025         joinable_threads_unlock ();
5026
5027         mono_gc_finalize_notify ();
5028 #endif
5029 }
5030
5031 /*
5032  * mono_threads_join_threads:
5033  *
5034  *   Join all joinable threads. This is called from the finalizer thread.
5035  * LOCKING: Acquires the threads lock.
5036  */
5037 void
5038 mono_threads_join_threads (void)
5039 {
5040 #ifndef HOST_WIN32
5041         GHashTableIter iter;
5042         gpointer key;
5043         gpointer tid;
5044         pthread_t thread;
5045         gboolean found;
5046
5047         /* Fastpath */
5048         if (!UnlockedRead (&joinable_thread_count))
5049                 return;
5050
5051         while (TRUE) {
5052                 joinable_threads_lock ();
5053                 found = FALSE;
5054                 if (g_hash_table_size (joinable_threads)) {
5055                         g_hash_table_iter_init (&iter, joinable_threads);
5056                         g_hash_table_iter_next (&iter, &key, (void**)&tid);
5057                         thread = (pthread_t)tid;
5058                         g_hash_table_remove (joinable_threads, key);
5059                         UnlockedDecrement (&joinable_thread_count);
5060                         found = TRUE;
5061                 }
5062                 joinable_threads_unlock ();
5063                 if (found) {
5064                         if (thread != pthread_self ()) {
5065                                 MONO_ENTER_GC_SAFE;
5066                                 /* This shouldn't block */
5067                                 mono_threads_join_lock ();
5068                                 mono_native_thread_join (thread);
5069                                 mono_threads_join_unlock ();
5070                                 MONO_EXIT_GC_SAFE;
5071                         }
5072                 } else {
5073                         break;
5074                 }
5075         }
5076 #endif
5077 }
5078
5079 /*
5080  * mono_thread_join:
5081  *
5082  *   Wait for thread TID to exit.
5083  * LOCKING: Acquires the threads lock.
5084  */
5085 void
5086 mono_thread_join (gpointer tid)
5087 {
5088 #ifndef HOST_WIN32
5089         pthread_t thread;
5090         gboolean found = FALSE;
5091
5092         joinable_threads_lock ();
5093         if (!joinable_threads)
5094                 joinable_threads = g_hash_table_new (NULL, NULL);
5095         if (g_hash_table_lookup (joinable_threads, tid)) {
5096                 g_hash_table_remove (joinable_threads, tid);
5097                 UnlockedDecrement (&joinable_thread_count);
5098                 found = TRUE;
5099         }
5100         joinable_threads_unlock ();
5101         if (!found)
5102                 return;
5103         thread = (pthread_t)tid;
5104         MONO_ENTER_GC_SAFE;
5105         mono_native_thread_join (thread);
5106         MONO_EXIT_GC_SAFE;
5107 #endif
5108 }
5109
5110 void
5111 mono_thread_internal_unhandled_exception (MonoObject* exc)
5112 {
5113         MonoClass *klass = exc->vtable->klass;
5114         if (is_threadabort_exception (klass)) {
5115                 mono_thread_internal_reset_abort (mono_thread_internal_current ());
5116         } else if (!is_appdomainunloaded_exception (klass)
5117                 && mono_runtime_unhandled_exception_policy_get () == MONO_UNHANDLED_POLICY_CURRENT) {
5118                 mono_unhandled_exception (exc);
5119                 if (mono_environment_exitcode_get () == 1) {
5120                         mono_environment_exitcode_set (255);
5121                         mono_invoke_unhandled_exception_hook (exc);
5122                         g_assert_not_reached ();
5123                 }
5124         }
5125 }
5126
5127 void
5128 ves_icall_System_Threading_Thread_GetStackTraces (MonoArray **out_threads, MonoArray **out_stack_traces)
5129 {
5130         MonoError error;
5131         mono_threads_get_thread_dump (out_threads, out_stack_traces, &error);
5132         mono_error_set_pending_exception (&error);
5133 }
5134
5135 /*
5136  * mono_threads_attach_coop: called by native->managed wrappers
5137  *
5138  *  - @dummy:
5139  *    - blocking mode: contains gc unsafe transition cookie
5140  *    - non-blocking mode: contains random data
5141  *  - @return: the original domain which needs to be restored, or NULL.
5142  */
5143 gpointer
5144 mono_threads_attach_coop (MonoDomain *domain, gpointer *dummy)
5145 {
5146         MonoDomain *orig;
5147         MonoThreadInfo *info;
5148         gboolean external;
5149
5150         orig = mono_domain_get ();
5151
5152         if (!domain) {
5153                 /* Happens when called from AOTed code which is only used in the root domain. */
5154                 domain = mono_get_root_domain ();
5155                 g_assert (domain);
5156         }
5157
5158         /* On coop, when we detached, we moved the thread from  RUNNING->BLOCKING.
5159          * If we try to reattach we do a BLOCKING->RUNNING transition.  If the thread
5160          * is fresh, mono_thread_attach() will do a STARTING->RUNNING transition so
5161          * we're only responsible for making the cookie. */
5162         if (mono_threads_is_blocking_transition_enabled ())
5163                 external = !(info = mono_thread_info_current_unchecked ()) || !mono_thread_info_is_live (info);
5164
5165         if (!mono_thread_internal_current ()) {
5166                 mono_thread_attach_full (domain, FALSE);
5167
5168                 // #678164
5169                 mono_thread_set_state (mono_thread_internal_current (), ThreadState_Background);
5170         }
5171
5172         if (orig != domain)
5173                 mono_domain_set (domain, TRUE);
5174
5175         if (mono_threads_is_blocking_transition_enabled ()) {
5176                 if (external) {
5177                         /* mono_thread_attach put the thread in RUNNING mode from STARTING, but we need to
5178                          * return the right cookie. */
5179                         *dummy = mono_threads_enter_gc_unsafe_region_cookie ();
5180                 } else {
5181                         /* thread state (BLOCKING|RUNNING) -> RUNNING */
5182                         *dummy = mono_threads_enter_gc_unsafe_region (dummy);
5183                 }
5184         }
5185
5186         return orig;
5187 }
5188
5189 /*
5190  * mono_threads_detach_coop: called by native->managed wrappers
5191  *
5192  *  - @cookie: the original domain which needs to be restored, or NULL.
5193  *  - @dummy:
5194  *    - blocking mode: contains gc unsafe transition cookie
5195  *    - non-blocking mode: contains random data
5196  */
5197 void
5198 mono_threads_detach_coop (gpointer cookie, gpointer *dummy)
5199 {
5200         MonoDomain *domain, *orig;
5201
5202         orig = (MonoDomain*) cookie;
5203
5204         domain = mono_domain_get ();
5205         g_assert (domain);
5206
5207         if (mono_threads_is_blocking_transition_enabled ()) {
5208                 /* it won't do anything if cookie is NULL
5209                  * thread state RUNNING -> (RUNNING|BLOCKING) */
5210                 mono_threads_exit_gc_unsafe_region (*dummy, dummy);
5211         }
5212
5213         if (orig != domain) {
5214                 if (!orig)
5215                         mono_domain_unset ();
5216                 else
5217                         mono_domain_set (orig, TRUE);
5218         }
5219 }
5220
5221 #if 0
5222 /* Returns TRUE if the current thread is ready to be interrupted. */
5223 gboolean
5224 mono_threads_is_ready_to_be_interrupted (void)
5225 {
5226         MonoInternalThread *thread;
5227
5228         thread = mono_thread_internal_current ();
5229         LOCK_THREAD (thread);
5230         if (thread->state & (ThreadState_SuspendRequested | ThreadState_AbortRequested)) {
5231                 UNLOCK_THREAD (thread);
5232                 return FALSE;
5233         }
5234
5235         if (mono_thread_get_abort_prot_block_count (thread) || mono_get_eh_callbacks ()->mono_current_thread_has_handle_block_guard ()) {
5236                 UNLOCK_THREAD (thread);
5237                 return FALSE;
5238         }
5239
5240         UNLOCK_THREAD (thread);
5241         return TRUE;
5242 }
5243 #endif
5244
5245 void
5246 mono_thread_internal_describe (MonoInternalThread *internal, GString *text)
5247 {
5248         g_string_append_printf (text, ", thread handle : %p", internal->handle);
5249
5250         if (internal->thread_info) {
5251                 g_string_append (text, ", state : ");
5252                 mono_thread_info_describe_interrupt_token ((MonoThreadInfo*) internal->thread_info, text);
5253         }
5254
5255         if (internal->owned_mutexes) {
5256                 int i;
5257
5258                 g_string_append (text, ", owns : [");
5259                 for (i = 0; i < internal->owned_mutexes->len; i++)
5260                         g_string_append_printf (text, i == 0 ? "%p" : ", %p", g_ptr_array_index (internal->owned_mutexes, i));
5261                 g_string_append (text, "]");
5262         }
5263 }
5264
5265 gboolean
5266 mono_thread_internal_is_current (MonoInternalThread *internal)
5267 {
5268         g_assert (internal);
5269         return mono_native_thread_id_equals (mono_native_thread_id_get (), MONO_UINT_TO_NATIVE_THREAD_ID (internal->tid));
5270 }