X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmisc%2Fobjects.c;h=83512eeef6bcb06a6dd1f323ad19eefd43d954b3;hb=cd133b2d01d94380ebe055d00e08dc49756a8493;hp=951c5f9896242db4b539934330c328fce87ad3d5;hpb=1cc00146619c1b99efdf8fe5128b45f14f24a731;p=vlc diff --git a/src/misc/objects.c b/src/misc/objects.c index 951c5f9896..83512eeef6 100644 --- a/src/misc/objects.c +++ b/src/misc/objects.c @@ -83,16 +83,7 @@ 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 +static void vlc_object_dump( vlc_object_t *p_this ); /***************************************************************************** * Local structure lock @@ -152,29 +143,20 @@ void *__vlc_custom_create( vlc_object_t *p_this, size_t i_size, return NULL; } - libvlc_global_data_t *p_libvlc_global; if( p_this == NULL ) { - /* Only the global root object is created out of the blue */ - p_libvlc_global = (libvlc_global_data_t *)p_new; - p_new->p_libvlc = NULL; - - object_counter = 0; /* reset */ - 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 - { - p_libvlc_global = vlc_global(); if( i_type == VLC_OBJECT_LIBVLC ) p_new->p_libvlc = (libvlc_int_t*)p_new; else - p_new->p_libvlc = p_this->p_libvlc; + { + p_new->p_libvlc = NULL; + vlc_mutex_init( &structure_lock ); + } + + p_this = p_priv->next = p_priv->prev = p_new; } + else + p_new->p_libvlc = p_this->p_libvlc; vlc_spin_init( &p_priv->ref_spin ); p_priv->i_refcount = 1; @@ -193,17 +175,10 @@ void *__vlc_custom_create( vlc_object_t *p_this, size_t i_size, 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 + p_priv->next = p_this; vlc_mutex_lock( &structure_lock ); - p_priv->prev = vlc_internals (p_libvlc_global)->prev; - vlc_internals (p_libvlc_global)->prev = p_new; + p_priv->prev = vlc_internals (p_this)->prev; + vlc_internals (p_this)->prev = p_new; vlc_internals (p_priv->prev)->next = p_new; p_new->i_object_id = object_counter++; /* fetch THEN increment */ vlc_mutex_unlock( &structure_lock ); @@ -334,43 +309,8 @@ static void vlc_object_destroy( vlc_object_t *p_this ) free( p_this->psz_header ); if( p_this->p_libvlc == NULL ) - { -#ifndef NDEBUG - libvlc_global_data_t *p_global = (libvlc_global_data_t *)p_this; - - assert( p_global == vlc_global() ); - /* Test for leaks */ - if (p_priv->next != p_this) - { - 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", - leaked->i_object_id, leaked->psz_object_type, - leaked->psz_object_name ); - /* Dump libvlc object to ease debugging */ - vlc_object_dump( leaked ); - fflush(stderr); - leaked = vlc_internals (leaked)->next; - } - while (leaked != first); - - /* 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. */ 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 ); @@ -614,27 +554,19 @@ void __vlc_object_kill( vlc_object_t *p_this ) * vlc_object_yield(), use the pointer as your reference, and call * vlc_object_release() when you're done. */ -void * vlc_object_get( int i_id ) +void * vlc_object_get( libvlc_int_t *p_anchor, int i_id ) { - 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 - { - int canc = vlc_savecancel (); - fprintf (stderr, "main thread uses deprecated vlc_object_get(%d)\n", - i_id); - vlc_restorecancel (canc); - } + int canc = vlc_savecancel (); + fprintf (stderr, "Use of deprecated vlc_object_get(%d) ", i_id); + vlc_backtrace (); + vlc_restorecancel (canc); #endif vlc_mutex_lock( &structure_lock ); - for( obj = vlc_internals (p_libvlc_global)->next; - obj != VLC_OBJECT (p_libvlc_global); + for( obj = vlc_internals (p_anchor)->next; + obj != VLC_OBJECT (p_anchor); obj = vlc_internals (obj)->next ) { if( obj->i_object_id == i_id ) @@ -645,10 +577,7 @@ void * vlc_object_get( int i_id ) } 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); + fprintf (stderr, "Object %d does not exist\n", i_id); #endif out: vlc_mutex_unlock( &structure_lock ); @@ -691,15 +620,25 @@ void * __vlc_object_find( vlc_object_t *p_this, int i_type, int i_mode ) return p_found; } +#undef vlc_object_find_name /** - **************************************************************************** - * find a named object and increment its refcount - ***************************************************************************** - * This function recursively looks for a given object name. i_mode can be one - * of FIND_PARENT, FIND_CHILD or FIND_ANYWHERE. - *****************************************************************************/ -void * __vlc_object_find_name( vlc_object_t *p_this, const char *psz_name, - int i_mode ) + * Finds a named object and increment its reference count. + * Beware that objects found in this manner can be "owned" by another thread, + * be of _any_ type, and be attached to any module (if any). With such an + * object reference, you can set or get object variables, emit log messages, + * and read write-once object parameters (i_object_id, psz_object_type, etc). + * You CANNOT cast the object to a more specific object type, and you + * definitely cannot invoke object type-specific callbacks with this. + * + * @param p_this object to search from + * @param psz_name name of the object to search for + * @param i_mode search direction: FIND_PARENT, FIND_CHILD or FIND_ANYWHERE. + * + * @return a matching object (must be released by the caller), + * or NULL on error. + */ +vlc_object_t *vlc_object_find_name( vlc_object_t *p_this, + const char *psz_name, int i_mode ) { vlc_object_t *p_found; @@ -757,16 +696,6 @@ 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 } /***************************************************************************** @@ -778,27 +707,6 @@ 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 ); @@ -823,6 +731,29 @@ void __vlc_object_release( vlc_object_t *p_this ) if( b_should_destroy ) { +#ifndef NDEBUG + if( VLC_OBJECT(p_this->p_libvlc) == p_this ) + { + /* Test for leaks */ + vlc_object_t *leaked = internals->next; + while( leaked != p_this ) + { + /* We are leaking this object */ + fprintf( stderr, + "ERROR: leaking object (id:%i, type:%s, name:%s)\n", + leaked->i_object_id, leaked->psz_object_type, + leaked->psz_object_name ); + /* Dump object to ease debugging */ + vlc_object_dump( leaked ); + fflush(stderr); + leaked = vlc_internals (leaked)->next; + } + + if( internals->next != p_this ) + /* Dump libvlc object to ease debugging */ + vlc_object_dump( p_this ); + } +#endif /* Remove the object from object list * so that it cannot be encountered by vlc_object_get() */ vlc_internals (internals->next)->prev = internals->prev; @@ -954,7 +885,7 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) * 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, + return vlc_list_find ((vlc_object_t *)p_module_bank, i_type, FIND_CHILD); return vlc_list_find (p_this->p_libvlc, i_type, FIND_CHILD); @@ -1017,10 +948,12 @@ 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_int_t *p_libvlc = p_this->p_libvlc; + (void)oldval; (void)p_data; if( *psz_cmd == 'l' ) { - vlc_object_t *root = VLC_OBJECT (vlc_global ()), *cur = root; + vlc_object_t *cur = VLC_OBJECT (p_libvlc); vlc_mutex_lock( &structure_lock ); do @@ -1028,7 +961,7 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, PrintObject (cur, ""); cur = vlc_internals (cur)->next; } - while (cur != root); + while (cur != VLC_OBJECT(p_libvlc)); vlc_mutex_unlock( &structure_lock ); } else @@ -1039,8 +972,8 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, { char *end; int i_id = strtol( newval.psz_string, &end, 0 ); - if( end != newval.psz_string ) - p_object = vlc_object_get( i_id ); + if( !*end ) + p_object = vlc_object_get( p_libvlc, i_id ); else /* try using the object's name to find it */ p_object = vlc_object_find_name( p_this, newval.psz_string, @@ -1059,7 +992,7 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1]; if( !p_object ) - p_object = p_this->p_libvlc ? VLC_OBJECT(p_this->p_libvlc) : p_this; + p_object = VLC_OBJECT(p_this->p_libvlc); psz_foo[0] = '|'; DumpStructure( p_object, 0, psz_foo ); @@ -1178,13 +1111,13 @@ void vlc_list_release( vlc_list_t *p_list ) /***************************************************************************** * dump an object. (Debug function) *****************************************************************************/ -void __vlc_object_dump( vlc_object_t *p_this ) +static void vlc_object_dump( vlc_object_t *p_this ) { - vlc_mutex_lock( &structure_lock ); char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1]; psz_foo[0] = '|'; + + vlc_assert_locked( &structure_lock ); DumpStructure( p_this, 0, psz_foo ); - vlc_mutex_unlock( &structure_lock ); } /* Following functions are local */ @@ -1488,103 +1421,3 @@ 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; - - int canc = vlc_savecancel (); - - 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"); - vlc_restorecancel (canc); -} - -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 (); - - int canc = vlc_savecancel (); - - 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; - } - vlc_restorecancel (canc); -} -#endif