void
fusion_exit( bool emergency )
{
fusion_dbg_print_memleaks();
direct_shutdown();
}
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();
}
int
main( int argc, char *argv[] )
{
DirectClock clock;
int counter = 0;
int res;
(void)res;
/* Initialize libdirect. */
direct_initialize();
// direct_config->log_level = DIRECT_LOG_ALL;
direct_log_domain_config_level( "Voodoo/Input", DIRECT_LOG_DEBUG_9 );
direct_log_domain_config_level( "Voodoo/Output", DIRECT_LOG_DEBUG_9 );
direct_log_domain_config_level( "Voodoo/Dispatch", DIRECT_LOG_DEBUG_9 );
direct_log_domain_config_level( "Voodoo/Manager", DIRECT_LOG_DEBUG_9 );
int pipe_1[2];
int pipe_2[2];
// int socket[2];
int fds_server[2];
int fds_client[2];
VoodooLink voodoo_link_server;
VoodooLink voodoo_link_client;
VoodooManager *manager_server;
VoodooManager *manager_client;
VoodooInstanceID instance;
// socketpair( PF_LOCAL, SOCK_STREAM, 0, fd );
res = pipe( pipe_1 );
res = pipe( pipe_2 );
fds_server[0] = pipe_1[0];
fds_server[1] = pipe_2[1];
fds_client[0] = pipe_2[0];
fds_client[1] = pipe_1[1];
voodoo_link_init_fd( &voodoo_link_server, fds_server );
voodoo_manager_create( &voodoo_link_server, NULL, NULL, &manager_server );
voodoo_manager_register_local( manager_server, VOODOO_INSTANCE_NONE, NULL, NULL, Dispatch, &instance );
voodoo_link_init_fd( &voodoo_link_client, fds_client );
voodoo_manager_create( &voodoo_link_client, NULL, NULL, &manager_client );
direct_clock_start( &clock );
#if !BENCH_SYNC
do {
voodoo_manager_request( manager_client, instance,
VOODOOTEST_METHOD_ID_Push, VREQ_NONE, NULL,
VMBT_INT, counter++,
VMBT_NONE );
} while (counter < NUM_ITEMS);
#else
do {
VoodooResponseMessage *response;
voodoo_manager_request( manager_client, instance,
VOODOOTEST_METHOD_ID_Sync, VREQ_RESPOND, &response,
VMBT_NONE );
voodoo_manager_finish_request( manager_client, response );
counter++;
} while (counter < NUM_ITEMS);
#endif
{
VoodooResponseMessage *response;
voodoo_manager_request( manager_client, instance,
VOODOOTEST_METHOD_ID_Sync, VREQ_RESPOND, &response,
VMBT_NONE );
voodoo_manager_finish_request( manager_client, response );
}
direct_clock_stop( &clock );
D_INFO( "Voodoo/Test: Stopped after %lld.%03lld seconds... (%lld items/sec)\n",
DIRECT_CLOCK_DIFF_SEC_MS( &clock ), NUM_ITEMS * 1000000ULL / direct_clock_diff( &clock ) );
/* Shutdown libdirect. */
direct_shutdown();
return 0;
}
int
main( int argc, char *argv[] )
{
DirectClock clock;
int counter = 0;
dfb_config_init( &argc, &argv );
/* Initialize libdirect. */
direct_initialize();
VoodooLink link;
VoodooManager *manager;
const char *hostname = argv[1] ?: "127.0.0.1";
voodoo_link_init_connect( &link, hostname, 23239, false );
voodoo_manager_create( &link, NULL, NULL, &manager );
direct_clock_start( &clock );
#if !BENCH_SYNC
do {
voodoo_manager_request( manager, 1,
VOODOOTEST_METHOD_ID_Push, VREQ_QUEUE, NULL,
VMBT_INT, counter++,
VMBT_NONE );
} while (counter < NUM_ITEMS);
#else
do {
VoodooResponseMessage *response;
voodoo_manager_request( manager, 1,
VOODOOTEST_METHOD_ID_Sync, VREQ_RESPOND, &response,
VMBT_NONE );
voodoo_manager_finish_request( manager, response );
counter++;
} while (counter < NUM_ITEMS);
#endif
{
VoodooResponseMessage *response;
voodoo_manager_request( manager, 1,
VOODOOTEST_METHOD_ID_Sync, VREQ_RESPOND, &response,
VMBT_NONE );
voodoo_manager_finish_request( manager, response );
}
direct_clock_stop( &clock );
D_INFO( "Voodoo/Test: Stopped after %lld.%03lld seconds... (%lld items/sec)\n",
DIRECT_CLOCK_DIFF_SEC_MS( &clock ), NUM_ITEMS * 1000000LL / direct_clock_diff( &clock ) );
/* Shutdown libdirect. */
direct_shutdown();
return 0;
}
int
main( int argc, char *argv[] )
{
int i;
DirectResult ret;
DirectLogType log_type = DLT_STDERR;
const char *log_param = NULL;
DirectLog *log;
for (i=1; i<argc; i++) {
if (!strcmp( argv[i], "-f" )) {
if (++i < argc) {
log_type = DLT_FILE;
log_param = argv[i];
}
else
return show_usage(argv[0]);
}
else if (!strcmp( argv[i], "-u" )) {
if (++i < argc) {
log_type = DLT_UDP;
log_param = argv[i];
}
else
return show_usage(argv[0]);
}
else
return show_usage(argv[0]);
}
/* Initialize logging. */
ret = direct_log_create( log_type, log_param, &log );
if (ret)
return -1;
/* Set default log to use. */
direct_log_set_default( log );
/* Test memory leak detector by not freeing this one. */
D_MALLOC( 1351 );
D_INFO( "Direct/Test: Application starting...\n" );
/* Initialize libdirect. */
direct_initialize();
D_INFO( "Direct/Test: Application stopping...\n" );
/* Shutdown libdirect. */
direct_shutdown();
D_INFO( "Direct/Test: You should see a leak message with debug-mem turned on...\n" );
/* Shutdown logging. */
direct_log_destroy( log );
direct_config->debug = true;
direct_print_memleaks();
return 0;
}
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;
}
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;
}
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;
}
int
main( int argc, char *argv[] )
{
int ret;
int fd;
struct stat stat;
void *ptr = MAP_FAILED;
Entity::vector faces;
DGIFFHeader header = {
magic: { 'D', 'G', 'I', 'F', 'F' },
major: 0,
minor: 0,
flags: DGIFF_FLAG_LITTLE_ENDIAN,
num_faces: 0
};
direct_initialize();
direct_debug_config_domain( "mkdgiff", true );
direct_config->debug = true;
direct_config->debugmem = true;
/* Parse the command line. */
if (!parse_command_line( argc, argv ))
return -1;
/* Open the file. */
fd = open( filename, O_RDONLY );
if (fd < 0) {
ret = errno2result( errno );
D_PERROR( "Font/DGIFF: Failure during open() of '%s'!\n", filename );
return ret;
}
/* Query file size etc. */
if (fstat( fd, &stat ) < 0) {
ret = errno2result( errno );
D_PERROR( "Font/DGIFF: Failure during fstat() of '%s'!\n", filename );
goto out;
}
/* Memory map the file. */
ptr = mmap( NULL, stat.st_size, PROT_READ, MAP_SHARED, fd, 0 );
if (ptr == MAP_FAILED) {
ret = errno2result( errno );
D_PERROR( "Font/DGIFF: Failure during mmap() of '%s'!\n", filename );
goto out;
}
get_entities( (const char*) ptr, stat.st_size, faces );
header.num_faces = faces.size();
fwrite( &header, sizeof(header), 1, stdout );
for (Entity::vector::const_iterator iter = faces.begin(); iter != faces.end(); iter++) {
const Face *face = dynamic_cast<const Face*>( *iter );
face->Dump();
ret = do_face( face );
if (ret)
goto out;
}
out:
if (ptr != MAP_FAILED)
munmap( ptr, stat.st_size );
close( fd );
direct_print_memleaks();
direct_shutdown();
return ret;
}
