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