* Samuel Hocevar <sam@zoy.org>
* Gildas Bazin <gbazin@netcourrier.com>
* Clément Sténac
+ * Rémi Denis-Courmont
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
# include <sched.h>
static pthread_mutex_t once_mutex = PTHREAD_MUTEX_INITIALIZER;
+#else
+static vlc_threadvar_t cancel_key;
#endif
/**
return p_root;
}
-#ifndef NDEBUG
+#ifdef HAVE_EXECINFO_H
+# include <execinfo.h>
+#endif
+
/**
- * Object running the current thread
+ * Print a backtrace to the standard error for debugging purpose.
*/
-static vlc_threadvar_t thread_object_key;
-
-vlc_object_t *vlc_threadobj (void)
+void vlc_trace (const char *fn, const char *file, unsigned line)
{
- return vlc_threadvar_get (&thread_object_key);
-}
+ fprintf (stderr, "at %s:%u in %s\n", file, line, fn);
+ fflush (stderr); /* needed before switch to low-level I/O */
+#ifdef HAVE_BACKTRACE
+ void *stack[20];
+ int len = backtrace (stack, sizeof (stack) / sizeof (stack[0]));
+ backtrace_symbols_fd (stack, len, 2);
#endif
+#ifndef WIN32
+ fsync (2);
+#endif
+}
-vlc_threadvar_t msg_context_global_key;
-
-#if defined(LIBVLC_USE_PTHREAD)
static inline unsigned long vlc_threadid (void)
{
+#if defined(LIBVLC_USE_PTHREAD)
union { pthread_t th; unsigned long int i; } v = { };
v.th = pthread_self ();
return v.i;
-}
-#if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE)
-# include <execinfo.h>
+#elif defined (WIN32)
+ return GetCurrentThreadId ();
+
+#else
+ return 0;
+
#endif
+}
/*****************************************************************************
* vlc_thread_fatal: Report an error from the threading layer
*****************************************************************************
* This is mostly meant for debugging.
*****************************************************************************/
-void vlc_pthread_fatal (const char *action, int error,
- const char *file, unsigned line)
+static void
+vlc_thread_fatal (const char *action, int error,
+ const char *function, const char *file, unsigned line)
{
- fprintf (stderr, "LibVLC fatal error %s in thread %lu at %s:%u: %d\n",
- action, vlc_threadid (), file, line, error);
+ fprintf (stderr, "LibVLC fatal error %s (%d) in thread %lu ",
+ action, error, vlc_threadid ());
+ vlc_trace (function, file, line);
/* Sometimes strerror_r() crashes too, so make sure we print an error
* message before we invoke it */
/* Avoid the strerror_r() prototype brain damage in glibc */
errno = error;
fprintf (stderr, " Error message: %m at:\n");
-#else
+#elif !defined (WIN32)
char buf[1000];
const char *msg;
#endif
fflush (stderr);
-#ifdef HAVE_BACKTRACE
- void *stack[20];
- int len = backtrace (stack, sizeof (stack) / sizeof (stack[0]));
- backtrace_symbols_fd (stack, len, 2);
-#endif
-
abort ();
}
+
+#ifndef NDEBUG
+# define VLC_THREAD_ASSERT( action ) \
+ if (val) vlc_thread_fatal (action, val, __func__, __FILE__, __LINE__)
#else
-void vlc_pthread_fatal (const char *action, int error,
- const char *file, unsigned line)
+# define VLC_THREAD_ASSERT( action ) ((void)val)
+#endif
+
+/**
+ * Per-thread cancellation data
+ */
+#ifndef LIBVLC_USE_PTHREAD_CANCEL
+typedef struct vlc_cancel_t
{
- (void)action; (void)error; (void)file; (void)line;
- abort();
-}
+ vlc_cleanup_t *cleaners;
+ bool killable;
+ bool killed;
+} vlc_cancel_t;
-static vlc_threadvar_t cancel_key;
+# define VLC_CANCEL_INIT { NULL, true, false }
#endif
/*****************************************************************************
}
/* We should be safe now. Do all the initialization stuff we want. */
-#ifndef NDEBUG
- vlc_threadvar_create( &thread_object_key, NULL );
-#endif
- vlc_threadvar_create( &msg_context_global_key, msg_StackDestroy );
-#ifndef LIBVLC_USE_PTHREAD
+#ifndef LIBVLC_USE_PTHREAD_CANCEL
vlc_threadvar_create( &cancel_key, free );
#endif
}
vlc_object_release( p_root );
#ifndef LIBVLC_USE_PTHREAD
vlc_threadvar_delete( &cancel_key );
-#endif
- vlc_threadvar_delete( &msg_context_global_key );
-#ifndef NDEBUG
- vlc_threadvar_delete( &thread_object_key );
#endif
}
i_initializations--;
return 0;
#elif defined( WIN32 )
- *p_mutex = CreateMutex( 0, FALSE, 0 );
+ *p_mutex = CreateMutex( NULL, FALSE, NULL );
return (*p_mutex != NULL) ? 0 : ENOMEM;
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- /* check the arguments and whether it's already been initialized */
- if( p_mutex == NULL )
- {
- return B_BAD_VALUE;
- }
-
- if( p_mutex->init == 9999 )
- {
- return EALREADY;
- }
-
- p_mutex->lock = create_sem( 1, "BeMutex" );
- if( p_mutex->lock < B_NO_ERROR )
- {
- return( -1 );
- }
-
- p_mutex->init = 9999;
- return B_OK;
-
#endif
}
}
-/*****************************************************************************
- * vlc_mutex_destroy: destroy a mutex, inner version
- *****************************************************************************/
-void __vlc_mutex_destroy( const char * psz_file, int i_line, vlc_mutex_t *p_mutex )
+/**
+ * Destroys a mutex. The mutex must not be locked.
+ *
+ * @param p_mutex mutex to destroy
+ * @return always succeeds
+ */
+void vlc_mutex_destroy (vlc_mutex_t *p_mutex)
{
#if defined( LIBVLC_USE_PTHREAD )
int val = pthread_mutex_destroy( p_mutex );
VLC_THREAD_ASSERT ("destroying mutex");
#elif defined( UNDER_CE )
- VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-
DeleteCriticalSection( &p_mutex->csection );
#elif defined( WIN32 )
- VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-
CloseHandle( *p_mutex );
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( p_mutex->init == 9999 )
- delete_sem( p_mutex->lock );
+#endif
+}
- p_mutex->init = 0;
+/**
+ * Acquires a mutex. If needed, waits for any other thread to release it.
+ * Beware of deadlocks when locking multiple mutexes at the same time,
+ * or when using mutexes from callbacks.
+ *
+ * @param p_mutex mutex initialized with vlc_mutex_init() or
+ * vlc_mutex_init_recursive()
+ */
+void vlc_mutex_lock (vlc_mutex_t *p_mutex)
+{
+#if defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_mutex_lock( p_mutex );
+ VLC_THREAD_ASSERT ("locking mutex");
+
+#elif defined( UNDER_CE )
+ EnterCriticalSection( &p_mutex->csection );
+
+#elif defined( WIN32 )
+ WaitForSingleObject( *p_mutex, INFINITE );
+
+#endif
+}
+
+
+/**
+ * Releases a mutex (or crashes if the mutex is not locked by the caller).
+ * @param p_mutex mutex locked with vlc_mutex_lock().
+ */
+void vlc_mutex_unlock (vlc_mutex_t *p_mutex)
+{
+#if defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_mutex_unlock( p_mutex );
+ VLC_THREAD_ASSERT ("unlocking mutex");
+
+#elif defined( UNDER_CE )
+ LeaveCriticalSection( &p_mutex->csection );
+
+#elif defined( WIN32 )
+ ReleaseMutex( *p_mutex );
#endif
}
/*****************************************************************************
- * vlc_cond_init: initialize a condition
+ * vlc_cond_init: initialize a condition variable
*****************************************************************************/
-int __vlc_cond_init( vlc_cond_t *p_condvar )
+int vlc_cond_init( vlc_cond_t *p_condvar )
{
#if defined( LIBVLC_USE_PTHREAD )
pthread_condattr_t attr;
NULL ); /* unnamed */
return *p_condvar ? 0 : ENOMEM;
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( !p_condvar )
- {
- return B_BAD_VALUE;
- }
-
- if( p_condvar->init == 9999 )
- {
- return EALREADY;
- }
-
- p_condvar->thread = -1;
- p_condvar->init = 9999;
- return 0;
-
#endif
}
-/*****************************************************************************
- * vlc_cond_destroy: destroy a condition, inner version
- *****************************************************************************/
-void __vlc_cond_destroy( const char * psz_file, int i_line, vlc_cond_t *p_condvar )
+/**
+ * Destroys a condition variable. No threads shall be waiting or signaling the
+ * condition.
+ * @param p_condvar condition variable to destroy
+ */
+void vlc_cond_destroy (vlc_cond_t *p_condvar)
{
#if defined( LIBVLC_USE_PTHREAD )
int val = pthread_cond_destroy( p_condvar );
VLC_THREAD_ASSERT ("destroying condition");
#elif defined( UNDER_CE ) || defined( WIN32 )
- VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-
CloseHandle( *p_condvar );
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- p_condvar->init = 0;
+#endif
+}
+
+/**
+ * Wakes up one thread waiting on a condition variable, if any.
+ * @param p_condvar condition variable
+ */
+void vlc_cond_signal (vlc_cond_t *p_condvar)
+{
+#if defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_cond_signal( p_condvar );
+ VLC_THREAD_ASSERT ("signaling condition variable");
+
+#elif defined( UNDER_CE ) || defined( WIN32 )
+ /* Release one waiting thread if one is available. */
+ /* For this trick to work properly, the vlc_cond_signal must be surrounded
+ * by a mutex. This will prevent another thread from stealing the signal */
+ /* PulseEvent() only works if none of the waiting threads is suspended.
+ * This is particularily problematic under a debug session.
+ * as documented in http://support.microsoft.com/kb/q173260/ */
+ PulseEvent( *p_condvar );
+
+#endif
+}
+
+/**
+ * Wakes up all threads (if any) waiting on a condition variable.
+ * @param p_cond condition variable
+ */
+void vlc_cond_broadcast (vlc_cond_t *p_condvar)
+{
+#if defined (LIBVLC_USE_PTHREAD)
+ pthread_cond_broadcast (p_condvar);
+
+#elif defined (WIN32)
+ SetEvent (*p_condvar);
+
+#endif
+}
+
+/**
+ * Waits for a condition variable. The calling thread will be suspended until
+ * another thread calls vlc_cond_signal() or vlc_cond_broadcast() on the same
+ * condition variable, the thread is cancelled with vlc_cancel(), or the
+ * system causes a "spurious" unsolicited wake-up.
+ *
+ * A mutex is needed to wait on a condition variable. It must <b>not</b> be
+ * a recursive mutex. Although it is possible to use the same mutex for
+ * multiple condition, it is not valid to use different mutexes for the same
+ * condition variable at the same time from different threads.
+ *
+ * In case of thread cancellation, the mutex is always locked before
+ * cancellation proceeds.
+ *
+ * The canonical way to use a condition variable to wait for event foobar is:
+ @code
+ vlc_mutex_lock (&lock);
+ mutex_cleanup_push (&lock); // release the mutex in case of cancellation
+
+ while (!foobar)
+ vlc_cond_wait (&wait, &lock);
+
+ --- foobar is now true, do something about it here --
+
+ vlc_cleanup_run (); // release the mutex
+ @endcode
+ *
+ * @param p_condvar condition variable to wait on
+ * @param p_mutex mutex which is unlocked while waiting,
+ * then locked again when waking up.
+ * @param deadline <b>absolute</b> timeout
+ *
+ * @return 0 if the condition was signaled, an error code in case of timeout.
+ */
+void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
+{
+#if defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_cond_wait( p_condvar, p_mutex );
+ VLC_THREAD_ASSERT ("waiting on condition");
+
+#elif defined( UNDER_CE )
+ LeaveCriticalSection( &p_mutex->csection );
+ WaitForSingleObject( *p_condvar, INFINITE );
+
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
+
+#elif defined( WIN32 )
+ do
+ vlc_testcancel ();
+ while (SignalObjectAndWait (*p_mutex, *p_condvar, INFINITE, TRUE)
+ == WAIT_IO_COMPLETION);
+
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
+
+#endif
+}
+
+/**
+ * Waits for a condition variable up to a certain date.
+ * This works like vlc_cond_wait(), except for the additional timeout.
+ *
+ * @param p_condvar condition variable to wait on
+ * @param p_mutex mutex which is unlocked while waiting,
+ * then locked again when waking up.
+ * @param deadline <b>absolute</b> timeout
+ *
+ * @return 0 if the condition was signaled, an error code in case of timeout.
+ */
+int vlc_cond_timedwait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
+ mtime_t deadline)
+{
+#if defined(LIBVLC_USE_PTHREAD)
+ lldiv_t d = lldiv( deadline, CLOCK_FREQ );
+ struct timespec ts = { d.quot, d.rem * (1000000000 / CLOCK_FREQ) };
+
+ int val = pthread_cond_timedwait (p_condvar, p_mutex, &ts);
+ if (val != ETIMEDOUT)
+ VLC_THREAD_ASSERT ("timed-waiting on condition");
+ return val;
+
+#elif defined( UNDER_CE )
+ mtime_t delay_ms = (deadline - mdate()) / (CLOCK_FREQ / 1000);
+ DWORD result;
+ if( delay_ms < 0 )
+ delay_ms = 0;
+
+ LeaveCriticalSection( &p_mutex->csection );
+ result = WaitForSingleObject( *p_condvar, delay_ms );
+
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
+
+ return (result == WAIT_TIMEOUT) ? ETIMEDOUT : 0;
+
+#elif defined( WIN32 )
+ DWORD result;
+
+ do
+ {
+ vlc_testcancel ();
+
+ mtime_t total = (deadline - mdate ())/1000;
+ if( total < 0 )
+ total = 0;
+
+ DWORD delay = (total > 0x7fffffff) ? 0x7fffffff : total;
+ result = SignalObjectAndWait (*p_mutex, *p_condvar, delay, TRUE);
+ }
+ while (result == WAIT_IO_COMPLETION);
+
+ /* Reacquire the mutex before return/cancel. */
+ vlc_mutex_lock (p_mutex);
+ return (result == WAIT_OBJECT_0) ? 0 : ETIMEDOUT;
#endif
}
#elif defined (WIN32)
static unsigned __stdcall vlc_entry (void *data)
{
+ vlc_cancel_t cancel_data = VLC_CANCEL_INIT;
vlc_thread_t self = data;
+
+ vlc_threadvar_set (&cancel_key, &cancel_data);
self->data = self->entry (self->data);
return 0;
}
* memory leaks and the signal functions not working (see Microsoft
* Knowledge Base, article 104641) */
HANDLE hThread;
- vlc_thread_t th = malloc (sizeof (*p_handle));
+ vlc_thread_t th = malloc (sizeof (*th));
if (th == NULL)
return ENOMEM;
free (th);
}
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- *p_handle = spawn_thread( entry, psz_name, priority, data );
- ret = resume_thread( *p_handle );
-
#endif
return ret;
}
+#if defined (WIN32)
+/* APC procedure for thread cancellation */
+static void CALLBACK vlc_cancel_self (ULONG_PTR dummy)
+{
+ (void)dummy;
+ vlc_control_cancel (VLC_DO_CANCEL);
+}
+#endif
+
/**
* Marks a thread as cancelled. Next time the target thread reaches a
* cancellation point (while not having disabled cancellation), it will
*/
void vlc_cancel (vlc_thread_t thread_id)
{
-#if defined (LIBVLC_USE_PTHREAD)
+#if defined (LIBVLC_USE_PTHREAD_CANCEL)
pthread_cancel (thread_id);
+#elif defined (WIN32)
+ QueueUserAPC (vlc_cancel_self, thread_id->handle, 0);
+#else
+# warning vlc_cancel is not implemented!
#endif
}
/**
* Waits for a thread to complete (if needed), and destroys it.
+ * This is a cancellation point; in case of cancellation, the join does _not_
+ * occur.
+ *
* @param handle thread handle
* @param p_result [OUT] pointer to write the thread return value or NULL
* @return 0 on success, a standard error code otherwise.
*/
-int vlc_join (vlc_thread_t handle, void **result)
+void vlc_join (vlc_thread_t handle, void **result)
{
#if defined( LIBVLC_USE_PTHREAD )
- return pthread_join (handle, result);
+ int val = pthread_join (handle, result);
+ if (val)
+ vlc_thread_fatal ("joining thread", val, __func__, __FILE__, __LINE__);
#elif defined( UNDER_CE ) || defined( WIN32 )
- WaitForSingleObject (handle->handle, INFINITE);
+ do
+ vlc_testcancel ();
+ while (WaitForSingleObjectEx (handle->handle, INFINITE, TRUE)
+ == WAIT_IO_COMPLETION);
+
CloseHandle (handle->handle);
if (result)
*result = handle->data;
free (handle);
- return 0;
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- int32_t exit_value;
- ret = (B_OK == wait_for_thread( p_priv->thread_id, &exit_value ));
- if( !ret && result )
- *result = (void *)exit_value;
-
- return ret;
#endif
}
void *(*func) (vlc_object_t *) = ((struct vlc_thread_boot *)data)->entry;
free (data);
-#ifndef NDEBUG
- vlc_threadvar_set (&thread_object_key, obj);
-#endif
msg_Dbg (obj, "thread started");
func (obj);
msg_Dbg (obj, "thread ended");
/*****************************************************************************
* vlc_thread_join: wait until a thread exits, inner version
*****************************************************************************/
-void __vlc_thread_join( vlc_object_t *p_this, const char * psz_file, int i_line )
+void __vlc_thread_join( vlc_object_t *p_this )
{
vlc_object_internals_t *p_priv = vlc_internals( p_this );
- int i_ret = 0;
#if defined( LIBVLC_USE_PTHREAD )
- /* Make sure we do return if we are calling vlc_thread_join()
- * from the joined thread */
- if (pthread_equal (pthread_self (), p_priv->thread_id))
- {
- msg_Warn (p_this, "joining the active thread (VLC might crash)");
- i_ret = pthread_detach (p_priv->thread_id);
- }
- else
- i_ret = vlc_join (p_priv->thread_id, NULL);
+ vlc_join (p_priv->thread_id, NULL);
#elif defined( UNDER_CE ) || defined( WIN32 )
HANDLE hThread;
DUPLICATE_SAME_ACCESS) )
{
p_priv->b_thread = false;
- i_ret = GetLastError();
- goto error;
+ return; /* We have a problem! */
}
vlc_join( p_priv->thread_id, NULL );
(double)((user_time%(60*1000000))/1000000.0) );
}
CloseHandle( hThread );
-error:
#else
- i_ret = vlc_join( p_priv->thread_id, NULL );
+ vlc_join( p_priv->thread_id, NULL );
#endif
- if( i_ret )
- {
- errno = i_ret;
- msg_Err( p_this, "thread_join(%lu) failed at %s:%d (%m)",
- (unsigned long)p_priv->thread_id, psz_file, i_line );
- }
- else
- msg_Dbg( p_this, "thread %lu joined (%s:%d)",
- (unsigned long)p_priv->thread_id, psz_file, i_line );
-
p_priv->b_thread = false;
}
vlc_cancel (priv->thread_id);
}
-typedef struct vlc_cleanup_t
-{
- struct vlc_cleanup_t *next;
- void (*proc) (void *);
- void *data;
-} vlc_cleanup_t;
-
-typedef struct vlc_cancel_t
-{
- vlc_cleanup_t *cleaners;
- bool killable;
- bool killed;
-} vlc_cancel_t;
-
void vlc_control_cancel (int cmd, ...)
{
-#ifdef LIBVLC_USE_PTHREAD
+ /* NOTE: This function only modifies thread-specific data, so there is no
+ * need to lock anything. */
+#ifdef LIBVLC_USE_PTHREAD_CANCEL
(void) cmd;
- abort();
+ assert (0);
#else
va_list ap;
- va_start (ap, cmd);
-
vlc_cancel_t *nfo = vlc_threadvar_get (&cancel_key);
if (nfo == NULL)
{
+#ifdef WIN32
+ /* Main thread - cannot be cancelled anyway */
+ return;
+#else
nfo = malloc (sizeof (*nfo));
if (nfo == NULL)
- abort ();
- nfo->cleaners = NULL;
- nfo->killed = false;
- nfo->killable = true;
+ return; /* Uho! Expect problems! */
+ *nfo = VLC_CANCEL_INIT;
+ vlc_threadvar_set (&cancel_key, nfo);
+#endif
}
+ va_start (ap, cmd);
switch (cmd)
{
case VLC_SAVE_CANCEL:
case VLC_DO_CANCEL:
nfo->killed = true;
break;
+
+ case VLC_CLEANUP_PUSH:
+ {
+ /* cleaner is a pointer to the caller stack, no need to allocate
+ * and copy anything. As a nice side effect, this cannot fail. */
+ vlc_cleanup_t *cleaner = va_arg (ap, vlc_cleanup_t *);
+ cleaner->next = nfo->cleaners;
+ nfo->cleaners = cleaner;
+ break;
+ }
+
+ case VLC_CLEANUP_POP:
+ {
+ nfo->cleaners = nfo->cleaners->next;
+ break;
+ }
}
va_end (ap);
#endif
projects / vlc / blobdiff