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
 120     return m;
 121 }
 122
 123 void pa_threaded_mainloop_free(pa_threaded_mainloop* m) {
 124     pa_assert(m);
 125
 126     /* Make sure that this function is not called from the helper thread */
 127     pa_assert((m->thread && !pa_thread_is_running(m->thread)) || !in_worker(m));
 128
 129     pa_threaded_mainloop_stop(m);
 130
 131     if (m->thread)
 132         pa_thread_free(m->thread);
 133
 134     pa_mainloop_free(m->real_mainloop);
 135
 136     pa_mutex_free(m->mutex);
 137     pa_cond_free(m->cond);
 138     pa_cond_free(m->accept_cond);
 139
 140     pa_xfree(m);
 141 }
 142
 143 int pa_threaded_mainloop_start(pa_threaded_mainloop *m) {
 144     pa_assert(m);
 145
 146     pa_assert(!m->thread || !pa_thread_is_running(m->thread));
 147
 148     if (!(m->thread = pa_thread_new(thread, m)))
 149         return -1;
 150
 151     return 0;
 152 }
 153
 154 void pa_threaded_mainloop_stop(pa_threaded_mainloop *m) {
 155     pa_assert(m);
 156
 157     if (!m->thread || !pa_thread_is_running(m->thread))
 158         return;
 159
 160     /* Make sure that this function is not called from the helper thread */
 161     pa_assert(!in_worker(m));
 162
 163     pa_mutex_lock(m->mutex);
 164     pa_mainloop_quit(m->real_mainloop, 0);
 165     pa_mutex_unlock(m->mutex);
 166
 167     pa_thread_join(m->thread);
 168 }
 169
 170 void pa_threaded_mainloop_lock(pa_threaded_mainloop *m) {
 171     pa_assert(m);
 172
 173     /* Make sure that this function is not called from the helper thread */
 174     pa_assert(!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m));
 175
 176     pa_mutex_lock(m->mutex);
 177 }
 178
 179 void pa_threaded_mainloop_unlock(pa_threaded_mainloop *m) {
 180     pa_assert(m);
 181
 182     /* Make sure that this function is not called from the helper thread */
 183     pa_assert(!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m));
 184
 185     pa_mutex_unlock(m->mutex);
 186 }
 187
 188 /* Called with the lock taken */
 189 void pa_threaded_mainloop_signal(pa_threaded_mainloop *m, int wait_for_accept) {
 190     pa_assert(m);
 191
 192     pa_cond_signal(m->cond, 1);
 193
 194     if (wait_for_accept) {
 195         m->n_waiting_for_accept ++;
 196
 197         while (m->n_waiting_for_accept > 0)
 198             pa_cond_wait(m->accept_cond, m->mutex);
 199     }
 200 }
 201
 202 /* Called with the lock taken */
 203 void pa_threaded_mainloop_wait(pa_threaded_mainloop *m) {
 204     pa_assert(m);
 205
 206     /* Make sure that this function is not called from the helper thread */
 207     pa_assert(!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m));
 208
 209     m->n_waiting ++;
 210
 211     pa_cond_wait(m->cond, m->mutex);
 212
 213     pa_assert(m->n_waiting > 0);
 214     m->n_waiting --;
 215 }
 216
 217 /* Called with the lock taken */
 218 void pa_threaded_mainloop_accept(pa_threaded_mainloop *m) {
 219     pa_assert(m);
 220
 221     /* Make sure that this function is not called from the helper thread */
 222     pa_assert(!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m));
 223
 224     pa_assert(m->n_waiting_for_accept > 0);
 225     m->n_waiting_for_accept --;
 226
 227     pa_cond_signal(m->accept_cond, 0);
 228 }
 229
 230 int pa_threaded_mainloop_get_retval(pa_threaded_mainloop *m) {
 231     pa_assert(m);
 232
 233     return pa_mainloop_get_retval(m->real_mainloop);
 234 }
 235
 236 pa_mainloop_api* pa_threaded_mainloop_get_api(pa_threaded_mainloop*m) {
 237     pa_assert(m);
 238
 239     return pa_mainloop_get_api(m->real_mainloop);
 240 }
 241
 242 int pa_threaded_mainloop_in_thread(pa_threaded_mainloop *m) {
 243     pa_assert(m);
 244
 245     return m->thread && pa_thread_self() == m->thread;
 246 }