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