mono/io-layer/wthreads.c

   1 /*
   2  * threads.c:  Thread handles
   3  *
   4  * Author:
   5  *      Dick Porter (dick@ximian.com)
   6  *
   7  * (C) 2002-2006 Ximian, Inc.
   8  * Copyright 2003-2011 Novell, Inc (http://www.novell.com)
   9  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
  10  */
  11
  12 #include <config.h>
  13 #include <stdio.h>
  14 #include <glib.h>
  15 #include <string.h>
  16 #include <pthread.h>
  17 #include <sched.h>
  18 #include <sys/time.h>
  19 #include <errno.h>
  20 #include <sys/types.h>
  21 #include <unistd.h>
  22
  23 #include <mono/io-layer/wapi.h>
  24 #include <mono/io-layer/wapi-private.h>
  25 #include <mono/io-layer/handles-private.h>
  26 #include <mono/io-layer/misc-private.h>
  27 #include <mono/io-layer/thread-private.h>
  28 #include <mono/io-layer/mutex-private.h>
  29
  30 #include <mono/utils/mono-threads.h>
  31 #include <mono/utils/atomic.h>
  32 #include <mono/utils/mono-mutex.h>
  33
  34 #ifdef HAVE_VALGRIND_MEMCHECK_H
  35 #include <valgrind/memcheck.h>
  36 #endif
  37
  38 #if 0
  39 #define DEBUG(...) g_message(__VA_ARGS__)
  40 #else
  41 #define DEBUG(...)
  42 #endif
  43
  44 #if 0
  45 #define WAIT_DEBUG(code) do { code } while (0)
  46 #else
  47 #define WAIT_DEBUG(code) do { } while (0)
  48 #endif
  49
  50 struct _WapiHandleOps _wapi_thread_ops = {
  51         NULL,                           /* close */
  52         NULL,                           /* signal */
  53         NULL,                           /* own */
  54         NULL,                           /* is_owned */
  55         NULL,                           /* special_wait */
  56         NULL                            /* prewait */
  57 };
  58
  59 static mono_once_t thread_ops_once = MONO_ONCE_INIT;
  60
  61 static void
  62 thread_ops_init (void)
  63 {
  64         _wapi_handle_register_capabilities (WAPI_HANDLE_THREAD,
  65                                             WAPI_HANDLE_CAP_WAIT);
  66 }
  67
  68 void
  69 _wapi_thread_cleanup (void)
  70 {
  71 }
  72
  73 static gpointer
  74 get_current_thread_handle (void)
  75 {
  76         MonoThreadInfo *info;
  77
  78         info = mono_thread_info_current ();
  79         g_assert (info);
  80         g_assert (info->handle);
  81         return info->handle;
  82 }
  83
  84 static WapiHandle_thread*
  85 lookup_thread (HANDLE handle)
  86 {
  87         WapiHandle_thread *thread;
  88         gboolean ok;
  89
  90         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
  91                                                           (gpointer *)&thread);
  92         g_assert (ok);
  93         return thread;
  94 }
  95
  96 static WapiHandle_thread*
  97 get_current_thread (void)
  98 {
  99         gpointer handle;
 100
 101         handle = get_current_thread_handle ();
 102         return lookup_thread (handle);
 103 }
 104
 105 void
 106 wapi_thread_handle_set_exited (gpointer handle, guint32 exitstatus)
 107 {
 108         WapiHandle_thread *thread_handle;
 109         int i, thr_ret;
 110         pid_t pid = _wapi_getpid ();
 111         pthread_t tid = pthread_self ();
 112
 113         if (_wapi_handle_issignalled (handle) ||
 114             _wapi_handle_type (handle) == WAPI_HANDLE_UNUSED) {
 115                 /* We must have already deliberately finished with
 116                  * this thread, so don't do any more now
 117                  */
 118                 return;
 119         }
 120
 121         DEBUG ("%s: Thread %p terminating", __func__, handle);
 122
 123         thread_handle = lookup_thread (handle);
 124
 125         DEBUG ("%s: Thread %p abandoning held mutexes", __func__, handle);
 126
 127         for (i = 0; i < thread_handle->owned_mutexes->len; i++) {
 128                 gpointer mutex = g_ptr_array_index (thread_handle->owned_mutexes, i);
 129
 130                 _wapi_mutex_abandon (mutex, pid, tid);
 131                 _wapi_thread_disown_mutex (mutex);
 132         }
 133         g_ptr_array_free (thread_handle->owned_mutexes, TRUE);
 134
 135         thr_ret = _wapi_handle_lock_handle (handle);
 136         g_assert (thr_ret == 0);
 137
 138         _wapi_handle_set_signal_state (handle, TRUE, TRUE);
 139
 140         thr_ret = _wapi_handle_unlock_handle (handle);
 141         g_assert (thr_ret == 0);
 142
 143         DEBUG("%s: Recording thread handle %p id %ld status as %d",
 144                   __func__, handle, thread_handle->id, exitstatus);
 145
 146         /* The thread is no longer active, so unref it */
 147         _wapi_handle_unref (handle);
 148 }
 149
 150 /*
 151  * wapi_create_thread_handle:
 152  *
 153  *   Create a thread handle for the current thread.
 154  */
 155 gpointer
 156 wapi_create_thread_handle (void)
 157 {
 158         WapiHandle_thread thread_handle = {0}, *thread;
 159         gpointer handle;
 160
 161         mono_once (&thread_ops_once, thread_ops_init);
 162
 163         thread_handle.owned_mutexes = g_ptr_array_new ();
 164
 165         handle = _wapi_handle_new (WAPI_HANDLE_THREAD, &thread_handle);
 166         if (handle == _WAPI_HANDLE_INVALID) {
 167                 g_warning ("%s: error creating thread handle", __func__);
 168                 SetLastError (ERROR_GEN_FAILURE);
 169
 170                 return NULL;
 171         }
 172
 173         thread = lookup_thread (handle);
 174
 175         thread->id = pthread_self ();
 176
 177         /*
 178          * Hold a reference while the thread is active, because we use
 179          * the handle to store thread exit information
 180          */
 181         _wapi_handle_ref (handle);
 182
 183         DEBUG ("%s: started thread id %ld", __func__, thread->id);
 184
 185         return handle;
 186 }
 187
 188 void
 189 wapi_ref_thread_handle (gpointer handle)
 190 {
 191         _wapi_handle_ref (handle);
 192 }
 193
 194 gpointer
 195 wapi_get_current_thread_handle (void)
 196 {
 197         return get_current_thread_handle ();
 198 }
 199
 200 /**
 201  * GetCurrentThreadId:
 202  *
 203  * Looks up the thread ID of the current thread.  This ID can be
 204  * passed to OpenThread() to create a new handle on this thread.
 205  *
 206  * Return value: the thread ID.  NB this is defined as DWORD (ie 32
 207  * bit) in the MS API, but we need to cope with 64 bit IDs for s390x
 208  * and amd64.  This doesn't really break the API, it just embraces and
 209  * extends it on 64bit platforms :)
 210  */
 211 gsize
 212 GetCurrentThreadId (void)
 213 {
 214         MonoNativeThreadId id;
 215
 216         id = mono_native_thread_id_get ();
 217         return MONO_NATIVE_THREAD_ID_TO_UINT (id);
 218 }
 219
 220 /**
 221  * SleepEx:
 222  * @ms: The time in milliseconds to suspend for
 223  * @alertable: if TRUE, the wait can be interrupted by an APC call
 224  *
 225  * Suspends execution of the current thread for @ms milliseconds.  A
 226  * value of zero causes the thread to relinquish its time slice.  A
 227  * value of %INFINITE causes an infinite delay.
 228  */
 229 guint32
 230 SleepEx (guint32 ms, gboolean alertable)
 231 {
 232         int ms_quot, ms_rem;
 233         int ret;
 234         gpointer current_thread = NULL;
 235 #if defined (__linux__) && !defined(PLATFORM_ANDROID)
 236         struct timespec start, target;
 237 #else
 238         struct timespec rem;
 239 #endif
 240
 241         DEBUG("%s: Sleeping for %d ms", __func__, ms);
 242
 243         if (alertable) {
 244                 current_thread = get_current_thread_handle ();
 245
 246                 if (_wapi_thread_cur_apc_pending ())
 247                         return WAIT_IO_COMPLETION;
 248         }
 249
 250         if(ms==0) {
 251                 sched_yield();
 252                 return 0;
 253         }
 254
 255         /* FIXME: check for INFINITE and sleep forever */
 256         ms_quot = ms / 1000;
 257         ms_rem = ms % 1000;
 258
 259 #if defined (__linux__) && !defined(PLATFORM_ANDROID)
 260         /* Use clock_nanosleep () to prevent time drifting problems when nanosleep () is interrupted by signals */
 261         ret = clock_gettime (CLOCK_MONOTONIC, &start);
 262         g_assert (ret == 0);
 263         target = start;
 264         target.tv_sec += ms_quot;
 265         target.tv_nsec += ms_rem * 1000000;
 266         if (target.tv_nsec > 999999999) {
 267                 target.tv_nsec -= 999999999;
 268                 target.tv_sec ++;
 269         }
 270
 271         while (TRUE) {
 272                 ret = clock_nanosleep (CLOCK_MONOTONIC, TIMER_ABSTIME, &target, NULL);
 273
 274                 if (alertable && _wapi_thread_cur_apc_pending ())
 275                         return WAIT_IO_COMPLETION;
 276
 277                 if (ret == 0)
 278                         break;
 279         }
 280
 281 #else
 282         struct timespec req;
 283
 284         req.tv_sec=ms_quot;
 285         req.tv_nsec=ms_rem*1000000;
 286
 287 again:
 288         memset (&rem, 0, sizeof (rem));
 289         ret=nanosleep(&req, &rem);
 290
 291         if (alertable && _wapi_thread_cur_apc_pending ())
 292                 return WAIT_IO_COMPLETION;
 293
 294         if(ret==-1) {
 295                 /* Sleep interrupted with rem time remaining */
 296 #ifdef DEBUG_ENABLED
 297                 guint32 rems=rem.tv_sec*1000 + rem.tv_nsec/1000000;
 298
 299                 g_message("%s: Still got %d ms to go", __func__, rems);
 300 #endif
 301                 req=rem;
 302                 goto again;
 303         }
 304
 305 #endif /* __linux__ */
 306
 307         return 0;
 308 }
 309
 310 void
 311 Sleep(guint32 ms)
 312 {
 313         SleepEx(ms, FALSE);
 314 }
 315
 316 gboolean
 317 _wapi_thread_cur_apc_pending (void)
 318 {
 319         return mono_thread_info_is_interrupt_state (mono_thread_info_current ());
 320 }
 321
 322 void
 323 _wapi_thread_own_mutex (gpointer mutex)
 324 {
 325         WapiHandle_thread *thread;
 326
 327         thread = get_current_thread ();
 328
 329         _wapi_handle_ref (mutex);
 330
 331         g_ptr_array_add (thread->owned_mutexes, mutex);
 332 }
 333
 334 void
 335 _wapi_thread_disown_mutex (gpointer mutex)
 336 {
 337         WapiHandle_thread *thread;
 338
 339         thread = get_current_thread ();
 340
 341         _wapi_handle_unref (mutex);
 342
 343         g_ptr_array_remove (thread->owned_mutexes, mutex);
 344 }
 345
 346 char*
 347 wapi_current_thread_desc (void)
 348 {
 349         WapiHandle_thread *thread;
 350         gpointer thread_handle;
 351         int i;
 352         GString* text;
 353         char *res;
 354
 355         thread_handle = get_current_thread_handle ();
 356         thread = lookup_thread (thread_handle);
 357
 358         text = g_string_new (0);
 359         g_string_append_printf (text, "thread handle %p state : ", thread_handle);
 360
 361         mono_thread_info_describe_interrupt_token (mono_thread_info_current (), text);
 362
 363         g_string_append_printf (text, " owns (");
 364         for (i = 0; i < thread->owned_mutexes->len; i++)
 365                 g_string_append_printf (text, i > 0 ? ", %p" : "%p", g_ptr_array_index (thread->owned_mutexes, i));
 366         g_string_append_printf (text, ")");
 367
 368         res = text->str;
 369         g_string_free (text, FALSE);
 370         return res;
 371 }