fdsem: remove superfluous parameter in call to pa_fdsem_new_shm

[pulseaudio] / src / pulsecore / fdsem.c

diff --git a/src/pulsecore/fdsem.c b/src/pulsecore/fdsem.c
index 1531e3db6399384089aff9c488db5e4f6ef8d7e4..b153dddd7ac4f003a009426c1de217c0e3d884fb 100644 (file)
--- a/src/pulsecore/fdsem.c
+++ b/src/pulsecore/fdsem.c
@@ -32,73 +32,45 @@
 
 #include <pulsecore/atomic.h>
 #include <pulsecore/log.h>
-#include <pulsecore/thread.h>
 #include <pulsecore/macro.h>
 #include <pulsecore/core-util.h>
+#include <pulsecore/core-error.h>
 #include <pulse/xmalloc.h>
 
 #ifndef HAVE_PIPE
 #include <pulsecore/pipe.h>
 #endif
 
-#ifdef __linux__
-
-#if !defined(__NR_eventfd) && defined(__i386__)
-#define __NR_eventfd 323
-#endif
-
-#if !defined(__NR_eventfd) && defined(__x86_64__)
-#define __NR_eventfd 284
-#endif
-
-#if !defined(__NR_eventfd) && defined(__arm__)
-#define __NR_eventfd (__NR_SYSCALL_BASE+351)
-#endif
-
-#if !defined(SYS_eventfd) && defined(__NR_eventfd)
-#define SYS_eventfd __NR_eventfd
-#endif
-
-#ifdef SYS_eventfd
-#define HAVE_EVENTFD
-
-static inline long eventfd(unsigned count) {
-    return syscall(SYS_eventfd, count);
-}
-
-#endif
+#ifdef HAVE_SYS_EVENTFD_H
+#include <sys/eventfd.h>
 #endif
 
 #include "fdsem.h"
 
 struct pa_fdsem {
     int fds[2];
-#ifdef HAVE_EVENTFD
+#ifdef HAVE_SYS_EVENTFD_H
     int efd;
 #endif
-
+    int write_type;
     pa_fdsem_data *data;
 };
 
 pa_fdsem *pa_fdsem_new(void) {
     pa_fdsem *f;
 
-    f = pa_xmalloc(PA_ALIGN(sizeof(pa_fdsem)) + PA_ALIGN(sizeof(pa_fdsem_data)));
+    f = pa_xmalloc0(PA_ALIGN(sizeof(pa_fdsem)) + PA_ALIGN(sizeof(pa_fdsem_data)));
 
-#ifdef HAVE_EVENTFD
-    if ((f->efd = eventfd(0)) >= 0) {
-        pa_make_fd_cloexec(f->efd);
+#ifdef HAVE_SYS_EVENTFD_H
+    if ((f->efd = eventfd(0, EFD_CLOEXEC)) >= 0)
         f->fds[0] = f->fds[1] = -1;
-    } else
+    else
 #endif
     {
-        if (pipe(f->fds) < 0) {
+        if (pa_pipe_cloexec(f->fds) < 0) {
             pa_xfree(f);
             return NULL;
         }
-
-        pa_make_fd_cloexec(f->fds[0]);
-        pa_make_fd_cloexec(f->fds[1]);
     }
 
     f->data = (pa_fdsem_data*) ((uint8_t*) f + PA_ALIGN(sizeof(pa_fdsem)));
@@ -116,8 +88,8 @@ pa_fdsem *pa_fdsem_open_shm(pa_fdsem_data *data, int event_fd) {
     pa_assert(data);
     pa_assert(event_fd >= 0);
 
-#ifdef HAVE_EVENTFD
-    f = pa_xnew(pa_fdsem, 1);
+#ifdef HAVE_SYS_EVENTFD_H
+    f = pa_xnew0(pa_fdsem, 1);
 
     f->efd = event_fd;
     pa_make_fd_cloexec(f->efd);
@@ -128,22 +100,20 @@ pa_fdsem *pa_fdsem_open_shm(pa_fdsem_data *data, int event_fd) {
     return f;
 }
 
-pa_fdsem *pa_fdsem_new_shm(pa_fdsem_data *data, int* event_fd) {
+pa_fdsem *pa_fdsem_new_shm(pa_fdsem_data *data) {
     pa_fdsem *f = NULL;
 
     pa_assert(data);
-    pa_assert(event_fd);
 
-#ifdef HAVE_EVENTFD
+#ifdef HAVE_SYS_EVENTFD_H
 
-    f = pa_xnew(pa_fdsem, 1);
+    f = pa_xnew0(pa_fdsem, 1);
 
-    if ((f->efd = eventfd(0)) < 0) {
+    if ((f->efd = eventfd(0, EFD_CLOEXEC)) < 0) {
         pa_xfree(f);
         return NULL;
     }
 
-    pa_make_fd_cloexec(f->efd);
     f->fds[0] = f->fds[1] = -1;
     f->data = data;
 
@@ -159,7 +129,7 @@ pa_fdsem *pa_fdsem_new_shm(pa_fdsem_data *data, int* event_fd) {
 void pa_fdsem_free(pa_fdsem *f) {
     pa_assert(f);
 
-#ifdef HAVE_EVENTFD
+#ifdef HAVE_SYS_EVENTFD_H
     if (f->efd >= 0)
         pa_close(f->efd);
 #endif
@@ -178,24 +148,34 @@ static void flush(pa_fdsem *f) {
     do {
         char x[10];
 
-#ifdef HAVE_EVENTFD
+#ifdef HAVE_SYS_EVENTFD_H
         if (f->efd >= 0) {
             uint64_t u;
 
-            if ((r = read(f->efd, &u, sizeof(u))) != sizeof(u)) {
-                pa_assert(r < 0 && errno == EINTR);
+            if ((r = pa_read(f->efd, &u, sizeof(u), NULL)) != sizeof(u)) {
+
+                if (r >= 0 || errno != EINTR) {
+                    pa_log_error("Invalid read from eventfd: %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+                    pa_assert_not_reached();
+                }
+
                 continue;
             }
             r = (ssize_t) u;
         } else
 #endif
 
-        if ((r = read(f->fds[0], &x, sizeof(x))) <= 0) {
-            pa_assert(r < 0 && errno == EINTR);
+        if ((r = pa_read(f->fds[0], &x, sizeof(x), NULL)) <= 0) {
+
+            if (r >= 0 || errno != EINTR) {
+                pa_log_error("Invalid read from pipe: %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+                pa_assert_not_reached();
+            }
+
             continue;
         }
 
-    } while (pa_atomic_sub(&f->data->in_pipe, r) > r);
+    } while (pa_atomic_sub(&f->data->in_pipe, (int) r) > (int) r);
 }
 
 void pa_fdsem_post(pa_fdsem *f) {
@@ -211,19 +191,27 @@ void pa_fdsem_post(pa_fdsem *f) {
 
             for (;;) {
 
-#ifdef HAVE_EVENTFD
+#ifdef HAVE_SYS_EVENTFD_H
                 if (f->efd >= 0) {
                     uint64_t u = 1;
 
-                    if ((r = write(f->efd, &u, sizeof(u))) != sizeof(u)) {
-                        pa_assert(r < 0 && errno == EINTR);
+                    if ((r = pa_write(f->efd, &u, sizeof(u), &f->write_type)) != sizeof(u)) {
+                        if (r >= 0 || errno != EINTR) {
+                            pa_log_error("Invalid write to eventfd: %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+                            pa_assert_not_reached();
+                        }
+
                         continue;
                     }
                 } else
 #endif
 
-                if ((r = write(f->fds[1], &x, 1)) != 1) {
-                    pa_assert(r < 0 && errno == EINTR);
+                if ((r = pa_write(f->fds[1], &x, 1, &f->write_type)) != 1) {
+                    if (r >= 0 || errno != EINTR) {
+                        pa_log_error("Invalid write to pipe: %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+                        pa_assert_not_reached();
+                    }
+
                     continue;
                 }
 
@@ -247,12 +235,17 @@ void pa_fdsem_wait(pa_fdsem *f) {
         char x[10];
         ssize_t r;
 
-#ifdef HAVE_EVENTFD
+#ifdef HAVE_SYS_EVENTFD_H
         if (f->efd >= 0) {
             uint64_t u;
 
-            if ((r = read(f->efd, &u, sizeof(u))) != sizeof(u)) {
-                pa_assert(r < 0 && errno == EINTR);
+            if ((r = pa_read(f->efd, &u, sizeof(u), NULL)) != sizeof(u)) {
+
+                if (r >= 0 || errno != EINTR) {
+                    pa_log_error("Invalid read from eventfd: %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+                    pa_assert_not_reached();
+                }
+
                 continue;
             }
 
@@ -260,12 +253,17 @@ void pa_fdsem_wait(pa_fdsem *f) {
         } else
 #endif
 
-        if ((r = read(f->fds[0], &x, sizeof(x))) <= 0) {
-            pa_assert(r < 0 && errno == EINTR);
+        if ((r = pa_read(f->fds[0], &x, sizeof(x), NULL)) <= 0) {
+
+            if (r >= 0 || errno != EINTR) {
+                pa_log_error("Invalid read from pipe: %s", r < 0 ? pa_cstrerror(errno) : "EOF");
+                pa_assert_not_reached();
+            }
+
             continue;
         }
 
-        pa_atomic_sub(&f->data->in_pipe, r);
+        pa_atomic_sub(&f->data->in_pipe, (int) r);
     }
 
     pa_assert_se(pa_atomic_dec(&f->data->waiting) >= 1);
@@ -285,7 +283,7 @@ int pa_fdsem_try(pa_fdsem *f) {
 int pa_fdsem_get(pa_fdsem *f) {
     pa_assert(f);
 
-#ifdef HAVE_EVENTFD
+#ifdef HAVE_SYS_EVENTFD_H
     if (f->efd >= 0)
         return f->efd;
 #endif