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