glib/gthread-posix.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * gthread.c: posix thread system implementation
   5  * Copyright 1998 Sebastian Wilhelmi; University of Karlsruhe
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /*
  24  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  25  * file for a list of people on the GLib Team.  See the ChangeLog
  26  * files for a list of changes.  These files are distributed with
  27  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  28  */
  29
  30 /* The GMutex, GCond and GPrivate implementations in this file are some
  31  * of the lowest-level code in GLib.  All other parts of GLib (messages,
  32  * memory, slices, etc) assume that they can freely use these facilities
  33  * without risking recursion.
  34  *
  35  * As such, these functions are NOT permitted to call any other part of
  36  * GLib.
  37  *
  38  * The thread manipulation functions (create, exit, join, etc.) have
  39  * more freedom -- they can do as they please.
  40  */
  41
  42 #include "config.h"
  43
  44 #include "gthread.h"
  45
  46 #include "gthreadprivate.h"
  47 #include "gslice.h"
  48 #include "gmessages.h"
  49 #include "gstrfuncs.h"
  50
  51 #include <stdlib.h>
  52 #include <stdio.h>
  53 #include <string.h>
  54 #include <errno.h>
  55 #include <pthread.h>
  56
  57 #ifdef HAVE_SYS_TIME_H
  58 # include <sys/time.h>
  59 #endif
  60 #ifdef HAVE_UNISTD_H
  61 # include <unistd.h>
  62 #endif
  63 #ifdef HAVE_SCHED_H
  64 #include <sched.h>
  65 #endif
  66 #ifdef HAVE_SYS_PRCTL_H
  67 #include <sys/prctl.h>
  68 #endif
  69
  70 static void
  71 g_thread_abort (gint         status,
  72                 const gchar *function)
  73 {
  74   fprintf (stderr, "GLib (gthread-posix.c): Unexpected error from C library during '%s': %s.  Aborting.\n",
  75            strerror (status), function);
  76   abort ();
  77 }
  78
  79 /* {{{1 GMutex */
  80
  81 static pthread_mutex_t *
  82 g_mutex_impl_new (void)
  83 {
  84   pthread_mutexattr_t *pattr = NULL;
  85   pthread_mutex_t *mutex;
  86   gint status;
  87
  88   mutex = malloc (sizeof (pthread_mutex_t));
  89   if G_UNLIKELY (mutex == NULL)
  90     g_thread_abort (errno, "malloc");
  91
  92 #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
  93   pthread_mutexattr_t attr;
  94   pthread_mutexattr_init (&attr);
  95   pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
  96   pattr = &attr;
  97 #endif
  98
  99   if G_UNLIKELY ((status = pthread_mutex_init (mutex, pattr)) != 0)
 100     g_thread_abort (status, "pthread_mutex_init");
 101
 102 #ifdef PTHREAD_ADAPTIVE_MUTEX_NP
 103   pthread_mutexattr_destroy (&attr);
 104 #endif
 105
 106   return mutex;
 107 }
 108
 109 static void
 110 g_mutex_impl_free (pthread_mutex_t *mutex)
 111 {
 112   pthread_mutex_destroy (mutex);
 113   free (mutex);
 114 }
 115
 116 static pthread_mutex_t *
 117 g_mutex_get_impl (GMutex *mutex)
 118 {
 119   pthread_mutex_t *impl = mutex->p;
 120
 121   if G_UNLIKELY (impl == NULL)
 122     {
 123       impl = g_mutex_impl_new ();
 124       if (!g_atomic_pointer_compare_and_exchange (&mutex->p, NULL, impl))
 125         g_mutex_impl_free (impl);
 126       impl = mutex->p;
 127     }
 128
 129   return impl;
 130 }
 131
 132
 133 /**
 134  * g_mutex_init:
 135  * @mutex: an uninitialized #GMutex
 136  *
 137  * Initializes a #GMutex so that it can be used.
 138  *
 139  * This function is useful to initialize a mutex that has been
 140  * allocated on the stack, or as part of a larger structure.
 141  * It is not necessary to initialize a mutex that has been
 142  * created that has been statically allocated.
 143  *
 144  * |[
 145  *   typedef struct {
 146  *     GMutex m;
 147  *     ...
 148  *   } Blob;
 149  *
 150  * Blob *b;
 151  *
 152  * b = g_new (Blob, 1);
 153  * g_mutex_init (&b->m);
 154  * ]|
 155  *
 156  * To undo the effect of g_mutex_init() when a mutex is no longer
 157  * needed, use g_mutex_clear().
 158  *
 159  * Calling g_mutex_init() on an already initialized #GMutex leads
 160  * to undefined behaviour.
 161  *
 162  * Since: 2.32
 163  */
 164 void
 165 g_mutex_init (GMutex *mutex)
 166 {
 167   mutex->p = g_mutex_impl_new ();
 168 }
 169
 170 /**
 171  * g_mutex_clear:
 172  * @mutex: an initialized #GMutex
 173  *
 174  * Frees the resources allocated to a mutex with g_mutex_init().
 175  *
 176  * This function should not be used with a #GMutex that has been
 177  * statically allocated.
 178  *
 179  * Calling g_mutex_clear() on a locked mutex leads to undefined
 180  * behaviour.
 181  *
 182  * Sine: 2.32
 183  */
 184 void
 185 g_mutex_clear (GMutex *mutex)
 186 {
 187   g_mutex_impl_free (mutex->p);
 188 }
 189
 190 /**
 191  * g_mutex_lock:
 192  * @mutex: a #GMutex
 193  *
 194  * Locks @mutex. If @mutex is already locked by another thread, the
 195  * current thread will block until @mutex is unlocked by the other
 196  * thread.
 197  *
 198  * This function can be used even if g_thread_init() has not yet been
 199  * called, and, in that case, will do nothing.
 200  *
 201  * <note>#GMutex is neither guaranteed to be recursive nor to be
 202  * non-recursive.  As such, calling g_mutex_lock() on a #GMutex that has
 203  * already been locked by the same thread results in undefined behaviour
 204  * (including but not limited to deadlocks).</note>
 205  */
 206 void
 207 g_mutex_lock (GMutex *mutex)
 208 {
 209   gint status;
 210
 211   if G_UNLIKELY ((status = pthread_mutex_lock (g_mutex_get_impl (mutex))) != 0)
 212     g_thread_abort (status, "pthread_mutex_lock");
 213 }
 214
 215 /**
 216  * g_mutex_unlock:
 217  * @mutex: a #GMutex
 218  *
 219  * Unlocks @mutex. If another thread is blocked in a g_mutex_lock()
 220  * call for @mutex, it will become unblocked and can lock @mutex itself.
 221  *
 222  * Calling g_mutex_unlock() on a mutex that is not locked by the
 223  * current thread leads to undefined behaviour.
 224  *
 225  * This function can be used even if g_thread_init() has not yet been
 226  * called, and, in that case, will do nothing.
 227  */
 228 void
 229 g_mutex_unlock (GMutex *mutex)
 230 {
 231   gint status;
 232
 233   if G_UNLIKELY ((status = pthread_mutex_unlock (g_mutex_get_impl (mutex))) != 0)
 234     g_thread_abort (status, "pthread_mutex_lock");
 235 }
 236
 237 /**
 238  * g_mutex_trylock:
 239  * @mutex: a #GMutex
 240  *
 241  * Tries to lock @mutex. If @mutex is already locked by another thread,
 242  * it immediately returns %FALSE. Otherwise it locks @mutex and returns
 243  * %TRUE.
 244  *
 245  * This function can be used even if g_thread_init() has not yet been
 246  * called, and, in that case, will immediately return %TRUE.
 247  *
 248  * <note>#GMutex is neither guaranteed to be recursive nor to be
 249  * non-recursive.  As such, calling g_mutex_lock() on a #GMutex that has
 250  * already been locked by the same thread results in undefined behaviour
 251  * (including but not limited to deadlocks or arbitrary return values).
 252  * </note>
 253
 254  * Returns: %TRUE if @mutex could be locked
 255  */
 256 gboolean
 257 g_mutex_trylock (GMutex *mutex)
 258 {
 259   gint status;
 260
 261   if G_LIKELY ((status = pthread_mutex_trylock (g_mutex_get_impl (mutex))) == 0)
 262     return TRUE;
 263
 264   if G_UNLIKELY (status != EBUSY)
 265     g_thread_abort (status, "pthread_mutex_trylock");
 266
 267   return FALSE;
 268 }
 269
 270 /* {{{1 GRecMutex */
 271
 272 static pthread_mutex_t *
 273 g_rec_mutex_impl_new (void)
 274 {
 275   pthread_mutexattr_t attr;
 276   pthread_mutex_t *mutex;
 277
 278   mutex = g_slice_new (pthread_mutex_t);
 279   pthread_mutexattr_init (&attr);
 280   pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
 281   pthread_mutex_init (mutex, &attr);
 282   pthread_mutexattr_destroy (&attr);
 283
 284   return mutex;
 285 }
 286
 287 static void
 288 g_rec_mutex_impl_free (pthread_mutex_t *mutex)
 289 {
 290   pthread_mutex_destroy (mutex);
 291   g_slice_free (pthread_mutex_t, mutex);
 292 }
 293
 294 static pthread_mutex_t *
 295 g_rec_mutex_get_impl (GRecMutex *rec_mutex)
 296 {
 297   pthread_mutex_t *impl = rec_mutex->p;
 298
 299   if G_UNLIKELY (impl == NULL)
 300     {
 301       impl = g_rec_mutex_impl_new ();
 302       if (!g_atomic_pointer_compare_and_exchange (&rec_mutex->p, NULL, impl))
 303         g_rec_mutex_impl_free (impl);
 304       impl = rec_mutex->p;
 305     }
 306
 307   return impl;
 308 }
 309
 310 /**
 311  * g_rec_mutex_init:
 312  * @rec_mutex: an uninitialized #GRecMutex
 313  *
 314  * Initializes a #GRecMutex so that it can be used.
 315  *
 316  * This function is useful to initialize a recursive mutex
 317  * that has been allocated on the stack, or as part of a larger
 318  * structure.
 319  *
 320  * It is not necessary to initialise a recursive mutex that has been
 321  * statically allocated.
 322  *
 323  * |[
 324  *   typedef struct {
 325  *     GRecMutex m;
 326  *     ...
 327  *   } Blob;
 328  *
 329  * Blob *b;
 330  *
 331  * b = g_new (Blob, 1);
 332  * g_rec_mutex_init (&b->m);
 333  * ]|
 334  *
 335  * Calling g_rec_mutex_init() on an already initialized #GRecMutex
 336  * leads to undefined behaviour.
 337  *
 338  * To undo the effect of g_rec_mutex_init() when a recursive mutex
 339  * is no longer needed, use g_rec_mutex_clear().
 340  *
 341  * Since: 2.32
 342  */
 343 void
 344 g_rec_mutex_init (GRecMutex *rec_mutex)
 345 {
 346   rec_mutex->p = g_rec_mutex_impl_new ();
 347 }
 348
 349 /**
 350  * g_rec_mutex_clear:
 351  * @rec_mutex: an initialized #GRecMutex
 352  *
 353  * Frees the resources allocated to a recursive mutex with
 354  * g_rec_mutex_init().
 355  *
 356  * This function should not be used with a #GRecMutex that has been
 357  * statically allocated.
 358  *
 359  * Calling g_rec_mutex_clear() on a locked recursive mutex leads
 360  * to undefined behaviour.
 361  *
 362  * Sine: 2.32
 363  */
 364 void
 365 g_rec_mutex_clear (GRecMutex *rec_mutex)
 366 {
 367   g_rec_mutex_impl_free (rec_mutex->p);
 368 }
 369
 370 /**
 371  * g_rec_mutex_lock:
 372  * @rec_mutex: a #GRecMutex
 373  *
 374  * Locks @rec_mutex. If @rec_mutex is already locked by another
 375  * thread, the current thread will block until @rec_mutex is
 376  * unlocked by the other thread. If @rec_mutex is already locked
 377  * by the current thread, the 'lock count' of @rec_mutex is increased.
 378  * The mutex will only become available again when it is unlocked
 379  * as many times as it has been locked.
 380  *
 381  * Since: 2.32
 382  */
 383 void
 384 g_rec_mutex_lock (GRecMutex *mutex)
 385 {
 386   pthread_mutex_lock (g_rec_mutex_get_impl (mutex));
 387 }
 388
 389 /**
 390  * g_rec_mutex_unlock:
 391  * @rec_mutex: a #RecGMutex
 392  *
 393  * Unlocks @rec_mutex. If another thread is blocked in a
 394  * g_rec_mutex_lock() call for @rec_mutex, it will become unblocked
 395  * and can lock @rec_mutex itself.
 396  *
 397  * Calling g_rec_mutex_unlock() on a recursive mutex that is not
 398  * locked by the current thread leads to undefined behaviour.
 399  *
 400  * Since: 2.32
 401  */
 402 void
 403 g_rec_mutex_unlock (GRecMutex *rec_mutex)
 404 {
 405   pthread_mutex_unlock (rec_mutex->p);
 406 }
 407
 408 /**
 409  * g_rec_mutex_trylock:
 410  * @rec_mutex: a #GRecMutex
 411  *
 412  * Tries to lock @rec_mutex. If @rec_mutex is already locked
 413  * by another thread, it immediately returns %FALSE. Otherwise
 414  * it locks @rec_mutex and returns %TRUE.
 415  *
 416  * Returns: %TRUE if @rec_mutex could be locked
 417  *
 418  * Since: 2.32
 419  */
 420 gboolean
 421 g_rec_mutex_trylock (GRecMutex *rec_mutex)
 422 {
 423   if (pthread_mutex_trylock (g_rec_mutex_get_impl (rec_mutex)) != 0)
 424     return FALSE;
 425
 426   return TRUE;
 427 }
 428
 429 /* {{{1 GRWLock */
 430
 431 static pthread_rwlock_t *
 432 g_rw_lock_impl_new (void)
 433 {
 434   pthread_rwlock_t *rwlock;
 435   gint status;
 436
 437   rwlock = malloc (sizeof (pthread_rwlock_t));
 438   if G_UNLIKELY (rwlock == NULL)
 439     g_thread_abort (errno, "malloc");
 440
 441   if G_UNLIKELY ((status = pthread_rwlock_init (rwlock, NULL)) != 0)
 442     g_thread_abort (status, "pthread_rwlock_init");
 443
 444   return rwlock;
 445 }
 446
 447 static void
 448 g_rw_lock_impl_free (pthread_rwlock_t *rwlock)
 449 {
 450   pthread_rwlock_destroy (rwlock);
 451   free (rwlock);
 452 }
 453
 454 static pthread_rwlock_t *
 455 g_rw_lock_get_impl (GRWLock *lock)
 456 {
 457   pthread_rwlock_t *impl = lock->p;
 458
 459   if G_UNLIKELY (impl == NULL)
 460     {
 461       impl = g_rw_lock_impl_new ();
 462       if (!g_atomic_pointer_compare_and_exchange (&lock->p, NULL, impl))
 463         g_rw_lock_impl_free (impl);
 464       impl = lock->p;
 465     }
 466
 467   return impl;
 468 }
 469
 470 /**
 471  * g_rw_lock_init:
 472  * @rw_lock: an uninitialized #GRWLock
 473  *
 474  * Initializes a #GRWLock so that it can be used.
 475  *
 476  * This function is useful to initialize a lock that has been
 477  * allocated on the stack, or as part of a larger structure.  It is not
 478  * necessary to initialise a reader-writer lock that has been statically
 479  * allocated.
 480  *
 481  * |[
 482  *   typedef struct {
 483  *     GRWLock l;
 484  *     ...
 485  *   } Blob;
 486  *
 487  * Blob *b;
 488  *
 489  * b = g_new (Blob, 1);
 490  * g_rw_lock_init (&b->l);
 491  * ]|
 492  *
 493  * To undo the effect of g_rw_lock_init() when a lock is no longer
 494  * needed, use g_rw_lock_clear().
 495  *
 496  * Calling g_rw_lock_init() on an already initialized #GRWLock leads
 497  * to undefined behaviour.
 498  *
 499  * Since: 2.32
 500  */
 501 void
 502 g_rw_lock_init (GRWLock *rw_lock)
 503 {
 504   rw_lock->p = g_rw_lock_impl_new ();
 505 }
 506
 507 /**
 508  * g_rw_lock_clear:
 509  * @rw_lock: an initialized #GRWLock
 510  *
 511  * Frees the resources allocated to a lock with g_rw_lock_init().
 512  *
 513  * This function should not be used with a #GRWLock that has been
 514  * statically allocated.
 515  *
 516  * Calling g_rw_lock_clear() when any thread holds the lock
 517  * leads to undefined behaviour.
 518  *
 519  * Sine: 2.32
 520  */
 521 void
 522 g_rw_lock_clear (GRWLock *rw_lock)
 523 {
 524   g_rw_lock_impl_free (rw_lock->p);
 525 }
 526
 527 /**
 528  * g_rw_lock_writer_lock:
 529  * @rw_lock: a #GRWLock
 530  *
 531  * Obtain a write lock on @rw_lock. If any thread already holds
 532  * a read or write lock on @rw_lock, the current thread will block
 533  * until all other threads have dropped their locks on @rw_lock.
 534  *
 535  * Since: 2.32
 536  */
 537 void
 538 g_rw_lock_writer_lock (GRWLock *rw_lock)
 539 {
 540   pthread_rwlock_wrlock (g_rw_lock_get_impl (rw_lock));
 541 }
 542
 543 /**
 544  * g_rw_lock_writer_trylock:
 545  * @rw_lock: a #GRWLock
 546  *
 547  * Tries to obtain a write lock on @rw_lock. If any other thread holds
 548  * a read or write lock on @rw_lock, it immediately returns %FALSE.
 549  * Otherwise it locks @rw_lock and returns %TRUE.
 550  *
 551  * Returns: %TRUE if @rw_lock could be locked
 552  *
 553  * Since: 2.32
 554  */
 555 gboolean
 556 g_rw_lock_writer_trylock (GRWLock *rw_lock)
 557 {
 558   if (pthread_rwlock_trywrlock (g_rw_lock_get_impl (rw_lock)) != 0)
 559     return FALSE;
 560
 561   return TRUE;
 562 }
 563
 564 /**
 565  * g_rw_lock_writer_unlock:
 566  * @rw_lock: a #GRWLock
 567  *
 568  * Release a write lock on @rw_lock.
 569  *
 570  * Calling g_rw_lock_writer_unlock() on a lock that is not held
 571  * by the current thread leads to undefined behaviour.
 572  *
 573  * Since: 2.32
 574  */
 575 void
 576 g_rw_lock_writer_unlock (GRWLock *rw_lock)
 577 {
 578   pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock));
 579 }
 580
 581 /**
 582  * g_rw_lock_reader_lock:
 583  * @rw_lock: a #GRWLock
 584  *
 585  * Obtain a read lock on @rw_lock. If another thread currently holds
 586  * the write lock on @rw_lock or blocks waiting for it, the current
 587  * thread will block. Read locks can be taken recursively.
 588  *
 589  * It is implementation-defined how many threads are allowed to
 590  * hold read locks on the same lock simultaneously.
 591  *
 592  * Since: 2.32
 593  */
 594 void
 595 g_rw_lock_reader_lock (GRWLock *rw_lock)
 596 {
 597   pthread_rwlock_rdlock (g_rw_lock_get_impl (rw_lock));
 598 }
 599
 600 /**
 601  * g_rw_lock_reader_trylock:
 602  * @rw_lock: a #GRWLock
 603  *
 604  * Tries to obtain a read lock on @rw_lock and returns %TRUE if
 605  * the read lock was successfully obtained. Otherwise it
 606  * returns %FALSE.
 607  *
 608  * Returns: %TRUE if @rw_lock could be locked
 609  *
 610  * Since: 2.32
 611  */
 612 gboolean
 613 g_rw_lock_reader_trylock (GRWLock *rw_lock)
 614 {
 615   if (pthread_rwlock_tryrdlock (g_rw_lock_get_impl (rw_lock)) != 0)
 616     return FALSE;
 617
 618   return TRUE;
 619 }
 620
 621 /**
 622  * g_rw_lock_reader_unlock:
 623  * @rw_lock: a #GRWLock
 624  *
 625  * Release a read lock on @rw_lock.
 626  *
 627  * Calling g_rw_lock_reader_unlock() on a lock that is not held
 628  * by the current thread leads to undefined behaviour.
 629  *
 630  * Since: 2.32
 631  */
 632 void
 633 g_rw_lock_reader_unlock (GRWLock *rw_lock)
 634 {
 635   pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock));
 636 }
 637
 638 /* {{{1 GCond */
 639
 640 static pthread_cond_t *
 641 g_cond_impl_new (void)
 642 {
 643   pthread_cond_t *cond;
 644   gint status;
 645
 646   cond = malloc (sizeof (pthread_cond_t));
 647   if G_UNLIKELY (cond == NULL)
 648     g_thread_abort (errno, "malloc");
 649
 650   if G_UNLIKELY ((status = pthread_cond_init (cond, NULL)) != 0)
 651     g_thread_abort (status, "pthread_cond_init");
 652
 653   return cond;
 654 }
 655
 656 static void
 657 g_cond_impl_free (pthread_cond_t *cond)
 658 {
 659   pthread_cond_destroy (cond);
 660   free (cond);
 661 }
 662
 663 static pthread_cond_t *
 664 g_cond_get_impl (GCond *cond)
 665 {
 666   pthread_cond_t *impl = cond->p;
 667
 668   if G_UNLIKELY (impl == NULL)
 669     {
 670       impl = g_cond_impl_new ();
 671       if (!g_atomic_pointer_compare_and_exchange (&cond->p, NULL, impl))
 672         g_cond_impl_free (impl);
 673       impl = cond->p;
 674     }
 675
 676   return impl;
 677 }
 678
 679 /**
 680  * g_cond_init:
 681  * @cond: an uninitialized #GCond
 682  *
 683  * Initialized a #GCond so that it can be used.
 684  *
 685  * This function is useful to initialize a #GCond that has been
 686  * allocated on the stack, or as part of a larger structure.
 687  * It is not necessary to initialize a #GCond that has been
 688  * statically allocated.
 689  *
 690  * To undo the effect of g_cond_init() when a #GCond is no longer
 691  * needed, use g_cond_clear().
 692  *
 693  * Calling g_cond_init() on an already initialized #GCond leads
 694  * to undefined behaviour.
 695  *
 696  * Since: 2.32
 697  */
 698 void
 699 g_cond_init (GCond *cond)
 700 {
 701   cond->p = g_cond_impl_new ();
 702 }
 703
 704 /**
 705  * g_cond_clear:
 706  * @cond: an initialized #GCond
 707  *
 708  * Frees the resources allocated to a #GCond with g_cond_init().
 709  *
 710  * This function should not be used with a #GCond that has been
 711  * statically allocated.
 712  *
 713  * Calling g_cond_clear() for a #GCond on which threads are
 714  * blocking leads to undefined behaviour.
 715  *
 716  * Since: 2.32
 717  */
 718 void
 719 g_cond_clear (GCond *cond)
 720 {
 721   g_cond_impl_free (cond->p);
 722 }
 723
 724 /**
 725  * g_cond_wait:
 726  * @cond: a #GCond
 727  * @mutex: a #GMutex that is currently locked
 728  *
 729  * Waits until this thread is woken up on @cond. The @mutex is unlocked
 730  * before falling asleep and locked again before resuming.
 731  *
 732  * This function can be used even if g_thread_init() has not yet been
 733  * called, and, in that case, will immediately return.
 734  */
 735 void
 736 g_cond_wait (GCond  *cond,
 737              GMutex *mutex)
 738 {
 739   gint status;
 740
 741   if G_UNLIKELY ((status = pthread_cond_wait (g_cond_get_impl (cond), g_mutex_get_impl (mutex))) != 0)
 742     g_thread_abort (status, "pthread_cond_wait");
 743 }
 744
 745 /**
 746  * g_cond_signal:
 747  * @cond: a #GCond
 748  *
 749  * If threads are waiting for @cond, at least one of them is unblocked.
 750  * If no threads are waiting for @cond, this function has no effect.
 751  * It is good practice to hold the same lock as the waiting thread
 752  * while calling this function, though not required.
 753  *
 754  * This function can be used even if g_thread_init() has not yet been
 755  * called, and, in that case, will do nothing.
 756  */
 757 void
 758 g_cond_signal (GCond *cond)
 759 {
 760   gint status;
 761
 762   if G_UNLIKELY ((status = pthread_cond_signal (g_cond_get_impl (cond))) != 0)
 763     g_thread_abort (status, "pthread_cond_signal");
 764 }
 765
 766 /**
 767  * g_cond_broadcast:
 768  * @cond: a #GCond
 769  *
 770  * If threads are waiting for @cond, all of them are unblocked.
 771  * If no threads are waiting for @cond, this function has no effect.
 772  * It is good practice to lock the same mutex as the waiting threads
 773  * while calling this function, though not required.
 774  *
 775  * This function can be used even if g_thread_init() has not yet been
 776  * called, and, in that case, will do nothing.
 777  */
 778 void
 779 g_cond_broadcast (GCond *cond)
 780 {
 781   gint status;
 782
 783   if G_UNLIKELY ((status = pthread_cond_broadcast (g_cond_get_impl (cond))) != 0)
 784     g_thread_abort (status, "pthread_cond_broadcast");
 785 }
 786
 787 /**
 788  * g_cond_timed_wait:
 789  * @cond: a #GCond
 790  * @mutex: a #GMutex that is currently locked
 791  * @abs_time: a #GTimeVal, determining the final time
 792  *
 793  * Waits until this thread is woken up on @cond, but not longer than
 794  * until the time specified by @abs_time. The @mutex is unlocked before
 795  * falling asleep and locked again before resuming.
 796  *
 797  * If @abs_time is %NULL, g_cond_timed_wait() acts like g_cond_wait().
 798  *
 799  * This function can be used even if g_thread_init() has not yet been
 800  * called, and, in that case, will immediately return %TRUE.
 801  *
 802  * To easily calculate @abs_time a combination of g_get_current_time()
 803  * and g_time_val_add() can be used.
 804  *
 805  * Returns: %TRUE if @cond was signalled, or %FALSE on timeout
 806  */
 807 gboolean
 808 g_cond_timed_wait (GCond    *cond,
 809                    GMutex   *mutex,
 810                    GTimeVal *abs_time)
 811 {
 812   struct timespec end_time;
 813   gint status;
 814
 815   if (abs_time == NULL)
 816     {
 817       g_cond_wait (cond, mutex);
 818       return TRUE;
 819     }
 820
 821   end_time.tv_sec = abs_time->tv_sec;
 822   end_time.tv_nsec = abs_time->tv_usec * 1000;
 823
 824   if ((status = pthread_cond_timedwait (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &end_time)) == 0)
 825     return TRUE;
 826
 827   if G_UNLIKELY (status != ETIMEDOUT)
 828     g_thread_abort (status, "pthread_cond_timedwait");
 829
 830   return FALSE;
 831 }
 832
 833 /**
 834  * g_cond_timedwait:
 835  * @cond: a #GCond
 836  * @mutex: a #GMutex that is currently locked
 837  * @abs_time: the final time, in microseconds
 838  *
 839  * A variant of g_cond_timed_wait() that takes @abs_time
 840  * as a #gint64 instead of a #GTimeVal.
 841  * See g_cond_timed_wait() for details.
 842  *
 843  * Returns: %TRUE if @cond was signalled, or %FALSE on timeout
 844  *
 845  * Since: 2.32
 846  */
 847 gboolean
 848 g_cond_timedwait (GCond  *cond,
 849                   GMutex *mutex,
 850                   gint64  abs_time)
 851 {
 852   struct timespec end_time;
 853   gint status;
 854
 855   end_time.tv_sec = abs_time / 1000000;
 856   end_time.tv_nsec = (abs_time % 1000000) * 1000;
 857
 858   if ((status = pthread_cond_timedwait (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &end_time)) == 0)
 859     return TRUE;
 860
 861   if G_UNLIKELY (status != ETIMEDOUT)
 862     g_thread_abort (status, "pthread_cond_timedwait");
 863
 864   return FALSE;
 865 }
 866
 867 /* {{{1 GPrivate */
 868
 869 /**
 870  * GPrivate:
 871  *
 872  * The #GPrivate struct is an opaque data structure to represent a
 873  * thread-local data key. It is approximately equivalent to the
 874  * pthread_setspecific()/pthread_getspecific() APIs on POSIX and to
 875  * TlsSetValue()/TlsGetValue() on Windows.
 876  *
 877  * If you don't already know why you might want this functionality,
 878  * then you probably don't need it.
 879  *
 880  * #GPrivate is a very limited resource (as far as 128 per program,
 881  * shared between all libraries). It is also not possible to destroy a
 882  * #GPrivate after it has been used. As such, it is only ever acceptable
 883  * to use #GPrivate in static scope, and even then sparingly so.
 884  *
 885  * See G_PRIVATE_INIT() for a couple of examples.
 886  *
 887  * The #GPrivate structure should be considered opaque.  It should only
 888  * be accessed via the <function>g_private_</function> functions.
 889  */
 890
 891 /**
 892  * G_PRIVATE_INIT:
 893  * @notify: a #GDestroyNotify
 894  *
 895  * A macro to assist with the static initialisation of a #GPrivate.
 896  *
 897  * This macro is useful for the case that a #GDestroyNotify function
 898  * should be associated the key.  This is needed when the key will be
 899  * used to point at memory that should be deallocated when the thread
 900  * exits.
 901  *
 902  * Additionally, the #GDestroyNotify will also be called on the previous
 903  * value stored in the key when g_private_replace() is used.
 904  *
 905  * If no #GDestroyNotify is needed, then use of this macro is not
 906  * required -- if the #GPrivate is declared in static scope then it will
 907  * be properly initialised by default (ie: to all zeros).  See the
 908  * examples below.
 909  *
 910  * |[
 911  * static GPrivate name_key = G_PRIVATE_INIT (g_free);
 912  *
 913  * // return value should not be freed
 914  * const gchar *
 915  * get_local_name (void)
 916  * {
 917  *   return g_private_get (&name_key);
 918  * }
 919  *
 920  * void
 921  * set_local_name (const gchar *name)
 922  * {
 923  *   g_private_replace (&name_key, g_strdup (name));
 924  * }
 925  *
 926  *
 927  * static GPrivate count_key;   // no free function
 928  *
 929  * gint
 930  * get_local_count (void)
 931  * {
 932  *   return GPOINTER_TO_INT (g_private_get (&count_key));
 933  * }
 934  *
 935  * void
 936  * set_local_count (gint count)
 937  * {
 938  *   g_private_set (&count_key, GINT_TO_POINTER (count));
 939  * }
 940  * ]|
 941  *
 942  * Since: 2.32
 943  **/
 944
 945 static pthread_key_t *
 946 g_private_impl_new (GDestroyNotify notify)
 947 {
 948   pthread_key_t *key;
 949   gint status;
 950
 951   key = malloc (sizeof (pthread_key_t));
 952   if G_UNLIKELY (key == NULL)
 953     g_thread_abort (errno, "malloc");
 954   status = pthread_key_create (key, notify);
 955   if G_UNLIKELY (status != 0)
 956     g_thread_abort (status, "pthread_key_create");
 957
 958   return key;
 959 }
 960
 961 static void
 962 g_private_impl_free (pthread_key_t *key)
 963 {
 964   gint status;
 965
 966   status = pthread_key_delete (*key);
 967   if G_UNLIKELY (status != 0)
 968     g_thread_abort (status, "pthread_key_delete");
 969   free (key);
 970 }
 971
 972 static pthread_key_t *
 973 g_private_get_impl (GPrivate *key)
 974 {
 975   pthread_key_t *impl = key->p;
 976
 977   if G_UNLIKELY (impl == NULL)
 978     {
 979       impl = g_private_impl_new (key->notify);
 980       if (!g_atomic_pointer_compare_and_exchange (&key->p, NULL, impl))
 981         {
 982           g_private_impl_free (impl);
 983           impl = key->p;
 984         }
 985     }
 986
 987   return impl;
 988 }
 989
 990 /**
 991  * g_private_get:
 992  * @key: a #GPrivate
 993  *
 994  * Returns the current value of the thread local variable @key.
 995  *
 996  * If the value has not yet been set in this thread, %NULL is returned.
 997  * Values are never copied between threads (when a new thread is
 998  * created, for example).
 999  *
1000  * Returns: the thread-local value
1001  */
1002 gpointer
1003 g_private_get (GPrivate *key)
1004 {
1005   /* quote POSIX: No errors are returned from pthread_getspecific(). */
1006   return pthread_getspecific (*g_private_get_impl (key));
1007 }
1008
1009 /**
1010  * g_private_set:
1011  * @key: a #GPrivate
1012  * @value: the new value
1013  *
1014  * Sets the thread local variable @key to have the value @value in the
1015  * current thread.
1016  *
1017  * This function differs from g_private_replace() in the following way:
1018  * the #GDestroyNotify for @key is not called on the old value.
1019  */
1020 void
1021 g_private_set (GPrivate *key,
1022                gpointer  value)
1023 {
1024   gint status;
1025
1026   if G_UNLIKELY ((status = pthread_setspecific (*g_private_get_impl (key), value)) != 0)
1027     g_thread_abort (status, "pthread_setspecific");
1028 }
1029
1030 /**
1031  * g_private_replace:
1032  * @key: a #GPrivate
1033  * @value: the new value
1034  *
1035  * Sets the thread local variable @key to have the value @value in the
1036  * current thread.
1037  *
1038  * This function differs from g_private_set() in the following way: if
1039  * the previous value was non-%NULL then the #GDestroyNotify handler for
1040  * @key is run on it.
1041  *
1042  * Since: 2.32
1043  **/
1044 void
1045 g_private_replace (GPrivate *key,
1046                    gpointer  value)
1047 {
1048   pthread_key_t *impl = g_private_get_impl (key);
1049   gpointer old;
1050   gint status;
1051
1052   old = pthread_getspecific (*impl);
1053   if (old && key->notify)
1054     key->notify (old);
1055
1056   if G_UNLIKELY ((status = pthread_setspecific (*impl, value)) != 0)
1057     g_thread_abort (status, "pthread_setspecific");
1058 }
1059
1060 /* {{{1 GThread */
1061
1062 #define posix_check_err(err, name) G_STMT_START{                        \
1063   int error = (err);                                                    \
1064   if (error)                                                            \
1065     g_error ("file %s: line %d (%s): error '%s' during '%s'",           \
1066            __FILE__, __LINE__, G_STRFUNC,                               \
1067            g_strerror (error), name);                                   \
1068   }G_STMT_END
1069
1070 #define posix_check_cmd(cmd) posix_check_err (cmd, #cmd)
1071
1072 void
1073 g_system_thread_free (GRealThread *thread)
1074 {
1075   g_slice_free (GRealThread, thread);
1076 }
1077
1078 GRealThread *
1079 g_system_thread_new (GThreadFunc   thread_func,
1080                      gulong        stack_size,
1081                      gboolean      joinable,
1082                      GError      **error)
1083 {
1084   GRealThread *thread;
1085   pthread_attr_t attr;
1086   gint ret;
1087
1088   thread = g_slice_new0 (GRealThread);
1089
1090   posix_check_cmd (pthread_attr_init (&attr));
1091
1092 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1093   if (stack_size)
1094     {
1095 #ifdef _SC_THREAD_STACK_MIN
1096       stack_size = MAX (sysconf (_SC_THREAD_STACK_MIN), stack_size);
1097 #endif /* _SC_THREAD_STACK_MIN */
1098       /* No error check here, because some systems can't do it and
1099        * we simply don't want threads to fail because of that. */
1100       pthread_attr_setstacksize (&attr, stack_size);
1101     }
1102 #endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */
1103
1104   posix_check_cmd (pthread_attr_setdetachstate (&attr,
1105           joinable ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED));
1106
1107   ret = pthread_create ((pthread_t *) &(thread->system_thread), &attr, (void* (*)(void*))thread_func, thread);
1108
1109   posix_check_cmd (pthread_attr_destroy (&attr));
1110
1111   if (ret == EAGAIN)
1112     {
1113       g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
1114                    "Error creating thread: %s", g_strerror (ret));
1115       g_slice_free (GRealThread, thread);
1116       return NULL;
1117     }
1118
1119   posix_check_err (ret, "pthread_create");
1120
1121   return thread;
1122 }
1123
1124 /**
1125  * g_thread_yield:
1126  *
1127  * Causes the calling thread to voluntarily relinquish the CPU, so
1128  * that other threads can run.
1129  *
1130  * This function is often used as a method to make busy wait less evil.
1131  */
1132 void
1133 g_thread_yield (void)
1134 {
1135   sched_yield ();
1136 }
1137
1138 void
1139 g_system_thread_wait (GRealThread *thread)
1140 {
1141   gpointer ignore;
1142   posix_check_cmd (pthread_join (*(pthread_t*)&(thread->system_thread), &ignore));
1143 }
1144
1145 void
1146 g_system_thread_exit (void)
1147 {
1148   pthread_exit (NULL);
1149 }
1150
1151 void
1152 g_system_thread_set_name (const gchar *name)
1153 {
1154 #ifdef HAVE_SYS_PRCTL_H
1155   prctl (PR_SET_NAME, name, 0, 0, 0, 0);
1156 #endif
1157 }
1158
1159 /* {{{1 Epilogue */
1160 /* vim:set foldmethod=marker: */