thread: Implement vlc_GetCPUCount for android.
[vlc.git] / 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 #include <vlc_atomic.h>
33
34 #include "libvlc.h"
35 #include <stdarg.h>
36 #include <assert.h>
37 #include <unistd.h> /* fsync() */
38 #include <signal.h>
39 #include <errno.h>
40 #include <time.h>
41
42 #include <pthread.h>
43 #include <sched.h>
44 #include <sys/time.h> /* gettimeofday() */
45
46 #ifdef __linux__
47 # include <sys/syscall.h> /* SYS_gettid */
48 #endif
49
50 #ifdef HAVE_EXECINFO_H
51 # include <execinfo.h>
52 #endif
53
54 #ifdef __APPLE__
55 # include <mach/mach_init.h> /* mach_task_self in semaphores */
56 # include <sys/sysctl.h>
57 #endif
58
59 #if defined(__OpenBSD__)
60 # include <sys/param.h>
61 # include <sys/sysctl.h>
62 # include <machine/cpu.h>
63 #endif
64
65 #if defined(__SunOS)
66 # include <unistd.h>
67 # include <sys/types.h>
68 # include <sys/processor.h>
69 # include <sys/pset.h>
70 #endif
71
72 #if !defined (_POSIX_TIMERS)
73 # define _POSIX_TIMERS (-1)
74 #endif
75 #if !defined (_POSIX_CLOCK_SELECTION)
76 /* Clock selection was defined in 2001 and became mandatory in 2008. */
77 # define _POSIX_CLOCK_SELECTION (-1)
78 #endif
79 #if !defined (_POSIX_MONOTONIC_CLOCK)
80 # define _POSIX_MONOTONIC_CLOCK (-1)
81 #endif
82
83 #if (_POSIX_TIMERS > 0)
84 static unsigned vlc_clock_prec;
85
86 # if (_POSIX_MONOTONIC_CLOCK > 0) && (_POSIX_CLOCK_SELECTION > 0)
87 /* Compile-time POSIX monotonic clock support */
88 #  define vlc_clock_id (CLOCK_MONOTONIC)
89
90 # elif (_POSIX_MONOTONIC_CLOCK == 0) && (_POSIX_CLOCK_SELECTION > 0)
91 /* Run-time POSIX monotonic clock support (see clock_setup() below) */
92 static clockid_t vlc_clock_id;
93
94 # else
95 /* No POSIX monotonic clock support */
96 #   define vlc_clock_id (CLOCK_REALTIME)
97 #   warning Monotonic clock not available. Expect timing issues.
98
99 # endif /* _POSIX_MONOTONIC_CLOKC */
100
101 static void vlc_clock_setup_once (void)
102 {
103 # if (_POSIX_MONOTONIC_CLOCK == 0)
104     long val = sysconf (_SC_MONOTONIC_CLOCK);
105     assert (val != 0);
106     vlc_clock_id = (val < 0) ? CLOCK_REALTIME : CLOCK_MONOTONIC;
107 # endif
108
109     struct timespec res;
110     if (unlikely(clock_getres (vlc_clock_id, &res) != 0 || res.tv_sec != 0))
111         abort ();
112     vlc_clock_prec = (res.tv_nsec + 500) / 1000;
113 }
114
115 static pthread_once_t vlc_clock_once = PTHREAD_ONCE_INIT;
116
117 # define vlc_clock_setup() \
118     pthread_once(&vlc_clock_once, vlc_clock_setup_once)
119
120 #else /* _POSIX_TIMERS */
121
122 # include <sys/time.h> /* gettimeofday() */
123 # if defined (HAVE_DECL_NANOSLEEP) && !HAVE_DECL_NANOSLEEP
124 int nanosleep (struct timespec *, struct timespec *);
125 # endif
126
127 # define vlc_clock_setup() (void)0
128 # warning Monotonic clock not available. Expect timing issues.
129 #endif /* _POSIX_TIMERS */
130
131 static struct timespec mtime_to_ts (mtime_t date)
132 {
133     lldiv_t d = lldiv (date, CLOCK_FREQ);
134     struct timespec ts = { d.quot, d.rem * (1000000000 / CLOCK_FREQ) };
135
136     return ts;
137 }
138
139 /**
140  * Print a backtrace to the standard error for debugging purpose.
141  */
142 void vlc_trace (const char *fn, const char *file, unsigned line)
143 {
144      fprintf (stderr, "at %s:%u in %s\n", file, line, fn);
145      fflush (stderr); /* needed before switch to low-level I/O */
146 #ifdef HAVE_BACKTRACE
147      void *stack[20];
148      int len = backtrace (stack, sizeof (stack) / sizeof (stack[0]));
149      backtrace_symbols_fd (stack, len, 2);
150 #endif
151      fsync (2);
152 }
153
154 static inline unsigned long vlc_threadid (void)
155 {
156 #if defined (__linux__)
157      /* glibc does not provide a call for this */
158      return syscall (SYS_gettid);
159
160 #else
161      union { pthread_t th; unsigned long int i; } v = { };
162      v.th = pthread_self ();
163      return v.i;
164
165 #endif
166 }
167
168 #ifndef NDEBUG
169 /*****************************************************************************
170  * vlc_thread_fatal: Report an error from the threading layer
171  *****************************************************************************
172  * This is mostly meant for debugging.
173  *****************************************************************************/
174 static void
175 vlc_thread_fatal (const char *action, int error,
176                   const char *function, const char *file, unsigned line)
177 {
178     int canc = vlc_savecancel ();
179     fprintf (stderr, "LibVLC fatal error %s (%d) in thread %lu ",
180              action, error, vlc_threadid ());
181     vlc_trace (function, file, line);
182
183     /* Sometimes strerror_r() crashes too, so make sure we print an error
184      * message before we invoke it */
185 #ifdef __GLIBC__
186     /* Avoid the strerror_r() prototype brain damage in glibc */
187     errno = error;
188     fprintf (stderr, " Error message: %m\n");
189 #else
190     char buf[1000];
191     const char *msg;
192
193     switch (strerror_r (error, buf, sizeof (buf)))
194     {
195         case 0:
196             msg = buf;
197             break;
198         case ERANGE: /* should never happen */
199             msg = "unknown (too big to display)";
200             break;
201         default:
202             msg = "unknown (invalid error number)";
203             break;
204     }
205     fprintf (stderr, " Error message: %s\n", msg);
206 #endif
207     fflush (stderr);
208
209     vlc_restorecancel (canc);
210     abort ();
211 }
212
213 # define VLC_THREAD_ASSERT( action ) \
214     if (unlikely(val)) \
215         vlc_thread_fatal (action, val, __func__, __FILE__, __LINE__)
216 #else
217 # define VLC_THREAD_ASSERT( action ) ((void)val)
218 #endif
219
220 #if defined (__GLIBC__) && (__GLIBC_MINOR__ < 6)
221 /* This is not prototyped under glibc, though it exists. */
222 int pthread_mutexattr_setkind_np( pthread_mutexattr_t *attr, int kind );
223 #endif
224
225 /*****************************************************************************
226  * vlc_mutex_init: initialize a mutex
227  *****************************************************************************/
228 void vlc_mutex_init( vlc_mutex_t *p_mutex )
229 {
230     pthread_mutexattr_t attr;
231
232     if (unlikely(pthread_mutexattr_init (&attr)))
233         abort();
234 #ifdef NDEBUG
235     pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_NORMAL );
236 #else
237     /* Create error-checking mutex to detect problems more easily. */
238 # if defined (__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ < 6)
239     pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_ERRORCHECK_NP );
240 # else
241     pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK );
242 # endif
243 #endif
244     if (unlikely(pthread_mutex_init (p_mutex, &attr)))
245         abort();
246     pthread_mutexattr_destroy( &attr );
247 }
248
249 /*****************************************************************************
250  * vlc_mutex_init: initialize a recursive mutex (Do not use)
251  *****************************************************************************/
252 void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
253 {
254     pthread_mutexattr_t attr;
255
256     if (unlikely(pthread_mutexattr_init (&attr)))
257         abort();
258 #if defined (__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ < 6)
259     pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
260 #else
261     pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
262 #endif
263     if (unlikely(pthread_mutex_init (p_mutex, &attr)))
264         abort();
265     pthread_mutexattr_destroy( &attr );
266 }
267
268
269 /**
270  * Destroys a mutex. The mutex must not be locked.
271  *
272  * @param p_mutex mutex to destroy
273  * @return always succeeds
274  */
275 void vlc_mutex_destroy (vlc_mutex_t *p_mutex)
276 {
277     int val = pthread_mutex_destroy( p_mutex );
278     VLC_THREAD_ASSERT ("destroying mutex");
279 }
280
281 #ifndef NDEBUG
282 # ifdef HAVE_VALGRIND_VALGRIND_H
283 #  include <valgrind/valgrind.h>
284 # else
285 #  define RUNNING_ON_VALGRIND (0)
286 # endif
287
288 void vlc_assert_locked (vlc_mutex_t *p_mutex)
289 {
290     if (RUNNING_ON_VALGRIND > 0)
291         return;
292     assert (pthread_mutex_lock (p_mutex) == EDEADLK);
293 }
294 #endif
295
296 /**
297  * Acquires a mutex. If needed, waits for any other thread to release it.
298  * Beware of deadlocks when locking multiple mutexes at the same time,
299  * or when using mutexes from callbacks.
300  * This function is not a cancellation-point.
301  *
302  * @param p_mutex mutex initialized with vlc_mutex_init() or
303  *                vlc_mutex_init_recursive()
304  */
305 void vlc_mutex_lock (vlc_mutex_t *p_mutex)
306 {
307     int val = pthread_mutex_lock( p_mutex );
308     VLC_THREAD_ASSERT ("locking mutex");
309 }
310
311 /**
312  * Acquires a mutex if and only if it is not currently held by another thread.
313  * This function never sleeps and can be used in delay-critical code paths.
314  * This function is not a cancellation-point.
315  *
316  * <b>Beware</b>: If this function fails, then the mutex is held... by another
317  * thread. The calling thread must deal with the error appropriately. That
318  * typically implies postponing the operations that would have required the
319  * mutex. If the thread cannot defer those operations, then it must use
320  * vlc_mutex_lock(). If in doubt, use vlc_mutex_lock() instead.
321  *
322  * @param p_mutex mutex initialized with vlc_mutex_init() or
323  *                vlc_mutex_init_recursive()
324  * @return 0 if the mutex could be acquired, an error code otherwise.
325  */
326 int vlc_mutex_trylock (vlc_mutex_t *p_mutex)
327 {
328     int val = pthread_mutex_trylock( p_mutex );
329
330     if (val != EBUSY)
331         VLC_THREAD_ASSERT ("locking mutex");
332     return val;
333 }
334
335 /**
336  * Releases a mutex (or crashes if the mutex is not locked by the caller).
337  * @param p_mutex mutex locked with vlc_mutex_lock().
338  */
339 void vlc_mutex_unlock (vlc_mutex_t *p_mutex)
340 {
341     int val = pthread_mutex_unlock( p_mutex );
342     VLC_THREAD_ASSERT ("unlocking mutex");
343 }
344
345 /**
346  * Initializes a condition variable.
347  */
348 void vlc_cond_init (vlc_cond_t *p_condvar)
349 {
350     pthread_condattr_t attr;
351
352     if (unlikely(pthread_condattr_init (&attr)))
353         abort ();
354 #if (_POSIX_CLOCK_SELECTION > 0)
355     vlc_clock_setup ();
356     pthread_condattr_setclock (&attr, vlc_clock_id);
357 #endif
358     if (unlikely(pthread_cond_init (p_condvar, &attr)))
359         abort ();
360     pthread_condattr_destroy (&attr);
361 }
362
363 /**
364  * Initializes a condition variable.
365  * Contrary to vlc_cond_init(), the wall clock will be used as a reference for
366  * the vlc_cond_timedwait() time-out parameter.
367  */
368 void vlc_cond_init_daytime (vlc_cond_t *p_condvar)
369 {
370     if (unlikely(pthread_cond_init (p_condvar, NULL)))
371         abort ();
372 }
373
374 /**
375  * Destroys a condition variable. No threads shall be waiting or signaling the
376  * condition.
377  * @param p_condvar condition variable to destroy
378  */
379 void vlc_cond_destroy (vlc_cond_t *p_condvar)
380 {
381     int val = pthread_cond_destroy( p_condvar );
382     VLC_THREAD_ASSERT ("destroying condition");
383 }
384
385 /**
386  * Wakes up one thread waiting on a condition variable, if any.
387  * @param p_condvar condition variable
388  */
389 void vlc_cond_signal (vlc_cond_t *p_condvar)
390 {
391     int val = pthread_cond_signal( p_condvar );
392     VLC_THREAD_ASSERT ("signaling condition variable");
393 }
394
395 /**
396  * Wakes up all threads (if any) waiting on a condition variable.
397  * @param p_cond condition variable
398  */
399 void vlc_cond_broadcast (vlc_cond_t *p_condvar)
400 {
401     pthread_cond_broadcast (p_condvar);
402 }
403
404 /**
405  * Waits for a condition variable. The calling thread will be suspended until
406  * another thread calls vlc_cond_signal() or vlc_cond_broadcast() on the same
407  * condition variable, the thread is cancelled with vlc_cancel(), or the
408  * system causes a "spurious" unsolicited wake-up.
409  *
410  * A mutex is needed to wait on a condition variable. It must <b>not</b> be
411  * a recursive mutex. Although it is possible to use the same mutex for
412  * multiple condition, it is not valid to use different mutexes for the same
413  * condition variable at the same time from different threads.
414  *
415  * In case of thread cancellation, the mutex is always locked before
416  * cancellation proceeds.
417  *
418  * The canonical way to use a condition variable to wait for event foobar is:
419  @code
420    vlc_mutex_lock (&lock);
421    mutex_cleanup_push (&lock); // release the mutex in case of cancellation
422
423    while (!foobar)
424        vlc_cond_wait (&wait, &lock);
425
426    --- foobar is now true, do something about it here --
427
428    vlc_cleanup_run (); // release the mutex
429   @endcode
430  *
431  * @param p_condvar condition variable to wait on
432  * @param p_mutex mutex which is unlocked while waiting,
433  *                then locked again when waking up.
434  * @param deadline <b>absolute</b> timeout
435  */
436 void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
437 {
438     int val = pthread_cond_wait( p_condvar, p_mutex );
439     VLC_THREAD_ASSERT ("waiting on condition");
440 }
441
442 /**
443  * Waits for a condition variable up to a certain date.
444  * This works like vlc_cond_wait(), except for the additional time-out.
445  *
446  * If the variable was initialized with vlc_cond_init(), the timeout has the
447  * same arbitrary origin as mdate(). If the variable was initialized with
448  * vlc_cond_init_daytime(), the timeout is expressed from the Unix epoch.
449  *
450  * @param p_condvar condition variable to wait on
451  * @param p_mutex mutex which is unlocked while waiting,
452  *                then locked again when waking up.
453  * @param deadline <b>absolute</b> timeout
454  *
455  * @return 0 if the condition was signaled, an error code in case of timeout.
456  */
457 int vlc_cond_timedwait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
458                         mtime_t deadline)
459 {
460     struct timespec ts = mtime_to_ts (deadline);
461     int val = pthread_cond_timedwait (p_condvar, p_mutex, &ts);
462     if (val != ETIMEDOUT)
463         VLC_THREAD_ASSERT ("timed-waiting on condition");
464     return val;
465 }
466
467 /**
468  * Initializes a semaphore.
469  */
470 void vlc_sem_init (vlc_sem_t *sem, unsigned value)
471 {
472 #if defined(__APPLE__)
473     if (unlikely(semaphore_create(mach_task_self(), sem, SYNC_POLICY_FIFO, value) != KERN_SUCCESS))
474         abort ();
475 #else
476     if (unlikely(sem_init (sem, 0, value)))
477         abort ();
478 #endif
479 }
480
481 /**
482  * Destroys a semaphore.
483  */
484 void vlc_sem_destroy (vlc_sem_t *sem)
485 {
486     int val;
487
488 #if defined(__APPLE__)
489     if (likely(semaphore_destroy(mach_task_self(), *sem) == KERN_SUCCESS))
490         return;
491
492     val = EINVAL;
493 #else
494     if (likely(sem_destroy (sem) == 0))
495         return;
496
497     val = errno;
498 #endif
499
500     VLC_THREAD_ASSERT ("destroying semaphore");
501 }
502
503 /**
504  * Increments the value of a semaphore.
505  * @return 0 on success, EOVERFLOW in case of integer overflow
506  */
507 int vlc_sem_post (vlc_sem_t *sem)
508 {
509     int val;
510
511 #if defined(__APPLE__)
512     if (likely(semaphore_signal(*sem) == KERN_SUCCESS))
513         return 0;
514
515     val = EINVAL;
516 #else
517     if (likely(sem_post (sem) == 0))
518         return 0;
519
520     val = errno;
521 #endif
522
523     if (unlikely(val != EOVERFLOW))
524         VLC_THREAD_ASSERT ("unlocking semaphore");
525     return val;
526 }
527
528 /**
529  * Atomically wait for the semaphore to become non-zero (if needed),
530  * then decrements it.
531  */
532 void vlc_sem_wait (vlc_sem_t *sem)
533 {
534     int val;
535
536 #if defined(__APPLE__)
537     if (likely(semaphore_wait(*sem) == KERN_SUCCESS))
538         return;
539
540     val = EINVAL;
541 #else
542     do
543         if (likely(sem_wait (sem) == 0))
544             return;
545     while ((val = errno) == EINTR);
546 #endif
547
548     VLC_THREAD_ASSERT ("locking semaphore");
549 }
550
551 /**
552  * Initializes a read/write lock.
553  */
554 void vlc_rwlock_init (vlc_rwlock_t *lock)
555 {
556     if (unlikely(pthread_rwlock_init (lock, NULL)))
557         abort ();
558 }
559
560 /**
561  * Destroys an initialized unused read/write lock.
562  */
563 void vlc_rwlock_destroy (vlc_rwlock_t *lock)
564 {
565     int val = pthread_rwlock_destroy (lock);
566     VLC_THREAD_ASSERT ("destroying R/W lock");
567 }
568
569 /**
570  * Acquires a read/write lock for reading. Recursion is allowed.
571  */
572 void vlc_rwlock_rdlock (vlc_rwlock_t *lock)
573 {
574     int val = pthread_rwlock_rdlock (lock);
575     VLC_THREAD_ASSERT ("acquiring R/W lock for reading");
576 }
577
578 /**
579  * Acquires a read/write lock for writing. Recursion is not allowed.
580  */
581 void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
582 {
583     int val = pthread_rwlock_wrlock (lock);
584     VLC_THREAD_ASSERT ("acquiring R/W lock for writing");
585 }
586
587 /**
588  * Releases a read/write lock.
589  */
590 void vlc_rwlock_unlock (vlc_rwlock_t *lock)
591 {
592     int val = pthread_rwlock_unlock (lock);
593     VLC_THREAD_ASSERT ("releasing R/W lock");
594 }
595
596 /**
597  * Allocates a thread-specific variable.
598  * @param key where to store the thread-specific variable handle
599  * @param destr a destruction callback. It is called whenever a thread exits
600  * and the thread-specific variable has a non-NULL value.
601  * @return 0 on success, a system error code otherwise. This function can
602  * actually fail because there is a fixed limit on the number of
603  * thread-specific variable in a process on most systems.
604  */
605 int vlc_threadvar_create (vlc_threadvar_t *key, void (*destr) (void *))
606 {
607     return pthread_key_create (key, destr);
608 }
609
610 void vlc_threadvar_delete (vlc_threadvar_t *p_tls)
611 {
612     pthread_key_delete (*p_tls);
613 }
614
615 /**
616  * Sets a thread-specific variable.
617  * @param key thread-local variable key (created with vlc_threadvar_create())
618  * @param value new value for the variable for the calling thread
619  * @return 0 on success, a system error code otherwise.
620  */
621 int vlc_threadvar_set (vlc_threadvar_t key, void *value)
622 {
623     return pthread_setspecific (key, value);
624 }
625
626 /**
627  * Gets the value of a thread-local variable for the calling thread.
628  * This function cannot fail.
629  * @return the value associated with the given variable for the calling
630  * or NULL if there is no value.
631  */
632 void *vlc_threadvar_get (vlc_threadvar_t key)
633 {
634     return pthread_getspecific (key);
635 }
636
637 static bool rt_priorities = false;
638 static int rt_offset;
639
640 void vlc_threads_setup (libvlc_int_t *p_libvlc)
641 {
642     static vlc_mutex_t lock = VLC_STATIC_MUTEX;
643     static bool initialized = false;
644
645     vlc_mutex_lock (&lock);
646     /* Initializes real-time priorities before any thread is created,
647      * just once per process. */
648     if (!initialized)
649     {
650 #ifndef __APPLE__
651         if (var_InheritBool (p_libvlc, "rt-priority"))
652 #endif
653         {
654             rt_offset = var_InheritInteger (p_libvlc, "rt-offset");
655             rt_priorities = true;
656         }
657         initialized = true;
658     }
659     vlc_mutex_unlock (&lock);
660 }
661
662
663 static int vlc_clone_attr (vlc_thread_t *th, pthread_attr_t *attr,
664                            void *(*entry) (void *), void *data, int priority)
665 {
666     int ret;
667
668     /* Block the signals that signals interface plugin handles.
669      * If the LibVLC caller wants to handle some signals by itself, it should
670      * block these before whenever invoking LibVLC. And it must obviously not
671      * start the VLC signals interface plugin.
672      *
673      * LibVLC will normally ignore any interruption caused by an asynchronous
674      * signal during a system call. But there may well be some buggy cases
675      * where it fails to handle EINTR (bug reports welcome). Some underlying
676      * libraries might also not handle EINTR properly.
677      */
678     sigset_t oldset;
679     {
680         sigset_t set;
681         sigemptyset (&set);
682         sigdelset (&set, SIGHUP);
683         sigaddset (&set, SIGINT);
684         sigaddset (&set, SIGQUIT);
685         sigaddset (&set, SIGTERM);
686
687         sigaddset (&set, SIGPIPE); /* We don't want this one, really! */
688         pthread_sigmask (SIG_BLOCK, &set, &oldset);
689     }
690
691 #if defined (_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING >= 0) \
692  && defined (_POSIX_THREAD_PRIORITY_SCHEDULING) \
693  && (_POSIX_THREAD_PRIORITY_SCHEDULING >= 0)
694     if (rt_priorities)
695     {
696         struct sched_param sp = { .sched_priority = priority + rt_offset, };
697         int policy;
698
699         if (sp.sched_priority <= 0)
700             sp.sched_priority += sched_get_priority_max (policy = SCHED_OTHER);
701         else
702             sp.sched_priority += sched_get_priority_min (policy = SCHED_RR);
703
704         pthread_attr_setschedpolicy (attr, policy);
705         pthread_attr_setschedparam (attr, &sp);
706     }
707 #else
708     (void) priority;
709 #endif
710
711     /* The thread stack size.
712      * The lower the value, the less address space per thread, the highest
713      * maximum simultaneous threads per process. Too low values will cause
714      * stack overflows and weird crashes. Set with caution. Also keep in mind
715      * that 64-bits platforms consume more stack than 32-bits one.
716      *
717      * Thanks to on-demand paging, thread stack size only affects address space
718      * consumption. In terms of memory, threads only use what they need
719      * (rounded up to the page boundary).
720      *
721      * For example, on Linux i386, the default is 2 mega-bytes, which supports
722      * about 320 threads per processes. */
723 #define VLC_STACKSIZE (128 * sizeof (void *) * 1024)
724
725 #ifdef VLC_STACKSIZE
726     ret = pthread_attr_setstacksize (attr, VLC_STACKSIZE);
727     assert (ret == 0); /* fails iif VLC_STACKSIZE is invalid */
728 #endif
729
730     ret = pthread_create (th, attr, entry, data);
731     pthread_sigmask (SIG_SETMASK, &oldset, NULL);
732     pthread_attr_destroy (attr);
733     return ret;
734 }
735
736 /**
737  * Creates and starts new thread.
738  *
739  * The thread must be <i>joined</i> with vlc_join() to reclaim resources
740  * when it is not needed anymore.
741  *
742  * @param th [OUT] pointer to write the handle of the created thread to
743  *                 (mandatory, must be non-NULL)
744  * @param entry entry point for the thread
745  * @param data data parameter given to the entry point
746  * @param priority thread priority value
747  * @return 0 on success, a standard error code on error.
748  */
749 int vlc_clone (vlc_thread_t *th, void *(*entry) (void *), void *data,
750                int priority)
751 {
752     pthread_attr_t attr;
753
754     pthread_attr_init (&attr);
755     return vlc_clone_attr (th, &attr, entry, data, priority);
756 }
757
758 /**
759  * Waits for a thread to complete (if needed), then destroys it.
760  * This is a cancellation point; in case of cancellation, the join does _not_
761  * occur.
762  * @warning
763  * A thread cannot join itself (normally VLC will abort if this is attempted).
764  * Also, a detached thread <b>cannot</b> be joined.
765  *
766  * @param handle thread handle
767  * @param p_result [OUT] pointer to write the thread return value or NULL
768  */
769 void vlc_join (vlc_thread_t handle, void **result)
770 {
771     int val = pthread_join (handle, result);
772     VLC_THREAD_ASSERT ("joining thread");
773 }
774
775 /**
776  * Creates and starts new detached thread.
777  * A detached thread cannot be joined. Its resources will be automatically
778  * released whenever the thread exits (in particular, its call stack will be
779  * reclaimed).
780  *
781  * Detached thread are particularly useful when some work needs to be done
782  * asynchronously, that is likely to be completed much earlier than the thread
783  * can practically be joined. In this case, thread detach can spare memory.
784  *
785  * A detached thread may be cancelled, so as to expedite its termination.
786  * Be extremely careful if you do this: while a normal joinable thread can
787  * safely be cancelled after it has already exited, cancelling an already
788  * exited detached thread is undefined: The thread handle would is destroyed
789  * immediately when the detached thread exits. So you need to ensure that the
790  * detached thread is still running before cancellation is attempted.
791  *
792  * @warning Care must be taken that any resources used by the detached thread
793  * remains valid until the thread completes.
794  *
795  * @note A detached thread must eventually exit just like another other
796  * thread. In practice, LibVLC will wait for detached threads to exit before
797  * it unloads the plugins.
798  *
799  * @param th [OUT] pointer to hold the thread handle, or NULL
800  * @param entry entry point for the thread
801  * @param data data parameter given to the entry point
802  * @param priority thread priority value
803  * @return 0 on success, a standard error code on error.
804  */
805 int vlc_clone_detach (vlc_thread_t *th, void *(*entry) (void *), void *data,
806                       int priority)
807 {
808     vlc_thread_t dummy;
809     pthread_attr_t attr;
810
811     if (th == NULL)
812         th = &dummy;
813
814     pthread_attr_init (&attr);
815     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
816     return vlc_clone_attr (th, &attr, entry, data, priority);
817 }
818
819 int vlc_set_priority (vlc_thread_t th, int priority)
820 {
821 #if defined (_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING >= 0) \
822  && defined (_POSIX_THREAD_PRIORITY_SCHEDULING) \
823  && (_POSIX_THREAD_PRIORITY_SCHEDULING >= 0)
824     if (rt_priorities)
825     {
826         struct sched_param sp = { .sched_priority = priority + rt_offset, };
827         int policy;
828
829         if (sp.sched_priority <= 0)
830             sp.sched_priority += sched_get_priority_max (policy = SCHED_OTHER);
831         else
832             sp.sched_priority += sched_get_priority_min (policy = SCHED_RR);
833
834         if (pthread_setschedparam (th, policy, &sp))
835             return VLC_EGENERIC;
836     }
837 #else
838     (void) priority;
839 #endif
840     return VLC_SUCCESS;
841 }
842
843 /**
844  * Marks a thread as cancelled. Next time the target thread reaches a
845  * cancellation point (while not having disabled cancellation), it will
846  * run its cancellation cleanup handler, the thread variable destructors, and
847  * terminate. vlc_join() must be used afterward regardless of a thread being
848  * cancelled or not.
849  */
850 void vlc_cancel (vlc_thread_t thread_id)
851 {
852     pthread_cancel (thread_id);
853 #ifdef HAVE_MAEMO
854     pthread_kill (thread_id, SIGRTMIN);
855 #endif
856 }
857
858 /**
859  * Save the current cancellation state (enabled or disabled), then disable
860  * cancellation for the calling thread.
861  * This function must be called before entering a piece of code that is not
862  * cancellation-safe, unless it can be proven that the calling thread will not
863  * be cancelled.
864  * @return Previous cancellation state (opaque value for vlc_restorecancel()).
865  */
866 int vlc_savecancel (void)
867 {
868     int state;
869     int val = pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &state);
870
871     VLC_THREAD_ASSERT ("saving cancellation");
872     return state;
873 }
874
875 /**
876  * Restore the cancellation state for the calling thread.
877  * @param state previous state as returned by vlc_savecancel().
878  * @return Nothing, always succeeds.
879  */
880 void vlc_restorecancel (int state)
881 {
882 #ifndef NDEBUG
883     int oldstate, val;
884
885     val = pthread_setcancelstate (state, &oldstate);
886     /* This should fail if an invalid value for given for state */
887     VLC_THREAD_ASSERT ("restoring cancellation");
888
889     if (unlikely(oldstate != PTHREAD_CANCEL_DISABLE))
890          vlc_thread_fatal ("restoring cancellation while not disabled", EINVAL,
891                            __func__, __FILE__, __LINE__);
892 #else
893     pthread_setcancelstate (state, NULL);
894 #endif
895 }
896
897 /**
898  * Issues an explicit deferred cancellation point.
899  * This has no effect if thread cancellation is disabled.
900  * This can be called when there is a rather slow non-sleeping operation.
901  * This is also used to force a cancellation point in a function that would
902  * otherwise "not always" be a one (block_FifoGet() is an example).
903  */
904 void vlc_testcancel (void)
905 {
906     pthread_testcancel ();
907 }
908
909 void vlc_control_cancel (int cmd, ...)
910 {
911     (void) cmd;
912     assert (0);
913 }
914
915 /**
916  * Precision monotonic clock.
917  *
918  * In principles, the clock has a precision of 1 MHz. But the actual resolution
919  * may be much lower, especially when it comes to sleeping with mwait() or
920  * msleep(). Most general-purpose operating systems provide a resolution of
921  * only 100 to 1000 Hz.
922  *
923  * @warning The origin date (time value "zero") is not specified. It is
924  * typically the time the kernel started, but this is platform-dependent.
925  * If you need wall clock time, use gettimeofday() instead.
926  *
927  * @return a timestamp in microseconds.
928  */
929 mtime_t mdate (void)
930 {
931 #if (_POSIX_TIMERS > 0)
932     struct timespec ts;
933
934     vlc_clock_setup ();
935     if (unlikely(clock_gettime (vlc_clock_id, &ts) != 0))
936         abort ();
937
938     return (INT64_C(1000000) * ts.tv_sec) + (ts.tv_nsec / 1000);
939
940 #else
941     struct timeval tv;
942
943     if (unlikely(gettimeofday (&tv, NULL) != 0))
944         abort ();
945     return (INT64_C(1000000) * tv.tv_sec) + tv.tv_usec;
946
947 #endif
948 }
949
950 #undef mwait
951 /**
952  * Waits until a deadline (possibly later due to OS scheduling).
953  * @param deadline timestamp to wait for (see mdate())
954  */
955 void mwait (mtime_t deadline)
956 {
957 #if (_POSIX_CLOCK_SELECTION > 0)
958     vlc_clock_setup ();
959     /* If the deadline is already elapsed, or within the clock precision,
960      * do not even bother the system timer. */
961     deadline -= vlc_clock_prec;
962
963     struct timespec ts = mtime_to_ts (deadline);
964
965     while (clock_nanosleep (vlc_clock_id, TIMER_ABSTIME, &ts, NULL) == EINTR);
966
967 #else
968     deadline -= mdate ();
969     if (deadline > 0)
970         msleep (deadline);
971
972 #endif
973 }
974
975 #undef msleep
976 /**
977  * Waits for an interval of time.
978  * @param delay how long to wait (in microseconds)
979  */
980 void msleep (mtime_t delay)
981 {
982     struct timespec ts = mtime_to_ts (delay);
983
984 #if (_POSIX_CLOCK_SELECTION > 0)
985     vlc_clock_setup ();
986     while (clock_nanosleep (vlc_clock_id, 0, &ts, &ts) == EINTR);
987
988 #else
989     while (nanosleep (&ts, &ts) == -1)
990         assert (errno == EINTR);
991
992 #endif
993 }
994
995
996 struct vlc_timer
997 {
998     vlc_thread_t thread;
999     vlc_cond_t   reschedule;
1000     vlc_mutex_t  lock;
1001     void       (*func) (void *);
1002     void        *data;
1003     mtime_t      value, interval;
1004     vlc_atomic_t overruns;
1005 };
1006
1007 VLC_NORETURN
1008 static void *vlc_timer_thread (void *data)
1009 {
1010     struct vlc_timer *timer = data;
1011
1012     vlc_mutex_lock (&timer->lock);
1013     mutex_cleanup_push (&timer->lock);
1014
1015     for (;;)
1016     {
1017         while (timer->value == 0)
1018             vlc_cond_wait (&timer->reschedule, &timer->lock);
1019
1020         if (vlc_cond_timedwait (&timer->reschedule, &timer->lock,
1021                                 timer->value) == 0)
1022             continue;
1023         if (timer->interval == 0)
1024             timer->value = 0; /* disarm */
1025         vlc_mutex_unlock (&timer->lock);
1026
1027         int canc = vlc_savecancel ();
1028         timer->func (timer->data);
1029         vlc_restorecancel (canc);
1030
1031         mtime_t now = mdate ();
1032         unsigned misses;
1033
1034         vlc_mutex_lock (&timer->lock);
1035         if (timer->interval == 0)
1036             continue;
1037
1038         misses = (now - timer->value) / timer->interval;
1039         timer->value += timer->interval;
1040         /* Try to compensate for one miss (mwait() will return immediately)
1041          * but no more. Otherwise, we might busy loop, after extended periods
1042          * without scheduling (suspend, SIGSTOP, RT preemption, ...). */
1043         if (misses > 1)
1044         {
1045             misses--;
1046             timer->value += misses * timer->interval;
1047             vlc_atomic_add (&timer->overruns, misses);
1048         }
1049     }
1050
1051     vlc_cleanup_pop ();
1052     assert (0);
1053 }
1054
1055 /**
1056  * Initializes an asynchronous timer.
1057  * @warning Asynchronous timers are processed from an unspecified thread.
1058  * Multiple occurences of a single interval timer are serialized; they cannot
1059  * run concurrently.
1060  *
1061  * @param id pointer to timer to be initialized
1062  * @param func function that the timer will call
1063  * @param data parameter for the timer function
1064  * @return 0 on success, a system error code otherwise.
1065  */
1066 int vlc_timer_create (vlc_timer_t *id, void (*func) (void *), void *data)
1067 {
1068     struct vlc_timer *timer = malloc (sizeof (*timer));
1069
1070     if (unlikely(timer == NULL))
1071         return ENOMEM;
1072     vlc_mutex_init (&timer->lock);
1073     vlc_cond_init (&timer->reschedule);
1074     assert (func);
1075     timer->func = func;
1076     timer->data = data;
1077     timer->value = 0;
1078     timer->interval = 0;
1079     vlc_atomic_set(&timer->overruns, 0);
1080
1081     if (vlc_clone (&timer->thread, vlc_timer_thread, timer,
1082                    VLC_THREAD_PRIORITY_INPUT))
1083     {
1084         vlc_cond_destroy (&timer->reschedule);
1085         vlc_mutex_destroy (&timer->lock);
1086         free (timer);
1087         return ENOMEM;
1088     }
1089
1090     *id = timer;
1091     return 0;
1092 }
1093
1094 /**
1095  * Destroys an initialized timer. If needed, the timer is first disarmed.
1096  * This function is undefined if the specified timer is not initialized.
1097  *
1098  * @warning This function <b>must</b> be called before the timer data can be
1099  * freed and before the timer callback function can be unloaded.
1100  *
1101  * @param timer timer to destroy
1102  */
1103 void vlc_timer_destroy (vlc_timer_t timer)
1104 {
1105     vlc_cancel (timer->thread);
1106     vlc_join (timer->thread, NULL);
1107     vlc_cond_destroy (&timer->reschedule);
1108     vlc_mutex_destroy (&timer->lock);
1109     free (timer);
1110 }
1111
1112 /**
1113  * Arm or disarm an initialized timer.
1114  * This functions overrides any previous call to itself.
1115  *
1116  * @note A timer can fire later than requested due to system scheduling
1117  * limitations. An interval timer can fail to trigger sometimes, either because
1118  * the system is busy or suspended, or because a previous iteration of the
1119  * timer is still running. See also vlc_timer_getoverrun().
1120  *
1121  * @param timer initialized timer
1122  * @param absolute the timer value origin is the same as mdate() if true,
1123  *                 the timer value is relative to now if false.
1124  * @param value zero to disarm the timer, otherwise the initial time to wait
1125  *              before firing the timer.
1126  * @param interval zero to fire the timer just once, otherwise the timer
1127  *                 repetition interval.
1128  */
1129 void vlc_timer_schedule (vlc_timer_t timer, bool absolute,
1130                          mtime_t value, mtime_t interval)
1131 {
1132     if (!absolute && value != 0)
1133         value += mdate();
1134
1135     vlc_mutex_lock (&timer->lock);
1136     timer->value = value;
1137     timer->interval = interval;
1138     vlc_cond_signal (&timer->reschedule);
1139     vlc_mutex_unlock (&timer->lock);
1140 }
1141
1142 /**
1143  * Fetch and reset the overrun counter for a timer.
1144  * @param timer initialized timer
1145  * @return the timer overrun counter, i.e. the number of times that the timer
1146  * should have run but did not since the last actual run. If all is well, this
1147  * is zero.
1148  */
1149 unsigned vlc_timer_getoverrun (vlc_timer_t timer)
1150 {
1151     return vlc_atomic_swap (&timer->overruns, 0);
1152 }
1153
1154
1155 /**
1156  * Count CPUs.
1157  * @return number of available (logical) CPUs.
1158  */
1159 unsigned vlc_GetCPUCount(void)
1160 {
1161 #if defined(HAVE_SCHED_GETAFFINITY)
1162     cpu_set_t cpu;
1163
1164     CPU_ZERO(&cpu);
1165     if (sched_getaffinity (getpid(), sizeof (cpu), &cpu) < 0)
1166         return 1;
1167
1168     return CPU_COUNT (&cpu);
1169
1170 #elif defined(__APPLE__)
1171     int count;
1172     size_t size = sizeof(count) ;
1173
1174     if (sysctlbyname ("hw.ncpu", &count, &size, NULL, 0))
1175         return 1; /* Failure */
1176     return count;
1177
1178 #elif defined(__OpenBSD__)
1179     int selectors[2] = { CTL_HW, HW_NCPU };
1180     int count;
1181     size_t size = sizeof(count);
1182
1183     if (sysctl (selectors, 2, &count, &size, NULL, 0))
1184         return 1; /* Failure */
1185     return count;
1186
1187 #elif defined(__SunOS)
1188     unsigned count = 0;
1189     int type;
1190     u_int numcpus;
1191     processor_info_t cpuinfo;
1192
1193     processorid_t *cpulist = malloc (sizeof (*cpulist) * sysconf(_SC_NPROCESSORS_MAX));
1194     if (unlikely(cpulist == NULL))
1195         return 1;
1196
1197     if (pset_info(PS_MYID, &type, &numcpus, cpulist) == 0)
1198     {
1199         for (u_int i = 0; i < numcpus; i++)
1200             if (processor_info (cpulist[i], &cpuinfo) == 0)
1201                 count += (cpuinfo.pi_state == P_ONLINE);
1202     }
1203     else
1204         count = sysconf (_SC_NPROCESSORS_ONLN);
1205     free (cpulist);
1206     return count ? count : 1;
1207 #elif defined(__ANDROID__)
1208     return sysconf(_SC_NPROCESSORS_CONF);
1209 #else
1210 #   warning "vlc_GetCPUCount is not implemented for your platform"
1211     return 1;
1212 #endif
1213 }