blob: 3224cfcc5854327843c9f459b77f8707e889994e [file] [log] [blame]
Phil Burkc0c70e32017-02-09 13:18:38 -08001/*
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
Eric Laurenta54f1282017-07-01 19:39:32 -070017#define LOG_TAG "AAudioEndpointManager"
Phil Burk71f35bb2017-04-13 16:05:07 -070018//#define LOG_NDEBUG 0
19#include <utils/Log.h>
20
Phil Burkc0c70e32017-02-09 13:18:38 -080021#include <assert.h>
Andy Hung47c5e532017-06-26 18:28:00 -070022#include <functional>
Phil Burkc0c70e32017-02-09 13:18:38 -080023#include <map>
24#include <mutex>
Andy Hung47c5e532017-06-26 18:28:00 -070025#include <sstream>
26#include <utility/AAudioUtilities.h>
Philip P. Moltmannbda45752020-07-17 16:41:18 -070027#include <media/AidlConversion.h>
Phil Burkc0c70e32017-02-09 13:18:38 -080028
Phil Burk836f9df2020-05-29 13:20:28 -070029#include "AAudioClientTracker.h"
Phil Burkc0c70e32017-02-09 13:18:38 -080030#include "AAudioEndpointManager.h"
Phil Burk39f02dd2017-08-04 09:13:31 -070031#include "AAudioServiceEndpointShared.h"
32#include "AAudioServiceEndpointMMAP.h"
33#include "AAudioServiceEndpointCapture.h"
34#include "AAudioServiceEndpointPlay.h"
Phil Burkc0c70e32017-02-09 13:18:38 -080035
36using namespace android;
37using namespace aaudio;
38
39ANDROID_SINGLETON_STATIC_INSTANCE(AAudioEndpointManager);
40
41AAudioEndpointManager::AAudioEndpointManager()
Phil Burk71f35bb2017-04-13 16:05:07 -070042 : Singleton<AAudioEndpointManager>()
Phil Burk39f02dd2017-08-04 09:13:31 -070043 , mSharedStreams()
44 , mExclusiveStreams() {
Phil Burkc0c70e32017-02-09 13:18:38 -080045}
46
Phil Burk0bd745e2020-10-17 18:20:01 +000047std::string AAudioEndpointManager::dump() const NO_THREAD_SAFETY_ANALYSIS {
Andy Hung47c5e532017-06-26 18:28:00 -070048 std::stringstream result;
Phil Burk39f02dd2017-08-04 09:13:31 -070049 int index = 0;
Andy Hung47c5e532017-06-26 18:28:00 -070050
Phil Burk4501b352017-06-29 18:12:36 -070051 result << "AAudioEndpointManager:" << "\n";
Phil Burk39f02dd2017-08-04 09:13:31 -070052
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";
Andy Hung47c5e532017-06-26 18:28:00 -070059 }
60
Phil Burk39f02dd2017-08-04 09:13:31 -070061 {
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;
Phil Burk55e5eab2018-04-10 15:16:38 -070072 for (const auto &stream : mExclusiveStreams) {
Phil Burk39f02dd2017-08-04 09:13:31 -070073 result << " #" << index++ << ":";
Phil Burk55e5eab2018-04-10 15:16:38 -070074 result << stream->dump() << "\n";
Phil Burk39f02dd2017-08-04 09:13:31 -070075 }
76
Phil Burk55e5eab2018-04-10 15:16:38 -070077 result << " ExclusiveSearchCount: " << mExclusiveSearchCount << "\n";
78 result << " ExclusiveFoundCount: " << mExclusiveFoundCount << "\n";
79 result << " ExclusiveOpenCount: " << mExclusiveOpenCount << "\n";
80 result << " ExclusiveCloseCount: " << mExclusiveCloseCount << "\n";
Phil Burk6e463ce2020-04-13 10:20:20 -070081 result << " ExclusiveStolenCount: " << mExclusiveStolenCount << "\n";
Phil Burk55e5eab2018-04-10 15:16:38 -070082 result << "\n";
83
Phil Burk39f02dd2017-08-04 09:13:31 -070084 if (isExclusiveLocked) {
85 mExclusiveLock.unlock();
86 }
Andy Hung47c5e532017-06-26 18:28:00 -070087 }
88
Phil Burk39f02dd2017-08-04 09:13:31 -070089 result << "Shared Endpoints: " << mSharedStreams.size() << "\n";
90 index = 0;
Phil Burk55e5eab2018-04-10 15:16:38 -070091 for (const auto &stream : mSharedStreams) {
Phil Burk39f02dd2017-08-04 09:13:31 -070092 result << " #" << index++ << ":";
Phil Burk55e5eab2018-04-10 15:16:38 -070093 result << stream->dump() << "\n";
Phil Burk39f02dd2017-08-04 09:13:31 -070094 }
95
Phil Burk55e5eab2018-04-10 15:16:38 -070096 result << " SharedSearchCount: " << mSharedSearchCount << "\n";
97 result << " SharedFoundCount: " << mSharedFoundCount << "\n";
98 result << " SharedOpenCount: " << mSharedOpenCount << "\n";
99 result << " SharedCloseCount: " << mSharedCloseCount << "\n";
100 result << "\n";
101
Phil Burk39f02dd2017-08-04 09:13:31 -0700102 if (isSharedLocked) {
103 mSharedLock.unlock();
Andy Hung47c5e532017-06-26 18:28:00 -0700104 }
105 return result.str();
106}
107
Phil Burk39f02dd2017-08-04 09:13:31 -0700108
109// Try to find an existing endpoint.
110sp<AAudioServiceEndpoint> AAudioEndpointManager::findExclusiveEndpoint_l(
111 const AAudioStreamConfiguration &configuration) {
112 sp<AAudioServiceEndpoint> endpoint;
Phil Burk55e5eab2018-04-10 15:16:38 -0700113 mExclusiveSearchCount++;
Chih-Hung Hsieh3ef324d2018-12-11 11:48:12 -0800114 for (const auto& ep : mExclusiveStreams) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700115 if (ep->matches(configuration)) {
Phil Burk55e5eab2018-04-10 15:16:38 -0700116 mExclusiveFoundCount++;
Phil Burk39f02dd2017-08-04 09:13:31 -0700117 endpoint = ep;
118 break;
119 }
120 }
121
Phil Burk4e1af9f2018-01-03 15:54:35 -0800122 ALOGV("findExclusiveEndpoint_l(), found %p for device = %d, sessionId = %d",
123 endpoint.get(), configuration.getDeviceId(), configuration.getSessionId());
Phil Burk39f02dd2017-08-04 09:13:31 -0700124 return endpoint;
125}
126
127// Try to find an existing endpoint.
128sp<AAudioServiceEndpointShared> AAudioEndpointManager::findSharedEndpoint_l(
129 const AAudioStreamConfiguration &configuration) {
130 sp<AAudioServiceEndpointShared> endpoint;
Phil Burk55e5eab2018-04-10 15:16:38 -0700131 mSharedSearchCount++;
Chih-Hung Hsieh3ef324d2018-12-11 11:48:12 -0800132 for (const auto& ep : mSharedStreams) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700133 if (ep->matches(configuration)) {
Phil Burk55e5eab2018-04-10 15:16:38 -0700134 mSharedFoundCount++;
Phil Burk39f02dd2017-08-04 09:13:31 -0700135 endpoint = ep;
136 break;
137 }
138 }
139
Phil Burk4e1af9f2018-01-03 15:54:35 -0800140 ALOGV("findSharedEndpoint_l(), found %p for device = %d, sessionId = %d",
141 endpoint.get(), configuration.getDeviceId(), configuration.getSessionId());
Phil Burk39f02dd2017-08-04 09:13:31 -0700142 return endpoint;
143}
144
145sp<AAudioServiceEndpoint> AAudioEndpointManager::openEndpoint(AAudioService &audioService,
Phil Burk15f97c92018-09-04 14:06:27 -0700146 const aaudio::AAudioStreamRequest &request) {
147 if (request.getConstantConfiguration().getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE) {
Phil Burk6e463ce2020-04-13 10:20:20 -0700148 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;
Phil Burk39f02dd2017-08-04 09:13:31 -0700155 } else {
156 return openSharedEndpoint(audioService, request);
157 }
158}
159
160sp<AAudioServiceEndpoint> AAudioEndpointManager::openExclusiveEndpoint(
Phil Burkbbd52862018-04-13 11:37:42 -0700161 AAudioService &aaudioService,
Phil Burk6e463ce2020-04-13 10:20:20 -0700162 const aaudio::AAudioStreamRequest &request,
163 sp<AAudioServiceEndpoint> &endpointToSteal) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700164
165 std::lock_guard<std::mutex> lock(mExclusiveLock);
166
167 const AAudioStreamConfiguration &configuration = request.getConstantConfiguration();
Phil Burk71f35bb2017-04-13 16:05:07 -0700168
169 // Try to find an existing endpoint.
Phil Burk39f02dd2017-08-04 09:13:31 -0700170 sp<AAudioServiceEndpoint> endpoint = findExclusiveEndpoint_l(configuration);
Eric Laurenta17ae742017-06-29 15:43:55 -0700171
Phil Burk39f02dd2017-08-04 09:13:31 -0700172 // If we find an existing one then this one cannot be exclusive.
173 if (endpoint.get() != nullptr) {
Phil Burk6e463ce2020-04-13 10:20:20 -0700174 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++;
Phil Burk836f9df2020-05-29 13:20:28 -0700179 // 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.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700186 pid_t pid = VALUE_OR_FATAL(
187 aidl2legacy_int32_t_pid_t(request.getIdentity().pid));
188 AAudioClientTracker::getInstance().setExclusiveEnabled(pid, false);
Phil Burk836f9df2020-05-29 13:20:28 -0700189 endpointToSteal = endpoint; // return it to caller
Phil Burk6e463ce2020-04-13 10:20:20 -0700190 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700191 return nullptr;
192 } else {
Phil Burkbbd52862018-04-13 11:37:42 -0700193 sp<AAudioServiceEndpointMMAP> endpointMMap = new AAudioServiceEndpointMMAP(aaudioService);
Phil Burk6e463ce2020-04-13 10:20:20 -0700194 ALOGV("%s(), no match so try to open MMAP %p for dev %d",
195 __func__, endpointMMap.get(), configuration.getDeviceId());
Phil Burk39f02dd2017-08-04 09:13:31 -0700196 endpoint = endpointMMap;
Eric Laurenta17ae742017-06-29 15:43:55 -0700197
Phil Burk39f02dd2017-08-04 09:13:31 -0700198 aaudio_result_t result = endpoint->open(request);
199 if (result != AAUDIO_OK) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700200 endpoint.clear();
201 } else {
202 mExclusiveStreams.push_back(endpointMMap);
Phil Burk55e5eab2018-04-10 15:16:38 -0700203 mExclusiveOpenCount++;
Phil Burk11e8d332017-05-24 09:59:02 -0700204 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800205 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700206
Phil Burk39f02dd2017-08-04 09:13:31 -0700207 if (endpoint.get() != nullptr) {
Phil Burk71f35bb2017-04-13 16:05:07 -0700208 // Increment the reference count under this lock.
Phil Burk39f02dd2017-08-04 09:13:31 -0700209 endpoint->setOpenCount(endpoint->getOpenCount() + 1);
Phil Burk6e463ce2020-04-13 10:20:20 -0700210 endpoint->setForSharing(request.isSharingModeMatchRequired());
Phil Burk71f35bb2017-04-13 16:05:07 -0700211 }
Phil Burk6e463ce2020-04-13 10:20:20 -0700212
Phil Burkc0c70e32017-02-09 13:18:38 -0800213 return endpoint;
214}
215
Phil Burk39f02dd2017-08-04 09:13:31 -0700216sp<AAudioServiceEndpoint> AAudioEndpointManager::openSharedEndpoint(
217 AAudioService &aaudioService,
218 const aaudio::AAudioStreamRequest &request) {
Phil Burk71f35bb2017-04-13 16:05:07 -0700219
Phil Burk39f02dd2017-08-04 09:13:31 -0700220 std::lock_guard<std::mutex> lock(mSharedLock);
Phil Burkec89b2e2017-06-20 15:05:06 -0700221
Phil Burk39f02dd2017-08-04 09:13:31 -0700222 const AAudioStreamConfiguration &configuration = request.getConstantConfiguration();
223 aaudio_direction_t direction = configuration.getDirection();
Phil Burk71f35bb2017-04-13 16:05:07 -0700224
Phil Burk39f02dd2017-08-04 09:13:31 -0700225 // 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();
Phil Burk71f35bb2017-04-13 16:05:07 -0700232 switch (direction) {
233 case AAUDIO_DIRECTION_INPUT:
Phil Burk39f02dd2017-08-04 09:13:31 -0700234 endpoint = new AAudioServiceEndpointCapture(aaudioService);
Phil Burk71f35bb2017-04-13 16:05:07 -0700235 break;
236 case AAUDIO_DIRECTION_OUTPUT:
Phil Burk39f02dd2017-08-04 09:13:31 -0700237 endpoint = new AAudioServiceEndpointPlay(aaudioService);
Phil Burk71f35bb2017-04-13 16:05:07 -0700238 break;
Phil Burk11e8d332017-05-24 09:59:02 -0700239 default:
240 break;
Phil Burk71f35bb2017-04-13 16:05:07 -0700241 }
Phil Burk87c9f642017-05-17 07:22:39 -0700242
Phil Burk39f02dd2017-08-04 09:13:31 -0700243 if (endpoint.get() != nullptr) {
244 aaudio_result_t result = endpoint->open(request);
245 if (result != AAUDIO_OK) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700246 endpoint.clear();
247 } else {
248 mSharedStreams.push_back(endpoint);
Phil Burk55e5eab2018-04-10 15:16:38 -0700249 mSharedOpenCount++;
Phil Burk39f02dd2017-08-04 09:13:31 -0700250 }
251 }
Phil Burk55e5eab2018-04-10 15:16:38 -0700252 ALOGV("%s(), created endpoint %p, requested device = %d, dir = %d",
Phil Burk19e990e2018-03-22 13:59:34 -0700253 __func__, endpoint.get(), configuration.getDeviceId(), (int)direction);
Phil Burk39f02dd2017-08-04 09:13:31 -0700254 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
264void 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
272void 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);
Phil Burk39f02dd2017-08-04 09:13:31 -0700281
Phil Burkfbf031e2017-10-12 15:58:31 -0700282 // If no longer in use then actually close it.
Phil Burk39f02dd2017-08-04 09:13:31 -0700283 if (newRefCount <= 0) {
284 mExclusiveStreams.erase(
285 std::remove(mExclusiveStreams.begin(), mExclusiveStreams.end(), serviceEndpoint),
286 mExclusiveStreams.end());
287
Phil Burk71f35bb2017-04-13 16:05:07 -0700288 serviceEndpoint->close();
Phil Burk55e5eab2018-04-10 15:16:38 -0700289 mExclusiveCloseCount++;
290 ALOGV("%s() %p for device %d",
Phil Burk19e990e2018-03-22 13:59:34 -0700291 __func__, serviceEndpoint.get(), serviceEndpoint->getDeviceId());
Phil Burk39f02dd2017-08-04 09:13:31 -0700292 }
293}
294
295void 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);
Phil Burk39f02dd2017-08-04 09:13:31 -0700304
Phil Burkfbf031e2017-10-12 15:58:31 -0700305 // If no longer in use then actually close it.
Phil Burk39f02dd2017-08-04 09:13:31 -0700306 if (newRefCount <= 0) {
307 mSharedStreams.erase(
308 std::remove(mSharedStreams.begin(), mSharedStreams.end(), serviceEndpoint),
309 mSharedStreams.end());
310
311 serviceEndpoint->close();
Phil Burkdd582922020-10-15 20:29:51 +0000312
Phil Burk55e5eab2018-04-10 15:16:38 -0700313 mSharedCloseCount++;
Phil Burk8b4e05e2019-12-17 12:12:09 -0800314 ALOGV("%s(%p) closed for device %d",
Phil Burk19e990e2018-03-22 13:59:34 -0700315 __func__, serviceEndpoint.get(), serviceEndpoint->getDeviceId());
Phil Burk71f35bb2017-04-13 16:05:07 -0700316 }
317}