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) GPOINTER_TO_UINT((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 } MonoThreadInfo;
 140
 141 typedef struct {
 142         void* (*thread_register)(THREAD_INFO_TYPE *info, void *baseaddr);
 143         /*
 144         This callback is called with @info still on the thread list.
 145         This call is made while holding the suspend lock, so don't do callbacks.
 146         SMR remains functional as its small_id has not been reclaimed.
 147         */
 148         void (*thread_unregister)(THREAD_INFO_TYPE *info);
 149         /*
 150         This callback is called right before thread_unregister. This is called
 151         without any locks held so it's the place for complicated cleanup.
 152
 153         The thread must remain operational between this call and thread_unregister.
 154         It must be possible to successfully suspend it after thread_unregister completes.
 155         */
 156         void (*thread_detach)(THREAD_INFO_TYPE *info);
 157         void (*thread_attach)(THREAD_INFO_TYPE *info);
 158         gboolean (*mono_method_is_critical) (void *method);
 159 #ifndef HOST_WIN32
 160         int (*mono_gc_pthread_create) (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
 161 #endif
 162 } MonoThreadInfoCallbacks;
 163
 164 typedef struct {
 165         void (*setup_async_callback) (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data);
 166         gboolean (*thread_state_init_from_sigctx) (MonoThreadUnwindState *state, void *sigctx);
 167         gboolean (*thread_state_init_from_handle) (MonoThreadUnwindState *tctx, MonoNativeThreadId thread_id, MonoNativeThreadHandle thread_handle);
 168 } MonoThreadInfoRuntimeCallbacks;
 169
 170 /*
 171 Requires the world to be stoped
 172 */
 173 #define FOREACH_THREAD(thread) MONO_LLS_FOREACH (mono_thread_info_list_head (), thread, THREAD_INFO_TYPE*)
 174 #define END_FOREACH_THREAD MONO_LLS_END_FOREACH
 175
 176 /*
 177 Snapshot iteration.
 178 */
 179 #define FOREACH_THREAD_SAFE(thread) MONO_LLS_FOREACH_SAFE (mono_thread_info_list_head (), thread, THREAD_INFO_TYPE*)
 180 #define END_FOREACH_THREAD_SAFE MONO_LLS_END_FOREACH_SAFE
 181
 182 #define mono_thread_info_get_tid(info) ((MonoNativeThreadId)((MonoThreadInfo*)info)->node.key)
 183 #define mono_thread_info_set_tid(info, val) do { ((MonoThreadInfo*)(info))->node.key = (uintptr_t)(val); } while (0)
 184
 185 /*
 186  * @thread_info_size is sizeof (GcThreadInfo), a struct the GC defines to make it possible to have
 187  * a single block with info from both camps.
 188  */
 189 void
 190 mono_threads_init (MonoThreadInfoCallbacks *callbacks, size_t thread_info_size) MONO_INTERNAL;
 191
 192 void
 193 mono_threads_runtime_init (MonoThreadInfoRuntimeCallbacks *callbacks) MONO_INTERNAL;
 194
 195 MonoThreadInfoCallbacks *
 196 mono_threads_get_callbacks (void) MONO_INTERNAL;
 197
 198 MonoThreadInfoRuntimeCallbacks *
 199 mono_threads_get_runtime_callbacks (void) MONO_INTERNAL;
 200
 201 int
 202 mono_thread_info_register_small_id (void) MONO_INTERNAL;
 203
 204 THREAD_INFO_TYPE *
 205 mono_thread_info_attach (void *baseptr) MONO_INTERNAL;
 206
 207 void
 208 mono_thread_info_dettach (void) MONO_INTERNAL;
 209
 210 THREAD_INFO_TYPE *
 211 mono_thread_info_current (void) MONO_INTERNAL;
 212
 213 int
 214 mono_thread_info_get_small_id (void) MONO_INTERNAL;
 215
 216 MonoLinkedListSet*
 217 mono_thread_info_list_head (void) MONO_INTERNAL;
 218
 219 THREAD_INFO_TYPE*
 220 mono_thread_info_lookup (MonoNativeThreadId id) MONO_INTERNAL;
 221
 222 THREAD_INFO_TYPE*
 223 mono_thread_info_safe_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel) MONO_INTERNAL;
 224
 225 gboolean
 226 mono_thread_info_resume (MonoNativeThreadId tid) MONO_INTERNAL;
 227
 228 void
 229 mono_thread_info_finish_suspend (void) MONO_INTERNAL;
 230
 231 void
 232 mono_thread_info_self_suspend (void) MONO_INTERNAL;
 233
 234 gboolean
 235 mono_thread_info_new_interrupt_enabled (void) MONO_INTERNAL;
 236
 237 void
 238 mono_thread_info_setup_async_call (THREAD_INFO_TYPE *info, void (*target_func)(void*), void *user_data) MONO_INTERNAL;
 239
 240 void
 241 mono_thread_info_suspend_lock (void) MONO_INTERNAL;
 242
 243 void
 244 mono_thread_info_suspend_unlock (void) MONO_INTERNAL;
 245
 246 void
 247 mono_thread_info_disable_new_interrupt (gboolean disable) MONO_INTERNAL;
 248
 249 void
 250 mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid) MONO_INTERNAL;
 251
 252 void
 253 mono_thread_info_set_is_async_context (gboolean async_context) MONO_INTERNAL;
 254
 255 gboolean
 256 mono_thread_info_is_async_context (void) MONO_INTERNAL;
 257
 258 HANDLE
 259 mono_threads_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid);
 260
 261 #if !defined(HOST_WIN32)
 262
 263 int
 264 mono_threads_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg) MONO_INTERNAL;
 265
 266 #if !defined(__MACH__)
 267 /*Use this instead of pthread_kill */
 268 int
 269 mono_threads_pthread_kill (THREAD_INFO_TYPE *info, int signum) MONO_INTERNAL;
 270 #endif
 271
 272 #else  /* !defined(HOST_WIN32) */
 273
 274 HANDLE
 275         mono_threads_CreateThread (LPSECURITY_ATTRIBUTES attributes, SIZE_T stack_size, LPTHREAD_START_ROUTINE start_routine, LPVOID arg, DWORD creation_flags, LPDWORD thread_id);
 276
 277
 278 #endif /* !defined(HOST_WIN32) */
 279
 280 /* Plartform specific functions DON'T use them */
 281 void mono_threads_init_platform (void) MONO_INTERNAL; //ok
 282 gboolean mono_threads_core_suspend (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 283 gboolean mono_threads_core_resume (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 284 void mono_threads_platform_register (THREAD_INFO_TYPE *info) MONO_INTERNAL; //ok
 285 void mono_threads_platform_free (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 286 void mono_threads_core_interrupt (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 287 void mono_threads_core_abort_syscall (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 288 gboolean mono_threads_core_needs_abort_syscall (void) MONO_INTERNAL;
 289
 290 MonoNativeThreadId mono_native_thread_id_get (void) MONO_INTERNAL;
 291
 292 gboolean mono_native_thread_id_equals (MonoNativeThreadId id1, MonoNativeThreadId id2) MONO_INTERNAL;
 293
 294 gboolean
 295 mono_native_thread_create (MonoNativeThreadId *tid, gpointer func, gpointer arg) MONO_INTERNAL;
 296
 297 #endif /* __MONO_THREADS_H__ */