more setvalue fixes and concurrency cleanup

veilid-core/src/routing_table/mod.rs

@@ -54,6 +54,9 @@ const ROUTING_TABLE: &str = "routing_table";
 const SERIALIZED_BUCKET_MAP: &[u8] = b"serialized_bucket_map";
 const CACHE_VALIDITY_KEY: &[u8] = b"cache_validity_key";
 
+// Critical sections
+const LOCK_TAG_TICK: &str = "TICK";
+
 pub type LowLevelProtocolPorts = BTreeSet<(LowLevelProtocolType, AddressType, u16)>;
 pub type ProtocolToPortMapping = BTreeMap<(ProtocolType, AddressType), (LowLevelProtocolType, u16)>;
 #[derive(Clone, Debug)]

veilid-core/src/routing_table/routing_domain_editor.rs

@@ -129,9 +129,11 @@ impl RoutingDomainEditor {
         }
 
         // Briefly pause routing table ticker while changes are made
-        if pause_tasks {
-            self.routing_table.pause_tasks(true).await;
-        }
+        let _tick_guard = if pause_tasks {
+            Some(self.routing_table.pause_tasks().await)
+        } else {
+            None
+        };
 
         // Apply changes
         let mut changed = false;
@@ -262,8 +264,5 @@ impl RoutingDomainEditor {
                 rss.reset();
             }
         }
-
-        // Unpause routing table ticker
-        self.routing_table.pause_tasks(false).await;
     }
 }

veilid-core/src/routing_table/routing_table_inner.rs

@@ -2,6 +2,7 @@ use super::*;
 use weak_table::PtrWeakHashSet;
 
 const RECENT_PEERS_TABLE_SIZE: usize = 64;
+
 pub type EntryCounts = BTreeMap<(RoutingDomain, CryptoKind), usize>;
 //////////////////////////////////////////////////////////////////////////
 
@@ -34,8 +35,9 @@ pub struct RoutingTableInner {
     pub(super) recent_peers: LruCache<TypedKey, RecentPeersEntry>,
     /// Storage for private/safety RouteSpecs
     pub(super) route_spec_store: Option<RouteSpecStore>,
-    /// Tick paused or not
-    pub(super) tick_paused: bool,
+    /// Async tagged critical sections table
+    /// Tag: "tick" -> in ticker
+    pub(super) critical_sections: AsyncTagLockTable<&'static str>,
 }
 
 impl RoutingTableInner {
@@ -52,7 +54,7 @@ impl RoutingTableInner {
             self_transfer_stats: TransferStatsDownUp::default(),
             recent_peers: LruCache::new(RECENT_PEERS_TABLE_SIZE),
             route_spec_store: None,
-            tick_paused: false,
+            critical_sections: AsyncTagLockTable::new(),
         }
     }
 

veilid-core/src/routing_table/tasks/mod.rs

@@ -126,9 +126,13 @@ impl RoutingTable {
     /// to run tick tasks which may run at slower tick rates as configured
     pub async fn tick(&self) -> EyreResult<()> {
         // Don't tick if paused
-        if self.inner.read().tick_paused {
+        let opt_tick_guard = {
+            let inner = self.inner.read();
+            inner.critical_sections.try_lock_tag(LOCK_TAG_TICK)
+        };
+        let Some(_tick_guard) = opt_tick_guard else {
             return Ok(());
-        }
+        };
 
         // Do rolling transfers every ROLLING_TRANSFERS_INTERVAL_SECS secs
         self.unlocked_inner.rolling_transfers_task.tick().await?;
@@ -183,22 +187,9 @@ impl RoutingTable {
 
         Ok(())
     }
-    pub(crate) async fn pause_tasks(&self, paused: bool) {
-        let cancel = {
-            let mut inner = self.inner.write();
-            if !inner.tick_paused && paused {
-                inner.tick_paused = true;
-                true
-            } else if inner.tick_paused && !paused {
-                inner.tick_paused = false;
-                false
-            } else {
-                false
-            }
-        };
-        if cancel {
-            self.cancel_tasks().await;
-        }
+    pub(crate) async fn pause_tasks(&self) -> AsyncTagLockGuard<&'static str> {
+        let critical_sections = self.inner.read().critical_sections.clone();
+        critical_sections.lock_tag(LOCK_TAG_TICK).await
     }
 
     pub(crate) async fn cancel_tasks(&self) {