fix: log and remove a deadlock when logging a diff message using the …

…blockchain

Signed-off-by: HashEngineering <[email protected]>

core/src/main/java/org/bitcoinj/evolution/AbstractQuorumState.java

@@ -47,6 +47,7 @@
 import org.bitcoinj.quorums.SimplifiedQuorumList;
 import org.bitcoinj.store.BlockStoreException;
 import org.bitcoinj.utils.ContextPropagatingThreadFactory;
+import org.bitcoinj.utils.DebugReentrantLock;
 import org.bitcoinj.utils.Threading;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -89,7 +90,8 @@ public abstract class AbstractQuorumState<Request extends AbstractQuorumRequest,
     public static final int MIN_CACHE_SIZE = 1;
 
     private static final Logger log = LoggerFactory.getLogger(AbstractQuorumState.class);
-    protected final ReentrantLock lock = Threading.lock("AbstractQuorumState");
+    // TODO: Revert to ReentrantLock with 21.0.1
+    protected final DebugReentrantLock lock = Threading.debugLock("AbstractQuorumState");
 
     Context context;
     DualBlockChain blockChain;
@@ -222,6 +224,7 @@ public abstract void processDiff(@Nullable Peer peer, DiffMessage difference,
     public abstract void requestUpdate(Peer peer, StoredBlock block);
 
     public void retryLastUpdate(Peer peer) {
+        log.info("retryLastUpdate: {}", lastRequest.getRequestMessage());
         if (peer != null) {
             peer.sendMessage(lastRequest.getRequestMessage());
         } else {
@@ -409,7 +412,8 @@ boolean requestNextMNListDiff() {
                     log.info("sending {} from {} to {}; \n  From {}\n To {}", lastRequest.request.getClass().getSimpleName(),
                             getMasternodeListAtTip().getHeight(), nextBlock.getHeight(), getMasternodeListAtTip().getBlockHash(), nextBlock.getHeader().getHash());
                     requestUpdate(downloadPeer, nextBlock);
-                    log.info("message = {}", lastRequest.getRequestMessage().toString(blockChain));
+                    // This was causing a dead lock when using toString(DualBlockchain).  Use toString() instead.
+                    log.info("message = {}", lastRequest.getRequestMessage());
                     waitingForMNListDiff = true;
                     return true;
                 } else {
@@ -745,7 +749,7 @@ private void retryLastRequest(Peer peer, Exception e) {
             try {
                 if (isLocked) {
                     downloadPeer = context.peerGroup.getDownloadPeer();
-                    log.info("{}: lock acquired, obtaining downloadPeer from peerGroup: {}",
+                    log.info("{}: peergroup lock acquired, obtaining downloadPeer from peerGroup: {}",
                             Thread.currentThread().getName(), downloadPeer);
                     if (downloadPeer == null) {
                         chooseRandomDownloadPeer();

core/src/main/java/org/bitcoinj/evolution/QuorumState.java

@@ -265,6 +265,27 @@ public void processDiff(@Nullable Peer peer, SimplifiedMasternodeListDiff mnlist
         mnlistdiff.dump(mnList.getHeight(), newHeight);
         lastRequest.setReceived();
 
+        // TODO: Remove with v21.0.1
+        if (lock.isLocked()) {
+            log.warn("the lock is held. holdCount {}, queue length {}, held by this thread {}", lock.getHoldCount(), lock.getQueueLength(), lock.isHeldByCurrentThread());
+            log.warn("the current thread is {} with stack trace:", Thread.currentThread().getName());
+            StackTraceElement [] trace = lock.getOwner().getStackTrace();
+            for (StackTraceElement e : trace) {
+                log.info("  {}", e);
+            }
+            log.warn("the lock is held by {} with stack trace:", lock.getOwner());
+            trace = lock.getOwner().getStackTrace();
+            for (StackTraceElement e : trace) {
+                log.info("  {}", e);
+            }
+            for (Thread thread : lock.getQueuedThreads()) {
+                log.info("queued thread: {}\n stack trace:", thread.getName());
+                trace = thread.getStackTrace();
+                for (StackTraceElement e : trace) {
+                    log.info("  {}", e);
+                }
+            }
+        }
         lock.lock();
         try {
             log.info("lock acquired when processing mnlistdiff");

core/src/main/java/org/bitcoinj/utils/DebugReentrantLock.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2022 Dash Core Group
+ *
+ * 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.
+ */
+
+package org.bitcoinj.utils;
+
+import java.util.Collection;
+import java.util.concurrent.locks.ReentrantLock;
+
+/** a subclass of ReentrantLock that provides access to the owner thread
+ *  and queued threads.
+ */
+
+public class DebugReentrantLock extends ReentrantLock {
+
+    public DebugReentrantLock(String name) {
+        super(true);
+    }
+
+    public Collection<Thread> getQueuedThreads() {
+        return super.getQueuedThreads();
+    }
+
+    public Thread getOwner() {
+        return super.getOwner();
+    }
+}

core/src/main/java/org/bitcoinj/utils/Threading.java

@@ -162,6 +162,11 @@ public static ReentrantLock lock(String name) {
             return factory.newReentrantLock(name);
     }
 
+    /** creates a lock that gives access to the owner thread **/
+    public static DebugReentrantLock debugLock(String name) {
+        return new DebugReentrantLock(name);
+    }
+
     public static void setUseDefaultAndroidPolicy(boolean use) {
         useDefaultAndroidPolicy = use;
     }