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 #include <mono/metadata/appdomain.h>
  18 #include <mono/metadata/domain-internals.h>
  19
  20 #include <errno.h>
  21
  22 #if defined(__MACH__)
  23 #include <mono/utils/mach-support.h>
  24 #endif
  25
  26 #define THREADS_DEBUG(...)
  27 //#define THREADS_DEBUG(...) g_message(__VA_ARGS__)
  28
  29 /*
  30 Mutex that makes sure only a single thread can be suspending others.
  31 Suspend is a very racy operation since it requires restarting until
  32 the target thread is not on an unsafe region.
  33
  34 We could implement this using critical regions, but would be much much
  35 harder for an operation that is hardly performance critical.
  36
  37 The GC has to acquire this lock before starting a STW to make sure
  38 a runtime suspend won't make it wronly see a thread in a safepoint
  39 when it is in fact not.
  40 */
  41 static MonoSemType global_suspend_semaphore;
  42
  43 static int thread_info_size;
  44 static MonoThreadInfoCallbacks threads_callbacks;
  45 static MonoThreadInfoRuntimeCallbacks runtime_callbacks;
  46 static MonoNativeTlsKey thread_info_key, small_id_key;
  47 static MonoLinkedListSet thread_list;
  48 static gboolean disable_new_interrupt = FALSE;
  49 static gboolean mono_threads_inited = FALSE;
  50
  51 static void mono_threads_unregister_current_thread (MonoThreadInfo *info);
  52
  53
  54 static inline void
  55 mono_hazard_pointer_clear_all (MonoThreadHazardPointers *hp, int retain)
  56 {
  57         if (retain != 0)
  58                 mono_hazard_pointer_clear (hp, 0);
  59         if (retain != 1)
  60                 mono_hazard_pointer_clear (hp, 1);
  61         if (retain != 2)
  62                 mono_hazard_pointer_clear (hp, 2);
  63 }
  64
  65 /*
  66 If return non null Hazard Pointer 1 holds the return value.
  67 */
  68 MonoThreadInfo*
  69 mono_thread_info_lookup (MonoNativeThreadId id)
  70 {
  71                 MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
  72
  73         if (!mono_lls_find (&thread_list, hp, (uintptr_t)id)) {
  74                 mono_hazard_pointer_clear_all (hp, -1);
  75                 return NULL;
  76         }
  77
  78         mono_hazard_pointer_clear_all (hp, 1);
  79         return mono_hazard_pointer_get_val (hp, 1);
  80 }
  81
  82 static gboolean
  83 mono_thread_info_insert (MonoThreadInfo *info)
  84 {
  85         MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
  86
  87         if (!mono_lls_insert (&thread_list, hp, (MonoLinkedListSetNode*)info)) {
  88                 mono_hazard_pointer_clear_all (hp, -1);
  89                 return FALSE;
  90         }
  91
  92         mono_hazard_pointer_clear_all (hp, -1);
  93         return TRUE;
  94 }
  95
  96 static gboolean
  97 mono_thread_info_remove (MonoThreadInfo *info)
  98 {
  99         MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
 100         gboolean res;
 101
 102         THREADS_DEBUG ("removing info %p\n", info);
 103         res = mono_lls_remove (&thread_list, hp, (MonoLinkedListSetNode*)info);
 104         mono_hazard_pointer_clear_all (hp, -1);
 105         return res;
 106 }
 107
 108 static void
 109 free_thread_info (gpointer mem)
 110 {
 111         MonoThreadInfo *info = mem;
 112
 113         MONO_SEM_DESTROY (&info->suspend_semaphore);
 114         MONO_SEM_DESTROY (&info->resume_semaphore);
 115         MONO_SEM_DESTROY (&info->finish_resume_semaphore);
 116         mono_threads_platform_free (info);
 117
 118         g_free (info);
 119 }
 120
 121 int
 122 mono_thread_info_register_small_id (void)
 123 {
 124         int small_id = mono_thread_small_id_alloc ();
 125         mono_native_tls_set_value (small_id_key, GUINT_TO_POINTER (small_id + 1));
 126         return small_id;
 127 }
 128
 129 static void*
 130 register_thread (MonoThreadInfo *info, gpointer baseptr)
 131 {
 132         int small_id = mono_thread_info_register_small_id ();
 133         gboolean result;
 134         mono_thread_info_set_tid (info, mono_native_thread_id_get ());
 135         info->small_id = small_id;
 136
 137         MONO_SEM_INIT (&info->suspend_semaphore, 1);
 138         MONO_SEM_INIT (&info->resume_semaphore, 0);
 139         MONO_SEM_INIT (&info->finish_resume_semaphore, 0);
 140
 141         /*set TLS early so SMR works */
 142         mono_native_tls_set_value (thread_info_key, info);
 143
 144         THREADS_DEBUG ("registering info %p tid %p small id %x\n", info, mono_thread_info_get_tid (info), info->small_id);
 145
 146         if (threads_callbacks.thread_register) {
 147                 if (threads_callbacks.thread_register (info, baseptr) == NULL) {
 148                         g_warning ("thread registation failed\n");
 149                         g_free (info);
 150                         return NULL;
 151                 }
 152         }
 153
 154         mono_threads_platform_register (info);
 155         info->thread_state = STATE_RUNNING;
 156         mono_thread_info_suspend_lock ();
 157         /*If this fail it means a given thread has been registered twice, which doesn't make sense. */
 158         result = mono_thread_info_insert (info);
 159         g_assert (result);
 160         mono_thread_info_suspend_unlock ();
 161         return info;
 162 }
 163
 164 static void
 165 unregister_thread (void *arg)
 166 {
 167         MonoThreadInfo *info = arg;
 168         int small_id = info->small_id;
 169         g_assert (info);
 170
 171         THREADS_DEBUG ("unregistering info %p\n", 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_dettach (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_dettach 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         if (!info)
 451                 return FALSE;
 452
 453         MONO_SEM_WAIT_UNITERRUPTIBLE (&info->suspend_semaphore);
 454
 455         THREADS_DEBUG ("resume %x IN COUNT %d\n",tid, info->suspend_count);
 456
 457         if (info->suspend_count <= 0) {
 458                 MONO_SEM_POST (&info->suspend_semaphore);
 459                 mono_hazard_pointer_clear (hp, 1);
 460                 return FALSE;
 461         }
 462
 463         /*
 464          * The theory here is that if we manage to suspend the thread it means it did not
 465          * start cleanup since it take the same lock.
 466         */
 467         g_assert (mono_thread_info_get_tid (info));
 468
 469         if (--info->suspend_count == 0)
 470                 result = mono_thread_info_resume_internal (info);
 471
 472         MONO_SEM_POST (&info->suspend_semaphore);
 473         mono_hazard_pointer_clear (hp, 1);
 474         mono_atomic_store_release (&mono_thread_info_current ()->inside_critical_region, FALSE);
 475
 476         return result;
 477 }
 478
 479 void
 480 mono_thread_info_finish_suspend (void)
 481 {
 482         mono_atomic_store_release (&mono_thread_info_current ()->inside_critical_region, FALSE);
 483 }
 484
 485 /*
 486 FIXME fix cardtable WB to be out of line and check with the runtime if the target is not the
 487 WB trampoline. Another option is to encode wb ranges in MonoJitInfo, but that is somewhat hard.
 488 */
 489 static gboolean
 490 is_thread_in_critical_region (MonoThreadInfo *info)
 491 {
 492         MonoMethod *method;
 493         MonoJitInfo *ji;
 494
 495         if (info->inside_critical_region)
 496                 return TRUE;
 497
 498         ji = mono_jit_info_table_find (
 499                 info->suspend_state.unwind_data [MONO_UNWIND_DATA_DOMAIN],
 500                 MONO_CONTEXT_GET_IP (&info->suspend_state.ctx));
 501
 502         if (!ji)
 503                 return FALSE;
 504
 505         method = mono_jit_info_get_method (ji);
 506
 507         return threads_callbacks.mono_method_is_critical (method);
 508 }
 509
 510 /*
 511 WARNING:
 512 If we are trying to suspend a target that is on a critical region
 513 and running a syscall we risk looping forever if @interrupt_kernel is FALSE.
 514 So, be VERY carefull in calling this with @interrupt_kernel == FALSE.
 515 */
 516 MonoThreadInfo*
 517 mono_thread_info_safe_suspend_sync (MonoNativeThreadId id, gboolean interrupt_kernel)
 518 {
 519         MonoThreadInfo *info = NULL;
 520         int sleep_duration = 0;
 521
 522         /*FIXME: unify this with self-suspend*/
 523         g_assert (id != mono_native_thread_id_get ());
 524
 525         mono_thread_info_suspend_lock ();
 526
 527         for (;;) {
 528                 if (!(info = mono_thread_info_suspend_sync (id, interrupt_kernel))) {
 529                         g_warning ("failed to suspend thread %p, hopefully it is dead", (gpointer)id);
 530                         mono_thread_info_suspend_unlock ();
 531                         return NULL;
 532                 }
 533                 /*WARNING: We now are in interrupt context until we resume the thread. */
 534                 if (!is_thread_in_critical_region (info))
 535                         break;
 536
 537                 if (!mono_thread_info_resume (id)) {
 538                         g_warning ("failed to result thread %p, hopefully it is dead", (gpointer)id);
 539                         mono_thread_info_suspend_unlock ();
 540                         return NULL;
 541                 }
 542                 THREADS_DEBUG ("restarted thread %p\n", (gpointer)id);
 543
 544                 if (!sleep_duration) {
 545 #ifdef HOST_WIN32
 546                         SwitchToThread ();
 547 #else
 548                         sched_yield ();
 549 #endif
 550                 }
 551                 else {
 552                         g_usleep (sleep_duration);
 553                 }
 554                 sleep_duration += 10;
 555         }
 556
 557         mono_atomic_store_release (&mono_thread_info_current ()->inside_critical_region, TRUE);
 558
 559         mono_thread_info_suspend_unlock ();
 560         return info;
 561 }
 562
 563 /**
 564 Inject an assynchronous call into the target thread. The target thread must be suspended and
 565 only a single async call can be setup for a given suspend cycle.
 566 This async call must cause stack unwinding as the current implementation doesn't save enough state
 567 to resume execution of the top-of-stack function. It's an acceptable limitation since this is
 568 currently used only to deliver exceptions.
 569 */
 570 void
 571 mono_thread_info_setup_async_call (MonoThreadInfo *info, void (*target_func)(void*), void *user_data)
 572 {
 573         g_assert (info->suspend_count);
 574         /*FIXME this is a bad assert, we probably should do proper locking and fail if one is already set*/
 575         g_assert (!info->async_target);
 576         info->async_target = target_func;
 577         /* This is not GC tracked */
 578         info->user_data = user_data;
 579 }
 580
 581 /*
 582 The suspend lock is held during any suspend in progress.
 583 A GC that has safepoints must take this lock as part of its
 584 STW to make sure no unsafe pending suspend is in progress.
 585 */
 586 void
 587 mono_thread_info_suspend_lock (void)
 588 {
 589         MONO_SEM_WAIT_UNITERRUPTIBLE (&global_suspend_semaphore);
 590 }
 591
 592 void
 593 mono_thread_info_suspend_unlock (void)
 594 {
 595         MONO_SEM_POST (&global_suspend_semaphore);
 596 }
 597
 598 void
 599 mono_thread_info_disable_new_interrupt (gboolean disable)
 600 {
 601         disable_new_interrupt = disable;
 602 }
 603
 604 /*
 605  * This is a very specific function whose only purpose is to
 606  * break a given thread from socket syscalls.
 607  *
 608  * This only exists because linux won't fail a call to connect
 609  * if the underlying is closed.
 610  *
 611  * TODO We should cleanup and unify this with the other syscall abort
 612  * facility.
 613  */
 614 void
 615 mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid)
 616 {
 617         MonoThreadHazardPointers *hp;
 618         MonoThreadInfo *info;
 619
 620         if (tid == mono_native_thread_id_get () || !mono_threads_core_needs_abort_syscall ())
 621                 return;
 622
 623         hp = mono_hazard_pointer_get ();
 624         info = mono_thread_info_lookup (tid); /*info on HP1*/
 625         if (!info)
 626                 return;
 627
 628         if (mono_thread_info_run_state (info) > STATE_RUNNING) {
 629                 mono_hazard_pointer_clear (hp, 1);
 630                 return;
 631         }
 632
 633         mono_thread_info_suspend_lock ();
 634
 635         mono_threads_core_abort_syscall (info);
 636
 637         mono_hazard_pointer_clear (hp, 1);
 638         mono_thread_info_suspend_unlock ();
 639 }
 640
 641 /*
 642 Disabled by default for now.
 643 To enable this we need mini to implement the callbacks by MonoThreadInfoRuntimeCallbacks
 644 which means mono-context and setup_async_callback, and we need a mono-threads backend.
 645 */
 646 gboolean
 647 mono_thread_info_new_interrupt_enabled (void)
 648 {
 649         /*We need STW gc events to work correctly*/
 650 #if defined (HAVE_BOEHM_GC) && !defined (USE_INCLUDED_LIBGC)
 651         return FALSE;
 652 #endif
 653         /*port not done*/
 654 #if defined(HOST_WIN32)
 655         return FALSE;
 656 #endif
 657 #if defined (__i386__)
 658         return !disable_new_interrupt;
 659 #endif
 660         return FALSE;
 661 }
 662
 663 /*
 664  * mono_thread_info_set_is_async_context:
 665  *
 666  *   Set whenever the current thread is in an async context. Some runtime functions might behave
 667  * differently while in an async context in order to be async safe.
 668  */
 669 void
 670 mono_thread_info_set_is_async_context (gboolean async_context)
 671 {
 672         MonoThreadInfo *info = mono_thread_info_current ();
 673
 674         if (info)
 675                 info->is_async_context = async_context;
 676 }
 677
 678 gboolean
 679 mono_thread_info_is_async_context (void)
 680 {
 681         MonoThreadInfo *info = mono_thread_info_current ();
 682
 683         if (info)
 684                 return info->is_async_context;
 685         else
 686                 return FALSE;
 687 }
 688