Merge branch 'master' of ssh://rootserver/home/lennart/git/public/pulseaudio

2 files changed, 120 insertions, 16 deletions

diff --git a/src/pulsecore/atomic.h b/src/pulsecore/atomic.h
index 119c445b..51d08210 100644
--- a/src/pulsecore/atomic.h
+++ b/src/pulsecore/atomic.h
@@ -180,6 +180,110 @@ static inline pa_bool_t pa_atomic_ptr_cmpxchg(pa_atomic_ptr_t *a, void *old_p, v
     return r == old_p;
 }
 
+#elif defined(__FreeBSD__)
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <machine/atomic.h>
+
+#if __FreeBSD_version < 600000
+#if defined(__i386__) || defined(__amd64__)
+#if defined(__amd64__)
+#define atomic_load_acq_64      atomic_load_acq_long
+#endif
+static inline u_int atomic_fetchadd_int(volatile u_int *p, u_int v) {
+    __asm __volatile(
+            "   " __XSTRING(MPLOCKED) "         "
+            "   xaddl   %0, %1 ;        "
+            "# atomic_fetchadd_int"
+            : "+r" (v),
+            "=m" (*p)
+            : "m" (*p));
+
+    return (v);
+}
+#elif defined(__sparc64__)
+#define atomic_load_acq_64      atomic_load_acq_long
+#define atomic_fetchadd_int     atomic_add_int
+#elif defined(__ia64__)
+#define atomic_load_acq_64      atomic_load_acq_long
+static inline uint32_t
+atomic_fetchadd_int(volatile uint32_t *p, uint32_t v) {
+    uint32_t value;
+
+    do {
+        value = *p;
+    } while (!atomic_cmpset_32(p, value, value + v));
+    return (value);
+}
+#endif
+#endif
+
+typedef struct pa_atomic {
+    volatile unsigned long value;
+} pa_atomic_t;
+
+#define PA_ATOMIC_INIT(v) { .value = (v) }
+
+static inline int pa_atomic_load(const pa_atomic_t *a) {
+    return (int) atomic_load_acq_int((unsigned int *) &a->value);
+}
+
+static inline void pa_atomic_store(pa_atomic_t *a, int i) {
+    atomic_store_rel_int((unsigned int *) &a->value, i);
+}
+
+static inline int pa_atomic_add(pa_atomic_t *a, int i) {
+    return atomic_fetchadd_int((unsigned int *) &a->value, i);
+}
+
+static inline int pa_atomic_sub(pa_atomic_t *a, int i) {
+    return atomic_fetchadd_int((unsigned int *) &a->value, -(i));
+}
+
+static inline int pa_atomic_inc(pa_atomic_t *a) {
+    return atomic_fetchadd_int((unsigned int *) &a->value, 1);
+}
+
+static inline int pa_atomic_dec(pa_atomic_t *a) {
+    return atomic_fetchadd_int((unsigned int *) &a->value, -1);
+}
+
+static inline int pa_atomic_cmpxchg(pa_atomic_t *a, int old_i, int new_i) {
+    return atomic_cmpset_int((unsigned int *) &a->value, old_i, new_i);
+}
+
+typedef struct pa_atomic_ptr {
+    volatile unsigned long value;
+} pa_atomic_ptr_t;
+
+#define PA_ATOMIC_PTR_INIT(v) { .value = (unsigned long) (v) }
+
+static inline void* pa_atomic_ptr_load(const pa_atomic_ptr_t *a) {
+#ifdef atomic_load_acq_64
+    return (void*) atomic_load_acq_ptr((unsigned long *) &a->value);
+#else
+    return (void*) atomic_load_acq_ptr((unsigned int *) &a->value);
+#endif
+}
+
+static inline void pa_atomic_ptr_store(pa_atomic_ptr_t *a, void *p) {
+#ifdef atomic_load_acq_64
+    atomic_store_rel_ptr(&a->value, (unsigned long) p);
+#else
+    atomic_store_rel_ptr((unsigned int *) &a->value, (unsigned int) p);
+#endif
+}
+
+static inline int pa_atomic_ptr_cmpxchg(pa_atomic_ptr_t *a, void *old_p, void* new_p) {
+#ifdef atomic_load_acq_64
+    return atomic_cmpset_ptr(&a->value, (unsigned long) old_p, (unsigned long) new_p);
+#else
+    return atomic_cmpset_ptr((unsigned int *) &a->value, (unsigned int) old_p, (unsigned int) new_p);
+#endif
+}
+
 #elif defined(__GNUC__) && (defined(__amd64__) || defined(__x86_64__))
 
 #warn "The native atomic operations implementation for AMD64 has not been tested thoroughly. libatomic_ops is known to not work properly on AMD64 and your gcc version is too old for the gcc-builtin atomic ops support. You have three options now: test the native atomic operations implementation for AMD64, fix libatomic_ops, or upgrade your GCC."
diff --git a/src/pulsecore/protocol-dbus.c b/src/pulsecore/protocol-dbus.c
index 5c1127be..e427bb19 100644
--- a/src/pulsecore/protocol-dbus.c
+++ b/src/pulsecore/protocol-dbus.c
@@ -958,7 +958,7 @@ pa_client *pa_dbus_protocol_get_client(pa_dbus_protocol *p, DBusConnection *conn
 void pa_dbus_protocol_add_signal_listener(
         pa_dbus_protocol *p,
         DBusConnection *conn,
-        const char *signal,
+        const char *signal_name,
         char **objects,
         unsigned n_objects) {
     struct connection_entry *conn_entry;
@@ -978,18 +978,18 @@ void pa_dbus_protocol_add_signal_listener(
     while ((object_path = pa_idxset_steal_first(conn_entry->all_signals_objects, NULL)))
         pa_xfree(object_path);
 
-    if (signal) {
+    if (signal_name) {
         conn_entry->listening_for_all_signals = FALSE;
 
         /* Replace the old object list with a new one. */
-        if ((object_set = pa_hashmap_remove(conn_entry->listening_signals, signal)))
+        if ((object_set = pa_hashmap_remove(conn_entry->listening_signals, signal_name)))
             pa_idxset_free(object_set, free_listened_object_name_cb, NULL);
         object_set = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 
         for (i = 0; i < n_objects; ++i)
             pa_idxset_put(object_set, pa_xstrdup(objects[i]), NULL);
 
-        pa_hashmap_put(conn_entry->listening_signals, signal, object_set);
+        pa_hashmap_put(conn_entry->listening_signals, signal_name, object_set);
 
     } else {
         conn_entry->listening_for_all_signals = TRUE;
@@ -1004,7 +1004,7 @@ void pa_dbus_protocol_add_signal_listener(
     }
 }
 
-void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal) {
+void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal_name) {
     struct connection_entry *conn_entry;
     pa_idxset *object_set;
 
@@ -1013,8 +1013,8 @@ void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection
 
     pa_assert_se((conn_entry = pa_hashmap_get(p->connections, conn)));
 
-    if (signal) {
-        if ((object_set = pa_hashmap_get(conn_entry->listening_signals, signal)))
+    if (signal_name) {
+        if ((object_set = pa_hashmap_get(conn_entry->listening_signals, signal_name)))
             pa_idxset_free(object_set, free_listened_object_name_cb, NULL);
 
     } else {
@@ -1030,7 +1030,7 @@ void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection
     }
 }
 
-void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal) {
+void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal_name) {
     struct connection_entry *conn_entry;
     void *state = NULL;
     pa_idxset *object_set;
@@ -1038,24 +1038,24 @@ void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal) {
     char *signal_string;
 
     pa_assert(p);
-    pa_assert(signal);
-    pa_assert(dbus_message_get_type(signal) == DBUS_MESSAGE_TYPE_SIGNAL);
-    pa_assert_se(dbus_message_get_interface(signal));
-    pa_assert_se(dbus_message_get_member(signal));
+    pa_assert(signal_name);
+    pa_assert(dbus_message_get_type(signal_name) == DBUS_MESSAGE_TYPE_SIGNAL);
+    pa_assert_se(dbus_message_get_interface(signal_name));
+    pa_assert_se(dbus_message_get_member(signal_name));
 
-    signal_string = pa_sprintf_malloc("%s.%s", dbus_message_get_interface(signal), dbus_message_get_member(signal));
+    signal_string = pa_sprintf_malloc("%s.%s", dbus_message_get_interface(signal_name), dbus_message_get_member(signal_name));
 
     PA_HASHMAP_FOREACH(conn_entry, p->connections, state) {
         if ((conn_entry->listening_for_all_signals /* Case 1: listening for all signals */
-             && (pa_idxset_get_by_data(conn_entry->all_signals_objects, dbus_message_get_path(signal), NULL)
+             && (pa_idxset_get_by_data(conn_entry->all_signals_objects, dbus_message_get_path(signal_name), NULL)
                  || pa_idxset_isempty(conn_entry->all_signals_objects)))
 
             || (!conn_entry->listening_for_all_signals /* Case 2: not listening for all signals */
                 && (object_set = pa_hashmap_get(conn_entry->listening_signals, signal_string))
-                && (pa_idxset_get_by_data(object_set, dbus_message_get_path(signal), NULL)
+                && (pa_idxset_get_by_data(object_set, dbus_message_get_path(signal_name), NULL)
                     || pa_idxset_isempty(object_set)))) {
 
-            pa_assert_se(signal_copy = dbus_message_copy(signal));
+            pa_assert_se(signal_copy = dbus_message_copy(signal_name));
             pa_assert_se(dbus_connection_send(conn_entry->connection, signal_copy, NULL));
             dbus_message_unref(signal_copy);
         }