VoodooConnectionLink::~VoodooConnectionLink()
{
D_DEBUG_AT( Voodoo_Connection, "VoodooConnectionLink::%s( %p )\n", __func__, this );
D_MAGIC_ASSERT( this, VoodooConnection );
/* Acquire locks and wake up waiters. */
direct_mutex_lock( &output.lock );
direct_waitqueue_broadcast( &output.wait );
direct_mutex_unlock( &output.lock );
/* Destroy conditions. */
direct_waitqueue_deinit( &output.wait );
/* Destroy locks. */
direct_mutex_deinit( &output.lock );
/* Deallocate buffers. */
D_FREE( input.buffer );
direct_tls_unregister( &output.tls );
}
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;
}
DirectResult
direct_map_create( unsigned int initial_size,
DirectMapCompareFunc compare_func,
DirectMapHashFunc hash_func,
void *ctx,
DirectMap **ret_map )
{
DirectMap *map;
D_DEBUG_AT( Direct_Map, "%s( size %u, compare %p, hash %p )\n", __func__, initial_size, compare_func, hash_func );
D_ASSERT( compare_func != NULL );
D_ASSERT( hash_func != NULL );
D_ASSERT( ret_map != NULL );
if (initial_size < 3)
initial_size = 3;
map = D_CALLOC( 1, sizeof (DirectMap) );
if (!map)
return D_OOM();
map->entries = D_CALLOC( initial_size, sizeof(MapEntry) );
if (!map->entries) {
D_FREE( map );
return D_OOM();
}
map->size = initial_size;
map->compare = compare_func;
map->hash = hash_func;
map->ctx = ctx;
D_MAGIC_SET( map, DirectMap );
*ret_map = map;
return DR_OK;
}
static DFBResult
localDeallocateBuffer( CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceBuffer *buffer,
CoreSurfaceAllocation *allocation,
void *alloc_data )
{
LocalAllocationData *alloc = alloc_data;
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( alloc, LocalAllocationData );
if (dfb_config->system_surface_align_base && dfb_config->system_surface_align_pitch)
// This was allocated by posix_memalign and requires "free()".
free( alloc->addr );
else
D_FREE( alloc->addr );
D_MAGIC_CLEAR( alloc );
return DFB_OK;
}
static DFBResult
system_leave( bool emergency )
{
DFBX11 *x11 = dfb_system_data();
DFBX11Shared *shared = x11->shared;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
/*
* Slave deinit
*/
if (shared->x11_pool_bridge)
dfb_surface_pool_bridge_leave( shared->x11_pool_bridge );
if (shared->vpsmem_pool)
dfb_surface_pool_leave( shared->vpsmem_pool );
if (shared->glx_pool)
dfb_surface_pool_leave( shared->glx_pool );
if (shared->x11window_pool)
dfb_surface_pool_leave( shared->x11window_pool );
if (shared->x11image_pool)
dfb_surface_pool_leave( shared->x11image_pool );
/*
* Local deinit (master and slave)
*/
if (x11->display)
XCloseDisplay( x11->display );
D_FREE( x11 );
return DFB_OK;
}
static DFBResult
system_join( CoreDFB *core, void **ret_data )
{
DFBResult ret;
void *tmp;
AndroidData *android;
AndroidDataShared *shared;
D_ASSERT( m_data == NULL );
android = D_CALLOC( 1, sizeof(AndroidData) );
if (!android)
return D_OOM();
android->core = core;
ret = core_arena_get_shared_field( core, "android", &tmp );
if (ret) {
D_FREE( android );
return ret;
}
android->shared = shared = tmp;
ret = InitLocal( android );
if (ret)
return ret;
*ret_data = m_data = android;
dfb_surface_pool_join( core, shared->pool, &androidSurfacePoolFuncs );
android->screen = dfb_screens_register( NULL, android, androidScreenFuncs );
android->layer = dfb_layers_register( android->screen, android, androidLayerFuncs );
return DFB_OK;
}
static void *
DecoupledCall_thread_main( DirectThread *thread,
void *ctx )
{
while (true) {
DecoupledCall *call;
direct_mutex_lock( &decoupled_calls_lock );
while (!decoupled_calls)
direct_waitqueue_wait( &decoupled_calls_wq, &decoupled_calls_lock );
call = (DecoupledCall*) decoupled_calls;
direct_list_remove( &decoupled_calls, &call->link );
direct_mutex_unlock( &decoupled_calls_lock );
ComaTestInstance *instance = call->instance;
IComaComponent *component = instance->component;
switch (call->method) {
case COMA_TEST_CALL1:
DispatchCall1( instance, call->data, call->serial );
break;
default:
component->Return( component, DR_NOIMPL, call->serial );
break;
}
D_FREE( call );
}
return NULL;
}
static void
IDirectFBImageProvider_ANDROID_Destruct( IDirectFBImageProvider *thiz )
{
JNIEnv *env = 0;
IDirectFBImageProvider_ANDROID_data *data = (IDirectFBImageProvider_ANDROID_data *)thiz->priv;
(*m_data->java_vm)->AttachCurrentThread( m_data->java_vm, &env, NULL );
if (!env) {
D_DEBUG_AT( imageProviderANDROID, "Destruct: Failed to attach current thread to JVM\n" );
return;
}
if (data->image) {
(*env)->ReleaseByteArrayElements( env, data->pixels, data->image, JNI_ABORT );
check_exception( env );
}
(*env)->DeleteGlobalRef( env, data->pixels );
check_exception( env );
if (data->path)
D_FREE( data->path );
}
static void
array_partial(void **state)
{
test_arg_t *arg = *state;
daos_obj_id_t oid;
daos_handle_t oh;
daos_iov_t dkey;
daos_sg_list_t sgl;
daos_iov_t sg_iov;
daos_iod_t iod;
daos_recx_t recx;
daos_recx_t recxs[4];
char *buf;
char *buf_out;
int rc, i;
arg->size = 4;
D_ALLOC(buf, arg->size * NUM_RECORDS);
assert_non_null(buf);
dts_buf_render(buf, arg->size * NUM_RECORDS);
/** open object */
oid = dts_oid_gen(DAOS_OC_REPL_MAX_RW, 0, arg->myrank);
rc = daos_obj_open(arg->coh, oid, 0, &oh, NULL);
assert_int_equal(rc, 0);
/** init dkey */
daos_iov_set(&dkey, "dkey", strlen("dkey"));
/** init scatter/gather */
daos_iov_set(&sg_iov, buf, arg->size * NUM_RECORDS);
sgl.sg_nr = 1;
sgl.sg_nr_out = 0;
sgl.sg_iovs = &sg_iov;
/** init I/O descriptor */
daos_iov_set(&iod.iod_name, "akey", strlen("akey"));
daos_csum_set(&iod.iod_kcsum, NULL, 0);
iod.iod_nr = 1;
iod.iod_size = arg->size;
recx.rx_idx = 0;
recx.rx_nr = NUM_RECORDS;
iod.iod_recxs = &recx;
iod.iod_eprs = NULL;
iod.iod_csums = NULL;
iod.iod_type = DAOS_IOD_ARRAY;
/** update record */
print_message("writing %lu records of %lu bytes each at offset %lu\n",
recx.rx_nr, iod.iod_size, recx.rx_idx);
rc = daos_obj_update(oh, DAOS_TX_NONE, &dkey, 1, &iod, &sgl, NULL);
assert_int_equal(rc, 0);
/** fetch 1/2 of the records back */
print_message("reading 1/2 of the records back ...\n");
D_ALLOC(buf_out, arg->size * NUM_RECORDS/2);
assert_non_null(buf_out);
memset(buf_out, 0, arg->size * NUM_RECORDS/2);
daos_iov_set(&sg_iov, buf_out, arg->size * NUM_RECORDS/2);
iod.iod_size = arg->size;
iod.iod_nr = 4;
for (i = 0; i < 4; i++) {
recxs[i].rx_idx = i*6;
recxs[i].rx_nr = 3;
}
iod.iod_recxs = recxs;
rc = daos_obj_fetch(oh, DAOS_TX_NONE, &dkey, 1, &iod, &sgl, NULL, NULL);
print_message("fetch returns %d\n", rc);
assert_int_equal(rc, 0);
/** verify record size */
print_message("validating record size ...\n");
assert_int_equal(iod.iod_size, arg->size);
/** Verify data consistency */
print_message("validating data ...\n");
for (i = 0; i < 4; i++) {
char *tmp1 = buf + i * 6 * arg->size;
char *tmp2 = buf_out + i * 3 * arg->size;
assert_memory_equal(tmp1, tmp2, arg->size * 3);
}
/** close object */
rc = daos_obj_close(oh, NULL);
assert_int_equal(rc, 0);
D_FREE(buf_out);
D_FREE(buf);
print_message("all good\n");
}
static void
array_simple(void **state)
{
test_arg_t *arg = *state;
daos_obj_id_t oid;
daos_handle_t oh;
daos_iov_t dkey;
daos_sg_list_t sgl;
daos_iov_t sg_iov;
daos_iod_t iod;
daos_recx_t recx;
char *buf;
char *buf_out;
int rc;
D_ALLOC(buf, arg->size * arg->nr);
assert_non_null(buf);
dts_buf_render(buf, arg->size * arg->nr);
/** open object */
oid = dts_oid_gen(DAOS_OC_REPL_MAX_RW, 0, arg->myrank);
rc = daos_obj_open(arg->coh, oid, 0, &oh, NULL);
assert_int_equal(rc, 0);
/** init dkey */
daos_iov_set(&dkey, "dkey", strlen("dkey"));
/** init scatter/gather */
daos_iov_set(&sg_iov, buf, arg->size * arg->nr);
sgl.sg_nr = 1;
sgl.sg_nr_out = 0;
sgl.sg_iovs = &sg_iov;
/** init I/O descriptor */
daos_iov_set(&iod.iod_name, "akey", strlen("akey"));
daos_csum_set(&iod.iod_kcsum, NULL, 0);
iod.iod_nr = 1;
iod.iod_size = arg->size;
srand(time(NULL) + arg->size);
recx.rx_idx = rand();
recx.rx_nr = arg->nr;
iod.iod_recxs = &recx;
iod.iod_eprs = NULL;
iod.iod_csums = NULL;
iod.iod_type = DAOS_IOD_ARRAY;
/** update record */
print_message("writing %lu records of %lu bytes each at offset %lu\n",
recx.rx_nr, iod.iod_size, recx.rx_idx);
rc = daos_obj_update(oh, DAOS_TX_NONE, &dkey, 1, &iod, &sgl, NULL);
assert_int_equal(rc, 0);
/** fetch data back */
print_message("reading data back ...\n");
D_ALLOC(buf_out, arg->size * arg->nr);
assert_non_null(buf_out);
memset(buf_out, 0, arg->size * arg->nr);
daos_iov_set(&sg_iov, buf_out, arg->size * arg->nr);
iod.iod_size = DAOS_REC_ANY;
rc = daos_obj_fetch(oh, DAOS_TX_NONE, &dkey, 1, &iod, &sgl, NULL, NULL);
assert_int_equal(rc, 0);
/** verify record size */
print_message("validating record size ...\n");
assert_int_equal(iod.iod_size, arg->size);
/** Verify data consistency */
print_message("validating data ...\n");
assert_memory_equal(buf, buf_out, arg->size * arg->nr);
/** close object */
rc = daos_obj_close(oh, NULL);
assert_int_equal(rc, 0);
D_FREE(buf_out);
D_FREE(buf);
print_message("all good\n");
}
static __inline__ void args_free( void *static_buffer, void *buffer )
{
if (buffer != static_buffer)
D_FREE( buffer );
}
DFBResult
IDirectFBFont_CreateFromBuffer( IDirectFBDataBuffer *buffer,
CoreDFB *core,
const DFBFontDescription *desc,
IDirectFBFont **interface )
{
DFBResult ret;
DirectInterfaceFuncs *funcs = NULL;
IDirectFBDataBuffer_data *buffer_data;
IDirectFBFont *ifont;
IDirectFBFont_ProbeContext ctx = {0};
/* Get the private information of the data buffer. */
buffer_data = (IDirectFBDataBuffer_data*) buffer->priv;
if (!buffer_data)
return DFB_DEAD;
/* Provide a fallback for image providers without data buffer support. */
ctx.filename = buffer_data->filename;
/* try to map the "file" content first */
if (try_map_file( buffer_data, &ctx ) != DFB_OK) {
/* try to load the "file" content from the buffer */
/* we need to be able to seek (this implies non-streamed,
so we also know the size) so we can reuse the buffer */
if (buffer->SeekTo( buffer, 0 ) == DFB_OK) {
unsigned int size, got;
/* get the "file" length */
buffer->GetLength( buffer, &size );
ctx.content = D_MALLOC( size );
if (!ctx.content)
return DR_NOLOCALMEMORY;
ctx.content_size = 0;
while (ctx.content_size < size) {
unsigned int get = size - ctx.content_size;
if (get > 8192)
get = 8192;
ret = buffer->WaitForData( buffer, get );
if (ret) {
D_DERROR( ret, "%s: WaitForData failed!\n", __FUNCTION__ );
break;
}
ret = buffer->GetData( buffer, get, ctx.content + ctx.content_size, &got );
if (ret) {
D_DERROR( ret, "%s: GetData failed!\n", __FUNCTION__ );
break;
}
if (!got)
break;
ctx.content_size += got;
}
if (ctx.content_size != size) {
D_ERROR( "%s: Got size %u differs from supposed %u!\n", __FUNCTION__, ctx.content_size, size );
D_FREE( ctx.content );
return DFB_FAILURE;
}
}
}
/* Find a suitable implementation. */
ret = DirectGetInterface( &funcs, "IDirectFBFont", NULL, DirectProbeInterface, &ctx );
if (ret) {
unmap_or_free( &ctx );
return ret;
}
DIRECT_ALLOCATE_INTERFACE( ifont, IDirectFBFont );
/* Construct the interface. */
ret = funcs->Construct( ifont, core, &ctx, desc );
if (ret) {
unmap_or_free( &ctx );
return ret;
}
/* store pointer for deletion at destroy */
{
IDirectFBFont_data *data = (IDirectFBFont_data*)(ifont->priv);
data->content = ctx.content;
data->content_size = ctx.content_size;
data->content_mapped = ctx.content_mapped;
}
*interface = ifont;
return DFB_OK;
}
DirectResult
fs_config_set( const char *name, const char *value )
{
if (!strcmp( name, "driver" )) {
if (value) {
if (fs_config->driver)
D_FREE( fs_config->driver );
fs_config->driver = D_STRDUP( value );
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "device" )) {
if (value) {
if (fs_config->device)
D_FREE( fs_config->device );
fs_config->device = D_STRDUP( value );
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "channels" )) {
if (value) {
int channels;
if (sscanf( value, "%d", &channels ) < 1) {
D_ERROR( "FusionSound/Config '%s': Could not parse value!\n", name );
return DR_INVARG;
}
else if (channels < 1 || channels > FS_MAX_CHANNELS) {
D_ERROR( "FusionSound/Config '%s': Unsupported value '%d'!\n", name, channels );
return DR_INVARG;
}
fs_config->channelmode = fs_mode_for_channels( channels );
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "channelmode" )) {
if (value) {
FSChannelMode mode;
mode = parse_modestring( value );
if (mode == FSCM_UNKNOWN) {
D_ERROR( "FusionSound/Config '%s': Could not parse value!\n", name );
return DR_INVARG;
}
fs_config->channelmode = mode;
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "sampleformat" )) {
if (value) {
FSSampleFormat format;
format = parse_sampleformat( value );
if (format == FSSF_UNKNOWN) {
D_ERROR( "FusionSound/Config '%s': Could not parse value!\n", name );
return DR_INVARG;
}
fs_config->sampleformat = format;
}
else {
D_ERROR( "FusionSound/Config '%s': No format specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "samplerate" )) {
if (value) {
int rate;
if (sscanf( value, "%d", &rate ) < 1) {
D_ERROR( "FusionSound/Config 'samplerate': "
"Could not parse value!\n" );
return DR_INVARG;
}
else if (rate < 1) {
D_ERROR( "FusionSound/Config '%s': Unsupported value '%d'!\n", name, rate );
return DR_INVARG;
}
fs_config->samplerate = rate;
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "buffertime" )) {
if (value) {
int time;
if (sscanf( value, "%d", &time ) < 1) {
D_ERROR( "FusionSound/Config 'buffertime': "
"Could not parse value!\n" );
return DR_INVARG;
}
else if (time < 1 || time > 5000) {
D_ERROR( "FusionSound/Config '%s': Unsupported value '%d'!\n", name, time );
return DR_INVARG;
}
fs_config->buffertime = time;
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "session" )) {
if (value) {
int session;
if (sscanf( value, "%d", &session ) < 1) {
D_ERROR( "FusionSound/Config '%s': Could not parse value!\n", name );
return DR_INVARG;
}
fs_config->session = session;
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp (name, "remote" )) {
if (value) {
char host[128];
int session = 0;
if (sscanf( value, "%127s:%d", host, &session ) < 1) {
D_ERROR( "FusionSound/Config '%s': "
"Could not parse value (format is <host>[:<session>])!\n", name );
return DR_INVARG;
}
if (fs_config->remote.host)
D_FREE( fs_config->remote.host );
fs_config->remote.host = D_STRDUP( host );
fs_config->remote.session = session;
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "remote-compression" )) {
if (value) {
if (!strcasecmp( value, "none" )) {
fs_config->remote_compression = FSRM_NONE;
}
else if (!strcasecmp( value, "dpack" )) {
fs_config->remote_compression = FSRM_DPACK;
}
else {
D_ERROR( "FusionSound/Config '%s': Unsupported value '%s'!\n", name, value );
return DR_INVARG;
}
}
else {
D_ERROR( "FusionSound/Config '%s': No value specified!\n", name );
return DR_INVARG;
}
}
else if (!strcmp( name, "banner" )) {
fs_config->banner = true;
}
else if (!strcmp( name, "no-banner" )) {
fs_config->banner = false;
}
else if (!strcmp( name, "wait" )) {
fs_config->wait = true;
}
else if (!strcmp( name, "no-wait" )) {
fs_config->wait = false;
}
else if (!strcmp( name, "deinit-check" )) {
fs_config->deinit_check = true;
}
else if (!strcmp( name, "no-deinit-check" )) {
fs_config->deinit_check = false;
}
else if (!strcmp( name, "dither" )) {
fs_config->dither = true;
}
else if (!strcmp( name, "no-dither" )) {
fs_config->dither = false;
}
else if (!strcmp( name, "dma" )) {
fs_config->dma = true;
}
else if (!strcmp( name, "no-dma" )) {
fs_config->dma = false;
}
else if (fusion_config_set( name, value ) && direct_config_set( name, value ))
return DR_UNSUPPORTED;
return DR_OK;
}
DFBResult
dfb_core_destroy( CoreDFB *core, bool emergency )
{
D_MAGIC_ASSERT( core, CoreDFB );
D_ASSERT( core->refs > 0 );
D_ASSERT( core == core_dfb );
D_DEBUG_AT( DirectFB_Core, "%s...\n", __FUNCTION__ );
if (!emergency) {
pthread_mutex_lock( &core_dfb_lock );
if (--core->refs) {
pthread_mutex_unlock( &core_dfb_lock );
return DFB_OK;
}
}
dfb_font_manager_destroy( core->font_manager );
if (core->signal_handler)
direct_signal_handler_remove( core->signal_handler );
if (core->cleanup_handler)
direct_cleanup_handler_remove( core->cleanup_handler );
if (core->master) {
if (emergency) {
fusion_kill( core->world, 0, SIGKILL, 1000 );
}
else {
fusion_kill( core->world, 0, SIGTERM, 5000 );
fusion_kill( core->world, 0, SIGKILL, 2000 );
}
}
dfb_core_process_cleanups( core, emergency );
while (fusion_arena_exit( core->arena, dfb_core_arena_shutdown,
core->master ? NULL : dfb_core_arena_leave,
core, emergency, NULL ) == DR_BUSY)
{
D_ONCE( "waiting for DirectFB slaves to terminate" );
direct_thread_sleep( 100000 );
}
fusion_exit( core->world, emergency );
if (!emergency)
direct_thread_remove_init_handler( core->init_handler );
D_MAGIC_CLEAR( core );
D_FREE( core );
core_dfb = NULL;
if (!emergency) {
pthread_mutex_unlock( &core_dfb_lock );
direct_shutdown();
}
return DFB_OK;
}
static void
signal_handler( int num, siginfo_t *info, void *foo )
{
ucontext_t *uctx = foo;
#else
static void
signal_handler( int num )
{
#endif
DirectResult ret;
int i;
DirectLink *l, *n;
SigHandled *sig = NULL;
void *addr = NULL;
// fflush(stdout);
// fflush(stderr);
for (i=0; i<NUM_SIGS_TO_HANDLE; i++) {
if (sigs_handled[i].signum == num) {
sig = &sigs_handled[i];
/* Using SA_RESETHAND, so... */
sig->signum = -1;
break;
}
}
/* ret = direct_sigaction( num, &sig->old_action, NULL );
if (ret) {
D_DERROR( ret, "Direct/Signals: Unable to restore previous handler for signal %d!\n", num );
sig = NULL;
}
*/
#ifndef SA_SIGINFO
D_LOG( Direct_Signals, FATAL, " --> Caught signal %d <--\n", num );
#else
if (info && info > (siginfo_t*) 0x100) {
bool shown = false;
/* Kernel genrated signal? */
if (info->si_code > 0 && info->si_code < 0x80) {
addr = info->si_addr;
switch (num) {
case SIGSEGV:
shown = show_segv( info, uctx );
break;
case SIGBUS:
shown = show_bus( info, uctx );
break;
case SIGILL:
shown = show_ill( info, uctx );
break;
case SIGFPE:
shown = show_fpe( info, uctx );
break;
default:
D_LOG( Direct_Signals, FATAL, " --> Caught signal %d <--\n", info->si_signo );
addr = NULL;
shown = true;
break;
}
}
else
shown = show_any( info, uctx );
if (!shown)
D_LOG( Direct_Signals, FATAL, " --> Caught signal %d (unknown origin) <--\n", info->si_signo );
}
else
D_LOG( Direct_Signals, FATAL, " --> Caught signal %d, no siginfo available <--\n", num );
#endif
direct_log_lock( NULL );
direct_trace_print_stacks();
direct_log_unlock( NULL );
/* Loop through all handlers. */
direct_mutex_lock( &handlers_lock );
direct_list_foreach_safe (l, n, handlers) {
DirectSignalHandler *handler = (DirectSignalHandler*) l;
if (handler->num != num && handler->num != DIRECT_SIGNAL_ANY)
continue;
switch (handler->func( num, addr, handler->ctx )) {
case DSHR_OK:
break;
case DSHR_REMOVE:
direct_list_remove( &handlers, &handler->link );
D_MAGIC_CLEAR( handler );
D_FREE( handler );
break;
case DSHR_RESUME:
D_LOG( Direct_Signals, FATAL, " '-> cured!\n" );
direct_mutex_unlock( &handlers_lock );
if (sig) {
ret = direct_sigaction( num, &sig->new_action, NULL );
if (ret)
D_DERROR( ret, "Direct/Signals: Unable to reinstall handler for signal %d!\n", num );
else
sig->signum = num;
}
return;
default:
D_BUG( "unknown result" );
break;
}
}
DFBResult
dfb_surface_pool_bridge_join( CoreDFB *core,
CoreSurfacePoolBridge *bridge,
const SurfacePoolBridgeFuncs *funcs,
void *context )
{
DFBResult ret;
D_MAGIC_ASSERT( bridge, CoreSurfacePoolBridge );
D_DEBUG_AT( Core_SurfPoolBridge, "%s( %p [%d], %p, %p )\n", __FUNCTION__, bridge, bridge->bridge_id, funcs, context );
D_ASSERT( core != NULL );
D_ASSERT( funcs != NULL );
D_ASSERT( bridge->bridge_id < MAX_SURFACE_POOL_BRIDGES );
D_ASSERT( bridge->bridge_id == bridge_count );
D_ASSERT( bridge_funcs[bridge->bridge_id] == NULL );
/* Enforce same order as initialization to be used during join. */
if (bridge->bridge_id != bridge_count) {
D_ERROR( "Core/SurfacePoolBridge: Wrong order of joining bridges, got %d, should be %d!\n",
bridge->bridge_id, bridge_count );
return DFB_BUG;
}
/* Allocate local bridge data. */
if (bridge->bridge_local_data_size &&
!(bridge_locals[bridge->bridge_id] = D_CALLOC( 1, bridge->bridge_local_data_size )))
return D_OOM();
/* Set function table of the bridge. */
bridge_funcs[bridge->bridge_id] = funcs;
/* Add to global bridge list. */
bridge_array[bridge->bridge_id] = bridge;
/* Adjust bridge count. */
if (bridge_count < bridge->bridge_id + 1)
bridge_count = bridge->bridge_id + 1;
funcs = get_funcs( bridge );
if (funcs->JoinPoolBridge) {
ret = funcs->JoinPoolBridge( core, bridge, bridge->data, get_local(bridge), context );
if (ret) {
D_DERROR( ret, "Core/SurfacePoolBridge: Joining '%s' failed!\n", bridge->desc.name );
if (bridge_locals[bridge->bridge_id]) {
D_FREE( bridge_locals[bridge->bridge_id] );
bridge_locals[bridge->bridge_id] = NULL;
}
bridge_array[bridge->bridge_id] = NULL;
bridge_funcs[bridge->bridge_id] = NULL;
bridge_count--;
return ret;
}
}
/* Insert new bridge into priority order */
insert_bridge_local( bridge );
return DFB_OK;
}
static int
cont_lookup(struct rdb_tx *tx, const struct cont_svc *svc, const uuid_t uuid,
struct cont **cont)
{
struct cont *p;
daos_iov_t key;
daos_iov_t tmp;
int rc;
daos_iov_set(&key, (void *)uuid, sizeof(uuid_t));
daos_iov_set(&tmp, NULL, 0);
/* check if the container exists or not */
rc = rdb_tx_lookup(tx, &svc->cs_conts, &key, &tmp);
if (rc != 0)
D_GOTO(err, rc);
D_ALLOC_PTR(p);
if (p == NULL) {
D_ERROR("Failed to allocate container descriptor\n");
D_GOTO(err, rc = -DER_NOMEM);
}
uuid_copy(p->c_uuid, uuid);
p->c_svc = (struct cont_svc *)svc;
/* c_prop */
rc = rdb_path_clone(&svc->cs_conts, &p->c_prop);
if (rc != 0)
D_GOTO(err_p, rc);
rc = rdb_path_push(&p->c_prop, &key);
if (rc != 0)
D_GOTO(err_attrs, rc);
/* c_lres */
rc = rdb_path_clone(&p->c_prop, &p->c_lres);
if (rc != 0)
D_GOTO(err_attrs, rc);
rc = rdb_path_push(&p->c_lres, &ds_cont_prop_lres);
if (rc != 0)
D_GOTO(err_lres, rc);
/* c_lhes */
rc = rdb_path_clone(&p->c_prop, &p->c_lhes);
if (rc != 0)
D_GOTO(err_lres, rc);
rc = rdb_path_push(&p->c_lhes, &ds_cont_prop_lhes);
if (rc != 0)
D_GOTO(err_lhes, rc);
/* c_snaps */
rc = rdb_path_clone(&p->c_prop, &p->c_snaps);
if (rc != 0)
D_GOTO(err_lhes, rc);
rc = rdb_path_push(&p->c_snaps, &ds_cont_prop_snapshots);
if (rc != 0)
D_GOTO(err_snaps, rc);
/* c_user */
rc = rdb_path_clone(&p->c_prop, &p->c_user);
if (rc != 0)
D_GOTO(err_snaps, rc);
rc = rdb_path_push(&p->c_user, &ds_cont_attr_user);
if (rc != 0)
D_GOTO(err_user, rc);
*cont = p;
return 0;
err_user:
rdb_path_fini(&p->c_user);
err_snaps:
rdb_path_fini(&p->c_snaps);
err_lhes:
rdb_path_fini(&p->c_lhes);
err_lres:
rdb_path_fini(&p->c_lres);
err_attrs:
rdb_path_fini(&p->c_prop);
err_p:
D_FREE(p);
err:
return rc;
}
static DFBResult
Construct( IDirectFBImageProvider *thiz,
... )
{
DFBResult ret = DFB_FAILURE;
IDirectFBDataBuffer *buffer;
CoreDFB *core;
va_list tag;
DIRECT_ALLOCATE_INTERFACE_DATA(thiz, IDirectFBImageProvider_PNG)
va_start( tag, thiz );
buffer = va_arg( tag, IDirectFBDataBuffer * );
core = va_arg( tag, CoreDFB * );
va_end( tag );
data->ref = 1;
data->buffer = buffer;
data->core = core;
/* Increase the data buffer reference counter. */
buffer->AddRef( buffer );
/* Create the PNG read handle. */
data->png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
NULL, NULL, NULL );
if (!data->png_ptr)
goto error;
if (setjmp( data->png_ptr->jmpbuf )) {
D_ERROR( "ImageProvider/PNG: Error reading header!\n" );
goto error;
}
/* Create the PNG info handle. */
data->info_ptr = png_create_info_struct( data->png_ptr );
if (!data->info_ptr)
goto error;
/* Setup progressive image loading. */
png_set_progressive_read_fn( data->png_ptr, data,
png_info_callback,
png_row_callback,
png_end_callback );
/* Read until info callback is called. */
ret = push_data_until_stage( data, STAGE_INFO, 64 );
if (ret)
goto error;
thiz->AddRef = IDirectFBImageProvider_PNG_AddRef;
thiz->Release = IDirectFBImageProvider_PNG_Release;
thiz->RenderTo = IDirectFBImageProvider_PNG_RenderTo;
thiz->SetRenderCallback = IDirectFBImageProvider_PNG_SetRenderCallback;
thiz->GetImageDescription = IDirectFBImageProvider_PNG_GetImageDescription;
thiz->GetSurfaceDescription = IDirectFBImageProvider_PNG_GetSurfaceDescription;
return DFB_OK;
error:
if (data->png_ptr)
png_destroy_read_struct( &data->png_ptr, &data->info_ptr, NULL );
buffer->Release( buffer );
if (data->image)
D_FREE( data->image );
DIRECT_DEALLOCATE_INTERFACE(thiz);
return ret;
}
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 );
}
Bool
dfb_x11_open_window( DFBX11 *x11, XWindow** ppXW, int iXPos, int iYPos, int iWidth, int iHeight, DFBSurfacePixelFormat format )
{
XWindow *xw;
XSetWindowAttributes attr = { .background_pixmap = 0 };
void *old_error_handler = 0;
unsigned int cw_mask = CWEventMask;
D_DEBUG_AT( X11_Window, "Creating %4dx%4d %s window...\n", iWidth, iHeight, dfb_pixelformat_name(format) );
xw = D_CALLOC( 1, sizeof(XWindow) );
if (!xw)
return D_OOM();
/* We set the structure as needed for our window */
xw->width = iWidth;
xw->height = iHeight;
xw->display = x11->display;
xw->screenptr = DefaultScreenOfDisplay(xw->display);
xw->screennum = DefaultScreen(xw->display);
xw->depth = DefaultDepthOfScreen(xw->screenptr);
xw->visual = DefaultVisualOfScreen(xw->screenptr);
attr.event_mask =
ButtonPressMask
| ButtonReleaseMask
| PointerMotionMask
| KeyPressMask
| KeyReleaseMask
| ExposureMask
| StructureNotifyMask;
if (dfb_config->x11_borderless) {
attr.override_redirect = True;
cw_mask |= CWOverrideRedirect;
}
XLockDisplay( x11->display );
old_error_handler = XSetErrorHandler( error_handler );
error_code = 0;
xw->window = XCreateWindow( xw->display,
RootWindowOfScreen(xw->screenptr),
iXPos, iYPos, iWidth, iHeight, 0, xw->depth, InputOutput,
xw->visual, cw_mask, &attr );
XSync( xw->display, False );
if (!xw->window || error_code) {
D_FREE( xw );
XUnlockDisplay( x11->display );
return False;
}
XSizeHints Hints;
/*
* Here we inform the function of what we are going to change for the
* window (there's also PPosition but it's obsolete)
*/
Hints.flags = PSize | PMinSize | PMaxSize;
/*
* Now we set the structure to the values we need for width & height.
* For esthetic reasons we set Width=MinWidth=MaxWidth.
* The same goes for Height. You can try whith differents values, or
* let's use Hints.flags=Psize; and resize your window..
*/
Hints.min_width = Hints.max_width = Hints.base_width = xw->width;
Hints.min_height = Hints.max_height = Hints.base_height = xw->height;
/* Now we can set the size hints for the specified window */
XSetWMNormalHints(xw->display,xw->window,&Hints);
/* We change the title of the window (default:Untitled) */
XStoreName(xw->display,xw->window,"DFB X11 system window");
xw->gc = XCreateGC(xw->display, xw->window, 0, NULL);
#if 0
// Create a null cursor
Pixmap pixmp1;
Pixmap pixmp2;
XColor fore;
XColor back;
char zero = 0;
pixmp1 = XCreateBitmapFromData( xw->display, xw->window, &zero, 1, 1 );
pixmp2 = XCreateBitmapFromData( xw->display, xw->window, &zero, 1, 1 );
xw->NullCursor = XCreatePixmapCursor( xw->display, pixmp1, pixmp2, &fore, &back, 0, 0 );
XFreePixmap ( xw->display, pixmp1 );
XFreePixmap ( xw->display, pixmp2 );
XDefineCursor( xw->display, xw->window, xw->NullCursor );
#endif
/* maps the window and raises it to the top of the stack */
XMapRaised( xw->display, xw->window );
if (x11->use_shm) {
// Shared memory
xw->shmseginfo=(XShmSegmentInfo *)D_CALLOC(1, sizeof(XShmSegmentInfo));
if (!xw->shmseginfo) {
x11->use_shm = false;
goto no_shm;
}
xw->ximage=XShmCreateImage(xw->display, xw->visual, xw->depth, ZPixmap,
NULL,xw->shmseginfo, xw->width, xw->height * 2);
XSync( xw->display, False );
if (!xw->ximage || error_code) {
D_ERROR("X11: Error creating shared image (XShmCreateImage) \n");
x11->use_shm = false;
D_FREE(xw->shmseginfo);
error_code = 0;
goto no_shm;
}
xw->bpp = (xw->ximage->bits_per_pixel + 7) / 8;
/* we firstly create our shared memory segment with the size we need, and
correct permissions for the owner, the group and the world --> 0777 */
xw->shmseginfo->shmid=shmget(IPC_PRIVATE,
xw->ximage->bytes_per_line * xw->ximage->height * 2,
IPC_CREAT|0777);
if (xw->shmseginfo->shmid<0) {
x11->use_shm = false;
XDestroyImage(xw->ximage);
D_FREE(xw->shmseginfo);
goto no_shm;
}
/* Then, we have to attach the segment to our process, and we let the
function search the correct memory place --> NULL. It's safest ! */
xw->shmseginfo->shmaddr = shmat( xw->shmseginfo->shmid, NULL, 0 );
if (!xw->shmseginfo->shmaddr) {
x11->use_shm = false;
shmctl(xw->shmseginfo->shmid,IPC_RMID,NULL);
XDestroyImage(xw->ximage);
D_FREE(xw->shmseginfo);
goto no_shm;
}
/* We set the buffer in Read and Write mode */
xw->shmseginfo->readOnly=False;
xw->virtualscreen= xw->ximage->data = xw->shmseginfo->shmaddr;
XSetErrorHandler( error_handler_shm );
XShmAttach(x11->display,xw->shmseginfo);
XShmPutImage(x11->display, xw->window, xw->gc, xw->ximage,
0, 0, 0, 0, 1, 1, False);
XSync(x11->display, False);
XSetErrorHandler( error_handler );
if (!x11->use_shm) {
shmdt(xw->shmseginfo->shmaddr);
shmctl(xw->shmseginfo->shmid,IPC_RMID,NULL);
XDestroyImage(xw->ximage);
D_FREE(xw->shmseginfo);
}
}
no_shm:
if (!x11->use_shm) {
int pitch;
xw->bpp = (xw->depth > 16) ? 4 :
(xw->depth > 8) ? 2 : 1;
pitch = (xw->bpp * xw->width + 3) & ~3;
/* Use malloc(), not D_MALLOC() here, because XCreateImage()
* will call free() on this data.
*/
xw->virtualscreen = malloc ( 2 * xw->height * pitch );
xw->ximage = XCreateImage( xw->display, xw->visual, xw->depth, ZPixmap, 0,
xw->virtualscreen, xw->width, xw->height * 2, 32, pitch );
XSync( xw->display, False );
if (!xw->ximage || error_code) {
D_ERROR( "X11/Window: XCreateImage( Visual %02lu, depth %d, size %dx%d, buffer %p [%d] ) failed!\n",
xw->visual->visualid, xw->depth, xw->width, xw->height * 2, xw->virtualscreen, pitch );
XFreeGC(xw->display,xw->gc);
XDestroyWindow(xw->display,xw->window);
XSetErrorHandler( old_error_handler );
XUnlockDisplay( x11->display );
D_FREE( xw );
return False;
}
}
XSetErrorHandler( old_error_handler );
XUnlockDisplay( x11->display );
D_INFO( "X11/Display: %ssing XShm.\n", x11->use_shm ? "U" : "Not u" );
(*ppXW) = xw;
return True;
}
void
dfb_x11_close_window( DFBX11 *x11, XWindow* xw )
{
if (x11->use_shm) {
XShmDetach( xw->display, xw->shmseginfo );
shmdt( xw->shmseginfo->shmaddr );
shmctl( xw->shmseginfo->shmid, IPC_RMID, NULL );
D_FREE( xw->shmseginfo );
}
XDestroyImage( xw->ximage );
XFreeGC( xw->display, xw->gc );
XDestroyWindow( xw->display, xw->window );
#if 0
XFreeCursor( xw->display, xw->NullCursor );
#endif
D_FREE( xw );
}
void
_fusion_call_process( FusionWorld *world, int call_id, FusionCallMessage *msg, void *ptr )
{
FusionCallHandlerResult result = FCHR_RETURN;
FusionCallHandler call_handler;
FusionCallReturn call_ret = {
.val = 0
};
D_DEBUG_AT( Fusion_Call, "%s( call_id %d, msg %p, ptr %p)\n", __FUNCTION__, call_id, msg, ptr );
D_MAGIC_ASSERT( world, FusionWorld );
D_ASSERT( msg != NULL );
D_ASSERT( msg->handler != NULL );
call_handler = msg->handler;
if (direct_log_domain_check( &Fusion_Call )) // avoid call to direct_trace_lookup_symbol_at
D_DEBUG_AT( Fusion_Call, " -> %s\n", direct_trace_lookup_symbol_at( call_handler ) );
result = call_handler( msg->caller, msg->call_arg, ptr ? ptr : msg->call_ptr, msg->ctx, msg->serial, &call_ret.val );
switch (result) {
case FCHR_RETURN:
if (msg->serial) {
call_ret.serial = msg->serial;
call_ret.call_id = call_id;
while (ioctl (world->fusion_fd, FUSION_CALL_RETURN, &call_ret)) {
switch (errno) {
case EINTR:
continue;
case EIDRM:
D_WARN( "caller withdrawn (signal?)" );
return;
case EINVAL:
D_ERROR( "Fusion/Call: invalid call\n" );
return;
default:
D_PERROR( "FUSION_CALL_RETURN" );
return;
}
}
}
break;
case FCHR_RETAIN:
break;
default:
D_BUG( "unknown result %d from call handler", result );
}
}
void
_fusion_call_process3( FusionWorld *world, int call_id, FusionCallMessage3 *msg, void *ptr )
{
FusionCallHandlerResult result = FCHR_RETURN;
FusionCallHandler3 call_handler;
FusionCallReturn3 call_ret;
char *ret_ptr = NULL;
unsigned int ret_length = 0;
D_DEBUG_AT( Fusion_Call, "%s( call_id %d, msg %p, ptr %p)\n", __FUNCTION__, call_id, msg, ptr );
D_MAGIC_ASSERT( world, FusionWorld );
D_ASSERT( msg != NULL );
D_ASSERT( msg->handler != NULL );
call_handler = msg->handler;
if (direct_log_domain_check( &Fusion_Call )) // avoid call to direct_trace_lookup_symbol_at
D_DEBUG_AT( Fusion_Call, " -> %s\n", direct_trace_lookup_symbol_at( call_handler ) );
if (msg->ret_length > FUSION_CALL_RETURN_DATA_MAX) {
D_ERROR( "Fusion/Call: Maximum return data length (%u) exceeded (%u)!\n", FUSION_CALL_RETURN_DATA_MAX, msg->ret_length );
}
else {
if (msg->ret_length > FUSION_CALL_RETURN_DATA_MAX_ON_STACK) {
ret_ptr = D_MALLOC( msg->ret_length );
if (!ret_ptr)
D_OOM();
}
else
ret_ptr = alloca( msg->ret_length );
}
if (ret_ptr)
result = call_handler( msg->caller, msg->call_arg, ptr ? ptr : msg->call_ptr, msg->call_length, msg->ctx, msg->serial, ret_ptr, msg->ret_length, &ret_length );
switch (result) {
case FCHR_RETURN:
if (msg->serial) {
call_ret.call_id = call_id;
call_ret.serial = msg->serial;
call_ret.ptr = ret_ptr;
call_ret.length = ret_length;
while (ioctl (world->fusion_fd, FUSION_CALL_RETURN3, &call_ret)) {
switch (errno) {
case EINTR:
continue;
case EIDRM:
D_DEBUG_AT( Fusion_Call, " -> caller withdrawn (signal?)\n" );
goto out;
case EINVAL:
D_ERROR( "Fusion/Call: invalid call\n" );
goto out;
default:
D_PERROR( "FUSION_CALL_RETURN3" );
goto out;
}
}
}
break;
case FCHR_RETAIN:
break;
default:
D_BUG( "unknown result %d from call handler", result );
}
out:
if (msg->ret_length > FUSION_CALL_RETURN_DATA_MAX_ON_STACK)
D_FREE( ret_ptr );
}
DirectResult
voodoo_link_init_connect( VoodooLink *link,
const char *hostname,
int port,
bool raw )
{
DirectResult ret;
int err;
struct addrinfo hints;
struct addrinfo *addr;
char portstr[10];
Link *l;
memset( &hints, 0, sizeof(hints) );
hints.ai_flags = AI_CANONNAME;
hints.ai_socktype = SOCK_STREAM;
hints.ai_family = PF_UNSPEC;
D_INFO( "Voodoo/Link: Looking up host '%s'...\n", hostname );
snprintf( portstr, sizeof(portstr), "%d", port );
err = getaddrinfo( hostname, portstr, &hints, &addr );
if (err) {
switch (err) {
case EAI_FAMILY:
D_ERROR( "Direct/Log: Unsupported address family!\n" );
return DR_UNSUPPORTED;
case EAI_SOCKTYPE:
D_ERROR( "Direct/Log: Unsupported socket type!\n" );
return DR_UNSUPPORTED;
case EAI_NONAME:
D_ERROR( "Direct/Log: Host not found!\n" );
return DR_FAILURE;
case EAI_SERVICE:
D_ERROR( "Direct/Log: Service is unreachable!\n" );
return DR_FAILURE;
#ifdef EAI_ADDRFAMILY
case EAI_ADDRFAMILY:
#endif
case EAI_NODATA:
D_ERROR( "Direct/Log: Host found, but has no address!\n" );
return DR_FAILURE;
case EAI_MEMORY:
return D_OOM();
case EAI_FAIL:
D_ERROR( "Direct/Log: A non-recoverable name server error occurred!\n" );
return DR_FAILURE;
case EAI_AGAIN:
D_ERROR( "Direct/Log: Temporary error, try again!\n" );
return DR_TEMPUNAVAIL;
default:
D_ERROR( "Direct/Log: Unknown error occured!?\n" );
return DR_FAILURE;
}
}
l = D_CALLOC( 1, sizeof(Link) );
if (!l)
return D_OOM();
/* Create the client socket. */
l->fd[0] = socket( addr->ai_family, SOCK_STREAM, 0 );
if (l->fd[0] < 0) {
ret = errno2result( errno );
D_PERROR( "Voodoo/Link: Socket creation failed!\n" );
freeaddrinfo( addr );
D_FREE( l );
return ret;
}
l->fd[1] = l->fd[0];
#if !VOODOO_BUILD_NO_SETSOCKOPT
if (setsockopt( l->fd[0], SOL_IP, IP_TOS, &tos, sizeof(tos) ) < 0)
D_PERROR( "Voodoo/Manager: Could not set IP_TOS!\n" );
if (setsockopt( l->fd[0], SOL_TCP, TCP_NODELAY, &one, sizeof(one) ) < 0)
D_PERROR( "Voodoo/Manager: Could not set TCP_NODELAY!\n" );
#endif
D_INFO( "Voodoo/Link: Connecting to '%s:%d'...\n", addr->ai_canonname, port );
/* Connect to the server. */
err = connect( l->fd[0], addr->ai_addr, addr->ai_addrlen );
freeaddrinfo( addr );
if (err) {
ret = errno2result( errno );
D_PERROR( "Voodoo/Link: Socket connect failed!\n" );
close( l->fd[0] );
D_FREE( l );
return ret;
}
D_INFO( "Voodoo/Link: Connected.\n" );
DUMP_SOCKET_OPTION( l->fd[0], SO_SNDLOWAT );
DUMP_SOCKET_OPTION( l->fd[0], SO_RCVLOWAT );
DUMP_SOCKET_OPTION( l->fd[0], SO_SNDBUF );
DUMP_SOCKET_OPTION( l->fd[0], SO_RCVBUF );
if (!raw) {
link->code = 0x80008676;
if (write( l->fd[1], &link->code, sizeof(link->code) ) != 4) {
D_ERROR( "Voodoo/Link: Coult not write initial four bytes!\n" );
close( l->fd[0] );
D_FREE( l );
return DR_IO;
}
}
D_INFO( "Voodoo/Link: Sent link code (%s).\n", raw ? "raw" : "packet" );
if (pipe( l->wakeup_fds ))
return errno2result( errno );
link->priv = l;
link->Close = Close;
link->Read = Read;
link->Write = Write;
link->SendReceive = SendReceive;
link->WakeUp = WakeUp;
link->WaitForData = WaitForData;
return DR_OK;
}
DFBResult
dfb_core_create( CoreDFB **ret_core )
{
int ret;
#if FUSION_BUILD_MULTI
char buf[16];
#endif
CoreDFB *core = NULL;
CoreDFBShared *shared = NULL;
D_ASSERT( ret_core != NULL );
D_ASSERT( dfb_config != NULL );
D_DEBUG_AT( DirectFB_Core, "%s...\n", __FUNCTION__ );
pthread_mutex_lock( &core_dfb_lock );
D_ASSERT( core_dfb == NULL || core_dfb->refs > 0 );
if (core_dfb) {
D_MAGIC_ASSERT( core_dfb, CoreDFB );
core_dfb->refs++;
*ret_core = core_dfb;
pthread_mutex_unlock( &core_dfb_lock );
return DFB_OK;
}
direct_initialize();
D_INFO( "DirectFB/Core: %s Application Core. ("BUILDTIME") %s%s\n",
FUSION_BUILD_MULTI ? "Multi" : "Single",
DIRECT_BUILD_DEBUG ? "[ DEBUG ]" : "",
DIRECT_BUILD_TRACE ? "[ TRACE ]" : "" );
#if defined(DFB_DYNAMIC_LINKING) && defined(SOPATH)
if (!dfb_lib_handle)
#ifdef RTLD_GLOBAL
dfb_lib_handle = dlopen(SOPATH, RTLD_GLOBAL|RTLD_LAZY);
#else
/* RTLD_GLOBAL is not defined on OpenBSD */
dfb_lib_handle = dlopen(SOPATH, RTLD_LAZY);
#endif
#endif
ret = dfb_system_lookup();
if (ret)
goto error;
/* Allocate local core structure. */
core = D_CALLOC( 1, sizeof(CoreDFB) );
if (!core) {
ret = D_OOM();
goto error;
}
core->refs = 1;
core->init_handler = direct_thread_add_init_handler( dfb_core_thread_init_handler, core );
#if FUSION_BUILD_MULTI
dfb_system_thread_init();
#endif
direct_find_best_memcpy();
D_MAGIC_SET( core, CoreDFB );
core_dfb = core;
ret = fusion_enter( dfb_config->session, DIRECTFB_CORE_ABI, FER_ANY, &core->world );
if (ret)
goto error;
core->fusion_id = fusion_id( core->world );
#if FUSION_BUILD_MULTI
D_DEBUG_AT( DirectFB_Core, "world %d, fusion id %d\n", fusion_world_index(core->world), core->fusion_id );
snprintf( buf, sizeof(buf), "%d", fusion_world_index(core->world) );
setenv( "DIRECTFB_SESSION", buf, true );
#endif
if (dfb_config->sync) {
D_INFO( "DirectFB/Core: calling sync()...\n" );
direct_sync();
}
if (dfb_config->core_sighandler)
direct_signal_handler_add( DIRECT_SIGNAL_ANY, dfb_core_signal_handler, core, &core->signal_handler );
if (fusion_arena_enter( core->world, "DirectFB/Core",
dfb_core_arena_initialize, dfb_core_arena_join,
core, &core->arena, &ret ) || ret)
{
ret = ret ? ret : DFB_FUSION;
goto error;
}
shared = core->shared;
D_MAGIC_ASSERT( shared, CoreDFBShared );
if (dfb_config->block_all_signals)
direct_signals_block_all();
if (dfb_config->deinit_check)
direct_cleanup_handler_add( dfb_core_deinit_check, NULL, &core->cleanup_handler );
fusion_skirmish_prevail( &shared->lock );
if (!core->master) {
while (!shared->active)
fusion_skirmish_wait( &shared->lock, 0 );
}
fusion_skirmish_dismiss( &shared->lock );
dfb_font_manager_create( core, &core->font_manager );
*ret_core = core;
pthread_mutex_unlock( &core_dfb_lock );
D_DEBUG_AT( DirectFB_Core, "Core successfully created.\n" );
return DFB_OK;
error:
if (core) {
if (core->world)
fusion_exit( core->world, false );
if (core->init_handler)
direct_thread_remove_init_handler( core->init_handler );
if (core->signal_handler)
direct_signal_handler_remove( core->signal_handler );
D_MAGIC_CLEAR( core );
D_FREE( core );
core_dfb = NULL;
}
pthread_mutex_unlock( &core_dfb_lock );
direct_shutdown();
return ret;
}
static DFBResult
system_initialize( CoreDFB *core, void **data )
{
DFBResult ret;
DFBX11 *x11;
DFBX11Shared *shared;
D_DEBUG_AT( X11_Core, "%s()\n", __FUNCTION__ );
x11 = D_CALLOC( 1, sizeof(DFBX11) );
if (!x11)
return D_OOM();
shared = SHCALLOC( dfb_core_shmpool( core ), 1, sizeof(DFBX11Shared) );
if (!shared) {
D_FREE( x11 );
return D_OOSHM();
}
/* we need the error handler to signal the error to us, so
use a global static */
shared_for_error_handler = shared;
XSetErrorHandler( error_handler );
/*
* Local init (master and slave)
*/
ret = InitLocal( x11, shared, core );
if (ret) {
SHFREE( dfb_core_shmpool( core ), shared );
D_FREE( x11 );
return ret;
}
/*
* Shared init (master only)
*/
shared->data_shmpool = dfb_core_shmpool_data( core );
shared->screen_size.w = x11->screenptr->width;
shared->screen_size.h = x11->screenptr->height;
fusion_skirmish_init( &shared->lock, "X11 System", dfb_core_world(core) );
fusion_call_init( &shared->call, call_handler, x11, dfb_core_world(core) );
/*
* Must be set before initializing the pools!
*/
*data = x11;
/*
* Master init
*/
dfb_surface_pool_initialize( core, &x11SurfacePoolFuncs, &shared->x11image_pool );
#ifdef USE_GLX
dfb_surface_pool_initialize( core, &glxSurfacePoolFuncs, &shared->glx_pool );
#endif
if (dfb_config->video_length) {
shared->vpsmem_length = dfb_config->video_length;
dfb_surface_pool_initialize( core, &vpsmemSurfacePoolFuncs, &shared->vpsmem_pool );
}
#ifdef USE_GLX
dfb_surface_pool_bridge_initialize( core, &x11SurfacePoolBridgeFuncs, x11, &shared->x11_pool_bridge );
#endif
fusion_arena_add_shared_field( dfb_core_arena( core ), "x11", shared );
return DFB_OK;
}
static DFBResult
IDirectFBImageProvider_JPEG2000_RenderTo( IDirectFBImageProvider *thiz,
IDirectFBSurface *destination,
const DFBRectangle *dest_rect )
{
IDirectFBSurface_data *dst_data;
CoreSurface *dst_surface;
CoreSurfaceBufferLock lock;
DFBRectangle rect;
DFBRegion clip;
DIRenderCallbackResult cb_result = DIRCR_OK;
DFBResult ret = DFB_OK;
DIRECT_INTERFACE_GET_DATA( IDirectFBImageProvider_JPEG2000 )
if (!destination)
return DFB_INVARG;
dst_data = destination->priv;
if (!dst_data || !dst_data->surface)
return DFB_DESTROYED;
dst_surface = dst_data->surface;
if (dest_rect) {
if (dest_rect->w < 1 || dest_rect->h < 1)
return DFB_INVARG;
rect = *dest_rect;
rect.x += dst_data->area.wanted.x;
rect.y += dst_data->area.wanted.y;
}
else {
rect = dst_data->area.wanted;
}
dfb_region_from_rectangle( &clip, &dst_data->area.current );
if (!dfb_rectangle_region_intersects( &rect, &clip ))
return DFB_OK;
ret = dfb_surface_lock_buffer( dst_surface, CSBR_BACK, CSAID_CPU, CSAF_WRITE, &lock );
if (ret)
return ret;
if (!data->buf) {
int cmptlut[3];
int width, height;
int tlx, tly;
int hs, vs;
int i, j;
bool direct, mono;
if (jas_image_numcmpts(data->image) > 1) {
cmptlut[0] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
cmptlut[1] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
cmptlut[2] = jas_image_getcmptbytype(data->image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
if (cmptlut[0] < 0 || cmptlut[1] < 0 || cmptlut[2] < 0) {
dfb_surface_unlock_buffer( dst_surface, &lock );
return DFB_UNSUPPORTED;
}
mono = false;
}
else {
cmptlut[0] = cmptlut[1] = cmptlut[2] = 0;
mono = true;
}
width = jas_image_width(data->image);
height = jas_image_height(data->image);
tlx = jas_image_cmpttlx(data->image, 0);
tly = jas_image_cmpttly(data->image, 0);
hs = jas_image_cmpthstep(data->image, 0);
vs = jas_image_cmptvstep(data->image, 0);
data->buf = D_MALLOC( width*height*4 );
if (!data->buf) {
dfb_surface_unlock_buffer( dst_surface, &lock );
return D_OOM();
}
direct = (rect.w == width && rect.h == height && data->render_callback);
#define GET_SAMPLE( n, x, y ) ({ \
int _s; \
_s = jas_image_readcmptsample(data->image, cmptlut[n], x, y); \
_s >>= jas_image_cmptprec(data->image, cmptlut[n]) - 8; \
if (_s > 255) \
_s = 255; \
else if (_s < 0) \
_s = 0; \
_s; \
})
for (i = 0; i < height; i++) {
u32 *dst = data->buf + i * width;
int x, y;
y = (i - tly) / vs;
if (y >= 0 && y < height) {
for (j = 0; j < width; j++) {
x = (j - tlx) / hs;
if (x >= 0 && x < width) {
unsigned int r, g, b;
if (mono) {
r = g = b = GET_SAMPLE(0, x, y);
}
else {
r = GET_SAMPLE(0, x, y);
g = GET_SAMPLE(1, x, y);
b = GET_SAMPLE(2, x, y);
}
*dst++ = 0xff000000 | (r << 16) | (g << 8) | b;
}
else {
*dst++ = 0;
}
}
}
else {
memset( dst, 0, width*4 );
}
if (direct) {
DFBRectangle r = { rect.x, rect.y+i, width, 1 };
dfb_copy_buffer_32( data->buf + i*width,
lock.addr, lock.pitch, &r, dst_surface, &clip );
if (data->render_callback) {
r = (DFBRectangle) { 0, i, width, 1 };
cb_result = data->render_callback( &r, data->render_callback_ctx );
if (cb_result != DIRCR_OK)
break;
}
}
}
if (!direct) {
dfb_scale_linear_32( data->buf, width, height,
lock.addr, lock.pitch, &rect, dst_surface, &clip );
if (data->render_callback) {
DFBRectangle r = { 0, 0, width, height };
data->render_callback( &r, data->render_callback_ctx );
}
}
if (cb_result != DIRCR_OK) {
D_FREE( data->buf );
data->buf = NULL;
ret = DFB_INTERRUPTED;
}
}
else {
int width = jas_image_width(data->image);
int height = jas_image_height(data->image);
dfb_scale_linear_32( data->buf, width, height,
lock.addr, lock.pitch, &rect, dst_surface, &clip );
if (data->render_callback) {
DFBRectangle r = {0, 0, width, height};
data->render_callback( &r, data->render_callback_ctx );
}
}
dfb_surface_unlock_buffer( dst_surface, &lock );
return ret;
}
DFBResult
dfb_vt_initialize()
{
DFBResult ret;
struct vt_stat vs;
D_DEBUG_AT( VT, "%s()\n", __FUNCTION__ );
dfb_vt = D_CALLOC( 1, sizeof(VirtualTerminal) );
setsid();
dfb_vt->fd0 = open( "/dev/tty0", O_RDONLY | O_NOCTTY );
if (dfb_vt->fd0 < 0) {
if (errno == ENOENT) {
dfb_vt->fd0 = open( "/dev/vc/0", O_RDONLY | O_NOCTTY );
if (dfb_vt->fd0 < 0) {
if (errno == ENOENT) {
D_PERROR( "DirectFB/core/vt: Couldn't open "
"neither `/dev/tty0' nor `/dev/vc/0'!\n" );
}
else {
D_PERROR( "DirectFB/core/vt: "
"Error opening `/dev/vc/0'!\n" );
}
D_FREE( dfb_vt );
dfb_vt = NULL;
return DFB_INIT;
}
}
else {
D_PERROR( "DirectFB/core/vt: Error opening `/dev/tty0'!\n");
D_FREE( dfb_vt );
dfb_vt = NULL;
return DFB_INIT;
}
}
if (ioctl( dfb_vt->fd0, VT_GETSTATE, &vs ) < 0) {
D_PERROR( "DirectFB/core/vt: VT_GETSTATE failed!\n" );
close( dfb_vt->fd0 );
D_FREE( dfb_vt );
dfb_vt = NULL;
return DFB_INIT;
}
dfb_vt->prev = vs.v_active;
if (!dfb_config->vt_switch) {
if (dfb_config->vt_num != -1)
dfb_vt->num = dfb_config->vt_num;
else
dfb_vt->num = dfb_vt->prev;
/* move vt to framebuffer */
dfb_vt->old_fb = vt_get_fb( dfb_vt->num );
vt_set_fb( dfb_vt->num, -1 );
}
else {
if (dfb_config->vt_num == -1) {
int n;
n = ioctl( dfb_vt->fd0, VT_OPENQRY, &dfb_vt->num );
if (n < 0 || dfb_vt->num == -1) {
D_PERROR( "DirectFB/core/vt: Cannot allocate VT!\n" );
close( dfb_vt->fd0 );
D_FREE( dfb_vt );
dfb_vt = NULL;
return DFB_INIT;
}
}
else {
dfb_vt->num = dfb_config->vt_num;
}
/* move vt to framebuffer */
dfb_vt->old_fb = vt_get_fb( dfb_vt->num );
vt_set_fb( dfb_vt->num, -1 );
/* switch to vt */
while (ioctl( dfb_vt->fd0, VT_ACTIVATE, dfb_vt->num ) < 0) {
if (errno == EINTR)
continue;
D_PERROR( "DirectFB/core/vt: VT_ACTIVATE failed!\n" );
close( dfb_vt->fd0 );
D_FREE( dfb_vt );
dfb_vt = NULL;
return DFB_INIT;
}
while (ioctl( dfb_vt->fd0, VT_WAITACTIVE, dfb_vt->num ) < 0) {
if (errno == EINTR)
continue;
D_PERROR( "DirectFB/core/vt: VT_WAITACTIVE failed!\n" );
close( dfb_vt->fd0 );
D_FREE( dfb_vt );
dfb_vt = NULL;
return DFB_INIT;
}
usleep( 40000 );
}
ret = vt_init_switching();
if (ret) {
if (dfb_config->vt_switch) {
D_DEBUG_AT( VT, " -> switching back...\n" );
ioctl( dfb_vt->fd0, VT_ACTIVATE, dfb_vt->prev );
ioctl( dfb_vt->fd0, VT_WAITACTIVE, dfb_vt->prev );
D_DEBUG_AT( VT, " -> ...switched back\n" );
ioctl( dfb_vt->fd0, VT_DISALLOCATE, dfb_vt->num );
}
close( dfb_vt->fd0 );
D_FREE( dfb_vt );
dfb_vt = NULL;
return ret;
}
dfb_fbdev->vt = dfb_vt;
return DFB_OK;
}
DirectResult
voodoo_link_init_local( VoodooLink *link,
const char *path,
bool raw )
{
DirectResult ret;
int err;
struct sockaddr_un addr;
Link *l;
D_ASSERT( link != NULL );
D_ASSERT( path != NULL );
l = D_CALLOC( 1, sizeof(Link) );
if (!l)
return D_OOM();
/* Create the client socket. */
l->fd[0] = socket( AF_LOCAL, SOCK_STREAM, 0 );
if (l->fd[0] < 0) {
ret = errno2result( errno );
D_PERROR( "Voodoo/Link: Socket creation failed!\n" );
D_FREE( l );
return ret;
}
l->fd[1] = l->fd[0];
#if !VOODOO_BUILD_NO_SETSOCKOPT
if (setsockopt( l->fd[0], SOL_IP, IP_TOS, &tos, sizeof(tos) ) < 0)
D_PERROR( "Voodoo/Manager: Could not set IP_TOS!\n" );
if (setsockopt( l->fd[0], SOL_TCP, TCP_NODELAY, &one, sizeof(one) ) < 0)
D_PERROR( "Voodoo/Manager: Could not set TCP_NODELAY!\n" );
#endif
D_INFO( "Voodoo/Link: Connecting to '%s'...\n", path );
memset( &addr, 0, sizeof(addr) );
/* Bind the socket to the local port. */
addr.sun_family = AF_UNIX;
snprintf( addr.sun_path + 1, UNIX_PATH_MAX - 1, "%s", path );
/* Connect to the server. */
err = connect( l->fd[0], (struct sockaddr*) &addr, strlen(addr.sun_path+1)+1 + sizeof(addr.sun_family) );
if (err) {
ret = errno2result( errno );
D_PERROR( "Voodoo/Link: Socket connect failed!\n" );
close( l->fd[0] );
D_FREE( l );
return ret;
}
D_INFO( "Voodoo/Link: Connected.\n" );
DUMP_SOCKET_OPTION( l->fd[0], SO_SNDLOWAT );
DUMP_SOCKET_OPTION( l->fd[0], SO_RCVLOWAT );
DUMP_SOCKET_OPTION( l->fd[0], SO_SNDBUF );
DUMP_SOCKET_OPTION( l->fd[0], SO_RCVBUF );
if (!raw) {
link->code = 0x80008676;
if (write( l->fd[1], &link->code, sizeof(link->code) ) != 4) {
D_ERROR( "Voodoo/Link: Coult not write initial four bytes!\n" );
close( l->fd[0] );
D_FREE( l );
return DR_IO;
}
}
D_INFO( "Voodoo/Link: Sent link code (%s).\n", raw ? "raw" : "packet" );
if (pipe( l->wakeup_fds ))
return errno2result( errno );
link->priv = l;
link->Close = Close;
link->Read = Read;
link->Write = Write;
link->SendReceive = SendReceive;
link->WakeUp = WakeUp;
link->WaitForData = WaitForData;
return DR_OK;
}
static void
dump_outputs( IDirectFBScreen *screen,
int num )
{
int i, n;
DFBResult ret;
DFBScreenOutputDescription *descs;
descs = D_CALLOC( num, sizeof(*descs) );
if (!descs) {
D_OOM();
return;
}
ret = screen->GetOutputDescriptions( screen, descs );
if (ret) {
DirectFBError( "IDirectFBScreen::GetOutputDescriptions", ret );
D_FREE( descs );
return;
}
for (i=0; i<num; i++) {
printf( " Output (%d) %s\n", i, descs[i].name );
/* Caps */
printf( " Caps: " );
for (n=0; output_caps[n].capability; n++) {
if (descs[i].caps & output_caps[n].capability)
printf( "%s ", output_caps[n].name );
}
printf( "\n" );
/* Connectors */
if (descs[i].caps & DSOCAPS_CONNECTORS) {
printf( " Connectors: " );
for (n=0; connectors[n].connector; n++) {
if (descs[i].all_connectors & connectors[n].connector)
printf( "%s ", connectors[n].name );
}
printf( "\n" );
}
/* Output Resolutions */
if (descs[i].caps & DSOCAPS_RESOLUTION) {
printf( " Resolutions: " );
for (n=0; resolutions[n].resolution; n++) {
if (descs[i].all_resolutions & resolutions[n].resolution)
printf( "%s ", resolutions[n].name );
}
printf( "\n" );
}
/* Signals */
printf( " Signals: " );
for (n=0; signals[n].signal; n++) {
if (descs[i].all_signals & signals[n].signal)
printf( "%s ", signals[n].name );
}
printf( "\n" );
printf( "\n" );
}
printf( "\n" );
D_FREE( descs );
}
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_vt_shutdown( bool emergency )
{
const char cursoron_str[] = "\033[?0;0;0c";
const char blankon_str[] = "\033[9;10]";
D_DEBUG_AT( VT, "%s()\n", __FUNCTION__ );
if (!dfb_vt)
return DFB_OK;
if (dfb_config->vt_switching) {
if (ioctl( dfb_vt->fd, VT_SETMODE, &dfb_vt->vt_mode ) < 0)
D_PERROR( "DirectFB/fbdev/vt: Unable to restore VT mode!!!\n" );
sigaction( SIG_SWITCH_FROM, &dfb_vt->sig_usr1, NULL );
sigaction( SIG_SWITCH_TO, &dfb_vt->sig_usr2, NULL );
direct_thread_cancel( dfb_vt->thread );
direct_thread_join( dfb_vt->thread );
direct_thread_destroy( dfb_vt->thread );
pthread_mutex_destroy( &dfb_vt->lock );
pthread_cond_destroy( &dfb_vt->wait );
}
if (dfb_config->kd_graphics) {
if (ioctl( dfb_vt->fd, KDSETMODE, KD_TEXT ) < 0)
D_PERROR( "DirectFB/Keyboard: KD_TEXT failed!\n" );
}
else {
write( dfb_vt->fd, blankon_str, sizeof(blankon_str) );
}
write( dfb_vt->fd, cursoron_str, sizeof(cursoron_str) );
if (dfb_config->vt_switch) {
D_DEBUG_AT( VT, " -> switching back...\n" );
if (ioctl( dfb_vt->fd0, VT_ACTIVATE, dfb_vt->prev ) < 0)
D_PERROR( "DirectFB/core/vt: VT_ACTIVATE" );
if (ioctl( dfb_vt->fd0, VT_WAITACTIVE, dfb_vt->prev ) < 0)
D_PERROR( "DirectFB/core/vt: VT_WAITACTIVE" );
D_DEBUG_AT( VT, " -> switched back...\n" );
usleep( 40000 );
/* restore con2fbmap */
vt_set_fb( dfb_vt->num, dfb_vt->old_fb );
if (close( dfb_vt->fd ) < 0)
D_PERROR( "DirectFB/core/vt: Unable to "
"close file descriptor of allocated VT!\n" );
if (ioctl( dfb_vt->fd0, VT_DISALLOCATE, dfb_vt->num ) < 0)
D_PERROR( "DirectFB/core/vt: Unable to disallocate VT!\n" );
}
else {
/* restore con2fbmap */
vt_set_fb( dfb_vt->num, dfb_vt->old_fb );
if (close( dfb_vt->fd ) < 0)
D_PERROR( "DirectFB/core/vt: Unable to "
"close file descriptor of current VT!\n" );
}
if (close( dfb_vt->fd0 ) < 0)
D_PERROR( "DirectFB/core/vt: Unable to "
"close file descriptor of tty0!\n" );
D_FREE( dfb_vt );
dfb_vt = dfb_fbdev->vt = NULL;
return DFB_OK;
}