src/darwin/thread.c

   1 /*****************************************************************************
   2  * thread.c : pthread back-end for LibVLC
   3  *****************************************************************************
   4  * Copyright (C) 1999-2013 VLC authors and VideoLAN
   5  *
   6  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
   7  *          Samuel Hocevar <sam@zoy.org>
   8  *          Gildas Bazin <gbazin@netcourrier.com>
   9  *          Clément Sténac
  10  *          Rémi Denis-Courmont
  11  *          Felix Paul Kühne <fkuehne # videolan.org>
  12  *
  13  * This program is free software; you can redistribute it and/or modify it
  14  * under the terms of the GNU Lesser General Public License as published by
  15  * the Free Software Foundation; either version 2.1 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21  * GNU Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this program; if not, write to the Free Software Foundation,
  25  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_atomic.h>
  34
  35 #include "libvlc.h"
  36 #include <signal.h>
  37 #include <errno.h>
  38 #include <assert.h>
  39
  40 #include <pthread.h>
  41 #include <mach/mach_init.h> /* mach_task_self in semaphores */
  42 #include <mach/mach_time.h>
  43 #include <execinfo.h>
  44
  45 static mach_timebase_info_data_t vlc_clock_conversion_factor;
  46
  47 static void vlc_clock_setup_once (void)
  48 {
  49     if (unlikely(mach_timebase_info (&vlc_clock_conversion_factor) != 0))
  50         abort ();
  51 }
  52
  53 static pthread_once_t vlc_clock_once = PTHREAD_ONCE_INIT;
  54
  55 #define vlc_clock_setup() \
  56     pthread_once(&vlc_clock_once, vlc_clock_setup_once)
  57
  58 static struct timespec mtime_to_ts (mtime_t date)
  59 {
  60     lldiv_t d = lldiv (date, CLOCK_FREQ);
  61     struct timespec ts = { d.quot, d.rem * (1000000000 / CLOCK_FREQ) };
  62
  63     return ts;
  64 }
  65
  66 /* Print a backtrace to the standard error for debugging purpose. */
  67 void vlc_trace (const char *fn, const char *file, unsigned line)
  68 {
  69      fprintf (stderr, "at %s:%u in %s\n", file, line, fn);
  70      fflush (stderr); /* needed before switch to low-level I/O */
  71      void *stack[20];
  72      int len = backtrace (stack, sizeof (stack) / sizeof (stack[0]));
  73      backtrace_symbols_fd (stack, len, 2);
  74      fsync (2);
  75 }
  76
  77 #ifndef NDEBUG
  78 /* Reports a fatal error from the threading layer, for debugging purposes. */
  79 static void
  80 vlc_thread_fatal (const char *action, int error,
  81                   const char *function, const char *file, unsigned line)
  82 {
  83     int canc = vlc_savecancel ();
  84     fprintf (stderr, "LibVLC fatal error %s (%d) in thread %lu ",
  85              action, error, vlc_thread_id ());
  86     vlc_trace (function, file, line);
  87
  88     char buf[1000];
  89     const char *msg;
  90
  91     switch (strerror_r (error, buf, sizeof (buf)))
  92     {
  93         case 0:
  94             msg = buf;
  95             break;
  96         case ERANGE: /* should never happen */
  97             msg = "unknown (too big to display)";
  98             break;
  99         default:
 100             msg = "unknown (invalid error number)";
 101             break;
 102     }
 103     fprintf (stderr, " Error message: %s\n", msg);
 104     fflush (stderr);
 105
 106     vlc_restorecancel (canc);
 107     abort ();
 108 }
 109
 110 # define VLC_THREAD_ASSERT( action ) \
 111     if (unlikely(val)) \
 112         vlc_thread_fatal (action, val, __func__, __FILE__, __LINE__)
 113 #else
 114 # define VLC_THREAD_ASSERT( action ) ((void)val)
 115 #endif
 116
 117 /* Initializes a fast mutex. */
 118 void vlc_mutex_init( vlc_mutex_t *p_mutex )
 119 {
 120     pthread_mutexattr_t attr;
 121
 122     if (unlikely(pthread_mutexattr_init (&attr)))
 123         abort();
 124 #ifdef NDEBUG
 125     pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_DEFAULT);
 126 #else
 127     pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK);
 128 #endif
 129     if (unlikely(pthread_mutex_init (p_mutex, &attr)))
 130         abort();
 131     pthread_mutexattr_destroy( &attr );
 132 }
 133
 134 void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
 135 {
 136     pthread_mutexattr_t attr;
 137
 138     if (unlikely(pthread_mutexattr_init (&attr)))
 139         abort();
 140     pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
 141     if (unlikely(pthread_mutex_init (p_mutex, &attr)))
 142         abort();
 143     pthread_mutexattr_destroy( &attr );
 144 }
 145
 146
 147 void vlc_mutex_destroy (vlc_mutex_t *p_mutex)
 148 {
 149     int val = pthread_mutex_destroy( p_mutex );
 150     VLC_THREAD_ASSERT ("destroying mutex");
 151 }
 152
 153 #ifndef NDEBUG
 154 # ifdef HAVE_VALGRIND_VALGRIND_H
 155 #  include <valgrind/valgrind.h>
 156 # else
 157 #  define RUNNING_ON_VALGRIND (0)
 158 # endif
 159
 160 void vlc_assert_locked (vlc_mutex_t *p_mutex)
 161 {
 162     if (RUNNING_ON_VALGRIND > 0)
 163         return;
 164     assert (pthread_mutex_lock (p_mutex) == EDEADLK);
 165 }
 166 #endif
 167
 168 void vlc_mutex_lock (vlc_mutex_t *p_mutex)
 169 {
 170     int val = pthread_mutex_lock( p_mutex );
 171     VLC_THREAD_ASSERT ("locking mutex");
 172 }
 173
 174 int vlc_mutex_trylock (vlc_mutex_t *p_mutex)
 175 {
 176     int val = pthread_mutex_trylock( p_mutex );
 177
 178     if (val != EBUSY)
 179         VLC_THREAD_ASSERT ("locking mutex");
 180     return val;
 181 }
 182
 183 void vlc_mutex_unlock (vlc_mutex_t *p_mutex)
 184 {
 185     int val = pthread_mutex_unlock( p_mutex );
 186     VLC_THREAD_ASSERT ("unlocking mutex");
 187 }
 188
 189 void vlc_cond_init (vlc_cond_t *p_condvar)
 190 {
 191     if (unlikely(pthread_cond_init (p_condvar, NULL)))
 192         abort ();
 193 }
 194
 195 void vlc_cond_init_daytime (vlc_cond_t *p_condvar)
 196 {
 197     if (unlikely(pthread_cond_init (p_condvar, NULL)))
 198         abort ();
 199 }
 200
 201 void vlc_cond_destroy (vlc_cond_t *p_condvar)
 202 {
 203     int val = pthread_cond_destroy (p_condvar);
 204
 205     /* due to a faulty pthread implementation within Darwin 11 and
 206      * later condition variables cannot be destroyed without
 207      * terminating the application immediately.
 208      * This Darwin kernel issue is still present in version 13
 209      * and might not be resolved prior to Darwin 15.
 210      * radar://12496249
 211      *
 212      * To work-around this, we are just leaking the condition variable
 213      * which is acceptable due to VLC's low number of created variables
 214      * and its usually limited runtime.
 215      * Ideally, we should implement a re-useable pool.
 216      */
 217     if (val != 0) {
 218         #ifndef NDEBUG
 219         printf("pthread_cond_destroy returned %i\n", val);
 220         #endif
 221
 222         if (val == EBUSY)
 223             return;
 224     }
 225
 226     VLC_THREAD_ASSERT ("destroying condition");
 227 }
 228
 229 void vlc_cond_signal (vlc_cond_t *p_condvar)
 230 {
 231     int val = pthread_cond_signal (p_condvar);
 232     VLC_THREAD_ASSERT ("signaling condition variable");
 233 }
 234
 235 void vlc_cond_broadcast (vlc_cond_t *p_condvar)
 236 {
 237     pthread_cond_broadcast (p_condvar);
 238 }
 239
 240 void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
 241 {
 242     int val = pthread_cond_wait (p_condvar, p_mutex);
 243     VLC_THREAD_ASSERT ("waiting on condition");
 244 }
 245
 246 int vlc_cond_timedwait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
 247                         mtime_t deadline)
 248 {
 249     /* according to POSIX standards, cond_timedwait should be a cancellation point
 250      * Of course, Darwin does not care */
 251     pthread_testcancel();
 252
 253     /*
 254      * mdate() is the monotonic clock, pthread_cond_timedwait expects
 255      * origin of gettimeofday(). Use timedwait_relative_np() instead.
 256      */
 257     mtime_t base = mdate();
 258     deadline -= base;
 259     if (deadline < 0)
 260         deadline = 0;
 261
 262     struct timespec ts = mtime_to_ts(deadline);
 263     int val = pthread_cond_timedwait_relative_np(p_condvar, p_mutex, &ts);
 264     if (val != ETIMEDOUT)
 265         VLC_THREAD_ASSERT ("timed-waiting on condition");
 266     return val;
 267 }
 268
 269 /* variant for vlc_cond_init_daytime */
 270 int vlc_cond_timedwait_daytime (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
 271                                 time_t deadline)
 272 {
 273     /*
 274      * Note that both pthread_cond_timedwait_relative_np and pthread_cond_timedwait
 275      * convert the given timeout to a mach absolute deadline, with system startup
 276      * as the time origin. There is no way you can change this behaviour.
 277      *
 278      * For more details, see: https://devforums.apple.com/message/931605
 279      */
 280
 281     pthread_testcancel();
 282
 283     /*
 284      * FIXME: It is assumed, that in this case the system waits until the real
 285      * time deadline is passed, even if the real time is adjusted in between.
 286      * This is not fulfilled, as described above.
 287      */
 288     struct timespec ts = mtime_to_ts(deadline);
 289     int val = pthread_cond_timedwait(p_condvar, p_mutex, &ts);
 290
 291     if (val != ETIMEDOUT)
 292         VLC_THREAD_ASSERT ("timed-waiting on condition");
 293     return val;
 294 }
 295
 296
 297 /* Initialize a semaphore. */
 298 void vlc_sem_init (vlc_sem_t *sem, unsigned value)
 299 {
 300     if (unlikely(semaphore_create(mach_task_self(), sem, SYNC_POLICY_FIFO, value) != KERN_SUCCESS))
 301         abort ();
 302 }
 303
 304 void vlc_sem_destroy (vlc_sem_t *sem)
 305 {
 306     int val;
 307
 308     if (likely(semaphore_destroy(mach_task_self(), *sem) == KERN_SUCCESS))
 309         return;
 310
 311     val = EINVAL;
 312
 313     VLC_THREAD_ASSERT ("destroying semaphore");
 314 }
 315
 316 int vlc_sem_post (vlc_sem_t *sem)
 317 {
 318     int val;
 319
 320     if (likely(semaphore_signal(*sem) == KERN_SUCCESS))
 321         return 0;
 322
 323     val = EINVAL;
 324
 325     if (unlikely(val != EOVERFLOW))
 326         VLC_THREAD_ASSERT ("unlocking semaphore");
 327     return val;
 328 }
 329
 330 void vlc_sem_wait (vlc_sem_t *sem)
 331 {
 332     int val;
 333
 334     if (likely(semaphore_wait(*sem) == KERN_SUCCESS))
 335         return;
 336
 337     val = EINVAL;
 338
 339     VLC_THREAD_ASSERT ("locking semaphore");
 340 }
 341
 342 void vlc_rwlock_init (vlc_rwlock_t *lock)
 343 {
 344     if (unlikely(pthread_rwlock_init (lock, NULL)))
 345         abort ();
 346 }
 347
 348 void vlc_rwlock_destroy (vlc_rwlock_t *lock)
 349 {
 350     int val = pthread_rwlock_destroy (lock);
 351     VLC_THREAD_ASSERT ("destroying R/W lock");
 352 }
 353
 354 void vlc_rwlock_rdlock (vlc_rwlock_t *lock)
 355 {
 356     int val = pthread_rwlock_rdlock (lock);
 357     VLC_THREAD_ASSERT ("acquiring R/W lock for reading");
 358 }
 359
 360 void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
 361 {
 362     int val = pthread_rwlock_wrlock (lock);
 363     VLC_THREAD_ASSERT ("acquiring R/W lock for writing");
 364 }
 365
 366 void vlc_rwlock_unlock (vlc_rwlock_t *lock)
 367 {
 368     int val = pthread_rwlock_unlock (lock);
 369     VLC_THREAD_ASSERT ("releasing R/W lock");
 370 }
 371
 372 void vlc_once(vlc_once_t *once, void (*cb)(void))
 373 {
 374     int val = pthread_once(once, cb);
 375     VLC_THREAD_ASSERT("initializing once");
 376 }
 377
 378 int vlc_threadvar_create (vlc_threadvar_t *key, void (*destr) (void *))
 379 {
 380     return pthread_key_create (key, destr);
 381 }
 382
 383 void vlc_threadvar_delete (vlc_threadvar_t *p_tls)
 384 {
 385     pthread_key_delete (*p_tls);
 386 }
 387
 388 int vlc_threadvar_set (vlc_threadvar_t key, void *value)
 389 {
 390     return pthread_setspecific (key, value);
 391 }
 392
 393 void *vlc_threadvar_get (vlc_threadvar_t key)
 394 {
 395     return pthread_getspecific (key);
 396 }
 397
 398 void vlc_threads_setup (libvlc_int_t *p_libvlc)
 399 {
 400     (void) p_libvlc;
 401 }
 402
 403 static int vlc_clone_attr (vlc_thread_t *th, pthread_attr_t *attr,
 404                            void *(*entry) (void *), void *data, int priority)
 405 {
 406     int ret;
 407
 408     sigset_t oldset;
 409     {
 410         sigset_t set;
 411         sigemptyset (&set);
 412         sigdelset (&set, SIGHUP);
 413         sigaddset (&set, SIGINT);
 414         sigaddset (&set, SIGQUIT);
 415         sigaddset (&set, SIGTERM);
 416
 417         sigaddset (&set, SIGPIPE); /* We don't want this one, really! */
 418         pthread_sigmask (SIG_BLOCK, &set, &oldset);
 419     }
 420
 421     (void) priority;
 422
 423 #define VLC_STACKSIZE (128 * sizeof (void *) * 1024)
 424
 425 #ifdef VLC_STACKSIZE
 426     ret = pthread_attr_setstacksize (attr, VLC_STACKSIZE);
 427     assert (ret == 0); /* fails iif VLC_STACKSIZE is invalid */
 428 #endif
 429
 430     ret = pthread_create (th, attr, entry, data);
 431     pthread_sigmask (SIG_SETMASK, &oldset, NULL);
 432     pthread_attr_destroy (attr);
 433     return ret;
 434 }
 435
 436 int vlc_clone (vlc_thread_t *th, void *(*entry) (void *), void *data,
 437                int priority)
 438 {
 439     pthread_attr_t attr;
 440
 441     pthread_attr_init (&attr);
 442     return vlc_clone_attr (th, &attr, entry, data, priority);
 443 }
 444
 445 void vlc_join (vlc_thread_t handle, void **result)
 446 {
 447     int val = pthread_join (handle, result);
 448     VLC_THREAD_ASSERT ("joining thread");
 449 }
 450
 451 int vlc_clone_detach (vlc_thread_t *th, void *(*entry) (void *), void *data,
 452                       int priority)
 453 {
 454     vlc_thread_t dummy;
 455     pthread_attr_t attr;
 456
 457     if (th == NULL)
 458         th = &dummy;
 459
 460     pthread_attr_init (&attr);
 461     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 462     return vlc_clone_attr (th, &attr, entry, data, priority);
 463 }
 464
 465 vlc_thread_t vlc_thread_self (void)
 466 {
 467     return pthread_self ();
 468 }
 469
 470 unsigned long vlc_thread_id (void)
 471 {
 472     return -1;
 473 }
 474
 475 int vlc_set_priority (vlc_thread_t th, int priority)
 476 {
 477     (void) th; (void) priority;
 478     return VLC_SUCCESS;
 479 }
 480
 481 void vlc_cancel (vlc_thread_t thread_id)
 482 {
 483     pthread_cancel (thread_id);
 484 }
 485
 486 int vlc_savecancel (void)
 487 {
 488     int state;
 489     int val = pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &state);
 490
 491     VLC_THREAD_ASSERT ("saving cancellation");
 492     return state;
 493 }
 494
 495 void vlc_restorecancel (int state)
 496 {
 497 #ifndef NDEBUG
 498     int oldstate, val;
 499
 500     val = pthread_setcancelstate (state, &oldstate);
 501     VLC_THREAD_ASSERT ("restoring cancellation");
 502
 503     if (unlikely(oldstate != PTHREAD_CANCEL_DISABLE))
 504          vlc_thread_fatal ("restoring cancellation while not disabled", EINVAL,
 505                            __func__, __FILE__, __LINE__);
 506 #else
 507     pthread_setcancelstate (state, NULL);
 508 #endif
 509 }
 510
 511 void vlc_testcancel (void)
 512 {
 513     pthread_testcancel ();
 514 }
 515
 516 void vlc_control_cancel (int cmd, ...)
 517 {
 518     (void) cmd;
 519     vlc_assert_unreachable ();
 520 }
 521
 522 mtime_t mdate (void)
 523 {
 524     vlc_clock_setup();
 525     uint64_t date = mach_absolute_time();
 526
 527     /* denom is uint32_t, switch to 64 bits to prevent overflow. */
 528     uint64_t denom = vlc_clock_conversion_factor.denom;
 529
 530     /* Switch to microsecs */
 531     denom *= 1000LL;
 532
 533     /* Split the division to prevent overflow */
 534     lldiv_t d = lldiv (vlc_clock_conversion_factor.numer, denom);
 535
 536     return (d.quot * date) + ((d.rem * date) / denom);
 537 }
 538
 539 #undef mwait
 540 void mwait (mtime_t deadline)
 541 {
 542     deadline -= mdate ();
 543     if (deadline > 0)
 544         msleep (deadline);
 545 }
 546
 547 #undef msleep
 548 void msleep (mtime_t delay)
 549 {
 550     struct timespec ts = mtime_to_ts (delay);
 551
 552     /* nanosleep uses mach_absolute_time and mach_wait_until internally,
 553        but also handles kernel errors. Thus we use just this. */
 554     while (nanosleep (&ts, &ts) == -1)
 555         assert (errno == EINTR);
 556 }
 557
 558 unsigned vlc_GetCPUCount(void)
 559 {
 560     return sysconf(_SC_NPROCESSORS_CONF);
 561 }