X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fobjects.c;h=a108f3d42c38fe0d5b813e0695ba6d7fe6711682;hb=0adb6e3edef57a255a4c405fbecdce5f6f1dd03c;hp=33c8b32de18794d9857d309b0476be9d7911c63b;hpb=6da90a1716250d282f16dc6bc9dacec5b9514caf;p=vlc diff --git a/src/misc/objects.c b/src/misc/objects.c index 33c8b32de1..a108f3d42c 100644 --- a/src/misc/objects.c +++ b/src/misc/objects.c @@ -62,12 +62,6 @@ #endif #include -/***************************************************************************** - * Constants - *****************************************************************************/ - -const vlc_destructor_t kVLCDestructor = NULL; - /***************************************************************************** * Local prototypes *****************************************************************************/ @@ -76,11 +70,8 @@ static int DumpCommand( vlc_object_t *, char const *, static vlc_object_t * FindObject ( vlc_object_t *, int, int ); static vlc_object_t * FindObjectName( vlc_object_t *, const char *, int ); -static void DetachObject ( vlc_object_t * ); 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 void SetAttachment ( vlc_object_t *, bool ); static vlc_list_t * NewList ( int ); static void ListReplace ( vlc_list_t *, vlc_object_t *, int ); @@ -89,12 +80,13 @@ static int CountChildren ( vlc_object_t *, int ); static void ListChildren ( vlc_list_t *, vlc_object_t *, int ); static void vlc_object_destroy( vlc_object_t *p_this ); -static void vlc_object_yield_locked( vlc_object_t *p_this ); +static void vlc_object_detach_unlocked (vlc_object_t *p_this); /***************************************************************************** * Local structure lock *****************************************************************************/ -static vlc_mutex_t 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 ) @@ -125,7 +117,6 @@ void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, p_new->b_die = false; p_new->b_error = false; p_new->b_dead = false; - p_priv->b_attached = false; p_new->b_force = false; p_new->psz_header = NULL; @@ -143,47 +134,32 @@ void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, } libvlc_global_data_t *p_libvlc_global; - if( i_type == VLC_OBJECT_GLOBAL ) + if( p_this == NULL ) { - /* If i_type is global, then p_new is actually p_libvlc_global */ + /* 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; p_libvlc_global->i_counter = 0; - p_libvlc_global->i_objects = 0; - p_libvlc_global->pp_objects = NULL; - p_priv->b_attached = true; + p_priv->next = p_priv->prev = p_new; vlc_mutex_init( &structure_lock ); } else { p_libvlc_global = vlc_global(); if( i_type == VLC_OBJECT_LIBVLC ) - { p_new->p_libvlc = (libvlc_int_t*)p_new; - p_priv->b_attached = true; - } else - { p_new->p_libvlc = p_this->p_libvlc; - } } - vlc_mutex_lock( &structure_lock ); - 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 ); - + vlc_spin_init( &p_priv->ref_spin ); p_priv->i_refcount = 1; - p_priv->pf_destructor = kVLCDestructor; + p_priv->pf_destructor = NULL; p_priv->b_thread = false; p_new->p_parent = NULL; - p_new->pp_children = NULL; - p_new->i_children = 0; + p_priv->pp_children = NULL; + p_priv->i_children = 0; p_new->p_private = NULL; @@ -194,6 +170,21 @@ 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 (NDEBUG) + /* ... */ +#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++; + vlc_mutex_unlock( &structure_lock ); + if( i_type == VLC_OBJECT_LIBVLC ) { var_Create( p_new, "list", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); @@ -307,10 +298,7 @@ void __vlc_object_set_destructor( vlc_object_t *p_this, vlc_destructor_t pf_destructor ) { vlc_object_internals_t *p_priv = vlc_internals(p_this ); - - vlc_mutex_lock( &structure_lock ); p_priv->pf_destructor = pf_destructor; - vlc_mutex_unlock( &structure_lock ); } /** @@ -325,9 +313,8 @@ static void vlc_object_destroy( vlc_object_t *p_this ) { vlc_object_internals_t *p_priv = vlc_internals( p_this ); - /* Automatically detach the object from its parents */ - if( p_this->p_parent ) vlc_object_detach( p_this ); - + /* Objects are always detached beforehand */ + assert( !p_this->p_parent ); /* Send a kill to the object's thread if applicable */ vlc_object_kill( p_this ); @@ -340,33 +327,6 @@ static void vlc_object_destroy( vlc_object_t *p_this ) if( p_priv->pf_destructor ) p_priv->pf_destructor( p_this ); - /* Sanity checks */ - if( p_this->i_children ) - { - int i; - - fprintf( stderr, - "ERROR: cannot delete object (%i, %s) with %d children\n", - p_this->i_object_id, p_this->psz_object_name, - p_this->i_children ); - - for( i = 0; i < p_this->i_children; i++ ) - { - fprintf( stderr, - "ERROR: Remaining children object " - "(id:%i, type:%s, name:%s)\n", - p_this->pp_children[i]->i_object_id, - p_this->pp_children[i]->psz_object_type, - p_this->pp_children[i]->psz_object_name ); - } - fflush(stderr); - - /* Dump libvlc object to ease debugging */ - vlc_object_dump( p_this->p_libvlc ); - - abort(); - } - /* Destroy the associated variables, starting from the end so that * no memmove calls have to be done. */ while( p_priv->i_vars ) @@ -379,40 +339,38 @@ static void vlc_object_destroy( vlc_object_t *p_this ) free( p_this->psz_header ); - if( p_this->i_object_type == VLC_OBJECT_GLOBAL ) + if( p_this->p_libvlc == NULL ) { 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 ); } @@ -420,10 +378,11 @@ static void vlc_object_destroy( vlc_object_t *p_this ) #if defined(WIN32) || defined(UNDER_CE) /* if object has an associated thread, close it now */ - if( p_priv->thread_id.hThread ) - CloseHandle(p_priv->thread_id.hThread); + if( p_priv->thread_id ) + CloseHandle(p_priv->thread_id); #endif + vlc_spin_destroy( &p_priv->ref_spin ); vlc_mutex_destroy( &p_this->object_lock ); vlc_cond_destroy( &p_this->object_wait ); vlc_spin_destroy( &p_priv->spin ); @@ -568,24 +527,23 @@ 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; } /** * 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, @@ -615,8 +573,7 @@ int __vlc_object_timedwait( vlc_object_t *obj, mtime_t deadline ) { ...preprocessing... - if (vlc_object_wait (self)) - continue; + vlc_object_wait (self); ...postprocessing... } @@ -635,6 +592,10 @@ bool __vlc_object_alive( vlc_object_t *obj ) /** * 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 ) { @@ -667,8 +628,8 @@ void __vlc_object_kill( vlc_object_t *p_this ) } if( p_this->i_object_type == VLC_OBJECT_LIBVLC ) - for( int i = 0; i < p_this->i_children ; i++ ) - vlc_object_kill( p_this->pp_children[i] ); + 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 ); @@ -676,67 +637,46 @@ void __vlc_object_kill( vlc_object_t *p_this ) /** - * find an object given its ID + * Find an object given its ID. * - * This function looks for the object whose i_object_id field is i_id. We - * use a dichotomy so that lookups are in log2(n). - *****************************************************************************/ + * This function looks for the object whose i_object_id field is i_id. + * This function is slow, and often used to hide bugs. Do not use it. + * If you need to retain reference to an object, yield the object pointer with + * 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 ) { - int i_max, i_middle; - vlc_object_t **pp_objects; libvlc_global_data_t *p_libvlc_global = vlc_global(); + vlc_object_t *obj = NULL; + vlc_object_t *caller = vlc_threadobj (); - vlc_mutex_lock( &structure_lock ); + 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); - pp_objects = p_libvlc_global->pp_objects; + vlc_mutex_lock( &structure_lock ); - /* 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_internals( pp_objects[i_middle+1] )->i_refcount > 0 ) - { - vlc_object_yield_locked( pp_objects[i_middle+1] ); - vlc_mutex_unlock( &structure_lock ); - return pp_objects[i_middle+1]; - } - break; - } - } - else if( vlc_internals( pp_objects[i_middle] )->i_refcount > 0 ) + if( obj->i_object_id == i_id ) { - vlc_object_yield_locked( pp_objects[i_middle] ); - vlc_mutex_unlock( &structure_lock ); - return pp_objects[i_middle]; - } - - if( i_max == 0 ) - { - /* this means that i_max == i_middle, and since we have already - * tested pp_objects[i_middle]), p_found is properly set. */ - break; + vlc_object_yield( obj ); + goto out; } } - + obj = NULL; + 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); +out: vlc_mutex_unlock( &structure_lock ); - return NULL; + return obj; } /** @@ -750,43 +690,28 @@ void * __vlc_object_find( vlc_object_t *p_this, int i_type, int i_mode ) { vlc_object_t *p_found; - vlc_mutex_lock( &structure_lock ); - /* If we are of the requested type ourselves, don't look further */ - if( !(i_mode & FIND_STRICT) && p_this->i_object_type == i_type - && vlc_internals( p_this )->i_refcount > 0 ) + if( !(i_mode & FIND_STRICT) && p_this->i_object_type == i_type ) { - vlc_object_yield_locked( p_this ); - vlc_mutex_unlock( &structure_lock ); + vlc_object_yield( p_this ); return p_this; } /* Otherwise, recursively look for the object */ - 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 + if ((i_mode & 0x000f) == FIND_ANYWHERE) { - p_found = FindObject( p_this, i_type, i_mode ); +#ifndef NDEBUG + if (i_type == VLC_OBJECT_PLAYLIST) + msg_Warn (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; } @@ -802,22 +727,17 @@ void * __vlc_object_find_name( vlc_object_t *p_this, const char *psz_name, { vlc_object_t *p_found; - vlc_mutex_lock( &structure_lock ); - - /* Avoid obvious freed object uses */ - assert( vlc_internals( p_this )->i_refcount > 0 ); - /* If have the requested name ourselves, don't look further */ if( !(i_mode & FIND_STRICT) && p_this->psz_object_name - && !strcmp( p_this->psz_object_name, psz_name ) - && vlc_internals( p_this )->i_refcount > 0 ) + && !strcmp( p_this->psz_object_name, psz_name ) ) { - vlc_object_yield_locked( p_this ); - vlc_mutex_unlock( &structure_lock ); + vlc_object_yield( p_this ); return p_this; } + vlc_mutex_lock( &structure_lock ); + /* Otherwise, recursively look for the object */ if( (i_mode & 0x000f) == FIND_ANYWHERE ) { @@ -849,64 +769,74 @@ void * __vlc_object_find_name( vlc_object_t *p_this, const char *psz_name, } /** - **************************************************************************** - * increment an object refcount - *****************************************************************************/ - -/* When the structure_lock is locked */ -static void vlc_object_yield_locked( vlc_object_t *p_this ) + * Increment an object reference counter. + */ +void __vlc_object_yield( vlc_object_t *p_this ) { - vlc_assert_locked (&structure_lock); + vlc_object_internals_t *internals = vlc_internals( p_this ); + vlc_spin_lock( &internals->ref_spin ); /* Avoid obvious freed object uses */ - assert( vlc_internals( p_this )->i_refcount > 0 ); - + assert( internals->i_refcount > 0 ); /* Increment the counter */ - vlc_internals( p_this )->i_refcount++; + internals->i_refcount++; + vlc_spin_unlock( &internals->ref_spin ); } -/* Public function */ -void __vlc_object_yield( vlc_object_t *p_this ) -{ - vlc_mutex_lock( &structure_lock ); - vlc_object_yield_locked( p_this ); - vlc_mutex_unlock( &structure_lock ); -} - - /***************************************************************************** * decrement an object refcount * And destroy the object if its refcount reach zero. *****************************************************************************/ void __vlc_object_release( vlc_object_t *p_this ) { + vlc_object_internals_t *internals = vlc_internals( p_this ); bool b_should_destroy; - vlc_mutex_lock( &structure_lock ); + vlc_spin_lock( &internals->ref_spin ); + assert( internals->i_refcount > 0 ); - assert( vlc_internals( p_this )->i_refcount > 0 ); - vlc_internals( p_this )->i_refcount--; - b_should_destroy = (vlc_internals( p_this )->i_refcount == 0); + if( internals->i_refcount > 1 ) + { + /* Fast path */ + /* There are still other references to the object */ + internals->i_refcount--; + vlc_spin_unlock( &internals->ref_spin ); + return; + } + vlc_spin_unlock( &internals->ref_spin ); + + /* Slow path */ + /* Remember that we cannot hold the spin while waiting on the mutex */ + vlc_mutex_lock( &structure_lock ); + /* Take the spin again. Note that another thread may have yielded the + * object in the (very short) mean time. */ + vlc_spin_lock( &internals->ref_spin ); + b_should_destroy = --internals->i_refcount == 0; + vlc_spin_unlock( &internals->ref_spin ); if( b_should_destroy ) { - /* Make sure this object can't be obtained via vlc_find_object now that - * it is freed */ - libvlc_global_data_t *p_libvlc_global = vlc_global(); - int i_index; - - /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's - * useless to try and recover anything if pp_objects gets smashed. */ - 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 ); + /* Remove the object from object list + * so that it cannot be encountered by vlc_object_get() */ + 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); + /* Detach from children to protect against FIND_PARENT */ + for (int i = 0; i < internals->i_children; i++) + internals->pp_children[i]->p_parent = NULL; } vlc_mutex_unlock( &structure_lock ); if( b_should_destroy ) + { + free( internals->pp_children ); + internals->pp_children = NULL; + internals->i_children = 0; vlc_object_destroy( p_this ); + } } /** @@ -922,25 +852,67 @@ void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent ) vlc_mutex_lock( &structure_lock ); - /* Avoid obvious freed object uses */ - assert( vlc_internals( p_this )->i_refcount > 0 ); - /* Attach the parent to its child */ + assert (!p_this->p_parent); p_this->p_parent = p_parent; /* Attach the child to its parent */ - INSERT_ELEM( p_parent->pp_children, p_parent->i_children, - p_parent->i_children, p_this ); + vlc_object_internals_t *priv = vlc_internals( 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 ); +} + + +static void vlc_object_detach_unlocked (vlc_object_t *p_this) +{ + vlc_assert_locked (&structure_lock); + + if (p_this->p_parent == NULL) + return; - /* Climb up the tree to see whether we are connected with the root */ - if( vlc_internals( p_parent )->b_attached ) + vlc_object_internals_t *priv = vlc_internals( p_this->p_parent ); + + int i_index, i; + + /* Remove p_this's parent */ + p_this->p_parent = NULL; + + /* Remove all of p_parent's children which are p_this */ + for( i_index = priv->i_children ; i_index-- ; ) { - SetAttachment( p_this, true ); + if( priv->pp_children[i_index] == p_this ) + { + priv->i_children--; + for( i = i_index ; i < priv->i_children ; i++ ) + priv->pp_children[i] = priv->pp_children[i+1]; + } } - vlc_mutex_unlock( &structure_lock ); + if( priv->i_children ) + { + priv->pp_children = (vlc_object_t **)realloc( priv->pp_children, + priv->i_children * sizeof(vlc_object_t *) ); + } + else + { + /* Special case - don't realloc() to zero to avoid leaking */ + free( priv->pp_children ); + priv->pp_children = NULL; + } } + /** **************************************************************************** * detach object from its parent @@ -952,25 +924,14 @@ void __vlc_object_detach( vlc_object_t *p_this ) if( !p_this ) return; vlc_mutex_lock( &structure_lock ); - if( !p_this->p_parent ) - { msg_Err( p_this, "object is not attached" ); - vlc_mutex_unlock( &structure_lock ); - return; - } - - /* Climb up the tree to see whether we are connected with the root */ - if( vlc_internals( p_this->p_parent )->b_attached ) - { - SetAttachment( p_this, false ); - } - - DetachObject( p_this ); + else + vlc_object_detach_unlocked( p_this ); vlc_mutex_unlock( &structure_lock ); - p_this = NULL; } + /** **************************************************************************** * find a list typed objects and increment their refcount @@ -981,49 +942,29 @@ void __vlc_object_detach( vlc_object_t *p_this ) vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) { vlc_list_t *p_list; - vlc_object_t **pp_current, **pp_end; - int i_count = 0, i_index = 0; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - vlc_mutex_lock( &structure_lock ); + int i_count = 0; /* Look for the objects */ switch( i_mode & 0x000f ) { case FIND_ANYWHERE: - pp_current = p_libvlc_global->pp_objects; - pp_end = pp_current + p_libvlc_global->i_objects; - - for( ; pp_current < pp_end ; pp_current++ ) - { - if( vlc_internals(*pp_current)->b_attached - && (*pp_current)->i_object_type == i_type ) - { - i_count++; - } - } - - p_list = NewList( i_count ); - pp_current = p_libvlc_global->pp_objects; - - for( ; pp_current < pp_end ; pp_current++ ) - { - if( vlc_internals(*pp_current)->b_attached - && (*pp_current)->i_object_type == i_type ) - { - ListReplace( p_list, *pp_current, i_index ); - if( i_index < i_count ) i_index++; - } - } - break; + /* 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 ); i_count = CountChildren( p_this, i_type ); p_list = NewList( i_count ); /* 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; @@ -1031,6 +972,7 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) p_list->i_count = 0; ListChildren( p_list, p_this, i_type ); + vlc_mutex_unlock( &structure_lock ); break; default: @@ -1039,11 +981,30 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) break; } - vlc_mutex_unlock( &structure_lock ); - return p_list; } +/** + * Gets the list of children of an objects, and increment their reference + * count. + * @return a list (possibly empty) or NULL in case of error. + */ +vlc_list_t *__vlc_list_children( vlc_object_t *obj ) +{ + vlc_list_t *l; + vlc_object_internals_t *priv = vlc_internals( obj ); + + vlc_mutex_lock( &structure_lock ); + l = NewList( priv->i_children ); + for (int i = 0; i < l->i_count; i++) + { + vlc_object_yield( priv->pp_children[i] ); + l->p_values[i].p_object = priv->pp_children[i]; + } + vlc_mutex_unlock( &structure_lock ); + return l; +} + /***************************************************************************** * DumpCommand: print the current vlc structure ***************************************************************************** @@ -1054,32 +1015,18 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) 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; + vlc_object_t *root = VLC_OBJECT (vlc_global ()), *cur = root; - pp_current = p_libvlc_global->pp_objects; - pp_end = pp_current + p_libvlc_global->i_objects; - - for( ; pp_current < pp_end ; pp_current++ ) + vlc_mutex_lock( &structure_lock ); + do { - if( vlc_internals(*pp_current)->b_attached ) - { - PrintObject( *pp_current, "" ); - } - else - { - printf( " o %.8i %s (not attached)\n", - (*pp_current)->i_object_id, - (*pp_current)->psz_object_type ); - } + PrintObject (cur, ""); + cur = vlc_internals (cur)->next; } - + while (cur != root); vlc_mutex_unlock( &structure_lock ); } else @@ -1093,25 +1040,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 ) { @@ -1254,46 +1185,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; @@ -1305,10 +1196,9 @@ static vlc_object_t * FindObject( vlc_object_t *p_this, int i_type, int i_mode ) p_tmp = p_this->p_parent; if( p_tmp ) { - if( p_tmp->i_object_type == i_type - && vlc_internals( p_tmp )->i_refcount > 0 ) + if( p_tmp->i_object_type == i_type ) { - vlc_object_yield_locked( p_tmp ); + vlc_object_yield( p_tmp ); return p_tmp; } else @@ -1319,16 +1209,15 @@ static vlc_object_t * FindObject( vlc_object_t *p_this, int i_type, int i_mode ) break; case FIND_CHILD: - for( i = p_this->i_children; i--; ) + for( i = vlc_internals( p_this )->i_children; i--; ) { - p_tmp = p_this->pp_children[i]; - if( p_tmp->i_object_type == i_type - && vlc_internals( p_tmp )->i_refcount > 0 ) + p_tmp = vlc_internals( p_this )->pp_children[i]; + if( p_tmp->i_object_type == i_type ) { - vlc_object_yield_locked( p_tmp ); + vlc_object_yield( p_tmp ); return p_tmp; } - else if( p_tmp->i_children ) + else if( vlc_internals( p_tmp )->i_children ) { p_tmp = FindObject( p_tmp, i_type, i_mode ); if( p_tmp ) @@ -1361,10 +1250,9 @@ static vlc_object_t * FindObjectName( vlc_object_t *p_this, if( p_tmp ) { if( p_tmp->psz_object_name - && !strcmp( p_tmp->psz_object_name, psz_name ) - && vlc_internals( p_tmp )->i_refcount > 0 ) + && !strcmp( p_tmp->psz_object_name, psz_name ) ) { - vlc_object_yield_locked( p_tmp ); + vlc_object_yield( p_tmp ); return p_tmp; } else @@ -1375,17 +1263,16 @@ static vlc_object_t * FindObjectName( vlc_object_t *p_this, break; case FIND_CHILD: - for( i = p_this->i_children; i--; ) + for( i = vlc_internals( p_this )->i_children; i--; ) { - p_tmp = p_this->pp_children[i]; + p_tmp = vlc_internals( p_this )->pp_children[i]; if( p_tmp->psz_object_name - && !strcmp( p_tmp->psz_object_name, psz_name ) - && vlc_internals( p_tmp )->i_refcount > 0 ) + && !strcmp( p_tmp->psz_object_name, psz_name ) ) { - vlc_object_yield_locked( p_tmp ); + vlc_object_yield( p_tmp ); return p_tmp; } - else if( p_tmp->i_children ) + else if( vlc_internals( p_tmp )->i_children ) { p_tmp = FindObjectName( p_tmp, psz_name, i_mode ); if( p_tmp ) @@ -1404,56 +1291,6 @@ static vlc_object_t * FindObjectName( vlc_object_t *p_this, return NULL; } -static void DetachObject( vlc_object_t *p_this ) -{ - vlc_object_t *p_parent = p_this->p_parent; - int i_index, i; - - /* Remove p_this's parent */ - p_this->p_parent = NULL; - - /* Remove all of p_parent's children which are p_this */ - for( i_index = p_parent->i_children ; i_index-- ; ) - { - if( p_parent->pp_children[i_index] == p_this ) - { - p_parent->i_children--; - for( i = i_index ; i < p_parent->i_children ; i++ ) - { - p_parent->pp_children[i] = p_parent->pp_children[i+1]; - } - } - } - - if( p_parent->i_children ) - { - p_parent->pp_children = (vlc_object_t **)realloc( p_parent->pp_children, - p_parent->i_children * sizeof(vlc_object_t *) ); - } - else - { - free( p_parent->pp_children ); - p_parent->pp_children = NULL; - } -} - -/***************************************************************************** - * SetAttachment: recursively set the b_attached flag of a subtree. - ***************************************************************************** - * This function is used by the attach and detach functions to propagate - * the b_attached flag in a subtree. - *****************************************************************************/ -static void SetAttachment( vlc_object_t *p_this, bool b_attached ) -{ - int i_index; - - for( i_index = p_this->i_children ; i_index-- ; ) - { - SetAttachment( p_this->pp_children[i_index], b_attached ); - } - - vlc_internals( p_this )->b_attached = b_attached; -} static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) { @@ -1469,7 +1306,7 @@ static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) } psz_children[0] = '\0'; - switch( p_this->i_children ) + switch( vlc_internals( p_this )->i_children ) { case 0: break; @@ -1477,7 +1314,8 @@ static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) strcpy( psz_children, ", 1 child" ); break; default: - snprintf( psz_children, 19, ", %i children", p_this->i_children ); + snprintf( psz_children, 19, ", %i children", + vlc_internals( p_this )->i_children ); break; } @@ -1488,12 +1326,8 @@ static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) psz_thread[0] = '\0'; if( vlc_internals( p_this )->b_thread ) - snprintf( psz_thread, 29, " (thread %u)", -#if defined(WIN32) || defined(UNDER_CE) - (unsigned)vlc_internals( p_this )->thread_id.id ); -#else - (unsigned)vlc_internals( p_this )->thread_id ); -#endif + snprintf( psz_thread, 29, " (thread %lu)", + (unsigned long)vlc_internals( p_this )->thread_id ); psz_parent[0] = '\0'; if( p_this->p_parent ) @@ -1521,7 +1355,7 @@ static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) return; } - for( i = 0 ; i < p_this->i_children ; i++ ) + for( i = 0 ; i < vlc_internals( p_this )->i_children ; i++ ) { if( i_level ) { @@ -1533,7 +1367,7 @@ static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) } } - if( i == p_this->i_children - 1 ) + if( i == vlc_internals( p_this )->i_children - 1 ) { psz_foo[i_level] = '`'; } @@ -1545,7 +1379,8 @@ static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) psz_foo[i_level+1] = '-'; psz_foo[i_level+2] = '\0'; - DumpStructure( p_this->pp_children[i], i_level + 2, psz_foo ); + DumpStructure( vlc_internals( p_this )->pp_children[i], i_level + 2, + psz_foo ); } } @@ -1583,7 +1418,7 @@ static void ListReplace( vlc_list_t *p_list, vlc_object_t *p_object, return; } - vlc_object_yield_locked( p_object ); + vlc_object_yield( p_object ); p_list->p_values[i_index].p_object = p_object; @@ -1605,7 +1440,7 @@ static void ListReplace( vlc_list_t *p_list, vlc_object_t *p_object, return; } - vlc_object_yield_locked( p_object ); + vlc_object_yield( p_object ); p_list->p_values[p_list->i_count].p_object = p_object; p_list->i_count++; @@ -1618,19 +1453,15 @@ static int CountChildren( vlc_object_t *p_this, int i_type ) vlc_object_t *p_tmp; int i, i_count = 0; - for( i = 0; i < p_this->i_children; i++ ) + for( i = 0; i < vlc_internals( p_this )->i_children; i++ ) { - p_tmp = p_this->pp_children[i]; + p_tmp = vlc_internals( p_this )->pp_children[i]; if( p_tmp->i_object_type == i_type ) { i_count++; } - - if( p_tmp->i_children ) - { - i_count += CountChildren( p_tmp, i_type ); - } + i_count += CountChildren( p_tmp, i_type ); } return i_count; @@ -1641,18 +1472,84 @@ static void ListChildren( vlc_list_t *p_list, vlc_object_t *p_this, int i_type ) vlc_object_t *p_tmp; int i; - for( i = 0; i < p_this->i_children; i++ ) + for( i = 0; i < vlc_internals( p_this )->i_children; i++ ) { - p_tmp = p_this->pp_children[i]; + p_tmp = vlc_internals( p_this )->pp_children[i]; if( p_tmp->i_object_type == i_type ) - { ListReplace( p_list, p_tmp, p_list->i_count++ ); - } - if( p_tmp->i_children ) - { - ListChildren( p_list, p_tmp, i_type ); - } + ListChildren( p_list, p_tmp, i_type ); } } + +#ifndef NDEBUG +# 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 reference! */ + vlc_object_t *caller = vlc_threadobj (); + if (caller == obj) + return; + + /* 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; + + 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; + + fprintf (stderr, "The %s %s thread object is accessing...\n" + "the %s %s object in a suspicous manner.\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"); +} +#endif