X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fobjects.c;h=03bbd6a245c7b2fed4b5d7d065c198f86f76b7b6;hb=bff9720dbec39d193e25cea5defee42da464ca92;hp=b4f3a6dfc60e4f7bacfe3cd3e93f8631ff865692;hpb=f9b646408f693e006d9df0afd3355374f0583d12;p=vlc diff --git a/src/misc/objects.c b/src/misc/objects.c index b4f3a6dfc6..03bbd6a245 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 @@ -82,11 +81,20 @@ 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_threadvar_t thread_object; void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, int i_type, const char *psz_type ) @@ -143,6 +151,10 @@ void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, p_libvlc_global->i_counter = 0; 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 { @@ -171,7 +183,7 @@ void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, p_priv->pipes[0] = p_priv->pipes[1] = -1; p_priv->next = VLC_OBJECT (p_libvlc_global); -#if defined (NDEBUG) +#if !defined (LIBVLC_REFCHECK) /* ... */ #elif defined (LIBVLC_USE_PTHREAD) p_priv->creator_id = pthread_self (); @@ -258,10 +270,6 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) 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"; @@ -372,6 +380,10 @@ static void vlc_object_destroy( vlc_object_t *p_this ) /* 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 ); @@ -647,6 +659,7 @@ void * vlc_object_get( 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) @@ -654,7 +667,7 @@ void * vlc_object_get( int i_id ) else fprintf (stderr, "main thread uses deprecated vlc_object_get(%d)\n", i_id); - +#endif vlc_mutex_lock( &structure_lock ); for( obj = vlc_internals (p_libvlc_global)->next; @@ -668,10 +681,12 @@ 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); +#endif out: vlc_mutex_unlock( &structure_lock ); return obj; @@ -779,6 +794,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 } /***************************************************************************** @@ -790,6 +815,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 ); @@ -859,15 +905,6 @@ void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent ) INSERT_ELEM( priv->pp_children, priv->i_children, priv->i_children, p_this ); - /* Kill the object if parent is already dead. - * Note: We should surely lock parent here, but that would - * create quite a few dead lock case. Hopefully, it - * is perfectly safe to do it that way. We only risk - * receiving kill event twice. But given current API - * it is ok. */ - if( p_this->p_parent->b_die ) - vlc_object_kill( p_this ); - vlc_mutex_unlock( &structure_lock ); } @@ -1481,7 +1518,7 @@ static void ListChildren( vlc_list_t *p_list, vlc_object_t *p_this, int i_type ) } } -#ifndef NDEBUG +#ifdef LIBVLC_REFCHECK # if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) # include # endif @@ -1511,29 +1548,29 @@ void vlc_refcheck (vlc_object_t *obj) #endif return; - /* A thread can use its own object without reference! */ + /* 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); - /* Object has more than one reference. - * The current thread could be holding a valid reference. */ - if (refs > 1) - return; + 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 in a suspicous manner.\n", + "the %s %s object without references.\n", caller && caller->psz_object_name ? caller->psz_object_name : "unnamed", caller ? caller->psz_object_type : "main", @@ -1550,4 +1587,27 @@ void vlc_refcheck (vlc_object_t *obj) 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