kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Changes for segfaults on shutdown and cpu usage 

git-svn-id: http://svn.openzap.org/svn/openzap/branches/sangoma_boost@932 a93c3328-9c30-0410-af19-c9cd2b2d52af
This commit is contained in:
David Yat Sin 2009-12-09 18:51:55 +00:00
parent c376f9d092
commit 15c93b5c0d
3 changed files with 74 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
libs/freetdm/src/ozmod/ozmod_sangoma_boost/ozmod_sangoma_boost.c
View File

@ -1466,7 +1466,7 @@ static void *zap_sangoma_boost_run(zap_thread_t *me, void *obj)
break;
}
if ((activity = zap_boost_wait_event(span, ms)) < 0) {
if ((activity = zap_boost_wait_event(span, -1)) < 0) {
zap_log(ZAP_LOG_ERROR, "zap_boost_wait_event failed\n");
goto error;
}
@ -1568,13 +1568,21 @@ static zap_status_t zap_sangoma_boost_start(zap_span_t *span)
static zap_status_t zap_sangoma_boost_stop(zap_span_t *span)
{
int cnt = 10;
zap_status_t status = ZAP_SUCCESS;
zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data;
if (sangoma_boost_data->sigmod) {
/* FIXME: we should make sure the span thread is stopped (use pthread_kill or openzap thread kill function) */
/* I think stopping the span before destroying the queue makes sense
otherwise may be boost events would still arrive when the queue is already destroyed! */
status = sangoma_boost_data->sigmod->stop_span(span);
zap_queue_enqueue(sangoma_boost_data->boost_queue, NULL);
while(zap_test_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RUNNING) && cnt-- > 0) {
zap_log(ZAP_LOG_DEBUG, "Waiting for boost thread\n");
zap_sleep(500);
}
zap_queue_destroy(&sangoma_boost_data->boost_queue);
return status;
}

11
libs/freetdm/src/ozmod/ozmod_wanpipe/ozmod_wanpipe.c
View File

@ -245,7 +245,11 @@ static unsigned wp_open_range(zap_span_t *span, unsigned spanno, unsigned start,
wanpipe_tdm_api_t tdm_api;
memset(&tdm_api, 0, sizeof(tdm_api));
#ifdef LIBSANGOMA_VERSION
sangstatus = sangoma_wait_obj_create(&sangoma_wait_obj, sockfd, SANGOMA_DEVICE_WAIT_OBJ);
/* we need SANGOMA_DEVICE_WAIT_OBJ_SIG and not SANGOMA_DEVICE_WAIT_OBJ alone because we need to call
* sangoma_wait_obj_sig to wake up any I/O waiters when closing the channel (typically on zap shutdown)
* this adds an extra pair of file descriptors to the waitable object
* */
sangstatus = sangoma_wait_obj_create(&sangoma_wait_obj, sockfd, SANGOMA_DEVICE_WAIT_OBJ_SIG);
if (sangstatus != SANG_STATUS_SUCCESS) {
zap_log(ZAP_LOG_ERROR, "failure create waitable object for s%dc%d\n", spanno, x);
continue;
@ -493,6 +497,11 @@ static ZIO_OPEN_FUNCTION(wanpipe_open)
*/
static ZIO_CLOSE_FUNCTION(wanpipe_close)
{
#ifdef LIBSANGOMA_VERSION
sangoma_wait_obj_t *waitobj = zchan->mod_data;
/* kick any I/O waiters */
sangoma_wait_obj_signal(waitobj);
#endif
return ZAP_SUCCESS;
}

93
libs/freetdm/src/zap_io.c
View File

@ -276,26 +276,6 @@ OZ_DECLARE_NONSTD(uint32_t) zap_hash_hashfromstring(void *ky)
return hash;
}
static zap_status_t zap_span_destroy(zap_span_t *span)
{
zap_status_t status = ZAP_FAIL;
if (zap_test_flag(span, ZAP_SPAN_CONFIGURED)) {
if (span->stop) {
span->stop(span);
}
if (span->zio && span->zio->span_destroy) {
zap_log(ZAP_LOG_INFO, "Destroying span %u type (%s)\n", span->span_id, span->type);
status = span->zio->span_destroy(span);
zap_safe_free(span->type);
zap_safe_free(span->dtmf_hangup);
}
}
return status;
}
static zap_status_t zap_channel_destroy(zap_channel_t *zchan)
{
@ -342,6 +322,48 @@ static zap_status_t zap_channel_destroy(zap_channel_t *zchan)
return ZAP_SUCCESS;
}
static zap_status_t zap_span_destroy(zap_span_t *span)
{
zap_status_t status = ZAP_SUCCESS;
unsigned j;
zap_mutex_lock(span->mutex);
/* stop the signaling */
if (span->stop) {
status = span->stop(span);
}
/* destroy the channels */
zap_clear_flag(span, ZAP_SPAN_CONFIGURED);
for(j = 1; j <= span->chan_count && span->channels[j]; j++) {
zap_channel_t *cur_chan = span->channels[j];
if (cur_chan) {
if (zap_test_flag(cur_chan, ZAP_CHANNEL_CONFIGURED)) {
zap_channel_destroy(cur_chan);
}
zap_safe_free(cur_chan);
cur_chan = NULL;
}
}
/* destroy the I/O for the span */
if (span->zio && span->zio->span_destroy) {
zap_log(ZAP_LOG_INFO, "Destroying span %u type (%s)\n", span->span_id, span->type);
if (span->zio->span_destroy(span) != ZAP_SUCCESS) {
status = ZAP_FAIL;
}
zap_safe_free(span->type);
zap_safe_free(span->dtmf_hangup);
}
/* destroy final basic resources of the span data structure */
zap_mutex_unlock(span->mutex);
zap_mutex_destroy(&span->mutex);
zap_safe_free(span->signal_data);
return status;
}
OZ_DECLARE(zap_status_t) zap_channel_get_alarms(zap_channel_t *zchan)
{
@ -481,7 +503,10 @@ OZ_DECLARE(zap_status_t) zap_span_close_all(void)
for (span = globals.spans; span; span = span->next) {
if (zap_test_flag(span, ZAP_SPAN_CONFIGURED)) {
for(j = 1; j <= span->chan_count && span->channels[j]; j++) {
zap_channel_destroy(span->channels[j]);
zap_channel_t *toclose = span->channels[j];
if (zap_test_flag(toclose, ZAP_CHANNEL_INUSE)) {
zap_channel_close(&toclose);
}
i++;
}
}
@ -1329,11 +1354,17 @@ OZ_DECLARE(zap_status_t) zap_channel_close(zap_channel_t **zchan)
return ZAP_FAIL;
}
if (!zap_test_flag(check, ZAP_CHANNEL_INUSE)) {
zap_log(ZAP_LOG_WARNING, "Called zap_channel_close but never zap_channel_open in chan %d:%d??\n", check->span_id, check->chan_id);
return ZAP_FAIL;
}
if (zap_test_flag(check, ZAP_CHANNEL_CONFIGURED)) {
zap_mutex_lock(check->mutex);
if (zap_test_flag(check, ZAP_CHANNEL_OPEN)) {
status = check->zio->close(check);
if (status == ZAP_SUCCESS) {
zap_clear_flag(check, ZAP_CHANNEL_INUSE);
zap_channel_reset(check);
*zchan = NULL;
}
@ -2889,7 +2920,6 @@ OZ_DECLARE(uint32_t) zap_running(void)
OZ_DECLARE(zap_status_t) zap_global_destroy(void)
{
unsigned int j;
zap_span_t *sp;
time_end();
@ -2905,25 +2935,6 @@ OZ_DECLARE(zap_status_t) zap_global_destroy(void)
if (cur_span) {
if (zap_test_flag(cur_span, ZAP_SPAN_CONFIGURED)) {
zap_mutex_lock(cur_span->mutex);
zap_clear_flag(cur_span, ZAP_SPAN_CONFIGURED);
for(j = 1; j <= cur_span->chan_count && cur_span->channels[j]; j++) {
zap_channel_t *cur_chan = cur_span->channels[j];
if (cur_chan) {
if (zap_test_flag(cur_chan, ZAP_CHANNEL_CONFIGURED)) {
zap_channel_destroy(cur_chan);
}
zap_safe_free(cur_chan);
cur_chan = NULL;
}
}
zap_mutex_unlock(cur_span->mutex);
if (cur_span->mutex) {
zap_mutex_destroy(&cur_span->mutex);
}
zap_safe_free(cur_span->signal_data);
zap_span_destroy(cur_span);
}