mono/metadata/threads.c

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