You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pulsar.apache.org by lh...@apache.org on 2026/09/14 14:18:17 UTC

(pulsar) 15/17: [fix] Fix cursor deadlock when skipping non-recoverable entries during mark-delete persistence (#26570)

This is an automated email from the ASF dual-hosted git repository.

lhotari pushed a commit to branch branch-4.0
in repository https://gitbox.apache.org/repos/asf/pulsar.git

commit f6a927ee428419880f752d0ad5f93c36b7a8156c
Author: void-ptr974 <vo...@protonmail.com>
AuthorDate: Mon Sep 14 08:43:11 2026 +0800

    [fix] Fix cursor deadlock when skipping non-recoverable entries during mark-delete persistence (#26570)
    
    (cherry picked from commit f613b16fe4a4507cc61f7d26c552e42b6da7eef2)
---
 .../bookkeeper/mledger/impl/ManagedCursorImpl.java | 37 +++++++++------------
 .../bookkeeper/mledger/impl/ManagedCursorTest.java | 38 ++++++++++++++++++++++
 2 files changed, 53 insertions(+), 22 deletions(-)

diff --git a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
index 450d7fe385c8..7a08f6bdbc57 100644
--- a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
+++ b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
@@ -3157,7 +3157,7 @@ public class ManagedCursorImpl implements ManagedCursor {
      * Manually acknowledge all entries from startPosition to endPosition.
      * - Since this is an uncommon event, we focus on maintainability. So we do not modify
      *   {@link #individualDeletedMessages} and {@link #batchDeletedIndexes}, but call
-     *   {@link #asyncDelete(Position, AsyncCallbacks.DeleteCallback, Object)}.
+     *   {@link #asyncDelete(Iterable, AsyncCallbacks.DeleteCallback, Object)}.
      * - This method is valid regardless of the consumer ACK type.
      * - If there is a consumer ack request after this event, it will also work.
      */
@@ -3174,31 +3174,24 @@ public class ManagedCursorImpl implements ManagedCursor {
             return;
         }
 
-        lock.writeLock().lock();
         log.warn("[{}] [{}] Since these entry for ledger [{}] is lost and the autoSkipNonRecoverableData is true, "
                         + "these entries [{}:{}) will be auto acknowledge in subscription",
                 ledger.getName(), name, ledgerId, startEntryId, endEntryId);
-        try {
-            for (long i = startEntryId; i < endEntryId; i++) {
-                if (!individualDeletedMessages.contains(ledgerId, i)) {
-                    asyncDelete(PositionFactory.create(ledgerId, i), new AsyncCallbacks.DeleteCallback() {
-                        @Override
-                        public void deleteComplete(Object ctx) {
-                            // ignore.
-                        }
+        asyncDelete(() -> LongStream.range(startEntryId, endEntryId)
+                        .mapToObj(i -> PositionFactory.create(ledgerId, i)).iterator(),
+                new AsyncCallbacks.DeleteCallback() {
+                    @Override
+                    public void deleteComplete(Object ctx) {
+                        // ignore.
+                    }
 
-                        @Override
-                        public void deleteFailed(ManagedLedgerException ex, Object ctx) {
-                            // The method internalMarkDelete already handled the failure operation. We only need to
-                            // make sure the memory state is updated.
-                            // If the broker crashed, the non-recoverable ledger will be detected again.
-                        }
-                    }, null);
-                }
-            }
-        } finally {
-            lock.writeLock().unlock();
-        }
+                    @Override
+                    public void deleteFailed(ManagedLedgerException ex, Object ctx) {
+                        // The method internalMarkDelete already handled the failure operation. We only need to
+                        // make sure the memory state is updated.
+                        // If the broker crashed, the non-recoverable ledger will be detected again.
+                    }
+                }, null);
     }
 
     // //////////////////////////////////////////////////
diff --git a/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/ManagedCursorTest.java b/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/ManagedCursorTest.java
index 6bdfb9054f0a..e03f863151a7 100644
--- a/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/ManagedCursorTest.java
+++ b/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/ManagedCursorTest.java
@@ -5627,6 +5627,44 @@ public class ManagedCursorTest extends MockedBookKeeperTestCase {
         ledger.close();
     }
 
+    @Test(timeOut = 20000)
+    public void testSkipNonRecoverableEntriesDoesNotHoldCursorLockWhilePersisting() throws Exception {
+        ManagedLedger ledger = factory.open("testSkipNonRecoverableEntriesDoesNotHoldCursorLockWhilePersisting",
+                new ManagedLedgerConfig());
+        ManagedCursorImpl cursor = (ManagedCursorImpl) ledger.openCursor("my-cursor");
+        Position firstPosition = ledger.addEntry("entry-0".getBytes(Encoding));
+        Position nextPosition = ledger.addEntry("entry-1".getBytes(Encoding));
+
+        AtomicBoolean readLockAvailable = new AtomicBoolean();
+        Thread skipThread = new Thread(
+                () -> cursor.skipNonRecoverableEntries(firstPosition, nextPosition),
+                "skip-non-recoverable-entries");
+        synchronized (cursor.pendingMarkDeleteOps) {
+            skipThread.start();
+            Awaitility.await().atMost(Duration.ofSeconds(5))
+                    .until(() -> skipThread.getState() == Thread.State.BLOCKED
+                            && Arrays.stream(skipThread.getStackTrace())
+                                    .anyMatch(frame -> frame.getMethodName().equals("internalAsyncMarkDelete")));
+            if (cursor.lock.readLock().tryLock()) {
+                try {
+                    readLockAvailable.set(true);
+                } finally {
+                    cursor.lock.readLock().unlock();
+                }
+            }
+        }
+
+        skipThread.join(TimeUnit.SECONDS.toMillis(5));
+        assertFalse(skipThread.isAlive(), "skip thread did not finish");
+        Awaitility.await().atMost(Duration.ofSeconds(5))
+                .until(() -> cursor.getStats().getPersistLedgerSucceed() > 0);
+        assertTrue(readLockAvailable.get(),
+                "skipNonRecoverableEntries must not hold the cursor lock while waiting to persist mark-delete");
+
+        cursor.close();
+        ledger.close();
+    }
+
     @Test
     public void testRecoverCursorWithTerminateManagedLedger() throws Exception {
         String mlName = "my_test_ledger";