mono/metadata/threads.c

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