mono/utils/mono-threads.h

   1 /*
   2  * mono-threads.h: Low-level threading
   3  *
   4  * Author:
   5  *      Rodrigo Kumpera (kumpera@gmail.com)
   6  *
   7  * (C) 2011 Novell, Inc
   8  */
   9
  10 #ifndef __MONO_THREADS_H__
  11 #define __MONO_THREADS_H__
  12
  13 #include <mono/utils/mono-semaphore.h>
  14 #include <mono/utils/mono-stack-unwinding.h>
  15 #include <mono/utils/mono-linked-list-set.h>
  16 #include <mono/utils/mono-mutex.h>
  17 #include <mono/utils/mono-tls.h>
  18 #include <mono/utils/mono-threads-coop.h>
  19 #include <mono/utils/mono-threads-api.h>
  20
  21 #include <glib.h>
  22 #include <config.h>
  23 #ifdef HOST_WIN32
  24
  25 #include <windows.h>
  26
  27 typedef DWORD MonoNativeThreadId;
  28 typedef HANDLE MonoNativeThreadHandle; /* unused */
  29
  30 typedef DWORD mono_native_thread_return_t;
  31
  32 #define MONO_NATIVE_THREAD_ID_TO_UINT(tid) (tid)
  33 #define MONO_UINT_TO_NATIVE_THREAD_ID(tid) ((MonoNativeThreadId)(tid))
  34
  35 #else
  36
  37 #include <pthread.h>
  38
  39 #if defined(__MACH__)
  40 #include <mono/utils/mach-support.h>
  41
  42 typedef thread_port_t MonoNativeThreadHandle;
  43
  44 #else
  45
  46 #include <unistd.h>
  47
  48 typedef pid_t MonoNativeThreadHandle;
  49
  50 #endif /* defined(__MACH__) */
  51
  52 typedef pthread_t MonoNativeThreadId;
  53
  54 typedef void* mono_native_thread_return_t;
  55
  56 #define MONO_NATIVE_THREAD_ID_TO_UINT(tid) (gsize)(tid)
  57 #define MONO_UINT_TO_NATIVE_THREAD_ID(tid) (MonoNativeThreadId)(gsize)(tid)
  58
  59 #endif /* #ifdef HOST_WIN32 */
  60
  61 /*
  62 THREAD_INFO_TYPE is a way to make the mono-threads module parametric - or sort of.
  63 The GC using mono-threads might extend the MonoThreadInfo struct to add its own
  64 data, this avoid a pointer indirection on what is on a lot of hot paths.
  65
  66 But extending MonoThreadInfo has de disavantage that all functions here return type
  67 would require a cast, something like the following:
  68
  69 typedef struct {
  70         MonoThreadInfo info;
  71         int stuff;
  72 }  MyThreadInfo;
  73
  74 ...
  75 ((MyThreadInfo*)mono_thread_info_current ())->stuff = 1;
  76
  77 While porting sgen to use mono-threads, the number of casts required was too much and
  78 code ended up looking horrible. So we use this cute little hack. The idea is that
  79 whomever is including this header can set the expected type to be used by functions here
  80 and reduce the number of casts drastically.
  81
  82 */
  83 #ifndef THREAD_INFO_TYPE
  84 #define THREAD_INFO_TYPE MonoThreadInfo
  85 #endif
  86
  87 /* Mono Threads internal configuration knows*/
  88
  89 /* Logging - enable them below if you need specific logging for the category you need */
  90 #define MOSTLY_ASYNC_SAFE_PRINTF(...) do { \
  91         char __buff[1024];      __buff [0] = '\0'; \
  92         g_snprintf (__buff, sizeof (__buff), __VA_ARGS__);      \
  93         write (1, __buff, strlen (__buff));     \
  94 } while (0)
  95
  96
  97 #if 1
  98 #define THREADS_DEBUG(...)
  99 #else
 100 #define THREADS_DEBUG MOSTLY_ASYNC_SAFE_PRINTF
 101 #endif
 102
 103 #if 1
 104 #define THREADS_STW_DEBUG(...)
 105 #else
 106 #define THREADS_STW_DEBUG MOSTLY_ASYNC_SAFE_PRINTF
 107 #endif
 108
 109 #if 1
 110 #define THREADS_SUSPEND_DEBUG(...)
 111 #else
 112 #define THREADS_SUSPEND_DEBUG MOSTLY_ASYNC_SAFE_PRINTF
 113 #endif
 114
 115 #if 1
 116 #define THREADS_STATE_MACHINE_DEBUG(...)
 117 #else
 118 #define THREADS_STATE_MACHINE_DEBUG MOSTLY_ASYNC_SAFE_PRINTF
 119 #endif
 120
 121 #if 1
 122 #define THREADS_INTERRUPT_DEBUG(...)
 123 #else
 124 #define THREADS_INTERRUPT_DEBUG MOSTLY_ASYNC_SAFE_PRINTF
 125 #endif
 126
 127 /* If this is defined, use the signals backed on Mach. Debug only as signals can't be made usable on OSX. */
 128 // #define USE_SIGNALS_ON_MACH
 129
 130 #if defined (_POSIX_VERSION) || defined (__native_client__)
 131 #if defined (__MACH__) && !defined (USE_SIGNALS_ON_MACH)
 132 #define USE_MACH_BACKEND
 133 #else
 134 #define USE_POSIX_BACKEND
 135 #endif
 136 #elif HOST_WIN32
 137 #define USE_WINDOWS_BACKEND
 138 #else
 139 #error "no backend support for current platform"
 140 #endif /* defined (_POSIX_VERSION) || defined (__native_client__) */
 141
 142 enum {
 143         STATE_STARTING                          = 0x00,
 144         STATE_RUNNING                           = 0x01,
 145         STATE_DETACHED                          = 0x02,
 146
 147         STATE_ASYNC_SUSPENDED                   = 0x03,
 148         STATE_SELF_SUSPENDED                    = 0x04,
 149         STATE_ASYNC_SUSPEND_REQUESTED   = 0x05,
 150         STATE_SELF_SUSPEND_REQUESTED    = 0x06,
 151         STATE_BLOCKING                                  = 0x07,
 152         STATE_BLOCKING_AND_SUSPENDED    = 0x8,
 153
 154         STATE_MAX                                               = 0x08,
 155
 156         THREAD_STATE_MASK                       = 0x00FF,
 157         THREAD_SUSPEND_COUNT_MASK       = 0xFF00,
 158         THREAD_SUSPEND_COUNT_SHIFT      = 8,
 159         THREAD_SUSPEND_COUNT_MAX        = 0xFF,
 160
 161         SELF_SUSPEND_STATE_INDEX = 0,
 162         ASYNC_SUSPEND_STATE_INDEX = 1,
 163 };
 164
 165 /*
 166  * This enum tells which async thread service corresponds to which bit.
 167  */
 168 typedef enum {
 169         MONO_SERVICE_REQUEST_SAMPLE = 1,
 170 } MonoAsyncJob;
 171
 172 typedef struct _MonoThreadInfoInterruptToken MonoThreadInfoInterruptToken;
 173
 174 typedef struct {
 175         MonoLinkedListSetNode node;
 176         guint32 small_id; /*Used by hazard pointers */
 177         MonoNativeThreadHandle native_handle; /* Valid on mach and android */
 178         int thread_state;
 179
 180         /*Tells if this thread was created by the runtime or not.*/
 181         gboolean runtime_thread;
 182
 183         /* Tells if this thread should be ignored or not by runtime services such as GC and profiling */
 184         gboolean tools_thread;
 185
 186         /* Max stack bounds, all valid addresses must be between [stack_start_limit, stack_end[ */
 187         void *stack_start_limit, *stack_end;
 188
 189         /* suspend machinery, fields protected by suspend_semaphore */
 190         MonoSemType suspend_semaphore;
 191         int suspend_count;
 192
 193         MonoSemType resume_semaphore;
 194
 195         /* only needed by the posix backend */
 196 #if defined(USE_POSIX_BACKEND)
 197         MonoSemType finish_resume_semaphore;
 198         gboolean syscall_break_signal;
 199         gboolean suspend_can_continue;
 200         int signal;
 201 #endif
 202
 203         /* This memory pool is used by coop GC to save stack data roots between GC unsafe regions */
 204         GByteArray *stackdata;
 205
 206         /*In theory, only the posix backend needs this, but having it on mach/win32 simplifies things a lot.*/
 207         MonoThreadUnwindState thread_saved_state [2]; //0 is self suspend, 1 is async suspend.
 208
 209         /*async call machinery, thread MUST be suspended before accessing those fields*/
 210         void (*async_target)(void*);
 211         void *user_data;
 212
 213         /*
 214         If true, this thread is running a critical region of code and cannot be suspended.
 215         A critical session is implicitly started when you call mono_thread_info_safe_suspend_sync
 216         and is ended when you call either mono_thread_info_resume or mono_thread_info_finish_suspend.
 217         */
 218         gboolean inside_critical_region;
 219
 220         /*
 221          * If TRUE, the thread is in async context. Code can use this information to avoid async-unsafe
 222          * operations like locking without having to pass an 'async' parameter around.
 223          */
 224         gboolean is_async_context;
 225
 226         gboolean create_suspended;
 227
 228         /* Semaphore used to implement CREATE_SUSPENDED */
 229         MonoSemType create_suspended_sem;
 230
 231         /*
 232          * Values of TLS variables for this thread.
 233          * This can be used to obtain the values of TLS variable for threads
 234          * other than the current one.
 235          */
 236         gpointer tls [TLS_KEY_NUM];
 237
 238         /* IO layer handle for this thread */
 239         /* Set when the thread is started, or in _wapi_thread_duplicate () */
 240         HANDLE handle;
 241
 242         /* Asynchronous service request. This flag is meant to be consumed by the multiplexing signal handlers to discover what sort of work they need to do.
 243          * Use the mono_threads_add_async_job and mono_threads_consume_async_jobs APIs to modify this flag.
 244          * In the future the signaling should be part of the API, but for now, it's only for massaging the bits.
 245          */
 246         volatile gint32 service_requests;
 247
 248         void *jit_data;
 249
 250         MonoThreadInfoInterruptToken *interrupt_token;
 251 } MonoThreadInfo;
 252
 253 typedef struct {
 254         void* (*thread_register)(THREAD_INFO_TYPE *info, void *baseaddr);
 255         /*
 256         This callback is called with @info still on the thread list.
 257         This call is made while holding the suspend lock, so don't do callbacks.
 258         SMR remains functional as its small_id has not been reclaimed.
 259         */
 260         void (*thread_unregister)(THREAD_INFO_TYPE *info);
 261         /*
 262         This callback is called right before thread_unregister. This is called
 263         without any locks held so it's the place for complicated cleanup.
 264
 265         The thread must remain operational between this call and thread_unregister.
 266         It must be possible to successfully suspend it after thread_unregister completes.
 267         */
 268         void (*thread_detach)(THREAD_INFO_TYPE *info);
 269         void (*thread_attach)(THREAD_INFO_TYPE *info);
 270         gboolean (*mono_method_is_critical) (void *method);
 271         gboolean (*mono_thread_in_critical_region) (THREAD_INFO_TYPE *info);
 272 } MonoThreadInfoCallbacks;
 273
 274 typedef struct {
 275         void (*setup_async_callback) (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data);
 276         gboolean (*thread_state_init_from_sigctx) (MonoThreadUnwindState *state, void *sigctx);
 277         gboolean (*thread_state_init_from_handle) (MonoThreadUnwindState *tctx, MonoThreadInfo *info);
 278         void (*thread_state_init) (MonoThreadUnwindState *tctx);
 279 } MonoThreadInfoRuntimeCallbacks;
 280
 281 //Not using 0 and 1 to ensure callbacks are not returning bad data
 282 typedef enum {
 283         MonoResumeThread = 0x1234,
 284         KeepSuspended = 0x4321,
 285 } SuspendThreadResult;
 286
 287 typedef SuspendThreadResult (*MonoSuspendThreadCallback) (THREAD_INFO_TYPE *info, gpointer user_data);
 288
 289 static inline gboolean
 290 mono_threads_filter_tools_threads (THREAD_INFO_TYPE *info)
 291 {
 292         return !((MonoThreadInfo*)info)->tools_thread;
 293 }
 294
 295 /*
 296 Requires the world to be stoped
 297 */
 298 #define FOREACH_THREAD(thread) MONO_LLS_FOREACH_FILTERED (mono_thread_info_list_head (), thread, mono_threads_filter_tools_threads, THREAD_INFO_TYPE*)
 299 #define END_FOREACH_THREAD MONO_LLS_END_FOREACH
 300
 301 /*
 302 Snapshot iteration.
 303 */
 304 #define FOREACH_THREAD_SAFE(thread) MONO_LLS_FOREACH_FILTERED_SAFE (mono_thread_info_list_head (), thread, mono_threads_filter_tools_threads, THREAD_INFO_TYPE*)
 305 #define END_FOREACH_THREAD_SAFE MONO_LLS_END_FOREACH_SAFE
 306
 307 static inline MonoNativeThreadId
 308 mono_thread_info_get_tid (THREAD_INFO_TYPE *info)
 309 {
 310         return MONO_UINT_TO_NATIVE_THREAD_ID (((MonoThreadInfo*) info)->node.key);
 311 }
 312
 313 static inline void
 314 mono_thread_info_set_tid (THREAD_INFO_TYPE *info, MonoNativeThreadId tid)
 315 {
 316         ((MonoThreadInfo*) info)->node.key = (uintptr_t) MONO_NATIVE_THREAD_ID_TO_UINT (tid);
 317 }
 318
 319 /*
 320  * @thread_info_size is sizeof (GcThreadInfo), a struct the GC defines to make it possible to have
 321  * a single block with info from both camps.
 322  */
 323 void
 324 mono_threads_init (MonoThreadInfoCallbacks *callbacks, size_t thread_info_size);
 325
 326 void
 327 mono_threads_runtime_init (MonoThreadInfoRuntimeCallbacks *callbacks);
 328
 329 MonoThreadInfoRuntimeCallbacks *
 330 mono_threads_get_runtime_callbacks (void);
 331
 332 int
 333 mono_thread_info_register_small_id (void);
 334
 335 THREAD_INFO_TYPE *
 336 mono_thread_info_attach (void *baseptr);
 337
 338 void
 339 mono_thread_info_detach (void);
 340
 341 gboolean
 342 mono_thread_info_is_exiting (void);
 343
 344 THREAD_INFO_TYPE *
 345 mono_thread_info_current (void);
 346
 347 THREAD_INFO_TYPE*
 348 mono_thread_info_current_unchecked (void);
 349
 350 int
 351 mono_thread_info_get_small_id (void);
 352
 353 MonoLinkedListSet*
 354 mono_thread_info_list_head (void);
 355
 356 THREAD_INFO_TYPE*
 357 mono_thread_info_lookup (MonoNativeThreadId id);
 358
 359 THREAD_INFO_TYPE*
 360 mono_thread_info_safe_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel);
 361
 362 gboolean
 363 mono_thread_info_resume (MonoNativeThreadId tid);
 364
 365 void
 366 mono_thread_info_set_name (MonoNativeThreadId tid, const char *name);
 367
 368 void
 369 mono_thread_info_safe_suspend_and_run (MonoNativeThreadId id, gboolean interrupt_kernel, MonoSuspendThreadCallback callback, gpointer user_data);
 370
 371 //XXX new API, fix the world
 372 void
 373 mono_thread_info_begin_self_suspend (void);
 374
 375 void
 376 mono_thread_info_end_self_suspend (void);
 377
 378 //END of new API
 379
 380 gboolean
 381 mono_thread_info_unified_management_enabled (void);
 382
 383 void
 384 mono_thread_info_setup_async_call (THREAD_INFO_TYPE *info, void (*target_func)(void*), void *user_data);
 385
 386 void
 387 mono_thread_info_suspend_lock (void);
 388
 389 void
 390 mono_thread_info_suspend_unlock (void);
 391
 392 void
 393 mono_thread_info_abort_socket_syscall_for_close (MonoThreadInfo *info);
 394
 395 void
 396 mono_thread_info_set_is_async_context (gboolean async_context);
 397
 398 gboolean
 399 mono_thread_info_is_async_context (void);
 400
 401 void
 402 mono_thread_info_get_stack_bounds (guint8 **staddr, size_t *stsize);
 403
 404 gboolean
 405 mono_thread_info_yield (void);
 406
 407 gint
 408 mono_thread_info_sleep (guint32 ms, gboolean *alerted);
 409
 410 gpointer
 411 mono_thread_info_tls_get (THREAD_INFO_TYPE *info, MonoTlsKey key);
 412
 413 void
 414 mono_thread_info_tls_set (THREAD_INFO_TYPE *info, MonoTlsKey key, gpointer value);
 415
 416 void
 417 mono_thread_info_exit (void);
 418
 419 HANDLE
 420 mono_thread_info_open_handle (void);
 421
 422 void
 423 mono_thread_info_install_interrupt (void (*callback) (gpointer data), gpointer data, gboolean *interrupted);
 424
 425 void
 426 mono_thread_info_uninstall_interrupt (gboolean *interrupted);
 427
 428 MonoThreadInfoInterruptToken*
 429 mono_thread_info_prepare_interrupt (THREAD_INFO_TYPE *info);
 430
 431 void
 432 mono_thread_info_finish_interrupt (MonoThreadInfoInterruptToken *token);
 433
 434 void
 435 mono_thread_info_self_interrupt (void);
 436
 437 void
 438 mono_thread_info_clear_self_interrupt (void);
 439
 440 gboolean
 441 mono_thread_info_is_interrupt_state (THREAD_INFO_TYPE *info);
 442
 443 void
 444 mono_thread_info_describe_interrupt_token (THREAD_INFO_TYPE *info, GString *text);
 445
 446 gboolean
 447 mono_thread_info_is_live (THREAD_INFO_TYPE *info);
 448
 449 HANDLE
 450 mono_threads_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid);
 451
 452 int
 453 mono_threads_get_max_stack_size (void);
 454
 455 HANDLE
 456 mono_threads_open_thread_handle (HANDLE handle, MonoNativeThreadId tid);
 457
 458 /*
 459 This is the async job submission/consumption API.
 460 XXX: This is a PROVISIONAL API only meant to be used by the statistical profiler.
 461 If you want to use/extend it anywhere else, understand that you'll have to do some API design work to better fit this puppy.
 462 */
 463 gboolean
 464 mono_threads_add_async_job (THREAD_INFO_TYPE *info, MonoAsyncJob job);
 465
 466 MonoAsyncJob
 467 mono_threads_consume_async_jobs (void);
 468
 469 MONO_API void
 470 mono_threads_attach_tools_thread (void);
 471
 472
 473 #if !defined(HOST_WIN32)
 474
 475 /*Use this instead of pthread_kill */
 476 int
 477 mono_threads_pthread_kill (THREAD_INFO_TYPE *info, int signum);
 478
 479 #endif /* !defined(HOST_WIN32) */
 480
 481 /* Internal API between mono-threads and its backends. */
 482
 483 /* Backend functions - a backend must implement all of the following */
 484 /*
 485 This is called very early in the runtime, it cannot access any runtime facilities.
 486
 487 */
 488 void mono_threads_init_platform (void); //ok
 489
 490 void mono_threads_init_coop (void);
 491
 492 void mono_threads_init_abort_syscall (void);
 493
 494 /*
 495 This begins async suspend. This function must do the following:
 496
 497 -Ensure the target will EINTR any syscalls if @interrupt_kernel is true
 498 -Call mono_threads_transition_finish_async_suspend as part of its async suspend.
 499 -Register the thread for pending suspend with mono_threads_add_to_pending_operation_set if needed.
 500
 501 If begin suspend fails the thread must be left uninterrupted and resumed.
 502 */
 503 gboolean mono_threads_core_begin_async_suspend (THREAD_INFO_TYPE *info, gboolean interrupt_kernel);
 504
 505 /*
 506 This verifies the outcome of an async suspend operation.
 507
 508 Some targets, such as posix, verify suspend results assynchronously. Suspend results must be
 509 available (in a non blocking way) after mono_threads_wait_pending_operations completes.
 510 */
 511 gboolean mono_threads_core_check_suspend_result (THREAD_INFO_TYPE *info);
 512
 513 /*
 514 This begins async resume. This function must do the following:
 515
 516 - Install an async target if one was requested.
 517 - Notify the target to resume.
 518 - Register the thread for pending ack with mono_threads_add_to_pending_operation_set if needed.
 519 */
 520 gboolean mono_threads_core_begin_async_resume (THREAD_INFO_TYPE *info);
 521
 522 void mono_threads_platform_register (THREAD_INFO_TYPE *info); //ok
 523 void mono_threads_platform_free (THREAD_INFO_TYPE *info);
 524 void mono_threads_core_abort_syscall (THREAD_INFO_TYPE *info);
 525 gboolean mono_threads_core_needs_abort_syscall (void);
 526 HANDLE mono_threads_core_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid);
 527 void mono_threads_core_resume_created (THREAD_INFO_TYPE *info, MonoNativeThreadId tid);
 528 void mono_threads_core_get_stack_bounds (guint8 **staddr, size_t *stsize);
 529 gboolean mono_threads_core_yield (void);
 530 void mono_threads_core_exit (int exit_code);
 531 void mono_threads_core_unregister (THREAD_INFO_TYPE *info);
 532 HANDLE mono_threads_core_open_handle (void);
 533 HANDLE mono_threads_core_open_thread_handle (HANDLE handle, MonoNativeThreadId tid);
 534 void mono_threads_core_set_name (MonoNativeThreadId tid, const char *name);
 535
 536 void mono_threads_coop_begin_global_suspend (void);
 537 void mono_threads_coop_end_global_suspend (void);
 538
 539 MonoNativeThreadId
 540 mono_native_thread_id_get (void);
 541
 542 gboolean
 543 mono_native_thread_id_equals (MonoNativeThreadId id1, MonoNativeThreadId id2);
 544
 545 gboolean
 546 mono_native_thread_create (MonoNativeThreadId *tid, gpointer func, gpointer arg);
 547
 548 /*Mach specific internals */
 549 void mono_threads_init_dead_letter (void);
 550 void mono_threads_install_dead_letter (void);
 551
 552 /* mono-threads internal API used by the backends. */
 553 /*
 554 This tells the suspend initiator that we completed suspend and will now be waiting for resume.
 555 */
 556 void mono_threads_notify_initiator_of_suspend (THREAD_INFO_TYPE* info);
 557 /*
 558 This tells the resume initiator that we completed resume duties and will return to runnable state.
 559 */
 560 void mono_threads_notify_initiator_of_resume (THREAD_INFO_TYPE* info);
 561
 562 /*
 563 This tells the resume initiator that we completed abort duties and will return to previous state.
 564 */
 565 void mono_threads_notify_initiator_of_abort (THREAD_INFO_TYPE* info);
 566
 567 /* Thread state machine functions */
 568
 569 typedef enum {
 570         ResumeError,
 571         ResumeOk,
 572         ResumeInitSelfResume,
 573         ResumeInitAsyncResume,
 574         ResumeInitBlockingResume,
 575 } MonoResumeResult;
 576
 577 typedef enum {
 578         SelfSuspendResumed,
 579         SelfSuspendWait,
 580         SelfSuspendNotifyAndWait,
 581 } MonoSelfSupendResult;
 582
 583 typedef enum {
 584         AsyncSuspendAlreadySuspended,
 585         AsyncSuspendWait,
 586         AsyncSuspendInitSuspend,
 587 } MonoRequestAsyncSuspendResult;
 588
 589 typedef enum {
 590         DoBlockingContinue, //in blocking mode, continue
 591         DoBlockingPollAndRetry, //async suspend raced blocking and won, pool and retry
 592 } MonoDoBlockingResult;
 593
 594 typedef enum {
 595         DoneBlockingAborted, //blocking was aborted and not properly restored, poll the state
 596         DoneBlockingOk, //exited blocking fine
 597         DoneBlockingWait, //thread should end suspended
 598 } MonoDoneBlockingResult;
 599
 600
 601 typedef enum {
 602         AbortBlockingIgnore, //Ignore
 603         AbortBlockingIgnoreAndPoll, //Ignore and pool
 604         AbortBlockingOk, //Abort worked
 605         AbortBlockingOkAndPool, //Abort worked, but pool before
 606 } MonoAbortBlockingResult;
 607
 608
 609 void mono_threads_transition_attach (THREAD_INFO_TYPE* info);
 610 gboolean mono_threads_transition_detach (THREAD_INFO_TYPE *info);
 611 void mono_threads_transition_request_self_suspension (THREAD_INFO_TYPE *info);
 612 MonoRequestAsyncSuspendResult mono_threads_transition_request_async_suspension (THREAD_INFO_TYPE *info);
 613 MonoSelfSupendResult mono_threads_transition_state_poll (THREAD_INFO_TYPE *info);
 614 MonoResumeResult mono_threads_transition_request_resume (THREAD_INFO_TYPE* info);
 615 gboolean mono_threads_transition_finish_async_suspend (THREAD_INFO_TYPE* info);
 616 void mono_threads_transition_async_suspend_compensation (THREAD_INFO_TYPE* info);
 617 MonoDoBlockingResult mono_threads_transition_do_blocking (THREAD_INFO_TYPE* info);
 618 MonoDoneBlockingResult mono_threads_transition_done_blocking (THREAD_INFO_TYPE* info);
 619 MonoAbortBlockingResult mono_threads_transition_abort_blocking (THREAD_INFO_TYPE* info);
 620
 621 MonoThreadUnwindState* mono_thread_info_get_suspend_state (THREAD_INFO_TYPE *info);
 622
 623
 624 void mono_thread_info_wait_for_resume (THREAD_INFO_TYPE *info);
 625 /* Advanced suspend API, used for suspending multiple threads as once. */
 626 gboolean mono_thread_info_is_running (THREAD_INFO_TYPE *info);
 627 gboolean mono_thread_info_is_live (THREAD_INFO_TYPE *info);
 628 int mono_thread_info_suspend_count (THREAD_INFO_TYPE *info);
 629 int mono_thread_info_current_state (THREAD_INFO_TYPE *info);
 630 const char* mono_thread_state_name (int state);
 631
 632 gboolean mono_thread_info_in_critical_location (THREAD_INFO_TYPE *info);
 633 gboolean mono_thread_info_begin_suspend (THREAD_INFO_TYPE *info, gboolean interrupt_kernel);
 634 gboolean mono_thread_info_begin_resume (THREAD_INFO_TYPE *info);
 635
 636 gboolean
 637 mono_thread_info_check_suspend_result (THREAD_INFO_TYPE *info);
 638
 639 void mono_threads_add_to_pending_operation_set (THREAD_INFO_TYPE* info); //XXX rename to something to reflect the fact that this is used for both suspend and resume
 640 gboolean mono_threads_wait_pending_operations (void);
 641 void mono_threads_begin_global_suspend (void);
 642 void mono_threads_end_global_suspend (void);
 643
 644 #endif /* __MONO_THREADS_H__ */