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