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  */
   9
  10 #include <config.h>
  11 #include <stdio.h>
  12 #include <glib.h>
  13 #include <string.h>
  14 #include <mono/utils/gc_wrapper.h>
  15 #include <pthread.h>
  16 #include <signal.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/mono-mutex.h>
  28 #include <mono/io-layer/thread-private.h>
  29 #include <mono/io-layer/mono-spinlock.h>
  30 #include <mono/io-layer/mutex-private.h>
  31 #include <mono/io-layer/atomic.h>
  32
  33 #ifdef HAVE_VALGRIND_MEMCHECK_H
  34 #include <valgrind/memcheck.h>
  35 #endif
  36
  37 #undef DEBUG
  38 #undef TLS_DEBUG
  39
  40 #if 0
  41 #define WAIT_DEBUG(code) do { code } while (0)
  42 #else
  43 #define WAIT_DEBUG(code) do { } while (0)
  44 #endif
  45
  46 /* Hash threads with tids. I thought of using TLS for this, but that
  47  * would have to set the data in the new thread, which is more hassle
  48  */
  49 static mono_once_t thread_hash_once = MONO_ONCE_INIT;
  50 static pthread_key_t thread_hash_key;
  51
  52 /* This key is used with attached threads and a destructor to signal
  53  * when attached threads exit, as they don't have the thread_exit()
  54  * infrastructure
  55  */
  56 static pthread_key_t thread_attached_key;
  57
  58 struct _WapiHandleOps _wapi_thread_ops = {
  59         NULL,                           /* close */
  60         NULL,                           /* signal */
  61         NULL,                           /* own */
  62         NULL,                           /* is_owned */
  63         NULL,                           /* special_wait */
  64         NULL                            /* prewait */
  65 };
  66
  67 static mono_once_t thread_ops_once=MONO_ONCE_INIT;
  68
  69 static void thread_ops_init (void)
  70 {
  71         _wapi_handle_register_capabilities (WAPI_HANDLE_THREAD,
  72                                             WAPI_HANDLE_CAP_WAIT);
  73 }
  74
  75 void _wapi_thread_cleanup (void)
  76 {
  77         int ret;
  78
  79         ret = pthread_key_delete (thread_hash_key);
  80         g_assert (ret == 0);
  81
  82         ret = pthread_key_delete (thread_attached_key);
  83         g_assert (ret == 0);
  84 }
  85
  86 /* Called by thread_exit(), but maybe indirectly by
  87  * mono_thread_manage() via mono_thread_signal_self() too
  88  */
  89 static void _wapi_thread_abandon_mutexes (gpointer handle)
  90 {
  91         struct _WapiHandle_thread *thread_handle;
  92         gboolean ok;
  93         int i;
  94         pid_t pid = _wapi_getpid ();
  95         pthread_t tid = pthread_self ();
  96
  97 #ifdef DEBUG
  98         g_message ("%s: Thread %p abandoning held mutexes", __func__, handle);
  99 #endif
 100
 101         if (handle == NULL) {
 102                 handle = _wapi_thread_handle_from_id (pthread_self ());
 103                 if (handle == NULL) {
 104                         /* Something gone badly wrong... */
 105                         return;
 106                 }
 107         }
 108
 109         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
 110                                   (gpointer *)&thread_handle);
 111         if (ok == FALSE) {
 112                 g_warning ("%s: error looking up thread handle %p", __func__,
 113                            handle);
 114                 return;
 115         }
 116
 117         if (!pthread_equal (thread_handle->id, tid)) {
 118                 return;
 119         }
 120
 121         for (i = 0; i < thread_handle->owned_mutexes->len; i++) {
 122                 gpointer mutex = g_ptr_array_index (thread_handle->owned_mutexes, i);
 123
 124                 _wapi_mutex_abandon (mutex, pid, tid);
 125                 _wapi_thread_disown_mutex (mutex);
 126         }
 127 }
 128
 129 void _wapi_thread_set_termination_details (gpointer handle,
 130                                            guint32 exitstatus)
 131 {
 132         struct _WapiHandle_thread *thread_handle;
 133         gboolean ok;
 134         int thr_ret;
 135
 136         if (_wapi_handle_issignalled (handle) ||
 137             _wapi_handle_type (handle) == WAPI_HANDLE_UNUSED) {
 138                 /* We must have already deliberately finished with
 139                  * this thread, so don't do any more now
 140                  */
 141                 return;
 142         }
 143
 144 #ifdef DEBUG
 145         g_message ("%s: Thread %p terminating", __func__, handle);
 146 #endif
 147
 148         _wapi_thread_abandon_mutexes (handle);
 149
 150         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
 151                                   (gpointer *)&thread_handle);
 152         if (ok == FALSE) {
 153                 g_warning ("%s: error looking up thread handle %p", __func__,
 154                            handle);
 155
 156                 return;
 157         }
 158
 159         pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_handle,
 160                               handle);
 161         thr_ret = _wapi_handle_lock_handle (handle);
 162         g_assert (thr_ret == 0);
 163
 164         thread_handle->exitstatus = exitstatus;
 165         thread_handle->state = THREAD_STATE_EXITED;
 166         MONO_SEM_DESTROY (&thread_handle->suspend_sem);
 167         g_ptr_array_free (thread_handle->owned_mutexes, TRUE);
 168
 169         _wapi_handle_set_signal_state (handle, TRUE, TRUE);
 170
 171         thr_ret = _wapi_handle_unlock_handle (handle);
 172         g_assert (thr_ret == 0);
 173         pthread_cleanup_pop (0);
 174
 175 #ifdef DEBUG
 176         g_message("%s: Recording thread handle %p id %ld status as %d",
 177                   __func__, handle, thread_handle->id, exitstatus);
 178 #endif
 179
 180         /* The thread is no longer active, so unref it */
 181         _wapi_handle_unref (handle);
 182 }
 183
 184 void _wapi_thread_signal_self (guint32 exitstatus)
 185 {
 186         gpointer handle;
 187
 188         handle = _wapi_thread_handle_from_id (pthread_self ());
 189         if (handle == NULL) {
 190                 /* Something gone badly wrong... */
 191                 return;
 192         }
 193
 194         _wapi_thread_set_termination_details (handle, exitstatus);
 195 }
 196
 197 /* Called by the thread creation code as a thread is finishing up, and
 198  * by ExitThread()
 199 */
 200 static void thread_exit (guint32 exitstatus, gpointer handle) G_GNUC_NORETURN;
 201 static void thread_exit (guint32 exitstatus, gpointer handle)
 202 {
 203         _wapi_thread_set_termination_details (handle, exitstatus);
 204
 205         /* Call pthread_exit() to call destructors and really exit the
 206          * thread
 207          */
 208         pthread_exit (NULL);
 209 }
 210
 211 static void thread_attached_exit (gpointer handle)
 212 {
 213         /* Drop the extra reference we take in thread_attach, now this
 214          * thread is dead
 215          */
 216
 217         _wapi_thread_set_termination_details (handle, 0);
 218 }
 219
 220 static void thread_hash_init(void)
 221 {
 222         int thr_ret;
 223
 224         thr_ret = pthread_key_create (&thread_hash_key, NULL);
 225         g_assert (thr_ret == 0);
 226
 227         thr_ret = pthread_key_create (&thread_attached_key,
 228                                       thread_attached_exit);
 229         g_assert (thr_ret == 0);
 230 }
 231
 232 static void _wapi_thread_suspend (struct _WapiHandle_thread *thread)
 233 {
 234         g_assert (pthread_equal (thread->id, pthread_self ()));
 235
 236         while (MONO_SEM_WAIT (&thread->suspend_sem) != 0 &&
 237                errno == EINTR);
 238 }
 239
 240 static void _wapi_thread_resume (struct _WapiHandle_thread *thread)
 241 {
 242         MONO_SEM_POST (&thread->suspend_sem);
 243 }
 244
 245 static void *thread_start_routine (gpointer args) G_GNUC_NORETURN;
 246 static void *thread_start_routine (gpointer args)
 247 {
 248         struct _WapiHandle_thread *thread = (struct _WapiHandle_thread *)args;
 249         int thr_ret;
 250
 251         thr_ret = pthread_detach (pthread_self ());
 252         g_assert (thr_ret == 0);
 253
 254         thr_ret = pthread_setspecific (thread_hash_key,
 255                                        (void *)thread->handle);
 256         if (thr_ret != 0) {
 257                 /* This is only supposed to happen when Mono is
 258                    shutting down.  We cannot assert on it, though,
 259                    because we must not depend on metadata, which is
 260                    where the shutdown code is.
 261
 262                    This is a race condition which arises because
 263                    pthreads don't allow creation of suspended threads.
 264                    Once Mono is set to shut down no new thread is
 265                    allowed to start, even though threads may still be
 266                    created.  We emulate suspended threads in this
 267                    function by calling _wapi_thread_suspend() below.
 268
 269                    So it can happen that even though Mono is already
 270                    shutting down we still end up here, and at this
 271                    point the thread_hash_key might already be
 272                    destroyed. */
 273                 pthread_exit (NULL);
 274         }
 275
 276         thread->id = pthread_self();
 277
 278 #ifdef DEBUG
 279         g_message ("%s: started thread id %ld", __func__, thread->id);
 280 #endif
 281
 282         if (thread->create_flags & CREATE_SUSPENDED) {
 283                 _wapi_thread_suspend (thread);
 284         }
 285
 286         thread_exit (thread->start_routine (thread->start_arg),
 287                      thread->handle);
 288
 289 #ifndef __GNUC__
 290         /* Even though we tell gcc that this function doesn't return,
 291          * other compilers won't see that.
 292          */
 293         return(NULL);
 294 #endif
 295 }
 296
 297 /**
 298  * CreateThread:
 299  * @security: Ignored for now.
 300  * @stacksize: the size in bytes of the new thread's stack. Use 0 to
 301  * default to the normal stack size. (Ignored for now).
 302  * @start: The function that the new thread should start with
 303  * @param: The parameter to give to @start.
 304  * @create: If 0, the new thread is ready to run immediately.  If
 305  * %CREATE_SUSPENDED, the new thread will be in the suspended state,
 306  * requiring a ResumeThread() call to continue running.
 307  * @tid: If non-NULL, the ID of the new thread is stored here.  NB
 308  * this is defined as a DWORD (ie 32bit) in the MS API, but we need to
 309  * cope with 64 bit IDs for s390x and amd64.
 310  *
 311  * Creates a new threading handle.
 312  *
 313  * Return value: a new handle, or NULL
 314  */
 315 gpointer CreateThread(WapiSecurityAttributes *security G_GNUC_UNUSED, guint32 stacksize,
 316                       WapiThreadStart start, gpointer param, guint32 create,
 317                       gsize *tid)
 318 {
 319         struct _WapiHandle_thread thread_handle = {0}, *thread_handle_p;
 320         pthread_attr_t attr;
 321         gpointer handle;
 322         gboolean ok;
 323         int ret;
 324         int thr_ret;
 325         int i, unrefs = 0;
 326         gpointer ct_ret = NULL;
 327
 328         mono_once (&thread_hash_once, thread_hash_init);
 329         mono_once (&thread_ops_once, thread_ops_init);
 330
 331         if (start == NULL) {
 332                 return(NULL);
 333         }
 334
 335         thread_handle.state = THREAD_STATE_START;
 336         thread_handle.owned_mutexes = g_ptr_array_new ();
 337         thread_handle.create_flags = create;
 338         thread_handle.start_routine = start;
 339         thread_handle.start_arg = param;
 340
 341         handle = _wapi_handle_new (WAPI_HANDLE_THREAD, &thread_handle);
 342         if (handle == _WAPI_HANDLE_INVALID) {
 343                 g_warning ("%s: error creating thread handle", __func__);
 344                 SetLastError (ERROR_GEN_FAILURE);
 345
 346                 return (NULL);
 347         }
 348
 349         pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_handle,
 350                               handle);
 351         thr_ret = _wapi_handle_lock_handle (handle);
 352         g_assert (thr_ret == 0);
 353
 354         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
 355                                   (gpointer *)&thread_handle_p);
 356         if (ok == FALSE) {
 357                 g_warning ("%s: error looking up thread handle %p", __func__,
 358                            handle);
 359                 SetLastError (ERROR_GEN_FAILURE);
 360
 361                 goto cleanup;
 362         }
 363
 364         /* Hold a reference while the thread is active, because we use
 365          * the handle to store thread exit information
 366          */
 367         _wapi_handle_ref (handle);
 368
 369         /* Set a 2M stack size.  This is the default on Linux, but BSD
 370          * needs it.  (The original bug report from Martin Dvorak <md@9ll.cz>
 371          * set the size to 2M-4k.  I don't know why it's short by 4k, so
 372          * I'm leaving it as 2M until I'm told differently.)
 373          */
 374         thr_ret = pthread_attr_init(&attr);
 375         g_assert (thr_ret == 0);
 376
 377         /* defaults of 2Mb for 32bits and 4Mb for 64bits */
 378         /* temporarily changed to use 1 MB: this allows more threads
 379          * to be used, as well as using less virtual memory and so
 380          * more is available for the GC heap.
 381          */
 382         if (stacksize == 0){
 383 #if HAVE_VALGRIND_MEMCHECK_H
 384                 if (RUNNING_ON_VALGRIND) {
 385                         stacksize = 1 << 20;
 386                 } else {
 387                         stacksize = (SIZEOF_VOID_P / 4) * 1024 * 1024;
 388                 }
 389 #else
 390                 stacksize = (SIZEOF_VOID_P / 4) * 1024 * 1024;
 391 #endif
 392         }
 393
 394 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
 395         thr_ret = pthread_attr_setstacksize(&attr, stacksize);
 396         g_assert (thr_ret == 0);
 397 #endif
 398
 399         MONO_SEM_INIT (&thread_handle_p->suspend_sem, 0);
 400         thread_handle_p->handle = handle;
 401
 402
 403         ret = pthread_create (&thread_handle_p->id, &attr,
 404                               thread_start_routine, (void *)thread_handle_p);
 405
 406         if (ret != 0) {
 407 #ifdef DEBUG
 408                 g_message ("%s: Thread create error: %s", __func__,
 409                            strerror(ret));
 410 #endif
 411
 412                 /* Two, because of the reference we took above */
 413                 unrefs = 2;
 414
 415                 goto cleanup;
 416         }
 417         ct_ret = handle;
 418
 419 #ifdef DEBUG
 420         g_message("%s: Started thread handle %p ID %ld", __func__, handle,
 421                   thread_handle_p->id);
 422 #endif
 423
 424         if (tid != NULL) {
 425 #ifdef PTHREAD_POINTER_ID
 426                 /* Don't use GPOINTER_TO_UINT here, it can't cope with
 427                  * sizeof(void *) > sizeof(uint) when a cast to uint
 428                  * would overflow
 429                  */
 430                 *tid = (gsize)(thread_handle_p->id);
 431 #else
 432                 *tid = thread_handle_p->id;
 433 #endif
 434         }
 435
 436 cleanup:
 437         thr_ret = _wapi_handle_unlock_handle (handle);
 438         g_assert (thr_ret == 0);
 439         pthread_cleanup_pop (0);
 440
 441         /* Must not call _wapi_handle_unref() with the shared handles
 442          * already locked
 443          */
 444         for (i = 0; i < unrefs; i++) {
 445                 _wapi_handle_unref (handle);
 446         }
 447
 448         return(ct_ret);
 449 }
 450
 451 /* The only time this function is called when tid != pthread_self ()
 452  * is from OpenThread (), so we can fast-path most cases by just
 453  * looking up the handle in TLS.  OpenThread () must cope with a NULL
 454  * return and do a handle search in that case.
 455  */
 456 gpointer _wapi_thread_handle_from_id (pthread_t tid)
 457 {
 458         gpointer ret;
 459
 460         if (pthread_equal (tid, pthread_self ()) &&
 461             (ret = pthread_getspecific (thread_hash_key)) != NULL) {
 462                 /* We know the handle */
 463
 464 #ifdef DEBUG
 465                 g_message ("%s: Returning %p for self thread %ld from TLS",
 466                            __func__, ret, tid);
 467 #endif
 468
 469                 return(ret);
 470         }
 471
 472 #ifdef DEBUG
 473         g_message ("%s: Returning NULL for unknown or non-self thread %ld",
 474                    __func__, tid);
 475 #endif
 476
 477
 478         return(NULL);
 479 }
 480
 481 static gboolean find_thread_by_id (gpointer handle, gpointer user_data)
 482 {
 483         pthread_t tid = (pthread_t)user_data;
 484         struct _WapiHandle_thread *thread_handle;
 485         gboolean ok;
 486
 487         /* Ignore threads that have already exited (ie they are signalled) */
 488         if (_wapi_handle_issignalled (handle) == FALSE) {
 489                 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
 490                                           (gpointer *)&thread_handle);
 491                 if (ok == FALSE) {
 492                         /* It's possible that the handle has vanished
 493                          * during the _wapi_search_handle before it
 494                          * gets here, so don't spam the console with
 495                          * warnings.
 496                          */
 497                         return(FALSE);
 498                 }
 499
 500 #ifdef DEBUG
 501                 g_message ("%s: looking at thread %ld from process %d", __func__, thread_handle->id, 0);
 502 #endif
 503
 504                 if (pthread_equal (thread_handle->id, tid)) {
 505 #ifdef DEBUG
 506                         g_message ("%s: found the thread we are looking for",
 507                                    __func__);
 508 #endif
 509                         return(TRUE);
 510                 }
 511         }
 512
 513 #ifdef DEBUG
 514         g_message ("%s: not found %ld, returning FALSE", __func__, tid);
 515 #endif
 516
 517         return(FALSE);
 518 }
 519
 520 /* NB tid is 32bit in MS API, but we need 64bit on amd64 and s390x
 521  * (and probably others)
 522  */
 523 gpointer OpenThread (guint32 access G_GNUC_UNUSED, gboolean inherit G_GNUC_UNUSED, gsize tid)
 524 {
 525         gpointer ret=NULL;
 526
 527         mono_once (&thread_hash_once, thread_hash_init);
 528         mono_once (&thread_ops_once, thread_ops_init);
 529
 530 #ifdef DEBUG
 531         g_message ("%s: looking up thread %"G_GSIZE_FORMAT, __func__, tid);
 532 #endif
 533
 534         ret = _wapi_thread_handle_from_id ((pthread_t)tid);
 535         if (ret == NULL) {
 536                 /* We need to search for this thread */
 537                 ret = _wapi_search_handle (WAPI_HANDLE_THREAD, find_thread_by_id, (gpointer)tid, NULL, FALSE/*TRUE*/);  /* FIXME: have a proper look at this, me might not need to set search_shared = TRUE */
 538         } else {
 539                 /* if _wapi_search_handle() returns a found handle, it
 540                  * refs it itself
 541                  */
 542                 _wapi_handle_ref (ret);
 543         }
 544
 545 #ifdef DEBUG
 546         g_message ("%s: returning thread handle %p", __func__, ret);
 547 #endif
 548
 549         return(ret);
 550 }
 551
 552 /**
 553  * ExitThread:
 554  * @exitcode: Sets the thread's exit code, which can be read from
 555  * another thread with GetExitCodeThread().
 556  *
 557  * Terminates the calling thread.  A thread can also exit by returning
 558  * from its start function. When the last thread in a process
 559  * terminates, the process itself terminates.
 560  */
 561 void ExitThread(guint32 exitcode)
 562 {
 563         gpointer thread = _wapi_thread_handle_from_id (pthread_self ());
 564
 565         if (thread != NULL) {
 566                 thread_exit(exitcode, thread);
 567         } else {
 568                 /* Just blow this thread away */
 569                 pthread_exit (NULL);
 570         }
 571 }
 572
 573 /**
 574  * GetExitCodeThread:
 575  * @handle: The thread handle to query
 576  * @exitcode: The thread @handle exit code is stored here
 577  *
 578  * Finds the exit code of @handle, and stores it in @exitcode.  If the
 579  * thread @handle is still running, the value stored is %STILL_ACTIVE.
 580  *
 581  * Return value: %TRUE, or %FALSE on error.
 582  */
 583 gboolean GetExitCodeThread(gpointer handle, guint32 *exitcode)
 584 {
 585         struct _WapiHandle_thread *thread_handle;
 586         gboolean ok;
 587
 588         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
 589                                   (gpointer *)&thread_handle);
 590         if (ok == FALSE) {
 591                 g_warning ("%s: error looking up thread handle %p", __func__,
 592                            handle);
 593                 return (FALSE);
 594         }
 595
 596 #ifdef DEBUG
 597         g_message ("%s: Finding exit status for thread handle %p id %ld",
 598                    __func__, handle, thread_handle->id);
 599 #endif
 600
 601         if (exitcode == NULL) {
 602 #ifdef DEBUG
 603                 g_message ("%s: Nowhere to store exit code", __func__);
 604 #endif
 605                 return(FALSE);
 606         }
 607
 608         if (thread_handle->state != THREAD_STATE_EXITED) {
 609 #ifdef DEBUG
 610                 g_message ("%s: Thread still active (state %d, exited is %d)",
 611                            __func__, thread_handle->state,
 612                            THREAD_STATE_EXITED);
 613 #endif
 614                 *exitcode = STILL_ACTIVE;
 615                 return(TRUE);
 616         }
 617
 618         *exitcode = thread_handle->exitstatus;
 619
 620         return(TRUE);
 621 }
 622
 623 /**
 624  * GetCurrentThreadId:
 625  *
 626  * Looks up the thread ID of the current thread.  This ID can be
 627  * passed to OpenThread() to create a new handle on this thread.
 628  *
 629  * Return value: the thread ID.  NB this is defined as DWORD (ie 32
 630  * bit) in the MS API, but we need to cope with 64 bit IDs for s390x
 631  * and amd64.  This doesn't really break the API, it just embraces and
 632  * extends it on 64bit platforms :)
 633  */
 634 gsize GetCurrentThreadId(void)
 635 {
 636         pthread_t tid = pthread_self();
 637
 638 #ifdef PTHREAD_POINTER_ID
 639         /* Don't use GPOINTER_TO_UINT here, it can't cope with
 640          * sizeof(void *) > sizeof(uint) when a cast to uint would
 641          * overflow
 642          */
 643         return((gsize)tid);
 644 #else
 645         return(tid);
 646 #endif
 647 }
 648
 649 static gpointer thread_attach(gsize *tid)
 650 {
 651         struct _WapiHandle_thread thread_handle = {0}, *thread_handle_p;
 652         gpointer handle;
 653         gboolean ok;
 654         int thr_ret;
 655
 656         mono_once (&thread_hash_once, thread_hash_init);
 657         mono_once (&thread_ops_once, thread_ops_init);
 658
 659         thread_handle.state = THREAD_STATE_START;
 660         thread_handle.owned_mutexes = g_ptr_array_new ();
 661
 662         handle = _wapi_handle_new (WAPI_HANDLE_THREAD, &thread_handle);
 663         if (handle == _WAPI_HANDLE_INVALID) {
 664                 g_warning ("%s: error creating thread handle", __func__);
 665
 666                 SetLastError (ERROR_GEN_FAILURE);
 667                 return (NULL);
 668         }
 669
 670         pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_handle,
 671                               handle);
 672         thr_ret = _wapi_handle_lock_handle (handle);
 673         g_assert (thr_ret == 0);
 674
 675         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
 676                                   (gpointer *)&thread_handle_p);
 677         if (ok == FALSE) {
 678                 g_warning ("%s: error looking up thread handle %p", __func__,
 679                            handle);
 680
 681                 SetLastError (ERROR_GEN_FAILURE);
 682                 goto cleanup;
 683         }
 684
 685         /* Hold a reference while the thread is active, because we use
 686          * the handle to store thread exit information
 687          */
 688         _wapi_handle_ref (handle);
 689
 690         /* suspend_sem is not used for attached threads, but
 691          * thread_exit() might try to destroy it
 692          */
 693         MONO_SEM_INIT (&thread_handle_p->suspend_sem, 0);
 694         thread_handle_p->handle = handle;
 695         thread_handle_p->id = pthread_self ();
 696
 697         thr_ret = pthread_setspecific (thread_hash_key, (void *)handle);
 698         g_assert (thr_ret == 0);
 699
 700         thr_ret = pthread_setspecific (thread_attached_key, (void *)handle);
 701         g_assert (thr_ret == 0);
 702
 703 #ifdef DEBUG
 704         g_message("%s: Attached thread handle %p ID %ld", __func__, handle,
 705                   thread_handle_p->id);
 706 #endif
 707
 708         if (tid != NULL) {
 709 #ifdef PTHREAD_POINTER_ID
 710                 /* Don't use GPOINTER_TO_UINT here, it can't cope with
 711                  * sizeof(void *) > sizeof(uint) when a cast to uint
 712                  * would overflow
 713                  */
 714                 *tid = (gsize)(thread_handle_p->id);
 715 #else
 716                 *tid = thread_handle_p->id;
 717 #endif
 718         }
 719
 720 cleanup:
 721         thr_ret = _wapi_handle_unlock_handle (handle);
 722         g_assert (thr_ret == 0);
 723         pthread_cleanup_pop (0);
 724
 725         return(handle);
 726 }
 727
 728 gpointer _wapi_thread_duplicate ()
 729 {
 730         gpointer ret = NULL;
 731
 732         mono_once (&thread_hash_once, thread_hash_init);
 733         mono_once (&thread_ops_once, thread_ops_init);
 734
 735         ret = _wapi_thread_handle_from_id (pthread_self ());
 736         if (!ret) {
 737                 ret = thread_attach (NULL);
 738         } else {
 739                 _wapi_handle_ref (ret);
 740         }
 741
 742         return(ret);
 743 }
 744
 745 /**
 746  * GetCurrentThread:
 747  *
 748  * Looks up the handle associated with the current thread.  Under
 749  * Windows this is a pseudohandle, and must be duplicated with
 750  * DuplicateHandle() for some operations.
 751  *
 752  * Return value: The current thread handle, or %NULL on failure.
 753  * (Unknown whether Windows has a possible failure here.  It may be
 754  * necessary to implement the pseudohandle-constant behaviour).
 755  */
 756 gpointer GetCurrentThread(void)
 757 {
 758         mono_once(&thread_hash_once, thread_hash_init);
 759         mono_once (&thread_ops_once, thread_ops_init);
 760
 761         return(_WAPI_THREAD_CURRENT);
 762 }
 763
 764 /**
 765  * ResumeThread:
 766  * @handle: the thread handle to resume
 767  *
 768  * Decrements the suspend count of thread @handle. A thread can only
 769  * run if its suspend count is zero.
 770  *
 771  * Return value: the previous suspend count, or 0xFFFFFFFF on error.
 772  */
 773 guint32 ResumeThread(gpointer handle)
 774 {
 775         struct _WapiHandle_thread *thread_handle;
 776         gboolean ok;
 777
 778         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
 779                                   (gpointer *)&thread_handle);
 780         if (ok == FALSE) {
 781                 g_warning ("%s: error looking up thread handle %p", __func__,
 782                            handle);
 783
 784                 return (0xFFFFFFFF);
 785         }
 786
 787         /* This is still a kludge that only copes with starting a
 788          * thread that was suspended on create, so don't bother with
 789          * the suspend count crap yet
 790          */
 791         _wapi_thread_resume (thread_handle);
 792         return(0xFFFFFFFF);
 793 }
 794
 795 /**
 796  * SuspendThread:
 797  * @handle: the thread handle to suspend
 798  *
 799  * Increments the suspend count of thread @handle. A thread can only
 800  * run if its suspend count is zero.
 801  *
 802  * Return value: the previous suspend count, or 0xFFFFFFFF on error.
 803  */
 804 guint32 SuspendThread(gpointer handle)
 805 {
 806         return(0xFFFFFFFF);
 807 }
 808
 809 /*
 810  * We assume here that TLS_MINIMUM_AVAILABLE is less than
 811  * PTHREAD_KEYS_MAX, allowing enough overhead for a few TLS keys for
 812  * library usage.
 813  *
 814  * Currently TLS_MINIMUM_AVAILABLE is 64 and _POSIX_THREAD_KEYS_MAX
 815  * (the minimum value for PTHREAD_KEYS_MAX) is 128, so we should be
 816  * fine.
 817  */
 818
 819 static pthread_key_t TLS_keys[TLS_MINIMUM_AVAILABLE];
 820 static gboolean TLS_used[TLS_MINIMUM_AVAILABLE]={FALSE};
 821 static guint32 TLS_spinlock=0;
 822
 823 guint32
 824 mono_pthread_key_for_tls (guint32 idx)
 825 {
 826         return (guint32)TLS_keys [idx];
 827 }
 828
 829 /**
 830  * TlsAlloc:
 831  *
 832  * Allocates a Thread Local Storage (TLS) index.  Any thread in the
 833  * same process can use this index to store and retrieve values that
 834  * are local to that thread.
 835  *
 836  * Return value: The index value, or %TLS_OUT_OF_INDEXES if no index
 837  * is available.
 838  */
 839 guint32 TlsAlloc(void)
 840 {
 841         guint32 i;
 842         int thr_ret;
 843
 844         MONO_SPIN_LOCK (TLS_spinlock);
 845
 846         for(i=0; i<TLS_MINIMUM_AVAILABLE; i++) {
 847                 if(TLS_used[i]==FALSE) {
 848                         TLS_used[i]=TRUE;
 849                         thr_ret = pthread_key_create(&TLS_keys[i], NULL);
 850                         g_assert (thr_ret == 0);
 851
 852                         MONO_SPIN_UNLOCK (TLS_spinlock);
 853
 854 #ifdef TLS_DEBUG
 855                         g_message ("%s: returning key %d", __func__, i);
 856 #endif
 857
 858                         return(i);
 859                 }
 860         }
 861
 862         MONO_SPIN_UNLOCK (TLS_spinlock);
 863
 864 #ifdef TLS_DEBUG
 865         g_message ("%s: out of indices", __func__);
 866 #endif
 867
 868
 869         return(TLS_OUT_OF_INDEXES);
 870 }
 871
 872 #define MAKE_GC_ID(idx) (GUINT_TO_POINTER((idx)|(GetCurrentThreadId()<<8)))
 873
 874 /**
 875  * TlsFree:
 876  * @idx: The TLS index to free
 877  *
 878  * Releases a TLS index, making it available for reuse.  This call
 879  * will delete any TLS data stored under index @idx in all threads.
 880  *
 881  * Return value: %TRUE on success, %FALSE otherwise.
 882  */
 883 gboolean TlsFree(guint32 idx)
 884 {
 885         int thr_ret;
 886
 887 #ifdef TLS_DEBUG
 888         g_message ("%s: freeing key %d", __func__, idx);
 889 #endif
 890
 891         MONO_SPIN_LOCK (TLS_spinlock);
 892
 893         if(TLS_used[idx]==FALSE) {
 894                 MONO_SPIN_UNLOCK (TLS_spinlock);
 895
 896                 return(FALSE);
 897         }
 898
 899         TLS_used[idx]=FALSE;
 900         thr_ret = pthread_key_delete(TLS_keys[idx]);
 901         g_assert (thr_ret == 0);
 902
 903         MONO_SPIN_UNLOCK (TLS_spinlock);
 904
 905         return(TRUE);
 906 }
 907
 908 /**
 909  * TlsGetValue:
 910  * @idx: The TLS index to retrieve
 911  *
 912  * Retrieves the TLS data stored under index @idx.
 913  *
 914  * Return value: The value stored in the TLS index @idx in the current
 915  * thread, or %NULL on error.  As %NULL can be a valid return value,
 916  * in this case GetLastError() returns %ERROR_SUCCESS.
 917  */
 918 gpointer TlsGetValue(guint32 idx)
 919 {
 920         gpointer ret;
 921
 922 #ifdef TLS_DEBUG
 923         g_message ("%s: looking up key %d", __func__, idx);
 924 #endif
 925
 926         ret=pthread_getspecific(TLS_keys[idx]);
 927
 928 #ifdef TLS_DEBUG
 929         g_message ("%s: returning %p", __func__, ret);
 930 #endif
 931
 932         return(ret);
 933 }
 934
 935 /**
 936  * TlsSetValue:
 937  * @idx: The TLS index to store
 938  * @value: The value to store under index @idx
 939  *
 940  * Stores @value at TLS index @idx.
 941  *
 942  * Return value: %TRUE on success, %FALSE otherwise.
 943  */
 944 gboolean TlsSetValue(guint32 idx, gpointer value)
 945 {
 946         int ret;
 947
 948 #ifdef TLS_DEBUG
 949         g_message ("%s: setting key %d to %p", __func__, idx, value);
 950 #endif
 951
 952         MONO_SPIN_LOCK (TLS_spinlock);
 953
 954         if(TLS_used[idx]==FALSE) {
 955 #ifdef TLS_DEBUG
 956                 g_message ("%s: key %d unused", __func__, idx);
 957 #endif
 958
 959                 MONO_SPIN_UNLOCK (TLS_spinlock);
 960
 961                 return(FALSE);
 962         }
 963
 964         ret=pthread_setspecific(TLS_keys[idx], value);
 965         if(ret!=0) {
 966 #ifdef TLS_DEBUG
 967                 g_message ("%s: pthread_setspecific error: %s", __func__,
 968                            strerror (ret));
 969 #endif
 970
 971                 MONO_SPIN_UNLOCK (TLS_spinlock);
 972
 973                 return(FALSE);
 974         }
 975
 976         MONO_SPIN_UNLOCK (TLS_spinlock);
 977
 978         return(TRUE);
 979 }
 980
 981 /**
 982  * SleepEx:
 983  * @ms: The time in milliseconds to suspend for
 984  * @alertable: if TRUE, the wait can be interrupted by an APC call
 985  *
 986  * Suspends execution of the current thread for @ms milliseconds.  A
 987  * value of zero causes the thread to relinquish its time slice.  A
 988  * value of %INFINITE causes an infinite delay.
 989  */
 990 guint32 SleepEx(guint32 ms, gboolean alertable)
 991 {
 992         struct timespec req, rem;
 993         int ms_quot, ms_rem;
 994         int ret;
 995         gpointer current_thread = NULL;
 996
 997 #ifdef DEBUG
 998         g_message("%s: Sleeping for %d ms", __func__, ms);
 999 #endif
1000
1001         if (alertable) {
1002                 current_thread = _wapi_thread_handle_from_id (pthread_self ());
1003                 if (current_thread == NULL) {
1004                         SetLastError (ERROR_INVALID_HANDLE);
1005                         return(WAIT_FAILED);
1006                 }
1007
1008                 if (_wapi_thread_apc_pending (current_thread)) {
1009                         _wapi_thread_dispatch_apc_queue (current_thread);
1010                         return WAIT_IO_COMPLETION;
1011                 }
1012         }
1013
1014         if(ms==0) {
1015                 sched_yield();
1016                 return 0;
1017         }
1018
1019         /* FIXME: check for INFINITE and sleep forever */
1020         ms_quot = ms / 1000;
1021         ms_rem = ms % 1000;
1022
1023         req.tv_sec=ms_quot;
1024         req.tv_nsec=ms_rem*1000000;
1025
1026 again:
1027         ret=nanosleep(&req, &rem);
1028
1029         if (alertable && _wapi_thread_apc_pending (current_thread)) {
1030                 _wapi_thread_dispatch_apc_queue (current_thread);
1031                 return WAIT_IO_COMPLETION;
1032         }
1033
1034         if(ret==-1) {
1035                 /* Sleep interrupted with rem time remaining */
1036 #ifdef DEBUG
1037                 guint32 rems=rem.tv_sec*1000 + rem.tv_nsec/1000000;
1038
1039                 g_message("%s: Still got %d ms to go", __func__, rems);
1040 #endif
1041                 req=rem;
1042                 goto again;
1043         }
1044
1045         return 0;
1046 }
1047
1048 void Sleep(guint32 ms)
1049 {
1050         SleepEx(ms, FALSE);
1051 }
1052
1053 gboolean _wapi_thread_cur_apc_pending (void)
1054 {
1055         gpointer thread = _wapi_thread_handle_from_id (pthread_self ());
1056
1057         if (thread == NULL) {
1058                 SetLastError (ERROR_INVALID_HANDLE);
1059                 return(FALSE);
1060         }
1061
1062         return(_wapi_thread_apc_pending (thread));
1063 }
1064
1065 gboolean _wapi_thread_apc_pending (gpointer handle)
1066 {
1067         struct _WapiHandle_thread *thread;
1068         gboolean ok;
1069
1070         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
1071                                   (gpointer *)&thread);
1072         if (ok == FALSE) {
1073 #ifdef DEBUG
1074                 /* This might happen at process shutdown, as all
1075                  * thread handles are forcibly closed.  If a thread
1076                  * still has an alertable wait the final
1077                  * _wapi_thread_apc_pending check will probably fail
1078                  * to find the handle
1079                  */
1080                 g_warning ("%s: error looking up thread handle %p", __func__,
1081                            handle);
1082 #endif
1083                 return (FALSE);
1084         }
1085
1086         return(thread->has_apc || thread->wait_handle == INTERRUPTION_REQUESTED_HANDLE);
1087 }
1088
1089 gboolean _wapi_thread_dispatch_apc_queue (gpointer handle)
1090 {
1091         /* We don't support calling APC functions */
1092         struct _WapiHandle_thread *thread;
1093         gboolean ok;
1094
1095         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
1096                                   (gpointer *)&thread);
1097         g_assert (ok);
1098
1099         thread->has_apc = FALSE;
1100
1101         return(TRUE);
1102 }
1103
1104 /*
1105  * In this implementation, APC_CALLBACK is ignored.
1106  * if HANDLE refers to the current thread, the only effect this function has
1107  * that if called from a signal handler, and the thread was waiting when receiving
1108  * the signal, the wait will be broken after the signal handler returns.
1109  * In this case, this function is async-signal-safe.
1110  */
1111 guint32 QueueUserAPC (WapiApcProc apc_callback, gpointer handle,
1112                       gpointer param)
1113 {
1114         struct _WapiHandle_thread *thread_handle;
1115         gboolean ok;
1116
1117         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_THREAD,
1118                                   (gpointer *)&thread_handle);
1119         if (ok == FALSE) {
1120                 g_warning ("%s: error looking up thread handle %p", __func__,
1121                            handle);
1122                 return (0);
1123         }
1124
1125         g_assert (thread_handle->id == GetCurrentThreadId ());
1126         /* No locking/memory barriers are needed here */
1127         thread_handle->has_apc = TRUE;
1128         return(1);
1129 }
1130
1131 /*
1132  * wapi_interrupt_thread:
1133  *
1134  *   This is not part of the WIN32 API.
1135  * The state of the thread handle HANDLE is set to 'interrupted' which means that
1136  * if the thread calls one of the WaitFor functions, the function will return with
1137  * WAIT_IO_COMPLETION instead of waiting. Also, if the thread was waiting when
1138  * this function was called, the wait will be broken.
1139  * It is possible that the wait functions return WAIT_IO_COMPLETION, but the
1140  * target thread didn't receive the interrupt signal yet, in this case it should
1141  * call the wait function again. This essentially means that the target thread will
1142  * busy wait until it is ready to process the interruption.
1143  * FIXME: get rid of QueueUserAPC and thread->has_apc, SleepEx seems to require it.
1144  */
1145 void wapi_interrupt_thread (gpointer thread_handle)
1146 {
1147         struct _WapiHandle_thread *thread;
1148         gboolean ok;
1149         gpointer prev_handle, wait_handle;
1150         guint32 idx;
1151         pthread_cond_t *cond;
1152         mono_mutex_t *mutex;
1153
1154         ok = _wapi_lookup_handle (thread_handle, WAPI_HANDLE_THREAD,
1155                                   (gpointer *)&thread);
1156         g_assert (ok);
1157
1158         while (TRUE) {
1159                 wait_handle = thread->wait_handle;
1160
1161                 /*
1162                  * Atomically obtain the handle the thread is waiting on, and
1163                  * change it to a flag value.
1164                  */
1165                 prev_handle = InterlockedCompareExchangePointer (&thread->wait_handle,
1166                                                                                                                  INTERRUPTION_REQUESTED_HANDLE, wait_handle);
1167                 if (prev_handle == INTERRUPTION_REQUESTED_HANDLE)
1168                         /* Already interrupted */
1169                         return;
1170                 if (prev_handle == wait_handle)
1171                         break;
1172
1173                 /* Try again */
1174         }
1175
1176         WAIT_DEBUG (printf ("%p: state -> INTERRUPTED.\n", thread_handle->id););
1177
1178         if (!wait_handle)
1179                 /* Not waiting */
1180                 return;
1181
1182         /* If we reach here, then wait_handle is set to the flag value,
1183          * which means that the target thread is either
1184          * - before the first CAS in timedwait, which means it won't enter the
1185          * wait.
1186          * - it is after the first CAS, so it is already waiting, or it will
1187          * enter the wait, and it will be interrupted by the broadcast.
1188          */
1189         idx = GPOINTER_TO_UINT(wait_handle);
1190         cond = &_WAPI_PRIVATE_HANDLES(idx).signal_cond;
1191         mutex = &_WAPI_PRIVATE_HANDLES(idx).signal_mutex;
1192
1193         mono_mutex_lock (mutex);
1194         mono_cond_broadcast (cond);
1195         mono_mutex_unlock (mutex);
1196
1197         /* ref added by set_wait_handle */
1198         _wapi_handle_unref (wait_handle);
1199 }
1200
1201 /*
1202  * wapi_clear_interruption:
1203  *
1204  *   This is not part of the WIN32 API.
1205  * Clear the 'interrupted' state of the calling thread.
1206  */
1207 void wapi_clear_interruption (void)
1208 {
1209         struct _WapiHandle_thread *thread;
1210         gboolean ok;
1211         gpointer prev_handle;
1212         gpointer thread_handle;
1213
1214         thread_handle = OpenThread (0, 0, GetCurrentThreadId ());
1215         ok = _wapi_lookup_handle (thread_handle, WAPI_HANDLE_THREAD,
1216                                                           (gpointer *)&thread);
1217         g_assert (ok);
1218
1219         prev_handle = InterlockedCompareExchangePointer (&thread->wait_handle,
1220                                                                                                          NULL, INTERRUPTION_REQUESTED_HANDLE);
1221         if (prev_handle == INTERRUPTION_REQUESTED_HANDLE)
1222                 WAIT_DEBUG (printf ("%p: state -> NORMAL.\n", GetCurrentThreadId ()););
1223
1224         _wapi_handle_unref (thread_handle);
1225 }
1226
1227 char* wapi_current_thread_desc ()
1228 {
1229         struct _WapiHandle_thread *thread;
1230         int i;
1231         gboolean ok;
1232         gpointer handle;
1233         gpointer thread_handle;
1234         GString* text;
1235         char *res;
1236
1237         thread_handle = OpenThread (0, 0, GetCurrentThreadId ());
1238         ok = _wapi_lookup_handle (thread_handle, WAPI_HANDLE_THREAD,
1239                                                           (gpointer *)&thread);
1240         if (!ok)
1241                 return g_strdup_printf ("thread handle %p state : lookup failure", thread_handle);
1242
1243         handle = thread->wait_handle;
1244         text = g_string_new (0);
1245         g_string_append_printf (text, "thread handle %p state : ", thread_handle);
1246
1247         if (!handle)
1248                 g_string_append_printf (text, "not waiting");
1249         else if (handle == INTERRUPTION_REQUESTED_HANDLE)
1250                 g_string_append_printf (text, "interrupted state");
1251         else
1252                 g_string_append_printf (text, "waiting on %p : %s ", handle, _wapi_handle_typename[_wapi_handle_type (handle)]);
1253         g_string_append_printf (text, " owns (");
1254         for (i = 0; i < thread->owned_mutexes->len; i++) {
1255                 gpointer mutex = g_ptr_array_index (thread->owned_mutexes, i);
1256                 if (i > 0)
1257                         g_string_append_printf (text, ", %p", mutex);
1258                 else
1259                         g_string_append_printf (text, "%p", mutex);
1260         }
1261         g_string_append_printf (text, ")");
1262
1263         res = text->str;
1264         g_string_free (text, FALSE);
1265         return res;
1266 }
1267
1268 /**
1269  * wapi_thread_set_wait_handle:
1270  *
1271  *   Set the wait handle for the current thread to HANDLE. Return TRUE on success, FALSE
1272  * if the thread is in interrupted state, and cannot start waiting.
1273  */
1274 gboolean wapi_thread_set_wait_handle (gpointer handle)
1275 {
1276         struct _WapiHandle_thread *thread;
1277         gboolean ok;
1278         gpointer prev_handle;
1279         gpointer thread_handle;
1280
1281         thread_handle = OpenThread (0, 0, GetCurrentThreadId ());
1282         ok = _wapi_lookup_handle (thread_handle, WAPI_HANDLE_THREAD,
1283                                                           (gpointer *)&thread);
1284         g_assert (ok);
1285
1286         prev_handle = InterlockedCompareExchangePointer (&thread->wait_handle,
1287                                                                                                          handle, NULL);
1288         _wapi_handle_unref (thread_handle);
1289
1290         if (prev_handle == NULL) {
1291                 /* thread->wait_handle acts as an additional reference to the handle */
1292                 _wapi_handle_ref (handle);
1293
1294                 WAIT_DEBUG (printf ("%p: state -> WAITING.\n", GetCurrentThreadId ()););
1295         } else {
1296                 g_assert (prev_handle == INTERRUPTION_REQUESTED_HANDLE);
1297                 WAIT_DEBUG (printf ("%p: unable to set state to WAITING.\n", GetCurrentThreadId ()););
1298         }
1299
1300         return prev_handle == NULL;
1301 }
1302
1303 /**
1304  * wapi_thread_clear_wait_handle:
1305  *
1306  *   Clear the wait handle of the current thread.
1307  */
1308 void wapi_thread_clear_wait_handle (gpointer handle)
1309 {
1310         struct _WapiHandle_thread *thread;
1311         gboolean ok;
1312         gpointer prev_handle;
1313         gpointer thread_handle;
1314
1315         thread_handle = OpenThread (0, 0, GetCurrentThreadId ());
1316         ok = _wapi_lookup_handle (thread_handle, WAPI_HANDLE_THREAD,
1317                                                           (gpointer *)&thread);
1318         g_assert (ok);
1319
1320         prev_handle = InterlockedCompareExchangePointer (&thread->wait_handle,
1321                                                                                                          NULL, handle);
1322
1323         if (prev_handle == handle) {
1324                 _wapi_handle_unref (handle);
1325                 WAIT_DEBUG (printf ("%p: state -> NORMAL.\n", GetCurrentThreadId ()););
1326         } else {
1327                 g_assert (prev_handle == INTERRUPTION_REQUESTED_HANDLE);
1328                 WAIT_DEBUG (printf ("%p: finished waiting.\n", GetCurrentThreadId ()););
1329         }
1330
1331         _wapi_handle_unref (thread_handle);
1332 }
1333
1334 void _wapi_thread_own_mutex (gpointer mutex)
1335 {
1336         struct _WapiHandle_thread *thread_handle;
1337         gboolean ok;
1338         gpointer thread;
1339
1340         thread = _wapi_thread_handle_from_id (pthread_self ());
1341         if (thread == NULL) {
1342                 g_warning ("%s: error looking up thread by ID", __func__);
1343                 return;
1344         }
1345
1346         ok = _wapi_lookup_handle (thread, WAPI_HANDLE_THREAD,
1347                                   (gpointer *)&thread_handle);
1348         if (ok == FALSE) {
1349                 g_warning ("%s: error looking up thread handle %p", __func__,
1350                            thread);
1351                 return;
1352         }
1353
1354         _wapi_handle_ref (mutex);
1355
1356         g_ptr_array_add (thread_handle->owned_mutexes, mutex);
1357 }
1358
1359 void _wapi_thread_disown_mutex (gpointer mutex)
1360 {
1361         struct _WapiHandle_thread *thread_handle;
1362         gboolean ok;
1363         gpointer thread;
1364
1365         thread = _wapi_thread_handle_from_id (pthread_self ());
1366         if (thread == NULL) {
1367                 g_warning ("%s: error looking up thread by ID", __func__);
1368                 return;
1369         }
1370
1371         ok = _wapi_lookup_handle (thread, WAPI_HANDLE_THREAD,
1372                                   (gpointer *)&thread_handle);
1373         if (ok == FALSE) {
1374                 g_warning ("%s: error looking up thread handle %p", __func__,
1375                            thread);
1376                 return;
1377         }
1378
1379         _wapi_handle_unref (mutex);
1380
1381         g_ptr_array_remove (thread_handle->owned_mutexes, mutex);
1382 }