ok maybe this will fix the conditional mutext race we will readlock the session…

ok maybe this will fix the conditional mutext race we will readlock the session during any callbacks and cancel the operation if read_lock fails

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@2709 d0543943-73ff-0310-b7d9-9358b9ac24b2

src/mod/endpoints/mod_sofia/mod_sofia.c

@@ -375,7 +375,7 @@ static void terminate_session(switch_core_session_t **session, switch_call_cause
 		switch_channel_t *channel = switch_core_session_get_channel(*session);
 		switch_channel_state_t state = switch_channel_get_state(channel);
 		struct private_object *tech_pvt = NULL;
-			
+
 		tech_pvt = switch_core_session_get_private(*session);
 
 		if (tech_pvt) {
@@ -456,7 +456,6 @@ static void do_invite(switch_core_session_t *session)
 	switch_set_flag_locked(tech_pvt, TFLAG_READY);
 	
 	tech_pvt->nh = nua_handle(tech_pvt->profile->nua, NULL, SIPTAG_TO_STR(tech_pvt->dest), TAG_END());
-
 	nua_handle_bind(tech_pvt->nh, session);
 	nua_invite(tech_pvt->nh,
 			   SOATAG_USER_SDP_STR(tech_pvt->local_sdp_str),
@@ -1560,7 +1559,12 @@ static void event_callback(nua_event_t   event,
 						   sip_t const  *sip,
 						   tagi_t        tags[])
 {
-
+	if (session) {
+		if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
+			/* too late */
+			return;
+		}
+	}
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "channel [%s] event [%s] status [%d] [%s]\n",
 					  session ? switch_channel_get_name(switch_core_session_get_channel(session)) : "null",nua_event_name (event), status, phrase);
 	
@@ -1681,6 +1685,10 @@ static void event_callback(nua_event_t   event,
 		break;
 
 	}
+
+	if (session) {
+		switch_core_session_rwunlock(session);
+	}
 }
 
 static void *SWITCH_THREAD_FUNC profile_thread_run(switch_thread_t *thread, void *obj)

src/switch_channel.c

@@ -381,8 +381,14 @@ SWITCH_DECLARE(void) switch_channel_clear_flag(switch_channel_t *channel, switch
 
 SWITCH_DECLARE(switch_channel_state_t) switch_channel_get_state(switch_channel_t *channel)
 {
+	switch_channel_state_t state;
 	assert(channel != NULL);
-	return channel->state;
+
+	switch_mutex_lock(channel->flag_mutex);
+	state = channel->state;
+	switch_mutex_unlock(channel->flag_mutex);
+
+	return state;
 }
 
 SWITCH_DECLARE(unsigned int) switch_channel_ready(switch_channel_t *channel)
@@ -433,16 +439,18 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_state(switch_c
 
 
 	assert(channel != NULL);
+	switch_mutex_lock(channel->flag_mutex);
+
 	last_state = channel->state;
 
 	if (last_state == state) {
-		return state;
+		goto done;
 	}
 
 	if (last_state >= CS_HANGUP && state < last_state) {
-		return last_state;
+		goto done;
 	}
-
+	
 	/* STUB for more dev
 	   case CS_INIT:
 	   switch(state) {
@@ -589,11 +597,11 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_state(switch_c
 				switch_event_fire(&event);
 			}
 		}
-		/*		
+				
 		if (state < CS_DONE) {
 			switch_core_session_signal_state_change(channel->session);
 		}
-		*/
+		
 	} else {
 		switch_log_printf(SWITCH_CHANNEL_ID_LOG, (char *) file, func, line, SWITCH_LOG_WARNING, "%s Invalid State Change %s -> %s\n", 
 						  channel->name,
@@ -606,6 +614,8 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_state(switch_c
 			assert(0);
 		}
 	}
+ done:
+	switch_mutex_unlock(channel->flag_mutex);
 	return channel->state;
 }
 
@@ -854,6 +864,7 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_hangup(switch_chan
 																   switch_call_cause_t hangup_cause)
 {
 	assert(channel != NULL);
+	switch_mutex_lock(channel->flag_mutex);
 
 	if (channel->times && !channel->times->hungup) {
 		channel->times->hungup = switch_time_now();
@@ -862,9 +873,7 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_hangup(switch_chan
 	if (channel->state < CS_HANGUP) {
 		switch_event_t *event;
 		switch_channel_state_t last_state = channel->state;
-		switch_mutex_lock(channel->flag_mutex);
 		channel->state = CS_HANGUP;
-		switch_mutex_unlock(channel->flag_mutex);
 		channel->hangup_cause = hangup_cause;
 		switch_log_printf(SWITCH_CHANNEL_ID_LOG, (char *) file, func, line, SWITCH_LOG_NOTICE, "Hangup %s [%s] [%s]\n", 
 						  channel->name,
@@ -876,8 +885,10 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_hangup(switch_chan
 		}
 
 		switch_core_session_kill_channel(channel->session, SWITCH_SIG_KILL);
-		//switch_core_session_signal_state_change(channel->session);
+		switch_core_session_signal_state_change(channel->session);
 	}
+
+	switch_mutex_unlock(channel->flag_mutex);
 	return channel->state;
 }
 

src/switch_core.c

@@ -90,8 +90,8 @@ struct switch_core_session {
 	switch_audio_resampler_t *read_resampler;
 	switch_audio_resampler_t *write_resampler;
 
-	//switch_mutex_t *mutex;
-	//switch_thread_cond_t *cond;
+	switch_mutex_t *mutex;
+	switch_thread_cond_t *cond;
 
 	switch_thread_rwlock_t *rwlock;
 
@@ -2489,13 +2489,13 @@ static void switch_core_standard_on_hold(switch_core_session_t *session)
 
 SWITCH_DECLARE(void) switch_core_session_signal_state_change(switch_core_session_t *session)
 {
-	return;
-	/* If trylock fails the signal is already awake so we needn't bother 
+
+	/* If trylock fails the signal is already awake so we needn't bother */
 	if (switch_mutex_trylock(session->mutex) == SWITCH_STATUS_SUCCESS) {
 		switch_thread_cond_signal(session->cond);
 		switch_mutex_unlock(session->mutex);
 	} 
-	*/
+	
 }
 
 SWITCH_DECLARE(unsigned int) switch_core_session_runing(switch_core_session_t *session)
@@ -2555,7 +2555,7 @@ static int handle_fatality(int sig)
 
 SWITCH_DECLARE(void) switch_core_session_run(switch_core_session_t *session)
 {
-	switch_channel_state_t state = CS_NEW, laststate = CS_HANGUP, midstate = CS_DONE;
+	switch_channel_state_t state = CS_NEW, laststate = CS_HANGUP, midstate = CS_DONE, endstate;
 	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;
@@ -2607,7 +2607,7 @@ SWITCH_DECLARE(void) switch_core_session_run(switch_core_session_t *session)
 	driver_state_handler = endpoint_interface->state_handler;
 	assert(driver_state_handler != NULL);
 
-	//switch_mutex_lock(session->mutex);
+	switch_mutex_lock(session->mutex);
 
 	while ((state = switch_channel_get_state(session->channel)) != CS_DONE) {
 		if (state != laststate) {
@@ -2886,20 +2886,20 @@ SWITCH_DECLARE(void) switch_core_session_run(switch_core_session_t *session)
 			laststate = midstate;
 		}
 		
-		if (state >= CS_HANGUP) {
+
+		endstate = switch_channel_get_state(session->channel);
+
+		if (endstate >= CS_HANGUP) {
 			goto done;
 		}
 
-		if (midstate == switch_channel_get_state(session->channel)) {
-			//switch_thread_cond_wait(session->cond, session->mutex);
-			switch_yield(10000);
-		} else {
-			switch_yield(1000);
+		if (midstate == endstate) {
+			switch_thread_cond_wait(session->cond, session->mutex);
 		}
 
 	}
  done:
-	//switch_mutex_unlock(session->mutex);
+	switch_mutex_unlock(session->mutex);
 
 #ifdef CRASH_PROT
 	apr_hash_set(runtime.stack_table, &thread_id, sizeof(thread_id), NULL);
@@ -3151,9 +3151,9 @@ SWITCH_DECLARE(switch_core_session_t *) switch_core_session_request(const switch
 	session->enc_read_frame.data = session->enc_read_buf;
 	session->enc_read_frame.buflen = sizeof(session->enc_read_buf);
 
-	//switch_mutex_init(&session->mutex, SWITCH_MUTEX_NESTED, session->pool);
+	switch_mutex_init(&session->mutex, SWITCH_MUTEX_NESTED, session->pool);
 	switch_thread_rwlock_create(&session->bug_rwlock, session->pool);
-	//switch_thread_cond_create(&session->cond, session->pool);
+	switch_thread_cond_create(&session->cond, session->pool);
 	switch_thread_rwlock_create(&session->rwlock, session->pool);
 
 	switch_mutex_lock(runtime.session_table_mutex);