char *
direct_dbg_strdup( const char* file, int line, const char *func, const char *string )
{
void *mem;
unsigned long *val;
size_t bytes = string ? direct_strlen( string ) + 1 : 1;
D_DEBUG_AT( Direct_Mem, " +"_ZUn(6)" bytes [%s:%d in %s()] <- \"%30s\"\n", bytes, file, line, func, string );
if (direct_config->debugmem) {
MemDesc *desc;
mem = direct_malloc( bytes + sizeof(MemDesc) );
D_DEBUG_AT( Direct_Mem, " '-> %p\n", mem );
if (!mem)
return NULL;
desc = fill_mem_desc( mem, bytes, func, file, line, direct_trace_copy_buffer(NULL) );
direct_mutex_lock( &alloc_lock );
direct_hash_insert( &alloc_hash, (unsigned long) desc->mem, desc );
direct_mutex_unlock( &alloc_lock );
if (string)
direct_memcpy( desc->mem, string, bytes );
else
*(u8*)desc->mem = 0;
return desc->mem;
}
mem = direct_malloc( bytes + DISABLED_OFFSET );
D_DEBUG_AT( Direct_Mem, " '-> %p\n", mem );
if (!mem)
return NULL;
val = mem;
val[0] = ~0;
if (string)
direct_memcpy( (char*) mem + DISABLED_OFFSET, string, bytes );
else
*((u8*)mem + DISABLED_OFFSET) = 0;
return (char*) mem + DISABLED_OFFSET;
}
DirectResult
voodoo_manager_register_local( VoodooManager *manager,
bool super,
void *dispatcher,
void *real,
VoodooDispatch dispatch,
VoodooInstanceID *ret_instance )
{
DirectResult ret;
VoodooInstance *instance;
VoodooInstanceID instance_id;
D_MAGIC_ASSERT( manager, VoodooManager );
D_ASSERT( dispatcher != NULL );
D_ASSERT( real != NULL );
D_ASSERT( dispatch != NULL );
D_ASSERT( ret_instance != NULL );
instance = D_CALLOC( 1, sizeof(VoodooInstance) );
if (!instance) {
D_WARN( "out of memory" );
return DR_NOLOCALMEMORY;
}
instance->super = super;
instance->proxy = dispatcher;
instance->real = real;
instance->dispatch = dispatch;
pthread_mutex_lock( &manager->instances.lock );
instance_id = ++manager->instances.last;
ret = direct_hash_insert( manager->instances.local, instance_id, instance );
pthread_mutex_unlock( &manager->instances.lock );
if (ret) {
D_ERROR( "Voodoo/Manager: Adding a new instance to the dispatcher hash table failed!\n" );
D_FREE( instance );
return ret;
}
D_DEBUG( "Voodoo/Manager: "
"Added instance %u, dispatcher %p, real %p.\n", instance_id, dispatcher, real );
*ret_instance = instance_id;
return DR_OK;
}
DirectResult
DirectResultTypeRegister( DirectResultType *type )
{
DirectResult ret;
D_DEBUG_AT( Direct_Result, "%s( %p )\n", __FUNCTION__, type );
D_ASSERT( type != NULL );
D_DEBUG_AT( Direct_Result, " -> refs %d\n", type->refs );
D_DEBUG_AT( Direct_Result, " -> base 0x%08x\n", type->base );
D_DEBUG_AT( Direct_Result, " -> strings %p\n", type->result_strings );
D_DEBUG_AT( Direct_Result, " -> count %u\n", type->result_count );
D_ASSERT( type->result_count > 0 );
D_ASSERT( type->result_count <= D_RESULT_TYPE_SPACE );
D_DEBUG_AT( Direct_Result, " => %s\n", type->result_strings[0] );
ret = direct_mutex_lock( &result_mutex );
if (ret)
return ret;
if (direct_hash_lookup( &result_types, type->base )) {
D_ASSERT( direct_hash_lookup( &result_types, type->base ) == type );
D_MAGIC_ASSERT( type, DirectResultType );
D_ASSERT( type->refs > 0 );
type->refs++;
}
else {
D_ASSERT( type->refs == 0 );
D_MAGIC_SET( type, DirectResultType );
ret = direct_hash_insert( &result_types, type->base, (void*) type );
if (ret)
D_MAGIC_CLEAR( type );
else
type->refs = 1;
}
direct_mutex_unlock( &result_mutex );
return ret;
}
void
direct_perf_count( DirectPerfCounterInstallation *installation, int diff )
{
DirectPerfCounter *counter;
D_ASSERT( installation != NULL );
direct_mutex_lock( &counter_lock );
if (installation->counter_id == 0) {
counter = D_CALLOC( 1, sizeof(DirectPerfCounter) );
if (!counter) {
direct_mutex_unlock( &counter_lock );
D_OOM();
return;
}
installation->counter_id = ++counter_ids;
D_ASSERT( installation->counter_id != 0 );
D_ASSERT( installation->counter_id != ~0 ); // FIXME: can there be more than 4 billion counters?
direct_snputs( counter->name, installation->name, sizeof(counter->name) );
counter->reset_on_dump = installation->reset_on_dump;
direct_hash_insert( &counter_hash, installation->counter_id, counter );
}
else {
counter = direct_hash_lookup( &counter_hash, installation->counter_id );
if (!counter) {
direct_mutex_unlock( &counter_lock );
D_BUG( "unknown performance counter installation (%lu)", installation->counter_id );
return;
}
}
counter->count += diff;
if (!counter->start)
counter->start = direct_clock_get_time( DIRECT_CLOCK_SESSION );
direct_mutex_unlock( &counter_lock );
}
void *
direct_dbg_calloc( const char* file, int line, const char *func, size_t count, size_t bytes )
{
void *mem;
unsigned long *val;
D_DEBUG_AT( Direct_Mem, " +"_ZUn(6)" bytes [%s:%d in %s()]\n", count * bytes, file, line, func );
if (direct_config->debugmem) {
MemDesc *desc;
mem = direct_calloc( 1, count * bytes + sizeof(MemDesc) );
D_DEBUG_AT( Direct_Mem, " '-> %p\n", mem );
if (!mem)
return NULL;
desc = fill_mem_desc( mem, count * bytes, func, file, line, direct_trace_copy_buffer(NULL) );
direct_mutex_lock( &alloc_lock );
direct_hash_insert( &alloc_hash, (unsigned long) desc->mem, desc );
direct_mutex_unlock( &alloc_lock );
return desc->mem;
}
mem = direct_calloc( 1, count * bytes + DISABLED_OFFSET );
D_DEBUG_AT( Direct_Mem, " '-> %p\n", mem );
if (!mem)
return NULL;
val = mem;
val[0] = ~0;
return (char*) mem + DISABLED_OFFSET;
}
DirectResult
voodoo_manager_register_remote( VoodooManager *manager,
bool super,
void *requestor,
VoodooInstanceID instance_id )
{
DirectResult ret;
VoodooInstance *instance;
D_MAGIC_ASSERT( manager, VoodooManager );
D_ASSERT( requestor != NULL );
D_ASSERT( instance_id != VOODOO_INSTANCE_NONE );
instance = D_CALLOC( 1, sizeof(VoodooInstance) );
if (!instance) {
D_WARN( "out of memory" );
return DR_NOLOCALMEMORY;
}
instance->super = super;
instance->proxy = requestor;
pthread_mutex_lock( &manager->instances.lock );
ret = direct_hash_insert( manager->instances.remote, instance_id, instance );
pthread_mutex_unlock( &manager->instances.lock );
if (ret) {
D_ERROR( "Voodoo/Manager: Adding a new instance to the requestor hash table failed!\n" );
D_FREE( instance );
return ret;
}
D_DEBUG( "Voodoo/Manager: "
"Added remote instance %u, requestor %p.\n", instance_id, requestor );
return DR_OK;
}
static void
InputHub_DeviceAdd( void *ctx,
DFBInputDeviceID device_id,
const DFBInputDeviceDescription *desc )
{
DirectResult ret;
InputHubDeviceNode *node;
D_DEBUG_AT( Input_Hub, "%s( ID %u, '%s' )\n", __FUNCTION__, device_id, desc->name );
node = direct_hash_lookup( m_nodes, device_id );
if (!node) {
node = D_CALLOC( 1, sizeof(InputHubDeviceNode) );
if (!node) {
D_OOM();
return;
}
node->device_id = device_id;
node->description = *desc;
ret = direct_hash_insert( m_nodes, device_id, node );
if (ret) {
D_FREE( node );
return;
}
ret = dfb_input_create_device( device_id, m_core, m_driver );
if (ret) {
direct_hash_remove( m_nodes, device_id );
D_FREE( node );
return;
}
}
else
D_WARN( "already have device (ID %u)", device_id );
}
static DFBResult
x11Lock( CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceAllocation *allocation,
void *alloc_data,
CoreSurfaceBufferLock *lock )
{
DFBResult ret;
x11PoolLocalData *local = pool_local;
x11AllocationData *alloc = alloc_data;
DFBX11 *x11 = local->x11;
DFBX11Shared *shared = x11->shared;
D_DEBUG_AT( X11_Surfaces, "%s( %p )\n", __FUNCTION__, allocation );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( allocation, CoreSurfaceAllocation );
D_MAGIC_ASSERT( lock, CoreSurfaceBufferLock );
D_ASSERT( local->hash != NULL );
pthread_mutex_lock( &local->lock );
if (alloc->real) {
void *addr = direct_hash_lookup( local->hash, alloc->image.seginfo.shmid );
if (!addr) {
ret = x11ImageAttach( &alloc->image, &addr );
if (ret) {
D_DERROR( ret, "X11/Surfaces: x11ImageAttach() failed!\n" );
pthread_mutex_unlock( &local->lock );
return ret;
}
direct_hash_insert( local->hash, alloc->image.seginfo.shmid, addr );
/* FIXME: When to remove/detach? */
}
lock->addr = addr;
lock->handle = &alloc->image;
}
else {
if (!alloc->ptr) {
D_DEBUG_AT( X11_Surfaces, " -> allocating memory in data_shmpool (%d bytes)\n", allocation->size );
alloc->ptr = SHCALLOC( shared->data_shmpool, 1, allocation->size );
if (!alloc->ptr) {
pthread_mutex_unlock( &local->lock );
return D_OOSHM();
}
}
lock->addr = alloc->ptr;
}
lock->pitch = alloc->pitch;
pthread_mutex_unlock( &local->lock );
return DFB_OK;
}
