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
  18 #include <glib.h>
  19
  20 #ifdef HOST_WIN32
  21
  22 #include <windows.h>
  23
  24 typedef DWORD MonoNativeThreadId;
  25 typedef HANDLE MonoNativeThreadHandle; /* unused */
  26
  27 typedef DWORD mono_native_thread_return_t;
  28
  29 #define MONO_NATIVE_THREAD_ID_TO_UINT(tid) (tid)
  30
  31 #else
  32
  33 #include <pthread.h>
  34
  35 #if defined(__MACH__)
  36 #include <mono/utils/mach-support.h>
  37
  38 typedef thread_port_t MonoNativeThreadHandle;
  39
  40 #else
  41
  42 #include <unistd.h>
  43
  44 typedef pid_t MonoNativeThreadHandle;
  45
  46 #endif /* defined(__MACH__) */
  47
  48 typedef pthread_t MonoNativeThreadId;
  49
  50 typedef void* mono_native_thread_return_t;
  51
  52 #define MONO_NATIVE_THREAD_ID_TO_UINT(tid) (gsize)(tid)
  53
  54 #endif /* #ifdef HOST_WIN32 */
  55
  56 /*
  57 THREAD_INFO_TYPE is a way to make the mono-threads module parametric - or sort of.
  58 The GC using mono-threads might extend the MonoThreadInfo struct to add its own
  59 data, this avoid a pointer indirection on what is on a lot of hot paths.
  60
  61 But extending MonoThreadInfo has de disavantage that all functions here return type
  62 would require a cast, something like the following:
  63
  64 typedef struct {
  65         MonoThreadInfo info;
  66         int stuff;
  67 }  MyThreadInfo;
  68
  69 ...
  70 ((MyThreadInfo*)mono_thread_info_current ())->stuff = 1;
  71
  72 While porting sgen to use mono-threads, the number of casts required was too much and
  73 code ended up looking horrible. So we use this cute little hack. The idea is that
  74 whomever is including this header can set the expected type to be used by functions here
  75 and reduce the number of casts drastically.
  76
  77 */
  78 #ifndef THREAD_INFO_TYPE
  79 #define THREAD_INFO_TYPE MonoThreadInfo
  80 #endif
  81
  82 enum {
  83         STATE_STARTING                  = 0x00,
  84         STATE_RUNNING                   = 0x01,
  85         STATE_SHUTTING_DOWN             = 0x02,
  86         STATE_DEAD                              = 0x03,
  87         RUN_STATE_MASK                  = 0x0F,
  88
  89         STATE_SUSPENDED                 = 0x10,
  90         STATE_SELF_SUSPENDED    = 0x20,
  91         SUSPEND_STATE_MASK              = 0xF0,
  92 };
  93
  94 #define mono_thread_info_run_state(info) (((MonoThreadInfo*)info)->thread_state & RUN_STATE_MASK)
  95 #define mono_thread_info_suspend_state(info) (((MonoThreadInfo*)info)->thread_state & SUSPEND_STATE_MASK)
  96
  97 typedef struct {
  98         MonoLinkedListSetNode node;
  99         guint32 small_id; /*Used by hazard pointers */
 100         MonoNativeThreadHandle native_handle; /* Valid on mach and android */
 101         int thread_state;
 102
 103         /*Tells if this thread was created by the runtime or not.*/
 104         gboolean runtime_thread;
 105
 106         /* suspend machinery, fields protected by suspend_semaphore */
 107         MonoSemType suspend_semaphore;
 108         int suspend_count;
 109
 110         MonoSemType finish_resume_semaphore;
 111         MonoSemType resume_semaphore;
 112
 113         /* only needed by the posix backend */
 114 #if (defined(_POSIX_VERSION) || defined(__native_client__)) && !defined (__MACH__)
 115         MonoSemType begin_suspend_semaphore;
 116         gboolean syscall_break_signal;
 117         gboolean suspend_can_continue;
 118 #endif
 119
 120         /*In theory, only the posix backend needs this, but having it on mach/win32 simplifies things a lot.*/
 121         MonoThreadUnwindState suspend_state;
 122
 123         /*async call machinery, thread MUST be suspended before accessing those fields*/
 124         void (*async_target)(void*);
 125         void *user_data;
 126
 127         /*
 128         If true, this thread is running a critical region of code and cannot be suspended.
 129         A critical session is implicitly started when you call mono_thread_info_safe_suspend_sync
 130         and is ended when you call either mono_thread_info_resume or mono_thread_info_finish_suspend.
 131         */
 132         gboolean inside_critical_region;
 133
 134         /*
 135          * If TRUE, the thread is in async context. Code can use this information to avoid async-unsafe
 136          * operations like locking without having to pass an 'async' parameter around.
 137          */
 138         gboolean is_async_context;
 139
 140         gboolean create_suspended;
 141
 142         /* Semaphore used to implement CREATE_SUSPENDED */
 143         MonoSemType create_suspended_sem;
 144 } MonoThreadInfo;
 145
 146 typedef struct {
 147         void* (*thread_register)(THREAD_INFO_TYPE *info, void *baseaddr);
 148         /*
 149         This callback is called with @info still on the thread list.
 150         This call is made while holding the suspend lock, so don't do callbacks.
 151         SMR remains functional as its small_id has not been reclaimed.
 152         */
 153         void (*thread_unregister)(THREAD_INFO_TYPE *info);
 154         /*
 155         This callback is called right before thread_unregister. This is called
 156         without any locks held so it's the place for complicated cleanup.
 157
 158         The thread must remain operational between this call and thread_unregister.
 159         It must be possible to successfully suspend it after thread_unregister completes.
 160         */
 161         void (*thread_detach)(THREAD_INFO_TYPE *info);
 162         void (*thread_attach)(THREAD_INFO_TYPE *info);
 163         gboolean (*mono_method_is_critical) (void *method);
 164 #ifndef HOST_WIN32
 165         int (*mono_gc_pthread_create) (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
 166 #endif
 167 } MonoThreadInfoCallbacks;
 168
 169 typedef struct {
 170         void (*setup_async_callback) (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data);
 171         gboolean (*thread_state_init_from_sigctx) (MonoThreadUnwindState *state, void *sigctx);
 172         gboolean (*thread_state_init_from_handle) (MonoThreadUnwindState *tctx, MonoNativeThreadId thread_id, MonoNativeThreadHandle thread_handle);
 173 } MonoThreadInfoRuntimeCallbacks;
 174
 175 /*
 176 Requires the world to be stoped
 177 */
 178 #define FOREACH_THREAD(thread) MONO_LLS_FOREACH (mono_thread_info_list_head (), thread, THREAD_INFO_TYPE*)
 179 #define END_FOREACH_THREAD MONO_LLS_END_FOREACH
 180
 181 /*
 182 Snapshot iteration.
 183 */
 184 #define FOREACH_THREAD_SAFE(thread) MONO_LLS_FOREACH_SAFE (mono_thread_info_list_head (), thread, THREAD_INFO_TYPE*)
 185 #define END_FOREACH_THREAD_SAFE MONO_LLS_END_FOREACH_SAFE
 186
 187 #define mono_thread_info_get_tid(info) ((MonoNativeThreadId)((MonoThreadInfo*)info)->node.key)
 188 #define mono_thread_info_set_tid(info, val) do { ((MonoThreadInfo*)(info))->node.key = (uintptr_t)(val); } while (0)
 189
 190 /*
 191  * @thread_info_size is sizeof (GcThreadInfo), a struct the GC defines to make it possible to have
 192  * a single block with info from both camps.
 193  */
 194 void
 195 mono_threads_init (MonoThreadInfoCallbacks *callbacks, size_t thread_info_size) MONO_INTERNAL;
 196
 197 void
 198 mono_threads_runtime_init (MonoThreadInfoRuntimeCallbacks *callbacks) MONO_INTERNAL;
 199
 200 MonoThreadInfoCallbacks *
 201 mono_threads_get_callbacks (void) MONO_INTERNAL;
 202
 203 MonoThreadInfoRuntimeCallbacks *
 204 mono_threads_get_runtime_callbacks (void) MONO_INTERNAL;
 205
 206 int
 207 mono_thread_info_register_small_id (void) MONO_INTERNAL;
 208
 209 THREAD_INFO_TYPE *
 210 mono_thread_info_attach (void *baseptr) MONO_INTERNAL;
 211
 212 void
 213 mono_thread_info_dettach (void) MONO_INTERNAL;
 214
 215 THREAD_INFO_TYPE *
 216 mono_thread_info_current (void) MONO_INTERNAL;
 217
 218 int
 219 mono_thread_info_get_small_id (void) MONO_INTERNAL;
 220
 221 MonoLinkedListSet*
 222 mono_thread_info_list_head (void) MONO_INTERNAL;
 223
 224 THREAD_INFO_TYPE*
 225 mono_thread_info_lookup (MonoNativeThreadId id) MONO_INTERNAL;
 226
 227 THREAD_INFO_TYPE*
 228 mono_thread_info_safe_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel) MONO_INTERNAL;
 229
 230 gboolean
 231 mono_thread_info_resume (MonoNativeThreadId tid) MONO_INTERNAL;
 232
 233 void
 234 mono_thread_info_finish_suspend (void) MONO_INTERNAL;
 235
 236 void
 237 mono_thread_info_self_suspend (void) MONO_INTERNAL;
 238
 239 gboolean
 240 mono_thread_info_new_interrupt_enabled (void) MONO_INTERNAL;
 241
 242 void
 243 mono_thread_info_setup_async_call (THREAD_INFO_TYPE *info, void (*target_func)(void*), void *user_data) MONO_INTERNAL;
 244
 245 void
 246 mono_thread_info_suspend_lock (void) MONO_INTERNAL;
 247
 248 void
 249 mono_thread_info_suspend_unlock (void) MONO_INTERNAL;
 250
 251 void
 252 mono_thread_info_disable_new_interrupt (gboolean disable) MONO_INTERNAL;
 253
 254 void
 255 mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid) MONO_INTERNAL;
 256
 257 void
 258 mono_thread_info_set_is_async_context (gboolean async_context) MONO_INTERNAL;
 259
 260 gboolean
 261 mono_thread_info_is_async_context (void) MONO_INTERNAL;
 262
 263 void
 264 mono_thread_info_get_stack_bounds (guint8 **staddr, size_t *stsize);
 265
 266 HANDLE
 267 mono_threads_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid);
 268
 269 #if !defined(HOST_WIN32)
 270
 271 #if !defined(__MACH__)
 272 /*Use this instead of pthread_kill */
 273 int
 274 mono_threads_pthread_kill (THREAD_INFO_TYPE *info, int signum) MONO_INTERNAL;
 275 #endif
 276
 277 #endif /* !defined(HOST_WIN32) */
 278
 279 /* Plartform specific functions DON'T use them */
 280 void mono_threads_init_platform (void) MONO_INTERNAL; //ok
 281 gboolean mono_threads_core_suspend (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 282 gboolean mono_threads_core_resume (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 283 void mono_threads_platform_register (THREAD_INFO_TYPE *info) MONO_INTERNAL; //ok
 284 void mono_threads_platform_free (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 285 void mono_threads_core_interrupt (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 286 void mono_threads_core_abort_syscall (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 287 gboolean mono_threads_core_needs_abort_syscall (void) MONO_INTERNAL;
 288 HANDLE mono_threads_core_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid) MONO_INTERNAL;
 289 void mono_threads_core_resume_created (THREAD_INFO_TYPE *info, MonoNativeThreadId tid) MONO_INTERNAL;
 290 void mono_threads_core_get_stack_bounds (guint8 **staddr, size_t *stsize) MONO_INTERNAL;
 291
 292 MonoNativeThreadId mono_native_thread_id_get (void) MONO_INTERNAL;
 293
 294 gboolean mono_native_thread_id_equals (MonoNativeThreadId id1, MonoNativeThreadId id2) MONO_INTERNAL;
 295
 296 gboolean
 297 mono_native_thread_create (MonoNativeThreadId *tid, gpointer func, gpointer arg) MONO_INTERNAL;
 298
 299 #endif /* __MONO_THREADS_H__ */