void
fusion_exit( bool emergency )
{
int foo;
FusionSendMessage msg;
D_ASSERT( fusion_refs > 0 );
/* decrement local reference counter */
if (--fusion_refs)
return;
if (!emergency) {
/* Wake up the read loop thread. */
msg.fusion_id = _fusion_id;
msg.msg_id = 0;
msg.msg_data = &foo;
msg.msg_size = sizeof(foo);
while (ioctl( _fusion_fd, FUSION_SEND_MESSAGE, &msg ) < 0) {
if (errno != EINTR) {
D_PERROR ("FUSION_SEND_MESSAGE");
break;
}
}
/* Wait for its termination. */
direct_thread_join( read_loop );
}
direct_thread_destroy( read_loop );
direct_signal_handler_remove( signal_handler );
/* Master has to deinitialize shared data. */
if (_fusion_id == 1) {
fusion_skirmish_destroy( &_fusion_shared->reactor_globals );
fusion_skirmish_destroy( &_fusion_shared->arenas_lock );
}
_fusion_shared = NULL;
/* Deinitialize or leave shared memory. */
__shmalloc_exit( _fusion_id == 1, true );
/* Reset local dispatch nodes. */
_fusion_reactor_free_all();
_fusion_id = 0;
if (close( _fusion_fd ))
D_PERROR( "Fusion/Exit: closing the fusion device failed!\n" );
_fusion_fd = -1;
direct_shutdown();
}
static void
driver_close_device( CoreGraphicsDevice *device,
void *driver_data,
void *device_data )
{
SH7722DeviceData *sdev = device_data;
D_DEBUG_AT( SH7722_Driver, "%s()\n", __FUNCTION__ );
/* Destroy JPEG lock. */
fusion_skirmish_destroy( &sdev->jpeg_lock );
/* Destroy BEU lock. */
fusion_skirmish_destroy( &sdev->beu_lock );
}
void
dfb_surfacemanager_destroy( SurfaceManager *manager )
{
Chunk *chunk;
D_ASSERT( manager != NULL );
D_ASSERT( manager->chunks != NULL );
D_MAGIC_ASSERT( manager, SurfaceManager );
D_MAGIC_CLEAR( manager );
/* Deallocate all chunks. */
chunk = manager->chunks;
while (chunk) {
Chunk *next = chunk->next;
D_MAGIC_CLEAR( chunk );
SHFREE( chunk );
chunk = next;
}
/* Destroy manager lock. */
fusion_skirmish_destroy( &manager->lock );
/* Deallocate manager struct. */
SHFREE( manager );
}
static void
bench_skirmish()
{
DirectResult ret;
FusionSkirmish skirmish;
ret = fusion_skirmish_init( &skirmish, "Benchmark", world );
if (ret) {
fprintf( stderr, "Fusion Error %d\n", ret );
return;
}
/* skirmish prevail/dismiss */
BENCH_START();
BENCH_LOOP() {
fusion_skirmish_prevail( &skirmish );
fusion_skirmish_dismiss( &skirmish );
}
BENCH_STOP();
printf( "skirmish prevail/dismiss -> %8.2f k/sec\n", BENCH_RESULT() );
fusion_skirmish_destroy( &skirmish );
printf( "\n" );
}
static DFBResult
dfb_clipboard_core_shutdown( DFBClipboardCore *data,
bool emergency )
{
DFBClipboardCoreShared *shared;
D_DEBUG_AT( Core_Clipboard, "dfb_clipboard_core_shutdown( %p, %semergency )\n", data, emergency ? "" : "no " );
D_MAGIC_ASSERT( data, DFBClipboardCore );
shared = data->shared;
D_MAGIC_ASSERT( shared, DFBClipboardCoreShared );
fusion_skirmish_destroy( &shared->lock );
if (shared->data)
SHFREE( shared->shmpool, shared->data );
if (shared->mime_type)
SHFREE( shared->shmpool, shared->mime_type );
D_MAGIC_CLEAR( data );
D_MAGIC_CLEAR( shared );
return DFB_OK;
}
DirectResult
fusion_shm_deinit( FusionWorld *world )
{
int i;
DirectResult ret;
FusionSHM *shm;
FusionSHMShared *shared;
D_MAGIC_ASSERT( world, FusionWorld );
shm = &world->shm;
D_MAGIC_ASSERT( shm, FusionSHM );
shared = shm->shared;
D_MAGIC_ASSERT( shared, FusionSHMShared );
ret = fusion_skirmish_prevail( &shared->lock );
if (ret)
return ret;
/* Deinitialize shared data. */
if (fusion_master( world )) {
D_ASSUME( shared->num_pools == 0 );
for (i=0; i<FUSION_SHM_MAX_POOLS; i++) {
if (shared->pools[i].active) {
D_MAGIC_ASSERT( &shared->pools[i], FusionSHMPoolShared );
D_MAGIC_ASSERT( &shm->pools[i], FusionSHMPool );
D_WARN( "destroying remaining '%s'", shared->pools[i].name );
fusion_shm_pool_destroy( world, &shared->pools[i] );
}
}
/* Destroy shared lock. */
fusion_skirmish_destroy( &shared->lock );
D_MAGIC_CLEAR( shared );
}
else {
for (i=0; i<FUSION_SHM_MAX_POOLS; i++) {
if (shared->pools[i].active) {
D_MAGIC_ASSERT( &shared->pools[i], FusionSHMPoolShared );
D_MAGIC_ASSERT( &shm->pools[i], FusionSHMPool );
fusion_shm_pool_detach( shm, &shared->pools[i] );
}
}
fusion_skirmish_dismiss( &shared->lock );
}
D_MAGIC_CLEAR( shm );
return DR_OK;
}
static void
region_destructor( FusionObject *object, bool zombie )
{
CoreLayerRegion *region = (CoreLayerRegion*) object;
CoreLayerContext *context = region->context;
CoreLayer *layer = dfb_layer_at( context->layer_id );
CoreLayerShared *shared = layer->shared;
(void) shared;
D_DEBUG_AT( Core_Layers, "destroying region %p (%s, %dx%d, "
"%s, %s, %s, %s%s)\n", region, shared->description.name,
region->config.width, region->config.height,
D_FLAGS_IS_SET( region->state,
CLRSF_CONFIGURED ) ? "configured" : "unconfigured",
D_FLAGS_IS_SET( region->state,
CLRSF_ENABLED ) ? "enabled" : "disabled",
D_FLAGS_IS_SET( region->state,
CLRSF_ACTIVE ) ? "active" : "inactive",
D_FLAGS_IS_SET( region->state,
CLRSF_REALIZED ) ? "realized" : "not realized",
zombie ? " - ZOMBIE" : "" );
/* Hide region etc. */
if (D_FLAGS_IS_SET( region->state, CLRSF_ENABLED ))
dfb_layer_region_disable( region );
/* Remove the region from the context. */
dfb_layer_context_remove_region( region->context, region );
/* Throw away its surface. */
if (region->surface) {
/* Detach the global listener. */
dfb_surface_detach_global( region->surface,
®ion->surface_reaction );
/* Unlink from structure. */
dfb_surface_unlink( ®ion->surface );
}
/* Unlink the context from the structure. */
dfb_layer_context_unlink( ®ion->context );
/* Free driver's region data. */
if (region->region_data)
SHFREE( region->region_data );
/* Deinitialize the lock. */
fusion_skirmish_destroy( ®ion->lock );
/* Destroy the object. */
fusion_object_destroy( object );
}
static void
surface_destructor( FusionObject *object, bool zombie, void *ctx )
{
int i;
CoreSurface *surface = (CoreSurface*) object;
D_MAGIC_ASSERT( surface, CoreSurface );
D_DEBUG_AT( Core_Surface, "destroying %p (%dx%d%s)\n", surface,
surface->config.size.w, surface->config.size.h, zombie ? " ZOMBIE" : "");
Core_Resource_RemoveSurface( surface );
CoreSurface_Deinit_Dispatch( &surface->call );
dfb_surface_lock( surface );
surface->state |= CSSF_DESTROYED;
/* announce surface destruction */
dfb_surface_notify( surface, CSNF_DESTROY );
/* unlink palette */
if (surface->palette) {
dfb_palette_detach_global( surface->palette, &surface->palette_reaction );
dfb_palette_unlink( &surface->palette );
}
/* destroy buffers */
for (i=0; i<MAX_SURFACE_BUFFERS; i++) {
if (surface->buffers[i])
dfb_surface_buffer_decouple( surface->buffers[i] );
}
dfb_system_surface_data_destroy( surface, surface->data );
/* release the system driver specific surface data */
if (surface->data) {
SHFREE( surface->shmpool, surface->data );
surface->data = NULL;
}
direct_serial_deinit( &surface->serial );
dfb_surface_unlock( surface );
fusion_skirmish_destroy( &surface->lock );
D_MAGIC_CLEAR( surface );
fusion_object_destroy( object );
}
static DFBResult
system_shutdown( bool emergency )
{
DFBX11 *x11 = dfb_system_data();
DFBX11Shared *shared = x11->shared;
/*
* Master deinit
*/
if (shared->x11_pool_bridge)
dfb_surface_pool_bridge_destroy( shared->x11_pool_bridge );
if (shared->vpsmem_pool)
dfb_surface_pool_destroy( shared->vpsmem_pool );
if (shared->glx_pool)
dfb_surface_pool_destroy( shared->glx_pool );
if (shared->x11image_pool)
dfb_surface_pool_destroy( shared->x11image_pool );
/*
* Shared deinit (master only)
*/
fusion_call_destroy( &shared->call );
fusion_skirmish_prevail( &shared->lock );
if (shared->xw)
dfb_x11_close_window( x11, shared->xw );
fusion_skirmish_destroy( &shared->lock );
SHFREE( dfb_core_shmpool( x11->core ), shared );
/*
* Local deinit (master and slave)
*/
if (x11->display)
XCloseDisplay( x11->display );
D_FREE( x11 );
return DFB_OK;
}
static DFBResult
system_shutdown( bool emergency )
{
D_ASSERT( dfb_vnc != NULL );
fusion_call_destroy( &dfb_vnc->call );
fusion_skirmish_prevail( &dfb_vnc->lock );
fusion_skirmish_destroy( &dfb_vnc->lock );
SHFREE( dfb_core_shmpool(dfb_vnc_core), dfb_vnc );
dfb_vnc = NULL;
dfb_vnc_core = NULL;
return DFB_OK;
}
static DFBResult
system_shutdown( bool emergency )
{
FusionSHMPoolShared *pool;
D_ASSERT( dfb_sdl != NULL );
/* Stop update thread. */
if (dfb_sdl->update.thread) {
if (!emergency) {
dfb_sdl->update.quit = true;
pthread_cond_signal( &dfb_sdl->update.cond );
direct_thread_join( dfb_sdl->update.thread );
}
direct_thread_destroy( dfb_sdl->update.thread );
}
dfb_surface_pool_destroy( dfb_sdl->sdl_pool );
fusion_call_destroy( &dfb_sdl->call );
fusion_skirmish_prevail( &dfb_sdl->lock );
SDL_Quit();
fusion_skirmish_destroy( &dfb_sdl->lock );
pool = dfb_core_shmpool(dfb_sdl_core);
while (dfb_sdl->modes) {
VideoMode *next = dfb_sdl->modes->next;
SHFREE( pool, dfb_sdl->modes );
dfb_sdl->modes = next;
}
SHFREE( pool, dfb_sdl );
dfb_sdl = NULL;
dfb_sdl_core = NULL;
return DFB_OK;
}
DirectResult
fusion_ref_destroy (FusionRef *ref)
{
FusionSkirmish *skirmish;
D_ASSERT( ref != NULL );
D_DEBUG_AT( Fusion_Ref, "fusion_ref_destroy( %p )\n", ref );
skirmish = &ref->multi.builtin.lock;
if (skirmish->multi.builtin.destroyed)
return DR_DESTROYED;
_fusion_remove_all_locals( _fusion_world(ref->multi.shared), ref );
fusion_skirmish_destroy( skirmish );
return DR_OK;
}
static DFBResult
system_shutdown( bool emergency )
{
D_ASSERT( dfb_rtd != NULL );
fusion_call_destroy( &dfb_rtd->call );
fusion_skirmish_prevail( &dfb_rtd->lock );
fusion_skirmish_destroy( &dfb_rtd->lock );
SHFREE( dfb_core_shmpool(dfb_rtd_core), dfb_rtd );
dfb_rtd = NULL;
dfb_rtd_core = NULL;
libk_uninit();
return DFB_OK;
}
static void
shutdown_pool( FusionSHM *shm,
FusionSHMPool *pool,
FusionSHMPoolShared *shared )
{
FusionWorld *world;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %p )\n", __FUNCTION__, shm, pool, shared );
D_MAGIC_ASSERT( shm, FusionSHM );
D_MAGIC_ASSERT( pool, FusionSHMPool );
D_MAGIC_ASSERT( shared, FusionSHMPoolShared );
world = shm->world;
D_MAGIC_ASSERT( world, FusionWorld );
SHFREE( shared, shared->name );
fusion_dbg_print_memleaks( shared );
if (munmap( shared->addr_base, shared->max_size ))
D_PERROR( "Fusion/SHM: Could not munmap shared memory file '%s'!\n", pool->filename );
if (pool->fd != -1 && close( pool->fd ))
D_PERROR( "Fusion/SHM: Could not close shared memory file '%s'!\n", pool->filename );
if (unlink( pool->filename ))
D_PERROR( "Fusion/SHM: Could not unlink shared memory file '%s'!\n", pool->filename );
shared->active = false;
pool->attached = false;
D_FREE( pool->filename );
D_MAGIC_CLEAR( pool );
fusion_skirmish_destroy( &shared->lock );
D_MAGIC_CLEAR( shared );
}
static DFBResult
dfb_colorhash_core_shutdown( DFBColorHashCore *data,
bool emergency )
{
DFBColorHashCoreShared *shared;
D_DEBUG_AT( Core_ColorHash, "dfb_colorhash_core_shutdown( %p, %semergency )\n", data, emergency ? "" : "no " );
D_MAGIC_ASSERT( data, DFBColorHashCore );
D_MAGIC_ASSERT( data->shared, DFBColorHashCoreShared );
shared = data->shared;
fusion_skirmish_destroy( &shared->hash_lock );
D_MAGIC_CLEAR( data );
D_MAGIC_CLEAR( shared );
return DFB_OK;
}
static void
surface_destructor( FusionObject *object, bool zombie, void *ctx )
{
int i;
CoreSurface *surface = (CoreSurface*) object;
D_MAGIC_ASSERT( surface, CoreSurface );
D_DEBUG_AT( Core_Surface, "destroying %p (%dx%d%s)\n", surface,
surface->config.size.w, surface->config.size.h, zombie ? " ZOMBIE" : "");
dfb_surface_lock( surface );
surface->state |= CSSF_DESTROYED;
/* announce surface destruction */
dfb_surface_notify( surface, CSNF_DESTROY );
/* unlink palette */
if (surface->palette) {
dfb_palette_detach_global( surface->palette, &surface->palette_reaction );
dfb_palette_unlink( &surface->palette );
}
/* destroy buffers */
for (i=0; i<MAX_SURFACE_BUFFERS; i++) {
if (surface->buffers[i])
dfb_surface_buffer_destroy( surface->buffers[i] );
}
direct_serial_deinit( &surface->serial );
dfb_surface_unlock( surface );
fusion_skirmish_destroy( &surface->lock );
D_MAGIC_CLEAR( surface );
fusion_object_destroy( object );
}
static int
dfb_core_arena_shutdown( FusionArena *arena,
void *ctx,
bool emergency)
{
DFBResult ret;
CoreDFB *core = ctx;
CoreDFBShared *shared;
FusionSHMPoolShared *pool;
D_MAGIC_ASSERT( core, CoreDFB );
shared = core->shared;
D_MAGIC_ASSERT( shared, CoreDFBShared );
pool = shared->shmpool;
D_DEBUG_AT( DirectFB_Core, "Shutting down...\n" );
if (!core->master) {
D_WARN( "refusing shutdown in slave" );
return dfb_core_leave( core, emergency );
}
CoreDFB_Deinit_Dispatch( &shared->call );
/* Shutdown. */
ret = dfb_core_shutdown( core, emergency );
fusion_skirmish_destroy( &shared->lock );
D_MAGIC_CLEAR( shared );
SHFREE( pool, shared );
fusion_shm_pool_destroy( core->world, pool );
return ret;
}
static void
bench_skirmish_threaded()
{
int i;
DirectResult ret;
FusionSkirmish skirmish;
ret = fusion_skirmish_init( &skirmish, "Threaded Benchmark", world );
if (ret) {
fprintf( stderr, "Fusion Error %d\n", ret );
return;
}
/* skirmish prevail/dismiss (2-5 threads) */
for (i=2; i<=5; i++) {
int t;
pthread_t threads[i];
BENCH_START();
for (t=0; t<i; t++)
pthread_create( &threads[t], NULL, prevail_dismiss_loop, &skirmish );
for (t=0; t<i; t++)
pthread_join( threads[t], NULL );
BENCH_STOP();
printf( "skirmish prevail/dismiss (%d threads) -> %8.2f k/sec\n", i, BENCH_RESULT() );
}
fusion_skirmish_destroy( &skirmish );
printf( "\n" );
}
DFBResult
dfb_surface_pool_bridge_destroy( CoreSurfacePoolBridge *bridge )
{
CoreSurfacePoolBridgeID bridge_id;
const SurfacePoolBridgeFuncs *funcs;
D_MAGIC_ASSERT( bridge, CoreSurfacePoolBridge );
bridge_id = bridge->bridge_id;
D_DEBUG_AT( Core_SurfPoolBridge, "%s( %p, '%s' [%d] )\n", __FUNCTION__, bridge, bridge->desc.name, bridge_id );
D_ASSERT( bridge->bridge_id >= 0 );
D_ASSERT( bridge_id < MAX_SURFACE_POOL_BRIDGES );
D_ASSERT( bridge_array[bridge_id] == bridge );
funcs = get_funcs( bridge );
if (funcs->DestroyPoolBridge)
funcs->DestroyPoolBridge( bridge, bridge->data, get_local(bridge) );
/* Free shared bridge data. */
if (bridge->data)
SHFREE( bridge->shmpool, bridge->data );
/* Free local pool data and remove from lists */
remove_bridge_local( bridge_id );
fusion_skirmish_destroy( &bridge->lock );
D_MAGIC_CLEAR( bridge );
SHFREE( bridge->shmpool, bridge );
return DFB_OK;
}
static DFBResult
system_shutdown( bool emergency )
{
D_ASSERT( dfb_x11 != NULL );
dfb_surface_pool_destroy( dfb_x11->surface_pool );
fusion_call_destroy( &dfb_x11->call );
fusion_skirmish_prevail( &dfb_x11->lock );
if (dfb_x11->xw)
dfb_x11_close_window( dfb_x11->xw );
if (dfb_x11->display)
XCloseDisplay( dfb_x11->display );
fusion_skirmish_destroy( &dfb_x11->lock );
SHFREE( dfb_core_shmpool(dfb_x11_core), dfb_x11 );
dfb_x11 = NULL;
dfb_x11_core = NULL;
return DFB_OK;
}
static DFBResult
system_shutdown( bool emergency )
{
DFBX11 *x11 = dfb_system_data();
DFBX11Shared *shared = x11->shared;
int i;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
/*
* Master deinit
*/
if (shared->x11_pool_bridge)
dfb_surface_pool_bridge_destroy( shared->x11_pool_bridge );
if (shared->vpsmem_pool)
dfb_surface_pool_destroy( shared->vpsmem_pool );
if (shared->glx_pool)
dfb_surface_pool_destroy( shared->glx_pool );
if (shared->x11image_pool)
dfb_surface_pool_destroy( shared->x11image_pool );
/*
* Shared deinit (master only)
*/
fusion_call_destroy( &shared->call );
fusion_skirmish_prevail( &shared->lock );
/* close remaining windows */
for( i=0; i<dfb_layer_num(); i++ ) {
CoreLayer *layer;
X11LayerData *lds;
layer = dfb_layer_at( i );
lds = layer->layer_data;
if( lds->xw ) {
dfb_x11_close_window( x11, lds->xw );
lds->xw = 0;
shared->window_count--;
}
}
fusion_skirmish_destroy( &shared->lock );
SHFREE( dfb_core_shmpool( x11->core ), shared );
/*
* Local deinit (master and slave)
*/
if (x11->display)
XCloseDisplay( x11->display );
D_FREE( x11 );
return DFB_OK;
}
DFBResult
dfb_surface_create( CoreDFB *core,
const CoreSurfaceConfig *config,
CoreSurfaceTypeFlags type,
unsigned long resource_id,
CorePalette *palette,
CoreSurface **ret_surface )
{
DFBResult ret = DFB_BUG;
int i, data_size;
int buffers;
CoreSurface *surface;
char buf[64];
D_ASSERT( core != NULL );
D_FLAGS_ASSERT( type, CSTF_ALL );
D_MAGIC_ASSERT_IF( palette, CorePalette );
D_ASSERT( ret_surface != NULL );
D_DEBUG_AT( Core_Surface, "dfb_surface_create( %p, %p, %p )\n", core, config, ret_surface );
surface = dfb_core_create_surface( core );
if (!surface)
return DFB_FUSION;
surface->data = NULL;
if (config) {
D_FLAGS_ASSERT( config->flags, CSCONF_ALL );
surface->config.flags = config->flags;
if (config->flags & CSCONF_SIZE) {
D_DEBUG_AT( Core_Surface, " -> %dx%d\n", config->size.w, config->size.h );
surface->config.size = config->size;
}
if (config->flags & CSCONF_FORMAT) {
D_DEBUG_AT( Core_Surface, " -> %s\n", dfb_pixelformat_name( config->format ) );
surface->config.format = config->format;
}
if (config->flags & CSCONF_CAPS) {
D_DEBUG_AT( Core_Surface, " -> caps 0x%08x\n", config->caps );
if (config->caps & DSCAPS_ROTATED)
D_UNIMPLEMENTED();
surface->config.caps = config->caps & ~DSCAPS_ROTATED;
}
if (config->flags & CSCONF_PREALLOCATED) {
D_DEBUG_AT( Core_Surface, " -> prealloc %p [%d]\n",
config->preallocated[0].addr,
config->preallocated[0].pitch );
direct_memcpy( surface->config.preallocated, config->preallocated, sizeof(config->preallocated) );
surface->config.preallocated_pool_id = config->preallocated_pool_id;
type |= CSTF_PREALLOCATED;
}
}
if (surface->config.caps & DSCAPS_SYSTEMONLY)
surface->type = (type & ~CSTF_EXTERNAL) | CSTF_INTERNAL;
else if (surface->config.caps & DSCAPS_VIDEOONLY)
surface->type = (type & ~CSTF_INTERNAL) | CSTF_EXTERNAL;
else
surface->type = type & ~(CSTF_INTERNAL | CSTF_EXTERNAL);
if (surface->config.caps & DSCAPS_SHARED)
surface->type |= CSTF_SHARED;
surface->resource_id = resource_id;
if (surface->config.caps & DSCAPS_TRIPLE)
buffers = 3;
else if (surface->config.caps & DSCAPS_DOUBLE)
buffers = 2;
else {
buffers = 1;
surface->config.caps &= ~DSCAPS_ROTATED;
}
surface->notifications = CSNF_ALL & ~CSNF_FLIP;
surface->alpha_ramp[0] = 0x00;
surface->alpha_ramp[1] = 0x55;
surface->alpha_ramp[2] = 0xaa;
surface->alpha_ramp[3] = 0xff;
if (surface->config.caps & DSCAPS_STATIC_ALLOC)
surface->config.min_size = surface->config.size;
surface->shmpool = dfb_core_shmpool( core );
direct_serial_init( &surface->serial );
snprintf( buf, sizeof(buf), "Surface %dx%d %s", surface->config.size.w,
surface->config.size.h, dfb_pixelformat_name(surface->config.format) );
fusion_ref_set_name( &surface->object.ref, buf );
fusion_skirmish_init2( &surface->lock, buf, dfb_core_world(core), fusion_config->secure_fusion );
// fusion_skirmish_add_permissions( &surface->lock, 0, FUSION_SKIRMISH_PERMIT_PREVAIL | FUSION_SKIRMISH_PERMIT_DISMISS );
D_MAGIC_SET( surface, CoreSurface );
if (dfb_config->warn.flags & DCWF_CREATE_SURFACE &&
dfb_config->warn.create_surface.min_size.w <= surface->config.size.w &&
dfb_config->warn.create_surface.min_size.h <= surface->config.size.h)
D_WARN( "create-surface %4dx%4d %6s, buffers %d, caps 0x%08x, type 0x%08x",
surface->config.size.w, surface->config.size.h, dfb_pixelformat_name(surface->config.format),
buffers, surface->config.caps, surface->type );
if (palette) {
dfb_surface_set_palette( surface, palette );
}
else if (DFB_PIXELFORMAT_IS_INDEXED( surface->config.format )) {
ret = dfb_surface_init_palette( core, surface );
if (ret)
goto error;
}
/* Create the system driver specific surface data information */
data_size = dfb_system_surface_data_size();
if (data_size) {
surface->data = SHCALLOC( surface->shmpool, 1, data_size );
if (!surface->data) {
ret = D_OOSHM();
goto error;
}
}
dfb_system_surface_data_init(surface,surface->data);
dfb_surface_lock( surface );
/* Create the Surface Buffers. */
for (i=0; i<buffers; i++) {
ret = dfb_surface_buffer_create( core, surface, CSBF_NONE, &surface->buffers[i] );
if (ret) {
D_DERROR( ret, "Core/Surface: Error creating surface buffer!\n" );
goto error;
}
surface->num_buffers++;
dfb_surface_buffer_globalize( surface->buffers[i] );
switch (i) {
case 0:
surface->buffer_indices[CSBR_FRONT] = i;
case 1:
surface->buffer_indices[CSBR_BACK] = i;
case 2:
surface->buffer_indices[CSBR_IDLE] = i;
}
}
dfb_surface_unlock( surface );
CoreSurface_Init_Dispatch( core, surface, &surface->call );
fusion_object_activate( &surface->object );
*ret_surface = surface;
return DFB_OK;
error:
for (i=0; i<MAX_SURFACE_BUFFERS; i++) {
if (surface->buffers[i])
dfb_surface_buffer_decouple( surface->buffers[i] );
}
/* release the system driver specific surface data */
if (surface->data) {
dfb_system_surface_data_destroy( surface, surface->data );
SHFREE( surface->shmpool, surface->data );
surface->data = NULL;
}
fusion_skirmish_destroy( &surface->lock );
direct_serial_deinit( &surface->serial );
D_MAGIC_CLEAR( surface );
fusion_object_destroy( &surface->object );
return ret;
}
DFBResult
dfb_surface_create( CoreDFB *core,
const CoreSurfaceConfig *config,
CoreSurfaceTypeFlags type,
unsigned long resource_id,
CorePalette *palette,
CoreSurface **ret_surface )
{
DFBResult ret = DFB_BUG;
int i;
int buffers;
CoreSurface *surface;
char buf[64];
D_ASSERT( core != NULL );
D_FLAGS_ASSERT( type, CSTF_ALL );
D_MAGIC_ASSERT_IF( palette, CorePalette );
D_ASSERT( ret_surface != NULL );
D_DEBUG_AT( Core_Surface, "dfb_surface_create( %p, %p, %p )\n", core, config, ret_surface );
surface = dfb_core_create_surface( core );
if (!surface)
return DFB_FUSION;
if (config) {
D_FLAGS_ASSERT( config->flags, CSCONF_ALL );
surface->config.flags = config->flags;
if (config->flags & CSCONF_SIZE) {
D_DEBUG_AT( Core_Surface, " -> %dx%d\n", config->size.w, config->size.h );
surface->config.size = config->size;
}
if (config->flags & CSCONF_FORMAT) {
D_DEBUG_AT( Core_Surface, " -> %s\n", dfb_pixelformat_name( config->format ) );
surface->config.format = config->format;
}
if (config->flags & CSCONF_CAPS) {
D_DEBUG_AT( Core_Surface, " -> caps 0x%08x\n", config->caps );
surface->config.caps = config->caps;
}
if (config->flags & CSCONF_PREALLOCATED) {
D_DEBUG_AT( Core_Surface, " -> prealloc %p [%d]\n",
config->preallocated[0].addr,
config->preallocated[0].pitch );
direct_memcpy( surface->config.preallocated, config->preallocated, sizeof(config->preallocated) );
type |= CSTF_PREALLOCATED;
}
}
if (surface->config.caps & DSCAPS_SYSTEMONLY)
surface->type = (type & ~CSTF_EXTERNAL) | CSTF_INTERNAL;
else if (surface->config.caps & DSCAPS_VIDEOONLY)
surface->type = (type & ~CSTF_INTERNAL) | CSTF_EXTERNAL;
else
surface->type = type & ~(CSTF_INTERNAL | CSTF_EXTERNAL);
if (surface->config.caps & DSCAPS_SHARED)
surface->type |= CSTF_SHARED;
surface->resource_id = resource_id;
if (surface->config.caps & DSCAPS_TRIPLE)
buffers = 3;
else if (surface->config.caps & DSCAPS_DOUBLE)
buffers = 2;
else
buffers = 1;
surface->notifications = CSNF_ALL & ~CSNF_FLIP;
surface->alpha_ramp[0] = 0x00;
surface->alpha_ramp[1] = 0x55;
surface->alpha_ramp[2] = 0xaa;
surface->alpha_ramp[3] = 0xff;
if (surface->config.caps & DSCAPS_STATIC_ALLOC)
surface->config.min_size = surface->config.size;
surface->shmpool = dfb_core_shmpool( core );
direct_serial_init( &surface->serial );
snprintf( buf, sizeof(buf), "Surface %dx%d %s", surface->config.size.w,
surface->config.size.h, dfb_pixelformat_name(surface->config.format) );
fusion_ref_set_name( &surface->object.ref, buf );
fusion_skirmish_init( &surface->lock, buf, dfb_core_world(core) );
fusion_object_set_lock( &surface->object, &surface->lock );
D_MAGIC_SET( surface, CoreSurface );
if (dfb_config->warn.flags & DCWF_CREATE_SURFACE &&
dfb_config->warn.create_surface.min_size.w <= surface->config.size.w &&
dfb_config->warn.create_surface.min_size.h <= surface->config.size.h)
D_WARN( "create-surface %4dx%4d %6s, buffers %d, caps 0x%08x, type 0x%08x",
surface->config.size.w, surface->config.size.h, dfb_pixelformat_name(surface->config.format),
buffers, surface->config.caps, surface->type );
if (palette) {
dfb_surface_set_palette( surface, palette );
}
else if (DFB_PIXELFORMAT_IS_INDEXED( surface->config.format )) {
ret = dfb_surface_init_palette( core, surface );
if (ret)
goto error;
}
/* Create the Surface Buffers. */
for (i=0; i<buffers; i++) {
CoreSurfaceBuffer *buffer;
ret = dfb_surface_buffer_new( surface, CSBF_NONE, &buffer );
if (ret) {
D_DERROR( ret, "Core/Surface: Error creating surface buffer!\n" );
goto error;
}
surface->buffers[surface->num_buffers++] = buffer;
switch (i) {
case 0:
surface->buffer_indices[CSBR_FRONT] = i;
case 1:
surface->buffer_indices[CSBR_BACK] = i;
case 2:
surface->buffer_indices[CSBR_IDLE] = i;
}
}
fusion_object_activate( &surface->object );
*ret_surface = surface;
return DFB_OK;
error:
D_MAGIC_CLEAR( surface );
for (i=0; i<MAX_SURFACE_BUFFERS; i++) {
if (surface->buffers[i])
dfb_surface_buffer_destroy( surface->buffers[i] );
}
fusion_skirmish_destroy( &surface->lock );
direct_serial_deinit( &surface->serial );
fusion_object_destroy( &surface->object );
return ret;
}
int
fusion_init( int world, int abi_version, int *world_ret )
{
char buf[20];
FusionEnter enter;
/* Check against multiple initialization. */
if (_fusion_id) {
/* Increment local reference counter. */
fusion_refs++;
return _fusion_id;
}
direct_initialize();
/* Open Fusion Kernel Device. */
if (world < 0) {
for (world=0; world<256; world++) {
snprintf( buf, sizeof(buf), "/dev/fusion/%d", world );
_fusion_fd = open (buf, O_RDWR | O_NONBLOCK | O_EXCL);
if (_fusion_fd < 0) {
if (errno == EBUSY)
continue;
D_PERROR( "Fusion/Init: opening '%s' failed!\n", buf );
direct_shutdown();
return -1;
}
else
break;
}
}
else {
snprintf( buf, sizeof(buf), "/dev/fusion/%d", world );
_fusion_fd = open (buf, O_RDWR | O_NONBLOCK);
if (_fusion_fd < 0) {
D_PERROR( "Fusion/Init: opening '%s' failed!\n", buf );
direct_shutdown();
return -1;
}
}
enter.api.major = FUSION_API_MAJOR;
enter.api.minor = FUSION_API_MINOR;
enter.fusion_id = 0;
/* Get our Fusion ID. */
if (ioctl( _fusion_fd, FUSION_ENTER, &enter )) {
D_PERROR( "Fusion/Init: FUSION_ENTER failed!\n" );
goto error;
}
if (!enter.fusion_id) {
D_ERROR( "Fusion/Init: Got no ID from FUSION_ENTER! Kernel module might be too old.\n" );
goto error;
}
_fusion_id = enter.fusion_id;
/* Initialize local reference counter. */
fusion_refs = 1;
/* Initialize shmalloc part. */
if (!__shmalloc_init( world, _fusion_id == 1 )) {
D_ERROR( "Fusion/Init: Shared memory initialization failed.\n"
"\n"
"Please make sure that a tmpfs mount point with at least 4MB of free space\n"
"is available for read/write, see the DirectFB README for more instructions.\n" );
goto error;
}
if (_fusion_id == 1) {
_fusion_shared = __shmalloc_allocate_root( sizeof(FusionShared) );
_fusion_shared->abi_version = abi_version;
fusion_skirmish_init( &_fusion_shared->arenas_lock, "Fusion Arenas" );
fusion_skirmish_init( &_fusion_shared->reactor_globals, "Fusion Reactor Globals" );
_sheap->reactor = fusion_reactor_new( sizeof(long), "Shared Memory Heap" );
if (!_sheap->reactor) {
__shmalloc_exit( true, true );
goto error_reactor;
}
gettimeofday( &_fusion_shared->start_time, NULL );
}
else {
_fusion_shared = __shmalloc_get_root();
if (_fusion_shared->abi_version != abi_version) {
D_ERROR( "Fusion/Init: ABI version mismatch (my: %d, their: %d)\n",
abi_version, _fusion_shared->abi_version );
__shmalloc_exit( false, false );
goto error;
}
}
__shmalloc_attach();
direct_clock_set_start( &_fusion_shared->start_time );
direct_signal_handler_add( SIGSEGV, fusion_signal_handler, NULL, &signal_handler );
read_loop = direct_thread_create( DTT_MESSAGING, fusion_read_loop, NULL, "Fusion Dispatch" );
if (world_ret)
*world_ret = world;
return _fusion_id;
error_reactor:
fusion_skirmish_destroy( &_fusion_shared->arenas_lock );
fusion_skirmish_destroy( &_fusion_shared->reactor_globals );
error:
_fusion_shared = NULL;
_fusion_id = 0;
close( _fusion_fd );
_fusion_fd = -1;
direct_shutdown();
return -1;
}
static DirectResult
init_pool( FusionSHM *shm,
FusionSHMPool *pool,
FusionSHMPoolShared *shared,
const char *name,
unsigned int max_size,
bool debug )
{
DirectResult ret;
int size;
FusionWorld *world;
FusionSHMPoolNew pool_new = { .pool_id = 0 };
FusionSHMPoolAttach pool_attach = { .pool_id = 0 };
FusionEntryInfo info;
char buf[FUSION_SHM_TMPFS_PATH_NAME_LEN + 32];
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %p, '%s', %d, %sdebug )\n",
__FUNCTION__, shm, pool, shared, name, max_size, debug ? "" : "non-" );
D_MAGIC_ASSERT( shm, FusionSHM );
D_MAGIC_ASSERT( shm->shared, FusionSHMShared );
D_ASSERT( name != NULL );
D_ASSERT( max_size > sizeof(shmalloc_heap) );
world = shm->world;
D_MAGIC_ASSERT( world, FusionWorld );
D_ASSERT( pool != NULL );
D_ASSERT( shared != NULL );
/* Fill out information for new pool. */
pool_new.max_size = max_size;
pool_new.max_size += BLOCKALIGN(sizeof(shmalloc_heap)) +
BLOCKALIGN( (max_size + BLOCKSIZE-1) / BLOCKSIZE * sizeof(shmalloc_info) );
/* Create the new pool. */
while (ioctl( world->fusion_fd, FUSION_SHMPOOL_NEW, &pool_new )) {
if (errno == EINTR)
continue;
D_PERROR( "Fusion/SHM: FUSION_SHMPOOL_NEW failed!\n" );
return DR_FUSION;
}
/* Set the pool info. */
info.type = FT_SHMPOOL;
info.id = pool_new.pool_id;
snprintf( info.name, sizeof(info.name), "%s", name );
ioctl( world->fusion_fd, FUSION_ENTRY_SET_INFO, &info );
fusion_entry_add_permissions( world, FT_SHMPOOL, pool_new.pool_id, 0,
FUSION_SHMPOOL_ATTACH,
FUSION_SHMPOOL_DETACH,
0 );
/* Set pool to attach to. */
pool_attach.pool_id = pool_new.pool_id;
/* Attach to the pool. */
while (ioctl( world->fusion_fd, FUSION_SHMPOOL_ATTACH, &pool_attach )) {
if (errno == EINTR)
continue;
D_PERROR( "Fusion/SHM: FUSION_SHMPOOL_ATTACH failed!\n" );
while (ioctl( world->fusion_fd, FUSION_SHMPOOL_DESTROY, &shared->pool_id )) {
if (errno != EINTR) {
D_PERROR( "Fusion/SHM: FUSION_SHMPOOL_DESTROY failed!\n" );
break;
}
}
return DR_FUSION;
}
/* Generate filename. */
snprintf( buf, sizeof(buf), "%s/fusion.%d.%d", shm->shared->tmpfs,
fusion_world_index( shm->world ), pool_new.pool_id );
/* Initialize the heap. */
ret = __shmalloc_init_heap( shm, buf, pool_new.addr_base, max_size, &size );
if (ret) {
while (ioctl( world->fusion_fd, FUSION_SHMPOOL_DESTROY, &shared->pool_id )) {
if (errno != EINTR) {
D_PERROR( "Fusion/SHM: FUSION_SHMPOOL_DESTROY failed!\n" );
break;
}
}
return ret;
}
/* Initialize local data. */
pool->attached = true;
pool->shm = shm;
pool->shared = shared;
pool->pool_id = pool_new.pool_id;
pool->filename = D_STRDUP( buf );
/* Initialize shared data. */
shared->active = true;
shared->debug = debug;
shared->shm = shm->shared;
shared->max_size = pool_new.max_size;
shared->pool_id = pool_new.pool_id;
shared->addr_base = pool_new.addr_base;
shared->heap = pool_new.addr_base;
shared->heap->pool = shared;
fusion_skirmish_init2( &shared->lock, name, world, fusion_config->secure_fusion );
D_MAGIC_SET( pool, FusionSHMPool );
D_MAGIC_SET( shared, FusionSHMPoolShared );
shared->name = SHSTRDUP( shared, name );
return DR_OK;
}
static DirectResult
join_pool( FusionSHM *shm,
FusionSHMPool *pool,
FusionSHMPoolShared *shared )
{
DirectResult ret;
FusionWorld *world;
FusionSHMPoolAttach pool_attach = { .pool_id = 0 };
char buf[FUSION_SHM_TMPFS_PATH_NAME_LEN + 32];
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %p )\n", __FUNCTION__, shm, pool, shared );
D_MAGIC_ASSERT( shm, FusionSHM );
D_MAGIC_ASSERT( shm->shared, FusionSHMShared );
D_MAGIC_ASSERT( shared, FusionSHMPoolShared );
#if !DIRECT_BUILD_DEBUGS
if (shared->debug) {
D_ERROR( "Fusion/SHM: Can't join debug enabled pool with pure-release library!\n" );
return DR_UNSUPPORTED;
}
#endif
world = shm->world;
D_MAGIC_ASSERT( world, FusionWorld );
/* Set pool to attach to. */
pool_attach.pool_id = shared->pool_id;
/* Attach to the pool. */
while (ioctl( world->fusion_fd, FUSION_SHMPOOL_ATTACH, &pool_attach )) {
if (errno == EINTR)
continue;
D_PERROR( "Fusion/SHM: FUSION_SHMPOOL_ATTACH failed!\n" );
return DR_FUSION;
}
/* Generate filename. */
snprintf( buf, sizeof(buf), "%s/fusion.%d.%d", shm->shared->tmpfs,
fusion_world_index( shm->world ), shared->pool_id );
/* Join the heap. */
ret = __shmalloc_join_heap( shm, buf, pool_attach.addr_base, shared->max_size,
!fusion_config->secure_fusion );
if (ret) {
while (ioctl( world->fusion_fd, FUSION_SHMPOOL_DETACH, &shared->pool_id )) {
if (errno != EINTR) {
D_PERROR( "Fusion/SHM: FUSION_SHMPOOL_DETACH failed!\n" );
break;
}
}
return ret;
}
/* Initialize local data. */
pool->attached = true;
pool->shm = shm;
pool->shared = shared;
pool->pool_id = shared->pool_id;
pool->filename = D_STRDUP( buf );
D_MAGIC_SET( pool, FusionSHMPool );
return DR_OK;
}
static void
leave_pool( FusionSHM *shm,
FusionSHMPool *pool,
FusionSHMPoolShared *shared )
{
FusionWorld *world;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %p )\n", __FUNCTION__, shm, pool, shared );
D_MAGIC_ASSERT( shm, FusionSHM );
D_MAGIC_ASSERT( pool, FusionSHMPool );
D_MAGIC_ASSERT( shared, FusionSHMPoolShared );
world = shm->world;
D_MAGIC_ASSERT( world, FusionWorld );
while (ioctl( world->fusion_fd, FUSION_SHMPOOL_DETACH, &shared->pool_id )) {
if (errno != EINTR) {
D_PERROR( "Fusion/SHM: FUSION_SHMPOOL_DETACH failed!\n" );
break;
}
}
if (munmap( shared->addr_base, shared->max_size ))
D_PERROR( "Fusion/SHM: Could not munmap shared memory file '%s'!\n", pool->filename );
pool->attached = false;
D_FREE( pool->filename );
D_MAGIC_CLEAR( pool );
}
static void
shutdown_pool( FusionSHM *shm,
FusionSHMPool *pool,
FusionSHMPoolShared *shared )
{
FusionWorld *world;
D_DEBUG_AT( Fusion_SHMPool, "%s( %p, %p, %p )\n", __FUNCTION__, shm, pool, shared );
D_MAGIC_ASSERT( shm, FusionSHM );
D_MAGIC_ASSERT( pool, FusionSHMPool );
D_MAGIC_ASSERT( shared, FusionSHMPoolShared );
world = shm->world;
D_MAGIC_ASSERT( world, FusionWorld );
SHFREE( shared, shared->name );
fusion_dbg_print_memleaks( shared );
while (ioctl( world->fusion_fd, FUSION_SHMPOOL_DESTROY, &shared->pool_id )) {
if (errno != EINTR) {
D_PERROR( "Fusion/SHM: FUSION_SHMPOOL_DESTROY failed!\n" );
break;
}
}
if (munmap( shared->addr_base, shared->max_size ))
D_PERROR( "Fusion/SHM: Could not munmap shared memory file '%s'!\n", pool->filename );
if (unlink( pool->filename ))
D_PERROR( "Fusion/SHM: Could not unlink shared memory file '%s'!\n", pool->filename );
shared->active = false;
pool->attached = false;
D_FREE( pool->filename );
D_MAGIC_CLEAR( pool );
fusion_skirmish_destroy( &shared->lock );
D_MAGIC_CLEAR( shared );
}
