Fix deadlock when executing CLI "pri show channels" and "ss7 show channels" commands.

* Fix sig_pri_lock_owner() to avoid deadlock properly.

* Code pri_grab() better.

* Fix sig_ss7_lock_owner() to avoid deadlock properly.

* Code ss7_grab() better.

(closes issue ASTERISK-19854)
Reported by: Jaxon
Patches:
      jira_asterisk_19854_v1.8.6.patch (license #5621) patch uploaded by rmudgett (Modified to do the same thing to sig_ss7)
Tested by: Jaxon

git-svn-id: https://origsvn.digium.com/svn/asterisk/branches/1.8@367976 65c4cc65-6c06-0410-ace0-fbb531ad65f3

diff --git a/channels/sig_pri.c b/channels/sig_pri.c
index 49073c9ce22ec2f9050e5436f4bff3614396461b..c40ac495ebaf4d0e71a58761962b700daf68a91e 100644 (file)
--- a/channels/sig_pri.c
+++ b/channels/sig_pri.c
@@ -115,13 +115,6 @@ static int pri_gendigittimeout = 8000;
 
 #define DCHAN_AVAILABLE        (DCHAN_NOTINALARM | DCHAN_UP)
 
-#define PRI_DEADLOCK_AVOIDANCE(p) \
-       do { \
-               sig_pri_unlock_private(p); \
-               usleep(1); \
-               sig_pri_lock_private(p); \
-       } while (0)
-
 static int pri_active_dchan_index(struct sig_pri_span *pri);
 
 static const char *sig_pri_call_level2str(enum sig_pri_call_level level)
@@ -345,16 +338,17 @@ static void sig_pri_lock_private(struct sig_pri_chan *p)
 
 static inline int pri_grab(struct sig_pri_chan *p, struct sig_pri_span *pri)
 {
-       int res;
        /* Grab the lock first */
-       do {
-               res = ast_mutex_trylock(&pri->lock);
-               if (res) {
-                       PRI_DEADLOCK_AVOIDANCE(p);
-               }
-       } while (res);
+       while (ast_mutex_trylock(&pri->lock)) {
+               /* Avoid deadlock */
+               sig_pri_unlock_private(p);
+               sched_yield();
+               sig_pri_lock_private(p);
+       }
        /* Then break the poll */
-       pthread_kill(pri->master, SIGURG);
+       if (pri->master != AST_PTHREADT_NULL) {
+               pthread_kill(pri->master, SIGURG);
+       }
        return 0;
 }
 
@@ -1193,10 +1187,13 @@ static void sig_pri_lock_owner(struct sig_pri_span *pri, int chanpos)
                        /* We got the lock */
                        break;
                }
-               /* We must unlock the PRI to avoid the possibility of a deadlock */
+
+               /* Avoid deadlock */
+               sig_pri_unlock_private(pri->pvts[chanpos]);
                ast_mutex_unlock(&pri->lock);
-               PRI_DEADLOCK_AVOIDANCE(pri->pvts[chanpos]);
+               sched_yield();
                ast_mutex_lock(&pri->lock);
+               sig_pri_lock_private(pri->pvts[chanpos]);
        }
 }
 

diff --git a/channels/sig_ss7.c b/channels/sig_ss7.c
index 210ef41f2812aa236cfb283c54acb610b3ad5b4a..b0f884e9d1592493e8a26f15806b23f5b55b13cc 100644 (file)
--- a/channels/sig_ss7.c
+++ b/channels/sig_ss7.c
@@ -67,13 +67,6 @@ static const char *sig_ss7_call_level2str(enum sig_ss7_call_level level)
        return "Unknown";
 }
 
-#define SIG_SS7_DEADLOCK_AVOIDANCE(p) \
-       do { \
-               sig_ss7_unlock_private(p); \
-               usleep(1); \
-               sig_ss7_lock_private(p); \
-       } while (0)
-
 static void sig_ss7_unlock_private(struct sig_ss7_chan *p)
 {
        if (p->calls->unlock_private) {
@@ -304,10 +297,13 @@ static void sig_ss7_lock_owner(struct sig_ss7_linkset *ss7, int chanpos)
                        /* We got the lock */
                        break;
                }
-               /* We must unlock the SS7 to avoid the possibility of a deadlock */
+
+               /* Avoid deadlock */
+               sig_ss7_unlock_private(ss7->pvts[chanpos]);
                ast_mutex_unlock(&ss7->lock);
-               SIG_SS7_DEADLOCK_AVOIDANCE(ss7->pvts[chanpos]);
+               sched_yield();
                ast_mutex_lock(&ss7->lock);
+               sig_ss7_lock_private(ss7->pvts[chanpos]);
        }
 }
 
@@ -1256,17 +1252,17 @@ static inline void ss7_rel(struct sig_ss7_linkset *ss7)
 
 static void ss7_grab(struct sig_ss7_chan *pvt, struct sig_ss7_linkset *ss7)
 {
-       int res;
        /* Grab the lock first */
-       do {
-               res = ast_mutex_trylock(&ss7->lock);
-               if (res) {
-                       SIG_SS7_DEADLOCK_AVOIDANCE(pvt);
-               }
-       } while (res);
+       while (ast_mutex_trylock(&ss7->lock)) {
+               /* Avoid deadlock */
+               sig_ss7_unlock_private(pvt);
+               sched_yield();
+               sig_ss7_lock_private(pvt);
+       }
        /* Then break the poll */
-       if (ss7->master != AST_PTHREADT_NULL)
+       if (ss7->master != AST_PTHREADT_NULL) {
                pthread_kill(ss7->master, SIGURG);
+       }
 }
 
 /*!