[Freeswitch-svn] [commit] r12173 - in freeswitch/trunk: libs/esl/src libs/esl/src/include src src/include src/mod/applications/mod_commands src/mod/event_handlers/mod_event_socket src/mod/formats/mod_local_stream
FreeSWITCH SVN
anthm at freeswitch.org
Thu Feb 19 17:10:59 PST 2009
Author: anthm
Date: Thu Feb 19 19:10:59 2009
New Revision: 12173
Log:
FSCORE-297
Modified:
freeswitch/trunk/libs/esl/src/esl.c
freeswitch/trunk/libs/esl/src/include/esl.h
freeswitch/trunk/src/include/switch_apr.h
freeswitch/trunk/src/include/switch_core.h
freeswitch/trunk/src/mod/applications/mod_commands/mod_commands.c
freeswitch/trunk/src/mod/event_handlers/mod_event_socket/mod_event_socket.c
freeswitch/trunk/src/mod/formats/mod_local_stream/mod_local_stream.c
freeswitch/trunk/src/switch_apr.c
freeswitch/trunk/src/switch_core.c
freeswitch/trunk/src/switch_core_session.c
freeswitch/trunk/src/switch_event.c
freeswitch/trunk/src/switch_loadable_module.c
freeswitch/trunk/src/switch_log.c
Modified: freeswitch/trunk/libs/esl/src/esl.c
==============================================================================
--- freeswitch/trunk/libs/esl/src/esl.c (original)
+++ freeswitch/trunk/libs/esl/src/esl.c Thu Feb 19 19:10:59 2009
@@ -643,7 +643,7 @@
hval = esl_event_get_header(handle->last_event, "content-type");
- if (strcasecmp(hval, "auth/request")) {
+ if (esl_safe_strcasecmp(hval, "auth/request")) {
snprintf(handle->err, sizeof(handle->err), "Connection Error");
goto fail;
}
@@ -660,7 +660,7 @@
hval = esl_event_get_header(handle->last_event, "reply-text");
- if (strcasecmp(hval, "+OK accepted")) {
+ if (esl_safe_strcasecmp(hval, "+OK accepted")) {
snprintf(handle->err, sizeof(handle->err), "Authentication Error");
goto fail;
}
@@ -876,7 +876,7 @@
hval = esl_event_get_header(revent, "content-type");
- if (!esl_strlen_zero(hval) && !strcasecmp(hval, "text/event-plain") && revent->body) {
+ if (!esl_strlen_zero(hval) && !esl_safe_strcasecmp(hval, "text/event-plain") && revent->body) {
const char *en;
esl_event_types_t et = ESL_EVENT_COMMAND;
char *body = strdup(revent->body);
Modified: freeswitch/trunk/libs/esl/src/include/esl.h
==============================================================================
--- freeswitch/trunk/libs/esl/src/include/esl.h (original)
+++ freeswitch/trunk/libs/esl/src/include/esl.h Thu Feb 19 19:10:59 2009
@@ -341,7 +341,7 @@
#define esl_recv(_h) esl_recv_event(_h, NULL)
#define esl_recv_timed(_h, _ms) esl_recv_event_timed(_h, _ms, NULL)
-
+#define esl_safe_strcasecmp(_s1, _s2) ((_s1) && (_s2)) ? strcasecmp((_s1), (_s2)) : 1
#ifdef __cplusplus
}
Modified: freeswitch/trunk/src/include/switch_apr.h
==============================================================================
--- freeswitch/trunk/src/include/switch_apr.h (original)
+++ freeswitch/trunk/src/include/switch_apr.h Thu Feb 19 19:10:59 2009
@@ -620,6 +620,8 @@
*/
SWITCH_DECLARE(switch_status_t) switch_queue_trypop(switch_queue_t *queue, void **data);
+SWITCH_DECLARE(switch_status_t) switch_queue_interrupt_all(switch_queue_t *queue);
+
/**
* push/add a object to the queue, returning immediatly if the queue is full
*
Modified: freeswitch/trunk/src/include/switch_core.h
==============================================================================
--- freeswitch/trunk/src/include/switch_core.h (original)
+++ freeswitch/trunk/src/include/switch_core.h Thu Feb 19 19:10:59 2009
@@ -1671,7 +1671,8 @@
/*!
\brief Launch a thread
*/
-SWITCH_DECLARE(void) switch_core_launch_thread(void *(SWITCH_THREAD_FUNC *func) (switch_thread_t *, void *), void *obj, switch_memory_pool_t *pool);
+SWITCH_DECLARE(switch_thread_t *) switch_core_launch_thread(void *(SWITCH_THREAD_FUNC *func) (switch_thread_t *, void *),
+ void *obj, switch_memory_pool_t *pool);
#endif
/*!
Modified: freeswitch/trunk/src/mod/applications/mod_commands/mod_commands.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_commands/mod_commands.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_commands/mod_commands.c Thu Feb 19 19:10:59 2009
@@ -40,7 +40,9 @@
#include <switch_version.h>
SWITCH_MODULE_LOAD_FUNCTION(mod_commands_load);
-SWITCH_MODULE_DEFINITION(mod_commands, mod_commands_load, NULL, NULL);
+SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_commands_shutdown);
+SWITCH_MODULE_DEFINITION(mod_commands, mod_commands_load, mod_commands_shutdown, NULL);
+
SWITCH_STANDARD_API(time_test_function)
{
@@ -2289,6 +2291,8 @@
return SWITCH_STATUS_SUCCESS;
}
+static switch_thread_rwlock_t *bgapi_rwlock = NULL;
+
struct bg_job {
char *cmd;
char *arg;
@@ -2309,6 +2313,8 @@
if (!job)
return NULL;
+ switch_thread_rwlock_rdlock(bgapi_rwlock);
+
pool = job->pool;
SWITCH_STANDARD_STREAM(stream);
@@ -2345,6 +2351,9 @@
job = NULL;
switch_core_destroy_memory_pool(&pool);
pool = NULL;
+
+ switch_thread_rwlock_unlock(bgapi_rwlock);
+
return NULL;
}
@@ -3183,11 +3192,37 @@
return SWITCH_STATUS_SUCCESS;
}
+SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_commands_shutdown)
+{
+ int x;
+
+
+ for (x = 30; x > 0; x--) {
+ if (switch_thread_rwlock_trywrlock(bgapi_rwlock) == SWITCH_STATUS_SUCCESS) {
+ switch_thread_rwlock_unlock(bgapi_rwlock);
+ break;
+ }
+ if (x == 30) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Waiting for bgapi threads.\n");
+ }
+ switch_yield(1000000);
+ }
+
+ if (!x) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Giving up waiting for bgapi threads.\n");
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+
SWITCH_MODULE_LOAD_FUNCTION(mod_commands_load)
{
switch_api_interface_t *commands_api_interface;
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
+ switch_thread_rwlock_create(&bgapi_rwlock, pool);
+
SWITCH_ADD_API(commands_api_interface, "group_call", "Generate a dial string to call a group", group_call_function, "<group>[@<domain>]");
SWITCH_ADD_API(commands_api_interface, "in_group", "determine if a user is in a group", in_group_function, "<user>[@<domain>] <group_name>");
Modified: freeswitch/trunk/src/mod/event_handlers/mod_event_socket/mod_event_socket.c
==============================================================================
--- freeswitch/trunk/src/mod/event_handlers/mod_event_socket/mod_event_socket.c (original)
+++ freeswitch/trunk/src/mod/event_handlers/mod_event_socket/mod_event_socket.c Thu Feb 19 19:10:59 2009
@@ -116,6 +116,7 @@
static void remove_listener(listener_t *listener);
+static void kill_all_listeners(void);
static uint32_t next_id(void)
{
@@ -452,31 +453,24 @@
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_event_socket_shutdown)
{
- listener_t *l;
int sanity = 0;
prefs.done = 1;
+ kill_all_listeners();
switch_log_unbind_logger(socket_logger);
close_socket(&listen_list.sock);
while (prefs.threads) {
- switch_yield(10000);
- if (++sanity == 1000) {
+ switch_yield(100000);
+ kill_all_listeners();
+ if (++sanity >= 200) {
break;
}
}
- switch_event_unbind(&globals.node);
-
- switch_mutex_lock(globals.listener_mutex);
- for (l = listen_list.listeners; l; l = l->next) {
- close_socket(&l->sock);
- }
- switch_mutex_unlock(globals.listener_mutex);
-
- switch_yield(1000000);
+ switch_event_unbind(&globals.node);
return SWITCH_STATUS_SUCCESS;
}
@@ -509,6 +503,22 @@
}
+static void kill_all_listeners(void)
+{
+ listener_t *l;
+
+ switch_mutex_lock(globals.listener_mutex);
+ for (l = listen_list.listeners; l; l = l->next) {
+ switch_clear_flag(l, LFLAG_RUNNING);
+ if (l->sock) {
+ switch_socket_shutdown(l->sock, SWITCH_SHUTDOWN_READWRITE);
+ switch_socket_close(l->sock);
+ }
+ }
+ switch_mutex_unlock(globals.listener_mutex);
+}
+
+
static listener_t *find_listener(uint32_t id)
{
listener_t *l, *r = NULL;
@@ -961,12 +971,16 @@
uint32_t max_len = sizeof(mbuf);
switch_channel_t *channel = NULL;
int clen = 0;
-
+
*event = NULL;
+
+ if (prefs.done) {
+ return SWITCH_STATUS_FALSE;
+ }
+
start = switch_epoch_time_now(NULL);
ptr = mbuf;
-
if (listener->session) {
channel = switch_core_session_get_channel(listener->session);
}
@@ -976,7 +990,7 @@
mlen = 1;
status = switch_socket_recv(listener->sock, ptr, &mlen);
- if (!SWITCH_STATUS_IS_BREAK(status) && status != SWITCH_STATUS_SUCCESS) {
+ if (prefs.done || (!SWITCH_STATUS_IS_BREAK(status) && status != SWITCH_STATUS_SUCCESS)) {
return SWITCH_STATUS_FALSE;
}
@@ -1044,7 +1058,7 @@
status = switch_socket_recv(listener->sock, p, &mlen);
- if (!SWITCH_STATUS_IS_BREAK(status) && status != SWITCH_STATUS_SUCCESS) {
+ if (prefs.done || (!SWITCH_STATUS_IS_BREAK(status) && status != SWITCH_STATUS_SUCCESS)) {
return SWITCH_STATUS_FALSE;
}
@@ -1211,10 +1225,15 @@
switch_stream_handle_t stream = { 0 };
char *reply, *freply = NULL;
switch_status_t status;
+
+ switch_mutex_lock(globals.listener_mutex);
+ prefs.threads++;
+ switch_mutex_unlock(globals.listener_mutex);
+
if (!acs) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Internal error.\n");
- return NULL;
+ goto cleanup;
}
if (!acs->listener || !switch_test_flag(acs->listener, LFLAG_RUNNING) ||
@@ -1291,6 +1310,11 @@
}
+ cleanup:
+ switch_mutex_lock(globals.listener_mutex);
+ prefs.threads--;
+ switch_mutex_unlock(globals.listener_mutex);
+
return NULL;
}
@@ -1934,7 +1958,7 @@
}
}
- while (switch_test_flag(listener, LFLAG_RUNNING) && listen_list.ready) {
+ while (!prefs.done && switch_test_flag(listener, LFLAG_RUNNING) && listen_list.ready) {
len = sizeof(buf);
memset(buf, 0, len);
status = read_packet(listener, &revent, 0);
@@ -2106,7 +2130,7 @@
config();
- for (;;) {
+ while(!prefs.done) {
rv = switch_sockaddr_info_get(&sa, prefs.ip, SWITCH_INET, prefs.port, 0, pool);
if (rv)
goto fail;
@@ -2132,7 +2156,7 @@
listen_list.ready = 1;
- for (;;) {
+ while(!prefs.done) {
if (switch_core_new_memory_pool(&listener_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "OH OH no pool\n");
goto fail;
Modified: freeswitch/trunk/src/mod/formats/mod_local_stream/mod_local_stream.c
==============================================================================
--- freeswitch/trunk/src/mod/formats/mod_local_stream/mod_local_stream.c (original)
+++ freeswitch/trunk/src/mod/formats/mod_local_stream/mod_local_stream.c Thu Feb 19 19:10:59 2009
@@ -222,13 +222,13 @@
if (!used && !is_open) {
break;
}
-
+
if (!is_open || used >= source->prebuf || (source->total && used > source->samples * 2)) {
used = switch_buffer_read(audio_buffer, dist_buf, source->samples * 2);
if (source->total) {
switch_mutex_lock(source->mutex);
- for (cp = source->context_list; cp; cp = cp->next) {
+ for (cp = source->context_list; cp && RUNNING; cp = cp->next) {
if (switch_test_flag(cp->handle, SWITCH_FILE_CALLBACK)) {
continue;
}
Modified: freeswitch/trunk/src/switch_apr.c
==============================================================================
--- freeswitch/trunk/src/switch_apr.c (original)
+++ freeswitch/trunk/src/switch_apr.c Thu Feb 19 19:10:59 2009
@@ -895,6 +895,11 @@
return apr_queue_trypop(queue, data);
}
+SWITCH_DECLARE(switch_status_t) switch_queue_interrupt_all(switch_queue_t *queue)
+{
+ return apr_queue_interrupt_all(queue);
+}
+
SWITCH_DECLARE(switch_status_t) switch_queue_trypush(switch_queue_t *queue, void *data)
{
apr_status_t s;
Modified: freeswitch/trunk/src/switch_core.c
==============================================================================
--- freeswitch/trunk/src/switch_core.c (original)
+++ freeswitch/trunk/src/switch_core.c Thu Feb 19 19:10:59 2009
@@ -345,9 +345,9 @@
*/
-SWITCH_DECLARE(void) switch_core_launch_thread(switch_thread_start_t func, void *obj, switch_memory_pool_t *pool)
+SWITCH_DECLARE(switch_thread_t *) switch_core_launch_thread(switch_thread_start_t func, void *obj, switch_memory_pool_t *pool)
{
- switch_thread_t *thread;
+ switch_thread_t *thread = NULL;
switch_threadattr_t *thd_attr = NULL;
switch_core_thread_session_t *ts;
int mypool;
@@ -356,11 +356,10 @@
if (!pool && switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate memory pool\n");
- return;
+ return NULL;
}
switch_threadattr_create(&thd_attr, pool);
- switch_threadattr_detach_set(thd_attr, 1);
if ((ts = switch_core_alloc(pool, sizeof(*ts))) == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate memory\n");
@@ -369,10 +368,13 @@
ts->pool = pool;
}
ts->objs[0] = obj;
+ ts->objs[1] = thread;
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_threadattr_priority_increase(thd_attr);
switch_thread_create(&thread, thd_attr, func, ts, pool);
}
+
+ return thread;
}
SWITCH_DECLARE(void) switch_core_set_globals(void)
@@ -1457,6 +1459,7 @@
SWITCH_DECLARE(switch_status_t) switch_core_destroy(void)
{
switch_event_t *event;
+
if (switch_event_create(&event, SWITCH_EVENT_SHUTDOWN) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Shutting Down");
switch_event_fire(&event);
@@ -1464,26 +1467,29 @@
switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
switch_set_flag((&runtime), SCF_SHUTTING_DOWN);
-
+
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "End existing sessions\n");
switch_core_session_hupall(SWITCH_CAUSE_SYSTEM_SHUTDOWN);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Clean up modules.\n");
- switch_core_memory_stop();
- switch_loadable_module_shutdown();
-
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Closing Event Engine.\n");
- switch_event_shutdown();
+ switch_loadable_module_shutdown();
+
if (switch_test_flag((&runtime), SCF_USE_SQL)) {
switch_core_sqldb_stop();
}
switch_scheduler_task_thread_stop();
-
+
switch_rtp_shutdown();
switch_xml_destroy();
+
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Closing Event Engine.\n");
+ switch_event_shutdown();
+
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Finalizing Shutdown.\n");
switch_log_shutdown();
+ switch_core_memory_stop();
+
if (runtime.console && runtime.console != stdout && runtime.console != stderr) {
fclose(runtime.console);
runtime.console = NULL;
Modified: freeswitch/trunk/src/switch_core_session.c
==============================================================================
--- freeswitch/trunk/src/switch_core_session.c (original)
+++ freeswitch/trunk/src/switch_core_session.c Thu Feb 19 19:10:59 2009
@@ -58,6 +58,9 @@
/* Acquire a read lock on the session */
#ifdef SWITCH_DEBUG_RWLOCKS
if (switch_core_session_perform_read_lock(session, file, func, line) != SWITCH_STATUS_SUCCESS) {
+#if EMACS_CC_MODE_IS_BUGGY
+ }
+#endif
#else
if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
#endif
@@ -127,21 +130,20 @@
void *val;
switch_core_session_t *session;
uint32_t loops = 0;
-
- switch_mutex_lock(runtime.throttle_mutex);
- for (hi = switch_hash_first(NULL, session_manager.session_table); hi; hi = switch_hash_next(hi)) {
- switch_hash_this(hi, NULL, NULL, &val);
- if (val) {
- session = (switch_core_session_t *) val;
- if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
- switch_channel_hangup(switch_core_session_get_channel(session), cause);
- switch_core_session_rwunlock(session);
+
+ while (session_manager.session_count > 0) {
+ switch_mutex_lock(runtime.throttle_mutex);
+ for (hi = switch_hash_first(NULL, session_manager.session_table); hi; hi = switch_hash_next(hi)) {
+ switch_hash_this(hi, NULL, NULL, &val);
+ if (val) {
+ session = (switch_core_session_t *) val;
+ if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
+ switch_channel_hangup(switch_core_session_get_channel(session), cause);
+ switch_core_session_rwunlock(session);
+ }
}
}
- }
- switch_mutex_unlock(runtime.throttle_mutex);
-
- while (session_manager.session_count > 0) {
+ switch_mutex_unlock(runtime.throttle_mutex);
switch_yield(1000000);
if (++loops == 30) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Giving up with %d session%s remaining\n",
@@ -151,6 +153,7 @@
}
}
+
SWITCH_DECLARE(switch_status_t) switch_core_session_message_send(const char *uuid_str, switch_core_session_message_t *message)
{
switch_core_session_t *session = NULL;
Modified: freeswitch/trunk/src/switch_event.c
==============================================================================
--- freeswitch/trunk/src/switch_event.c (original)
+++ freeswitch/trunk/src/switch_event.c Thu Feb 19 19:10:59 2009
@@ -74,7 +74,9 @@
static switch_memory_pool_t *RUNTIME_POOL = NULL;
static switch_memory_pool_t *THRUNTIME_POOL = NULL;
#define NUMBER_OF_QUEUES 3
+static switch_thread_t *EVENT_QUEUE_THREADS[NUMBER_OF_QUEUES] = { 0 };
static switch_queue_t *EVENT_QUEUE[NUMBER_OF_QUEUES] = { 0 };
+static switch_thread_t *EVENT_DISPATCH_QUEUE_THREADS[MAX_DISPATCH_VAL] = { 0 };
static switch_queue_t *EVENT_DISPATCH_QUEUE[MAX_DISPATCH_VAL] = { 0 };
static int POOL_COUNT_MAX = SWITCH_CORE_QUEUE_LEN;
static switch_mutex_t *EVENT_QUEUE_MUTEX = NULL;
@@ -174,15 +176,15 @@
static int switch_events_match(switch_event_t *event, switch_event_node_t *node)
{
int match = 0;
-
+
if (node->event_id == SWITCH_EVENT_ALL) {
match++;
-
+
if (!node->subclass) {
return match;
}
}
-
+
if (match || event->event_id == node->event_id) {
if (event->subclass_name && node->subclass) {
@@ -227,6 +229,10 @@
void *pop = NULL;
switch_event_t *event = NULL;
+ if (!SYSTEM_RUNNING) {
+ break;
+ }
+
if (switch_queue_pop(queue, &pop) != SWITCH_STATUS_SUCCESS) {
break;
}
@@ -278,6 +284,10 @@
break;
}
+ if (!SYSTEM_RUNNING) {
+ break;
+ }
+
event = (switch_event_t *) pop;
while (event) {
@@ -313,20 +323,22 @@
switch_event_types_t e;
switch_event_node_t *node;
- switch_thread_rwlock_rdlock(RWLOCK);
- for (e = (*event)->event_id;; e = SWITCH_EVENT_ALL) {
- for (node = EVENT_NODES[e]; node; node = node->next) {
- if (switch_events_match(*event, node)) {
- (*event)->bind_user_data = node->user_data;
- node->callback(*event);
+ if (SYSTEM_RUNNING) {
+ switch_thread_rwlock_rdlock(RWLOCK);
+ for (e = (*event)->event_id;; e = SWITCH_EVENT_ALL) {
+ for (node = EVENT_NODES[e]; node; node = node->next) {
+ if (switch_events_match(*event, node)) {
+ (*event)->bind_user_data = node->user_data;
+ node->callback(*event);
+ }
+ }
+
+ if (e == SWITCH_EVENT_ALL) {
+ break;
}
}
-
- if (e == SWITCH_EVENT_ALL) {
- break;
- }
+ switch_thread_rwlock_unlock(RWLOCK);
}
- switch_thread_rwlock_unlock(RWLOCK);
switch_event_destroy(event);
}
@@ -416,10 +428,10 @@
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Returning %d recycled event header(s) %d bytes\n",
size, (int) sizeof(switch_event_header_t) * size);
- while (switch_queue_trypop(EVENT_HEADER_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS) {
+ while (switch_queue_trypop(EVENT_HEADER_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS && pop) {
free(pop);
}
- while (switch_queue_trypop(EVENT_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS) {
+ while (switch_queue_trypop(EVENT_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS && pop) {
free(pop);
}
}
@@ -438,12 +450,14 @@
for (x = 0; x < 3; x++) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping event queue %d\n", x);
- switch_queue_push(EVENT_QUEUE[x], NULL);
+ switch_queue_trypush(EVENT_QUEUE[x], NULL);
+ switch_queue_interrupt_all(EVENT_QUEUE[x]);
}
for (x = 0; x < SOFT_MAX_DISPATCH; x++) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping dispatch queue %d\n", x);
- switch_queue_push(EVENT_DISPATCH_QUEUE[x], NULL);
+ switch_queue_trypush(EVENT_DISPATCH_QUEUE[x], NULL);
+ switch_queue_interrupt_all(EVENT_DISPATCH_QUEUE[x]);
}
while (x < 10000 && THREAD_COUNT) {
@@ -453,7 +467,35 @@
}
last = THREAD_COUNT;
}
+
+ for (x = 0; x < SOFT_MAX_DISPATCH; x++) {
+ void *pop = NULL;
+ switch_event_t *event = NULL;
+ switch_status_t st;
+
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping dispatch thread %d\n", x);
+ switch_thread_join(&st, EVENT_DISPATCH_QUEUE_THREADS[x]);
+
+ while (switch_queue_trypop(EVENT_DISPATCH_QUEUE[x], &pop) == SWITCH_STATUS_SUCCESS && pop) {
+ event = (switch_event_t *) pop;
+ switch_event_destroy(&event);
+ }
+ }
+ for (x = 0; x < NUMBER_OF_QUEUES; x++) {
+ void *pop = NULL;
+ switch_event_t *event = NULL;
+ switch_status_t st;
+
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping queue thread %d\n", x);
+ switch_thread_join(&st, EVENT_QUEUE_THREADS[x]);
+
+ while (switch_queue_trypop(EVENT_QUEUE[x], &pop) == SWITCH_STATUS_SUCCESS && pop) {
+ event = (switch_event_t *) pop;
+ switch_event_destroy(&event);
+ }
+ }
+
for (hi = switch_hash_first(NULL, CUSTOM_HASH); hi; hi = switch_hash_next(hi)) {
switch_event_subclass_t *subclass;
switch_hash_this(hi, &var, NULL, &val);
@@ -472,7 +514,6 @@
static void launch_dispatch_threads(uint32_t max, int len, switch_memory_pool_t *pool)
{
- switch_thread_t *thread;
switch_threadattr_t *thd_attr;
uint32_t index = 0;
@@ -492,8 +533,7 @@
switch_threadattr_create(&thd_attr, pool);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_threadattr_priority_increase(thd_attr);
- switch_threadattr_detach_set(thd_attr, 1);
- switch_thread_create(&thread, thd_attr, switch_event_dispatch_thread, EVENT_DISPATCH_QUEUE[index], pool);
+ switch_thread_create(&EVENT_DISPATCH_QUEUE_THREADS[index], thd_attr, switch_event_dispatch_thread, EVENT_DISPATCH_QUEUE[index], pool);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Create event dispatch thread %d\n", index);
}
@@ -502,18 +542,26 @@
SWITCH_DECLARE(switch_status_t) switch_event_init(switch_memory_pool_t *pool)
{
- switch_thread_t *thread;
switch_threadattr_t *thd_attr;;
switch_assert(pool != NULL);
+ THRUNTIME_POOL = RUNTIME_POOL = pool;
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Activate Eventing Engine.\n");
+ switch_thread_rwlock_create(&RWLOCK, RUNTIME_POOL);
+ switch_mutex_init(&BLOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
+ switch_mutex_init(&POOL_LOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
+ switch_mutex_init(&EVENT_QUEUE_MUTEX, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
+ switch_core_hash_init(&CUSTOM_HASH, RUNTIME_POOL);
+
+ switch_mutex_lock(EVENT_QUEUE_MUTEX);
+ SYSTEM_RUNNING = -1;
+ switch_mutex_unlock(EVENT_QUEUE_MUTEX);
switch_threadattr_create(&thd_attr, pool);
- switch_threadattr_detach_set(thd_attr, 1);
gethostname(hostname, sizeof(hostname));
switch_find_local_ip(guess_ip_v4, sizeof(guess_ip_v4), AF_INET);
switch_find_local_ip(guess_ip_v6, sizeof(guess_ip_v6), AF_INET6);
- THRUNTIME_POOL = RUNTIME_POOL = pool;
switch_queue_create(&EVENT_QUEUE[0], POOL_COUNT_MAX + 10, THRUNTIME_POOL);
switch_queue_create(&EVENT_QUEUE[1], POOL_COUNT_MAX + 10, THRUNTIME_POOL);
@@ -521,21 +569,13 @@
switch_queue_create(&EVENT_RECYCLE_QUEUE, 250000, THRUNTIME_POOL);
switch_queue_create(&EVENT_HEADER_RECYCLE_QUEUE, 250000, THRUNTIME_POOL);
-
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Activate Eventing Engine.\n");
- switch_thread_rwlock_create(&RWLOCK, RUNTIME_POOL);
- switch_mutex_init(&BLOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
- switch_mutex_init(&POOL_LOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
- switch_mutex_init(&EVENT_QUEUE_MUTEX, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
- switch_core_hash_init(&CUSTOM_HASH, RUNTIME_POOL);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_threadattr_priority_increase(thd_attr);
- switch_threadattr_detach_set(thd_attr, 1);
launch_dispatch_threads(1, DISPATCH_QUEUE_LEN, RUNTIME_POOL);
- switch_thread_create(&thread, thd_attr, switch_event_thread, EVENT_QUEUE[0], RUNTIME_POOL);
- switch_thread_create(&thread, thd_attr, switch_event_thread, EVENT_QUEUE[1], RUNTIME_POOL);
- switch_thread_create(&thread, thd_attr, switch_event_thread, EVENT_QUEUE[2], RUNTIME_POOL);
+ switch_thread_create(&EVENT_QUEUE_THREADS[0], thd_attr, switch_event_thread, EVENT_QUEUE[0], RUNTIME_POOL);
+ switch_thread_create(&EVENT_QUEUE_THREADS[1], thd_attr, switch_event_thread, EVENT_QUEUE[1], RUNTIME_POOL);
+ switch_thread_create(&EVENT_QUEUE_THREADS[2], thd_attr, switch_event_thread, EVENT_QUEUE[2], RUNTIME_POOL);
while (!THREAD_COUNT) {
switch_cond_next();
@@ -1029,7 +1069,7 @@
if (SYSTEM_RUNNING <= 0) {
/* sorry we're closed */
switch_event_destroy(event);
- return SWITCH_STATUS_FALSE;
+ return SWITCH_STATUS_SUCCESS;
}
switch_event_add_header_string(*event, SWITCH_STACK_BOTTOM, "Event-Name", switch_event_name((*event)->event_id));
Modified: freeswitch/trunk/src/switch_loadable_module.c
==============================================================================
--- freeswitch/trunk/src/switch_loadable_module.c (original)
+++ freeswitch/trunk/src/switch_loadable_module.c Thu Feb 19 19:10:59 2009
@@ -52,6 +52,7 @@
switch_module_shutdown_t switch_module_shutdown;
switch_memory_pool_t *pool;
switch_status_t status;
+ switch_thread_t *thread;
};
struct switch_loadable_module_container {
@@ -117,7 +118,7 @@
if (module->switch_module_runtime) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Starting runtime thread for %s\n", module->module_interface->module_name);
- switch_core_launch_thread(switch_loadable_module_exec, module, loadable_modules.pool);
+ module->thread = switch_core_launch_thread(switch_loadable_module_exec, module, loadable_modules.pool);
}
}
switch_mutex_unlock(loadable_modules.mutex);
@@ -910,7 +911,7 @@
} else if ((status = switch_loadable_module_load_file(path, file, global, &new_module)) == SWITCH_STATUS_SUCCESS) {
if ((status = switch_loadable_module_process(file, new_module)) == SWITCH_STATUS_SUCCESS && runtime) {
if (new_module->switch_module_runtime) {
- switch_core_launch_thread(switch_loadable_module_exec, new_module, new_module->pool);
+ new_module->thread = switch_core_launch_thread(switch_loadable_module_exec, new_module, new_module->pool);
}
} else if (status != SWITCH_STATUS_SUCCESS) {
*err = "module load routine returned an error";
@@ -1053,7 +1054,7 @@
module->switch_module_runtime = switch_module_runtime;
}
if (runtime && module->switch_module_runtime) {
- switch_core_launch_thread(switch_loadable_module_exec, module, module->pool);
+ module->thread = switch_core_launch_thread(switch_loadable_module_exec, module, module->pool);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Successfully Loaded [%s]\n", module_interface->module_name);
return switch_loadable_module_process((char *) module->filename, module);
@@ -1241,6 +1242,13 @@
if (unload && module->status != SWITCH_STATUS_NOUNLOAD && !(flags & SCF_VG)) {
switch_memory_pool_t *pool;
+ switch_status_t st;
+
+ if (module->thread) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s stopping runtime thread.\n", module->module_interface->module_name);
+ switch_thread_join(&st, module->thread);
+ }
+
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s unloaded.\n", module->module_interface->module_name);
switch_dso_destroy(&module->lib);
if ((pool = module->pool)) {
Modified: freeswitch/trunk/src/switch_log.c
==============================================================================
--- freeswitch/trunk/src/switch_log.c (original)
+++ freeswitch/trunk/src/switch_log.c Thu Feb 19 19:10:59 2009
@@ -193,6 +193,8 @@
return SWITCH_STATUS_SUCCESS;
}
+static switch_thread_t *thread;
+
static void *SWITCH_THREAD_FUNC log_thread(switch_thread_t *thread, void *obj)
{
@@ -382,7 +384,6 @@
SWITCH_DECLARE(switch_status_t) switch_log_init(switch_memory_pool_t *pool, switch_bool_t colorize)
{
- switch_thread_t *thread;
switch_threadattr_t *thd_attr;;
switch_assert(pool != NULL);
@@ -397,7 +398,6 @@
switch_queue_create(&LOG_RECYCLE_QUEUE, SWITCH_CORE_QUEUE_LEN, LOG_POOL);
switch_mutex_init(&BINDLOCK, SWITCH_MUTEX_NESTED, LOG_POOL);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- switch_threadattr_detach_set(thd_attr, 1);
switch_thread_create(&thread, thd_attr, log_thread, NULL, LOG_POOL);
while (!THREAD_RUNNING) {
@@ -433,12 +433,16 @@
SWITCH_DECLARE(switch_status_t) switch_log_shutdown(void)
{
+ switch_status_t st;
THREAD_RUNNING = -1;
switch_queue_push(LOG_QUEUE, NULL);
while (THREAD_RUNNING) {
switch_cond_next();
}
+
+ switch_thread_join(&st, thread);
+
switch_core_memory_reclaim_logger();
return SWITCH_STATUS_SUCCESS;
More information about the Freeswitch-svn
mailing list