use priority inheritance on mutexes where applicable

git-svn-id: file:///home/lennart/svn/public/pulseaudio/branches/lennart@1837 fefdeb5f-60dc-0310-8127-8f9354f1896f

diff --git a/configure.ac b/configure.ac
index f179827fc945131740cfc2920ec7d3a715027e81..c12cfc0eb6d6b8e108087f6ee723337736025714 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -297,6 +297,22 @@ AC_CHECK_FUNCS([setresuid setresgid setreuid setregid seteuid setegid ppoll])
 
 ACX_PTHREAD
 
+AC_MSG_CHECKING([for PTHREAD_PRIO_INHERIT])
+AC_LANG_CONFTEST([AC_LANG_SOURCE([[
+#include <pthread.h> 
+int main() { int i = PTHREAD_PRIO_INHERIT; }]])])
+$PTHREAD_CC conftest.c $PTHREAD_CFLAGS $CFLAGS $PTHREAD_LIBS -o conftest > /dev/null 2> /dev/null
+ret=$?
+rm -f conftest.o conftest
+
+if test $ret -eq 0 ; then
+    AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], 1, [Have PTHREAD_PRIO_INHERIT.])
+    AC_MSG_RESULT([yes])
+else
+    AC_MSG_RESULT([no])
+fi
+
+
 #### Large File-Support (LFS) ####
 
 AC_SYS_LARGEFILE

diff --git a/src/daemon/main.c b/src/daemon/main.c
index e01bb231318803cd8576fc4a5e99662d8e3c95ac..f34e59e9e4a99c7d29789529b0713ff9173f1dcc 100644 (file)
--- a/src/daemon/main.c
+++ b/src/daemon/main.c
@@ -330,7 +330,7 @@ static const char *libtool_get_error(void) {
 }
 
 static void libtool_init(void)  {
-    pa_assert_se(libtool_mutex = pa_mutex_new(1));
+    pa_assert_se(libtool_mutex = pa_mutex_new(TRUE, FALSE));
     pa_assert_se(lt_dlmutex_register(libtool_lock, libtool_unlock, libtool_set_error, libtool_get_error) == 0);
     pa_assert_se(lt_dlinit() == 0);
 }

diff --git a/src/modules/module-combine.c b/src/modules/module-combine.c
index 235e04e68c96bed3acb1419b3dec235c43d08aec..7ac7b9ab1667c41b0f662e849e8b1e5412ae01d4 100644 (file)
--- a/src/modules/module-combine.c
+++ b/src/modules/module-combine.c
@@ -947,7 +947,7 @@ int pa__init(pa_module*m) {
     u->thread_info.master = u->master = NULL;
     u->time_event = NULL; 
     u->adjust_time = DEFAULT_ADJUST_TIME; 
-    u->mutex = pa_mutex_new(0);
+    u->mutex = pa_mutex_new(FALSE, TRUE);
     pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
     u->rtpoll = NULL;
     u->thread = NULL;

diff --git a/src/pulse/thread-mainloop.c b/src/pulse/thread-mainloop.c
index 29769e2b3d93bc6363f3f0e654b20eecbd4eaa52..3068570538c91ac82d77622e75d136a28ed0d00e 100644 (file)
--- a/src/pulse/thread-mainloop.c
+++ b/src/pulse/thread-mainloop.c
@@ -103,7 +103,7 @@ pa_threaded_mainloop *pa_threaded_mainloop_new(void) {
         return NULL;
     }
 
-    m->mutex = pa_mutex_new(1);
+    m->mutex = pa_mutex_new(TRUE, FALSE);
     m->cond = pa_cond_new();
     m->accept_cond = pa_cond_new();
     m->thread = NULL;

diff --git a/src/pulsecore/asyncmsgq.c b/src/pulsecore/asyncmsgq.c
index b36544605fe3e76fb614b3ef36015523d2d27386..c0917ca67cc8411292f2c3b7ce8fa9d1650232a2 100644 (file)
--- a/src/pulsecore/asyncmsgq.c
+++ b/src/pulsecore/asyncmsgq.c
@@ -67,7 +67,7 @@ pa_asyncmsgq *pa_asyncmsgq_new(unsigned size) {
 
     PA_REFCNT_INIT(a);
     pa_assert_se(a->asyncq = pa_asyncq_new(size));
-    pa_assert_se(a->mutex = pa_mutex_new(0));
+    pa_assert_se(a->mutex = pa_mutex_new(FALSE, TRUE));
     a->current = NULL;
 
     return a;

diff --git a/src/pulsecore/memblock.c b/src/pulsecore/memblock.c
index 05fc34d9208ad00a6347e14349350743f5482d6d..3827dc031303940a174a0eaa35b145253747f352 100644 (file)
--- a/src/pulsecore/memblock.c
+++ b/src/pulsecore/memblock.c
@@ -660,7 +660,7 @@ pa_mempool* pa_mempool_new(int shared) {
 
     p = pa_xnew(pa_mempool, 1);
 
-    p->mutex = pa_mutex_new(1);
+    p->mutex = pa_mutex_new(TRUE, TRUE);
     p->semaphore = pa_semaphore_new(0);
 
     p->block_size = PA_PAGE_ALIGN(PA_MEMPOOL_SLOT_SIZE);
@@ -781,7 +781,7 @@ pa_memimport* pa_memimport_new(pa_mempool *p, pa_memimport_release_cb_t cb, void
     pa_assert(cb);
 
     i = pa_xnew(pa_memimport, 1);
-    i->mutex = pa_mutex_new(1);
+    i->mutex = pa_mutex_new(TRUE, TRUE);
     i->pool = p;
     i->segments = pa_hashmap_new(NULL, NULL);
     i->blocks = pa_hashmap_new(NULL, NULL);
@@ -909,18 +909,22 @@ finish:
 
 int pa_memimport_process_revoke(pa_memimport *i, uint32_t id) {
     pa_memblock *b;
+    int ret = 0;
     pa_assert(i);
 
     pa_mutex_lock(i->mutex);
 
-    if (!(b = pa_hashmap_get(i->blocks, PA_UINT32_TO_PTR(id))))
-        return -1;
+    if (!(b = pa_hashmap_get(i->blocks, PA_UINT32_TO_PTR(id)))) {
+        ret = -1;
+        goto finish;
+    }
 
     memblock_replace_import(b);
 
+finish:
     pa_mutex_unlock(i->mutex);
 
-    return 0;
+    return ret;
 }
 
 /* For sending blocks to other nodes */
@@ -934,7 +938,7 @@ pa_memexport* pa_memexport_new(pa_mempool *p, pa_memexport_revoke_cb_t cb, void
         return NULL;
 
     e = pa_xnew(pa_memexport, 1);
-    e->mutex = pa_mutex_new(1);
+    e->mutex = pa_mutex_new(TRUE, TRUE);
     e->pool = p;
     PA_LLIST_HEAD_INIT(struct memexport_slot, e->free_slots);
     PA_LLIST_HEAD_INIT(struct memexport_slot, e->used_slots);

diff --git a/src/pulsecore/mutex-posix.c b/src/pulsecore/mutex-posix.c
index 64f466d9c77b30c15a8ee763786b017d32f74e9b..19e095bbae8ec360682290543474d4cc768ae052 100644 (file)
--- a/src/pulsecore/mutex-posix.c
+++ b/src/pulsecore/mutex-posix.c
@@ -40,15 +40,20 @@ struct pa_cond {
     pthread_cond_t cond;
 };
 
-pa_mutex* pa_mutex_new(int recursive) {
+pa_mutex* pa_mutex_new(pa_bool_t recursive, pa_bool_t inherit_priority) {
     pa_mutex *m;
     pthread_mutexattr_t attr;
 
     pthread_mutexattr_init(&attr);
-
+    
     if (recursive)
         pa_assert_se(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0);
 
+#ifdef HAVE_PTHREAD_PRIO_INHERIT
+    if (inherit_priority)
+        pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
+#endif
+
     m = pa_xnew(pa_mutex, 1);
     pa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0);
     return m;

diff --git a/src/pulsecore/mutex.h b/src/pulsecore/mutex.h
index b2e34c07a8d8459a82fda64891d28fc124f144c3..72e887819175adc7d1925b314fd88659907b31e5 100644 (file)
--- a/src/pulsecore/mutex.h
+++ b/src/pulsecore/mutex.h
@@ -24,9 +24,17 @@
   USA.
 ***/
 
+#include <pulsecore/macro.h>
+
 typedef struct pa_mutex pa_mutex;
 
-pa_mutex* pa_mutex_new(int recursive);
+/* Please think twice before enabling priority inheritance. This is no
+ * magic wand! Use it only when the potentially priorized threads are
+ * good candidates for it. Don't use this blindly! Also, note that
+ * only very few operating systems actually implement this, hence this
+ * is merely a hint. */
+pa_mutex* pa_mutex_new(pa_bool_t recursive, pa_bool_t inherit_priority);
+
 void pa_mutex_free(pa_mutex *m);
 void pa_mutex_lock(pa_mutex *m);
 void pa_mutex_unlock(pa_mutex *m);

diff --git a/src/pulsecore/once-posix.c b/src/pulsecore/once-posix.c
index fba0ddf12acc5dfe650169a62b61e748049c6c3e..4f6e5b62c3c571b1b60626b63ca69c3d65c3a3b0 100644 (file)
--- a/src/pulsecore/once-posix.c
+++ b/src/pulsecore/once-posix.c
@@ -58,7 +58,7 @@ int pa_once_begin(pa_once *control) {
             return 0;
         }
 
-        pa_assert_se(m = pa_mutex_new(0));
+        pa_assert_se(m = pa_mutex_new(FALSE, FALSE));
         pa_mutex_lock(m);
 
         if (pa_atomic_ptr_cmpxchg(&control->mutex, NULL, m))

diff --git a/src/tests/thread-test.c b/src/tests/thread-test.c
index 0077cde5a8f157b99f1084ea80968cd7595c6006..72dde6cbb942201727ba8d4fbbbd3a81fe807fca 100644 (file)
--- a/src/tests/thread-test.c
+++ b/src/tests/thread-test.c
@@ -98,7 +98,7 @@ int main(int argc, char *argv[]) {
 
     assert(pa_thread_is_running(pa_thread_self()));
 
-    mutex = pa_mutex_new(0);
+    mutex = pa_mutex_new(FALSE, FALSE);
     cond1 = pa_cond_new();
     cond2 = pa_cond_new();
     tls = pa_tls_new(pa_xfree);