services/surfaceflinger/TransactionCompletedThread.cpp - android_frameworks_native - Gitiles

 /*
  * 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.
  */

 //#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) {
     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) {
         transactionStats->surfaceStats.emplace_back(surfaceControl, handle->acquireTime,
                                                     handle->previousReleaseFence,
                                                     handle->transformHint);
     }
     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);
                     listener->unlinkToDeath(mDeathRecipient);
                     if (transactionStatsDeque.empty()) {
                         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
	/*
	* 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.
	*/

	//#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) {
	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) {
	transactionStats->surfaceStats.emplace_back(surfaceControl, handle->acquireTime,
	handle->previousReleaseFence,
	handle->transformHint);
	}
	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);
	listener->unlinkToDeath(mDeathRecipient);
	if (transactionStatsDeque.empty()) {
	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