mono/utils/mono-threads.c

   1 /*
   2  * mono-threads.c: Low-level threading
   3  *
   4  * Author:
   5  *      Rodrigo Kumpera (kumpera@gmail.com)
   6  *
   7  * Copyright 2011 Novell, Inc (http://www.novell.com)
   8  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
   9  */
  10
  11 #include <mono/utils/mono-compiler.h>
  12 #include <mono/utils/mono-semaphore.h>
  13 #include <mono/utils/mono-threads.h>
  14 #include <mono/utils/mono-tls.h>
  15 #include <mono/utils/hazard-pointer.h>
  16 #include <mono/utils/mono-memory-model.h>
  17
  18 #include <errno.h>
  19
  20 #if defined(__MACH__)
  21 #include <mono/utils/mach-support.h>
  22 #endif
  23
  24 #define THREADS_DEBUG(...)
  25 //#define THREADS_DEBUG(...) g_message(__VA_ARGS__)
  26
  27 /*
  28 Mutex that makes sure only a single thread can be suspending others.
  29 Suspend is a very racy operation since it requires restarting until
  30 the target thread is not on an unsafe region.
  31
  32 We could implement this using critical regions, but would be much much
  33 harder for an operation that is hardly performance critical.
  34
  35 The GC has to acquire this lock before starting a STW to make sure
  36 a runtime suspend won't make it wronly see a thread in a safepoint
  37 when it is in fact not.
  38 */
  39 static MonoSemType global_suspend_semaphore;
  40
  41 static int thread_info_size;
  42 static MonoThreadInfoCallbacks threads_callbacks;
  43 static MonoThreadInfoRuntimeCallbacks runtime_callbacks;
  44 static MonoNativeTlsKey thread_info_key, small_id_key;
  45 static MonoLinkedListSet thread_list;
  46 static gboolean disable_new_interrupt = FALSE;
  47 static gboolean mono_threads_inited = FALSE;
  48
  49 static void mono_threads_unregister_current_thread (MonoThreadInfo *info);
  50
  51
  52 static inline void
  53 mono_hazard_pointer_clear_all (MonoThreadHazardPointers *hp, int retain)
  54 {
  55         if (retain != 0)
  56                 mono_hazard_pointer_clear (hp, 0);
  57         if (retain != 1)
  58                 mono_hazard_pointer_clear (hp, 1);
  59         if (retain != 2)
  60                 mono_hazard_pointer_clear (hp, 2);
  61 }
  62
  63 /*
  64 If return non null Hazard Pointer 1 holds the return value.
  65 */
  66 MonoThreadInfo*
  67 mono_thread_info_lookup (MonoNativeThreadId id)
  68 {
  69                 MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
  70
  71         if (!mono_lls_find (&thread_list, hp, (uintptr_t)id)) {
  72                 mono_hazard_pointer_clear_all (hp, -1);
  73                 return NULL;
  74         }
  75
  76         mono_hazard_pointer_clear_all (hp, 1);
  77         return mono_hazard_pointer_get_val (hp, 1);
  78 }
  79
  80 static gboolean
  81 mono_thread_info_insert (MonoThreadInfo *info)
  82 {
  83         MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
  84
  85         if (!mono_lls_insert (&thread_list, hp, (MonoLinkedListSetNode*)info)) {
  86                 mono_hazard_pointer_clear_all (hp, -1);
  87                 return FALSE;
  88         }
  89
  90         mono_hazard_pointer_clear_all (hp, -1);
  91         return TRUE;
  92 }
  93
  94 static gboolean
  95 mono_thread_info_remove (MonoThreadInfo *info)
  96 {
  97         MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
  98         gboolean res;
  99
 100         THREADS_DEBUG ("removing info %p\n", info);
 101         res = mono_lls_remove (&thread_list, hp, (MonoLinkedListSetNode*)info);
 102         mono_hazard_pointer_clear_all (hp, -1);
 103         return res;
 104 }
 105
 106 static void
 107 free_thread_info (gpointer mem)
 108 {
 109         MonoThreadInfo *info = mem;
 110
 111         MONO_SEM_DESTROY (&info->suspend_semaphore);
 112         MONO_SEM_DESTROY (&info->resume_semaphore);
 113         MONO_SEM_DESTROY (&info->finish_resume_semaphore);
 114         mono_threads_platform_free (info);
 115
 116         g_free (info);
 117 }
 118
 119 int
 120 mono_thread_info_register_small_id (void)
 121 {
 122         int small_id = mono_thread_small_id_alloc ();
 123         mono_native_tls_set_value (small_id_key, GUINT_TO_POINTER (small_id + 1));
 124         return small_id;
 125 }
 126
 127 static void*
 128 register_thread (MonoThreadInfo *info, gpointer baseptr)
 129 {
 130         int small_id = mono_thread_info_register_small_id ();
 131         gboolean result;
 132         mono_thread_info_set_tid (info, mono_native_thread_id_get ());
 133         info->small_id = small_id;
 134
 135         MONO_SEM_INIT (&info->suspend_semaphore, 1);
 136         MONO_SEM_INIT (&info->resume_semaphore, 0);
 137         MONO_SEM_INIT (&info->finish_resume_semaphore, 0);
 138
 139         /*set TLS early so SMR works */
 140         mono_native_tls_set_value (thread_info_key, info);
 141
 142         THREADS_DEBUG ("registering info %p tid %p small id %x\n", info, mono_thread_info_get_tid (info), info->small_id);
 143
 144         if (threads_callbacks.thread_register) {
 145                 if (threads_callbacks.thread_register (info, baseptr) == NULL) {
 146                         g_warning ("thread registation failed\n");
 147                         g_free (info);
 148                         return NULL;
 149                 }
 150         }
 151
 152         mono_threads_platform_register (info);
 153         info->thread_state = STATE_RUNNING;
 154         mono_thread_info_suspend_lock ();
 155         /*If this fail it means a given thread has been registered twice, which doesn't make sense. */
 156         result = mono_thread_info_insert (info);
 157         g_assert (result);
 158         mono_thread_info_suspend_unlock ();
 159         return info;
 160 }
 161
 162 static void
 163 unregister_thread (void *arg)
 164 {
 165         MonoThreadInfo *info = arg;
 166         int small_id = info->small_id;
 167         g_assert (info);
 168
 169         THREADS_DEBUG ("unregistering info %p\n", info);
 170
 171         mono_threads_core_unregister (info);
 172
 173         /*
 174          * TLS destruction order is not reliable so small_id might be cleaned up
 175          * before us.
 176          */
 177         mono_native_tls_set_value (small_id_key, GUINT_TO_POINTER (info->small_id + 1));
 178
 179         info->thread_state = STATE_SHUTTING_DOWN;
 180
 181         /*
 182         First perform the callback that requires no locks.
 183         This callback has the potential of taking other locks, so we do it before.
 184         After it completes, the thread remains functional.
 185         */
 186         if (threads_callbacks.thread_detach)
 187                 threads_callbacks.thread_detach (info);
 188
 189         mono_thread_info_suspend_lock ();
 190
 191         /*
 192         Now perform the callback that must be done under locks.
 193         This will render the thread useless and non-suspendable, so it must
 194         be done while holding the suspend lock to give no other thread chance
 195         to suspend it.
 196         */
 197         if (threads_callbacks.thread_unregister)
 198                 threads_callbacks.thread_unregister (info);
 199         mono_threads_unregister_current_thread (info);
 200
 201         info->thread_state = STATE_DEAD;
 202         mono_thread_info_suspend_unlock ();
 203
 204         /*now it's safe to free the thread info.*/
 205         mono_thread_hazardous_free_or_queue (info, free_thread_info, TRUE, FALSE);
 206         mono_thread_small_id_free (small_id);
 207 }
 208
 209 /**
 210  * Removes the current thread from the thread list.
 211  * This must be called from the thread unregister callback and nowhere else.
 212  * The current thread must be passed as TLS might have already been cleaned up.
 213 */
 214 static void
 215 mono_threads_unregister_current_thread (MonoThreadInfo *info)
 216 {
 217         gboolean result;
 218         g_assert (mono_thread_info_get_tid (info) == mono_native_thread_id_get ());
 219         result = mono_thread_info_remove (info);
 220         g_assert (result);
 221 }
 222
 223 MonoThreadInfo*
 224 mono_thread_info_current (void)
 225 {
 226         MonoThreadInfo *info = (MonoThreadInfo*)mono_native_tls_get_value (thread_info_key);
 227         if (info)
 228                 return info;
 229
 230         info = mono_thread_info_lookup (mono_native_thread_id_get ()); /*info on HP1*/
 231
 232         /*
 233         We might be called during thread cleanup, but we cannot be called after cleanup as happened.
 234         The way to distinguish between before, during and after cleanup is the following:
 235
 236         -If the TLS key is set, cleanup has not begun;
 237         -If the TLS key is clean, but the thread remains registered, cleanup is in progress;
 238         -If the thread is nowhere to be found, cleanup has finished.
 239
 240         We cannot function after cleanup since there's no way to ensure what will happen.
 241         */
 242         g_assert (info);
 243
 244         /*We're looking up the current thread which will not be freed until we finish running, so no need to keep it on a HP */
 245         mono_hazard_pointer_clear (mono_hazard_pointer_get (), 1);
 246
 247         return info;
 248 }
 249
 250 int
 251 mono_thread_info_get_small_id (void)
 252 {
 253         gpointer val = mono_native_tls_get_value (small_id_key);
 254         if (!val)
 255                 return -1;
 256         return GPOINTER_TO_INT (val) - 1;
 257 }
 258
 259 MonoLinkedListSet*
 260 mono_thread_info_list_head (void)
 261 {
 262         return &thread_list;
 263 }
 264
 265 MonoThreadInfo*
 266 mono_thread_info_attach (void *baseptr)
 267 {
 268         MonoThreadInfo *info;
 269         if (!mono_threads_inited)
 270         {
 271                 /* This can happen from DllMain(DLL_THREAD_ATTACH) on Windows, if a
 272                  * thread is created before an embedding API user initialized Mono. */
 273                 THREADS_DEBUG ("mono_thread_info_attach called before mono_threads_init\n");
 274                 return NULL;
 275         }
 276         info = mono_native_tls_get_value (thread_info_key);
 277         if (!info) {
 278                 info = g_malloc0 (thread_info_size);
 279                 THREADS_DEBUG ("attaching %p\n", info);
 280                 if (!register_thread (info, baseptr))
 281                         return NULL;
 282         } else if (threads_callbacks.thread_attach) {
 283                 threads_callbacks.thread_attach (info);
 284         }
 285         return info;
 286 }
 287
 288 void
 289 mono_thread_info_detach (void)
 290 {
 291         MonoThreadInfo *info;
 292         if (!mono_threads_inited)
 293         {
 294                 /* This can happen from DllMain(THREAD_DETACH) on Windows, if a thread
 295                  * is created before an embedding API user initialized Mono. */
 296                 THREADS_DEBUG ("mono_thread_info_detach called before mono_threads_init\n");
 297                 return;
 298         }
 299         info = mono_native_tls_get_value (thread_info_key);
 300         if (info) {
 301                 THREADS_DEBUG ("detaching %p\n", info);
 302                 unregister_thread (info);
 303                 mono_native_tls_set_value (thread_info_key, NULL);
 304         }
 305 }
 306
 307 void
 308 mono_threads_init (MonoThreadInfoCallbacks *callbacks, size_t info_size)
 309 {
 310         gboolean res;
 311         threads_callbacks = *callbacks;
 312         thread_info_size = info_size;
 313 #ifdef HOST_WIN32
 314         res = mono_native_tls_alloc (&thread_info_key, NULL);
 315 #else
 316         res = mono_native_tls_alloc (&thread_info_key, unregister_thread);
 317 #endif
 318         g_assert (res);
 319
 320         res = mono_native_tls_alloc (&small_id_key, NULL);
 321         g_assert (res);
 322
 323         MONO_SEM_INIT (&global_suspend_semaphore, 1);
 324
 325         mono_lls_init (&thread_list, NULL);
 326         mono_thread_smr_init ();
 327         mono_threads_init_platform ();
 328
 329 #if defined(__MACH__)
 330         mono_mach_init (thread_info_key);
 331 #endif
 332
 333         mono_threads_inited = TRUE;
 334
 335         g_assert (sizeof (MonoNativeThreadId) <= sizeof (uintptr_t));
 336 }
 337
 338 void
 339 mono_threads_runtime_init (MonoThreadInfoRuntimeCallbacks *callbacks)
 340 {
 341         runtime_callbacks = *callbacks;
 342 }
 343
 344 MonoThreadInfoCallbacks *
 345 mono_threads_get_callbacks (void)
 346 {
 347         return &threads_callbacks;
 348 }
 349
 350 MonoThreadInfoRuntimeCallbacks *
 351 mono_threads_get_runtime_callbacks (void)
 352 {
 353         return &runtime_callbacks;
 354 }
 355
 356 /*
 357 The return value is only valid until a matching mono_thread_info_resume is called
 358 */
 359 static MonoThreadInfo*
 360 mono_thread_info_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel)
 361 {
 362         MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
 363         MonoThreadInfo *info = mono_thread_info_lookup (tid); /*info on HP1*/
 364         if (!info)
 365                 return NULL;
 366
 367         MONO_SEM_WAIT_UNITERRUPTIBLE (&info->suspend_semaphore);
 368
 369         /*thread is on the process of detaching*/
 370         if (mono_thread_info_run_state (info) > STATE_RUNNING) {
 371                 mono_hazard_pointer_clear (hp, 1);
 372                 return NULL;
 373         }
 374
 375         THREADS_DEBUG ("suspend %x IN COUNT %d\n", tid, info->suspend_count);
 376
 377         if (info->suspend_count) {
 378                 ++info->suspend_count;
 379                 mono_hazard_pointer_clear (hp, 1);
 380                 MONO_SEM_POST (&info->suspend_semaphore);
 381                 return info;
 382         }
 383
 384         if (!mono_threads_core_suspend (info)) {
 385                 MONO_SEM_POST (&info->suspend_semaphore);
 386                 mono_hazard_pointer_clear (hp, 1);
 387                 return NULL;
 388         }
 389
 390         if (interrupt_kernel)
 391                 mono_threads_core_interrupt (info);
 392
 393         ++info->suspend_count;
 394         info->thread_state |= STATE_SUSPENDED;
 395         MONO_SEM_POST (&info->suspend_semaphore);
 396         mono_hazard_pointer_clear (hp, 1);
 397
 398         return info;
 399 }
 400
 401 void
 402 mono_thread_info_self_suspend (void)
 403 {
 404         gboolean ret;
 405         MonoThreadInfo *info = mono_thread_info_current ();
 406         if (!info)
 407                 return;
 408
 409         MONO_SEM_WAIT_UNITERRUPTIBLE (&info->suspend_semaphore);
 410
 411         THREADS_DEBUG ("self suspend IN COUNT %d\n", info->suspend_count);
 412
 413         g_assert (info->suspend_count == 0);
 414         ++info->suspend_count;
 415
 416         info->thread_state |= STATE_SELF_SUSPENDED;
 417
 418         ret = mono_threads_get_runtime_callbacks ()->thread_state_init_from_sigctx (&info->suspend_state, NULL);
 419         g_assert (ret);
 420
 421         MONO_SEM_POST (&info->suspend_semaphore);
 422
 423         MONO_SEM_WAIT_UNITERRUPTIBLE (&info->resume_semaphore);
 424
 425         g_assert (!info->async_target); /*FIXME this should happen normally for suspend. */
 426         MONO_SEM_POST (&info->finish_resume_semaphore);
 427 }
 428
 429 static gboolean
 430 mono_thread_info_resume_internal (MonoThreadInfo *info)
 431 {
 432         gboolean result;
 433         if (mono_thread_info_suspend_state (info) == STATE_SELF_SUSPENDED) {
 434                 MONO_SEM_POST (&info->resume_semaphore);
 435                 MONO_SEM_WAIT_UNITERRUPTIBLE (&info->finish_resume_semaphore);
 436                 result = TRUE;
 437         } else {
 438                 result = mono_threads_core_resume (info);
 439         }
 440         info->thread_state &= ~SUSPEND_STATE_MASK;
 441         return result;
 442 }
 443
 444 gboolean
 445 mono_thread_info_resume (MonoNativeThreadId tid)
 446 {
 447         gboolean result = TRUE;
 448         MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
 449         MonoThreadInfo *info = mono_thread_info_lookup (tid); /*info on HP1*/
 450
 451         if (!info)
 452                 return FALSE;
 453
 454         if (info->create_suspended) {
 455                 /* Have to special case this, as the normal suspend/resume pair are racy, they don't work if he resume is received before the suspend */
 456                 info->create_suspended = FALSE;
 457                 mono_threads_core_resume_created (info, tid);
 458                 return TRUE;
 459         }
 460
 461         MONO_SEM_WAIT_UNITERRUPTIBLE (&info->suspend_semaphore);
 462
 463         THREADS_DEBUG ("resume %x IN COUNT %d\n",tid, info->suspend_count);
 464
 465         if (info->suspend_count <= 0) {
 466                 MONO_SEM_POST (&info->suspend_semaphore);
 467                 mono_hazard_pointer_clear (hp, 1);
 468                 return FALSE;
 469         }
 470
 471         /*
 472          * The theory here is that if we manage to suspend the thread it means it did not
 473          * start cleanup since it take the same lock.
 474         */
 475         g_assert (mono_thread_info_get_tid (info));
 476
 477         if (--info->suspend_count == 0)
 478                 result = mono_thread_info_resume_internal (info);
 479
 480         MONO_SEM_POST (&info->suspend_semaphore);
 481         mono_hazard_pointer_clear (hp, 1);
 482         mono_atomic_store_release (&mono_thread_info_current ()->inside_critical_region, FALSE);
 483
 484         return result;
 485 }
 486
 487 void
 488 mono_thread_info_finish_suspend (void)
 489 {
 490         mono_atomic_store_release (&mono_thread_info_current ()->inside_critical_region, FALSE);
 491 }
 492
 493 /*
 494 FIXME fix cardtable WB to be out of line and check with the runtime if the target is not the
 495 WB trampoline. Another option is to encode wb ranges in MonoJitInfo, but that is somewhat hard.
 496 */
 497 static gboolean
 498 is_thread_in_critical_region (MonoThreadInfo *info)
 499 {
 500         MonoMethod *method;
 501         MonoJitInfo *ji;
 502
 503         if (info->inside_critical_region)
 504                 return TRUE;
 505
 506         /* The target thread might be shutting down and the domain might be null, which means no managed code left to run. */
 507         if (!info->suspend_state.unwind_data [MONO_UNWIND_DATA_DOMAIN])
 508                 return FALSE;
 509
 510         ji = mono_jit_info_table_find (
 511                 info->suspend_state.unwind_data [MONO_UNWIND_DATA_DOMAIN],
 512                 MONO_CONTEXT_GET_IP (&info->suspend_state.ctx));
 513
 514         if (!ji)
 515                 return FALSE;
 516
 517         method = mono_jit_info_get_method (ji);
 518
 519         return threads_callbacks.mono_method_is_critical (method);
 520 }
 521
 522 /*
 523 WARNING:
 524 If we are trying to suspend a target that is on a critical region
 525 and running a syscall we risk looping forever if @interrupt_kernel is FALSE.
 526 So, be VERY carefull in calling this with @interrupt_kernel == FALSE.
 527 */
 528 MonoThreadInfo*
 529 mono_thread_info_safe_suspend_sync (MonoNativeThreadId id, gboolean interrupt_kernel)
 530 {
 531         MonoThreadInfo *info = NULL;
 532         int sleep_duration = 0;
 533
 534         /*FIXME: unify this with self-suspend*/
 535         g_assert (id != mono_native_thread_id_get ());
 536
 537         mono_thread_info_suspend_lock ();
 538
 539         for (;;) {
 540                 if (!(info = mono_thread_info_suspend_sync (id, interrupt_kernel))) {
 541                         g_warning ("failed to suspend thread %p, hopefully it is dead", (gpointer)id);
 542                         mono_thread_info_suspend_unlock ();
 543                         return NULL;
 544                 }
 545                 /*WARNING: We now are in interrupt context until we resume the thread. */
 546                 if (!is_thread_in_critical_region (info))
 547                         break;
 548
 549                 if (!mono_thread_info_resume (id)) {
 550                         g_warning ("failed to result thread %p, hopefully it is dead", (gpointer)id);
 551                         mono_thread_info_suspend_unlock ();
 552                         return NULL;
 553                 }
 554                 THREADS_DEBUG ("restarted thread %p\n", (gpointer)id);
 555
 556                 if (!sleep_duration) {
 557 #ifdef HOST_WIN32
 558                         SwitchToThread ();
 559 #else
 560                         sched_yield ();
 561 #endif
 562                 }
 563                 else {
 564                         g_usleep (sleep_duration);
 565                 }
 566                 sleep_duration += 10;
 567         }
 568
 569         mono_atomic_store_release (&mono_thread_info_current ()->inside_critical_region, TRUE);
 570
 571         mono_thread_info_suspend_unlock ();
 572         return info;
 573 }
 574
 575 /**
 576 Inject an assynchronous call into the target thread. The target thread must be suspended and
 577 only a single async call can be setup for a given suspend cycle.
 578 This async call must cause stack unwinding as the current implementation doesn't save enough state
 579 to resume execution of the top-of-stack function. It's an acceptable limitation since this is
 580 currently used only to deliver exceptions.
 581 */
 582 void
 583 mono_thread_info_setup_async_call (MonoThreadInfo *info, void (*target_func)(void*), void *user_data)
 584 {
 585         g_assert (info->suspend_count);
 586         /*FIXME this is a bad assert, we probably should do proper locking and fail if one is already set*/
 587         g_assert (!info->async_target);
 588         info->async_target = target_func;
 589         /* This is not GC tracked */
 590         info->user_data = user_data;
 591 }
 592
 593 /*
 594 The suspend lock is held during any suspend in progress.
 595 A GC that has safepoints must take this lock as part of its
 596 STW to make sure no unsafe pending suspend is in progress.
 597 */
 598 void
 599 mono_thread_info_suspend_lock (void)
 600 {
 601         MONO_SEM_WAIT_UNITERRUPTIBLE (&global_suspend_semaphore);
 602 }
 603
 604 void
 605 mono_thread_info_suspend_unlock (void)
 606 {
 607         MONO_SEM_POST (&global_suspend_semaphore);
 608 }
 609
 610 void
 611 mono_thread_info_disable_new_interrupt (gboolean disable)
 612 {
 613         disable_new_interrupt = disable;
 614 }
 615
 616 /*
 617  * This is a very specific function whose only purpose is to
 618  * break a given thread from socket syscalls.
 619  *
 620  * This only exists because linux won't fail a call to connect
 621  * if the underlying is closed.
 622  *
 623  * TODO We should cleanup and unify this with the other syscall abort
 624  * facility.
 625  */
 626 void
 627 mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid)
 628 {
 629         MonoThreadHazardPointers *hp;
 630         MonoThreadInfo *info;
 631
 632         if (tid == mono_native_thread_id_get () || !mono_threads_core_needs_abort_syscall ())
 633                 return;
 634
 635         hp = mono_hazard_pointer_get ();
 636         info = mono_thread_info_lookup (tid); /*info on HP1*/
 637         if (!info)
 638                 return;
 639
 640         if (mono_thread_info_run_state (info) > STATE_RUNNING) {
 641                 mono_hazard_pointer_clear (hp, 1);
 642                 return;
 643         }
 644
 645         mono_thread_info_suspend_lock ();
 646
 647         mono_threads_core_abort_syscall (info);
 648
 649         mono_hazard_pointer_clear (hp, 1);
 650         mono_thread_info_suspend_unlock ();
 651 }
 652
 653 /*
 654 Disabled by default for now.
 655 To enable this we need mini to implement the callbacks by MonoThreadInfoRuntimeCallbacks
 656 which means mono-context and setup_async_callback, and we need a mono-threads backend.
 657 */
 658 gboolean
 659 mono_thread_info_new_interrupt_enabled (void)
 660 {
 661         /*We need STW gc events to work correctly*/
 662 #if defined (HAVE_BOEHM_GC) && !defined (USE_INCLUDED_LIBGC)
 663         return FALSE;
 664 #endif
 665         /*port not done*/
 666 #if defined(HOST_WIN32)
 667         return FALSE;
 668 #endif
 669 #if defined (__i386__)
 670         return !disable_new_interrupt;
 671 #endif
 672         return FALSE;
 673 }
 674
 675 /*
 676  * mono_thread_info_set_is_async_context:
 677  *
 678  *   Set whenever the current thread is in an async context. Some runtime functions might behave
 679  * differently while in an async context in order to be async safe.
 680  */
 681 void
 682 mono_thread_info_set_is_async_context (gboolean async_context)
 683 {
 684         MonoThreadInfo *info = mono_thread_info_current ();
 685
 686         if (info)
 687                 info->is_async_context = async_context;
 688 }
 689
 690 gboolean
 691 mono_thread_info_is_async_context (void)
 692 {
 693         MonoThreadInfo *info = mono_thread_info_current ();
 694
 695         if (info)
 696                 return info->is_async_context;
 697         else
 698                 return FALSE;
 699 }
 700
 701 /*
 702  * mono_threads_create_thread:
 703  *
 704  *   Create a new thread executing START with argument ARG. Store its id into OUT_TID.
 705  * Returns: a windows or io-layer handle for the thread.
 706  */
 707 HANDLE
 708 mono_threads_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid)
 709 {
 710         return mono_threads_core_create_thread (start, arg, stack_size, creation_flags, out_tid);
 711 }
 712
 713 /*
 714  * mono_thread_info_get_stack_bounds:
 715  *
 716  *   Return the address and size of the current threads stack. Return NULL as the
 717  * stack address if the stack address cannot be determined.
 718  */
 719 void
 720 mono_thread_info_get_stack_bounds (guint8 **staddr, size_t *stsize)
 721 {
 722         return mono_threads_core_get_stack_bounds (staddr, stsize);
 723 }
 724
 725 gboolean
 726 mono_thread_info_yield (void)
 727 {
 728         return mono_threads_core_yield ();
 729 }
 730
 731 gpointer
 732 mono_thread_info_tls_get (THREAD_INFO_TYPE *info, MonoTlsKey key)
 733 {
 734         return ((MonoThreadInfo*)info)->tls [key];
 735 }
 736
 737 /*
 738  * mono_threads_info_tls_set:
 739  *
 740  *   Set the TLS key to VALUE in the info structure. This can be used to obtain
 741  * values of TLS variables for threads other than the current thread.
 742  * This should only be used for infrequently changing TLS variables, and it should
 743  * be paired with setting the real TLS variable since this provides no GC tracking.
 744  */
 745 void
 746 mono_thread_info_tls_set (THREAD_INFO_TYPE *info, MonoTlsKey key, gpointer value)
 747 {
 748         ((MonoThreadInfo*)info)->tls [key] = value;
 749 }
 750
 751 /*
 752  * mono_thread_info_exit:
 753  *
 754  *   Exit the current thread.
 755  * This function doesn't return.
 756  */
 757 void
 758 mono_thread_info_exit (void)
 759 {
 760         mono_threads_core_exit (0);
 761 }
 762
 763 /*
 764  * mono_thread_info_open_handle:
 765  *
 766  *   Return a io-layer/win32 handle for the current thread.
 767  * The handle need to be closed by calling CloseHandle () when it is no
 768  * longer needed.
 769  */
 770 HANDLE
 771 mono_thread_info_open_handle (void)
 772 {
 773         return mono_threads_core_open_handle ();
 774 }