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         WapiHandle_thread *thread;
 320
 321         thread = lookup_thread (get_current_thread_handle ());
 322         return thread->wait_handle == INTERRUPTION_REQUESTED_HANDLE;
 323 }
 324
 325 /*
 326  * wapi_interrupt_thread:
 327  *
 328  * The state of the thread handle HANDLE is set to 'interrupted' which means that
 329  * if the thread calls one of the WaitFor functions, the function will return with
 330  * WAIT_IO_COMPLETION instead of waiting. Also, if the thread was waiting when
 331  * this function was called, the wait will be broken.
 332  * It is possible that the wait functions return WAIT_IO_COMPLETION, but the
 333  * target thread didn't receive the interrupt signal yet, in this case it should
 334  * call the wait function again. This essentially means that the target thread will
 335  * busy wait until it is ready to process the interruption.
 336  */
 337 gpointer
 338 wapi_prepare_interrupt_thread (gpointer thread_handle)
 339 {
 340         WapiHandle_thread *thread;
 341         gpointer prev_handle, wait_handle;
 342
 343         thread = lookup_thread (thread_handle); /* FIXME this is wrong, move this whole thing to MonoThreads where it can be done lockfree */
 344
 345         while (TRUE) {
 346                 wait_handle = thread->wait_handle;
 347
 348                 /*
 349                  * Atomically obtain the handle the thread is waiting on, and
 350                  * change it to a flag value.
 351                  */
 352                 prev_handle = InterlockedCompareExchangePointer (&thread->wait_handle,
 353                                                                                                                  INTERRUPTION_REQUESTED_HANDLE, wait_handle);
 354                 if (prev_handle == INTERRUPTION_REQUESTED_HANDLE)
 355                         /* Already interrupted */
 356                         return 0;
 357                 if (prev_handle == wait_handle)
 358                         break;
 359
 360                 /* Try again */
 361         }
 362
 363         WAIT_DEBUG (printf ("%p: state -> INTERRUPTED.\n", thread->id););
 364
 365         return wait_handle;
 366 }
 367
 368 void
 369 wapi_finish_interrupt_thread (gpointer wait_handle)
 370 {
 371         pthread_cond_t *cond;
 372         mono_mutex_t *mutex;
 373         guint32 idx;
 374
 375         if (!wait_handle)
 376                 /* Not waiting */
 377                 return;
 378
 379         /* If we reach here, then wait_handle is set to the flag value,
 380          * which means that the target thread is either
 381          * - before the first CAS in timedwait, which means it won't enter the
 382          * wait.
 383          * - it is after the first CAS, so it is already waiting, or it will
 384          * enter the wait, and it will be interrupted by the broadcast.
 385          */
 386         idx = GPOINTER_TO_UINT(wait_handle);
 387         cond = &_WAPI_PRIVATE_HANDLES(idx).signal_cond;
 388         mutex = &_WAPI_PRIVATE_HANDLES(idx).signal_mutex;
 389
 390         mono_mutex_lock (mutex);
 391         mono_cond_broadcast (cond);
 392         mono_mutex_unlock (mutex);
 393
 394         /* ref added by set_wait_handle */
 395         _wapi_handle_unref (wait_handle);
 396 }
 397
 398 /*
 399  * wapi_self_interrupt:
 400  *
 401  *   This is not part of the WIN32 API.
 402  * Set the 'interrupted' state of the calling thread if it's NULL.
 403  */
 404 void
 405 wapi_self_interrupt (void)
 406 {
 407         gpointer wait_handle;
 408
 409         wait_handle = wapi_prepare_interrupt_thread (get_current_thread_handle ());
 410         if (wait_handle)
 411                 /* ref added by set_wait_handle */
 412                 _wapi_handle_unref (wait_handle);
 413 }
 414
 415 /*
 416  * wapi_clear_interruption:
 417  *
 418  *   This is not part of the WIN32 API.
 419  * Clear the 'interrupted' state of the calling thread.
 420  * This function is signal safe
 421  */
 422 void
 423 wapi_clear_interruption (void)
 424 {
 425         WapiHandle_thread *thread;
 426         gpointer prev_handle;
 427
 428         thread = get_current_thread ();
 429
 430         prev_handle = InterlockedCompareExchangePointer (&thread->wait_handle,
 431                                                                                                          NULL, INTERRUPTION_REQUESTED_HANDLE);
 432         if (prev_handle == INTERRUPTION_REQUESTED_HANDLE)
 433                 WAIT_DEBUG (printf ("%p: state -> NORMAL.\n", GetCurrentThreadId ()););
 434 }
 435
 436 /**
 437  * wapi_thread_set_wait_handle:
 438  *
 439  *   Set the wait handle for the current thread to HANDLE. Return TRUE on success, FALSE
 440  * if the thread is in interrupted state, and cannot start waiting.
 441  */
 442 gboolean
 443 wapi_thread_set_wait_handle (gpointer handle)
 444 {
 445         WapiHandle_thread *thread;
 446         gpointer prev_handle;
 447
 448         thread = get_current_thread ();
 449
 450         prev_handle = InterlockedCompareExchangePointer (&thread->wait_handle,
 451                                                                                                          handle, NULL);
 452         if (prev_handle == NULL) {
 453                 /* thread->wait_handle acts as an additional reference to the handle */
 454                 _wapi_handle_ref (handle);
 455
 456                 WAIT_DEBUG (printf ("%p: state -> WAITING.\n", GetCurrentThreadId ()););
 457         } else {
 458                 g_assert (prev_handle == INTERRUPTION_REQUESTED_HANDLE);
 459                 WAIT_DEBUG (printf ("%p: unable to set state to WAITING.\n", GetCurrentThreadId ()););
 460         }
 461
 462         return prev_handle == NULL;
 463 }
 464
 465 /**
 466  * wapi_thread_clear_wait_handle:
 467  *
 468  *   Clear the wait handle of the current thread.
 469  */
 470 void
 471 wapi_thread_clear_wait_handle (gpointer handle)
 472 {
 473         WapiHandle_thread *thread;
 474         gpointer prev_handle;
 475
 476         thread = get_current_thread ();
 477
 478         prev_handle = InterlockedCompareExchangePointer (&thread->wait_handle,
 479                                                                                                          NULL, handle);
 480         if (prev_handle == handle) {
 481                 _wapi_handle_unref (handle);
 482                 WAIT_DEBUG (printf ("%p: state -> NORMAL.\n", GetCurrentThreadId ()););
 483         } else {
 484                 /*It can be NULL if it was asynchronously cleared*/
 485                 g_assert (prev_handle == INTERRUPTION_REQUESTED_HANDLE || prev_handle == NULL);
 486                 WAIT_DEBUG (printf ("%p: finished waiting.\n", GetCurrentThreadId ()););
 487         }
 488 }
 489
 490 void
 491 _wapi_thread_own_mutex (gpointer mutex)
 492 {
 493         WapiHandle_thread *thread;
 494
 495         thread = get_current_thread ();
 496
 497         _wapi_handle_ref (mutex);
 498
 499         g_ptr_array_add (thread->owned_mutexes, mutex);
 500 }
 501
 502 void
 503 _wapi_thread_disown_mutex (gpointer mutex)
 504 {
 505         WapiHandle_thread *thread;
 506
 507         thread = get_current_thread ();
 508
 509         _wapi_handle_unref (mutex);
 510
 511         g_ptr_array_remove (thread->owned_mutexes, mutex);
 512 }
 513
 514 char*
 515 wapi_current_thread_desc (void)
 516 {
 517         WapiHandle_thread *thread;
 518         gpointer thread_handle;
 519         int i;
 520         gpointer handle;
 521         GString* text;
 522         char *res;
 523
 524         thread_handle = get_current_thread_handle ();
 525         thread = lookup_thread (thread_handle);
 526
 527         handle = thread->wait_handle;
 528         text = g_string_new (0);
 529         g_string_append_printf (text, "thread handle %p state : ", thread_handle);
 530
 531         if (!handle)
 532                 g_string_append_printf (text, "not waiting");
 533         else if (handle == INTERRUPTION_REQUESTED_HANDLE)
 534                 g_string_append_printf (text, "interrupted state");
 535         else
 536                 g_string_append_printf (text, "waiting on %p : %s ", handle, _wapi_handle_typename[_wapi_handle_type (handle)]);
 537         g_string_append_printf (text, " owns (");
 538         for (i = 0; i < thread->owned_mutexes->len; i++) {
 539                 gpointer mutex = g_ptr_array_index (thread->owned_mutexes, i);
 540                 if (i > 0)
 541                         g_string_append_printf (text, ", %p", mutex);
 542                 else
 543                         g_string_append_printf (text, "%p", mutex);
 544         }
 545         g_string_append_printf (text, ")");
 546
 547         res = text->str;
 548         g_string_free (text, FALSE);
 549         return res;
 550 }