performance tuning

git-svn-id: http://svn.openzap.org/svn/openzap/trunk@684 a93c3328-9c30-0410-af19-c9cd2b2d52af

diff --git a/libs/freetdm/src/include/openzap.h b/libs/freetdm/src/include/openzap.h
index 81e7124dfb0a762667548a0de868c71a907b32fb..9397766bf532cb0b14cae222b12f43504c953a21 100644 (file)
--- a/libs/freetdm/src/include/openzap.h
+++ b/libs/freetdm/src/include/openzap.h
@@ -87,6 +87,7 @@
 #pragma comment(lib, "Winmm")
 #endif
 
+#define ZAP_THREAD_STACKSIZE 240 * 1024
 #define ZAP_ENUM_NAMES(_NAME, _STRINGS) static const char * _NAME [] = { _STRINGS , NULL };
 #define ZAP_STR2ENUM_P(_FUNC1, _FUNC2, _TYPE) _TYPE _FUNC1 (const char *name); const char * _FUNC2 (_TYPE type);
 #define ZAP_STR2ENUM(_FUNC1, _FUNC2, _TYPE, _STRINGS, _MAX)    \

diff --git a/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.c b/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.c
index 3b227c3c9b7a56b027f7101118bb03c1d7d695b5..1220a93a77d26cd9df48237eebea158733508bdc 100644 (file)
--- a/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.c
+++ b/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.c
@@ -97,7 +97,8 @@ static struct lpwrap_pri_event_list LPWRAP_PRI_EVENT_LIST[] = {
        {15, LPWRAP_PRI_EVENT_HANGUP_REQ, "HANGUP_REQ"},
        {16, LPWRAP_PRI_EVENT_NOTIFY, "NOTIFY"},
        {17, LPWRAP_PRI_EVENT_PROGRESS, "PROGRESS"},
-       {18, LPWRAP_PRI_EVENT_KEYPAD_DIGIT, "KEYPAD_DIGIT"}
+       {18, LPWRAP_PRI_EVENT_KEYPAD_DIGIT, "KEYPAD_DIGIT"},
+       {19, LPWRAP_PRI_EVENT_IO_FAIL, "IO_FAIL"}
 };
 
 #define LINE "--------------------------------------------------------------------------------"
@@ -114,8 +115,9 @@ static int __pri_lpwrap_read(struct pri *pri, void *buf, int buflen)
        int res;
 
        if (zap_channel_read(spri->zdchan, buf, &len) != ZAP_SUCCESS) {
-               printf("D-READ FAIL! [%s]\n", spri->zdchan->last_error);
-               return 0;
+               zap_log(ZAP_LOG_CRIT, "span %d D-READ FAIL! [%s]\n", spri->span, spri->zdchan->last_error);
+               zap_clear_flag(spri, LPWRAP_PRI_READY);
+               return -1;
        }
        res = (int)len;
        memset(&((unsigned char*)buf)[res],0,2);
@@ -133,8 +135,9 @@ static int __pri_lpwrap_write(struct pri *pri, void *buf, int buflen)
        zap_size_t len = buflen -2;
 
        if (zap_channel_write(spri->zdchan, buf, buflen, &len) != ZAP_SUCCESS) {
-               printf("D-WRITE FAIL! [%s]\n", spri->zdchan->last_error);
-        return 0;
+               zap_log(ZAP_LOG_CRIT, "span %d D-WRITE FAIL! [%s]\n", spri->span, spri->zdchan->last_error);
+               zap_clear_flag(spri, LPWRAP_PRI_READY);
+        return -1;
        }
        
        //print_bits(buf, (int)buflen-2, bb, sizeof(bb), 1, 0);
@@ -155,6 +158,7 @@ int lpwrap_init_pri(struct lpwrap_pri *spri, int span, zap_channel_t *dchan, int
                spri->span = span;
                pri_set_debug(spri->pri, debug);
                ret = 0;
+               zap_set_flag(spri, LPWRAP_PRI_READY);
        } else {
                fprintf(stderr, "Unable to create PRI\n");
        }
@@ -168,6 +172,7 @@ int lpwrap_one_loop(struct lpwrap_pri *spri)
        fd_set rfds, efds;
        struct timeval now = {0,0}, *next;
        pri_event *event;
+       event_handler handler;
     int sel;
        
        if (spri->on_loop) {
@@ -210,7 +215,6 @@ int lpwrap_one_loop(struct lpwrap_pri *spri)
        }
 
        if (event) {
-               event_handler handler;
                /* 0 is catchall event handler */
                if ((handler = spri->eventmap[event->e] ? spri->eventmap[event->e] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) {
                        handler(spri, event->e, event);
@@ -219,16 +223,25 @@ int lpwrap_one_loop(struct lpwrap_pri *spri)
                }
        }
 
-       return sel;
+       if (zap_test_flag(spri, LPWRAP_PRI_READY)) {
+               return sel;
+       }
+
+       if ((handler = spri->eventmap[LPWRAP_PRI_EVENT_IO_FAIL] ? spri->eventmap[LPWRAP_PRI_EVENT_IO_FAIL] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) {
+               handler(spri, LPWRAP_PRI_EVENT_IO_FAIL, NULL);
+       }
+
+       return -1;
 }
 
 int lpwrap_run_pri(struct lpwrap_pri *spri)
 {
        int ret = 0;
-
+       
        for (;;){
-               ret=lpwrap_one_loop(spri);
-               if (ret < 0){
+               ret = lpwrap_one_loop(spri);
+
+               if (ret < 0) {
 
 #ifndef WIN32 //This needs to be adressed fror WIN32 still
                        if (errno == EINTR){
@@ -236,9 +249,8 @@ int lpwrap_run_pri(struct lpwrap_pri *spri)
                                continue;
                        }
 #endif 
-                       printf("Error = %i\n",ret);
-                       perror("Lpwrap Run Pri: ");
-                       break;          
+                       zap_log(ZAP_LOG_CRIT, "Error = %i [%s]\n", ret, strerror(errno));
+                       break;
                }
        }
 

diff --git a/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.h b/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.h
index 9333e3a0495faa2b400af56b0d3bd41da9e2eb72..8ed6ab016f47fb65051db7744c1f004d49c01b35 100644 (file)
--- a/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.h
+++ b/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.h
@@ -58,7 +58,8 @@ typedef enum {
        LPWRAP_PRI_EVENT_HANGUP_REQ = PRI_EVENT_HANGUP_REQ,
        LPWRAP_PRI_EVENT_NOTIFY = PRI_EVENT_NOTIFY,
        LPWRAP_PRI_EVENT_PROGRESS = PRI_EVENT_PROGRESS,
-       LPWRAP_PRI_EVENT_KEYPAD_DIGIT = PRI_EVENT_KEYPAD_DIGIT
+       LPWRAP_PRI_EVENT_KEYPAD_DIGIT = PRI_EVENT_KEYPAD_DIGIT,
+       LPWRAP_PRI_EVENT_IO_FAIL = 19
 } lpwrap_pri_event_t;
 
 typedef enum {

diff --git a/libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.c b/libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.c
index 2e7a00b1f78823f2b900308d81741d79ccd14ac7..a3f4a6a205973f6b98f1b81f260e4a616c6e5204 100644 (file)
--- a/libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.c
+++ b/libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.c
@@ -704,28 +704,70 @@ static int on_anything(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_ev
 
 
 
+static int on_io_fail(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event * pevent)
+{
+
+       zap_log(ZAP_LOG_DEBUG, "Caught Event span %d %u (%s)\n", spri->span, event_type, lpwrap_pri_event_str(event_type));
+       return 0;
+}
+
+
+
 static void *zap_libpri_run(zap_thread_t *me, void *obj)
 {
        zap_span_t *span = (zap_span_t *) obj;
        zap_libpri_data_t *isdn_data = span->signal_data;
-
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_ANY, on_anything);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_RING, on_ring);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_RINGING, on_ringing);
-       //LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_SETUP_ACK, on_proceed);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_PROCEEDING, on_proceed);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_ANSWER, on_answer);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_DCHAN_UP, on_dchan_up);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_DCHAN_DOWN, on_dchan_down);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_HANGUP_REQ, on_hangup);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_HANGUP, on_hangup);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_INFO_RECEIVED, on_info);
-       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_RESTART, on_restart);
-
-       isdn_data->spri.on_loop = check_flags;
-       isdn_data->spri.private_info = span;
+       int x, i;
        
-       lpwrap_run_pri(&isdn_data->spri);
+       while(zap_running()) {
+               x = 0;
+
+               for(i = 1; i <= span->chan_count; i++) {
+                       if (span->channels[i]->type == ZAP_CHAN_TYPE_DQ921) {
+                               if (zap_channel_open(span->span_id, i, &isdn_data->dchan) == ZAP_SUCCESS) {
+                                       zap_log(ZAP_LOG_DEBUG, "opening d-channel #%d %d:%d\n", x, isdn_data->dchan->span_id, isdn_data->dchan->chan_id);
+                                       isdn_data->dchan->state = ZAP_CHANNEL_STATE_UP;
+                                       x++;
+                                       break;
+                               }
+                       }
+               }
+
+               
+               if (x && lpwrap_init_pri(&isdn_data->spri,
+                                                       span->span_id,  // span
+                                                       isdn_data->dchan, // dchan
+                                                       isdn_data->pswitch,
+                                                       isdn_data->node,
+                                                       isdn_data->debug) < 0) {
+                       snprintf(span->last_error, sizeof(span->last_error), "PRI init FAIL!");
+               } else {
+
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_ANY, on_anything);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_RING, on_ring);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_RINGING, on_ringing);
+                       //LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_SETUP_ACK, on_proceed);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_PROCEEDING, on_proceed);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_ANSWER, on_answer);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_DCHAN_UP, on_dchan_up);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_DCHAN_DOWN, on_dchan_down);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_HANGUP_REQ, on_hangup);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_HANGUP, on_hangup);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_INFO_RECEIVED, on_info);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_RESTART, on_restart);
+                       LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_IO_FAIL, on_io_fail);
+
+
+                       isdn_data->spri.on_loop = check_flags;
+                       isdn_data->spri.private_info = span;
+                       
+                       lpwrap_run_pri(&isdn_data->spri);
+                       zap_channel_close(&isdn_data->dchan);
+               }
+               
+               zap_log(ZAP_LOG_CRIT, "PRI down on span %d\n", isdn_data->spri.span);
+               zap_sleep(5000);
+       }
 
        
        return NULL;
@@ -736,9 +778,10 @@ static zap_status_t zap_libpri_start(zap_span_t *span)
        zap_status_t ret;
 
        zap_libpri_data_t *isdn_data = span->signal_data;
-       zap_set_flag(isdn_data, OZMOD_LIBPRI_RUNNING);
 
+       zap_set_flag(isdn_data, OZMOD_LIBPRI_RUNNING);
        ret = zap_thread_create_detached(zap_libpri_run, span);
+
        if (ret != ZAP_SUCCESS) {
                return ret;
        }
@@ -806,7 +849,7 @@ static int str2dp(char *dp)
 static ZIO_SIG_CONFIGURE_FUNCTION(zap_libpri_configure_span)
 {
        uint32_t i, x = 0;
-       zap_channel_t *dchans[2] = {0};
+       //zap_channel_t *dchans[2] = {0};
        zap_libpri_data_t *isdn_data;
        char *var, *val;
        int32_t opts = 0;
@@ -823,19 +866,23 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_libpri_configure_span)
                                snprintf(span->last_error, sizeof(span->last_error), "Span has more than 2 D-Channels!");
                                return ZAP_FAIL;
                        } else {
+#if 0
                                if (zap_channel_open(span->span_id, i, &dchans[x]) == ZAP_SUCCESS) {
                                        zap_log(ZAP_LOG_DEBUG, "opening d-channel #%d %d:%d\n", x, dchans[x]->span_id, dchans[x]->chan_id);
                                        dchans[x]->state = ZAP_CHANNEL_STATE_UP;
                                        x++;
                                }
+#endif
                        }
                }
        }
        
+#if 0
        if (!x) {
                snprintf(span->last_error, sizeof(span->last_error), "Span has no D-Channels!");
                return ZAP_FAIL;
        }
+#endif
 
        isdn_data = malloc(sizeof(*isdn_data));
        assert(isdn_data != NULL);
@@ -888,21 +935,12 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_libpri_configure_span)
 
        span->start = zap_libpri_start;
        isdn_data->sig_cb = sig_cb;
-       isdn_data->dchans[0] = dchans[0];
-       isdn_data->dchans[1] = dchans[1];
-       isdn_data->dchan = isdn_data->dchans[0];
+       //isdn_data->dchans[0] = dchans[0];
+       //isdn_data->dchans[1] = dchans[1];
+       //isdn_data->dchan = isdn_data->dchans[0];
        
        isdn_data->debug = parse_debug(debug);
                
-       if (lpwrap_init_pri(&isdn_data->spri,
-                                               span->span_id,  // span
-                                               isdn_data->dchan, // dchan
-                                               isdn_data->pswitch,
-                                               isdn_data->node,
-                                               isdn_data->debug) < 0) {
-               snprintf(span->last_error, sizeof(span->last_error), "PRI init FAIL!");
-               return ZAP_FAIL;
-       }
 
        span->signal_data = isdn_data;
        span->signal_type = ZAP_SIGTYPE_ISDN;

diff --git a/libs/freetdm/src/zap_io.c b/libs/freetdm/src/zap_io.c
index 88d800a47fdf9f4faa7e3163fa526af5d20011b9..a9f6e57fa8aa7f4de677f19dd61ec9e61740d4b2 100644 (file)
--- a/libs/freetdm/src/zap_io.c
+++ b/libs/freetdm/src/zap_io.c
@@ -2563,6 +2563,8 @@ zap_status_t zap_global_init(void)
 
        time_init();
        
+       zap_thread_override_default_stacksize(ZAP_THREAD_STACKSIZE);
+
        memset(&interfaces, 0, sizeof(interfaces));
        globals.interface_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys);
        globals.module_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys);