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
  19 #include <glib.h>
  20
  21 #ifdef HOST_WIN32
  22
  23 #include <windows.h>
  24
  25 typedef DWORD MonoNativeThreadId;
  26 typedef HANDLE MonoNativeThreadHandle; /* unused */
  27
  28 typedef DWORD mono_native_thread_return_t;
  29
  30 #define MONO_NATIVE_THREAD_ID_TO_UINT(tid) (tid)
  31 #define MONO_UINT_TO_NATIVE_THREAD_ID(tid) ((MonoNativeThreadId)(tid))
  32
  33 #else
  34
  35 #include <pthread.h>
  36
  37 #if defined(__MACH__)
  38 #include <mono/utils/mach-support.h>
  39
  40 typedef thread_port_t MonoNativeThreadHandle;
  41
  42 #else
  43
  44 #include <unistd.h>
  45
  46 typedef pid_t MonoNativeThreadHandle;
  47
  48 #endif /* defined(__MACH__) */
  49
  50 typedef pthread_t MonoNativeThreadId;
  51
  52 typedef void* mono_native_thread_return_t;
  53
  54 #define MONO_NATIVE_THREAD_ID_TO_UINT(tid) (gsize)(tid)
  55 #define MONO_UINT_TO_NATIVE_THREAD_ID(tid) (MonoNativeThreadId)(gsize)(tid)
  56
  57 #endif /* #ifdef HOST_WIN32 */
  58
  59 /*
  60 THREAD_INFO_TYPE is a way to make the mono-threads module parametric - or sort of.
  61 The GC using mono-threads might extend the MonoThreadInfo struct to add its own
  62 data, this avoid a pointer indirection on what is on a lot of hot paths.
  63
  64 But extending MonoThreadInfo has de disavantage that all functions here return type
  65 would require a cast, something like the following:
  66
  67 typedef struct {
  68         MonoThreadInfo info;
  69         int stuff;
  70 }  MyThreadInfo;
  71
  72 ...
  73 ((MyThreadInfo*)mono_thread_info_current ())->stuff = 1;
  74
  75 While porting sgen to use mono-threads, the number of casts required was too much and
  76 code ended up looking horrible. So we use this cute little hack. The idea is that
  77 whomever is including this header can set the expected type to be used by functions here
  78 and reduce the number of casts drastically.
  79
  80 */
  81 #ifndef THREAD_INFO_TYPE
  82 #define THREAD_INFO_TYPE MonoThreadInfo
  83 #endif
  84
  85 enum {
  86         STATE_STARTING                  = 0x00,
  87         STATE_RUNNING                   = 0x01,
  88         STATE_SHUTTING_DOWN             = 0x02,
  89         STATE_DEAD                              = 0x03,
  90         RUN_STATE_MASK                  = 0x0F,
  91
  92         STATE_SUSPENDED                 = 0x10,
  93         STATE_SELF_SUSPENDED    = 0x20,
  94         SUSPEND_STATE_MASK              = 0xF0,
  95 };
  96
  97 /*
  98  * This enum tells which async thread service corresponds to which bit.
  99  */
 100 typedef enum {
 101         MONO_SERVICE_REQUEST_SAMPLE = 1,
 102 } MonoAsyncJob;
 103
 104 typedef struct {
 105         MonoLinkedListSetNode node;
 106         guint32 small_id; /*Used by hazard pointers */
 107         MonoNativeThreadHandle native_handle; /* Valid on mach and android */
 108         int thread_state;
 109
 110         /*Tells if this thread was created by the runtime or not.*/
 111         gboolean runtime_thread;
 112
 113         /* Tells if this thread should be ignored or not by runtime services such as GC and profiling */
 114         gboolean tools_thread;
 115
 116         /* Max stack bounds, all valid addresses must be between [stack_start_limit, stack_end[ */
 117         void *stack_start_limit, *stack_end;
 118
 119         /* suspend machinery, fields protected by suspend_semaphore */
 120         MonoSemType suspend_semaphore;
 121         int suspend_count;
 122
 123         MonoSemType finish_resume_semaphore;
 124         MonoSemType resume_semaphore;
 125
 126         /* only needed by the posix backend */
 127 #if (defined(_POSIX_VERSION) || defined(__native_client__)) && !defined (__MACH__)
 128         MonoSemType begin_suspend_semaphore;
 129         gboolean syscall_break_signal;
 130         gboolean suspend_can_continue;
 131 #endif
 132
 133         /*In theory, only the posix backend needs this, but having it on mach/win32 simplifies things a lot.*/
 134         MonoThreadUnwindState suspend_state;
 135
 136         /*async call machinery, thread MUST be suspended before accessing those fields*/
 137         void (*async_target)(void*);
 138         void *user_data;
 139
 140         /*
 141         If true, this thread is running a critical region of code and cannot be suspended.
 142         A critical session is implicitly started when you call mono_thread_info_safe_suspend_sync
 143         and is ended when you call either mono_thread_info_resume or mono_thread_info_finish_suspend.
 144         */
 145         gboolean inside_critical_region;
 146
 147         /*
 148          * If TRUE, the thread is in async context. Code can use this information to avoid async-unsafe
 149          * operations like locking without having to pass an 'async' parameter around.
 150          */
 151         gboolean is_async_context;
 152
 153         gboolean create_suspended;
 154
 155         /* Semaphore used to implement CREATE_SUSPENDED */
 156         MonoSemType create_suspended_sem;
 157
 158         /*
 159          * Values of TLS variables for this thread.
 160          * This can be used to obtain the values of TLS variable for threads
 161          * other than the current one.
 162          */
 163         gpointer tls [TLS_KEY_NUM];
 164
 165         /* IO layer handle for this thread */
 166         /* Set when the thread is started, or in _wapi_thread_duplicate () */
 167         HANDLE handle;
 168
 169         /* 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.
 170          * Use the mono_threads_add_async_job and mono_threads_consume_async_jobs APIs to modify this flag.
 171          * In the future the signaling should be part of the API, but for now, it's only for massaging the bits.
 172          */
 173         volatile gint32 service_requests;
 174 } MonoThreadInfo;
 175
 176 typedef struct {
 177         void* (*thread_register)(THREAD_INFO_TYPE *info, void *baseaddr);
 178         /*
 179         This callback is called with @info still on the thread list.
 180         This call is made while holding the suspend lock, so don't do callbacks.
 181         SMR remains functional as its small_id has not been reclaimed.
 182         */
 183         void (*thread_unregister)(THREAD_INFO_TYPE *info);
 184         /*
 185         This callback is called right before thread_unregister. This is called
 186         without any locks held so it's the place for complicated cleanup.
 187
 188         The thread must remain operational between this call and thread_unregister.
 189         It must be possible to successfully suspend it after thread_unregister completes.
 190         */
 191         void (*thread_detach)(THREAD_INFO_TYPE *info);
 192         void (*thread_attach)(THREAD_INFO_TYPE *info);
 193         gboolean (*mono_method_is_critical) (void *method);
 194         gboolean (*mono_thread_in_critical_region) (THREAD_INFO_TYPE *info);
 195         void (*thread_exit)(void *retval);
 196 #ifndef HOST_WIN32
 197         int (*mono_gc_pthread_create) (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
 198 #endif
 199 } MonoThreadInfoCallbacks;
 200
 201 typedef struct {
 202         void (*setup_async_callback) (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data);
 203         gboolean (*thread_state_init_from_sigctx) (MonoThreadUnwindState *state, void *sigctx);
 204         gboolean (*thread_state_init_from_handle) (MonoThreadUnwindState *tctx, MonoThreadInfo *info);
 205 } MonoThreadInfoRuntimeCallbacks;
 206
 207 static inline gboolean
 208 mono_threads_filter_tools_threads (THREAD_INFO_TYPE *info)
 209 {
 210         return !((MonoThreadInfo*)info)->tools_thread;
 211 }
 212
 213 /*
 214 Requires the world to be stoped
 215 */
 216 #define FOREACH_THREAD(thread) MONO_LLS_FOREACH_FILTERED (mono_thread_info_list_head (), thread, mono_threads_filter_tools_threads, THREAD_INFO_TYPE*)
 217 #define END_FOREACH_THREAD MONO_LLS_END_FOREACH
 218
 219 /*
 220 Snapshot iteration.
 221 */
 222 #define FOREACH_THREAD_SAFE(thread) MONO_LLS_FOREACH_FILTERED_SAFE (mono_thread_info_list_head (), thread, mono_threads_filter_tools_threads, THREAD_INFO_TYPE*)
 223 #define END_FOREACH_THREAD_SAFE MONO_LLS_END_FOREACH_SAFE
 224
 225 #define mono_thread_info_get_tid(info) ((MonoNativeThreadId)((MonoThreadInfo*)info)->node.key)
 226 #define mono_thread_info_set_tid(info, val) do { ((MonoThreadInfo*)(info))->node.key = (uintptr_t)(val); } while (0)
 227
 228 /*
 229  * @thread_info_size is sizeof (GcThreadInfo), a struct the GC defines to make it possible to have
 230  * a single block with info from both camps.
 231  */
 232 void
 233 mono_threads_init (MonoThreadInfoCallbacks *callbacks, size_t thread_info_size);
 234
 235 void
 236 mono_threads_runtime_init (MonoThreadInfoRuntimeCallbacks *callbacks);
 237
 238 MonoThreadInfoCallbacks *
 239 mono_threads_get_callbacks (void);
 240
 241 MonoThreadInfoRuntimeCallbacks *
 242 mono_threads_get_runtime_callbacks (void);
 243
 244 int
 245 mono_thread_info_register_small_id (void);
 246
 247 THREAD_INFO_TYPE *
 248 mono_thread_info_attach (void *baseptr);
 249
 250 void
 251 mono_thread_info_detach (void);
 252
 253 gboolean
 254 mono_thread_info_is_exiting (void);
 255
 256 THREAD_INFO_TYPE *
 257 mono_thread_info_current (void);
 258
 259 int
 260 mono_thread_info_get_small_id (void);
 261
 262 MonoLinkedListSet*
 263 mono_thread_info_list_head (void);
 264
 265 THREAD_INFO_TYPE*
 266 mono_thread_info_lookup (MonoNativeThreadId id);
 267
 268 THREAD_INFO_TYPE*
 269 mono_thread_info_safe_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel);
 270
 271 gboolean
 272 mono_thread_info_resume (MonoNativeThreadId tid);
 273
 274 void
 275 mono_thread_info_set_name (MonoNativeThreadId tid, const char *name);
 276
 277 void
 278 mono_thread_info_finish_suspend (MonoThreadInfo *info);
 279
 280 void
 281 mono_thread_info_finish_suspend_and_resume (MonoThreadInfo *info);
 282
 283 void
 284 mono_thread_info_self_suspend (void);
 285
 286 gboolean
 287 mono_thread_info_new_interrupt_enabled (void);
 288
 289 void
 290 mono_thread_info_setup_async_call (THREAD_INFO_TYPE *info, void (*target_func)(void*), void *user_data);
 291
 292 void
 293 mono_thread_info_suspend_lock (void);
 294
 295 void
 296 mono_thread_info_suspend_unlock (void);
 297
 298 void
 299 mono_thread_info_disable_new_interrupt (gboolean disable);
 300
 301 void
 302 mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid);
 303
 304 void
 305 mono_thread_info_set_is_async_context (gboolean async_context);
 306
 307 gboolean
 308 mono_thread_info_is_async_context (void);
 309
 310 void
 311 mono_thread_info_get_stack_bounds (guint8 **staddr, size_t *stsize);
 312
 313 gboolean
 314 mono_thread_info_yield (void);
 315
 316 gpointer
 317 mono_thread_info_tls_get (THREAD_INFO_TYPE *info, MonoTlsKey key);
 318
 319 void
 320 mono_thread_info_tls_set (THREAD_INFO_TYPE *info, MonoTlsKey key, gpointer value);
 321
 322 void
 323 mono_thread_info_exit (void);
 324
 325 HANDLE
 326 mono_thread_info_open_handle (void);
 327
 328 gpointer
 329 mono_thread_info_prepare_interrupt (HANDLE thread_handle);
 330
 331 void
 332 mono_thread_info_finish_interrupt (gpointer wait_handle);
 333
 334 void
 335 mono_thread_info_interrupt (HANDLE thread_handle);
 336
 337 void
 338 mono_thread_info_self_interrupt (void);
 339
 340 void
 341 mono_thread_info_clear_interruption (void);
 342
 343 gboolean
 344 mono_thread_info_is_live (THREAD_INFO_TYPE *info);
 345
 346 HANDLE
 347 mono_threads_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid);
 348
 349 int
 350 mono_threads_get_max_stack_size (void);
 351
 352 HANDLE
 353 mono_threads_open_thread_handle (HANDLE handle, MonoNativeThreadId tid);
 354
 355 /*
 356 This is the async job submission/consumption API.
 357 XXX: This is a PROVISIONAL API only meant to be used by the statistical profiler.
 358 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.
 359 */
 360 gboolean
 361 mono_threads_add_async_job (THREAD_INFO_TYPE *info, MonoAsyncJob job);
 362
 363 MonoAsyncJob
 364 mono_threads_consume_async_jobs (void);
 365
 366 MONO_API void
 367 mono_threads_attach_tools_thread (void);
 368
 369
 370 #if !defined(HOST_WIN32)
 371
 372 /*Use this instead of pthread_kill */
 373 int
 374 mono_threads_pthread_kill (THREAD_INFO_TYPE *info, int signum);
 375
 376 #endif /* !defined(HOST_WIN32) */
 377
 378 /* Plartform specific functions DON'T use them */
 379 void mono_threads_init_platform (void); //ok
 380 gboolean mono_threads_core_suspend (THREAD_INFO_TYPE *info, gboolean interrupt_kernel);
 381 gboolean mono_threads_core_resume (THREAD_INFO_TYPE *info);
 382 void mono_threads_platform_register (THREAD_INFO_TYPE *info); //ok
 383 void mono_threads_platform_free (THREAD_INFO_TYPE *info);
 384 void mono_threads_core_interrupt (THREAD_INFO_TYPE *info);
 385 void mono_threads_core_abort_syscall (THREAD_INFO_TYPE *info);
 386 gboolean mono_threads_core_needs_abort_syscall (void);
 387 HANDLE mono_threads_core_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid);
 388 void mono_threads_core_resume_created (THREAD_INFO_TYPE *info, MonoNativeThreadId tid);
 389 void mono_threads_core_get_stack_bounds (guint8 **staddr, size_t *stsize);
 390 gboolean mono_threads_core_yield (void);
 391 void mono_threads_core_exit (int exit_code);
 392 void mono_threads_core_unregister (THREAD_INFO_TYPE *info);
 393 HANDLE mono_threads_core_open_handle (void);
 394 HANDLE mono_threads_core_open_thread_handle (HANDLE handle, MonoNativeThreadId tid);
 395 void mono_threads_core_set_name (MonoNativeThreadId tid, const char *name);
 396 gpointer mono_threads_core_prepare_interrupt (HANDLE thread_handle);
 397 void mono_threads_core_finish_interrupt (gpointer wait_handle);
 398 void mono_threads_core_self_interrupt (void);
 399 void mono_threads_core_clear_interruption (void);
 400
 401 MonoNativeThreadId mono_native_thread_id_get (void);
 402
 403 gboolean mono_native_thread_id_equals (MonoNativeThreadId id1, MonoNativeThreadId id2);
 404
 405 gboolean
 406 mono_native_thread_create (MonoNativeThreadId *tid, gpointer func, gpointer arg);
 407
 408 /*Mach specific internals */
 409 void mono_threads_init_dead_letter (void);
 410 void mono_threads_install_dead_letter (void);
 411
 412 #endif /* __MONO_THREADS_H__ */