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