Author: anthm Date: Thu May 10 12:56:29 2007 New Revision: 5123 Modified: freeswitch/trunk/Makefile.am freeswitch/trunk/conf/switch.conf.xml freeswitch/trunk/configure.in freeswitch/trunk/src/include/private/switch_core.h freeswitch/trunk/src/include/switch_utils.h freeswitch/trunk/src/switch_core.c freeswitch/trunk/src/switch_core_memory.c freeswitch/trunk/src/switch_core_session.c freeswitch/trunk/src/switch_core_sqldb.c freeswitch/trunk/src/switch_core_state_machine.c Log: make crash protection a runtime option instead of a compile-time option Modified: freeswitch/trunk/Makefile.am ============================================================================== --- freeswitch/trunk/Makefile.am (original) +++ freeswitch/trunk/Makefile.am Thu May 10 12:56:29 2007 @@ -10,10 +10,6 @@ BASE = $(switch_srcdir) OSARCH=`uname -s` -if CRASHPROT -AM_CFLAGS += -DCRASH_PROT -endif - .DEFAULT: @cd src/mod && $(MAKE) $(AM_MAKEFLAGS) $@ Modified: freeswitch/trunk/conf/switch.conf.xml ============================================================================== --- freeswitch/trunk/conf/switch.conf.xml (original) +++ freeswitch/trunk/conf/switch.conf.xml Thu May 10 12:56:29 2007 @@ -2,6 +2,8 @@ <settings> <!--Most channels to allow at once --> <param name="max-sessions" value="1000"/> + <!--Try to catch any crashes that can be recoverable (in the context of a call)--> + <param name="crash-protection" value="false"/> <!--RTP port range --> <!--<param name="rtp-start-port" value="16384"/>--> <!--<param name="rtp-end-port" value="32768"/>--> Modified: freeswitch/trunk/configure.in ============================================================================== --- freeswitch/trunk/configure.in (original) +++ freeswitch/trunk/configure.in Thu May 10 12:56:29 2007 @@ -311,9 +311,6 @@ LIBCURL_CHECK_CONFIG([yes], [7.13.0], [LIBCURL_DEPS=''], [LIBCURL_DEPS='${switch_srcdir}/libs/curl/lib/libcurl.la';LIBCURL='${switch_srcdir}/libs/curl/lib/libcurl.la';LIBCURL_CPPFLAGS='-I${switch_srcdir}/libs/curl/include']) AC_SUBST(LIBCURL_DEPS) -AC_ARG_ENABLE(crash-protection, - [ --enable-crash-protection Compile with CRASH Protection],,[enable_crash_prot="no"]) - AC_ARG_ENABLE(core-odbc-support, [ --enable-core-odbc-support Compile with ODBC Support],,[enable_core_odbc_support="no"]) @@ -323,7 +320,6 @@ #AX_LIB_MYSQL([MINIMUM-VERSION]) AX_LIB_MYSQL -AM_CONDITIONAL([CRASHPROT],[test "x$enable_crash_prot" != "xno"]) AM_CONDITIONAL([ADD_ODBC],[test "x$enable_core_odbc_support" != "xno"]) AM_CONDITIONAL([ADD_LIBEDIT],[test "x$enable_core_libedit_support" != "xno"]) AM_CONDITIONAL([HAVE_MYSQL],[test "$found_mysql" = "yes"]) Modified: freeswitch/trunk/src/include/private/switch_core.h ============================================================================== --- freeswitch/trunk/src/include/private/switch_core.h (original) +++ freeswitch/trunk/src/include/private/switch_core.h Thu May 10 12:56:29 2007 @@ -63,12 +63,6 @@ /* #define DEBUG_ALLOC */ #define DO_EVENTS -#ifdef CRASH_PROT -#define __CP "ENABLED" -#else -#define __CP "DISABLED" -#endif - #define SWITCH_EVENT_QUEUE_LEN 256 #define SWITCH_MESSAGE_QUEUE_LEN 256 #define SWITCH_SQL_QUEUE_LEN 2000 @@ -145,6 +139,22 @@ struct switch_media_bug *next; }; +struct switch_runtime { + switch_time_t initiated; + switch_hash_t *global_vars; + switch_memory_pool_t *memory_pool; + const switch_state_handler_table_t *state_handlers[SWITCH_MAX_STATE_HANDLERS]; + int state_handler_index; + FILE *console; + uint8_t running; + char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1]; + uint32_t no_new_sessions; + uint32_t shutting_down; + uint32_t crash_prot; +}; + +extern struct switch_runtime runtime; + void switch_core_sqldb_start(switch_memory_pool_t *pool); void switch_core_sqldb_stop(void); void switch_core_session_init(switch_memory_pool_t *pool); Modified: freeswitch/trunk/src/include/switch_utils.h ============================================================================== --- freeswitch/trunk/src/include/switch_utils.h (original) +++ freeswitch/trunk/src/include/switch_utils.h Thu May 10 12:56:29 2007 @@ -76,6 +76,8 @@ (expr && ( !strcasecmp(expr, "yes") ||\ !strcasecmp(expr, "on") ||\ !strcasecmp(expr, "true") ||\ +!strcasecmp(expr, "enabled") ||\ +!strcasecmp(expr, "active") ||\ atoi(expr))) ? SWITCH_TRUE : SWITCH_FALSE /*! \brief find local ip of the box Modified: freeswitch/trunk/src/switch_core.c ============================================================================== --- freeswitch/trunk/src/switch_core.c (original) +++ freeswitch/trunk/src/switch_core.c Thu May 10 12:56:29 2007 @@ -40,19 +40,7 @@ SWITCH_DECLARE_DATA switch_directories SWITCH_GLOBAL_dirs = { 0 }; /* The main runtime obj we keep this hidden for ourselves */ -static struct { - switch_time_t initiated; - switch_hash_t *global_vars; - switch_memory_pool_t *memory_pool; - const switch_state_handler_table_t *state_handlers[SWITCH_MAX_STATE_HANDLERS]; - int state_handler_index; - FILE *console; - uint8_t running; - char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1]; - uint32_t no_new_sessions; - uint32_t shutting_down; -} runtime; - +struct switch_runtime runtime; static void send_heartbeat(void) { @@ -424,7 +412,6 @@ switch_core_set_globals(); switch_core_session_init(runtime.memory_pool); - switch_core_state_machine_init(runtime.memory_pool); switch_core_hash_init(&runtime.global_vars, runtime.memory_pool); @@ -443,7 +430,9 @@ const char *var = switch_xml_attr_soft(param, "name"); const char *val = switch_xml_attr_soft(param, "value"); - if (!strcasecmp(var, "max-sessions")) { + if (!strcasecmp(var, "crash-protection")) { + runtime.crash_prot = switch_true(val); + } else if (!strcasecmp(var, "max-sessions")) { switch_core_session_limit(atoi(val)); } else if (!strcasecmp(var, "rtp-start-port")) { @@ -469,6 +458,8 @@ switch_xml_free(xml); } + switch_core_state_machine_init(runtime.memory_pool); + *err = NULL; if (console) { @@ -583,7 +574,8 @@ } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, - "\nFreeSWITCH Version %s Started.\nCrash Protection [%s]\nMax Sessions[%u]\n\n", SWITCH_VERSION_FULL, __CP, + "\nFreeSWITCH Version %s Started.\nCrash Protection [%s]\nMax Sessions[%u]\n\n", SWITCH_VERSION_FULL, + runtime.crash_prot ? "Enabled" : "Disabled", switch_core_session_limit(0)); return SWITCH_STATUS_SUCCESS; Modified: freeswitch/trunk/src/switch_core_memory.c ============================================================================== --- freeswitch/trunk/src/switch_core_memory.c (original) +++ freeswitch/trunk/src/switch_core_memory.c Thu May 10 12:56:29 2007 @@ -36,7 +36,7 @@ static struct { switch_memory_pool_t *memory_pool; -} runtime; +} memory_manager; SWITCH_DECLARE(switch_memory_pool_t *) switch_core_session_get_pool(switch_core_session_t *session) { @@ -68,14 +68,14 @@ SWITCH_DECLARE(void *) switch_core_permanent_alloc(switch_size_t memory) { void *ptr = NULL; - assert(runtime.memory_pool != NULL); + assert(memory_manager.memory_pool != NULL); #ifdef DEBUG_ALLOC switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Perm Allocate %d\n", memory); #endif - if ((ptr = apr_palloc(runtime.memory_pool, memory)) != 0) { + if ((ptr = apr_palloc(memory_manager.memory_pool, memory)) != 0) { memset(ptr, 0, memory); } return ptr; @@ -85,7 +85,7 @@ { char *duped = NULL; switch_size_t len; - assert(runtime.memory_pool != NULL); + assert(memory_manager.memory_pool != NULL); if (!todup) return NULL; @@ -96,7 +96,7 @@ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Perm Allocate %d\n", len); #endif - if (todup && (duped = apr_palloc(runtime.memory_pool, len)) != 0) { + if (todup && (duped = apr_palloc(memory_manager.memory_pool, len)) != 0) { strncpy(duped, todup, len); } return duped; @@ -214,8 +214,8 @@ switch_memory_pool_t *switch_core_memory_init(void) { - memset(&runtime, 0, sizeof(runtime)); + memset(&memory_manager, 0, sizeof(memory_manager)); - apr_pool_create(&runtime.memory_pool, NULL); - return runtime.memory_pool; + apr_pool_create(&memory_manager.memory_pool, NULL); + return memory_manager.memory_pool; } Modified: freeswitch/trunk/src/switch_core_session.c ============================================================================== --- freeswitch/trunk/src/switch_core_session.c (original) +++ freeswitch/trunk/src/switch_core_session.c Thu May 10 12:56:29 2007 @@ -41,7 +41,7 @@ uint32_t session_count; uint32_t session_limit; switch_size_t session_id; -} runtime; +} session_manager; #ifdef SWITCH_DEBUG_RWLOCKS @@ -53,8 +53,8 @@ switch_core_session_t *session = NULL; if (uuid_str) { - switch_mutex_lock(runtime.session_table_mutex); - if ((session = switch_core_hash_find(runtime.session_table, uuid_str))) { + switch_mutex_lock(session_manager.session_table_mutex); + if ((session = switch_core_hash_find(session_manager.session_table, uuid_str))) { /* 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) { @@ -65,7 +65,7 @@ session = NULL; } } - switch_mutex_unlock(runtime.session_table_mutex); + switch_mutex_unlock(session_manager.session_table_mutex); } /* if its not NULL, now it's up to you to rwunlock this */ @@ -80,8 +80,8 @@ switch_channel_t *channel; uint32_t loops = 0; - switch_mutex_lock(runtime.session_table_mutex); - for (hi = switch_hash_first(runtime.memory_pool, runtime.session_table); hi; hi = switch_hash_next(hi)) { + switch_mutex_lock(session_manager.session_table_mutex); + for (hi = switch_hash_first(session_manager.memory_pool, 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; @@ -90,13 +90,13 @@ switch_core_session_kill_channel(session, SWITCH_SIG_KILL); } } - switch_mutex_unlock(runtime.session_table_mutex); + switch_mutex_unlock(session_manager.session_table_mutex); - while (runtime.session_count > 0) { + while (session_manager.session_count > 0) { switch_yield(100000); if (++loops == 100) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Giving up with %d session%s remaining\n", - runtime.session_count, runtime.session_count == 1 ? "" : "s"); + session_manager.session_count, session_manager.session_count == 1 ? "" : "s"); break; } } @@ -107,8 +107,8 @@ switch_core_session_t *session = NULL; switch_status_t status = SWITCH_STATUS_FALSE; - switch_mutex_lock(runtime.session_table_mutex); - if ((session = switch_core_hash_find(runtime.session_table, uuid_str)) != 0) { + switch_mutex_lock(session_manager.session_table_mutex); + if ((session = switch_core_hash_find(session_manager.session_table, uuid_str)) != 0) { /* Acquire a read lock on the session or forget it the channel is dead */ if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) { if (switch_channel_get_state(session->channel) < CS_HANGUP) { @@ -117,7 +117,7 @@ switch_core_session_rwunlock(session); } } - switch_mutex_unlock(runtime.session_table_mutex); + switch_mutex_unlock(session_manager.session_table_mutex); return status; } @@ -127,8 +127,8 @@ switch_core_session_t *session = NULL; switch_status_t status = SWITCH_STATUS_FALSE; - switch_mutex_lock(runtime.session_table_mutex); - if ((session = switch_core_hash_find(runtime.session_table, uuid_str)) != 0) { + switch_mutex_lock(session_manager.session_table_mutex); + if ((session = switch_core_hash_find(session_manager.session_table, uuid_str)) != 0) { /* Acquire a read lock on the session or forget it the channel is dead */ if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) { if (switch_channel_get_state(session->channel) < CS_HANGUP) { @@ -137,7 +137,7 @@ switch_core_session_rwunlock(session); } } - switch_mutex_unlock(runtime.session_table_mutex); + switch_mutex_unlock(session_manager.session_table_mutex); return status; } @@ -662,12 +662,12 @@ switch_scheduler_del_task_group((*session)->uuid_str); - switch_mutex_lock(runtime.session_table_mutex); - switch_core_hash_delete(runtime.session_table, (*session)->uuid_str); - if (runtime.session_count) { - runtime.session_count--; + switch_mutex_lock(session_manager.session_table_mutex); + switch_core_hash_delete(session_manager.session_table, (*session)->uuid_str); + if (session_manager.session_count) { + session_manager.session_count--; } - switch_mutex_unlock(runtime.session_table_mutex); + switch_mutex_unlock(session_manager.session_table_mutex); if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_DESTROY) == SWITCH_STATUS_SUCCESS) { switch_channel_event_set_data((*session)->channel, event); @@ -750,11 +750,11 @@ assert(endpoint_interface != NULL); - switch_mutex_lock(runtime.session_table_mutex); - count = runtime.session_count; - switch_mutex_unlock(runtime.session_table_mutex); + switch_mutex_lock(session_manager.session_table_mutex); + count = session_manager.session_count; + switch_mutex_unlock(session_manager.session_table_mutex); - if ((count + 1) > runtime.session_limit) { + if ((count + 1) > session_manager.session_limit) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Over Session Limit!\n"); return NULL; } @@ -812,23 +812,23 @@ switch_thread_rwlock_create(&session->rwlock, session->pool); snprintf(session->name, sizeof(session->name), "%"SWITCH_SIZE_T_FMT, session->id); - switch_mutex_lock(runtime.session_table_mutex); - session->id = runtime.session_id++; - switch_core_hash_insert(runtime.session_table, session->uuid_str, session); - runtime.session_count++; - switch_mutex_unlock(runtime.session_table_mutex); + switch_mutex_lock(session_manager.session_table_mutex); + session->id = session_manager.session_id++; + switch_core_hash_insert(session_manager.session_table, session->uuid_str, session); + session_manager.session_count++; + switch_mutex_unlock(session_manager.session_table_mutex); return session; } SWITCH_DECLARE(uint32_t) switch_core_session_count(void) { - return runtime.session_count; + return session_manager.session_count; } SWITCH_DECLARE(switch_size_t) switch_core_session_id(void) { - return runtime.session_id; + return session_manager.session_id; } @@ -867,21 +867,21 @@ SWITCH_DECLARE(uint32_t) switch_core_session_limit(uint32_t new_limit) { if (new_limit) { - runtime.session_limit = new_limit; + session_manager.session_limit = new_limit; } - return runtime.session_limit; + return session_manager.session_limit; } void switch_core_session_init(switch_memory_pool_t *pool) { - memset(&runtime, 0, sizeof(runtime)); - runtime.session_limit = 1000; - runtime.session_id = 1; - runtime.memory_pool = pool; - switch_core_hash_init(&runtime.session_table, runtime.memory_pool); - switch_mutex_init(&runtime.session_table_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool); + memset(&session_manager, 0, sizeof(session_manager)); + session_manager.session_limit = 1000; + session_manager.session_id = 1; + session_manager.memory_pool = pool; + switch_core_hash_init(&session_manager.session_table, session_manager.memory_pool); + switch_mutex_init(&session_manager.session_table_mutex, SWITCH_MUTEX_NESTED, session_manager.memory_pool); } Modified: freeswitch/trunk/src/switch_core_sqldb.c ============================================================================== --- freeswitch/trunk/src/switch_core_sqldb.c (original) +++ freeswitch/trunk/src/switch_core_sqldb.c Thu May 10 12:56:29 2007 @@ -40,7 +40,7 @@ switch_queue_t *sql_queue; switch_memory_pool_t *memory_pool; int thread_running; -} runtime; +} sql_manager; static switch_status_t switch_core_db_persistant_execute_trans(switch_core_db_t *db, char *sql, uint32_t retries) { @@ -157,14 +157,14 @@ char *sql; switch_size_t newlen; - if (!runtime.event_db) { - runtime.event_db = switch_core_db_handle(); + if (!sql_manager.event_db) { + sql_manager.event_db = switch_core_db_handle(); } - runtime.thread_running = 1; + sql_manager.thread_running = 1; for (;;) { - if (switch_queue_trypop(runtime.sql_queue, &pop) == SWITCH_STATUS_SUCCESS) { + if (switch_queue_trypop(sql_manager.sql_queue, &pop) == SWITCH_STATUS_SUCCESS) { sql = (char *) pop; if (sql) { @@ -199,7 +199,7 @@ if (trans && ((itterations == target) || nothing_in_queue)) { - if (switch_core_db_persistant_execute_trans(runtime.event_db, sqlbuf, 1000) != SWITCH_STATUS_SUCCESS) { + if (switch_core_db_persistant_execute_trans(sql_manager.event_db, sqlbuf, 1000) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL thread unable to commit transaction, records lost!\n"); } itterations = 0; @@ -228,7 +228,7 @@ sql = switch_mprintf("insert into tasks values('%q','%q','%q','%q')", switch_event_get_header(event, "task-id"), switch_event_get_header(event, "task-desc"), - switch_event_get_header(event, "task-group"), switch_event_get_header(event, "task-runtime") + switch_event_get_header(event, "task-group"), switch_event_get_header(event, "task-sql_manager") ); break; case SWITCH_EVENT_DEL_SCHEDULE: @@ -236,8 +236,8 @@ sql = switch_mprintf("delete from tasks where task_id=%q", switch_event_get_header(event, "task-id")); break; case SWITCH_EVENT_RE_SCHEDULE: - sql = switch_mprintf("update tasks set task_runtime='%q' where task_id=%q", - switch_event_get_header(event, "task-runtime"), switch_event_get_header(event, "task-id")); + sql = switch_mprintf("update tasks set task_sql_manager='%q' where task_id=%q", + switch_event_get_header(event, "task-sql_manager"), switch_event_get_header(event, "task-id")); break; case SWITCH_EVENT_CHANNEL_DESTROY: sql = switch_mprintf("delete from channels where uuid='%q'", switch_event_get_header(event, "unique-id")); @@ -334,7 +334,7 @@ } if (sql) { - switch_queue_push(runtime.sql_queue, sql); + switch_queue_push(sql_manager.sql_queue, sql); sql = NULL; } } @@ -345,10 +345,10 @@ switch_thread_t *thread; switch_threadattr_t *thd_attr;; - runtime.memory_pool = pool; + sql_manager.memory_pool = pool; /* Activate SQL database */ - if ((runtime.db = switch_core_db_handle()) == 0) { + if ((sql_manager.db = switch_core_db_handle()) == 0) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB!\n"); } else { char create_channels_sql[] = @@ -382,43 +382,43 @@ char create_tasks_sql[] = "CREATE TABLE tasks (\n" " task_id INTEGER(4),\n" - " task_desc VARCHAR(255),\n" " task_group VARCHAR(255),\n" " task_runtime INTEGER(8)\n" ");\n"; + " task_desc VARCHAR(255),\n" " task_group VARCHAR(255),\n" " task_sql_manager INTEGER(8)\n" ");\n"; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Opening DB\n"); - switch_core_db_exec(runtime.db, "drop table channels", NULL, NULL, NULL); - switch_core_db_exec(runtime.db, "drop table calls", NULL, NULL, NULL); - switch_core_db_exec(runtime.db, "drop table interfaces", NULL, NULL, NULL); - switch_core_db_exec(runtime.db, "drop table tasks", NULL, NULL, NULL); - switch_core_db_exec(runtime.db, create_channels_sql, NULL, NULL, NULL); - switch_core_db_exec(runtime.db, create_calls_sql, NULL, NULL, NULL); - switch_core_db_exec(runtime.db, create_interfaces_sql, NULL, NULL, NULL); - switch_core_db_exec(runtime.db, create_tasks_sql, NULL, NULL, NULL); + switch_core_db_exec(sql_manager.db, "drop table channels", NULL, NULL, NULL); + switch_core_db_exec(sql_manager.db, "drop table calls", NULL, NULL, NULL); + switch_core_db_exec(sql_manager.db, "drop table interfaces", NULL, NULL, NULL); + switch_core_db_exec(sql_manager.db, "drop table tasks", NULL, NULL, NULL); + switch_core_db_exec(sql_manager.db, create_channels_sql, NULL, NULL, NULL); + switch_core_db_exec(sql_manager.db, create_calls_sql, NULL, NULL, NULL); + switch_core_db_exec(sql_manager.db, create_interfaces_sql, NULL, NULL, NULL); + switch_core_db_exec(sql_manager.db, create_tasks_sql, NULL, NULL, NULL); if (switch_event_bind("core_db", SWITCH_EVENT_ALL, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't bind event handler!\n"); } } - switch_queue_create(&runtime.sql_queue, SWITCH_SQL_QUEUE_LEN, runtime.memory_pool); + switch_queue_create(&sql_manager.sql_queue, SWITCH_SQL_QUEUE_LEN, sql_manager.memory_pool); - switch_threadattr_create(&thd_attr, runtime.memory_pool); + switch_threadattr_create(&thd_attr, sql_manager.memory_pool); switch_threadattr_detach_set(thd_attr, 1); switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE); - switch_thread_create(&thread, thd_attr, switch_core_sql_thread, NULL, runtime.memory_pool); - while (!runtime.thread_running) { + switch_thread_create(&thread, thd_attr, switch_core_sql_thread, NULL, sql_manager.memory_pool); + while (!sql_manager.thread_running) { switch_yield(10000); } } void switch_core_sqldb_stop(void) { - switch_queue_push(runtime.sql_queue, NULL); + switch_queue_push(sql_manager.sql_queue, NULL); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Waiting for unfinished SQL transactions\n"); - while (switch_queue_size(runtime.sql_queue) > 0) { + while (switch_queue_size(sql_manager.sql_queue) > 0) { switch_yield(10000); } - switch_core_db_close(runtime.db); - switch_core_db_close(runtime.event_db); + switch_core_db_close(sql_manager.db); + switch_core_db_close(sql_manager.event_db); } Modified: freeswitch/trunk/src/switch_core_state_machine.c ============================================================================== --- freeswitch/trunk/src/switch_core_state_machine.c (original) +++ freeswitch/trunk/src/switch_core_state_machine.c Thu May 10 12:56:29 2007 @@ -204,9 +204,7 @@ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Standard HIBERNATE\n"); } - -#ifdef CRASH_PROT -static switch_hash_t *stack_table; +static switch_hash_t *stack_table = NULL; #if defined (__GNUC__) && defined (LINUX) #include <execinfo.h> #include <stdio.h> @@ -254,14 +252,13 @@ abort(); } } -#endif + void switch_core_state_machine_init(switch_memory_pool_t *pool) { - (void)0; -#ifdef CRASH_PROT - switch_core_hash_init(&stack_table, pool); -#endif + if (runtime.crash_prot) { + switch_core_hash_init(&stack_table, pool); + } } SWITCH_DECLARE(void) switch_core_session_run(switch_core_session_t *session) @@ -270,31 +267,33 @@ const switch_endpoint_interface_t *endpoint_interface; const switch_state_handler_table_t *driver_state_handler = NULL; const switch_state_handler_table_t *application_state_handler = NULL; - -#ifdef CRASH_PROT - switch_thread_id_t thread_id = switch_thread_self(); + switch_thread_id_t thread_id; jmp_buf env; int sig; - signal(SIGSEGV, handle_fatality); - signal(SIGFPE, handle_fatality); + if (runtime.crash_prot) { + thread_id = switch_thread_self(); + signal(SIGSEGV, handle_fatality); + signal(SIGFPE, handle_fatality); #ifndef WIN32 - signal(SIGBUS, handle_fatality); + signal(SIGBUS, handle_fatality); #endif - if ((sig = setjmp(env)) != 0) { - switch_event_t *event; + if ((sig = setjmp(env)) != 0) { + switch_event_t *event; - if (switch_event_create(&event, SWITCH_EVENT_SESSION_CRASH) == SWITCH_STATUS_SUCCESS) { - switch_channel_event_set_data(session->channel, event); - switch_event_fire(&event); + if (switch_event_create(&event, SWITCH_EVENT_SESSION_CRASH) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(session->channel, event); + switch_event_fire(&event); + } + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Thread has crashed for channel %s\n", switch_channel_get_name(session->channel)); + switch_channel_hangup(session->channel, SWITCH_CAUSE_CRASH); + } else { + apr_hash_set(stack_table, &thread_id, sizeof(thread_id), &env); } - switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Thread has crashed for channel %s\n", switch_channel_get_name(session->channel)); - switch_channel_hangup(session->channel, SWITCH_CAUSE_CRASH); - } else { - apr_hash_set(stack_table, &thread_id, sizeof(thread_id), &env); } -#endif + + /* Life of the channel. you have channel and pool in your session everywhere you go you use the session to malloc with @@ -646,9 +645,9 @@ done: switch_mutex_unlock(session->mutex); -#ifdef CRASH_PROT - apr_hash_set(stack_table, &thread_id, sizeof(thread_id), NULL); -#endif + if (runtime.crash_prot) { + apr_hash_set(stack_table, &thread_id, sizeof(thread_id), NULL); + } session->thread_running = 0; }