banman: schedule sweep at ban expiry instead of polling

Give BanMan access to CScheduler so it can fire SweepBanned()
at the exact moment the next ban expires. This triggers
BannedListChanged to refresh the GUI without polling timers.

Track m_next_sweep_time to avoid scheduling when a sweep is
already pending for an earlier time. Ban() compares the new
ban's expiry directly against the tracked time (O(1), no loop).

Use a generation counter (m_sweep_seq) so that when a new ban
moves the scheduled time forward, all previously-queued callbacks
are invalidated. Stale callbacks check their captured sequence
number against the current one and bail immediately without
locking or sweeping.

Fixes bitcoinknots#273

Author: Bortlesboat

src/banman.cpp

@@ -9,10 +9,14 @@
 #include <logging.h>
 #include <netaddress.h>
 #include <node/interface_ui.h>
+#include <scheduler.h>
 #include <sync.h>
 #include <util/time.h>
 #include <util/translation.h>
 
+#include <algorithm>
+#include <limits>
+
 
 BanMan::BanMan(fs::path ban_file, CClientUIInterface* client_interface, int64_t default_ban_time)
     : m_client_interface(client_interface), m_ban_db(std::move(ban_file)), m_default_ban_time(default_ban_time)
@@ -26,6 +30,43 @@ BanMan::~BanMan()
     DumpBanlist();
 }
 
+void BanMan::StartScheduledTasks(CScheduler& scheduler)
+{
+    LOCK(m_banned_mutex);
+    m_scheduler = &scheduler;
+    ScheduleNextSweep();
+}
+
+void BanMan::SweepBannedAndSchedule(uint64_t expected_seq)
+{
+    LOCK(m_banned_mutex);
+    if (expected_seq != m_sweep_seq) return;
+    SweepBanned();
+    m_next_sweep_time = std::numeric_limits<int64_t>::max();
+    ScheduleNextSweep();
+}
+
+void BanMan::ScheduleNextSweep()
+{
+    AssertLockHeld(m_banned_mutex);
+
+    if (!m_scheduler) return;
+    if (m_banned.empty()) return;
+
+    int64_t earliest = std::numeric_limits<int64_t>::max();
+    for (const auto& [subnet, entry] : m_banned) {
+        if (entry.nBanUntil < earliest) {
+            earliest = entry.nBanUntil;
+        }
+    }
+
+    m_next_sweep_time = earliest;
+    uint64_t seq = ++m_sweep_seq;
+    int64_t now = GetTime();
+    auto delay = std::chrono::seconds(std::max<int64_t>(0, earliest - now));
+    m_scheduler->scheduleFromNow([this, seq] { SweepBannedAndSchedule(seq); }, delay);
+}
+
 void BanMan::LoadBanlist()
 {
     LOCK(m_banned_mutex);
@@ -144,6 +185,13 @@ void BanMan::Ban(const CSubNet& sub_net, int64_t ban_time_offset, bool since_uni
         if (m_banned[sub_net].nBanUntil < ban_entry.nBanUntil) {
             m_banned[sub_net] = ban_entry;
             m_is_dirty = true;
+            if (m_scheduler && ban_entry.nBanUntil < m_next_sweep_time) {
+                m_next_sweep_time = ban_entry.nBanUntil;
+                uint64_t seq = ++m_sweep_seq;
+                int64_t now = GetTime();
+                auto delay = std::chrono::seconds(std::max<int64_t>(0, m_next_sweep_time - now));
+                m_scheduler->scheduleFromNow([this, seq] { SweepBannedAndSchedule(seq); }, delay);
+            }
         } else
             return;
     }

src/banman.h

@@ -13,6 +13,7 @@
 
 #include <chrono>
 #include <cstdint>
+#include <limits>
 #include <memory>
 
 // NOTE: When adjusting this, update rpcnet:setban's help ("24h")
@@ -23,6 +24,7 @@ static constexpr std::chrono::minutes DUMP_BANS_INTERVAL{15};
 
 class CClientUIInterface;
 class CNetAddr;
+class CScheduler;
 class CSubNet;
 
 // Banman manages two related but distinct concepts:
@@ -62,6 +64,7 @@ class BanMan
     BanMan(fs::path ban_file, CClientUIInterface* client_interface, int64_t default_ban_time);
     void Ban(const CNetAddr& net_addr, int64_t ban_time_offset = 0, bool since_unix_epoch = false) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
     void Ban(const CSubNet& sub_net, int64_t ban_time_offset = 0, bool since_unix_epoch = false) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
+    void StartScheduledTasks(CScheduler& scheduler) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
     void Discourage(const CNetAddr& net_addr) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
     void ClearBanned() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
 
@@ -83,8 +86,13 @@ class BanMan
     void LoadBanlist() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
     //!clean unused entries (if bantime has expired)
     void SweepBanned() EXCLUSIVE_LOCKS_REQUIRED(m_banned_mutex);
+    void SweepBannedAndSchedule(uint64_t expected_seq) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex);
+    void ScheduleNextSweep() EXCLUSIVE_LOCKS_REQUIRED(m_banned_mutex);
 
     Mutex m_banned_mutex;
+    CScheduler* m_scheduler GUARDED_BY(m_banned_mutex){nullptr};
+    int64_t m_next_sweep_time GUARDED_BY(m_banned_mutex){std::numeric_limits<int64_t>::max()};
+    uint64_t m_sweep_seq GUARDED_BY(m_banned_mutex){0};
     banmap_t m_banned GUARDED_BY(m_banned_mutex);
     bool m_is_dirty GUARDED_BY(m_banned_mutex){false};
     CClientUIInterface* m_client_interface = nullptr;

src/init.cpp

@@ -2437,6 +2437,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         banman->DumpBanlist();
     }, DUMP_BANS_INTERVAL);
 
+    banman->StartScheduledTasks(scheduler);
+
     if (node.peerman) node.peerman->StartScheduledTasks(scheduler);
 
 #if HAVE_SYSTEM