1 files changed, 174 insertions, 78 deletions

diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index e4d754b1..65cc3a40 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -124,11 +124,8 @@
 
 #include "bgp.h"
 
-
-struct linpool *bgp_linpool;		/* Global temporary pool */
-struct linpool *bgp_linpool2;		/* Global temporary pool for bgp_rt_notify() */
-static list bgp_sockets;		/* Global list of listening sockets */
-
+/* Global list of listening sockets */
+static list STATIC_LIST_INIT(bgp_sockets);
 
 static void bgp_connect(struct bgp_proto *p);
 static void bgp_active(struct bgp_proto *p);
@@ -140,6 +137,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
@@ -152,16 +158,14 @@ static void bgp_listen_sock_err(sock *sk UNUSED, int err);
 static int
 bgp_open(struct bgp_proto *p)
 {
+  ASSERT_DIE(birdloop_inside(&main_birdloop));
+
   struct bgp_socket *bs = NULL;
   struct iface *ifa = p->cf->strict_bind ? p->cf->iface : NULL;
   ip_addr addr = p->cf->strict_bind ? p->cf->local_ip :
     (p->ipv4 ? IPA_NONE4 : IPA_NONE6);
   uint port = p->cf->local_port;
 
-  /* FIXME: Add some global init? */
-  if (!bgp_linpool)
-    init_list(&bgp_sockets);
-
   /* We assume that cf->iface is defined iff cf->local_ip is link-local */
 
   WALK_LIST(bs, bgp_sockets)
@@ -180,7 +184,7 @@ bgp_open(struct bgp_proto *p)
   sk->sport = port;
   sk->iface = ifa;
   sk->vrf = p->p.vrf;
-  sk->flags = 0;
+  sk->flags = SKF_PASSIVE_THREAD;
   sk->tos = IP_PREC_INTERNET_CONTROL;
   sk->rbsize = BGP_RX_BUFFER_SIZE;
   sk->tbsize = BGP_TX_BUFFER_SIZE;
@@ -198,12 +202,6 @@ bgp_open(struct bgp_proto *p)
 
   add_tail(&bgp_sockets, &bs->n);
 
-  if (!bgp_linpool)
-  {
-    bgp_linpool  = lp_new_default(proto_pool);
-    bgp_linpool2 = lp_new_default(proto_pool);
-  }
-
   return 0;
 
 err:
@@ -222,6 +220,7 @@ err:
 static void
 bgp_close(struct bgp_proto *p)
 {
+  ASSERT_DIE(birdloop_inside(&main_birdloop));
   struct bgp_socket *bs = p->sock;
 
   ASSERT(bs && bs->uc);
@@ -232,15 +231,6 @@ bgp_close(struct bgp_proto *p)
   rfree(bs->sk);
   rem_node(&bs->n);
   mb_free(bs);
-
-  if (!EMPTY_LIST(bgp_sockets))
-    return;
-
-  rfree(bgp_linpool);
-  bgp_linpool = NULL;
-
-  rfree(bgp_linpool2);
-  bgp_linpool2 = NULL;
 }
 
 static inline int
@@ -325,7 +315,7 @@ bgp_initiate(struct bgp_proto *p)
   {
     p->start_state = BSS_DELAY;
     BGP_TRACE(D_EVENTS, "Startup delayed by %d seconds due to errors", p->startup_delay);
-    bgp_start_timer(p->startup_timer, p->startup_delay);
+    bgp_start_timer(p, p->startup_timer, p->startup_delay);
   }
   else
     bgp_startup(p);
@@ -346,6 +336,7 @@ err1:
 
 /**
  * bgp_start_timer - start a BGP timer
+ * @p: bgp_proto which the timer belongs to
  * @t: timer
  * @value: time (in seconds) to fire (0 to disable the timer)
  *
@@ -354,14 +345,16 @@ err1:
  * timers.
  */
 void
-bgp_start_timer(timer *t, uint value)
+bgp_start_timer(struct bgp_proto *p, timer *t, uint value)
 {
+  BGP_ASSERT_INSIDE(p);
+
   if (value)
   {
     /* The randomization procedure is specified in RFC 4271 section 10 */
     btime time = value S;
     btime randomize = random() % ((time / 4) + 1);
-    tm_start(t, time - randomize);
+    tm_start_in(t, time - randomize, p->p.loop);
   }
   else
     tm_stop(t);
@@ -377,7 +370,7 @@ bgp_start_timer(timer *t, uint value)
 void
 bgp_close_conn(struct bgp_conn *conn)
 {
-  // struct bgp_proto *p = conn->bgp;
+  BGP_ASSERT_INSIDE(conn->bgp);
 
   DBG("BGP: Closing connection\n");
   conn->packets_to_send = 0;
@@ -469,6 +462,8 @@ bgp_graceful_close_conn(struct bgp_conn *conn, int subcode, byte *data, uint len
 static void
 bgp_down(struct bgp_proto *p)
 {
+  bgp_start_timer(p, p->startup_timer, 0);
+
   if (p->start_state > BSS_PREPARE)
   {
     bgp_setup_auth(p, 0);
@@ -482,21 +477,34 @@ bgp_down(struct bgp_proto *p)
 }
 
 static void
-bgp_decision(void *vp)
+bgp_active_event(void *vp)
 {
   struct bgp_proto *p = vp;
 
-  DBG("BGP: Decision start\n");
+  BGP_ASSERT_INSIDE(p);
+
+  DBG("%s: Decision start\n", p->p.name);
   if ((p->p.proto_state == PS_START) &&
       (p->outgoing_conn.state == BS_IDLE) &&
       (p->incoming_conn.state != BS_OPENCONFIRM) &&
       !p->passive)
     bgp_active(p);
+}
+
+static void
+bgp_down_event(void *vp)
+{
+  struct bgp_proto *p = vp;
 
+  BGP_ENTER(p);
+
+  DBG("%s: Down event\n", p->p.name);
   if ((p->p.proto_state == PS_STOP) &&
       (p->outgoing_conn.state == BS_IDLE) &&
       (p->incoming_conn.state == BS_IDLE))
     bgp_down(p);
+
+  BGP_LEAVE(p);
 }
 
 static struct bgp_proto *
@@ -528,7 +536,7 @@ bgp_stop(struct bgp_proto *p, int subcode, byte *data, uint len)
   proto_notify_state(&p->p, PS_STOP);
   bgp_graceful_close_conn(&p->outgoing_conn, subcode, data, len);
   bgp_graceful_close_conn(&p->incoming_conn, subcode, data, len);
-  ev_schedule(p->event);
+  ev_send_loop(&main_birdloop, p->down_event);
 }
 
 static inline void
@@ -575,6 +583,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;
@@ -719,7 +728,7 @@ bgp_conn_enter_close_state(struct bgp_conn *conn)
   conn->sk->rx_hook = NULL;
 
   /* Timeout for CLOSE state, if we cannot send notification soon then we just hangup */
-  bgp_start_timer(conn->hold_timer, 10);
+  bgp_start_timer(p, conn->hold_timer, 10);
 
   if (os == BS_ESTABLISHED)
     bgp_conn_leave_established_state(p);
@@ -733,7 +742,8 @@ bgp_conn_enter_idle_state(struct bgp_conn *conn)
 
   bgp_close_conn(conn);
   bgp_conn_set_state(conn, BS_IDLE);
-  ev_schedule(p->event);
+  ev_send_loop(p->p.loop, p->active_event);
+  ev_send_loop(&main_birdloop, p->down_event);
 
   if (os == BS_ESTABLISHED)
     bgp_conn_leave_established_state(p);
@@ -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 */
@@ -808,9 +818,54 @@ bgp_handle_graceful_restart(struct bgp_proto *p)
   ASSERT(p->gr_active_num > 0);
 
   proto_notify_state(&p->p, PS_START);
-  tm_start(p->gr_timer, p->conn->remote_caps->gr_time S);
+  tm_start_in(p->gr_timer, p->conn->remote_caps->gr_time S, p->p.loop);
+}
+
+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);
 }
 
 /**
@@ -875,8 +933,8 @@ 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);
+      tm_start_in(c->stale_timer, c->stale_time S, p->p.loop);
+      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);
 }
 
 
@@ -955,7 +1010,7 @@ bgp_send_open(struct bgp_conn *conn)
   bgp_prepare_capabilities(conn);
   bgp_schedule_packet(conn, NULL, PKT_OPEN);
   bgp_conn_set_state(conn, BS_OPENSENT);
-  bgp_start_timer(conn->hold_timer, conn->bgp->cf->initial_hold_time);
+  bgp_start_timer(conn->bgp, conn->hold_timer, conn->bgp->cf->initial_hold_time);
 }
 
 static void
@@ -1032,7 +1087,7 @@ bgp_hold_timeout(timer *t)
      and perhaps just not processed BGP packets in time. */
 
   if (sk_rx_ready(conn->sk) > 0)
-    bgp_start_timer(conn->hold_timer, 10);
+    bgp_start_timer(p, conn->hold_timer, 10);
   else if ((conn->state == BS_ESTABLISHED) && p->llgr_ready)
   {
     BGP_TRACE(D_EVENTS, "Hold timer expired");
@@ -1077,10 +1132,12 @@ bgp_setup_conn(struct bgp_proto *p, struct bgp_conn *conn)
 static void
 bgp_setup_sk(struct bgp_conn *conn, sock *s)
 {
+  ASSERT_DIE(s->flags & SKF_THREAD);
   s->data = conn;
   s->err_hook = bgp_sock_err;
   s->fast_rx = 1;
   conn->sk = s;
+  sk_start(s);
 }
 
 static void
@@ -1089,10 +1146,12 @@ bgp_active(struct bgp_proto *p)
   int delay = MAX(1, p->cf->connect_delay_time);
   struct bgp_conn *conn = &p->outgoing_conn;
 
+  BGP_ASSERT_INSIDE(p);
+
   BGP_TRACE(D_EVENTS, "Connect delayed by %d seconds", delay);
   bgp_setup_conn(p, conn);
   bgp_conn_set_state(conn, BS_ACTIVE);
-  bgp_start_timer(conn->connect_timer, delay);
+  bgp_start_timer(p, conn->connect_timer, delay);
 }
 
 /**
@@ -1109,9 +1168,12 @@ bgp_connect(struct bgp_proto *p)	/* Enter Connect state and start establishing c
   struct bgp_conn *conn = &p->outgoing_conn;
   int hops = p->cf->multihop ? : 1;
 
+  BGP_ASSERT_INSIDE(p);
+
   DBG("BGP: Connecting\n");
   sock *s = sk_new(p->p.pool);
   s->type = SK_TCP_ACTIVE;
+  s->flags |= SKF_THREAD;
   s->saddr = p->local_ip;
   s->daddr = p->remote_ip;
   s->dport = p->cf->remote_port;
@@ -1139,7 +1201,7 @@ bgp_connect(struct bgp_proto *p)	/* Enter Connect state and start establishing c
       goto err;
 
   DBG("BGP: Waiting for connect success\n");
-  bgp_start_timer(conn->connect_timer, p->cf->connect_retry_time);
+  bgp_start_timer(p, conn->connect_timer, p->cf->connect_retry_time);
   return;
 
 err:
@@ -1211,6 +1273,18 @@ bgp_incoming_connection(sock *sk, uint dummy UNUSED)
     return 0;
   }
 
+  if (p->p.loop == &main_birdloop)
+  {
+    /* Protocol is down for whatever reason. No need for locking. */
+    BGP_TRACE(D_EVENTS, "Incoming connection from %I%J (port %d) rejected (protocol is down)",
+	    sk->daddr, ipa_is_link_local(sk->daddr) ? sk->iface : NULL,
+	    sk->dport);
+    rfree(sk);
+    return 0;
+  }
+
+  BGP_ENTER(p);
+
   /*
    * BIRD should keep multiple incoming connections in OpenSent state (for
    * details RFC 4271 8.2.1 par 3), but it keeps just one. Duplicate incoming
@@ -1240,6 +1314,7 @@ bgp_incoming_connection(sock *sk, uint dummy UNUSED)
   if (!acc)
   {
     rfree(sk);
+    BGP_LEAVE(p);
     return 0;
   }
 
@@ -1265,6 +1340,7 @@ bgp_incoming_connection(sock *sk, uint dummy UNUSED)
     p = bgp_spawn(p, sk->daddr);
     p->postponed_sk = sk;
     rmove(sk, p->p.pool);
+    BGP_LEAVE(p);
     return 0;
   }
 
@@ -1272,12 +1348,14 @@ bgp_incoming_connection(sock *sk, uint dummy UNUSED)
   bgp_setup_conn(p, &p->incoming_conn);
   bgp_setup_sk(&p->incoming_conn, sk);
   bgp_send_open(&p->incoming_conn);
+  BGP_LEAVE(p);
   return 0;
 
 err:
   sk_log_error(sk, p->p.name);
   log(L_ERR "%s: Incoming connection aborted", p->p.name);
   rfree(sk);
+  BGP_LEAVE(p);
   return 0;
 }
 
@@ -1312,10 +1390,9 @@ bgp_neigh_notify(neighbor *n)
   struct bgp_proto *p = (struct bgp_proto *) n->proto;
   int ps = p->p.proto_state;
 
-  if (n != p->neigh)
-    return;
+  BGP_ASSERT_INSIDE(p);
 
-  if ((ps == PS_DOWN) || (ps == PS_STOP))
+  if ((n != p->neigh) || (ps == PS_DOWN) || (ps == PS_STOP))
     return;
 
   int prepare = (ps == PS_START) && (p->start_state == BSS_PREPARE);
@@ -1393,7 +1470,7 @@ bgp_update_bfd(struct bgp_proto *p, const struct bfd_options *bfd)
   if (bfd && !p->bfd_req && !bgp_is_dynamic(p))
     p->bfd_req = bfd_request_session(p->p.pool, p->remote_ip, p->local_ip,
 				     p->cf->multihop ? NULL : p->neigh->iface,
-				     p->p.vrf, bgp_bfd_notify, p, bfd);
+				     p->p.vrf, bgp_bfd_notify, p, birdloop_event_list(p->p.loop), bfd);
 
   if (!bfd && p->bfd_req)
   {
@@ -1408,12 +1485,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
@@ -1474,9 +1548,12 @@ bgp_start_locked(struct object_lock *lock)
   struct bgp_proto *p = lock->data;
   const struct bgp_config *cf = p->cf;
 
+  BGP_ENTER(p);
+
   if (p->p.proto_state != PS_START)
   {
     DBG("BGP: Got lock in different state %d\n", p->p.proto_state);
+    BGP_LEAVE(p);
     return;
   }
 
@@ -1486,10 +1563,11 @@ bgp_start_locked(struct object_lock *lock)
   {
     /* Multi-hop sessions do not use neighbor entries */
     bgp_initiate(p);
+    BGP_LEAVE(p);
     return;
   }
 
-  neighbor *n = neigh_find(&p->p, p->remote_ip, cf->iface, NEF_STICKY);
+  neighbor *n = neigh_find(&p->p, p->remote_ip, cf->iface, NEF_STICKY | NEF_NOTIFY_MAIN);
   if (!n)
   {
     log(L_ERR "%s: Invalid remote address %I%J", p->p.name, p->remote_ip, cf->iface);
@@ -1497,6 +1575,7 @@ bgp_start_locked(struct object_lock *lock)
     p->p.disabled = 1;
     bgp_store_error(p, NULL, BE_MISC, BEM_INVALID_NEXT_HOP);
     proto_notify_state(&p->p, PS_DOWN);
+    BGP_LEAVE(p);
     return;
   }
 
@@ -1508,6 +1587,8 @@ bgp_start_locked(struct object_lock *lock)
     BGP_TRACE(D_EVENTS, "Waiting for link on %s", n->iface->name);
   else
     bgp_start_neighbor(p);
+
+  BGP_LEAVE(p);
 }
 
 static int
@@ -1546,10 +1627,13 @@ bgp_start(struct proto *P)
   p->stats.rx_bytes = p->stats.tx_bytes = 0;
   p->last_rx_update = 0;
 
-  p->event = ev_new_init(p->p.pool, bgp_decision, p);
+  p->active_event = ev_new_init(p->p.pool, bgp_active_event, p);
+  p->down_event = ev_new_init(p->p.pool, bgp_down_event, p);
   p->startup_timer = tm_new_init(p->p.pool, bgp_startup_timeout, p, 0, 0);
   p->gr_timer = tm_new_init(p->p.pool, bgp_graceful_restart_timeout, p, 0, 0);
 
+  p->rx_lp = lp_new_default(p->p.pool);
+
   p->local_id = proto_get_router_id(P->cf);
   if (p->rr_client)
     p->rr_cluster_id = p->cf->rr_cluster_id ? p->cf->rr_cluster_id : p->local_id;
@@ -1677,6 +1761,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 +1781,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 +1835,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 +1921,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;
 
@@ -2430,6 +2524,9 @@ bgp_show_proto_info(struct proto *P)
 {
   struct bgp_proto *p = (struct bgp_proto *) P;
 
+  if (p->p.proto_state != PS_DOWN)
+    BGP_ASSERT_INSIDE(p);
+
   cli_msg(-1006, "  BGP state:          %s", bgp_state_dsc(p));
 
   if (bgp_is_dynamic(p) && p->cf->remote_range)
@@ -2556,6 +2653,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
 };