Fix undefined behaviour in pulseaudio --start.
[platform/upstream/pulseaudio.git] / src / pulsecore / thread-posix.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 #include <pthread.h>
28 #include <sched.h>
29 #include <errno.h>
30
31 #ifdef __linux__
32 #include <sys/prctl.h>
33 #endif
34
35 #include <pulse/xmalloc.h>
36 #include <pulsecore/atomic.h>
37 #include <pulsecore/macro.h>
38
39 #include "thread.h"
40
41 struct pa_thread {
42     pthread_t id;
43     pa_thread_func_t thread_func;
44     void *userdata;
45     pa_atomic_t running;
46     bool joined;
47     char *name;
48 };
49
50 struct pa_tls {
51     pthread_key_t key;
52 };
53
54 static void thread_free_cb(void *p) {
55     pa_thread *t = p;
56
57     pa_assert(t);
58
59     if (!t->thread_func) {
60         /* This is a foreign thread, we need to free the struct */
61         pa_xfree(t->name);
62         pa_xfree(t);
63     }
64 }
65
66 PA_STATIC_TLS_DECLARE(current_thread, thread_free_cb);
67
68 static void* internal_thread_func(void *userdata) {
69     pa_thread *t = userdata;
70     pa_assert(t);
71
72 #ifdef __linux__
73     prctl(PR_SET_NAME, t->name);
74 #elif defined(HAVE_PTHREAD_SETNAME_NP) && defined(OS_IS_DARWIN)
75     pthread_setname_np(t->name);
76 #endif
77
78     t->id = pthread_self();
79
80     PA_STATIC_TLS_SET(current_thread, t);
81
82     pa_atomic_inc(&t->running);
83     t->thread_func(t->userdata);
84     pa_atomic_sub(&t->running, 2);
85
86     return NULL;
87 }
88
89 pa_thread* pa_thread_new(const char *name, pa_thread_func_t thread_func, void *userdata) {
90     pa_thread *t;
91
92     pa_assert(thread_func);
93
94     t = pa_xnew0(pa_thread, 1);
95     t->name = pa_xstrdup(name);
96     t->thread_func = thread_func;
97     t->userdata = userdata;
98
99     if (pthread_create(&t->id, NULL, internal_thread_func, t) < 0) {
100         pa_xfree(t);
101         return NULL;
102     }
103
104     pa_atomic_inc(&t->running);
105
106     return t;
107 }
108
109 int pa_thread_is_running(pa_thread *t) {
110     pa_assert(t);
111
112     /* Unfortunately there is no way to tell whether a "foreign"
113      * thread is still running. See
114      * http://udrepper.livejournal.com/16844.html for more
115      * information */
116     pa_assert(t->thread_func);
117
118     return pa_atomic_load(&t->running) > 0;
119 }
120
121 void pa_thread_free(pa_thread *t) {
122     pa_assert(t);
123
124     pa_thread_join(t);
125
126     pa_xfree(t->name);
127     pa_xfree(t);
128 }
129
130 void pa_thread_free_nojoin(pa_thread *t) {
131     pa_assert(t);
132
133     pa_xfree(t->name);
134     pa_xfree(t);
135 }
136
137 int pa_thread_join(pa_thread *t) {
138     pa_assert(t);
139     pa_assert(t->thread_func);
140
141     if (t->joined)
142         return -1;
143
144     t->joined = true;
145     return pthread_join(t->id, NULL);
146 }
147
148 pa_thread* pa_thread_self(void) {
149     pa_thread *t;
150
151     if ((t = PA_STATIC_TLS_GET(current_thread)))
152         return t;
153
154     /* This is a foreign thread, let's create a pthread structure to
155      * make sure that we can always return a sensible pointer */
156
157     t = pa_xnew0(pa_thread, 1);
158     t->id = pthread_self();
159     t->joined = true;
160     pa_atomic_store(&t->running, 2);
161
162     PA_STATIC_TLS_SET(current_thread, t);
163
164     return t;
165 }
166
167 void* pa_thread_get_data(pa_thread *t) {
168     pa_assert(t);
169
170     return t->userdata;
171 }
172
173 void pa_thread_set_data(pa_thread *t, void *userdata) {
174     pa_assert(t);
175
176     t->userdata = userdata;
177 }
178
179 void pa_thread_set_name(pa_thread *t, const char *name) {
180     pa_assert(t);
181
182     pa_xfree(t->name);
183     t->name = pa_xstrdup(name);
184
185 #ifdef __linux__
186     prctl(PR_SET_NAME, name);
187 #elif defined(HAVE_PTHREAD_SETNAME_NP) && defined(OS_IS_DARWIN)
188     pthread_setname_np(name);
189 #endif
190 }
191
192 const char *pa_thread_get_name(pa_thread *t) {
193     pa_assert(t);
194
195 #ifdef __linux__
196     if (!t->name) {
197         t->name = pa_xmalloc(17);
198
199         if (prctl(PR_GET_NAME, t->name) >= 0)
200             t->name[16] = 0;
201         else {
202             pa_xfree(t->name);
203             t->name = NULL;
204         }
205     }
206 #elif defined(HAVE_PTHREAD_GETNAME_NP) && defined(OS_IS_DARWIN)
207     if (!t->name) {
208         t->name = pa_xmalloc0(17);
209         pthread_getname_np(t->id, t->name, 16);
210     }
211 #endif
212
213     return t->name;
214 }
215
216 void pa_thread_yield(void) {
217 #ifdef HAVE_PTHREAD_YIELD
218     pthread_yield();
219 #else
220     pa_assert_se(sched_yield() == 0);
221 #endif
222 }
223
224 pa_tls* pa_tls_new(pa_free_cb_t free_cb) {
225     pa_tls *t;
226
227     t = pa_xnew(pa_tls, 1);
228
229     if (pthread_key_create(&t->key, free_cb) < 0) {
230         pa_xfree(t);
231         return NULL;
232     }
233
234     return t;
235 }
236
237 void pa_tls_free(pa_tls *t) {
238     pa_assert(t);
239
240     pa_assert_se(pthread_key_delete(t->key) == 0);
241     pa_xfree(t);
242 }
243
244 void *pa_tls_get(pa_tls *t) {
245     pa_assert(t);
246
247     return pthread_getspecific(t->key);
248 }
249
250 void *pa_tls_set(pa_tls *t, void *userdata) {
251     void *r;
252
253     r = pthread_getspecific(t->key);
254     pa_assert_se(pthread_setspecific(t->key, userdata) == 0);
255     return r;
256 }