1 /*
2 * Copyright (C) 2017 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 #define LOG_TAG "AAudioEndpointManager"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20
21 #include <assert.h>
22 #include <functional>
23 #include <map>
24 #include <mutex>
25 #include <sstream>
26 #include <utility/AAudioUtilities.h>
27 #include <media/AidlConversion.h>
28
29 #include "AAudioClientTracker.h"
30 #include "AAudioEndpointManager.h"
31 #include "AAudioServiceEndpointShared.h"
32 #include "AAudioServiceEndpointMMAP.h"
33 #include "AAudioServiceEndpointCapture.h"
34 #include "AAudioServiceEndpointPlay.h"
35
36 using namespace android;
37 using namespace aaudio;
38
39 ANDROID_SINGLETON_STATIC_INSTANCE(AAudioEndpointManager);
40
AAudioEndpointManager()41 AAudioEndpointManager::AAudioEndpointManager()
42 : Singleton<AAudioEndpointManager>()
43 , mSharedStreams()
44 , mExclusiveStreams() {
45 }
46
dump() const47 std::string AAudioEndpointManager::dump() const NO_THREAD_SAFETY_ANALYSIS {
48 std::stringstream result;
49 int index = 0;
50
51 result << "AAudioEndpointManager:" << "\n";
52
53 const bool isSharedLocked = AAudio_tryUntilTrue(
54 [this]()->bool { return mSharedLock.try_lock(); } /* f */,
55 50 /* times */,
56 20 /* sleepMs */);
57 if (!isSharedLocked) {
58 result << "AAudioEndpointManager Shared may be deadlocked\n";
59 }
60
61 {
62 const bool isExclusiveLocked = AAudio_tryUntilTrue(
63 [this]() -> bool { return mExclusiveLock.try_lock(); } /* f */,
64 50 /* times */,
65 20 /* sleepMs */);
66 if (!isExclusiveLocked) {
67 result << "AAudioEndpointManager Exclusive may be deadlocked\n";
68 }
69
70 result << "Exclusive MMAP Endpoints: " << mExclusiveStreams.size() << "\n";
71 index = 0;
72 for (const auto &stream : mExclusiveStreams) {
73 result << " #" << index++ << ":";
74 result << stream->dump() << "\n";
75 }
76
77 result << " ExclusiveSearchCount: " << mExclusiveSearchCount << "\n";
78 result << " ExclusiveFoundCount: " << mExclusiveFoundCount << "\n";
79 result << " ExclusiveOpenCount: " << mExclusiveOpenCount << "\n";
80 result << " ExclusiveCloseCount: " << mExclusiveCloseCount << "\n";
81 result << " ExclusiveStolenCount: " << mExclusiveStolenCount << "\n";
82 result << "\n";
83
84 if (isExclusiveLocked) {
85 mExclusiveLock.unlock();
86 }
87 }
88
89 result << "Shared Endpoints: " << mSharedStreams.size() << "\n";
90 index = 0;
91 for (const auto &stream : mSharedStreams) {
92 result << " #" << index++ << ":";
93 result << stream->dump() << "\n";
94 }
95
96 result << " SharedSearchCount: " << mSharedSearchCount << "\n";
97 result << " SharedFoundCount: " << mSharedFoundCount << "\n";
98 result << " SharedOpenCount: " << mSharedOpenCount << "\n";
99 result << " SharedCloseCount: " << mSharedCloseCount << "\n";
100 result << "\n";
101
102 if (isSharedLocked) {
103 mSharedLock.unlock();
104 }
105 return result.str();
106 }
107
108
109 // Try to find an existing endpoint.
findExclusiveEndpoint_l(const AAudioStreamConfiguration & configuration)110 sp<AAudioServiceEndpoint> AAudioEndpointManager::findExclusiveEndpoint_l(
111 const AAudioStreamConfiguration &configuration) {
112 sp<AAudioServiceEndpoint> endpoint;
113 mExclusiveSearchCount++;
114 for (const auto& ep : mExclusiveStreams) {
115 if (ep->matches(configuration)) {
116 mExclusiveFoundCount++;
117 endpoint = ep;
118 break;
119 }
120 }
121
122 ALOGV("findExclusiveEndpoint_l(), found %p for device = %d, sessionId = %d",
123 endpoint.get(), configuration.getDeviceId(), configuration.getSessionId());
124 return endpoint;
125 }
126
127 // Try to find an existing endpoint.
findSharedEndpoint_l(const AAudioStreamConfiguration & configuration)128 sp<AAudioServiceEndpointShared> AAudioEndpointManager::findSharedEndpoint_l(
129 const AAudioStreamConfiguration &configuration) {
130 sp<AAudioServiceEndpointShared> endpoint;
131 mSharedSearchCount++;
132 for (const auto& ep : mSharedStreams) {
133 if (ep->matches(configuration)) {
134 mSharedFoundCount++;
135 endpoint = ep;
136 break;
137 }
138 }
139
140 ALOGV("findSharedEndpoint_l(), found %p for device = %d, sessionId = %d",
141 endpoint.get(), configuration.getDeviceId(), configuration.getSessionId());
142 return endpoint;
143 }
144
openEndpoint(AAudioService & audioService,const aaudio::AAudioStreamRequest & request)145 sp<AAudioServiceEndpoint> AAudioEndpointManager::openEndpoint(AAudioService &audioService,
146 const aaudio::AAudioStreamRequest &request) {
147 if (request.getConstantConfiguration().getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE) {
148 sp<AAudioServiceEndpoint> endpointToSteal;
149 sp<AAudioServiceEndpoint> foundEndpoint =
150 openExclusiveEndpoint(audioService, request, endpointToSteal);
151 if (endpointToSteal.get()) {
152 endpointToSteal->releaseRegisteredStreams(); // free the MMAP resource
153 }
154 return foundEndpoint;
155 } else {
156 return openSharedEndpoint(audioService, request);
157 }
158 }
159
openExclusiveEndpoint(AAudioService & aaudioService,const aaudio::AAudioStreamRequest & request,sp<AAudioServiceEndpoint> & endpointToSteal)160 sp<AAudioServiceEndpoint> AAudioEndpointManager::openExclusiveEndpoint(
161 AAudioService &aaudioService,
162 const aaudio::AAudioStreamRequest &request,
163 sp<AAudioServiceEndpoint> &endpointToSteal) {
164
165 std::lock_guard<std::mutex> lock(mExclusiveLock);
166
167 const AAudioStreamConfiguration &configuration = request.getConstantConfiguration();
168
169 // Try to find an existing endpoint.
170 sp<AAudioServiceEndpoint> endpoint = findExclusiveEndpoint_l(configuration);
171
172 // If we find an existing one then this one cannot be exclusive.
173 if (endpoint.get() != nullptr) {
174 if (kStealingEnabled
175 && !endpoint->isForSharing() // not currently SHARED
176 && !request.isSharingModeMatchRequired()) { // app did not request a shared stream
177 ALOGD("%s() endpoint in EXCLUSIVE use. Steal it!", __func__);
178 mExclusiveStolenCount++;
179 // Prevent this process from getting another EXCLUSIVE stream.
180 // This will prevent two clients from colliding after a DISCONNECTION
181 // when they both try to open an exclusive stream at the same time.
182 // That can result in a stream getting disconnected between the OPEN
183 // and START calls. This will help preserve app compatibility.
184 // An app can avoid having this happen by closing their streams when
185 // the app is paused.
186 pid_t pid = VALUE_OR_FATAL(
187 aidl2legacy_int32_t_pid_t(request.getAttributionSource().pid));
188 AAudioClientTracker::getInstance().setExclusiveEnabled(pid, false);
189 endpointToSteal = endpoint; // return it to caller
190 }
191 return nullptr;
192 } else {
193 sp<AAudioServiceEndpointMMAP> endpointMMap = new AAudioServiceEndpointMMAP(aaudioService);
194 ALOGV("%s(), no match so try to open MMAP %p for dev %d",
195 __func__, endpointMMap.get(), configuration.getDeviceId());
196 endpoint = endpointMMap;
197
198 aaudio_result_t result = endpoint->open(request);
199 if (result != AAUDIO_OK) {
200 endpoint.clear();
201 } else {
202 mExclusiveStreams.push_back(endpointMMap);
203 mExclusiveOpenCount++;
204 }
205 }
206
207 if (endpoint.get() != nullptr) {
208 // Increment the reference count under this lock.
209 endpoint->setOpenCount(endpoint->getOpenCount() + 1);
210 endpoint->setForSharing(request.isSharingModeMatchRequired());
211 }
212
213 return endpoint;
214 }
215
openSharedEndpoint(AAudioService & aaudioService,const aaudio::AAudioStreamRequest & request)216 sp<AAudioServiceEndpoint> AAudioEndpointManager::openSharedEndpoint(
217 AAudioService &aaudioService,
218 const aaudio::AAudioStreamRequest &request) {
219
220 std::lock_guard<std::mutex> lock(mSharedLock);
221
222 const AAudioStreamConfiguration &configuration = request.getConstantConfiguration();
223 aaudio_direction_t direction = configuration.getDirection();
224
225 // Try to find an existing endpoint.
226 sp<AAudioServiceEndpointShared> endpoint = findSharedEndpoint_l(configuration);
227
228 // If we can't find an existing one then open a new one.
229 if (endpoint.get() == nullptr) {
230 // we must call openStream with audioserver identity
231 int64_t token = IPCThreadState::self()->clearCallingIdentity();
232 switch (direction) {
233 case AAUDIO_DIRECTION_INPUT:
234 endpoint = new AAudioServiceEndpointCapture(aaudioService);
235 break;
236 case AAUDIO_DIRECTION_OUTPUT:
237 endpoint = new AAudioServiceEndpointPlay(aaudioService);
238 break;
239 default:
240 break;
241 }
242
243 if (endpoint.get() != nullptr) {
244 aaudio_result_t result = endpoint->open(request);
245 if (result != AAUDIO_OK) {
246 endpoint.clear();
247 } else {
248 mSharedStreams.push_back(endpoint);
249 mSharedOpenCount++;
250 }
251 }
252 ALOGV("%s(), created endpoint %p, requested device = %d, dir = %d",
253 __func__, endpoint.get(), configuration.getDeviceId(), (int)direction);
254 IPCThreadState::self()->restoreCallingIdentity(token);
255 }
256
257 if (endpoint.get() != nullptr) {
258 // Increment the reference count under this lock.
259 endpoint->setOpenCount(endpoint->getOpenCount() + 1);
260 }
261 return endpoint;
262 }
263
closeEndpoint(sp<AAudioServiceEndpoint> serviceEndpoint)264 void AAudioEndpointManager::closeEndpoint(sp<AAudioServiceEndpoint>serviceEndpoint) {
265 if (serviceEndpoint->getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE) {
266 return closeExclusiveEndpoint(serviceEndpoint);
267 } else {
268 return closeSharedEndpoint(serviceEndpoint);
269 }
270 }
271
closeExclusiveEndpoint(sp<AAudioServiceEndpoint> serviceEndpoint)272 void AAudioEndpointManager::closeExclusiveEndpoint(sp<AAudioServiceEndpoint> serviceEndpoint) {
273 if (serviceEndpoint.get() == nullptr) {
274 return;
275 }
276
277 // Decrement the reference count under this lock.
278 std::lock_guard<std::mutex> lock(mExclusiveLock);
279 int32_t newRefCount = serviceEndpoint->getOpenCount() - 1;
280 serviceEndpoint->setOpenCount(newRefCount);
281
282 // If no longer in use then actually close it.
283 if (newRefCount <= 0) {
284 mExclusiveStreams.erase(
285 std::remove(mExclusiveStreams.begin(), mExclusiveStreams.end(), serviceEndpoint),
286 mExclusiveStreams.end());
287
288 serviceEndpoint->close();
289 mExclusiveCloseCount++;
290 ALOGV("%s() %p for device %d",
291 __func__, serviceEndpoint.get(), serviceEndpoint->getDeviceId());
292 }
293 }
294
closeSharedEndpoint(sp<AAudioServiceEndpoint> serviceEndpoint)295 void AAudioEndpointManager::closeSharedEndpoint(sp<AAudioServiceEndpoint> serviceEndpoint) {
296 if (serviceEndpoint.get() == nullptr) {
297 return;
298 }
299
300 // Decrement the reference count under this lock.
301 std::lock_guard<std::mutex> lock(mSharedLock);
302 int32_t newRefCount = serviceEndpoint->getOpenCount() - 1;
303 serviceEndpoint->setOpenCount(newRefCount);
304
305 // If no longer in use then actually close it.
306 if (newRefCount <= 0) {
307 mSharedStreams.erase(
308 std::remove(mSharedStreams.begin(), mSharedStreams.end(), serviceEndpoint),
309 mSharedStreams.end());
310
311 serviceEndpoint->close();
312
313 mSharedCloseCount++;
314 ALOGV("%s(%p) closed for device %d",
315 __func__, serviceEndpoint.get(), serviceEndpoint->getDeviceId());
316 }
317 }
318