1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "sles_allinclusive.h"
18
19
20 // Use this macro to validate a pthread_t before passing it into pthread_gettid_np.
21 // One of the common reasons for deadlock is trying to lock a mutex for an object
22 // which has been destroyed (which does memset to 0x00 or 0x55 as the final step).
23 // To avoid crashing with a SIGSEGV right before we're about to log a deadlock warning,
24 // we check that the pthread_t is probably valid. Note that it is theoretically
25 // possible for something to look like a valid pthread_t but not actually be valid.
26 // So we might still crash, but only in the case where a deadlock was imminent anyway.
27 #define LIKELY_VALID(ptr) (((ptr) != (pthread_t) 0) && ((((size_t) (ptr)) & 3) == 0))
28
29
30 /** \brief Exclusively lock an object */
31
32 #ifdef USE_DEBUG
33
init_time_spec(timespec * ts,long delta)34 void init_time_spec(timespec* ts, long delta) {
35 clock_gettime(CLOCK_REALTIME, ts);
36 ts->tv_nsec += delta;
37
38 if (ts->tv_nsec >= 1000000000L) {
39 ts->tv_sec++;
40 ts->tv_nsec -= 1000000000L;
41 }
42 }
43
object_lock_exclusive_(IObject * thiz,const char * file,int line)44 void object_lock_exclusive_(IObject *thiz, const char *file, int line)
45 {
46 int ok;
47 ok = pthread_mutex_trylock(&thiz->mMutex);
48 if (0 != ok) {
49 // not android_atomic_acquire_load because we don't care about relative load/load ordering
50 int32_t oldGeneration = thiz->mGeneration;
51 // wait up to a total of 250 ms
52 static const long nanoBackoffs[] = {
53 10 * 1000000, 20 * 1000000, 30 * 1000000, 40 * 1000000, 50 * 1000000, 100 * 1000000};
54 unsigned i = 0;
55 timespec ts;
56 memset(&ts, 0, sizeof(timespec));
57 for (;;) {
58 init_time_spec(&ts, nanoBackoffs[i]);
59 ok = pthread_mutex_timedlock(&thiz->mMutex, &ts);
60 if (0 == ok) {
61 break;
62 }
63 if (EBUSY == ok) {
64 // this is the expected return value for timeout, and will be handled below
65 } else if (EDEADLK == ok) {
66 // we don't use the kind of mutex that can return this error, but just in case
67 SL_LOGE("%s:%d: recursive lock detected", file, line);
68 } else {
69 // some other return value
70 SL_LOGE("%s:%d: pthread_mutex_lock_timeout_np returned %d", file, line, ok);
71 }
72 // is anyone else making forward progress?
73 int32_t newGeneration = thiz->mGeneration;
74 if (newGeneration != oldGeneration) {
75 // if we ever see forward progress then lock without timeout (more efficient)
76 goto forward_progress;
77 }
78 // no, then continue trying to lock but with increasing timeouts
79 if (++i >= (sizeof(nanoBackoffs) / sizeof(nanoBackoffs[0]))) {
80 // the extra block avoids a C++ compiler error about goto past initialization
81 {
82 pthread_t me = pthread_self();
83 pthread_t owner = thiz->mOwner;
84 // unlikely, but this could result in a memory fault if owner is corrupt
85 pid_t ownerTid = LIKELY_VALID(owner) ? pthread_gettid_np(owner) : -1;
86 SL_LOGW("%s:%d: pthread %p (tid %d) sees object %p was locked by pthread %p"
87 " (tid %d) at %s:%d\n", file, line, *(void **)&me, gettid(), thiz,
88 *(void **)&owner, ownerTid, thiz->mFile, thiz->mLine);
89 }
90 forward_progress:
91 // attempt one more time without timeout; maybe this time we will be successful
92 ok = pthread_mutex_lock(&thiz->mMutex);
93 assert(0 == ok);
94 break;
95 }
96 }
97 }
98 // here if mutex was successfully locked
99 pthread_t zero;
100 memset(&zero, 0, sizeof(pthread_t));
101 if (0 != memcmp(&zero, &thiz->mOwner, sizeof(pthread_t))) {
102 pthread_t me = pthread_self();
103 pthread_t owner = thiz->mOwner;
104 pid_t ownerTid = LIKELY_VALID(owner) ? pthread_gettid_np(owner) : -1;
105 if (pthread_equal(pthread_self(), owner)) {
106 SL_LOGE("%s:%d: pthread %p (tid %d) sees object %p was recursively locked by pthread"
107 " %p (tid %d) at %s:%d\n", file, line, *(void **)&me, gettid(), thiz,
108 *(void **)&owner, ownerTid, thiz->mFile, thiz->mLine);
109 } else {
110 SL_LOGE("%s:%d: pthread %p (tid %d) sees object %p was left unlocked in unexpected"
111 " state by pthread %p (tid %d) at %s:%d\n", file, line, *(void **)&me, gettid(),
112 thiz, *(void **)&owner, ownerTid, thiz->mFile, thiz->mLine);
113 }
114 assert(false);
115 }
116 thiz->mOwner = pthread_self();
117 thiz->mFile = file;
118 thiz->mLine = line;
119 // not android_atomic_inc because we are already holding a mutex
120 ++thiz->mGeneration;
121 }
122 #else
object_lock_exclusive(IObject * thiz)123 void object_lock_exclusive(IObject *thiz)
124 {
125 int ok;
126 ok = pthread_mutex_lock(&thiz->mMutex);
127 assert(0 == ok);
128 }
129 #endif
130
131
132 /** \brief Exclusively unlock an object and do not report any updates */
133
134 #ifdef USE_DEBUG
object_unlock_exclusive_(IObject * thiz,const char * file,int line)135 void object_unlock_exclusive_(IObject *thiz, const char *file, int line)
136 {
137 assert(pthread_equal(pthread_self(), thiz->mOwner));
138 assert(NULL != thiz->mFile);
139 assert(0 != thiz->mLine);
140 memset(&thiz->mOwner, 0, sizeof(pthread_t));
141 thiz->mFile = file;
142 thiz->mLine = line;
143 int ok;
144 ok = pthread_mutex_unlock(&thiz->mMutex);
145 assert(0 == ok);
146 }
147 #else
object_unlock_exclusive(IObject * thiz)148 void object_unlock_exclusive(IObject *thiz)
149 {
150 int ok;
151 ok = pthread_mutex_unlock(&thiz->mMutex);
152 assert(0 == ok);
153 }
154 #endif
155
156
157 /** \brief Exclusively unlock an object and report updates to the specified bit-mask of
158 * attributes
159 */
160
161 #ifdef USE_DEBUG
object_unlock_exclusive_attributes_(IObject * thiz,unsigned attributes,const char * file,int line)162 void object_unlock_exclusive_attributes_(IObject *thiz, unsigned attributes,
163 const char *file, int line)
164 #else
165 void object_unlock_exclusive_attributes(IObject *thiz, unsigned attributes)
166 #endif
167 {
168
169 #ifdef USE_DEBUG
170 assert(pthread_equal(pthread_self(), thiz->mOwner));
171 assert(NULL != thiz->mFile);
172 assert(0 != thiz->mLine);
173 #endif
174
175 int ok;
176
177 // make SL object IDs be contiguous with XA object IDs
178 SLuint32 objectID = IObjectToObjectID(thiz);
179 SLuint32 index = objectID;
180 if ((XA_OBJECTID_ENGINE <= index) && (index <= XA_OBJECTID_CAMERADEVICE)) {
181 ;
182 } else if ((SL_OBJECTID_ENGINE <= index) && (index <= SL_OBJECTID_METADATAEXTRACTOR)) {
183 index -= SL_OBJECTID_ENGINE - XA_OBJECTID_CAMERADEVICE - 1;
184 } else {
185 assert(false);
186 index = 0;
187 }
188
189 // first synchronously handle updates to attributes here, while object is still locked.
190 // This appears to be a loop, but actually typically runs through the loop only once.
191 unsigned asynchronous = attributes;
192 while (attributes) {
193 // this sequence is carefully crafted to be O(1); tread carefully when making changes
194 unsigned bit = ctz(attributes);
195 // ATTR_INDEX_MAX == next bit position after the last attribute
196 assert(ATTR_INDEX_MAX > bit);
197 // compute the entry in the handler table using object ID and bit number
198 AttributeHandler handler = handlerTable[index][bit];
199 if (NULL != handler) {
200 asynchronous &= ~(*handler)(thiz);
201 }
202 attributes &= ~(1 << bit);
203 }
204
205 // any remaining attributes are handled asynchronously in the sync thread
206 if (asynchronous) {
207 unsigned oldAttributesMask = thiz->mAttributesMask;
208 thiz->mAttributesMask = oldAttributesMask | asynchronous;
209 if (oldAttributesMask) {
210 asynchronous = ATTR_NONE;
211 }
212 }
213
214 #ifdef ANDROID
215 // FIXME hack to safely handle a post-unlock PrefetchStatus callback and/or AudioTrack::start()
216 slPrefetchCallback prefetchCallback = NULL;
217 void *prefetchContext = NULL;
218 SLuint32 prefetchEvents = SL_PREFETCHEVENT_NONE;
219 android::sp<android::AudioTrack> audioTrack;
220 if (SL_OBJECTID_AUDIOPLAYER == objectID) {
221 CAudioPlayer *ap = (CAudioPlayer *) thiz;
222 prefetchCallback = ap->mPrefetchStatus.mDeferredPrefetchCallback;
223 prefetchContext = ap->mPrefetchStatus.mDeferredPrefetchContext;
224 prefetchEvents = ap->mPrefetchStatus.mDeferredPrefetchEvents;
225 ap->mPrefetchStatus.mDeferredPrefetchCallback = NULL;
226 // clearing these next two fields is not required, but avoids stale data during debugging
227 ap->mPrefetchStatus.mDeferredPrefetchContext = NULL;
228 ap->mPrefetchStatus.mDeferredPrefetchEvents = SL_PREFETCHEVENT_NONE;
229 if (ap->mDeferredStart) {
230 audioTrack = ap->mTrackPlayer->mAudioTrack;
231 ap->mDeferredStart = false;
232 }
233 }
234 #endif
235
236 #ifdef USE_DEBUG
237 memset(&thiz->mOwner, 0, sizeof(pthread_t));
238 thiz->mFile = file;
239 thiz->mLine = line;
240 #endif
241 ok = pthread_mutex_unlock(&thiz->mMutex);
242 assert(0 == ok);
243
244 #ifdef ANDROID
245 // FIXME call the prefetch status callback while not holding the mutex on AudioPlayer
246 if (NULL != prefetchCallback) {
247 // note these are synchronous by the application's thread as it is about to return from API
248 assert(prefetchEvents != SL_PREFETCHEVENT_NONE);
249 CAudioPlayer *ap = (CAudioPlayer *) thiz;
250 // spec requires separate callbacks for each event
251 if (SL_PREFETCHEVENT_STATUSCHANGE & prefetchEvents) {
252 (*prefetchCallback)(&ap->mPrefetchStatus.mItf, prefetchContext,
253 SL_PREFETCHEVENT_STATUSCHANGE);
254 }
255 if (SL_PREFETCHEVENT_FILLLEVELCHANGE & prefetchEvents) {
256 (*prefetchCallback)(&ap->mPrefetchStatus.mItf, prefetchContext,
257 SL_PREFETCHEVENT_FILLLEVELCHANGE);
258 }
259 }
260
261 // call AudioTrack::start() while not holding the mutex on AudioPlayer
262 if (audioTrack != 0) {
263 audioTrack->start();
264 audioTrack.clear();
265 }
266 #endif
267
268 // first update to this interface since previous sync
269 if (ATTR_NONE != asynchronous) {
270 unsigned id = thiz->mInstanceID;
271 if (0 != id) {
272 --id;
273 assert(MAX_INSTANCE > id);
274 IEngine *thisEngine = &thiz->mEngine->mEngine;
275 // FIXME atomic or here
276 interface_lock_exclusive(thisEngine);
277 thisEngine->mChangedMask |= 1 << id;
278 interface_unlock_exclusive(thisEngine);
279 }
280 }
281
282 }
283
284
285 /** \brief Wait on the condition variable associated with the object; see pthread_cond_wait */
286
287 #ifdef USE_DEBUG
object_cond_wait_(IObject * thiz,const char * file,int line)288 void object_cond_wait_(IObject *thiz, const char *file, int line)
289 {
290 // note that this will unlock the mutex, so we have to clear the owner
291 assert(pthread_equal(pthread_self(), thiz->mOwner));
292 assert(NULL != thiz->mFile);
293 assert(0 != thiz->mLine);
294 memset(&thiz->mOwner, 0, sizeof(pthread_t));
295 thiz->mFile = file;
296 thiz->mLine = line;
297 // alas we don't know the new owner's identity
298 int ok;
299 ok = pthread_cond_wait(&thiz->mCond, &thiz->mMutex);
300 assert(0 == ok);
301 // restore my ownership
302 thiz->mOwner = pthread_self();
303 thiz->mFile = file;
304 thiz->mLine = line;
305 }
306 #else
object_cond_wait(IObject * thiz)307 void object_cond_wait(IObject *thiz)
308 {
309 int ok;
310 ok = pthread_cond_wait(&thiz->mCond, &thiz->mMutex);
311 assert(0 == ok);
312 }
313 #endif
314
315
316 /** \brief Signal the condition variable associated with the object; see pthread_cond_signal */
317
object_cond_signal(IObject * thiz)318 void object_cond_signal(IObject *thiz)
319 {
320 int ok;
321 ok = pthread_cond_signal(&thiz->mCond);
322 assert(0 == ok);
323 }
324
325
326 /** \brief Broadcast the condition variable associated with the object;
327 * see pthread_cond_broadcast
328 */
329
object_cond_broadcast(IObject * thiz)330 void object_cond_broadcast(IObject *thiz)
331 {
332 int ok;
333 ok = pthread_cond_broadcast(&thiz->mCond);
334 assert(0 == ok);
335 }
336