src/pulsecore/mutex-posix.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2006 Lennart Poettering
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2.1 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <pthread.h>
  27 #include <errno.h>
  28
  29 #include <pulse/xmalloc.h>
  30 #include <pulsecore/macro.h>
  31 #include <pulsecore/log.h>
  32 #include <pulsecore/core-error.h>
  33
  34 #include "mutex.h"
  35
  36 struct pa_mutex {
  37     pthread_mutex_t mutex;
  38 };
  39
  40 struct pa_cond {
  41     pthread_cond_t cond;
  42 };
  43
  44 pa_mutex* pa_mutex_new(pa_bool_t recursive, pa_bool_t inherit_priority) {
  45     pa_mutex *m;
  46     pthread_mutexattr_t attr;
  47     int r;
  48
  49     pa_assert_se(pthread_mutexattr_init(&attr) == 0);
  50
  51     if (recursive)
  52         pa_assert_se(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0);
  53
  54 #ifdef HAVE_PTHREAD_PRIO_INHERIT
  55     if (inherit_priority)
  56         pa_assert_se(pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT) == 0);
  57 #endif
  58
  59     m = pa_xnew(pa_mutex, 1);
  60
  61 #ifndef HAVE_PTHREAD_PRIO_INHERIT
  62     pa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0);
  63
  64 #else
  65     if ((r = pthread_mutex_init(&m->mutex, &attr))) {
  66
  67         /* If this failed, then this was probably due to non-available
  68          * priority inheritance. In which case we fall back to normal
  69          * mutexes. */
  70         pa_assert(r == ENOTSUP && inherit_priority);
  71
  72         pa_assert_se(pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_NONE) == 0);
  73         pa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0);
  74     }
  75 #endif
  76
  77     return m;
  78 }
  79
  80 void pa_mutex_free(pa_mutex *m) {
  81     pa_assert(m);
  82
  83     pa_assert_se(pthread_mutex_destroy(&m->mutex) == 0);
  84     pa_xfree(m);
  85 }
  86
  87 void pa_mutex_lock(pa_mutex *m) {
  88     pa_assert(m);
  89
  90     pa_assert_se(pthread_mutex_lock(&m->mutex) == 0);
  91 }
  92
  93 pa_bool_t pa_mutex_try_lock(pa_mutex *m) {
  94     int r;
  95     pa_assert(m);
  96
  97     if ((r = pthread_mutex_trylock(&m->mutex)) != 0) {
  98         pa_assert(r == EBUSY);
  99         return FALSE;
 100     }
 101
 102     return TRUE;
 103 }
 104
 105 void pa_mutex_unlock(pa_mutex *m) {
 106     pa_assert(m);
 107
 108     pa_assert_se(pthread_mutex_unlock(&m->mutex) == 0);
 109 }
 110
 111 pa_cond *pa_cond_new(void) {
 112     pa_cond *c;
 113
 114     c = pa_xnew(pa_cond, 1);
 115     pa_assert_se(pthread_cond_init(&c->cond, NULL) == 0);
 116     return c;
 117 }
 118
 119 void pa_cond_free(pa_cond *c) {
 120     pa_assert(c);
 121
 122     pa_assert_se(pthread_cond_destroy(&c->cond) == 0);
 123     pa_xfree(c);
 124 }
 125
 126 void pa_cond_signal(pa_cond *c, int broadcast) {
 127     pa_assert(c);
 128
 129     if (broadcast)
 130         pa_assert_se(pthread_cond_broadcast(&c->cond) == 0);
 131     else
 132         pa_assert_se(pthread_cond_signal(&c->cond) == 0);
 133 }
 134
 135 int pa_cond_wait(pa_cond *c, pa_mutex *m) {
 136     pa_assert(c);
 137     pa_assert(m);
 138
 139     return pthread_cond_wait(&c->cond, &m->mutex);
 140 }
 141
 142 pa_mutex* pa_static_mutex_get(pa_static_mutex *s, pa_bool_t recursive, pa_bool_t inherit_priority) {
 143     pa_mutex *m;
 144
 145     pa_assert(s);
 146
 147     /* First, check if already initialized and short cut */
 148     if ((m = pa_atomic_ptr_load(&s->ptr)))
 149         return m;
 150
 151     /* OK, not initialized, so let's allocate, and fill in */
 152     m = pa_mutex_new(recursive, inherit_priority);
 153     if ((pa_atomic_ptr_cmpxchg(&s->ptr, NULL, m)))
 154         return m;
 155
 156     pa_mutex_free(m);
 157
 158     /* Him, filling in failed, so someone else must have filled in
 159      * already */
 160     pa_assert_se(m = pa_atomic_ptr_load(&s->ptr));
 161     return m;
 162 }