static void _ecore_pipe_unhandle(Ecore_Pipe *p) { p->handling--; if (p->delete_me) { _ecore_pipe_del(p); } }
/** * Free an Ecore_Pipe object created with ecore_pipe_add(). * * @param p The Ecore_Pipe object to be freed. * @return The pointer to the private data */ EAPI void * ecore_pipe_del(Ecore_Pipe *p) { void *r; EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL); _ecore_lock(); r = _ecore_pipe_del(p); _ecore_unlock(); return r; }
/** * Shut down connections, signal handlers sockets etc. * * @return 0 if ecore shuts down, greater than 0 otherwise. * This function shuts down all things set up in ecore_init() and cleans up all * event queues, handlers, filters, timers, idlers, idle enterers/exiters * etc. set up after ecore_init() was called. * * Do not call this function from any callback that may be called from the main * loop, as the main loop will then fall over and not function properly. */ EAPI int ecore_shutdown(void) { Ecore_Pipe *p; /* * take a lock here because _ecore_event_shutdown() does callbacks */ _ecore_lock(); if (_ecore_init_count <= 0) { ERR("Init count not greater than 0 in shutdown."); _ecore_unlock(); return 0; } if (--_ecore_init_count != 0) goto unlock; if (_ecore_fps_debug) _ecore_fps_debug_shutdown(); _ecore_poller_shutdown(); _ecore_animator_shutdown(); _ecore_glib_shutdown(); _ecore_job_shutdown(); _ecore_thread_shutdown(); /* this looks horrible - a hack for now, but something to note. as * we delete the _thread_call pipe a thread COULD be doing * ecore_pipe_write() or what not to it at the same time - we * must ensure all possible users of this _thread_call are finished * and exited before we delete it here */ /* * ok - this causes other valgrind complaints regarding glib aquiring * locks internally. so fix bug a or bug b. let's leave the original * bug in then and leave this as a note for now */ /* * It should be fine now as we do wait for thread to shutdown before * we try to destroy the pipe. */ p = _thread_call; _thread_call = NULL; _ecore_pipe_wait(p, 1, 0.1); _ecore_pipe_del(p); eina_lock_free(&_thread_safety); eina_condition_free(&_thread_cond); eina_lock_free(&_thread_mutex); eina_condition_free(&_thread_feedback_cond); eina_lock_free(&_thread_feedback_mutex); eina_lock_free(&_thread_id_lock); #ifndef HAVE_EXOTIC _ecore_exe_shutdown(); #endif _ecore_idle_enterer_shutdown(); _ecore_idle_exiter_shutdown(); _ecore_idler_shutdown(); _ecore_timer_shutdown(); _ecore_event_shutdown(); _ecore_main_shutdown(); _ecore_signal_shutdown(); _ecore_main_loop_shutdown(); #if HAVE_MALLINFO if (getenv("ECORE_MEM_STAT")) { _ecore_memory_statistic(NULL); ERR("[%i] Memory MAX total: %i, free: %i", _ecore_memory_pid, _ecore_memory_max_total, _ecore_memory_max_free); } #endif ecore_mempool_shutdown(); eina_log_domain_unregister(_ecore_log_dom); _ecore_log_dom = -1; eina_shutdown(); #ifdef HAVE_EVIL evil_shutdown(); #endif unlock: _ecore_unlock(); return _ecore_init_count; }