void
_fusion_call_process( FusionWorld *world, int call_id, FusionCallMessage *msg )
{
FusionCallHandler call_handler;
FusionCallHandlerResult result;
FusionCallReturn callret;
D_MAGIC_ASSERT( world, FusionWorld );
D_ASSERT( msg != NULL );
call_handler = msg->handler;
D_ASSERT( call_handler != NULL );
callret.type = FMT_CALLRET;
callret.val = 0;
result = call_handler( msg->caller, msg->call_arg, msg->call_ptr, msg->ctx, msg->serial, &callret.val );
switch (result) {
case FCHR_RETURN:
if (!(msg->flags & FCEF_ONEWAY)) {
struct sockaddr_un addr;
addr.sun_family = AF_UNIX;
snprintf( addr.sun_path, sizeof(addr.sun_path),
"/tmp/.fusion-%d/call.%x.%x", fusion_world_index( world ), call_id, msg->serial );
if (_fusion_send_message( world->fusion_fd, &callret, sizeof(callret), &addr ))
D_ERROR( "Fusion/Call: Couldn't send call return (serial: 0x%08x)!\n", msg->serial );
}
break;
case FCHR_RETAIN:
break;
default:
D_BUG( "unknown result %d from call handler", result );
break;
}
}
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;
}
DirectResult
fusion_call_execute (FusionCall *call,
FusionCallExecFlags flags,
int call_arg,
void *call_ptr,
int *ret_val)
{
DirectResult ret = DR_OK;
FusionWorld *world;
FusionCallMessage msg;
struct sockaddr_un addr;
D_ASSERT( call != NULL );
if (!call->handler)
return DR_DESTROYED;
if (!(flags & FCEF_NODIRECT) && call->fusion_id == _fusion_id( call->shared )) {
int ret;
FusionCallHandlerResult result;
result = call->handler( _fusion_id( call->shared ), call_arg, call_ptr, call->ctx, 0, &ret );
if (result != FCHR_RETURN)
D_WARN( "local call handler returned FCHR_RETAIN, need FCEF_NODIRECT" );
if (ret_val)
*ret_val = ret;
return DR_OK;
}
world = _fusion_world( call->shared );
msg.type = FMT_CALL;
msg.caller = world->fusion_id;
msg.call_id = call->call_id;
msg.call_arg = call_arg;
msg.call_ptr = call_ptr;
msg.handler = call->handler;
msg.ctx = call->ctx;
msg.flags = flags;
if (flags & FCEF_ONEWAY) {
/* Invalidate serial. */
msg.serial = -1;
/* Send message. */
addr.sun_family = AF_UNIX;
snprintf( addr.sun_path, sizeof(addr.sun_path),
"/tmp/.fusion-%d/%lx", call->shared->world_index, call->fusion_id );
ret = _fusion_send_message( world->fusion_fd, &msg, sizeof(msg), &addr );
}
else {
int fd;
socklen_t len;
int err;
fd = socket( PF_LOCAL, SOCK_RAW, 0 );
if (fd < 0) {
D_PERROR( "Fusion/Call: Error creating local socket!\n" ) ;
return DR_IO;
}
/* Set close-on-exec flag. */
fcntl( fd, F_SETFD, FD_CLOEXEC );
addr.sun_family = AF_UNIX;
len = snprintf( addr.sun_path, sizeof(addr.sun_path),
"/tmp/.fusion-%d/call.%x.", fusion_world_index( world ), call->call_id );
/* Generate call serial (socket address is based on it). */
for (msg.serial = 0; msg.serial <= 0xffffff; msg.serial++) {
snprintf( addr.sun_path+len, sizeof(addr.sun_path)-len, "%x", msg.serial );
err = bind( fd, (struct sockaddr*)&addr, sizeof(addr) );
if (err == 0) {
chmod( addr.sun_path, 0660 );
/* Change group, if requested. */
if (fusion_config->shmfile_gid != (gid_t)-1)
chown( addr.sun_path, -1, fusion_config->shmfile_gid );
break;
}
}
if (err < 0) {
D_PERROR( "Fusion/Call: Error binding local socket!\n" );
close( fd );
return DR_IO;
}
/* Send message. */
snprintf( addr.sun_path, sizeof(addr.sun_path),
"/tmp/.fusion-%d/%lx", call->shared->world_index, call->fusion_id );
ret = _fusion_send_message( fd, &msg, sizeof(msg), &addr );
if (ret == DR_OK) {
FusionCallReturn callret;
/* Wait for reply. */
ret = _fusion_recv_message( fd, &callret, sizeof(callret), NULL );
if (ret == DR_OK) {
if (ret_val)
*ret_val = callret.val;
}
}
len = sizeof(addr);
if (getsockname( fd, (struct sockaddr*)&addr, &len ) == 0)
unlink( addr.sun_path );
close( fd );
}
return ret;
}
int
main( int argc, char *argv[] )
{
DirectResult ret;
pid_t child_pid;
TestMessage message = {0};
FusionReactor *reactor;
Reaction reaction;
FusionCall call;
DirectFBInit( &argc, &argv );
ret = fusion_enter( -1, 0, FER_MASTER, &m_world );
if (ret) {
D_DERROR( ret, "fusion_enter() failed" );
return ret;
}
MSG( "Entered world %d as master (FusionID %lu, pid %d)\n",
fusion_world_index( m_world ), fusion_id( m_world ), getpid() );
reactor = fusion_reactor_new( sizeof(TestMessage), "Test", m_world );
if (!reactor) {
D_ERROR( "fusion_reactor_new() failed\n" );
return -1;
}
MSG( "Attaching to reactor...\n" );
ret = fusion_reactor_attach( reactor, reaction_callback, NULL, &reaction );
if (ret) {
D_DERROR( ret, "fusion_reactor_attach() failed" );
return ret;
}
MSG( ".........FORKING NOW.........\n" );
fusion_world_set_fork_action( m_world, FFA_FORK );
child_pid = fork();
fusion_world_set_fork_action( m_world, FFA_CLOSE );
switch (child_pid) {
case -1:
D_PERROR( "fork() failed" );
break;
case 0:
setsid();
MSG( "...arrived after fork() in child (pid %d)..\n", getpid() );
MSG( "..child (FusionID %lu).\n", fusion_id( m_world ) );
usleep( 400000 );
break;
default:
usleep( 100000 );
MSG( "...returned from fork() in parent, child pid %d.\n", child_pid );
MSG( "Initializing dispatch callback...\n" );
ret = fusion_call_init( &call, dispatch_callback, NULL, m_world );
if (ret) {
D_DERROR( ret, "fusion_call_init() failed" );
return ret;
}
MSG( "Setting dispatch callback...\n" );
ret = fusion_reactor_set_dispatch_callback( reactor, &call, NULL );
if (ret) {
D_DERROR( ret, "fusion_reactor_set_dispatch_callback() failed" );
return ret;
}
MSG( "Sending message via reactor...\n" );
fusion_reactor_dispatch( reactor, &message, true, NULL );
usleep( 100000 );
MSG( "Destroying reactor...\n" );
fusion_reactor_destroy( reactor );
MSG( "...destroyed reactor!\n" );
usleep( 400000 );
MSG( "Freeing reactor...\n" );
fusion_reactor_free( reactor );
MSG( "...freed reactor!\n" );
break;
}
MSG( "Exiting from world %d (FusionID %lu, pid %d)...\n",
fusion_world_index( m_world ), fusion_id( m_world ), getpid() );
fusion_exit( m_world, false );
return 0;
}
static DirectResult
init_pool( FusionSHM *shm,
FusionSHMPool *pool,
FusionSHMPoolShared *shared,
const char *name,
unsigned int max_size,
bool debug )
{
DirectResult ret;
int size;
long page_size;
int pool_id;
unsigned int pool_max_size;
void *pool_addr_base = NULL;
FusionWorld *world;
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 );
page_size = direct_pagesize();
pool_id = ++world->shared->pool_ids;
pool_max_size = max_size + BLOCKALIGN(sizeof(shmalloc_heap)) +
BLOCKALIGN( (max_size + BLOCKSIZE-1) / BLOCKSIZE * sizeof(shmalloc_info) );
pool_addr_base = world->shared->pool_base;
world->shared->pool_base += ((pool_max_size + page_size - 1) & ~(page_size - 1)) + page_size;
/* Exceeded limit? */
if (world->shared->pool_base > world->shared->pool_max)
return DR_NOSHAREDMEMORY;
/* Generate filename. */
snprintf( buf, sizeof(buf), "%s/fusion.%d.%d", shm->shared->tmpfs,
fusion_world_index( world ), pool_id );
/* Initialize the heap. */
ret = __shmalloc_init_heap( shm, buf, pool_addr_base, max_size, &size );
if (ret)
return ret;
/* initialize local data. */
pool->attached = true;
pool->shm = shm;
pool->shared = shared;
pool->pool_id = pool_id;
pool->filename = D_STRDUP( buf );
/* Initialize shared data. */
shared->active = true;
shared->debug = debug;
shared->shm = shm->shared;
shared->max_size = pool_max_size;
shared->pool_id = pool_id;
shared->addr_base = pool_addr_base;
shared->heap = pool_addr_base;
shared->heap->pool = shared;
fusion_skirmish_init( &shared->lock, name, world );
D_MAGIC_SET( pool, FusionSHMPool );
D_MAGIC_SET( shared, FusionSHMPoolShared );
shared->name = SHSTRDUP( shared, name );
return DR_OK;
}
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 );
}
int
main( int argc, char *argv[] )
{
DirectResult ret;
pid_t child_pid;
TestMessage message = {0};
DirectFBInit( &argc, &argv );
ret = fusion_enter( -1, 0, FER_MASTER, &m_world );
if (ret) {
D_DERROR( ret, "fusion_enter() failed" );
return ret;
}
MSG( "Entered world %d as master (FusionID %lu, pid %d)\n",
fusion_world_index( m_world ), fusion_id( m_world ), getpid() );
ret = fusion_ref_init( &m_ref, "Test", m_world );
if (ret) {
D_DERROR( ret, "fusion_ref_init() failed" );
return -1;
}
MSG( "Adding local reference...\n" );
fusion_ref_up( &m_ref, false );
m_reactor = fusion_reactor_new( sizeof(TestMessage), "Test", m_world );
if (!m_reactor) {
D_ERROR( "fusion_reactor_new() failed\n" );
return -1;
}
MSG( "Attaching to reactor...\n" );
ret = fusion_reactor_attach( m_reactor, reaction_callback, NULL, &m_reaction );
if (ret) {
D_DERROR( ret, "fusion_reactor_attach() failed" );
return ret;
}
MSG( ".........FORKING NOW.........\n" );
fusion_world_set_fork_action( m_world, FFA_FORK );
child_pid = fork();
fusion_world_set_fork_action( m_world, FFA_CLOSE );
switch (child_pid) {
case -1:
D_PERROR( "fork() failed" );
break;
case 0:
setsid();
MSG( "...arrived after fork() in child (pid %d)..\n", getpid() );
MSG( "..child (FusionID %lu).\n", fusion_id( m_world ) );
break;
default:
usleep( 200000 );
MSG( "...returned from fork() in parent, child pid %d.\n", child_pid );
break;
}
MSG( "Sending message via reactor...\n" );
fusion_reactor_dispatch( m_reactor, &message, true, NULL );
usleep( 200000 );
MSG( "Removing local reference...\n" );
fusion_ref_down( &m_ref, false );
usleep( 200000 );
MSG( "Exiting from world %d (FusionID %lu, pid %d)...\n",
fusion_world_index( m_world ), fusion_id( m_world ), getpid() );
fusion_exit( m_world, false );
return 0;
}
