src/posix/thread.c

   1 /*****************************************************************************
   2  * thread.c : pthread back-end for LibVLC
   3  *****************************************************************************
   4  * Copyright (C) 1999-2009 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  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU Lesser General Public License as published by
  14  * the Free Software Foundation; either version 2.1 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this program; if not, write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc_common.h>
  32
  33 #include "libvlc.h"
  34 #include <stdarg.h>
  35 #include <stdatomic.h>
  36 #include <signal.h>
  37 #include <errno.h>
  38 #include <time.h>
  39 #include <assert.h>
  40
  41 #include <sys/types.h>
  42 #include <unistd.h> /* fsync() */
  43 #include <pthread.h>
  44 #include <sched.h>
  45
  46 #ifdef HAVE_EXECINFO_H
  47 # include <execinfo.h>
  48 #endif
  49 #if defined(__SunOS)
  50 # include <sys/processor.h>
  51 # include <sys/pset.h>
  52 #endif
  53
  54 #if !defined (_POSIX_TIMERS)
  55 # define _POSIX_TIMERS (-1)
  56 #endif
  57 #if !defined (_POSIX_CLOCK_SELECTION)
  58 /* Clock selection was defined in 2001 and became mandatory in 2008. */
  59 # define _POSIX_CLOCK_SELECTION (-1)
  60 #endif
  61 #if !defined (_POSIX_MONOTONIC_CLOCK)
  62 # define _POSIX_MONOTONIC_CLOCK (-1)
  63 #endif
  64
  65 #if (_POSIX_TIMERS > 0)
  66 static unsigned vlc_clock_prec;
  67
  68 # if (_POSIX_MONOTONIC_CLOCK > 0) && (_POSIX_CLOCK_SELECTION > 0)
  69 /* Compile-time POSIX monotonic clock support */
  70 #  define vlc_clock_id (CLOCK_MONOTONIC)
  71
  72 # elif (_POSIX_MONOTONIC_CLOCK == 0) && (_POSIX_CLOCK_SELECTION > 0)
  73 /* Run-time POSIX monotonic clock support (see clock_setup() below) */
  74 static clockid_t vlc_clock_id;
  75
  76 # else
  77 /* No POSIX monotonic clock support */
  78 #   define vlc_clock_id (CLOCK_REALTIME)
  79 #   warning Monotonic clock not available. Expect timing issues.
  80
  81 # endif /* _POSIX_MONOTONIC_CLOKC */
  82
  83 static void vlc_clock_setup_once (void)
  84 {
  85 # if (_POSIX_MONOTONIC_CLOCK == 0)
  86     long val = sysconf (_SC_MONOTONIC_CLOCK);
  87     assert (val != 0);
  88     vlc_clock_id = (val < 0) ? CLOCK_REALTIME : CLOCK_MONOTONIC;
  89 # endif
  90
  91     struct timespec res;
  92     if (unlikely(clock_getres (vlc_clock_id, &res) != 0 || res.tv_sec != 0))
  93         abort ();
  94     vlc_clock_prec = (res.tv_nsec + 500) / 1000;
  95 }
  96
  97 static pthread_once_t vlc_clock_once = PTHREAD_ONCE_INIT;
  98
  99 # define vlc_clock_setup() \
 100     pthread_once(&vlc_clock_once, vlc_clock_setup_once)
 101
 102 #else /* _POSIX_TIMERS */
 103
 104 # include <sys/time.h> /* gettimeofday() */
 105
 106 # define vlc_clock_setup() (void)0
 107 # warning Monotonic clock not available. Expect timing issues.
 108 #endif /* _POSIX_TIMERS */
 109
 110 static struct timespec mtime_to_ts (mtime_t date)
 111 {
 112     lldiv_t d = lldiv (date, CLOCK_FREQ);
 113     struct timespec ts = { d.quot, d.rem * (1000000000 / CLOCK_FREQ) };
 114
 115     return ts;
 116 }
 117
 118 /**
 119  * Print a backtrace to the standard error for debugging purpose.
 120  */
 121 void vlc_trace (const char *fn, const char *file, unsigned line)
 122 {
 123      fprintf (stderr, "at %s:%u in %s\n", file, line, fn);
 124      fflush (stderr); /* needed before switch to low-level I/O */
 125 #ifdef HAVE_BACKTRACE
 126      void *stack[20];
 127      int len = backtrace (stack, sizeof (stack) / sizeof (stack[0]));
 128      backtrace_symbols_fd (stack, len, 2);
 129 #endif
 130      fsync (2);
 131 }
 132
 133 #ifndef NDEBUG
 134 /**
 135  * Reports a fatal error from the threading layer, for debugging purposes.
 136  */
 137 static void
 138 vlc_thread_fatal (const char *action, int error,
 139                   const char *function, const char *file, unsigned line)
 140 {
 141     int canc = vlc_savecancel ();
 142     fprintf (stderr, "LibVLC fatal error %s (%d) in thread %lu ",
 143              action, error, vlc_thread_id ());
 144     vlc_trace (function, file, line);
 145     perror ("Thread error");
 146     fflush (stderr);
 147
 148     vlc_restorecancel (canc);
 149     abort ();
 150 }
 151
 152 # define VLC_THREAD_ASSERT( action ) \
 153     if (unlikely(val)) \
 154         vlc_thread_fatal (action, val, __func__, __FILE__, __LINE__)
 155 #else
 156 # define VLC_THREAD_ASSERT( action ) ((void)val)
 157 #endif
 158
 159 void vlc_mutex_init( vlc_mutex_t *p_mutex )
 160 {
 161     pthread_mutexattr_t attr;
 162
 163     if (unlikely(pthread_mutexattr_init (&attr)))
 164         abort();
 165 #ifdef NDEBUG
 166     pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_DEFAULT);
 167 #else
 168     pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK);
 169 #endif
 170     if (unlikely(pthread_mutex_init (p_mutex, &attr)))
 171         abort();
 172     pthread_mutexattr_destroy( &attr );
 173 }
 174
 175 void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
 176 {
 177     pthread_mutexattr_t attr;
 178
 179     if (unlikely(pthread_mutexattr_init (&attr)))
 180         abort();
 181     pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
 182     if (unlikely(pthread_mutex_init (p_mutex, &attr)))
 183         abort();
 184     pthread_mutexattr_destroy( &attr );
 185 }
 186
 187 void vlc_mutex_destroy (vlc_mutex_t *p_mutex)
 188 {
 189     int val = pthread_mutex_destroy( p_mutex );
 190     VLC_THREAD_ASSERT ("destroying mutex");
 191 }
 192
 193 #ifndef NDEBUG
 194 # ifdef HAVE_VALGRIND_VALGRIND_H
 195 #  include <valgrind/valgrind.h>
 196 # else
 197 #  define RUNNING_ON_VALGRIND (0)
 198 # endif
 199
 200 /**
 201  * Asserts that a mutex is locked by the calling thread.
 202  */
 203 void vlc_assert_locked (vlc_mutex_t *p_mutex)
 204 {
 205     if (RUNNING_ON_VALGRIND > 0)
 206         return;
 207     assert (pthread_mutex_lock (p_mutex) == EDEADLK);
 208 }
 209 #endif
 210
 211 void vlc_mutex_lock (vlc_mutex_t *p_mutex)
 212 {
 213     int val = pthread_mutex_lock( p_mutex );
 214     VLC_THREAD_ASSERT ("locking mutex");
 215 }
 216
 217 int vlc_mutex_trylock (vlc_mutex_t *p_mutex)
 218 {
 219     int val = pthread_mutex_trylock( p_mutex );
 220
 221     if (val != EBUSY)
 222         VLC_THREAD_ASSERT ("locking mutex");
 223     return val;
 224 }
 225
 226 void vlc_mutex_unlock (vlc_mutex_t *p_mutex)
 227 {
 228     int val = pthread_mutex_unlock( p_mutex );
 229     VLC_THREAD_ASSERT ("unlocking mutex");
 230 }
 231
 232 void vlc_cond_init (vlc_cond_t *p_condvar)
 233 {
 234     pthread_condattr_t attr;
 235
 236     if (unlikely(pthread_condattr_init (&attr)))
 237         abort ();
 238 #if (_POSIX_CLOCK_SELECTION > 0)
 239     vlc_clock_setup ();
 240     pthread_condattr_setclock (&attr, vlc_clock_id);
 241 #endif
 242     if (unlikely(pthread_cond_init (p_condvar, &attr)))
 243         abort ();
 244     pthread_condattr_destroy (&attr);
 245 }
 246
 247 void vlc_cond_init_daytime (vlc_cond_t *p_condvar)
 248 {
 249     if (unlikely(pthread_cond_init (p_condvar, NULL)))
 250         abort ();
 251 }
 252
 253 void vlc_cond_destroy (vlc_cond_t *p_condvar)
 254 {
 255     int val = pthread_cond_destroy( p_condvar );
 256     VLC_THREAD_ASSERT ("destroying condition");
 257 }
 258
 259 void vlc_cond_signal (vlc_cond_t *p_condvar)
 260 {
 261     int val = pthread_cond_signal( p_condvar );
 262     VLC_THREAD_ASSERT ("signaling condition variable");
 263 }
 264
 265 void vlc_cond_broadcast (vlc_cond_t *p_condvar)
 266 {
 267     pthread_cond_broadcast (p_condvar);
 268 }
 269
 270 void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
 271 {
 272     int val = pthread_cond_wait( p_condvar, p_mutex );
 273     VLC_THREAD_ASSERT ("waiting on condition");
 274 }
 275
 276 int vlc_cond_timedwait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
 277                         mtime_t deadline)
 278 {
 279     struct timespec ts = mtime_to_ts (deadline);
 280     int val = pthread_cond_timedwait (p_condvar, p_mutex, &ts);
 281     if (val != ETIMEDOUT)
 282         VLC_THREAD_ASSERT ("timed-waiting on condition");
 283     return val;
 284 }
 285
 286 int vlc_cond_timedwait_daytime (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
 287                                 time_t deadline)
 288 {
 289     struct timespec ts = { deadline, 0 };
 290     int val = pthread_cond_timedwait (p_condvar, p_mutex, &ts);
 291     if (val != ETIMEDOUT)
 292         VLC_THREAD_ASSERT ("timed-waiting on condition");
 293     return val;
 294 }
 295
 296 void vlc_sem_init (vlc_sem_t *sem, unsigned value)
 297 {
 298     if (unlikely(sem_init (sem, 0, value)))
 299         abort ();
 300 }
 301
 302 void vlc_sem_destroy (vlc_sem_t *sem)
 303 {
 304     int val;
 305
 306     if (likely(sem_destroy (sem) == 0))
 307         return;
 308
 309     val = errno;
 310
 311     VLC_THREAD_ASSERT ("destroying semaphore");
 312 }
 313
 314 int vlc_sem_post (vlc_sem_t *sem)
 315 {
 316     int val;
 317
 318     if (likely(sem_post (sem) == 0))
 319         return 0;
 320
 321     val = errno;
 322
 323     if (unlikely(val != EOVERFLOW))
 324         VLC_THREAD_ASSERT ("unlocking semaphore");
 325     return val;
 326 }
 327
 328 void vlc_sem_wait (vlc_sem_t *sem)
 329 {
 330     int val;
 331
 332     do
 333         if (likely(sem_wait (sem) == 0))
 334             return;
 335     while ((val = errno) == EINTR);
 336
 337     VLC_THREAD_ASSERT ("locking semaphore");
 338 }
 339
 340 void vlc_rwlock_init (vlc_rwlock_t *lock)
 341 {
 342     if (unlikely(pthread_rwlock_init (lock, NULL)))
 343         abort ();
 344 }
 345
 346 void vlc_rwlock_destroy (vlc_rwlock_t *lock)
 347 {
 348     int val = pthread_rwlock_destroy (lock);
 349     VLC_THREAD_ASSERT ("destroying R/W lock");
 350 }
 351
 352 void vlc_rwlock_rdlock (vlc_rwlock_t *lock)
 353 {
 354     int val = pthread_rwlock_rdlock (lock);
 355     VLC_THREAD_ASSERT ("acquiring R/W lock for reading");
 356 }
 357
 358 void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
 359 {
 360     int val = pthread_rwlock_wrlock (lock);
 361     VLC_THREAD_ASSERT ("acquiring R/W lock for writing");
 362 }
 363
 364 void vlc_rwlock_unlock (vlc_rwlock_t *lock)
 365 {
 366     int val = pthread_rwlock_unlock (lock);
 367     VLC_THREAD_ASSERT ("releasing R/W lock");
 368 }
 369
 370 void vlc_once(vlc_once_t *once, void (*cb)(void))
 371 {
 372     int val = pthread_once(once, cb);
 373     VLC_THREAD_ASSERT("initializing once");
 374 }
 375
 376 int vlc_threadvar_create (vlc_threadvar_t *key, void (*destr) (void *))
 377 {
 378     return pthread_key_create (key, destr);
 379 }
 380
 381 void vlc_threadvar_delete (vlc_threadvar_t *p_tls)
 382 {
 383     pthread_key_delete (*p_tls);
 384 }
 385
 386 int vlc_threadvar_set (vlc_threadvar_t key, void *value)
 387 {
 388     return pthread_setspecific (key, value);
 389 }
 390
 391 void *vlc_threadvar_get (vlc_threadvar_t key)
 392 {
 393     return pthread_getspecific (key);
 394 }
 395
 396 static bool rt_priorities = false;
 397 static int rt_offset;
 398
 399 void vlc_threads_setup (libvlc_int_t *p_libvlc)
 400 {
 401     static vlc_mutex_t lock = VLC_STATIC_MUTEX;
 402     static bool initialized = false;
 403
 404     vlc_mutex_lock (&lock);
 405     /* Initializes real-time priorities before any thread is created,
 406      * just once per process. */
 407     if (!initialized)
 408     {
 409         if (var_InheritBool (p_libvlc, "rt-priority"))
 410         {
 411             rt_offset = var_InheritInteger (p_libvlc, "rt-offset");
 412             rt_priorities = true;
 413         }
 414         initialized = true;
 415     }
 416     vlc_mutex_unlock (&lock);
 417 }
 418
 419
 420 static int vlc_clone_attr (vlc_thread_t *th, pthread_attr_t *attr,
 421                            void *(*entry) (void *), void *data, int priority)
 422 {
 423     int ret;
 424
 425     /* Block the signals that signals interface plugin handles.
 426      * If the LibVLC caller wants to handle some signals by itself, it should
 427      * block these before whenever invoking LibVLC. And it must obviously not
 428      * start the VLC signals interface plugin.
 429      *
 430      * LibVLC will normally ignore any interruption caused by an asynchronous
 431      * signal during a system call. But there may well be some buggy cases
 432      * where it fails to handle EINTR (bug reports welcome). Some underlying
 433      * libraries might also not handle EINTR properly.
 434      */
 435     sigset_t oldset;
 436     {
 437         sigset_t set;
 438         sigemptyset (&set);
 439         sigdelset (&set, SIGHUP);
 440         sigaddset (&set, SIGINT);
 441         sigaddset (&set, SIGQUIT);
 442         sigaddset (&set, SIGTERM);
 443
 444         sigaddset (&set, SIGPIPE); /* We don't want this one, really! */
 445         pthread_sigmask (SIG_BLOCK, &set, &oldset);
 446     }
 447
 448 #if defined (_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING >= 0) \
 449  && defined (_POSIX_THREAD_PRIORITY_SCHEDULING) \
 450  && (_POSIX_THREAD_PRIORITY_SCHEDULING >= 0)
 451     if (rt_priorities)
 452     {
 453         struct sched_param sp = { .sched_priority = priority + rt_offset, };
 454         int policy;
 455
 456         if (sp.sched_priority <= 0)
 457             sp.sched_priority += sched_get_priority_max (policy = SCHED_OTHER);
 458         else
 459             sp.sched_priority += sched_get_priority_min (policy = SCHED_RR);
 460
 461         pthread_attr_setschedpolicy (attr, policy);
 462         pthread_attr_setschedparam (attr, &sp);
 463         pthread_attr_setinheritsched (attr, PTHREAD_EXPLICIT_SCHED);
 464     }
 465 #else
 466     (void) priority;
 467 #endif
 468
 469     /* The thread stack size.
 470      * The lower the value, the less address space per thread, the highest
 471      * maximum simultaneous threads per process. Too low values will cause
 472      * stack overflows and weird crashes. Set with caution. Also keep in mind
 473      * that 64-bits platforms consume more stack than 32-bits one.
 474      *
 475      * Thanks to on-demand paging, thread stack size only affects address space
 476      * consumption. In terms of memory, threads only use what they need
 477      * (rounded up to the page boundary).
 478      *
 479      * For example, on Linux i386, the default is 2 mega-bytes, which supports
 480      * about 320 threads per processes. */
 481 #define VLC_STACKSIZE (128 * sizeof (void *) * 1024)
 482
 483 #ifdef VLC_STACKSIZE
 484     ret = pthread_attr_setstacksize (attr, VLC_STACKSIZE);
 485     assert (ret == 0); /* fails iif VLC_STACKSIZE is invalid */
 486 #endif
 487
 488     ret = pthread_create(&th->handle, attr, entry, data);
 489     pthread_sigmask (SIG_SETMASK, &oldset, NULL);
 490     pthread_attr_destroy (attr);
 491     return ret;
 492 }
 493
 494 int vlc_clone (vlc_thread_t *th, void *(*entry) (void *), void *data,
 495                int priority)
 496 {
 497     pthread_attr_t attr;
 498
 499     pthread_attr_init (&attr);
 500     return vlc_clone_attr (th, &attr, entry, data, priority);
 501 }
 502
 503 void vlc_join(vlc_thread_t th, void **result)
 504 {
 505     int val = pthread_join(th.handle, result);
 506     VLC_THREAD_ASSERT ("joining thread");
 507 }
 508
 509 /**
 510  * Creates and starts new detached thread.
 511  * A detached thread cannot be joined. Its resources will be automatically
 512  * released whenever the thread exits (in particular, its call stack will be
 513  * reclaimed).
 514  *
 515  * Detached thread are particularly useful when some work needs to be done
 516  * asynchronously, that is likely to be completed much earlier than the thread
 517  * can practically be joined. In this case, thread detach can spare memory.
 518  *
 519  * A detached thread may be cancelled, so as to expedite its termination.
 520  * Be extremely careful if you do this: while a normal joinable thread can
 521  * safely be cancelled after it has already exited, cancelling an already
 522  * exited detached thread is undefined: The thread handle would is destroyed
 523  * immediately when the detached thread exits. So you need to ensure that the
 524  * detached thread is still running before cancellation is attempted.
 525  *
 526  * @warning Care must be taken that any resources used by the detached thread
 527  * remains valid until the thread completes.
 528  *
 529  * @note A detached thread must eventually exit just like another other
 530  * thread. In practice, LibVLC will wait for detached threads to exit before
 531  * it unloads the plugins.
 532  *
 533  * @param th [OUT] pointer to hold the thread handle, or NULL
 534  * @param entry entry point for the thread
 535  * @param data data parameter given to the entry point
 536  * @param priority thread priority value
 537  * @return 0 on success, a standard error code on error.
 538  */
 539 int vlc_clone_detach (vlc_thread_t *th, void *(*entry) (void *), void *data,
 540                       int priority)
 541 {
 542     vlc_thread_t dummy;
 543     pthread_attr_t attr;
 544
 545     if (th == NULL)
 546         th = &dummy;
 547
 548     pthread_attr_init (&attr);
 549     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 550     return vlc_clone_attr (th, &attr, entry, data, priority);
 551 }
 552
 553 vlc_thread_t vlc_thread_self (void)
 554 {
 555     vlc_thread_t thread = { pthread_self() };
 556     return thread;
 557 }
 558
 559 VLC_WEAK unsigned long vlc_thread_id(void)
 560 {
 561      return -1;
 562 }
 563
 564 int vlc_set_priority (vlc_thread_t th, int priority)
 565 {
 566 #if defined (_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING >= 0) \
 567  && defined (_POSIX_THREAD_PRIORITY_SCHEDULING) \
 568  && (_POSIX_THREAD_PRIORITY_SCHEDULING >= 0)
 569     if (rt_priorities)
 570     {
 571         struct sched_param sp = { .sched_priority = priority + rt_offset, };
 572         int policy;
 573
 574         if (sp.sched_priority <= 0)
 575             sp.sched_priority += sched_get_priority_max (policy = SCHED_OTHER);
 576         else
 577             sp.sched_priority += sched_get_priority_min (policy = SCHED_RR);
 578
 579         if (pthread_setschedparam(th.handle, policy, &sp))
 580             return VLC_EGENERIC;
 581     }
 582 #else
 583     (void) th; (void) priority;
 584 #endif
 585     return VLC_SUCCESS;
 586 }
 587
 588 void vlc_cancel(vlc_thread_t th)
 589 {
 590     pthread_cancel(th.handle);
 591 }
 592
 593 int vlc_savecancel (void)
 594 {
 595     int state;
 596     int val = pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &state);
 597
 598     VLC_THREAD_ASSERT ("saving cancellation");
 599     return state;
 600 }
 601
 602 void vlc_restorecancel (int state)
 603 {
 604 #ifndef NDEBUG
 605     int oldstate, val;
 606
 607     val = pthread_setcancelstate (state, &oldstate);
 608     /* This should fail if an invalid value for given for state */
 609     VLC_THREAD_ASSERT ("restoring cancellation");
 610
 611     if (unlikely(oldstate != PTHREAD_CANCEL_DISABLE))
 612          vlc_thread_fatal ("restoring cancellation while not disabled", EINVAL,
 613                            __func__, __FILE__, __LINE__);
 614 #else
 615     pthread_setcancelstate (state, NULL);
 616 #endif
 617 }
 618
 619 void vlc_testcancel (void)
 620 {
 621     pthread_testcancel ();
 622 }
 623
 624 void vlc_control_cancel (int cmd, ...)
 625 {
 626     (void) cmd;
 627     vlc_assert_unreachable ();
 628 }
 629
 630 mtime_t mdate (void)
 631 {
 632 #if (_POSIX_TIMERS > 0)
 633     struct timespec ts;
 634
 635     vlc_clock_setup ();
 636     if (unlikely(clock_gettime (vlc_clock_id, &ts) != 0))
 637         abort ();
 638
 639     return (INT64_C(1000000) * ts.tv_sec) + (ts.tv_nsec / 1000);
 640
 641 #else
 642     struct timeval tv;
 643
 644     if (unlikely(gettimeofday (&tv, NULL) != 0))
 645         abort ();
 646     return (INT64_C(1000000) * tv.tv_sec) + tv.tv_usec;
 647
 648 #endif
 649 }
 650
 651 #undef mwait
 652 void mwait (mtime_t deadline)
 653 {
 654 #if (_POSIX_CLOCK_SELECTION > 0)
 655     vlc_clock_setup ();
 656     /* If the deadline is already elapsed, or within the clock precision,
 657      * do not even bother the system timer. */
 658     deadline -= vlc_clock_prec;
 659
 660     struct timespec ts = mtime_to_ts (deadline);
 661
 662     while (clock_nanosleep (vlc_clock_id, TIMER_ABSTIME, &ts, NULL) == EINTR);
 663
 664 #else
 665     deadline -= mdate ();
 666     if (deadline > 0)
 667         msleep (deadline);
 668
 669 #endif
 670 }
 671
 672 #undef msleep
 673 void msleep (mtime_t delay)
 674 {
 675     struct timespec ts = mtime_to_ts (delay);
 676
 677 #if (_POSIX_CLOCK_SELECTION > 0)
 678     vlc_clock_setup ();
 679     while (clock_nanosleep (vlc_clock_id, 0, &ts, &ts) == EINTR);
 680
 681 #else
 682     while (nanosleep (&ts, &ts) == -1)
 683         assert (errno == EINTR);
 684
 685 #endif
 686 }
 687
 688 unsigned vlc_GetCPUCount(void)
 689 {
 690 #if defined(HAVE_SCHED_GETAFFINITY)
 691     cpu_set_t cpu;
 692
 693     CPU_ZERO(&cpu);
 694     if (sched_getaffinity (0, sizeof (cpu), &cpu) < 0)
 695         return 1;
 696
 697     return CPU_COUNT (&cpu);
 698
 699 #elif defined(__SunOS)
 700     unsigned count = 0;
 701     int type;
 702     u_int numcpus;
 703     processor_info_t cpuinfo;
 704
 705     processorid_t *cpulist = vlc_alloc (sysconf(_SC_NPROCESSORS_MAX), sizeof (*cpulist));
 706     if (unlikely(cpulist == NULL))
 707         return 1;
 708
 709     if (pset_info(PS_MYID, &type, &numcpus, cpulist) == 0)
 710     {
 711         for (u_int i = 0; i < numcpus; i++)
 712             if (processor_info (cpulist[i], &cpuinfo) == 0)
 713                 count += (cpuinfo.pi_state == P_ONLINE);
 714     }
 715     else
 716         count = sysconf (_SC_NPROCESSORS_ONLN);
 717     free (cpulist);
 718     return count ? count : 1;
 719 #elif defined(_SC_NPROCESSORS_CONF)
 720     return sysconf(_SC_NPROCESSORS_CONF);
 721 #else
 722 #   warning "vlc_GetCPUCount is not implemented for your platform"
 723     return 1;
 724 #endif
 725 }