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