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 #else
  30
  31 #include <pthread.h>
  32
  33 #if defined(__MACH__)
  34 #include <mono/utils/mach-support.h>
  35
  36 typedef thread_port_t MonoNativeThreadHandle;
  37
  38 #else
  39
  40 #include <unistd.h>
  41
  42 typedef pid_t MonoNativeThreadHandle;
  43
  44 #endif /* defined(__MACH__) */
  45
  46 typedef pthread_t MonoNativeThreadId;
  47
  48 typedef void* mono_native_thread_return_t;
  49
  50 #endif /* #ifdef HOST_WIN32 */
  51
  52 /*
  53 THREAD_INFO_TYPE is a way to make the mono-threads module parametric - or sort of.
  54 The GC using mono-threads might extend the MonoThreadInfo struct to add its own
  55 data, this avoid a pointer indirection on what is on a lot of hot paths.
  56
  57 But extending MonoThreadInfo has de disavantage that all functions here return type
  58 would require a cast, something like the following:
  59
  60 typedef struct {
  61         MonoThreadInfo info;
  62         int stuff;
  63 }  MyThreadInfo;
  64
  65 ...
  66 ((MyThreadInfo*)mono_thread_info_current ())->stuff = 1;
  67
  68 While porting sgen to use mono-threads, the number of casts required was too much and
  69 code ended up looking horrible. So we use this cute little hack. The idea is that
  70 whomever is including this header can set the expected type to be used by functions here
  71 and reduce the number of casts drastically.
  72
  73 */
  74 #ifndef THREAD_INFO_TYPE
  75 #define THREAD_INFO_TYPE MonoThreadInfo
  76 #endif
  77
  78 enum {
  79         STATE_STARTING                  = 0x01,
  80         STATE_RUNNING                   = 0x02,
  81         STATE_SHUTTING_DOWN             = 0x03,
  82         STATE_DEAD                              = 0x04,
  83         RUN_STATE_MASK                  = 0x0F,
  84
  85         STATE_SUSPENDED                 = 0x10,
  86         STATE_SELF_SUSPENDED    = 0x20,
  87         SUSPEND_STATE_MASK              = 0xF0,
  88 };
  89
  90 #define mono_thread_info_run_state(info) ((info)->thread_state & RUN_STATE_MASK)
  91 #define mono_thread_info_suspend_state(info) ((info)->thread_state & SUSPEND_STATE_MASK)
  92
  93 typedef struct {
  94         MonoLinkedListSetNode node;
  95         guint32 small_id; /*Used by hazard pointers */
  96         MonoNativeThreadHandle native_handle; /* Valid on mach and android */
  97         int thread_state;
  98
  99         /* suspend machinery, fields protected by the suspend_lock */
 100         mono_mutex_t suspend_lock;
 101         int suspend_count;
 102
 103         MonoSemType finish_resume_semaphore;
 104         MonoSemType resume_semaphore;
 105
 106         /* only needed by the posix backend */
 107 #if (defined(_POSIX_VERSION) || defined(__native_client__)) && !defined (__MACH__)
 108         MonoSemType suspend_semaphore;
 109         gboolean syscall_break_signal;
 110         gboolean suspend_can_continue;
 111 #endif
 112
 113         /*In theory, only the posix backend needs this, but having it on mach/win32 simplifies things a lot.*/
 114         MonoThreadUnwindState suspend_state;
 115
 116         /*async call machinery, thread MUST be suspended before accessing those fields*/
 117         void (*async_target)(void*);
 118         void *user_data;
 119 } MonoThreadInfo;
 120
 121 typedef struct {
 122         void* (*thread_register)(THREAD_INFO_TYPE *info, void *baseaddr);
 123         /*
 124         This callback is called after @info is removed from the thread list.
 125         SMR remains functional as its small_id has not been reclaimed.
 126         */
 127         void (*thread_unregister)(THREAD_INFO_TYPE *info);
 128         void (*thread_attach)(THREAD_INFO_TYPE *info);
 129         gboolean (*mono_method_is_critical) (void *method);
 130 #ifndef HOST_WIN32
 131         int (*mono_gc_pthread_create) (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
 132 #endif
 133 } MonoThreadInfoCallbacks;
 134
 135 typedef struct {
 136         void (*setup_async_callback) (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data);
 137         gboolean (*thread_state_init_from_sigctx) (MonoThreadUnwindState *state, void *sigctx);
 138         gboolean (*thread_state_init_from_handle) (MonoThreadUnwindState *tctx, MonoNativeThreadId thread_id, MonoNativeThreadHandle thread_handle);
 139 } MonoThreadInfoRuntimeCallbacks;
 140
 141 /*
 142 Requires the world to be stoped
 143 */
 144 #define FOREACH_THREAD(thread) MONO_LLS_FOREACH (mono_thread_info_list_head (), thread, SgenThreadInfo*)
 145 #define END_FOREACH_THREAD MONO_LLS_END_FOREACH
 146
 147 /*
 148 Snapshot iteration.
 149 */
 150 #define FOREACH_THREAD_SAFE(thread) MONO_LLS_FOREACH_SAFE (mono_thread_info_list_head (), thread, SgenThreadInfo*)
 151 #define END_FOREACH_THREAD_SAFE MONO_LLS_END_FOREACH_SAFE
 152
 153 #define mono_thread_info_get_tid(info) ((MonoNativeThreadId)((MonoThreadInfo*)info)->node.key)
 154 #define mono_thread_info_set_tid(info, val) do { ((MonoThreadInfo*)(info))->node.key = (uintptr_t)(val); } while (0)
 155
 156 /*
 157  * @thread_info_size is sizeof (GcThreadInfo), a struct the GC defines to make it possible to have
 158  * a single block with info from both camps.
 159  */
 160 void
 161 mono_threads_init (MonoThreadInfoCallbacks *callbacks, size_t thread_info_size) MONO_INTERNAL;
 162
 163 void
 164 mono_threads_runtime_init (MonoThreadInfoRuntimeCallbacks *callbacks) MONO_INTERNAL;
 165
 166 MonoThreadInfoCallbacks *
 167 mono_threads_get_callbacks (void) MONO_INTERNAL;
 168
 169 MonoThreadInfoRuntimeCallbacks *
 170 mono_threads_get_runtime_callbacks (void) MONO_INTERNAL;
 171
 172 int
 173 mono_thread_info_register_small_id (void) MONO_INTERNAL;
 174
 175 THREAD_INFO_TYPE *
 176 mono_thread_info_attach (void *baseptr) MONO_INTERNAL;
 177
 178 void
 179 mono_thread_info_dettach (void) MONO_INTERNAL;
 180
 181 THREAD_INFO_TYPE *
 182 mono_thread_info_current (void) MONO_INTERNAL;
 183
 184 int
 185 mono_thread_info_get_small_id (void) MONO_INTERNAL;
 186
 187 MonoLinkedListSet*
 188 mono_thread_info_list_head (void) MONO_INTERNAL;
 189
 190 MonoThreadInfo*
 191 mono_thread_info_lookup (MonoNativeThreadId id) MONO_INTERNAL;
 192
 193 MonoThreadInfo*
 194 mono_thread_info_safe_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel) MONO_INTERNAL;
 195
 196 gboolean
 197 mono_thread_info_resume (MonoNativeThreadId tid) MONO_INTERNAL;
 198
 199 void
 200 mono_thread_info_self_suspend (void) MONO_INTERNAL;
 201
 202 gboolean
 203 mono_thread_info_new_interrupt_enabled (void) MONO_INTERNAL;
 204
 205 void
 206 mono_thread_info_setup_async_call (MonoThreadInfo *info, void (*target_func)(void*), void *user_data) MONO_INTERNAL;
 207
 208 void
 209 mono_thread_info_suspend_lock (void) MONO_INTERNAL;
 210
 211 void
 212 mono_thread_info_suspend_unlock (void) MONO_INTERNAL;
 213
 214 void
 215 mono_threads_unregister_current_thread (THREAD_INFO_TYPE *info) MONO_INTERNAL;
 216
 217 void
 218 mono_thread_info_disable_new_interrupt (gboolean disable) MONO_INTERNAL;
 219
 220 void
 221 mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid) MONO_INTERNAL;
 222
 223 #if !defined(HOST_WIN32)
 224
 225 int
 226 mono_threads_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg) MONO_INTERNAL;
 227
 228 #if !defined(__MACH__)
 229 /*Use this instead of pthread_kill */
 230 int
 231 mono_threads_pthread_kill (THREAD_INFO_TYPE *info, int signum) MONO_INTERNAL;
 232 #endif
 233
 234 #else  /* !defined(HOST_WIN32) */
 235
 236 HANDLE
 237         mono_threads_CreateThread (LPSECURITY_ATTRIBUTES attributes, SIZE_T stack_size, LPTHREAD_START_ROUTINE start_routine, LPVOID arg, DWORD creation_flags, LPDWORD thread_id);
 238
 239
 240 #endif /* !defined(HOST_WIN32) */
 241
 242 /* Plartform specific functions DON'T use them */
 243 void mono_threads_init_platform (void) MONO_INTERNAL; //ok
 244 gboolean mono_threads_core_suspend (MonoThreadInfo *info) MONO_INTERNAL;
 245 gboolean mono_threads_core_resume (MonoThreadInfo *info) MONO_INTERNAL;
 246 void mono_threads_platform_register (MonoThreadInfo *info) MONO_INTERNAL; //ok
 247 void mono_threads_platform_free (MonoThreadInfo *info) MONO_INTERNAL;
 248 void mono_threads_core_interrupt (MonoThreadInfo *info) MONO_INTERNAL;
 249 void mono_threads_core_abort_syscall (MonoThreadInfo *info) MONO_INTERNAL;
 250 gboolean mono_threads_core_needs_abort_syscall (void) MONO_INTERNAL;
 251
 252 MonoNativeThreadId mono_native_thread_id_get (void) MONO_INTERNAL;
 253
 254 gboolean mono_native_thread_id_equals (MonoNativeThreadId id1, MonoNativeThreadId id2) MONO_INTERNAL;
 255
 256 gboolean
 257 mono_native_thread_create (MonoNativeThreadId *tid, gpointer func, gpointer arg) MONO_INTERNAL;
 258
 259 #endif /* __MONO_THREADS_H__ */