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  * (C) 2001 Ximian, Inc.
  10  */
  11
  12 #include <config.h>
  13 #ifdef PLATFORM_WIN32
  14 #define _WIN32_WINNT 0x0500
  15 #endif
  16
  17 #include <glib.h>
  18 #include <signal.h>
  19 #include <string.h>
  20
  21 #include <mono/metadata/object.h>
  22 #include <mono/metadata/domain-internals.h>
  23 #include <mono/metadata/profiler-private.h>
  24 #include <mono/metadata/threads.h>
  25 #include <mono/metadata/threadpool.h>
  26 #include <mono/metadata/threads-types.h>
  27 #include <mono/metadata/exception.h>
  28 #include <mono/metadata/environment.h>
  29 #include <mono/metadata/monitor.h>
  30 #include <mono/metadata/gc-internal.h>
  31 #include <mono/metadata/marshal.h>
  32 #include <mono/io-layer/io-layer.h>
  33 #include <mono/metadata/object-internals.h>
  34 #include <mono/metadata/mono-debug-debugger.h>
  35 #include <mono/utils/mono-compiler.h>
  36
  37 #include <mono/os/gc_wrapper.h>
  38
  39 /*#define THREAD_DEBUG(a) do { a; } while (0)*/
  40 #define THREAD_DEBUG(a)
  41 /*#define THREAD_WAIT_DEBUG(a) do { a; } while (0)*/
  42 #define THREAD_WAIT_DEBUG(a)
  43 /*#define LIBGC_DEBUG(a) do { a; } while (0)*/
  44 #define LIBGC_DEBUG(a)
  45
  46 /* Provide this for systems with glib < 2.6 */
  47 #ifndef G_GSIZE_FORMAT
  48 #   if GLIB_SIZEOF_LONG == 8
  49 #       define G_GSIZE_FORMAT "lu"
  50 #   else
  51 #       define G_GSIZE_FORMAT "u"
  52 #   endif
  53 #endif
  54
  55 struct StartInfo
  56 {
  57         guint32 (*func)(void *);
  58         MonoThread *obj;
  59         MonoObject *delegate;
  60         void *start_arg;
  61         MonoDomain *domain;
  62 };
  63
  64 typedef union {
  65         gint32 ival;
  66         gfloat fval;
  67 } IntFloatUnion;
  68
  69 typedef union {
  70         gint64 ival;
  71         gdouble fval;
  72 } LongDoubleUnion;
  73
  74 typedef struct {
  75         int idx;
  76         int offset;
  77 } StaticDataInfo;
  78
  79 /* Number of cached culture objects in the MonoThread->cached_culture_info array
  80  * (per-type): we use the first NUM entries for CultureInfo and the last for
  81  * UICultureInfo. So the size of the array is really NUM_CACHED_CULTURES * 2.
  82  */
  83 #define NUM_CACHED_CULTURES 4
  84 #define CULTURES_START_IDX 0
  85 #define UICULTURES_START_IDX NUM_CACHED_CULTURES
  86
  87 /*
  88  * The "os_handle" field of the WaitHandle class.
  89  */
  90 static MonoClassField *wait_handle_os_handle_field = NULL;
  91
  92 /* Controls access to the 'threads' hash table */
  93 #define mono_threads_lock() EnterCriticalSection (&threads_mutex)
  94 #define mono_threads_unlock() LeaveCriticalSection (&threads_mutex)
  95 static CRITICAL_SECTION threads_mutex;
  96
  97 /* Controls access to context static data */
  98 #define mono_contexts_lock() EnterCriticalSection (&contexts_mutex)
  99 #define mono_contexts_unlock() LeaveCriticalSection (&contexts_mutex)
 100 static CRITICAL_SECTION contexts_mutex;
 101
 102 /* Holds current status of static data heap */
 103 static StaticDataInfo thread_static_info;
 104 static StaticDataInfo context_static_info;
 105
 106 /* The hash of existing threads (key is thread ID) that need joining
 107  * before exit
 108  */
 109 static MonoGHashTable *threads=NULL;
 110
 111 /* The TLS key that holds the MonoObject assigned to each thread */
 112 static guint32 current_object_key = -1;
 113
 114 #ifdef HAVE_KW_THREAD
 115 /* we need to use both the Tls* functions and __thread because
 116  * the gc needs to see all the threads
 117  */
 118 static __thread MonoThread * tls_current_object MONO_TLS_FAST;
 119 #define SET_CURRENT_OBJECT(x) do { \
 120         tls_current_object = x; \
 121         TlsSetValue (current_object_key, x); \
 122 } while (FALSE)
 123 #define GET_CURRENT_OBJECT() tls_current_object
 124 #else
 125 #define SET_CURRENT_OBJECT(x) TlsSetValue (current_object_key, x);
 126 #define GET_CURRENT_OBJECT() (MonoThread*) TlsGetValue (current_object_key);
 127 #endif
 128
 129 /* function called at thread start */
 130 static MonoThreadStartCB mono_thread_start_cb = NULL;
 131
 132 /* function called at thread attach */
 133 static MonoThreadAttachCB mono_thread_attach_cb = NULL;
 134
 135 /* function called at thread cleanup */
 136 static MonoThreadCleanupFunc mono_thread_cleanup_fn = NULL;
 137
 138 /* The default stack size for each thread */
 139 static guint32 default_stacksize = 0;
 140 #define default_stacksize_for_thread(thread) ((thread)->stack_size? (thread)->stack_size: default_stacksize)
 141
 142 static void thread_adjust_static_data (MonoThread *thread);
 143 static void mono_init_static_data_info (StaticDataInfo *static_data);
 144 static guint32 mono_alloc_static_data_slot (StaticDataInfo *static_data, guint32 size, guint32 align);
 145 static gboolean mono_thread_resume (MonoThread* thread);
 146 static void mono_thread_start (MonoThread *thread);
 147
 148 /* Spin lock for InterlockedXXX 64 bit functions */
 149 #define mono_interlocked_lock() EnterCriticalSection (&interlocked_mutex)
 150 #define mono_interlocked_unlock() LeaveCriticalSection (&interlocked_mutex)
 151 static CRITICAL_SECTION interlocked_mutex;
 152
 153 /* global count of thread interruptions requested */
 154 static gint32 thread_interruption_requested = 0;
 155
 156 /* Event signaled when a thread changes its background mode */
 157 static HANDLE background_change_event;
 158
 159 guint32
 160 mono_thread_get_tls_key (void)
 161 {
 162         return current_object_key;
 163 }
 164
 165 gint32
 166 mono_thread_get_tls_offset (void)
 167 {
 168         int offset;
 169         MONO_THREAD_VAR_OFFSET (tls_current_object,offset);
 170         return offset;
 171 }
 172
 173 /* handle_store() and handle_remove() manage the array of threads that
 174  * still need to be waited for when the main thread exits.
 175  */
 176 static void handle_store(MonoThread *thread)
 177 {
 178         mono_threads_lock ();
 179
 180         THREAD_DEBUG (g_message ("%s: thread %p ID %"G_GSIZE_FORMAT, __func__, thread, (gsize)thread->tid));
 181
 182         if(threads==NULL) {
 183                 MONO_GC_REGISTER_ROOT (threads);
 184                 threads=mono_g_hash_table_new(NULL, NULL);
 185         }
 186
 187         /* We don't need to duplicate thread->handle, because it is
 188          * only closed when the thread object is finalized by the GC.
 189          */
 190         mono_g_hash_table_insert(threads, (gpointer)(gsize)(thread->tid),
 191                                  thread);
 192
 193         mono_threads_unlock ();
 194 }
 195
 196 static void handle_remove(gsize tid)
 197 {
 198         THREAD_DEBUG (g_message ("%s: thread ID %"G_GSIZE_FORMAT, __func__, tid));
 199
 200         mono_threads_lock ();
 201
 202
 203         if (threads)
 204                 mono_g_hash_table_remove (threads, (gpointer)tid);
 205
 206         mono_threads_unlock ();
 207
 208         /* Don't close the handle here, wait for the object finalizer
 209          * to do it. Otherwise, the following race condition applies:
 210          *
 211          * 1) Thread exits (and handle_remove() closes the handle)
 212          *
 213          * 2) Some other handle is reassigned the same slot
 214          *
 215          * 3) Another thread tries to join the first thread, and
 216          * blocks waiting for the reassigned handle to be signalled
 217          * (which might never happen).  This is possible, because the
 218          * thread calling Join() still has a reference to the first
 219          * thread's object.
 220          */
 221 }
 222
 223 static void thread_cleanup (MonoThread *thread)
 224 {
 225         g_assert (thread != NULL);
 226
 227         mono_release_type_locks (thread);
 228
 229         if (!mono_monitor_enter (thread->synch_lock))
 230                 return;
 231
 232         thread->state |= ThreadState_Stopped;
 233         mono_monitor_exit (thread->synch_lock);
 234
 235         mono_profiler_thread_end (thread->tid);
 236         handle_remove (thread->tid);
 237
 238         mono_thread_pop_appdomain_ref ();
 239
 240         if (thread->serialized_culture_info)
 241                 g_free (thread->serialized_culture_info);
 242
 243         thread->cached_culture_info = NULL;
 244
 245         if (mono_thread_cleanup_fn)
 246                 mono_thread_cleanup_fn (thread);
 247 }
 248
 249 static guint32 WINAPI start_wrapper(void *data)
 250 {
 251         struct StartInfo *start_info=(struct StartInfo *)data;
 252         guint32 (*start_func)(void *);
 253         void *start_arg;
 254         gsize tid;
 255         MonoThread *thread=start_info->obj;
 256         MonoObject *start_delegate = start_info->delegate;
 257
 258         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Start wrapper", __func__, GetCurrentThreadId ()));
 259
 260         /* We can be sure start_info->obj->tid and
 261          * start_info->obj->handle have been set, because the thread
 262          * was created suspended, and these values were set before the
 263          * thread resumed
 264          */
 265
 266         tid=thread->tid;
 267
 268         SET_CURRENT_OBJECT (thread);
 269
 270         if (!mono_domain_set (start_info->domain, FALSE)) {
 271                 /* No point in raising an appdomain_unloaded exception here */
 272                 /* FIXME: Cleanup here */
 273                 return 0;
 274         }
 275
 276         start_func = start_info->func;
 277         start_arg = start_info->start_arg;
 278
 279         /* This MUST be called before any managed code can be
 280          * executed, as it calls the callback function that (for the
 281          * jit) sets the lmf marker.
 282          */
 283         mono_thread_new_init (tid, &tid, start_func);
 284         thread->stack_ptr = &tid;
 285
 286         LIBGC_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT",%d) Setting thread stack to %p", __func__, GetCurrentThreadId (), getpid (), thread->stack_ptr));
 287
 288         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Setting current_object_key to %p", __func__, GetCurrentThreadId (), thread));
 289
 290         mono_profiler_thread_start (tid);
 291
 292         if(thread->start_notify!=NULL) {
 293                 /* Let the thread that called Start() know we're
 294                  * ready
 295                  */
 296                 ReleaseSemaphore (thread->start_notify, 1, NULL);
 297         }
 298
 299         g_free (start_info);
 300
 301         /* Every thread references the appdomain which created it */
 302         mono_thread_push_appdomain_ref (mono_domain_get ());
 303
 304         thread_adjust_static_data (thread);
 305 #ifdef DEBUG
 306         g_message ("%s: start_wrapper for %"G_GSIZE_FORMAT, __func__,
 307                    thread->tid);
 308 #endif
 309
 310         /* start_func is set only for unamanged start functions */
 311         if (start_func) {
 312                 start_func (start_arg);
 313         } else {
 314                 void *args [1];
 315                 g_assert (start_delegate != NULL);
 316                 args [0] = start_arg;
 317                 /* we may want to handle the exception here. See comment below on unhandled exceptions */
 318                 mono_runtime_delegate_invoke (start_delegate, args, NULL);
 319         }
 320
 321         /* If the thread calls ExitThread at all, this remaining code
 322          * will not be executed, but the main thread will eventually
 323          * call thread_cleanup() on this thread's behalf.
 324          */
 325
 326         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Start wrapper terminating", __func__, GetCurrentThreadId ()));
 327
 328         /* Remove the reference to the thread object in the TLS data,
 329          * so the thread object can be finalized.  This won't be
 330          * reached if the thread threw an uncaught exception, so those
 331          * thread handles will stay referenced :-( (This is due to
 332          * missing support for scanning thread-specific data in the
 333          * Boehm GC - the io-layer keeps a GC-visible hash of pointers
 334          * to TLS data.)
 335          */
 336         SET_CURRENT_OBJECT (NULL);
 337
 338         thread_cleanup (thread);
 339
 340         return(0);
 341 }
 342
 343 void mono_thread_new_init (gsize tid, gpointer stack_start, gpointer func)
 344 {
 345         if (mono_thread_start_cb) {
 346                 mono_thread_start_cb (tid, stack_start, func);
 347         }
 348 }
 349
 350 void mono_threads_set_default_stacksize (guint32 stacksize)
 351 {
 352         default_stacksize = stacksize;
 353 }
 354
 355 guint32 mono_threads_get_default_stacksize (void)
 356 {
 357         return default_stacksize;
 358 }
 359
 360 void mono_thread_create (MonoDomain *domain, gpointer func, gpointer arg)
 361 {
 362         MonoThread *thread;
 363         HANDLE thread_handle;
 364         struct StartInfo *start_info;
 365         gsize tid;
 366
 367         thread=(MonoThread *)mono_object_new (domain,
 368                                               mono_defaults.thread_class);
 369
 370         start_info=g_new0 (struct StartInfo, 1);
 371         start_info->func = func;
 372         start_info->obj = thread;
 373         start_info->domain = domain;
 374         start_info->start_arg = arg;
 375
 376         /* Create suspended, so we can do some housekeeping before the thread
 377          * starts
 378          */
 379         thread_handle = CreateThread(NULL, default_stacksize_for_thread (thread), (LPTHREAD_START_ROUTINE)start_wrapper, start_info,
 380                                      CREATE_SUSPENDED, &tid);
 381         THREAD_DEBUG (g_message ("%s: Started thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, tid, thread_handle));
 382         if (thread_handle == NULL) {
 383                 /* The thread couldn't be created, so throw an exception */
 384                 mono_raise_exception (mono_get_exception_execution_engine ("Couldn't create thread"));
 385                 return;
 386         }
 387
 388         thread->handle=thread_handle;
 389         thread->tid=tid;
 390
 391         MONO_OBJECT_SETREF (thread, synch_lock, mono_object_new (domain, mono_defaults.object_class));
 392
 393         handle_store(thread);
 394
 395         ResumeThread (thread_handle);
 396 }
 397
 398 MonoThread *
 399 mono_thread_attach (MonoDomain *domain)
 400 {
 401         MonoThread *thread;
 402         HANDLE thread_handle;
 403         gsize tid;
 404
 405         if ((thread = mono_thread_current ())) {
 406                 if (domain != mono_domain_get ())
 407                         mono_domain_set (domain, TRUE);
 408                 /* Already attached */
 409                 return thread;
 410         }
 411
 412         if (!mono_gc_register_thread (&domain)) {
 413                 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 ());
 414         }
 415
 416         thread = (MonoThread *)mono_object_new (domain,
 417                                                 mono_defaults.thread_class);
 418
 419         thread_handle = GetCurrentThread ();
 420         g_assert (thread_handle);
 421
 422         tid=GetCurrentThreadId ();
 423
 424         /*
 425          * The handle returned by GetCurrentThread () is a pseudo handle, so it can't be used to
 426          * refer to the thread from other threads for things like aborting.
 427          */
 428         DuplicateHandle (GetCurrentProcess (), thread_handle, GetCurrentProcess (), &thread_handle,
 429                                          THREAD_ALL_ACCESS, TRUE, 0);
 430
 431         thread->handle=thread_handle;
 432         thread->tid=tid;
 433         thread->stack_ptr = &tid;
 434         MONO_OBJECT_SETREF (thread, synch_lock, mono_object_new (domain, mono_defaults.object_class));
 435
 436         THREAD_DEBUG (g_message ("%s: Attached thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, tid, thread_handle));
 437
 438         handle_store(thread);
 439
 440         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Setting current_object_key to %p", __func__, GetCurrentThreadId (), thread));
 441
 442         SET_CURRENT_OBJECT (thread);
 443         mono_domain_set (domain, TRUE);
 444
 445         thread_adjust_static_data (thread);
 446
 447         if (mono_thread_attach_cb) {
 448                 mono_thread_attach_cb (tid, &tid);
 449         }
 450
 451         return(thread);
 452 }
 453
 454 void
 455 mono_thread_detach (MonoThread *thread)
 456 {
 457         g_return_if_fail (thread != NULL);
 458
 459         THREAD_DEBUG (g_message ("%s: mono_thread_detach for %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
 460         SET_CURRENT_OBJECT (NULL);
 461
 462         thread_cleanup (thread);
 463
 464         /* Don't need to CloseHandle this thread, even though we took a
 465          * reference in mono_thread_attach (), because the GC will do it
 466          * when the Thread object is finalised.
 467          */
 468 }
 469
 470 void
 471 mono_thread_exit ()
 472 {
 473         MonoThread *thread = mono_thread_current ();
 474
 475         SET_CURRENT_OBJECT (NULL);
 476         thread_cleanup (thread);
 477
 478         /* we could add a callback here for embedders to use. */
 479         if (thread == mono_thread_get_main ())
 480                 exit (mono_environment_exitcode_get ());
 481         ExitThread (-1);
 482 }
 483
 484 HANDLE ves_icall_System_Threading_Thread_Thread_internal(MonoThread *this,
 485                                                          MonoObject *start)
 486 {
 487         guint32 (*start_func)(void *);
 488         struct StartInfo *start_info;
 489         HANDLE thread;
 490         gsize tid;
 491
 492         MONO_ARCH_SAVE_REGS;
 493
 494         THREAD_DEBUG (g_message("%s: Trying to start a new thread: this (%p) start (%p)", __func__, this, start));
 495
 496         mono_monitor_enter (this->synch_lock);
 497
 498         if ((this->state & ThreadState_Unstarted) == 0) {
 499                 mono_monitor_exit (this->synch_lock);
 500                 mono_raise_exception (mono_get_exception_thread_state ("Thread has already been started."));
 501                 return NULL;
 502         }
 503
 504         if ((this->state & ThreadState_Aborted) != 0) {
 505                 mono_monitor_exit (this->synch_lock);
 506                 return this;
 507         }
 508         start_func = NULL;
 509         {
 510                 /* This is freed in start_wrapper */
 511                 start_info = g_new0 (struct StartInfo, 1);
 512                 start_info->func = start_func;
 513                 start_info->start_arg = this->start_obj; /* FIXME: GC object stored in unmanaged memory */
 514                 start_info->delegate = start;
 515                 start_info->obj = this;
 516                 start_info->domain = mono_domain_get ();
 517
 518                 this->start_notify=CreateSemaphore (NULL, 0, 0x7fffffff, NULL);
 519                 if(this->start_notify==NULL) {
 520                         mono_monitor_exit (this->synch_lock);
 521                         g_warning ("%s: CreateSemaphore error 0x%x", __func__, GetLastError ());
 522                         return(NULL);
 523                 }
 524
 525                 thread=CreateThread(NULL, default_stacksize_for_thread (this), (LPTHREAD_START_ROUTINE)start_wrapper, start_info,
 526                                     CREATE_SUSPENDED, &tid);
 527                 if(thread==NULL) {
 528                         mono_monitor_exit (this->synch_lock);
 529                         g_warning("%s: CreateThread error 0x%x", __func__, GetLastError());
 530                         return(NULL);
 531                 }
 532
 533                 this->handle=thread;
 534                 this->tid=tid;
 535
 536                 /* Don't call handle_store() here, delay it to Start.
 537                  * We can't join a thread (trying to will just block
 538                  * forever) until it actually starts running, so don't
 539                  * store the handle till then.
 540                  */
 541
 542                 mono_thread_start (this);
 543
 544                 this->state &= ~ThreadState_Unstarted;
 545
 546                 THREAD_DEBUG (g_message ("%s: Started thread ID %"G_GSIZE_FORMAT" (handle %p)", __func__, tid, thread));
 547
 548                 mono_monitor_exit (this->synch_lock);
 549                 return(thread);
 550         }
 551 }
 552
 553 void ves_icall_System_Threading_Thread_Thread_free_internal (MonoThread *this,
 554                                                              HANDLE thread)
 555 {
 556         MONO_ARCH_SAVE_REGS;
 557
 558         THREAD_DEBUG (g_message ("%s: Closing thread %p, handle %p", __func__, this, thread));
 559
 560         CloseHandle (thread);
 561 }
 562
 563 static void mono_thread_start (MonoThread *thread)
 564 {
 565         MONO_ARCH_SAVE_REGS;
 566
 567         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Launching thread %p (%"G_GSIZE_FORMAT")", __func__, GetCurrentThreadId (), thread, (gsize)thread->tid));
 568
 569         /* Only store the handle when the thread is about to be
 570          * launched, to avoid the main thread deadlocking while trying
 571          * to clean up a thread that will never be signalled.
 572          */
 573         handle_store (thread);
 574
 575         ResumeThread (thread->handle);
 576
 577         if(thread->start_notify!=NULL) {
 578                 /* Wait for the thread to set up its TLS data etc, so
 579                  * theres no potential race condition if someone tries
 580                  * to look up the data believing the thread has
 581                  * started
 582                  */
 583
 584                 THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") waiting for thread %p (%"G_GSIZE_FORMAT") to start", __func__, GetCurrentThreadId (), thread, (gsize)thread->tid));
 585
 586                 WaitForSingleObjectEx (thread->start_notify, INFINITE, FALSE);
 587                 CloseHandle (thread->start_notify);
 588                 thread->start_notify = NULL;
 589         }
 590
 591         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Done launching thread %p (%"G_GSIZE_FORMAT")", __func__, GetCurrentThreadId (), thread, (gsize)thread->tid));
 592 }
 593
 594 void ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms)
 595 {
 596         MonoThread *thread = mono_thread_current ();
 597
 598         MONO_ARCH_SAVE_REGS;
 599
 600         THREAD_DEBUG (g_message ("%s: Sleeping for %d ms", __func__, ms));
 601
 602         mono_monitor_enter (thread->synch_lock);
 603         thread->state |= ThreadState_WaitSleepJoin;
 604         mono_monitor_exit (thread->synch_lock);
 605
 606         SleepEx(ms,TRUE);
 607
 608         mono_monitor_enter (thread->synch_lock);
 609         thread->state &= ~ThreadState_WaitSleepJoin;
 610         mono_monitor_exit (thread->synch_lock);
 611 }
 612
 613 gint32
 614 ves_icall_System_Threading_Thread_GetDomainID (void)
 615 {
 616         MONO_ARCH_SAVE_REGS;
 617
 618         return mono_domain_get()->domain_id;
 619 }
 620
 621 MonoString*
 622 ves_icall_System_Threading_Thread_GetName_internal (MonoThread *this_obj)
 623 {
 624         MonoString* str;
 625         mono_monitor_enter (this_obj->synch_lock);
 626
 627         if (!this_obj->name)
 628                 str = NULL;
 629         else
 630                 str = mono_string_new_utf16 (mono_domain_get (), this_obj->name, this_obj->name_len);
 631
 632         mono_monitor_exit (this_obj->synch_lock);
 633         return str;
 634 }
 635
 636 void
 637 ves_icall_System_Threading_Thread_SetName_internal (MonoThread *this_obj, MonoString *name)
 638 {
 639         mono_monitor_enter (this_obj->synch_lock);
 640
 641         if (this_obj->name) {
 642                 mono_monitor_exit (this_obj->synch_lock);
 643                 mono_raise_exception (mono_get_exception_invalid_operation ("Thread.Name can only be set once."));
 644                 return;
 645         }
 646         if (name) {
 647                 this_obj->name = g_new (gunichar2, mono_string_length (name));
 648                 memcpy (this_obj->name, mono_string_chars (name), mono_string_length (name) * 2);
 649                 this_obj->name_len = mono_string_length (name);
 650         }
 651         else
 652                 this_obj->name = NULL;
 653
 654         mono_monitor_exit (this_obj->synch_lock);
 655 }
 656
 657 static MonoObject*
 658 lookup_cached_culture (MonoThread *this, MonoDomain *domain, int start_idx)
 659 {
 660         MonoObject *res;
 661         int i;
 662
 663         if (this->cached_culture_info) {
 664                 domain = mono_domain_get ();
 665                 for (i = start_idx; i < start_idx + NUM_CACHED_CULTURES; ++i) {
 666                         res = mono_array_get (this->cached_culture_info, MonoObject*, i);
 667                         if (res && res->vtable->domain == domain)
 668                                 return res;
 669                 }
 670         }
 671
 672         return NULL;
 673 }
 674
 675 MonoObject*
 676 ves_icall_System_Threading_Thread_GetCachedCurrentCulture (MonoThread *this)
 677 {
 678         return lookup_cached_culture (this, mono_domain_get (), CULTURES_START_IDX);
 679 }
 680
 681 MonoArray*
 682 ves_icall_System_Threading_Thread_GetSerializedCurrentCulture (MonoThread *this)
 683 {
 684         MonoArray *res;
 685
 686         mono_monitor_enter (this->synch_lock);
 687         if (this->serialized_culture_info) {
 688                 res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, this->serialized_culture_info_len);
 689                 memcpy (mono_array_addr (res, guint8, 0), this->serialized_culture_info, this->serialized_culture_info_len);
 690         } else {
 691                 res = NULL;
 692         }
 693         mono_monitor_exit (this->synch_lock);
 694
 695         return res;
 696 }
 697
 698 static void
 699 cache_culture (MonoThread *this, MonoObject *culture, int start_idx)
 700 {
 701         int i;
 702         MonoDomain *domain = mono_domain_get ();
 703         MonoObject *obj;
 704         int free_slot = -1;
 705         int same_domain_slot = -1;
 706
 707         mono_monitor_enter (this->synch_lock);
 708         if (!this->cached_culture_info)
 709                 this->cached_culture_info = mono_array_new (mono_object_domain (this), mono_defaults.object_class, NUM_CACHED_CULTURES * 2);
 710
 711         for (i = start_idx; i < start_idx + NUM_CACHED_CULTURES; ++i) {
 712                 obj = mono_array_get (this->cached_culture_info, MonoObject*, i);
 713                 /* Free entry */
 714                 if (!obj) {
 715                         free_slot = i;
 716                         /* we continue, because there may be a slot used with the same domain */
 717                         continue;
 718                 }
 719                 /* Replace */
 720                 if (obj->vtable->domain == domain) {
 721                         same_domain_slot = i;
 722                         break;
 723                 }
 724         }
 725         if (same_domain_slot >= 0)
 726                 mono_array_setref (this->cached_culture_info, same_domain_slot, culture);
 727         else if (free_slot >= 0)
 728                 mono_array_setref (this->cached_culture_info, free_slot, culture);
 729         /* we may want to replace an existing entry here, even when no suitable slot is found */
 730         mono_monitor_exit (this->synch_lock);
 731 }
 732
 733 void
 734 ves_icall_System_Threading_Thread_SetCachedCurrentCulture (MonoThread *this, MonoObject *culture)
 735 {
 736         cache_culture (this, culture, CULTURES_START_IDX);
 737 }
 738
 739 void
 740 ves_icall_System_Threading_Thread_SetSerializedCurrentCulture (MonoThread *this, MonoArray *arr)
 741 {
 742         mono_monitor_enter (this->synch_lock);
 743         if (this->serialized_culture_info)
 744                 g_free (this->serialized_culture_info);
 745         this->serialized_culture_info = g_new0 (guint8, mono_array_length (arr));
 746         this->serialized_culture_info_len = mono_array_length (arr);
 747         memcpy (this->serialized_culture_info, mono_array_addr (arr, guint8, 0), mono_array_length (arr));
 748         mono_monitor_exit (this->synch_lock);
 749 }
 750
 751
 752 MonoObject*
 753 ves_icall_System_Threading_Thread_GetCachedCurrentUICulture (MonoThread *this)
 754 {
 755         return lookup_cached_culture (this, mono_domain_get (), UICULTURES_START_IDX);
 756 }
 757
 758 MonoArray*
 759 ves_icall_System_Threading_Thread_GetSerializedCurrentUICulture (MonoThread *this)
 760 {
 761         MonoArray *res;
 762
 763         mono_monitor_enter (this->synch_lock);
 764         if (this->serialized_ui_culture_info) {
 765                 res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, this->serialized_ui_culture_info_len);
 766                 memcpy (mono_array_addr (res, guint8, 0), this->serialized_ui_culture_info, this->serialized_ui_culture_info_len);
 767         } else {
 768                 res = NULL;
 769         }
 770         mono_monitor_exit (this->synch_lock);
 771
 772         return res;
 773 }
 774
 775 void
 776 ves_icall_System_Threading_Thread_SetCachedCurrentUICulture (MonoThread *this, MonoObject *culture)
 777 {
 778         cache_culture (this, culture, UICULTURES_START_IDX);
 779 }
 780
 781 void
 782 ves_icall_System_Threading_Thread_SetSerializedCurrentUICulture (MonoThread *this, MonoArray *arr)
 783 {
 784         mono_monitor_enter (this->synch_lock);
 785         if (this->serialized_ui_culture_info)
 786                 g_free (this->serialized_ui_culture_info);
 787         this->serialized_ui_culture_info = g_new0 (guint8, mono_array_length (arr));
 788         this->serialized_ui_culture_info_len = mono_array_length (arr);
 789         memcpy (this->serialized_ui_culture_info, mono_array_addr (arr, guint8, 0), mono_array_length (arr));
 790         mono_monitor_exit (this->synch_lock);
 791 }
 792
 793 /* the jit may read the compiled code of this function */
 794 MonoThread *
 795 mono_thread_current (void)
 796 {
 797         THREAD_DEBUG (g_message ("%s: returning %p", __func__, GET_CURRENT_OBJECT ()));
 798         return GET_CURRENT_OBJECT ();
 799 }
 800
 801 gboolean ves_icall_System_Threading_Thread_Join_internal(MonoThread *this,
 802                                                          int ms, HANDLE thread)
 803 {
 804         gboolean ret;
 805
 806         MONO_ARCH_SAVE_REGS;
 807
 808         mono_monitor_enter (this->synch_lock);
 809
 810         if ((this->state & ThreadState_Unstarted) != 0) {
 811                 mono_monitor_exit (this->synch_lock);
 812                 mono_raise_exception (mono_get_exception_thread_state ("Thread has not been started."));
 813                 return FALSE;
 814         }
 815
 816         this->state |= ThreadState_WaitSleepJoin;
 817         mono_monitor_exit (this->synch_lock);
 818
 819         if(ms== -1) {
 820                 ms=INFINITE;
 821         }
 822         THREAD_DEBUG (g_message ("%s: joining thread handle %p, %d ms", __func__, thread, ms));
 823
 824         ret=WaitForSingleObjectEx (thread, ms, TRUE);
 825
 826         mono_monitor_enter (this->synch_lock);
 827         this->state &= ~ThreadState_WaitSleepJoin;
 828         mono_monitor_exit (this->synch_lock);
 829
 830         if(ret==WAIT_OBJECT_0) {
 831                 THREAD_DEBUG (g_message ("%s: join successful", __func__));
 832
 833                 return(TRUE);
 834         }
 835
 836         THREAD_DEBUG (g_message ("%s: join failed", __func__));
 837
 838         return(FALSE);
 839 }
 840
 841 /* FIXME: exitContext isnt documented */
 842 gboolean ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext)
 843 {
 844         HANDLE *handles;
 845         guint32 numhandles;
 846         guint32 ret;
 847         guint32 i;
 848         MonoObject *waitHandle;
 849         MonoClass *klass;
 850         MonoThread *thread = mono_thread_current ();
 851
 852         MONO_ARCH_SAVE_REGS;
 853
 854         numhandles = mono_array_length(mono_handles);
 855         handles = g_new0(HANDLE, numhandles);
 856
 857         if (wait_handle_os_handle_field == 0) {
 858                 /* Get the field os_handle which will contain the actual handle */
 859                 klass = mono_class_from_name(mono_defaults.corlib, "System.Threading", "WaitHandle");
 860                 wait_handle_os_handle_field = mono_class_get_field_from_name(klass, "os_handle");
 861         }
 862
 863         for(i = 0; i < numhandles; i++) {
 864                 waitHandle = mono_array_get(mono_handles, MonoObject*, i);
 865                 mono_field_get_value(waitHandle, wait_handle_os_handle_field, &handles[i]);
 866         }
 867
 868         if(ms== -1) {
 869                 ms=INFINITE;
 870         }
 871
 872         mono_monitor_enter (thread->synch_lock);
 873         thread->state |= ThreadState_WaitSleepJoin;
 874         mono_monitor_exit (thread->synch_lock);
 875
 876         ret=WaitForMultipleObjectsEx(numhandles, handles, TRUE, ms, TRUE);
 877
 878         mono_monitor_enter (thread->synch_lock);
 879         thread->state &= ~ThreadState_WaitSleepJoin;
 880         mono_monitor_exit (thread->synch_lock);
 881
 882         g_free(handles);
 883
 884         if(ret==WAIT_FAILED) {
 885                 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Wait failed", __func__, GetCurrentThreadId ()));
 886                 return(FALSE);
 887         } else if(ret==WAIT_TIMEOUT || ret == WAIT_IO_COMPLETION) {
 888                 /* Do we want to try again if we get
 889                  * WAIT_IO_COMPLETION? The documentation for
 890                  * WaitHandle doesn't give any clues.  (We'd have to
 891                  * fiddle with the timeout if we retry.)
 892                  */
 893                 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Wait timed out", __func__, GetCurrentThreadId ()));
 894                 return(FALSE);
 895         }
 896
 897         return(TRUE);
 898 }
 899
 900 /* FIXME: exitContext isnt documented */
 901 gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext)
 902 {
 903         HANDLE *handles;
 904         guint32 numhandles;
 905         guint32 ret;
 906         guint32 i;
 907         MonoObject *waitHandle;
 908         MonoClass *klass;
 909         MonoThread *thread = mono_thread_current ();
 910
 911         MONO_ARCH_SAVE_REGS;
 912
 913         numhandles = mono_array_length(mono_handles);
 914         handles = g_new0(HANDLE, numhandles);
 915
 916         if (wait_handle_os_handle_field == 0) {
 917                 /* Get the field os_handle which will contain the actual handle */
 918                 klass = mono_class_from_name(mono_defaults.corlib, "System.Threading", "WaitHandle");
 919                 wait_handle_os_handle_field = mono_class_get_field_from_name(klass, "os_handle");
 920         }
 921
 922         for(i = 0; i < numhandles; i++) {
 923                 waitHandle = mono_array_get(mono_handles, MonoObject*, i);
 924                 mono_field_get_value(waitHandle, wait_handle_os_handle_field, &handles[i]);
 925         }
 926
 927         if(ms== -1) {
 928                 ms=INFINITE;
 929         }
 930
 931         mono_monitor_enter (thread->synch_lock);
 932         thread->state |= ThreadState_WaitSleepJoin;
 933         mono_monitor_exit (thread->synch_lock);
 934
 935         ret=WaitForMultipleObjectsEx(numhandles, handles, FALSE, ms, TRUE);
 936
 937         mono_monitor_enter (thread->synch_lock);
 938         thread->state &= ~ThreadState_WaitSleepJoin;
 939         mono_monitor_exit (thread->synch_lock);
 940
 941         g_free(handles);
 942
 943         THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") returning %d", __func__, GetCurrentThreadId (), ret));
 944
 945         /*
 946          * These need to be here.  See MSDN dos on WaitForMultipleObjects.
 947          */
 948         if (ret >= WAIT_OBJECT_0 && ret <= WAIT_OBJECT_0 + numhandles - 1) {
 949                 return ret - WAIT_OBJECT_0;
 950         }
 951         else if (ret >= WAIT_ABANDONED_0 && ret <= WAIT_ABANDONED_0 + numhandles - 1) {
 952                 return ret - WAIT_ABANDONED_0;
 953         }
 954         else {
 955                 return ret;
 956         }
 957 }
 958
 959 /* FIXME: exitContext isnt documented */
 960 gboolean ves_icall_System_Threading_WaitHandle_WaitOne_internal(MonoObject *this, HANDLE handle, gint32 ms, gboolean exitContext)
 961 {
 962         guint32 ret;
 963         MonoThread *thread = mono_thread_current ();
 964
 965         MONO_ARCH_SAVE_REGS;
 966
 967         THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") waiting for %p, %d ms", __func__, GetCurrentThreadId (), handle, ms));
 968
 969         if(ms== -1) {
 970                 ms=INFINITE;
 971         }
 972
 973         mono_monitor_enter (thread->synch_lock);
 974         thread->state |= ThreadState_WaitSleepJoin;
 975         mono_monitor_exit (thread->synch_lock);
 976
 977         ret=WaitForSingleObjectEx (handle, ms, TRUE);
 978
 979         mono_monitor_enter (thread->synch_lock);
 980         thread->state &= ~ThreadState_WaitSleepJoin;
 981         mono_monitor_exit (thread->synch_lock);
 982
 983         if(ret==WAIT_FAILED) {
 984                 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Wait failed", __func__, GetCurrentThreadId ()));
 985                 return(FALSE);
 986         } else if(ret==WAIT_TIMEOUT || ret == WAIT_IO_COMPLETION) {
 987                 /* Do we want to try again if we get
 988                  * WAIT_IO_COMPLETION? The documentation for
 989                  * WaitHandle doesn't give any clues.  (We'd have to
 990                  * fiddle with the timeout if we retry.)
 991                  */
 992                 THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Wait timed out", __func__, GetCurrentThreadId ()));
 993                 return(FALSE);
 994         }
 995
 996         return(TRUE);
 997 }
 998
 999 HANDLE ves_icall_System_Threading_Mutex_CreateMutex_internal (MonoBoolean owned, MonoString *name, MonoBoolean *created)
1000 {
1001         HANDLE mutex;
1002
1003         MONO_ARCH_SAVE_REGS;
1004
1005         *created = TRUE;
1006
1007         if (name == NULL) {
1008                 mutex = CreateMutex (NULL, owned, NULL);
1009         } else {
1010                 mutex = CreateMutex (NULL, owned, mono_string_chars (name));
1011
1012                 if (GetLastError () == ERROR_ALREADY_EXISTS) {
1013                         *created = FALSE;
1014                 }
1015         }
1016
1017         return(mutex);
1018 }
1019
1020 void ves_icall_System_Threading_Mutex_ReleaseMutex_internal (HANDLE handle ) {
1021         MONO_ARCH_SAVE_REGS;
1022
1023         ReleaseMutex(handle);
1024 }
1025
1026 HANDLE ves_icall_System_Threading_Mutex_OpenMutex_internal (MonoString *name,
1027                                                             gint32 rights,
1028                                                             gint32 *error)
1029 {
1030         HANDLE ret;
1031
1032         MONO_ARCH_SAVE_REGS;
1033
1034         *error = ERROR_SUCCESS;
1035
1036         ret = OpenMutex (rights, FALSE, mono_string_chars (name));
1037         if (ret == NULL) {
1038                 *error = GetLastError ();
1039         }
1040
1041         return(ret);
1042 }
1043
1044
1045 HANDLE ves_icall_System_Threading_Semaphore_CreateSemaphore_internal (gint32 initialCount, gint32 maximumCount, MonoString *name, MonoBoolean *created)
1046 {
1047         HANDLE sem;
1048
1049         MONO_ARCH_SAVE_REGS;
1050
1051         *created = TRUE;
1052
1053         if (name == NULL) {
1054                 sem = CreateSemaphore (NULL, initialCount, maximumCount, NULL);
1055         } else {
1056                 sem = CreateSemaphore (NULL, initialCount, maximumCount,
1057                                        mono_string_chars (name));
1058
1059                 if (GetLastError () == ERROR_ALREADY_EXISTS) {
1060                         *created = FALSE;
1061                 }
1062         }
1063
1064         return(sem);
1065 }
1066
1067 gint32 ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal (HANDLE handle, gint32 releaseCount, MonoBoolean *fail)
1068 {
1069         gint32 prevcount;
1070
1071         MONO_ARCH_SAVE_REGS;
1072
1073         *fail = !ReleaseSemaphore (handle, releaseCount, &prevcount);
1074
1075         return (prevcount);
1076 }
1077
1078 HANDLE ves_icall_System_Threading_Semaphore_OpenSemaphore_internal (MonoString *name, gint32 rights, gint32 *error)
1079 {
1080         HANDLE ret;
1081
1082         MONO_ARCH_SAVE_REGS;
1083
1084         *error = ERROR_SUCCESS;
1085
1086         ret = OpenSemaphore (rights, FALSE, mono_string_chars (name));
1087         if (ret == NULL) {
1088                 *error = GetLastError ();
1089         }
1090
1091         return(ret);
1092 }
1093
1094 HANDLE ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual, MonoBoolean initial, MonoString *name, MonoBoolean *created)
1095 {
1096         HANDLE event;
1097
1098         MONO_ARCH_SAVE_REGS;
1099
1100         *created = TRUE;
1101
1102         if (name == NULL) {
1103                 event = CreateEvent (NULL, manual, initial, NULL);
1104         } else {
1105                 event = CreateEvent (NULL, manual, initial,
1106                                      mono_string_chars (name));
1107
1108                 if (GetLastError () == ERROR_ALREADY_EXISTS) {
1109                         *created = FALSE;
1110                 }
1111         }
1112
1113         return(event);
1114 }
1115
1116 gboolean ves_icall_System_Threading_Events_SetEvent_internal (HANDLE handle) {
1117         MONO_ARCH_SAVE_REGS;
1118
1119         return (SetEvent(handle));
1120 }
1121
1122 gboolean ves_icall_System_Threading_Events_ResetEvent_internal (HANDLE handle) {
1123         MONO_ARCH_SAVE_REGS;
1124
1125         return (ResetEvent(handle));
1126 }
1127
1128 void
1129 ves_icall_System_Threading_Events_CloseEvent_internal (HANDLE handle) {
1130         MONO_ARCH_SAVE_REGS;
1131
1132         CloseHandle (handle);
1133 }
1134
1135 HANDLE ves_icall_System_Threading_Events_OpenEvent_internal (MonoString *name,
1136                                                              gint32 rights,
1137                                                              gint32 *error)
1138 {
1139         HANDLE ret;
1140
1141         MONO_ARCH_SAVE_REGS;
1142
1143         *error = ERROR_SUCCESS;
1144
1145         ret = OpenEvent (rights, FALSE, mono_string_chars (name));
1146         if (ret == NULL) {
1147                 *error = GetLastError ();
1148         }
1149
1150         return(ret);
1151 }
1152
1153 gint32 ves_icall_System_Threading_Interlocked_Increment_Int (gint32 *location)
1154 {
1155         MONO_ARCH_SAVE_REGS;
1156
1157         return InterlockedIncrement (location);
1158 }
1159
1160 gint64 ves_icall_System_Threading_Interlocked_Increment_Long (gint64 *location)
1161 {
1162         gint64 ret;
1163
1164         MONO_ARCH_SAVE_REGS;
1165
1166         mono_interlocked_lock ();
1167
1168         ret = ++ *location;
1169
1170         mono_interlocked_unlock ();
1171
1172
1173         return ret;
1174 }
1175
1176 gint32 ves_icall_System_Threading_Interlocked_Decrement_Int (gint32 *location)
1177 {
1178         MONO_ARCH_SAVE_REGS;
1179
1180         return InterlockedDecrement(location);
1181 }
1182
1183 gint64 ves_icall_System_Threading_Interlocked_Decrement_Long (gint64 * location)
1184 {
1185         gint64 ret;
1186
1187         MONO_ARCH_SAVE_REGS;
1188
1189         mono_interlocked_lock ();
1190
1191         ret = -- *location;
1192
1193         mono_interlocked_unlock ();
1194
1195         return ret;
1196 }
1197
1198 gint32 ves_icall_System_Threading_Interlocked_Exchange_Int (gint32 *location, gint32 value)
1199 {
1200         MONO_ARCH_SAVE_REGS;
1201
1202         return InterlockedExchange(location, value);
1203 }
1204
1205 MonoObject * ves_icall_System_Threading_Interlocked_Exchange_Object (MonoObject **location, MonoObject *value)
1206 {
1207         MONO_ARCH_SAVE_REGS;
1208
1209         return (MonoObject *) InterlockedExchangePointer((gpointer *) location, value);
1210 }
1211
1212 gfloat ves_icall_System_Threading_Interlocked_Exchange_Single (gfloat *location, gfloat value)
1213 {
1214         IntFloatUnion val, ret;
1215
1216         MONO_ARCH_SAVE_REGS;
1217
1218         val.fval = value;
1219         ret.ival = InterlockedExchange((gint32 *) location, val.ival);
1220
1221         return ret.fval;
1222 }
1223
1224 gint64
1225 ves_icall_System_Threading_Interlocked_Exchange_Long (gint64 *location, gint64 value)
1226 {
1227 #if SIZEOF_VOID_P == 8
1228         return (gint64) InterlockedExchangePointer((gpointer *) location, (gpointer)value);
1229 #else
1230         gint64 res;
1231
1232         /*
1233          * According to MSDN, this function is only atomic with regards to the
1234          * other Interlocked functions on 32 bit platforms.
1235          */
1236         mono_interlocked_lock ();
1237         res = *location;
1238         *location = value;
1239         mono_interlocked_unlock ();
1240
1241         return res;
1242 #endif
1243 }
1244
1245 gdouble
1246 ves_icall_System_Threading_Interlocked_Exchange_Double (gdouble *location, gdouble value)
1247 {
1248 #if SIZEOF_VOID_P == 8
1249         LongDoubleUnion val, ret;
1250
1251         val.fval = value;
1252         ret.ival = (gint64)InterlockedExchangePointer((gpointer *) location, (gpointer)val.ival);
1253
1254         return ret.fval;
1255 #else
1256         gdouble res;
1257
1258         /*
1259          * According to MSDN, this function is only atomic with regards to the
1260          * other Interlocked functions on 32 bit platforms.
1261          */
1262         mono_interlocked_lock ();
1263         res = *location;
1264         *location = value;
1265         mono_interlocked_unlock ();
1266
1267         return res;
1268 #endif
1269 }
1270
1271 gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *location, gint32 value, gint32 comparand)
1272 {
1273         MONO_ARCH_SAVE_REGS;
1274
1275         return InterlockedCompareExchange(location, value, comparand);
1276 }
1277
1278 MonoObject * ves_icall_System_Threading_Interlocked_CompareExchange_Object (MonoObject **location, MonoObject *value, MonoObject *comparand)
1279 {
1280         MONO_ARCH_SAVE_REGS;
1281
1282         return (MonoObject *) InterlockedCompareExchangePointer((gpointer *) location, value, comparand);
1283 }
1284
1285 gfloat ves_icall_System_Threading_Interlocked_CompareExchange_Single (gfloat *location, gfloat value, gfloat comparand)
1286 {
1287         IntFloatUnion val, ret, cmp;
1288
1289         MONO_ARCH_SAVE_REGS;
1290
1291         val.fval = value;
1292         cmp.fval = comparand;
1293         ret.ival = InterlockedCompareExchange((gint32 *) location, val.ival, cmp.ival);
1294
1295         return ret.fval;
1296 }
1297
1298 gdouble
1299 ves_icall_System_Threading_Interlocked_CompareExchange_Double (gdouble *location, gdouble value, gdouble comparand)
1300 {
1301 #if SIZEOF_VOID_P == 8
1302         LongDoubleUnion val, comp, ret;
1303
1304         val.fval = value;
1305         comp.fval = comparand;
1306         ret.ival = (gint64)InterlockedCompareExchangePointer((gpointer *) location, (gpointer)val.ival, (gpointer)comp.ival);
1307
1308         return ret.fval;
1309 #else
1310         gdouble old;
1311
1312         mono_interlocked_lock ();
1313         old = *location;
1314         if (old == comparand)
1315                 *location = value;
1316         mono_interlocked_unlock ();
1317
1318         return old;
1319 #endif
1320 }
1321
1322 gint64
1323 ves_icall_System_Threading_Interlocked_CompareExchange_Long (gint64 *location, gint64 value, gint64 comparand)
1324 {
1325 #if SIZEOF_VOID_P == 8
1326         return (gint64)InterlockedCompareExchangePointer((gpointer *) location, (gpointer)value, (gpointer)comparand);
1327 #else
1328         gint64 old;
1329
1330         mono_interlocked_lock ();
1331         old = *location;
1332         if (old == comparand)
1333                 *location = value;
1334         mono_interlocked_unlock ();
1335
1336         return old;
1337 #endif
1338 }
1339
1340 MonoObject*
1341 ves_icall_System_Threading_Interlocked_CompareExchange_T (MonoObject **location, MonoObject *value, MonoObject *comparand)
1342 {
1343         MONO_ARCH_SAVE_REGS;
1344
1345         return InterlockedCompareExchangePointer ((gpointer *)location, value, comparand);
1346 }
1347
1348 MonoObject*
1349 ves_icall_System_Threading_Interlocked_Exchange_T (MonoObject **location, MonoObject *value)
1350 {
1351         MONO_ARCH_SAVE_REGS;
1352
1353         return InterlockedExchangePointer ((gpointer *)location, value);
1354 }
1355
1356 gint32
1357 ves_icall_System_Threading_Interlocked_Add_Int (gint32 *location, gint32 value)
1358 {
1359 #if SIZEOF_VOID_P == 8
1360         /* Should be implemented as a JIT intrinsic */
1361         mono_raise_exception (mono_get_exception_not_implemented (NULL));
1362         return 0;
1363 #else
1364         gint32 orig;
1365
1366         mono_interlocked_lock ();
1367         orig = *location;
1368         *location = orig + value;
1369         mono_interlocked_unlock ();
1370
1371         return orig + value;
1372 #endif
1373 }
1374
1375 gint64
1376 ves_icall_System_Threading_Interlocked_Add_Long (gint64 *location, gint64 value)
1377 {
1378 #if SIZEOF_VOID_P == 8
1379         /* Should be implemented as a JIT intrinsic */
1380         mono_raise_exception (mono_get_exception_not_implemented (NULL));
1381         return 0;
1382 #else
1383         gint64 orig;
1384
1385         mono_interlocked_lock ();
1386         orig = *location;
1387         *location = orig + value;
1388         mono_interlocked_unlock ();
1389
1390         return orig + value;
1391 #endif
1392 }
1393
1394 gint64
1395 ves_icall_System_Threading_Interlocked_Read_Long (gint64 *location)
1396 {
1397 #if SIZEOF_VOID_P == 8
1398         /* 64 bit reads are already atomic */
1399         return *location;
1400 #else
1401         gint64 res;
1402
1403         mono_interlocked_lock ();
1404         res = *location;
1405         mono_interlocked_unlock ();
1406
1407         return res;
1408 #endif
1409 }
1410
1411 void
1412 ves_icall_System_Threading_Thread_MemoryBarrier (void)
1413 {
1414         /* Should be implemented as a JIT intrinsic */
1415         mono_raise_exception (mono_get_exception_not_implemented (NULL));
1416 }
1417
1418 void
1419 ves_icall_System_Threading_Thread_ClrState (MonoThread* this, guint32 state)
1420 {
1421         mono_monitor_enter (this->synch_lock);
1422         this->state &= ~state;
1423         if (state & ThreadState_Background) {
1424                 /* If the thread changes the background mode, the main thread has to
1425                  * be notified, since it has to rebuild the list of threads to
1426                  * wait for.
1427                  */
1428                 SetEvent (background_change_event);
1429         }
1430         mono_monitor_exit (this->synch_lock);
1431 }
1432
1433 void
1434 ves_icall_System_Threading_Thread_SetState (MonoThread* this, guint32 state)
1435 {
1436         mono_monitor_enter (this->synch_lock);
1437         this->state |= state;
1438         if (state & ThreadState_Background) {
1439                 /* If the thread changes the background mode, the main thread has to
1440                  * be notified, since it has to rebuild the list of threads to
1441                  * wait for.
1442                  */
1443                 SetEvent (background_change_event);
1444         }
1445         mono_monitor_exit (this->synch_lock);
1446 }
1447
1448 guint32
1449 ves_icall_System_Threading_Thread_GetState (MonoThread* this)
1450 {
1451         guint32 state;
1452         mono_monitor_enter (this->synch_lock);
1453         state = this->state;
1454         mono_monitor_exit (this->synch_lock);
1455         return state;
1456 }
1457
1458 int
1459 mono_thread_get_abort_signal (void)
1460 {
1461 #if defined (__MINGW32__) || defined (_MSC_VER)
1462         return -1;
1463 #else
1464 #ifndef SIGRTMIN
1465         return SIGUSR1;
1466 #else
1467         static int abort_signum = -1;
1468         int i;
1469         if (abort_signum != -1)
1470                 return abort_signum;
1471         /* we try to avoid SIGRTMIN and any one that might have been set already, see bug #75387 */
1472         for (i = SIGRTMIN + 1; i < SIGRTMAX; ++i) {
1473                 struct sigaction sinfo;
1474                 sigaction (i, NULL, &sinfo);
1475                 if (sinfo.sa_handler == SIG_DFL && (void*)sinfo.sa_sigaction == (void*)SIG_DFL) {
1476                         abort_signum = i;
1477                         return i;
1478                 }
1479         }
1480         /* fallback to the old way */
1481         return SIGRTMIN;
1482 #endif
1483 #endif /*defined (__MINGW32__) || defined (_MSC_VER) */
1484 }
1485
1486 #if defined (__MINGW32__) || defined (_MSC_VER)
1487 static void CALLBACK interruption_request_apc (ULONG_PTR param)
1488 {
1489         MonoException* exc = mono_thread_request_interruption (FALSE);
1490         if (exc) mono_raise_exception (exc);
1491 }
1492 #endif /* defined (__MINGW32__) || defined (_MSC_VER) */
1493
1494 /*
1495  * signal_thread_state_change
1496  *
1497  * Tells the thread that his state has changed and it has to enter the new
1498  * state as soon as possible.
1499  */
1500 static void signal_thread_state_change (MonoThread *thread)
1501 {
1502         if (thread == mono_thread_current ()) {
1503                 /* Do it synchronously */
1504                 MonoException *exc = mono_thread_request_interruption (FALSE);
1505                 if (exc)
1506                         mono_raise_exception (exc);
1507         }
1508
1509 #if defined (__MINGW32__) || defined (_MSC_VER)
1510         QueueUserAPC ((PAPCFUNC)interruption_request_apc, thread->handle, NULL);
1511 #else
1512         /* fixme: store the state somewhere */
1513 #ifdef PTHREAD_POINTER_ID
1514         pthread_kill ((gpointer)(gsize)(thread->tid), mono_thread_get_abort_signal ());
1515 #else
1516         pthread_kill (thread->tid, mono_thread_get_abort_signal ());
1517 #endif
1518 #endif /* defined (__MINGW32__) || defined (__MSC_VER) */
1519 }
1520
1521 void
1522 ves_icall_System_Threading_Thread_Abort (MonoThread *thread, MonoObject *state)
1523 {
1524         MONO_ARCH_SAVE_REGS;
1525
1526         mono_monitor_enter (thread->synch_lock);
1527
1528         if ((thread->state & ThreadState_AbortRequested) != 0 ||
1529                 (thread->state & ThreadState_StopRequested) != 0 ||
1530                 (thread->state & ThreadState_Stopped) != 0)
1531         {
1532                 mono_monitor_exit (thread->synch_lock);
1533                 return;
1534         }
1535
1536         if ((thread->state & ThreadState_Unstarted) != 0) {
1537                 thread->state |= ThreadState_Aborted;
1538                 mono_monitor_exit (thread->synch_lock);
1539                 return;
1540         }
1541
1542         thread->state |= ThreadState_AbortRequested;
1543         MONO_OBJECT_SETREF (thread, abort_state, state);
1544         thread->abort_exc = NULL;
1545
1546         mono_monitor_exit (thread->synch_lock);
1547
1548         THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") Abort requested for %p (%"G_GSIZE_FORMAT")", __func__, GetCurrentThreadId (), thread, (gsize)thread->tid));
1549
1550         /* Make sure the thread is awake */
1551         mono_thread_resume (thread);
1552
1553         signal_thread_state_change (thread);
1554 }
1555
1556 void
1557 ves_icall_System_Threading_Thread_ResetAbort (void)
1558 {
1559         MonoThread *thread = mono_thread_current ();
1560
1561         MONO_ARCH_SAVE_REGS;
1562
1563         mono_monitor_enter (thread->synch_lock);
1564
1565         thread->state &= ~ThreadState_AbortRequested;
1566
1567         if (!thread->abort_exc) {
1568                 const char *msg = "Unable to reset abort because no abort was requested";
1569                 mono_monitor_exit (thread->synch_lock);
1570                 mono_raise_exception (mono_get_exception_thread_state (msg));
1571         } else {
1572                 thread->abort_exc = NULL;
1573                 thread->abort_state = NULL;
1574         }
1575
1576         mono_monitor_exit (thread->synch_lock);
1577 }
1578
1579 static gboolean
1580 mono_thread_suspend (MonoThread *thread)
1581 {
1582         MONO_ARCH_SAVE_REGS;
1583
1584         mono_monitor_enter (thread->synch_lock);
1585
1586         if ((thread->state & ThreadState_Unstarted) != 0 ||
1587                 (thread->state & ThreadState_Aborted) != 0 ||
1588                 (thread->state & ThreadState_Stopped) != 0)
1589         {
1590                 mono_monitor_exit (thread->synch_lock);
1591                 return FALSE;
1592         }
1593
1594         if ((thread->state & ThreadState_Suspended) != 0 ||
1595                 (thread->state & ThreadState_SuspendRequested) != 0 ||
1596                 (thread->state & ThreadState_StopRequested) != 0)
1597         {
1598                 mono_monitor_exit (thread->synch_lock);
1599                 return TRUE;
1600         }
1601
1602         thread->state |= ThreadState_SuspendRequested;
1603         mono_monitor_exit (thread->synch_lock);
1604
1605         signal_thread_state_change (thread);
1606         return TRUE;
1607 }
1608
1609 void
1610 ves_icall_System_Threading_Thread_Suspend (MonoThread *thread)
1611 {
1612         if (!mono_thread_suspend (thread))
1613                 mono_raise_exception (mono_get_exception_thread_state ("Thread has not been started, or is dead."));
1614 }
1615
1616 static gboolean
1617 mono_thread_resume (MonoThread *thread)
1618 {
1619         MONO_ARCH_SAVE_REGS;
1620
1621         mono_monitor_enter (thread->synch_lock);
1622
1623         if ((thread->state & ThreadState_SuspendRequested) != 0) {
1624                 thread->state &= ~ThreadState_SuspendRequested;
1625                 mono_monitor_exit (thread->synch_lock);
1626                 return TRUE;
1627         }
1628
1629         if ((thread->state & ThreadState_Suspended) == 0 ||
1630                 (thread->state & ThreadState_Unstarted) != 0 ||
1631                 (thread->state & ThreadState_Aborted) != 0 ||
1632                 (thread->state & ThreadState_Stopped) != 0)
1633         {
1634                 mono_monitor_exit (thread->synch_lock);
1635                 return FALSE;
1636         }
1637
1638         thread->resume_event = CreateEvent (NULL, TRUE, FALSE, NULL);
1639
1640         /* Awake the thread */
1641         SetEvent (thread->suspend_event);
1642
1643         mono_monitor_exit (thread->synch_lock);
1644
1645         /* Wait for the thread to awake */
1646         WaitForSingleObject (thread->resume_event, INFINITE);
1647         CloseHandle (thread->resume_event);
1648         thread->resume_event = NULL;
1649
1650         return TRUE;
1651 }
1652
1653 void
1654 ves_icall_System_Threading_Thread_Resume (MonoThread *thread)
1655 {
1656         if (!mono_thread_resume (thread))
1657                 mono_raise_exception (mono_get_exception_thread_state ("Thread has not been started, or is dead."));
1658 }
1659
1660 static gboolean
1661 find_wrapper (MonoMethod *m, gint no, gint ilo, gboolean managed, gpointer data)
1662 {
1663         if (managed)
1664                 return TRUE;
1665
1666         if (m->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
1667                 m->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
1668                 m->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH)
1669         {
1670                 *((gboolean*)data) = TRUE;
1671                 return TRUE;
1672         }
1673         return FALSE;
1674 }
1675
1676 static gboolean
1677 is_running_protected_wrapper (void)
1678 {
1679         gboolean found = FALSE;
1680         mono_stack_walk (find_wrapper, &found);
1681         return found;
1682 }
1683
1684 void mono_thread_stop (MonoThread *thread)
1685 {
1686         mono_monitor_enter (thread->synch_lock);
1687
1688         if ((thread->state & ThreadState_StopRequested) != 0 ||
1689                 (thread->state & ThreadState_Stopped) != 0)
1690         {
1691                 mono_monitor_exit (thread->synch_lock);
1692                 return;
1693         }
1694
1695         /* Make sure the thread is awake */
1696         mono_thread_resume (thread);
1697
1698         thread->state |= ThreadState_StopRequested;
1699         thread->state &= ~ThreadState_AbortRequested;
1700
1701         mono_monitor_exit (thread->synch_lock);
1702
1703         signal_thread_state_change (thread);
1704 }
1705
1706 gint8
1707 ves_icall_System_Threading_Thread_VolatileRead1 (void *ptr)
1708 {
1709         return *((volatile gint8 *) (ptr));
1710 }
1711
1712 gint16
1713 ves_icall_System_Threading_Thread_VolatileRead2 (void *ptr)
1714 {
1715         return *((volatile gint16 *) (ptr));
1716 }
1717
1718 gint32
1719 ves_icall_System_Threading_Thread_VolatileRead4 (void *ptr)
1720 {
1721         return *((volatile gint32 *) (ptr));
1722 }
1723
1724 gint64
1725 ves_icall_System_Threading_Thread_VolatileRead8 (void *ptr)
1726 {
1727         return *((volatile gint64 *) (ptr));
1728 }
1729
1730 void *
1731 ves_icall_System_Threading_Thread_VolatileReadIntPtr (void *ptr)
1732 {
1733         return (void *)  *((volatile void **) ptr);
1734 }
1735
1736 void
1737 ves_icall_System_Threading_Thread_VolatileWrite1 (void *ptr, gint8 value)
1738 {
1739         *((volatile gint8 *) ptr) = value;
1740 }
1741
1742 void
1743 ves_icall_System_Threading_Thread_VolatileWrite2 (void *ptr, gint16 value)
1744 {
1745         *((volatile gint16 *) ptr) = value;
1746 }
1747
1748 void
1749 ves_icall_System_Threading_Thread_VolatileWrite4 (void *ptr, gint32 value)
1750 {
1751         *((volatile gint32 *) ptr) = value;
1752 }
1753
1754 void
1755 ves_icall_System_Threading_Thread_VolatileWrite8 (void *ptr, gint64 value)
1756 {
1757         *((volatile gint64 *) ptr) = value;
1758 }
1759
1760 void
1761 ves_icall_System_Threading_Thread_VolatileWriteIntPtr (void *ptr, void *value)
1762 {
1763         *((volatile void **) ptr) = value;
1764 }
1765
1766 void mono_thread_init (MonoThreadStartCB start_cb,
1767                        MonoThreadAttachCB attach_cb)
1768 {
1769         InitializeCriticalSection(&threads_mutex);
1770         InitializeCriticalSection(&interlocked_mutex);
1771         InitializeCriticalSection(&contexts_mutex);
1772         background_change_event = CreateEvent (NULL, TRUE, FALSE, NULL);
1773
1774         mono_init_static_data_info (&thread_static_info);
1775         mono_init_static_data_info (&context_static_info);
1776
1777         current_object_key=TlsAlloc();
1778         THREAD_DEBUG (g_message ("%s: Allocated current_object_key %d", __func__, current_object_key));
1779
1780         mono_thread_start_cb = start_cb;
1781         mono_thread_attach_cb = attach_cb;
1782
1783         /* Get a pseudo handle to the current process.  This is just a
1784          * kludge so that wapi can build a process handle if needed.
1785          * As a pseudo handle is returned, we don't need to clean
1786          * anything up.
1787          */
1788         GetCurrentProcess ();
1789 }
1790
1791 void mono_thread_cleanup (void)
1792 {
1793 #if !defined(PLATFORM_WIN32) && !defined(RUN_IN_SUBTHREAD)
1794         /* The main thread must abandon any held mutexes (particularly
1795          * important for named mutexes as they are shared across
1796          * processes, see bug 74680.)  This will happen when the
1797          * thread exits, but if it's not running in a subthread it
1798          * won't exit in time.
1799          */
1800         /* Using non-w32 API is a nasty kludge, but I couldn't find
1801          * anything in the documentation that would let me do this
1802          * here yet still be safe to call on windows.
1803          */
1804         _wapi_thread_signal_self (mono_environment_exitcode_get ());
1805 #endif
1806
1807         DeleteCriticalSection (&threads_mutex);
1808         DeleteCriticalSection (&interlocked_mutex);
1809         DeleteCriticalSection (&contexts_mutex);
1810         CloseHandle (background_change_event);
1811 }
1812
1813 void
1814 mono_threads_install_cleanup (MonoThreadCleanupFunc func)
1815 {
1816         mono_thread_cleanup_fn = func;
1817 }
1818
1819 G_GNUC_UNUSED
1820 static void print_tids (gpointer key, gpointer value, gpointer user)
1821 {
1822         /* GPOINTER_TO_UINT breaks horribly if sizeof(void *) >
1823          * sizeof(uint) and a cast to uint would overflow
1824          */
1825         /* Older versions of glib don't have G_GSIZE_FORMAT, so just
1826          * print this as a pointer.
1827          */
1828         g_message ("Waiting for: %p", key);
1829 }
1830
1831 struct wait_data
1832 {
1833         HANDLE handles[MAXIMUM_WAIT_OBJECTS];
1834         MonoThread *threads[MAXIMUM_WAIT_OBJECTS];
1835         guint32 num;
1836 };
1837
1838 static void wait_for_tids (struct wait_data *wait, guint32 timeout)
1839 {
1840         guint32 i, ret;
1841
1842         THREAD_DEBUG (g_message("%s: %d threads to wait for in this batch", __func__, wait->num));
1843
1844         ret=WaitForMultipleObjectsEx(wait->num, wait->handles, TRUE, timeout, FALSE);
1845
1846         if(ret==WAIT_FAILED) {
1847                 /* See the comment in build_wait_tids() */
1848                 THREAD_DEBUG (g_message ("%s: Wait failed", __func__));
1849                 return;
1850         }
1851
1852         for(i=0; i<wait->num; i++)
1853                 CloseHandle (wait->handles[i]);
1854
1855         if (ret == WAIT_TIMEOUT)
1856                 return;
1857
1858         for(i=0; i<wait->num; i++) {
1859                 gsize tid = wait->threads[i]->tid;
1860
1861                 if(mono_g_hash_table_lookup (threads, (gpointer)tid)!=NULL) {
1862                         /* This thread must have been killed, because
1863                          * it hasn't cleaned itself up. (It's just
1864                          * possible that the thread exited before the
1865                          * parent thread had a chance to store the
1866                          * handle, and now there is another pointer to
1867                          * the already-exited thread stored.  In this
1868                          * case, we'll just get two
1869                          * mono_profiler_thread_end() calls for the
1870                          * same thread.)
1871                          */
1872
1873                         THREAD_DEBUG (g_message ("%s: cleaning up after thread %"G_GSIZE_FORMAT, __func__, tid));
1874                         thread_cleanup (wait->threads[i]);
1875                 }
1876         }
1877 }
1878
1879 static void wait_for_tids_or_state_change (struct wait_data *wait, guint32 timeout)
1880 {
1881         guint32 i, ret, count;
1882
1883         THREAD_DEBUG (g_message("%s: %d threads to wait for in this batch", __func__, wait->num));
1884
1885         /* Add the thread state change event, so it wakes up if a thread changes
1886          * to background mode.
1887          */
1888         count = wait->num;
1889         if (count < MAXIMUM_WAIT_OBJECTS) {
1890                 wait->handles [count] = background_change_event;
1891                 count++;
1892         }
1893
1894         ret=WaitForMultipleObjectsEx (count, wait->handles, FALSE, timeout, FALSE);
1895
1896         if(ret==WAIT_FAILED) {
1897                 /* See the comment in build_wait_tids() */
1898                 THREAD_DEBUG (g_message ("%s: Wait failed", __func__));
1899                 return;
1900         }
1901
1902         for(i=0; i<wait->num; i++)
1903                 CloseHandle (wait->handles[i]);
1904
1905         if (ret == WAIT_TIMEOUT)
1906                 return;
1907
1908         if (ret < wait->num) {
1909                 gsize tid = wait->threads[ret]->tid;
1910                 mono_threads_lock ();
1911                 if (mono_g_hash_table_lookup (threads, (gpointer)tid)!=NULL) {
1912                         /* See comment in wait_for_tids about thread cleanup */
1913                         mono_threads_unlock ();
1914                         THREAD_DEBUG (g_message ("%s: cleaning up after thread %"G_GSIZE_FORMAT, __func__, tid));
1915                         thread_cleanup (wait->threads [ret]);
1916                 } else
1917                         mono_threads_unlock ();
1918         }
1919 }
1920
1921 static void build_wait_tids (gpointer key, gpointer value, gpointer user)
1922 {
1923         struct wait_data *wait=(struct wait_data *)user;
1924
1925         if(wait->num<MAXIMUM_WAIT_OBJECTS) {
1926                 HANDLE handle;
1927                 MonoThread *thread=(MonoThread *)value;
1928
1929                 /* Ignore background threads, we abort them later */
1930                 mono_monitor_enter (thread->synch_lock);
1931                 if (thread->state & ThreadState_Background) {
1932                         THREAD_DEBUG (g_message ("%s: ignoring background thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
1933                         mono_monitor_exit (thread->synch_lock);
1934                         return; /* just leave, ignore */
1935                 }
1936                 mono_monitor_exit (thread->synch_lock);
1937
1938                 if (mono_gc_is_finalizer_thread (thread)) {
1939                         THREAD_DEBUG (g_message ("%s: ignoring finalizer thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
1940                         return;
1941                 }
1942
1943                 if (thread == mono_thread_current ()) {
1944                         THREAD_DEBUG (g_message ("%s: ignoring current thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
1945                         return;
1946                 }
1947
1948                 if (thread == mono_thread_get_main ()) {
1949                         THREAD_DEBUG (g_message ("%s: ignoring main thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
1950                         return;
1951                 }
1952
1953                 handle = OpenThread (THREAD_ALL_ACCESS, TRUE, thread->tid);
1954                 if (handle == NULL) {
1955                         THREAD_DEBUG (g_message ("%s: ignoring unopenable thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
1956                         return;
1957                 }
1958
1959                 wait->handles[wait->num]=handle;
1960                 wait->threads[wait->num]=thread;
1961                 wait->num++;
1962
1963                 THREAD_DEBUG (g_message ("%s: adding thread %"G_GSIZE_FORMAT, __func__, (gsize)thread->tid));
1964         } else {
1965                 /* Just ignore the rest, we can't do anything with
1966                  * them yet
1967                  */
1968         }
1969 }
1970
1971 static gboolean
1972 remove_and_abort_threads (gpointer key, gpointer value, gpointer user)
1973 {
1974         struct wait_data *wait=(struct wait_data *)user;
1975         gsize self = GetCurrentThreadId ();
1976         MonoThread *thread = (MonoThread *) value;
1977         HANDLE handle;
1978
1979         if (wait->num >= MAXIMUM_WAIT_OBJECTS)
1980                 return FALSE;
1981
1982         /* The finalizer thread is not a background thread */
1983         if (thread->tid != self && (thread->state & ThreadState_Background) != 0) {
1984
1985                 handle = OpenThread (THREAD_ALL_ACCESS, TRUE, thread->tid);
1986                 if (handle == NULL)
1987                         return FALSE;
1988
1989                 if(thread->state & ThreadState_AbortRequested ||
1990                    thread->state & ThreadState_Aborted) {
1991                         THREAD_DEBUG (g_message ("%s: Thread id %"G_GSIZE_FORMAT" already aborting", __func__, (gsize)thread->tid));
1992                         return(TRUE);
1993                 }
1994
1995                 /* printf ("A: %d\n", wait->num); */
1996                 wait->handles[wait->num]=thread->handle;
1997                 wait->threads[wait->num]=thread;
1998                 wait->num++;
1999
2000                 THREAD_DEBUG (g_print ("%s: Aborting id: %"G_GSIZE_FORMAT"\n", __func__, (gsize)thread->tid));
2001                 mono_thread_stop (thread);
2002                 return TRUE;
2003         }
2004
2005         return (thread->tid != self && !mono_gc_is_finalizer_thread (thread));
2006 }
2007
2008 void mono_thread_manage (void)
2009 {
2010         struct wait_data *wait=g_new0 (struct wait_data, 1);
2011
2012         /* join each thread that's still running */
2013         THREAD_DEBUG (g_message ("%s: Joining each running thread...", __func__));
2014
2015         mono_threads_lock ();
2016         if(threads==NULL) {
2017                 THREAD_DEBUG (g_message("%s: No threads", __func__));
2018                 mono_threads_unlock ();
2019                 return;
2020         }
2021         mono_threads_unlock ();
2022
2023         do {
2024                 mono_threads_lock ();
2025                 THREAD_DEBUG (g_message ("%s: There are %d threads to join", __func__, mono_g_hash_table_size (threads));
2026                         mono_g_hash_table_foreach (threads, print_tids, NULL));
2027
2028                 ResetEvent (background_change_event);
2029                 wait->num=0;
2030                 mono_g_hash_table_foreach (threads, build_wait_tids, wait);
2031                 mono_threads_unlock ();
2032                 if(wait->num>0) {
2033                         /* Something to wait for */
2034                         wait_for_tids_or_state_change (wait, INFINITE);
2035                 }
2036                 THREAD_DEBUG (g_message ("%s: I have %d threads after waiting.", __func__, wait->num));
2037         } while(wait->num>0);
2038
2039         mono_runtime_set_shutting_down ();
2040
2041         THREAD_DEBUG (g_message ("%s: threadpool cleanup", __func__));
2042         mono_thread_pool_cleanup ();
2043
2044         /*
2045          * Remove everything but the finalizer thread and self.
2046          * Also abort all the background threads
2047          * */
2048         do {
2049                 mono_threads_lock ();
2050
2051                 wait->num = 0;
2052                 mono_g_hash_table_foreach_remove (threads, remove_and_abort_threads, wait);
2053
2054                 mono_threads_unlock ();
2055
2056                 THREAD_DEBUG (g_message ("%s: wait->num is now %d", __func__, wait->num));
2057                 if(wait->num>0) {
2058                         /* Something to wait for */
2059                         wait_for_tids (wait, INFINITE);
2060                 }
2061         } while (wait->num > 0);
2062
2063         /*
2064          * give the subthreads a chance to really quit (this is mainly needed
2065          * to get correct user and system times from getrusage/wait/time(1)).
2066          * This could be removed if we avoid pthread_detach() and use pthread_join().
2067          */
2068 #ifndef PLATFORM_WIN32
2069         sched_yield ();
2070 #endif
2071
2072         g_free (wait);
2073 }
2074
2075 static void terminate_thread (gpointer key, gpointer value, gpointer user)
2076 {
2077         MonoThread *thread=(MonoThread *)value;
2078
2079         if(thread->tid != (gsize)user) {
2080                 /*TerminateThread (thread->handle, -1);*/
2081         }
2082 }
2083
2084 void mono_thread_abort_all_other_threads (void)
2085 {
2086         gsize self = GetCurrentThreadId ();
2087
2088         mono_threads_lock ();
2089         THREAD_DEBUG (g_message ("%s: There are %d threads to abort", __func__,
2090                                  mono_g_hash_table_size (threads));
2091                       mono_g_hash_table_foreach (threads, print_tids, NULL));
2092
2093         mono_g_hash_table_foreach (threads, terminate_thread, (gpointer)self);
2094
2095         mono_threads_unlock ();
2096 }
2097
2098 static void
2099 collect_threads (gpointer key, gpointer value, gpointer user_data)
2100 {
2101         MonoThread *thread = (MonoThread*)value;
2102         struct wait_data *wait = (struct wait_data*)user_data;
2103         HANDLE handle;
2104
2105         if (wait->num<MAXIMUM_WAIT_OBJECTS) {
2106                 handle = OpenThread (THREAD_ALL_ACCESS, TRUE, thread->tid);
2107                 if (handle == NULL)
2108                         return;
2109
2110                 wait->handles [wait->num] = handle;
2111                 wait->threads [wait->num] = thread;
2112                 wait->num++;
2113         }
2114 }
2115
2116 /*
2117  * mono_thread_suspend_all_other_threads:
2118  *
2119  *  Suspend all managed threads except the finalizer thread and this thread.
2120  */
2121 void mono_thread_suspend_all_other_threads (void)
2122 {
2123         struct wait_data *wait = g_new0 (struct wait_data, 1);
2124         int i, waitnum;
2125         gsize self = GetCurrentThreadId ();
2126         gpointer *events;
2127         guint32 eventidx = 0;
2128
2129         /*
2130          * Make a copy of the hashtable since we can't do anything with
2131          * threads while threads_mutex is held.
2132          */
2133         mono_threads_lock ();
2134         mono_g_hash_table_foreach (threads, collect_threads, wait);
2135         mono_threads_unlock ();
2136
2137         events = g_new0 (gpointer, wait->num);
2138         waitnum = 0;
2139         /* Get the suspended events that we'll be waiting for */
2140         for (i = 0; i < wait->num; ++i) {
2141                 MonoThread *thread = wait->threads [i];
2142
2143                 if ((thread->tid == self) || mono_gc_is_finalizer_thread (thread)) {
2144                         //CloseHandle (wait->handles [i]);
2145                         wait->threads [i] = NULL; /* ignore this thread in next loop */
2146                         continue;
2147                 }
2148
2149                 mono_monitor_enter (thread->synch_lock);
2150
2151                 if ((thread->state & ThreadState_Suspended) != 0 ||
2152                         (thread->state & ThreadState_SuspendRequested) != 0 ||
2153                         (thread->state & ThreadState_StopRequested) != 0 ||
2154                         (thread->state & ThreadState_Stopped) != 0) {
2155                         mono_monitor_exit (thread->synch_lock);
2156                         CloseHandle (wait->handles [i]);
2157                         wait->threads [i] = NULL; /* ignore this thread in next loop */
2158                         continue;
2159                 }
2160
2161                 /* Convert abort requests into suspend requests */
2162                 if ((thread->state & ThreadState_AbortRequested) != 0)
2163                         thread->state &= ~ThreadState_AbortRequested;
2164
2165                 thread->state |= ThreadState_SuspendRequested;
2166
2167                 if (thread->suspended_event == NULL)
2168                         thread->suspended_event = CreateEvent (NULL, TRUE, FALSE, NULL);
2169
2170                 events [eventidx++] = thread->suspended_event;
2171                 mono_monitor_exit (thread->synch_lock);
2172
2173                 /* Signal the thread to suspend */
2174                 signal_thread_state_change (thread);
2175         }
2176
2177         WaitForMultipleObjectsEx (eventidx, events, TRUE, INFINITE, FALSE);
2178         for (i = 0; i < wait->num; ++i) {
2179                 MonoThread *thread = wait->threads [i];
2180
2181                 if (thread == NULL)
2182                         continue;
2183
2184                 mono_monitor_enter (thread->synch_lock);
2185                 CloseHandle (thread->suspended_event);
2186                 thread->suspended_event = NULL;
2187                 mono_monitor_exit (thread->synch_lock);
2188         }
2189
2190         g_free (events);
2191         g_free (wait);
2192 }
2193
2194 /**
2195  * mono_threads_request_thread_dump:
2196  *
2197  *   Ask all threads except the current to print their stacktrace to stdout.
2198  */
2199 void
2200 mono_threads_request_thread_dump (void)
2201 {
2202         struct wait_data *wait = g_new0 (struct wait_data, 1);
2203         int i;
2204
2205         /*
2206          * Make a copy of the hashtable since we can't do anything with
2207          * threads while threads_mutex is held.
2208          */
2209         mono_threads_lock ();
2210         mono_g_hash_table_foreach (threads, collect_threads, wait);
2211         mono_threads_unlock ();
2212
2213         for (i = 0; i < wait->num; ++i) {
2214                 MonoThread *thread = wait->threads [i];
2215
2216                 if (!mono_gc_is_finalizer_thread (thread) && (thread != mono_thread_current ()) && !thread->thread_dump_requested) {
2217                         thread->thread_dump_requested = TRUE;
2218
2219                         signal_thread_state_change (thread);
2220                 }
2221
2222                 CloseHandle (wait->handles [i]);
2223         }
2224 }
2225
2226 /*
2227  * mono_thread_push_appdomain_ref:
2228  *
2229  *   Register that the current thread may have references to objects in domain
2230  * @domain on its stack. Each call to this function should be paired with a
2231  * call to pop_appdomain_ref.
2232  */
2233 void
2234 mono_thread_push_appdomain_ref (MonoDomain *domain)
2235 {
2236         MonoThread *thread = mono_thread_current ();
2237
2238         if (thread) {
2239                 /* printf ("PUSH REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, domain->friendly_name); */
2240                 mono_threads_lock ();
2241                 thread->appdomain_refs = g_slist_prepend (thread->appdomain_refs, domain);
2242                 mono_threads_unlock ();
2243         }
2244 }
2245
2246 void
2247 mono_thread_pop_appdomain_ref (void)
2248 {
2249         MonoThread *thread = mono_thread_current ();
2250
2251         if (thread) {
2252                 /* printf ("POP REF: %"G_GSIZE_FORMAT" -> %s.\n", (gsize)thread->tid, ((MonoDomain*)(thread->appdomain_refs->data))->friendly_name); */
2253                 mono_threads_lock ();
2254                 /* FIXME: How can the list be empty ? */
2255                 if (thread->appdomain_refs)
2256                         thread->appdomain_refs = g_slist_remove (thread->appdomain_refs, thread->appdomain_refs->data);
2257                 mono_threads_unlock ();
2258         }
2259 }
2260
2261 gboolean
2262 mono_thread_has_appdomain_ref (MonoThread *thread, MonoDomain *domain)
2263 {
2264         gboolean res;
2265         mono_threads_lock ();
2266         res = g_slist_find (thread->appdomain_refs, domain) != NULL;
2267         mono_threads_unlock ();
2268         return res;
2269 }
2270
2271 typedef struct abort_appdomain_data {
2272         struct wait_data wait;
2273         MonoDomain *domain;
2274 } abort_appdomain_data;
2275
2276 static void
2277 abort_appdomain_thread (gpointer key, gpointer value, gpointer user_data)
2278 {
2279         MonoThread *thread = (MonoThread*)value;
2280         abort_appdomain_data *data = (abort_appdomain_data*)user_data;
2281         MonoDomain *domain = data->domain;
2282
2283         if (mono_thread_has_appdomain_ref (thread, domain)) {
2284                 HANDLE handle = OpenThread (THREAD_ALL_ACCESS, TRUE, thread->tid);
2285                 if (handle == NULL)
2286                         return;
2287
2288                 /* printf ("ABORTING THREAD %p BECAUSE IT REFERENCES DOMAIN %s.\n", thread->tid, domain->friendly_name); */
2289
2290                 ves_icall_System_Threading_Thread_Abort (thread, NULL);
2291
2292                 if(data->wait.num<MAXIMUM_WAIT_OBJECTS) {
2293                         data->wait.handles [data->wait.num] = handle;
2294                         data->wait.threads [data->wait.num] = thread;
2295                         data->wait.num++;
2296                 } else {
2297                         /* Just ignore the rest, we can't do anything with
2298                          * them yet
2299                          */
2300                 }
2301         }
2302 }
2303
2304 /*
2305  * mono_threads_abort_appdomain_threads:
2306  *
2307  *   Abort threads which has references to the given appdomain.
2308  */
2309 gboolean
2310 mono_threads_abort_appdomain_threads (MonoDomain *domain, int timeout)
2311 {
2312         abort_appdomain_data user_data;
2313         guint32 start_time;
2314
2315         /* printf ("ABORT BEGIN.\n"); */
2316
2317         start_time = GetTickCount ();
2318         do {
2319                 mono_threads_lock ();
2320
2321                 user_data.domain = domain;
2322                 user_data.wait.num = 0;
2323                 mono_g_hash_table_foreach (threads, abort_appdomain_thread, &user_data);
2324                 mono_threads_unlock ();
2325
2326                 if (user_data.wait.num > 0)
2327                         /*
2328                          * We should wait for the threads either to abort, or to leave the
2329                          * domain. We can't do the latter, so we wait with a timeout.
2330                          */
2331                         wait_for_tids (&user_data.wait, 100);
2332
2333                 /* Update remaining time */
2334                 timeout -= GetTickCount () - start_time;
2335                 start_time = GetTickCount ();
2336
2337                 if (timeout < 0)
2338                         return FALSE;
2339         }
2340         while (user_data.wait.num > 0);
2341
2342         /* printf ("ABORT DONE.\n"); */
2343
2344         return TRUE;
2345 }
2346
2347 static void
2348 clear_cached_culture (gpointer key, gpointer value, gpointer user_data)
2349 {
2350         MonoThread *thread = (MonoThread*)value;
2351         MonoDomain *domain = (MonoDomain*)user_data;
2352         int i;
2353
2354         /* No locking needed here */
2355         /* FIXME: why no locking? writes to the cache are protected with synch_lock above */
2356
2357         if (thread->cached_culture_info) {
2358                 for (i = 0; i < NUM_CACHED_CULTURES * 2; ++i) {
2359                         MonoObject *obj = mono_array_get (thread->cached_culture_info, MonoObject*, i);
2360                         if (obj && obj->vtable->domain == domain)
2361                                 mono_array_set (thread->cached_culture_info, MonoObject*, i, NULL);
2362                 }
2363         }
2364 }
2365
2366 /*
2367  * mono_threads_clear_cached_culture:
2368  *
2369  *   Clear the cached_current_culture from all threads if it is in the
2370  * given appdomain.
2371  */
2372 void
2373 mono_threads_clear_cached_culture (MonoDomain *domain)
2374 {
2375         mono_threads_lock ();
2376         mono_g_hash_table_foreach (threads, clear_cached_culture, domain);
2377         mono_threads_unlock ();
2378 }
2379
2380 /*
2381  * mono_thread_get_pending_exception:
2382  *
2383  *   Return an exception which needs to be raised when leaving a catch clause.
2384  * This is used for undeniable exception propagation.
2385  */
2386 MonoException*
2387 mono_thread_get_pending_exception (void)
2388 {
2389         MonoThread *thread = mono_thread_current ();
2390
2391         MONO_ARCH_SAVE_REGS;
2392
2393         if (thread && thread->abort_exc && !is_running_protected_wrapper ()) {
2394                 /*
2395                  * FIXME: Clear the abort exception and return an AppDomainUnloaded
2396                  * exception if the thread no longer references a dying appdomain.
2397                  */
2398                 thread->abort_exc->trace_ips = NULL;
2399                 thread->abort_exc->stack_trace = NULL;
2400                 return thread->abort_exc;
2401         }
2402
2403         return NULL;
2404 }
2405
2406 #define NUM_STATIC_DATA_IDX 8
2407 static const int static_data_size [NUM_STATIC_DATA_IDX] = {
2408         1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216
2409 };
2410
2411
2412 /*
2413  *  mono_alloc_static_data
2414  *
2415  *   Allocate memory blocks for storing threads or context static data
2416  */
2417 static void
2418 mono_alloc_static_data (gpointer **static_data_ptr, guint32 offset)
2419 {
2420         guint idx = (offset >> 24) - 1;
2421         int i;
2422
2423         gpointer* static_data = *static_data_ptr;
2424         if (!static_data) {
2425                 static_data = mono_gc_alloc_fixed (static_data_size [0], NULL);
2426                 *static_data_ptr = static_data;
2427                 static_data [0] = static_data;
2428         }
2429
2430         for (i = 1; i <= idx; ++i) {
2431                 if (static_data [i])
2432                         continue;
2433                 static_data [i] = mono_gc_alloc_fixed (static_data_size [i], NULL);
2434         }
2435 }
2436
2437 /*
2438  *  mono_init_static_data_info
2439  *
2440  *   Initializes static data counters
2441  */
2442 static void mono_init_static_data_info (StaticDataInfo *static_data)
2443 {
2444         static_data->idx = 0;
2445         static_data->offset = 0;
2446 }
2447
2448 /*
2449  *  mono_alloc_static_data_slot
2450  *
2451  *   Generates an offset for static data. static_data contains the counters
2452  *  used to generate it.
2453  */
2454 static guint32
2455 mono_alloc_static_data_slot (StaticDataInfo *static_data, guint32 size, guint32 align)
2456 {
2457         guint32 offset;
2458
2459         if (!static_data->idx && !static_data->offset) {
2460                 /*
2461                  * we use the first chunk of the first allocation also as
2462                  * an array for the rest of the data
2463                  */
2464                 static_data->offset = sizeof (gpointer) * NUM_STATIC_DATA_IDX;
2465         }
2466         static_data->offset += align - 1;
2467         static_data->offset &= ~(align - 1);
2468         if (static_data->offset + size >= static_data_size [static_data->idx]) {
2469                 static_data->idx ++;
2470                 g_assert (size <= static_data_size [static_data->idx]);
2471                 /*
2472                  * massive unloading and reloading of domains with thread-static
2473                  * data may eventually exceed the allocated storage...
2474                  * Need to check what the MS runtime does in that case.
2475                  * Note that for each appdomain, we need to allocate a separate
2476                  * thread data slot for security reasons. We could keep track
2477                  * of the slots per-domain and when the domain is unloaded
2478                  * out the slots on a sort of free list.
2479                  */
2480                 g_assert (static_data->idx < NUM_STATIC_DATA_IDX);
2481                 static_data->offset = 0;
2482         }
2483         offset = static_data->offset | ((static_data->idx + 1) << 24);
2484         static_data->offset += size;
2485         return offset;
2486 }
2487
2488 /*
2489  * ensure thread static fields already allocated are valid for thread
2490  * This function is called when a thread is created or on thread attach.
2491  */
2492 static void
2493 thread_adjust_static_data (MonoThread *thread)
2494 {
2495         guint32 offset;
2496
2497         mono_threads_lock ();
2498         if (thread_static_info.offset || thread_static_info.idx > 0) {
2499                 /* get the current allocated size */
2500                 offset = thread_static_info.offset | ((thread_static_info.idx + 1) << 24);
2501                 mono_alloc_static_data (&(thread->static_data), offset);
2502         }
2503         mono_threads_unlock ();
2504 }
2505
2506 static void
2507 alloc_thread_static_data_helper (gpointer key, gpointer value, gpointer user)
2508 {
2509         MonoThread *thread = value;
2510         guint32 offset = GPOINTER_TO_UINT (user);
2511
2512         mono_alloc_static_data (&(thread->static_data), offset);
2513 }
2514
2515 /*
2516  * The offset for a special static variable is composed of three parts:
2517  * a bit that indicates the type of static data (0:thread, 1:context),
2518  * an index in the array of chunks of memory for the thread (thread->static_data)
2519  * and an offset in that chunk of mem. This allows allocating less memory in the
2520  * common case.
2521  */
2522
2523 guint32
2524 mono_alloc_special_static_data (guint32 static_type, guint32 size, guint32 align)
2525 {
2526         guint32 offset;
2527         if (static_type == SPECIAL_STATIC_THREAD)
2528         {
2529                 mono_threads_lock ();
2530                 offset = mono_alloc_static_data_slot (&thread_static_info, size, align);
2531                 /* This can be called during startup */
2532                 if (threads != NULL)
2533                         mono_g_hash_table_foreach (threads, alloc_thread_static_data_helper, GUINT_TO_POINTER (offset));
2534                 mono_threads_unlock ();
2535         }
2536         else
2537         {
2538                 g_assert (static_type == SPECIAL_STATIC_CONTEXT);
2539                 mono_contexts_lock ();
2540                 offset = mono_alloc_static_data_slot (&context_static_info, size, align);
2541                 mono_contexts_unlock ();
2542                 offset |= 0x80000000;   /* Set the high bit to indicate context static data */
2543         }
2544         return offset;
2545 }
2546
2547 gpointer
2548 mono_get_special_static_data (guint32 offset)
2549 {
2550         /* The high bit means either thread (0) or static (1) data. */
2551
2552         guint32 static_type = (offset & 0x80000000);
2553         int idx;
2554
2555         offset &= 0x7fffffff;
2556         idx = (offset >> 24) - 1;
2557
2558         if (static_type == 0)
2559         {
2560                 MonoThread *thread = mono_thread_current ();
2561                 return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
2562         }
2563         else
2564         {
2565                 /* Allocate static data block under demand, since we don't have a list
2566                 // of contexts
2567                 */
2568                 MonoAppContext *context = mono_context_get ();
2569                 if (!context->static_data || !context->static_data [idx]) {
2570                         mono_contexts_lock ();
2571                         mono_alloc_static_data (&(context->static_data), offset);
2572                         mono_contexts_unlock ();
2573                 }
2574                 return ((char*) context->static_data [idx]) + (offset & 0xffffff);
2575         }
2576 }
2577
2578 static MonoClassField *local_slots = NULL;
2579
2580 typedef struct {
2581         /* local tls data to get locals_slot from a thread */
2582         guint32 offset;
2583         int idx;
2584         /* index in the locals_slot array */
2585         int slot;
2586 } LocalSlotID;
2587
2588 static void
2589 clear_local_slot (gpointer key, gpointer value, gpointer user_data)
2590 {
2591         LocalSlotID *sid = user_data;
2592         MonoThread *thread = (MonoThread*)value;
2593         MonoArray *slots_array;
2594         /*
2595          * the static field is stored at: ((char*) thread->static_data [idx]) + (offset & 0xffffff);
2596          * it is for the right domain, so we need to check if it is allocated an initialized
2597          * for the current thread.
2598          */
2599         /*g_print ("handling thread %p\n", thread);*/
2600         if (!thread->static_data || !thread->static_data [sid->idx])
2601                 return;
2602         slots_array = *(MonoArray **)(((char*) thread->static_data [sid->idx]) + (sid->offset & 0xffffff));
2603         if (!slots_array || sid->slot >= mono_array_length (slots_array))
2604                 return;
2605         mono_array_set (slots_array, MonoObject*, sid->slot, NULL);
2606 }
2607
2608 void
2609 mono_thread_free_local_slot_values (int slot, MonoBoolean thread_local)
2610 {
2611         MonoDomain *domain;
2612         LocalSlotID sid;
2613         sid.slot = slot;
2614         if (thread_local) {
2615                 void *addr = NULL;
2616                 if (!local_slots) {
2617                         local_slots = mono_class_get_field_from_name (mono_defaults.thread_class, "local_slots");
2618                         if (!local_slots) {
2619                                 g_warning ("local_slots field not found in Thread class");
2620                                 return;
2621                         }
2622                 }
2623                 domain = mono_domain_get ();
2624                 mono_domain_lock (domain);
2625                 if (domain->special_static_fields)
2626                         addr = g_hash_table_lookup (domain->special_static_fields, local_slots);
2627                 mono_domain_unlock (domain);
2628                 if (!addr)
2629                         return;
2630                 /*g_print ("freeing slot %d at %p\n", slot, addr);*/
2631                 sid.offset = GPOINTER_TO_UINT (addr);
2632                 sid.offset &= 0x7fffffff;
2633                 sid.idx = (sid.offset >> 24) - 1;
2634                 mono_threads_lock ();
2635                 mono_g_hash_table_foreach (threads, clear_local_slot, &sid);
2636                 mono_threads_unlock ();
2637         } else {
2638                 /* FIXME: clear the slot for MonoAppContexts, too */
2639         }
2640 }
2641
2642 #ifdef __MINGW32__
2643 static CALLBACK void dummy_apc (ULONG_PTR param)
2644 {
2645 }
2646 #else
2647 static guint32 dummy_apc (gpointer param)
2648 {
2649         return 0;
2650 }
2651 #endif
2652
2653 /*
2654  * mono_thread_execute_interruption
2655  *
2656  * Performs the operation that the requested thread state requires (abort,
2657  * suspend or stop)
2658  */
2659 static MonoException* mono_thread_execute_interruption (MonoThread *thread)
2660 {
2661         mono_monitor_enter (thread->synch_lock);
2662
2663         if (thread->interruption_requested) {
2664                 /* this will consume pending APC calls */
2665                 WaitForSingleObjectEx (GetCurrentThread(), 0, TRUE);
2666                 InterlockedDecrement (&thread_interruption_requested);
2667                 thread->interruption_requested = FALSE;
2668         }
2669
2670         if ((thread->state & ThreadState_AbortRequested) != 0) {
2671                 if (thread->abort_exc == NULL)
2672                         MONO_OBJECT_SETREF (thread, abort_exc, mono_get_exception_thread_abort ());
2673                 mono_monitor_exit (thread->synch_lock);
2674                 return thread->abort_exc;
2675         }
2676         else if ((thread->state & ThreadState_SuspendRequested) != 0) {
2677                 thread->state &= ~ThreadState_SuspendRequested;
2678                 thread->state |= ThreadState_Suspended;
2679                 thread->suspend_event = CreateEvent (NULL, TRUE, FALSE, NULL);
2680                 if (thread->suspended_event)
2681                         SetEvent (thread->suspended_event);
2682                 mono_monitor_exit (thread->synch_lock);
2683
2684                 WaitForSingleObject (thread->suspend_event, INFINITE);
2685
2686                 mono_monitor_enter (thread->synch_lock);
2687                 CloseHandle (thread->suspend_event);
2688                 thread->suspend_event = NULL;
2689                 thread->state &= ~ThreadState_Suspended;
2690
2691                 /* The thread that requested the resume will have replaced this event
2692                  * and will be waiting for it
2693                  */
2694                 SetEvent (thread->resume_event);
2695                 mono_monitor_exit (thread->synch_lock);
2696                 return NULL;
2697         }
2698         else if ((thread->state & ThreadState_StopRequested) != 0) {
2699                 /* FIXME: do this through the JIT? */
2700                 mono_monitor_exit (thread->synch_lock);
2701                 mono_thread_exit ();
2702                 return NULL;
2703         }
2704
2705         mono_monitor_exit (thread->synch_lock);
2706         return NULL;
2707 }
2708
2709 /*
2710  * mono_thread_request_interruption
2711  *
2712  * A signal handler can call this method to request the interruption of a
2713  * thread. The result of the interruption will depend on the current state of
2714  * the thread. If the result is an exception that needs to be throw, it is
2715  * provided as return value.
2716  */
2717 MonoException* mono_thread_request_interruption (gboolean running_managed)
2718 {
2719         MonoThread *thread = mono_thread_current ();
2720
2721         /* The thread may already be stopping */
2722         if (thread == NULL)
2723                 return NULL;
2724
2725         mono_monitor_enter (thread->synch_lock);
2726
2727         if (thread->interruption_requested) {
2728                 mono_monitor_exit (thread->synch_lock);
2729                 return NULL;
2730         }
2731
2732         if (!running_managed || is_running_protected_wrapper ()) {
2733                 /* Can't stop while in unmanaged code. Increase the global interruption
2734                    request count. When exiting the unmanaged method the count will be
2735                    checked and the thread will be interrupted. */
2736
2737                 InterlockedIncrement (&thread_interruption_requested);
2738                 thread->interruption_requested = TRUE;
2739                 mono_monitor_exit (thread->synch_lock);
2740
2741                 /* this will awake the thread if it is in WaitForSingleObject
2742                    or similar */
2743                 QueueUserAPC ((PAPCFUNC)dummy_apc, thread->handle, NULL);
2744                 return NULL;
2745         }
2746         else {
2747                 mono_monitor_exit (thread->synch_lock);
2748                 return mono_thread_execute_interruption (thread);
2749         }
2750 }
2751
2752 gboolean mono_thread_interruption_requested ()
2753 {
2754         if (thread_interruption_requested) {
2755                 MonoThread *thread = mono_thread_current ();
2756                 /* The thread may already be stopping */
2757                 if (thread != NULL)
2758                         return (thread->interruption_requested);
2759         }
2760         return FALSE;
2761 }
2762
2763 static void mono_thread_interruption_checkpoint_request (gboolean bypass_abort_protection)
2764 {
2765         MonoThread *thread = mono_thread_current ();
2766
2767         /* The thread may already be stopping */
2768         if (thread == NULL)
2769                 return;
2770
2771         if (thread->interruption_requested && (bypass_abort_protection || !is_running_protected_wrapper ())) {
2772                 MonoException* exc = mono_thread_execute_interruption (thread);
2773                 if (exc) mono_raise_exception (exc);
2774         }
2775 }
2776
2777 /*
2778  * Performs the interruption of the current thread, if one has been requested,
2779  * and the thread is not running a protected wrapper.
2780  */
2781 void mono_thread_interruption_checkpoint ()
2782 {
2783         mono_thread_interruption_checkpoint_request (FALSE);
2784 }
2785
2786 /*
2787  * Performs the interruption of the current thread, if one has been requested.
2788  */
2789 void mono_thread_force_interruption_checkpoint ()
2790 {
2791         mono_thread_interruption_checkpoint_request (TRUE);
2792 }
2793
2794 /**
2795  * mono_thread_interruption_request_flag:
2796  *
2797  * Returns the address of a flag that will be non-zero if an interruption has
2798  * been requested for a thread. The thread to interrupt may not be the current
2799  * thread, so an additional call to mono_thread_interruption_requested() or
2800  * mono_thread_interruption_checkpoint() is allways needed if the flag is not
2801  * zero.
2802  */
2803 gint32* mono_thread_interruption_request_flag ()
2804 {
2805         return &thread_interruption_requested;
2806 }