gthread-posix.c 36.3 KB
Newer Older
1 2 3 4 5 6 7
/* GLIB - Library of useful routines for C programming
 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * gthread.c: posix thread system implementation
 * Copyright 1998 Sebastian Wilhelmi; University of Karlsruhe
 *
 * 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.1 of the License, or (at your option) any later version.
11 12 13 14
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * 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, see <http://www.gnu.org/licenses/>.
19 20
 */

21
/*
22
 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
23 24
 * file for a list of people on the GLib Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
25
 * GLib at ftp://ftp.gtk.org/pub/gtk/.
26 27
 */

Allison Karlitskaya's avatar
Allison Karlitskaya committed
28 29
/* The GMutex, GCond and GPrivate implementations in this file are some
 * of the lowest-level code in GLib.  All other parts of GLib (messages,
30 31 32 33 34 35 36 37
 * memory, slices, etc) assume that they can freely use these facilities
 * without risking recursion.
 *
 * As such, these functions are NOT permitted to call any other part of
 * GLib.
 *
 * The thread manipulation functions (create, exit, join, etc.) have
 * more freedom -- they can do as they please.
38 39
 */

40
#include "config.h"
41

42
#include "gthread.h"
43

Allison Karlitskaya's avatar
Allison Karlitskaya committed
44
#include "gthreadprivate.h"
45
#include "gslice.h"
46 47
#include "gmessages.h"
#include "gstrfuncs.h"
48
#include "gmain.h"
49
#include "gutils.h"
50 51

#include <stdlib.h>
52
#include <stdio.h>
53 54
#include <string.h>
#include <errno.h>
55 56
#include <pthread.h>

57 58 59
#include <sys/time.h>
#include <unistd.h>

60 61 62
#ifdef HAVE_PTHREAD_SET_NAME_NP
#include <pthread_np.h>
#endif
63 64 65
#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
66 67 68
#ifdef G_OS_WIN32
#include <windows.h>
#endif
69

70 71 72 73 74
/* clang defines __ATOMIC_SEQ_CST but doesn't support the GCC extension */
#if defined(HAVE_FUTEX) && defined(__ATOMIC_SEQ_CST) && !defined(__clang__)
#define USE_NATIVE_MUTEX
#endif

75 76 77 78 79
static void
g_thread_abort (gint         status,
                const gchar *function)
{
  fprintf (stderr, "GLib (gthread-posix.c): Unexpected error from C library during '%s': %s.  Aborting.\n",
80
           function, strerror (status));
81
  g_abort ();
82 83 84
}

/* {{{1 GMutex */
Matthias Clasen's avatar
Matthias Clasen committed
85

86 87
#if !defined(USE_NATIVE_MUTEX)

88 89 90 91 92 93
static pthread_mutex_t *
g_mutex_impl_new (void)
{
  pthread_mutexattr_t *pattr = NULL;
  pthread_mutex_t *mutex;
  gint status;
94 95 96
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
  pthread_mutexattr_t attr;
#endif
97 98 99 100 101 102

  mutex = malloc (sizeof (pthread_mutex_t));
  if G_UNLIKELY (mutex == NULL)
    g_thread_abort (errno, "malloc");

#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
103 104 105
  pthread_mutexattr_init (&attr);
  pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
  pattr = &attr;
106 107 108 109 110
#endif

  if G_UNLIKELY ((status = pthread_mutex_init (mutex, pattr)) != 0)
    g_thread_abort (status, "pthread_mutex_init");

111
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
112 113 114 115 116 117 118 119 120 121 122 123 124
  pthread_mutexattr_destroy (&attr);
#endif

  return mutex;
}

static void
g_mutex_impl_free (pthread_mutex_t *mutex)
{
  pthread_mutex_destroy (mutex);
  free (mutex);
}

125
static inline pthread_mutex_t *
126 127
g_mutex_get_impl (GMutex *mutex)
{
128
  pthread_mutex_t *impl = g_atomic_pointer_get (&mutex->p);
129 130 131 132

  if G_UNLIKELY (impl == NULL)
    {
      impl = g_mutex_impl_new ();
133
      if (!g_atomic_pointer_compare_and_exchange (&mutex->p, NULL, impl))
134
        g_mutex_impl_free (impl);
135
      impl = mutex->p;
136 137 138 139 140 141
    }

  return impl;
}


Matthias Clasen's avatar
Matthias Clasen committed
142 143 144 145 146 147 148 149 150
/**
 * g_mutex_init:
 * @mutex: an uninitialized #GMutex
 *
 * Initializes a #GMutex so that it can be used.
 *
 * This function is useful to initialize a mutex that has been
 * allocated on the stack, or as part of a larger structure.
 * It is not necessary to initialize a mutex that has been
151
 * statically allocated.
Matthias Clasen's avatar
Matthias Clasen committed
152
 *
153
 * |[<!-- language="C" --> 
Matthias Clasen's avatar
Matthias Clasen committed
154 155
 *   typedef struct {
 *     GMutex m;
Matthias Clasen's avatar
Matthias Clasen committed
156
 *     ...
Matthias Clasen's avatar
Matthias Clasen committed
157 158 159 160 161 162 163 164 165 166 167
 *   } Blob;
 *
 * Blob *b;
 *
 * b = g_new (Blob, 1);
 * g_mutex_init (&b->m);
 * ]|
 *
 * To undo the effect of g_mutex_init() when a mutex is no longer
 * needed, use g_mutex_clear().
 *
Matthias Clasen's avatar
Matthias Clasen committed
168 169 170
 * Calling g_mutex_init() on an already initialized #GMutex leads
 * to undefined behaviour.
 *
Matthias Clasen's avatar
Matthias Clasen committed
171 172
 * Since: 2.32
 */
173 174 175
void
g_mutex_init (GMutex *mutex)
{
176
  mutex->p = g_mutex_impl_new ();
177 178
}

Matthias Clasen's avatar
Matthias Clasen committed
179 180 181 182 183 184
/**
 * g_mutex_clear:
 * @mutex: an initialized #GMutex
 *
 * Frees the resources allocated to a mutex with g_mutex_init().
 *
185 186
 * This function should not be used with a #GMutex that has been
 * statically allocated.
Matthias Clasen's avatar
Matthias Clasen committed
187
 *
Matthias Clasen's avatar
Matthias Clasen committed
188 189 190
 * Calling g_mutex_clear() on a locked mutex leads to undefined
 * behaviour.
 *
191
 * Sine: 2.32
Matthias Clasen's avatar
Matthias Clasen committed
192
 */
193 194 195
void
g_mutex_clear (GMutex *mutex)
{
196
  g_mutex_impl_free (mutex->p);
197 198
}

Matthias Clasen's avatar
Matthias Clasen committed
199 200 201 202 203 204 205 206
/**
 * g_mutex_lock:
 * @mutex: a #GMutex
 *
 * Locks @mutex. If @mutex is already locked by another thread, the
 * current thread will block until @mutex is unlocked by the other
 * thread.
 *
207
 * #GMutex is neither guaranteed to be recursive nor to be
208 209
 * non-recursive.  As such, calling g_mutex_lock() on a #GMutex that has
 * already been locked by the same thread results in undefined behaviour
210
 * (including but not limited to deadlocks).
Matthias Clasen's avatar
Matthias Clasen committed
211
 */
212 213 214 215 216
void
g_mutex_lock (GMutex *mutex)
{
  gint status;

217
  if G_UNLIKELY ((status = pthread_mutex_lock (g_mutex_get_impl (mutex))) != 0)
218 219 220
    g_thread_abort (status, "pthread_mutex_lock");
}

Matthias Clasen's avatar
Matthias Clasen committed
221 222 223 224 225
/**
 * g_mutex_unlock:
 * @mutex: a #GMutex
 *
 * Unlocks @mutex. If another thread is blocked in a g_mutex_lock()
Matthias Clasen's avatar
Matthias Clasen committed
226 227 228 229
 * call for @mutex, it will become unblocked and can lock @mutex itself.
 *
 * Calling g_mutex_unlock() on a mutex that is not locked by the
 * current thread leads to undefined behaviour.
Matthias Clasen's avatar
Matthias Clasen committed
230
 */
231 232 233 234 235
void
g_mutex_unlock (GMutex *mutex)
{
  gint status;

236
  if G_UNLIKELY ((status = pthread_mutex_unlock (g_mutex_get_impl (mutex))) != 0)
237
    g_thread_abort (status, "pthread_mutex_unlock");
238 239
}

Matthias Clasen's avatar
Matthias Clasen committed
240 241 242 243 244 245 246 247
/**
 * g_mutex_trylock:
 * @mutex: a #GMutex
 *
 * Tries to lock @mutex. If @mutex is already locked by another thread,
 * it immediately returns %FALSE. Otherwise it locks @mutex and returns
 * %TRUE.
 *
248
 * #GMutex is neither guaranteed to be recursive nor to be
249 250 251
 * non-recursive.  As such, calling g_mutex_lock() on a #GMutex that has
 * already been locked by the same thread results in undefined behaviour
 * (including but not limited to deadlocks or arbitrary return values).
252
 *
Matthias Clasen's avatar
Matthias Clasen committed
253
 * Returns: %TRUE if @mutex could be locked
Matthias Clasen's avatar
Matthias Clasen committed
254
 */
255 256 257 258 259
gboolean
g_mutex_trylock (GMutex *mutex)
{
  gint status;

260
  if G_LIKELY ((status = pthread_mutex_trylock (g_mutex_get_impl (mutex))) == 0)
261 262 263 264 265 266 267 268
    return TRUE;

  if G_UNLIKELY (status != EBUSY)
    g_thread_abort (status, "pthread_mutex_trylock");

  return FALSE;
}

269 270
#endif /* !defined(USE_NATIVE_MUTEX) */

271 272 273 274 275 276 277 278
/* {{{1 GRecMutex */

static pthread_mutex_t *
g_rec_mutex_impl_new (void)
{
  pthread_mutexattr_t attr;
  pthread_mutex_t *mutex;

279 280 281 282
  mutex = malloc (sizeof (pthread_mutex_t));
  if G_UNLIKELY (mutex == NULL)
    g_thread_abort (errno, "malloc");

283 284 285 286 287 288 289 290 291 292 293 294
  pthread_mutexattr_init (&attr);
  pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
  pthread_mutex_init (mutex, &attr);
  pthread_mutexattr_destroy (&attr);

  return mutex;
}

static void
g_rec_mutex_impl_free (pthread_mutex_t *mutex)
{
  pthread_mutex_destroy (mutex);
295
  free (mutex);
296 297
}

298
static inline pthread_mutex_t *
299
g_rec_mutex_get_impl (GRecMutex *rec_mutex)
300
{
301
  pthread_mutex_t *impl = g_atomic_pointer_get (&rec_mutex->p);
302

303
  if G_UNLIKELY (impl == NULL)
304 305
    {
      impl = g_rec_mutex_impl_new ();
306
      if (!g_atomic_pointer_compare_and_exchange (&rec_mutex->p, NULL, impl))
307
        g_rec_mutex_impl_free (impl);
308
      impl = rec_mutex->p;
309 310 311 312 313
    }

  return impl;
}

Matthias Clasen's avatar
Matthias Clasen committed
314 315 316 317 318 319 320 321 322
/**
 * g_rec_mutex_init:
 * @rec_mutex: an uninitialized #GRecMutex
 *
 * Initializes a #GRecMutex so that it can be used.
 *
 * This function is useful to initialize a recursive mutex
 * that has been allocated on the stack, or as part of a larger
 * structure.
323 324 325
 *
 * It is not necessary to initialise a recursive mutex that has been
 * statically allocated.
Matthias Clasen's avatar
Matthias Clasen committed
326
 *
327
 * |[<!-- language="C" --> 
Matthias Clasen's avatar
Matthias Clasen committed
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
 *   typedef struct {
 *     GRecMutex m;
 *     ...
 *   } Blob;
 *
 * Blob *b;
 *
 * b = g_new (Blob, 1);
 * g_rec_mutex_init (&b->m);
 * ]|
 *
 * Calling g_rec_mutex_init() on an already initialized #GRecMutex
 * leads to undefined behaviour.
 *
 * To undo the effect of g_rec_mutex_init() when a recursive mutex
 * is no longer needed, use g_rec_mutex_clear().
 *
 * Since: 2.32
 */
347
void
Matthias Clasen's avatar
Matthias Clasen committed
348
g_rec_mutex_init (GRecMutex *rec_mutex)
349
{
350
  rec_mutex->p = g_rec_mutex_impl_new ();
351 352
}

Matthias Clasen's avatar
Matthias Clasen committed
353 354 355 356 357 358 359
/**
 * g_rec_mutex_clear:
 * @rec_mutex: an initialized #GRecMutex
 *
 * Frees the resources allocated to a recursive mutex with
 * g_rec_mutex_init().
 *
360 361
 * This function should not be used with a #GRecMutex that has been
 * statically allocated.
Matthias Clasen's avatar
Matthias Clasen committed
362 363 364 365 366 367
 *
 * Calling g_rec_mutex_clear() on a locked recursive mutex leads
 * to undefined behaviour.
 *
 * Sine: 2.32
 */
368
void
Matthias Clasen's avatar
Matthias Clasen committed
369
g_rec_mutex_clear (GRecMutex *rec_mutex)
370
{
371
  g_rec_mutex_impl_free (rec_mutex->p);
372 373
}

Matthias Clasen's avatar
Matthias Clasen committed
374 375 376 377 378 379 380 381 382 383 384 385 386
/**
 * g_rec_mutex_lock:
 * @rec_mutex: a #GRecMutex
 *
 * Locks @rec_mutex. If @rec_mutex is already locked by another
 * thread, the current thread will block until @rec_mutex is
 * unlocked by the other thread. If @rec_mutex is already locked
 * by the current thread, the 'lock count' of @rec_mutex is increased.
 * The mutex will only become available again when it is unlocked
 * as many times as it has been locked.
 *
 * Since: 2.32
 */
387 388 389 390 391 392
void
g_rec_mutex_lock (GRecMutex *mutex)
{
  pthread_mutex_lock (g_rec_mutex_get_impl (mutex));
}

Matthias Clasen's avatar
Matthias Clasen committed
393 394
/**
 * g_rec_mutex_unlock:
Stef Walter's avatar
Stef Walter committed
395
 * @rec_mutex: a #GRecMutex
Matthias Clasen's avatar
Matthias Clasen committed
396 397 398 399 400 401 402 403 404 405
 *
 * Unlocks @rec_mutex. If another thread is blocked in a
 * g_rec_mutex_lock() call for @rec_mutex, it will become unblocked
 * and can lock @rec_mutex itself.
 *
 * Calling g_rec_mutex_unlock() on a recursive mutex that is not
 * locked by the current thread leads to undefined behaviour.
 *
 * Since: 2.32
 */
406
void
Matthias Clasen's avatar
Matthias Clasen committed
407
g_rec_mutex_unlock (GRecMutex *rec_mutex)
408
{
409
  pthread_mutex_unlock (rec_mutex->p);
410 411
}

Matthias Clasen's avatar
Matthias Clasen committed
412 413 414 415 416 417 418 419 420 421 422 423
/**
 * g_rec_mutex_trylock:
 * @rec_mutex: a #GRecMutex
 *
 * Tries to lock @rec_mutex. If @rec_mutex is already locked
 * by another thread, it immediately returns %FALSE. Otherwise
 * it locks @rec_mutex and returns %TRUE.
 *
 * Returns: %TRUE if @rec_mutex could be locked
 *
 * Since: 2.32
 */
424
gboolean
Matthias Clasen's avatar
Matthias Clasen committed
425
g_rec_mutex_trylock (GRecMutex *rec_mutex)
426
{
Matthias Clasen's avatar
Matthias Clasen committed
427
  if (pthread_mutex_trylock (g_rec_mutex_get_impl (rec_mutex)) != 0)
428 429 430
    return FALSE;

  return TRUE;
431 432
}

Allison Karlitskaya's avatar
Allison Karlitskaya committed
433 434
/* {{{1 GRWLock */

435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
static pthread_rwlock_t *
g_rw_lock_impl_new (void)
{
  pthread_rwlock_t *rwlock;
  gint status;

  rwlock = malloc (sizeof (pthread_rwlock_t));
  if G_UNLIKELY (rwlock == NULL)
    g_thread_abort (errno, "malloc");

  if G_UNLIKELY ((status = pthread_rwlock_init (rwlock, NULL)) != 0)
    g_thread_abort (status, "pthread_rwlock_init");

  return rwlock;
}

static void
g_rw_lock_impl_free (pthread_rwlock_t *rwlock)
{
  pthread_rwlock_destroy (rwlock);
  free (rwlock);
}

458
static inline pthread_rwlock_t *
459 460
g_rw_lock_get_impl (GRWLock *lock)
{
461
  pthread_rwlock_t *impl = g_atomic_pointer_get (&lock->p);
462 463 464 465

  if G_UNLIKELY (impl == NULL)
    {
      impl = g_rw_lock_impl_new ();
466
      if (!g_atomic_pointer_compare_and_exchange (&lock->p, NULL, impl))
467
        g_rw_lock_impl_free (impl);
468
      impl = lock->p;
469 470 471 472 473
    }

  return impl;
}

Matthias Clasen's avatar
Matthias Clasen committed
474 475
/**
 * g_rw_lock_init:
476
 * @rw_lock: an uninitialized #GRWLock
Matthias Clasen's avatar
Matthias Clasen committed
477 478 479 480
 *
 * Initializes a #GRWLock so that it can be used.
 *
 * This function is useful to initialize a lock that has been
481 482 483
 * allocated on the stack, or as part of a larger structure.  It is not
 * necessary to initialise a reader-writer lock that has been statically
 * allocated.
Matthias Clasen's avatar
Matthias Clasen committed
484
 *
485
 * |[<!-- language="C" --> 
Matthias Clasen's avatar
Matthias Clasen committed
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
 *   typedef struct {
 *     GRWLock l;
 *     ...
 *   } Blob;
 *
 * Blob *b;
 *
 * b = g_new (Blob, 1);
 * g_rw_lock_init (&b->l);
 * ]|
 *
 * To undo the effect of g_rw_lock_init() when a lock is no longer
 * needed, use g_rw_lock_clear().
 *
 * Calling g_rw_lock_init() on an already initialized #GRWLock leads
 * to undefined behaviour.
 *
 * Since: 2.32
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
505
void
506
g_rw_lock_init (GRWLock *rw_lock)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
507
{
508
  rw_lock->p = g_rw_lock_impl_new ();
Allison Karlitskaya's avatar
Allison Karlitskaya committed
509 510
}

Matthias Clasen's avatar
Matthias Clasen committed
511 512
/**
 * g_rw_lock_clear:
513
 * @rw_lock: an initialized #GRWLock
Matthias Clasen's avatar
Matthias Clasen committed
514 515 516
 *
 * Frees the resources allocated to a lock with g_rw_lock_init().
 *
517 518 519
 * This function should not be used with a #GRWLock that has been
 * statically allocated.
 *
Matthias Clasen's avatar
Matthias Clasen committed
520 521 522 523 524
 * Calling g_rw_lock_clear() when any thread holds the lock
 * leads to undefined behaviour.
 *
 * Sine: 2.32
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
525
void
526
g_rw_lock_clear (GRWLock *rw_lock)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
527
{
528
  g_rw_lock_impl_free (rw_lock->p);
Allison Karlitskaya's avatar
Allison Karlitskaya committed
529 530
}

Matthias Clasen's avatar
Matthias Clasen committed
531 532
/**
 * g_rw_lock_writer_lock:
533
 * @rw_lock: a #GRWLock
Matthias Clasen's avatar
Matthias Clasen committed
534
 *
535 536 537
 * Obtain a write lock on @rw_lock. If any thread already holds
 * a read or write lock on @rw_lock, the current thread will block
 * until all other threads have dropped their locks on @rw_lock.
Matthias Clasen's avatar
Matthias Clasen committed
538 539 540
 *
 * Since: 2.32
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
541
void
542
g_rw_lock_writer_lock (GRWLock *rw_lock)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
543
{
544 545 546 547
  int retval = pthread_rwlock_wrlock (g_rw_lock_get_impl (rw_lock));

  if (retval != 0)
    g_critical ("Failed to get RW lock %p: %s", rw_lock, g_strerror (retval));
Allison Karlitskaya's avatar
Allison Karlitskaya committed
548 549
}

Matthias Clasen's avatar
Matthias Clasen committed
550 551
/**
 * g_rw_lock_writer_trylock:
552
 * @rw_lock: a #GRWLock
Matthias Clasen's avatar
Matthias Clasen committed
553
 *
554 555 556
 * Tries to obtain a write lock on @rw_lock. If any other thread holds
 * a read or write lock on @rw_lock, it immediately returns %FALSE.
 * Otherwise it locks @rw_lock and returns %TRUE.
Matthias Clasen's avatar
Matthias Clasen committed
557
 *
558
 * Returns: %TRUE if @rw_lock could be locked
Matthias Clasen's avatar
Matthias Clasen committed
559 560 561
 *
 * Since: 2.32
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
562
gboolean
563
g_rw_lock_writer_trylock (GRWLock *rw_lock)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
564
{
565
  if (pthread_rwlock_trywrlock (g_rw_lock_get_impl (rw_lock)) != 0)
566 567 568
    return FALSE;

  return TRUE;
Allison Karlitskaya's avatar
Allison Karlitskaya committed
569 570
}

Matthias Clasen's avatar
Matthias Clasen committed
571 572
/**
 * g_rw_lock_writer_unlock:
573
 * @rw_lock: a #GRWLock
Matthias Clasen's avatar
Matthias Clasen committed
574
 *
575
 * Release a write lock on @rw_lock.
Matthias Clasen's avatar
Matthias Clasen committed
576 577 578 579 580 581
 *
 * Calling g_rw_lock_writer_unlock() on a lock that is not held
 * by the current thread leads to undefined behaviour.
 *
 * Since: 2.32
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
582
void
583
g_rw_lock_writer_unlock (GRWLock *rw_lock)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
584
{
585
  pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock));
Allison Karlitskaya's avatar
Allison Karlitskaya committed
586 587
}

Matthias Clasen's avatar
Matthias Clasen committed
588 589
/**
 * g_rw_lock_reader_lock:
590
 * @rw_lock: a #GRWLock
Matthias Clasen's avatar
Matthias Clasen committed
591
 *
592
 * Obtain a read lock on @rw_lock. If another thread currently holds
593 594 595 596
 * the write lock on @rw_lock, the current thread will block. If another thread
 * does not hold the write lock, but is waiting for it, it is implementation
 * defined whether the reader or writer will block. Read locks can be taken
 * recursively.
Matthias Clasen's avatar
Matthias Clasen committed
597 598
 *
 * It is implementation-defined how many threads are allowed to
599 600
 * hold read locks on the same lock simultaneously. If the limit is hit,
 * or if a deadlock is detected, a critical warning will be emitted.
Matthias Clasen's avatar
Matthias Clasen committed
601 602 603
 *
 * Since: 2.32
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
604
void
605
g_rw_lock_reader_lock (GRWLock *rw_lock)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
606
{
607 608 609 610
  int retval = pthread_rwlock_rdlock (g_rw_lock_get_impl (rw_lock));

  if (retval != 0)
    g_critical ("Failed to get RW lock %p: %s", rw_lock, g_strerror (retval));
Allison Karlitskaya's avatar
Allison Karlitskaya committed
611 612
}

Matthias Clasen's avatar
Matthias Clasen committed
613 614
/**
 * g_rw_lock_reader_trylock:
615
 * @rw_lock: a #GRWLock
Matthias Clasen's avatar
Matthias Clasen committed
616
 *
617
 * Tries to obtain a read lock on @rw_lock and returns %TRUE if
Matthias Clasen's avatar
Matthias Clasen committed
618 619 620
 * the read lock was successfully obtained. Otherwise it
 * returns %FALSE.
 *
621
 * Returns: %TRUE if @rw_lock could be locked
Matthias Clasen's avatar
Matthias Clasen committed
622 623 624
 *
 * Since: 2.32
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
625
gboolean
626
g_rw_lock_reader_trylock (GRWLock *rw_lock)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
627
{
628
  if (pthread_rwlock_tryrdlock (g_rw_lock_get_impl (rw_lock)) != 0)
629 630 631
    return FALSE;

  return TRUE;
Allison Karlitskaya's avatar
Allison Karlitskaya committed
632 633
}

Matthias Clasen's avatar
Matthias Clasen committed
634 635
/**
 * g_rw_lock_reader_unlock:
636
 * @rw_lock: a #GRWLock
Matthias Clasen's avatar
Matthias Clasen committed
637
 *
638
 * Release a read lock on @rw_lock.
Matthias Clasen's avatar
Matthias Clasen committed
639 640 641 642 643 644
 *
 * Calling g_rw_lock_reader_unlock() on a lock that is not held
 * by the current thread leads to undefined behaviour.
 *
 * Since: 2.32
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
645
void
646
g_rw_lock_reader_unlock (GRWLock *rw_lock)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
647
{
648
  pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock));
Allison Karlitskaya's avatar
Allison Karlitskaya committed
649 650
}

651 652
/* {{{1 GCond */

653 654
#if !defined(USE_NATIVE_MUTEX)

655 656 657
static pthread_cond_t *
g_cond_impl_new (void)
{
658
  pthread_condattr_t attr;
659 660 661
  pthread_cond_t *cond;
  gint status;

662
  pthread_condattr_init (&attr);
663 664 665 666 667 668 669

#ifdef HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
#elif defined (HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined (CLOCK_MONOTONIC)
  if G_UNLIKELY ((status = pthread_condattr_setclock (&attr, CLOCK_MONOTONIC)) != 0)
    g_thread_abort (status, "pthread_condattr_setclock");
#else
#error Cannot support GCond on your platform.
670 671
#endif

672 673 674 675
  cond = malloc (sizeof (pthread_cond_t));
  if G_UNLIKELY (cond == NULL)
    g_thread_abort (errno, "malloc");

676
  if G_UNLIKELY ((status = pthread_cond_init (cond, &attr)) != 0)
677 678
    g_thread_abort (status, "pthread_cond_init");

679 680
  pthread_condattr_destroy (&attr);

681 682 683 684 685 686 687 688 689 690
  return cond;
}

static void
g_cond_impl_free (pthread_cond_t *cond)
{
  pthread_cond_destroy (cond);
  free (cond);
}

691
static inline pthread_cond_t *
692 693
g_cond_get_impl (GCond *cond)
{
694
  pthread_cond_t *impl = g_atomic_pointer_get (&cond->p);
695 696 697 698

  if G_UNLIKELY (impl == NULL)
    {
      impl = g_cond_impl_new ();
699
      if (!g_atomic_pointer_compare_and_exchange (&cond->p, NULL, impl))
700
        g_cond_impl_free (impl);
701
      impl = cond->p;
702 703 704 705 706
    }

  return impl;
}

Matthias Clasen's avatar
Matthias Clasen committed
707 708 709 710
/**
 * g_cond_init:
 * @cond: an uninitialized #GCond
 *
711
 * Initialises a #GCond so that it can be used.
Matthias Clasen's avatar
Matthias Clasen committed
712
 *
713 714 715
 * This function is useful to initialise a #GCond that has been
 * allocated as part of a larger structure.  It is not necessary to
 * initialise a #GCond that has been statically allocated.
Matthias Clasen's avatar
Matthias Clasen committed
716 717 718 719
 *
 * To undo the effect of g_cond_init() when a #GCond is no longer
 * needed, use g_cond_clear().
 *
720
 * Calling g_cond_init() on an already-initialised #GCond leads
Matthias Clasen's avatar
Matthias Clasen committed
721
 * to undefined behaviour.
Matthias Clasen's avatar
Matthias Clasen committed
722 723 724
 *
 * Since: 2.32
 */
725 726 727
void
g_cond_init (GCond *cond)
{
728
  cond->p = g_cond_impl_new ();
729 730
}

Matthias Clasen's avatar
Matthias Clasen committed
731 732
/**
 * g_cond_clear:
733
 * @cond: an initialised #GCond
Matthias Clasen's avatar
Matthias Clasen committed
734
 *
Matthias Clasen's avatar
Matthias Clasen committed
735
 * Frees the resources allocated to a #GCond with g_cond_init().
Matthias Clasen's avatar
Matthias Clasen committed
736
 *
737 738
 * This function should not be used with a #GCond that has been
 * statically allocated.
Matthias Clasen's avatar
Matthias Clasen committed
739
 *
Matthias Clasen's avatar
Matthias Clasen committed
740 741 742
 * Calling g_cond_clear() for a #GCond on which threads are
 * blocking leads to undefined behaviour.
 *
Matthias Clasen's avatar
Matthias Clasen committed
743 744
 * Since: 2.32
 */
745 746 747
void
g_cond_clear (GCond *cond)
{
748
  g_cond_impl_free (cond->p);
749 750
}

Matthias Clasen's avatar
Matthias Clasen committed
751 752 753 754 755
/**
 * g_cond_wait:
 * @cond: a #GCond
 * @mutex: a #GMutex that is currently locked
 *
756
 * Atomically releases @mutex and waits until @cond is signalled.
757 758
 * When this function returns, @mutex is locked again and owned by the
 * calling thread.
Matthias Clasen's avatar
Matthias Clasen committed
759
 *
760 761 762 763 764 765 766 767 768 769 770
 * When using condition variables, it is possible that a spurious wakeup
 * may occur (ie: g_cond_wait() returns even though g_cond_signal() was
 * not called).  It's also possible that a stolen wakeup may occur.
 * This is when g_cond_signal() is called, but another thread acquires
 * @mutex before this thread and modifies the state of the program in
 * such a way that when g_cond_wait() is able to return, the expected
 * condition is no longer met.
 *
 * For this reason, g_cond_wait() must always be used in a loop.  See
 * the documentation for #GCond for a complete example.
 **/
771 772 773 774 775 776
void
g_cond_wait (GCond  *cond,
             GMutex *mutex)
{
  gint status;

777
  if G_UNLIKELY ((status = pthread_cond_wait (g_cond_get_impl (cond), g_mutex_get_impl (mutex))) != 0)
778 779 780
    g_thread_abort (status, "pthread_cond_wait");
}

Matthias Clasen's avatar
Matthias Clasen committed
781 782 783 784
/**
 * g_cond_signal:
 * @cond: a #GCond
 *
Matthias Clasen's avatar
Matthias Clasen committed
785 786
 * If threads are waiting for @cond, at least one of them is unblocked.
 * If no threads are waiting for @cond, this function has no effect.
Matthias Clasen's avatar
Matthias Clasen committed
787 788 789
 * It is good practice to hold the same lock as the waiting thread
 * while calling this function, though not required.
 */
790 791 792 793 794
void
g_cond_signal (GCond *cond)
{
  gint status;

795
  if G_UNLIKELY ((status = pthread_cond_signal (g_cond_get_impl (cond))) != 0)
796 797 798
    g_thread_abort (status, "pthread_cond_signal");
}

Matthias Clasen's avatar
Matthias Clasen committed
799 800 801 802
/**
 * g_cond_broadcast:
 * @cond: a #GCond
 *
Matthias Clasen's avatar
Matthias Clasen committed
803 804
 * If threads are waiting for @cond, all of them are unblocked.
 * If no threads are waiting for @cond, this function has no effect.
Matthias Clasen's avatar
Matthias Clasen committed
805 806 807
 * It is good practice to lock the same mutex as the waiting threads
 * while calling this function, though not required.
 */
808 809 810 811 812
void
g_cond_broadcast (GCond *cond)
{
  gint status;

813
  if G_UNLIKELY ((status = pthread_cond_broadcast (g_cond_get_impl (cond))) != 0)
814 815 816
    g_thread_abort (status, "pthread_cond_broadcast");
}

Matthias Clasen's avatar
Matthias Clasen committed
817
/**
818
 * g_cond_wait_until:
Matthias Clasen's avatar
Matthias Clasen committed
819 820
 * @cond: a #GCond
 * @mutex: a #GMutex that is currently locked
821
 * @end_time: the monotonic time to wait until
Matthias Clasen's avatar
Matthias Clasen committed
822
 *
823
 * Waits until either @cond is signalled or @end_time has passed.
Matthias Clasen's avatar
Matthias Clasen committed
824
 *
825 826 827
 * As with g_cond_wait() it is possible that a spurious or stolen wakeup
 * could occur.  For that reason, waiting on a condition variable should
 * always be in a loop, based on an explicitly-checked predicate.
Matthias Clasen's avatar
Matthias Clasen committed
828
 *
829 830 831
 * %TRUE is returned if the condition variable was signalled (or in the
 * case of a spurious wakeup).  %FALSE is returned if @end_time has
 * passed.
Matthias Clasen's avatar
Matthias Clasen committed
832
 *
833
 * The following code shows how to correctly perform a timed wait on a
834
 * condition variable (extending the example presented in the
835
 * documentation for #GCond):
Matthias Clasen's avatar
Matthias Clasen committed
836
 *
837
 * |[<!-- language="C" --> 
838 839 840 841 842 843 844 845 846 847 848 849
 * gpointer
 * pop_data_timed (void)
 * {
 *   gint64 end_time;
 *   gpointer data;
 *
 *   g_mutex_lock (&data_mutex);
 *
 *   end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND;
 *   while (!current_data)
 *     if (!g_cond_wait_until (&data_cond, &data_mutex, end_time))
 *       {
Matthias Clasen's avatar
Matthias Clasen committed
850
 *         // timeout has passed.
851 852 853 854
 *         g_mutex_unlock (&data_mutex);
 *         return NULL;
 *       }
 *
Matthias Clasen's avatar
Matthias Clasen committed
855
 *   // there is data for us
856 857 858 859 860 861 862 863
 *   data = current_data;
 *   current_data = NULL;
 *
 *   g_mutex_unlock (&data_mutex);
 *
 *   return data;
 * }
 * ]|
Matthias Clasen's avatar
Matthias Clasen committed
864
 *
865 866 867
 * Notice that the end time is calculated once, before entering the
 * loop and reused.  This is the motivation behind the use of absolute
 * time on this API -- if a relative time of 5 seconds were passed
868
 * directly to the call and a spurious wakeup occurred, the program would
869 870
 * have to start over waiting again (which would lead to a total wait
 * time of more than 5 seconds).
Matthias Clasen's avatar
Matthias Clasen committed
871
 *
872
 * Returns: %TRUE on a signal, %FALSE on a timeout
Matthias Clasen's avatar
Matthias Clasen committed
873
 * Since: 2.32
874
 **/
875
gboolean
876 877 878
g_cond_wait_until (GCond  *cond,
                   GMutex *mutex,
                   gint64  end_time)
879
{
880
  struct timespec ts;
881 882
  gint status;

883 884 885 886 887 888 889 890 891
#ifdef HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
  /* end_time is given relative to the monotonic clock as returned by
   * g_get_monotonic_time().
   *
   * Since this pthreads wants the relative time, convert it back again.
   */
  {
    gint64 now = g_get_monotonic_time ();
    gint64 relative;
892

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
    if (end_time <= now)
      return FALSE;

    relative = end_time - now;

    ts.tv_sec = relative / 1000000;
    ts.tv_nsec = (relative % 1000000) * 1000;

    if ((status = pthread_cond_timedwait_relative_np (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &ts)) == 0)
      return TRUE;
  }
#elif defined (HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined (CLOCK_MONOTONIC)
  /* This is the exact check we used during init to set the clock to
   * monotonic, so if we're in this branch, timedwait() will already be
   * expecting a monotonic clock.
   */
  {
    ts.tv_sec = end_time / 1000000;
    ts.tv_nsec = (end_time % 1000000) * 1000;

    if ((status = pthread_cond_timedwait (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &ts)) == 0)
      return TRUE;
  }
916
#else
917
#error Cannot support GCond on your platform.
918
#endif
919 920 921 922 923 924 925

  if G_UNLIKELY (status != ETIMEDOUT)
    g_thread_abort (status, "pthread_cond_timedwait");

  return FALSE;
}

926 927
#endif /* defined(USE_NATIVE_MUTEX) */

928 929
/* {{{1 GPrivate */

930 931 932 933
/**
 * GPrivate:
 *
 * The #GPrivate struct is an opaque data structure to represent a
Matthias Clasen's avatar
Matthias Clasen committed
934 935 936
 * thread-local data key. It is approximately equivalent to the
 * pthread_setspecific()/pthread_getspecific() APIs on POSIX and to
 * TlsSetValue()/TlsGetValue() on Windows.
937
 *
Matthias Clasen's avatar
Matthias Clasen committed
938 939
 * If you don't already know why you might want this functionality,
 * then you probably don't need it.
940 941
 *
 * #GPrivate is a very limited resource (as far as 128 per program,
Matthias Clasen's avatar
Matthias Clasen committed
942
 * shared between all libraries). It is also not possible to destroy a
943 944 945 946 947 948
 * #GPrivate after it has been used. As such, it is only ever acceptable
 * to use #GPrivate in static scope, and even then sparingly so.
 *
 * See G_PRIVATE_INIT() for a couple of examples.
 *
 * The #GPrivate structure should be considered opaque.  It should only
949
 * be accessed via the g_private_ functions.
950 951 952 953 954 955 956 957 958
 */

/**
 * G_PRIVATE_INIT:
 * @notify: a #GDestroyNotify
 *
 * A macro to assist with the static initialisation of a #GPrivate.
 *
 * This macro is useful for the case that a #GDestroyNotify function
959
 * should be associated with the key.  This is needed when the key will be
960 961 962 963 964 965 966 967 968 969 970
 * used to point at memory that should be deallocated when the thread
 * exits.
 *
 * Additionally, the #GDestroyNotify will also be called on the previous
 * value stored in the key when g_private_replace() is used.
 *
 * If no #GDestroyNotify is needed, then use of this macro is not
 * required -- if the #GPrivate is declared in static scope then it will
 * be properly initialised by default (ie: to all zeros).  See the
 * examples below.
 *
971
 * |[<!-- language="C" --> 
972 973
 * static GPrivate name_key = G_PRIVATE_INIT (g_free);
 *
Matthias Clasen's avatar
Matthias Clasen committed
974
 * // return value should not be freed
975 976 977 978 979 980 981 982 983 984 985 986 987
 * const gchar *
 * get_local_name (void)
 * {
 *   return g_private_get (&name_key);
 * }
 *
 * void
 * set_local_name (const gchar *name)
 * {
 *   g_private_replace (&name_key, g_strdup (name));
 * }
 *
 *
Matthias Clasen's avatar
Matthias Clasen committed
988
 * static GPrivate count_key;   // no free function
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
 *
 * gint
 * get_local_count (void)
 * {
 *   return GPOINTER_TO_INT (g_private_get (&count_key));
 * }
 *
 * void
 * set_local_count (gint count)
 * {
 *   g_private_set (&count_key, GINT_TO_POINTER (count));
 * }
 * ]|
 *
 * Since: 2.32
 **/

static pthread_key_t *
g_private_impl_new (GDestroyNotify notify)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
1008
{
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
  pthread_key_t *key;
  gint status;

  key = malloc (sizeof (pthread_key_t));
  if G_UNLIKELY (key == NULL)
    g_thread_abort (errno, "malloc");
  status = pthread_key_create (key, notify);
  if G_UNLIKELY (status != 0)
    g_thread_abort (status, "pthread_key_create");

  return key;
}

static void
g_private_impl_free (pthread_key_t *key)
{
  gint status;

  status = pthread_key_delete (*key);
  if G_UNLIKELY (status != 0)
    g_thread_abort (status, "pthread_key_delete");
  free (key);
}

1033
static inline pthread_key_t *
1034 1035
g_private_get_impl (GPrivate *key)
{
1036
  pthread_key_t *impl = g_atomic_pointer_get (&key->p);
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048

  if G_UNLIKELY (impl == NULL)
    {
      impl = g_private_impl_new (key->notify);
      if (!g_atomic_pointer_compare_and_exchange (&key->p, NULL, impl))
        {
          g_private_impl_free (impl);
          impl = key->p;
        }
    }

  return impl;
Allison Karlitskaya's avatar
Allison Karlitskaya committed
1049 1050
}

Matthias Clasen's avatar
Matthias Clasen committed
1051 1052
/**
 * g_private_get:
1053
 * @key: a #GPrivate
Matthias Clasen's avatar
Matthias Clasen committed
1054
 *
1055
 * Returns the current value of the thread local variable @key.
Matthias Clasen's avatar
Matthias Clasen committed
1056
 *
1057 1058 1059 1060 1061
 * If the value has not yet been set in this thread, %NULL is returned.
 * Values are never copied between threads (when a new thread is
 * created, for example).
 *
 * Returns: the thread-local value
Matthias Clasen's avatar
Matthias Clasen committed
1062
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
1063
gpointer
1064
g_private_get (GPrivate *key)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
1065 1066
{
  /* quote POSIX: No errors are returned from pthread_getspecific(). */
1067
  return pthread_getspecific (*g_private_get_impl (key));
Allison Karlitskaya's avatar
Allison Karlitskaya committed
1068 1069
}

Matthias Clasen's avatar
Matthias Clasen committed
1070 1071
/**
 * g_private_set:
1072 1073
 * @key: a #GPrivate
 * @value: the new value
Matthias Clasen's avatar
Matthias Clasen committed
1074
 *
1075 1076
 * Sets the thread local variable @key to have the value @value in the
 * current thread.
Matthias Clasen's avatar
Matthias Clasen committed
1077
 *
1078 1079
 * This function differs from g_private_replace() in the following way:
 * the #GDestroyNotify for @key is not called on the old value.
Matthias Clasen's avatar
Matthias Clasen committed
1080
 */
Allison Karlitskaya's avatar
Allison Karlitskaya committed
1081
void
1082 1083
g_private_set (GPrivate *key,
               gpointer  value)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
1084 1085 1086
{
  gint status;

1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
  if G_UNLIKELY ((status = pthread_setspecific (*g_private_get_impl (key), value)) != 0)
    g_thread_abort (status, "pthread_setspecific");
}

/**
 * g_private_replace:
 * @key: a #GPrivate
 * @value: the new value
 *
 * Sets the thread local variable @key to have the value @value in the
 * current thread.
 *
 * This function differs from g_private_set() in the following way: if
 * the previous value was non-%NULL then the #GDestroyNotify handler for
 * @key is run on it.
 *
 * Since: 2.32
 **/
void
g_private_replace (GPrivate *key,
                   gpointer  value)
{
  pthread_key_t *impl = g_private_get_impl (key);
  gpointer old;
  gint status;

  old = pthread_getspecific (*impl);
  if (old && key->notify)
    key->notify (old);
1116

1117
  if G_UNLIKELY ((status = pthread_setspecific (*impl, value)) != 0)
Allison Karlitskaya's avatar
Allison Karlitskaya committed
1118 1119 1120 1121 1122
    g_thread_abort (status, "pthread_setspecific");
}

/* {{{1 GThread */

1123 1124 1125
#define posix_check_err(err, name) G_STMT_START{			\
  int error = (err); 							\
  if (error)	 		 		 			\
1126
    g_error ("file %s: line %d (%s): error '%s' during '%s'",		\
1127
           __FILE__, __LINE__, G_STRFUNC,				\
1128 1129 1130
           g_strerror (error), name);					\
  }G_STMT_END

1131
#define posix_check_cmd(cmd) posix_check_err (cmd, #cmd)
1132

1133 1134 1135 1136 1137
typedef struct
{
  GRealThread thread;

  pthread_t system_thread;
1138 1139
  gboolean  joined;
  GMutex    lock;
1140 1141
} GThreadPosix;

1142 1143 1144
void
g_system_thread_free (GRealThread *thread)
{
1145 1146
  GThreadPosix *pt = (GThreadPosix *) thread;

1147 1148 1149 1150 1151
  if (!pt->joined)
    pthread_detach (pt->system_thread);

  g_mutex_clear (&pt->lock);

1152
  g_slice_free (GThreadPosix, pt);
1153 1154
}

1155
GRealThread *
1156
g_system_thread_new (GThreadFunc   proxy,
1157
                     gulong        stack_size,
1158 1159 1160
                     const char   *name,
                     GThreadFunc   func,
                     gpointer      data,
1161
                     GError      **error)
1162
{
1163
  GThreadPosix *thread;
1164
  GRealThread *base_thread;
1165
  pthread_attr_t attr;
1166
  gint ret;
1167

1168
  thread = g_slice_new0 (GThreadPosix);
1169 1170 1171 1172 1173 1174 1175
  base_thread = (GRealThread*)thread;
  base_thread->ref_count = 2;
  base_thread->ours = TRUE;
  base_thread->thread.joinable = TRUE;
  base_thread->thread.func = func;
  base_thread->thread.data = data;
  base_thread->name = g_strdup (name);
1176

1177
  posix_check_cmd (pthread_attr_init (&attr));
1178

1179 1180
#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
  if (stack_size)
1181
    {
1182
#ifdef _SC_THREAD_STACK_MIN
1183 1184
      long min_stack_size = sysconf (_SC_THREAD_STACK_MIN);
      if (min_stack_size >= 0)
1185
        stack_size = MAX ((gulong) min_stack_size, stack_size);
1186
#endif /* _SC_THREAD_STACK_MIN */
1187 1188 1189
      /* No error check here, because some systems can't do it and
       * we simply don't want threads to fail because of that. */
      pthread_attr_setstacksize (&attr, stack_size);
1190
    }
1191 1192
#endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */

1193
  ret = pthread_create (&thread->system_thread, &attr, (void* (*)(void*))proxy, thread);
1194

1195
  posix_check_cmd (pthread_attr_destroy (&attr));
1196

1197
  if (ret == EAGAIN)
1198 1199
    {
      g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN, 
1200
                   "Error creating thread: %s", g_strerror (ret));
1201
      g_slice_free (GThreadPosix, thread);
1202
      return NULL;
1203 1204
    }

1205
  posix_check_err (ret, "pthread_create");
1206

1207 1208
  g_mutex_init (&thread->lock);

1209
  return (GRealThread *) thread;
1210 1211
}

1212 1213 1214
/**
 * g_thread_yield:
 *
Matthias Clasen's avatar
Matthias Clasen committed
1215 1216
 * Causes the calling thread to voluntarily relinquish the CPU, so
 * that other threads can run.
1217 1218 1219
 *
 * This function is often used as a method to make busy wait less evil.
 */
1220 1221
void
g_thread_yield (void)
1222
{
1223
  sched_yield ();
1224 1225
}

1226
void
1227
g_system_thread_wait (GRealThread *thread)
1228
{
1229
  GThreadPosix *pt = (GThreadPosix *) thread;
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239

  g_mutex_lock (&pt->lock);

  if (!pt->joined)
    {
      posix_check_cmd (pthread_join (pt->system_thread, NULL));
      pt->joined = TRUE;
    }

  g_mutex_unlock (&pt->lock);
1240 1241
}

1242 1243
void
g_system_thread_exit (void)
1244 1245
{
  pthread_exit (NULL);
1246 1247
}

1248 1249 1250
void
g_system_thread_set_name (const gchar *name)
{
1251
#if defined(HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID)
1252
  pthread_setname_np (name); /* on OS X and iOS */
1253 1254 1255 1256 1257 1258
#elif defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID)
  pthread_setname_np (pthread_self (), name); /* on Linux and Solaris */
#elif defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID_AND_ARG)
  pthread_setname_np (pthread_self (), "%s", (gchar *) name); /* on NetBSD */
#elif defined(HAVE_PTHREAD_SET_NAME_NP)
  pthread_set_name_np (pthread_self (), name); /* on FreeBSD, DragonFlyBSD, OpenBSD */
Matthias Clasen's avatar
Matthias Clasen committed
1259
#endif
1260 1261
}

1262 1263 1264 1265 1266 1267 1268
/* {{{1 GMutex and GCond futex implementation */

#if defined(USE_NATIVE_MUTEX)

#include <linux/futex.h>
#include <sys/syscall.h>

1269 1270 1271 1272 1273
#ifndef FUTEX_WAIT_PRIVATE
#define FUTEX_WAIT_PRIVATE FUTEX_WAIT
#define FUTEX_WAKE_PRIVATE FUTEX_WAKE
#endif

1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
/* We should expand the set of operations available in gatomic once we
 * have better C11 support in GCC in common distributions (ie: 4.9).
 *
 * Before then, let's define a couple of useful things for our own
 * purposes...
 */

#define exchange_acquire(ptr, new) \
  __atomic_exchange_4((ptr), (new), __ATOMIC_ACQUIRE)
#define compare_exchange_acquire(ptr, old, new) \
  __atomic_compare_exchange_4((ptr), (old), (new), 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)

#define exchange_release(ptr, new) \
  __atomic_exchange_4((ptr), (new), __ATOMIC_RELEASE)
#define store_release(ptr, new) \
  __atomic_store_4((ptr), (new), __ATOMIC_RELEASE)

/* Our strategy for the mutex is pretty simple:
 *
 *  0: not in use
 *
 *  1: acquired by one thread only, no contention
 *
 *  > 1: contended
 *
 *
 * As such, attempting to acquire the lock should involve an increment.
 * If we find that the previous value was 0 then we can return
 * immediately.
 *
 * On unlock, we always store 0 to indicate that the lock is available.
 * If the value there was 1 before then we didn't have contention and
 * can return immediately.  If the value was something other than 1 then
 * we have the contended case and need to wake a waiter.
 *
 * If it was not 0 then there is another thread holding it and we must
 * wait.  We must always ensure that we mark a value >1 while we are
 * waiting in order to instruct the holder to do a wake operation on
 * unlock.
 */

void
g_mutex_init (GMutex *mutex)
{
  mutex->i[0] = 0;
}

void
g_mutex_clear (GMutex *mutex)
{
1324 1325 1326
  if G_UNLIKELY (mutex->i[0] != 0)
    {
      fprintf (stderr, "g_mutex_clear() called on uninitialised or locked mutex\n");
1327
      g_abort ();
1328
    }
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
}

static void __attribute__((noinline))
g_mutex_lock_slowpath (GMutex *mutex)
{
  /* Set to 2 to indicate contention.  If it was zero before then we
   * just acquired the lock.
   *
   * Otherwise, sleep for as long as the 2 remains...
   */
  while (exchange_acquire (&mutex->i[0], 2) != 0)
1340
    syscall (__NR_futex, &mutex->i[0], (gsize) FUTEX_WAIT_PRIVATE, (gsize) 2, NULL);
1341 1342 1343
}

static void __attribute__((noinline))
1344 1345
g_mutex_unlock_slowpath (GMutex *mutex,
                         guint   prev)
1346 1347
{
  /* We seem to get better code for the uncontended case by splitting
1348
   * this out...
1349
   */
1350 1351 1352
  if G_UNLIKELY (prev == 0)
    {
      fprintf (stderr, "Attempt to unlock mutex that was not locked\n");
1353
      g_abort ();
1354 1355
    }

1356
  syscall (__NR_futex, &mutex->i[0], (gsize) FUTEX_WAKE_PRIVATE, (gsize) 1, NULL);
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
}

void
g_mutex_lock (GMutex *mutex)
{
  /* 0 -> 1 and we're done.  Anything else, and we need to wait... */
  if G_UNLIKELY (g_atomic_int_add (&mutex->i[0], 1) != 0)
    g_mutex_lock_slowpath (mutex);
}

void
g_mutex_unlock (GMutex *mutex)
{
1370 1371 1372 1373
  guint prev;

  prev = exchange_release (&mutex->i[0], 0);

1374
  /* 1-> 0 and we're done.  Anything else and we need to signal... */
1375 1376
  if G_UNLIKELY (prev != 1)
    g_mutex_unlock_slowpath (mutex, prev);
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
}

gboolean
g_mutex_trylock (GMutex *mutex)
{
  guint zero = 0;

  /* We don't want to touch the value at all unless we can move it from
   * exactly 0 to 1.
   */
  return compare_exchange_acquire (&mutex->i[0], &zero, 1);
}

/* Condition variables are implemented in a rather simple way as well.
 * In many ways, futex() as an abstraction is even more ideally suited
 * to condition variables than it is to mutexes.
 *
 * We store a generation counter.  We sample it with the lock held and
 * unlock before sleeping on the futex.
 *
 * Signalling simply involves increasing the counter and making the
 * appropriate futex call.
 *
 * The only thing that is the slightest bit complicated is timed waits
 * because we must convert our absolute time to relative.
 */

void
g_cond_init (GCond *cond)
{
  cond->i[0] = 0;
}

void
g_cond_clear (GCond *cond)
{
}

void
g_cond_wait (GCond  *cond,
             GMutex *mutex)
{
1419
  guint sampled = (guint) g_atomic_int_get (&cond->i[0]);
1420 1421

  g_mutex_unlock (mutex);
1422
  syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAIT_PRIVATE, (gsize) sampled, NULL);
1423 1424 1425 1426 1427 1428 1429 1430
  g_mutex_lock (mutex);
}

void
g_cond_signal (GCond *cond)
{
  g_atomic_int_inc (&cond->i[0]);

1431
  syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAKE_PRIVATE, (gsize) 1, NULL);
1432 1433 1434 1435 1436 1437 1438
}

void
g_cond_broadcast (GCond *cond)
{
  g_atomic_int_inc (&cond->i[0]);

1439
  syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAKE_PRIVATE, (gsize) INT_MAX, NULL);
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
}

gboolean
g_cond_wait_until (GCond  *cond,
                   GMutex *mutex,
                   gint64  end_time)
{
  struct timespec now;
  struct timespec span;
  guint sampled;
1450
  int res;
1451
  gboolean success;
1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469

  if (end_time < 0)
    return FALSE;

  clock_gettime (CLOCK_MONOTONIC, &now);
  span.tv_sec = (end_time / 1000000) - now.tv_sec;
  span.tv_nsec = ((end_time % 1000000) * 1000) - now.tv_nsec;
  if (span.tv_nsec < 0)
    {
      span.tv_nsec += 1000000000;
      span.tv_sec--;
    }

  if (span.tv_sec < 0)
    return FALSE;

  sampled = cond->i[0];
  g_mutex_unlock (mutex);
1470
  res = syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAIT_PRIVATE, (gsize) sampled, &span);
1471
  success = (res < 0 && errno == ETIMEDOUT) ? FALSE : TRUE;
1472 1473
  g_mutex_lock (mutex);

1474
  return success;
1475 1476 1477 1478 1479
}

#endif

  /* {{{1 Epilogue */
1480
/* vim:set foldmethod=marker: */