Skip to content

V
vlc-1.1
Commit 0774c40b authored by Rémi Denis-Courmont's avatar Rémi Denis-Courmont
Browse files
Options

Rework threading: 

 - lock/unlock/signal/wait/destroy functions cannot fail unless there is a bug,
   so have them return void rather than an unused int, and assert against bugs.
 - Fix a few corner case minor bugs.
 - Use fprintf() rather than msg_Err() to avoid infinite recursions.
parent 612a1f1d
Hide whitespace changes
Inline Side-by-side
Showing with 105 additions and 297 deletions
include/vlc_threads_funcs.h
View file @ 0774c40b
...@@ -35,25 +35,17 @@ ...@@ -35,25 +35,17 @@
/***************************************************************************** /*****************************************************************************
* Function definitions * Function definitions
*****************************************************************************/ *****************************************************************************/
VLC_EXPORT( void, vlc_threads_error, ( vlc_object_t *) );
VLC_EXPORT( int, __vlc_mutex_init, ( vlc_object_t *, vlc_mutex_t * ) ); VLC_EXPORT( int, __vlc_mutex_init, ( vlc_object_t *, vlc_mutex_t * ) );
VLC_EXPORT( int, __vlc_mutex_init_recursive, ( vlc_object_t *, vlc_mutex_t * ) ); VLC_EXPORT( int, __vlc_mutex_init_recursive, ( vlc_object_t *, vlc_mutex_t * ) );
VLC_EXPORT( int, __vlc_mutex_destroy, ( const char *, int, vlc_mutex_t * ) ); VLC_EXPORT( void, __vlc_mutex_destroy, ( const char *, int, vlc_mutex_t * ) );
VLC_EXPORT( int, __vlc_cond_init, ( vlc_object_t *, vlc_cond_t * ) ); VLC_EXPORT( int, __vlc_cond_init, ( vlc_object_t *, vlc_cond_t * ) );
VLC_EXPORT( int, __vlc_cond_destroy, ( const char *, int, vlc_cond_t * ) ); VLC_EXPORT( void, __vlc_cond_destroy, ( const char *, int, vlc_cond_t * ) );
VLC_EXPORT( int, __vlc_threadvar_create, (vlc_object_t *, vlc_threadvar_t * ) ); VLC_EXPORT( int, __vlc_threadvar_create, (vlc_object_t *, vlc_threadvar_t * ) );
VLC_EXPORT( int, __vlc_thread_create, ( vlc_object_t *, const char *, int, const char *, void * ( * ) ( void * ), int, vlc_bool_t ) ); VLC_EXPORT( int, __vlc_thread_create, ( vlc_object_t *, const char *, int, const char *, void * ( * ) ( void * ), int, vlc_bool_t ) );
VLC_EXPORT( int, __vlc_thread_set_priority, ( vlc_object_t *, const char *, int, int ) ); VLC_EXPORT( int, __vlc_thread_set_priority, ( vlc_object_t *, const char *, int, int ) );
VLC_EXPORT( void, __vlc_thread_ready, ( vlc_object_t * ) ); VLC_EXPORT( void, __vlc_thread_ready, ( vlc_object_t * ) );
VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, const char *, int ) ); VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, const char *, int ) );
/*****************************************************************************
* vlc_threads_error: Signalize an error in the threading system
*****************************************************************************/
#ifdef NDEBUG
# define vlc_threads_error( P_THIS ) (void)0
#endif
/***************************************************************************** /*****************************************************************************
* vlc_threads_init: initialize threads system * vlc_threads_init: initialize threads system
*****************************************************************************/ *****************************************************************************/
...@@ -85,71 +77,37 @@ VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, const char *, int ) ); ...@@ -85,71 +77,37 @@ VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, const char *, int ) );
__vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX ) __vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
#if defined(LIBVLC_USE_PTHREAD) #if defined(LIBVLC_USE_PTHREAD)
static inline unsigned long int CAST_PTHREAD_TO_INT (pthread_t th) VLC_EXPORT(void, vlc_pthread_fatal, (const char *action, int error, const char *file, unsigned line));
{
union { pthread_t th; unsigned long int i; } v = { }; # define VLC_THREAD_ASSERT( action ) \
v.th = th; if (val) \
return v.i; vlc_pthread_fatal (action, val, psz_file, i_line)
} #else
# define VLC_THREAD_ASSERT (void)0
#endif #endif
static inline int __vlc_mutex_lock( const char * psz_file, int i_line, static inline void __vlc_mutex_lock( const char * psz_file, int i_line,
vlc_mutex_t * p_mutex ) vlc_mutex_t * p_mutex )
{ {
int i_result;
/* In case of error : */
unsigned long int i_thread = 0;
#if defined( UNDER_CE ) #if defined( UNDER_CE )
EnterCriticalSection( &p_mutex->csection ); EnterCriticalSection( &p_mutex->csection );
i_result = 0;
#elif defined( WIN32 ) #elif defined( WIN32 )
if( p_mutex->mutex ) if( p_mutex->mutex )
{
WaitForSingleObject( p_mutex->mutex, INFINITE ); WaitForSingleObject( p_mutex->mutex, INFINITE );
}
else else
{
EnterCriticalSection( &p_mutex->csection ); EnterCriticalSection( &p_mutex->csection );
}
i_result = 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H ) #elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_mutex == NULL ) acquire_sem( p_mutex->lock );
{
i_result = B_BAD_VALUE;
}
else if( p_mutex->init < 2000 )
{
i_result = B_NO_INIT;
}
else
{
i_result = acquire_sem( p_mutex->lock );
}
#elif defined(LIBVLC_USE_PTHREAD) #elif defined(LIBVLC_USE_PTHREAD)
# define vlc_assert_locked( m ) \ # define vlc_assert_locked( m ) \
assert (pthread_mutex_lock (&((m)->mutex)) == EDEADLK) assert (pthread_mutex_lock (&((m)->mutex)) == EDEADLK)
int val = pthread_mutex_lock( &p_mutex->mutex );
i_result = pthread_mutex_lock( &p_mutex->mutex ); VLC_THREAD_ASSERT ("locking mutex");
if ( i_result )
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
errno = i_result;
}
#endif #endif
if( i_result )
{
msg_Err( p_mutex->p_this,
"thread %li: mutex_lock failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
vlc_threads_error( p_mutex->p_this );
}
return i_result;
} }
#ifndef vlc_assert_locked #ifndef vlc_assert_locked
...@@ -162,62 +120,26 @@ static inline int __vlc_mutex_lock( const char * psz_file, int i_line, ...@@ -162,62 +120,26 @@ static inline int __vlc_mutex_lock( const char * psz_file, int i_line,
#define vlc_mutex_unlock( P_MUTEX ) \ #define vlc_mutex_unlock( P_MUTEX ) \
__vlc_mutex_unlock( __FILE__, __LINE__, P_MUTEX ) __vlc_mutex_unlock( __FILE__, __LINE__, P_MUTEX )
static inline int __vlc_mutex_unlock( const char * psz_file, int i_line, static inline void __vlc_mutex_unlock( const char * psz_file, int i_line,
vlc_mutex_t *p_mutex ) vlc_mutex_t *p_mutex )
{ {
int i_result;
/* In case of error : */
unsigned long int i_thread = 0;
#if defined( UNDER_CE ) #if defined( UNDER_CE )
LeaveCriticalSection( &p_mutex->csection ); LeaveCriticalSection( &p_mutex->csection );
i_result = 0;
#elif defined( WIN32 ) #elif defined( WIN32 )
if( p_mutex->mutex ) if( p_mutex->mutex )
{
ReleaseMutex( p_mutex->mutex ); ReleaseMutex( p_mutex->mutex );
}
else else
{
LeaveCriticalSection( &p_mutex->csection ); LeaveCriticalSection( &p_mutex->csection );
}
i_result = 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H ) #elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_mutex == NULL ) release_sem( p_mutex->lock );
{
i_result = B_BAD_VALUE;
}
else if( p_mutex->init < 2000 )
{
i_result = B_NO_INIT;
}
else
{
release_sem( p_mutex->lock );
return B_OK;
}
#elif defined(LIBVLC_USE_PTHREAD) #elif defined(LIBVLC_USE_PTHREAD)
i_result = pthread_mutex_unlock( &p_mutex->mutex ); int val = pthread_mutex_unlock( &p_mutex->mutex );
if ( i_result ) VLC_THREAD_ASSERT ("unlocking mutex");
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
errno = i_result;
}
#endif #endif
if( i_result )
{
msg_Err( p_mutex->p_this,
"thread %li: mutex_unlock failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
vlc_threads_error( p_mutex->p_this );
}
return i_result;
} }
/***************************************************************************** /*****************************************************************************
...@@ -238,16 +160,11 @@ static inline int __vlc_mutex_unlock( const char * psz_file, int i_line, ...@@ -238,16 +160,11 @@ static inline int __vlc_mutex_unlock( const char * psz_file, int i_line,
#define vlc_cond_signal( P_COND ) \ #define vlc_cond_signal( P_COND ) \
__vlc_cond_signal( __FILE__, __LINE__, P_COND ) __vlc_cond_signal( __FILE__, __LINE__, P_COND )
static inline int __vlc_cond_signal( const char * psz_file, int i_line, static inline void __vlc_cond_signal( const char * psz_file, int i_line,
vlc_cond_t *p_condvar ) vlc_cond_t *p_condvar )
{ {
int i_result;
/* In case of error : */
unsigned long int i_thread = 0;
#if defined( UNDER_CE ) #if defined( UNDER_CE )
PulseEvent( p_condvar->event ); PulseEvent( p_condvar->event );
i_result = 0;
#elif defined( WIN32 ) #elif defined( WIN32 )
/* Release one waiting thread if one is available. */ /* Release one waiting thread if one is available. */
...@@ -255,11 +172,9 @@ static inline int __vlc_cond_signal( const char * psz_file, int i_line, ...@@ -255,11 +172,9 @@ static inline int __vlc_cond_signal( const char * psz_file, int i_line,
* by a mutex. This will prevent another thread from stealing the signal */ * by a mutex. This will prevent another thread from stealing the signal */
if( !p_condvar->semaphore ) if( !p_condvar->semaphore )
{ {
/* /* PulseEvent() only works if none of the waiting threads is suspended.
** PulseEvent() only works if none of the waiting threads is suspended. * This is particularily problematic under a debug session.
** this is particularily problematic under a debug session. * as documented in http://support.microsoft.com/kb/q173260/ */
** as documented in http://support.microsoft.com/kb/q173260/
*/
PulseEvent( p_condvar->event ); PulseEvent( p_condvar->event );
} }
else if( p_condvar->i_win9x_cv == 1 ) else if( p_condvar->i_win9x_cv == 1 )
...@@ -293,64 +208,34 @@ static inline int __vlc_cond_signal( const char * psz_file, int i_line, ...@@ -293,64 +208,34 @@ static inline int __vlc_cond_signal( const char * psz_file, int i_line,
WaitForSingleObject( p_condvar->event, INFINITE ); WaitForSingleObject( p_condvar->event, INFINITE );
} }
} }
i_result = 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H ) #elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_condvar == NULL ) while( p_condvar->thread != -1 )
{ {
i_result = B_BAD_VALUE; thread_info info;
} if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE )
else if( p_condvar->init < 2000 ) return;
{
i_result = B_NO_INIT; if( info.state != B_THREAD_SUSPENDED )
}
else
{
while( p_condvar->thread != -1 )
{ {
thread_info info; /* The waiting thread is not suspended so it could
if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE ) * have been interrupted beetwen the unlock and the
{ * suspend_thread line. That is why we sleep a little
return 0; * before retesting p_condver->thread. */
} snooze( 10000 );
}
if( info.state != B_THREAD_SUSPENDED ) else
{ {
/* The waiting thread is not suspended so it could /* Ok, we have to wake up that thread */
* have been interrupted beetwen the unlock and the resume_thread( p_condvar->thread );
* suspend_thread line. That is why we sleep a little
* before retesting p_condver->thread. */
snooze( 10000 );
}
else
{
/* Ok, we have to wake up that thread */
resume_thread( p_condvar->thread );
return 0;
}
} }
i_result = 0;
} }
#elif defined(LIBVLC_USE_PTHREAD) #elif defined(LIBVLC_USE_PTHREAD)
i_result = pthread_cond_signal( &p_condvar->cond ); int val = pthread_cond_signal( &p_condvar->cond );
if ( i_result ) VLC_THREAD_ASSERT ("signaling condition variable");
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
errno = i_result;
}
#endif #endif
if( i_result )
{
msg_Err( p_condvar->p_this,
"thread %li: cond_signal failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
vlc_threads_error( p_condvar->p_this );
}
return i_result;
} }
/***************************************************************************** /*****************************************************************************
...@@ -359,13 +244,9 @@ static inline int __vlc_cond_signal( const char * psz_file, int i_line, ...@@ -359,13 +244,9 @@ static inline int __vlc_cond_signal( const char * psz_file, int i_line,
#define vlc_cond_wait( P_COND, P_MUTEX ) \ #define vlc_cond_wait( P_COND, P_MUTEX ) \
__vlc_cond_wait( __FILE__, __LINE__, P_COND, P_MUTEX ) __vlc_cond_wait( __FILE__, __LINE__, P_COND, P_MUTEX )
static inline int __vlc_cond_wait( const char * psz_file, int i_line, static inline void __vlc_cond_wait( const char * psz_file, int i_line,
vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex ) vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex )
{ {
int i_result;
/* In case of error : */
unsigned long int i_thread = 0;
#if defined( UNDER_CE ) #if defined( UNDER_CE )
p_condvar->i_waiting_threads++; p_condvar->i_waiting_threads++;
LeaveCriticalSection( &p_mutex->csection ); LeaveCriticalSection( &p_mutex->csection );
...@@ -375,8 +256,6 @@ static inline int __vlc_cond_wait( const char * psz_file, int i_line, ...@@ -375,8 +256,6 @@ static inline int __vlc_cond_wait( const char * psz_file, int i_line,
/* Reacquire the mutex before returning. */ /* Reacquire the mutex before returning. */
vlc_mutex_lock( p_mutex ); vlc_mutex_lock( p_mutex );
i_result = 0;
#elif defined( WIN32 ) #elif defined( WIN32 )
if( !p_condvar->semaphore ) if( !p_condvar->semaphore )
{ {
...@@ -451,22 +330,7 @@ static inline int __vlc_cond_wait( const char * psz_file, int i_line, ...@@ -451,22 +330,7 @@ static inline int __vlc_cond_wait( const char * psz_file, int i_line,
/* Reacquire the mutex before returning. */ /* Reacquire the mutex before returning. */
vlc_mutex_lock( p_mutex ); vlc_mutex_lock( p_mutex );
i_result = 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H ) #elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_condvar == NULL )
{
i_result = B_BAD_VALUE;
}
else if( p_mutex == NULL )
{
i_result = B_BAD_VALUE;
}
else if( p_condvar->init < 2000 )
{
i_result = B_NO_INIT;
}
/* The p_condvar->thread var is initialized before the unlock because /* The p_condvar->thread var is initialized before the unlock because
* it enables to identify when the thread is interrupted beetwen the * it enables to identify when the thread is interrupted beetwen the
* unlock line and the suspend_thread line */ * unlock line and the suspend_thread line */
...@@ -476,27 +340,12 @@ static inline int __vlc_cond_wait( const char * psz_file, int i_line, ...@@ -476,27 +340,12 @@ static inline int __vlc_cond_wait( const char * psz_file, int i_line,
p_condvar->thread = -1; p_condvar->thread = -1;
vlc_mutex_lock( p_mutex ); vlc_mutex_lock( p_mutex );
i_result = 0;
#elif defined(LIBVLC_USE_PTHREAD) #elif defined(LIBVLC_USE_PTHREAD)
i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex ); int val = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex );
if ( i_result ) VLC_THREAD_ASSERT ("waiting on condition");
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
errno = i_result;
}
#endif #endif
if( i_result )
{
msg_Err( p_condvar->p_this,
"thread %li: cond_wait failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
vlc_threads_error( p_condvar->p_this );
}
return i_result;
} }
...@@ -513,9 +362,6 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line, ...@@ -513,9 +362,6 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
vlc_mutex_t *p_mutex, vlc_mutex_t *p_mutex,
mtime_t deadline ) mtime_t deadline )
{ {
int i_res;
unsigned long int i_thread = 0;
#if defined( UNDER_CE ) #if defined( UNDER_CE )
mtime_t delay_ms = (deadline - mdate())/1000; mtime_t delay_ms = (deadline - mdate())/1000;
...@@ -531,9 +377,8 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line, ...@@ -531,9 +377,8 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
/* Reacquire the mutex before returning. */ /* Reacquire the mutex before returning. */
vlc_mutex_lock( p_mutex ); vlc_mutex_lock( p_mutex );
i_res = (int)result;
if(result == WAIT_TIMEOUT) if(result == WAIT_TIMEOUT)
return WAIT_TIMEOUT; /* this error is perfectly normal */ return ETIMEDOUT; /* this error is perfectly normal */
#elif defined( WIN32 ) #elif defined( WIN32 )
DWORD result; DWORD result;
...@@ -623,37 +468,23 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line, ...@@ -623,37 +468,23 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
/* Reacquire the mutex before returning. */ /* Reacquire the mutex before returning. */
vlc_mutex_lock( p_mutex ); vlc_mutex_lock( p_mutex );
if(result == WAIT_TIMEOUT) if(result == WAIT_TIMEOUT)
return WAIT_TIMEOUT; /* this error is perfectly normal */ return ETIMEDOUT; /* this error is perfectly normal */
i_res = (int)result;
#elif defined( HAVE_KERNEL_SCHEDULER_H ) #elif defined( HAVE_KERNEL_SCHEDULER_H )
# error Unimplemented # error Unimplemented
#elif defined(LIBVLC_USE_PTHREAD) #elif defined(LIBVLC_USE_PTHREAD)
lldiv_t d = lldiv( deadline, 1000000 ); lldiv_t d = lldiv( deadline, 1000000 );
struct timespec ts = { d.quot, d.rem * 1000 }; struct timespec ts = { d.quot, d.rem * 1000 };
i_res = pthread_cond_timedwait( &p_condvar->cond, &p_mutex->mutex, &ts ); int val = pthread_cond_timedwait (&p_condvar->cond, &p_mutex->mutex, &ts);
if( i_res == ETIMEDOUT ) if (val == ETIMEDOUT)
return ETIMEDOUT; /* this error is perfectly normal */ return ETIMEDOUT; /* this error is perfectly normal */
else VLC_THREAD_ASSERT ("timed-waiting on condition");
if ( i_res ) /* other errors = bug */
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
errno = i_res;
}
#endif #endif
if( i_res ) return 0;
{
msg_Err( p_condvar->p_this,
"thread %li: cond_wait failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_res );
vlc_threads_error( p_condvar->p_this );
}
return i_res;
} }
/***************************************************************************** /*****************************************************************************
...@@ -726,25 +557,28 @@ static inline int vlc_spin_init (vlc_spinlock_t *spin) ...@@ -726,25 +557,28 @@ static inline int vlc_spin_init (vlc_spinlock_t *spin)
/** /**
* Acquires a spinlock. * Acquires a spinlock.
*/ */
static inline int vlc_spin_lock (vlc_spinlock_t *spin) static inline void vlc_spin_lock (vlc_spinlock_t *spin)
{ {
return pthread_spin_lock (&spin->spin); int val = pthread_spin_lock (&spin->spin);
assert (val == 0);
} }
/** /**
* Releases a spinlock. * Releases a spinlock.
*/ */
static inline int vlc_spin_unlock (vlc_spinlock_t *spin) static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
{ {
return pthread_spin_unlock (&spin->spin); int val = pthread_spin_unlock (&spin->spin);
assert (val == 0);
} }
/** /**
* Deinitializes a spinlock. * Deinitializes a spinlock.
*/ */
static inline int vlc_spin_destroy (vlc_spinlock_t *spin) static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
{ {
return pthread_spin_destroy (&spin->spin); int val = pthread_spin_destroy (&spin->spin);
assert (val == 0);
} }
#elif defined( WIN32 ) #elif defined( WIN32 )
...@@ -762,25 +596,23 @@ static inline int vlc_spin_init (vlc_spinlock_t *spin) ...@@ -762,25 +596,23 @@ static inline int vlc_spin_init (vlc_spinlock_t *spin)
/** /**
* Acquires a spinlock. * Acquires a spinlock.
*/ */
static inline int vlc_spin_lock (vlc_spinlock_t *spin) static inline void vlc_spin_lock (vlc_spinlock_t *spin)
{ {
EnterCriticalSection(spin); EnterCriticalSection(spin);
return 0;
} }
/** /**
* Releases a spinlock. * Releases a spinlock.
*/ */
static inline int vlc_spin_unlock (vlc_spinlock_t *spin) static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
{ {
LeaveCriticalSection(spin); LeaveCriticalSection(spin);
return 0;
} }
/** /**
* Deinitializes a spinlock. * Deinitializes a spinlock.
*/ */
static inline int vlc_spin_destroy (vlc_spinlock_t *spin) static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
{ {
DeleteCriticalSection(spin); DeleteCriticalSection(spin);
return 0; return 0;
...@@ -789,7 +621,6 @@ static inline int vlc_spin_destroy (vlc_spinlock_t *spin) ...@@ -789,7 +621,6 @@ static inline int vlc_spin_destroy (vlc_spinlock_t *spin)
#else #else
/* Fallback to plain mutexes if spinlocks are not available */ /* Fallback to plain mutexes if spinlocks are not available */
typedef vlc_mutex_t vlc_spinlock_t; typedef vlc_mutex_t vlc_spinlock_t;
......
src/libvlc.sym
View file @ 0774c40b
...@@ -432,6 +432,7 @@ __vlc_object_waitpipe ...@@ -432,6 +432,7 @@ __vlc_object_waitpipe
__vlc_object_yield __vlc_object_yield
vlc_opendir vlc_opendir
vlc_parse_cmdline vlc_parse_cmdline
vlc_pthread_fatal
vlc_rand_bytes vlc_rand_bytes
vlc_readdir vlc_readdir
vlc_scandir vlc_scandir
...@@ -448,7 +449,6 @@ vlc_submodule_create ...@@ -448,7 +449,6 @@ vlc_submodule_create
__vlc_thread_create __vlc_thread_create
__vlc_thread_join __vlc_thread_join
__vlc_thread_ready __vlc_thread_ready
vlc_threads_error
__vlc_thread_set_priority __vlc_thread_set_priority
__vlc_threadvar_create __vlc_threadvar_create
vlc_ureduce vlc_ureduce
......
src/misc/threads.c
View file @ 0774c40b
...@@ -78,20 +78,40 @@ static pthread_mutex_t once_mutex = PTHREAD_MUTEX_INITIALIZER; ...@@ -78,20 +78,40 @@ static pthread_mutex_t once_mutex = PTHREAD_MUTEX_INITIALIZER;
vlc_threadvar_t msg_context_global_key; vlc_threadvar_t msg_context_global_key;
#ifndef NDEBUG #if defined(LIBVLC_USE_PTHREAD)
static inline unsigned long vlc_threadid (void)
{
union { pthread_t th; unsigned long int i; } v = { };
v.th = pthread_self ();
return v.i;
}
/***************************************************************************** /*****************************************************************************
* vlc_threads_error: Report an error from the threading mecanism * vlc_thread_fatal: Report an error from the threading layer
***************************************************************************** *****************************************************************************
* This is especially useful to debug those errors, as this is a nice symbol * This is mostly meant for debugging.
* on which you can break.
*****************************************************************************/ *****************************************************************************/
void vlc_threads_error( vlc_object_t *p_this ) void vlc_pthread_fatal (const char *action, int error,
const char *file, unsigned line)
{ {
msg_Err( p_this, "Error detected. Put a breakpoint in '%s' to debug.", char buf[1000];
__func__ ); const char *msg;
fprintf (stderr, "LibVLC fatal error %s in thread %lu at %s:%u: %d\n",
action, vlc_threadid (), file, line, error);
fflush (stderr);
/* Sometimes strerror_r() crashes too, so make sure we print an error
* message before we invoke it */
msg = strerror_r (error, buf, sizeof (buf));
fprintf (stderr, " %s\n", msg ? msg : "(null)");
fflush (stderr);
abort ();
} }
#endif #endif
/***************************************************************************** /*****************************************************************************
* vlc_threads_init: initialize threads system * vlc_threads_init: initialize threads system
***************************************************************************** *****************************************************************************
...@@ -309,6 +329,8 @@ int __vlc_mutex_init( vlc_object_t *p_this, vlc_mutex_t *p_mutex ) ...@@ -309,6 +329,8 @@ int __vlc_mutex_init( vlc_object_t *p_this, vlc_mutex_t *p_mutex )
*****************************************************************************/ *****************************************************************************/
int __vlc_mutex_init_recursive( vlc_object_t *p_this, vlc_mutex_t *p_mutex ) int __vlc_mutex_init_recursive( vlc_object_t *p_this, vlc_mutex_t *p_mutex )
{ {
p_mutex->p_this = p_this;
#if defined( WIN32 ) #if defined( WIN32 )
/* Create mutex returns a recursive mutex */ /* Create mutex returns a recursive mutex */
p_mutex->mutex = CreateMutex( 0, FALSE, 0 ); p_mutex->mutex = CreateMutex( 0, FALSE, 0 );
...@@ -341,54 +363,28 @@ int __vlc_mutex_init_recursive( vlc_object_t *p_this, vlc_mutex_t *p_mutex ) ...@@ -341,54 +363,28 @@ int __vlc_mutex_init_recursive( vlc_object_t *p_this, vlc_mutex_t *p_mutex )
/***************************************************************************** /*****************************************************************************
* vlc_mutex_destroy: destroy a mutex, inner version * vlc_mutex_destroy: destroy a mutex, inner version
*****************************************************************************/ *****************************************************************************/
int __vlc_mutex_destroy( const char * psz_file, int i_line, vlc_mutex_t *p_mutex ) void __vlc_mutex_destroy( const char * psz_file, int i_line, vlc_mutex_t *p_mutex )
{ {
int i_result;
/* In case of error : */
int i_thread = -1;
#if defined( UNDER_CE ) #if defined( UNDER_CE )
DeleteCriticalSection( &p_mutex->csection ); DeleteCriticalSection( &p_mutex->csection );
return 0;
#elif defined( WIN32 ) #elif defined( WIN32 )
if( p_mutex->mutex ) if( p_mutex->mutex )
{
CloseHandle( p_mutex->mutex ); CloseHandle( p_mutex->mutex );
}
else else
{
DeleteCriticalSection( &p_mutex->csection ); DeleteCriticalSection( &p_mutex->csection );
}
return 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H ) #elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_mutex->init == 9999 ) if( p_mutex->init == 9999 )
{
delete_sem( p_mutex->lock ); delete_sem( p_mutex->lock );
}
p_mutex->init = 0; p_mutex->init = 0;
return B_OK;
#elif defined( LIBVLC_USE_PTHREAD ) #elif defined( LIBVLC_USE_PTHREAD )
i_result = pthread_mutex_destroy( &p_mutex->mutex ); int val = pthread_mutex_destroy( &p_mutex->mutex );
if( i_result ) VLC_THREAD_ASSERT ("destroying mutex");
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
errno = i_result;
}
#endif #endif
if( i_result )
{
msg_Err( p_mutex->p_this,
"thread %d: mutex_destroy failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
vlc_threads_error( p_mutex->p_this );
}
return i_result;
} }
/***************************************************************************** /*****************************************************************************
...@@ -490,47 +486,31 @@ int __vlc_cond_init( vlc_object_t *p_this, vlc_cond_t *p_condvar ) ...@@ -490,47 +486,31 @@ int __vlc_cond_init( vlc_object_t *p_this, vlc_cond_t *p_condvar )
/***************************************************************************** /*****************************************************************************
* vlc_cond_destroy: destroy a condition, inner version * vlc_cond_destroy: destroy a condition, inner version
*****************************************************************************/ *****************************************************************************/
int __vlc_cond_destroy( const char * psz_file, int i_line, vlc_cond_t *p_condvar ) void __vlc_cond_destroy( const char * psz_file, int i_line, vlc_cond_t *p_condvar )
{ {
int i_result;
/* In case of error : */
int i_thread = -1;
#if defined( UNDER_CE ) #if defined( UNDER_CE )
i_result = !CloseHandle( p_condvar->event ); CloseHandle( p_condvar->event );
#elif defined( WIN32 ) #elif defined( WIN32 )
if( !p_condvar->semaphore ) if( !p_condvar->semaphore )
i_result = !CloseHandle( p_condvar->event ); CloseHandle( p_condvar->event );
else else
i_result = !CloseHandle( p_condvar->event ) {
|| !CloseHandle( p_condvar->semaphore ); CloseHandle( p_condvar->event );
CloseHandle( p_condvar->semaphore );
}
if( p_condvar->semaphore != NULL ) if( p_condvar->semaphore != NULL )
DeleteCriticalSection( &p_condvar->csection ); DeleteCriticalSection( &p_condvar->csection );
#elif defined( HAVE_KERNEL_SCHEDULER_H ) #elif defined( HAVE_KERNEL_SCHEDULER_H )
p_condvar->init = 0; p_condvar->init = 0;
return 0;
#elif defined( LIBVLC_USE_PTHREAD ) #elif defined( LIBVLC_USE_PTHREAD )
i_result = pthread_cond_destroy( &p_condvar->cond ); int val = pthread_cond_destroy( &p_condvar->cond );
if( i_result ) VLC_THREAD_ASSERT ("destroying condition");
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
errno = i_result;
}
#endif #endif
if( i_result )
{
msg_Err( p_condvar->p_this,
"thread %d: cond_destroy failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
vlc_threads_error( p_condvar->p_this );
}
return i_result;
} }
/***************************************************************************** /*****************************************************************************
...@@ -681,7 +661,6 @@ int __vlc_thread_create( vlc_object_t *p_this, const char * psz_file, int i_line ...@@ -681,7 +661,6 @@ int __vlc_thread_create( vlc_object_t *p_this, const char * psz_file, int i_line
errno = i_ret; errno = i_ret;
msg_Err( p_this, "%s thread could not be created at %s:%d (%m)", msg_Err( p_this, "%s thread could not be created at %s:%d (%m)",
psz_name, psz_file, i_line ); psz_name, psz_file, i_line );
vlc_threads_error( p_this );
vlc_mutex_unlock( &p_this->object_lock ); vlc_mutex_unlock( &p_this->object_lock );
} }
...@@ -782,7 +761,6 @@ void __vlc_thread_join( vlc_object_t *p_this, const char * psz_file, int i_line ...@@ -782,7 +761,6 @@ void __vlc_thread_join( vlc_object_t *p_this, const char * psz_file, int i_line
msg_Err( p_this, "thread_join(%u) failed at %s:%d (%s)", msg_Err( p_this, "thread_join(%u) failed at %s:%d (%s)",
(unsigned int)p_priv->thread_id.id, (unsigned int)p_priv->thread_id.id,
psz_file, i_line, GetLastError() ); psz_file, i_line, GetLastError() );
vlc_threads_error( p_this );
p_priv->b_thread = VLC_FALSE; p_priv->b_thread = VLC_FALSE;
return; return;
} }
...@@ -847,7 +825,6 @@ void __vlc_thread_join( vlc_object_t *p_this, const char * psz_file, int i_line ...@@ -847,7 +825,6 @@ void __vlc_thread_join( vlc_object_t *p_this, const char * psz_file, int i_line
errno = i_ret; errno = i_ret;
msg_Err( p_this, "thread_join(%u) failed at %s:%d (%m)", msg_Err( p_this, "thread_join(%u) failed at %s:%d (%m)",
(unsigned int)p_priv->thread_id, psz_file, i_line ); (unsigned int)p_priv->thread_id, psz_file, i_line );
vlc_threads_error( p_this );
} }
else else
{ {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment