mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2025-01-23 17:31:55 +00:00
Code Releases Activity

BFD: direct notifications to protocol loops

Browse Source
This commit is contained in:
Maria Matejka 2022-02-02 11:20:53 +01:00
parent 09380db594
commit d262695d4e
10 changed files with 182 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/event.h
View File

@ -63,6 +63,7 @@ static inline void ev_init_cork(struct event_cork *ec, const char *name)
};
void ev_send(event_list *, event *);
#define ev_send_self(e) ({ ASSERT_DIE((e)->list); ev_send((e)->list, (e)); })
#define ev_send_loop(l, e) ev_send(birdloop_event_list((l)), (e))
#define ev_schedule(e) ({ ASSERT_THE_BIRD_LOCKED; if (!ev_active((e))) ev_send(&global_event_list, (e)); })

12
nest/bfd.h
View File

@ -23,6 +23,11 @@ struct bfd_options {
u8 mode;
};
struct bfd_session_state {
u8 state;
u8 diag;
};
struct bfd_request {
resource r;
node n;
@ -35,12 +40,12 @@ struct bfd_request {
void (*hook)(struct bfd_request *);
void *data;
event event;
struct bfd_session *session;
struct bfd_session_state old_state;
u8 state;
u8 diag;
u8 old_state;
u8 down;
};
@ -51,13 +56,12 @@ struct bfd_request {
#define BFD_STATE_INIT 2
#define BFD_STATE_UP 3
static inline struct bfd_options * bfd_new_options(void)
{ return cfg_allocz(sizeof(struct bfd_options)); }
#ifdef CONFIG_BFD
struct bfd_request * bfd_request_session(pool *p, ip_addr addr, ip_addr local, struct iface *iface, struct iface *vrf, void (*hook)(struct bfd_request *), void *data, const struct bfd_options *opts);
struct bfd_request * bfd_request_session(pool *p, ip_addr addr, ip_addr local, struct iface *iface, struct iface *vrf, void (*hook)(struct bfd_request *), void *data, struct event_list *list, const struct bfd_options *opts);
void bfd_update_request(struct bfd_request *req, const struct bfd_options *opts);
static inline void cf_check_bfd(int use UNUSED) { }

8
nest/proto.c
View File

@ -1762,8 +1762,14 @@ protos_commit(struct config *new, struct config *old, int force_reconfig, int ty
nc->proto = p;
/* We will try to reconfigure protocol p */
if (! force_reconfig && proto_reconfigure(p, oc, nc, type))
if (!force_reconfig)
{
int ok;
PROTO_LOCKED_FROM_MAIN(p)
ok = proto_reconfigure(p, oc, nc, type);
if (ok)
continue;
}
if (nc->parent)
{

386
proto/bfd/bfd.c
View File

@ -116,20 +116,23 @@
DEFINE_DOMAIN(rtable);
#define BFD_LOCK LOCK_DOMAIN(rtable, bfd_global.lock)
#define BFD_UNLOCK UNLOCK_DOMAIN(rtable, bfd_global.lock)
#define BFD_ASSERT_LOCKED ASSERT_DIE(DOMAIN_IS_LOCKED(rtable, bfd_global.lock))
static struct {
DOMAIN(rtable) lock;
list wait_list;
list pickup_list;
list proto_list;
} bfd_global;
static struct bfd_session bfd_admin_down = { .loc = { .state = BFD_STATE_ADMIN_DOWN }, };
const char *bfd_state_names[] = { "AdminDown", "Down", "Init", "Up" };
static void bfd_session_set_min_tx(struct bfd_session *s, u32 val);
static struct bfd_iface *bfd_get_iface(struct bfd_proto *p, ip_addr local, struct iface *iface);
static void bfd_free_iface(struct bfd_iface *ifa);
static inline void bfd_notify_kick(struct bfd_proto *p);
static void bfd_remove_session(struct bfd_proto *p, struct bfd_session *s);
static void bfd_reconfigure_session_hook(void *vsession);
/*
@ -148,37 +151,57 @@ bfd_merge_options(const struct bfd_iface_config *cf, const struct bfd_options *o
};
}
static void
static int
bfd_session_update_state(struct bfd_session *s, uint state, uint diag)
{
struct bfd_proto *p = s->ifa->bfd;
uint old_state = s->loc_state;
int notify;
uint old_state = BFD_LOC_STATE(s).state;
if (state == old_state)
return;
{
if (current_time() > s->last_reqlist_check + 5 S)
{
BFD_LOCK;
if (EMPTY_LIST(s->request_list))
{
bfd_remove_session(p, s);
BFD_UNLOCK;
return 1;
}
s->last_reqlist_check = current_time();
BFD_UNLOCK;
}
return 0;
}
TRACE(D_EVENTS, "Session to %I changed state from %s to %s",
s->addr, bfd_state_names[old_state], bfd_state_names[state]);
bfd_lock_sessions(p);
s->loc_state = state;
s->loc_diag = diag;
atomic_store_explicit(&s->loc, ((struct bfd_session_state) { .state = state, .diag = diag }), memory_order_release);
s->last_state_change = current_time();
notify = !NODE_VALID(&s->n);
if (notify)
add_tail(&p->notify_list, &s->n);
bfd_unlock_sessions(p);
if (state == BFD_STATE_UP)
bfd_session_set_min_tx(s, s->cf.min_tx_int);
if (old_state == BFD_STATE_UP)
bfd_session_set_min_tx(s, s->cf.idle_tx_int);
if (notify)
bfd_notify_kick(p);
BFD_LOCK;
if (EMPTY_LIST(s->request_list))
{
bfd_remove_session(p, s);
BFD_UNLOCK;
return 1;
}
struct bfd_request *req;
node *nn;
WALK_LIST2(req, nn, s->request_list, n)
ev_send_self(&req->event);
BFD_UNLOCK;
return 0;
}
static void
@ -223,8 +246,8 @@ bfd_session_control_tx_timer(struct bfd_session *s, int reset)
if (s->rem_demand_mode &&
!s->poll_active &&
(s->loc_state == BFD_STATE_UP) &&
(s->rem_state == BFD_STATE_UP))
(BFD_LOC_STATE(s).state == BFD_STATE_UP) &&
(s->rem.state == BFD_STATE_UP))
goto stop;
if (s->rem_min_rx_int == 0)
@ -294,28 +317,29 @@ bfd_session_process_ctl(struct bfd_session *s, u8 flags, u32 old_tx_int, u32 old
int next_state = 0;
int diag = BFD_DIAG_NOTHING;
switch (s->loc_state)
switch (BFD_LOC_STATE(s).state)
{
case BFD_STATE_ADMIN_DOWN:
return;
case BFD_STATE_DOWN:
if (s->rem_state == BFD_STATE_DOWN) next_state = BFD_STATE_INIT;
else if (s->rem_state == BFD_STATE_INIT) next_state = BFD_STATE_UP;
if (s->rem.state == BFD_STATE_DOWN) next_state = BFD_STATE_INIT;
else if (s->rem.state == BFD_STATE_INIT) next_state = BFD_STATE_UP;
break;
case BFD_STATE_INIT:
if (s->rem_state == BFD_STATE_ADMIN_DOWN) next_state = BFD_STATE_DOWN, diag = BFD_DIAG_NEIGHBOR_DOWN;
else if (s->rem_state >= BFD_STATE_INIT) next_state = BFD_STATE_UP;
if (s->rem.state == BFD_STATE_ADMIN_DOWN) next_state = BFD_STATE_DOWN, diag = BFD_DIAG_NEIGHBOR_DOWN;
else if (s->rem.state >= BFD_STATE_INIT) next_state = BFD_STATE_UP;
break;
case BFD_STATE_UP:
if (s->rem_state <= BFD_STATE_DOWN) next_state = BFD_STATE_DOWN, diag = BFD_DIAG_NEIGHBOR_DOWN;
if (s->rem.state <= BFD_STATE_DOWN) next_state = BFD_STATE_DOWN, diag = BFD_DIAG_NEIGHBOR_DOWN;
break;
}
if (next_state)
bfd_session_update_state(s, next_state, diag);
if (bfd_session_update_state(s, next_state, diag))
return;
bfd_session_control_tx_timer(s, 0);
@ -330,7 +354,7 @@ bfd_session_timeout(struct bfd_session *s)
TRACE(D_EVENTS, "Session to %I expired", s->addr);
s->rem_state = BFD_STATE_DOWN;
s->rem.state = BFD_STATE_DOWN;
s->rem_id = 0;
s->rem_min_tx_int = 0;
s->rem_min_rx_int = 1;
@ -341,7 +365,8 @@ bfd_session_timeout(struct bfd_session *s)
s->poll_active = 0;
s->poll_scheduled = 0;
bfd_session_update_state(s, BFD_STATE_DOWN, BFD_DIAG_TIMEOUT);
if (bfd_session_update_state(s, BFD_STATE_DOWN, BFD_DIAG_TIMEOUT))
return;
bfd_session_control_tx_timer(s, 1);
}
@ -357,7 +382,7 @@ bfd_session_set_min_tx(struct bfd_session *s, u32 val)
s->des_min_tx_new = val;
/* Postpone timer update if des_min_tx_int increases and the session is up */
if ((s->loc_state != BFD_STATE_UP) || (val < s->des_min_tx_int))
if ((BFD_LOC_STATE(s).state != BFD_STATE_UP) || (val < s->des_min_tx_int))
{
s->des_min_tx_int = val;
bfd_session_update_tx_interval(s);
@ -377,7 +402,7 @@ bfd_session_set_min_rx(struct bfd_session *s, u32 val)
s->req_min_rx_new = val;
/* Postpone timer update if req_min_rx_int decreases and the session is up */
if ((s->loc_state != BFD_STATE_UP) || (val > s->req_min_rx_int))
if ((BFD_LOC_STATE(s).state != BFD_STATE_UP) || (val > s->req_min_rx_int))
{
s->req_min_rx_int = val;
bfd_session_update_detection_time(s, 0);
@ -389,12 +414,14 @@ bfd_session_set_min_rx(struct bfd_session *s, u32 val)
struct bfd_session *
bfd_find_session_by_id(struct bfd_proto *p, u32 id)
{
ASSERT_DIE(birdloop_inside(p->p.loop));
return HASH_FIND(p->session_hash_id, HASH_ID, id);
}
struct bfd_session *
bfd_find_session_by_addr(struct bfd_proto *p, ip_addr addr, uint ifindex)
{
ASSERT_DIE(birdloop_inside(p->p.loop));
return HASH_FIND(p->session_hash_ip, HASH_IP, addr, ifindex);
}
@ -428,6 +455,7 @@ static struct bfd_session *
bfd_add_session(struct bfd_proto *p, ip_addr addr, ip_addr local, struct iface *iface, struct bfd_options *opts)
{
ASSERT_DIE(birdloop_inside(p->p.loop));
BFD_ASSERT_LOCKED;
struct bfd_iface *ifa = bfd_get_iface(p, local, iface);
@ -441,10 +469,15 @@ bfd_add_session(struct bfd_proto *p, ip_addr addr, ip_addr local, struct iface *
HASH_INSERT(p->session_hash_ip, HASH_IP, s);
s->cf = bfd_merge_options(ifa->cf, opts);
s->update_event = (event) {
.hook = bfd_reconfigure_session_hook,
.data = s,
.list = birdloop_event_list(p->p.loop),
};
/* Initialization of state variables - see RFC 5880 6.8.1 */
s->loc_state = BFD_STATE_DOWN;
s->rem_state = BFD_STATE_DOWN;
atomic_store_explicit(&s->loc, ((struct bfd_session_state) { .state = BFD_STATE_DOWN }), memory_order_relaxed);
s->rem.state = BFD_STATE_DOWN;
s->des_min_tx_int = s->des_min_tx_new = s->cf.idle_tx_int;
s->req_min_rx_int = s->req_min_rx_new = s->cf.min_rx_int;
s->rem_min_rx_int = 1;
@ -465,42 +498,12 @@ bfd_add_session(struct bfd_proto *p, ip_addr addr, ip_addr local, struct iface *
return s;
}
/*
static void
bfd_open_session(struct bfd_proto *p, struct bfd_session *s, ip_addr local, struct iface *ifa)
bfd_remove_session(struct bfd_proto *p, struct bfd_session *s)
{
birdloop_enter(p->p.loop);
s->opened = 1;
bfd_session_control_tx_timer(s);
birdloop_leave(p->p.loop);
}
static void
bfd_close_session(struct bfd_proto *p, struct bfd_session *s)
{
birdloop_enter(p->p.loop);
s->opened = 0;
bfd_session_update_state(s, BFD_STATE_DOWN, BFD_DIAG_PATH_DOWN);
bfd_session_control_tx_timer(s);
birdloop_leave(p->p.loop);
}
*/
static void
bfd_remove_session_locked(struct bfd_proto *p, struct bfd_session *s)
{
/* Caller should ensure that request list is empty */
/* Remove session from notify list if scheduled for notification */
/* No need for bfd_lock_sessions(), we are already protected by birdloop_enter() */
if (NODE_VALID(&s->n))
rem_node(&s->n);
ASSERT_DIE(birdloop_inside(p->p.loop));
BFD_ASSERT_LOCKED;
ASSERT_DIE(EMPTY_LIST(s->request_list));
bfd_free_iface(s->ifa);
@ -515,26 +518,22 @@ bfd_remove_session_locked(struct bfd_proto *p, struct bfd_session *s)
sl_free(p->session_slab, s);
}
static void
bfd_remove_session(struct bfd_proto *p, struct bfd_session *s)
{
birdloop_enter(p->p.loop);
bfd_remove_session_locked(p, s);
birdloop_leave(p->p.loop);
}
static void
bfd_reconfigure_session(struct bfd_proto *p, struct bfd_session *s)
{
ASSERT_DIE(birdloop_inside(p->p.loop));
BFD_LOCK;
if (EMPTY_LIST(s->request_list))
{
bfd_remove_session(p, s);
BFD_UNLOCK;
return;
birdloop_enter(p->p.loop);
}
struct bfd_request *req = SKIP_BACK(struct bfd_request, n, HEAD(s->request_list));
s->cf = bfd_merge_options(s->ifa->cf, &req->opts);
u32 tx = (s->loc_state == BFD_STATE_UP) ? s->cf.min_tx_int : s->cf.idle_tx_int;
u32 tx = (BFD_LOC_STATE(s).state == BFD_STATE_UP) ? s->cf.min_tx_int : s->cf.idle_tx_int;
bfd_session_set_min_tx(s, tx);
bfd_session_set_min_rx(s, s->cf.min_rx_int);
s->detect_mult = s->cf.multiplier;
@ -542,9 +541,15 @@ bfd_reconfigure_session(struct bfd_proto *p, struct bfd_session *s)
bfd_session_control_tx_timer(s, 0);
birdloop_leave(p->p.loop);
TRACE(D_EVENTS, "Session to %I reconfigured", s->addr);
BFD_UNLOCK;
}
static void
bfd_reconfigure_session_hook(void *data)
{
struct bfd_session *s = data;
return bfd_reconfigure_session(s->ifa->bfd, s);
}
@ -612,7 +617,7 @@ bfd_free_iface(struct bfd_iface *ifa)
}
static void
bfd_reconfigure_iface(struct bfd_proto *p, struct bfd_iface *ifa, struct bfd_config *nc)
bfd_reconfigure_iface(struct bfd_proto *p UNUSED, struct bfd_iface *ifa, struct bfd_config *nc)
{
struct bfd_iface_config *new = bfd_find_iface_config(nc, ifa->iface);
struct bfd_iface_config *old = ifa->cf;
@ -626,9 +631,7 @@ bfd_reconfigure_iface(struct bfd_proto *p, struct bfd_iface *ifa, struct bfd_con
(new->passive != old->passive);
/* This should be probably changed to not access ifa->cf from the BFD thread */
birdloop_enter(p->p.loop);
ifa->cf = new;
birdloop_leave(p->p.loop);
}
@ -637,17 +640,22 @@ bfd_reconfigure_iface(struct bfd_proto *p, struct bfd_iface *ifa, struct bfd_con
*/
static void
bfd_request_notify(struct bfd_request *req, u8 state, u8 diag)
bfd_request_notify(void *data)
{
u8 old_state = req->state;
struct bfd_request *req = data;
struct bfd_session_state old = req->old_state;
if (state == old_state)
BFD_LOCK; /* Needed to safely access req->session */
struct bfd_session_state new = atomic_load_explicit(&req->session->loc, memory_order_acquire);
BFD_UNLOCK;
if (new.state == old.state)
return;
req->state = state;
req->diag = diag;
req->old_state = old_state;
req->down = (old_state == BFD_STATE_UP) && (state == BFD_STATE_DOWN);
req->state = new.state;
req->diag = new.diag;
req->old_state = new;
req->down = (old.state == BFD_STATE_UP) && (new.state == BFD_STATE_DOWN);
if (req->hook)
req->hook(req);
@ -656,6 +664,9 @@ bfd_request_notify(struct bfd_request *req, u8 state, u8 diag)
static int
bfd_add_request(struct bfd_proto *p, struct bfd_request *req)
{
BFD_ASSERT_LOCKED;
ASSERT_DIE(req->session == &bfd_admin_down);
struct bfd_config *cf = (struct bfd_config *) (p->p.cf);
if (p->p.vrf && (p->p.vrf != req->vrf))
@ -669,7 +680,6 @@ bfd_add_request(struct bfd_proto *p, struct bfd_request *req)
uint ifindex = req->iface ? req->iface->index : 0;
struct bfd_session *s = bfd_find_session_by_addr(p, req->addr, ifindex);
u8 state, diag;
if (!s)
s = bfd_add_session(p, req->addr, req->local, req->iface, &req->opts);
@ -678,12 +688,7 @@ bfd_add_request(struct bfd_proto *p, struct bfd_request *req)
add_tail(&s->request_list, &req->n);
req->session = s;
bfd_lock_sessions(p);
state = s->loc_state;
diag = s->loc_diag;
bfd_unlock_sessions(p);
bfd_request_notify(req, state, diag);
ev_send_self(&req->event);
return 1;
}
@ -691,41 +696,35 @@ bfd_add_request(struct bfd_proto *p, struct bfd_request *req)
static void
bfd_pickup_requests(void *_data UNUSED)
{
node *n;
WALK_LIST(n, bfd_global.proto_list)
struct bfd_proto *p;
node *nn;
WALK_LIST2(p, nn, bfd_global.proto_list, bfd_node)
{
struct bfd_proto *p = SKIP_BACK(struct bfd_proto, bfd_node, n);
birdloop_enter(p->p.loop);
BFD_LOCK;
struct bfd_request *req;
node *rn, *rnxt;
WALK_LIST_DELSAFE(rn, rnxt, bfd_global.pickup_list)
bfd_add_request(p, SKIP_BACK(struct bfd_request, n, rn));
WALK_LIST2_DELSAFE(req, rn, rnxt, bfd_global.wait_list, n)
bfd_add_request(p, req);
BFD_UNLOCK;
birdloop_ping(p->p.loop);
birdloop_leave(p->p.loop);
}
BFD_LOCK;
node *rn, *rnxt;
WALK_LIST_DELSAFE(rn, rnxt, bfd_global.pickup_list)
{
rem_node(rn);
add_tail(&bfd_global.wait_list, rn);
bfd_request_notify(SKIP_BACK(struct bfd_request, n, rn), BFD_STATE_ADMIN_DOWN, 0);
}
BFD_UNLOCK;
}
static event bfd_pickup_event = { .hook = bfd_pickup_requests };
#define bfd_schedule_pickup() ev_send(&global_event_list, &bfd_pickup_event)
static void
bfd_take_requests(struct bfd_proto *p)
{
struct bfd_request *req;
node *n, *nn;
BFD_LOCK;
WALK_LIST_DELSAFE(n, nn, bfd_global.wait_list)
bfd_add_request(p, SKIP_BACK(struct bfd_request, n, n));
WALK_LIST2_DELSAFE(req, n, nn, bfd_global.wait_list, n)
bfd_add_request(p, req);
BFD_UNLOCK;
}
@ -740,14 +739,13 @@ bfd_drop_requests(struct bfd_proto *p)
{
struct bfd_request *req = SKIP_BACK(struct bfd_request, n, n);
rem_node(&req->n);
add_tail(&bfd_global.pickup_list, &req->n);
req->session = NULL;
bfd_request_notify(req, BFD_STATE_ADMIN_DOWN, 0);
add_tail(&bfd_global.wait_list, &req->n);
req->session = &bfd_admin_down;
ev_send_self(&req->event);
}
ev_send(&global_event_list, &bfd_pickup_event);
bfd_remove_session_locked(p, s);
bfd_schedule_pickup();
bfd_remove_session(p, s);
}
HASH_WALK_END;
BFD_UNLOCK;
@ -759,6 +757,7 @@ struct bfd_request *
bfd_request_session(pool *p, ip_addr addr, ip_addr local,
struct iface *iface, struct iface *vrf,
void (*hook)(struct bfd_request *), void *data,
struct event_list *list,
const struct bfd_options *opts)
{
struct bfd_request *req = ralloc(p, &bfd_request_class);
@ -773,12 +772,16 @@ bfd_request_session(pool *p, ip_addr addr, ip_addr local,
req->hook = hook;
req->data = data;
req->session = NULL;
req->event = (event) {
.hook = bfd_request_notify,
.data = req,
.list = list,
};
BFD_LOCK;
add_tail(&bfd_global.pickup_list, &req->n);
ev_send(&global_event_list, &bfd_pickup_event);
req->session = &bfd_admin_down;
add_tail(&bfd_global.wait_list, &req->n);
bfd_schedule_pickup();
BFD_UNLOCK;
return req;
@ -787,30 +790,29 @@ bfd_request_session(pool *p, ip_addr addr, ip_addr local,
void
bfd_update_request(struct bfd_request *req, const struct bfd_options *opts)
{
struct bfd_session *s = req->session;
if (!memcmp(opts, &req->opts, sizeof(const struct bfd_options)))
return;
BFD_LOCK;
req->opts = *opts;
if (s)
bfd_reconfigure_session(s->ifa->bfd, s);
struct bfd_session *s = req->session;
if (s != &bfd_admin_down)
ev_send_self(&s->update_event);
BFD_UNLOCK;
}
static void
bfd_request_free(resource *r)
{
struct bfd_request *req = (struct bfd_request *) r;
struct bfd_session *s = req->session;
BFD_LOCK;
rem_node(&req->n);
BFD_UNLOCK;
/* Remove the session if there is no request for it. Skip that if
inside notify hooks, will be handled by bfd_notify_hook() itself */
if (s && EMPTY_LIST(s->request_list) && !s->notify_running)
bfd_remove_session(s->ifa->bfd, s);
ev_postpone(&req->event);
}
static void
@ -847,7 +849,7 @@ bfd_neigh_notify(struct neighbor *nb)
if ((nb->scope > 0) && !n->req)
{
ip_addr local = ipa_nonzero(n->local) ? n->local : nb->ifa->ip;
n->req = bfd_request_session(p->p.pool, n->addr, local, nb->iface, p->p.vrf, NULL, NULL, NULL);
n->req = bfd_request_session(p->p.pool, n->addr, local, nb->iface, p->p.vrf, NULL, NULL, birdloop_event_list(p->p.loop), NULL);
}
if ((nb->scope <= 0) && n->req)
@ -864,7 +866,7 @@ bfd_start_neighbor(struct bfd_proto *p, struct bfd_neighbor *n)
if (n->multihop)
{
n->req = bfd_request_session(p->p.pool, n->addr, n->local, NULL, p->p.vrf, NULL, NULL, NULL);
n->req = bfd_request_session(p->p.pool, n->addr, n->local, NULL, p->p.vrf, NULL, NULL, birdloop_event_list(p->p.loop), NULL);
return;
}
@ -938,100 +940,6 @@ bfd_reconfigure_neighbors(struct bfd_proto *p, struct bfd_config *new)
}
/*
* BFD notify socket
*/
/* This core notify code should be replaced after main loop transition to birdloop */
int pipe(int pipefd[2]);
void pipe_drain(int fd);
void pipe_kick(int fd);
static int
bfd_notify_hook(sock *sk, uint len UNUSED)
{
struct bfd_proto *p = sk->data;
struct bfd_session *s;
list tmp_list;
u8 state, diag;
node *n, *nn;
pipe_drain(sk->fd);
bfd_lock_sessions(p);
init_list(&tmp_list);
add_tail_list(&tmp_list, &p->notify_list);
init_list(&p->notify_list);
bfd_unlock_sessions(p);
WALK_LIST_FIRST(s, tmp_list)
{
bfd_lock_sessions(p);
rem_node(&s->n);
state = s->loc_state;
diag = s->loc_diag;
bfd_unlock_sessions(p);
s->notify_running = 1;
WALK_LIST_DELSAFE(n, nn, s->request_list)
bfd_request_notify(SKIP_BACK(struct bfd_request, n, n), state, diag);
s->notify_running = 0;
/* Remove the session if all requests were removed in notify hooks */
if (EMPTY_LIST(s->request_list))
bfd_remove_session(p, s);
}
return 0;
}
static inline void
bfd_notify_kick(struct bfd_proto *p)
{
pipe_kick(p->notify_ws->fd);
}
static void
bfd_noterr_hook(sock *sk, int err)
{
struct bfd_proto *p = sk->data;
log(L_ERR "%s: Notify socket error: %m", p->p.name, err);
}
static void
bfd_notify_init(struct bfd_proto *p)
{
int pfds[2];
sock *sk;
int rv = pipe(pfds);
if (rv < 0)
die("pipe: %m");
sk = sk_new(p->p.pool);
sk->type = SK_MAGIC;
sk->rx_hook = bfd_notify_hook;
sk->err_hook = bfd_noterr_hook;
sk->fd = pfds[0];
sk->data = p;
if (sk_open(sk) < 0)
die("bfd: sk_open failed");
p->notify_rs = sk;
/* The write sock is not added to any event loop */
sk = sk_new(p->p.pool);
sk->type = SK_MAGIC;
sk->fd = pfds[1];
sk->data = p;
sk->flags = SKF_THREAD;
sk->loop = p->p.loop;
if (sk_open(sk) < 0)
die("bfd: sk_open failed");
p->notify_ws = sk;
}
/*
* BFD protocol glue
*/
@ -1041,7 +949,6 @@ bfd_init_all(void)
{
bfd_global.lock = DOMAIN_NEW(rtable, "BFD Global");
init_list(&bfd_global.wait_list);
init_list(&bfd_global.pickup_list);
init_list(&bfd_global.proto_list);
}
@ -1061,17 +968,12 @@ bfd_start(struct proto *P)
struct bfd_proto *p = (struct bfd_proto *) P;
struct bfd_config *cf = (struct bfd_config *) (P->cf);
pthread_spin_init(&p->lock, PTHREAD_PROCESS_PRIVATE);
p->session_slab = sl_new(P->pool, sizeof(struct bfd_session));
HASH_INIT(p->session_hash_id, P->pool, 8);
HASH_INIT(p->session_hash_ip, P->pool, 8);
init_list(&p->iface_list);
init_list(&p->notify_list);
bfd_notify_init(p);
add_tail(&bfd_global.proto_list, &p->bfd_node);
if (cf->accept_ipv4 && cf->accept_direct)
@ -1125,6 +1027,8 @@ bfd_reconfigure(struct proto *P, struct proto_config *c)
struct bfd_config *new = (struct bfd_config *) c;
struct bfd_iface *ifa;
ASSERT_DIE(birdloop_inside(P->loop));
/* TODO: Improve accept reconfiguration */
if ((new->accept_ipv4 != old->accept_ipv4) ||
(new->accept_ipv6 != old->accept_ipv6) ||
@ -1137,12 +1041,12 @@ bfd_reconfigure(struct proto *P, struct proto_config *c)
WALK_LIST(ifa, p->iface_list)
bfd_reconfigure_iface(p, ifa, new);
HASH_WALK(p->session_hash_id, next_id, s)
HASH_WALK_DELSAFE(p->session_hash_id, next_id, s)
{
if (s->ifa->changed)
bfd_reconfigure_session(p, s);
}
HASH_WALK_END;
HASH_WALK_DELSAFE_END;
bfd_reconfigure_neighbors(p, new);
@ -1167,13 +1071,14 @@ bfd_show_sessions(struct proto *P)
{
byte tbuf[TM_DATETIME_BUFFER_SIZE];
struct bfd_proto *p = (struct bfd_proto *) P;
uint state, diag UNUSED;
btime tx_int, timeout;
const char *ifname;
birdloop_enter(P->loop);
if (p->p.proto_state != PS_UP)
{
cli_msg(-1020, "%s: is not up", p->p.name);
birdloop_leave(P->loop);
return;
}
@ -1181,12 +1086,9 @@ bfd_show_sessions(struct proto *P)
cli_msg(-1020, "%-25s %-10s %-10s %-12s %8s %8s",
"IP address", "Interface", "State", "Since", "Interval", "Timeout");
HASH_WALK(p->session_hash_id, next_id, s)
{
/* FIXME: this is thread-unsafe, but perhaps harmless */
state = s->loc_state;
diag = s->loc_diag;
uint state = BFD_LOC_STATE(s).state;
ifname = (s->ifa && s->ifa->iface) ? s->ifa->iface->name : "---";
tx_int = s->last_tx ? MAX(s->des_min_tx_int, s->rem_min_rx_int) : 0;
timeout = (btime) MAX(s->req_min_rx_int, s->rem_min_tx_int) * s->rem_detect_mult;
@ -1198,6 +1100,8 @@ bfd_show_sessions(struct proto *P)
s->addr, ifname, bfd_state_names[state], tbuf, tx_int, timeout);
}
HASH_WALK_END;
birdloop_leave(P->loop);
}

23
proto/bfd/bfd.h
View File

@ -88,18 +88,12 @@ struct bfd_proto
{
struct proto p;
pthread_spinlock_t lock;
node bfd_node;
slab *session_slab;
HASH(struct bfd_session) session_hash_id;
HASH(struct bfd_session) session_hash_ip;
sock *notify_rs;
sock *notify_ws;
list notify_list;
sock *rx4_1;
sock *rx6_1;
sock *rx4_m;
@ -122,7 +116,6 @@ struct bfd_iface
struct bfd_session
{
node n;
ip_addr addr; /* Address of session */
struct bfd_iface *ifa; /* Iface associated with session */
struct bfd_session *next_id; /* Next in bfd.session_hash_id */
@ -133,14 +126,15 @@ struct bfd_session
u8 poll_active;
u8 poll_scheduled;
u8 loc_state;
u8 rem_state;
u8 loc_diag;
u8 rem_diag;
_Atomic struct bfd_session_state loc;
struct bfd_session_state rem;
#define BFD_LOC_STATE(s) atomic_load_explicit(&(s)->loc, memory_order_relaxed)
u32 loc_id; /* Local session ID (local discriminator) */
u32 rem_id; /* Remote session ID (remote discriminator) */
struct bfd_session_config cf; /* Static configuration parameters */
struct bfd_session_config cf; /* Static configuration parameers */
event update_event; /* Reconfiguration requested */
u32 des_min_tx_int; /* Desired min rx interval, local option */
u32 des_min_tx_new; /* Used for des_min_tx_int change */
@ -162,6 +156,7 @@ struct bfd_session
list request_list; /* List of client requests (struct bfd_request) */
btime last_state_change; /* Time of last state change */
btime last_reqlist_check; /* Time of last check whether the request list is not empty */
u8 notify_running; /* 1 if notify hooks are running */
u8 rx_csn_known; /* Received crypto sequence number is known */
@ -208,10 +203,6 @@ extern const char *bfd_state_names[];
extern const u8 bfd_auth_type_to_hash_alg[];
static inline void bfd_lock_sessions(struct bfd_proto *p) { pthread_spin_lock(&p->lock); }
static inline void bfd_unlock_sessions(struct bfd_proto *p) { pthread_spin_unlock(&p->lock); }
/* bfd.c */
struct bfd_session * bfd_find_session_by_id(struct bfd_proto *p, u32 id);
struct bfd_session * bfd_find_session_by_addr(struct bfd_proto *p, ip_addr addr, uint ifindex);

15
proto/bfd/packets.c
View File

@ -290,9 +290,11 @@ bfd_send_ctl(struct bfd_proto *p, struct bfd_session *s, int final)
if (!sk)
return;
struct bfd_session_state loc = BFD_LOC_STATE(s);
pkt = (struct bfd_ctl_packet *) sk->tbuf;
pkt->vdiag = bfd_pack_vdiag(1, s->loc_diag);
pkt->flags = bfd_pack_flags(s->loc_state, 0);
pkt->vdiag = bfd_pack_vdiag(1, loc.diag);
pkt->flags = bfd_pack_flags(loc.state, 0);
pkt->detect_mult = s->detect_mult;
pkt->length = BFD_BASE_LEN;
pkt->snd_id = htonl(s->loc_id);
@ -313,7 +315,7 @@ bfd_send_ctl(struct bfd_proto *p, struct bfd_session *s, int final)
log(L_WARN "%s: Old packet overwritten in TX buffer", p->p.name);
TRACE(D_PACKETS, "Sending CTL to %I [%s%s]", s->addr,
bfd_state_names[s->loc_state], bfd_format_flags(pkt->flags, fb));
bfd_state_names[loc.state], bfd_format_flags(pkt->flags, fb));
sk_send_to(sk, pkt->length, s->addr, sk->dport);
}
@ -382,16 +384,17 @@ bfd_rx_hook(sock *sk, uint len)
u32 old_rx_int = s->rem_min_rx_int;
s->rem_id= ntohl(pkt->snd_id);
s->rem_state = bfd_pkt_get_state(pkt);
s->rem_diag = bfd_pkt_get_diag(pkt);
s->rem.state = bfd_pkt_get_state(pkt);
s->rem.diag = bfd_pkt_get_diag(pkt);
s->rem_demand_mode = pkt->flags & BFD_FLAG_DEMAND;
s->rem_min_tx_int = ntohl(pkt->des_min_tx_int);
s->rem_min_rx_int = ntohl(pkt->req_min_rx_int);
s->rem_detect_mult = pkt->detect_mult;
TRACE(D_PACKETS, "CTL received from %I [%s%s]", sk->faddr,
bfd_state_names[s->rem_state], bfd_format_flags(pkt->flags, fb));
bfd_state_names[s->rem.state], bfd_format_flags(pkt->flags, fb));
/* This call may drop the session, must be called in tail position */
bfd_session_process_ctl(s, pkt->flags, old_tx_int, old_rx_int);
return 1;

2
proto/bgp/bgp.c
View File

@ -1460,7 +1460,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)
{

2
proto/ospf/neighbor.c
View File

@ -777,7 +777,7 @@ ospf_neigh_update_bfd(struct ospf_neighbor *n, int use_bfd)
if (use_bfd && !n->bfd_req)
n->bfd_req = bfd_request_session(n->pool, n->ip, n->ifa->addr->ip,
n->ifa->iface, p->p.vrf,
ospf_neigh_bfd_hook, n, NULL);
ospf_neigh_bfd_hook, n, birdloop_event_list(p->p.loop), NULL);
if (!use_bfd && n->bfd_req)
{

2
proto/rip/rip.c
View File

@ -513,7 +513,7 @@ rip_update_bfd(struct rip_proto *p, struct rip_neighbor *n)
ip_addr saddr = rip_is_v2(p) ? n->ifa->sk->saddr : n->nbr->ifa->ip;
n->bfd_req = bfd_request_session(p->p.pool, n->nbr->addr, saddr,
n->nbr->iface, p->p.vrf,
rip_bfd_notify, n, NULL);
rip_bfd_notify, n, birdloop_event_list(p->p.loop), NULL);
}
if (!use_bfd && n->bfd_req)

2
proto/static/static.c
View File

@ -206,7 +206,7 @@ static_update_bfd(struct static_proto *p, struct static_route *r)
// ip_addr local = ipa_nonzero(r->local) ? r->local : nb->ifa->ip;
r->bfd_req = bfd_request_session(p->p.pool, r->via, nb->ifa->ip,
nb->iface, p->p.vrf,
static_bfd_notify, r, NULL);
static_bfd_notify, r, birdloop_event_list(p->p.loop), NULL);
}
if (!bfd_up && r->bfd_req)