services/surfaceflinger/TransactionCompletedThread.cpp

/*
 * 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;
}

void TransactionCompletedThread::clearAllPending() {
    std::lock_guard lock(mMutex);
    if (!mRunning) {
        return;
    }
    mPendingTransactions.clear();
    mConditionVariable.notify_all();
}

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