diff options
Diffstat (limited to 'services/surfaceflinger/TransactionCompletedThread.cpp')
| -rw-r--r-- | services/surfaceflinger/TransactionCompletedThread.cpp | 371 |
1 files changed, 0 insertions, 371 deletions
diff --git a/services/surfaceflinger/TransactionCompletedThread.cpp b/services/surfaceflinger/TransactionCompletedThread.cpp deleted file mode 100644 index ca244934e4..0000000000 --- a/services/surfaceflinger/TransactionCompletedThread.cpp +++ /dev/null @@ -1,371 +0,0 @@ -/* - * Copyright 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// TODO(b/129481165): remove the #pragma below and fix conversion issues -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wconversion" - -//#define LOG_NDEBUG 0 -#undef LOG_TAG -#define LOG_TAG "TransactionCompletedThread" -#define ATRACE_TAG ATRACE_TAG_GRAPHICS - -#include "TransactionCompletedThread.h" - -#include <cinttypes> - -#include <binder/IInterface.h> -#include <utils/RefBase.h> - -namespace android { - -// Returns 0 if they are equal -// <0 if the first id that doesn't match is lower in c2 or all ids match but c2 is shorter -// >0 if the first id that doesn't match is greater in c2 or all ids match but c2 is longer -// -// See CallbackIdsHash for a explaniation of why this works -static int compareCallbackIds(const std::vector<CallbackId>& c1, - const std::vector<CallbackId>& c2) { - if (c1.empty()) { - return !c2.empty(); - } - return c1.front() - c2.front(); -} - -TransactionCompletedThread::~TransactionCompletedThread() { - std::lock_guard lockThread(mThreadMutex); - - { - std::lock_guard lock(mMutex); - mKeepRunning = false; - mConditionVariable.notify_all(); - } - - if (mThread.joinable()) { - mThread.join(); - } - - { - std::lock_guard lock(mMutex); - for (const auto& [listener, transactionStats] : mCompletedTransactions) { - listener->unlinkToDeath(mDeathRecipient); - } - } -} - -void TransactionCompletedThread::run() { - std::lock_guard lock(mMutex); - if (mRunning || !mKeepRunning) { - return; - } - mDeathRecipient = new ThreadDeathRecipient(); - mRunning = true; - - std::lock_guard lockThread(mThreadMutex); - mThread = std::thread(&TransactionCompletedThread::threadMain, this); -} - -status_t TransactionCompletedThread::startRegistration(const ListenerCallbacks& listenerCallbacks) { - // begin running if not already running - run(); - std::lock_guard lock(mMutex); - if (!mRunning) { - ALOGE("cannot add callback because the callback thread isn't running"); - return BAD_VALUE; - } - - auto [itr, inserted] = mRegisteringTransactions.insert(listenerCallbacks); - auto& [listener, callbackIds] = listenerCallbacks; - - if (inserted) { - if (mCompletedTransactions.count(listener) == 0) { - status_t err = listener->linkToDeath(mDeathRecipient); - if (err != NO_ERROR) { - ALOGE("cannot add callback because linkToDeath failed, err: %d", err); - return err; - } - } - auto& transactionStatsDeque = mCompletedTransactions[listener]; - transactionStatsDeque.emplace_back(callbackIds); - } - - return NO_ERROR; -} - -status_t TransactionCompletedThread::endRegistration(const ListenerCallbacks& listenerCallbacks) { - std::lock_guard lock(mMutex); - if (!mRunning) { - ALOGE("cannot add callback because the callback thread isn't running"); - return BAD_VALUE; - } - - auto itr = mRegisteringTransactions.find(listenerCallbacks); - if (itr == mRegisteringTransactions.end()) { - ALOGE("cannot end a registration that does not exist"); - return BAD_VALUE; - } - - mRegisteringTransactions.erase(itr); - - return NO_ERROR; -} - -bool TransactionCompletedThread::isRegisteringTransaction( - const sp<IBinder>& transactionListener, const std::vector<CallbackId>& callbackIds) { - ListenerCallbacks listenerCallbacks(transactionListener, callbackIds); - - auto itr = mRegisteringTransactions.find(listenerCallbacks); - return itr != mRegisteringTransactions.end(); -} - -status_t TransactionCompletedThread::registerPendingCallbackHandle( - const sp<CallbackHandle>& handle) { - std::lock_guard lock(mMutex); - if (!mRunning) { - ALOGE("cannot register callback handle because the callback thread isn't running"); - return BAD_VALUE; - } - - // If we can't find the transaction stats something has gone wrong. The client should call - // startRegistration before trying to register a pending callback handle. - TransactionStats* transactionStats; - status_t err = findTransactionStats(handle->listener, handle->callbackIds, &transactionStats); - if (err != NO_ERROR) { - ALOGE("cannot find transaction stats"); - return err; - } - - mPendingTransactions[handle->listener][handle->callbackIds]++; - return NO_ERROR; -} - -status_t TransactionCompletedThread::finalizePendingCallbackHandles( - const std::deque<sp<CallbackHandle>>& handles) { - if (handles.empty()) { - return NO_ERROR; - } - std::lock_guard lock(mMutex); - if (!mRunning) { - ALOGE("cannot add presented callback handle because the callback thread isn't running"); - return BAD_VALUE; - } - - for (const auto& handle : handles) { - auto listener = mPendingTransactions.find(handle->listener); - if (listener != mPendingTransactions.end()) { - auto& pendingCallbacks = listener->second; - auto pendingCallback = pendingCallbacks.find(handle->callbackIds); - - if (pendingCallback != pendingCallbacks.end()) { - auto& pendingCount = pendingCallback->second; - - // Decrease the pending count for this listener - if (--pendingCount == 0) { - pendingCallbacks.erase(pendingCallback); - } - } else { - ALOGW("there are more latched callbacks than there were registered callbacks"); - } - if (listener->second.size() == 0) { - mPendingTransactions.erase(listener); - } - } else { - ALOGW("cannot find listener in mPendingTransactions"); - } - - status_t err = addCallbackHandle(handle); - if (err != NO_ERROR) { - ALOGE("could not add callback handle"); - return err; - } - } - - return NO_ERROR; -} - -status_t TransactionCompletedThread::registerUnpresentedCallbackHandle( - const sp<CallbackHandle>& handle) { - std::lock_guard lock(mMutex); - if (!mRunning) { - ALOGE("cannot add unpresented callback handle because the callback thread isn't running"); - return BAD_VALUE; - } - - return addCallbackHandle(handle); -} - -status_t TransactionCompletedThread::findTransactionStats( - const sp<IBinder>& listener, const std::vector<CallbackId>& callbackIds, - TransactionStats** outTransactionStats) { - auto& transactionStatsDeque = mCompletedTransactions[listener]; - - // Search back to front because the most recent transactions are at the back of the deque - auto itr = transactionStatsDeque.rbegin(); - for (; itr != transactionStatsDeque.rend(); itr++) { - if (compareCallbackIds(itr->callbackIds, callbackIds) == 0) { - *outTransactionStats = &(*itr); - return NO_ERROR; - } - } - - ALOGE("could not find transaction stats"); - return BAD_VALUE; -} - -status_t TransactionCompletedThread::addCallbackHandle(const sp<CallbackHandle>& handle) { - // If we can't find the transaction stats something has gone wrong. The client should call - // startRegistration before trying to add a callback handle. - TransactionStats* transactionStats; - status_t err = findTransactionStats(handle->listener, handle->callbackIds, &transactionStats); - if (err != NO_ERROR) { - return err; - } - - transactionStats->latchTime = handle->latchTime; - // If the layer has already been destroyed, don't add the SurfaceControl to the callback. - // The client side keeps a sp<> to the SurfaceControl so if the SurfaceControl has been - // destroyed the client side is dead and there won't be anyone to send the callback to. - sp<IBinder> surfaceControl = handle->surfaceControl.promote(); - if (surfaceControl) { - FrameEventHistoryStats eventStats(handle->frameNumber, - handle->gpuCompositionDoneFence->getSnapshot().fence, - handle->compositorTiming, handle->refreshStartTime, - handle->dequeueReadyTime); - transactionStats->surfaceStats.emplace_back(surfaceControl, handle->acquireTime, - handle->previousReleaseFence, - handle->transformHint, eventStats); - } - return NO_ERROR; -} - -void TransactionCompletedThread::addPresentFence(const sp<Fence>& presentFence) { - std::lock_guard<std::mutex> lock(mMutex); - mPresentFence = presentFence; -} - -void TransactionCompletedThread::sendCallbacks() { - std::lock_guard lock(mMutex); - if (mRunning) { - mConditionVariable.notify_all(); - } -} - -void TransactionCompletedThread::threadMain() { - std::lock_guard lock(mMutex); - - while (mKeepRunning) { - mConditionVariable.wait(mMutex); - std::vector<ListenerStats> completedListenerStats; - - // For each listener - auto completedTransactionsItr = mCompletedTransactions.begin(); - while (completedTransactionsItr != mCompletedTransactions.end()) { - auto& [listener, transactionStatsDeque] = *completedTransactionsItr; - ListenerStats listenerStats; - listenerStats.listener = listener; - - // For each transaction - auto transactionStatsItr = transactionStatsDeque.begin(); - while (transactionStatsItr != transactionStatsDeque.end()) { - auto& transactionStats = *transactionStatsItr; - - // If this transaction is still registering, it is not safe to send a callback - // because there could be surface controls that haven't been added to - // transaction stats or mPendingTransactions. - if (isRegisteringTransaction(listener, transactionStats.callbackIds)) { - break; - } - - // If we are still waiting on the callback handles for this transaction, stop - // here because all transaction callbacks for the same listener must come in order - auto pendingTransactions = mPendingTransactions.find(listener); - if (pendingTransactions != mPendingTransactions.end() && - pendingTransactions->second.count(transactionStats.callbackIds) != 0) { - break; - } - - // If the transaction has been latched - if (transactionStats.latchTime >= 0) { - if (!mPresentFence) { - break; - } - transactionStats.presentFence = mPresentFence; - } - - // Remove the transaction from completed to the callback - listenerStats.transactionStats.push_back(std::move(transactionStats)); - transactionStatsItr = transactionStatsDeque.erase(transactionStatsItr); - } - // If the listener has completed transactions - if (!listenerStats.transactionStats.empty()) { - // If the listener is still alive - if (listener->isBinderAlive()) { - // Send callback. The listener stored in listenerStats - // comes from the cross-process setTransactionState call to - // SF. This MUST be an ITransactionCompletedListener. We - // keep it as an IBinder due to consistency reasons: if we - // interface_cast at the IPC boundary when reading a Parcel, - // we get pointers that compare unequal in the SF process. - interface_cast<ITransactionCompletedListener>(listenerStats.listener) - ->onTransactionCompleted(listenerStats); - if (transactionStatsDeque.empty()) { - listener->unlinkToDeath(mDeathRecipient); - completedTransactionsItr = - mCompletedTransactions.erase(completedTransactionsItr); - } else { - completedTransactionsItr++; - } - } else { - completedTransactionsItr = - mCompletedTransactions.erase(completedTransactionsItr); - } - } else { - completedTransactionsItr++; - } - - completedListenerStats.push_back(std::move(listenerStats)); - } - - if (mPresentFence) { - mPresentFence.clear(); - } - - // If everyone else has dropped their reference to a layer and its listener is dead, - // we are about to cause the layer to be deleted. If this happens at the wrong time and - // we are holding mMutex, we will cause a deadlock. - // - // The deadlock happens because this thread is holding on to mMutex and when we delete - // the layer, it grabs SF's mStateLock. A different SF binder thread grabs mStateLock, - // then call's TransactionCompletedThread::run() which tries to grab mMutex. - // - // To avoid this deadlock, we need to unlock mMutex when dropping our last reference to - // to the layer. - mMutex.unlock(); - completedListenerStats.clear(); - mMutex.lock(); - } -} - -// ----------------------------------------------------------------------- - -CallbackHandle::CallbackHandle(const sp<IBinder>& transactionListener, - const std::vector<CallbackId>& ids, const sp<IBinder>& sc) - : listener(transactionListener), callbackIds(ids), surfaceControl(sc) {} - -} // namespace android - -// TODO(b/129481165): remove the #pragma below and fix conversion issues -#pragma clang diagnostic pop // ignored "-Wconversion" |