list hooks; /* List of announcement hooks */
int pipe_busy; /* Pipe loop detection */
int use_count; /* Number of protocols using this table */
+ 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.
*/
- struct event *gc_event; /* Garbage collector event */
+ struct event *rt_event; /* Routing table event */
int gc_counter; /* Number of operations since last GC */
bird_clock_t gc_time; /* Time of last GC */
+ byte gc_scheduled; /* GC is scheduled */
+ byte hcu_scheduled; /* Hostcache update is scheduled */
+ byte nhu_state; /* Next Hop Update state */
+ struct fib_iterator nhu_fit; /* Next Hop Update FIB iterator */
} rtable;
typedef struct network {
struct rte *routes; /* Available routes for this network */
} net;
+struct hostcache {
+ struct fib htable;
+ list hostentries;
+ byte update_hostcache;
+};
+
+struct hostentry {
+ struct fib_node fn;
+ node ln;
+ unsigned uc; /* Use count */
+ struct iface *iface; /* Chosen outgoing interface */
+ ip_addr gw; /* Chosen next hop */
+ byte dest; /* Chosen route destination type (RTD_...) */
+ byte pxlen; /* Pxlen from net that matches route */
+ struct rtable *tab;
+};
+
typedef struct rte {
struct rte *next;
net *net; /* Network this RTE belongs to */
void rt_dump_all(void);
int rt_feed_baby(struct proto *p);
void rt_feed_baby_abort(struct proto *p);
-void rt_prune(rtable *tab);
void rt_prune_all(void);
struct rtable_config *rt_new_table(struct symbol *s);
u16 hash_key; /* Hash over important fields */
ip_addr gw; /* Next hop */
ip_addr from; /* Advertising router */
+ struct hostentry *hostentry; /* Hostentry for recursive next-hops */
struct iface *iface; /* Outgoing interface */
struct ea_list *eattrs; /* Extended Attribute chain */
} rta;
void rta_dump(rta *);
void rta_dump_all(void);
void rta_show(struct cli *, rta *, ea_list *);
+void rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr *gw);
+
+/*
+ * rta_set_recursive_next_hop() acquires hostentry from hostcache and
+ * fills rta->hostentry field. New hostentry has zero use
+ * count. Cached rta locks its hostentry (increases its use count),
+ * uncached rta does not lock it. Hostentry with zero use count is
+ * removed asynchronously during host cache update, therefore it is
+ * safe to hold such hostentry temorarily. There is no need to hold
+ * a lock for hostentry->dep table, because that table contains routes
+ * responsible for that hostentry, and therefore is non-empty if given
+ * hostentry has non-zero use count. The protocol responsible for routes
+ * with recursive next hops should also hold a lock for a table governing
+ * that routes (argument tab to rta_set_recursive_next_hop()).
+ */
+
+static inline void rt_lock_hostentry(struct hostentry *he) { if (he) he->uc++; }
+static inline void rt_unlock_hostentry(struct hostentry *he) { if (he) he->uc--; }
+
extern struct protocol *attr_class_to_protocol[EAP_MAX];
static list routing_tables;
static void rt_format_via(rte *e, byte *via);
+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_next_hop_update(rtable *tab);
+static void rt_prune(rtable *tab);
+
+static inline void rt_schedule_gc(rtable *tab);
static void
rte_init(struct fib_node *N)
* This is a tricky part - we don't know whether route 'old' was
* exported to protocol 'p' or was filtered by the export filter.
* We try tu run the export filter to know this to have a correct
- * value in 'old' argument of rt_update (and proper filter value)
+ * value in 'old' argument of rte_update (and proper filter value)
*
* FIXME - this is broken because 'configure soft' may change
* filters but keep routes. Refeed is expected to be called after
new->attrs->proto->stats.pref_routes++;
if (old)
old->attrs->proto->stats.pref_routes--;
+
+ if (tab->hostcache)
+ rt_notify_hostcache(tab, net);
}
WALK_LIST(a, tab->hooks)
}
}
+
static inline int
rte_validate(rte *e)
{
rte_announce(table, RA_ANY, net, new, old, tmpa);
-
if (new && rte_better(new, old_best))
{
/* The first case - the new route is cleary optimal, we link it
}
else if (table->gc_counter++ >= table->config->gc_max_ops &&
table->gc_time + table->config->gc_min_time <= now)
- ev_schedule(table->gc_event);
+ rt_schedule_gc(table);
}
else if (new)
{
rte_update_unlock();
}
+/* Independent call to rte_announce(), used from next hop
+ recalculation, outside of rte_update(). new must be non-NULL */
+static inline void
+rte_announce_i(rtable *tab, unsigned type, net *n, rte *new, rte *old)
+{
+ struct proto *src;
+ ea_list *tmpa;
+
+ rte_update_lock();
+ src = new->attrs->proto;
+ tmpa = src->make_tmp_attrs ? src->make_tmp_attrs(new, rte_update_pool) : NULL;
+ rte_announce(tab, type, n, new, old, tmpa);
+ rte_update_unlock();
+}
+
void
rte_discard(rtable *t, rte *old) /* Non-filtered route deletion, used during garbage collection */
{
rt_dump(t);
}
+static inline void
+rt_schedule_gc(rtable *tab)
+{
+ if (tab->gc_scheduled)
+ return;
+
+ tab->gc_scheduled = 1;
+ ev_schedule(tab->rt_event);
+}
+
+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)
+{
+ if (tab->nhu_state == 0)
+ ev_schedule(tab->rt_event);
+
+ /* state change 0->1, 2->3 */
+ tab->nhu_state |= 1;
+}
+
static void
-rt_gc(void *tab)
+rt_event(void *ptr)
{
- rtable *t = tab;
+ rtable *tab = ptr;
+
+ if (tab->hcu_scheduled)
+ rt_update_hostcache(tab);
+
+ if (tab->nhu_state)
+ rt_next_hop_update(tab);
- DBG("Entered routing table garbage collector for %s after %d seconds and %d deletes\n",
- t->name, (int)(now - t->gc_time), t->gc_counter);
- rt_prune(t);
+ if (tab->gc_scheduled)
+ rt_prune(tab);
}
void
init_list(&t->hooks);
if (cf)
{
- t->gc_event = ev_new(p);
- t->gc_event->hook = rt_gc;
- t->gc_event->data = t;
+ t->rt_event = ev_new(p);
+ t->rt_event->hook = rt_event;
+ t->rt_event->data = t;
t->gc_time = now;
}
}
* the routing table and removes all routes belonging to inactive
* protocols and also stale network entries.
*/
-void
+static void
rt_prune(rtable *tab)
{
struct fib_iterator fit;
#endif
tab->gc_counter = 0;
tab->gc_time = now;
+ tab->gc_scheduled = 0;
}
/**
rt_prune(t);
}
+void
+rt_preconfig(struct config *c)
+{
+ struct symbol *s = cf_find_symbol("master");
+
+ init_list(&c->tables);
+ c->master_rtc = rt_new_table(s);
+}
+
+
+/*
+ * Some functions for handing internal next hop updates
+ * triggered by rt_schedule_nhu().
+ */
+
+static inline int
+hostentry_diff(struct hostentry *he, struct iface *iface, ip_addr gw, byte dest)
+{
+ return (he->iface != iface) || !ipa_equal(he->gw, gw) || (he->dest != dest);
+}
+
+static inline int
+rta_next_hop_outdated(rta *a)
+{
+ struct hostentry *he = a->hostentry;
+ return he && hostentry_diff(he, a->iface, a->gw, a->dest);
+}
+
+static inline void
+rta_apply_hostentry(rta *a, struct hostentry *he)
+{
+ a->hostentry = he;
+ a->iface = he->iface;
+ a->gw = he->gw;
+ a->dest = he->dest;
+}
+
+static inline rte *
+rt_next_hop_update_rte(rtable *tab, rte *old)
+{
+ rta a;
+ memcpy(&a, old->attrs, sizeof(rta));
+ rta_apply_hostentry(&a, old->attrs->hostentry);
+ a.aflags = 0;
+
+ rte *e = sl_alloc(rte_slab);
+ memcpy(e, old, sizeof(rte));
+ e->attrs = rta_lookup(&a);
+
+ return e;
+}
+
+static inline int
+rt_next_hop_update_net(rtable *tab, net *n)
+{
+ rte **k, *e, *new, *old_best, **new_best;
+ int count = 0;
+ int free_old_best = 0;
+
+ old_best = n->routes;
+ if (!old_best)
+ return 0;
+
+ new_best = NULL;
+
+ for (k = &n->routes; e = *k; k = &e->next)
+ {
+ if (rta_next_hop_outdated(e->attrs))
+ {
+ new = rt_next_hop_update_rte(tab, e);
+ *k = new;
+
+ rte_announce_i(tab, RA_ANY, n, new, e);
+ rte_trace_in(D_ROUTES, new->sender, new, "updated");
+
+ if (e != old_best)
+ rte_free_quick(e);
+ else /* Freeing of the old best rte is postponed */
+ free_old_best = 1;
+
+ e = new;
+ count++;
+ }
+
+ if (!new_best || rte_better(e, *new_best))
+ new_best = k;
+ }
+
+ /* Relink the new best route to the first position */
+ new = *new_best;
+ if (new != n->routes)
+ {
+ *new_best = new->next;
+ new->next = n->routes;
+ n->routes = new;
+ }
+
+ /* Announce the new best route */
+ if (new != old_best)
+ {
+ rte_announce_i(tab, RA_OPTIMAL, n, new, old_best);
+ rte_trace_in(D_ROUTES, new->sender, new, "updated [best]");
+ }
+
+ if (free_old_best)
+ rte_free_quick(old_best);
+
+ return count;
+}
+
+static void
+rt_next_hop_update(rtable *tab)
+{
+ struct fib_iterator *fit = &tab->nhu_fit;
+ int max_feed = 32;
+
+ if (tab->nhu_state == 0)
+ return;
+
+ if (tab->nhu_state == 1)
+ {
+ FIB_ITERATE_INIT(fit, &tab->fib);
+ tab->nhu_state = 2;
+ }
+
+ FIB_ITERATE_START(&tab->fib, fit, fn)
+ {
+ if (max_feed <= 0)
+ {
+ FIB_ITERATE_PUT(fit, fn);
+ ev_schedule(tab->rt_event);
+ return;
+ }
+ max_feed -= rt_next_hop_update_net(tab, (net *) fn);
+ }
+ FIB_ITERATE_END(fn);
+
+ /* state change 2->0, 3->1 */
+ tab->nhu_state &= 1;
+
+ if (tab->nhu_state > 0)
+ ev_schedule(tab->rt_event);
+}
+
+
struct rtable_config *
rt_new_table(struct symbol *s)
{
return c;
}
-void
-rt_preconfig(struct config *c)
-{
- struct symbol *s = cf_find_symbol("master");
-
- init_list(&c->tables);
- c->master_rtc = rt_new_table(s);
-}
-
/**
* rt_lock_table - lock a routing table
* @r: routing table to be locked
{
struct config *conf = r->deleted;
DBG("Deleting routing table %s\n", r->name);
+ if (r->hostcache)
+ rt_free_hostcache(r);
rem_node(&r->n);
fib_free(&r->fib);
+ rfree(r->rt_event);
mb_free(r);
config_del_obstacle(conf);
}
}
}
+static void
+hostentry_init(struct fib_node *fn)
+{
+ ((struct hostentry *) fn)->uc = 0;
+ ((struct hostentry *) fn)->tab = NULL;
+}
+
+static void
+rt_init_hostcache(rtable *tab)
+{
+ struct hostcache *hc = mb_allocz(rt_table_pool, sizeof(struct hostcache));
+ init_list(&hc->hostentries);
+ fib_init(&hc->htable, rt_table_pool, sizeof(struct hostentry), 0, hostentry_init);
+ tab->hostcache = hc;
+}
+
+static void
+rt_free_hostcache(rtable *tab)
+{
+ struct hostcache *hc = tab->hostcache;
+
+ node *n;
+ WALK_LIST(n, hc->hostentries)
+ {
+ struct hostentry *he = SKIP_BACK(struct hostentry, ln, n);
+ if (he->uc)
+ log(L_ERR "Hostcache is not empty in table %s", tab->name);
+ }
+
+ fib_free(&hc->htable);
+ mb_free(hc);
+}
+
+static void
+rt_notify_hostcache(rtable *tab, net *net)
+{
+ struct hostcache *hc = tab->hostcache;
+
+ if (tab->hcu_scheduled)
+ return;
+
+ node *n;
+ WALK_LIST(n, hc->hostentries)
+ {
+ struct hostentry *he = SKIP_BACK(struct hostentry, ln, n);
+ if (ipa_in_net(he->fn.prefix, net->n.prefix, net->n.pxlen) &&
+ (he->pxlen <= net->n.pxlen))
+ {
+ rt_schedule_hcu(tab);
+ return;
+ }
+ }
+}
+
+static int
+if_local_addr(ip_addr a, struct iface *i)
+{
+ struct ifa *b;
+
+ WALK_LIST(b, i->addrs)
+ if (ipa_equal(a, b->ip))
+ return 1;
+
+ return 0;
+}
+
+static int
+rt_update_hostentry(rtable *tab, struct hostentry *he)
+{
+ struct iface *old_iface = he->iface;
+ ip_addr old_gw = he->gw;
+ byte old_dest = he->dest;
+
+ net *n = fib_route(&tab->fib, he->fn.prefix, MAX_PREFIX_LENGTH);
+ if (n && n->routes)
+ {
+ rta *a = n->routes->attrs;
+
+ if (a->dest == RTD_DEVICE)
+ {
+ if (if_local_addr(he->fn.prefix, a->iface))
+ {
+ /* The host address is a local address, this is not valid */
+ log(L_WARN "Next hop address %I is a local address of iface %s",
+ he->fn.prefix, a->iface->name);
+ he->iface = NULL;
+ he->gw = IPA_NONE;
+ he->dest = RTD_UNREACHABLE;
+ }
+ else
+ {
+ /* The host is directly reachable, us it as a gateway */
+ he->iface = a->iface;
+ he->gw = he->fn.prefix;
+ he->dest = RTD_ROUTER;
+ }
+ }
+ else
+ {
+ /* The host is reachable through some route entry */
+ he->iface = a->iface;
+ he->gw = a->gw;
+ he->dest = a->dest;
+ }
+
+ he->pxlen = n->n.pxlen;
+ }
+ else
+ {
+ /* The host is unreachable */
+ he->iface = NULL;
+ he->gw = IPA_NONE;
+ he->dest = RTD_UNREACHABLE;
+
+ he->pxlen = 0;
+ }
+
+ return hostentry_diff(he, old_iface, old_gw, old_dest);
+}
+
+static void
+rt_update_hostcache(rtable *tab)
+{
+ struct hostcache *hc = tab->hostcache;
+ struct hostentry *he;
+ node *n, *x;
+
+ WALK_LIST_DELSAFE(n, x, hc->hostentries)
+ {
+ he = SKIP_BACK(struct hostentry, ln, n);
+ if (!he->uc)
+ {
+ /* Delete a hostentry */
+ rem_node(&he->ln);
+ fib_delete(&hc->htable, he);
+ continue;
+ }
+
+ if (rt_update_hostentry(tab, he))
+ rt_schedule_nhu(he->tab);
+ }
+
+ tab->hcu_scheduled = 0;
+}
+
+static struct hostentry *
+rt_find_hostentry(rtable *tab, ip_addr *a, rtable *dep)
+{
+ struct hostentry *he;
+
+ if (!tab->hostcache)
+ rt_init_hostcache(tab);
+
+ he = fib_get(&tab->hostcache->htable, a, MAX_PREFIX_LENGTH);
+ if (!he->tab)
+ {
+ /* New entry */
+ add_tail(&tab->hostcache->hostentries, &he->ln);
+ he->tab = dep;
+
+ rt_update_hostentry(tab, he);
+ }
+
+ return he;
+}
+
+void
+rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr *gw)
+{
+ rta_apply_hostentry(a, rt_find_hostentry(tab, gw, dep));
+}
+
/*
* CLI commands
*/
projects / thirdparty / bird.git / commitdiff
