*/
void rte_withdraw(struct channel *c, net_addr *net, struct rte_src *src);
+/* Single route update order */
+struct rte_update {
+ struct rte_update *next; /* Internal single-linked list */
+ struct rte_src *src; /* Key: rte_src */
+ rte* rte; /* Value: the route itself */
+ enum rte_update_flags {
+ RUF_IGNORE = 1, /* Ignore this update */
+ } flags;
+ net_addr n[0]; /* Key: net */
+};
+
+struct rte_update_batch {
+ struct linpool *lp; /* Linpool to allocate the batch from */
+ struct rte_update *first, **last; /* Single route update order list */
+};
+
+/**
+ * rte_update_init - prepare a route update batch
+ *
+ * If you want to import / withdraw more routes than one, you should pack them
+ * into one batch and then execute them all at once. This function prepares
+ * the batch.
+ */
+struct rte_update_batch * rte_update_init(void);
+
+/**
+ * rte_update_get - prepare a route import
+ *
+ * @batch: the batch to put this import in
+ * @n: network address
+ * @src: the route source identifier (NULL for default)
+ *
+ * This function returns a structure for route import.
+ * You shall fill in only the @rte member of the returned structure
+ * (the pointer is already set) and set the flags.
+ * The route attributes must exist until rte_update_commit()
+ * is called which you can do either by calling rta_lookup()
+ * or by allocating from the batch->lp linpool.
+ */
+struct rte_update * rte_update_get(struct rte_update_batch *batch, net_addr *n, struct rte_src *src);
+
+/**
+ * rte_withdraw_get - prepare a route withdraw
+ *
+ * @batch: the batch to put this import in
+ * @n: network address
+ * @src: the route source identifier (NULL for default)
+ *
+ * This function registers a withdraw. You may only set flags in the returned structure.
+ */
+struct rte_update * rte_withdraw_get(struct rte_update_batch *batch, net_addr *n, struct rte_src *src);
+
+/**
+ * rte_update_commit - do all the prepared updates
+ *
+ * @batch: batch to commit
+ * @c: channel to send the updates to
+ *
+ * This function does all the prepared updates.
+ */
+void rte_update_commit(struct rte_update_batch *batch, struct channel *c);
+
+/**
+ * rte_update_cancel - cancel the prepared updates
+ *
+ * @batch: batch to cancel
+ *
+ * In case of error, you may want to send no update.
+ * This frees all the memory allocated to the batch together with the batch itself.
+ */
+void rte_update_cancel(struct rte_update_batch *batch);
+
extern list routing_tables;
struct config;
}
}
+static struct rte_src *
+rte_fix_src(struct channel *c, rte *new)
+{
+ if (new->attrs->src)
+ return new->attrs->src;
+ else if (rta_is_cached(new->attrs))
+ bug("src is NULL in cached RTA");
+ else
+ return new->attrs->src = c->proto->main_source;
+}
+
static void
rte_update2(struct channel *c, const net_addr *n, rte *new, struct rte_src *src)
{
if (!new->pref)
new->pref = c->preference;
+ src = rte_fix_src(c, new);
+
stats->imp_updates_received++;
if (!rte_validate(new))
{
}
else
{
+ if (!src)
+ src = c->proto->main_source;
+
stats->imp_withdraws_received++;
- if (!(nn = net_find(c->table, n)) || !src)
+ if (!(nn = net_find(c->table, n)))
{
stats->imp_withdraws_ignored++;
rte_update_unlock();
rte_update_unlock();
}
+struct rte_update_batch *
+rte_update_init(void)
+{
+ rte_update_lock();
+ struct rte_update_batch *batch = lp_alloc(rte_update_pool, sizeof(struct rte_update_batch));
+ batch->lp = rte_update_pool;
+ batch->first = NULL;
+ batch->last = &(batch->first);
+ return batch;
+}
+
static int rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
void
-rte_withdraw(struct channel *c, net_addr *n, struct rte_src *src)
+rte_update_commit(struct rte_update_batch *batch, struct channel *c)
+{
+ ASSERT(batch->lp);
+
+ _Bool have_in_table = c->in_table;
+
+ for (struct rte_update *ru = batch->first; ru; ru = ru->next)
+ if ((ru->flags & RUF_IGNORE) ||
+ have_in_table && !rte_update_in(c, ru->n, ru->rte, ru->src))
+ rte_free_quick(ru->rte);
+ else
+ rte_update2(c, ru->n, ru->rte, ru->src);
+
+ batch->lp = NULL;
+ rte_update_unlock();
+}
+
+void
+rte_update_cancel(struct rte_update_batch *batch)
+{
+ ASSERT(batch->lp);
+
+ for (struct rte_update *ru = batch->first; ru; ru = ru->next)
+ if (ru->rte)
+ rte_free_quick(ru->rte);
+
+ batch->lp = NULL;
+ rte_update_unlock();
+}
+
+struct rte_update *
+rte_withdraw_get(struct rte_update_batch *batch, net_addr *n, struct rte_src *src)
{
- if (!src)
- src = c->proto->main_source;
+ struct rte_update *ru = lp_alloc(batch->lp, sizeof(struct rte_update) + n->length);
+
+ *(batch->last) = ru;
+ batch->last = &(ru->next);
+ ru->next = NULL;
- if (!c->in_table || rte_update_in(c, n, NULL, src))
+ net_copy(ru->n, n);
+ ru->src = src;
+ ru->rte = NULL;
+ ru->flags = 0;
+ return ru;
+}
+
+void
+rte_withdraw(struct channel *c, net_addr *n, struct rte_src *src)
+{
+ if (c->in_table && !rte_update_in(c, n, NULL, src ?: c->proto->main_source))
rte_update2(c, n, NULL, src ?: c->proto->main_source);
}
+struct rte_update *
+rte_update_get(struct rte_update_batch *batch, net_addr *n, struct rte_src *src)
+{
+ struct rte_update *ru = rte_withdraw_get(batch, n, src);
+
+ rte *e = sl_alloc(rte_slab);
+
+ e->id = 0;
+ e->flags = 0;
+ e->pref = 0;
+
+ ru->rte = e;
+
+ return ru;
+}
+
void
rte_update(struct channel *c, net_addr *n, struct rte *new)
{
e->attrs->src = c->proto->main_source;
}
- if (!c->in_table || rte_update_in(c, n, e, e->attrs->src))
+ if (c->in_table && !rte_update_in(c, n, e, e->attrs->src))
+ rte_free_quick(e);
+ else
rte_update2(c, n, e, e->attrs->src);
}
u32 last_id;
struct rte_src *last_src;
rta *cached_rta;
+ struct rte_update_batch *update_batch;
};
#define BGP_PORT 179
static inline void
bgp_parse_error(struct bgp_parse_state *s, uint subcode)
{
+ if (s->update_batch)
+ rte_update_cancel(s->update_batch);
+
s->err_subcode = subcode;
longjmp(s->err_jmpbuf, 1);
}
if (!a0)
{
/* Route withdraw */
- rte_withdraw(&(s->channel->c), n, s->last_src);
+ rte_withdraw_get(s->update_batch, n, s->last_src);
return;
}
a0->eattrs = ea;
}
- rte e0 = {
- .attrs = rta_clone(s->cached_rta),
- .u.bgp.stale = -1,
- };
-
- rte_update(&(s->channel->c), n, &e0);
+ struct rte_update *ru = rte_update_get(s->update_batch, n, s->last_src);
+ ru->rte->pflags = 0;
+ ru->rte->attrs = rta_clone(s->cached_rta);
+ ru->rte->u.bgp.suppressed = 0;
+ ru->rte->u.bgp.stale = -1;
+ return;
}
static void
if (ea)
{
- a = allocz(RTA_MAX_SIZE);
+ a = lp_allocz(s->update_batch->lp, RTA_MAX_SIZE);
a->source = RTS_BGP;
a->scope = SCOPE_UNIVERSE;
!s.mp_reach_len && !s.mp_unreach_len && s.mp_unreach_af)
{ bgp_rx_end_mark(&s, s.mp_unreach_af); goto done; }
+ s.update_batch = rte_update_init();
+
if (s.ip_unreach_len)
bgp_decode_nlri(&s, BGP_AF_IPV4, s.ip_unreach_nlri, s.ip_unreach_len, NULL, NULL, 0);
bgp_decode_nlri(&s, s.mp_reach_af, s.mp_reach_nlri, s.mp_reach_len,
ea, s.mp_next_hop_data, s.mp_next_hop_len);
+ rte_update_commit(s.update_batch, &s.channel->c);
+ s.update_batch = NULL;
+
done:
rta_free(s.cached_rta);
lp_flush(s.pool);
OSPF_TRACE(D_EVENTS, "Starting routing table synchronization");
+ struct rte_update_batch *rub = rte_update_init();
+
DBG("Now syncing my rt table with nest's\n");
FIB_ITERATE_INIT(&fit, fib);
again1:
if (reload || ort_changed(nf, &a0))
{
- rte e0 = {
- .attrs = rta_lookup(&a0),
- .u.ospf.metric1 = nf->old_metric1 = nf->n.metric1,
- .u.ospf.metric2 = nf->old_metric2 = nf->n.metric2,
- .u.ospf.tag = nf->old_tag = nf->n.tag,
- .u.ospf.router_id = nf->old_rid = nf->n.rid,
- .pflags = EA_ID_FLAG(EA_OSPF_METRIC1) | EA_ID_FLAG(EA_OSPF_ROUTER_ID),
- };
+ struct rte_update *ru = rte_update_get(rub, nf->fn.addr, NULL);
+ ru->rte->attrs = rta_lookup(&a0);
rta_free(nf->old_rta);
- nf->old_rta = rta_clone(e0.attrs);
+ nf->old_rta = rta_clone(ru->rte->attrs);
+
+ ru->rte->u.ospf.metric1 = nf->old_metric1 = nf->n.metric1;
+ ru->rte->u.ospf.metric2 = nf->old_metric2 = nf->n.metric2;
+ ru->rte->u.ospf.tag = nf->old_tag = nf->n.tag;
+ ru->rte->u.ospf.router_id = nf->old_rid = nf->n.rid;
+ ru->rte->pflags = EA_ID_FLAG(EA_OSPF_METRIC1) | EA_ID_FLAG(EA_OSPF_ROUTER_ID);
if (nf->n.type == RTS_OSPF_EXT2)
- e0.pflags |= EA_ID_FLAG(EA_OSPF_METRIC2);
+ ru->rte->pflags |= EA_ID_FLAG(EA_OSPF_METRIC2);
/* Perhaps onfly if tag is non-zero? */
if ((nf->n.type == RTS_OSPF_EXT1) || (nf->n.type == RTS_OSPF_EXT2))
- e0.pflags |= EA_ID_FLAG(EA_OSPF_TAG);
+ ru->rte->pflags |= EA_ID_FLAG(EA_OSPF_TAG);
DBG("Mod rte type %d - %N via %I on iface %s, met %d\n",
a0.source, nf->fn.addr, a0.gw, a0.iface ? a0.iface->name : "(none)", nf->n.metric1);
-
- rte_update(p->p.main_channel, nf->fn.addr, &e0);
}
}
else if (nf->old_rta)
rta_free(nf->old_rta);
nf->old_rta = NULL;
- rte_withdraw(p->p.main_channel, nf->fn.addr, NULL);
+ rte_withdraw_get(rub, nf->fn.addr, NULL);
}
/* Remove unused rt entry, some special entries are persistent */
}
FIB_ITERATE_END;
+ rte_update_commit(rub, p->p.main_channel);
+
WALK_LIST(oa, p->area_list)
{
/* Cleanup ASBR hash tables */
clock_gettime(CLOCK_MONOTONIC, &ts_generated);
- for (uint i=0; i<N; i++)
- {
- rte e0 = { .attrs = p->data[i].a, };
- rte_update(P->main_channel, &(p->data[i].net), &e0);
+ struct rte_update_batch *rub = rte_update_init();
+
+ for (uint i=0; i<N; i++) {
+ struct rte_update *ru = rte_update_get(rub, &(p->data[i].net), NULL);
+ ru->rte->attrs = p->data[i].a;
+ ru->rte->pflags = 0;
}
+ rte_update_commit(rub, P->main_channel);
+
clock_gettime(CLOCK_MONOTONIC, &ts_update);
+ rub = rte_update_init();
+
if (!p->keep)
for (uint i=0; i<N; i++)
- rte_withdraw(P->main_channel, &(p->data[i].net), NULL);
+ rte_withdraw_get(rub, &(p->data[i].net), NULL);
+
+ rte_update_commit(rub, P->main_channel);
clock_gettime(CLOCK_MONOTONIC, &ts_withdraw);
static linpool *static_lp;
static void
-static_announce_rte(struct static_proto *p, struct static_route *r)
+static_announce_rte(struct static_proto *p, struct rte_update_batch *rub, struct static_route *r)
{
- rta *a = allocz(RTA_MAX_SIZE);
- a->src = p->p.main_source;
+ rta *a = lp_allocz(rub->lp, RTA_MAX_SIZE);
a->source = RTS_STATIC;
a->scope = SCOPE_UNIVERSE;
a->dest = r->dest;
if (!r2->active)
continue;
- struct nexthop *nh = allocz(NEXTHOP_MAX_SIZE);
+ struct nexthop *nh = lp_allocz(rub->lp, NEXTHOP_MAX_SIZE);
nh->gw = r2->via;
nh->iface = r2->neigh->iface;
nh->flags = r2->onlink ? RNF_ONLINK : 0;
return;
/* We skip rta_lookup() here */
- rte e0 = { .attrs = a }, *e = &e0;
+ struct rte_update *ru = rte_update_get(rub, r->net, NULL);
+ ru->rte->pflags = 0;
+ ru->rte->attrs = a;
if (r->cmds)
- f_eval_rte(r->cmds, &e, static_lp);
+ f_eval_rte(r->cmds, &(ru->rte), rub->lp);
- rte_update(p->p.main_channel, r->net, e);
r->state = SRS_CLEAN;
- if (r->cmds)
- lp_flush(static_lp);
-
return;
withdraw:
if (r->state == SRS_DOWN)
return;
- rte_withdraw(p->p.main_channel, r->net, NULL);
+ rte_withdraw_get(rub, r->net, NULL);
r->state = SRS_DOWN;
}
{
struct static_proto *p = P;
+ struct rte_update_batch *rub = rte_update_init();
BUFFER_WALK(p->marked, r)
- static_announce_rte(P, r);
+ static_announce_rte(p, rub, r);
BUFFER_FLUSH(p->marked);
+ rte_update_commit(rub, p->p.main_channel);
}
static void
}
static void
-static_add_rte(struct static_proto *p, struct static_route *r)
+static_add_rte(struct static_proto *p, struct rte_update_batch *rub, struct static_route *r)
{
if (r->dest == RTD_UNICAST)
{
}
}
- static_announce_rte(p, r);
+ static_announce_rte(p, rub, r);
}
static void
}
static void
-static_remove_rte(struct static_proto *p, struct static_route *r)
+static_remove_rte(struct static_proto *p, struct rte_update_batch *rub, struct static_route *r)
{
if (r->state)
- rte_withdraw(p->p.main_channel, r->net, NULL);
+ rte_withdraw_get(rub, r->net, NULL);
static_reset_rte(p, r);
}
}
static void
-static_reconfigure_rte(struct static_proto *p, struct static_route *or, struct static_route *nr)
+static_reconfigure_rte(struct static_proto *p, struct rte_update_batch *rub, struct static_route *or, struct static_route *nr)
{
if ((or->state == SRS_CLEAN) && !static_same_rte(or, nr))
nr->state = SRS_DIRTY;
else
nr->state = or->state;
- static_add_rte(p, nr);
+ static_add_rte(p, rub, nr);
static_reset_rte(p, or);
}
/* We have to go UP before routes could be installed */
proto_notify_state(P, PS_UP);
+ struct rte_update_batch *rub = rte_update_init();
+
WALK_LIST(r, cf->routes)
- static_add_rte(p, r);
+ static_add_rte(p, rub, r);
+
+ rte_update_commit(rub, p->p.main_channel);
return PS_UP;
}
if (!proto_configure_channel(P, &P->main_channel, proto_cf_main_channel(CF)))
return 0;
+ struct rte_update_batch *rub = rte_update_init();
+
p->p.cf = CF;
/* Reset route lists in neighbor entries */
for (or = HEAD(o->routes), nr = HEAD(n->routes);
NODE_VALID(or) && NODE_VALID(nr) && net_equal(or->net, nr->net);
or = NODE_NEXT(or), nr = NODE_NEXT(nr))
- static_reconfigure_rte(p, or, nr);
+ static_reconfigure_rte(p, rub, or, nr);
if (!NODE_VALID(or) && !NODE_VALID(nr))
+ {
+ rte_update_commit(rub, p->p.main_channel);
return 1;
+ }
/* Reconfigure remaining routes, sort them to find matching pairs */
struct static_route *or2, *nr2, **orbuf, **nrbuf;
{
int x = net_compare(orbuf[orpos]->net, nrbuf[nrpos]->net);
if (x < 0)
- static_remove_rte(p, orbuf[orpos++]);
+ static_remove_rte(p, rub, orbuf[orpos++]);
else if (x > 0)
- static_add_rte(p, nrbuf[nrpos++]);
+ static_add_rte(p, rub, nrbuf[nrpos++]);
else
- static_reconfigure_rte(p, orbuf[orpos++], nrbuf[nrpos++]);
+ static_reconfigure_rte(p, rub, orbuf[orpos++], nrbuf[nrpos++]);
}
while (orpos < ornum)
- static_remove_rte(p, orbuf[orpos++]);
+ static_remove_rte(p, rub, orbuf[orpos++]);
while (nrpos < nrnum)
- static_add_rte(p, nrbuf[nrpos++]);
+ static_add_rte(p, rub, nrbuf[nrpos++]);
+
+ rte_update_commit(rub, p->p.main_channel);
xfree(orbuf);
xfree(nrbuf);
}
static void
-krt_learn_announce_update(struct krt_proto *p, rte *e)
+krt_learn_announce_update(struct rte_update_batch *rub, rte *e)
{
- rte e0 = {
- .attrs = rta_clone(e->attrs),
- .pflags = EA_ID_FLAG(EA_KRT_SOURCE) | EA_ID_FLAG(EA_KRT_METRIC),
- .u.krt = e->u.krt,
- };
-
- rte_update(p->p.main_channel, e->net->n.addr, &e0);
+ struct rte_update *ru = rte_update_get(rub, e->net->n.addr, NULL);
+ ru->rte->attrs = rta_clone(e->attrs);
+ ru->rte->pflags = EA_ID_FLAG(EA_KRT_SOURCE) | EA_ID_FLAG(EA_KRT_METRIC);
+ ru->rte->u.krt = e->u.krt;
}
static void
-krt_learn_announce_delete(struct krt_proto *p, net_addr *n)
+krt_learn_announce_delete(struct rte_update_batch *rub, net *n)
{
- rte_withdraw(p->p.main_channel, n, NULL);
+ rte_withdraw_get(rub, n->n.addr, NULL);
}
/* Called when alien route is discovered during scan */
KRT_TRACE(p, D_EVENTS, "Pruning inherited routes");
+ struct rte_update_batch *rub = rte_update_init();
+
FIB_ITERATE_INIT(&fit, fib);
again:
FIB_ITERATE_START(fib, &fit, net, n)
{
DBG("%I/%d: deleting\n", n->n.prefix, n->n.pxlen);
if (old_best)
- krt_learn_announce_delete(p, n->n.addr);
+ krt_learn_announce_delete(rub, n);
FIB_ITERATE_PUT(&fit);
fib_delete(fib, n);
if ((best != old_best) || p->reload)
{
DBG("%I/%d: announcing (metric=%d)\n", n->n.prefix, n->n.pxlen, best->u.krt.metric);
- krt_learn_announce_update(p, best);
+ krt_learn_announce_update(rub, best);
}
else
DBG("%I/%d: uptodate (metric=%d)\n", n->n.prefix, n->n.pxlen, best->u.krt.metric);
}
FIB_ITERATE_END;
+ rte_update_commit(rub, p->p.main_channel);
+
p->reload = 0;
}
n->routes = best;
}
+ struct rte_update_batch *rub = rte_update_init();
if (best != old_best)
{
DBG("krt_learn_async: distributing change\n");
if (best)
- krt_learn_announce_update(p, best);
+ krt_learn_announce_update(rub, best);
else
- krt_learn_announce_delete(p, n->n.addr);
+ krt_learn_announce_delete(rub, n);
}
+ rte_update_commit(rub, p->p.main_channel);
}
static void
projects / thirdparty / bird.git / commitdiff
