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