X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fobjects.c;h=96214c14d0710889a451e8df0252bc433da03894;hb=ba8f5af2374314a1aac064c1d12a76779e0de8bc;hp=069d385bc0b36546909fadcfb58aef3abd76c37e;hpb=848663122bc0a1ce567444fdab83a630b79ea6ae;p=vlc diff --git a/src/misc/objects.c b/src/misc/objects.c index 069d385bc0..96214c14d0 100644 --- a/src/misc/objects.c +++ b/src/misc/objects.c @@ -2,7 +2,6 @@ * objects.c: vlc_object_t handling ***************************************************************************** * Copyright (C) 2004-2008 the VideoLAN team - * $Id$ * * Authors: Samuel Hocevar * @@ -34,7 +33,7 @@ # include "config.h" #endif -#include +#include #include "../libvlc.h" #include @@ -72,7 +71,6 @@ static vlc_object_t * FindObject ( vlc_object_t *, int, int ); static vlc_object_t * FindObjectName( vlc_object_t *, const char *, int ); static void PrintObject ( vlc_object_t *, const char * ); static void DumpStructure ( vlc_object_t *, int, char * ); -static int FindIndex ( vlc_object_t *, vlc_object_t **, int ); static vlc_list_t * NewList ( int ); static void ListReplace ( vlc_list_t *, vlc_object_t *, int ); @@ -83,13 +81,23 @@ static void ListChildren ( vlc_list_t *, vlc_object_t *, int ); static void vlc_object_destroy( vlc_object_t *p_this ); static void vlc_object_detach_unlocked (vlc_object_t *p_this); +#ifdef LIBVLC_REFCHECK +static vlc_threadvar_t held_objects; +typedef struct held_list_t +{ + struct held_list_t *next; + vlc_object_t *obj; +} held_list_t; +static void held_objects_destroy (void *); +#endif + /***************************************************************************** * Local structure lock *****************************************************************************/ -static vlc_mutex_t structure_lock; +static vlc_mutex_t structure_lock; -void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, - int i_type, const char *psz_type ) +void *__vlc_custom_create( vlc_object_t *p_this, size_t i_size, + int i_type, const char *psz_type ) { vlc_object_t *p_new; vlc_object_internals_t *p_priv; @@ -141,9 +149,12 @@ void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, p_new->p_libvlc = NULL; p_libvlc_global->i_counter = 0; - p_libvlc_global->i_objects = 0; - p_libvlc_global->pp_objects = NULL; + p_priv->next = p_priv->prev = p_new; vlc_mutex_init( &structure_lock ); +#ifdef LIBVLC_REFCHECK + /* TODO: use the destruction callback to track ref leaks */ + vlc_threadvar_create( &held_objects, held_objects_destroy ); +#endif } else { @@ -165,18 +176,25 @@ void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, p_new->p_private = NULL; /* Initialize mutexes and condvars */ - vlc_mutex_init( &p_new->object_lock ); - vlc_cond_init( p_new, &p_new->object_wait ); + vlc_mutex_init( &p_priv->lock ); + vlc_cond_init( p_new, &p_priv->wait ); vlc_mutex_init( &p_priv->var_lock ); vlc_spin_init( &p_priv->spin ); p_priv->pipes[0] = p_priv->pipes[1] = -1; + p_priv->next = VLC_OBJECT (p_libvlc_global); +#if !defined (LIBVLC_REFCHECK) + /* ... */ +#elif defined (LIBVLC_USE_PTHREAD) + p_priv->creator_id = pthread_self (); +#elif defined (WIN32) + p_priv->creator_id = GetCurrentThreadId (); +#endif vlc_mutex_lock( &structure_lock ); + p_priv->prev = vlc_internals (p_libvlc_global)->prev; + vlc_internals (p_libvlc_global)->prev = p_new; + vlc_internals (p_priv->prev)->next = p_new; p_new->i_object_id = p_libvlc_global->i_counter++; - /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's - * useless to try and recover anything if pp_objects gets smashed. */ - TAB_APPEND( p_libvlc_global->i_objects, p_libvlc_global->pp_objects, - p_new ); vlc_mutex_unlock( &structure_lock ); if( i_type == VLC_OBJECT_LIBVLC ) @@ -208,26 +226,10 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) switch( i_type ) { - case VLC_OBJECT_LIBVLC: - i_size = sizeof(libvlc_int_t); - psz_type = "libvlc"; - break; case VLC_OBJECT_INTF: i_size = sizeof(intf_thread_t); psz_type = "interface"; break; - case VLC_OBJECT_DIALOGS: - i_size = sizeof(intf_thread_t); - psz_type = "dialogs"; - break; - case VLC_OBJECT_DEMUX: - i_size = sizeof(demux_t); - psz_type = "demux"; - break; - case VLC_OBJECT_ACCESS: - i_size = sizeof(access_t); - psz_type = "access"; - break; case VLC_OBJECT_DECODER: i_size = sizeof(decoder_t); psz_type = "decoder"; @@ -240,22 +242,10 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) i_size = sizeof(encoder_t); psz_type = "encoder"; break; - case VLC_OBJECT_FILTER: - i_size = sizeof(filter_t); - psz_type = "filter"; - break; - case VLC_OBJECT_VOUT: - i_size = sizeof(vout_thread_t); - psz_type = "video output"; - break; case VLC_OBJECT_AOUT: i_size = sizeof(aout_instance_t); psz_type = "audio output"; break; - case VLC_OBJECT_SOUT: - i_size = sizeof(sout_instance_t); - psz_type = "stream output"; - break; case VLC_OBJECT_OPENGL: i_size = sizeof( vout_thread_t ); psz_type = "opengl"; @@ -264,13 +254,9 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) i_size = sizeof( announce_handler_t ); psz_type = "announce"; break; - case VLC_OBJECT_INTERACTION: - i_size = sizeof( interaction_t ); - psz_type = "interaction"; - break; default: - i_size = i_type > (int)sizeof(vlc_object_t) - ? i_type : (int)sizeof(vlc_object_t); + assert( i_type > 0 ); /* unknown type?! */ + i_size = i_type; i_type = VLC_OBJECT_GENERIC; psz_type = "generic"; break; @@ -315,7 +301,12 @@ static void vlc_object_destroy( vlc_object_t *p_this ) /* If we are running on a thread, wait until it ends */ if( p_priv->b_thread ) + { + msg_Warn (p_this->p_libvlc, /* do NOT use a dead object for logging! */ + "%s %d destroyed while thread alive (VLC might crash)", + p_this->psz_object_type, p_this->i_object_id); vlc_thread_join( p_this ); + } /* Call the custom "subclass" destructor */ if( p_priv->pf_destructor ) @@ -335,42 +326,41 @@ static void vlc_object_destroy( vlc_object_t *p_this ) if( p_this->p_libvlc == NULL ) { +#ifndef NDEBUG libvlc_global_data_t *p_global = (libvlc_global_data_t *)p_this; -#ifndef NDEBUG assert( p_global == vlc_global() ); /* Test for leaks */ - if( p_global->i_objects > 0 ) + if (p_priv->next != p_this) { - int i; - for( i = 0; i < p_global->i_objects; i++ ) + vlc_object_t *leaked = p_priv->next, *first = leaked; + do { /* We are leaking this object */ fprintf( stderr, "ERROR: leaking object (id:%i, type:%s, name:%s)\n", - p_global->pp_objects[i]->i_object_id, - p_global->pp_objects[i]->psz_object_type, - p_global->pp_objects[i]->psz_object_name ); - + leaked->i_object_id, leaked->psz_object_type, + leaked->psz_object_name ); /* Dump libvlc object to ease debugging */ - vlc_object_dump( p_global->pp_objects[i] ); - + vlc_object_dump( leaked ); fflush(stderr); + leaked = vlc_internals (leaked)->next; } + while (leaked != first); - /* Dump libvlc object to ease debugging */ + /* Dump global object to ease debugging */ vlc_object_dump( p_this ); - /* Strongly abort, cause we want these to be fixed */ abort(); } #endif /* We are the global object ... no need to lock. */ - free( p_global->pp_objects ); - p_global->pp_objects = NULL; - vlc_mutex_destroy( &structure_lock ); +#ifdef LIBVLC_REFCHECK + held_objects_destroy( vlc_threadvar_get( &held_objects ) ); + vlc_threadvar_delete( &held_objects ); +#endif } FREENULL( p_this->psz_object_name ); @@ -382,8 +372,8 @@ static void vlc_object_destroy( vlc_object_t *p_this ) #endif vlc_spin_destroy( &p_priv->ref_spin ); - vlc_mutex_destroy( &p_this->object_lock ); - vlc_cond_destroy( &p_this->object_wait ); + vlc_mutex_destroy( &p_priv->lock ); + vlc_cond_destroy( &p_priv->wait ); vlc_spin_destroy( &p_priv->spin ); if( p_priv->pipes[1] != -1 ) close( p_priv->pipes[1] ); @@ -398,13 +388,13 @@ static void vlc_object_destroy( vlc_object_t *p_this ) void __vlc_object_lock( vlc_object_t *obj ) { - vlc_mutex_lock( &obj->object_lock ); + vlc_mutex_lock( &(vlc_internals(obj)->lock) ); } void __vlc_object_unlock( vlc_object_t *obj ) { - vlc_assert_locked( &obj->object_lock ); - vlc_mutex_unlock( &obj->object_lock ); + vlc_assert_locked( &(vlc_internals(obj)->lock) ); + vlc_mutex_unlock( &(vlc_internals(obj)->lock) ); } #ifdef WIN32 @@ -526,78 +516,47 @@ int __vlc_object_waitpipe( vlc_object_t *obj ) /** * Waits for the object to be signaled (using vlc_object_signal()). - * If the object already has a signal pending, this function will return - * immediately. It is asserted that the caller holds the object lock. + * It is assumed that the caller has locked the object. This function will + * unlock the object, and lock it again before returning. + * If the object was signaled before the caller locked the object, it is + * undefined whether the signal will be lost or will wake the process. * * @return true if the object is dying and should terminate. */ -bool __vlc_object_wait( vlc_object_t *obj ) +void __vlc_object_wait( vlc_object_t *obj ) { - vlc_assert_locked( &obj->object_lock ); - vlc_cond_wait( &obj->object_wait, &obj->object_lock ); - return obj->b_die; + vlc_object_internals_t *priv = vlc_internals( obj ); + vlc_assert_locked( &priv->lock); + vlc_cond_wait( &priv->wait, &priv->lock ); } /** * Waits for the object to be signaled (using vlc_object_signal()), or for - * a timer to expire. - * If the object already has a signal pending, this function will return - * immediately. It is asserted that the caller holds the object lock. + * a timer to expire. It is asserted that the caller holds the object lock. * - * @return negative if the object is dying and should terminate, - * positive if the the object has been signaled but is not dying, - * 0 if timeout has been reached. + * @return 0 if the object was signaled before the timer expiration, or + * ETIMEDOUT if the timer expired without any signal. */ int __vlc_object_timedwait( vlc_object_t *obj, mtime_t deadline ) { - int v; - - vlc_assert_locked( &obj->object_lock ); - v = vlc_cond_timedwait( &obj->object_wait, &obj->object_lock, deadline ); - if( v == 0 ) /* signaled */ - return obj->b_die ? -1 : 1; - return 0; -} - - -/** - * Checks whether an object has been "killed". - * The object lock must be held. - * - * Typical code for an object thread could be: - * - vlc_object_lock (self); - ...initialization... - while (vlc_object_alive (self)) - { - ...preprocessing... - - if (vlc_object_wait (self)) - continue; - - ...postprocessing... - } - ...deinitialization... - vlc_object_unlock (self); - * - * - * @return true iff the object has not been killed yet - */ -bool __vlc_object_alive( vlc_object_t *obj ) -{ - vlc_assert_locked( &obj->object_lock ); - return !obj->b_die; + vlc_object_internals_t *priv = vlc_internals( obj ); + vlc_assert_locked( &priv->lock); + return vlc_cond_timedwait( &priv->wait, &priv->lock, deadline ); } /** * Signals an object for which the lock is held. + * At least one thread currently sleeping in vlc_object_wait() or + * vlc_object_timedwait() will wake up, assuming that there is at least one + * such thread in the first place. Otherwise, it is undefined whether the + * signal will be lost or will wake up one or more thread later. */ void __vlc_object_signal_unlocked( vlc_object_t *obj ) { - vlc_assert_locked (&obj->object_lock); - vlc_cond_signal( &obj->object_wait ); + vlc_assert_locked (&(vlc_internals(obj)->lock)); + vlc_cond_signal( &(vlc_internals(obj)->wait) ); } @@ -607,16 +566,16 @@ void __vlc_object_signal_unlocked( vlc_object_t *obj ) */ void __vlc_object_kill( vlc_object_t *p_this ) { - vlc_object_internals_t *internals = vlc_internals( p_this ); + vlc_object_internals_t *priv = vlc_internals( p_this ); int fd; - vlc_mutex_lock( &p_this->object_lock ); + vlc_object_lock( p_this ); p_this->b_die = true; - vlc_spin_lock (&internals->spin); - fd = internals->pipes[1]; - internals->pipes[1] = -1; - vlc_spin_unlock (&internals->spin); + vlc_spin_lock (&priv->spin); + fd = priv->pipes[1]; + priv->pipes[1] = -1; + vlc_spin_unlock (&priv->spin); if( fd != -1 ) { @@ -624,12 +583,9 @@ void __vlc_object_kill( vlc_object_t *p_this ) close (fd); } - if( p_this->i_object_type == VLC_OBJECT_LIBVLC ) - for( int i = 0; i < internals->i_children ; i++ ) - vlc_object_kill( internals->pp_children[i] ); - vlc_object_signal_unlocked( p_this ); - vlc_mutex_unlock( &p_this->object_lock ); + /* This also serves as a memory barrier toward vlc_object_alive(): */ + vlc_object_unlock( p_this ); } @@ -644,50 +600,37 @@ void __vlc_object_kill( vlc_object_t *p_this ) */ void * vlc_object_get( int i_id ) { - int i_max, i_middle; - vlc_object_t **pp_objects; libvlc_global_data_t *p_libvlc_global = vlc_global(); vlc_object_t *obj = NULL; +#ifndef NDEBUG + vlc_object_t *caller = vlc_threadobj (); + if (caller) + msg_Dbg (caller, "uses deprecated vlc_object_get(%d)", i_id); + else + fprintf (stderr, "main thread uses deprecated vlc_object_get(%d)\n", + i_id); +#endif vlc_mutex_lock( &structure_lock ); - pp_objects = p_libvlc_global->pp_objects; - - /* Perform our dichotomy */ - for( i_max = p_libvlc_global->i_objects - 1 ; ; ) + for( obj = vlc_internals (p_libvlc_global)->next; + obj != VLC_OBJECT (p_libvlc_global); + obj = vlc_internals (obj)->next ) { - i_middle = i_max / 2; - - if( pp_objects[i_middle]->i_object_id > i_id ) - { - i_max = i_middle; - } - else if( pp_objects[i_middle]->i_object_id < i_id ) - { - if( i_middle ) - { - pp_objects += i_middle; - i_max -= i_middle; - } - else - { - /* This happens when there are only two remaining objects */ - if( pp_objects[i_middle+1]->i_object_id == i_id ) - { - vlc_object_yield( pp_objects[i_middle+1] ); - obj = pp_objects[i_middle+1]; - } - break; - } - } - else + if( obj->i_object_id == i_id ) { - vlc_object_yield( pp_objects[i_middle] ); - obj = pp_objects[i_middle]; - break; + vlc_object_yield( obj ); + goto out; } } - + obj = NULL; +#ifndef NDEBUG + if (caller) + msg_Warn (caller, "wants non-existing object %d", i_id); + else + fprintf (stderr, "main thread wants non-existing object %d\n", i_id); +#endif +out: vlc_mutex_unlock( &structure_lock ); return obj; } @@ -710,34 +653,21 @@ void * __vlc_object_find( vlc_object_t *p_this, int i_type, int i_mode ) return p_this; } - vlc_mutex_lock( &structure_lock ); - /* Otherwise, recursively look for the object */ - if( (i_mode & 0x000f) == FIND_ANYWHERE ) + if ((i_mode & 0x000f) == FIND_ANYWHERE) { - vlc_object_t *p_root = p_this; - - /* Find the root */ - while( p_root->p_parent != NULL && - p_root != VLC_OBJECT( p_this->p_libvlc ) ) - { - p_root = p_root->p_parent; - } - - p_found = FindObject( p_root, i_type, (i_mode & ~0x000f)|FIND_CHILD ); - if( p_found == NULL && p_root != VLC_OBJECT( p_this->p_libvlc ) ) - { - p_found = FindObject( VLC_OBJECT( p_this->p_libvlc ), - i_type, (i_mode & ~0x000f)|FIND_CHILD ); - } - } - else - { - p_found = FindObject( p_this, i_type, i_mode ); +#ifndef NDEBUG + if (i_type == VLC_OBJECT_PLAYLIST) + msg_Err (p_this, "using vlc_object_find(VLC_OBJECT_PLAYLIST) " + "instead of pl_Yield()"); +#endif + return vlc_object_find (p_this->p_libvlc, i_type, + (i_mode & ~0x000f)|FIND_CHILD); } + vlc_mutex_lock( &structure_lock ); + p_found = FindObject( p_this, i_type, i_mode ); vlc_mutex_unlock( &structure_lock ); - return p_found; } @@ -807,6 +737,16 @@ void __vlc_object_yield( vlc_object_t *p_this ) /* Increment the counter */ internals->i_refcount++; vlc_spin_unlock( &internals->ref_spin ); +#ifdef LIBVLC_REFCHECK + /* Update the list of referenced objects */ + /* Using TLS, so no need to lock */ + /* The following line may leak memory if a thread leaks objects. */ + held_list_t *newhead = malloc (sizeof (*newhead)); + held_list_t *oldhead = vlc_threadvar_get (&held_objects); + newhead->next = oldhead; + newhead->obj = p_this; + vlc_threadvar_set (&held_objects, newhead); +#endif } /***************************************************************************** @@ -818,6 +758,27 @@ void __vlc_object_release( vlc_object_t *p_this ) vlc_object_internals_t *internals = vlc_internals( p_this ); bool b_should_destroy; +#ifdef LIBVLC_REFCHECK + /* Update the list of referenced objects */ + /* Using TLS, so no need to lock */ + for (held_list_t *hlcur = vlc_threadvar_get (&held_objects), + *hlprev = NULL; + hlcur != NULL; + hlprev = hlcur, hlcur = hlcur->next) + { + if (hlcur->obj == p_this) + { + if (hlprev == NULL) + vlc_threadvar_set (&held_objects, hlcur->next); + else + hlprev->next = hlcur->next; + free (hlcur); + break; + } + } + /* TODO: what if releasing without references? */ +#endif + vlc_spin_lock( &internals->ref_spin ); assert( internals->i_refcount > 0 ); @@ -842,15 +803,10 @@ void __vlc_object_release( vlc_object_t *p_this ) if( b_should_destroy ) { - /* Remove the object from the table + /* Remove the object from object list * so that it cannot be encountered by vlc_object_get() */ - libvlc_global_data_t *p_libvlc_global = vlc_global(); - int i_index; - - i_index = FindIndex( p_this, p_libvlc_global->pp_objects, - p_libvlc_global->i_objects ); - REMOVE_ELEM( p_libvlc_global->pp_objects, - p_libvlc_global->i_objects, i_index ); + vlc_internals (internals->next)->prev = internals->prev; + vlc_internals (internals->prev)->next = internals->next; /* Detach from parent to protect against FIND_CHILDREN */ vlc_object_detach_unlocked (p_this); @@ -970,7 +926,13 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) switch( i_mode & 0x000f ) { case FIND_ANYWHERE: - return vlc_list_find (vlc_global (), i_type, FIND_CHILD); + /* Modules should probably not be object, and the module should perhaps + * not be shared across LibVLC instances. In the mean time, this ugly + * hack is brought to you by Courmisch. */ + if (i_type == VLC_OBJECT_MODULE) + return vlc_list_find ((vlc_object_t *)vlc_global ()->p_module_bank, + i_type, FIND_CHILD); + return vlc_list_find (p_this->p_libvlc, i_type, FIND_CHILD); case FIND_CHILD: vlc_mutex_lock( &structure_lock ); @@ -980,6 +942,7 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) /* Check allocation was successful */ if( p_list->i_count != i_count ) { + vlc_mutex_unlock( &structure_lock ); msg_Err( p_this, "list allocation failed!" ); p_list->i_count = 0; break; @@ -1030,21 +993,18 @@ vlc_list_t *__vlc_list_children( vlc_object_t *obj ) static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, vlc_value_t oldval, vlc_value_t newval, void *p_data ) { - libvlc_global_data_t *p_libvlc_global = vlc_global(); - (void)oldval; (void)p_data; if( *psz_cmd == 'l' ) { - vlc_mutex_lock( &structure_lock ); - - vlc_object_t **pp_current, **pp_end; - - pp_current = p_libvlc_global->pp_objects; - pp_end = pp_current + p_libvlc_global->i_objects; - - for( ; pp_current < pp_end ; pp_current++ ) - PrintObject( *pp_current, "" ); + vlc_object_t *root = VLC_OBJECT (vlc_global ()), *cur = root; + vlc_mutex_lock( &structure_lock ); + do + { + PrintObject (cur, ""); + cur = vlc_internals (cur)->next; + } + while (cur != root); vlc_mutex_unlock( &structure_lock ); } else @@ -1058,25 +1018,9 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, if( end != newval.psz_string ) p_object = vlc_object_get( i_id ); else - { /* try using the object's name to find it */ - vlc_object_t *p_libvlc = vlc_object_get( 1 ); - if( p_libvlc ) - { - /* Look in p_libvlc's children tree */ - p_object = vlc_object_find_name( p_libvlc, - newval.psz_string, - FIND_CHILD ); - vlc_object_release( p_libvlc ); - } - if( !p_object ) - { - /* If it's not in libvlc, look in libvlc_global (== p_this) */ - p_object = vlc_object_find_name( p_this, - newval.psz_string, - FIND_CHILD ); - } - } + p_object = vlc_object_find_name( p_this, newval.psz_string, + FIND_ANYWHERE ); if( !p_object ) { @@ -1219,46 +1163,6 @@ void __vlc_object_dump( vlc_object_t *p_this ) /* Following functions are local */ -/***************************************************************************** - * FindIndex: find the index of an object in an array of objects - ***************************************************************************** - * This function assumes that p_this can be found in pp_objects. It will not - * crash if p_this cannot be found, but will return a wrong value. It is your - * duty to check the return value if you are not certain that the object could - * be found for sure. - *****************************************************************************/ -static int FindIndex( vlc_object_t *p_this, - vlc_object_t **pp_objects, int i_count ) -{ - int i_middle = i_count / 2; - - if( i_count == 0 ) - { - return 0; - } - - if( pp_objects[i_middle] == p_this ) - { - return i_middle; - } - - if( i_count == 1 ) - { - return 0; - } - - /* We take advantage of the sorted array */ - if( pp_objects[i_middle]->i_object_id < p_this->i_object_id ) - { - return i_middle + FindIndex( p_this, pp_objects + i_middle, - i_count - i_middle ); - } - else - { - return FindIndex( p_this, pp_objects, i_middle ); - } -} - static vlc_object_t * FindObject( vlc_object_t *p_this, int i_type, int i_mode ) { int i; @@ -1556,3 +1460,97 @@ static void ListChildren( vlc_list_t *p_list, vlc_object_t *p_this, int i_type ) ListChildren( p_list, p_tmp, i_type ); } } + +#ifdef LIBVLC_REFCHECK +# if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) +# include +# endif + +void vlc_refcheck (vlc_object_t *obj) +{ + static unsigned errors = 0; + if (errors > 100) + return; + + /* Anyone can use the root object (though it should not exist) */ + if (obj == VLC_OBJECT (vlc_global ())) + return; + + /* Anyone can use its libvlc instance object */ + if (obj == VLC_OBJECT (obj->p_libvlc)) + return; + + /* The thread that created the object holds the initial reference */ + vlc_object_internals_t *priv = vlc_internals (obj); +#if defined (LIBVLC_USE_PTHREAD) + if (pthread_equal (priv->creator_id, pthread_self ())) +#elif defined WIN32 + if (priv->creator_id == GetCurrentThreadId ()) +#else + if (0) +#endif + return; + + /* A thread can use its own object without references! */ + vlc_object_t *caller = vlc_threadobj (); + if (caller == obj) + return; +#if 0 + /* The calling thread is younger than the object. + * Access could be valid through cross-thread synchronization; + * we would need better accounting. */ + if (caller && (caller->i_object_id > obj->i_object_id)) + return; +#endif + int refs; + vlc_spin_lock (&priv->ref_spin); + refs = priv->i_refcount; + vlc_spin_unlock (&priv->ref_spin); + + for (held_list_t *hlcur = vlc_threadvar_get (&held_objects); + hlcur != NULL; hlcur = hlcur->next) + if (hlcur->obj == obj) + return; + + fprintf (stderr, "The %s %s thread object is accessing...\n" + "the %s %s object without references.\n", + caller && caller->psz_object_name + ? caller->psz_object_name : "unnamed", + caller ? caller->psz_object_type : "main", + obj->psz_object_name ? obj->psz_object_name : "unnamed", + obj->psz_object_type); + fflush (stderr); + +#ifdef HAVE_BACKTRACE + void *stack[20]; + int stackdepth = backtrace (stack, sizeof (stack) / sizeof (stack[0])); + backtrace_symbols_fd (stack, stackdepth, 2); +#endif + + if (++errors == 100) + fprintf (stderr, "Too many reference errors!\n"); +} + +static void held_objects_destroy (void *data) +{ + VLC_UNUSED( data ); + held_list_t *hl = vlc_threadvar_get (&held_objects); + vlc_object_t *caller = vlc_threadobj (); + + while (hl != NULL) + { + held_list_t *buf = hl->next; + vlc_object_t *obj = hl->obj; + + fprintf (stderr, "The %s %s thread object leaked a reference to...\n" + "the %s %s object.\n", + caller && caller->psz_object_name + ? caller->psz_object_name : "unnamed", + caller ? caller->psz_object_type : "main", + obj->psz_object_name ? obj->psz_object_name : "unnamed", + obj->psz_object_type); + free (hl); + hl = buf; + } +} +#endif