BBQ: Clean up acquire states on BQ disconnect

When the producer disconnects, all buffers in the queue will
be freed. So clean up the bbq acquire state and handle any
pending release callbacks. If we do get a release callback for
a pending buffer for a disconnected queue, we cannot
release the buffer back to the queue. So track these
separately and drop the release callbacks as they come.

Transaction callbacks are still expected to come in the
order they were submitted regardless of buffer queue
state. So we can continue to handle the pending
transactions and transaction complete callbacks. When
the queue is reconnected, the queue will increment the
framenumbers starting from the last queued framenumber.

Bug: 201482894
Test: atest BLASTBufferQueueTest
Change-Id: I110530c2135804fc7b9545602dd6430014cad85c

1 files changed, 66 insertions, 7 deletions

diff --git a/libs/gui/BLASTBufferQueue.cpp b/libs/gui/BLASTBufferQueue.cpp
index 9080822f92..9cb7c88956 100644
--- a/libs/gui/BLASTBufferQueue.cpp
+++ b/libs/gui/BLASTBufferQueue.cpp
@@ -58,13 +58,22 @@ namespace android {
     ALOGE("[%s](f:%u,a:%u) " x, mName.c_str(), mNumFrameAvailable, mNumAcquired, ##__VA_ARGS__)
 
 void BLASTBufferItemConsumer::onDisconnect() {
-    Mutex::Autolock lock(mMutex);
-    mPreviouslyConnected = mCurrentlyConnected;
-    mCurrentlyConnected = false;
-    if (mPreviouslyConnected) {
-        mDisconnectEvents.push(mCurrentFrameNumber);
+    {
+        Mutex::Autolock lock(mMutex);
+        mPreviouslyConnected = mCurrentlyConnected;
+        mCurrentlyConnected = false;
+        if (mPreviouslyConnected) {
+            mDisconnectEvents.push(mCurrentFrameNumber);
+        }
+        mFrameEventHistory.onDisconnect();
+    }
+
+    {
+        std::scoped_lock lock(mBufferQueueMutex);
+        if (mBLASTBufferQueue != nullptr) {
+            mBLASTBufferQueue->onProducerDisconnect();
+        }
     }
-    mFrameEventHistory.onDisconnect();
 }
 
 void BLASTBufferItemConsumer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps,
@@ -202,7 +211,11 @@ void BLASTBufferQueue::update(const sp<SurfaceControl>& surface, uint32_t width,
     }
 
     SurfaceComposerClient::Transaction t;
-    const bool setBackpressureFlag = !SurfaceControl::isSameSurface(mSurfaceControl, surface);
+    bool setBackpressureFlag = false;
+    if (!SurfaceControl::isSameSurface(mSurfaceControl, surface)) {
+        mSurfaceControlSwapCount++;
+        setBackpressureFlag = true;
+    }
     bool applyTransaction = false;
 
     // Always update the native object even though they might have the same layer handle, so we can
@@ -388,6 +401,19 @@ void BLASTBufferQueue::releaseBufferCallback(
     std::unique_lock _lock{mMutex};
     BQA_LOGV("releaseBufferCallback %s", id.to_string().c_str());
 
+    const auto it = mFreedBuffers.find(id);
+    if (it != mFreedBuffers.end()) {
+        mFreedBuffers.erase(it);
+        BQA_LOGV("releaseBufferCallback ignoring freed buffer %s", id.to_string().c_str());
+        return;
+    }
+
+    if (mFreedBuffers.size() != 0 && mLogMissingReleaseCallback) {
+        BQA_LOGD("Unexpected out of order buffer release. mFreedBuffer count=%d",
+                 static_cast<uint32_t>(mFreedBuffers.size()));
+        mLogMissingReleaseCallback = false;
+    }
+
     // Calculate how many buffers we need to hold before we release them back
     // to the buffer queue. This will prevent higher latency when we are running
     // on a lower refresh rate than the max supported. We only do that for EGL
@@ -593,6 +619,12 @@ void BLASTBufferQueue::onFrameAvailable(const BufferItem& item) {
     ATRACE_CALL();
     std::unique_lock _lock{mMutex};
 
+    if ((mSurfaceControlSwapCount > mProducerDisconnectCount) && mLogScSwap) {
+        BQA_LOGD("Expected producer disconnect sc swap count=%d bq disconnect count=%d",
+                 mSurfaceControlSwapCount, mProducerDisconnectCount);
+        mLogScSwap = false;
+    }
+
     const bool nextTransactionSet = mNextTransaction != nullptr;
     BQA_LOGV("onFrameAvailable-start nextTransactionSet=%s", boolToString(nextTransactionSet));
     if (nextTransactionSet) {
@@ -959,4 +991,31 @@ uint64_t BLASTBufferQueue::getLastAcquiredFrameNum() {
     return mLastAcquiredFrameNumber;
 }
 
+// When the producer disconnects, all buffers in the queue will be freed. So clean up the bbq
+// acquire state and handle any pending release callbacks. If we do get a release callback for a
+// pending buffer for a disconnected queue, we cannot release the buffer back to the queue. So track
+// these separately and drop the release callbacks as they come.
+
+// Transaction callbacks are still expected to come in the order they were submitted regardless of
+// buffer queue state. So we can continue to handles the pending transactions and transaction
+// complete callbacks. When the queue is reconnected, the queue will increment the framenumbers
+// starting from the last queued framenumber.
+void BLASTBufferQueue::onProducerDisconnect() {
+    BQA_LOGV("onProducerDisconnect");
+    std::scoped_lock _lock{mMutex};
+    // reset counts since the queue has been disconnected and all buffers have been freed.
+    mNumFrameAvailable = 0;
+    mNumAcquired = 0;
+
+    // Track submitted buffers in a different container so we can handle any pending release buffer
+    // callbacks without affecting the BBQ acquire state.
+    mFreedBuffers.insert(mSubmitted.begin(), mSubmitted.end());
+    mSubmitted.clear();
+    mPendingRelease.clear();
+    mProducerDisconnectCount++;
+    mCallbackCV.notify_all();
+    mLogMissingReleaseCallback = true;
+    mLogScSwap = true;
+}
+
 } // namespace android