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, 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, TRUE, 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)
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         MONO_ENTER_GC_SAFE;
2941         ret = mono_thread_info_wait_multiple_handle(wait->handles, wait->num, NULL, TRUE, timeout, TRUE);
2942         MONO_EXIT_GC_SAFE;
2943
2944         if(ret==MONO_THREAD_INFO_WAIT_RET_FAILED) {
2945                 /* See the comment in build_wait_tids() */
2946                 THREAD_DEBUG (g_message ("%s: Wait failed", __func__));
2947                 return;
2948         }
2949
2950         for(i=0; i<wait->num; i++)
2951                 mono_threads_close_thread_handle (wait->handles [i]);
2952
2953         if (ret == MONO_THREAD_INFO_WAIT_RET_TIMEOUT)
2954                 return;
2955
2956         for(i=0; i<wait->num; i++) {
2957                 MonoInternalThread *internal;
2958
2959                 internal = wait->threads [i];
2960
2961                 mono_threads_lock ();
2962                 if (mono_g_hash_table_lookup (threads, (gpointer) internal->tid) == internal)
2963                         g_error ("%s: failed to call mono_thread_detach_internal on thread %p, InternalThread: %p", __func__, internal->tid, internal);
2964                 mono_threads_unlock ();
2965         }
2966 }
2967
2968 static void wait_for_tids_or_state_change (struct wait_data *wait, guint32 timeout)
2969 {
2970         guint32 i;
2971         MonoThreadInfoWaitRet ret;
2972
2973         THREAD_DEBUG (g_message("%s: %d threads to wait for in this batch", __func__, wait->num));
2974
2975         /* Add the thread state change event, so it wakes
2976          * up if a thread changes to background mode. */
2977
2978         MONO_ENTER_GC_SAFE;
2979         ret = mono_thread_info_wait_multiple_handle (wait->handles, wait->num, &background_change_event, FALSE, timeout, TRUE);
2980         MONO_EXIT_GC_SAFE;
2981
2982         if(ret==MONO_THREAD_INFO_WAIT_RET_FAILED) {
2983                 /* See the comment in build_wait_tids() */
2984                 THREAD_DEBUG (g_message ("%s: Wait failed", __func__));
2985                 return;
2986         }
2987
2988         for(i=0; i<wait->num; i++)
2989                 mono_threads_close_thread_handle (wait->handles [i]);
2990
2991         if (ret == MONO_THREAD_INFO_WAIT_RET_TIMEOUT)
2992                 return;
2993
2994         if (ret < wait->num) {
2995                 MonoInternalThread *internal;
2996
2997                 internal = wait->threads [ret];
2998
2999                 mono_threads_lock ();
3000                 if (mono_g_hash_table_lookup (threads, (gpointer) internal->tid) == internal)
3001                         g_error ("%s: failed to call mono_thread_detach_internal on thread %p, InternalThread: %p", __func__, internal->tid, internal);
3002                 mono_threads_unlock ();
3003         }
3004 }
3005
3006 static void build_wait_tids (gpointer key, gpointer value, gpointer user)
3007 {
3008         struct wait_data *wait=(struct wait_data *)user;
3009
3010         if(wait->num<MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS - 1) {
3011                 MonoInternalThread *thread=(MonoInternalThread *)value;
3012
3013                 /* Ignore background threads, we abort them later */
3014                 /* Do not lock here since it is not needed and the caller holds threads_lock */
3015                 if (thread->state & ThreadState_Background) {
3016                         THREAD_DEBUG (g_message ("%s: ignoring background thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3017                         return; /* just leave, ignore */
3018                 }
3019
3020                 if (mono_gc_is_finalizer_internal_thread (thread)) {
3021                         THREAD_DEBUG (g_message ("%s: ignoring finalizer thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3022                         return;
3023                 }
3024
3025                 if (thread == mono_thread_internal_current ()) {
3026                         THREAD_DEBUG (g_message ("%s: ignoring current thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3027                         return;
3028                 }
3029
3030                 if (mono_thread_get_main () && (thread == mono_thread_get_main ()->internal_thread)) {
3031                         THREAD_DEBUG (g_message ("%s: ignoring main thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3032                         return;
3033                 }
3034
3035                 if (thread->flags & MONO_THREAD_FLAG_DONT_MANAGE) {
3036                         THREAD_DEBUG (g_message ("%s: ignoring thread %" G_GSIZE_FORMAT "with DONT_MANAGE flag set.", __func__, (gsize)thread->tid));
3037                         return;
3038                 }
3039
3040                 THREAD_DEBUG (g_message ("%s: Invoking mono_thread_manage callback on thread %p", __func__, thread));
3041                 if ((thread->manage_callback == NULL) || (thread->manage_callback (thread->root_domain_thread) == TRUE)) {
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_message ("%s: adding thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3047                 } else {
3048                         THREAD_DEBUG (g_message ("%s: ignoring (because of callback) thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
3049                 }
3050
3051
3052         } else {
3053                 /* Just ignore the rest, we can't do anything with
3054                  * them yet
3055                  */
3056         }
3057 }
3058
3059 static gboolean
3060 remove_and_abort_threads (gpointer key, gpointer value, gpointer user)
3061 {
3062         struct wait_data *wait=(struct wait_data *)user;
3063         MonoNativeThreadId self = mono_native_thread_id_get ();
3064         MonoInternalThread *thread = (MonoInternalThread *)value;
3065
3066         if (wait->num >= MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS)
3067                 return FALSE;
3068
3069         /* The finalizer thread is not a background thread */
3070         if (!mono_native_thread_id_equals (thread_get_tid (thread), self)
3071              && (thread->state & ThreadState_Background) != 0
3072              && (thread->flags & MONO_THREAD_FLAG_DONT_MANAGE) == 0
3073         ) {
3074                 wait->handles[wait->num] = mono_threads_open_thread_handle (thread->handle);
3075                 wait->threads[wait->num] = thread;
3076                 wait->num++;
3077
3078                 THREAD_DEBUG (g_print ("%s: Aborting id: %"G_GSIZE_FORMAT"\n", __func__, (gsize)thread->tid));
3079                 mono_thread_internal_abort (thread);
3080                 return TRUE;
3081         }
3082
3083         return !mono_native_thread_id_equals (thread_get_tid (thread), self)
3084                 && !mono_gc_is_finalizer_internal_thread (thread);
3085 }
3086
3087 /**
3088  * mono_threads_set_shutting_down:
3089  *
3090  * Is called by a thread that wants to shut down Mono. If the runtime is already
3091  * shutting down, the calling thread is suspended/stopped, and this function never
3092  * returns.
3093  */
3094 void
3095 mono_threads_set_shutting_down (void)
3096 {
3097         MonoInternalThread *current_thread = mono_thread_internal_current ();
3098
3099         mono_threads_lock ();
3100
3101         if (shutting_down) {
3102                 mono_threads_unlock ();
3103
3104                 /* Make sure we're properly suspended/stopped */
3105
3106                 LOCK_THREAD (current_thread);
3107
3108                 if ((current_thread->state & ThreadState_SuspendRequested) ||
3109                     (current_thread->state & ThreadState_AbortRequested) ||
3110                     (current_thread->state & ThreadState_StopRequested)) {
3111                         UNLOCK_THREAD (current_thread);
3112                         mono_thread_execute_interruption ();
3113                 } else {
3114                         current_thread->state |= ThreadState_Stopped;
3115                         UNLOCK_THREAD (current_thread);
3116                 }
3117
3118                 /*since we're killing the thread, detach it.*/
3119                 mono_thread_detach_internal (current_thread);
3120
3121                 /* Wake up other threads potentially waiting for us */
3122                 mono_thread_info_exit (0);
3123         } else {
3124                 shutting_down = TRUE;
3125
3126                 /* Not really a background state change, but this will
3127                  * interrupt the main thread if it is waiting for all
3128                  * the other threads.
3129                  */
3130                 mono_os_event_set (&background_change_event);
3131
3132                 mono_threads_unlock ();
3133         }
3134 }
3135
3136 void mono_thread_manage (void)
3137 {
3138         struct wait_data wait_data;
3139         struct wait_data *wait = &wait_data;
3140
3141         memset (wait, 0, sizeof (struct wait_data));
3142         /* join each thread that's still running */
3143         THREAD_DEBUG (g_message ("%s: Joining each running thread...", __func__));
3144
3145         mono_threads_lock ();
3146         if(threads==NULL) {
3147                 THREAD_DEBUG (g_message("%s: No threads", __func__));
3148                 mono_threads_unlock ();
3149                 return;
3150         }
3151         mono_threads_unlock ();
3152
3153         do {
3154                 mono_threads_lock ();
3155                 if (shutting_down) {
3156                         /* somebody else is shutting down */
3157                         mono_threads_unlock ();
3158                         break;
3159                 }
3160                 THREAD_DEBUG (g_message ("%s: There are %d threads to join", __func__, mono_g_hash_table_size (threads));
3161                         mono_g_hash_table_foreach (threads, print_tids, NULL));
3162
3163                 mono_os_event_reset (&background_change_event);
3164                 wait->num=0;
3165                 /*We must zero all InternalThread pointers to avoid making the GC unhappy.*/
3166                 memset (wait->threads, 0, MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS * SIZEOF_VOID_P);
3167                 mono_g_hash_table_foreach (threads, build_wait_tids, wait);
3168                 mono_threads_unlock ();
3169                 if(wait->num>0) {
3170                         /* Something to wait for */
3171                         wait_for_tids_or_state_change (wait, INFINITE);
3172                 }
3173                 THREAD_DEBUG (g_message ("%s: I have %d threads after waiting.", __func__, wait->num));
3174         } while(wait->num>0);
3175
3176         /* Mono is shutting down, so just wait for the end */
3177         if (!mono_runtime_try_shutdown ()) {
3178                 /*FIXME mono_thread_suspend probably should call mono_thread_execute_interruption when self interrupting. */
3179                 mono_thread_suspend (mono_thread_internal_current ());
3180                 mono_thread_execute_interruption ();
3181         }
3182
3183         /*
3184          * Remove everything but the finalizer thread and self.
3185          * Also abort all the background threads
3186          * */
3187         do {
3188                 mono_threads_lock ();
3189
3190                 wait->num = 0;
3191                 /*We must zero all InternalThread pointers to avoid making the GC unhappy.*/
3192                 memset (wait->threads, 0, MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS * SIZEOF_VOID_P);
3193                 mono_g_hash_table_foreach_remove (threads, remove_and_abort_threads, wait);
3194
3195                 mono_threads_unlock ();
3196
3197                 THREAD_DEBUG (g_message ("%s: wait->num is now %d", __func__, wait->num));
3198                 if(wait->num>0) {
3199                         /* Something to wait for */
3200                         wait_for_tids (wait, INFINITE);
3201                 }
3202         } while (wait->num > 0);
3203
3204         /*
3205          * give the subthreads a chance to really quit (this is mainly needed
3206          * to get correct user and system times from getrusage/wait/time(1)).
3207          * This could be removed if we avoid pthread_detach() and use pthread_join().
3208          */
3209         mono_thread_info_yield ();
3210 }
3211
3212 static void
3213 collect_threads_for_suspend (gpointer key, gpointer value, gpointer user_data)
3214 {
3215         MonoInternalThread *thread = (MonoInternalThread*)value;
3216         struct wait_data *wait = (struct wait_data*)user_data;
3217
3218         /*
3219          * We try to exclude threads early, to avoid running into the MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS
3220          * limitation.
3221          * This needs no locking.
3222          */
3223         if ((thread->state & ThreadState_Suspended) != 0 ||
3224                 (thread->state & ThreadState_Stopped) != 0)
3225                 return;
3226
3227         if (wait->num<MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS) {
3228                 wait->handles [wait->num] = mono_threads_open_thread_handle (thread->handle);
3229                 wait->threads [wait->num] = thread;
3230                 wait->num++;
3231         }
3232 }
3233
3234 /*
3235  * mono_thread_suspend_all_other_threads:
3236  *
3237  *  Suspend all managed threads except the finalizer thread and this thread. It is
3238  * not possible to resume them later.
3239  */
3240 void mono_thread_suspend_all_other_threads (void)
3241 {
3242         struct wait_data wait_data;
3243         struct wait_data *wait = &wait_data;
3244         int i;
3245         MonoNativeThreadId self = mono_native_thread_id_get ();
3246         guint32 eventidx = 0;
3247         gboolean starting, finished;
3248
3249         memset (wait, 0, sizeof (struct wait_data));
3250         /*
3251          * The other threads could be in an arbitrary state at this point, i.e.
3252          * they could be starting up, shutting down etc. This means that there could be
3253          * threads which are not even in the threads hash table yet.
3254          */
3255
3256         /*
3257          * First we set a barrier which will be checked by all threads before they
3258          * are added to the threads hash table, and they will exit if the flag is set.
3259          * This ensures that no threads could be added to the hash later.
3260          * We will use shutting_down as the barrier for now.
3261          */
3262         g_assert (shutting_down);
3263
3264         /*
3265          * We make multiple calls to WaitForMultipleObjects since:
3266          * - we can only wait for MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS threads
3267          * - some threads could exit without becoming suspended
3268          */
3269         finished = FALSE;
3270         while (!finished) {
3271                 /*
3272                  * Make a copy of the hashtable since we can't do anything with
3273                  * threads while threads_mutex is held.
3274                  */
3275                 wait->num = 0;
3276                 /*We must zero all InternalThread pointers to avoid making the GC unhappy.*/
3277                 memset (wait->threads, 0, MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS * SIZEOF_VOID_P);
3278                 mono_threads_lock ();
3279                 mono_g_hash_table_foreach (threads, collect_threads_for_suspend, wait);
3280                 mono_threads_unlock ();
3281
3282                 eventidx = 0;
3283                 /* Get the suspended events that we'll be waiting for */
3284                 for (i = 0; i < wait->num; ++i) {
3285                         MonoInternalThread *thread = wait->threads [i];
3286
3287                         if (mono_native_thread_id_equals (thread_get_tid (thread), self)
3288                              || mono_gc_is_finalizer_internal_thread (thread)
3289                              || (thread->flags & MONO_THREAD_FLAG_DONT_MANAGE)
3290                         ) {
3291                                 //mono_threads_close_thread_handle (wait->handles [i]);
3292                                 wait->threads [i] = NULL; /* ignore this thread in next loop */
3293                                 continue;
3294                         }
3295
3296                         LOCK_THREAD (thread);
3297
3298                         if ((thread->state & ThreadState_Suspended) != 0 ||
3299                                 (thread->state & ThreadState_StopRequested) != 0 ||
3300                                 (thread->state & ThreadState_Stopped) != 0) {
3301                                 UNLOCK_THREAD (thread);
3302                                 mono_threads_close_thread_handle (wait->handles [i]);
3303                                 wait->threads [i] = NULL; /* ignore this thread in next loop */
3304                                 continue;
3305                         }
3306
3307                         ++eventidx;
3308
3309                         /* Convert abort requests into suspend requests */
3310                         if ((thread->state & ThreadState_AbortRequested) != 0)
3311                                 thread->state &= ~ThreadState_AbortRequested;
3312
3313                         thread->state |= ThreadState_SuspendRequested;
3314                         if (mono_threads_is_coop_enabled ())
3315                                 mono_os_event_reset (thread->suspended);
3316
3317                         /* Signal the thread to suspend + calls UNLOCK_THREAD (thread) */
3318                         async_suspend_internal (thread, TRUE);
3319                 }
3320                 if (eventidx <= 0) {
3321                         /*
3322                          * If there are threads which are starting up, we wait until they
3323                          * are suspended when they try to register in the threads hash.
3324                          * This is guaranteed to finish, since the threads which can create new
3325                          * threads get suspended after a while.
3326                          * FIXME: The finalizer thread can still create new threads.
3327                          */
3328                         mono_threads_lock ();
3329                         if (threads_starting_up)
3330                                 starting = mono_g_hash_table_size (threads_starting_up) > 0;
3331                         else
3332                                 starting = FALSE;
3333                         mono_threads_unlock ();
3334                         if (starting)
3335                                 mono_thread_info_sleep (100, NULL);
3336                         else
3337                                 finished = TRUE;
3338                 }
3339         }
3340 }
3341
3342 typedef struct {
3343         MonoInternalThread *thread;
3344         MonoStackFrameInfo *frames;
3345         int nframes, max_frames;
3346         int nthreads, max_threads;
3347         MonoInternalThread **threads;
3348 } ThreadDumpUserData;
3349
3350 static gboolean thread_dump_requested;
3351
3352 /* This needs to be async safe */
3353 static gboolean
3354 collect_frame (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
3355 {
3356         ThreadDumpUserData *ud = (ThreadDumpUserData *)data;
3357
3358         if (ud->nframes < ud->max_frames) {
3359                 memcpy (&ud->frames [ud->nframes], frame, sizeof (MonoStackFrameInfo));
3360                 ud->nframes ++;
3361         }
3362
3363         return FALSE;
3364 }
3365
3366 /* This needs to be async safe */
3367 static SuspendThreadResult
3368 get_thread_dump (MonoThreadInfo *info, gpointer ud)
3369 {
3370         ThreadDumpUserData *user_data = (ThreadDumpUserData *)ud;
3371         MonoInternalThread *thread = user_data->thread;
3372
3373 #if 0
3374 /* This no longer works with remote unwinding */
3375         g_string_append_printf (text, " tid=0x%p this=0x%p ", (gpointer)(gsize)thread->tid, thread);
3376         mono_thread_internal_describe (thread, text);
3377         g_string_append (text, "\n");
3378 #endif
3379
3380         if (thread == mono_thread_internal_current ())
3381                 mono_get_eh_callbacks ()->mono_walk_stack_with_ctx (collect_frame, NULL, MONO_UNWIND_SIGNAL_SAFE, ud);
3382         else
3383                 mono_get_eh_callbacks ()->mono_walk_stack_with_state (collect_frame, mono_thread_info_get_suspend_state (info), MONO_UNWIND_SIGNAL_SAFE, ud);
3384
3385         return MonoResumeThread;
3386 }
3387
3388 typedef struct {
3389         int nthreads, max_threads;
3390         MonoInternalThread **threads;
3391 } CollectThreadsUserData;
3392
3393 static void
3394 collect_thread (gpointer key, gpointer value, gpointer user)
3395 {
3396         CollectThreadsUserData *ud = (CollectThreadsUserData *)user;
3397         MonoInternalThread *thread = (MonoInternalThread *)value;
3398
3399         if (ud->nthreads < ud->max_threads)
3400                 ud->threads [ud->nthreads ++] = thread;
3401 }
3402
3403 /*
3404  * Collect running threads into the THREADS array.
3405  * THREADS should be an array allocated on the stack.
3406  */
3407 static int
3408 collect_threads (MonoInternalThread **thread_array, int max_threads)
3409 {
3410         CollectThreadsUserData ud;
3411
3412         memset (&ud, 0, sizeof (ud));
3413         /* This array contains refs, but its on the stack, so its ok */
3414         ud.threads = thread_array;
3415         ud.max_threads = max_threads;
3416
3417         mono_threads_lock ();
3418         mono_g_hash_table_foreach (threads, collect_thread, &ud);
3419         mono_threads_unlock ();
3420
3421         return ud.nthreads;
3422 }
3423
3424 static void
3425 dump_thread (MonoInternalThread *thread, ThreadDumpUserData *ud)
3426 {
3427         GString* text = g_string_new (0);
3428         char *name;
3429         GError *error = NULL;
3430         int i;
3431
3432         ud->thread = thread;
3433         ud->nframes = 0;
3434
3435         /* Collect frames for the thread */
3436         if (thread == mono_thread_internal_current ()) {
3437                 get_thread_dump (mono_thread_info_current (), ud);
3438         } else {
3439                 mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), FALSE, get_thread_dump, ud);
3440         }
3441
3442         /*
3443          * Do all the non async-safe work outside of get_thread_dump.
3444          */
3445         if (thread->name) {
3446                 name = g_utf16_to_utf8 (thread->name, thread->name_len, NULL, NULL, &error);
3447                 g_assert (!error);
3448                 g_string_append_printf (text, "\n\"%s\"", name);
3449                 g_free (name);
3450         }
3451         else if (thread->threadpool_thread) {
3452                 g_string_append (text, "\n\"<threadpool thread>\"");
3453         } else {
3454                 g_string_append (text, "\n\"<unnamed thread>\"");
3455         }
3456
3457         for (i = 0; i < ud->nframes; ++i) {
3458                 MonoStackFrameInfo *frame = &ud->frames [i];
3459                 MonoMethod *method = NULL;
3460
3461                 if (frame->type == FRAME_TYPE_MANAGED)
3462                         method = mono_jit_info_get_method (frame->ji);
3463
3464                 if (method) {
3465                         gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, frame->domain);
3466                         g_string_append_printf (text, "  %s\n", location);
3467                         g_free (location);
3468                 } else {
3469                         g_string_append_printf (text, "  at <unknown> <0x%05x>\n", frame->native_offset);
3470                 }
3471         }
3472
3473         fprintf (stdout, "%s", text->str);
3474
3475 #if PLATFORM_WIN32 && TARGET_WIN32 && _DEBUG
3476         OutputDebugStringA(text->str);
3477 #endif
3478
3479         g_string_free (text, TRUE);
3480         fflush (stdout);
3481 }
3482
3483 void
3484 mono_threads_perform_thread_dump (void)
3485 {
3486         ThreadDumpUserData ud;
3487         MonoInternalThread *thread_array [128];
3488         int tindex, nthreads;
3489
3490         if (!thread_dump_requested)
3491                 return;
3492
3493         printf ("Full thread dump:\n");
3494
3495         /* Make a copy of the threads hash to avoid doing work inside threads_lock () */
3496         nthreads = collect_threads (thread_array, 128);
3497
3498         memset (&ud, 0, sizeof (ud));
3499         ud.frames = g_new0 (MonoStackFrameInfo, 256);
3500         ud.max_frames = 256;
3501
3502         for (tindex = 0; tindex < nthreads; ++tindex)
3503                 dump_thread (thread_array [tindex], &ud);
3504
3505         g_free (ud.frames);
3506
3507         thread_dump_requested = FALSE;
3508 }
3509
3510 /* Obtain the thread dump of all threads */
3511 static gboolean
3512 mono_threads_get_thread_dump (MonoArray **out_threads, MonoArray **out_stack_frames, MonoError *error)
3513 {
3514
3515         ThreadDumpUserData ud;
3516         MonoInternalThread *thread_array [128];
3517         MonoDomain *domain = mono_domain_get ();
3518         MonoDebugSourceLocation *location;
3519         int tindex, nthreads;
3520
3521         mono_error_init (error);
3522
3523         *out_threads = NULL;
3524         *out_stack_frames = NULL;
3525
3526         /* Make a copy of the threads hash to avoid doing work inside threads_lock () */
3527         nthreads = collect_threads (thread_array, 128);
3528
3529         memset (&ud, 0, sizeof (ud));
3530         ud.frames = g_new0 (MonoStackFrameInfo, 256);
3531         ud.max_frames = 256;
3532
3533         *out_threads = mono_array_new_checked (domain, mono_defaults.thread_class, nthreads, error);
3534         if (!is_ok (error))
3535                 goto leave;
3536         *out_stack_frames = mono_array_new_checked (domain, mono_defaults.array_class, nthreads, error);
3537         if (!is_ok (error))
3538                 goto leave;
3539
3540         for (tindex = 0; tindex < nthreads; ++tindex) {
3541                 MonoInternalThread *thread = thread_array [tindex];
3542                 MonoArray *thread_frames;
3543                 int i;
3544
3545                 ud.thread = thread;
3546                 ud.nframes = 0;
3547
3548                 /* Collect frames for the thread */
3549                 if (thread == mono_thread_internal_current ()) {
3550                         get_thread_dump (mono_thread_info_current (), &ud);
3551                 } else {
3552                         mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), FALSE, get_thread_dump, &ud);
3553                 }
3554
3555                 mono_array_setref_fast (*out_threads, tindex, mono_thread_current_for_thread (thread));
3556
3557                 thread_frames = mono_array_new_checked (domain, mono_defaults.stack_frame_class, ud.nframes, error);
3558                 if (!is_ok (error))
3559                         goto leave;
3560                 mono_array_setref_fast (*out_stack_frames, tindex, thread_frames);
3561
3562                 for (i = 0; i < ud.nframes; ++i) {
3563                         MonoStackFrameInfo *frame = &ud.frames [i];
3564                         MonoMethod *method = NULL;
3565                         MonoStackFrame *sf = (MonoStackFrame *)mono_object_new_checked (domain, mono_defaults.stack_frame_class, error);
3566                         if (!is_ok (error))
3567                                 goto leave;
3568
3569                         sf->native_offset = frame->native_offset;
3570
3571                         if (frame->type == FRAME_TYPE_MANAGED)
3572                                 method = mono_jit_info_get_method (frame->ji);
3573
3574                         if (method) {
3575                                 sf->method_address = (gsize) frame->ji->code_start;
3576
3577                                 MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, NULL, error);
3578                                 if (!is_ok (error))
3579                                         goto leave;
3580                                 MONO_OBJECT_SETREF (sf, method, rm);
3581
3582                                 location = mono_debug_lookup_source_location (method, frame->native_offset, domain);
3583                                 if (location) {
3584                                         sf->il_offset = location->il_offset;
3585
3586                                         if (location && location->source_file) {
3587                                                 MONO_OBJECT_SETREF (sf, filename, mono_string_new (domain, location->source_file));
3588                                                 sf->line = location->row;
3589                                                 sf->column = location->column;
3590                                         }
3591                                         mono_debug_free_source_location (location);
3592                                 } else {
3593                                         sf->il_offset = -1;
3594                                 }
3595                         }
3596                         mono_array_setref (thread_frames, i, sf);
3597                 }
3598         }
3599
3600 leave:
3601         g_free (ud.frames);
3602         return is_ok (error);
3603 }
3604
3605 /**
3606  * mono_threads_request_thread_dump:
3607  *
3608  *   Ask all threads except the current to print their stacktrace to stdout.
3609  */
3610 void
3611 mono_threads_request_thread_dump (void)
3612 {
3613         /*The new thread dump code runs out of the finalizer thread. */
3614         thread_dump_requested = TRUE;
3615         mono_gc_finalize_notify ();
3616 }
3617
3618 struct ref_stack {
3619         gpointer *refs;
3620         gint allocated; /* +1 so that refs [allocated] == NULL */
3621         gint bottom;
3622 };
3623
3624 typedef struct ref_stack RefStack;
3625
3626 static RefStack *
3627 ref_stack_new (gint initial_size)
3628 {
3629         RefStack *rs;
3630
3631         initial_size = MAX (initial_size, 16) + 1;
3632         rs = g_new0 (RefStack, 1);
3633         rs->refs = g_new0 (gpointer, initial_size);
3634         rs->allocated = initial_size;
3635         return rs;
3636 }
3637
3638 static void
3639 ref_stack_destroy (gpointer ptr)
3640 {
3641         RefStack *rs = (RefStack *)ptr;
3642
3643         if (rs != NULL) {
3644                 g_free (rs->refs);
3645                 g_free (rs);
3646         }
3647 }
3648
3649 static void
3650 ref_stack_push (RefStack *rs, gpointer ptr)
3651 {
3652         g_assert (rs != NULL);
3653
3654         if (rs->bottom >= rs->allocated) {
3655                 rs->refs = (void **)g_realloc (rs->refs, rs->allocated * 2 * sizeof (gpointer) + 1);
3656                 rs->allocated <<= 1;
3657                 rs->refs [rs->allocated] = NULL;
3658         }
3659         rs->refs [rs->bottom++] = ptr;
3660 }
3661
3662 static void
3663 ref_stack_pop (RefStack *rs)
3664 {
3665         if (rs == NULL || rs->bottom == 0)
3666                 return;
3667
3668         rs->bottom--;
3669         rs->refs [rs->bottom] = NULL;
3670 }
3671
3672 static gboolean
3673 ref_stack_find (RefStack *rs, gpointer ptr)
3674 {
3675         gpointer *refs;
3676
3677         if (rs == NULL)
3678                 return FALSE;
3679
3680         for (refs = rs->refs; refs && *refs; refs++) {
3681                 if (*refs == ptr)
3682                         return TRUE;
3683         }
3684         return FALSE;
3685 }
3686
3687 /*
3688  * mono_thread_push_appdomain_ref:
3689  *
3690  *   Register that the current thread may have references to objects in domain
3691  * @domain on its stack. Each call to this function should be paired with a
3692  * call to pop_appdomain_ref.
3693  */
3694 void
3695 mono_thread_push_appdomain_ref (MonoDomain *domain)
3696 {
3697         MonoInternalThread *thread = mono_thread_internal_current ();
3698
3699         if (thread) {
3700                 /* printf ("PUSH REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, domain->friendly_name); */
3701                 SPIN_LOCK (thread->lock_thread_id);
3702                 if (thread->appdomain_refs == NULL)
3703                         thread->appdomain_refs = ref_stack_new (16);
3704                 ref_stack_push ((RefStack *)thread->appdomain_refs, domain);
3705                 SPIN_UNLOCK (thread->lock_thread_id);
3706         }
3707 }
3708
3709 void
3710 mono_thread_pop_appdomain_ref (void)
3711 {
3712         MonoInternalThread *thread = mono_thread_internal_current ();
3713
3714         if (thread) {
3715                 /* printf ("POP REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, ((MonoDomain*)(thread->appdomain_refs->data))->friendly_name); */
3716                 SPIN_LOCK (thread->lock_thread_id);
3717                 ref_stack_pop ((RefStack *)thread->appdomain_refs);
3718                 SPIN_UNLOCK (thread->lock_thread_id);
3719         }
3720 }
3721
3722 gboolean
3723 mono_thread_internal_has_appdomain_ref (MonoInternalThread *thread, MonoDomain *domain)
3724 {
3725         gboolean res;
3726         SPIN_LOCK (thread->lock_thread_id);
3727         res = ref_stack_find ((RefStack *)thread->appdomain_refs, domain);
3728         SPIN_UNLOCK (thread->lock_thread_id);
3729         return res;
3730 }
3731
3732 gboolean
3733 mono_thread_has_appdomain_ref (MonoThread *thread, MonoDomain *domain)
3734 {
3735         return mono_thread_internal_has_appdomain_ref (thread->internal_thread, domain);
3736 }
3737
3738 typedef struct abort_appdomain_data {
3739         struct wait_data wait;
3740         MonoDomain *domain;
3741 } abort_appdomain_data;
3742
3743 static void
3744 collect_appdomain_thread (gpointer key, gpointer value, gpointer user_data)
3745 {
3746         MonoInternalThread *thread = (MonoInternalThread*)value;
3747         abort_appdomain_data *data = (abort_appdomain_data*)user_data;
3748         MonoDomain *domain = data->domain;
3749
3750         if (mono_thread_internal_has_appdomain_ref (thread, domain)) {
3751                 /* printf ("ABORTING THREAD %p BECAUSE IT REFERENCES DOMAIN %s.\n", thread->tid, domain->friendly_name); */
3752
3753                 if(data->wait.num<MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS) {
3754                         data->wait.handles [data->wait.num] = mono_threads_open_thread_handle (thread->handle);
3755                         data->wait.threads [data->wait.num] = thread;
3756                         data->wait.num++;
3757                 } else {
3758                         /* Just ignore the rest, we can't do anything with
3759                          * them yet
3760                          */
3761                 }
3762         }
3763 }
3764
3765 /*
3766  * mono_threads_abort_appdomain_threads:
3767  *
3768  *   Abort threads which has references to the given appdomain.
3769  */
3770 gboolean
3771 mono_threads_abort_appdomain_threads (MonoDomain *domain, int timeout)
3772 {
3773 #ifdef __native_client__
3774         return FALSE;
3775 #endif
3776
3777         abort_appdomain_data user_data;
3778         gint64 start_time;
3779         int orig_timeout = timeout;
3780         int i;
3781
3782         THREAD_DEBUG (g_message ("%s: starting abort", __func__));
3783
3784         start_time = mono_msec_ticks ();
3785         do {
3786                 mono_threads_lock ();
3787
3788                 user_data.domain = domain;
3789                 user_data.wait.num = 0;
3790                 /* This shouldn't take any locks */
3791                 mono_g_hash_table_foreach (threads, collect_appdomain_thread, &user_data);
3792                 mono_threads_unlock ();
3793
3794                 if (user_data.wait.num > 0) {
3795                         /* Abort the threads outside the threads lock */
3796                         for (i = 0; i < user_data.wait.num; ++i)
3797                                 mono_thread_internal_abort (user_data.wait.threads [i]);
3798
3799                         /*
3800                          * We should wait for the threads either to abort, or to leave the
3801                          * domain. We can't do the latter, so we wait with a timeout.
3802                          */
3803                         wait_for_tids (&user_data.wait, 100);
3804                 }
3805
3806                 /* Update remaining time */
3807                 timeout -= mono_msec_ticks () - start_time;
3808                 start_time = mono_msec_ticks ();
3809
3810                 if (orig_timeout != -1 && timeout < 0)
3811                         return FALSE;
3812         }
3813         while (user_data.wait.num > 0);
3814
3815         THREAD_DEBUG (g_message ("%s: abort done", __func__));
3816
3817         return TRUE;
3818 }
3819
3820 static void
3821 clear_cached_culture (gpointer key, gpointer value, gpointer user_data)
3822 {
3823         MonoInternalThread *thread = (MonoInternalThread*)value;
3824         MonoDomain *domain = (MonoDomain*)user_data;
3825         int i;
3826
3827         /* No locking needed here */
3828         /* FIXME: why no locking? writes to the cache are protected with synch_cs above */
3829
3830         if (thread->cached_culture_info) {
3831                 for (i = 0; i < NUM_CACHED_CULTURES * 2; ++i) {
3832                         MonoObject *obj = mono_array_get (thread->cached_culture_info, MonoObject*, i);
3833                         if (obj && obj->vtable->domain == domain)
3834                                 mono_array_set (thread->cached_culture_info, MonoObject*, i, NULL);
3835                 }
3836         }
3837 }
3838
3839 /*
3840  * mono_threads_clear_cached_culture:
3841  *
3842  *   Clear the cached_current_culture from all threads if it is in the
3843  * given appdomain.
3844  */
3845 void
3846 mono_threads_clear_cached_culture (MonoDomain *domain)
3847 {
3848         mono_threads_lock ();
3849         mono_g_hash_table_foreach (threads, clear_cached_culture, domain);
3850         mono_threads_unlock ();
3851 }
3852
3853 /*
3854  * mono_thread_get_undeniable_exception:
3855  *
3856  *   Return an exception which needs to be raised when leaving a catch clause.
3857  * This is used for undeniable exception propagation.
3858  */
3859 MonoException*
3860 mono_thread_get_undeniable_exception (void)
3861 {
3862         MonoInternalThread *thread = mono_thread_internal_current ();
3863
3864         if (thread && thread->abort_exc && !is_running_protected_wrapper ()) {
3865                 /*
3866                  * FIXME: Clear the abort exception and return an AppDomainUnloaded
3867                  * exception if the thread no longer references a dying appdomain.
3868                  */
3869                 thread->abort_exc->trace_ips = NULL;
3870                 thread->abort_exc->stack_trace = NULL;
3871                 return thread->abort_exc;
3872         }
3873
3874         return NULL;
3875 }
3876
3877 #if MONO_SMALL_CONFIG
3878 #define NUM_STATIC_DATA_IDX 4
3879 static const int static_data_size [NUM_STATIC_DATA_IDX] = {
3880         64, 256, 1024, 4096
3881 };
3882 #else
3883 #define NUM_STATIC_DATA_IDX 8
3884 static const int static_data_size [NUM_STATIC_DATA_IDX] = {
3885         1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216
3886 };
3887 #endif
3888
3889 static MonoBitSet *thread_reference_bitmaps [NUM_STATIC_DATA_IDX];
3890 static MonoBitSet *context_reference_bitmaps [NUM_STATIC_DATA_IDX];
3891
3892 static void
3893 mark_slots (void *addr, MonoBitSet **bitmaps, MonoGCMarkFunc mark_func, void *gc_data)
3894 {
3895         gpointer *static_data = (gpointer *)addr;
3896
3897         for (int i = 0; i < NUM_STATIC_DATA_IDX; ++i) {
3898                 void **ptr = (void **)static_data [i];
3899
3900                 if (!ptr)
3901                         continue;
3902
3903                 MONO_BITSET_FOREACH (bitmaps [i], idx, {
3904                         void **p = ptr + idx;
3905
3906                         if (*p)
3907                                 mark_func ((MonoObject**)p, gc_data);
3908                 });
3909         }
3910 }
3911
3912 static void
3913 mark_tls_slots (void *addr, MonoGCMarkFunc mark_func, void *gc_data)
3914 {
3915         mark_slots (addr, thread_reference_bitmaps, mark_func, gc_data);
3916 }
3917
3918 static void
3919 mark_ctx_slots (void *addr, MonoGCMarkFunc mark_func, void *gc_data)
3920 {
3921         mark_slots (addr, context_reference_bitmaps, mark_func, gc_data);
3922 }
3923
3924 /*
3925  *  mono_alloc_static_data
3926  *
3927  *   Allocate memory blocks for storing threads or context static data
3928  */
3929 static void
3930 mono_alloc_static_data (gpointer **static_data_ptr, guint32 offset, gboolean threadlocal)
3931 {
3932         guint idx = ACCESS_SPECIAL_STATIC_OFFSET (offset, index);
3933         int i;
3934
3935         gpointer* static_data = *static_data_ptr;
3936         if (!static_data) {
3937                 static MonoGCDescriptor tls_desc = MONO_GC_DESCRIPTOR_NULL;
3938                 static MonoGCDescriptor ctx_desc = MONO_GC_DESCRIPTOR_NULL;
3939
3940                 if (mono_gc_user_markers_supported ()) {
3941                         if (tls_desc == MONO_GC_DESCRIPTOR_NULL)
3942                                 tls_desc = mono_gc_make_root_descr_user (mark_tls_slots);
3943
3944                         if (ctx_desc == MONO_GC_DESCRIPTOR_NULL)
3945                                 ctx_desc = mono_gc_make_root_descr_user (mark_ctx_slots);
3946                 }
3947
3948                 static_data = (void **)mono_gc_alloc_fixed (static_data_size [0], threadlocal ? tls_desc : ctx_desc,
3949                         threadlocal ? MONO_ROOT_SOURCE_THREAD_STATIC : MONO_ROOT_SOURCE_CONTEXT_STATIC,
3950                         threadlocal ? "managed thread-static variables" : "managed context-static variables");
3951                 *static_data_ptr = static_data;
3952                 static_data [0] = static_data;
3953         }
3954
3955         for (i = 1; i <= idx; ++i) {
3956                 if (static_data [i])
3957                         continue;
3958
3959                 if (mono_gc_user_markers_supported ())
3960                         static_data [i] = g_malloc0 (static_data_size [i]);
3961                 else
3962                         static_data [i] = mono_gc_alloc_fixed (static_data_size [i], MONO_GC_DESCRIPTOR_NULL,
3963                                 threadlocal ? MONO_ROOT_SOURCE_THREAD_STATIC : MONO_ROOT_SOURCE_CONTEXT_STATIC,
3964                                 threadlocal ? "managed thread-static variables" : "managed context-static variables");
3965         }
3966 }
3967
3968 static void
3969 mono_free_static_data (gpointer* static_data)
3970 {
3971         int i;
3972         for (i = 1; i < NUM_STATIC_DATA_IDX; ++i) {
3973                 gpointer p = static_data [i];
3974                 if (!p)
3975                         continue;
3976                 /*
3977                  * At this point, the static data pointer array is still registered with the
3978                  * GC, so must ensure that mark_tls_slots() will not encounter any invalid
3979                  * data.  Freeing the individual arrays without first nulling their slots
3980                  * would make it possible for mark_tls/ctx_slots() to encounter a pointer to
3981                  * such an already freed array.  See bug #13813.
3982                  */
3983                 static_data [i] = NULL;
3984                 mono_memory_write_barrier ();
3985                 if (mono_gc_user_markers_supported ())
3986                         g_free (p);
3987                 else
3988                         mono_gc_free_fixed (p);
3989         }
3990         mono_gc_free_fixed (static_data);
3991 }
3992
3993 /*
3994  *  mono_init_static_data_info
3995  *
3996  *   Initializes static data counters
3997  */
3998 static void mono_init_static_data_info (StaticDataInfo *static_data)
3999 {
4000         static_data->idx = 0;
4001         static_data->offset = 0;
4002         static_data->freelist = NULL;
4003 }
4004
4005 /*
4006  *  mono_alloc_static_data_slot
4007  *
4008  *   Generates an offset for static data. static_data contains the counters
4009  *  used to generate it.
4010  */
4011 static guint32
4012 mono_alloc_static_data_slot (StaticDataInfo *static_data, guint32 size, guint32 align)
4013 {
4014         if (!static_data->idx && !static_data->offset) {
4015                 /*
4016                  * we use the first chunk of the first allocation also as
4017                  * an array for the rest of the data
4018                  */
4019                 static_data->offset = sizeof (gpointer) * NUM_STATIC_DATA_IDX;
4020         }
4021         static_data->offset += align - 1;
4022         static_data->offset &= ~(align - 1);
4023         if (static_data->offset + size >= static_data_size [static_data->idx]) {
4024                 static_data->idx ++;
4025                 g_assert (size <= static_data_size [static_data->idx]);
4026                 g_assert (static_data->idx < NUM_STATIC_DATA_IDX);
4027                 static_data->offset = 0;
4028         }
4029         guint32 offset = MAKE_SPECIAL_STATIC_OFFSET (static_data->idx, static_data->offset, 0);
4030         static_data->offset += size;
4031         return offset;
4032 }
4033
4034 /*
4035  * LOCKING: requires that threads_mutex is held
4036  */
4037 static void
4038 context_adjust_static_data (MonoAppContext *ctx)
4039 {
4040         if (context_static_info.offset || context_static_info.idx > 0) {
4041                 guint32 offset = MAKE_SPECIAL_STATIC_OFFSET (context_static_info.idx, context_static_info.offset, 0);
4042                 mono_alloc_static_data (&ctx->static_data, offset, FALSE);
4043                 ctx->data->static_data = ctx->static_data;
4044         }
4045 }
4046
4047 /*
4048  * LOCKING: requires that threads_mutex is held
4049  */
4050 static void
4051 alloc_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
4052 {
4053         MonoInternalThread *thread = (MonoInternalThread *)value;
4054         guint32 offset = GPOINTER_TO_UINT (user);
4055
4056         mono_alloc_static_data (&(thread->static_data), offset, TRUE);
4057 }
4058
4059 /*
4060  * LOCKING: requires that threads_mutex is held
4061  */
4062 static void
4063 alloc_context_static_data_helper (gpointer key, gpointer value, gpointer user)
4064 {
4065         MonoAppContext *ctx = (MonoAppContext *) mono_gchandle_get_target (GPOINTER_TO_INT (key));
4066
4067         if (!ctx)
4068                 return;
4069
4070         guint32 offset = GPOINTER_TO_UINT (user);
4071         mono_alloc_static_data (&ctx->static_data, offset, FALSE);
4072         ctx->data->static_data = ctx->static_data;
4073 }
4074
4075 static StaticDataFreeList*
4076 search_slot_in_freelist (StaticDataInfo *static_data, guint32 size, guint32 align)
4077 {
4078         StaticDataFreeList* prev = NULL;
4079         StaticDataFreeList* tmp = static_data->freelist;
4080         while (tmp) {
4081                 if (tmp->size == size) {
4082                         if (prev)
4083                                 prev->next = tmp->next;
4084                         else
4085                                 static_data->freelist = tmp->next;
4086                         return tmp;
4087                 }
4088                 prev = tmp;
4089                 tmp = tmp->next;
4090         }
4091         return NULL;
4092 }
4093
4094 #if SIZEOF_VOID_P == 4
4095 #define ONE_P 1
4096 #else
4097 #define ONE_P 1ll
4098 #endif
4099
4100 static void
4101 update_reference_bitmap (MonoBitSet **sets, guint32 offset, uintptr_t *bitmap, int numbits)
4102 {
4103         int idx = ACCESS_SPECIAL_STATIC_OFFSET (offset, index);
4104         if (!sets [idx])
4105                 sets [idx] = mono_bitset_new (static_data_size [idx] / sizeof (uintptr_t), 0);
4106         MonoBitSet *rb = sets [idx];
4107         offset = ACCESS_SPECIAL_STATIC_OFFSET (offset, offset);
4108         offset /= sizeof (uintptr_t);
4109         /* offset is now the bitmap offset */
4110         for (int i = 0; i < numbits; ++i) {
4111                 if (bitmap [i / sizeof (uintptr_t)] & (ONE_P << (i & (sizeof (uintptr_t) * 8 -1))))
4112                         mono_bitset_set_fast (rb, offset + i);
4113         }
4114 }
4115
4116 static void
4117 clear_reference_bitmap (MonoBitSet **sets, guint32 offset, guint32 size)
4118 {
4119         int idx = ACCESS_SPECIAL_STATIC_OFFSET (offset, index);
4120         MonoBitSet *rb = sets [idx];
4121         offset = ACCESS_SPECIAL_STATIC_OFFSET (offset, offset);
4122         offset /= sizeof (uintptr_t);
4123         /* offset is now the bitmap offset */
4124         for (int i = 0; i < size / sizeof (uintptr_t); i++)
4125                 mono_bitset_clear_fast (rb, offset + i);
4126 }
4127
4128 guint32
4129 mono_alloc_special_static_data (guint32 static_type, guint32 size, guint32 align, uintptr_t *bitmap, int numbits)
4130 {
4131         g_assert (static_type == SPECIAL_STATIC_THREAD || static_type == SPECIAL_STATIC_CONTEXT);
4132
4133         StaticDataInfo *info;
4134         MonoBitSet **sets;
4135
4136         if (static_type == SPECIAL_STATIC_THREAD) {
4137                 info = &thread_static_info;
4138                 sets = thread_reference_bitmaps;
4139         } else {
4140                 info = &context_static_info;
4141                 sets = context_reference_bitmaps;
4142         }
4143
4144         mono_threads_lock ();
4145
4146         StaticDataFreeList *item = search_slot_in_freelist (info, size, align);
4147         guint32 offset;
4148
4149         if (item) {
4150                 offset = item->offset;
4151                 g_free (item);
4152         } else {
4153                 offset = mono_alloc_static_data_slot (info, size, align);
4154         }
4155
4156         update_reference_bitmap (sets, offset, bitmap, numbits);
4157
4158         if (static_type == SPECIAL_STATIC_THREAD) {
4159                 /* This can be called during startup */
4160                 if (threads != NULL)
4161                         mono_g_hash_table_foreach (threads, alloc_thread_static_data_helper, GUINT_TO_POINTER (offset));
4162         } else {
4163                 if (contexts != NULL)
4164                         g_hash_table_foreach (contexts, alloc_context_static_data_helper, GUINT_TO_POINTER (offset));
4165
4166                 ACCESS_SPECIAL_STATIC_OFFSET (offset, type) = SPECIAL_STATIC_OFFSET_TYPE_CONTEXT;
4167         }
4168
4169         mono_threads_unlock ();
4170
4171         return offset;
4172 }
4173
4174 gpointer
4175 mono_get_special_static_data_for_thread (MonoInternalThread *thread, guint32 offset)
4176 {
4177         guint32 static_type = ACCESS_SPECIAL_STATIC_OFFSET (offset, type);
4178
4179         if (static_type == SPECIAL_STATIC_OFFSET_TYPE_THREAD) {
4180                 return get_thread_static_data (thread, offset);
4181         } else {
4182                 return get_context_static_data (thread->current_appcontext, offset);
4183         }
4184 }
4185
4186 gpointer
4187 mono_get_special_static_data (guint32 offset)
4188 {
4189         return mono_get_special_static_data_for_thread (mono_thread_internal_current (), offset);
4190 }
4191
4192 typedef struct {
4193         guint32 offset;
4194         guint32 size;
4195 } OffsetSize;
4196
4197 /*
4198  * LOCKING: requires that threads_mutex is held
4199  */
4200 static void
4201 free_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
4202 {
4203         MonoInternalThread *thread = (MonoInternalThread *)value;
4204         OffsetSize *data = (OffsetSize *)user;
4205         int idx = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, index);
4206         int off = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, offset);
4207         char *ptr;
4208
4209         if (!thread->static_data || !thread->static_data [idx])
4210                 return;
4211         ptr = ((char*) thread->static_data [idx]) + off;
4212         mono_gc_bzero_atomic (ptr, data->size);
4213 }
4214
4215 /*
4216  * LOCKING: requires that threads_mutex is held
4217  */
4218 static void
4219 free_context_static_data_helper (gpointer key, gpointer value, gpointer user)
4220 {
4221         MonoAppContext *ctx = (MonoAppContext *) mono_gchandle_get_target (GPOINTER_TO_INT (key));
4222
4223         if (!ctx)
4224                 return;
4225
4226         OffsetSize *data = (OffsetSize *)user;
4227         int idx = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, index);
4228         int off = ACCESS_SPECIAL_STATIC_OFFSET (data->offset, offset);
4229         char *ptr;
4230
4231         if (!ctx->static_data || !ctx->static_data [idx])
4232                 return;
4233
4234         ptr = ((char*) ctx->static_data [idx]) + off;
4235         mono_gc_bzero_atomic (ptr, data->size);
4236 }
4237
4238 static void
4239 do_free_special_slot (guint32 offset, guint32 size)
4240 {
4241         guint32 static_type = ACCESS_SPECIAL_STATIC_OFFSET (offset, type);
4242         MonoBitSet **sets;
4243         StaticDataInfo *info;
4244
4245         if (static_type == SPECIAL_STATIC_OFFSET_TYPE_THREAD) {
4246                 info = &thread_static_info;
4247                 sets = thread_reference_bitmaps;
4248         } else {
4249                 info = &context_static_info;
4250                 sets = context_reference_bitmaps;
4251         }
4252
4253         guint32 data_offset = offset;
4254         ACCESS_SPECIAL_STATIC_OFFSET (data_offset, type) = 0;
4255         OffsetSize data = { data_offset, size };
4256
4257         clear_reference_bitmap (sets, data.offset, data.size);
4258
4259         if (static_type == SPECIAL_STATIC_OFFSET_TYPE_THREAD) {
4260                 if (threads != NULL)
4261                         mono_g_hash_table_foreach (threads, free_thread_static_data_helper, &data);
4262         } else {
4263                 if (contexts != NULL)
4264                         g_hash_table_foreach (contexts, free_context_static_data_helper, &data);
4265         }
4266
4267         if (!mono_runtime_is_shutting_down ()) {
4268                 StaticDataFreeList *item = g_new0 (StaticDataFreeList, 1);
4269
4270                 item->offset = offset;
4271                 item->size = size;
4272
4273                 item->next = info->freelist;
4274                 info->freelist = item;
4275         }
4276 }
4277
4278 static void
4279 do_free_special (gpointer key, gpointer value, gpointer data)
4280 {
4281         MonoClassField *field = (MonoClassField *)key;
4282         guint32 offset = GPOINTER_TO_UINT (value);
4283         gint32 align;
4284         guint32 size;
4285         size = mono_type_size (field->type, &align);
4286         do_free_special_slot (offset, size);
4287 }
4288
4289 void
4290 mono_alloc_special_static_data_free (GHashTable *special_static_fields)
4291 {
4292         mono_threads_lock ();
4293
4294         g_hash_table_foreach (special_static_fields, do_free_special, NULL);
4295
4296         mono_threads_unlock ();
4297 }
4298
4299 #ifdef HOST_WIN32
4300 static void CALLBACK dummy_apc (ULONG_PTR param)
4301 {
4302 }
4303 #endif
4304
4305 /*
4306  * mono_thread_execute_interruption
4307  *
4308  * Performs the operation that the requested thread state requires (abort,
4309  * suspend or stop)
4310  */
4311 static MonoException*
4312 mono_thread_execute_interruption (void)
4313 {
4314         MonoInternalThread *thread = mono_thread_internal_current ();
4315         MonoThread *sys_thread = mono_thread_current ();
4316
4317         LOCK_THREAD (thread);
4318
4319         /* MonoThread::interruption_requested can only be changed with atomics */
4320         if (InterlockedCompareExchange (&thread->interruption_requested, FALSE, TRUE)) {
4321                 /* this will consume pending APC calls */
4322 #ifdef HOST_WIN32
4323                 WaitForSingleObjectEx (GetCurrentThread(), 0, TRUE);
4324 #endif
4325                 InterlockedDecrement (&thread_interruption_requested);
4326
4327                 /* Clear the interrupted flag of the thread so it can wait again */
4328                 mono_thread_info_clear_self_interrupt ();
4329         }
4330
4331         /* If there's a pending exception and an AbortRequested, the pending exception takes precedence */
4332         if (sys_thread->pending_exception) {
4333                 MonoException *exc;
4334
4335                 exc = sys_thread->pending_exception;
4336                 sys_thread->pending_exception = NULL;
4337
4338                 UNLOCK_THREAD (thread);
4339                 return exc;
4340         } else if ((thread->state & ThreadState_AbortRequested) != 0) {
4341                 UNLOCK_THREAD (thread);
4342                 g_assert (sys_thread->pending_exception == NULL);
4343                 if (thread->abort_exc == NULL) {
4344                         /*
4345                          * This might be racy, but it has to be called outside the lock
4346                          * since it calls managed code.
4347                          */
4348                         MONO_OBJECT_SETREF (thread, abort_exc, mono_get_exception_thread_abort ());
4349                 }
4350                 return thread->abort_exc;
4351         }
4352         else if ((thread->state & ThreadState_SuspendRequested) != 0) {
4353                 /* calls UNLOCK_THREAD (thread) */
4354                 self_suspend_internal ();
4355                 return NULL;
4356         }
4357         else if ((thread->state & ThreadState_StopRequested) != 0) {
4358                 /* FIXME: do this through the JIT? */
4359
4360                 UNLOCK_THREAD (thread);
4361
4362                 mono_thread_exit ();
4363                 return NULL;
4364         } else if (thread->thread_interrupt_requested) {
4365
4366                 thread->thread_interrupt_requested = FALSE;
4367                 UNLOCK_THREAD (thread);
4368
4369                 return(mono_get_exception_thread_interrupted ());
4370         }
4371
4372         UNLOCK_THREAD (thread);
4373
4374         return NULL;
4375 }
4376
4377 /*
4378  * mono_thread_request_interruption
4379  *
4380  * A signal handler can call this method to request the interruption of a
4381  * thread. The result of the interruption will depend on the current state of
4382  * the thread. If the result is an exception that needs to be throw, it is
4383  * provided as return value.
4384  */
4385 MonoException*
4386 mono_thread_request_interruption (gboolean running_managed)
4387 {
4388         MonoInternalThread *thread = mono_thread_internal_current ();
4389
4390         /* The thread may already be stopping */
4391         if (thread == NULL)
4392                 return NULL;
4393
4394 #ifdef HOST_WIN32
4395         if (thread->interrupt_on_stop &&
4396                 thread->state & ThreadState_StopRequested &&
4397                 thread->state & ThreadState_Background)
4398                 ExitThread (1);
4399 #endif
4400         if (InterlockedCompareExchange (&thread->interruption_requested, 1, 0) == 1)
4401                 return NULL;
4402         InterlockedIncrement (&thread_interruption_requested);
4403
4404         if (!running_managed || is_running_protected_wrapper ()) {
4405                 /* Can't stop while in unmanaged code. Increase the global interruption
4406                    request count. When exiting the unmanaged method the count will be
4407                    checked and the thread will be interrupted. */
4408
4409                 /* this will awake the thread if it is in WaitForSingleObject
4410                    or similar */
4411                 /* Our implementation of this function ignores the func argument */
4412 #ifdef HOST_WIN32
4413                 QueueUserAPC ((PAPCFUNC)dummy_apc, thread->native_handle, (ULONG_PTR)NULL);
4414 #else
4415                 mono_thread_info_self_interrupt ();
4416 #endif
4417                 return NULL;
4418         }
4419         else {
4420                 return mono_thread_execute_interruption ();
4421         }
4422 }
4423
4424 /*This function should be called by a thread after it has exited all of
4425  * its handle blocks at interruption time.*/
4426 MonoException*
4427 mono_thread_resume_interruption (void)
4428 {
4429         MonoInternalThread *thread = mono_thread_internal_current ();
4430         gboolean still_aborting;
4431
4432         /* The thread may already be stopping */
4433         if (thread == NULL)
4434                 return NULL;
4435
4436         LOCK_THREAD (thread);
4437         still_aborting = (thread->state & (ThreadState_AbortRequested|ThreadState_StopRequested)) != 0;
4438         UNLOCK_THREAD (thread);
4439
4440         /*This can happen if the protected block called Thread::ResetAbort*/
4441         if (!still_aborting)
4442                 return FALSE;
4443
4444         if (InterlockedCompareExchange (&thread->interruption_requested, 1, 0) == 1)
4445                 return NULL;
4446         InterlockedIncrement (&thread_interruption_requested);
4447
4448         mono_thread_info_self_interrupt ();
4449
4450         return mono_thread_execute_interruption ();
4451 }
4452
4453 gboolean mono_thread_interruption_requested ()
4454 {
4455         if (thread_interruption_requested) {
4456                 MonoInternalThread *thread = mono_thread_internal_current ();
4457                 /* The thread may already be stopping */
4458                 if (thread != NULL)
4459                         return (thread->interruption_requested);
4460         }
4461         return FALSE;
4462 }
4463
4464 static MonoException*
4465 mono_thread_interruption_checkpoint_request (gboolean bypass_abort_protection)
4466 {
4467         MonoInternalThread *thread = mono_thread_internal_current ();
4468
4469         /* The thread may already be stopping */
4470         if (thread == NULL)
4471                 return NULL;
4472
4473         if (thread->interruption_requested && (bypass_abort_protection || !is_running_protected_wrapper ())) {
4474                 MonoException* exc = mono_thread_execute_interruption ();
4475                 if (exc)
4476                         return exc;
4477         }
4478         return NULL;
4479 }
4480
4481 /*
4482  * Performs the interruption of the current thread, if one has been requested,
4483  * and the thread is not running a protected wrapper.
4484  * Return the exception which needs to be thrown, if any.
4485  */
4486 MonoException*
4487 mono_thread_interruption_checkpoint (void)
4488 {
4489         return mono_thread_interruption_checkpoint_request (FALSE);
4490 }
4491
4492 /*
4493  * Performs the interruption of the current thread, if one has been requested.
4494  * Return the exception which needs to be thrown, if any.
4495  */
4496 MonoException*
4497 mono_thread_force_interruption_checkpoint_noraise (void)
4498 {
4499         return mono_thread_interruption_checkpoint_request (TRUE);
4500 }
4501
4502 /*
4503  * mono_set_pending_exception:
4504  *
4505  *   Set the pending exception of the current thread to EXC.
4506  * The exception will be thrown when execution returns to managed code.
4507  */
4508 void
4509 mono_set_pending_exception (MonoException *exc)
4510 {
4511         MonoThread *thread = mono_thread_current ();
4512
4513         /* The thread may already be stopping */
4514         if (thread == NULL)
4515                 return;
4516
4517         MONO_OBJECT_SETREF (thread, pending_exception, exc);
4518
4519     mono_thread_request_interruption (FALSE);
4520 }
4521
4522 /**
4523  * mono_thread_interruption_request_flag:
4524  *
4525  * Returns the address of a flag that will be non-zero if an interruption has
4526  * been requested for a thread. The thread to interrupt may not be the current
4527  * thread, so an additional call to mono_thread_interruption_requested() or
4528  * mono_thread_interruption_checkpoint() is allways needed if the flag is not
4529  * zero.
4530  */
4531 gint32* mono_thread_interruption_request_flag ()
4532 {
4533         return &thread_interruption_requested;
4534 }
4535
4536 void
4537 mono_thread_init_apartment_state (void)
4538 {
4539 #ifdef HOST_WIN32
4540         MonoInternalThread* thread = mono_thread_internal_current ();
4541
4542         /* Positive return value indicates success, either
4543          * S_OK if this is first CoInitialize call, or
4544          * S_FALSE if CoInitialize already called, but with same
4545          * threading model. A negative value indicates failure,
4546          * probably due to trying to change the threading model.
4547          */
4548         if (CoInitializeEx(NULL, (thread->apartment_state == ThreadApartmentState_STA)
4549                         ? COINIT_APARTMENTTHREADED
4550                         : COINIT_MULTITHREADED) < 0) {
4551                 thread->apartment_state = ThreadApartmentState_Unknown;
4552         }
4553 #endif
4554 }
4555
4556 void
4557 mono_thread_cleanup_apartment_state (void)
4558 {
4559 #ifdef HOST_WIN32
4560         MonoInternalThread* thread = mono_thread_internal_current ();
4561
4562         if (thread && thread->apartment_state != ThreadApartmentState_Unknown) {
4563                 CoUninitialize ();
4564         }
4565 #endif
4566 }
4567
4568 void
4569 mono_thread_set_state (MonoInternalThread *thread, MonoThreadState state)
4570 {
4571         LOCK_THREAD (thread);
4572         thread->state |= state;
4573         UNLOCK_THREAD (thread);
4574 }
4575
4576 /**
4577  * mono_thread_test_and_set_state:
4578  *
4579  * Test if current state of @thread include @test. If it does not, OR @set into the state.
4580  *
4581  * Returns TRUE is @set was OR'd in.
4582  */
4583 gboolean
4584 mono_thread_test_and_set_state (MonoInternalThread *thread, MonoThreadState test, MonoThreadState set)
4585 {
4586         LOCK_THREAD (thread);
4587
4588         if ((thread->state & test) != 0) {
4589                 UNLOCK_THREAD (thread);
4590                 return FALSE;
4591         }
4592
4593         thread->state |= set;
4594         UNLOCK_THREAD (thread);
4595
4596         return TRUE;
4597 }
4598
4599 void
4600 mono_thread_clr_state (MonoInternalThread *thread, MonoThreadState state)
4601 {
4602         LOCK_THREAD (thread);
4603         thread->state &= ~state;
4604         UNLOCK_THREAD (thread);
4605 }
4606
4607 gboolean
4608 mono_thread_test_state (MonoInternalThread *thread, MonoThreadState test)
4609 {
4610         gboolean ret = FALSE;
4611
4612         LOCK_THREAD (thread);
4613
4614         if ((thread->state & test) != 0) {
4615                 ret = TRUE;
4616         }
4617
4618         UNLOCK_THREAD (thread);
4619
4620         return ret;
4621 }
4622
4623 static gboolean has_tls_get = FALSE;
4624
4625 void
4626 mono_runtime_set_has_tls_get (gboolean val)
4627 {
4628         has_tls_get = val;
4629 }
4630
4631 gboolean
4632 mono_runtime_has_tls_get (void)
4633 {
4634         return has_tls_get;
4635 }
4636
4637 static void
4638 self_interrupt_thread (void *_unused)
4639 {
4640         MonoException *exc;
4641         MonoThreadInfo *info;
4642
4643         exc = mono_thread_execute_interruption ();
4644         if (!exc) {
4645                 if (mono_threads_is_coop_enabled ()) {
4646                         /* We can return from an async call in coop, as
4647                          * it's simply called when exiting the safepoint */
4648                         return;
4649                 }
4650
4651                 g_error ("%s: we can't resume from an async call", __func__);
4652         }
4653
4654         info = mono_thread_info_current ();
4655
4656         /* We must use _with_context since we didn't trampoline into the runtime */
4657         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. */
4658 }
4659
4660 static gboolean
4661 mono_jit_info_match (MonoJitInfo *ji, gpointer ip)
4662 {
4663         if (!ji)
4664                 return FALSE;
4665         return ji->code_start <= ip && (char*)ip < (char*)ji->code_start + ji->code_size;
4666 }
4667
4668 static gboolean
4669 last_managed (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
4670 {
4671         MonoJitInfo **dest = (MonoJitInfo **)data;
4672         *dest = frame->ji;
4673         return TRUE;
4674 }
4675
4676 static MonoJitInfo*
4677 mono_thread_info_get_last_managed (MonoThreadInfo *info)
4678 {
4679         MonoJitInfo *ji = NULL;
4680         if (!info)
4681                 return NULL;
4682
4683         /*
4684          * The suspended thread might be holding runtime locks. Make sure we don't try taking
4685          * any runtime locks while unwinding. In coop case we shouldn't safepoint in regions
4686          * where we hold runtime locks.
4687          */
4688         if (!mono_threads_is_coop_enabled ())
4689                 mono_thread_info_set_is_async_context (TRUE);
4690         mono_get_eh_callbacks ()->mono_walk_stack_with_state (last_managed, mono_thread_info_get_suspend_state (info), MONO_UNWIND_SIGNAL_SAFE, &ji);
4691         if (!mono_threads_is_coop_enabled ())
4692                 mono_thread_info_set_is_async_context (FALSE);
4693         return ji;
4694 }
4695
4696 typedef struct {
4697         MonoInternalThread *thread;
4698         gboolean install_async_abort;
4699         MonoThreadInfoInterruptToken *interrupt_token;
4700 } AbortThreadData;
4701
4702 static SuspendThreadResult
4703 async_abort_critical (MonoThreadInfo *info, gpointer ud)
4704 {
4705         AbortThreadData *data = (AbortThreadData *)ud;
4706         MonoInternalThread *thread = data->thread;
4707         MonoJitInfo *ji = NULL;
4708         gboolean protected_wrapper;
4709         gboolean running_managed;
4710
4711         if (mono_get_eh_callbacks ()->mono_install_handler_block_guard (mono_thread_info_get_suspend_state (info)))
4712                 return MonoResumeThread;
4713
4714         /*
4715         The target thread is running at least one protected block, which must not be interrupted, so we give up.
4716         The protected block code will give them a chance when appropriate.
4717         */
4718         if (thread->abort_protected_block_count)
4719                 return MonoResumeThread;
4720
4721         /*someone is already interrupting it*/
4722         if (InterlockedCompareExchange (&thread->interruption_requested, 1, 0) == 1)
4723                 return MonoResumeThread;
4724
4725         InterlockedIncrement (&thread_interruption_requested);
4726
4727         ji = mono_thread_info_get_last_managed (info);
4728         protected_wrapper = ji && !ji->is_trampoline && !ji->async && mono_threads_is_critical_method (mono_jit_info_get_method (ji));
4729         running_managed = mono_jit_info_match (ji, MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx));
4730
4731         if (!protected_wrapper && running_managed) {
4732                 /*We are in managed code*/
4733                 /*Set the thread to call */
4734                 if (data->install_async_abort)
4735                         mono_thread_info_setup_async_call (info, self_interrupt_thread, NULL);
4736                 return MonoResumeThread;
4737         } else {
4738                 /*
4739                  * This will cause waits to be broken.
4740                  * It will also prevent the thread from entering a wait, so if the thread returns
4741                  * from the wait before it receives the abort signal, it will just spin in the wait
4742                  * functions in the io-layer until the signal handler calls QueueUserAPC which will
4743                  * make it return.
4744                  */
4745                 data->interrupt_token = mono_thread_info_prepare_interrupt (info);
4746
4747                 return MonoResumeThread;
4748         }
4749 }
4750
4751 static void
4752 async_abort_internal (MonoInternalThread *thread, gboolean install_async_abort)
4753 {
4754         AbortThreadData data;
4755
4756         g_assert (thread != mono_thread_internal_current ());
4757
4758         data.thread = thread;
4759         data.install_async_abort = install_async_abort;
4760         data.interrupt_token = NULL;
4761
4762         mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), TRUE, async_abort_critical, &data);
4763         if (data.interrupt_token)
4764                 mono_thread_info_finish_interrupt (data.interrupt_token);
4765         /*FIXME we need to wait for interruption to complete -- figure out how much into interruption we should wait for here*/
4766 }
4767
4768 static void
4769 self_abort_internal (MonoError *error)
4770 {
4771         MonoException *exc;
4772
4773         mono_error_init (error);
4774
4775         /* FIXME this is insanely broken, it doesn't cause interruption to happen synchronously
4776          * since passing FALSE to mono_thread_request_interruption makes sure it returns NULL */
4777
4778         /*
4779         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.
4780         */
4781         exc = mono_thread_request_interruption (TRUE);
4782         if (exc)
4783                 mono_error_set_exception_instance (error, exc);
4784         else
4785                 mono_thread_info_self_interrupt ();
4786 }
4787
4788 typedef struct {
4789         MonoInternalThread *thread;
4790         gboolean interrupt;
4791         MonoThreadInfoInterruptToken *interrupt_token;
4792 } SuspendThreadData;
4793
4794 static SuspendThreadResult
4795 async_suspend_critical (MonoThreadInfo *info, gpointer ud)
4796 {
4797         SuspendThreadData *data = (SuspendThreadData *)ud;
4798         MonoInternalThread *thread = data->thread;
4799         MonoJitInfo *ji = NULL;
4800         gboolean protected_wrapper;
4801         gboolean running_managed;
4802
4803         ji = mono_thread_info_get_last_managed (info);
4804         protected_wrapper = ji && !ji->is_trampoline && !ji->async && mono_threads_is_critical_method (mono_jit_info_get_method (ji));
4805         running_managed = mono_jit_info_match (ji, MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx));
4806
4807         if (running_managed && !protected_wrapper) {
4808                 if (mono_threads_is_coop_enabled ()) {
4809                         mono_thread_info_setup_async_call (info, self_interrupt_thread, NULL);
4810                         return MonoResumeThread;
4811                 } else {
4812                         thread->state &= ~ThreadState_SuspendRequested;
4813                         thread->state |= ThreadState_Suspended;
4814                         return KeepSuspended;
4815                 }
4816         } else {
4817                 if (InterlockedCompareExchange (&thread->interruption_requested, 1, 0) == 0)
4818                         InterlockedIncrement (&thread_interruption_requested);
4819                 if (data->interrupt)
4820                         data->interrupt_token = mono_thread_info_prepare_interrupt ((MonoThreadInfo *)thread->thread_info);
4821
4822                 return MonoResumeThread;
4823         }
4824 }
4825
4826 /* LOCKING: called with @thread synch_cs held, and releases it */
4827 static void
4828 async_suspend_internal (MonoInternalThread *thread, gboolean interrupt)
4829 {
4830         SuspendThreadData data;
4831
4832         g_assert (thread != mono_thread_internal_current ());
4833
4834         // MOSTLY_ASYNC_SAFE_PRINTF ("ASYNC SUSPEND thread %p\n", thread_get_tid (thread));
4835
4836         data.thread = thread;
4837         data.interrupt = interrupt;
4838         data.interrupt_token = NULL;
4839
4840         mono_thread_info_safe_suspend_and_run (thread_get_tid (thread), interrupt, async_suspend_critical, &data);
4841         if (data.interrupt_token)
4842                 mono_thread_info_finish_interrupt (data.interrupt_token);
4843
4844         UNLOCK_THREAD (thread);
4845 }
4846
4847 /* LOCKING: called with @thread synch_cs held, and releases it */
4848 static void
4849 self_suspend_internal (void)
4850 {
4851         MonoInternalThread *thread;
4852
4853         thread = mono_thread_internal_current ();
4854
4855         // MOSTLY_ASYNC_SAFE_PRINTF ("SELF SUSPEND thread %p\n", thread_get_tid (thread));
4856
4857         if (!mono_threads_is_coop_enabled ())
4858                 mono_thread_info_begin_self_suspend ();
4859
4860         thread->state &= ~ThreadState_SuspendRequested;
4861         thread->state |= ThreadState_Suspended;
4862
4863         UNLOCK_THREAD (thread);
4864
4865         if (!mono_threads_is_coop_enabled ())
4866                 mono_thread_info_end_self_suspend ();
4867         else {
4868                 MonoOSEvent *event;
4869                 MonoOSEventWaitRet res;
4870
4871                 event = thread->suspended;
4872
4873                 MONO_ENTER_GC_SAFE;
4874                 res = mono_os_event_wait_one (event, MONO_INFINITE_WAIT);
4875                 g_assert (res == MONO_OS_EVENT_WAIT_RET_SUCCESS_0);
4876                 MONO_EXIT_GC_SAFE;
4877         }
4878 }
4879
4880 /*
4881  * mono_thread_is_foreign:
4882  * @thread: the thread to query
4883  *
4884  * This function allows one to determine if a thread was created by the mono runtime and has
4885  * a well defined lifecycle or it's a foreigh one, created by the native environment.
4886  *
4887  * Returns: TRUE if @thread was not created by the runtime.
4888  */
4889 mono_bool
4890 mono_thread_is_foreign (MonoThread *thread)
4891 {
4892         MonoThreadInfo *info = (MonoThreadInfo *)thread->internal_thread->thread_info;
4893         return info->runtime_thread == FALSE;
4894 }
4895
4896 /*
4897  * mono_add_joinable_thread:
4898  *
4899  *   Add TID to the list of joinable threads.
4900  * LOCKING: Acquires the threads lock.
4901  */
4902 void
4903 mono_threads_add_joinable_thread (gpointer tid)
4904 {
4905 #ifndef HOST_WIN32
4906         /*
4907          * We cannot detach from threads because it causes problems like
4908          * 2fd16f60/r114307. So we collect them and join them when
4909          * we have time (in he finalizer thread).
4910          */
4911         joinable_threads_lock ();
4912         if (!joinable_threads)
4913                 joinable_threads = g_hash_table_new (NULL, NULL);
4914         g_hash_table_insert (joinable_threads, tid, tid);
4915         joinable_thread_count ++;
4916         joinable_threads_unlock ();
4917
4918         mono_gc_finalize_notify ();
4919 #endif
4920 }
4921
4922 /*
4923  * mono_threads_join_threads:
4924  *
4925  *   Join all joinable threads. This is called from the finalizer thread.
4926  * LOCKING: Acquires the threads lock.
4927  */
4928 void
4929 mono_threads_join_threads (void)
4930 {
4931 #ifndef HOST_WIN32
4932         GHashTableIter iter;
4933         gpointer key;
4934         gpointer tid;
4935         pthread_t thread;
4936         gboolean found;
4937
4938         /* Fastpath */
4939         if (!joinable_thread_count)
4940                 return;
4941
4942         while (TRUE) {
4943                 joinable_threads_lock ();
4944                 found = FALSE;
4945                 if (g_hash_table_size (joinable_threads)) {
4946                         g_hash_table_iter_init (&iter, joinable_threads);
4947                         g_hash_table_iter_next (&iter, &key, (void**)&tid);
4948                         thread = (pthread_t)tid;
4949                         g_hash_table_remove (joinable_threads, key);
4950                         joinable_thread_count --;
4951                         found = TRUE;
4952                 }
4953                 joinable_threads_unlock ();
4954                 if (found) {
4955                         if (thread != pthread_self ()) {
4956                                 MONO_ENTER_GC_SAFE;
4957                                 /* This shouldn't block */
4958                                 mono_native_thread_join (thread);
4959                                 MONO_EXIT_GC_SAFE;
4960                         }
4961                 } else {
4962                         break;
4963                 }
4964         }
4965 #endif
4966 }
4967
4968 /*
4969  * mono_thread_join:
4970  *
4971  *   Wait for thread TID to exit.
4972  * LOCKING: Acquires the threads lock.
4973  */
4974 void
4975 mono_thread_join (gpointer tid)
4976 {
4977 #ifndef HOST_WIN32
4978         pthread_t thread;
4979         gboolean found = FALSE;
4980
4981         joinable_threads_lock ();
4982         if (!joinable_threads)
4983                 joinable_threads = g_hash_table_new (NULL, NULL);
4984         if (g_hash_table_lookup (joinable_threads, tid)) {
4985                 g_hash_table_remove (joinable_threads, tid);
4986                 joinable_thread_count --;
4987                 found = TRUE;
4988         }
4989         joinable_threads_unlock ();
4990         if (!found)
4991                 return;
4992         thread = (pthread_t)tid;
4993         MONO_ENTER_GC_SAFE;
4994         mono_native_thread_join (thread);
4995         MONO_EXIT_GC_SAFE;
4996 #endif
4997 }
4998
4999 void
5000 mono_thread_internal_check_for_interruption_critical (MonoInternalThread *thread)
5001 {
5002         if ((thread->state & (ThreadState_StopRequested | ThreadState_SuspendRequested)) != 0)
5003                 mono_thread_interruption_checkpoint ();
5004 }
5005
5006 void
5007 mono_thread_internal_unhandled_exception (MonoObject* exc)
5008 {
5009         MonoClass *klass = exc->vtable->klass;
5010         if (is_threadabort_exception (klass)) {
5011                 mono_thread_internal_reset_abort (mono_thread_internal_current ());
5012         } else if (!is_appdomainunloaded_exception (klass)
5013                 && mono_runtime_unhandled_exception_policy_get () == MONO_UNHANDLED_POLICY_CURRENT) {
5014                 mono_unhandled_exception (exc);
5015                 if (mono_environment_exitcode_get () == 1) {
5016                         mono_environment_exitcode_set (255);
5017                         mono_invoke_unhandled_exception_hook (exc);
5018                         g_assert_not_reached ();
5019                 }
5020         }
5021 }
5022
5023 void
5024 ves_icall_System_Threading_Thread_GetStackTraces (MonoArray **out_threads, MonoArray **out_stack_traces)
5025 {
5026         MonoError error;
5027         mono_threads_get_thread_dump (out_threads, out_stack_traces, &error);
5028         mono_error_set_pending_exception (&error);
5029 }
5030
5031 /*
5032  * mono_threads_attach_coop: called by native->managed wrappers
5033  *
5034  * In non-coop mode:
5035  *  - @dummy: is NULL
5036  *  - @return: the original domain which needs to be restored, or NULL.
5037  *
5038  * In coop mode:
5039  *  - @dummy: contains the original domain
5040  *  - @return: a cookie containing current MonoThreadInfo*.
5041  */
5042 gpointer
5043 mono_threads_attach_coop (MonoDomain *domain, gpointer *dummy)
5044 {
5045         MonoDomain *orig;
5046         gboolean fresh_thread = FALSE;
5047
5048         if (!domain) {
5049                 /* Happens when called from AOTed code which is only used in the root domain. */
5050                 domain = mono_get_root_domain ();
5051         }
5052
5053         g_assert (domain);
5054
5055         /* On coop, when we detached, we moved the thread from  RUNNING->BLOCKING.
5056          * If we try to reattach we do a BLOCKING->RUNNING transition.  If the thread
5057          * is fresh, mono_thread_attach() will do a STARTING->RUNNING transition so
5058          * we're only responsible for making the cookie. */
5059         if (mono_threads_is_coop_enabled ()) {
5060                 MonoThreadInfo *info = mono_thread_info_current_unchecked ();
5061                 fresh_thread = !info || !mono_thread_info_is_live (info);
5062         }
5063
5064         if (!mono_thread_internal_current ()) {
5065                 mono_thread_attach_full (domain, FALSE);
5066
5067                 // #678164
5068                 mono_thread_set_state (mono_thread_internal_current (), ThreadState_Background);
5069         }
5070
5071         orig = mono_domain_get ();
5072         if (orig != domain)
5073                 mono_domain_set (domain, TRUE);
5074
5075         if (!mono_threads_is_coop_enabled ())
5076                 return orig != domain ? orig : NULL;
5077
5078         if (fresh_thread) {
5079                 *dummy = NULL;
5080                 /* mono_thread_attach put the thread in RUNNING mode from STARTING, but we need to
5081                  * return the right cookie. */
5082                 return mono_threads_enter_gc_unsafe_region_cookie ();
5083         } else {
5084                 *dummy = orig;
5085                 /* thread state (BLOCKING|RUNNING) -> RUNNING */
5086                 return mono_threads_enter_gc_unsafe_region (dummy);
5087         }
5088 }
5089
5090 /*
5091  * mono_threads_detach_coop: called by native->managed wrappers
5092  *
5093  * In non-coop mode:
5094  *  - @cookie: the original domain which needs to be restored, or NULL.
5095  *  - @dummy: is NULL
5096  *
5097  * In coop mode:
5098  *  - @cookie: contains current MonoThreadInfo* if it was in BLOCKING mode, NULL otherwise
5099  *  - @dummy: contains the original domain
5100  */
5101 void
5102 mono_threads_detach_coop (gpointer cookie, gpointer *dummy)
5103 {
5104         MonoDomain *domain, *orig;
5105
5106         if (!mono_threads_is_coop_enabled ()) {
5107                 orig = (MonoDomain*) cookie;
5108                 if (orig)
5109                         mono_domain_set (orig, TRUE);
5110         } else {
5111                 orig = (MonoDomain*) *dummy;
5112
5113                 domain = mono_domain_get ();
5114                 g_assert (domain);
5115
5116                 /* it won't do anything if cookie is NULL
5117                  * thread state RUNNING -> (RUNNING|BLOCKING) */
5118                 mono_threads_exit_gc_unsafe_region (cookie, dummy);
5119
5120                 if (orig != domain) {
5121                         if (!orig)
5122                                 mono_domain_unset ();
5123                         else
5124                                 mono_domain_set (orig, TRUE);
5125                 }
5126         }
5127 }
5128
5129 void
5130 mono_threads_begin_abort_protected_block (void)
5131 {
5132         MonoInternalThread *thread;
5133
5134         thread = mono_thread_internal_current ();
5135         ++thread->abort_protected_block_count;
5136         mono_memory_barrier ();
5137 }
5138
5139 void
5140 mono_threads_end_abort_protected_block (void)
5141 {
5142         MonoInternalThread *thread;
5143
5144         thread = mono_thread_internal_current ();
5145
5146         mono_memory_barrier ();
5147         --thread->abort_protected_block_count;
5148 }
5149
5150 MonoException*
5151 mono_thread_try_resume_interruption (void)
5152 {
5153         MonoInternalThread *thread;
5154
5155         thread = mono_thread_internal_current ();
5156         if (thread->abort_protected_block_count || mono_get_eh_callbacks ()->mono_current_thread_has_handle_block_guard ())
5157                 return NULL;
5158
5159         return mono_thread_resume_interruption ();
5160 }
5161
5162 #if 0
5163 /* Returns TRUE if the current thread is ready to be interrupted. */
5164 gboolean
5165 mono_threads_is_ready_to_be_interrupted (void)
5166 {
5167         MonoInternalThread *thread;
5168
5169         thread = mono_thread_internal_current ();
5170         LOCK_THREAD (thread);
5171         if (thread->state & (MonoThreadState)(ThreadState_StopRequested | ThreadState_SuspendRequested | ThreadState_AbortRequested)) {
5172                 UNLOCK_THREAD (thread);
5173                 return FALSE;
5174         }
5175
5176         if (thread->abort_protected_block_count || mono_get_eh_callbacks ()->mono_current_thread_has_handle_block_guard ()) {
5177                 UNLOCK_THREAD (thread);
5178                 return FALSE;
5179         }
5180
5181         UNLOCK_THREAD (thread);
5182         return TRUE;
5183 }
5184 #endif
5185
5186 void
5187 mono_thread_internal_describe (MonoInternalThread *internal, GString *text)
5188 {
5189         g_string_append_printf (text, ", thread handle : %p", internal->handle);
5190
5191         if (internal->thread_info) {
5192                 g_string_append (text, ", state : ");
5193                 mono_thread_info_describe_interrupt_token ((MonoThreadInfo*) internal->thread_info, text);
5194         }
5195
5196         if (internal->owned_mutexes) {
5197                 int i;
5198
5199                 g_string_append (text, ", owns : [");
5200                 for (i = 0; i < internal->owned_mutexes->len; i++)
5201                         g_string_append_printf (text, i == 0 ? "%p" : ", %p", g_ptr_array_index (internal->owned_mutexes, i));
5202                 g_string_append (text, "]");
5203         }
5204 }
5205
5206 gboolean
5207 mono_thread_internal_is_current (MonoInternalThread *internal)
5208 {
5209         g_assert (internal);
5210         return mono_native_thread_id_equals (mono_native_thread_id_get (), MONO_UINT_TO_NATIVE_THREAD_ID (internal->tid));
5211 }