1 files changed, 93 insertions, 32 deletions

diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index e4d754b1..b825f778 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -140,6 +140,15 @@ static void bgp_update_bfd(struct bgp_proto *p, const struct bfd_options *bfd);
 static int bgp_incoming_connection(sock *sk, uint dummy UNUSED);
 static void bgp_listen_sock_err(sock *sk UNUSED, int err);
 
+static void bgp_graceful_restart_feed(struct bgp_channel *c);
+static inline void channel_refresh_end_reload(struct channel *c)
+{
+  channel_refresh_end(c);
+
+  if (c->in_table)
+    channel_request_reload(c);
+}
+
 /**
  * bgp_open - open a BGP instance
  * @p: BGP instance
@@ -575,6 +584,7 @@ bgp_conn_enter_established_state(struct bgp_conn *conn)
     p->link_addr = p->neigh->iface->llv6->ip;
 
   conn->sk->fast_rx = 0;
+  conn->sk->cork = &rt_cork;
 
   p->conn = conn;
   p->last_error_class = 0;
@@ -775,25 +785,25 @@ bgp_handle_graceful_restart(struct bgp_proto *p)
       {
       case BGP_GRS_NONE:
 	c->gr_active = BGP_GRS_ACTIVE;
-	rt_refresh_begin(c->c.table, &c->c);
+	channel_refresh_begin(&c->c);
 	break;
 
       case BGP_GRS_ACTIVE:
-	rt_refresh_end(c->c.table, &c->c);
-	rt_refresh_begin(c->c.table, &c->c);
+	channel_refresh_end(&c->c);
+	channel_refresh_begin(&c->c);
 	break;
 
       case BGP_GRS_LLGR:
-	rt_refresh_begin(c->c.table, &c->c);
-	rt_modify_stale(c->c.table, &c->c);
+	channel_refresh_begin(&c->c);
+	bgp_graceful_restart_feed(c);
 	break;
       }
     }
     else
     {
       /* Just flush the routes */
-      rt_refresh_begin(c->c.table, &c->c);
-      rt_refresh_end(c->c.table, &c->c);
+      channel_refresh_begin(&c->c);
+      channel_refresh_end(&c->c);
     }
 
     /* Reset bucket and prefix tables */
@@ -811,6 +821,51 @@ bgp_handle_graceful_restart(struct bgp_proto *p)
   tm_start(p->gr_timer, p->conn->remote_caps->gr_time S);
 }
 
+static void
+bgp_graceful_restart_feed_done(struct rt_export_request *req)
+{
+  req->hook = NULL;
+}
+
+static void
+bgp_graceful_restart_feed_dump_req(struct rt_export_request *req)
+{
+  struct bgp_channel *c = SKIP_BACK(struct bgp_channel, stale_feed, req);
+  debug("  BGP-GR %s.%s export request %p\n", c->c.proto->name, c->c.name, req);
+}
+
+static void
+bgp_graceful_restart_feed_log_state_change(struct rt_export_request *req, u8 state)
+{
+  struct bgp_channel *c = SKIP_BACK(struct bgp_channel, stale_feed, req);
+  struct bgp_proto *p = (void *) c->c.proto;
+  BGP_TRACE(D_EVENTS, "Long-lived graceful restart export state changed to %s", rt_export_state_name(state));
+
+  if (state == TES_READY)
+    rt_stop_export(req, bgp_graceful_restart_feed_done);
+}
+
+static void
+bgp_graceful_restart_drop_export(struct rt_export_request *req UNUSED, const net_addr *n UNUSED, struct rt_pending_export *rpe UNUSED)
+{ /* Nothing to do */ }
+
+static void
+bgp_graceful_restart_feed(struct bgp_channel *c)
+{
+  c->stale_feed = (struct rt_export_request) {
+    .name = "BGP-GR",
+    .list = &global_work_list,
+    .trace_routes = c->c.debug | c->c.proto->debug,
+    .dump_req = bgp_graceful_restart_feed_dump_req,
+    .log_state_change = bgp_graceful_restart_feed_log_state_change,
+    .export_bulk = bgp_rte_modify_stale,
+    .export_one = bgp_graceful_restart_drop_export,
+  };
+
+  rt_request_export(c->c.table, &c->stale_feed);
+}
+
+
 /**
  * bgp_graceful_restart_done - finish active BGP graceful restart
  * @c: BGP channel
@@ -833,8 +888,11 @@ bgp_graceful_restart_done(struct bgp_channel *c)
   if (!p->gr_active_num)
     BGP_TRACE(D_EVENTS, "Neighbor graceful restart done");
 
+  if (c->stale_feed.hook)
+    rt_stop_export(&c->stale_feed, bgp_graceful_restart_feed_done);
+
   tm_stop(c->stale_timer);
-  rt_refresh_end(c->c.table, &c->c);
+  channel_refresh_end_reload(&c->c);
 }
 
 /**
@@ -876,7 +934,7 @@ bgp_graceful_restart_timeout(timer *t)
       /* Channel is in GR, and supports LLGR -> start LLGR */
       c->gr_active = BGP_GRS_LLGR;
       tm_start(c->stale_timer, c->stale_time S);
-      rt_modify_stale(c->c.table, &c->c);
+      bgp_graceful_restart_feed(c);
     }
   }
   else
@@ -913,11 +971,11 @@ bgp_refresh_begin(struct bgp_channel *c)
   if (c->load_state == BFS_LOADING)
   { log(L_WARN "%s: BEGIN-OF-RR received before END-OF-RIB, ignoring", p->p.name); return; }
 
-  c->load_state = BFS_REFRESHING;
-  rt_refresh_begin(c->c.table, &c->c);
+  if (c->load_state == BFS_REFRESHING)
+    channel_refresh_end(&c->c);
 
-  if (c->c.in_table)
-    rt_refresh_begin(c->c.in_table, &c->c);
+  c->load_state = BFS_REFRESHING;
+  channel_refresh_begin(&c->c);
 }
 
 /**
@@ -938,10 +996,7 @@ bgp_refresh_end(struct bgp_channel *c)
   { log(L_WARN "%s: END-OF-RR received without prior BEGIN-OF-RR, ignoring", p->p.name); return; }
 
   c->load_state = BFS_NONE;
-  rt_refresh_end(c->c.table, &c->c);
-
-  if (c->c.in_table)
-    rt_prune_sync(c->c.in_table, 0);
+  channel_refresh_end_reload(&c->c);
 }
 
 
@@ -1408,12 +1463,9 @@ bgp_reload_routes(struct channel *C)
   struct bgp_proto *p = (void *) C->proto;
   struct bgp_channel *c = (void *) C;
 
-  ASSERT(p->conn && (p->route_refresh || c->c.in_table));
+  ASSERT(p->conn && (p->route_refresh));
 
-  if (c->c.in_table)
-    channel_schedule_reload(C);
-  else
-    bgp_schedule_packet(p->conn, c, PKT_ROUTE_REFRESH);
+  bgp_schedule_packet(p->conn, c, PKT_ROUTE_REFRESH);
 }
 
 static void
@@ -1677,6 +1729,13 @@ done:
   return p->p.proto_state;
 }
 
+struct rte_owner_class bgp_rte_owner_class = {
+  .get_route_info = 	bgp_get_route_info,
+  .rte_better =		bgp_rte_better,
+  .rte_mergable =	bgp_rte_mergable,
+  .rte_igp_metric =	bgp_rte_igp_metric,
+};
+
 static struct proto *
 bgp_init(struct proto_config *CF)
 {
@@ -1690,10 +1749,9 @@ bgp_init(struct proto_config *CF)
   P->reload_routes = bgp_reload_routes;
   P->feed_begin = bgp_feed_begin;
   P->feed_end = bgp_feed_end;
-  P->rte_better = bgp_rte_better;
-  P->rte_mergable = bgp_rte_mergable;
-  P->rte_recalculate = cf->deterministic_med ? bgp_rte_recalculate : NULL;
-  P->rte_modify = bgp_rte_modify_stale;
+
+  P->sources.class = &bgp_rte_owner_class;
+  P->sources.rte_recalculate = cf->deterministic_med ? bgp_rte_recalculate : NULL;
 
   p->cf = cf;
   p->is_internal = (cf->local_as == cf->remote_as);
@@ -1745,17 +1803,19 @@ bgp_channel_start(struct channel *C)
   ip_addr src = p->local_ip;
 
   if (c->igp_table_ip4)
-    rt_lock_table(c->igp_table_ip4);
+    RT_LOCKED(c->igp_table_ip4, t)
+      rt_lock_table(t);
 
   if (c->igp_table_ip6)
-    rt_lock_table(c->igp_table_ip6);
+    RT_LOCKED(c->igp_table_ip6, t)
+      rt_lock_table(t);
 
   c->pool = p->p.pool; // XXXX
   bgp_init_bucket_table(c);
   bgp_init_prefix_table(c);
 
   if (c->cf->import_table)
-    channel_setup_in_table(C);
+    channel_setup_in_table(C, 0);
 
   if (c->cf->export_table)
     channel_setup_out_table(C);
@@ -1829,10 +1889,12 @@ bgp_channel_cleanup(struct channel *C)
   struct bgp_channel *c = (void *) C;
 
   if (c->igp_table_ip4)
-    rt_unlock_table(c->igp_table_ip4);
+    RT_LOCKED(c->igp_table_ip4, t)
+      rt_unlock_table(t);
 
   if (c->igp_table_ip6)
-    rt_unlock_table(c->igp_table_ip6);
+    RT_LOCKED(c->igp_table_ip6, t)
+      rt_unlock_table(t);
 
   c->index = 0;
 
@@ -2556,6 +2618,5 @@ struct protocol proto_bgp = {
   .copy_config = 	bgp_copy_config,
   .get_status = 	bgp_get_status,
   .get_attr = 		bgp_get_attr,
-  .get_route_info = 	bgp_get_route_info,
   .show_proto_info = 	bgp_show_proto_info
 };