src/pulse/thread-mainloop.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #ifndef OS_IS_WIN32
  28 #include <pthread.h>
  29 #endif
  30
  31 #include <signal.h>
  32 #include <stdio.h>
  33
  34 #ifdef HAVE_POLL_H
  35 #include <poll.h>
  36 #else
  37 #include <pulsecore/poll.h>
  38 #endif
  39
  40 #include <pulse/xmalloc.h>
  41 #include <pulse/mainloop.h>
  42 #include <pulse/i18n.h>
  43
  44 #include <pulsecore/log.h>
  45 #include <pulsecore/hashmap.h>
  46 #include <pulsecore/thread.h>
  47 #include <pulsecore/mutex.h>
  48 #include <pulsecore/macro.h>
  49
  50 #include "thread-mainloop.h"
  51
  52 struct pa_threaded_mainloop {
  53     pa_mainloop *real_mainloop;
  54     volatile int n_waiting, n_waiting_for_accept;
  55
  56     pa_thread* thread;
  57     pa_mutex* mutex;
  58     pa_cond* cond, *accept_cond;
  59 };
  60
  61 static inline int in_worker(pa_threaded_mainloop *m) {
  62     return pa_thread_self() == m->thread;
  63 }
  64
  65 static int poll_func(struct pollfd *ufds, unsigned long nfds, int timeout, void *userdata) {
  66     pa_mutex *mutex = userdata;
  67     int r;
  68
  69     pa_assert(mutex);
  70
  71     /* Before entering poll() we unlock the mutex, so that
  72      * avahi_simple_poll_quit() can succeed from another thread. */
  73
  74     pa_mutex_unlock(mutex);
  75     r = poll(ufds, nfds, timeout);
  76     pa_mutex_lock(mutex);
  77
  78     return r;
  79 }
  80
  81 static void thread(void *userdata) {
  82     pa_threaded_mainloop *m = userdata;
  83
  84 #ifndef OS_IS_WIN32
  85     sigset_t mask;
  86
  87     /* Make sure that signals are delivered to the main thread */
  88     sigfillset(&mask);
  89     pthread_sigmask(SIG_BLOCK, &mask, NULL);
  90 #endif
  91
  92     pa_mutex_lock(m->mutex);
  93
  94     pa_mainloop_run(m->real_mainloop, NULL);
  95
  96     pa_mutex_unlock(m->mutex);
  97 }
  98
  99 pa_threaded_mainloop *pa_threaded_mainloop_new(void) {
 100     pa_threaded_mainloop *m;
 101
 102     pa_init_i18n();
 103
 104     m = pa_xnew(pa_threaded_mainloop, 1);
 105
 106     if (!(m->real_mainloop = pa_mainloop_new())) {
 107         pa_xfree(m);
 108         return NULL;
 109     }
 110
 111     m->mutex = pa_mutex_new(TRUE, TRUE);
 112     m->cond = pa_cond_new();
 113     m->accept_cond = pa_cond_new();
 114     m->thread = NULL;
 115
 116     pa_mainloop_set_poll_func(m->real_mainloop, poll_func, m->mutex);
 117
 118     m->n_waiting = 0;
 119     m->n_waiting_for_accept = 0;
 120
 121     return m;
 122 }
 123
 124 void pa_threaded_mainloop_free(pa_threaded_mainloop* m) {
 125     pa_assert(m);
 126
 127     /* Make sure that this function is not called from the helper thread */
 128     pa_assert((m->thread && !pa_thread_is_running(m->thread)) || !in_worker(m));
 129
 130     pa_threaded_mainloop_stop(m);
 131
 132     if (m->thread)
 133         pa_thread_free(m->thread);
 134
 135     pa_mainloop_free(m->real_mainloop);
 136
 137     pa_mutex_free(m->mutex);
 138     pa_cond_free(m->cond);
 139     pa_cond_free(m->accept_cond);
 140
 141     pa_xfree(m);
 142 }
 143
 144 int pa_threaded_mainloop_start(pa_threaded_mainloop *m) {
 145     pa_assert(m);
 146
 147     pa_assert(!m->thread || !pa_thread_is_running(m->thread));
 148
 149     if (!(m->thread = pa_thread_new(thread, m)))
 150         return -1;
 151
 152     return 0;
 153 }
 154
 155 void pa_threaded_mainloop_stop(pa_threaded_mainloop *m) {
 156     pa_assert(m);
 157
 158     if (!m->thread || !pa_thread_is_running(m->thread))
 159         return;
 160
 161     /* Make sure that this function is not called from the helper thread */
 162     pa_assert(!in_worker(m));
 163
 164     pa_mutex_lock(m->mutex);
 165     pa_mainloop_quit(m->real_mainloop, 0);
 166     pa_mutex_unlock(m->mutex);
 167
 168     pa_thread_join(m->thread);
 169 }
 170
 171 void pa_threaded_mainloop_lock(pa_threaded_mainloop *m) {
 172     pa_assert(m);
 173
 174     /* Make sure that this function is not called from the helper thread */
 175     pa_assert(!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m));
 176
 177     pa_mutex_lock(m->mutex);
 178 }
 179
 180 void pa_threaded_mainloop_unlock(pa_threaded_mainloop *m) {
 181     pa_assert(m);
 182
 183     /* Make sure that this function is not called from the helper thread */
 184     pa_assert(!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m));
 185
 186     pa_mutex_unlock(m->mutex);
 187 }
 188
 189 /* Called with the lock taken */
 190 void pa_threaded_mainloop_signal(pa_threaded_mainloop *m, int wait_for_accept) {
 191     pa_assert(m);
 192
 193     pa_cond_signal(m->cond, 1);
 194
 195     if (wait_for_accept) {
 196         m->n_waiting_for_accept ++;
 197
 198         while (m->n_waiting_for_accept > 0)
 199             pa_cond_wait(m->accept_cond, m->mutex);
 200     }
 201 }
 202
 203 /* Called with the lock taken */
 204 void pa_threaded_mainloop_wait(pa_threaded_mainloop *m) {
 205     pa_assert(m);
 206
 207     /* Make sure that this function is not called from the helper thread */
 208     pa_assert(!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m));
 209
 210     m->n_waiting ++;
 211
 212     pa_cond_wait(m->cond, m->mutex);
 213
 214     pa_assert(m->n_waiting > 0);
 215     m->n_waiting --;
 216 }
 217
 218 /* Called with the lock taken */
 219 void pa_threaded_mainloop_accept(pa_threaded_mainloop *m) {
 220     pa_assert(m);
 221
 222     /* Make sure that this function is not called from the helper thread */
 223     pa_assert(!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m));
 224
 225     pa_assert(m->n_waiting_for_accept > 0);
 226     m->n_waiting_for_accept --;
 227
 228     pa_cond_signal(m->accept_cond, 0);
 229 }
 230
 231 int pa_threaded_mainloop_get_retval(pa_threaded_mainloop *m) {
 232     pa_assert(m);
 233
 234     return pa_mainloop_get_retval(m->real_mainloop);
 235 }
 236
 237 pa_mainloop_api* pa_threaded_mainloop_get_api(pa_threaded_mainloop*m) {
 238     pa_assert(m);
 239
 240     return pa_mainloop_get_api(m->real_mainloop);
 241 }
 242
 243 int pa_threaded_mainloop_in_thread(pa_threaded_mainloop *m) {
 244     pa_assert(m);
 245
 246     return m->thread && pa_thread_self() == m->thread;
 247 }