DirectResult
voodoo_manager_destroy( VoodooManager *manager )
{
D_MAGIC_ASSERT( manager, VoodooManager );
D_DEBUG( "Voodoo/Manager: Destroying manager at %p!\n", manager );
if (!manager->quit)
voodoo_manager_quit( manager );
/* Wait for manager threads exiting. */
direct_thread_join( manager->input.thread );
direct_thread_destroy( manager->input.thread );
direct_thread_join( manager->dispatcher );
direct_thread_destroy( manager->dispatcher );
direct_thread_join( manager->output.thread );
direct_thread_destroy( manager->output.thread );
/* Destroy conditions. */
pthread_cond_destroy( &manager->input.wait );
pthread_cond_destroy( &manager->response.wait );
pthread_cond_destroy( &manager->output.wait );
/* Destroy locks. */
pthread_mutex_destroy( &manager->instances.lock );
pthread_mutex_destroy( &manager->input.lock );
pthread_mutex_destroy( &manager->response.lock );
pthread_mutex_destroy( &manager->output.lock );
/* Release all remaining interfaces. */
direct_hash_iterate( manager->instances.local, instance_iterator, (void*) false );
direct_hash_iterate( manager->instances.local, instance_iterator, (void*) true );
direct_hash_destroy( manager->instances.local );
direct_hash_destroy( manager->instances.remote );
D_MAGIC_CLEAR( manager );
/* Deallocate manager structure. */
D_FREE( manager );
return DR_OK;
}
static void
IComaComponent_One_Destruct( IComaComponent *thiz )
{
int i;
IComaComponent_One_data *data = thiz->priv;
D_DEBUG( "%s (%p)\n", __FUNCTION__, thiz );
/* If method_func is non-NULL, we're the creator */
if (data->method_func) {
if (data->dispatch_thread) {
data->dispatch_stop = true;
OneQueue_WakeUp( &data->method_qid, 1 );
direct_thread_join( data->dispatch_thread );
direct_thread_destroy( data->dispatch_thread );
}
OneQueue_Destroy( data->method_qid );
for (i=0; i<data->num_notifications; i--)
OneQueue_Destroy( data->notifications[i].qid );
}
data->notify_stop = true;
OneQueue_WakeUp( &data->notify_qid, 1 );
if (data->notify_thread) {
direct_thread_join( data->notify_thread );
direct_thread_destroy( data->notify_thread );
}
OneQueue_Destroy( data->notify_qid );
direct_hash_iterate( data->calls, call_iterator, data );
direct_hash_destroy( data->calls );
direct_mutex_deinit( &data->calls_lock );
if (data->notifications)
D_FREE( data->notifications );
if (data->listeners)
D_FREE( data->listeners );
One_Shutdown();
DIRECT_DEALLOCATE_INTERFACE( thiz );
}
static DFBResult
x11LeavePool( CoreSurfacePool *pool,
void *pool_data,
void *pool_local )
{
x11PoolLocalData *local = pool_local;
D_DEBUG_AT( X11_Surfaces, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
pthread_mutex_destroy( &local->lock );
direct_hash_destroy( local->hash );
return DFB_OK;
}
static void
IComaComponent_Dispatcher_Destruct( IComaComponent *thiz )
{
IComaComponent_Dispatcher_data *data;
D_DEBUG( "%s (%p)\n", __FUNCTION__, thiz );
data = thiz->priv;
D_FREE( data->component_name );
D_FREE( data->coma_name );
direct_hash_destroy( data->listeners );
data->real->Release( data->real );
DIRECT_DEALLOCATE_INTERFACE( thiz );
}
DirectResult
voodoo_manager_create( int fd,
VoodooClient *client,
VoodooServer *server,
VoodooManager **ret_manager )
{
DirectResult ret;
VoodooManager *manager;
int val;
unsigned int len;
static const int tos = IPTOS_LOWDELAY;
D_ASSERT( fd >= 0 );
D_ASSERT( (client != NULL) ^ (server != NULL) );
D_ASSERT( ret_manager != NULL );
/* Allocate manager structure. */
manager = D_CALLOC( 1, sizeof(VoodooManager) );
if (!manager) {
D_WARN( "out of memory" );
return DR_NOLOCALMEMORY;
}
D_DEBUG( "Voodoo/Manager: Creating manager at %p.\n", manager );
if (setsockopt( fd, SOL_IP, IP_TOS, &tos, sizeof(tos) ) < 0)
D_PERROR( "Voodoo/Manager: Could not set IP_TOS!\n" );
if (setsockopt( fd, SOL_TCP, TCP_NODELAY, &one, sizeof(one) ) < 0)
D_PERROR( "Voodoo/Manager: Could not set TCP_NODELAY!\n" );
DUMP_SOCKET_OPTION( SO_SNDLOWAT );
DUMP_SOCKET_OPTION( SO_RCVLOWAT );
DUMP_SOCKET_OPTION( SO_SNDBUF );
DUMP_SOCKET_OPTION( SO_RCVBUF );
/* Create the hash table for dispatcher instances. */
ret = direct_hash_create( 251, &manager->instances.local );
if (ret) {
D_FREE( manager );
return ret;
}
/* Create the hash table for requestor instances. */
ret = direct_hash_create( 251, &manager->instances.remote );
if (ret) {
direct_hash_destroy( manager->instances.local );
D_FREE( manager );
return ret;
}
/* Store file descriptor. */
manager->fd = fd;
/* Store client or server. */
manager->client = client;
manager->server = server;
/* Initialize all locks. */
direct_util_recursive_pthread_mutex_init( &manager->instances.lock );
direct_util_recursive_pthread_mutex_init( &manager->response.lock );
direct_util_recursive_pthread_mutex_init( &manager->input.lock );
direct_util_recursive_pthread_mutex_init( &manager->output.lock );
/* Initialize all wait conditions. */
pthread_cond_init( &manager->response.wait, NULL );
pthread_cond_init( &manager->input.wait, NULL );
pthread_cond_init( &manager->output.wait, NULL );
/* Set default buffer limit. */
manager->input.max = IN_BUF_MAX;
D_MAGIC_SET( manager, VoodooManager );
/* Create all threads. */
manager->dispatcher = direct_thread_create( DTT_MESSAGING, manager_dispatch_loop,
manager, "Voodoo Dispatch" );
manager->input.thread = direct_thread_create( DTT_INPUT, manager_input_loop,
manager, "Voodoo Input" );
manager->output.thread = direct_thread_create( DTT_OUTPUT, manager_output_loop,
manager, "Voodoo Output" );
/* Return the new manager. */
*ret_manager = manager;
return DR_OK;
}
