Perf/ibd speedups (#277)

* Silence per-block LogPrintf calls on sync hot path

Four unconditional LogPrintf calls were firing on every PON header and
every block connect/disconnect during IBD, dominating debug.log volume
and measurably slowing sync. Convert them to LogPrint with a category
so they only fire under -debug=pon or -debug=fluxnode.

- src/pon/pon.cpp: PON difficulty adjustment traces (2x per PON header)
- src/fluxnode/fluxnode.cpp: FluxnodeCache::LogDebugData, plus an
  early-return so the per-block string concatenation over
  mapStartTxTracker / mapStartTxDOSTracker is skipped when the fluxnode
  category isn't active.

* Adopt Bitcoin Core's dbcache split to favor the in-memory UTXO set

Fluxd used to allocate 3/4 of -dbcache to the block tree DB whenever
-insightexplorer was enabled, which left only ~76 MiB of in-memory UTXO
cache at the default -dbcache=450. During IBD this caused frequent
full-cache flushes (multi-second stalls every few thousand blocks).

Switch to Bitcoin Core's allocation: block tree DB gets 1/8 of the
total, capped at 2 MiB without txindex or 1024 MiB with txindex /
insightexplorer. Coin DB cache is capped at 8 MiB. The remainder goes
to the in-memory UTXO set.

At -dbcache=450 with all indexes on, the UTXO cache grows from ~76 MiB
to ~386 MiB; at -dbcache=2000 it reaches ~1.7 GiB, which eliminates
most flush stalls during IBD.

* Implement BIP 152 low-bandwidth mode (peer-initiated compact blocks)

PR #266 shipped high-bandwidth compact block relay (unsolicited
cmpctblock messages to up to three peers). Low-bandwidth mode lets a
peer request a compact block on demand via getdata, saving bandwidth
for edge peers (light clients, metered connections) that haven't opted
into high-bandwidth announcements.

Adds MSG_CMPCT_BLOCK as a new inv type, handled by ProcessGetData.
When a block is within MAX_CMPCTBLOCK_DEPTH (5 blocks) of the tip, the
server responds with a cmpctblock message; older blocks fall back to
sending a full block because the requester is unlikely to have the
mempool state needed to reconstruct it.

Type number 11 is used instead of the BIP 152 canonical value of 4
because type 4 is already allocated to "spork" on the Flux network.
IsFluxnodeType() is tightened to an explicit [4, 10] range so the new
type isn't misrouted.

* Early-return CheckForExpired/UndoExpiredStartTx when tracker is empty

CheckForExpiredStartTx and CheckForUndoExpiredStartTx are called on
every ConnectBlock/DisconnectBlock. For most of chain history the
relevant trackers (mapStartTxTracker, mapStartTxDOSTracker) are empty,
so the iterate-and-conditionally-copy loops do no work but still pay
for the cs_main-adjacent lock acquisition and the subsequent log
lines. Skip the body entirely when there is nothing to do.

The emptiness check runs under the lock, so it races correctly with
concurrent modifications.

* Cap debug.log size and enforce it at runtime

Previously ShrinkDebugFile() only ran at startup and only when -debug
was not set (the -shrinkdebugfile default was !fDebug). With debug=1
the log could grow without bound.

Changes:
- -maxdebugfilesize upper cap is now 10 GiB when -debug is enabled
  (so a long debug session has room to breathe) and 2 GiB otherwise.
  The 500 MB default is unchanged.
- Default -shrinkdebugfile to true so the cap is enforced even when
  debug logging is on.
- Make ShrinkDebugFile() safe to call at runtime by writing the kept
  tail to a temp file and atomically renaming; concurrent LogPrintStr
  writes land on the unlinked inode and fReopenDebugLog is set so the
  next log write reopens on the new file.
- Schedule ShrinkDebugFile() every 5 minutes so a long-running node
  with heavy debug output doesn't fill the disk between restarts.

* Harden BIP 152 compact block handling

Two fixes identified by an audit of fluxd's BIP 152 implementation
against Bitcoin Core:

1. Clean up per-peer compact-block in-flight state on disconnect.
   FinalizeNode previously iterated mapPartialBlocks but did nothing
   (a TODO comment acknowledged the gap). Peer-keyed cleanup is
   actually available via listCompactBlocksInFlight, which stores
   {NodeId, block hash} markers. Walk it, drop entries for the
   disconnecting peer, and drop the corresponding mapPartialBlocks /
   mapPartialBlocksTime entries only when no other peer is still
   working on the same block. Prevents a slow memory leak when peers
   churn mid-reconstruction.

2. Unify the compact block depth constant as MAX_CMPCTBLOCK_DEPTH,
   shared by the cmpctblock reception check and the new low-bandwidth
   MSG_CMPCT_BLOCK getdata response. Value is 100, sized to roughly
   Bitcoin Core's ~50-minute wall-clock window at fluxd's 30-second
   PON block spacing (Bitcoin uses 5 at 10-minute blocks). The prior
   reception value of 10 covered only ~5 minutes on PON, which is too
   narrow for typical mempool turnover.

Author: blondfrogs

src/fluxnode/fluxnode.cpp

@@ -479,6 +479,9 @@ bool FluxnodeCache::CheckNewStartTx(const COutPoint& out, int nHeight, bool fFro
 void FluxnodeCache::CheckForExpiredStartTx(const int& p_nHeight)
 {
     LOCK2(cs, g_fluxnodeCache.cs);
+    if (g_fluxnodeCache.mapStartTxTracker.empty()) {
+        return;
+    }
     int removalHeight = p_nHeight - FLUXNODE_START_TX_EXPIRATION_HEIGHT;
 
     if (IsPONActive(p_nHeight)) {
@@ -507,6 +510,9 @@ void FluxnodeCache::CheckForExpiredStartTx(const int& p_nHeight)
 void FluxnodeCache::CheckForUndoExpiredStartTx(const int& p_nHeight)
 {
     LOCK2(cs, g_fluxnodeCache.cs);
+    if (g_fluxnodeCache.mapStartTxDOSTracker.empty()) {
+        return;
+    }
     int removalHeight = p_nHeight - FLUXNODE_START_TX_EXPIRATION_HEIGHT;
 
     if (IsPONActive(p_nHeight)) {
@@ -1809,6 +1815,8 @@ int GetNumberOfTiers()
 
 void FluxnodeCache::LogDebugData(const int& nHeight, const uint256& blockhash, bool fFromDisconnect)
 {
+    if (!LogAcceptCategory("fluxnode")) return;
+
     LOCK(cs);
     std::string printme = "{ \n";
     for (const auto &printitem: mapStartTxTracker) {
@@ -1823,10 +1831,10 @@ void FluxnodeCache::LogDebugData(const int& nHeight, const uint256& blockhash, b
     printme3 = printme3 + "}";
 
     if (fFromDisconnect) {
-        LogPrintf("Disconnecting - printing after block=%d, hash=%s\n, mapStart=%s\n\n, mapStartTxDOSTracker=%s\n\n",
+        LogPrint("fluxnode", "Disconnecting - printing after block=%d, hash=%s\n, mapStart=%s\n\n, mapStartTxDOSTracker=%s\n\n",
                   nHeight, blockhash.GetHex(), printme, printme3);
     } else {
-        LogPrintf("printing after block=%d, hash=%s\n, mapStart=%s\n\n, mapStartTxDOSTracker=%s\n\n",
+        LogPrint("fluxnode", "printing after block=%d, hash=%s\n, mapStart=%s\n\n, mapStartTxDOSTracker=%s\n\n",
                   nHeight, blockhash.GetHex(), printme, printme3);
     }
 

src/init.cpp

@@ -1224,8 +1224,10 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
 #ifndef WIN32
     CreatePidFile(GetPidFile(), getpid());
 #endif
-    // Shrink debug.log on startup if it's too large (configurable, default 500MB) - keeps last 50MB
-    if (GetBoolArg("-shrinkdebugfile", !fDebug))
+    // Shrink debug.log on startup if it's too large (configurable, default
+    // 500 MB, capped at 10 GB). Runs regardless of -debug so the file can't
+    // grow without bound when debug logging is enabled.
+    if (GetBoolArg("-shrinkdebugfile", true))
         ShrinkDebugFile();
 
     if (fPrintToDebugLog)
@@ -1474,24 +1476,24 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
         }
     }
 
-    // cache size calculations
-    int64_t nTotalCache = (GetArg("-dbcache", nDefaultDbCache) << 20);
-    nTotalCache = std::max(nTotalCache, nMinDbCache << 20); // total cache cannot be less than nMinDbCache
-    nTotalCache = std::min(nTotalCache, nMaxDbCache << 20); // total cache cannot be greated than nMaxDbcache
-    int64_t nBlockTreeDBCache = nTotalCache / 8;
-    if (nBlockTreeDBCache > (1 << 21) && !GetBoolArg("-txindex", false))
-        nBlockTreeDBCache = (1 << 21); // block tree db cache shouldn't be larger than 2 MiB
-
     // https://github.com/bitpay/bitcoin/commit/c91d78b578a8700a45be936cb5bb0931df8f4b87#diff-c865a8939105e6350a50af02766291b7R1233
-    if (GetBoolArg("-insightexplorer", false)) {
-        if (!GetBoolArg("-txindex", false)) {
-            return InitError(_("-insightexplorer requires -txindex."));
-        }
-        // increase cache if additional indices are needed
-        nBlockTreeDBCache = nTotalCache * 3 / 4;
+    if (GetBoolArg("-insightexplorer", false) && !GetBoolArg("-txindex", false)) {
+        return InitError(_("-insightexplorer requires -txindex."));
     }
+
+    // cache size calculations (matches Bitcoin Core's allocation so most of
+    // -dbcache goes to the in-memory UTXO set during IBD instead of the
+    // block tree DB)
+    const bool fHaveBlockTreeIndexes = GetBoolArg("-txindex", false) ||
+                                        GetBoolArg("-insightexplorer", false);
+    int64_t nTotalCache = (GetArg("-dbcache", nDefaultDbCache) << 20);
+    nTotalCache = std::max(nTotalCache, nMinDbCache << 20); // total cache cannot be less than nMinDbCache
+    nTotalCache = std::min(nTotalCache, nMaxDbCache << 20); // total cache cannot be greater than nMaxDbcache
+    int64_t nBlockTreeDBCache = std::min(nTotalCache / 8,
+        (fHaveBlockTreeIndexes ? nMaxBlockDBAndTxIndexCache : nMaxBlockDBCache) << 20);
     nTotalCache -= nBlockTreeDBCache;
     int64_t nCoinDBCache = std::min(nTotalCache / 2, (nTotalCache / 4) + (1 << 23)); // use 25%-50% of the remainder for disk cache
+    nCoinDBCache = std::min(nCoinDBCache, nMaxCoinsDBCache << 20);
     nTotalCache -= nCoinDBCache;
     nCoinCacheUsage = nTotalCache; // the rest goes to in-memory cache
     LogPrintf("Cache configuration:\n");
@@ -2069,6 +2071,10 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
                                          boost::ref(cs_main), boost::cref(pindexBestHeader), nPowTargetSpacing);
     scheduler.scheduleEvery(f, nPowTargetSpacing);
 
+    // Periodically cap debug.log size. Runs even when -debug is enabled so a
+    // firehose of debug output can't fill the disk. Interval: 5 minutes.
+    scheduler.scheduleEvery(&ShrinkDebugFile, 300);
+
 #ifdef ENABLE_MINING
     // Generate coins in the background
     GenerateBitcoins(GetBoolArg("-gen", false), GetArg("-genproclimit", 1), chainparams);

src/main.cpp

@@ -634,11 +634,35 @@ void FinalizeNode(NodeId nodeid) {
     // Remove from high-bandwidth compact block peer list
     lNodesAnnouncingHeaderAndIDs.remove(nodeid);
 
-    // Clean up any partial compact blocks from this peer
-    for (auto it = mapPartialBlocks.begin(); it != mapPartialBlocks.end(); ) {
-        // Note: PartiallyDownloadedBlock doesn't track which peer it came from in current implementation
-        // This is something we should improve in future iterations
-        ++it;
+    // Clean up any compact-block in-flight state tied to this peer.
+    // listCompactBlocksInFlight is the source of truth; mapCompactBlocksInFlight
+    // is the hash->iterator index. Collect affected block hashes so we can drop
+    // their partial-block entries once no other peer is still working on them.
+    std::set<uint256> affectedHashes;
+    for (auto it = listCompactBlocksInFlight.begin(); it != listCompactBlocksInFlight.end(); ) {
+        if (it->nodeid == nodeid) {
+            affectedHashes.insert(it->hash);
+            auto mapIt = mapCompactBlocksInFlight.find(it->hash);
+            if (mapIt != mapCompactBlocksInFlight.end() && mapIt->second.first == nodeid) {
+                mapCompactBlocksInFlight.erase(mapIt);
+            }
+            it = listCompactBlocksInFlight.erase(it);
+        } else {
+            ++it;
+        }
+    }
+    for (const uint256& hash : affectedHashes) {
+        bool stillInFlight = false;
+        for (const auto& marker : listCompactBlocksInFlight) {
+            if (marker.hash == hash) {
+                stillInFlight = true;
+                break;
+            }
+        }
+        if (!stillInFlight) {
+            mapPartialBlocks.erase(hash);
+            mapPartialBlocksTime.erase(hash);
+        }
     }
 
     mapNodeState.erase(nodeid);
@@ -6876,6 +6900,7 @@ bool static AlreadyHave(const CInv& inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
                    pcoinsTip->HaveCoins(inv.hash);
         }
     case MSG_BLOCK:
+    case MSG_CMPCT_BLOCK:
         return mapBlockIndex.count(inv.hash);
     }
     // Don't know what it is, just say we already got one
@@ -6902,7 +6927,7 @@ void static ProcessGetData(CNode* pfrom, const Consensus::Params& consensusParam
             boost::this_thread::interruption_point();
             it++;
 
-            if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK)
+            if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK || inv.type == MSG_CMPCT_BLOCK)
             {
                 bool send = false;
                 BlockMap::iterator mi = mapBlockIndex.find(inv.hash);
@@ -6934,6 +6959,18 @@ void static ProcessGetData(CNode* pfrom, const Consensus::Params& consensusParam
                         assert(!"cannot load block from disk");
                     if (inv.type == MSG_BLOCK)
                         pfrom->PushMessage("block", block);
+                    else if (inv.type == MSG_CMPCT_BLOCK)
+                    {
+                        // BIP 152 low-bandwidth mode: peer-initiated compact block request.
+                        // For older blocks fall back to sending the full block because the
+                        // peer is unlikely to have the mempool state needed to reconstruct.
+                        if (mi->second->nHeight >= chainActive.Height() - MAX_CMPCTBLOCK_DEPTH) {
+                            CBlockHeaderAndShortTxIDs cmpctblock(block, false);
+                            pfrom->PushMessage("cmpctblock", cmpctblock);
+                        } else {
+                            pfrom->PushMessage("block", block);
+                        }
+                    }
                     else // MSG_FILTERED_BLOCK)
                     {
                         LOCK(pfrom->cs_filter);
@@ -7981,7 +8018,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
 
         // DoS protection: only accept compact blocks that are close to the tip
         // This prevents attackers from wasting our CPU/bandwidth with old blocks
-        if (pindex->nHeight < chainActive.Height() - MAX_BLOCKTXN_DEPTH) {
+        if (pindex->nHeight < chainActive.Height() - MAX_CMPCTBLOCK_DEPTH) {
             LogPrint("cmpctblock", "Ignoring compact block from peer %d at height %d (tip is %d)\n",
                      pfrom->id, pindex->nHeight, chainActive.Height());
             return true;

src/main.h

@@ -125,8 +125,15 @@ static const int64_t DEFAULT_MAX_TIP_AGE = 4 * 60 * 60;
 static const int MAX_UNCONNECTING_HEADERS = 10;
 /** Maximum number of compact blocks in flight per block */
 static const unsigned int MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK = 3;
-/** Maximum depth for responding to GETBLOCKTXN requests */
-static const int MAX_BLOCKTXN_DEPTH = 10;
+/** Maximum depth at which we accept inbound cmpctblock messages or serve
+ *  outbound ones in response to MSG_CMPCT_BLOCK getdata requests.
+ *  Older blocks fall back to a full block because the requester's mempool
+ *  is unlikely to have the transactions needed to reconstruct.
+ *
+ *  Sized to roughly match Bitcoin Core's ~50-minute wall-clock window.
+ *  Bitcoin Core uses 5 at 10-minute block times; fluxd runs 30-second
+ *  PON blocks, so 100 blocks ≈ 50 minutes. */
+static const int MAX_CMPCTBLOCK_DEPTH = 100;
 /** Size of extra transaction pool for compact block reconstruction */
 static const unsigned int EXTRA_TXNS_FOR_COMPACT_BLOCKS = 100;
 

src/pon/pon.cpp

@@ -137,7 +137,7 @@ unsigned int GetNextPONWorkRequired(const CBlockIndex* pindexLast)
     // Target timespan = (window - 1) * target spacing (because we're measuring intervals)
     int64_t targetTimespan = (lookbackWindow - 1) * params.nPonTargetSpacing;
 
-    LogPrintf("PON: Adjustment at height %d: first=%d, last=%d, actualTimespan=%d, targetTimespan=%d\n",
+    LogPrint("pon", "PON: Adjustment at height %d: first=%d, last=%d, actualTimespan=%d, targetTimespan=%d\n",
               nextHeight, pindexFirst->nHeight, pindexLast->nHeight, actualTimespan, targetTimespan);
 
     // Sanity check
@@ -187,7 +187,7 @@ unsigned int GetNextPONWorkRequired(const CBlockIndex* pindexLast)
         newTarget = ponLimit;  // Use easiest difficulty as failsafe
     }
 
-    LogPrintf("PON difficulty adjustment: height=%d, actualTimespan=%d, targetTimespan=%d, before=%08x, after=%08x\n",
+    LogPrint("pon", "PON difficulty adjustment: height=%d, actualTimespan=%d, targetTimespan=%d, before=%08x, after=%08x\n",
               pindexLast->nHeight + 1, actualTimespan, targetTimespan,
               pindexLast->nBits, newTarget.GetCompact());
 

src/protocol.cpp

@@ -25,7 +25,8 @@ static const char* ppszTypeName[] =
     "zn quorum",
     "zn announce",
     "zn ping",
-    "dstx"
+    "dstx",
+    "cmpct block"
 };
 
 CMessageHeader::CMessageHeader(const MessageStartChars& pchMessageStartIn)
@@ -139,7 +140,9 @@ bool CInv::IsKnownType() const
 
 bool CInv::IsFluxnodeType() const
 {
-    return (type >= 4);
+    // Types 4-10 are Flux-network-specific invs (spork, zn winner, etc).
+    // MSG_CMPCT_BLOCK (type 11) is not a fluxnode type.
+    return (type >= 4 && type <= 10);
 }
 
 const char* CInv::GetCommand() const

src/protocol.h

@@ -160,7 +160,13 @@ enum {
     MSG_BLOCK,
     // Nodes may always request a MSG_FILTERED_BLOCK in a getdata, however,
     // MSG_FILTERED_BLOCK should not appear in any invs except as a part of getdata.
-    MSG_FILTERED_BLOCK
+    MSG_FILTERED_BLOCK,
+    // Reserved inv types 4-10 are used for fluxnode-specific invs (see
+    // ppszTypeName in protocol.cpp).
+    // BIP 152 low-bandwidth mode: peer-initiated compact block request.
+    // Diverges from Bitcoin Core's MSG_CMPCT_BLOCK=4 because type 4 is
+    // already used as "spork" on the Flux network.
+    MSG_CMPCT_BLOCK = 11,
 };
 
 #endif // BITCOIN_PROTOCOL_H

src/txdb.h

@@ -46,6 +46,13 @@ static const int64_t nDefaultDbCache = 450;
 static const int64_t nMaxDbCache = sizeof(void*) > 4 ? 16384 : 1024;
 //! min. -dbcache in (MiB)
 static const int64_t nMinDbCache = 4;
+//! Max memory allocated to block tree DB specific cache (MiB)
+static const int64_t nMaxBlockDBCache = 2;
+//! Max memory allocated to block tree DB specific cache, if -txindex or
+//  insight-explorer indexes are enabled (MiB)
+static const int64_t nMaxBlockDBAndTxIndexCache = 1024;
+//! Max memory allocated to coin DB specific cache (MiB)
+static const int64_t nMaxCoinsDBCache = 8;
 
 struct CDiskTxPos : public CDiskBlockPos
 {

src/util.cpp

@@ -892,37 +892,54 @@ void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length) {
 
 void ShrinkDebugFile()
 {
-    // Scroll debug.log if it's getting too big
+    // Scroll debug.log if it's getting too big.
+    // Safe to call at any time: reads the tail into memory, writes to a temp
+    // file, and atomically renames over debug.log. Any concurrent LogPrintStr
+    // writes land on the unlinked inode; LogPrintStr reopens on next call
+    // when fReopenDebugLog is set.
     boost::filesystem::path pathLog = GetDataDir() / "debug.log";
-    FILE* file = fopen(pathLog.string().c_str(), "r");
 
-    // Get configurable size threshold (default 500MB, min 10MB, max 10GB)
-    int64_t nMaxLogSizeMB = GetArg("-maxdebugfilesize", 500); // Default 500MB
-    if (nMaxLogSizeMB < 10) nMaxLogSizeMB = 10;       // Minimum 10MB
-    if (nMaxLogSizeMB > 2048) nMaxLogSizeMB = 2048; // Maximum 2GB
+    // Get configurable size threshold. Default 500 MB, min 10 MB. Upper cap
+    // depends on whether debug logging is active: 10 GiB with -debug on so a
+    // long debug session has room to breathe, 2 GiB otherwise.
+    int64_t nMaxLogSizeMB = GetArg("-maxdebugfilesize", 500);
+    const int64_t nUpperCapMB = fDebug ? 10240 : 2048;
+    if (nMaxLogSizeMB < 10) nMaxLogSizeMB = 10;
+    if (nMaxLogSizeMB > nUpperCapMB) nMaxLogSizeMB = nUpperCapMB;
     int64_t nMaxLogSize = nMaxLogSizeMB * 1000000;
 
-    if (file && boost::filesystem::file_size(pathLog) > nMaxLogSize)
-    {
-        LogPrintf("ShrinkDebugFile: debug.log size is %.1f MB, shrinking to last 50 MB...\n",
-                  boost::filesystem::file_size(pathLog) / 1000000.0);
-
-        // Keep last 50MB when shrinking (reasonable amount for debugging)
-        std::vector <char> vch(50000000,0);
-        fseek(file, -((long)vch.size()), SEEK_END);
-        int nBytes = fread(begin_ptr(vch), 1, vch.size(), file);
-        fclose(file);
-
-        file = fopen(pathLog.string().c_str(), "w");
-        if (file)
-        {
-            fwrite(begin_ptr(vch), 1, nBytes, file);
-            fclose(file);
-            LogPrintf("ShrinkDebugFile: Shrinking complete, kept %.1f MB\n", nBytes / 1000000.0);
-        }
+    boost::system::error_code ec;
+    uintmax_t curSize = boost::filesystem::file_size(pathLog, ec);
+    if (ec || (int64_t)curSize <= nMaxLogSize)
+        return;
+
+    // Keep last 50 MB when shrinking.
+    const size_t nKeepBytes = 50 * 1000 * 1000;
+
+    FILE* src = fopen(pathLog.string().c_str(), "rb");
+    if (!src) return;
+
+    std::vector<char> vch(nKeepBytes, 0);
+    fseek(src, -(long)vch.size(), SEEK_END);
+    size_t nBytes = fread(begin_ptr(vch), 1, vch.size(), src);
+    fclose(src);
+
+    boost::filesystem::path pathTmp = pathLog;
+    pathTmp += ".tmp";
+    FILE* dst = fopen(pathTmp.string().c_str(), "wb");
+    if (!dst) return;
+    fwrite(begin_ptr(vch), 1, nBytes, dst);
+    fclose(dst);
+
+    boost::filesystem::rename(pathTmp, pathLog, ec);
+    if (ec) {
+        boost::filesystem::remove(pathTmp, ec);
+        return;
     }
-    else if (file != NULL)
-        fclose(file);
+
+    // Tell LogPrintStr to reopen the log on its next write so future output
+    // goes to the new (truncated) file instead of the unlinked inode.
+    fReopenDebugLog = true;
 }
 
 #ifdef WIN32