log: Mitigate disk filling attacks by rate limiting LogPrintf, LogInfo, LogWarning, LogError #32604

 0COMMITS="e95bfc1d537e06d223dfcaec510181aa3d3f8386 f29b081b9277332523b7025394cad15b02cc53d2"; \
 1STOP=900000; DBCACHE=2500; \
 2CC=gcc; CXX=g++; \
 3BASE_DIR="/mnt/my_storage"; DATA_DIR="$BASE_DIR/BitcoinData"; LOG_DIR="$BASE_DIR/logs"; \
 4(echo ""; for c in $COMMITS; do git fetch -q origin $c && git log -1 --pretty='%h %s' $c || exit 1; done; echo "") && \
 5hyperfine \
 6  --sort command \
 7  --runs 1 \
 8  --export-json "$BASE_DIR/rdx-$(sed -E 's/(\w{8})\w+ ?/\1-/g;s/-$//'<<<"$COMMITS")-$STOP-$DBCACHE-$CC.json" \
 9  --parameter-list COMMIT ${COMMITS// /,} \
10  --prepare "killall bitcoind; rm -f $DATA_DIR/debug.log; git checkout {COMMIT}; git clean -fxd; git reset --hard && \
11    cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release && ninja -C build bitcoind && \
12    ./build/bin/bitcoind -datadir=$DATA_DIR -stopatheight=$STOP -dbcache=1000 -printtoconsole=0; sleep 10" \
13  --cleanup "cp $DATA_DIR/debug.log $LOG_DIR/debug-{COMMIT}-$(date +%s).log" \
14  "COMPILER=$CC ./build/bin/bitcoind -datadir=$DATA_DIR -stopatheight=$STOP -dbcache=$DBCACHE -reindex -blocksonly -connect=0 -printtoconsole=0"

0Benchmark 1: COMPILER=gcc ./build/bin/bitcoind -datadir=/mnt/my_storage/BitcoinData -stopatheight=900000 -dbcache=2500 -reindex -blocksonly -connect=0 -printtoconsole=0 (COMMIT = e95bfc1d537e06d223dfcaec510181aa3d3f8386)
1  Time (abs ≡):        29033.291 s               [User: 43597.672 s, System: 1644.619 s]
2 
3Benchmark 2: COMPILER=gcc ./build/bin/bitcoind -datadir=/mnt/my_storage/BitcoinData -stopatheight=900000 -dbcache=2500 -reindex -blocksonly -connect=0 -printtoconsole=0 (COMMIT = f29b081b9277332523b7025394cad15b02cc53d2)
4  Time (abs ≡):        28875.472 s               [User: 43552.019 s, System: 1541.380 s]

0Relative speed comparison
1        1.01          COMPILER=gcc ./build/bin/bitcoind -datadir=/mnt/my_storage/BitcoinData -stopatheight=900000 -dbcache=2500 -reindex -blocksonly -connect=0 -printtoconsole=0 (COMMIT = e95bfc1d537e06d223dfcaec510181aa3d3f8386)
2        1.00          COMPILER=gcc ./build/bin/bitcoind -datadir=/mnt/my_storage/BitcoinData -stopatheight=900000 -dbcache=2500 -reindex -blocksonly -connect=0 -printtoconsole=0 (COMMIT = f29b081b9277332523b7025394cad15b02cc53d2)

0    LogInfo(/*rate_limit=*/100, "%s%s: new best=%s height=%d version=0x%08x log2_work=%f tx=%lu date='%s' progress=%f cache=%.1fMiB(%utxo)%s\n",

0        return lhs.line() == rhs.line() && strcmp(lhs.file_name(), rhs.file_name()) == 0 ;

  0diff --git a/src/logging.cpp b/src/logging.cpp
  1index 1e20c10368..c4ae881ffd 100644
  2--- a/src/logging.cpp
  3+++ b/src/logging.cpp
  4@@ -5,6 +5,7 @@
  5 
  6 #include <logging.h>
  7 #include <memusage.h>
  8+#include <sync.h>
  9 #include <util/check.h>
 10 #include <util/fs.h>
 11 #include <util/string.h>
 12@@ -376,41 +377,40 @@ static size_t MemUsage(const BCLog::Logger::BufferedLog& buflog)
 13     return buflog.str.size() + buflog.logging_function.size() + strlen(buflog.source_loc.file_name()) + buflog.threadname.size() + memusage::MallocUsage(sizeof(memusage::list_node<BCLog::Logger::BufferedLog>));
 14 }
 15 
 16-bool BCLog::Logger::NeedsRateLimiting(bool should_ratelimit, const std::source_location& source_loc, std::string& str, std::string_view logging_function)
 17+bool BCLog::LogRateLimiter::NeedsRateLimiting(const std::source_location& source_loc, std::string& str)
 18 {
 19+    StdLockGuard scoped_lock(m_cs);
 20     // Whether or not logging to disk was/is ratelimited for this source location.
 21     bool was_ratelimited{false};
 22     bool is_ratelimited{false};
 23 
 24-    if (m_ratelimit && should_ratelimit) {
 25-        // Check to see if we were rate limited before calling ResetWindow.
 26-        was_ratelimited = m_suppressed_locations.find(source_loc) != m_suppressed_locations.end();
 27+    // Check to see if we were rate limited before calling ResetWindow.
 28+    was_ratelimited = m_suppressed_locations.find(source_loc) != m_suppressed_locations.end();
 29 
 30-        // If the m_limiter window has elapsed, then we need to clear the unordered map and set.
 31-        if (m_limiter.ResetWindow()) {
 32-            m_source_locations.clear();
 33-            m_suppressed_locations.clear();
 34-        }
 35+    // If the m_limiter window has elapsed, then we need to clear the unordered map and set.
 36+    if (ResetWindow()) {
 37+        m_source_locations.clear();
 38+        m_suppressed_locations.clear();
 39+    }
 40 
 41-        is_ratelimited = !m_source_locations[source_loc].Consume(str.size());
 42+    is_ratelimited = !m_source_locations[source_loc].Consume(str.size());
 43 
 44-        if (!is_ratelimited && was_ratelimited) {
 45-            uint64_t dropped_bytes = m_source_locations[source_loc].GetDroppedBytes();
 46+    if (!is_ratelimited && was_ratelimited) {
 47+        uint64_t dropped_bytes{m_source_locations[source_loc].GetDroppedBytes()};
 48 
 49-            str.insert(0, strprintf("Restarting logging from %s:%d (%s): "
 50-                                    "(%d MiB) were dropped during the last hour.\n",
 51-                                    source_loc.file_name(), source_loc.line(), logging_function,
 52-                                    dropped_bytes / (1024 * 1024)));
 53-        } else if (is_ratelimited && !was_ratelimited) {
 54-            // Logging from this source location will be suppressed until the current window resets.
 55-            m_suppressed_locations.insert(source_loc);
 56+        str.insert(0, strprintf("Restarting logging from %s:%d (%s): "
 57+                                "(%d MiB) were dropped during the last hour.\n",
 58+                                source_loc.file_name(), source_loc.line(), source_loc.function_name(),
 59+                                dropped_bytes / (1024 * 1024)));
 60+    } else if (is_ratelimited && !was_ratelimited) {
 61+        // Logging from this source location will be suppressed until the current window resets.
 62+        m_suppressed_locations.insert(source_loc);
 63 
 64-            str.insert(0, strprintf("Excessive logging detected from %s:%d (%s): >%d MiB logged during the last hour."
 65-                                    "Suppressing logging to disk from this source location for up to one hour. "
 66-                                    "Console logging unaffected. Last log entry.",
 67-                                    source_loc.file_name(), source_loc.line(), logging_function,
 68-                                    LogRateLimiter::WINDOW_MAX_BYTES / (1024 * 1024)));
 69-        }
 70+        str.insert(0, strprintf("Excessive logging detected from %s:%d (%s): >%d MiB logged during the last hour."
 71+                                "Suppressing logging to disk from this source location for up to one hour. "
 72+                                "Console logging unaffected. Last log entry.",
 73+                                source_loc.file_name(), source_loc.line(), source_loc.function_name(),
 74+                                LogRateLimiter::WINDOW_MAX_BYTES / (1024 * 1024)));
 75     }
 76 
 77     // To avoid confusion caused by dropped log messages when debugging an issue,
 78@@ -479,7 +479,7 @@ void BCLog::Logger::LogPrintStr_(std::string_view str, std::string_view logging_
 79     }
 80 
 81     FormatLogStrInPlace(str_prefixed, category, level, source_loc, logging_function, util::ThreadGetInternalName(), SystemClock::now(), GetMockTime());
 82-    bool ratelimit = NeedsRateLimiting(should_ratelimit, source_loc, str_prefixed, logging_function);
 83+    bool ratelimit = m_ratelimit && should_ratelimit && m_limiter.NeedsRateLimiting(source_loc, str_prefixed);
 84 
 85     if (m_print_to_console) {
 86         // print to console
 87diff --git a/src/logging.h b/src/logging.h
 88index b94b9cb495..f9441f6913 100644
 89--- a/src/logging.h
 90+++ b/src/logging.h
 91@@ -48,7 +48,7 @@ struct SourceLocationHasher {
 92     {
 93         // Use CSipHasher(0, 0) as a simple way to get uniform distribution.
 94         return static_cast<size_t>(CSipHasher(0, 0)
 95-                                       .Write(std::hash<std::string>{}(s.file_name()))
 96+                                       .Write(std::hash<std::string_view>{}(s.file_name()))
 97                                        .Write(std::hash<int>{}(s.line()))
 98                                        .Finalize());
 99     }
100@@ -106,13 +106,18 @@ namespace BCLog {
101     constexpr auto DEFAULT_LOG_LEVEL{Level::Debug};
102     constexpr size_t DEFAULT_MAX_LOG_BUFFER{1'000'000}; // buffer up to 1MB of log data prior to StartLogging
103 
104+    class SourceLocationCounter;
105     //! Fixed window rate limiter for logging.
106     class LogRateLimiter
107     {
108     private:
109         //! Timestamp of the last window reset.
110         std::chrono::time_point<NodeClock> m_last_reset;
111-
112+        //! Counters for each source location that has attempted to log something.
113+        std::unordered_map<std::source_location, SourceLocationCounter, SourceLocationHasher, SourceLocationEqual> m_source_locations GUARDED_BY(m_cs);
114+        //! Set of source file locations that were dropped on the last log attempt.
115+        std::unordered_set<std::source_location, SourceLocationHasher, SourceLocationEqual> m_suppressed_locations GUARDED_BY(m_cs);
116+        mutable StdMutex m_cs; // TODO: does LogRateLimiter need to use Logger:m_cs instead? Didn't investigate.
117     public:
118         //! Interval after which the window is reset.
119         static constexpr std::chrono::hours WINDOW_SIZE{1};
120@@ -120,6 +125,8 @@ namespace BCLog {
121         static constexpr uint64_t WINDOW_MAX_BYTES{1024 * 1024};
122         //! Attempts to reset the window if the window interval has passed. Returns true if the window was reset.
123         bool ResetWindow();
124+        //! Check if we need to rate limit a source_location.
125+        bool NeedsRateLimiting(const std::source_location& source_loc, std::string& str) EXCLUSIVE_LOCKS_REQUIRED(!m_cs);
126 
127         LogRateLimiter() : m_last_reset{NodeClock::now()} {}
128 
129@@ -176,10 +183,6 @@ namespace BCLog {
130 
131         //! Keeps track of the last time we've reset the logging window.
132         LogRateLimiter m_limiter GUARDED_BY(m_cs);
133-        //! Counters for each source location that has attempted to log something.
134-        std::unordered_map<std::source_location, SourceLocationCounter, SourceLocationHasher, SourceLocationEqual> m_source_locations GUARDED_BY(m_cs);
135-        //! Set of source file locations that were dropped on the last log attempt.
136-        std::unordered_set<std::source_location, SourceLocationHasher, SourceLocationEqual> m_suppressed_locations GUARDED_BY(m_cs);
137 
138         //! Category-specific log level. Overrides `m_log_level`.
139         std::unordered_map<LogFlags, Level> m_category_log_levels GUARDED_BY(m_cs);
140@@ -193,9 +196,6 @@ namespace BCLog {
141 
142         void FormatLogStrInPlace(std::string& str, LogFlags category, Level level, const std::source_location& source_loc, std::string_view logging_function, std::string_view threadname, SystemClock::time_point now, std::chrono::seconds mocktime) const;
143 
144-        /** Check if we need to rate limit a source_location. */
145-        bool NeedsRateLimiting(bool should_ratelimit, const std::source_location& source_loc, std::string& str, std::string_view logging_function) EXCLUSIVE_LOCKS_REQUIRED(m_cs);
146-
147         std::string LogTimestampStr(SystemClock::time_point now, std::chrono::seconds mocktime) const;
148 
149         /** Slots that connect to the print signal */

0__func__: AppInitParameterInteraction
1source_location: bool AppInitParameterInteraction(const ArgsManager &)

0                                       .Write(std::hash<std::string_view>{}(s.file_name()))

 0diff --git a/src/logging.h b/src/logging.h
 1index d588ef86dc..5f298405e7 100644
 2--- a/src/logging.h
 3+++ b/src/logging.h
 4@@ -349,17 +349,13 @@ inline void LogPrintFormatInternal(const std::source_location& source_loc, const
 5 // Use a macro instead of a function for conditional logging to prevent
 6 // evaluating arguments when logging for the category is not enabled.
 7 
 8-// Log by prefixing the output with the passed category name and severity level. This can either
 9-// log conditionally if the category is allowed or unconditionally if level >= BCLog::Level::Info
10-// is passed. Note that this function bypasses rate limiting. Callers need to take care to ensure
11-// that an attacker cannot trigger a disk-fill vulnerability if level >= Info is used. Additionally,
12-// users specifying -debug are assumed to be developers or power users who are aware that -debug
13-// may cause excessive disk usage due to logging.
14-#define LogPrintLevel(category, level, ...)                                           \
15-    do {                                                                              \
16-        if (LogAcceptCategory((category), (level))) {                                 \
17-            LogPrintLevel_(category, level, /*should_ratelimit=*/false, __VA_ARGS__); \
18-        }                                                                             \
19+// Log conditionally, prefixing the output with the passed category name and severity level.
20+#define LogPrintLevel(category, level, ...)                             \
21+    do {                                                                \
22+        if (LogAcceptCategory((category), (level))) {                   \
23+            bool rate_limit{level >= BCLog::Info};                      \
24+            LogPrintLevel_(category, level, rate_limit, __VA_ARGS__);   \
25+        }                                                               \
26     } while (0)
27 
28 // Log conditionally, prefixing the output with the passed category name.

0        m_limiter.MaybeResetWindow();

0        //! Attempts to reset the logging window if the window interval has passed. This will clear
1        //! m_source_locations and m_suppressed_locations if a reset occurs.

0        //! Consumes `source_loc`'s available bytes corresponding to the size of the (formatted)
1        //! `str` and returns true if it exceeds the allowance in the current time window.

  0diff --git a/src/logging.cpp b/src/logging.cpp
  1index e31e346549..006bac6a98 100644
  2--- a/src/logging.cpp
  3+++ b/src/logging.cpp
  4@@ -74,8 +74,7 @@ bool BCLog::Logger::StartLogging()
  5     // dump buffered messages from before we opened the log
  6     m_buffering = false;
  7     if (m_buffer_lines_discarded > 0) {
  8-        const auto source_loc{std::source_location::current()};
  9-        LogPrintStr_(strprintf("Early logging buffer overflowed, %d log lines discarded.\n", m_buffer_lines_discarded), source_loc, BCLog::ALL, Level::Info, /*should_ratelimit=*/false);
 10+        LogPrintStr_(strprintf("Early logging buffer overflowed, %d log lines discarded.\n", m_buffer_lines_discarded), std::source_location::current(), BCLog::ALL, Level::Info, /*should_ratelimit=*/false);
 11     }
 12     while (!m_msgs_before_open.empty()) {
 13         const auto& buflog = m_msgs_before_open.front();
 14@@ -434,13 +433,13 @@ void BCLog::Logger::FormatLogStrInPlace(std::string& str, BCLog::LogFlags catego
 15     str.insert(0, LogTimestampStr(now, mocktime));
 16 }
 17 
 18-void BCLog::Logger::LogPrintStr(std::string_view str, const std::source_location& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 19+void BCLog::Logger::LogPrintStr(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 20 {
 21     StdLockGuard scoped_lock(m_cs);
 22-    return LogPrintStr_(str, source_loc, category, level, should_ratelimit);
 23+    return LogPrintStr_(str, std::move(source_loc), category, level, should_ratelimit);
 24 }
 25 
 26-void BCLog::Logger::LogPrintStr_(std::string_view str, const std::source_location& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 27+void BCLog::Logger::LogPrintStr_(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 28 {
 29     std::string str_prefixed = LogEscapeMessage(str);
 30 
 31@@ -451,7 +450,7 @@ void BCLog::Logger::LogPrintStr_(std::string_view str, const std::source_locatio
 32                 .mocktime=GetMockTime(),
 33                 .str=str_prefixed,
 34                 .threadname=util::ThreadGetInternalName(),
 35-                .source_loc=source_loc,
 36+                .source_loc=std::move(source_loc),
 37                 .category=category,
 38                 .level=level,
 39             };
 40diff --git a/src/logging.h b/src/logging.h
 41index d588ef86dc..edef5c074f 100644
 42--- a/src/logging.h
 43+++ b/src/logging.h
 44@@ -201,7 +201,7 @@ namespace BCLog {
 45         std::list<std::function<void(const std::string&)>> m_print_callbacks GUARDED_BY(m_cs) {};
 46 
 47         /** Send a string to the log output (internal) */
 48-        void LogPrintStr_(std::string_view str, const std::source_location& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 49+        void LogPrintStr_(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 50             EXCLUSIVE_LOCKS_REQUIRED(m_cs);
 51 
 52         std::string GetLogPrefix(LogFlags category, Level level) const;
 53@@ -220,7 +220,7 @@ namespace BCLog {
 54         std::atomic<bool> m_reopen_file{false};
 55 
 56         /** Send a string to the log output */
 57-        void LogPrintStr(std::string_view str, const std::source_location& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 58+        void LogPrintStr(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
 59             EXCLUSIVE_LOCKS_REQUIRED(!m_cs);
 60 
 61         /** Returns whether logs will be written to any output */
 62@@ -320,7 +320,7 @@ static inline bool LogAcceptCategory(BCLog::LogFlags category, BCLog::Level leve
 63 bool GetLogCategory(BCLog::LogFlags& flag, std::string_view str);
 64 
 65 template <typename... Args>
 66-inline void LogPrintFormatInternal(const std::source_location& source_loc, const BCLog::LogFlags flag, const BCLog::Level level, const bool should_ratelimit, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
 67+inline void LogPrintFormatInternal(std::source_location&& source_loc, const BCLog::LogFlags flag, const BCLog::Level level, const bool should_ratelimit, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
 68 {
 69     if (LogInstance().Enabled()) {
 70         std::string log_msg;
 71@@ -329,7 +329,7 @@ inline void LogPrintFormatInternal(const std::source_location& source_loc, const
 72         } catch (tinyformat::format_error& fmterr) {
 73             log_msg = "Error \"" + std::string{fmterr.what()} + "\" while formatting log message: " + fmt.fmt;
 74         }
 75-        LogInstance().LogPrintStr(log_msg, source_loc, flag, level, should_ratelimit);
 76+        LogInstance().LogPrintStr(log_msg, std::move(source_loc), flag, level, should_ratelimit);
 77     }
 78 }
 79 
 80diff --git a/src/test/logging_tests.cpp b/src/test/logging_tests.cpp
 81index 0043df182e..f5ce17aa23 100644
 82--- a/src/test/logging_tests.cpp
 83+++ b/src/test/logging_tests.cpp
 84@@ -97,12 +97,12 @@ BOOST_FIXTURE_TEST_CASE(logging_LogPrintStr, LogSetup)
 85         std::source_location::current(),
 86         std::source_location::current(),
 87     };
 88-    LogInstance().LogPrintStr("foo1: bar1", source_locs[0], BCLog::LogFlags::NET, BCLog::Level::Debug, /*should_ratelimit=*/false);
 89-    LogInstance().LogPrintStr("foo2: bar2", source_locs[1], BCLog::LogFlags::NET, BCLog::Level::Info, /*should_ratelimit=*/false);
 90-    LogInstance().LogPrintStr("foo3: bar3", source_locs[2], BCLog::LogFlags::ALL, BCLog::Level::Debug, /*should_ratelimit=*/false);
 91-    LogInstance().LogPrintStr("foo4: bar4", source_locs[3], BCLog::LogFlags::ALL, BCLog::Level::Info, /*should_ratelimit=*/false);
 92-    LogInstance().LogPrintStr("foo5: bar5", source_locs[4], BCLog::LogFlags::NONE, BCLog::Level::Debug, /*should_ratelimit=*/false);
 93-    LogInstance().LogPrintStr("foo6: bar6", source_locs[5], BCLog::LogFlags::NONE, BCLog::Level::Info, /*should_ratelimit=*/false);
 94+    LogInstance().LogPrintStr("foo1: bar1", std::move(source_locs[0]), BCLog::LogFlags::NET, BCLog::Level::Debug, /*should_ratelimit=*/false);
 95+    LogInstance().LogPrintStr("foo2: bar2", std::move(source_locs[1]), BCLog::LogFlags::NET, BCLog::Level::Info, /*should_ratelimit=*/false);
 96+    LogInstance().LogPrintStr("foo3: bar3", std::move(source_locs[2]), BCLog::LogFlags::ALL, BCLog::Level::Debug, /*should_ratelimit=*/false);
 97+    LogInstance().LogPrintStr("foo4: bar4", std::move(source_locs[3]), BCLog::LogFlags::ALL, BCLog::Level::Info, /*should_ratelimit=*/false);
 98+    LogInstance().LogPrintStr("foo5: bar5", std::move(source_locs[4]), BCLog::LogFlags::NONE, BCLog::Level::Debug, /*should_ratelimit=*/false);
 99+    LogInstance().LogPrintStr("foo6: bar6", std::move(source_locs[5]), BCLog::LogFlags::NONE, BCLog::Level::Info, /*should_ratelimit=*/false);
100     std::ifstream file{tmp_log_path};
101     std::vector<std::string> log_lines;
102     for (std::string log; std::getline(file, log);) {

0                                       .Write(s.line())

 0diff --git a/src/logging.cpp b/src/logging.cpp
 1index 827d1bad10..fec8e5ec58 100644
 2--- a/src/logging.cpp
 3+++ b/src/logging.cpp
 4@@ -379,17 +379,13 @@ static size_t MemUsage(const BCLog::Logger::BufferedLog& buflog)
 5 
 6 bool BCLog::LogRateLimiter::NeedsRateLimiting(const std::source_location& source_loc, std::string& str)
 7 {
 8-    // Whether or not logging to disk was/is ratelimited for this source location.
 9-    bool was_ratelimited{false};
10-    bool is_ratelimited{false};
11-
12     // Check to see if we were rate limited before calling MaybeResetWindow.
13-    was_ratelimited = m_suppressed_locations.find(source_loc) != m_suppressed_locations.end();
14+    bool was_ratelimited{m_suppressed_locations.contains(source_loc)};
15 
16     // If the window has elapsed, then we need to clear the unordered map and set.
17     MaybeResetWindow(str);
18 
19-    is_ratelimited = !m_source_locations[source_loc].Consume(str.size());
20+    bool is_ratelimited{!m_source_locations[source_loc].Consume(str.size())};
21 
22     if (is_ratelimited && !was_ratelimited) {
23         // Logging from this source location will be suppressed until the current window resets.

0static size_t MemUsage(const BCLog::Logger::BufferedLog& buflog)
1{
2    return memusage::DynamicUsage(buflog.str) +
3           memusage::DynamicUsage(buflog.threadname) +
4           memusage::MallocUsage(sizeof(memusage::list_node<BCLog::Logger::BufferedLog>));
5}

 0diff --git a/src/test/logging_tests.cpp b/src/test/logging_tests.cpp
 1index c9b7913ee4..d673792ab6 100644
 2--- a/src/test/logging_tests.cpp
 3+++ b/src/test/logging_tests.cpp
 4@@ -114,15 +114,16 @@ BOOST_FIXTURE_TEST_CASE(logging_LogPrintStr, LogSetup)
 5     for (std::string log; std::getline(file, log);) {
 6         log_lines.push_back(log);
 7     }
 8-    std::string file_name = util::RemovePrefix(source_locs[0].file_name(), "./");
 9-    std::string function_name{source_locs[0].function_name()};
10+    auto format_source_location = [](const std::source_location& loc) {
11+        return tfm::format("[%s:%s] [%s]", util::RemovePrefixView(loc.file_name(), "./"), loc.line(), loc.function_name());
12+    };
13     std::vector<std::string> expected = {
14-        "[" + file_name + ":" + util::ToString(source_locs[0].line()) + "] [" + function_name + "] [net] foo1: bar1",
15-        "[" + file_name + ":" + util::ToString(source_locs[1].line()) + "] [" + function_name + "] [net:info] foo2: bar2",
16-        "[" + file_name + ":" + util::ToString(source_locs[2].line()) + "] [" + function_name + "] [debug] foo3: bar3",
17-        "[" + file_name + ":" + util::ToString(source_locs[3].line()) + "] [" + function_name + "] foo4: bar4",
18-        "[" + file_name + ":" + util::ToString(source_locs[4].line()) + "] [" + function_name + "] [debug] foo5: bar5",
19-        "[" + file_name + ":" + util::ToString(source_locs[5].line()) + "] [" + function_name + "] foo6: bar6",
20+        format_source_location(source_locs[0]) + " [net] foo1: bar1",
21+        format_source_location(source_locs[1]) + " [net:info] foo2: bar2",
22+        format_source_location(source_locs[2]) + " [debug] foo3: bar3",
23+        format_source_location(source_locs[3]) + " foo4: bar4",
24+        format_source_location(source_locs[4]) + " [debug] foo5: bar5",
25+        format_source_location(source_locs[5]) + " foo6: bar6",
26     };
27     BOOST_CHECK_EQUAL_COLLECTIONS(log_lines.begin(), log_lines.end(), expected.begin(), expected.end());
28 }

0    m_limiter.m_last_reset = NodeClock::now();

 0BOOST_FIXTURE_TEST_CASE(logging_LogPrintStr, LogSetup)
 1{
 2    LogInstance().m_log_sourcelocations = true;
 3
 4    struct Case {
 5        std::string msg;
 6        BCLog::LogFlags cat;
 7        BCLog::Level level;
 8        std::string prefix;
 9        std::source_location loc;
10    };
11
12    std::vector<Case> cases = {
13        {"foo1: bar1", BCLog::NET,  BCLog::Level::Debug, "[net] ",      std::source_location::current()},
14        {"foo2: bar2", BCLog::NET,  BCLog::Level::Info,  "[net:info] ", std::source_location::current()},
15        {"foo3: bar3", BCLog::ALL,  BCLog::Level::Debug, "[debug] ",    std::source_location::current()},
16        {"foo4: bar4", BCLog::ALL,  BCLog::Level::Info,  "",            std::source_location::current()},
17        {"foo5: bar5", BCLog::NONE, BCLog::Level::Debug, "[debug] ",    std::source_location::current()},
18        {"foo6: bar6", BCLog::NONE, BCLog::Level::Info,  "",            std::source_location::current()},
19    };
20
21    std::vector<std::string> expected;
22    for (auto& [msg, cat, level, prefix, loc] : cases) {
23        expected.push_back(tfm::format("[%s:%s] [%s] %s%s", loc.file_name(), loc.line(), loc.function_name(), prefix, msg));
24        LogInstance().LogPrintStr(msg, std::move(loc), cat, level, /*should_ratelimit=*/false);
25    }
26    std::ifstream file{tmp_log_path};
27    std::string line;
28    for (const auto& exp : expected) {
29        BOOST_REQUIRE(std::getline(file, line));
30        BOOST_CHECK_EQUAL(line, exp);
31    }
32    BOOST_CHECK(!std::getline(file, line));
33}

0        //! Returns whether enough bytes were available.