int (*rte_better)(struct rte *, struct rte *);
int (*rte_same)(struct rte *, struct rte *);
int (*rte_mergable)(struct rte *, struct rte *);
+ struct rte * (*rte_modify)(struct rte *, struct linpool *);
void (*rte_insert)(struct network *, struct rte *);
void (*rte_remove)(struct network *, struct rte *);
#ifdef CONFIG_BGP
struct {
u8 suppressed; /* Used for deterministic MED comparison */
+ s8 stale; /* Route is LLGR_STALE, -1 if unknown */
} bgp;
#endif
#ifdef CONFIG_BABEL
#define REF_FILTERED 2 /* Route is rejected by import filter */
#define REF_STALE 4 /* Route is stale in a refresh cycle */
#define REF_DISCARD 8 /* Route is scheduled for discard */
+#define REF_MODIFY 16 /* Route is scheduled for modify */
/* Route is valid for propagation (may depend on other flags in the future), accepts NULL */
static inline int rte_is_valid(rte *r) { return r && !(r->flags & REF_FILTERED); }
rte *rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, struct ea_list **tmpa, linpool *pool, int silent);
void rt_refresh_begin(rtable *t, struct announce_hook *ah);
void rt_refresh_end(rtable *t, struct announce_hook *ah);
+void rt_modify_stale(rtable *t, struct announce_hook *ah);
void rte_dump(rte *);
void rte_free(rte *);
rte *rte_do_cow(rte *);
rte_update_unlock();
}
+/* Modify existing route by protocol hook, used for long-lived graceful restart */
+static inline void
+rte_modify(rte *old)
+{
+ rte_update_lock();
+
+ rte *new = old->sender->proto->rte_modify(old, rte_update_pool);
+ if (new != old)
+ {
+ if (new)
+ {
+ if (!rta_is_cached(new->attrs))
+ new->attrs = rta_lookup(new->attrs);
+ new->flags = (old->flags & ~REF_MODIFY) | REF_COW;
+ }
+
+ rte_recalculate(old->sender, old->net, new, old->attrs->src);
+ }
+
+ rte_update_unlock();
+}
+
/* Check rtable for best route to given net whether it would be exported do p */
int
rt_examine(rtable *t, ip_addr prefix, int pxlen, struct proto *p, struct filter *filter)
rt_schedule_prune(t);
}
+void
+rt_modify_stale(rtable *t, struct announce_hook *ah)
+{
+ int prune = 0;
+ net *n;
+ rte *e;
+
+ FIB_WALK(&t->fib, fn)
+ {
+ n = (net *) fn;
+ for (e = n->routes; e; e = e->next)
+ if ((e->sender == ah) && (e->flags & REF_STALE) && !(e->flags & REF_FILTERED))
+ {
+ e->flags |= REF_MODIFY;
+ prune = 1;
+ }
+ }
+ FIB_WALK_END;
+
+ if (prune)
+ rt_schedule_prune(t);
+}
+
/**
* rte_dump - dump a route
rescan:
for (e=n->routes; e; e=e->next)
+ {
if (e->sender->proto->flushing || (e->flags & REF_DISCARD))
{
if (*limit <= 0)
goto rescan;
}
+
+ if (e->flags & REF_MODIFY)
+ {
+ if (*limit <= 0)
+ {
+ FIB_ITERATE_PUT(fit, fn);
+ return 0;
+ }
+
+ rte_modify(e);
+ (*limit)--;
+
+ goto rescan;
+ }
+ }
+
if (!n->routes) /* Orphaned FIB entry */
{
FIB_ITERATE_PUT(fit, fn);
DBG("\tNO_EXPORT\n");
return 1;
}
+
+ if (!p->conn->peer_llgr_aware && int_set_contains(d, BGP_COMM_LLGR_STALE))
+ return 1;
}
return 0;
return (rd == RTD_ROUTER) || (rd == RTD_DEVICE) || (rd == RTD_MULTIPATH);
}
+static inline int
+rte_stale(rte *r)
+{
+ if (r->u.bgp.stale < 0)
+ {
+ /* If staleness is unknown, compute and cache it */
+ eattr *a = ea_find(r->attrs->eattrs, EA_CODE(EAP_BGP, BA_COMMUNITY));
+ r->u.bgp.stale = a && int_set_contains(a->u.ptr, BGP_COMM_LLGR_STALE);
+ }
+
+ return r->u.bgp.stale;
+}
+
int
bgp_rte_better(rte *new, rte *old)
{
if (n < o)
return 0;
+ /* LLGR draft - depreference stale routes */
+ n = rte_stale(new);
+ o = rte_stale(old);
+ if (n > o)
+ return 0;
+ if (n < o)
+ return 1;
+
/* Start with local preferences */
x = ea_find(new->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
y = ea_find(old->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
if (!rte_resolvable(sec))
return 0;
+ /* LLGR draft - depreference stale routes */
+ if (rte_stale(pri) != rte_stale(sec))
+ return 0;
+
/* Start with local preferences */
x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
return old_is_group_best;
}
+struct rte *
+bgp_rte_modify_stale(struct rte *r, struct linpool *pool)
+{
+ eattr *a = ea_find(r->attrs->eattrs, EA_CODE(EAP_BGP, BA_COMMUNITY));
+ struct adata *ad = a ? a->u.ptr : NULL;
+
+ if (ad && int_set_contains(ad, BGP_COMM_NO_LLGR))
+ return NULL;
+
+ if (ad && int_set_contains(ad, BGP_COMM_LLGR_STALE))
+ return r;
+
+ r = rte_cow_rta(r, pool);
+ bgp_attach_attr(&(r->attrs->eattrs), pool, BA_COMMUNITY,
+ (uintptr_t) int_set_add(pool, ad, BGP_COMM_LLGR_STALE));
+ r->u.bgp.stale = 1;
+
+ return r;
+}
+
+
static struct adata *
bgp_aggregator_convert_to_new(struct adata *old, struct linpool *pool)
{
return newa;
}
-
/* Take last req_as ASNs from path old2 (in 2B format), convert to 4B format
* and append path old4 (in 4B format).
*/
if (e->u.bgp.suppressed)
buf += bsprintf(buf, "-");
+ if (rte_stale(e))
+ buf += bsprintf(buf, "s");
+
if (e->attrs->hostentry)
{
if (!rte_resolvable(e))
if (p->p.gr_recovery && (p->cf->gr_mode == BGP_GR_ABLE) && peer_gr_ready)
p->p.gr_wait = 1;
- if (p->gr_active)
+ if (p->gr_active == BGP_GRS_ACTIVE)
tm_stop(p->gr_timer);
- if (p->gr_active && (!conn->peer_gr_able || !(conn->peer_gr_aflags & BGP_GRF_FORWARDING)))
+ /* Check F-bit for regular graceful restart */
+ if ((p->gr_active == BGP_GRS_ACTIVE) &&
+ (!conn->peer_gr_able || !(conn->peer_gr_aflags & BGP_GRF_FORWARDING)))
+ bgp_graceful_restart_done(p);
+
+ /* Check F-bit for long-lived graceful restart */
+ if (((p->gr_active == BGP_GRS_LLGR_1) || (p->gr_active == BGP_GRS_LLGR_2)) &&
+ (!conn->peer_llgr_able || !(conn->peer_llgr_aflags & BGP_LLGRF_FORWARDING)))
bgp_graceful_restart_done(p);
/* GR capability implies that neighbor will send End-of-RIB */
p->gr_active ? " - already pending" : "");
proto_notify_state(&p->p, PS_START);
- if (p->gr_active)
+ switch (p->gr_active)
+ {
+ case BGP_GRS_ACTIVE:
rt_refresh_end(p->p.main_ahook->table, p->p.main_ahook);
+ break;
+
+ case BGP_GRS_LLGR_1:
+ rt_refresh_begin(p->p.main_ahook->table, p->p.main_ahook);
+ return;
+
+ case BGP_GRS_LLGR_2:
+ rt_refresh_begin(p->p.main_ahook->table, p->p.main_ahook);
+ rt_modify_stale(p->p.main_ahook->table, p->p.main_ahook);
+ return;
+ }
- p->gr_active = 1;
- bgp_start_timer(p->gr_timer, p->conn->peer_gr_time);
+ p->stale_time = p->cf->llgr_mode ? p->conn->peer_llgr_time : 0;
+ p->gr_active = !p->stale_time ? BGP_GRS_ACTIVE : BGP_GRS_LLGR_1;
+ tm_start(p->gr_timer, p->conn->peer_gr_time);
rt_refresh_begin(p->p.main_ahook->table, p->p.main_ahook);
}
{
struct bgp_proto *p = t->data;
- BGP_TRACE(D_EVENTS, "Neighbor graceful restart timeout");
- bgp_stop(p, 0, NULL, 0);
-}
+ switch (p->gr_active)
+ {
+ case BGP_GRS_ACTIVE:
+ BGP_TRACE(D_EVENTS, "Neighbor graceful restart timeout");
+ bgp_stop(p, 0, NULL, 0);
+ return;
+
+ case BGP_GRS_LLGR_1:
+ BGP_TRACE(D_EVENTS, "Neighbor graceful restart timeout");
+ p->gr_active = BGP_GRS_LLGR_2;
+ tm_start(p->gr_timer, p->stale_time);
+ rt_modify_stale(p->p.main_ahook->table, p->p.main_ahook);
+ return;
+ case BGP_GRS_LLGR_2:
+ BGP_TRACE(D_EVENTS, "Long-lived graceful restart timeout");
+ p->gr_active = 0;
+ rt_refresh_end(p->p.main_ahook->table, p->p.main_ahook);
+ return;
+ }
+}
/**
* bgp_refresh_begin - start incoming enhanced route refresh sequence
conn->peer_gr_time = 0;
conn->peer_gr_flags = 0;
conn->peer_gr_aflags = 0;
+ conn->peer_llgr_aware = 0;
+ conn->peer_llgr_able = 0;
+ conn->peer_llgr_time = 0;
+ conn->peer_llgr_aflags = 0;
conn->peer_ext_messages_support = 0;
DBG("BGP: Sending open\n");
P->rte_better = bgp_rte_better;
P->rte_mergable = bgp_rte_mergable;
P->rte_recalculate = c->deterministic_med ? bgp_rte_recalculate : NULL;
+ P->rte_modify = bgp_rte_modify_stale;
p->cf = c;
p->local_as = c->local_as;
if (!c->missing_lladdr)
c->missing_lladdr = c->rs_client ? MLL_IGNORE : MLL_SELF;
+ /* LLGR mode default based on GR mode */
+ if (c->llgr_mode < 0)
+ c->llgr_mode = c->gr_mode ? BGP_LLGR_AWARE : 0;
+
/* Disable after error incompatible with restart limit action */
if (c->c.in_limit && (c->c.in_limit->action == PLA_RESTART) && c->disable_after_error)
c->c.in_limit->action = PLA_DISABLE;
if (c->secondary && !c->c.table->sorted)
cf_error("BGP with secondary option requires sorted table");
+
+ if (!c->gr_mode && c->llgr_mode)
+ cf_error("Long-lived graceful restart requires basic graceful restart");
}
static int
if (p->gr_active)
cli_msg(-1006, " Neighbor graceful restart active");
+ if (p->gr_active && p->gr_timer->expires)
+ cli_msg(-1006, " %-15s %d/-",
+ (p->gr_active != BGP_GRS_LLGR_2) ? "Restart timer:" : "LL stale timer:",
+ p->gr_timer->expires - now);
+
if (P->proto_state == PS_START)
{
struct bgp_conn *oc = &p->outgoing_conn;
(oc->connect_retry_timer->expires))
cli_msg(-1006, " Connect delay: %d/%d",
oc->connect_retry_timer->expires - now, p->cf->connect_delay_time);
-
- if (p->gr_active && p->gr_timer->expires)
- cli_msg(-1006, " Restart timer: %d/-", p->gr_timer->expires - now);
}
else if (P->proto_state == PS_UP)
{
c->peer_refresh_support ? " refresh" : "",
c->peer_enhanced_refresh_support ? " enhanced-refresh" : "",
c->peer_gr_able ? " restart-able" : (c->peer_gr_aware ? " restart-aware" : ""),
+ c->peer_llgr_able ? " llgr-able" : (c->peer_llgr_aware ? " llgr-aware" : ""),
c->peer_as4_support ? " AS4" : "",
(c->peer_add_path & ADD_PATH_RX) ? " add-path-rx" : "",
(c->peer_add_path & ADD_PATH_TX) ? " add-path-tx" : "",
int allow_local_as; /* Allow that number of local ASNs in incoming AS_PATHs */
int allow_local_pref; /* Allow LOCAL_PREF in EBGP sessions */
int gr_mode; /* Graceful restart mode (BGP_GR_*) */
+ int llgr_mode; /* Long-lived graceful restart mode (BGP_LLGR_*) */
int setkey; /* Set MD5 password to system SA/SP database */
unsigned gr_time; /* Graceful restart timeout */
+ unsigned llgr_time; /* Long-lived graceful restart timeout */
unsigned connect_delay_time; /* Minimum delay between connect attempts */
unsigned connect_retry_time; /* Timeout for connect attempts */
unsigned hold_time, initial_hold_time;
/* For peer_gr_aflags */
#define BGP_GRF_FORWARDING 0x80
+#define BGP_LLGR_ABLE 1
+#define BGP_LLGR_AWARE 2
+
+#define BGP_LLGRF_FORWARDING 0x80
+
+#define BGP_GRS_NONE 0 /* No GR */
+#define BGP_GRS_ACTIVE 1 /* Graceful restart per RFC 4724 */
+#define BGP_GRS_LLGR_1 2 /* Long-lived GR phase 1 (restart time) */
+#define BGP_GRS_LLGR_2 3 /* Long-lived GR phase 2 (stale time) */
+
struct bgp_conn {
struct bgp_proto *bgp;
u16 peer_gr_time;
u8 peer_gr_flags;
u8 peer_gr_aflags;
+ u8 peer_llgr_aware;
+ u8 peer_llgr_able;
+ u16 peer_llgr_time;
+ u8 peer_llgr_aflags;
u8 peer_ext_messages_support; /* Peer supports extended message length [draft] */
unsigned hold_time, keepalive_time; /* Times calculated from my and neighbor's requirements */
};
int rr_client; /* Whether neighbor is RR client of me */
int rs_client; /* Whether neighbor is RS client of me */
u8 gr_ready; /* Neighbor could do graceful restart */
- u8 gr_active; /* Neighbor is doing graceful restart */
+ u8 gr_active; /* Neighbor is doing graceful restart (BGP_GRS_*) */
u8 feed_state; /* Feed state (TX) for EoR, RR packets, see BFS_* */
u8 load_state; /* Load state (RX) for EoR, RR packets, see BFS_* */
+ uint stale_time; /* Long-lived stale time for LLGR */
struct bgp_conn *conn; /* Connection we have established */
struct bgp_conn outgoing_conn; /* Outgoing connection we're working with */
struct bgp_conn incoming_conn; /* Incoming connection we have neither accepted nor rejected yet */
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);
+struct rte *bgp_rte_modify_stale(struct rte *r, struct linpool *pool);
void bgp_rt_notify(struct proto *P, rtable *tbl UNUSED, net *n, rte *new, rte *old UNUSED, ea_list *attrs);
int bgp_import_control(struct proto *, struct rte **, struct ea_list **, struct linpool *);
void bgp_init_bucket_table(struct bgp_proto *);
#define BGP_COMM_NO_ADVERTISE 0xffffff02 /* Don't export at all */
#define BGP_COMM_NO_EXPORT_SUBCONFED 0xffffff03 /* NO_EXPORT even in local confederation */
+#define BGP_COMM_LLGR_STALE 0xffff0006 /* Route is stale according to LLGR */
+#define BGP_COMM_NO_LLGR 0xffff0007 /* Do not treat the route according to LLGR */
+
/* Origins */
#define ORIGIN_IGP 0
INTERPRET, COMMUNITIES, BGP_ORIGINATOR_ID, BGP_CLUSTER_LIST, IGP,
TABLE, GATEWAY, DIRECT, RECURSIVE, MED, TTL, SECURITY, DETERMINISTIC,
SECONDARY, ALLOW, BFD, ADD, PATHS, RX, TX, GRACEFUL, RESTART, AWARE,
- CHECK, LINK, PORT, EXTENDED, MESSAGES, SETKEY, BGP_LARGE_COMMUNITY)
+ CHECK, LINK, PORT, EXTENDED, MESSAGES, SETKEY, BGP_LARGE_COMMUNITY,
+ LONG, LIVED, STALE)
CF_KEYWORDS(CEASE, PREFIX, LIMIT, HIT, ADMINISTRATIVE, SHUTDOWN, RESET, PEER,
CONFIGURATION, CHANGE, DECONFIGURED, CONNECTION, REJECTED, COLLISION,
BGP_CFG->default_local_pref = 100;
BGP_CFG->gr_mode = BGP_GR_AWARE;
BGP_CFG->gr_time = 120;
+ BGP_CFG->llgr_mode = -1;
+ BGP_CFG->llgr_time = 3600;
BGP_CFG->setkey = 1;
}
;
| bgp_proto GRACEFUL RESTART bool ';' { BGP_CFG->gr_mode = $4; }
| bgp_proto GRACEFUL RESTART AWARE ';' { BGP_CFG->gr_mode = BGP_GR_AWARE; }
| bgp_proto GRACEFUL RESTART TIME expr ';' { BGP_CFG->gr_time = $5; }
+ | bgp_proto LONG LIVED GRACEFUL RESTART bool ';' { BGP_CFG->llgr_mode = $6; }
+ | bgp_proto LONG LIVED GRACEFUL RESTART AWARE ';' { BGP_CFG->llgr_mode = BGP_LLGR_AWARE; }
+ | bgp_proto LONG LIVED STALE TIME expr ';' { BGP_CFG->llgr_time = $6; }
| bgp_proto IGP TABLE rtable ';' { BGP_CFG->igp_table = $4; }
| bgp_proto TTL SECURITY bool ';' { BGP_CFG->ttl_security = $4; }
| bgp_proto CHECK LINK bool ';' { BGP_CFG->check_link = $4; }
return buf;
}
+static byte *
+bgp_put_cap_llgr1(struct bgp_proto *p, byte *buf)
+{
+ *buf++ = 71; /* Capability 71: Support for long-lived graceful restart */
+ *buf++ = 7; /* Capability data length */
+
+ *buf++ = 0; /* Appropriate AF */
+ *buf++ = BGP_AF;
+ *buf++ = 1; /* and SAFI 1 */
+
+ /* Next is 8bit flags and 24bit time */
+ put_u32(buf, p->cf->llgr_time);
+ buf[0] = p->p.gr_recovery ? BGP_LLGRF_FORWARDING : 0;
+ buf += 4;
+
+ return buf;
+}
+
+static byte *
+bgp_put_cap_llgr2(struct bgp_proto *p UNUSED, byte *buf)
+{
+ *buf++ = 71; /* Capability 71: Support for long-lived graceful restart */
+ *buf++ = 0; /* Capability data length */
+ return buf;
+}
+
static byte *
bgp_create_open(struct bgp_conn *conn, byte *buf)
if (p->cf->enable_extended_messages)
cap = bgp_put_cap_ext_msg(p, cap);
+ if (p->cf->llgr_mode == BGP_LLGR_ABLE)
+ cap = bgp_put_cap_llgr1(p, cap);
+ else if (p->cf->llgr_mode == BGP_LLGR_AWARE)
+ cap = bgp_put_cap_llgr2(p, cap);
+
cap_len = cap - buf - 12;
if (cap_len > 0)
{
conn->peer_enhanced_refresh_support = 1;
break;
+ case 71: /* Long-lived graceful restart capability, RFC draft */
+ if (cl % 7)
+ goto err;
+ conn->peer_llgr_aware = 1;
+ conn->peer_llgr_able = 0;
+ conn->peer_llgr_time = 0;
+ conn->peer_llgr_aflags = 0;
+ for (i = 0; i < cl; i += 4)
+ if (opt[2+i+0] == 0 && opt[2+i+1] == BGP_AF && opt[2+i+2] == 1) /* Match AFI/SAFI */
+ {
+ conn->peer_llgr_able = 1;
+ conn->peer_llgr_time = get_u32(opt + 2+i+3) & 0xffffff;
+ conn->peer_llgr_aflags = opt[2+i+3];
+ }
+ break;
+
/* We can safely ignore all other capabilities */
}
len -= 2 + cl;
opt += 2 + cl;
}
+
+ /* The LLGR capability must be advertised together with the GR capability,
+ otherwise it must be disregarded */
+ if (!conn->peer_gr_aware && conn->peer_llgr_aware)
+ {
+ conn->peer_llgr_aware = 0;
+ conn->peer_llgr_able = 0;
+ conn->peer_llgr_time = 0;
+ conn->peer_llgr_aflags = 0;
+ }
+
return;
err:
p->as4_session = p->cf->enable_as4 && conn->peer_as4_support;
p->add_path_rx = (p->cf->add_path & ADD_PATH_RX) && (conn->peer_add_path & ADD_PATH_TX);
p->add_path_tx = (p->cf->add_path & ADD_PATH_TX) && (conn->peer_add_path & ADD_PATH_RX);
- p->gr_ready = p->cf->gr_mode && conn->peer_gr_able;
+ p->gr_ready = (p->cf->gr_mode && conn->peer_gr_able) ||
+ (p->cf->llgr_mode && conn->peer_llgr_able);
p->ext_messages = p->cf->enable_extended_messages && conn->peer_ext_messages_support;
/* Update RA mode */
e->net = n;
e->pflags = 0;
e->u.bgp.suppressed = 0;
+ e->u.bgp.stale = -1;
rte_update2(p->p.main_ahook, n, e, *src);
}
memcpy(&(e->u), &(new->u), sizeof(e->u));
e->pref = new->pref;
e->pflags = new->pflags;
+
+#ifdef CONFIG_BGP
+ /* Hack to cleanup cached value */
+ if (e->attrs->src->proto->proto == &proto_bgp)
+ e->u.bgp.stale = -1;
+#endif
}
src = a.src;
projects / thirdparty / bird.git / commitdiff
