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