2 * BIRD -- Bidirectional Forwarding Detection (BFD)
4 * Can be freely distributed and used under the terms of the GNU GPL.
8 * DOC: Bidirectional Forwarding Detection
10 * The BFD protocol is implemented in three files: |bfd.c| containing the
11 * protocol logic and the protocol glue with BIRD core, |packets.c| handling BFD
12 * packet processing, RX, TX and protocol sockets. |io.c| then contains generic
13 * code for the event loop, threads and event sources (sockets, microsecond
14 * timers). This generic code will be merged to the main BIRD I/O code in the
17 * The BFD implementation uses a separate thread with an internal event loop for
18 * handling the protocol logic, which requires high-res and low-latency timing,
19 * so it is not affected by the rest of BIRD, which has several low-granularity
20 * hooks in the main loop, uses second-based timers and cannot offer good
21 * latency. The core of BFD protocol (the code related to BFD sessions,
22 * interfaces and packets) runs in the BFD thread, while the rest (the code
23 * related to BFD requests, BFD neighbors and the protocol glue) runs in the
26 * BFD sessions are represented by structure &bfd_session that contains a state
27 * related to the session and two timers (TX timer for periodic packets and hold
28 * timer for session timeout). These sessions are allocated from @session_slab
29 * and are accessible by two hash tables, @session_hash_id (by session ID) and
30 * @session_hash_ip (by IP addresses of neighbors). Slab and both hashes are in
31 * the main protocol structure &bfd_proto. The protocol logic related to BFD
32 * sessions is implemented in internal functions bfd_session_*(), which are
33 * expected to be called from the context of BFD thread, and external functions
34 * bfd_add_session(), bfd_remove_session() and bfd_reconfigure_session(), which
35 * form an interface to the BFD core for the rest and are expected to be called
36 * from the context of main thread.
38 * Each BFD session has an associated BFD interface, represented by structure
39 * &bfd_iface. A BFD interface contains a socket used for TX (the one for RX is
40 * shared in &bfd_proto), an interface configuration and reference counter.
41 * Compared to interface structures of other protocols, these structures are not
42 * created and removed based on interface notification events, but according to
43 * the needs of BFD sessions. When a new session is created, it requests a
44 * proper BFD interface by function bfd_get_iface(), which either finds an
45 * existing one in &iface_list (from &bfd_proto) or allocates a new one. When a
46 * session is removed, an associated iface is discharged by bfd_free_iface().
48 * BFD requests are the external API for the other protocols. When a protocol
49 * wants a BFD session, it calls bfd_request_session(), which creates a
50 * structure &bfd_request containing approprite information and an notify hook.
51 * This structure is a resource associated with the caller's resource pool. When
52 * a BFD protocol is available, a BFD request is submitted to the protocol, an
53 * appropriate BFD session is found or created and the request is attached to
54 * the session. When a session changes state, all attached requests (and related
55 * protocols) are notified. Note that BFD requests do not depend on BFD protocol
56 * running. When the BFD protocol is stopped or removed (or not available from
57 * beginning), related BFD requests are stored in @bfd_wait_list, where waits
60 * BFD neighbors are just a way to statically configure BFD sessions without
61 * requests from other protocol. Structures &bfd_neighbor are part of BFD
62 * configuration (like static routes in the static protocol). BFD neighbors are
63 * handled by BFD protocol like it is a BFD client -- when a BFD neighbor is
64 * ready, the protocol just creates a BFD request like any other protocol.
66 * The protocol uses a new generic event loop (structure &birdloop) from |io.c|,
67 * which supports sockets, timers and events like the main loop. Timers
68 * (structure &timer2) are new microsecond based timers, while sockets and
69 * events are the same. A birdloop is associated with a thread (field @thread)
70 * in which event hooks are executed. Most functions for setting event sources
71 * (like sk_start() or tm2_start()) must be called from the context of that
72 * thread. Birdloop allows to temporarily acquire the context of that thread for
73 * the main thread by calling birdloop_enter() and then birdloop_leave(), which
74 * also ensures mutual exclusion with all event hooks. Note that resources
75 * associated with a birdloop (like timers) should be attached to the
76 * independent resource pool, detached from the main resource tree.
78 * There are two kinds of interaction between the BFD core (running in the BFD
79 * thread) and the rest of BFD (running in the main thread). The first kind are
80 * configuration calls from main thread to the BFD thread (like bfd_add_session()).
81 * These calls are synchronous and use birdloop_enter() mechanism for mutual
82 * exclusion. The second kind is a notification about session changes from the
83 * BFD thread to the main thread. This is done in an asynchronous way, sesions
84 * with pending notifications are linked (in the BFD thread) to @notify_list in
85 * &bfd_proto, and then bfd_notify_hook() in the main thread is activated using
86 * bfd_notify_kick() and a pipe. The hook then processes scheduled sessions and
87 * calls hooks from associated BFD requests. This @notify_list (and state fields
88 * in structure &bfd_session) is protected by a spinlock in &bfd_proto and
89 * functions bfd_lock_sessions() / bfd_unlock_sessions().
91 * There are few data races (accessing @p->p.debug from TRACE() from the BFD
92 * thread and accessing some some private fields of %bfd_session from
93 * bfd_show_sessions() from the main thread, but these are harmless (i hope).
95 * TODO: document functions and access restrictions for fields in BFD structures.
97 * Supported standards:
98 * - RFC 5880 - main BFD standard
99 * - RFC 5881 - BFD for IP links
100 * - RFC 5882 - generic application of BFD
101 * - RFC 5883 - BFD for multihop paths
107 #define HASH_ID_KEY(n) n->loc_id
108 #define HASH_ID_NEXT(n) n->next_id
109 #define HASH_ID_EQ(a,b) a == b
110 #define HASH_ID_FN(k) k
112 #define HASH_IP_KEY(n) n->addr
113 #define HASH_IP_NEXT(n) n->next_ip
114 #define HASH_IP_EQ(a,b) ipa_equal(a,b)
115 #define HASH_IP_FN(k) ipa_hash(k)
117 static list bfd_proto_list
;
118 static list bfd_wait_list
;
120 const char *bfd_state_names
[] = { "AdminDown", "Down", "Init", "Up" };
122 static void bfd_session_set_min_tx(struct bfd_session
*s
, u32 val
);
123 static struct bfd_iface
*bfd_get_iface(struct bfd_proto
*p
, ip_addr local
, struct iface
*iface
);
124 static void bfd_free_iface(struct bfd_iface
*ifa
);
125 static inline void bfd_notify_kick(struct bfd_proto
*p
);
133 bfd_session_update_state(struct bfd_session
*s
, uint state
, uint diag
)
135 struct bfd_proto
*p
= s
->ifa
->bfd
;
136 uint old_state
= s
->loc_state
;
139 if (state
== old_state
)
142 TRACE(D_EVENTS
, "Session to %I changed state from %s to %s",
143 s
->addr
, bfd_state_names
[old_state
], bfd_state_names
[state
]);
145 bfd_lock_sessions(p
);
146 s
->loc_state
= state
;
149 notify
= !NODE_VALID(&s
->n
);
151 add_tail(&p
->notify_list
, &s
->n
);
152 bfd_unlock_sessions(p
);
154 if (state
== BFD_STATE_UP
)
155 bfd_session_set_min_tx(s
, s
->ifa
->cf
->min_tx_int
);
157 if (old_state
== BFD_STATE_UP
)
158 bfd_session_set_min_tx(s
, s
->ifa
->cf
->idle_tx_int
);
165 bfd_session_update_tx_interval(struct bfd_session
*s
)
167 u32 tx_int
= MAX(s
->des_min_tx_int
, s
->rem_min_rx_int
);
168 u32 tx_int_l
= tx_int
- (tx_int
/ 4); // 75 %
169 u32 tx_int_h
= tx_int
- (tx_int
/ 10); // 90 %
171 s
->tx_timer
->recurrent
= tx_int_l
;
172 s
->tx_timer
->randomize
= tx_int_h
- tx_int_l
;
174 /* Do not set timer if no previous event */
178 /* Set timer relative to last tx_timer event */
179 tm2_set(s
->tx_timer
, s
->last_tx
+ tx_int_l
);
183 bfd_session_update_detection_time(struct bfd_session
*s
, int kick
)
185 btime timeout
= (btime
) MAX(s
->req_min_rx_int
, s
->rem_min_tx_int
) * s
->rem_detect_mult
;
188 s
->last_rx
= current_time();
193 tm2_set(s
->hold_timer
, s
->last_rx
+ timeout
);
197 bfd_session_control_tx_timer(struct bfd_session
*s
, int reset
)
199 // if (!s->opened) goto stop;
201 if (s
->passive
&& (s
->rem_id
== 0))
204 if (s
->rem_demand_mode
&&
206 (s
->loc_state
== BFD_STATE_UP
) &&
207 (s
->rem_state
== BFD_STATE_UP
))
210 if (s
->rem_min_rx_int
== 0)
213 /* So TX timer should run */
214 if (reset
|| !tm2_active(s
->tx_timer
))
217 tm2_start(s
->tx_timer
, 0);
223 tm2_stop(s
->tx_timer
);
228 bfd_session_request_poll(struct bfd_session
*s
, u8 request
)
230 /* Not sure about this, but doing poll in this case does not make sense */
234 s
->poll_scheduled
|= request
;
239 s
->poll_active
= s
->poll_scheduled
;
240 s
->poll_scheduled
= 0;
242 bfd_session_control_tx_timer(s
, 1);
246 bfd_session_terminate_poll(struct bfd_session
*s
)
248 u8 poll_done
= s
->poll_active
& ~s
->poll_scheduled
;
250 if (poll_done
& BFD_POLL_TX
)
251 s
->des_min_tx_int
= s
->des_min_tx_new
;
253 if (poll_done
& BFD_POLL_RX
)
254 s
->req_min_rx_int
= s
->req_min_rx_new
;
256 s
->poll_active
= s
->poll_scheduled
;
257 s
->poll_scheduled
= 0;
259 /* Timers are updated by caller - bfd_session_process_ctl() */
263 bfd_session_process_ctl(struct bfd_session
*s
, u8 flags
, u32 old_tx_int
, u32 old_rx_int
)
265 if (s
->poll_active
&& (flags
& BFD_FLAG_FINAL
))
266 bfd_session_terminate_poll(s
);
268 if ((s
->des_min_tx_int
!= old_tx_int
) || (s
->rem_min_rx_int
!= old_rx_int
))
269 bfd_session_update_tx_interval(s
);
271 bfd_session_update_detection_time(s
, 1);
273 /* Update session state */
275 int diag
= BFD_DIAG_NOTHING
;
277 switch (s
->loc_state
)
279 case BFD_STATE_ADMIN_DOWN
:
283 if (s
->rem_state
== BFD_STATE_DOWN
) next_state
= BFD_STATE_INIT
;
284 else if (s
->rem_state
== BFD_STATE_INIT
) next_state
= BFD_STATE_UP
;
288 if (s
->rem_state
== BFD_STATE_ADMIN_DOWN
) next_state
= BFD_STATE_DOWN
, diag
= BFD_DIAG_NEIGHBOR_DOWN
;
289 else if (s
->rem_state
>= BFD_STATE_INIT
) next_state
= BFD_STATE_UP
;
293 if (s
->rem_state
<= BFD_STATE_DOWN
) next_state
= BFD_STATE_DOWN
, diag
= BFD_DIAG_NEIGHBOR_DOWN
;
298 bfd_session_update_state(s
, next_state
, diag
);
300 bfd_session_control_tx_timer(s
, 0);
302 if (flags
& BFD_FLAG_POLL
)
303 bfd_send_ctl(s
->ifa
->bfd
, s
, 1);
307 bfd_session_timeout(struct bfd_session
*s
)
309 struct bfd_proto
*p
= s
->ifa
->bfd
;
311 TRACE(D_EVENTS
, "Session to %I expired", s
->addr
);
313 s
->rem_state
= BFD_STATE_DOWN
;
315 s
->rem_min_tx_int
= 0;
316 s
->rem_min_rx_int
= 1;
317 s
->rem_demand_mode
= 0;
318 s
->rem_detect_mult
= 0;
321 s
->poll_scheduled
= 0;
323 bfd_session_update_state(s
, BFD_STATE_DOWN
, BFD_DIAG_TIMEOUT
);
325 bfd_session_control_tx_timer(s
, 1);
329 bfd_session_set_min_tx(struct bfd_session
*s
, u32 val
)
331 /* Note that des_min_tx_int <= des_min_tx_new */
333 if (val
== s
->des_min_tx_new
)
336 s
->des_min_tx_new
= val
;
338 /* Postpone timer update if des_min_tx_int increases and the session is up */
339 if ((s
->loc_state
!= BFD_STATE_UP
) || (val
< s
->des_min_tx_int
))
341 s
->des_min_tx_int
= val
;
342 bfd_session_update_tx_interval(s
);
345 bfd_session_request_poll(s
, BFD_POLL_TX
);
349 bfd_session_set_min_rx(struct bfd_session
*s
, u32 val
)
351 /* Note that req_min_rx_int >= req_min_rx_new */
353 if (val
== s
->req_min_rx_new
)
356 s
->req_min_rx_new
= val
;
358 /* Postpone timer update if req_min_rx_int decreases and the session is up */
359 if ((s
->loc_state
!= BFD_STATE_UP
) || (val
> s
->req_min_rx_int
))
361 s
->req_min_rx_int
= val
;
362 bfd_session_update_detection_time(s
, 0);
365 bfd_session_request_poll(s
, BFD_POLL_RX
);
369 bfd_find_session_by_id(struct bfd_proto
*p
, u32 id
)
371 return HASH_FIND(p
->session_hash_id
, HASH_ID
, id
);
375 bfd_find_session_by_addr(struct bfd_proto
*p
, ip_addr addr
)
377 return HASH_FIND(p
->session_hash_ip
, HASH_IP
, addr
);
381 bfd_tx_timer_hook(timer2
*t
)
383 struct bfd_session
*s
= t
->data
;
385 s
->last_tx
= current_time();
386 bfd_send_ctl(s
->ifa
->bfd
, s
, 0);
390 bfd_hold_timer_hook(timer2
*t
)
392 bfd_session_timeout(t
->data
);
396 bfd_get_free_id(struct bfd_proto
*p
)
399 for (id
= random_u32(); 1; id
++)
400 if (id
&& !bfd_find_session_by_id(p
, id
))
406 static struct bfd_session
*
407 bfd_add_session(struct bfd_proto
*p
, ip_addr addr
, ip_addr local
, struct iface
*iface
)
409 birdloop_enter(p
->loop
);
411 struct bfd_iface
*ifa
= bfd_get_iface(p
, local
, iface
);
413 struct bfd_session
*s
= sl_alloc(p
->session_slab
);
414 bzero(s
, sizeof(struct bfd_session
));
418 s
->loc_id
= bfd_get_free_id(p
);
420 HASH_INSERT(p
->session_hash_id
, HASH_ID
, s
);
421 HASH_INSERT(p
->session_hash_ip
, HASH_IP
, s
);
424 /* Initialization of state variables - see RFC 5880 6.8.1 */
425 s
->loc_state
= BFD_STATE_DOWN
;
426 s
->rem_state
= BFD_STATE_DOWN
;
427 s
->des_min_tx_int
= s
->des_min_tx_new
= ifa
->cf
->idle_tx_int
;
428 s
->req_min_rx_int
= s
->req_min_rx_new
= ifa
->cf
->min_rx_int
;
429 s
->rem_min_rx_int
= 1;
430 s
->detect_mult
= ifa
->cf
->multiplier
;
431 s
->passive
= ifa
->cf
->passive
;
433 s
->tx_timer
= tm2_new_init(p
->tpool
, bfd_tx_timer_hook
, s
, 0, 0);
434 s
->hold_timer
= tm2_new_init(p
->tpool
, bfd_hold_timer_hook
, s
, 0, 0);
435 bfd_session_update_tx_interval(s
);
436 bfd_session_control_tx_timer(s
, 1);
438 init_list(&s
->request_list
);
439 s
->last_state_change
= now
;
441 TRACE(D_EVENTS
, "Session to %I added", s
->addr
);
443 birdloop_leave(p
->loop
);
450 bfd_open_session(struct bfd_proto *p, struct bfd_session *s, ip_addr local, struct iface *ifa)
452 birdloop_enter(p->loop);
456 bfd_session_control_tx_timer(s);
458 birdloop_leave(p->loop);
462 bfd_close_session(struct bfd_proto *p, struct bfd_session *s)
464 birdloop_enter(p->loop);
468 bfd_session_update_state(s, BFD_STATE_DOWN, BFD_DIAG_PATH_DOWN);
469 bfd_session_control_tx_timer(s);
471 birdloop_leave(p->loop);
476 bfd_remove_session(struct bfd_proto
*p
, struct bfd_session
*s
)
478 ip_addr ip
= s
->addr
;
480 /* Caller should ensure that request list is empty */
482 birdloop_enter(p
->loop
);
484 /* Remove session from notify list if scheduled for notification */
485 /* No need for bfd_lock_sessions(), we are already protected by birdloop_enter() */
486 if (NODE_VALID(&s
->n
))
489 bfd_free_iface(s
->ifa
);
492 rfree(s
->hold_timer
);
494 HASH_REMOVE(p
->session_hash_id
, HASH_ID
, s
);
495 HASH_REMOVE(p
->session_hash_ip
, HASH_IP
, s
);
497 sl_free(p
->session_slab
, s
);
499 TRACE(D_EVENTS
, "Session to %I removed", ip
);
501 birdloop_leave(p
->loop
);
505 bfd_reconfigure_session(struct bfd_proto
*p
, struct bfd_session
*s
)
507 birdloop_enter(p
->loop
);
509 struct bfd_iface_config
*cf
= s
->ifa
->cf
;
511 u32 tx
= (s
->loc_state
== BFD_STATE_UP
) ? cf
->min_tx_int
: cf
->idle_tx_int
;
512 bfd_session_set_min_tx(s
, tx
);
513 bfd_session_set_min_rx(s
, cf
->min_rx_int
);
514 s
->detect_mult
= cf
->multiplier
;
515 s
->passive
= cf
->passive
;
517 bfd_session_control_tx_timer(s
, 0);
519 birdloop_leave(p
->loop
);
521 TRACE(D_EVENTS
, "Session to %I reconfigured", s
->addr
);
529 static struct bfd_iface_config bfd_default_iface
= {
530 .min_rx_int
= BFD_DEFAULT_MIN_RX_INT
,
531 .min_tx_int
= BFD_DEFAULT_MIN_TX_INT
,
532 .idle_tx_int
= BFD_DEFAULT_IDLE_TX_INT
,
533 .multiplier
= BFD_DEFAULT_MULTIPLIER
536 static inline struct bfd_iface_config
*
537 bfd_find_iface_config(struct bfd_config
*cf
, struct iface
*iface
)
539 struct bfd_iface_config
*ic
;
541 ic
= iface
? (void *) iface_patt_find(&cf
->patt_list
, iface
, NULL
) : cf
->multihop
;
543 return ic
? ic
: &bfd_default_iface
;
546 static struct bfd_iface
*
547 bfd_get_iface(struct bfd_proto
*p
, ip_addr local
, struct iface
*iface
)
549 struct bfd_iface
*ifa
;
551 WALK_LIST(ifa
, p
->iface_list
)
552 if (ipa_equal(ifa
->local
, local
) && (ifa
->iface
== iface
))
553 return ifa
->uc
++, ifa
;
555 struct bfd_config
*cf
= (struct bfd_config
*) (p
->p
.cf
);
556 struct bfd_iface_config
*ic
= bfd_find_iface_config(cf
, iface
);
558 ifa
= mb_allocz(p
->tpool
, sizeof(struct bfd_iface
));
564 ifa
->sk
= bfd_open_tx_sk(p
, local
, iface
);
567 add_tail(&p
->iface_list
, &ifa
->n
);
573 bfd_free_iface(struct bfd_iface
*ifa
)
575 if (!ifa
|| --ifa
->uc
)
589 bfd_reconfigure_iface(struct bfd_proto
*p
, struct bfd_iface
*ifa
, struct bfd_config
*nc
)
591 struct bfd_iface_config
*nic
= bfd_find_iface_config(nc
, ifa
->iface
);
592 ifa
->changed
= !!memcmp(nic
, ifa
->cf
, sizeof(struct bfd_iface_config
));
594 /* This should be probably changed to not access ifa->cf from the BFD thread */
595 birdloop_enter(p
->loop
);
597 birdloop_leave(p
->loop
);
606 bfd_request_notify(struct bfd_request
*req
, u8 state
, u8 diag
)
608 u8 old_state
= req
->state
;
610 if (state
== old_state
)
615 req
->old_state
= old_state
;
616 req
->down
= (old_state
== BFD_STATE_UP
) && (state
== BFD_STATE_DOWN
);
623 bfd_add_request(struct bfd_proto
*p
, struct bfd_request
*req
)
625 struct bfd_session
*s
= bfd_find_session_by_addr(p
, req
->addr
);
629 s
= bfd_add_session(p
, req
->addr
, req
->local
, req
->iface
);
632 add_tail(&s
->request_list
, &req
->n
);
635 bfd_lock_sessions(p
);
636 state
= s
->loc_state
;
638 bfd_unlock_sessions(p
);
640 bfd_request_notify(req
, state
, diag
);
646 bfd_submit_request(struct bfd_request
*req
)
650 WALK_LIST(n
, bfd_proto_list
)
651 if (bfd_add_request(SKIP_BACK(struct bfd_proto
, bfd_node
, n
), req
))
655 add_tail(&bfd_wait_list
, &req
->n
);
657 bfd_request_notify(req
, BFD_STATE_ADMIN_DOWN
, 0);
661 bfd_take_requests(struct bfd_proto
*p
)
665 WALK_LIST_DELSAFE(n
, nn
, bfd_wait_list
)
666 bfd_add_request(p
, SKIP_BACK(struct bfd_request
, n
, n
));
670 bfd_drop_requests(struct bfd_proto
*p
)
674 HASH_WALK(p
->session_hash_id
, next_id
, s
)
676 /* We assume that p is not in bfd_proto_list */
677 WALK_LIST_FIRST(n
, s
->request_list
)
678 bfd_submit_request(SKIP_BACK(struct bfd_request
, n
, n
));
683 static struct resclass bfd_request_class
;
686 bfd_request_session(pool
*p
, ip_addr addr
, ip_addr local
, struct iface
*iface
,
687 void (*hook
)(struct bfd_request
*), void *data
)
689 struct bfd_request
*req
= ralloc(p
, &bfd_request_class
);
691 /* Hack: self-link req->n, we will call rem_node() on it */
692 req
->n
.prev
= req
->n
.next
= &req
->n
;
698 bfd_submit_request(req
);
707 bfd_request_free(resource
*r
)
709 struct bfd_request
*req
= (struct bfd_request
*) r
;
710 struct bfd_session
*s
= req
->session
;
714 /* Remove the session if there is no request for it. Skip that if
715 inside notify hooks, will be handled by bfd_notify_hook() itself */
717 if (s
&& EMPTY_LIST(s
->request_list
) && !s
->notify_running
)
718 bfd_remove_session(s
->ifa
->bfd
, s
);
722 bfd_request_dump(resource
*r
)
724 struct bfd_request
*req
= (struct bfd_request
*) r
;
726 debug("(code %p, data %p)\n", req
->hook
, req
->data
);
729 static struct resclass bfd_request_class
= {
731 sizeof(struct bfd_request
),
744 bfd_neigh_notify(struct neighbor
*nb
)
746 struct bfd_proto
*p
= (struct bfd_proto
*) nb
->proto
;
747 struct bfd_neighbor
*n
= nb
->data
;
752 if ((nb
->scope
> 0) && !n
->req
)
754 ip_addr local
= ipa_nonzero(n
->local
) ? n
->local
: nb
->ifa
->ip
;
755 n
->req
= bfd_request_session(p
->p
.pool
, n
->addr
, local
, nb
->iface
, NULL
, NULL
);
758 if ((nb
->scope
<= 0) && n
->req
)
766 bfd_start_neighbor(struct bfd_proto
*p
, struct bfd_neighbor
*n
)
772 n
->req
= bfd_request_session(p
->p
.pool
, n
->addr
, n
->local
, NULL
, NULL
, NULL
);
776 struct neighbor
*nb
= neigh_find2(&p
->p
, &n
->addr
, n
->iface
, NEF_STICKY
);
779 log(L_ERR
"%s: Invalid remote address %I%J", p
->p
.name
, n
->addr
, n
->iface
);
785 log(L_ERR
"%s: Duplicate neighbor %I", p
->p
.name
, n
->addr
);
793 bfd_neigh_notify(nb
);
795 TRACE(D_EVENTS
, "Waiting for %I%J to become my neighbor", n
->addr
, n
->iface
);
799 bfd_stop_neighbor(struct bfd_proto
*p
, struct bfd_neighbor
*n
)
802 n
->neigh
->data
= NULL
;
810 bfd_same_neighbor(struct bfd_neighbor
*x
, struct bfd_neighbor
*y
)
812 return ipa_equal(x
->addr
, y
->addr
) && ipa_equal(x
->local
, y
->local
) &&
813 (x
->iface
== y
->iface
) && (x
->multihop
== y
->multihop
);
817 bfd_reconfigure_neighbors(struct bfd_proto
*p
, struct bfd_config
*new)
819 struct bfd_config
*old
= (struct bfd_config
*) (p
->p
.cf
);
820 struct bfd_neighbor
*on
, *nn
;
822 WALK_LIST(on
, old
->neigh_list
)
824 WALK_LIST(nn
, new->neigh_list
)
825 if (bfd_same_neighbor(nn
, on
))
827 nn
->neigh
= on
->neigh
;
829 nn
->neigh
->data
= nn
;
836 bfd_stop_neighbor(p
, on
);
839 WALK_LIST(nn
, new->neigh_list
)
841 bfd_start_neighbor(p
, nn
);
849 /* This core notify code should be replaced after main loop transition to birdloop */
851 int pipe(int pipefd
[2]);
852 void pipe_drain(int fd
);
853 void pipe_kick(int fd
);
856 bfd_notify_hook(sock
*sk
, int len
)
858 struct bfd_proto
*p
= sk
->data
;
859 struct bfd_session
*s
;
866 bfd_lock_sessions(p
);
867 init_list(&tmp_list
);
868 add_tail_list(&tmp_list
, &p
->notify_list
);
869 init_list(&p
->notify_list
);
870 bfd_unlock_sessions(p
);
872 WALK_LIST_FIRST(s
, tmp_list
)
874 bfd_lock_sessions(p
);
876 state
= s
->loc_state
;
878 bfd_unlock_sessions(p
);
880 /* FIXME: convert to btime and move to bfd_session_update_state() */
881 s
->last_state_change
= now
;
883 s
->notify_running
= 1;
884 WALK_LIST_DELSAFE(n
, nn
, s
->request_list
)
885 bfd_request_notify(SKIP_BACK(struct bfd_request
, n
, n
), state
, diag
);
886 s
->notify_running
= 0;
888 /* Remove the session if all requests were removed in notify hooks */
889 if (EMPTY_LIST(s
->request_list
))
890 bfd_remove_session(p
, s
);
897 bfd_notify_kick(struct bfd_proto
*p
)
899 pipe_kick(p
->notify_ws
->fd
);
903 bfd_noterr_hook(sock
*sk
, int err
)
905 struct bfd_proto
*p
= sk
->data
;
906 log(L_ERR
"%s: Notify socket error: %m", p
->p
.name
, err
);
910 bfd_notify_init(struct bfd_proto
*p
)
919 sk
= sk_new(p
->p
.pool
);
921 sk
->rx_hook
= bfd_notify_hook
;
922 sk
->err_hook
= bfd_noterr_hook
;
926 die("bfd: sk_open failed");
929 /* The write sock is not added to any event loop */
930 sk
= sk_new(p
->p
.pool
);
934 sk
->flags
= SKF_THREAD
;
936 die("bfd: sk_open failed");
948 init_list(&bfd_proto_list
);
949 init_list(&bfd_wait_list
);
952 static struct proto
*
953 bfd_init(struct proto_config
*c
)
955 struct proto
*p
= proto_new(c
);
957 p
->neigh_notify
= bfd_neigh_notify
;
963 bfd_start(struct proto
*P
)
965 struct bfd_proto
*p
= (struct bfd_proto
*) P
;
966 struct bfd_config
*cf
= (struct bfd_config
*) (P
->cf
);
968 p
->loop
= birdloop_new();
969 p
->tpool
= rp_new(NULL
, "BFD thread root");
970 pthread_spin_init(&p
->lock
, PTHREAD_PROCESS_PRIVATE
);
972 p
->session_slab
= sl_new(P
->pool
, sizeof(struct bfd_session
));
973 HASH_INIT(p
->session_hash_id
, P
->pool
, 8);
974 HASH_INIT(p
->session_hash_ip
, P
->pool
, 8);
976 init_list(&p
->iface_list
);
978 init_list(&p
->notify_list
);
981 add_tail(&bfd_proto_list
, &p
->bfd_node
);
983 birdloop_enter(p
->loop
);
984 p
->rx4_1
= bfd_open_rx_sk(p
, 0, 4);
985 p
->rx4_m
= bfd_open_rx_sk(p
, 1, 4);
986 p
->rx6_1
= bfd_open_rx_sk(p
, 0, 6);
987 p
->rx6_m
= bfd_open_rx_sk(p
, 1, 6);
988 birdloop_leave(p
->loop
);
990 bfd_take_requests(p
);
992 struct bfd_neighbor
*n
;
993 WALK_LIST(n
, cf
->neigh_list
)
994 bfd_start_neighbor(p
, n
);
996 birdloop_start(p
->loop
);
1003 bfd_shutdown(struct proto
*P
)
1005 struct bfd_proto
*p
= (struct bfd_proto
*) P
;
1006 struct bfd_config
*cf
= (struct bfd_config
*) (P
->cf
);
1008 rem_node(&p
->bfd_node
);
1010 birdloop_stop(p
->loop
);
1012 struct bfd_neighbor
*n
;
1013 WALK_LIST(n
, cf
->neigh_list
)
1014 bfd_stop_neighbor(p
, n
);
1016 bfd_drop_requests(p
);
1018 /* FIXME: This is hack */
1019 birdloop_enter(p
->loop
);
1021 birdloop_leave(p
->loop
);
1023 birdloop_free(p
->loop
);
1029 bfd_reconfigure(struct proto
*P
, struct proto_config
*c
)
1031 struct bfd_proto
*p
= (struct bfd_proto
*) P
;
1032 // struct bfd_config *old = (struct bfd_config *) (P->cf);
1033 struct bfd_config
*new = (struct bfd_config
*) c
;
1034 struct bfd_iface
*ifa
;
1036 birdloop_mask_wakeups(p
->loop
);
1038 WALK_LIST(ifa
, p
->iface_list
)
1039 bfd_reconfigure_iface(p
, ifa
, new);
1041 HASH_WALK(p
->session_hash_id
, next_id
, s
)
1043 if (s
->ifa
->changed
)
1044 bfd_reconfigure_session(p
, s
);
1048 bfd_reconfigure_neighbors(p
, new);
1050 birdloop_unmask_wakeups(p
->loop
);
1055 /* Ensure one instance */
1056 struct bfd_config
*bfd_cf
;
1059 bfd_preconfig(struct protocol
*P UNUSED
, struct config
*c UNUSED
)
1065 bfd_copy_config(struct proto_config
*dest
, struct proto_config
*src
)
1067 struct bfd_config
*d
= (struct bfd_config
*) dest
;
1068 // struct bfd_config *s = (struct bfd_config *) src;
1070 /* We clean up patt_list and neigh_list, neighbors and ifaces are non-sharable */
1071 init_list(&d
->patt_list
);
1072 init_list(&d
->neigh_list
);
1076 bfd_show_sessions(struct proto
*P
)
1078 byte tbuf
[TM_DATETIME_BUFFER_SIZE
];
1079 struct bfd_proto
*p
= (struct bfd_proto
*) P
;
1080 uint state
, diag UNUSED
;
1081 u32 tx_int
, timeout
;
1084 if (p
->p
.proto_state
!= PS_UP
)
1086 cli_msg(-1020, "%s: is not up", p
->p
.name
);
1091 cli_msg(-1020, "%s:", p
->p
.name
);
1092 cli_msg(-1020, "%-25s %-10s %-10s %-10s %8s %8s",
1093 "IP address", "Interface", "State", "Since", "Interval", "Timeout");
1096 HASH_WALK(p
->session_hash_id
, next_id
, s
)
1098 /* FIXME: this is thread-unsafe, but perhaps harmless */
1099 state
= s
->loc_state
;
1101 ifname
= (s
->ifa
&& s
->ifa
->iface
) ? s
->ifa
->iface
->name
: "---";
1102 tx_int
= s
->last_tx
? (MAX(s
->des_min_tx_int
, s
->rem_min_rx_int
) TO_MS
) : 0;
1103 timeout
= (MAX(s
->req_min_rx_int
, s
->rem_min_tx_int
) TO_MS
) * s
->rem_detect_mult
;
1105 state
= (state
< 4) ? state
: 0;
1106 tm_format_datetime(tbuf
, &config
->tf_proto
, s
->last_state_change
);
1108 cli_msg(-1020, "%-25I %-10s %-10s %-10s %3u.%03u %3u.%03u",
1109 s
->addr
, ifname
, bfd_state_names
[state
], tbuf
,
1110 tx_int
/ 1000, tx_int
% 1000, timeout
/ 1000, timeout
% 1000);
1118 struct protocol proto_bfd
= {
1120 .template = "bfd%d",
1121 .proto_size
= sizeof(struct bfd_proto
),
1122 .config_size
= sizeof(struct bfd_config
),
1125 .shutdown
= bfd_shutdown
,
1126 .reconfigure
= bfd_reconfigure
,
1127 .preconfig
= bfd_preconfig
,
1128 .copy_config
= bfd_copy_config
,