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; }