From 432dfe3b9b97062be243609d69e0f49bdb0bcaf6 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Fri, 22 Jul 2022 15:48:20 +0200
Subject: Fixed a rarely used part of Babel: comparing two routes in table by
 their metric

---
 proto/babel/babel.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 7ea1aba8..ecfd2763 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -2338,8 +2338,8 @@ babel_rt_notify(struct proto *P, struct channel *c UNUSED, struct network *net,
 static int
 babel_rte_better(struct rte *new, struct rte *old)
 {
-  uint new_metric = ea_find(new->attrs->eattrs, EA_BABEL_SEQNO)->u.data;
-  uint old_metric = ea_find(old->attrs->eattrs, EA_BABEL_SEQNO)->u.data;
+  uint new_metric = ea_get_int(new->attrs->eattrs, EA_BABEL_METRIC, BABEL_INFINITY);
+  uint old_metric = ea_get_int(old->attrs->eattrs, EA_BABEL_METRIC, BABEL_INFINITY);
 
   return new_metric < old_metric;
 }
-- 
cgit v1.2.3


From 73abd91ac661f28d9341c7fbb80d2f7a71db186d Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Fri, 22 Jul 2022 16:09:37 +0200
Subject: rip_rte_better() uses the IGP_METRIC_UNKNOWN instead of
 protocol-specific infinity

---
 proto/rip/rip.c | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index 6ca7a6b5..b0b5b8a1 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -1101,24 +1101,18 @@ rip_reload_routes(struct channel *C)
   rip_kick_timer(p);
 }
 
-static int
-rip_rte_better(struct rte *new, struct rte *old)
-{
-  ASSERT_DIE(new->src == old->src);
-  struct rip_proto *p = (struct rip_proto *) new->src->proto;
-
-  u32 new_metric = ea_get_int(new->attrs->eattrs, EA_RIP_METRIC, p->infinity);
-  u32 old_metric = ea_get_int(old->attrs->eattrs, EA_RIP_METRIC, p->infinity);
-
-  return new_metric < old_metric;
-}
-
 static u32
 rip_rte_igp_metric(struct rte *rt)
 {
   return ea_get_int(rt->attrs->eattrs, EA_RIP_METRIC, IGP_METRIC_UNKNOWN);
 }
 
+static int
+rip_rte_better(struct rte *new, struct rte *old)
+{
+  return rip_rte_igp_metric(new) < rip_rte_igp_metric(old);
+}
+
 static void
 rip_postconfig(struct proto_config *CF)
 {
-- 
cgit v1.2.3


From 34912b029b161cbbed44057dfa913669ccb087eb Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Tue, 30 Aug 2022 18:05:00 +0200
Subject: Tables: Requesting prune only after export cleanup

We can't free the network structures before the export has been cleaned
up, therefore it makes more sense to request prune only after export
cleanup. This change also reduces prune calls on table shutdown.
---
 nest/rt-table.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index 3ade4237..8e1e03fb 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1748,10 +1748,6 @@ rte_recalculate(struct rt_import_hook *c, net *net, rte *new, struct rte_src *sr
   rte_announce(table, net, new_stored, old_stored,
       net->routes, old_best_stored);
 
-  if (!net->routes &&
-      (table->gc_counter++ >= table->config->gc_threshold))
-    rt_kick_prune_timer(table);
-
 #if 0
   /* Enable and reimplement these callbacks if anybody wants to use them */
   if (old_ok && p->rte_remove)
@@ -2852,6 +2848,7 @@ rt_export_cleanup(rtable *tab)
   u64 min_seq = ~((u64) 0);
   struct rt_pending_export *last_export_to_free = NULL;
   struct rt_pending_export *first = tab->exporter.first;
+  int want_prune = 0;
 
   struct rt_export_hook *eh;
   node *n;
@@ -2928,6 +2925,8 @@ rt_export_cleanup(rtable *tab)
       /* First is now the next one */
       net->first = atomic_load_explicit(&first->next, memory_order_relaxed);
 
+    want_prune += !net->routes && !net->first;
+
     /* For now, the old route may be finally freed */
     if (first->old)
     {
@@ -3003,6 +3002,9 @@ done:;
 	rt_unlock_table(tab);
       }
 
+  if ((tab->gc_counter += want_prune) >= tab->config->gc_threshold)
+    rt_kick_prune_timer(tab);
+
   if (tab->export_used)
     ev_schedule(tab->rt_event);
 
-- 
cgit v1.2.3


From 397fec4741b40f61d06a467b4110aad7e996485c Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Thu, 1 Sep 2022 14:21:56 +0200
Subject: Default tables are not created unless actually used.

This allows for setting default table values at the beginning of config
file before "master4" and "master6" tables are initialized.
---
 conf/conf.h           |  2 +-
 nest/config.Y         |  7 ++++++-
 nest/proto.c          |  2 +-
 nest/rt-show.c        |  4 ++--
 nest/rt-table.c       | 50 ++++++++++++++++++++++++++++++++++++++++----------
 nest/rt.h             |  2 ++
 proto/bgp/bgp.c       |  4 ++--
 proto/static/static.c |  4 ++--
 8 files changed, 56 insertions(+), 19 deletions(-)

diff --git a/conf/conf.h b/conf/conf.h
index 50e01bf5..ffefa519 100644
--- a/conf/conf.h
+++ b/conf/conf.h
@@ -27,7 +27,7 @@ struct config {
 
   int mrtdump_file;			/* Configured MRTDump file (sysdep, fd in unix) */
   const char *syslog_name;		/* Name used for syslog (NULL -> no syslog) */
-  struct rtable_config *def_tables[NET_MAX]; /* Default routing tables for each network */
+  struct symbol *def_tables[NET_MAX];	/* Default routing tables for each network */
   struct iface_patt *router_id_from;	/* Configured list of router ID iface patterns */
 
   u32 router_id;			/* Our Router ID */
diff --git a/nest/config.Y b/nest/config.Y
index 91147a29..4bf0fefe 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -361,7 +361,11 @@ channel_end:
 proto_channel: channel_start channel_opt_list channel_end;
 
 
-rtable: CF_SYM_KNOWN { cf_assert_symbol($1, SYM_TABLE); $$ = $1->table; } ;
+rtable: CF_SYM_KNOWN {
+  cf_assert_symbol($1, SYM_TABLE);
+  if (!$1->table) rt_new_default_table($1);
+  $$ = $1->table;
+} ;
 
 imexport:
    FILTER filter { $$ = $2; }
@@ -683,6 +687,7 @@ r_args:
    }
 | r_args TABLE symbol_known {
      cf_assert_symbol($3, SYM_TABLE);
+     if (!$3->table) cf_error("Table %s not configured", $3->name);
      $$ = $1;
      rt_show_add_table($$, $3->table->table);
      $$->tables_defined_by = RSD_TDB_DIRECT;
diff --git a/nest/proto.c b/nest/proto.c
index 853b1cf9..ef3e3f4d 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -864,7 +864,7 @@ channel_config_new(const struct channel_class *cc, const char *name, uint net_ty
     if (proto->net_type && (net_type != proto->net_type))
       cf_error("Different channel type");
 
-    tab = new_config->def_tables[net_type];
+    tab = rt_get_default_table(new_config, net_type);
   }
 
   if (!cc)
diff --git a/nest/rt-show.c b/nest/rt-show.c
index 17400029..5d7723cf 100644
--- a/nest/rt-show.c
+++ b/nest/rt-show.c
@@ -400,8 +400,8 @@ rt_show_get_default_tables(struct rt_show_data *d)
   }
 
   for (int i=1; i<NET_MAX; i++)
-    if (config->def_tables[i] && config->def_tables[i]->table)
-      rt_show_add_table(d, config->def_tables[i]->table);
+    if (config->def_tables[i] && config->def_tables[i]->table && config->def_tables[i]->table->table)
+      rt_show_add_table(d, config->def_tables[i]->table->table);
 }
 
 static inline void
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 8e1e03fb..f0552965 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -3094,8 +3094,8 @@ rt_preconfig(struct config *c)
 {
   init_list(&c->tables);
 
-  rt_new_table(cf_get_symbol("master4"), NET_IP4);
-  rt_new_table(cf_get_symbol("master6"), NET_IP6);
+  c->def_tables[NET_IP4] = cf_define_symbol(cf_get_symbol("master4"), SYM_TABLE, table, NULL);
+  c->def_tables[NET_IP6] = cf_define_symbol(cf_get_symbol("master6"), SYM_TABLE, table, NULL);
 }
 
 void
@@ -3110,6 +3110,13 @@ rt_postconfig(struct config *c)
   WALK_LIST(rc, c->tables)
     if (rc->gc_period == (uint) -1)
       rc->gc_period = (uint) def_gc_period;
+
+  for (uint net_type = 0; net_type < NET_MAX; net_type++)
+    if (c->def_tables[net_type] && !c->def_tables[net_type]->table)
+    {
+      c->def_tables[net_type]->class = SYM_VOID;
+      c->def_tables[net_type] = NULL;
+    }
 }
 
 
@@ -3584,19 +3591,42 @@ rt_next_hop_update(rtable *tab)
     ev_schedule(tab->rt_event);
 }
 
+void
+rt_new_default_table(struct symbol *s)
+{
+  for (uint addr_type = 0; addr_type < NET_MAX; addr_type++)
+    if (s == new_config->def_tables[addr_type])
+    {
+      s->table = rt_new_table(s, addr_type);
+      return;
+    }
+
+  bug("Requested an unknown new default table: %s", s->name);
+}
+
+struct rtable_config *
+rt_get_default_table(struct config *cf, uint addr_type)
+{
+  struct symbol *ts = cf->def_tables[addr_type];
+  if (!ts)
+    return NULL;
+
+  if (!ts->table)
+    rt_new_default_table(ts);
+
+  return ts->table;
+}
 
 struct rtable_config *
 rt_new_table(struct symbol *s, uint addr_type)
 {
-  /* Hack that allows to 'redefine' the master table */
-  if ((s->class == SYM_TABLE) &&
-      (s->table == new_config->def_tables[addr_type]) &&
-      ((addr_type == NET_IP4) || (addr_type == NET_IP6)))
-    return s->table;
-
   struct rtable_config *c = cfg_allocz(sizeof(struct rtable_config));
 
-  cf_define_symbol(s, SYM_TABLE, table, c);
+  if (s == new_config->def_tables[addr_type])
+    s->table = c;
+  else
+    cf_define_symbol(s, SYM_TABLE, table, c);
+
   c->name = s->name;
   c->addr_type = addr_type;
   c->gc_threshold = 1000;
@@ -3610,7 +3640,7 @@ rt_new_table(struct symbol *s, uint addr_type)
 
   /* First table of each type is kept as default */
   if (! new_config->def_tables[addr_type])
-    new_config->def_tables[addr_type] = c;
+    new_config->def_tables[addr_type] = s;
 
   return c;
 }
diff --git a/nest/rt.h b/nest/rt.h
index 1a6b7a93..f5cf9457 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -481,6 +481,8 @@ void rt_reload_channel_abort(struct channel *c);
 void rt_refeed_channel(struct channel *c);
 void rt_prune_sync(rtable *t, int all);
 struct rtable_config *rt_new_table(struct symbol *s, uint addr_type);
+void rt_new_default_table(struct symbol *s);
+struct rtable_config *rt_get_default_table(struct config *cf, uint addr_type);
 
 static inline int rt_is_ip(rtable *tab)
 { return (tab->addr_type == NET_IP4) || (tab->addr_type == NET_IP6); }
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 68c788ea..97b18fcf 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -1934,7 +1934,7 @@ bgp_default_igp_table(struct bgp_config *cf, struct bgp_channel_config *cc, u32
     return cc2->c.table;
 
   /* Last, try default table of given type */
-  if (tab = cf->c.global->def_tables[type])
+  if (tab = rt_get_default_table(cf->c.global, type))
     return tab;
 
   cf_error("Undefined IGP table");
@@ -1953,7 +1953,7 @@ bgp_default_base_table(struct bgp_config *cf, struct bgp_channel_config *cc)
     return cc2->c.table;
 
   /* Last, try default table of given type */
-  struct rtable_config *tab = cf->c.global->def_tables[type];
+  struct rtable_config *tab = rt_get_default_table(cf->c.global, type);
   if (tab)
     return tab;
 
diff --git a/proto/static/static.c b/proto/static/static.c
index 65f3eccc..cb764a1c 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -436,11 +436,11 @@ static_postconfig(struct proto_config *CF)
 
   if (!cf->igp_table_ip4)
     cf->igp_table_ip4 = (cc->table->addr_type == NET_IP4) ?
-      cc->table : cf->c.global->def_tables[NET_IP4];
+      cc->table : rt_get_default_table(cf->c.global, NET_IP4);
 
   if (!cf->igp_table_ip6)
     cf->igp_table_ip6 = (cc->table->addr_type == NET_IP6) ?
-      cc->table : cf->c.global->def_tables[NET_IP6];
+      cc->table : rt_get_default_table(cf->c.global, NET_IP6);
 
   WALK_LIST(r, cf->routes)
     if (r->net && (r->net->type != CF->net_type))
-- 
cgit v1.2.3


From 83ceb91b50ae75ee5509faa74e2f6d4bdcf78505 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Tue, 30 Aug 2022 19:40:58 +0200
Subject: Table debug is now a per-table setting and has categories.

---
 doc/bird.sgml   | 15 +++++++++++++++
 nest/config.Y   |  3 ++-
 nest/rt-table.c | 32 ++++++++++++++++----------------
 nest/rt.h       |  1 +
 4 files changed, 34 insertions(+), 17 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index c29353fc..b12ac544 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -505,6 +505,11 @@ include "tablename.conf";;
 	See <ref id="channel-debug" name="debug"> in the channel section.
 	Default: off.
 
+	<tag><label id="opt-debug-tables">debug tables all|off|{ states|routes|filters|events [, <m/.../] }</tag>
+	Set global defaults of table debugging options.
+	See <ref id="rtable-debug" name="debug"> in the table section.
+	Default: off.
+
 	<tag><label id="opt-debug-commands">debug commands <m/number/</tag>
 	Control logging of client connections (0 for no logging, 1 for logging
 	of connects and disconnects, 2 and higher for logging of all client
@@ -708,6 +713,16 @@ to set options.
         second one is the high threshold (when to pause). The higher is the
         threshold, the more memory can get used. In most cases, the defaults
 	should work for you. Default: 128, 512.
+
+	<tag><label id="rtable-debug">debug all|off|{ states|routes|events [, <m/.../] }</tag>
+	Set table debugging options. Each table can write some trace messages
+	into log with category <cf/trace/. You can request <cf/all/ trace messages
+	or select some types: <cf/states/ for table state changes and auxiliary
+	processes, <cf/routes/ for auxiliary route notifications (next hop update,
+        flowspec revalidation) and <cf/events/ for more detailed auxiliary routine
+	debug. See also <ref id="channel-debug" name="channel debugging option">.
+	Default: off.
+
 </descrip>
 
 
diff --git a/nest/config.Y b/nest/config.Y
index 4bf0fefe..3ad6530d 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -235,6 +235,7 @@ table_opt:
      if ($3 > $4) cf_error("Cork low threshold must be lower than the high threshold.");
      this_table->cork_threshold.low = $3;
      this_table->cork_threshold.high = $4; }
+ | DEBUG bool { this_table->debug = $2; }
  ;
 
 table_opts:
@@ -394,7 +395,7 @@ debug_default:
    DEBUG PROTOCOLS debug_mask { new_config->proto_default_debug = $3; }
  | DEBUG CHANNELS debug_mask { new_config->channel_default_debug = $3; }
  | DEBUG COMMANDS expr { new_config->cli_debug = $3; }
- | DEBUG TABLES bool { new_config->table_debug = $3; }
+ | DEBUG TABLES debug_mask { new_config->table_debug = $3; }
  ;
 
 /* MRTDUMP PROTOCOLS is in systep/unix/config.Y */
diff --git a/nest/rt-table.c b/nest/rt-table.c
index f0552965..7fc0d280 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -188,6 +188,12 @@ const char *rt_export_state_name(u8 state)
 static inline struct rte_storage *rt_next_hop_update_rte(rtable *tab, net *n, rte *old);
 static struct hostentry *rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep);
 
+#define rt_trace(tab, level, fmt, args...)  do {\
+  rtable *t = (tab);				\
+  if (t->config->debug & (level))		\
+    log(L_TRACE "%s: " fmt, t->name, ##args);	\
+} while (0)
+
 static void
 net_init_with_trie(struct fib *f, void *N)
 {
@@ -2315,8 +2321,7 @@ rt_export_used(struct rt_exporter *e)
 {
   rtable *tab = SKIP_BACK(rtable, exporter, e);
 
-  if (config->table_debug)
-    log(L_TRACE "%s: Export cleanup requested", tab->name);
+  rt_trace(tab, D_EVENTS, "Export cleanup requested");
 
   if (tab->export_used)
     return;
@@ -2341,8 +2346,8 @@ rt_event(void *ptr)
       (tab->hcu_scheduled || tab->nhu_state) && rt_cork_check(tab->uncork_event)
       )
   {
-    if (!tab->hcu_corked && !tab->nhu_corked && config->table_debug)
-      log(L_TRACE "%s: Auxiliary routines corked", tab->name);
+    if (!tab->hcu_corked && !tab->nhu_corked)
+      rt_trace(tab, D_STATES, "Next hop updater corked");
 
     tab->hcu_corked |= tab->hcu_scheduled;
     tab->hcu_scheduled = 0;
@@ -2374,8 +2379,7 @@ rt_uncork_event(void *ptr)
   tab->nhu_state |= tab->nhu_corked;
   tab->nhu_corked = 0;
 
-  if (config->table_debug)
-    log(L_TRACE "%s: Auxiliary routines uncorked", tab->name);
+  rt_trace(tab, D_STATES, "Next hop updater uncorked");
 
   ev_schedule(tab->rt_event);
 }
@@ -2704,7 +2708,7 @@ rt_prune_table(rtable *tab)
   struct rt_import_hook *ih;
   node *n, *x;
 
-  DBG("Pruning route table %s\n", tab->name);
+  rt_trace(tab, D_STATES, "Pruning");
 #ifdef DEBUGGING
   fib_check(&tab->fib);
 #endif
@@ -2882,9 +2886,7 @@ rt_export_cleanup(rtable *tab)
 
   tab->exporter.first = last_export_to_free ? rt_next_export_fast(last_export_to_free) : NULL;
 
-  if (config->table_debug)
-    log(L_TRACE "%s: Export cleanup, old exporter.first seq %lu, new %lu, min_seq %ld",
-      tab->name,
+  rt_trace(tab, D_STATES, "Export cleanup, old exporter.first seq %lu, new %lu, min_seq %ld",
       first ? first->seq : 0,
       tab->exporter.first ? tab->exporter.first->seq : 0,
       min_seq);
@@ -2962,8 +2964,7 @@ rt_export_cleanup(rtable *tab)
 
       if (EMPTY_LIST(tab->exporter.pending))
       {
-	if (config->table_debug)
-	  log(L_TRACE "%s: Resetting export seq", tab->name);
+	rt_trace(tab, D_EVENTS, "Resetting export seq");
 
 	node *n;
 	WALK_LIST2(eh, n, tab->exporter.hooks, n)
@@ -3635,6 +3636,7 @@ rt_new_table(struct symbol *s, uint addr_type)
   c->max_settle_time = 20 S;
   c->cork_threshold.low = 128;
   c->cork_threshold.high = 512;
+  c->debug = new_config->table_debug;
 
   add_tail(&new_config->tables, &c->n);
 
@@ -3691,8 +3693,7 @@ rt_check_cork_low(rtable *tab)
     tab->cork_active = 0;
     rt_cork_release();
 
-    if (config->table_debug)
-      log(L_TRACE "%s: Uncorked", tab->name);
+    rt_trace(tab, D_STATES, "Uncorked");
   }
 }
 
@@ -3704,8 +3705,7 @@ rt_check_cork_high(rtable *tab)
     tab->cork_active = 1;
     rt_cork_acquire();
 
-    if (config->table_debug)
-      log(L_TRACE "%s: Corked", tab->name);
+    rt_trace(tab, D_STATES, "Corked");
   }
 }
 
diff --git a/nest/rt.h b/nest/rt.h
index f5cf9457..66edf227 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -59,6 +59,7 @@ struct rtable_config {
   uint gc_period;			/* Approximate time between two consecutive GC runs */
   byte sorted;				/* Routes of network are sorted according to rte_better() */
   byte trie_used;			/* Rtable has attached trie */
+  byte debug;				/* Whether to log */
   btime min_settle_time;		/* Minimum settle time for notifications */
   btime max_settle_time;		/* Maximum settle time for notifications */
   btime export_settle_time;		/* Delay before exports are announced */
-- 
cgit v1.2.3


From 7450eea071941c683da158d6dfe8365288eed5b8 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 31 Aug 2022 11:58:27 +0200
Subject: Miscellaneous refactoring

---
 nest/proto.c      | 11 ++--------
 nest/rt-table.c   | 60 +++++++++++++++++++++++++------------------------------
 nest/rt.h         |  7 +++++++
 proto/bgp/attrs.c |  7 +++++++
 4 files changed, 43 insertions(+), 42 deletions(-)

diff --git a/nest/proto.c b/nest/proto.c
index ef3e3f4d..d2374792 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -450,12 +450,8 @@ channel_start_import(struct channel *c)
     return;
   }
 
-  int nlen = strlen(c->name) + strlen(c->proto->name) + 2;
-  char *rn = mb_allocz(c->proto->pool, nlen);
-  bsprintf(rn, "%s.%s", c->proto->name, c->name);
-
   c->in_req = (struct rt_import_request) {
-    .name = rn,
+    .name = mb_sprintf(c->proto->pool, "%s.%s", c->proto->name, c->name),
     .trace_routes = c->debug | c->proto->debug,
     .dump_req = channel_dump_import_req,
     .log_state_change = channel_import_log_state_change,
@@ -483,12 +479,9 @@ channel_start_export(struct channel *c)
   }
 
   ASSERT(c->channel_state == CS_UP);
-  int nlen = strlen(c->name) + strlen(c->proto->name) + 2;
-  char *rn = mb_allocz(c->proto->pool, nlen);
-  bsprintf(rn, "%s.%s", c->proto->name, c->name);
 
   c->out_req = (struct rt_export_request) {
-    .name = rn,
+    .name = mb_sprintf(c->proto->pool, "%s.%s", c->proto->name, c->name),
     .list = proto_work_list(c->proto),
     .addr = c->out_subprefix,
     .addr_mode = c->out_subprefix ? TE_ADDR_IN : TE_ADDR_NONE,
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 7fc0d280..d4e0d63c 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -908,7 +908,7 @@ channel_rpe_mark_seen(struct rt_export_request *req, struct rt_pending_export *r
 }
 
 void
-rt_notify_accepted(struct rt_export_request *req, const net_addr *n, struct rt_pending_export *rpe,
+rt_notify_accepted(struct rt_export_request *req, const net_addr *n, struct rt_pending_export *first,
     struct rte **feed, uint count)
 {
   struct channel *c = SKIP_BACK(struct channel, out_req, req);
@@ -952,7 +952,7 @@ rt_notify_accepted(struct rt_export_request *req, const net_addr *n, struct rt_p
 
 done:
   /* Check obsolete routes for previously exported */
-  while (rpe)
+  RPE_WALK(first, rpe, NULL)
   {
     channel_rpe_mark_seen(req, rpe);
     if (rpe->old)
@@ -963,7 +963,6 @@ done:
 	old_best = &rpe->old->rte;
       }
     }
-    rpe = rpe_next(rpe, NULL);
   }
 
   /* Nothing to export */
@@ -1036,7 +1035,7 @@ rt_export_merged(struct channel *c, struct rte **feed, uint count, linpool *pool
 }
 
 void
-rt_notify_merged(struct rt_export_request *req, const net_addr *n, struct rt_pending_export *rpe,
+rt_notify_merged(struct rt_export_request *req, const net_addr *n, struct rt_pending_export *first,
     struct rte **feed, uint count)
 {
   struct channel *c = SKIP_BACK(struct channel, out_req, req);
@@ -1062,7 +1061,7 @@ rt_notify_merged(struct rt_export_request *req, const net_addr *n, struct rt_pen
     }
 
   /* Check obsolete routes for previously exported */
-  while (rpe)
+  RPE_WALK(first, rpe, NULL)
   {
     channel_rpe_mark_seen(req, rpe);
     if (rpe->old)
@@ -1073,7 +1072,6 @@ rt_notify_merged(struct rt_export_request *req, const net_addr *n, struct rt_pen
 	old_best = &rpe->old->rte;
       }
     }
-    rpe = rpe_next(rpe, NULL);
   }
 
   /* Prepare new merged route */
@@ -1084,17 +1082,16 @@ rt_notify_merged(struct rt_export_request *req, const net_addr *n, struct rt_pen
 }
 
 void
-rt_notify_optimal(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *rpe)
+rt_notify_optimal(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *first)
 {
   struct channel *c = SKIP_BACK(struct channel, out_req, req);
-  rte *o = RTE_VALID_OR_NULL(rpe->old_best);
-  struct rte_storage *new_best = rpe->new_best;
+  rte *o = RTE_VALID_OR_NULL(first->old_best);
+  struct rte_storage *new_best = first->new_best;
 
-  while (rpe)
+  RPE_WALK(first, rpe, NULL)
   {
     channel_rpe_mark_seen(req, rpe);
     new_best = rpe->new_best;
-    rpe = rpe_next(rpe, NULL);
   }
 
   rte n0 = RTE_COPY_VALID(new_best);
@@ -1103,27 +1100,26 @@ rt_notify_optimal(struct rt_export_request *req, const net_addr *net, struct rt_
 }
 
 void
-rt_notify_any(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *rpe)
+rt_notify_any(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *first)
 {
   struct channel *c = SKIP_BACK(struct channel, out_req, req);
 
-  rte *n = RTE_VALID_OR_NULL(rpe->new);
-  rte *o = RTE_VALID_OR_NULL(rpe->old);
+  rte *n = RTE_VALID_OR_NULL(first->new);
+  rte *o = RTE_VALID_OR_NULL(first->old);
 
   if (!n && !o)
   {
-    channel_rpe_mark_seen(req, rpe);
+    channel_rpe_mark_seen(req, first);
     return;
   }
 
   struct rte_src *src = n ? n->src : o->src;
-  struct rte_storage *new_latest = rpe->new;
+  struct rte_storage *new_latest = first->new;
 
-  while (rpe)
+  RPE_WALK(first, rpe, src)
   {
     channel_rpe_mark_seen(req, rpe);
     new_latest = rpe->new;
-    rpe = rpe_next(rpe, src);
   }
 
   rte n0 = RTE_COPY_VALID(new_latest);
@@ -1362,7 +1358,7 @@ rte_announce(rtable *tab, net *net, struct rte_storage *new, struct rte_storage
 	  &net->last->next, &rpenull, rpe,
 	  memory_order_relaxed,
 	  memory_order_relaxed));
-    
+
   }
 
   net->last = rpe;
@@ -1918,8 +1914,13 @@ rt_table_export_done(struct rt_export_hook *hook)
   struct rt_exporter *re = hook->table;
   struct rtable *tab = SKIP_BACK(struct rtable, exporter, re);
 
-  rt_unlock_table(tab);
   DBG("Export hook %p in table %s finished uc=%u\n", hook, tab->name, tab->use_count);
+
+  /* Free the hook before unlocking the table */
+  rfree(hook->pool);
+
+  /* Unlock the table; this may free it */
+  rt_unlock_table(tab);
 }
 
 static void
@@ -1935,13 +1936,10 @@ rt_export_stopped(void *data)
   rem_node(&hook->n);
 
   /* Report the channel as stopped. */
-  hook->stopped(hook->req);
+  CALL(hook->stopped, hook->req);
 
   /* Reporting the hook as finished. */
   CALL(tab->done, hook);
-
-  /* Free the hook. */
-  rfree(hook->pool);
 }
 
 static inline void
@@ -1950,8 +1948,7 @@ rt_set_import_state(struct rt_import_hook *hook, u8 state)
   hook->last_state_change = current_time();
   hook->import_state = state;
 
-  if (hook->req->log_state_change)
-    hook->req->log_state_change(hook->req, state);
+  CALL(hook->req->log_state_change, hook->req, state);
 }
 
 void
@@ -1960,8 +1957,7 @@ rt_set_export_state(struct rt_export_hook *hook, u8 state)
   hook->last_state_change = current_time();
   atomic_store_explicit(&hook->export_state, state, memory_order_release);
 
-  if (hook->req->log_state_change)
-    hook->req->log_state_change(hook->req, state);
+  CALL(hook->req->log_state_change, hook->req, state);
 }
 
 void
@@ -2919,7 +2915,7 @@ rt_export_cleanup(rtable *tab)
     net *net = SKIP_BACK(struct network, n.addr, (net_addr (*)[0]) n);
 
     ASSERT_DIE(net->first == first);
-    
+
     if (first == net->last)
       /* The only export here */
       net->last = net->first = NULL;
@@ -2949,7 +2945,7 @@ rt_export_cleanup(rtable *tab)
     ASSERT_DIE(pos < end);
 
     struct rt_pending_export *next = NULL;
-    
+
     if (++pos < end)
       next = &reb->export[pos];
     else
@@ -3931,9 +3927,7 @@ rt_feed_net(struct rt_export_hook *c, net *n)
     count = 1;
   }
 
-  for (struct rt_pending_export *rpe = n->first; rpe; rpe = rpe_next(rpe, NULL))
-    rpe_mark_seen(c, rpe);
-
+  rpe_mark_seen_all(c, n->first, NULL);
   return count;
 }
 
diff --git a/nest/rt.h b/nest/rt.h
index 66edf227..e7ba55f6 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -386,9 +386,16 @@ void rte_import(struct rt_import_request *req, const net_addr *net, rte *new, st
 /* Get next rpe. If src is given, it must match. */
 struct rt_pending_export *rpe_next(struct rt_pending_export *rpe, struct rte_src *src);
 
+/* Walk all rpe's */
+#define RPE_WALK(first, it, src) \
+  for (struct rt_pending_export *it = (first); it; it = rpe_next(it, (src)))
+
 /* Mark the pending export processed */
 void rpe_mark_seen(struct rt_export_hook *hook, struct rt_pending_export *rpe);
 
+#define rpe_mark_seen_all(hook, first, src) \
+  RPE_WALK(first, rpe, src) rpe_mark_seen((hook), rpe)
+
 /* Get pending export seen status */
 int rpe_get_seen(struct rt_export_hook *hook, struct rt_pending_export *rpe);
 
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 2543ee73..84a0b023 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -1977,6 +1977,12 @@ bgp_out_table_export_start(struct rt_exporter *re, struct rt_export_request *req
   return hook;
 }
 
+static void
+bgp_out_table_export_done(struct rt_export_hook *hook)
+{
+  rfree(hook->pool);
+}
+
 void
 bgp_setup_out_table(struct bgp_channel *c)
 {
@@ -1985,6 +1991,7 @@ bgp_setup_out_table(struct bgp_channel *c)
   c->prefix_exporter = (struct rt_exporter) {
     .addr_type = c->c.table->addr_type,
     .start = bgp_out_table_export_start,
+    .done = bgp_out_table_export_done,
   };
 
   init_list(&c->prefix_exporter.hooks);
-- 
cgit v1.2.3


From ecdb1ec6eabbf0c47c410e9bb8551ab5d039a650 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 31 Aug 2022 14:01:59 +0200
Subject: Hostcache update notification converted to an export hook

Instead of synchronous notifications, we use the asynchronous export
framework to notify also hostcache updates. This allows us to do the
hostcache update and the subsequent next hop update notification without
locking collisions.
---
 nest/rt-table.c | 120 ++++++++++++++++++++++++++++++++++----------------------
 nest/rt.h       |  73 ++++++++++++++++++----------------
 2 files changed, 112 insertions(+), 81 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index d4e0d63c..e23e766e 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -43,10 +43,10 @@
  * all prefixes that may influence resolving of tracked next hops.
  *
  * When a best route changes in the src table, the hostcache is notified using
- * rt_notify_hostcache(), which immediately checks using the trie whether the
+ * an auxiliary export request, which checks using the trie whether the
  * change is relevant and if it is, then it schedules asynchronous hostcache
  * recomputation. The recomputation is done by rt_update_hostcache() (called
- * from rt_event() of src table), it walks through all hostentries and resolves
+ * as an event of src table), it walks through all hostentries and resolves
  * them (by rt_update_hostentry()). It also updates the trie. If a change in
  * hostentry resolution was found, then it schedules asynchronous nexthop
  * recomputation of associated dst table. That is done by rt_next_hop_update()
@@ -130,8 +130,7 @@ struct rt_export_block {
 };
 
 static void rt_free_hostcache(rtable *tab);
-static void rt_notify_hostcache(rtable *tab, net *net);
-static void rt_update_hostcache(rtable *tab);
+static void rt_update_hostcache(void *tab);
 static void rt_next_hop_update(rtable *tab);
 static inline void rt_next_hop_resolve_rte(rte *r);
 static inline void rt_flowspec_resolve_rte(rte *r, struct channel *c);
@@ -1280,9 +1279,6 @@ rte_announce(rtable *tab, net *net, struct rte_storage *new, struct rte_storage
     if (old_best_valid)
       old_best->rte.sender->stats.pref--;
 
-    if (tab->hostcache)
-      rt_notify_hostcache(tab, net);
-
     if (!EMPTY_LIST(tab->flowspec_links))
       rt_flowspec_notify(tab, net);
   }
@@ -2238,8 +2234,8 @@ void
 rt_dump_hooks(rtable *tab)
 {
   debug("Dump of hooks in routing table <%s>%s\n", tab->name, tab->deleted ? " (deleted)" : "");
-  debug("  nhu_state=%u hcu_scheduled=%u use_count=%d rt_count=%u\n",
-      tab->nhu_state, tab->hcu_scheduled, tab->use_count, tab->rt_count);
+  debug("  nhu_state=%u use_count=%d rt_count=%u\n",
+      tab->nhu_state, tab->use_count, tab->rt_count);
   debug("  last_rt_change=%t gc_time=%t gc_counter=%d prune_state=%u\n",
       tab->last_rt_change, tab->gc_time, tab->gc_counter, tab->prune_state);
 
@@ -2279,16 +2275,6 @@ rt_dump_hooks_all(void)
     rt_dump_hooks(t);
 }
 
-static inline void
-rt_schedule_hcu(rtable *tab)
-{
-  if (tab->hcu_scheduled)
-    return;
-
-  tab->hcu_scheduled = 1;
-  ev_schedule(tab->rt_event);
-}
-
 static inline void
 rt_schedule_nhu(rtable *tab)
 {
@@ -2336,25 +2322,15 @@ rt_event(void *ptr)
   if (tab->export_used)
     rt_export_cleanup(tab);
 
-  if (
-      tab->hcu_corked ||
-      tab->nhu_corked ||
-      (tab->hcu_scheduled || tab->nhu_state) && rt_cork_check(tab->uncork_event)
-      )
+  if (tab->nhu_corked || tab->nhu_state && rt_cork_check(tab->uncork_event))
   {
-    if (!tab->hcu_corked && !tab->nhu_corked)
+    if (!tab->nhu_corked)
       rt_trace(tab, D_STATES, "Next hop updater corked");
 
-    tab->hcu_corked |= tab->hcu_scheduled;
-    tab->hcu_scheduled = 0;
-
     tab->nhu_corked |= tab->nhu_state;
     tab->nhu_state = 0;
   }
 
-  if (tab->hcu_scheduled)
-    rt_update_hostcache(tab);
-
   if (tab->nhu_state)
     rt_next_hop_update(tab);
 
@@ -2369,9 +2345,6 @@ rt_uncork_event(void *ptr)
 {
   rtable *tab = ptr;
 
-  tab->hcu_scheduled |= tab->hcu_corked;
-  tab->hcu_corked = 0;
-
   tab->nhu_state |= tab->nhu_corked;
   tab->nhu_corked = 0;
 
@@ -3719,6 +3692,9 @@ rt_reconfigure(rtable *tab, struct rtable_config *new, struct rtable_config *old
   tab->name = new->name;
   tab->config = new;
 
+  if (tab->hostcache)
+    tab->hostcache->req.trace_routes = new->debug;
+
   tab->cork_threshold = new->cork_threshold;
 
   if (new->cork_threshold.high != old->cork_threshold.high)
@@ -3771,6 +3747,10 @@ rt_commit(struct config *new, struct config *old)
 	  tab->deleted = old;
 	  config_add_obstacle(old);
 	  rt_lock_table(tab);
+
+	  if (tab->hostcache)
+	    rt_stop_export(&tab->hostcache->req, NULL);
+
 	  rt_unlock_table(tab);
 	}
     }
@@ -4055,6 +4035,41 @@ hc_delete_hostentry(struct hostcache *hc, pool *p, struct hostentry *he)
     hc_resize(hc, p, hc->hash_order - HC_LO_STEP);
 }
 
+static void
+hc_notify_dump_req(struct rt_export_request *req)
+{
+  debug("  Table %s (%p)\n", req->name, req);
+}
+
+static void
+hc_notify_export_one(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *first)
+{
+  struct hostcache *hc = SKIP_BACK(struct hostcache, req, req);
+
+  /* No interest in this update, mark seen only */
+  if (ev_active(&hc->update) || !trie_match_net(hc->trie, net))
+  {
+    rpe_mark_seen_all(req->hook, first, NULL);
+    return;
+  }
+
+  /* This net may affect some hostentries, check the actual change */
+  rte *o = RTE_VALID_OR_NULL(first->old_best);
+  struct rte_storage *new_best = first->new_best;
+
+  RPE_WALK(first, rpe, NULL)
+  {
+    rpe_mark_seen(req->hook, rpe);
+    new_best = rpe->new_best;
+  }
+
+  /* Yes, something has actually changed. Do the hostcache update.
+   * We don't need any more updates until then. */
+  if (o != RTE_VALID_OR_NULL(new_best))
+    ev_schedule_work(&hc->update);
+}
+
+
 static void
 rt_init_hostcache(rtable *tab)
 {
@@ -4068,6 +4083,21 @@ rt_init_hostcache(rtable *tab)
   hc->lp = lp_new(tab->rp);
   hc->trie = f_new_trie(hc->lp, 0);
 
+  hc->update = (event) {
+    .hook = rt_update_hostcache,
+    .data = tab,
+  };
+
+  hc->req = (struct rt_export_request) {
+    .name = mb_sprintf(tab->rp, "%s.hcu.notifier", tab->name),
+    .list = &global_work_list,
+    .trace_routes = tab->config->debug,
+    .dump_req = hc_notify_dump_req,
+    .export_one = hc_notify_export_one,
+  };
+
+  rt_request_export(&tab->exporter, &hc->req);
+
   tab->hostcache = hc;
 }
 
@@ -4094,16 +4124,6 @@ rt_free_hostcache(rtable *tab)
   */
 }
 
-static void
-rt_notify_hostcache(rtable *tab, net *net)
-{
-  if (tab->hcu_scheduled)
-    return;
-
-  if (trie_match_net(tab->hostcache->trie, net->n.addr))
-    rt_schedule_hcu(tab);
-}
-
 static int
 if_local_addr(ip_addr a, struct iface *i)
 {
@@ -4200,9 +4220,17 @@ done:
 }
 
 static void
-rt_update_hostcache(rtable *tab)
+rt_update_hostcache(void *data)
 {
+  rtable *tab = data;
   struct hostcache *hc = tab->hostcache;
+
+  if (rt_cork_check(&hc->update))
+  {
+    rt_trace(tab, D_STATES, "Hostcache update corked");
+    return;
+  }
+
   struct hostentry *he;
   node *n, *x;
 
@@ -4222,8 +4250,6 @@ rt_update_hostcache(rtable *tab)
       if (rt_update_hostentry(tab, he))
 	rt_schedule_nhu(he->tab);
     }
-
-  tab->hcu_scheduled = 0;
 }
 
 static struct hostentry *
diff --git a/nest/rt.h b/nest/rt.h
index e7ba55f6..5839ba66 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -27,6 +27,7 @@ struct protocol;
 struct proto;
 struct channel;
 struct rte_src;
+struct hostcache;
 struct symbol;
 struct timer;
 struct filter;
@@ -116,8 +117,6 @@ typedef struct rtable {
   uint gc_counter;			/* Number of operations since last GC */
   byte prune_state;			/* Table prune state, 1 -> scheduled, 2-> running */
   byte prune_trie;			/* Prune prefix trie during next table prune */
-  byte hcu_scheduled;			/* Hostcache update is scheduled */
-  byte hcu_corked;			/* Hostcache update is corked with this state */
   byte nhu_state;			/* Next Hop Update state */
   byte nhu_corked;			/* Next Hop Update is corked with this state */
   byte export_used;			/* Pending Export pruning is scheduled */
@@ -185,43 +184,12 @@ static inline int rt_cork_check(event *e)
 }
 
 
-#define NHU_CLEAN	0
-#define NHU_SCHEDULED	1
-#define NHU_RUNNING	2
-#define NHU_DIRTY	3
-
 typedef struct network {
   struct rte_storage *routes;		/* Available routes for this network */
   struct rt_pending_export *first, *last;
   struct fib_node n;			/* FIB flags reserved for kernel syncer */
 } net;
 
-struct hostcache {
-  slab *slab;				/* Slab holding all hostentries */
-  struct hostentry **hash_table;	/* Hash table for hostentries */
-  unsigned hash_order, hash_shift;
-  unsigned hash_max, hash_min;
-  unsigned hash_items;
-  linpool *lp;				/* Linpool for trie */
-  struct f_trie *trie;			/* Trie of prefixes that might affect hostentries */
-  list hostentries;			/* List of all hostentries */
-  byte update_hostcache;
-};
-
-struct hostentry {
-  node ln;
-  ip_addr addr;				/* IP address of host, part of key */
-  ip_addr link;				/* (link-local) IP address of host, used as gw
-					   if host is directly attached */
-  struct rtable *tab;			/* Dependent table, part of key */
-  struct hostentry *next;		/* Next in hash chain */
-  unsigned hash_key;			/* Hash key */
-  unsigned uc;				/* Use count */
-  ea_list *src;				/* Source attributes */
-  byte nexthop_linkable;		/* Nexthop list is completely non-device */
-  u32 igp_metric;			/* Chosen route IGP metric */
-};
-
 struct rte_storage {
   struct rte_storage *next;		/* Next in chain */
   struct rte rte;			/* Route data */
@@ -394,7 +362,7 @@ struct rt_pending_export *rpe_next(struct rt_pending_export *rpe, struct rte_src
 void rpe_mark_seen(struct rt_export_hook *hook, struct rt_pending_export *rpe);
 
 #define rpe_mark_seen_all(hook, first, src) \
-  RPE_WALK(first, rpe, src) rpe_mark_seen((hook), rpe)
+  RPE_WALK((first), _rpe, (src)) rpe_mark_seen((hook), _rpe)
 
 /* Get pending export seen status */
 int rpe_get_seen(struct rt_export_hook *hook, struct rt_pending_export *rpe);
@@ -412,6 +380,43 @@ int rpe_get_seen(struct rt_export_hook *hook, struct rt_pending_export *rpe);
 #define RIC_REJECT	-1		/* Rejected by protocol */
 #define RIC_DROP	-2		/* Silently dropped by protocol */
 
+/*
+ * Next hop update data structures
+ */
+
+#define NHU_CLEAN	0
+#define NHU_SCHEDULED	1
+#define NHU_RUNNING	2
+#define NHU_DIRTY	3
+
+struct hostentry {
+  node ln;
+  ip_addr addr;				/* IP address of host, part of key */
+  ip_addr link;				/* (link-local) IP address of host, used as gw
+					   if host is directly attached */
+  struct rtable *tab;			/* Dependent table, part of key */
+  struct hostentry *next;		/* Next in hash chain */
+  unsigned hash_key;			/* Hash key */
+  unsigned uc;				/* Use count */
+  ea_list *src;				/* Source attributes */
+  byte nexthop_linkable;		/* Nexthop list is completely non-device */
+  u32 igp_metric;			/* Chosen route IGP metric */
+};
+
+struct hostcache {
+  slab *slab;				/* Slab holding all hostentries */
+  struct hostentry **hash_table;	/* Hash table for hostentries */
+  unsigned hash_order, hash_shift;
+  unsigned hash_max, hash_min;
+  unsigned hash_items;
+  linpool *lp;				/* Linpool for trie */
+  struct f_trie *trie;			/* Trie of prefixes that might affect hostentries */
+  list hostentries;			/* List of all hostentries */
+  event update;
+  struct rt_export_request req;		/* Notifier */
+};
+
+
 #define rte_update  channel_rte_import
 /**
  * rte_update - enter a new update to a routing table
-- 
cgit v1.2.3


From cd628d124dbdcfdbd870b3df5840cc6888d36f9d Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 31 Aug 2022 16:04:36 +0200
Subject: Flowspec revalidate notification converted to an export hook

Instead of synchronous notifications, we use the asynchronous export
framework to notify flowspec src route updates. This allows us to
invoke flowspec revalidation without locking collisions.
---
 nest/rt-table.c | 140 ++++++++++++++++++++++++++++++++++----------------------
 nest/rt.h       |  14 +++---
 2 files changed, 92 insertions(+), 62 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index e23e766e..72f85370 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -60,15 +60,14 @@
  * routes depends of resolving their network prefixes in IP routing tables. This
  * is similar to the recursive next hop mechanism, but simpler as there are no
  * intermediate hostcache and hostentries (because flows are less likely to
- * share common net prefix than routes sharing a common next hop). In src table,
- * there is a list of dst tables (list flowspec_links), this list is updated by
- * flowpsec channels (by rt_flowspec_link() and rt_flowspec_unlink() during
- * channel start/stop). Each dst table has its own trie of prefixes that may
- * influence validation of flowspec routes in it (flowspec_trie).
+ * share common net prefix than routes sharing a common next hop). Every dst
+ * table has its own export request in every src table. Each dst table has its
+ * own trie of prefixes that may influence validation of flowspec routes in it
+ * (flowspec_trie).
  *
- * When a best route changes in the src table, rt_flowspec_notify() immediately
- * checks all dst tables from the list using their tries to see whether the
- * change is relevant for them. If it is, then an asynchronous re-validation of
+ * When a best route changes in the src table, the notification mechanism is
+ * invoked by the export request which checks its dst table's trie to see
+ * whether the change is relevant, and if so, an asynchronous re-validation of
  * flowspec routes in the dst table is scheduled. That is also done by function
  * rt_next_hop_update(), like nexthop recomputation above. It iterates over all
  * flowspec routes and re-validates them. It also recalculates the trie.
@@ -136,7 +135,6 @@ static inline void rt_next_hop_resolve_rte(rte *r);
 static inline void rt_flowspec_resolve_rte(rte *r, struct channel *c);
 static inline void rt_prune_table(rtable *tab);
 static inline void rt_schedule_notify(rtable *tab);
-static void rt_flowspec_notify(rtable *tab, net *net);
 static void rt_kick_prune_timer(rtable *tab);
 static void rt_feed_by_fib(void *);
 static void rt_feed_by_trie(void *);
@@ -1278,9 +1276,6 @@ rte_announce(rtable *tab, net *net, struct rte_storage *new, struct rte_storage
       new_best->rte.sender->stats.pref++;
     if (old_best_valid)
       old_best->rte.sender->stats.pref--;
-
-    if (!EMPTY_LIST(tab->flowspec_links))
-      rt_flowspec_notify(tab, net);
   }
 
   rt_schedule_notify(tab);
@@ -2448,13 +2443,59 @@ rt_unsubscribe(struct rt_subscription *s)
   rt_unlock_table(s->tab);
 }
 
+static void
+rt_flowspec_export_one(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *first)
+{
+  struct rt_flowspec_link *ln = SKIP_BACK(struct rt_flowspec_link, req, req);
+  rtable *dst = ln->dst;
+  ASSUME(rt_is_flow(dst));
+
+  /* No need to inspect it further if recalculation is already active */
+  if ((dst->nhu_state == NHU_SCHEDULED) || (dst->nhu_state == NHU_DIRTY)
+      || !trie_match_net(dst->flowspec_trie, net))
+  {
+    rpe_mark_seen_all(req->hook, first, NULL);
+    return;
+  }
+
+  /* This net may affect some flowspecs, check the actual change */
+  rte *o = RTE_VALID_OR_NULL(first->old_best);
+  struct rte_storage *new_best = first->new_best;
+
+  RPE_WALK(first, rpe, NULL)
+  {
+    rpe_mark_seen(req->hook, rpe);
+    new_best = rpe->new_best;
+  }
+
+  /* Yes, something has actually changed. Schedule the update. */
+  if (o != RTE_VALID_OR_NULL(new_best))
+    rt_schedule_nhu(dst);
+}
+
+static void
+rt_flowspec_dump_req(struct rt_export_request *req)
+{
+  struct rt_flowspec_link *ln = SKIP_BACK(struct rt_flowspec_link, req, req);
+  debug("  Flowspec link for table %s (%p)\n", ln->dst->name, req);
+}
+
 static struct rt_flowspec_link *
 rt_flowspec_find_link(rtable *src, rtable *dst)
 {
-  struct rt_flowspec_link *ln;
-  WALK_LIST(ln, src->flowspec_links)
-    if ((ln->src == src) && (ln->dst == dst))
-      return ln;
+  struct rt_export_hook *hook; node *n;
+  WALK_LIST2(hook, n, src->exporter.hooks, n)
+    switch (atomic_load_explicit(&hook->export_state, memory_order_acquire))
+    {
+      case TES_FEEDING:
+      case TES_READY:
+	if (hook->req->export_one == rt_flowspec_export_one)
+	{
+	  struct rt_flowspec_link *ln = SKIP_BACK(struct rt_flowspec_link, req, hook->req);
+	  if (ln->dst == dst)
+	    return ln;
+	}
+    }
 
   return NULL;
 }
@@ -2469,56 +2510,45 @@ rt_flowspec_link(rtable *src, rtable *dst)
 
   if (!ln)
   {
-    rt_lock_table(src);
     rt_lock_table(dst);
 
-    ln = mb_allocz(src->rp, sizeof(struct rt_flowspec_link));
+    pool *p = src->rp;
+    ln = mb_allocz(p, sizeof(struct rt_flowspec_link));
     ln->src = src;
     ln->dst = dst;
-    add_tail(&src->flowspec_links, &ln->n);
+    ln->req = (struct rt_export_request) {
+      .name = mb_sprintf(p, "%s.flowspec.notifier", dst->name),
+      .list = &global_work_list,
+      .trace_routes = src->config->debug,
+      .dump_req = rt_flowspec_dump_req,
+      .export_one = rt_flowspec_export_one,
+    };
+
+    rt_request_export(&src->exporter, &ln->req);
   }
 
   ln->uc++;
 }
 
-void
-rt_flowspec_unlink(rtable *src, rtable *dst)
+static void
+rt_flowspec_link_stopped(struct rt_export_request *req)
 {
-  struct rt_flowspec_link *ln = rt_flowspec_find_link(src, dst);
-
-  ASSERT(ln && (ln->uc > 0));
-
-  ln->uc--;
-
-  if (!ln->uc)
-  {
-    rem_node(&ln->n);
-    mb_free(ln);
+  struct rt_flowspec_link *ln = SKIP_BACK(struct rt_flowspec_link, req, req);
+  rtable *dst = ln->dst;
 
-    rt_unlock_table(src);
-    rt_unlock_table(dst);
-  }
+  mb_free(ln);
+  rt_unlock_table(dst);
 }
 
-static void
-rt_flowspec_notify(rtable *src, net *net)
+void
+rt_flowspec_unlink(rtable *src, rtable *dst)
 {
-  /* Only IP tables are src links */
-  ASSERT(rt_is_ip(src));
-
-  struct rt_flowspec_link *ln;
-  WALK_LIST(ln, src->flowspec_links)
-  {
-    rtable *dst = ln->dst;
-    ASSERT(rt_is_flow(dst));
+  struct rt_flowspec_link *ln = rt_flowspec_find_link(src, dst);
 
-    /* No need to inspect it further if recalculation is already active */
-    if ((dst->nhu_state == NHU_SCHEDULED) || (dst->nhu_state == NHU_DIRTY))
-      continue;
+  ASSERT(ln && (ln->uc > 0));
 
-    if (trie_match_net(dst->flowspec_trie, net->n.addr))
-      rt_schedule_nhu(dst);
-  }
+  if (!--ln->uc)
+    rt_stop_export(&ln->req, rt_flowspec_link_stopped);
 }
 
 static void
@@ -2596,8 +2626,6 @@ rt_setup(pool *pp, struct rtable_config *cf)
     t->fib.init = net_init_with_trie;
   }
 
-  init_list(&t->flowspec_links);
-
   t->exporter = (struct rt_exporter) {
     .addr_type = t->addr_type,
     .start = rt_table_export_start,
@@ -3695,6 +3723,11 @@ rt_reconfigure(rtable *tab, struct rtable_config *new, struct rtable_config *old
   if (tab->hostcache)
     tab->hostcache->req.trace_routes = new->debug;
 
+  struct rt_export_hook *hook; node *n;
+  WALK_LIST2(hook, n, tab->exporter.hooks, n)
+    if (hook->req->export_one == rt_flowspec_export_one)
+      hook->req->trace_routes = new->debug;
+
   tab->cork_threshold = new->cork_threshold;
 
   if (new->cork_threshold.high != old->cork_threshold.high)
@@ -4063,8 +4096,7 @@ hc_notify_export_one(struct rt_export_request *req, const net_addr *net, struct
     new_best = rpe->new_best;
   }
 
-  /* Yes, something has actually changed. Do the hostcache update.
-   * We don't need any more updates until then. */
+  /* Yes, something has actually changed. Do the hostcache update. */
   if (o != RTE_VALID_OR_NULL(new_best))
     ev_schedule_work(&hc->update);
 }
diff --git a/nest/rt.h b/nest/rt.h
index 5839ba66..01e444f6 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -132,7 +132,6 @@ typedef struct rtable {
 
   list subscribers;			/* Subscribers for notifications */
   struct timer *settle_timer;		/* Settle time for notifications */
-  list flowspec_links;			/* List of flowspec links, src for NET_IPx and dst for NET_FLOWx */
   struct f_trie *flowspec_trie;		/* Trie for evaluation of flowspec notifications */
 } rtable;
 
@@ -143,13 +142,6 @@ struct rt_subscription {
   event_list *list;
 };
 
-struct rt_flowspec_link {
-  node n;
-  rtable *src;
-  rtable *dst;
-  u32 uc;
-};
-
 extern struct rt_cork {
   _Atomic uint active;
   event_list queue;
@@ -416,6 +408,12 @@ struct hostcache {
   struct rt_export_request req;		/* Notifier */
 };
 
+struct rt_flowspec_link {
+  rtable *src;
+  rtable *dst;
+  u32 uc;
+  struct rt_export_request req;
+};
 
 #define rte_update  channel_rte_import
 /**
-- 
cgit v1.2.3


From dd786e338c4adccee7077c8ecfaf56df2831ee4c Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Thu, 1 Sep 2022 10:39:56 +0200
Subject: ROA subscriptions are also converted to export requests.

By this, the requesting channels do the timers in their own loops,
avoiding unnecessary synchronization when the central timer went off.

This is of course less effective for now, yet it allows to easily
implement selective reloads in future.
---
 doc/bird.sgml   |  24 +++++-------
 nest/config.Y   |   4 +-
 nest/proto.c    | 117 ++++++++++++++++++++++++++++++++++++++++++++++----------
 nest/protocol.h |   8 +++-
 nest/rt-table.c |  96 +++-------------------------------------------
 nest/rt.h       |  14 -------
 6 files changed, 121 insertions(+), 142 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index b12ac544..2bce3d57 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -675,21 +675,6 @@ to set options.
 	disadvantage is that trie-enabled routing tables require more memory,
 	which may be an issue especially in multi-table setups. Default: off.
 
-	<tag><label id="rtable-min-settle-time">min settle time <m/time/</tag>
-	Specify a minimum value of the settle time. When a ROA table changes,
-	automatic <ref id="proto-rpki-reload" name="RPKI reload"> may be
-	triggered, after a short settle time. Minimum settle time is a delay
-	from the last ROA table change to wait for more updates. Default: 1 s.
-
-
-	<tag><label id="rtable-max-settle-time">max settle time <m/time/</tag>
-	Specify a maximum value of the settle time. When a ROA table changes,
-	automatic <ref id="proto-rpki-reload" name="RPKI reload"> may be
-	triggered, after a short settle time. Maximum settle time is an upper
-	limit to the settle time from the initial ROA table change even if
-	there are consecutive updates gradually renewing the settle time.
-	Default: 20 s.
-
 	<tag><label id="rtable-gc-threshold">gc threshold <m/number/</tag>
 	Specify a minimum amount of removed networks that triggers a garbage
 	collection (GC) cycle. Default: 1000.
@@ -980,6 +965,15 @@ inherited from templates can be updated by new definitions.
 	<ref id="bgp-export-table" name="export table"> (for respective
 	direction). Default: on.
 
+	<tag><label id="rtable-min-settle-time">min settle time <m/time/</tag>
+	Minimum settle time is a delay from the last ROA table change to wait
+	for more updates before triggering automatic reload. Default: 1 s.
+
+	<tag><label id="rtable-min-settle-time">min settle time <m/time/</tag>
+        Maximum settle time is an upper limit to the settle time from the
+        initial ROA table change even if there are consecutive updates gradually
+        renewing the settle time.  Default: 20 s.
+
 	<tag><label id="proto-import-limit">import limit [<m/number/ | off ] [action warn | block | restart | disable]</tag>
 	Specify an import route limit (a maximum number of routes imported from
 	the protocol) and optionally the action to be taken when the limit is
diff --git a/nest/config.Y b/nest/config.Y
index 3ad6530d..ea7846e2 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -227,8 +227,6 @@ table_opt:
        cf_error("Trie option not supported for %s table", net_label[this_table->addr_type]);
      this_table->trie_used = $2;
    }
- | MIN SETTLE TIME expr_us { this_table->min_settle_time = $4; }
- | MAX SETTLE TIME expr_us { this_table->max_settle_time = $4; }
  | GC THRESHOLD expr { this_table->gc_threshold = $3; }
  | GC PERIOD expr_us { this_table->gc_period = (uint) $3; if ($3 > 3600 S_) cf_error("GC period must be at most 3600 s"); }
  | CORK THRESHOLD expr expr {
@@ -323,6 +321,8 @@ channel_item_:
  | RECEIVE LIMIT limit_spec { this_channel->rx_limit = $3; }
  | IMPORT LIMIT limit_spec { this_channel->in_limit = $3; }
  | EXPORT LIMIT limit_spec { this_channel->out_limit = $3; }
+ | MIN SETTLE TIME expr_us { this_channel->min_settle_time = $4; }
+ | MAX SETTLE TIME expr_us { this_channel->max_settle_time = $4; }
  | PREFERENCE expr { this_channel->preference = $2; check_u16($2); }
  | IMPORT KEEP FILTERED bool {
      if ($4)
diff --git a/nest/proto.c b/nest/proto.c
index d2374792..f4615c2f 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -55,6 +55,7 @@ static void channel_update_limit(struct channel *c, struct limit *l, int dir, st
 static void channel_reset_limit(struct channel *c, struct limit *l, int dir);
 static void channel_feed_end(struct channel *c);
 static void channel_export_stopped(struct rt_export_request *req);
+static void channel_check_stopped(struct channel *c);
 
 static inline int proto_is_done(struct proto *p)
 { return (p->proto_state == PS_DOWN) && proto_is_inactive(p); }
@@ -312,10 +313,19 @@ proto_remove_channels(struct proto *p)
     proto_remove_channel(p, c);
 }
 
+struct roa_subscription {
+  node roa_node;
+  timer t;
+  btime base_settle_time;		/* Start of settling interval */
+  struct channel *c;
+  struct rt_export_request req;
+};
+
 static void
-channel_roa_in_changed(void *_data)
+channel_roa_in_changed(struct timer *t)
 {
-  struct channel *c = _data;
+  struct roa_subscription *s = SKIP_BACK(struct roa_subscription, t, t);
+  struct channel *c = s->c;
   int active = !!c->reload_req.hook;
 
   CD(c, "Reload triggered by RPKI change%s", active ? " - already active" : "");
@@ -327,9 +337,11 @@ channel_roa_in_changed(void *_data)
 }
 
 static void
-channel_roa_out_changed(void *_data)
+channel_roa_out_changed(struct timer *t)
 {
-  struct channel *c = _data;
+  struct roa_subscription *s = SKIP_BACK(struct roa_subscription, t, t);
+  struct channel *c = s->c;
+
   CD(c, "Feeding triggered by RPKI change");
 
   c->refeed_pending = 1;
@@ -338,29 +350,56 @@ channel_roa_out_changed(void *_data)
     rt_stop_export(&c->out_req, channel_export_stopped);
 }
 
-/* Temporary code, subscriptions should be changed to resources */
-struct roa_subscription {
-  struct rt_subscription s;
-  node roa_node;
-};
+static void
+channel_export_one_roa(struct rt_export_request *req, const net_addr *net UNUSED, struct rt_pending_export *first)
+{
+  struct roa_subscription *s = SKIP_BACK(struct roa_subscription, req, req);
+
+  /* TODO: use the information about what roa has changed */
+
+  if (!tm_active(&s->t))
+  {
+    s->base_settle_time = current_time();
+    tm_start(&s->t, s->base_settle_time + s->c->min_settle_time);
+  }
+  else
+    tm_set(&s->t,
+	MIN(s->base_settle_time + s->c->max_settle_time,
+	    current_time() + s->c->min_settle_time));
+
+
+  rpe_mark_seen_all(req->hook, first, NULL);
+}
+
+static void
+channel_dump_roa_req(struct rt_export_request *req)
+{
+  struct roa_subscription *s = SKIP_BACK(struct roa_subscription, req, req);
+  struct channel *c = s->c;
+  rtable *tab = SKIP_BACK(rtable, exporter, req->hook->table);
+
+  debug("  Channel %s.%s ROA %s change notifier from table %s request %p\n",
+      c->proto->name, c->name,
+      (s->t.hook == channel_roa_in_changed) ? "import" : "export",
+      tab->name, req);
+}
 
 static int
 channel_roa_is_subscribed(struct channel *c, rtable *tab, int dir)
 {
-  void (*hook)(void *) =
+  void (*hook)(struct timer *) =
     dir ? channel_roa_in_changed : channel_roa_out_changed;
 
   struct roa_subscription *s;
   node *n;
 
   WALK_LIST2(s, n, c->roa_subscriptions, roa_node)
-    if ((s->s.tab == tab) && (s->s.event->hook == hook))
+    if ((s->req.hook->table == &tab->exporter) && (s->t.hook == hook))
       return 1;
 
   return 0;
 }
 
-
 static void
 channel_roa_subscribe(struct channel *c, rtable *tab, int dir)
 {
@@ -368,21 +407,40 @@ channel_roa_subscribe(struct channel *c, rtable *tab, int dir)
     return;
 
   struct roa_subscription *s = mb_allocz(c->proto->pool, sizeof(struct roa_subscription));
-  s->s.event = ev_new_init(c->proto->pool, dir ? channel_roa_in_changed : channel_roa_out_changed, c);
-  s->s.list = proto_work_list(c->proto);
 
-  rt_subscribe(tab, &s->s);
+  *s = (struct roa_subscription) {
+    .t = { .hook = dir ? channel_roa_in_changed : channel_roa_out_changed, },
+    .c = c,
+    .req = {
+      .name = mb_sprintf(c->proto->pool, "%s.%s.roa-%s.%s",
+	  c->proto->name, c->name, dir ? "in" : "out", tab->name),
+      .list = proto_work_list(c->proto),
+      .trace_routes = c->debug | c->proto->debug,
+      .dump_req = channel_dump_roa_req,
+      .export_one = channel_export_one_roa,
+    },
+  };
 
   add_tail(&c->roa_subscriptions, &s->roa_node);
+  rt_request_export(&tab->exporter, &s->req);
 }
 
 static void
-channel_roa_unsubscribe(struct roa_subscription *s)
+channel_roa_unsubscribed(struct rt_export_request *req)
 {
-  rt_unsubscribe(&s->s);
+  struct roa_subscription *s = SKIP_BACK(struct roa_subscription, req, req);
+  struct channel *c = s->c;
+
   rem_node(&s->roa_node);
-  rfree(s->s.event);
   mb_free(s);
+  
+  channel_check_stopped(c);
+}
+
+static void
+channel_roa_unsubscribe(struct roa_subscription *s)
+{
+  rt_stop_export(&s->req, channel_roa_unsubscribed);
 }
 
 static void
@@ -525,7 +583,7 @@ channel_check_stopped(struct channel *c)
   switch (c->channel_state)
   {
     case CS_STOP:
-      if (c->out_req.hook || c->in_req.hook)
+      if (!EMPTY_LIST(c->roa_subscriptions) || c->out_req.hook || c->in_req.hook)
 	return;
 
       channel_set_state(c, CS_DOWN);
@@ -533,7 +591,7 @@ channel_check_stopped(struct channel *c)
 
       break;
     case CS_PAUSE:
-      if (c->out_req.hook)
+      if (!EMPTY_LIST(c->roa_subscriptions) || c->out_req.hook)
 	return;
 
       channel_set_state(c, CS_START);
@@ -876,6 +934,9 @@ channel_config_new(const struct channel_class *cc, const char *name, uint net_ty
   cf->debug = new_config->channel_default_debug;
   cf->rpki_reload = 1;
 
+  cf->min_settle_time = 1 S;
+  cf->max_settle_time = 20 S;
+
   add_tail(&proto->channels, &cf->n);
 
   return cf;
@@ -956,6 +1017,22 @@ channel_reconfigure(struct channel *c, struct channel_config *cf)
   c->in_req.trace_routes = c->out_req.trace_routes = c->debug | c->proto->debug;
   c->rpki_reload = cf->rpki_reload;
 
+  if (	  (c->min_settle_time != cf->min_settle_time)
+       || (c->max_settle_time != cf->max_settle_time))
+  {
+    c->min_settle_time = cf->min_settle_time;
+    c->max_settle_time = cf->max_settle_time;
+
+    struct roa_subscription *s;
+    node *n;
+
+    WALK_LIST2(s, n, c->roa_subscriptions, roa_node)
+      if (tm_active(&s->t))
+	tm_set(&s->t,
+	    MIN(s->base_settle_time + c->max_settle_time,
+	      current_time() + c->min_settle_time));
+  }
+
   /* Execute channel-specific reconfigure hook */
   if (c->channel->reconfigure && !c->channel->reconfigure(c, cf, &import_changed, &export_changed))
     return 0;
diff --git a/nest/protocol.h b/nest/protocol.h
index 709d6415..a3eeb198 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -463,6 +463,9 @@ struct channel_config {
   struct channel_limit in_limit;	/* Limit for importing routes from protocol */
   struct channel_limit out_limit;	/* Limit for exporting routes to protocol */
 
+  btime min_settle_time;		/* Minimum settle time for ROA-induced reload */
+  btime max_settle_time;		/* Maximum settle time for ROA-induced reload */
+
   u8 net_type;				/* Routing table network type (NET_*), 0 for undefined */
   u8 ra_mode;				/* Mode of received route advertisements (RA_*) */
   u16 preference;			/* Default route preference */
@@ -490,6 +493,9 @@ struct channel {
   struct limit in_limit;		/* Input limit */
   struct limit out_limit;		/* Output limit */
 
+  btime min_settle_time;		/* Minimum settle time for ROA-induced reload */
+  btime max_settle_time;		/* Maximum settle time for ROA-induced reload */
+
   u8 limit_actions[PLD_MAX];		/* Limit actions enum */
   u8 limit_active;			/* Flags for active limits */
 
@@ -543,7 +549,7 @@ struct channel {
 
   struct rt_exporter *out_table;	/* Internal table for exported routes */
 
-  list roa_subscriptions;		/* List of active ROA table subscriptions based on filters roa_check() */
+  list roa_subscriptions;		/* List of active ROA table subscriptions based on filters' roa_check() calls */
 };
 
 #define RIK_REJECTED	1			/* Routes rejected in import filter are kept */
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 72f85370..2fa736e2 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -82,9 +82,8 @@
  * will be re-validated later in this round anyway.
  *
  * The third mechanism is used for RPKI re-validation of IP routes and it is the
- * simplest. It is just a list of subscribers in src table, who are notified
- * when any change happened, but only after a settle time. Also, in RPKI case
- * the dst is not a table, but a channel, who refeeds routes through a filter.
+ * simplest. It is also an auxiliary export request belonging to the
+ * appropriate channel, triggering its reload/refeed timer after a settle time.
  */
 
 #undef LOCAL_DEBUG
@@ -134,7 +133,6 @@ static void rt_next_hop_update(rtable *tab);
 static inline void rt_next_hop_resolve_rte(rte *r);
 static inline void rt_flowspec_resolve_rte(rte *r, struct channel *c);
 static inline void rt_prune_table(rtable *tab);
-static inline void rt_schedule_notify(rtable *tab);
 static void rt_kick_prune_timer(rtable *tab);
 static void rt_feed_by_fib(void *);
 static void rt_feed_by_trie(void *);
@@ -1270,15 +1268,10 @@ rte_announce(rtable *tab, net *net, struct rte_storage *new, struct rte_storage
   if ((new == old) && (new_best == old_best))
     return;
 
-  if (new_best_valid || old_best_valid)
-  {
-    if (new_best_valid)
-      new_best->rte.sender->stats.pref++;
-    if (old_best_valid)
-      old_best->rte.sender->stats.pref--;
-  }
-
-  rt_schedule_notify(tab);
+  if (new_best_valid)
+    new_best->rte.sender->stats.pref++;
+  if (old_best_valid)
+    old_best->rte.sender->stats.pref--;
 
   if (EMPTY_LIST(tab->exporter.hooks) && EMPTY_LIST(tab->exporter.pending))
   {
@@ -2371,78 +2364,6 @@ rt_kick_prune_timer(rtable *tab)
 }
 
 
-static inline btime
-rt_settled_time(rtable *tab)
-{
-  ASSUME(tab->base_settle_time != 0);
-
-  return MIN(tab->last_rt_change + tab->config->min_settle_time,
-	     tab->base_settle_time + tab->config->max_settle_time);
-}
-
-static void
-rt_settle_timer(timer *t)
-{
-  rtable *tab = t->data;
-
-  if (!tab->base_settle_time)
-    return;
-
-  btime settled_time = rt_settled_time(tab);
-  if (current_time() < settled_time)
-  {
-    tm_set(tab->settle_timer, settled_time);
-    return;
-  }
-
-  /* Settled */
-  tab->base_settle_time = 0;
-
-  struct rt_subscription *s;
-  WALK_LIST(s, tab->subscribers)
-    ev_send(s->list, s->event);
-}
-
-static void
-rt_kick_settle_timer(rtable *tab)
-{
-  tab->base_settle_time = current_time();
-
-  if (!tab->settle_timer)
-    tab->settle_timer = tm_new_init(tab->rp, rt_settle_timer, tab, 0, 0);
-
-  if (!tm_active(tab->settle_timer))
-    tm_set(tab->settle_timer, rt_settled_time(tab));
-}
-
-static inline void
-rt_schedule_notify(rtable *tab)
-{
-  if (EMPTY_LIST(tab->subscribers))
-    return;
-
-  if (tab->base_settle_time)
-    return;
-
-  rt_kick_settle_timer(tab);
-}
-
-void
-rt_subscribe(rtable *tab, struct rt_subscription *s)
-{
-  s->tab = tab;
-  rt_lock_table(tab);
-  DBG("rt_subscribe(%s)\n", tab->name);
-  add_tail(&tab->subscribers, &s->n);
-}
-
-void
-rt_unsubscribe(struct rt_subscription *s)
-{
-  rem_node(&s->n);
-  rt_unlock_table(s->tab);
-}
-
 static void
 rt_flowspec_export_one(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *first)
 {
@@ -2580,7 +2501,6 @@ rt_free(resource *_r)
   fib_free(&r->fib);
   hmap_free(&r->id_map);
   rfree(r->rt_event);
-  rfree(r->settle_timer);
   mb_free(r);
   */
 }
@@ -2642,8 +2562,6 @@ rt_setup(pool *pp, struct rtable_config *cf)
   hmap_init(&t->id_map, p, 1024);
   hmap_set(&t->id_map, 0);
 
-  init_list(&t->subscribers);
-
   t->rt_event = ev_new_init(p, rt_event, t);
   t->uncork_event = ev_new_init(p, rt_uncork_event, t);
   t->prune_timer = tm_new_init(p, rt_prune_timer, t, 0, 0);
@@ -3629,8 +3547,6 @@ rt_new_table(struct symbol *s, uint addr_type)
   c->addr_type = addr_type;
   c->gc_threshold = 1000;
   c->gc_period = (uint) -1;	/* set in rt_postconfig() */
-  c->min_settle_time = 1 S;
-  c->max_settle_time = 20 S;
   c->cork_threshold.low = 128;
   c->cork_threshold.high = 512;
   c->debug = new_config->table_debug;
diff --git a/nest/rt.h b/nest/rt.h
index 01e444f6..c5948512 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -61,8 +61,6 @@ struct rtable_config {
   byte sorted;				/* Routes of network are sorted according to rte_better() */
   byte trie_used;			/* Rtable has attached trie */
   byte debug;				/* Whether to log */
-  btime min_settle_time;		/* Minimum settle time for notifications */
-  btime max_settle_time;		/* Maximum settle time for notifications */
   btime export_settle_time;		/* Delay before exports are announced */
   struct rt_cork_threshold cork_threshold;	/* Cork threshold values */
 };
@@ -112,7 +110,6 @@ typedef struct rtable {
   struct event *uncork_event;		/* Called when uncork happens */
   struct timer *prune_timer;		/* Timer for periodic pruning / GC */
   btime last_rt_change;			/* Last time when route changed */
-  btime base_settle_time;		/* Start time of rtable settling interval */
   btime gc_time;			/* Time of last GC */
   uint gc_counter;			/* Number of operations since last GC */
   byte prune_state;			/* Table prune state, 1 -> scheduled, 2-> running */
@@ -130,18 +127,9 @@ typedef struct rtable {
   u32 trie_old_lock_count;		/* Old prefix trie locked by walks */
   struct tbf rl_pipe;			/* Rate limiting token buffer for pipe collisions */
 
-  list subscribers;			/* Subscribers for notifications */
-  struct timer *settle_timer;		/* Settle time for notifications */
   struct f_trie *flowspec_trie;		/* Trie for evaluation of flowspec notifications */
 } rtable;
 
-struct rt_subscription {
-  node n;
-  rtable *tab;
-  event *event;
-  event_list *list;
-};
-
 extern struct rt_cork {
   _Atomic uint active;
   event_list queue;
@@ -461,8 +449,6 @@ void rt_lock_table(rtable *);
 void rt_unlock_table(rtable *);
 struct f_trie * rt_lock_trie(rtable *tab);
 void rt_unlock_trie(rtable *tab, struct f_trie *trie);
-void rt_subscribe(rtable *tab, struct rt_subscription *s);
-void rt_unsubscribe(struct rt_subscription *s);
 void rt_flowspec_link(rtable *src, rtable *dst);
 void rt_flowspec_unlink(rtable *src, rtable *dst);
 rtable *rt_setup(pool *, struct rtable_config *);
-- 
cgit v1.2.3


From 66ccdc2a0c8f10263679e7fac37c1db1adf64b4f Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Thu, 1 Sep 2022 11:17:35 +0200
Subject: Added an indirection to the export announcement routine

There are performance reasons for this, mostly that we don't want to
ping the table service routine with every import.
---
 nest/proto.c    |  1 +
 nest/rt-table.c | 72 +++++++++++++++++++++++++++++++++++++++------------------
 nest/rt.h       |  3 +++
 3 files changed, 54 insertions(+), 22 deletions(-)

diff --git a/nest/proto.c b/nest/proto.c
index f4615c2f..783672ec 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -511,6 +511,7 @@ channel_start_import(struct channel *c)
   c->in_req = (struct rt_import_request) {
     .name = mb_sprintf(c->proto->pool, "%s.%s", c->proto->name, c->name),
     .trace_routes = c->debug | c->proto->debug,
+    .list = proto_work_list(c->proto),
     .dump_req = channel_dump_import_req,
     .log_state_change = channel_import_log_state_change,
     .preimport = channel_preimport,
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 2fa736e2..3188ddf8 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1354,9 +1354,6 @@ rte_announce(rtable *tab, net *net, struct rte_storage *new, struct rte_storage
     tab->exporter.first = rpe;
 
   rt_check_cork_high(tab);
-
-  if (!tm_active(tab->exporter.export_timer))
-    tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
 }
 
 static struct rt_pending_export *
@@ -1410,6 +1407,9 @@ rt_announce_exports(timer *tm)
 {
   rtable *tab = tm->data;
 
+  if (EMPTY_LIST(tab->exporter.pending))
+    return;
+
   struct rt_export_hook *c; node *n;
   WALK_LIST2(c, n, tab->exporter.hooks, n)
   {
@@ -1420,6 +1420,28 @@ rt_announce_exports(timer *tm)
   }
 }
 
+static void
+rt_import_announce_exports(void *_hook)
+{
+  struct rt_import_hook *hook = _hook;
+  rtable *tab = hook->table;
+
+
+  if (hook->import_state == TIS_CLEARED)
+  {
+    rt_trace(tab, D_EVENTS, "Hook %s stopped", hook->req->name);
+    hook->stopped(hook->req);
+    rem_node(&hook->n);
+    mb_free(hook);
+    rt_unlock_table(tab);
+  }
+
+  rt_trace(tab, D_EVENTS, "Announcing exports after imports from %s", hook->req->name);
+
+  if (!tm_active(tab->exporter.export_timer))
+    tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
+}
+
 static struct rt_pending_export *
 rt_last_export(struct rt_exporter *tab)
 {
@@ -1535,7 +1557,7 @@ rte_same(rte *x, rte *y)
 
 static inline int rte_is_ok(rte *e) { return e && !rte_is_filtered(e); }
 
-static void
+static int
 rte_recalculate(struct rt_import_hook *c, net *net, rte *new, struct rte_src *src)
 {
   struct rt_import_request *req = c->req;
@@ -1588,7 +1610,7 @@ rte_recalculate(struct rt_import_hook *c, net *net, rte *new, struct rte_src *sr
 
 	      /* We need to free the already stored route here before returning */
 	      rte_free(new_stored);
-	      return;
+	      return 0;
 	  }
 
 	*before_old = (*before_old)->next;
@@ -1598,7 +1620,7 @@ rte_recalculate(struct rt_import_hook *c, net *net, rte *new, struct rte_src *sr
   if (!old && !new)
     {
       stats->withdraws_ignored++;
-      return;
+      return 0;
     }
 
   /* If rejected by import limit, we need to pretend there is no route */
@@ -1734,14 +1756,7 @@ rte_recalculate(struct rt_import_hook *c, net *net, rte *new, struct rte_src *sr
   rte_announce(table, net, new_stored, old_stored,
       net->routes, old_best_stored);
 
-#if 0
-  /* Enable and reimplement these callbacks if anybody wants to use them */
-  if (old_ok && p->rte_remove)
-    p->rte_remove(net, old);
-  if (new_ok && p->rte_insert)
-    p->rte_insert(net, &new_stored->rte);
-#endif
-
+  return 1;
 }
 
 int
@@ -1869,8 +1884,9 @@ rte_import(struct rt_import_request *req, const net_addr *n, rte *new, struct rt
       return;
     }
 
-  /* And recalculate the best route */
-  rte_recalculate(hook, nn, new, src);
+  /* Recalculate the best route */
+  if (rte_recalculate(hook, nn, new, src))
+    ev_send(req->list, &hook->announce_event);
 }
 
 /* Check rtable for best route to given net whether it would be exported do p */
@@ -1951,14 +1967,14 @@ rt_request_import(rtable *tab, struct rt_import_request *req)
 
   struct rt_import_hook *hook = req->hook = mb_allocz(tab->rp, sizeof(struct rt_import_hook));
 
+  hook->announce_event = (event) { .hook = rt_import_announce_exports, .data = hook };
+
   DBG("Lock table %s for import %p req=%p uc=%u\n", tab->name, hook, req, tab->use_count);
 
   hook->req = req;
   hook->table = tab;
 
   rt_set_import_state(hook, TIS_UP);
-
-  hook->n = (node) {};
   add_tail(&tab->imports, &hook->n);
 }
 
@@ -2313,7 +2329,13 @@ rt_event(void *ptr)
   if (tab->nhu_corked || tab->nhu_state && rt_cork_check(tab->uncork_event))
   {
     if (!tab->nhu_corked)
+    {
       rt_trace(tab, D_STATES, "Next hop updater corked");
+      if ((tab->nhu_state & NHU_RUNNING)
+	  && !EMPTY_LIST(tab->exporter.pending)
+	  && !tm_active(tab->exporter.export_timer))
+	tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
+    }
 
     tab->nhu_corked |= tab->nhu_state;
     tab->nhu_state = 0;
@@ -2699,6 +2721,10 @@ again:
     }
   FIB_ITERATE_END;
 
+  rt_trace(tab, D_EVENTS, "Prune done, scheduling export timer");
+  if (!tm_active(tab->exporter.export_timer))
+    tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
+
 #ifdef DEBUGGING
   fib_check(&tab->fib);
 #endif
@@ -2912,10 +2938,7 @@ done:;
       if (!first || (first->seq >= ih->flush_seq))
       {
 	ih->import_state = TIS_CLEARED;
-	ih->stopped(ih->req);
-	rem_node(&ih->n);
-	mb_free(ih);
-	rt_unlock_table(tab);
+	ev_send(ih->req->list, &ih->announce_event);
       }
 
   if ((tab->gc_counter += want_prune) >= tab->config->gc_threshold)
@@ -3497,6 +3520,11 @@ rt_next_hop_update(rtable *tab)
     }
   FIB_ITERATE_END;
 
+  rt_trace(tab, D_EVENTS, "NHU done, scheduling export timer");
+
+  if (!tm_active(tab->exporter.export_timer))
+    tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
+
   /* State change:
    *   NHU_DIRTY   -> NHU_SCHEDULED
    *   NHU_RUNNING -> NHU_CLEAN
diff --git a/nest/rt.h b/nest/rt.h
index c5948512..78585c79 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -187,6 +187,8 @@ struct rt_import_request {
   char *name;
   u8 trace_routes;
 
+  event_list *list;			/* Where to schedule announce events */
+
   void (*dump_req)(struct rt_import_request *req);
   void (*log_state_change)(struct rt_import_request *req, u8 state);
   /* Preimport is called when the @new route is just-to-be inserted, replacing @old.
@@ -218,6 +220,7 @@ struct rt_import_hook {
   u8 stale_pruning;			/* Last prune started when this value was set at stale_valid */
 
   void (*stopped)(struct rt_import_request *);	/* Stored callback when import is stopped */
+  event announce_event;			/* This event announces table updates */
 };
 
 struct rt_pending_export {
-- 
cgit v1.2.3


From 636bc44e61b5361b675ddd1ad7edb0b5ff2c2f2f Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Mon, 5 Sep 2022 06:58:42 +0200
Subject: Exporter routine refactoring to allow for nicer table locking

---
 nest/config.Y     |   2 +-
 nest/proto.c      |  12 +--
 nest/rt-show.c    |   8 +-
 nest/rt-table.c   | 284 +++++++++++++++++++++++++++++++-----------------------
 nest/rt.h         |  65 +++++++++----
 proto/bgp/attrs.c |  62 ++++++------
 proto/bgp/bgp.c   |   2 +-
 7 files changed, 254 insertions(+), 181 deletions(-)

diff --git a/nest/config.Y b/nest/config.Y
index ea7846e2..e8c4aa9a 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -702,7 +702,7 @@ r_args:
    }
  | r_args IMPORT TABLE channel_arg {
      if (!($4->in_keep & RIK_PREFILTER)) cf_error("No import table in channel %s.%s", $4->proto->name, $4->name);
-     rt_show_add_exporter($$, &$4->table->exporter, "import")->prefilter = $4;
+     rt_show_add_exporter($$, &$4->table->exporter.e, "import")->prefilter = $4;
      $$->tables_defined_by = RSD_TDB_DIRECT;
    }
  | r_args EXPORT TABLE channel_arg {
diff --git a/nest/proto.c b/nest/proto.c
index 783672ec..5f4b7b2d 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -376,7 +376,7 @@ channel_dump_roa_req(struct rt_export_request *req)
 {
   struct roa_subscription *s = SKIP_BACK(struct roa_subscription, req, req);
   struct channel *c = s->c;
-  rtable *tab = SKIP_BACK(rtable, exporter, req->hook->table);
+  rtable *tab = SKIP_BACK(rtable, exporter.e, req->hook->table);
 
   debug("  Channel %s.%s ROA %s change notifier from table %s request %p\n",
       c->proto->name, c->name,
@@ -394,7 +394,7 @@ channel_roa_is_subscribed(struct channel *c, rtable *tab, int dir)
   node *n;
 
   WALK_LIST2(s, n, c->roa_subscriptions, roa_node)
-    if ((s->req.hook->table == &tab->exporter) && (s->t.hook == hook))
+    if ((s->req.hook->table == &tab->exporter.e) && (s->t.hook == hook))
       return 1;
 
   return 0;
@@ -422,7 +422,7 @@ channel_roa_subscribe(struct channel *c, rtable *tab, int dir)
   };
 
   add_tail(&c->roa_subscriptions, &s->roa_node);
-  rt_request_export(&tab->exporter, &s->req);
+  rt_request_export(tab, &s->req);
 }
 
 static void
@@ -575,7 +575,7 @@ channel_start_export(struct channel *c)
   }
 
   DBG("%s.%s: Channel start export req=%p\n", c->proto->name, c->name, &c->out_req);
-  rt_request_export(&c->table->exporter, &c->out_req);
+  rt_request_export(c->table, &c->out_req);
 }
 
 static void
@@ -629,7 +629,7 @@ channel_export_stopped(struct rt_export_request *req)
   {
     c->refeeding = 1;
     c->refeed_pending = 0;
-    rt_request_export(&c->table->exporter, req);
+    rt_request_export(c->table, req);
     return;
   }
 
@@ -673,7 +673,7 @@ channel_schedule_reload(struct channel *c)
 {
   ASSERT(c->in_req.hook);
 
-  rt_request_export(&c->table->exporter, &c->reload_req);
+  rt_request_export(c->table, &c->reload_req);
 }
 
 static void
diff --git a/nest/rt-show.c b/nest/rt-show.c
index 5d7723cf..d17818db 100644
--- a/nest/rt-show.c
+++ b/nest/rt-show.c
@@ -301,7 +301,7 @@ rt_show_cont(struct rt_show_data *d)
   if (d->tables_defined_by & RSD_TDB_SET)
     rt_show_table(d);
 
-  rt_request_export(d->tab->table, &d->req);
+  rt_request_export_other(d->tab->table, &d->req);
 }
 
 static void
@@ -356,7 +356,7 @@ rt_show_add_exporter(struct rt_show_data *d, struct rt_exporter *t, const char *
 struct rt_show_data_rtable *
 rt_show_add_table(struct rt_show_data *d, struct rtable *t)
 {
-  struct rt_show_data_rtable *rsdr = rt_show_add_exporter(d, &t->exporter, t->name);
+  struct rt_show_data_rtable *rsdr = rt_show_add_exporter(d, &t->exporter.e, t->name);
 
   struct proto_config *krt = t->config->krt_attached;
   if (krt)
@@ -419,11 +419,11 @@ rt_show_prepare_tables(struct rt_show_data *d)
     if (d->export_mode)
     {
       if (!tab->export_channel && d->export_channel &&
-	  (tab->table == &d->export_channel->table->exporter))
+	  (tab->table == &d->export_channel->table->exporter.e))
 	tab->export_channel = d->export_channel;
 
       if (!tab->export_channel && d->export_protocol)
-	tab->export_channel = proto_find_channel_by_table(d->export_protocol, SKIP_BACK(rtable, exporter, tab->table));
+	tab->export_channel = proto_find_channel_by_table(d->export_protocol, SKIP_BACK(rtable, exporter.e, tab->table));
 
       if (!tab->export_channel)
       {
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 3188ddf8..de955ebb 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -138,13 +138,13 @@ static void rt_feed_by_fib(void *);
 static void rt_feed_by_trie(void *);
 static void rt_feed_equal(void *);
 static void rt_feed_for(void *);
-static uint rt_feed_net(struct rt_export_hook *c, net *n);
+static uint rt_feed_net(struct rt_table_export_hook *c, net *n);
 static void rt_check_cork_low(rtable *tab);
 static void rt_check_cork_high(rtable *tab);
 static void rt_cork_release_hook(void *);
 
-static inline void rt_export_used(struct rt_exporter *);
-static void rt_export_cleanup(rtable *tab);
+static void rt_export_used(struct rt_table_exporter *);
+static void rt_export_cleanup(rtable *);
 
 static int rte_same(rte *x, rte *y);
 
@@ -1162,9 +1162,10 @@ rpe_next(struct rt_pending_export *rpe, struct rte_src *src)
 }
 
 static struct rt_pending_export * rt_next_export_fast(struct rt_pending_export *last);
-static void
-rte_export(struct rt_export_hook *hook, struct rt_pending_export *rpe)
+static int
+rte_export(struct rt_table_export_hook *th, struct rt_pending_export *rpe)
 {
+  struct rt_export_hook *hook = &th->h;
   if (bmap_test(&hook->seq_map, rpe->seq))
     goto ignore;	/* Seen already */
 
@@ -1216,15 +1217,16 @@ rte_export(struct rt_export_hook *hook, struct rt_pending_export *rpe)
 
 ignore:
   /* Get the next export if exists */
-  hook->rpe_next = rt_next_export_fast(rpe);
+  th->rpe_next = rt_next_export_fast(rpe);
 
   /* The last block may be available to free */
-  if (PAGE_HEAD(hook->rpe_next) != PAGE_HEAD(rpe))
-    CALL(hook->table->used, hook->table);
+  int used = (PAGE_HEAD(th->rpe_next) != PAGE_HEAD(rpe));
 
   /* Releasing this export for cleanup routine */
   DBG("store hook=%p last_export=%p seq=%lu\n", hook, rpe, rpe->seq);
-  atomic_store_explicit(&hook->last_export, rpe, memory_order_release);
+  atomic_store_explicit(&th->last_export, rpe, memory_order_release);
+
+  return used;
 }
 
 /**
@@ -1273,7 +1275,7 @@ rte_announce(rtable *tab, net *net, struct rte_storage *new, struct rte_storage
   if (old_best_valid)
     old_best->rte.sender->stats.pref--;
 
-  if (EMPTY_LIST(tab->exporter.hooks) && EMPTY_LIST(tab->exporter.pending))
+  if (EMPTY_LIST(tab->exporter.e.hooks) && EMPTY_LIST(tab->exporter.pending))
   {
     /* No export hook and no pending exports to cleanup. We may free the route immediately. */
     if (!old)
@@ -1382,7 +1384,7 @@ rt_next_export_fast(struct rt_pending_export *last)
 }
 
 static struct rt_pending_export *
-rt_next_export(struct rt_export_hook *hook, struct rt_exporter *tab)
+rt_next_export(struct rt_table_export_hook *hook, struct rt_table_exporter *tab)
 {
   /* As the table is locked, it is safe to reload the last export pointer */
   struct rt_pending_export *last = atomic_load_explicit(&hook->last_export, memory_order_acquire);
@@ -1399,7 +1401,7 @@ rt_next_export(struct rt_export_hook *hook, struct rt_exporter *tab)
 static inline void
 rt_send_export_event(struct rt_export_hook *hook)
 {
-  ev_send(hook->req->list, hook->event);
+  ev_send(hook->req->list, &hook->event);
 }
 
 static void
@@ -1411,7 +1413,7 @@ rt_announce_exports(timer *tm)
     return;
 
   struct rt_export_hook *c; node *n;
-  WALK_LIST2(c, n, tab->exporter.hooks, n)
+  WALK_LIST2(c, n, tab->exporter.e.hooks, n)
   {
     if (atomic_load_explicit(&c->export_state, memory_order_acquire) != TES_READY)
       continue;
@@ -1443,7 +1445,7 @@ rt_import_announce_exports(void *_hook)
 }
 
 static struct rt_pending_export *
-rt_last_export(struct rt_exporter *tab)
+rt_last_export(struct rt_table_exporter *tab)
 {
   struct rt_pending_export *rpe = NULL;
 
@@ -1463,31 +1465,33 @@ rt_last_export(struct rt_exporter *tab)
 static void
 rt_export_hook(void *_data)
 {
-  struct rt_export_hook *c = _data;
+  struct rt_table_export_hook *c = _data;
 
-  ASSERT_DIE(atomic_load_explicit(&c->export_state, memory_order_relaxed) == TES_READY);
+  ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_READY);
 
   if (!c->rpe_next)
   {
     c->rpe_next = rt_next_export(c, c->table);
 
     if (!c->rpe_next)
-    {
-      CALL(c->table->used, c->table);
-      return;
-    }
+      return rt_export_used(c->table);
   }
 
+  int used = 0;
+
   /* Process the export */
   for (uint i=0; i<RT_EXPORT_BULK; i++)
   {
-    rte_export(c, c->rpe_next);
+    used += rte_export(c, c->rpe_next);
 
     if (!c->rpe_next)
       break;
   }
 
-  rt_send_export_event(c);
+  if (used)
+    rt_export_used(c->table);
+
+  rt_send_export_event(&c->h);
 }
 
 
@@ -1909,28 +1913,27 @@ rt_examine(rtable *t, net_addr *a, struct channel *c, const struct filter *filte
 }
 
 static void
-rt_table_export_done(struct rt_export_hook *hook)
+rt_table_export_done(void *hh)
 {
-  struct rt_exporter *re = hook->table;
-  struct rtable *tab = SKIP_BACK(struct rtable, exporter, re);
+  struct rt_table_export_hook *hook = hh;
+  struct rtable *tab = SKIP_BACK(struct rtable, exporter, hook->table);
 
   DBG("Export hook %p in table %s finished uc=%u\n", hook, tab->name, tab->use_count);
 
-  /* Free the hook before unlocking the table */
-  rfree(hook->pool);
+  /* Drop pending exports */
+  rt_export_used(&tab->exporter);
+
+  /* Do the common code */
+  rt_export_stopped(&hook->h);
 
   /* Unlock the table; this may free it */
   rt_unlock_table(tab);
 }
 
-static void
+void
 rt_export_stopped(void *data)
 {
   struct rt_export_hook *hook = data;
-  struct rt_exporter *tab = hook->table;
-
-  /* Drop pending exports */
-  CALL(tab->used, tab);
 
   /* Unlist */
   rem_node(&hook->n);
@@ -1938,8 +1941,8 @@ rt_export_stopped(void *data)
   /* Report the channel as stopped. */
   CALL(hook->stopped, hook->req);
 
-  /* Reporting the hook as finished. */
-  CALL(tab->done, hook);
+  /* Free the hook itself together with its pool */
+  rfree(hook->pool);
 }
 
 static inline void
@@ -1991,15 +1994,16 @@ rt_stop_import(struct rt_import_request *req, void (*stopped)(struct rt_import_r
   hook->stopped = stopped;
 }
 
-static struct rt_export_hook *
+static void
 rt_table_export_start(struct rt_exporter *re, struct rt_export_request *req)
 {
-  rtable *tab = SKIP_BACK(rtable, exporter, re);
+  rtable *tab = SKIP_BACK(rtable, exporter.e, re);
   rt_lock_table(tab);
 
-  pool *p = rp_new(tab->rp, "Export hook");
-  struct rt_export_hook *hook = mb_allocz(p, sizeof(struct rt_export_hook));
-  hook->pool = p;
+  req->hook = rt_alloc_export(re, sizeof(struct rt_table_export_hook));
+  req->hook->req = req;
+
+  struct rt_table_export_hook *hook = SKIP_BACK(struct rt_table_export_hook, h, req->hook);
 
   /* stats zeroed by mb_allocz */
   switch (req->addr_mode)
@@ -2007,24 +2011,24 @@ rt_table_export_start(struct rt_exporter *re, struct rt_export_request *req)
     case TE_ADDR_IN:
       if (tab->trie && net_val_match(tab->addr_type, NB_IP))
       {
-	hook->walk_state = mb_allocz(p, sizeof (struct f_trie_walk_state));
+	hook->walk_state = mb_allocz(hook->h.pool, sizeof (struct f_trie_walk_state));
 	hook->walk_lock = rt_lock_trie(tab);
 	trie_walk_init(hook->walk_state, tab->trie, req->addr);
-	hook->event = ev_new_init(p, rt_feed_by_trie, hook);
+	hook->h.event.hook = rt_feed_by_trie;
 	break;
       }
       /* fall through */
     case TE_ADDR_NONE:
       FIB_ITERATE_INIT(&hook->feed_fit, &tab->fib);
-      hook->event = ev_new_init(p, rt_feed_by_fib, hook);
+      hook->h.event.hook = rt_feed_by_fib;
       break;
 
     case TE_ADDR_EQUAL:
-      hook->event = ev_new_init(p, rt_feed_equal, hook);
+      hook->h.event.hook = rt_feed_equal;
       break;
 
     case TE_ADDR_FOR:
-      hook->event = ev_new_init(p, rt_feed_for, hook);
+      hook->h.event.hook = rt_feed_for;
       break;
 
     default:
@@ -2033,22 +2037,42 @@ rt_table_export_start(struct rt_exporter *re, struct rt_export_request *req)
 
   DBG("New export hook %p req %p in table %s uc=%u\n", hook, req, tab->name, tab->use_count);
 
-  return hook;
+  struct rt_pending_export *rpe = rt_last_export(hook->table);
+  DBG("store hook=%p last_export=%p seq=%lu\n", hook, rpe, rpe ? rpe->seq : 0);
+  atomic_store_explicit(&hook->last_export, rpe, memory_order_relaxed);
+
+  rt_init_export(re, req->hook);
+}
+
+void rt_request_export(rtable *tab, struct rt_export_request *req)
+{
+  rt_table_export_start(&tab->exporter.e, req);
 }
 
 void
-rt_request_export(struct rt_exporter *re, struct rt_export_request *req)
+rt_request_export_other(struct rt_exporter *re, struct rt_export_request *req)
 {
-  struct rt_export_hook *hook = req->hook = re->start(re, req);
+  return re->class->start(re, req);
+}
 
-  hook->req = req;
+struct rt_export_hook *
+rt_alloc_export(struct rt_exporter *re, uint size)
+{
+  pool *p = rp_new(re->rp, "Export hook");
+  struct rt_export_hook *hook = mb_allocz(p, size);
+
+  hook->pool = p;
   hook->table = re;
 
-  bmap_init(&hook->seq_map, hook->pool, 1024);
+  return hook;
+}
 
-  struct rt_pending_export *rpe = rt_last_export(hook->table);
-  DBG("store hook=%p last_export=%p seq=%lu\n", hook, rpe, rpe ? rpe->seq : 0);
-  atomic_store_explicit(&hook->last_export, rpe, memory_order_relaxed);
+void
+rt_init_export(struct rt_exporter *re, struct rt_export_hook *hook)
+{
+  hook->event.data = hook;
+
+  bmap_init(&hook->seq_map, hook->pool, 1024);
 
   hook->n = (node) {};
   add_tail(&re->hooks, &hook->n);
@@ -2059,14 +2083,15 @@ rt_request_export(struct rt_exporter *re, struct rt_export_request *req)
 }
 
 static void
-rt_table_export_stop(struct rt_export_hook *hook)
+rt_table_export_stop(struct rt_export_hook *hh)
 {
+  struct rt_table_export_hook *hook = SKIP_BACK(struct rt_table_export_hook, h, hh);
   rtable *tab = SKIP_BACK(rtable, exporter, hook->table);
 
-  if (atomic_load_explicit(&hook->export_state, memory_order_relaxed) != TES_FEEDING)
+  if (atomic_load_explicit(&hh->export_state, memory_order_relaxed) != TES_FEEDING)
     return;
 
-  switch (hook->req->addr_mode)
+  switch (hh->req->addr_mode)
   {
     case TE_ADDR_IN:
       if (hook->walk_lock)
@@ -2087,17 +2112,18 @@ rt_table_export_stop(struct rt_export_hook *hook)
 void
 rt_stop_export(struct rt_export_request *req, void (*stopped)(struct rt_export_request *))
 {
+  ASSERT_DIE(birdloop_inside(req->list->loop));
   ASSERT_DIE(req->hook);
   struct rt_export_hook *hook = req->hook;
 
   /* Cancel the feeder event */
-  ev_postpone(hook->event);
+  ev_postpone(&hook->event);
 
   /* Stop feeding from the exporter */
-  CALL(hook->table->stop, hook);
+  CALL(hook->table->class->stop, hook);
 
   /* Reset the event as the stopped event */
-  hook->event->hook = rt_export_stopped;
+  hook->event.hook = hook->table->class->done;
   hook->stopped = stopped;
 
   /* Update export state */
@@ -2253,13 +2279,14 @@ rt_dump_hooks(rtable *tab)
        ih->last_state_change, ih->import_state, ih->stopped);
   }
 
-  struct rt_export_hook *eh;
-  WALK_LIST(eh, tab->exporter.hooks)
+  struct rt_table_export_hook *eh;
+  WALK_LIST(eh, tab->exporter.e.hooks)
   {
-    eh->req->dump_req(eh->req);
+    eh->h.req->dump_req(eh->h.req);
     debug("  Export hook %p requested by %p:"
        " refeed_pending=%u last_state_change=%t export_state=%u\n",
-       eh, eh->req, eh->refeed_pending, eh->last_state_change, atomic_load_explicit(&eh->export_state, memory_order_relaxed));
+       eh, eh->h.req, eh->refeed_pending, eh->h.last_state_change,
+       atomic_load_explicit(&eh->h.export_state, memory_order_relaxed));
   }
   debug("\n");
 }
@@ -2303,7 +2330,7 @@ rt_schedule_prune(rtable *tab)
 }
 
 static void
-rt_export_used(struct rt_exporter *e)
+rt_export_used(struct rt_table_exporter *e)
 {
   rtable *tab = SKIP_BACK(rtable, exporter, e);
 
@@ -2426,15 +2453,15 @@ rt_flowspec_dump_req(struct rt_export_request *req)
 static struct rt_flowspec_link *
 rt_flowspec_find_link(rtable *src, rtable *dst)
 {
-  struct rt_export_hook *hook; node *n;
-  WALK_LIST2(hook, n, src->exporter.hooks, n)
-    switch (atomic_load_explicit(&hook->export_state, memory_order_acquire))
+  struct rt_table_export_hook *hook; node *n;
+  WALK_LIST2(hook, n, src->exporter.e.hooks, h.n)
+    switch (atomic_load_explicit(&hook->h.export_state, memory_order_acquire))
     {
       case TES_FEEDING:
       case TES_READY:
-	if (hook->req->export_one == rt_flowspec_export_one)
+	if (hook->h.req->export_one == rt_flowspec_export_one)
 	{
-	  struct rt_flowspec_link *ln = SKIP_BACK(struct rt_flowspec_link, req, hook->req);
+	  struct rt_flowspec_link *ln = SKIP_BACK(struct rt_flowspec_link, req, hook->h.req);
 	  if (ln->dst == dst)
 	    return ln;
 	}
@@ -2467,7 +2494,7 @@ rt_flowspec_link(rtable *src, rtable *dst)
       .export_one = rt_flowspec_export_one,
     };
 
-    rt_request_export(&src->exporter, &ln->req);
+    rt_request_export(src, &ln->req);
   }
 
   ln->uc++;
@@ -2544,6 +2571,18 @@ static struct resclass rt_class = {
   .memsize = NULL,
 };
 
+static const struct rt_exporter_class rt_table_exporter_class = {
+  .start = rt_table_export_start,
+  .stop = rt_table_export_stop,
+  .done = rt_table_export_done,
+};
+
+void
+rt_exporter_init(struct rt_exporter *e)
+{
+  init_list(&e->hooks);
+}
+
 rtable *
 rt_setup(pool *pp, struct rtable_config *cf)
 {
@@ -2568,17 +2607,6 @@ rt_setup(pool *pp, struct rtable_config *cf)
     t->fib.init = net_init_with_trie;
   }
 
-  t->exporter = (struct rt_exporter) {
-    .addr_type = t->addr_type,
-    .start = rt_table_export_start,
-    .stop = rt_table_export_stop,
-    .done = rt_table_export_done,
-    .used = rt_export_used,
-  };
-
-  init_list(&t->exporter.hooks);
-  init_list(&t->exporter.pending);
-
   init_list(&t->imports);
 
   hmap_init(&t->id_map, p, 1024);
@@ -2587,9 +2615,21 @@ rt_setup(pool *pp, struct rtable_config *cf)
   t->rt_event = ev_new_init(p, rt_event, t);
   t->uncork_event = ev_new_init(p, rt_uncork_event, t);
   t->prune_timer = tm_new_init(p, rt_prune_timer, t, 0, 0);
-  t->exporter.export_timer = tm_new_init(p, rt_announce_exports, t, 0, 0);
   t->last_rt_change = t->gc_time = current_time();
-  t->exporter.next_seq = 1;
+
+  t->exporter = (struct rt_table_exporter) {
+    .e = {
+      .class = &rt_table_exporter_class,
+      .addr_type = t->addr_type,
+      .rp = t->rp,
+    },
+    .export_timer = tm_new_init(p, rt_announce_exports, t, 0, 0),
+    .next_seq = 1,
+  };
+
+  rt_exporter_init(&t->exporter.e);
+
+  init_list(&t->exporter.pending);
 
   t->cork_threshold = cf->cork_threshold;
 
@@ -2781,7 +2821,7 @@ again:
     }
 
   /* In some cases, we may want to directly proceed to export cleanup */
-  if (EMPTY_LIST(tab->exporter.hooks) && flushed_channels)
+  if (EMPTY_LIST(tab->exporter.e.hooks) && flushed_channels)
     rt_export_cleanup(tab);
 }
 
@@ -2795,11 +2835,11 @@ rt_export_cleanup(rtable *tab)
   struct rt_pending_export *first = tab->exporter.first;
   int want_prune = 0;
 
-  struct rt_export_hook *eh;
+  struct rt_table_export_hook *eh;
   node *n;
-  WALK_LIST2(eh, n, tab->exporter.hooks, n)
+  WALK_LIST2(eh, n, tab->exporter.e.hooks, h.n)
   {
-    switch (atomic_load_explicit(&eh->export_state, memory_order_acquire))
+    switch (atomic_load_explicit(&eh->h.export_state, memory_order_acquire))
     {
       case TES_DOWN:
 	continue;
@@ -2832,9 +2872,9 @@ rt_export_cleanup(rtable *tab)
       tab->exporter.first ? tab->exporter.first->seq : 0,
       min_seq);
 
-  WALK_LIST2(eh, n, tab->exporter.hooks, n)
+  WALK_LIST2(eh, n, tab->exporter.e.hooks, h.n)
   {
-    if (atomic_load_explicit(&eh->export_state, memory_order_acquire) != TES_READY)
+    if (atomic_load_explicit(&eh->h.export_state, memory_order_acquire) != TES_READY)
       continue;
 
     struct rt_pending_export *last = atomic_load_explicit(&eh->last_export, memory_order_acquire);
@@ -2908,13 +2948,13 @@ rt_export_cleanup(rtable *tab)
 	rt_trace(tab, D_EVENTS, "Resetting export seq");
 
 	node *n;
-	WALK_LIST2(eh, n, tab->exporter.hooks, n)
+	WALK_LIST2(eh, n, tab->exporter.e.hooks, h.n)
 	{
-	  if (atomic_load_explicit(&eh->export_state, memory_order_acquire) != TES_READY)
+	  if (atomic_load_explicit(&eh->h.export_state, memory_order_acquire) != TES_READY)
 	    continue;
 
 	  ASSERT_DIE(atomic_load_explicit(&eh->last_export, memory_order_acquire) == NULL);
-	  bmap_reset(&eh->seq_map, 1024);
+	  bmap_reset(&eh->h.seq_map, 1024);
 	}
 
 	tab->exporter.next_seq = 1;
@@ -3667,10 +3707,10 @@ rt_reconfigure(rtable *tab, struct rtable_config *new, struct rtable_config *old
   if (tab->hostcache)
     tab->hostcache->req.trace_routes = new->debug;
 
-  struct rt_export_hook *hook; node *n;
-  WALK_LIST2(hook, n, tab->exporter.hooks, n)
-    if (hook->req->export_one == rt_flowspec_export_one)
-      hook->req->trace_routes = new->debug;
+  struct rt_table_export_hook *hook; node *n;
+  WALK_LIST2(hook, n, tab->exporter.e.hooks, h.n)
+    if (hook->h.req->export_one == rt_flowspec_export_one)
+      hook->h.req->trace_routes = new->debug;
 
   tab->cork_threshold = new->cork_threshold;
 
@@ -3745,7 +3785,7 @@ rt_commit(struct config *new, struct config *old)
 static void
 rt_feed_done(struct rt_export_hook *c)
 {
-  c->event->hook = rt_export_hook;
+  c->event.hook = rt_export_hook;
 
   rt_set_export_state(c, TES_READY);
 
@@ -3764,12 +3804,12 @@ rt_feed_done(struct rt_export_hook *c)
 static void
 rt_feed_by_fib(void *data)
 {
-  struct rt_export_hook *c = data;
+  struct rt_table_export_hook *c = data;
 
   struct fib_iterator *fit = &c->feed_fit;
   int max_feed = 256;
 
-  ASSERT(atomic_load_explicit(&c->export_state, memory_order_relaxed) == TES_FEEDING);
+  ASSERT(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
 
   rtable *tab = SKIP_BACK(rtable, exporter, c->table);
 
@@ -3778,25 +3818,25 @@ rt_feed_by_fib(void *data)
       if (max_feed <= 0)
 	{
 	  FIB_ITERATE_PUT(fit);
-	  rt_send_export_event(c);
+	  rt_send_export_event(&c->h);
 	  return;
 	}
 
-      if (atomic_load_explicit(&c->export_state, memory_order_acquire) != TES_FEEDING)
+      if (atomic_load_explicit(&c->h.export_state, memory_order_acquire) != TES_FEEDING)
 	return;
 
-      if ((c->req->addr_mode == TE_ADDR_NONE) || net_in_netX(n->n.addr, c->req->addr))
+      if ((c->h.req->addr_mode == TE_ADDR_NONE) || net_in_netX(n->n.addr, c->h.req->addr))
 	max_feed -= rt_feed_net(c, n);
     }
   FIB_ITERATE_END;
 
-  rt_feed_done(c);
+  rt_feed_done(&c->h);
 }
 
 static void
 rt_feed_by_trie(void *data)
 {
-  struct rt_export_hook *c = data;
+  struct rt_table_export_hook *c = data;
   rtable *tab = SKIP_BACK(rtable, exporter, c->table);
 
   ASSERT_DIE(c->walk_state);
@@ -3804,7 +3844,7 @@ rt_feed_by_trie(void *data)
 
   int max_feed = 256;
 
-  ASSERT(atomic_load_explicit(&c->export_state, memory_order_relaxed) == TES_FEEDING);
+  ASSERT(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
 
   net_addr addr;
   while (trie_walk_next(ws, &addr))
@@ -3816,7 +3856,7 @@ rt_feed_by_trie(void *data)
     if ((max_feed -= rt_feed_net(c, n)) <= 0)
       return;
 
-    if (atomic_load_explicit(&c->export_state, memory_order_acquire) != TES_FEEDING)
+    if (atomic_load_explicit(&c->h.export_state, memory_order_acquire) != TES_FEEDING)
       return;
   }
 
@@ -3826,65 +3866,65 @@ rt_feed_by_trie(void *data)
   mb_free(c->walk_state);
   c->walk_state = NULL;
 
-  rt_feed_done(c);
+  rt_feed_done(&c->h);
 }
 
 static void
 rt_feed_equal(void *data)
 {
-  struct rt_export_hook *c = data;
+  struct rt_table_export_hook *c = data;
   rtable *tab = SKIP_BACK(rtable, exporter, c->table);
 
-  ASSERT_DIE(atomic_load_explicit(&c->export_state, memory_order_relaxed) == TES_FEEDING);
-  ASSERT_DIE(c->req->addr_mode == TE_ADDR_EQUAL);
+  ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
+  ASSERT_DIE(c->h.req->addr_mode == TE_ADDR_EQUAL);
 
-  net *n = net_find(tab, c->req->addr);
+  net *n = net_find(tab, c->h.req->addr);
   if (n)
     rt_feed_net(c, n);
 
-  rt_feed_done(c);
+  rt_feed_done(&c->h);
 }
 
 static void
 rt_feed_for(void *data)
 {
-  struct rt_export_hook *c = data;
+  struct rt_table_export_hook *c = data;
   rtable *tab = SKIP_BACK(rtable, exporter, c->table);
 
-  ASSERT_DIE(atomic_load_explicit(&c->export_state, memory_order_relaxed) == TES_FEEDING);
-  ASSERT_DIE(c->req->addr_mode == TE_ADDR_FOR);
+  ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
+  ASSERT_DIE(c->h.req->addr_mode == TE_ADDR_FOR);
 
-  net *n = net_route(tab, c->req->addr);
+  net *n = net_route(tab, c->h.req->addr);
   if (n)
     rt_feed_net(c, n);
 
-  rt_feed_done(c);
+  rt_feed_done(&c->h);
 }
 
 static uint
-rt_feed_net(struct rt_export_hook *c, net *n)
+rt_feed_net(struct rt_table_export_hook *c, net *n)
 {
   uint count = 0;
 
-  if (c->req->export_bulk)
+  if (c->h.req->export_bulk)
   {
     count = rte_feed_count(n);
     if (count)
     {
       rte **feed = alloca(count * sizeof(rte *));
       rte_feed_obtain(n, feed, count);
-      c->req->export_bulk(c->req, n->n.addr, NULL, feed, count);
+      c->h.req->export_bulk(c->h.req, n->n.addr, NULL, feed, count);
     }
   }
 
   else if (n->routes)
   {
     struct rt_pending_export rpe = { .new = n->routes, .new_best = n->routes };
-    c->req->export_one(c->req, n->n.addr, &rpe);
+    c->h.req->export_one(c->h.req, n->n.addr, &rpe);
     count = 1;
   }
 
-  rpe_mark_seen_all(c, n->first, NULL);
+  rpe_mark_seen_all(&c->h, n->first, NULL);
   return count;
 }
 
@@ -4072,7 +4112,7 @@ rt_init_hostcache(rtable *tab)
     .export_one = hc_notify_export_one,
   };
 
-  rt_request_export(&tab->exporter, &hc->req);
+  rt_request_export(tab, &hc->req);
 
   tab->hostcache = hc;
 }
diff --git a/nest/rt.h b/nest/rt.h
index 78585c79..a14c23e7 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -67,16 +67,23 @@ struct rtable_config {
 
 struct rt_export_hook;
 struct rt_export_request;
+struct rt_exporter;
+
+struct rt_exporter_class {
+  void (*start)(struct rt_exporter *, struct rt_export_request *);
+  void (*stop)(struct rt_export_hook *);
+  void (*done)(void *_rt_export_hook);
+};
 
 struct rt_exporter {
+  const struct rt_exporter_class *class;
+  pool *rp;
   list hooks;				/* Registered route export hooks */
   uint addr_type;			/* Type of address data exported (NET_*) */
+};
 
-  struct rt_export_hook *(*start)(struct rt_exporter *, struct rt_export_request *);
-  void (*stop)(struct rt_export_hook *);
-  void (*done)(struct rt_export_hook *);
-  void (*used)(struct rt_exporter *);
-
+struct rt_table_exporter {
+  struct rt_exporter e;
   list pending;				/* List of packed struct rt_pending_export */
   struct timer *export_timer;
 
@@ -97,7 +104,7 @@ typedef struct rtable {
   u32 rt_count;				/* Number of routes in the table */
 
   list imports;				/* Registered route importers */
-  struct rt_exporter exporter;		/* Exporter API structure */
+  struct rt_table_exporter exporter;	/* Exporter API structure */
 
   struct hmap id_map;
   struct hostcache *hostcache;
@@ -266,29 +273,39 @@ struct rt_export_hook {
     u32 withdraws_received;		/* Number of route withdraws received */
   } stats;
 
+  btime last_state_change;		/* Time of last state transition */
+
+  _Atomic u8 export_state;		/* Route export state (TES_*, see below) */
+  struct event event;			/* Event running all the export operations */
+
+  struct bmap seq_map;			/* Keep track which exports were already procesed */
+
+  void (*stopped)(struct rt_export_request *);	/* Stored callback when export is stopped */
+};
+
+struct rt_table_export_hook {
+  union {
+    struct rt_export_hook h;
+    struct {				/* Overriding the parent structure beginning */
+      node _n;
+      struct rt_table_exporter *table;
+    };
+  };
+  
   union {
     struct fib_iterator feed_fit;		/* Routing table iterator used during feeding */
     struct {
       struct f_trie_walk_state *walk_state;	/* Iterator over networks in trie */
       struct f_trie *walk_lock;			/* Locked trie for walking */
     };
-    u32 hash_iter;				/* Iterator over hash */
   };
 
-  struct bmap seq_map;			/* Keep track which exports were already procesed */
-
-  struct rt_pending_export * _Atomic last_export;/* Last export processed */
+  struct rt_pending_export *_Atomic last_export;/* Last export processed */
   struct rt_pending_export *rpe_next;	/* Next pending export to process */
 
-  btime last_state_change;		/* Time of last state transition */
-
   u8 refeed_pending;			/* Refeeding and another refeed is scheduled */
-  _Atomic u8 export_state;		/* Route export state (TES_*, see below) */
   u8 feed_type;				/* Which feeding method is used (TFT_*, see below) */
 
-  struct event *event;			/* Event running all the export operations */
-
-  void (*stopped)(struct rt_export_request *);	/* Stored callback when export is stopped */
 };
 
 #define TIS_DOWN	0
@@ -317,7 +334,8 @@ struct rt_export_hook {
 #define TFT_HASH	3
 
 void rt_request_import(rtable *tab, struct rt_import_request *req);
-void rt_request_export(struct rt_exporter *tab, struct rt_export_request *req);
+void rt_request_export(rtable *tab, struct rt_export_request *req);
+void rt_request_export_other(struct rt_exporter *tab, struct rt_export_request *req);
 
 void rt_export_once(struct rt_exporter *tab, struct rt_export_request *req);
 
@@ -334,6 +352,10 @@ void rt_set_export_state(struct rt_export_hook *hook, u8 state);
 
 void rte_import(struct rt_import_request *req, const net_addr *net, rte *new, struct rte_src *src);
 
+/*
+ * For table export processing
+ */
+
 /* Get next rpe. If src is given, it must match. */
 struct rt_pending_export *rpe_next(struct rt_pending_export *rpe, struct rte_src *src);
 
@@ -350,6 +372,15 @@ void rpe_mark_seen(struct rt_export_hook *hook, struct rt_pending_export *rpe);
 /* Get pending export seen status */
 int rpe_get_seen(struct rt_export_hook *hook, struct rt_pending_export *rpe);
 
+/*
+ * For rt_export_hook and rt_exporter inheritance
+ */
+
+void rt_init_export(struct rt_exporter *re, struct rt_export_hook *hook);
+struct rt_export_hook *rt_alloc_export(struct rt_exporter *re, uint size);
+void rt_export_stopped(void *data);
+void rt_exporter_init(struct rt_exporter *re);
+
 /* Types of route announcement, also used as flags */
 #define RA_UNDEF	0		/* Undefined RA type */
 #define RA_OPTIMAL	1		/* Announcement of optimal route change */
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 84a0b023..dcced164 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -1867,25 +1867,30 @@ bgp_free_pending_tx(struct bgp_channel *c)
  *	Prefix hash table exporter
  */
 
+struct bgp_out_export_hook {
+  struct rt_export_hook h;
+  u32 hash_iter;				/* Iterator over hash */
+};
+
 static void
 bgp_out_table_feed(void *data)
 {
-  struct rt_export_hook *hook = data;
-  struct bgp_channel *bc = SKIP_BACK(struct bgp_channel, prefix_exporter, hook->table);
+  struct bgp_out_export_hook *hook = data;
+  struct bgp_channel *bc = SKIP_BACK(struct bgp_channel, prefix_exporter, hook->h.table);
   struct bgp_pending_tx *c = bc->ptx;
 
   int max = 512;
 
-  const net_addr *neq = (hook->req->addr_mode == TE_ADDR_EQUAL) ? hook->req->addr : NULL;
+  const net_addr *neq = (hook->h.req->addr_mode == TE_ADDR_EQUAL) ? hook->h.req->addr : NULL;
   const net_addr *cand = NULL;
 
   do {
     HASH_WALK_ITER(c->prefix_hash, PXH, n, hook->hash_iter)
     {
-      switch (hook->req->addr_mode)
+      switch (hook->h.req->addr_mode)
       {
 	case TE_ADDR_IN:
-	  if (!net_in_netX(n->net, hook->req->addr))
+	  if (!net_in_netX(n->net, hook->h.req->addr))
 	    continue;
 	  /* fall through */
 	case TE_ADDR_NONE:
@@ -1897,7 +1902,7 @@ bgp_out_table_feed(void *data)
 	case TE_ADDR_FOR:
 	  if (!neq)
 	  {
-	    if (net_in_netX(hook->req->addr, n->net) && (!cand || (n->net->length > cand->length)))
+	    if (net_in_netX(hook->h.req->addr, n->net) && (!cand || (n->net->length > cand->length)))
 	      cand = n->net;
 	    continue;
 	  }
@@ -1942,13 +1947,13 @@ bgp_out_table_feed(void *data)
 	.new = &es, .new_best = &es,
       };
 
-      if (hook->req->export_bulk)
+      if (hook->h.req->export_bulk)
       {
 	rte *feed = &es.rte;
-	hook->req->export_bulk(hook->req, n->net, &rpe, &feed, 1);
+	hook->h.req->export_bulk(hook->h.req, n->net, &rpe, &feed, 1);
       }
-      else if (hook->req->export_one)
-	hook->req->export_one(hook->req, n->net, &rpe);
+      else if (hook->h.req->export_one)
+	hook->h.req->export_one(hook->h.req, n->net, &rpe);
       else
 	bug("No export method in export request");
     }
@@ -1959,43 +1964,40 @@ bgp_out_table_feed(void *data)
   } while (neq);
 
   if (hook->hash_iter)
-    ev_schedule_work(hook->event);
+    ev_schedule_work(&hook->h.event);
   else
-    rt_set_export_state(hook, TES_READY);
+    rt_set_export_state(&hook->h, TES_READY);
 }
 
-static struct rt_export_hook *
-bgp_out_table_export_start(struct rt_exporter *re, struct rt_export_request *req UNUSED)
+static void
+bgp_out_table_export_start(struct rt_exporter *re, struct rt_export_request *req)
 {
-  struct bgp_channel *bc = SKIP_BACK(struct bgp_channel, prefix_exporter, re);
-  pool *p = rp_new(bc->c.proto->pool, "Export hook");
-  struct rt_export_hook *hook = mb_allocz(p, sizeof(struct rt_export_hook));
-  hook->pool = p;
-  hook->event = ev_new_init(p, bgp_out_table_feed, hook);
-  hook->feed_type = TFT_HASH;
+  req->hook = rt_alloc_export(re, sizeof(struct bgp_out_export_hook));
+  req->hook->req = req;
 
-  return hook;
-}
+  struct bgp_out_export_hook *hook = SKIP_BACK(struct bgp_out_export_hook, h, req->hook);
 
-static void
-bgp_out_table_export_done(struct rt_export_hook *hook)
-{
-  rfree(hook->pool);
+  hook->h.event.hook = bgp_out_table_feed;
+  rt_init_export(re, req->hook);
 }
 
+static const struct rt_exporter_class bgp_out_table_export_class = {
+  .start = bgp_out_table_export_start,
+  .done = rt_export_stopped,
+};
+
 void
 bgp_setup_out_table(struct bgp_channel *c)
 {
   ASSERT_DIE(c->c.out_table == NULL);
 
   c->prefix_exporter = (struct rt_exporter) {
+    .class = &bgp_out_table_export_class,
     .addr_type = c->c.table->addr_type,
-    .start = bgp_out_table_export_start,
-    .done = bgp_out_table_export_done,
+    .rp = c->c.proto->pool,
   };
 
-  init_list(&c->prefix_exporter.hooks);
-  init_list(&c->prefix_exporter.pending);
+  rt_exporter_init(&c->prefix_exporter);
 
   c->c.out_table = &c->prefix_exporter;
 }
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 97b18fcf..573e3d25 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -847,7 +847,7 @@ bgp_graceful_restart_feed(struct bgp_channel *c)
     .export_one = bgp_graceful_restart_drop_export,
   };
 
-  rt_request_export(&c->c.table->exporter, &c->stale_feed);
+  rt_request_export(c->c.table, &c->stale_feed);
 }
 
 
-- 
cgit v1.2.3


From 28accd4f05e9c153d702736f3e08fa66e81a5536 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Mon, 5 Sep 2022 12:55:36 +0200
Subject: Next hop update triggered at the very end of hostcache update

---
 nest/rt-table.c | 19 +++++++++++++++++--
 nest/rt.h       |  3 +++
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index de955ebb..0cca6142 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -103,6 +103,7 @@
 #include "lib/string.h"
 #include "lib/alloca.h"
 #include "lib/flowspec.h"
+#include "lib/idm.h"
 
 #ifdef CONFIG_BGP
 #include "proto/bgp/bgp.h"
@@ -2420,7 +2421,7 @@ rt_flowspec_export_one(struct rt_export_request *req, const net_addr *net, struc
   rtable *dst = ln->dst;
   ASSUME(rt_is_flow(dst));
 
-  /* No need to inspect it further if recalculation is already active */
+  /* No need to inspect it further if recalculation is already scheduled */
   if ((dst->nhu_state == NHU_SCHEDULED) || (dst->nhu_state == NHU_DIRTY)
       || !trie_match_net(dst->flowspec_trie, net))
   {
@@ -2583,6 +2584,9 @@ rt_exporter_init(struct rt_exporter *e)
   init_list(&e->hooks);
 }
 
+static struct idm rtable_idm;
+uint rtable_max_id = 0;
+
 rtable *
 rt_setup(pool *pp, struct rtable_config *cf)
 {
@@ -2596,6 +2600,9 @@ rt_setup(pool *pp, struct rtable_config *cf)
   t->name = cf->name;
   t->config = cf;
   t->addr_type = cf->addr_type;
+  t->id = idm_alloc(&rtable_idm);
+  if (t->id >= rtable_max_id)
+    rtable_max_id = t->id + 1;
 
   fib_init(&t->fib, p, t->addr_type, sizeof(net), OFFSETOF(net, n), 0, NULL);
 
@@ -2659,6 +2666,7 @@ rt_init(void)
   init_list(&deleted_routing_tables);
   ev_init_list(&rt_cork.queue, &main_birdloop, "Route cork release");
   rt_cork.run = (event) { .hook = rt_cork_release_hook };
+  idm_init(&rtable_idm, rt_table_pool, 256);
 }
 
 
@@ -4247,6 +4255,9 @@ rt_update_hostcache(void *data)
     return;
   }
 
+  /* Destination schedule map */
+  rtable **nhu_pending = tmp_allocz(sizeof(rtable *) * rtable_max_id);
+
   struct hostentry *he;
   node *n, *x;
 
@@ -4264,8 +4275,12 @@ rt_update_hostcache(void *data)
 	}
 
       if (rt_update_hostentry(tab, he))
-	rt_schedule_nhu(he->tab);
+	nhu_pending[he->tab->id] = he->tab;
     }
+
+  for (uint i=0; i<rtable_max_id; i++)
+    if (nhu_pending[i])
+      rt_schedule_nhu(nhu_pending[i]);
 }
 
 static struct hostentry *
diff --git a/nest/rt.h b/nest/rt.h
index a14c23e7..b94024fd 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -91,6 +91,8 @@ struct rt_table_exporter {
   u64 next_seq;				/* The next export will have this ID */
 };
 
+extern uint rtable_max_id;
+
 typedef struct rtable {
   resource r;
   node n;				/* Node in list of all tables */
@@ -100,6 +102,7 @@ typedef struct rtable {
   struct f_trie *trie;			/* Trie of prefixes defined in fib */
   char *name;				/* Name of this table */
   uint addr_type;			/* Type of address data stored in table (NET_*) */
+  uint id;				/* Integer table ID for fast lookup */
   int use_count;			/* Number of protocols using this table */
   u32 rt_count;				/* Number of routes in the table */
 
-- 
cgit v1.2.3


From a61a04b5c8fcfccf491f7f9baebab352c3692f54 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Tue, 6 Sep 2022 19:38:40 +0200
Subject: Next hop refactoring to allow for table locking

---
 nest/rt-table.c | 137 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 82 insertions(+), 55 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index 0cca6142..07933332 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -181,7 +181,6 @@ const char *rt_export_state_name(u8 state)
     return rt_export_state_name_array[state];
 }
 
-static inline struct rte_storage *rt_next_hop_update_rte(rtable *tab, net *n, rte *old);
 static struct hostentry *rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep);
 
 #define rt_trace(tab, level, fmt, args...)  do {\
@@ -3250,17 +3249,16 @@ rta_next_hop_outdated(ea_list *a)
     ? head : NULL;
 }
 
-static inline struct rte_storage *
-rt_next_hop_update_rte(rtable *tab, net *n, rte *old)
+static inline int
+rt_next_hop_update_rte(rte *old, rte *new)
 {
   struct hostentry_adata *head = rta_next_hop_outdated(old->attrs);
   if (!head)
-    return NULL;
-
-  rte e0 = *old;
-  rta_apply_hostentry(&e0.attrs, head);
+    return 0;
 
-  return rte_store(&e0, n, tab);
+  *new = *old;
+  rta_apply_hostentry(&new->attrs, head);
+  return 1;
 }
 
 static inline void
@@ -3392,31 +3390,30 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, ea_list *
 
 #endif /* CONFIG_BGP */
 
-static struct rte_storage *
-rt_flowspec_update_rte(rtable *tab, net *n, rte *r)
+static int
+rt_flowspec_update_rte(rtable *tab, rte *r, rte *new)
 {
 #ifdef CONFIG_BGP
   if (r->generation || (rt_get_source_attr(r) != RTS_BGP))
-    return NULL;
+    return 0;
 
   struct bgp_channel *bc = (struct bgp_channel *) SKIP_BACK(struct channel, in_req, r->sender->req);
   if (!bc->base_table)
-    return NULL;
+    return 0;
 
   struct bgp_proto *p = SKIP_BACK(struct bgp_proto, p, bc->c.proto);
 
   enum flowspec_valid old = rt_get_flowspec_valid(r),
-		      valid = rt_flowspec_check(bc->base_table, tab, n->n.addr, r->attrs, p->is_interior);
+		      valid = rt_flowspec_check(bc->base_table, tab, r->net, r->attrs, p->is_interior);
 
   if (old == valid)
-    return NULL;
-
-  rte new = *r;
-  ea_set_attr_u32(&new.attrs, &ea_gen_flowspec_valid, 0, valid);
+    return 0;
 
-  return rte_store(&new, n, tab);
+  *new = *r;
+  ea_set_attr_u32(&new->attrs, &ea_gen_flowspec_valid, 0, valid);
+  return 1;
 #else
-  return NULL;
+  return 0;
 #endif
 }
 
@@ -3453,8 +3450,7 @@ rt_flowspec_resolve_rte(rte *r, struct channel *c)
 static inline int
 rt_next_hop_update_net(rtable *tab, net *n)
 {
-  struct rte_storage *new;
-  int count = 0;
+  uint count = 0;
   int is_flow = net_is_flow(n->n.addr);
 
   struct rte_storage *old_best = n->routes;
@@ -3462,49 +3458,71 @@ rt_next_hop_update_net(rtable *tab, net *n)
     return 0;
 
   for (struct rte_storage *e, **k = &n->routes; e = *k; k = &e->next)
-    if (is_flow || rta_next_hop_outdated(e->rte.attrs))
-      count++;
+    count++;
 
   if (!count)
     return 0;
 
   struct rte_multiupdate {
-    struct rte_storage *old, *new;
-  } *updates = alloca(sizeof(struct rte_multiupdate) * count);
+    struct rte_storage *old, *new_stored;
+    rte new;
+  } *updates = tmp_allocz(sizeof(struct rte_multiupdate) * (count+1));
 
-  int pos = 0;
+  //struct rt_pending_export *last_pending = n->last;
+
+  uint pos = 0;
   for (struct rte_storage *e, **k = &n->routes; e = *k; k = &e->next)
-    if (is_flow || rta_next_hop_outdated(e->rte.attrs))
-      {
-	struct rte_storage *new = is_flow
-	  ? rt_flowspec_update_rte(tab, n, &e->rte)
-	  : rt_next_hop_update_rte(tab, n, &e->rte);
+    updates[pos++].old = e;
 
-	if (!new)
-	  continue;
+  uint mod = 0;
+  if (is_flow)
+    for (uint i = 0; i < pos; i++)
+      mod += rt_flowspec_update_rte(tab, &updates[i].old->rte, &updates[i].new);
 
-	/* Call a pre-comparison hook */
-	/* Not really an efficient way to compute this */
-	if (e->rte.src->owner->rte_recalculate)
-	  e->rte.src->owner->rte_recalculate(tab, n, &new->rte, &e->rte, &old_best->rte);
+  else
+    for (uint i = 0; i < pos; i++)
+      mod += rt_next_hop_update_rte(&updates[i].old->rte, &updates[i].new);
+
+  if (!mod)
+    return 0;
 
-	updates[pos++] = (struct rte_multiupdate) {
-	  .old = e,
-	  .new = new,
-	};
+  /* Next commit: Here check whether the network hasn't changed while generating updates */
 
-	/* Replace the route in the list */
-	new->next = e->next;
-	*k = e = new;
+  for (uint i = 0; i < pos; i++)
+    if (updates[i].new.attrs)
+      {
+	/* Call a pre-comparison hook */
+	/* Not really an efficient way to compute this */
+	if (updates[i].old->rte.src->owner->rte_recalculate)
+	  updates[i].old->rte.src->owner->rte_recalculate(tab, n, &updates[i].new, &updates[i].old->rte, &old_best->rte);
+	/* And store the route */
+	struct rte_storage *ns = updates[i].new_stored = rte_store(&updates[i].new, n, tab);
 
 	/* Get a new ID for the route */
-	new->rte.lastmod = current_time();
-	new->rte.id = hmap_first_zero(&tab->id_map);
-	hmap_set(&tab->id_map, new->rte.id);
+	ns->rte.lastmod = current_time();
+	ns->rte.id = hmap_first_zero(&tab->id_map);
+	hmap_set(&tab->id_map, ns->rte.id);
       }
 
-  ASSERT_DIE(pos <= count);
-  count = pos;
+  /* Now we reconstruct the original linked list */
+  struct rte_storage **nptr = &n->routes;
+  for (uint i = 0; i < pos; i++)
+  {
+    updates[i].old->next = NULL;
+
+    struct rte_storage *put = updates[i].new_stored ?: updates[i].old;
+    *nptr = put;
+    nptr = &put->next;
+  }
+  *nptr = NULL;
+
+  {
+    uint t = 0;
+    for (struct rte_storage *e = n->routes; e; e = e->next)
+      t++;
+    ASSERT_DIE(t == pos);
+    ASSERT_DIE(pos == count);
+  }
 
   /* Find the new best route */
   struct rte_storage **new_best = NULL;
@@ -3515,7 +3533,7 @@ rt_next_hop_update_net(rtable *tab, net *n)
     }
 
   /* Relink the new best route to the first position */
-  new = *new_best;
+  struct rte_storage *new = *new_best;
   if (new != n->routes)
     {
       *new_best = new->next;
@@ -3523,19 +3541,25 @@ rt_next_hop_update_net(rtable *tab, net *n)
       n->routes = new;
     }
 
+  uint total = 0;
   /* Announce the changes */
-  for (int i=0; i<count; i++)
+  for (uint i=0; i<count; i++)
   {
-    _Bool nb = (new == updates[i].new), ob = (old_best == updates[i].old);
+    if (!updates[i].new_stored)
+      continue;
+
+    _Bool nb = (new->rte.src == updates[i].new.src), ob = (i == 0);
     const char *best_indicator[2][2] = {
       { "autoupdated", "autoupdated [-best]" },
       { "autoupdated [+best]", "autoupdated [best]" }
     };
-    rt_rte_trace_in(D_ROUTES, updates[i].new->rte.sender->req, &updates[i].new->rte, best_indicator[nb][ob]);
-    rte_announce(tab, n, updates[i].new, updates[i].old, new, old_best);
+    rt_rte_trace_in(D_ROUTES, updates[i].new.sender->req, &updates[i].new, best_indicator[nb][ob]);
+    rte_announce(tab, n, updates[i].new_stored, updates[i].old, new, old_best);
+
+    total++;
   }
 
-  return count;
+  return total;
 }
 
 static void
@@ -3564,7 +3588,10 @@ rt_next_hop_update(rtable *tab)
 	  ev_schedule(tab->rt_event);
 	  return;
 	}
+      lp_state lps;
+      lp_save(tmp_linpool, &lps);
       max_feed -= rt_next_hop_update_net(tab, n);
+      lp_restore(tmp_linpool, &lps);
     }
   FIB_ITERATE_END;
 
-- 
cgit v1.2.3


From e2c612063649cb5134459ab0a2c7377f00d6e9c0 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 7 Sep 2022 13:12:44 +0200
Subject: Next hop updater has its own event

---
 nest/rt-table.c | 119 ++++++++++++++++++++++++++++++--------------------------
 nest/rt.h       |   2 +-
 2 files changed, 65 insertions(+), 56 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index 07933332..eb53eff7 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -130,7 +130,7 @@ struct rt_export_block {
 
 static void rt_free_hostcache(rtable *tab);
 static void rt_update_hostcache(void *tab);
-static void rt_next_hop_update(rtable *tab);
+static void rt_next_hop_update(void *tab);
 static inline void rt_next_hop_resolve_rte(rte *r);
 static inline void rt_flowspec_resolve_rte(rte *r, struct channel *c);
 static inline void rt_prune_table(rtable *tab);
@@ -2309,14 +2309,26 @@ rt_dump_hooks_all(void)
 static inline void
 rt_schedule_nhu(rtable *tab)
 {
-  if (tab->nhu_state == NHU_CLEAN)
-    ev_schedule(tab->rt_event);
-
-  /* state change:
-   *   NHU_CLEAN   -> NHU_SCHEDULED
-   *   NHU_RUNNING -> NHU_DIRTY
-   */
-  tab->nhu_state |= NHU_SCHEDULED;
+  if (tab->nhu_corked)
+  {
+    if (!(tab->nhu_corked & NHU_SCHEDULED))
+    {
+      tab->nhu_corked |= NHU_SCHEDULED;
+      rt_lock_table(tab);
+    }
+  }
+  else if (!(tab->nhu_state & NHU_SCHEDULED))
+  {
+    rt_trace(tab, D_EVENTS, "Scheduling NHU");
+    rt_lock_table(tab);
+
+    /* state change:
+     *   NHU_CLEAN   -> NHU_SCHEDULED
+     *   NHU_RUNNING -> NHU_DIRTY
+     */
+    if ((tab->nhu_state |= NHU_SCHEDULED) == NHU_SCHEDULED)
+      ev_schedule(tab->nhu_event);
+  }
 }
 
 void
@@ -2353,43 +2365,12 @@ rt_event(void *ptr)
   if (tab->export_used)
     rt_export_cleanup(tab);
 
-  if (tab->nhu_corked || tab->nhu_state && rt_cork_check(tab->uncork_event))
-  {
-    if (!tab->nhu_corked)
-    {
-      rt_trace(tab, D_STATES, "Next hop updater corked");
-      if ((tab->nhu_state & NHU_RUNNING)
-	  && !EMPTY_LIST(tab->exporter.pending)
-	  && !tm_active(tab->exporter.export_timer))
-	tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
-    }
-
-    tab->nhu_corked |= tab->nhu_state;
-    tab->nhu_state = 0;
-  }
-
-  if (tab->nhu_state)
-    rt_next_hop_update(tab);
-
   if (tab->prune_state)
     rt_prune_table(tab);
 
   rt_unlock_table(tab);
 }
 
-static void
-rt_uncork_event(void *ptr)
-{
-  rtable *tab = ptr;
-
-  tab->nhu_state |= tab->nhu_corked;
-  tab->nhu_corked = 0;
-
-  rt_trace(tab, D_STATES, "Next hop updater uncorked");
-
-  ev_schedule(tab->rt_event);
-}
-
 static void
 rt_prune_timer(timer *t)
 {
@@ -2619,7 +2600,7 @@ rt_setup(pool *pp, struct rtable_config *cf)
   hmap_set(&t->id_map, 0);
 
   t->rt_event = ev_new_init(p, rt_event, t);
-  t->uncork_event = ev_new_init(p, rt_uncork_event, t);
+  t->nhu_event = ev_new_init(p, rt_next_hop_update, t);
   t->prune_timer = tm_new_init(p, rt_prune_timer, t, 0, 0);
   t->last_rt_change = t->gc_time = current_time();
 
@@ -3563,29 +3544,56 @@ rt_next_hop_update_net(rtable *tab, net *n)
 }
 
 static void
-rt_next_hop_update(rtable *tab)
+rt_next_hop_update(void *_tab)
 {
-  struct fib_iterator *fit = &tab->nhu_fit;
-  int max_feed = 32;
+  rtable *tab = _tab;
+
+  /* If called from an uncork hook, reset the state */
+  if (tab->nhu_corked)
+  {
+    ASSERT_DIE(tab->nhu_state == 0);
+    tab->nhu_state = tab->nhu_corked;
+    tab->nhu_corked = 0;
+    rt_trace(tab, D_STATES, "Next hop updater uncorked");
+  }
+
+  if (!tab->nhu_state)
+    bug("Called NHU event for no reason in table %s", tab->name);
 
-  if (tab->nhu_state == NHU_CLEAN)
+  /* Check corkedness */
+  if (rt_cork_check(tab->nhu_event))
+  {
+    rt_trace(tab, D_STATES, "Next hop updater corked");
+    if ((tab->nhu_state & NHU_RUNNING)
+	&& !EMPTY_LIST(tab->exporter.pending)
+	&& !tm_active(tab->exporter.export_timer))
+      tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
+
+    tab->nhu_corked = tab->nhu_state;
+    tab->nhu_state = 0;
     return;
+  }
+
+  struct fib_iterator *fit = &tab->nhu_fit;
+  int max_feed = 32;
 
+  /* Initialize a new run */
   if (tab->nhu_state == NHU_SCHEDULED)
-    {
-      FIB_ITERATE_INIT(fit, &tab->fib);
-      tab->nhu_state = NHU_RUNNING;
+  {
+    FIB_ITERATE_INIT(fit, &tab->fib);
+    tab->nhu_state = NHU_RUNNING;
 
-      if (tab->flowspec_trie)
-	rt_flowspec_reset_trie(tab);
-    }
+    if (tab->flowspec_trie)
+      rt_flowspec_reset_trie(tab);
+  }
 
+  /* Walk the fib one net after another */
   FIB_ITERATE_START(&tab->fib, fit, net, n)
     {
       if (max_feed <= 0)
 	{
 	  FIB_ITERATE_PUT(fit);
-	  ev_schedule(tab->rt_event);
+	  ev_schedule(tab->nhu_event);
 	  return;
 	}
       lp_state lps;
@@ -3595,6 +3603,7 @@ rt_next_hop_update(rtable *tab)
     }
   FIB_ITERATE_END;
 
+  /* Finished NHU, cleanup */
   rt_trace(tab, D_EVENTS, "NHU done, scheduling export timer");
 
   if (!tm_active(tab->exporter.export_timer))
@@ -3604,10 +3613,10 @@ rt_next_hop_update(rtable *tab)
    *   NHU_DIRTY   -> NHU_SCHEDULED
    *   NHU_RUNNING -> NHU_CLEAN
    */
-  tab->nhu_state &= 1;
+  if ((tab->nhu_state &= NHU_SCHEDULED) == NHU_SCHEDULED)
+    ev_schedule(tab->nhu_event);
 
-  if (tab->nhu_state != NHU_CLEAN)
-    ev_schedule(tab->rt_event);
+  rt_unlock_table(tab);
 }
 
 void
diff --git a/nest/rt.h b/nest/rt.h
index b94024fd..987a9ff8 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -117,7 +117,7 @@ typedef struct rtable {
 					 * obstacle from this routing table.
 					 */
   struct event *rt_event;		/* Routing table event */
-  struct event *uncork_event;		/* Called when uncork happens */
+  struct event *nhu_event;		/* Specific event for next hop update */
   struct timer *prune_timer;		/* Timer for periodic pruning / GC */
   btime last_rt_change;			/* Last time when route changed */
   btime gc_time;			/* Time of last GC */
-- 
cgit v1.2.3


From 5103de4e8ed7f4744326129a4296cf3511b1e1f9 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 7 Sep 2022 15:06:22 +0200
Subject: Table long-locking debug code

---
 nest/rt-table.c | 10 +++++-----
 nest/rt.h       |  8 ++++++--
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index eb53eff7..cdf0fd3e 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -3680,10 +3680,10 @@ rt_new_table(struct symbol *s, uint addr_type)
  * preventing it from being freed when it gets undefined in a new
  * configuration.
  */
-void
-rt_lock_table(rtable *r)
+void rt_lock_table_debug(rtable *tab, const char *file, uint line)
 {
-  r->use_count++;
+  rt_trace(tab, D_STATES, "Locked at %s:%d", file, line);
+  tab->use_count++;
 }
 
 /**
@@ -3694,9 +3694,9 @@ rt_lock_table(rtable *r)
  * that is decrease its use count and delete it if it's scheduled
  * for deletion by configuration changes.
  */
-void
-rt_unlock_table(rtable *r)
+void rt_unlock_table_debug(rtable *r, const char *file, uint line)
 {
+  rt_trace(r, D_STATES, "Unlocked at %s:%d", file, line);
   if (!--r->use_count && r->deleted)
     {
       struct config *conf = r->deleted;
diff --git a/nest/rt.h b/nest/rt.h
index 987a9ff8..82d74296 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -482,8 +482,12 @@ void rt_init(void);
 void rt_preconfig(struct config *);
 void rt_postconfig(struct config *);
 void rt_commit(struct config *new, struct config *old);
-void rt_lock_table(rtable *);
-void rt_unlock_table(rtable *);
+
+void rt_lock_table_debug(rtable *, const char *file, uint line);
+void rt_unlock_table_debug(rtable *, const char *file, uint line);
+#define rt_lock_table(tab)	rt_lock_table_debug(tab, __FILE__, __LINE__)
+#define rt_unlock_table(tab)	rt_unlock_table_debug(tab, __FILE__, __LINE__)
+
 struct f_trie * rt_lock_trie(rtable *tab);
 void rt_unlock_trie(rtable *tab, struct f_trie *trie);
 void rt_flowspec_link(rtable *src, rtable *dst);
-- 
cgit v1.2.3


From a42877b9bf09c4c042bced3910ade9b71ce3724c Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 7 Sep 2022 20:26:20 +0200
Subject: Table feed refactoring to allow for locking and unlocking

---
 nest/rt-table.c | 151 +++++++++++++++++++++++++++++++++++++++-----------------
 nest/rt.h       |   5 ++
 2 files changed, 112 insertions(+), 44 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index cdf0fd3e..ef06dd7c 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -139,7 +139,6 @@ static void rt_feed_by_fib(void *);
 static void rt_feed_by_trie(void *);
 static void rt_feed_equal(void *);
 static void rt_feed_for(void *);
-static uint rt_feed_net(struct rt_table_export_hook *c, net *n);
 static void rt_check_cork_low(rtable *tab);
 static void rt_check_cork_high(rtable *tab);
 static void rt_cork_release_hook(void *);
@@ -2015,6 +2014,7 @@ rt_table_export_start(struct rt_exporter *re, struct rt_export_request *req)
 	hook->walk_lock = rt_lock_trie(tab);
 	trie_walk_init(hook->walk_state, tab->trie, req->addr);
 	hook->h.event.hook = rt_feed_by_trie;
+	hook->walk_last.type = 0;
 	break;
       }
       /* fall through */
@@ -3836,6 +3836,74 @@ rt_feed_done(struct rt_export_hook *c)
   rt_send_export_event(c);
 }
 
+#define MAX_FEED_BLOCK	1024
+typedef struct {
+  uint cnt, pos;
+  union {
+    struct rt_pending_export *rpe;
+    struct {
+      rte **feed;
+      uint *start;
+    };
+  };
+} rt_feed_block;
+
+static int
+rt_prepare_feed(struct rt_table_export_hook *c, net *n, rt_feed_block *b)
+{
+  if (n->routes)
+  {
+    if (c->h.req->export_bulk)
+    {
+      uint cnt = rte_feed_count(n);
+      if (b->cnt && (b->cnt + cnt > MAX_FEED_BLOCK))
+	return 0;
+
+      if (!b->cnt)
+      {
+	b->feed = tmp_alloc(sizeof(rte *) * MAX(MAX_FEED_BLOCK, cnt));
+	b->start = tmp_alloc(sizeof(uint) * ((cnt >= MAX_FEED_BLOCK) ? 2 : (MAX_FEED_BLOCK + 2 - cnt)));
+      }
+
+      rte_feed_obtain(n, &b->feed[b->cnt], cnt);
+      b->start[b->pos++] = b->cnt;
+      b->cnt += cnt;
+    }
+    else if (b->pos == MAX_FEED_BLOCK)
+      return 0;
+    else
+    {
+      if (!b->pos)
+	b->rpe = tmp_alloc(sizeof(struct rt_pending_export) * MAX_FEED_BLOCK);
+
+      b->rpe[b->pos++] = (struct rt_pending_export) { .new = n->routes, .new_best = n->routes };
+    }
+  }
+
+  rpe_mark_seen_all(&c->h, n->first, NULL);
+  return 1;
+}
+
+static void
+rt_process_feed(struct rt_table_export_hook *c, rt_feed_block *b)
+{
+  if (!b->pos)
+    return;
+
+  if (c->h.req->export_bulk)
+  {
+    b->start[b->pos] = b->cnt;
+    for (uint p = 0; p < b->pos; p++)
+    {
+      rte **feed = &b->feed[b->start[p]];
+      c->h.req->export_bulk(c->h.req, feed[0]->net, NULL, feed, b->start[p+1] - b->start[p]);
+    }
+  }
+  else
+    for (uint p = 0; p < b->pos; p++)
+      c->h.req->export_one(c->h.req, b->rpe[p].new->rte.net, &b->rpe[p]);
+}
+
 /**
  * rt_feed_by_fib - advertise all routes to a channel by walking a fib
  * @c: channel to be fed
@@ -3851,7 +3919,8 @@ rt_feed_by_fib(void *data)
   struct rt_table_export_hook *c = data;
 
   struct fib_iterator *fit = &c->feed_fit;
-  int max_feed = 256;
+
+  rt_feed_block block = {};
 
   ASSERT(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
 
@@ -3859,21 +3928,23 @@ rt_feed_by_fib(void *data)
 
   FIB_ITERATE_START(&tab->fib, fit, net, n)
     {
-      if (max_feed <= 0)
+      if ((c->h.req->addr_mode == TE_ADDR_NONE) || net_in_netX(n->n.addr, c->h.req->addr))
+      {
+	if (atomic_load_explicit(&c->h.export_state, memory_order_acquire) != TES_FEEDING)
+	  return;
+
+	if (!rt_prepare_feed(c, n, &block))
 	{
 	  FIB_ITERATE_PUT(fit);
+	  rt_process_feed(c, &block);
 	  rt_send_export_event(&c->h);
 	  return;
 	}
-
-      if (atomic_load_explicit(&c->h.export_state, memory_order_acquire) != TES_FEEDING)
-	return;
-
-      if ((c->h.req->addr_mode == TE_ADDR_NONE) || net_in_netX(n->n.addr, c->h.req->addr))
-	max_feed -= rt_feed_net(c, n);
+      }
     }
   FIB_ITERATE_END;
 
+  rt_process_feed(c, &block);
   rt_feed_done(&c->h);
 }
 
@@ -3886,23 +3957,29 @@ rt_feed_by_trie(void *data)
   ASSERT_DIE(c->walk_state);
   struct f_trie_walk_state *ws = c->walk_state;
 
-  int max_feed = 256;
+  rt_feed_block block = {};
 
   ASSERT(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
 
-  net_addr addr;
-  while (trie_walk_next(ws, &addr))
-  {
-    net *n = net_find(tab, &addr);
+  do {
+    if (!c->walk_last.type)
+      continue;
+
+    net *n = net_find(tab, &c->walk_last);
     if (!n)
       continue;
 
-    if ((max_feed -= rt_feed_net(c, n)) <= 0)
+    if (atomic_load_explicit(&c->h.export_state, memory_order_acquire) != TES_FEEDING)
       return;
 
-    if (atomic_load_explicit(&c->h.export_state, memory_order_acquire) != TES_FEEDING)
+    if (!rt_prepare_feed(c, n, &block))
+    {
+      rt_process_feed(c, &block);
+      rt_send_export_event(&c->h);
       return;
+    }
   }
+  while (trie_walk_next(ws, &c->walk_last));
 
   rt_unlock_trie(tab, c->walk_lock);
   c->walk_lock = NULL;
@@ -3910,6 +3987,8 @@ rt_feed_by_trie(void *data)
   mb_free(c->walk_state);
   c->walk_state = NULL;
 
+  c->walk_last.type = 0;
+
   rt_feed_done(&c->h);
 }
 
@@ -3922,9 +4001,14 @@ rt_feed_equal(void *data)
   ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
   ASSERT_DIE(c->h.req->addr_mode == TE_ADDR_EQUAL);
 
+  rt_feed_block block = {};
+
   net *n = net_find(tab, c->h.req->addr);
   if (n)
-    rt_feed_net(c, n);
+  {
+    ASSERT_DIE(rt_prepare_feed(c, n, &block));
+    rt_process_feed(c, &block);
+  }
 
   rt_feed_done(&c->h);
 }
@@ -3938,40 +4022,19 @@ rt_feed_for(void *data)
   ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
   ASSERT_DIE(c->h.req->addr_mode == TE_ADDR_FOR);
 
+  rt_feed_block block = {};
+
   net *n = net_route(tab, c->h.req->addr);
   if (n)
-    rt_feed_net(c, n);
-
-  rt_feed_done(&c->h);
-}
-
-static uint
-rt_feed_net(struct rt_table_export_hook *c, net *n)
-{
-  uint count = 0;
-
-  if (c->h.req->export_bulk)
   {
-    count = rte_feed_count(n);
-    if (count)
-    {
-      rte **feed = alloca(count * sizeof(rte *));
-      rte_feed_obtain(n, feed, count);
-      c->h.req->export_bulk(c->h.req, n->n.addr, NULL, feed, count);
-    }
-  }
-
-  else if (n->routes)
-  {
-    struct rt_pending_export rpe = { .new = n->routes, .new_best = n->routes };
-    c->h.req->export_one(c->h.req, n->n.addr, &rpe);
-    count = 1;
+    ASSERT_DIE(rt_prepare_feed(c, n, &block));
+    rt_process_feed(c, &block);
   }
 
-  rpe_mark_seen_all(&c->h, n->first, NULL);
-  return count;
+  rt_feed_done(&c->h);
 }
 
+
 /*
  *	Import table
  */
diff --git a/nest/rt.h b/nest/rt.h
index 82d74296..7cf8a91f 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -300,6 +300,11 @@ struct rt_table_export_hook {
     struct {
       struct f_trie_walk_state *walk_state;	/* Iterator over networks in trie */
       struct f_trie *walk_lock;			/* Locked trie for walking */
+      union {					/* Last net visited but not processed */
+	net_addr walk_last;
+	net_addr_ip4 walk_last_ip4;
+	net_addr_ip6 walk_last_ip6;
+      };
     };
   };
 
-- 
cgit v1.2.3


From fb7fb6744582b2bb74b3b1e32696bd5534e93054 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 7 Sep 2022 13:54:20 +0200
Subject: Table access is now locked.

---
 filter/f-inst.c   |   2 +-
 lib/birdlib.h     |   3 +-
 lib/route.h       |   4 +-
 nest/config.Y     |   3 +-
 nest/proto.c      |  11 +-
 nest/protocol.h   |   7 +-
 nest/rt-show.c    |  11 +-
 nest/rt-table.c   | 736 +++++++++++++++++++++++++++++++++---------------------
 nest/rt.h         |  91 ++++---
 proto/bfd/bfd.c   |   1 -
 proto/bgp/attrs.c |  15 +-
 proto/bgp/bgp.h   |   2 +-
 proto/mrt/mrt.c   |  39 ++-
 proto/mrt/mrt.h   |   6 +-
 proto/perf/perf.c |   4 +-
 sysdep/unix/krt.c |  21 +-
 16 files changed, 604 insertions(+), 352 deletions(-)

diff --git a/filter/f-inst.c b/filter/f-inst.c
index 60042476..426b598f 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -1467,7 +1467,7 @@
     ARG(1, T_NET);
     ARG(2, T_INT);
     RTC(3);
-    struct rtable *table = rtc->table;
+    rtable *table = rtc->table;
 
     u32 as = v2.val.i;
 
diff --git a/lib/birdlib.h b/lib/birdlib.h
index d55b1a44..d743ecdf 100644
--- a/lib/birdlib.h
+++ b/lib/birdlib.h
@@ -14,8 +14,9 @@
 
 /* Ugly structure offset handling macros */
 
+#define SAME_TYPE(a, b)	({ int _ = ((a) != (b)); !_; })
 #define OFFSETOF(s, i) ((size_t) &((s *)0)->i)
-#define SKIP_BACK(s, i, p) ({ s *_ptr = ((s *)((char *)p - OFFSETOF(s, i))); ASSERT_DIE(&_ptr->i == p); _ptr; })
+#define SKIP_BACK(s, i, p) ({ s *_ptr = ((s *)((char *)p - OFFSETOF(s, i))); SAME_TYPE(&_ptr->i, p); _ptr; })
 #define BIRD_ALIGN(s, a) (((s)+a-1)&~(a-1))
 #define CPU_STRUCT_ALIGN  (MAX_(_Alignof(void*), _Alignof(u64)))
 #define BIRD_CPU_ALIGN(s) BIRD_ALIGN((s), CPU_STRUCT_ALIGN)
diff --git a/lib/route.h b/lib/route.h
index f5456396..eae251e7 100644
--- a/lib/route.h
+++ b/lib/route.h
@@ -20,7 +20,7 @@
 struct network;
 struct proto;
 struct cli;
-struct rtable;
+struct rtable_private;
 
 typedef struct rte {
   struct ea_list *attrs;		/* Attributes of this route */
@@ -63,7 +63,7 @@ struct rte_owner_class {
 
 struct rte_owner {
   struct rte_owner_class *class;
-  int (*rte_recalculate)(struct rtable *, struct network *, struct rte *, struct rte *, struct rte *);
+  int (*rte_recalculate)(struct rtable_private *, struct network *, struct rte *, struct rte *, struct rte *);
   HASH(struct rte_src) hash;
   const char *name;
   u32 hash_key;
diff --git a/nest/config.Y b/nest/config.Y
index e8c4aa9a..84c76ae9 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -702,7 +702,8 @@ r_args:
    }
  | r_args IMPORT TABLE channel_arg {
      if (!($4->in_keep & RIK_PREFILTER)) cf_error("No import table in channel %s.%s", $4->proto->name, $4->name);
-     rt_show_add_exporter($$, &$4->table->exporter.e, "import")->prefilter = $4;
+     RT_LOCKED($4->table, tab)
+       rt_show_add_exporter($$, &tab->exporter.e, "import")->prefilter = $4;
      $$->tables_defined_by = RSD_TDB_DIRECT;
    }
  | r_args EXPORT TABLE channel_arg {
diff --git a/nest/proto.c b/nest/proto.c
index 5f4b7b2d..783a936c 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -169,7 +169,7 @@ proto_cf_find_channel(struct proto_config *pc, uint net_type)
  * Returns pointer to channel or NULL
  */
 struct channel *
-proto_find_channel_by_table(struct proto *p, struct rtable *t)
+proto_find_channel_by_table(struct proto *p, rtable *t)
 {
   struct channel *c;
 
@@ -376,7 +376,7 @@ channel_dump_roa_req(struct rt_export_request *req)
 {
   struct roa_subscription *s = SKIP_BACK(struct roa_subscription, req, req);
   struct channel *c = s->c;
-  rtable *tab = SKIP_BACK(rtable, exporter.e, req->hook->table);
+  struct rtable_private *tab = SKIP_BACK(struct rtable_private, exporter.e, req->hook->table);
 
   debug("  Channel %s.%s ROA %s change notifier from table %s request %p\n",
       c->proto->name, c->name,
@@ -394,7 +394,8 @@ channel_roa_is_subscribed(struct channel *c, rtable *tab, int dir)
   node *n;
 
   WALK_LIST2(s, n, c->roa_subscriptions, roa_node)
-    if ((s->req.hook->table == &tab->exporter.e) && (s->t.hook == hook))
+    if ((tab == SKIP_BACK(rtable, priv.exporter.e, s->req.hook->table))
+	  && (s->t.hook == hook))
       return 1;
 
   return 0;
@@ -447,7 +448,7 @@ static void
 channel_roa_subscribe_filter(struct channel *c, int dir)
 {
   const struct filter *f = dir ? c->in_filter : c->out_filter;
-  struct rtable *tab;
+  rtable *tab;
   int valid = 1, found = 0;
 
   if ((f == FILTER_ACCEPT) || (f == FILTER_REJECT))
@@ -609,8 +610,6 @@ channel_import_stopped(struct rt_import_request *req)
 {
   struct channel *c = SKIP_BACK(struct channel, in_req, req);
 
-  req->hook = NULL;
-
   mb_free(c->in_req.name);
   c->in_req.name = NULL;
 
diff --git a/nest/protocol.h b/nest/protocol.h
index a3eeb198..e9461d41 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -18,7 +18,6 @@
 
 struct iface;
 struct ifa;
-struct rtable;
 struct rte;
 struct neighbor;
 struct rta;
@@ -189,7 +188,7 @@ struct proto {
    *	   rte_remove	Called whenever a rte is removed from the routing table.
    */
 
-  int (*rte_recalculate)(struct rtable *, struct network *, struct rte *, struct rte *, struct rte *);
+  int (*rte_recalculate)(struct rtable_private *, struct network *, struct rte *, struct rte *, struct rte *);
   int (*rte_better)(struct rte *, struct rte *);
   int (*rte_mergable)(struct rte *, struct rte *);
   void (*rte_insert)(struct network *, struct rte *);
@@ -482,7 +481,7 @@ struct channel {
   const struct channel_class *channel;
   struct proto *proto;
 
-  struct rtable *table;
+  rtable *table;
   const struct filter *in_filter;	/* Input filter */
   const struct filter *out_filter;	/* Output filter */
   const net_addr *out_subprefix;	/* Export only subprefixes of this net */
@@ -613,7 +612,7 @@ struct channel_config *proto_cf_find_channel(struct proto_config *p, uint net_ty
 static inline struct channel_config *proto_cf_main_channel(struct proto_config *pc)
 { return proto_cf_find_channel(pc, pc->net_type); }
 
-struct channel *proto_find_channel_by_table(struct proto *p, struct rtable *t);
+struct channel *proto_find_channel_by_table(struct proto *p, rtable *t);
 struct channel *proto_find_channel_by_name(struct proto *p, const char *n);
 struct channel *proto_add_channel(struct proto *p, struct channel_config *cf);
 int proto_configure_channel(struct proto *p, struct channel **c, struct channel_config *cf);
diff --git a/nest/rt-show.c b/nest/rt-show.c
index d17818db..dc88047a 100644
--- a/nest/rt-show.c
+++ b/nest/rt-show.c
@@ -354,9 +354,11 @@ rt_show_add_exporter(struct rt_show_data *d, struct rt_exporter *t, const char *
 }
 
 struct rt_show_data_rtable *
-rt_show_add_table(struct rt_show_data *d, struct rtable *t)
+rt_show_add_table(struct rt_show_data *d, rtable *t)
 {
-  struct rt_show_data_rtable *rsdr = rt_show_add_exporter(d, &t->exporter.e, t->name);
+  struct rt_show_data_rtable *rsdr;
+  RT_LOCKED(t, tp)
+    rsdr = rt_show_add_exporter(d, &tp->exporter.e, t->name);
 
   struct proto_config *krt = t->config->krt_attached;
   if (krt)
@@ -418,12 +420,13 @@ rt_show_prepare_tables(struct rt_show_data *d)
     /* Ensure there is defined export_channel for each table */
     if (d->export_mode)
     {
+      rtable *rt = SKIP_BACK(rtable, priv.exporter.e, tab->table);
       if (!tab->export_channel && d->export_channel &&
-	  (tab->table == &d->export_channel->table->exporter.e))
+	  (rt == d->export_channel->table))
 	tab->export_channel = d->export_channel;
 
       if (!tab->export_channel && d->export_protocol)
-	tab->export_channel = proto_find_channel_by_table(d->export_protocol, SKIP_BACK(rtable, exporter.e, tab->table));
+	tab->export_channel = proto_find_channel_by_table(d->export_protocol, rt);
 
       if (!tab->export_channel)
       {
diff --git a/nest/rt-table.c b/nest/rt-table.c
index ef06dd7c..95248635 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -128,23 +128,24 @@ struct rt_export_block {
   struct rt_pending_export export[];
 };
 
-static void rt_free_hostcache(rtable *tab);
+static void rt_free_hostcache(struct rtable_private *tab);
 static void rt_update_hostcache(void *tab);
 static void rt_next_hop_update(void *tab);
 static inline void rt_next_hop_resolve_rte(rte *r);
 static inline void rt_flowspec_resolve_rte(rte *r, struct channel *c);
-static inline void rt_prune_table(rtable *tab);
-static void rt_kick_prune_timer(rtable *tab);
+static inline void rt_prune_table(struct rtable_private *tab);
+static void rt_kick_prune_timer(struct rtable_private *tab);
 static void rt_feed_by_fib(void *);
 static void rt_feed_by_trie(void *);
 static void rt_feed_equal(void *);
 static void rt_feed_for(void *);
-static void rt_check_cork_low(rtable *tab);
-static void rt_check_cork_high(rtable *tab);
+static void rt_check_cork_low(struct rtable_private *tab);
+static void rt_check_cork_high(struct rtable_private *tab);
 static void rt_cork_release_hook(void *);
+static void rt_delete(void *);
 
 static void rt_export_used(struct rt_table_exporter *);
-static void rt_export_cleanup(rtable *);
+static void rt_export_cleanup(struct rtable_private *tab);
 
 static int rte_same(rte *x, rte *y);
 
@@ -180,10 +181,10 @@ const char *rt_export_state_name(u8 state)
     return rt_export_state_name_array[state];
 }
 
-static struct hostentry *rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep);
+static struct hostentry *rt_get_hostentry(struct rtable_private *tab, ip_addr a, ip_addr ll, rtable *dep);
 
 #define rt_trace(tab, level, fmt, args...)  do {\
-  rtable *t = (tab);				\
+  struct rtable_private *t = (tab);		\
   if (t->config->debug & (level))		\
     log(L_TRACE "%s: " fmt, t->name, ##args);	\
 } while (0)
@@ -191,7 +192,7 @@ static struct hostentry *rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rt
 static void
 net_init_with_trie(struct fib *f, void *N)
 {
-  rtable *tab = SKIP_BACK(rtable, fib, f);
+  struct rtable_private *tab = SKIP_BACK(struct rtable_private, fib, f);
   net *n = N;
 
   if (tab->trie)
@@ -202,7 +203,7 @@ net_init_with_trie(struct fib *f, void *N)
 }
 
 static inline net *
-net_route_ip4_trie(rtable *t, const net_addr_ip4 *n0)
+net_route_ip4_trie(struct rtable_private *t, const net_addr_ip4 *n0)
 {
   TRIE_WALK_TO_ROOT_IP4(t->trie, n0, n)
   {
@@ -216,7 +217,7 @@ net_route_ip4_trie(rtable *t, const net_addr_ip4 *n0)
 }
 
 static inline net *
-net_route_vpn4_trie(rtable *t, const net_addr_vpn4 *n0)
+net_route_vpn4_trie(struct rtable_private *t, const net_addr_vpn4 *n0)
 {
   TRIE_WALK_TO_ROOT_IP4(t->trie, (const net_addr_ip4 *) n0, px)
   {
@@ -232,7 +233,7 @@ net_route_vpn4_trie(rtable *t, const net_addr_vpn4 *n0)
 }
 
 static inline net *
-net_route_ip6_trie(rtable *t, const net_addr_ip6 *n0)
+net_route_ip6_trie(struct rtable_private *t, const net_addr_ip6 *n0)
 {
   TRIE_WALK_TO_ROOT_IP6(t->trie, n0, n)
   {
@@ -246,7 +247,7 @@ net_route_ip6_trie(rtable *t, const net_addr_ip6 *n0)
 }
 
 static inline net *
-net_route_vpn6_trie(rtable *t, const net_addr_vpn6 *n0)
+net_route_vpn6_trie(struct rtable_private *t, const net_addr_vpn6 *n0)
 {
   TRIE_WALK_TO_ROOT_IP6(t->trie, (const net_addr_ip6 *) n0, px)
   {
@@ -262,7 +263,7 @@ net_route_vpn6_trie(rtable *t, const net_addr_vpn6 *n0)
 }
 
 static inline void *
-net_route_ip6_sadr_trie(rtable *t, const net_addr_ip6_sadr *n0)
+net_route_ip6_sadr_trie(struct rtable_private *t, const net_addr_ip6_sadr *n0)
 {
   TRIE_WALK_TO_ROOT_IP6(t->trie, (const net_addr_ip6 *) n0, px)
   {
@@ -295,7 +296,7 @@ net_route_ip6_sadr_trie(rtable *t, const net_addr_ip6_sadr *n0)
 }
 
 static inline net *
-net_route_ip4_fib(rtable *t, const net_addr_ip4 *n0)
+net_route_ip4_fib(struct rtable_private *t, const net_addr_ip4 *n0)
 {
   net_addr_ip4 n;
   net_copy_ip4(&n, n0);
@@ -311,7 +312,7 @@ net_route_ip4_fib(rtable *t, const net_addr_ip4 *n0)
 }
 
 static inline net *
-net_route_vpn4_fib(rtable *t, const net_addr_vpn4 *n0)
+net_route_vpn4_fib(struct rtable_private *t, const net_addr_vpn4 *n0)
 {
   net_addr_vpn4 n;
   net_copy_vpn4(&n, n0);
@@ -327,7 +328,7 @@ net_route_vpn4_fib(rtable *t, const net_addr_vpn4 *n0)
 }
 
 static inline net *
-net_route_ip6_fib(rtable *t, const net_addr_ip6 *n0)
+net_route_ip6_fib(struct rtable_private *t, const net_addr_ip6 *n0)
 {
   net_addr_ip6 n;
   net_copy_ip6(&n, n0);
@@ -343,7 +344,7 @@ net_route_ip6_fib(rtable *t, const net_addr_ip6 *n0)
 }
 
 static inline net *
-net_route_vpn6_fib(rtable *t, const net_addr_vpn6 *n0)
+net_route_vpn6_fib(struct rtable_private *t, const net_addr_vpn6 *n0)
 {
   net_addr_vpn6 n;
   net_copy_vpn6(&n, n0);
@@ -359,7 +360,7 @@ net_route_vpn6_fib(rtable *t, const net_addr_vpn6 *n0)
 }
 
 static inline void *
-net_route_ip6_sadr_fib(rtable *t, const net_addr_ip6_sadr *n0)
+net_route_ip6_sadr_fib(struct rtable_private *t, const net_addr_ip6_sadr *n0)
 {
   net_addr_ip6_sadr n;
   net_copy_ip6_sadr(&n, n0);
@@ -399,7 +400,7 @@ net_route_ip6_sadr_fib(rtable *t, const net_addr_ip6_sadr *n0)
 }
 
 net *
-net_route(rtable *tab, const net_addr *n)
+net_route(struct rtable_private *tab, const net_addr *n)
 {
   ASSERT(tab->addr_type == n->type);
 
@@ -442,7 +443,7 @@ net_route(rtable *tab, const net_addr *n)
 
 
 static int
-net_roa_check_ip4_trie(rtable *tab, const net_addr_ip4 *px, u32 asn)
+net_roa_check_ip4_trie(struct rtable_private *tab, const net_addr_ip4 *px, u32 asn)
 {
   int anything = 0;
 
@@ -470,7 +471,7 @@ net_roa_check_ip4_trie(rtable *tab, const net_addr_ip4 *px, u32 asn)
 }
 
 static int
-net_roa_check_ip4_fib(rtable *tab, const net_addr_ip4 *px, u32 asn)
+net_roa_check_ip4_fib(struct rtable_private *tab, const net_addr_ip4 *px, u32 asn)
 {
   struct net_addr_roa4 n = NET_ADDR_ROA4(px->prefix, px->pxlen, 0, 0);
   struct fib_node *fn;
@@ -502,7 +503,7 @@ net_roa_check_ip4_fib(rtable *tab, const net_addr_ip4 *px, u32 asn)
 }
 
 static int
-net_roa_check_ip6_trie(rtable *tab, const net_addr_ip6 *px, u32 asn)
+net_roa_check_ip6_trie(struct rtable_private *tab, const net_addr_ip6 *px, u32 asn)
 {
   int anything = 0;
 
@@ -530,7 +531,7 @@ net_roa_check_ip6_trie(rtable *tab, const net_addr_ip6 *px, u32 asn)
 }
 
 static int
-net_roa_check_ip6_fib(rtable *tab, const net_addr_ip6 *px, u32 asn)
+net_roa_check_ip6_fib(struct rtable_private *tab, const net_addr_ip6 *px, u32 asn)
 {
   struct net_addr_roa6 n = NET_ADDR_ROA6(px->prefix, px->pxlen, 0, 0);
   struct fib_node *fn;
@@ -577,24 +578,30 @@ net_roa_check_ip6_fib(rtable *tab, const net_addr_ip6 *px, u32 asn)
  * must have type NET_IP4 or NET_IP6, respectively.
  */
 int
-net_roa_check(rtable *tab, const net_addr *n, u32 asn)
+net_roa_check(rtable *tp, const net_addr *n, u32 asn)
 {
-  if ((tab->addr_type == NET_ROA4) && (n->type == NET_IP4))
-  {
-    if (tab->trie)
-      return net_roa_check_ip4_trie(tab, (const net_addr_ip4 *) n, asn);
-    else
-      return net_roa_check_ip4_fib (tab, (const net_addr_ip4 *) n, asn);
-  }
-  else if ((tab->addr_type == NET_ROA6) && (n->type == NET_IP6))
+  int out = ROA_UNKNOWN;
+
+  RT_LOCKED(tp, tab)
   {
-    if (tab->trie)
-      return net_roa_check_ip6_trie(tab, (const net_addr_ip6 *) n, asn);
+    if ((tab->addr_type == NET_ROA4) && (n->type == NET_IP4))
+    {
+      if (tab->trie)
+	out = net_roa_check_ip4_trie(tab, (const net_addr_ip4 *) n, asn);
+      else
+	out = net_roa_check_ip4_fib (tab, (const net_addr_ip4 *) n, asn);
+    }
+    else if ((tab->addr_type == NET_ROA6) && (n->type == NET_IP6))
+    {
+      if (tab->trie)
+	out = net_roa_check_ip6_trie(tab, (const net_addr_ip6 *) n, asn);
+      else
+	out = net_roa_check_ip6_fib (tab, (const net_addr_ip6 *) n, asn);
+    }
     else
-      return net_roa_check_ip6_fib (tab, (const net_addr_ip6 *) n, asn);
+      out = ROA_UNKNOWN;	/* Should not happen */
   }
-  else
-    return ROA_UNKNOWN;	/* Should not happen */
+  return out;
 }
 
 /**
@@ -618,7 +625,7 @@ rte_find(net *net, struct rte_src *src)
 
 
 struct rte_storage *
-rte_store(const rte *r, net *net, rtable *tab)
+rte_store(const rte *r, net *net, struct rtable_private *tab)
 {
   struct rte_storage *e = sl_alloc(tab->rte_slab);
 
@@ -1164,6 +1171,7 @@ static struct rt_pending_export * rt_next_export_fast(struct rt_pending_export *
 static int
 rte_export(struct rt_table_export_hook *th, struct rt_pending_export *rpe)
 {
+  rtable *tab = RT_PUB(SKIP_BACK(struct rtable_private, exporter, th->table));
   struct rt_export_hook *hook = &th->h;
   if (bmap_test(&hook->seq_map, rpe->seq))
     goto ignore;	/* Seen already */
@@ -1202,6 +1210,7 @@ rte_export(struct rt_table_export_hook *th, struct rt_pending_export *rpe)
   else if (hook->req->export_bulk)
   {
     net *net = SKIP_BACK(struct network, n.addr, (net_addr (*)[0]) n);
+    RT_LOCK(tab);
     uint count = rte_feed_count(net);
     rte **feed = NULL;
     if (count)
@@ -1209,6 +1218,7 @@ rte_export(struct rt_table_export_hook *th, struct rt_pending_export *rpe)
       feed = alloca(count * sizeof(rte *));
       rte_feed_obtain(net, feed, count);
     }
+    RT_UNLOCK(tab);
     hook->req->export_bulk(hook->req, n, rpe, feed, count);
   }
   else
@@ -1260,7 +1270,7 @@ ignore:
  * done outside of scope of rte_announce().
  */
 static void
-rte_announce(rtable *tab, net *net, struct rte_storage *new, struct rte_storage *old,
+rte_announce(struct rtable_private *tab, net *net, struct rte_storage *new, struct rte_storage *old,
 	     struct rte_storage *new_best, struct rte_storage *old_best)
 {
   int new_best_valid = rte_is_valid(RTE_OR_NULL(new_best));
@@ -1385,6 +1395,8 @@ rt_next_export_fast(struct rt_pending_export *last)
 static struct rt_pending_export *
 rt_next_export(struct rt_table_export_hook *hook, struct rt_table_exporter *tab)
 {
+  ASSERT_DIE(RT_IS_LOCKED(SKIP_BACK(struct rtable_private, exporter, tab)));
+
   /* As the table is locked, it is safe to reload the last export pointer */
   struct rt_pending_export *last = atomic_load_explicit(&hook->last_export, memory_order_acquire);
 
@@ -1406,41 +1418,47 @@ rt_send_export_event(struct rt_export_hook *hook)
 static void
 rt_announce_exports(timer *tm)
 {
-  rtable *tab = tm->data;
-
-  if (EMPTY_LIST(tab->exporter.pending))
-    return;
-
-  struct rt_export_hook *c; node *n;
-  WALK_LIST2(c, n, tab->exporter.e.hooks, n)
-  {
-    if (atomic_load_explicit(&c->export_state, memory_order_acquire) != TES_READY)
-      continue;
+  RT_LOCKED((rtable *) tm->data, tab)
+    if (!EMPTY_LIST(tab->exporter.pending))
+    {
+      struct rt_export_hook *c; node *n;
+      WALK_LIST2(c, n, tab->exporter.e.hooks, n)
+      {
+	if (atomic_load_explicit(&c->export_state, memory_order_acquire) != TES_READY)
+	  continue;
 
-    rt_send_export_event(c);
-  }
+	rt_send_export_event(c);
+      }
+    }
 }
 
 static void
 rt_import_announce_exports(void *_hook)
 {
   struct rt_import_hook *hook = _hook;
-  rtable *tab = hook->table;
+  RT_LOCKED(hook->table, tab)
+  {
+    if (hook->import_state == TIS_CLEARED)
+    {
+      void (*stopped)(struct rt_import_request *) = hook->stopped;
+      struct rt_import_request *req = hook->req;
+      req->hook = NULL;
 
+      rt_trace(tab, D_EVENTS, "Hook %s stopped", req->name);
+      rem_node(&hook->n);
+      mb_free(hook);
+      rt_unlock_table(tab);
+      RT_UNLOCK(tab);
 
-  if (hook->import_state == TIS_CLEARED)
-  {
-    rt_trace(tab, D_EVENTS, "Hook %s stopped", hook->req->name);
-    hook->stopped(hook->req);
-    rem_node(&hook->n);
-    mb_free(hook);
-    rt_unlock_table(tab);
-  }
+      stopped(req);
+      return;
+    }
 
-  rt_trace(tab, D_EVENTS, "Announcing exports after imports from %s", hook->req->name);
+    rt_trace(tab, D_EVENTS, "Announcing exports after imports from %s", hook->req->name);
 
-  if (!tm_active(tab->exporter.export_timer))
-    tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
+    if (!tm_active(tab->exporter.export_timer))
+      tm_start(tab->exporter.export_timer, tab->config->export_settle_time);
+  }
 }
 
 static struct rt_pending_export *
@@ -1465,15 +1483,23 @@ static void
 rt_export_hook(void *_data)
 {
   struct rt_table_export_hook *c = _data;
+  rtable *tab = SKIP_BACK(rtable, priv.exporter, c->table);
 
   ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_READY);
 
   if (!c->rpe_next)
   {
+    RT_LOCK(tab);
     c->rpe_next = rt_next_export(c, c->table);
 
     if (!c->rpe_next)
-      return rt_export_used(c->table);
+    {
+      rt_export_used(c->table);
+      RT_UNLOCK(tab);
+      return;
+    }
+
+    RT_UNLOCK(tab);
   }
 
   int used = 0;
@@ -1488,7 +1514,8 @@ rt_export_hook(void *_data)
   }
 
   if (used)
-    rt_export_used(c->table);
+    RT_LOCKED(tab, _)
+      rt_export_used(c->table);
 
   rt_send_export_event(&c->h);
 }
@@ -1561,10 +1588,9 @@ rte_same(rte *x, rte *y)
 static inline int rte_is_ok(rte *e) { return e && !rte_is_filtered(e); }
 
 static int
-rte_recalculate(struct rt_import_hook *c, net *net, rte *new, struct rte_src *src)
+rte_recalculate(struct rtable_private *table, struct rt_import_hook *c, net *net, rte *new, struct rte_src *src)
 {
   struct rt_import_request *req = c->req;
-  struct rtable *table = c->table;
   struct rt_import_stats *stats = &c->stats;
   struct rte_storage *old_best_stored = net->routes, *old_stored = NULL;
   rte *old_best = old_best_stored ? &old_best_stored->rte : NULL;
@@ -1870,40 +1896,47 @@ rte_import(struct rt_import_request *req, const net_addr *n, rte *new, struct rt
   if (!hook)
     return;
 
-  net *nn;
-  if (new)
+  RT_LOCKED(hook->table, tab)
+  {
+    net *nn;
+    if (new)
     {
       /* Use the actual struct network, not the dummy one */
-      nn = net_get(hook->table, n);
+      nn = net_get(tab, n);
       new->net = nn->n.addr;
       new->sender = hook;
 
       /* Set the stale cycle */
       new->stale_cycle = hook->stale_set;
     }
-  else if (!(nn = net_find(hook->table, n)))
+    else if (!(nn = net_find(tab, n)))
     {
       req->hook->stats.withdraws_ignored++;
-      return;
+      RT_RETURN(tab);
     }
 
-  /* Recalculate the best route */
-  if (rte_recalculate(hook, nn, new, src))
-    ev_send(req->list, &hook->announce_event);
+    /* Recalculate the best route */
+    if (rte_recalculate(tab, hook, nn, new, src))
+      ev_send(req->list, &hook->announce_event);
+  }
 }
 
 /* Check rtable for best route to given net whether it would be exported do p */
 int
-rt_examine(rtable *t, net_addr *a, struct channel *c, const struct filter *filter)
+rt_examine(rtable *tp, net_addr *a, struct channel *c, const struct filter *filter)
 {
-  net *n = net_find(t, a);
+  rte rt = {};
 
-  if (!n || !rte_is_valid(RTE_OR_NULL(n->routes)))
-    return 0;
+  RT_LOCKED(tp, t)
+  {
+    net *n = net_find(t, a);
+    if (n)
+      rt = RTE_COPY_VALID(n->routes);
+  }
 
-  rte rt = n->routes->rte;
+  if (!rt.src)
+    return 0;
 
-  /* Rest is stripped down export_filter() */
   int v = c->proto->preexport ? c->proto->preexport(c, &rt) : 0;
   if (v == RIC_PROCESS)
     v = (f_run(filter, &rt, FF_SILENT) <= F_ACCEPT);
@@ -1915,31 +1948,37 @@ static void
 rt_table_export_done(void *hh)
 {
   struct rt_table_export_hook *hook = hh;
-  struct rtable *tab = SKIP_BACK(struct rtable, exporter, hook->table);
+  struct rt_export_request *req = hook->h.req;
+  void (*stopped)(struct rt_export_request *) = hook->h.stopped;
+  rtable *t = SKIP_BACK(rtable, priv.exporter, hook->table);
 
-  DBG("Export hook %p in table %s finished uc=%u\n", hook, tab->name, tab->use_count);
+  RT_LOCKED(t, tab)
+  {
+    DBG("Export hook %p in table %s finished uc=%u\n", hook, tab->name, tab->use_count);
+
+    /* Drop pending exports */
+    rt_export_used(&tab->exporter);
 
-  /* Drop pending exports */
-  rt_export_used(&tab->exporter);
+    /* Do the common code; this frees the hook */
+    rt_export_stopped(&hook->h);
+  }
 
-  /* Do the common code */
-  rt_export_stopped(&hook->h);
+  /* Report the channel as stopped. */
+  CALL(stopped, req);
 
   /* Unlock the table; this may free it */
-  rt_unlock_table(tab);
+  rt_unlock_table(t);
 }
 
 void
-rt_export_stopped(void *data)
+rt_export_stopped(struct rt_export_hook *hook)
 {
-  struct rt_export_hook *hook = data;
+  /* Unlink from the request */
+  hook->req->hook = NULL;
 
   /* Unlist */
   rem_node(&hook->n);
 
-  /* Report the channel as stopped. */
-  CALL(hook->stopped, hook->req);
-
   /* Free the hook itself together with its pool */
   rfree(hook->pool);
 }
@@ -1963,21 +2002,24 @@ rt_set_export_state(struct rt_export_hook *hook, u8 state)
 }
 
 void
-rt_request_import(rtable *tab, struct rt_import_request *req)
+rt_request_import(rtable *t, struct rt_import_request *req)
 {
-  rt_lock_table(tab);
+  RT_LOCKED(t, tab)
+  {
+    rt_lock_table(tab);
 
-  struct rt_import_hook *hook = req->hook = mb_allocz(tab->rp, sizeof(struct rt_import_hook));
+    struct rt_import_hook *hook = req->hook = mb_allocz(tab->rp, sizeof(struct rt_import_hook));
 
-  hook->announce_event = (event) { .hook = rt_import_announce_exports, .data = hook };
+    hook->announce_event = (event) { .hook = rt_import_announce_exports, .data = hook };
 
-  DBG("Lock table %s for import %p req=%p uc=%u\n", tab->name, hook, req, tab->use_count);
+    DBG("Lock table %s for import %p req=%p uc=%u\n", tab->name, hook, req, tab->use_count);
 
-  hook->req = req;
-  hook->table = tab;
+    hook->req = req;
+    hook->table = t;
 
-  rt_set_import_state(hook, TIS_UP);
-  add_tail(&tab->imports, &hook->n);
+    rt_set_import_state(hook, TIS_UP);
+    add_tail(&tab->imports, &hook->n);
+  }
 }
 
 void
@@ -1986,17 +2028,18 @@ rt_stop_import(struct rt_import_request *req, void (*stopped)(struct rt_import_r
   ASSERT_DIE(req->hook);
   struct rt_import_hook *hook = req->hook;
 
-  rt_schedule_prune(hook->table);
-
-  rt_set_import_state(hook, TIS_STOP);
-
-  hook->stopped = stopped;
+  RT_LOCKED(hook->table, tab)
+  {
+    rt_schedule_prune(tab);
+    rt_set_import_state(hook, TIS_STOP);
+    hook->stopped = stopped;
+  }
 }
 
 static void
-rt_table_export_start(struct rt_exporter *re, struct rt_export_request *req)
+rt_table_export_start_locked(struct rtable_private *tab, struct rt_export_request *req)
 {
-  rtable *tab = SKIP_BACK(rtable, exporter.e, re);
+  struct rt_exporter *re = &tab->exporter.e;
   rt_lock_table(tab);
 
   req->hook = rt_alloc_export(re, sizeof(struct rt_table_export_hook));
@@ -2044,9 +2087,17 @@ rt_table_export_start(struct rt_exporter *re, struct rt_export_request *req)
   rt_init_export(re, req->hook);
 }
 
-void rt_request_export(rtable *tab, struct rt_export_request *req)
+static void
+rt_table_export_start(struct rt_exporter *re, struct rt_export_request *req)
+{
+  RT_LOCKED(SKIP_BACK(rtable, priv.exporter.e, re), tab)
+    rt_table_export_start_locked(tab, req);
+}
+ 
+void rt_request_export(rtable *t, struct rt_export_request *req)
 {
-  rt_table_export_start(&tab->exporter.e, req);
+  RT_LOCKED(t, tab)
+    rt_table_export_start_locked(tab, req);  /* Is locked inside */
 }
 
 void
@@ -2083,30 +2134,40 @@ rt_init_export(struct rt_exporter *re, struct rt_export_hook *hook)
 }
 
 static void
-rt_table_export_stop(struct rt_export_hook *hh)
+rt_table_export_stop_locked(struct rt_export_hook *hh)
 {
   struct rt_table_export_hook *hook = SKIP_BACK(struct rt_table_export_hook, h, hh);
-  rtable *tab = SKIP_BACK(rtable, exporter, hook->table);
+  struct rtable_private *tab = SKIP_BACK(struct rtable_private, exporter, hook->table);
 
-  if (atomic_load_explicit(&hh->export_state, memory_order_relaxed) != TES_FEEDING)
-    return;
-
-  switch (hh->req->addr_mode)
-  {
-    case TE_ADDR_IN:
-      if (hook->walk_lock)
-      {
-	rt_unlock_trie(tab, hook->walk_lock);
-	hook->walk_lock = NULL;
-	mb_free(hook->walk_state);
-	hook->walk_state = NULL;
+  if (atomic_load_explicit(&hh->export_state, memory_order_relaxed) == TES_FEEDING)
+    switch (hh->req->addr_mode)
+    {
+      case TE_ADDR_IN:
+	if (hook->walk_lock)
+	{
+	  rt_unlock_trie(tab, hook->walk_lock);
+	  hook->walk_lock = NULL;
+	  mb_free(hook->walk_state);
+	  hook->walk_state = NULL;
+	  break;
+	}
+	/* fall through */
+      case TE_ADDR_NONE:
+	fit_get(&tab->fib, &hook->feed_fit);
 	break;
-      }
-      /* fall through */
-    case TE_ADDR_NONE:
-      fit_get(&tab->fib, &hook->feed_fit);
-      break;
-  }
+    }
+}
+
+static void
+rt_table_export_stop(struct rt_export_hook *hh)
+{
+  struct rt_table_export_hook *hook = SKIP_BACK(struct rt_table_export_hook, h, hh);
+  rtable *t = SKIP_BACK(rtable, priv.exporter, hook->table);
+  if (RT_IS_LOCKED(t))
+    rt_table_export_stop_locked(hh);
+  else
+    RT_LOCKED(t, tab)
+      rt_table_export_stop_locked(hh);
 }
 
 void
@@ -2154,12 +2215,15 @@ rt_refresh_begin(struct rt_import_request *req)
   ASSERT_DIE(hook);
   ASSERT_DIE(hook->stale_set == hook->stale_valid);
 
+  RT_LOCKED(hook->table, tab)
+  {
+
   /* If the pruning routine is too slow */
   if ((hook->stale_pruned < hook->stale_valid) && (hook->stale_pruned + 128 < hook->stale_valid)
       || (hook->stale_pruned > hook->stale_valid) && (hook->stale_pruned > hook->stale_valid + 128))
   {
     log(L_WARN "Route refresh flood in table %s", hook->table->name);
-    FIB_WALK(&hook->table->fib, net, n)
+    FIB_WALK(&tab->fib, net, n)
       {
        for (struct rte_storage *e = n->routes; e; e = e->next)
          if (e->rte.sender == req->hook)
@@ -2180,6 +2244,8 @@ rt_refresh_begin(struct rt_import_request *req)
 
   if (req->trace_routes & D_STATES)
     log(L_TRACE "%s: route refresh begin [%u]", req->name, hook->stale_set);
+
+  }
 }
 
 /**
@@ -2196,13 +2262,16 @@ rt_refresh_end(struct rt_import_request *req)
   struct rt_import_hook *hook = req->hook;
   ASSERT_DIE(hook);
 
-  hook->stale_valid++;
-  ASSERT_DIE(hook->stale_set == hook->stale_valid);
+  RT_LOCKED(hook->table, tab)
+  {
+    hook->stale_valid++;
+    ASSERT_DIE(hook->stale_set == hook->stale_valid);
 
-  rt_schedule_prune(hook->table);
+    rt_schedule_prune(tab);
 
-  if (req->trace_routes & D_STATES)
-    log(L_TRACE "%s: route refresh end [%u]", req->name, hook->stale_valid);
+    if (req->trace_routes & D_STATES)
+      log(L_TRACE "%s: route refresh end [%u]", req->name, hook->stale_valid);
+  }
 }
 
 /**
@@ -2227,8 +2296,11 @@ rte_dump(struct rte_storage *e)
  * This function dumps contents of a given routing table to debug output.
  */
 void
-rt_dump(rtable *t)
+rt_dump(rtable *tp)
 {
+  RT_LOCKED(tp, t)
+  {
+
   debug("Dump of routing table <%s>%s\n", t->name, t->deleted ? " (deleted)" : "");
 #ifdef DEBUGGING
   fib_check(&t->fib);
@@ -2240,6 +2312,8 @@ rt_dump(rtable *t)
     }
   FIB_WALK_END;
   debug("\n");
+
+  }
 }
 
 /**
@@ -2261,8 +2335,11 @@ rt_dump_all(void)
 }
 
 void
-rt_dump_hooks(rtable *tab)
+rt_dump_hooks(rtable *tp)
 {
+  RT_LOCKED(tp, tab)
+  {
+
   debug("Dump of hooks in routing table <%s>%s\n", tab->name, tab->deleted ? " (deleted)" : "");
   debug("  nhu_state=%u use_count=%d rt_count=%u\n",
       tab->nhu_state, tab->use_count, tab->rt_count);
@@ -2289,6 +2366,8 @@ rt_dump_hooks(rtable *tab)
        atomic_load_explicit(&eh->h.export_state, memory_order_relaxed));
   }
   debug("\n");
+
+  }
 }
 
 void
@@ -2307,7 +2386,7 @@ rt_dump_hooks_all(void)
 }
 
 static inline void
-rt_schedule_nhu(rtable *tab)
+rt_schedule_nhu(struct rtable_private *tab)
 {
   if (tab->nhu_corked)
   {
@@ -2332,7 +2411,7 @@ rt_schedule_nhu(rtable *tab)
 }
 
 void
-rt_schedule_prune(rtable *tab)
+rt_schedule_prune(struct rtable_private *tab)
 {
   if (tab->prune_state == 0)
     ev_schedule(tab->rt_event);
@@ -2344,7 +2423,8 @@ rt_schedule_prune(rtable *tab)
 static void
 rt_export_used(struct rt_table_exporter *e)
 {
-  rtable *tab = SKIP_BACK(rtable, exporter, e);
+  struct rtable_private *tab = SKIP_BACK(struct rtable_private, exporter, e);
+  ASSERT_DIE(RT_IS_LOCKED(tab));
 
   rt_trace(tab, D_EVENTS, "Export cleanup requested");
 
@@ -2358,7 +2438,8 @@ rt_export_used(struct rt_table_exporter *e)
 static void
 rt_event(void *ptr)
 {
-  rtable *tab = ptr;
+  RT_LOCKED((rtable *) ptr, tab)
+  {
 
   rt_lock_table(tab);
 
@@ -2369,19 +2450,19 @@ rt_event(void *ptr)
     rt_prune_table(tab);
 
   rt_unlock_table(tab);
+  }
 }
 
 static void
 rt_prune_timer(timer *t)
 {
-  rtable *tab = t->data;
-
-  if (tab->gc_counter >= tab->config->gc_threshold)
-    rt_schedule_prune(tab);
+  RT_LOCKED((rtable *) t->data, tab)
+    if (tab->gc_counter >= tab->config->gc_threshold)
+      rt_schedule_prune(tab);
 }
 
 static void
-rt_kick_prune_timer(rtable *tab)
+rt_kick_prune_timer(struct rtable_private *tab)
 {
   /* Return if prune is already scheduled */
   if (tm_active(tab->prune_timer) || (tab->prune_state & 1))
@@ -2398,13 +2479,15 @@ static void
 rt_flowspec_export_one(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *first)
 {
   struct rt_flowspec_link *ln = SKIP_BACK(struct rt_flowspec_link, req, req);
-  rtable *dst = ln->dst;
-  ASSUME(rt_is_flow(dst));
+  rtable *dst_pub = ln->dst;
+  ASSUME(rt_is_flow(dst_pub));
+  struct rtable_private *dst = RT_LOCK(dst_pub);
 
   /* No need to inspect it further if recalculation is already scheduled */
   if ((dst->nhu_state == NHU_SCHEDULED) || (dst->nhu_state == NHU_DIRTY)
       || !trie_match_net(dst->flowspec_trie, net))
   {
+    RT_UNLOCK(dst_pub);
     rpe_mark_seen_all(req->hook, first, NULL);
     return;
   }
@@ -2422,6 +2505,8 @@ rt_flowspec_export_one(struct rt_export_request *req, const net_addr *net, struc
   /* Yes, something has actually changed. Schedule the update. */
   if (o != RTE_VALID_OR_NULL(new_best))
     rt_schedule_nhu(dst);
+
+  RT_UNLOCK(dst_pub);
 }
 
 static void
@@ -2432,7 +2517,7 @@ rt_flowspec_dump_req(struct rt_export_request *req)
 }
 
 static struct rt_flowspec_link *
-rt_flowspec_find_link(rtable *src, rtable *dst)
+rt_flowspec_find_link(struct rtable_private *src, rtable *dst)
 {
   struct rt_table_export_hook *hook; node *n;
   WALK_LIST2(hook, n, src->exporter.e.hooks, h.n)
@@ -2452,33 +2537,41 @@ rt_flowspec_find_link(rtable *src, rtable *dst)
 }
 
 void
-rt_flowspec_link(rtable *src, rtable *dst)
+rt_flowspec_link(rtable *src_pub, rtable *dst_pub)
 {
-  ASSERT(rt_is_ip(src));
-  ASSERT(rt_is_flow(dst));
+  ASSERT(rt_is_ip(src_pub));
+  ASSERT(rt_is_flow(dst_pub));
 
-  struct rt_flowspec_link *ln = rt_flowspec_find_link(src, dst);
+  int lock_dst = 0;
 
-  if (!ln)
+  RT_LOCKED(src_pub, src)
   {
-    rt_lock_table(dst);
-
-    pool *p = src->rp;
-    ln = mb_allocz(p, sizeof(struct rt_flowspec_link));
-    ln->src = src;
-    ln->dst = dst;
-    ln->req = (struct rt_export_request) {
-      .name = mb_sprintf(p, "%s.flowspec.notifier", dst->name),
-      .list = &global_work_list,
-      .trace_routes = src->config->debug,
-      .dump_req = rt_flowspec_dump_req,
-      .export_one = rt_flowspec_export_one,
-    };
+    struct rt_flowspec_link *ln = rt_flowspec_find_link(src, dst_pub);
+
+    if (!ln)
+    {
+      pool *p = src->rp;
+      ln = mb_allocz(p, sizeof(struct rt_flowspec_link));
+      ln->src = src_pub;
+      ln->dst = dst_pub;
+      ln->req = (struct rt_export_request) {
+	.name = mb_sprintf(p, "%s.flowspec.notifier", dst_pub->name),
+	.list = &global_work_list,
+	.trace_routes = src->config->debug,
+	.dump_req = rt_flowspec_dump_req,
+	.export_one = rt_flowspec_export_one,
+      };
+
+      rt_table_export_start_locked(src, &ln->req);
+
+      lock_dst = 1;
+    }
 
-    rt_request_export(src, &ln->req);
+    ln->uc++;
   }
 
-  ln->uc++;
+  if (lock_dst)
+    rt_lock_table(dst_pub);
 }
 
 static void
@@ -2494,16 +2587,20 @@ rt_flowspec_link_stopped(struct rt_export_request *req)
 void
 rt_flowspec_unlink(rtable *src, rtable *dst)
 {
-  struct rt_flowspec_link *ln = rt_flowspec_find_link(src, dst);
+  struct rt_flowspec_link *ln;
+  RT_LOCKED(src, t)
+  {
+    ln = rt_flowspec_find_link(t, dst);
 
-  ASSERT(ln && (ln->uc > 0));
+    ASSERT(ln && (ln->uc > 0));
 
-  if (!--ln->uc)
-    rt_stop_export(&ln->req, rt_flowspec_link_stopped);
+    if (!--ln->uc)
+      rt_stop_export(&ln->req, rt_flowspec_link_stopped);
+  }
 }
 
 static void
-rt_flowspec_reset_trie(rtable *tab)
+rt_flowspec_reset_trie(struct rtable_private *tab)
 {
   linpool *lp = tab->flowspec_trie->lp;
   int ipv4 = tab->flowspec_trie->ipv4;
@@ -2516,7 +2613,9 @@ rt_flowspec_reset_trie(rtable *tab)
 static void
 rt_free(resource *_r)
 {
-  rtable *r = (rtable *) _r;
+  struct rtable_private *r = SKIP_BACK(struct rtable_private, r, _r);
+
+  DOMAIN_FREE(rtable, r->lock);
 
   DBG("Deleting routing table %s\n", r->name);
   ASSERT_DIE(r->use_count == 0);
@@ -2538,14 +2637,15 @@ rt_free(resource *_r)
 static void
 rt_res_dump(resource *_r)
 {
-  rtable *r = (rtable *) _r;
+  struct rtable_private *r = SKIP_BACK(struct rtable_private, r, _r);
+
   debug("name \"%s\", addr_type=%s, rt_count=%u, use_count=%d\n",
       r->name, net_label[r->addr_type], r->rt_count, r->use_count);
 }
 
 static struct resclass rt_class = {
   .name = "Routing table",
-  .size = sizeof(struct rtable),
+  .size = sizeof(rtable),
   .free = rt_free,
   .dump = rt_res_dump,
   .lookup = NULL,
@@ -2572,7 +2672,7 @@ rt_setup(pool *pp, struct rtable_config *cf)
 {
   pool *p = rp_newf(pp, "Routing table %s", cf->name);
 
-  rtable *t = ralloc(p, &rt_class);
+  struct rtable_private *t = ralloc(p, &rt_class);
   t->rp = p;
 
   t->rte_slab = sl_new(p, sizeof(struct rte_storage));
@@ -2584,6 +2684,8 @@ rt_setup(pool *pp, struct rtable_config *cf)
   if (t->id >= rtable_max_id)
     rtable_max_id = t->id + 1;
 
+  t->lock = DOMAIN_NEW(rtable, t->name);
+
   fib_init(&t->fib, p, t->addr_type, sizeof(net), OFFSETOF(net, n), 0, NULL);
 
   if (cf->trie_used)
@@ -2622,13 +2724,13 @@ rt_setup(pool *pp, struct rtable_config *cf)
 
   t->rl_pipe = (struct tbf) TBF_DEFAULT_LOG_LIMITS;
 
-  if (rt_is_flow(t))
+  if (rt_is_flow(RT_PUB(t)))
   {
     t->flowspec_trie = f_new_trie(lp_new_default(p), 0);
     t->flowspec_trie->ipv4 = (t->addr_type == NET_FLOW4);
   }
 
-  return t;
+  return RT_PUB(t);
 }
 
 /**
@@ -2665,7 +2767,7 @@ rt_init(void)
  * iteration.
  */
 static void
-rt_prune_table(rtable *tab)
+rt_prune_table(struct rtable_private *tab)
 {
   struct fib_iterator *fit = &tab->prune_fit;
   int limit = 2000;
@@ -2727,7 +2829,7 @@ again:
 	    (e->rte.stale_cycle < s->stale_valid) ||
 	    (e->rte.stale_cycle > s->stale_set))
 	  {
-	    rte_recalculate(e->rte.sender, n, NULL, e->rte.src);
+	    rte_recalculate(tab, e->rte.sender, n, NULL, e->rte.src);
 	    limit--;
 
 	    goto rescan;
@@ -2814,7 +2916,7 @@ again:
 }
 
 static void
-rt_export_cleanup(rtable *tab)
+rt_export_cleanup(struct rtable_private *tab)
 {
   tab->export_used = 0;
 
@@ -3004,7 +3106,7 @@ rt_cork_release_hook(void *data UNUSED)
  *
  */
 struct f_trie *
-rt_lock_trie(rtable *tab)
+rt_lock_trie(struct rtable_private *tab)
 {
   ASSERT(tab->trie);
 
@@ -3021,7 +3123,7 @@ rt_lock_trie(rtable *tab)
  * It may free the trie and schedule next trie pruning.
  */
 void
-rt_unlock_trie(rtable *tab, struct f_trie *trie)
+rt_unlock_trie(struct rtable_private *tab, struct f_trie *trie)
 {
   ASSERT(trie);
 
@@ -3093,7 +3195,7 @@ rt_postconfig(struct config *c)
  */
 
 void
-ea_set_hostentry(ea_list **to, struct rtable *dep, struct rtable *tab, ip_addr gw, ip_addr ll, u32 lnum, u32 labels[lnum])
+ea_set_hostentry(ea_list **to, rtable *dep, rtable *src, ip_addr gw, ip_addr ll, u32 lnum, u32 labels[lnum])
 {
   struct {
     struct adata ad;
@@ -3101,7 +3203,8 @@ ea_set_hostentry(ea_list **to, struct rtable *dep, struct rtable *tab, ip_addr g
     u32 labels[lnum];
   } *head = (void *) tmp_alloc_adata(sizeof *head - sizeof(struct adata));
 
-  head->he = rt_get_hostentry(tab, gw, ll, dep);
+  RT_LOCKED(src, tab)
+    head->he = rt_get_hostentry(tab, gw, ll, dep);
   memcpy(head->labels, labels, lnum * sizeof(u32));
 
   ea_set_attr(to, EA_LITERAL_DIRECT_ADATA(
@@ -3297,7 +3400,6 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, ea_list *
 {
   ASSERT(rt_is_ip(tab_ip));
   ASSERT(rt_is_flow(tab_flow));
-  ASSERT(tab_ip->trie);
 
   /* RFC 8955 6. a) Flowspec has defined dst prefix */
   if (!net_flow_has_dst_prefix(n))
@@ -3317,32 +3419,45 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, ea_list *
   else
     net_fill_ip6(&dst, net6_prefix(n), net6_pxlen(n));
 
-  /* Find best-match BGP unicast route for flowspec dst prefix */
-  net *nb = net_route(tab_ip, &dst);
-  const rte *rb = nb ? &nb->routes->rte : NULL;
+  rte rb = {};
+  net_addr_union nau;
+  RT_LOCKED(tab_ip, tip)
+  {
+    ASSERT(tip->trie);
+    /* Find best-match BGP unicast route for flowspec dst prefix */
+    net *nb = net_route(tip, &dst);
+    if (nb)
+    {
+      rb = RTE_COPY_VALID(nb->routes);
+      rta_clone(rb.attrs);
+      net_copy(&nau.n, nb->n.addr);
+      rb.net = &nau.n;
+    }
+  }
 
   /* Register prefix to trie for tracking further changes */
   int max_pxlen = (n->type == NET_FLOW4) ? IP4_MAX_PREFIX_LENGTH : IP6_MAX_PREFIX_LENGTH;
-  trie_add_prefix(tab_flow->flowspec_trie, &dst, (nb ? nb->n.addr->pxlen : 0), max_pxlen);
+  RT_LOCKED(tab_flow, tfl)
+    trie_add_prefix(tfl->flowspec_trie, &dst, (rb.net ? rb.net->pxlen : 0), max_pxlen);
 
   /* No best-match BGP route -> no flowspec */
-  if (!rb || (rt_get_source_attr(rb) != RTS_BGP))
+  if (!rb.attrs || (rt_get_source_attr(&rb) != RTS_BGP))
     return FLOWSPEC_INVALID;
 
   /* Find ORIGINATOR_ID values */
   u32 orig_a = ea_get_int(a, "bgp_originator_id", 0);
-  u32 orig_b = ea_get_int(rb->attrs, "bgp_originator_id", 0);
+  u32 orig_b = ea_get_int(rb.attrs, "bgp_originator_id", 0);
 
   /* Originator is either ORIGINATOR_ID (if present), or BGP neighbor address (if not) */
   if ((orig_a != orig_b) || (!orig_a && !orig_b && !ipa_equal(
 	  ea_get_ip(a, &ea_gen_from, IPA_NONE),
-	  ea_get_ip(rb->attrs, &ea_gen_from, IPA_NONE)
+	  ea_get_ip(rb.attrs, &ea_gen_from, IPA_NONE)
 	  )))
     return FLOWSPEC_INVALID;
 
 
   /* Find ASN of the best-match route, for use in next checks */
-  u32 asn_b = rta_get_first_asn(rb->attrs);
+  u32 asn_b = rta_get_first_asn(rb.attrs);
   if (!asn_b)
     return FLOWSPEC_INVALID;
 
@@ -3351,20 +3466,23 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, ea_list *
     return FLOWSPEC_INVALID;
 
   /* RFC 8955 6. c) More-specific routes are from the same AS as the best-match route */
-  TRIE_WALK(tab_ip->trie, subnet, &dst)
+  RT_LOCKED(tab_ip, tip)
   {
-    net *nc = net_find_valid(tab_ip, &subnet);
-    if (!nc)
-      continue;
+    TRIE_WALK(tip->trie, subnet, &dst)
+    {
+      net *nc = net_find_valid(tip, &subnet);
+      if (!nc)
+	continue;
 
-    const rte *rc = &nc->routes->rte;
-    if (rt_get_source_attr(rc) != RTS_BGP)
-      return FLOWSPEC_INVALID;
+      const rte *rc = &nc->routes->rte;
+      if (rt_get_source_attr(rc) != RTS_BGP)
+	RT_RETURN(tip, FLOWSPEC_INVALID);
 
-    if (rta_get_first_asn(rc->attrs) != asn_b)
-      return FLOWSPEC_INVALID;
+      if (rta_get_first_asn(rc->attrs) != asn_b)
+	RT_RETURN(tip, FLOWSPEC_INVALID);
+    }
+    TRIE_WALK_END;
   }
-  TRIE_WALK_END;
 
   return FLOWSPEC_VALID;
 }
@@ -3429,7 +3547,7 @@ rt_flowspec_resolve_rte(rte *r, struct channel *c)
 }
 
 static inline int
-rt_next_hop_update_net(rtable *tab, net *n)
+rt_next_hop_update_net(struct rtable_private *tab, net *n)
 {
   uint count = 0;
   int is_flow = net_is_flow(n->n.addr);
@@ -3449,41 +3567,38 @@ rt_next_hop_update_net(rtable *tab, net *n)
     rte new;
   } *updates = tmp_allocz(sizeof(struct rte_multiupdate) * (count+1));
 
-  //struct rt_pending_export *last_pending = n->last;
+  struct rt_pending_export *last_pending = n->last;
 
   uint pos = 0;
   for (struct rte_storage *e, **k = &n->routes; e = *k; k = &e->next)
     updates[pos++].old = e;
 
+  /* This is an exceptional place where table can be unlocked while keeping its data:
+   * the reason why this is safe is that NHU must be always run from the same
+   * thread as cleanup routines, therefore the only real problem may arise when
+   * some importer does a change on this particular net (destination) while NHU
+   * is being computed. Statistically, this should almost never happen. In such
+   * case, we just drop all the computed changes and do it once again.
+   * */
+  RT_UNLOCK(tab);
+
   uint mod = 0;
   if (is_flow)
     for (uint i = 0; i < pos; i++)
-      mod += rt_flowspec_update_rte(tab, &updates[i].old->rte, &updates[i].new);
+      mod += rt_flowspec_update_rte(RT_PUB(tab), &updates[i].old->rte, &updates[i].new);
 
   else
     for (uint i = 0; i < pos; i++)
       mod += rt_next_hop_update_rte(&updates[i].old->rte, &updates[i].new);
 
+  RT_LOCK(RT_PUB(tab));
+
   if (!mod)
     return 0;
 
-  /* Next commit: Here check whether the network hasn't changed while generating updates */
-
-  for (uint i = 0; i < pos; i++)
-    if (updates[i].new.attrs)
-      {
-	/* Call a pre-comparison hook */
-	/* Not really an efficient way to compute this */
-	if (updates[i].old->rte.src->owner->rte_recalculate)
-	  updates[i].old->rte.src->owner->rte_recalculate(tab, n, &updates[i].new, &updates[i].old->rte, &old_best->rte);
-	/* And store the route */
-	struct rte_storage *ns = updates[i].new_stored = rte_store(&updates[i].new, n, tab);
-
-	/* Get a new ID for the route */
-	ns->rte.lastmod = current_time();
-	ns->rte.id = hmap_first_zero(&tab->id_map);
-	hmap_set(&tab->id_map, ns->rte.id);
-      }
+  /* Something has changed inbetween, retry NHU. */
+  if (last_pending != n->last)
+    return rt_next_hop_update_net(tab, n);
 
   /* Now we reconstruct the original linked list */
   struct rte_storage **nptr = &n->routes;
@@ -3491,12 +3606,33 @@ rt_next_hop_update_net(rtable *tab, net *n)
   {
     updates[i].old->next = NULL;
 
-    struct rte_storage *put = updates[i].new_stored ?: updates[i].old;
+    struct rte_storage *put;
+    if (updates[i].new.attrs)
+      put = updates[i].new_stored = rte_store(&updates[i].new, n, tab);
+    else
+      put = updates[i].old;
+
     *nptr = put;
     nptr = &put->next;
   }
   *nptr = NULL;
 
+  /* Call the pre-comparison hooks */
+  for (uint i = 0; i < pos; i++)
+    if (updates[i].new_stored)
+      {
+	/* Get a new ID for the route */
+	updates[i].new_stored->rte.lastmod = current_time();
+	updates[i].new_stored->rte.id = hmap_first_zero(&tab->id_map);
+	hmap_set(&tab->id_map, updates[i].new_stored->rte.id);
+
+	/* Call a pre-comparison hook */
+	/* Not really an efficient way to compute this */
+	if (updates[i].old->rte.src->owner->rte_recalculate)
+	  updates[i].old->rte.src->owner->rte_recalculate(tab, n, &updates[i].new_stored->rte, &updates[i].old->rte, &old_best->rte);
+      }
+
+#if DEBUGGING
   {
     uint t = 0;
     for (struct rte_storage *e = n->routes; e; e = e->next)
@@ -3504,6 +3640,7 @@ rt_next_hop_update_net(rtable *tab, net *n)
     ASSERT_DIE(t == pos);
     ASSERT_DIE(pos == count);
   }
+#endif
 
   /* Find the new best route */
   struct rte_storage **new_best = NULL;
@@ -3546,7 +3683,8 @@ rt_next_hop_update_net(rtable *tab, net *n)
 static void
 rt_next_hop_update(void *_tab)
 {
-  rtable *tab = _tab;
+  RT_LOCKED((rtable *) _tab, tab)
+  {
 
   /* If called from an uncork hook, reset the state */
   if (tab->nhu_corked)
@@ -3571,7 +3709,7 @@ rt_next_hop_update(void *_tab)
 
     tab->nhu_corked = tab->nhu_state;
     tab->nhu_state = 0;
-    return;
+    RT_RETURN(tab);
   }
 
   struct fib_iterator *fit = &tab->nhu_fit;
@@ -3594,7 +3732,7 @@ rt_next_hop_update(void *_tab)
 	{
 	  FIB_ITERATE_PUT(fit);
 	  ev_schedule(tab->nhu_event);
-	  return;
+	  RT_RETURN(tab);
 	}
       lp_state lps;
       lp_save(tmp_linpool, &lps);
@@ -3617,6 +3755,8 @@ rt_next_hop_update(void *_tab)
     ev_schedule(tab->nhu_event);
 
   rt_unlock_table(tab);
+
+  }
 }
 
 void
@@ -3680,10 +3820,11 @@ rt_new_table(struct symbol *s, uint addr_type)
  * preventing it from being freed when it gets undefined in a new
  * configuration.
  */
-void rt_lock_table_debug(rtable *tab, const char *file, uint line)
+void
+rt_lock_table_priv(struct rtable_private *r, const char *file, uint line)
 {
-  rt_trace(tab, D_STATES, "Locked at %s:%d", file, line);
-  tab->use_count++;
+  rt_trace(r, D_STATES, "Locked at %s:%d", file, line);
+  r->use_count++;
 }
 
 /**
@@ -3694,21 +3835,33 @@ void rt_lock_table_debug(rtable *tab, const char *file, uint line)
  * that is decrease its use count and delete it if it's scheduled
  * for deletion by configuration changes.
  */
-void rt_unlock_table_debug(rtable *r, const char *file, uint line)
+void
+rt_unlock_table_priv(struct rtable_private *r, const char *file, uint line)
 {
   rt_trace(r, D_STATES, "Unlocked at %s:%d", file, line);
   if (!--r->use_count && r->deleted)
-    {
-      struct config *conf = r->deleted;
+    /* Schedule the delete event to finish this up */
+    ev_send(&global_event_list, ev_new_init(r->rp, rt_delete, r));
+}
 
-      /* Delete the routing table by freeing its pool */
-      rt_shutdown(r);
-      config_del_obstacle(conf);
-    }
+static void
+rt_delete(void *tab_)
+{
+  /* We assume that nobody holds the table reference now as use_count is zero.
+   * Anyway the last holder may still hold the lock. Therefore we lock and
+   * unlock it the last time to be sure that nobody is there. */
+  struct rtable_private *tab = RT_LOCK((rtable *) tab_);
+  struct config *conf = tab->deleted;
+
+  RT_UNLOCK(RT_PUB(tab));
+
+  rfree(tab->rp);
+  config_del_obstacle(conf);
 }
 
+
 static void
-rt_check_cork_low(rtable *tab)
+rt_check_cork_low(struct rtable_private *tab)
 {
   if (!tab->cork_active)
     return;
@@ -3723,7 +3876,7 @@ rt_check_cork_low(rtable *tab)
 }
 
 static void
-rt_check_cork_high(rtable *tab)
+rt_check_cork_high(struct rtable_private *tab)
 {
   if (!tab->cork_active && tab->exporter.first && (tab->exporter.first->seq + tab->cork_threshold.high <= tab->exporter.next_seq))
   {
@@ -3736,7 +3889,7 @@ rt_check_cork_high(rtable *tab)
 
 
 static int
-rt_reconfigure(rtable *tab, struct rtable_config *new, struct rtable_config *old)
+rt_reconfigure(struct rtable_private *tab, struct rtable_config *new, struct rtable_config *old)
 {
   if ((new->addr_type != old->addr_type) ||
       (new->sorted != old->sorted) ||
@@ -3744,7 +3897,7 @@ rt_reconfigure(rtable *tab, struct rtable_config *new, struct rtable_config *old
     return 0;
 
   DBG("\t%s: same\n", new->name);
-  new->table = tab;
+  new->table = RT_PUB(tab);
   tab->name = new->name;
   tab->config = new;
 
@@ -3796,13 +3949,20 @@ rt_commit(struct config *new, struct config *old)
     {
       WALK_LIST(o, old->tables)
 	{
-	  rtable *tab = o->table;
+	  struct rtable_private *tab = RT_LOCK(o->table);
+
 	  if (tab->deleted)
+	  {
+	    RT_UNLOCK(tab);
 	    continue;
+	  }
 
 	  r = rt_find_table_config(new, o->name);
 	  if (r && !new->shutdown && rt_reconfigure(tab, r, o))
+	  {
+	    RT_UNLOCK(tab);
 	    continue;
+	  }
 
 	  DBG("\t%s: deleted\n", o->name);
 	  tab->deleted = old;
@@ -3813,6 +3973,8 @@ rt_commit(struct config *new, struct config *old)
 	    rt_stop_export(&tab->hostcache->req, NULL);
 
 	  rt_unlock_table(tab);
+
+	  RT_UNLOCK(tab);
 	}
     }
 
@@ -3917,14 +4079,13 @@ static void
 rt_feed_by_fib(void *data)
 {
   struct rt_table_export_hook *c = data;
-
   struct fib_iterator *fit = &c->feed_fit;
-
   rt_feed_block block = {};
 
   ASSERT(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
 
-  rtable *tab = SKIP_BACK(rtable, exporter, c->table);
+  RT_LOCKED(RT_PUB(SKIP_BACK(struct rtable_private, exporter, c->table)), tab)
+  {
 
   FIB_ITERATE_START(&tab->fib, fit, net, n)
     {
@@ -3936,6 +4097,7 @@ rt_feed_by_fib(void *data)
 	if (!rt_prepare_feed(c, n, &block))
 	{
 	  FIB_ITERATE_PUT(fit);
+	  RT_UNLOCK(tab);
 	  rt_process_feed(c, &block);
 	  rt_send_export_event(&c->h);
 	  return;
@@ -3943,6 +4105,7 @@ rt_feed_by_fib(void *data)
       }
     }
   FIB_ITERATE_END;
+  }
 
   rt_process_feed(c, &block);
   rt_feed_done(&c->h);
@@ -3952,13 +4115,14 @@ static void
 rt_feed_by_trie(void *data)
 {
   struct rt_table_export_hook *c = data;
-  rtable *tab = SKIP_BACK(rtable, exporter, c->table);
+  rt_feed_block block = {};
+
+  RT_LOCKED(RT_PUB(SKIP_BACK(struct rtable_private, exporter, c->table)), tab)
+  {
 
   ASSERT_DIE(c->walk_state);
   struct f_trie_walk_state *ws = c->walk_state;
 
-  rt_feed_block block = {};
-
   ASSERT(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
 
   do {
@@ -3970,10 +4134,11 @@ rt_feed_by_trie(void *data)
       continue;
 
     if (atomic_load_explicit(&c->h.export_state, memory_order_acquire) != TES_FEEDING)
-      return;
+      RT_RETURN(tab);
 
     if (!rt_prepare_feed(c, n, &block))
     {
+      RT_UNLOCK(tab);
       rt_process_feed(c, &block);
       rt_send_export_event(&c->h);
       return;
@@ -3989,6 +4154,9 @@ rt_feed_by_trie(void *data)
 
   c->walk_last.type = 0;
 
+  }
+
+  rt_process_feed(c, &block);
   rt_feed_done(&c->h);
 }
 
@@ -3996,19 +4164,20 @@ static void
 rt_feed_equal(void *data)
 {
   struct rt_table_export_hook *c = data;
-  rtable *tab = SKIP_BACK(rtable, exporter, c->table);
+  rt_feed_block block = {};
+  net *n;
 
-  ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
-  ASSERT_DIE(c->h.req->addr_mode == TE_ADDR_EQUAL);
+  RT_LOCKED(RT_PUB(SKIP_BACK(struct rtable_private, exporter, c->table)), tab)
+  {
+    ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
+    ASSERT_DIE(c->h.req->addr_mode == TE_ADDR_EQUAL);
 
-  rt_feed_block block = {};
+    if (n = net_find(tab, c->h.req->addr))
+      ASSERT_DIE(rt_prepare_feed(c, n, &block));
+  }
 
-  net *n = net_find(tab, c->h.req->addr);
   if (n)
-  {
-    ASSERT_DIE(rt_prepare_feed(c, n, &block));
     rt_process_feed(c, &block);
-  }
 
   rt_feed_done(&c->h);
 }
@@ -4017,19 +4186,20 @@ static void
 rt_feed_for(void *data)
 {
   struct rt_table_export_hook *c = data;
-  rtable *tab = SKIP_BACK(rtable, exporter, c->table);
+  rt_feed_block block = {};
+  net *n;
 
-  ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
-  ASSERT_DIE(c->h.req->addr_mode == TE_ADDR_FOR);
+  RT_LOCKED(RT_PUB(SKIP_BACK(struct rtable_private, exporter, c->table)), tab)
+  {
+    ASSERT_DIE(atomic_load_explicit(&c->h.export_state, memory_order_relaxed) == TES_FEEDING);
+    ASSERT_DIE(c->h.req->addr_mode == TE_ADDR_FOR);
 
-  rt_feed_block block = {};
+    if (n = net_route(tab, c->h.req->addr))
+      ASSERT_DIE(rt_prepare_feed(c, n, &block));
+  }
 
-  net *n = net_route(tab, c->h.req->addr);
   if (n)
-  {
-    ASSERT_DIE(rt_prepare_feed(c, n, &block));
     rt_process_feed(c, &block);
-  }
 
   rt_feed_done(&c->h);
 }
@@ -4194,7 +4364,7 @@ hc_notify_export_one(struct rt_export_request *req, const net_addr *net, struct
 
 
 static void
-rt_init_hostcache(rtable *tab)
+rt_init_hostcache(struct rtable_private *tab)
 {
   struct hostcache *hc = mb_allocz(tab->rp, sizeof(struct hostcache));
   init_list(&hc->hostentries);
@@ -4219,13 +4389,13 @@ rt_init_hostcache(rtable *tab)
     .export_one = hc_notify_export_one,
   };
 
-  rt_request_export(tab, &hc->req);
+  rt_table_export_start_locked(tab, &hc->req);
 
   tab->hostcache = hc;
 }
 
 static void
-rt_free_hostcache(rtable *tab)
+rt_free_hostcache(struct rtable_private *tab)
 {
   struct hostcache *hc = tab->hostcache;
 
@@ -4277,7 +4447,7 @@ rt_get_igp_metric(const rte *rt)
 }
 
 static int
-rt_update_hostentry(rtable *tab, struct hostentry *he)
+rt_update_hostentry(struct rtable_private *tab, struct hostentry *he)
 {
   ea_list *old_src = he->src;
   int direct = 0;
@@ -4345,17 +4515,21 @@ done:
 static void
 rt_update_hostcache(void *data)
 {
-  rtable *tab = data;
+  rtable **nhu_pending;
+
+  RT_LOCKED((rtable *) data, tab)
+  {
+
   struct hostcache *hc = tab->hostcache;
 
   if (rt_cork_check(&hc->update))
   {
     rt_trace(tab, D_STATES, "Hostcache update corked");
-    return;
+    RT_RETURN(tab);
   }
 
   /* Destination schedule map */
-  rtable **nhu_pending = tmp_allocz(sizeof(rtable *) * rtable_max_id);
+  nhu_pending = tmp_allocz(sizeof(rtable *) * rtable_max_id);
 
   struct hostentry *he;
   node *n, *x;
@@ -4376,14 +4550,16 @@ rt_update_hostcache(void *data)
       if (rt_update_hostentry(tab, he))
 	nhu_pending[he->tab->id] = he->tab;
     }
+  }
 
   for (uint i=0; i<rtable_max_id; i++)
     if (nhu_pending[i])
-      rt_schedule_nhu(nhu_pending[i]);
+      RT_LOCKED(nhu_pending[i], dst)
+	rt_schedule_nhu(dst);
 }
 
 static struct hostentry *
-rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep)
+rt_get_hostentry(struct rtable_private *tab, ip_addr a, ip_addr ll, rtable *dep)
 {
   struct hostentry *he;
 
diff --git a/nest/rt.h b/nest/rt.h
index 7cf8a91f..3a8489e8 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -53,7 +53,7 @@ struct rt_cork_threshold {
 struct rtable_config {
   node n;
   char *name;
-  struct rtable *table;
+  union rtable *table;
   struct proto_config *krt_attached;	/* Kernel syncer attached to this table */
   uint addr_type;			/* Type of address data stored in table (NET_*) */
   uint gc_threshold;			/* Maximum number of operations before GC is run */
@@ -93,16 +93,28 @@ struct rt_table_exporter {
 
 extern uint rtable_max_id;
 
-typedef struct rtable {
-  resource r;
-  node n;				/* Node in list of all tables */
+DEFINE_DOMAIN(rtable);
+
+/* The public part of rtable structure */
+#define RTABLE_PUBLIC \
+    resource r;											\
+    node n;				/* Node in list of all tables */			\
+    char *name;				/* Name of this table */				\
+    uint addr_type;			/* Type of address data stored in table (NET_*) */	\
+    uint id;				/* Integer table ID for fast lookup */			\
+    DOMAIN(rtable) lock;		/* Lock to take to access the private parts */		\
+    struct rtable_config *config;	/* Configuration of this table */			\
+
+/* The complete rtable structure */
+struct rtable_private {
+  /* Once more the public part */
+  RTABLE_PUBLIC;
+
+  /* Here the private items not to be accessed without locking */
   pool *rp;				/* Resource pool to allocate everything from, including itself */
   struct slab *rte_slab;		/* Slab to allocate route objects */
   struct fib fib;
   struct f_trie *trie;			/* Trie of prefixes defined in fib */
-  char *name;				/* Name of this table */
-  uint addr_type;			/* Type of address data stored in table (NET_*) */
-  uint id;				/* Integer table ID for fast lookup */
   int use_count;			/* Number of protocols using this table */
   u32 rt_count;				/* Number of routes in the table */
 
@@ -111,7 +123,6 @@ typedef struct rtable {
 
   struct hmap id_map;
   struct hostcache *hostcache;
-  struct rtable_config *config;		/* Configuration of this table */
   struct config *deleted;		/* Table doesn't exist in current configuration,
 					 * delete as soon as use_count becomes 0 and remove
 					 * obstacle from this routing table.
@@ -138,8 +149,28 @@ typedef struct rtable {
   struct tbf rl_pipe;			/* Rate limiting token buffer for pipe collisions */
 
   struct f_trie *flowspec_trie;		/* Trie for evaluation of flowspec notifications */
+};
+
+/* The final union private-public rtable structure */
+typedef union rtable {
+  struct {
+    RTABLE_PUBLIC;
+  };
+  struct rtable_private priv;
 } rtable;
 
+#define RT_IS_LOCKED(tab)	DOMAIN_IS_LOCKED(rtable, (tab)->lock)
+
+#define RT_LOCK(tab)	({ LOCK_DOMAIN(rtable, (tab)->lock); &(tab)->priv; })
+#define RT_UNLOCK(tab)	UNLOCK_DOMAIN(rtable, (tab)->lock)
+#define RT_PRIV(tab)	({ ASSERT_DIE(RT_IS_LOCKED((tab))); &(tab)->priv; })
+#define RT_PUB(tab)	SKIP_BACK(rtable, priv, tab)
+
+#define RT_LOCKED(tpub, tpriv) for (struct rtable_private *tpriv = RT_LOCK(tpub); tpriv; RT_UNLOCK(tpriv), (tpriv = NULL))
+#define RT_RETURN(tpriv, ...) do { RT_UNLOCK(tpriv); return __VA_ARGS__; } while (0)
+
+#define RT_PRIV_SAME(tpriv, tpub)	(&(tpub)->priv == (tpriv))
+
 extern struct rt_cork {
   _Atomic uint active;
   event_list queue;
@@ -386,7 +417,7 @@ int rpe_get_seen(struct rt_export_hook *hook, struct rt_pending_export *rpe);
 
 void rt_init_export(struct rt_exporter *re, struct rt_export_hook *hook);
 struct rt_export_hook *rt_alloc_export(struct rt_exporter *re, uint size);
-void rt_export_stopped(void *data);
+void rt_export_stopped(struct rt_export_hook *hook);
 void rt_exporter_init(struct rt_exporter *re);
 
 /* Types of route announcement, also used as flags */
@@ -416,7 +447,7 @@ struct hostentry {
   ip_addr addr;				/* IP address of host, part of key */
   ip_addr link;				/* (link-local) IP address of host, used as gw
 					   if host is directly attached */
-  struct rtable *tab;			/* Dependent table, part of key */
+  rtable *tab;				/* Dependent table, part of key */
   struct hostentry *next;		/* Next in hash chain */
   unsigned hash_key;			/* Hash key */
   unsigned uc;				/* Use count */
@@ -487,34 +518,36 @@ void rt_init(void);
 void rt_preconfig(struct config *);
 void rt_postconfig(struct config *);
 void rt_commit(struct config *new, struct config *old);
-
-void rt_lock_table_debug(rtable *, const char *file, uint line);
-void rt_unlock_table_debug(rtable *, const char *file, uint line);
-#define rt_lock_table(tab)	rt_lock_table_debug(tab, __FILE__, __LINE__)
-#define rt_unlock_table(tab)	rt_unlock_table_debug(tab, __FILE__, __LINE__)
-
-struct f_trie * rt_lock_trie(rtable *tab);
-void rt_unlock_trie(rtable *tab, struct f_trie *trie);
+void rt_lock_table_priv(struct rtable_private *, const char *file, uint line);
+void rt_unlock_table_priv(struct rtable_private *, const char *file, uint line);
+static inline void rt_lock_table_pub(rtable *t, const char *file, uint line)
+{ RT_LOCKED(t, tt) rt_lock_table_priv(tt, file, line); }
+static inline void rt_unlock_table_pub(rtable *t, const char *file, uint line)
+{ RT_LOCKED(t, tt) rt_unlock_table_priv(tt, file, line); }
+
+#define rt_lock_table(t)	_Generic((t),  rtable *: rt_lock_table_pub, \
+				struct rtable_private *: rt_lock_table_priv)((t), __FILE__, __LINE__)
+#define rt_unlock_table(t)	_Generic((t),  rtable *: rt_unlock_table_pub, \
+				struct rtable_private *: rt_unlock_table_priv)((t), __FILE__, __LINE__)
+
+struct f_trie * rt_lock_trie(struct rtable_private *tab);
+void rt_unlock_trie(struct rtable_private *tab, struct f_trie *trie);
 void rt_flowspec_link(rtable *src, rtable *dst);
 void rt_flowspec_unlink(rtable *src, rtable *dst);
 rtable *rt_setup(pool *, struct rtable_config *);
-static inline void rt_shutdown(rtable *r) { rfree(r->rp); }
 
-static inline net *net_find(rtable *tab, const net_addr *addr) { return (net *) fib_find(&tab->fib, addr); }
-static inline net *net_find_valid(rtable *tab, const net_addr *addr)
+static inline net *net_find(struct rtable_private *tab, const net_addr *addr) { return (net *) fib_find(&tab->fib, addr); }
+static inline net *net_find_valid(struct rtable_private *tab, const net_addr *addr)
 { net *n = net_find(tab, addr); return (n && n->routes && rte_is_valid(&n->routes->rte)) ? n : NULL; }
-static inline net *net_get(rtable *tab, const net_addr *addr) { return (net *) fib_get(&tab->fib, addr); }
-net *net_get(rtable *tab, const net_addr *addr);
-net *net_route(rtable *tab, const net_addr *n);
+static inline net *net_get(struct rtable_private *tab, const net_addr *addr) { return (net *) fib_get(&tab->fib, addr); }
+net *net_route(struct rtable_private *tab, const net_addr *n);
 int rt_examine(rtable *t, net_addr *a, struct channel *c, const struct filter *filter);
 rte *rt_export_merged(struct channel *c, rte ** feed, uint count, linpool *pool, int silent);
 void rt_refresh_begin(struct rt_import_request *);
 void rt_refresh_end(struct rt_import_request *);
 void rt_modify_stale(rtable *t, struct rt_import_request *);
-void rt_schedule_prune(rtable *t);
+void rt_schedule_prune(struct rtable_private *t);
 void rte_dump(struct rte_storage *);
-void rte_free(struct rte_storage *);
-struct rte_storage *rte_store(const rte *, net *net, rtable *);
 void rt_dump(rtable *);
 void rt_dump_all(void);
 void rt_dump_hooks(rtable *);
@@ -575,7 +608,7 @@ struct rt_show_data {
 
 void rt_show(struct rt_show_data *);
 struct rt_show_data_rtable * rt_show_add_exporter(struct rt_show_data *d, struct rt_exporter *t, const char *name);
-struct rt_show_data_rtable * rt_show_add_table(struct rt_show_data *d, struct rtable *t);
+struct rt_show_data_rtable * rt_show_add_table(struct rt_show_data *d, rtable *t);
 
 /* Value of table definition mode in struct rt_show_data */
 #define RSD_TDB_DEFAULT	  0		/* no table specified */
@@ -602,7 +635,7 @@ struct hostentry_adata {
 };
 
 void
-ea_set_hostentry(ea_list **to, struct rtable *dep, struct rtable *tab, ip_addr gw, ip_addr ll, u32 lnum, u32 labels[lnum]);
+ea_set_hostentry(ea_list **to, rtable *dep, rtable *tab, ip_addr gw, ip_addr ll, u32 lnum, u32 labels[lnum]);
 
 void ea_show_hostentry(const struct adata *ad, byte *buf, uint size);
 void ea_show_nexthop_list(struct cli *c, struct nexthop_adata *nhad);
diff --git a/proto/bfd/bfd.c b/proto/bfd/bfd.c
index e7d27f74..331ba730 100644
--- a/proto/bfd/bfd.c
+++ b/proto/bfd/bfd.c
@@ -113,7 +113,6 @@
 #define HASH_IP_EQ(a1,n1,a2,n2)	ipa_equal(a1, a2) && n1 == n2
 #define HASH_IP_FN(a,n)		ipa_hash(a) ^ u32_hash(n)
 
-DEFINE_DOMAIN(rtable);
 #define BFD_LOCK	LOCK_DOMAIN(rtable, bfd_global.lock)
 #define BFD_UNLOCK	UNLOCK_DOMAIN(rtable, bfd_global.lock)
 
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index dcced164..bfdd9ac5 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -1981,9 +1981,20 @@ bgp_out_table_export_start(struct rt_exporter *re, struct rt_export_request *req
   rt_init_export(re, req->hook);
 }
 
+static void
+bgp_out_table_export_done(void *data)
+{
+  struct bgp_out_export_hook *hook = data;
+  struct rt_export_request *req = hook->h.req;
+  void (*stopped)(struct rt_export_request *) = hook->h.stopped;
+
+  rt_export_stopped(&hook->h);
+  CALL(stopped, req);
+}
+
 static const struct rt_exporter_class bgp_out_table_export_class = {
   .start = bgp_out_table_export_start,
-  .done = rt_export_stopped,
+  .done = bgp_out_table_export_done,
 };
 
 void
@@ -2519,7 +2530,7 @@ use_deterministic_med(struct rte_storage *r)
 }
 
 int
-bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best)
+bgp_rte_recalculate(struct rtable_private *table, net *net, rte *new, rte *old, rte *old_best)
 {
   rte *key = new ? new : old;
   u32 lpref = rt_get_preference(key);
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index 0cd327a2..1bcfb915 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -599,7 +599,7 @@ void bgp_done_prefix(struct bgp_channel *c, struct bgp_prefix *px, struct bgp_bu
 
 int bgp_rte_better(struct rte *, struct rte *);
 int bgp_rte_mergable(rte *pri, rte *sec);
-int bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best);
+int bgp_rte_recalculate(struct rtable_private *table, net *net, rte *new, rte *old, rte *old_best);
 void bgp_rte_modify_stale(struct rt_export_request *req, const net_addr *n, struct rt_pending_export *rpe UNUSED, rte **feed, uint count);
 u32 bgp_rte_igp_metric(const rte *);
 void bgp_rt_notify(struct proto *P, struct channel *C, const net_addr *n, rte *new, const rte *old);
diff --git a/proto/mrt/mrt.c b/proto/mrt/mrt.c
index f4c09ab1..f07f9ca2 100644
--- a/proto/mrt/mrt.c
+++ b/proto/mrt/mrt.c
@@ -228,7 +228,7 @@ mrt_next_table_(rtable *tab, rtable *tab_ptr, const char *pattern)
        NODE_VALID(tn);
        tn = tn->next)
   {
-    tab = SKIP_BACK(struct rtable, n, tn);
+    tab = SKIP_BACK(rtable, n, tn);
     if (patmatch(pattern, tab->name) &&
 	((tab->addr_type == NET_IP4) || (tab->addr_type == NET_IP6)))
       return tab;
@@ -243,13 +243,15 @@ mrt_next_table(struct mrt_table_dump_state *s)
   rtable *tab = mrt_next_table_(s->table, s->table_ptr, s->table_expr);
 
   if (s->table)
-    rt_unlock_table(s->table);
+    RT_LOCKED(s->table, tab)
+      rt_unlock_table(tab);
 
   s->table = tab;
   s->ipv4 = tab ? (tab->addr_type == NET_IP4) : 0;
 
   if (s->table)
-    rt_lock_table(s->table);
+    RT_LOCKED(s->table, tab)
+      rt_lock_table(tab);
 
   return s->table;
 }
@@ -573,14 +575,18 @@ mrt_table_dump_init(pool *pp)
 static void
 mrt_table_dump_free(struct mrt_table_dump_state *s)
 {
-  if (s->table_open)
-    FIB_ITERATE_UNLINK(&s->fit, &s->table->fib);
-
   if (s->table)
-    rt_unlock_table(s->table);
+    RT_LOCKED(s->table, tab)
+    {
+      if (s->table_open)
+	FIB_ITERATE_UNLINK(&s->fit, &tab->fib);
+
+      rt_unlock_table(tab);
+    }
 
   if (s->table_ptr)
-    rt_unlock_table(s->table_ptr);
+    RT_LOCKED(s->table_ptr, tab)
+      rt_unlock_table(tab);
 
   config_del_obstacle(s->config);
 
@@ -606,16 +612,19 @@ mrt_table_dump_step(struct mrt_table_dump_state *s)
 
     mrt_peer_table_dump(s);
 
-    FIB_ITERATE_INIT(&s->fit, &s->table->fib);
+    RT_LOCKED(s->table, tab)
+    {
+
+    FIB_ITERATE_INIT(&s->fit, &tab->fib);
     s->table_open = 1;
 
   step:
-    FIB_ITERATE_START(&s->table->fib, &s->fit, net, n)
+    FIB_ITERATE_START(&tab->fib, &s->fit, net, n)
     {
       if (s->max < 0)
       {
 	FIB_ITERATE_PUT(&s->fit);
-	return 0;
+	RT_RETURN(tab, 0);
       }
 
       /* With Always ADD_PATH option, we jump directly to second phase */
@@ -630,6 +639,8 @@ mrt_table_dump_step(struct mrt_table_dump_state *s)
     FIB_ITERATE_END;
     s->table_open = 0;
 
+    }
+
     mrt_close_file(s);
     mrt_peer_table_flush(s);
   }
@@ -661,7 +672,8 @@ mrt_timer(timer *t)
   s->always_add_path = cf->always_add_path;
 
   if (s->table_ptr)
-    rt_lock_table(s->table_ptr);
+    RT_LOCKED(s->table_ptr, tab)
+      rt_lock_table(tab);
 
   p->table_dump = s;
   ev_schedule(p->event);
@@ -737,7 +749,8 @@ mrt_dump_cmd(struct mrt_dump_data *d)
   s->filename = d->filename;
 
   if (s->table_ptr)
-    rt_lock_table(s->table_ptr);
+    RT_LOCKED(s->table_ptr, tab)
+      rt_lock_table(tab);
 
   this_cli->cont = mrt_dump_cont;
   this_cli->cleanup = mrt_dump_cleanup;
diff --git a/proto/mrt/mrt.h b/proto/mrt/mrt.h
index 3b83aa39..f535a391 100644
--- a/proto/mrt/mrt.h
+++ b/proto/mrt/mrt.h
@@ -40,7 +40,7 @@ struct mrt_proto {
 
 struct mrt_dump_data {
   const char *table_expr;
-  struct rtable *table_ptr;
+  rtable *table_ptr;
   const struct filter *filter;
   const char *filename;
 };
@@ -60,7 +60,7 @@ struct mrt_table_dump_state {
 
 					/* Configuration information */
   const char *table_expr;		/* Wildcard for table name (or NULL) */
-  struct rtable *table_ptr;		/* Explicit table (or NULL) */
+  rtable *table_ptr;			/* Explicit table (or NULL) */
   const struct filter *filter;		/* Optional filter */
   const char *filename;			/* Filename pattern */
   int always_add_path;			/* Always use *_ADDPATH message subtypes */
@@ -73,7 +73,7 @@ struct mrt_table_dump_state {
 
   HASH(struct mrt_peer_entry) peer_hash; /* Hash for peers to find the index */
 
-  struct rtable *table;			/* Processed table, NULL initially */
+  rtable *table;			/* Processed table, NULL initially */
   struct fib_iterator fit;		/* Iterator in processed table */
   int table_open;			/* Whether iterator is linked */
 
diff --git a/proto/perf/perf.c b/proto/perf/perf.c
index d82ac8aa..9adafe5a 100644
--- a/proto/perf/perf.c
+++ b/proto/perf/perf.c
@@ -202,7 +202,9 @@ perf_loop(void *data)
     p->exp++;
   }
 
-  rt_schedule_prune(P->main_channel->table);
+  RT_LOCKED(P->main_channel->table, tab)
+    rt_schedule_prune(tab);
+
   ev_schedule(p->loop);
 }
 
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index cfa9b1ee..d507c133 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -366,6 +366,13 @@ rte_feed_obtain(net *n, rte **feed, uint count)
 static struct rte *
 krt_export_net(struct krt_proto *p, net *net)
 {
+  /* FIXME: Here we are calling filters in table-locked context when exporting
+   * to kernel. Here BIRD can crash if the user requested ROA check in kernel
+   * export filter. It doesn't make much sense to write the filters like this,
+   * therefore we may keep this unfinished piece of work here for later as it
+   * won't really affect anybody. */
+  ASSERT_DIE(RT_IS_LOCKED(p->p.main_channel->table));
+
   struct channel *c = p->p.main_channel;
   const struct filter *filter = c->out_filter;
 
@@ -446,6 +453,9 @@ krt_got_route(struct krt_proto *p, rte *e, s8 src)
 #endif
   /* The rest is for KRT_SRC_BIRD (or KRT_SRC_UNKNOWN) */
 
+  RT_LOCKED(p->p.main_channel->table, tab)
+  {
+
   /* Deleting all routes if flush is requested */
   if (p->flush_routes)
     goto delete;
@@ -454,7 +464,7 @@ krt_got_route(struct krt_proto *p, rte *e, s8 src)
   if (!p->ready)
     goto ignore;
 
-  net *net = net_find(p->p.main_channel->table, e->net);
+  net *net = net_find(tab, e->net);
   if (!net || !krt_is_installed(p, net))
     goto delete;
 
@@ -499,7 +509,9 @@ delete:
   krt_replace_rte(p, e->net, NULL, e);
   goto done;
 
-done:
+done:;
+  }
+
   lp_flush(krt_filter_lp);
 }
 
@@ -512,7 +524,8 @@ krt_init_scan(struct krt_proto *p)
 static void
 krt_prune(struct krt_proto *p)
 {
-  struct rtable *t = p->p.main_channel->table;
+  RT_LOCKED(p->p.main_channel->table, t)
+  {
 
   KRT_TRACE(p, D_EVENTS, "Pruning table %s", t->name);
   FIB_WALK(&t->fib, net, n)
@@ -534,6 +547,8 @@ krt_prune(struct krt_proto *p)
 
   if (p->ready)
     p->initialized = 1;
+
+  }
 }
 
 static void
-- 
cgit v1.2.3