21 #include <openssl/sha.h> 25 #include <x86intrin.h> 44 #if defined(clib_crc32c_uses_intrinsics) && !defined (__i386__) 45 checksum = crc32_u64 (0, discriminator);
46 checksum = crc32_u64 (checksum, expire_time);
47 checksum = crc32_u64 (checksum, secret);
49 checksum =
clib_xxhash (discriminator ^ expire_time ^ secret);
83 s =
format (s,
"{auth-type=%u:%s, conf-key-id=%u, use-count=%u}, ",
106 int handling_wakeup);
135 BFD_DBG (
"set local_diag, bs_idx=%d: '%d:%s'", bs->
bs_idx, code,
163 return "BFD_POLL_" #x; 175 BFD_DBG (
"Setting poll state=%s, bs_idx=%u",
186 BFD_DBG (
"Recalculated transmit interval " BFD_CLK_FMT,
195 BFD_DBG (
"Recalculated echo transmit interval " BFD_CLK_FMT,
214 BFD_DBG (
"Missed %lu transmit events (now is %lu, calc " 215 "tx_timeout is %lu)",
233 BFD_DBG (
"Missed %lu transmit events (now is %lu, calc " 234 "tx_timeout is %lu)",
242 BFD_DBG (
"Next transmit in %lu nsec/%.02fs@%lu",
257 BFD_DBG (
"Missed %lu echo transmit events (now is %lu, calc tx_timeout " 264 BFD_DBG (
"Next echo transmit in %lu nsec/%.02fs@%lu",
279 BFD_DBG (
"Recalculated detection time %lu nsec/%.3fs",
302 if (tx_timeout && rx_timeout)
304 next =
clib_min (tx_timeout, rx_timeout);
318 BFD_DBG (
"bs_idx=%u, tx_timeout=%lu, echo_tx_timeout=%lu, rx_timeout=%lu, " 328 u32 wheel_time_ticks =
331 BFD_DBG (
"event_time_nsec %lu (%lu nsec/%.3fs in future) -> " 335 wheel_time_ticks = wheel_time_ticks ? wheel_time_ticks : 1;
340 BFD_DBG (
"tw_timer_update(%p, %u, %lu);", &bm->wheel, bs->
tw_id,
347 BFD_DBG (
"tw_timer_start(%p, %u, 0, %lu) == %u;", &bm->wheel,
348 bs->
bs_idx, wheel_time_ticks);
351 if (!handling_wakeup)
390 u64 desired_min_tx_nsec)
393 BFD_DBG (
"Set effective desired min tx to " BFD_CLK_FMT,
404 u64 required_min_rx_nsec)
407 BFD_DBG (
"Set effective required min rx to " BFD_CLK_FMT,
414 u64 now,
u32 remote_required_min_rx_usec)
420 BFD_DBG (
"Set remote min rx to " BFD_CLK_FMT,
430 u32 remote_required_min_echo_rx_usec)
437 BFD_DBG (
"Set remote min echo rx to " BFD_CLK_FMT,
500 const bfd_pkt_t *pkt = (bfd_pkt_t *) t->
data;
503 s =
format (s,
"BFD v%u, diag=%u(%s), state=%u(%s),\n" 504 " flags=(P:%u, F:%u, C:%u, A:%u, D:%u, M:%u), " 505 "detect_mult=%u, length=%u\n",
515 if (t->
len >= sizeof (bfd_pkt_t) &&
516 pkt->head.length >= sizeof (bfd_pkt_t))
518 s =
format (s,
" my discriminator: %u\n",
519 clib_net_to_host_u32 (pkt->my_disc));
520 s =
format (s,
" your discriminator: %u\n",
521 clib_net_to_host_u32 (pkt->your_disc));
522 s =
format (s,
" desired min tx interval: %u\n",
523 clib_net_to_host_u32 (pkt->des_min_tx));
524 s =
format (s,
" required min rx interval: %u\n",
525 clib_net_to_host_u32 (pkt->req_min_rx));
526 s =
format (s,
" required min echo rx interval: %u",
527 clib_net_to_host_u32 (pkt->req_min_echo_rx));
529 if (t->
len >= sizeof (bfd_pkt_with_common_auth_t) &&
530 pkt->head.length >= sizeof (bfd_pkt_with_common_auth_t) &&
533 const bfd_pkt_with_common_auth_t *with_auth = (
void *) pkt;
534 const bfd_auth_common_t *common = &with_auth->common_auth;
535 s =
format (s,
"\n auth len: %u\n", common->len);
536 s =
format (s,
" auth type: %u:%s\n", common->type,
538 if (t->
len >= sizeof (bfd_pkt_with_sha1_auth_t) &&
539 pkt->head.length >= sizeof (bfd_pkt_with_sha1_auth_t) &&
540 (BFD_AUTH_TYPE_keyed_sha1 == common->type ||
541 BFD_AUTH_TYPE_meticulous_keyed_sha1 == common->type))
543 const bfd_pkt_with_sha1_auth_t *with_sha1 = (
void *) pkt;
544 const bfd_auth_sha1_t *sha1 = &with_sha1->sha1_auth;
545 s =
format (s,
" seq num: %u\n",
546 clib_net_to_host_u32 (sha1->seq_num));
547 s =
format (s,
" key id: %u\n", sha1->key_id);
549 sizeof (sha1->hash));
583 BFD_DBG (
"Ignoring event RPC for non-existent session index %u",
621 BFD_DBG (
"Ignoring notify RPC for non-existent session index %u",
655 case BFD_STATE_admin_down:
725 case BFD_TRANSPORT_UDP4:
729 case BFD_TRANSPORT_UDP6:
741 case BFD_TRANSPORT_UDP4:
745 case BFD_TRANSPORT_UDP6:
758 case BFD_TRANSPORT_UDP4:
759 BFD_DBG (
"Transport bfd echo via udp4, bs_idx=%u", bs->
bs_idx);
762 case BFD_TRANSPORT_UDP6:
763 BFD_DBG (
"Transport bfd echo via udp6, bs_idx=%u", bs->
bs_idx);
775 case BFD_TRANSPORT_UDP4:
776 BFD_DBG (
"Transport bfd echo via udp4, bs_idx=%u", bs->
bs_idx);
779 case BFD_TRANSPORT_UDP6:
780 BFD_DBG (
"Transport bfd echo via udp6, bs_idx=%u", bs->
bs_idx);
792 bfd_auth_sha1_t *auth = &pkt->sha1_auth;
794 pkt->pkt.head.length +=
sizeof (*auth);
803 auth->type_len.len =
sizeof (bfd_auth_sha1_t);
812 unsigned char hash[
sizeof (auth->hash)];
813 SHA1 ((
unsigned char *) pkt,
sizeof (*pkt), hash);
828 case BFD_AUTH_TYPE_reserved:
830 case BFD_AUTH_TYPE_simple_password:
832 case BFD_AUTH_TYPE_keyed_md5:
834 case BFD_AUTH_TYPE_meticulous_keyed_md5:
836 "internal error, unexpected BFD auth type '%d'",
840 case BFD_AUTH_TYPE_keyed_sha1:
842 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
843 bfd_add_sha1_auth_section (b, bs);
846 case BFD_AUTH_TYPE_keyed_sha1:
848 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
850 "internal error, unexpected BFD auth type '%d'",
866 case BFD_TRANSPORT_UDP4:
868 case BFD_TRANSPORT_UDP6:
881 bfd_length =
sizeof (bfd_pkt_t);
887 pkt->head.length = bfd_length;
902 pkt->req_min_echo_rx = clib_host_to_net_u32 (1);
931 pkt->expire_time_nsec =
939 BFD_ERR (
"cannot send echo packet out, turning echo off");
946 BFD_ERR (
"cannot send echo packet out, turning echo off");
957 (
"No need to send echo packet now, now is %lu, tx_timeout is %lu",
968 BFD_DBG (
"Remote min rx interval is zero, not sending periodic control " 981 BFD_DBG (
"Remote demand is set, not sending periodic control frame");
1000 case BFD_POLL_NEEDED:
1001 if (now < bs->poll_state_start_or_timeout_nsec)
1003 BFD_DBG (
"Cannot start a poll sequence yet, need to wait for " 1012 case BFD_POLL_IN_PROGRESS:
1013 case BFD_POLL_IN_PROGRESS_AND_QUEUED:
1015 BFD_DBG (
"Setting poll bit in packet, bs_idx=%u", bs->
bs_idx);
1017 case BFD_POLL_NOT_NEEDED:
1033 (
"No need to send control frame now, now is %lu, tx_timeout is %lu",
1043 BFD_DBG (
"Send final control frame for bs_idx=%lu", bs->
bs_idx);
1059 u64 now,
int handling_wakeup)
1063 BFD_DBG (
"Rx timeout, session goes down");
1078 bfd_set_state (vm, bm, bs, BFD_STATE_down, handling_wakeup);
1092 BFD_DBG (
"Echo rx timeout, session goes down");
1094 bfd_set_state (vm, bm, bs, BFD_STATE_down, handling_wakeup);
1105 case BFD_STATE_admin_down:
1108 case BFD_STATE_down:
1111 case BFD_STATE_init:
1121 BFD_DBG (
"Switching on echo function, bs_idx=%u", bs->
bs_idx);
1148 uword event_type, *event_data = 0;
1157 BFD_DBG (
"wakeup, now is %llunsec, vlib_time_now() is %.9f", now,
1163 u32 first_expires_in_ticks =
1164 TW (tw_timer_first_expires_in_ticks) (&bm->wheel);
1165 if (!first_expires_in_ticks)
1168 (
"tw_timer_first_expires_in_ticks(%p) returns 0ticks",
1170 timeout = bm->wheel.next_run_time - vm_time;
1171 BFD_DBG (
"wheel.next_run_time is %.9f",
1172 bm->wheel.next_run_time);
1179 BFD_DBG (
"tw_timer_first_expires_in_ticks(%p) returns %luticks",
1180 &bm->wheel, first_expires_in_ticks);
1181 u64 next_expire_nsec =
1187 BFD_DBG (
"vlib_process_wait_for_event_or_clock(vm, %.09f)",
1197 uword *session_index;
1226 BFD_DBG (
"Ignoring event for non-existent session index %u",
1227 (
u32) * session_index);
1244 BFD_DBG (
"Ignoring event for non-existent session index %u",
1245 (
u32) * session_index);
1254 BFD_DBG (
"tw_timer_expire_timers_vec(%p, %.04f);", &bm->wheel, vm_time);
1262 const u32 bs_idx = *p;
1274 _vec_len (expired) = 0;
1278 _vec_len (event_data) = 0;
1292 .name =
"bfd-process",
1342 setbuf (stdout, NULL);
1354 BFD_DBG (
"tw_timer_wheel_init(%p, %p, %.04f, %u)", &bm->wheel, NULL,
1360 if (n_vlib_mains > 1)
1378 const unsigned limit = 1000;
1379 unsigned counter = 0;
1383 if (counter > limit)
1386 "couldn't allocate unused session discriminator even " 1387 "after %u tries!", limit);
1457 BFD_ERR (
"BFD verification failed - unexpected version: '%d'",
1461 if (pkt->head.length < sizeof (bfd_pkt_t) ||
1463 pkt->head.length < sizeof (bfd_pkt_with_common_auth_t)))
1465 BFD_ERR (
"BFD verification failed - unexpected length: '%d' (auth " 1470 if (!pkt->head.detect_mult)
1472 BFD_ERR (
"BFD verification failed - unexpected detect-mult: '%d'",
1473 pkt->head.detect_mult);
1478 BFD_ERR (
"BFD verification failed - unexpected multipoint: '%d'",
1484 BFD_ERR (
"BFD verification failed - unexpected my-disc: '%d'",
1488 if (!pkt->your_disc)
1491 if (pkt_state != BFD_STATE_down && pkt_state != BFD_STATE_admin_down)
1493 BFD_ERR (
"BFD verification failed - unexpected state: '%s' " 1504 BFD_DBG (
"Switching authentication key from %U to %U for bs_idx=%u",
1520 if (BFD_AUTH_TYPE_meticulous_keyed_md5 == auth_type ||
1521 BFD_AUTH_TYPE_meticulous_keyed_sha1 == auth_type)
1530 u32 received_seq_num,
int is_meticulous)
1541 BFD_DBG (
"BFD peer unresponsive for %lu nsec, which is > 2 * " 1542 "detection_time=%u nsec, resetting remote_seq_number_known " 1549 const u32 max_u32 = 0xffffffff;
1568 if (received_seq_num > x &&
1569 received_seq_num < bs->auth.remote_seq_number + is_meticulous)
1572 (
"Recvd sequence number=%u out of ranges <0, %u>, <%u, %u>",
1573 received_seq_num, x,
1584 if (received_seq_num < min || received_seq_num > max)
1586 BFD_ERR (
"Recvd sequence number=%u out of range <%u, %u>",
1587 received_seq_num, min, max);
1601 auth_key->
auth_type == BFD_AUTH_TYPE_meticulous_keyed_sha1);
1603 u8 result[SHA_DIGEST_LENGTH];
1604 bfd_pkt_with_common_auth_t *with_common = (
void *) pkt;
1605 if (pkt_size <
sizeof (*with_common))
1607 BFD_ERR (
"Packet size too small to hold authentication common header");
1610 if (with_common->common_auth.type != auth_key->
auth_type)
1612 BFD_ERR (
"BFD auth type mismatch, packet auth=%d:%s doesn't match " 1613 "in-use auth=%d:%s",
1614 with_common->common_auth.type,
1619 bfd_pkt_with_sha1_auth_t *with_sha1 = (
void *) pkt;
1620 if (pkt_size <
sizeof (*with_sha1) ||
1621 with_sha1->sha1_auth.type_len.len <
sizeof (with_sha1->sha1_auth))
1624 (
"BFD size mismatch, payload size=%u, expected=%u, auth_len=%u, " 1625 "expected=%u", pkt_size,
sizeof (*with_sha1),
1626 with_sha1->sha1_auth.type_len.len, sizeof (with_sha1->sha1_auth));
1629 if (with_sha1->sha1_auth.key_id != bfd_key_id)
1632 (
"BFD key ID mismatch, packet key ID=%u doesn't match key ID=%u%s",
1633 with_sha1->sha1_auth.key_id, bfd_key_id,
1635 auth.
is_delayed ?
" (but a delayed auth change is scheduled)" :
"");
1639 if (!SHA1_Init (&ctx))
1645 if (!SHA1_Update (&ctx, with_sha1,
1646 sizeof (*with_sha1) -
sizeof (with_sha1->sha1_auth.hash)))
1648 BFD_ERR (
"SHA1_Update failed");
1651 if (!SHA1_Update (&ctx, auth_key->
key, sizeof (auth_key->
key)))
1653 BFD_ERR (
"SHA1_Update failed");
1656 if (!SHA1_Final (result, &ctx))
1658 BFD_ERR (
"SHA1_Final failed");
1661 if (0 == memcmp (result, with_sha1->sha1_auth.hash, SHA_DIGEST_LENGTH))
1665 BFD_ERR (
"SHA1 hash: %U doesn't match the expected value: %U",
1679 case BFD_AUTH_TYPE_reserved:
1681 "internal error, unexpected auth_type=%d:%s",
1685 case BFD_AUTH_TYPE_simple_password:
1687 "internal error, not implemented, unexpected auth_type=%d:%s",
1691 case BFD_AUTH_TYPE_keyed_md5:
1693 case BFD_AUTH_TYPE_meticulous_keyed_md5:
1696 "internal error, not implemented, unexpected auth_type=%d:%s",
1699 case BFD_AUTH_TYPE_keyed_sha1:
1701 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
1705 const u32 seq_num = clib_net_to_host_u32 (((bfd_pkt_with_sha1_auth_t
1718 "internal error, attempt to use SHA1 without SSL support");
1786 if (pkt_size >
sizeof (*pkt))
1788 BFD_ERR (
"BFD verification failed - unexpected packet size '%d' " 1789 "(auth not present)", pkt_size);
1818 if (!bs || (pkt->your_disc && pkt->your_disc != bs->
local_discr))
1832 ((bfd_pkt_with_common_auth_t *) (pkt))->common_auth.type;
1835 case BFD_AUTH_TYPE_reserved:
1837 case BFD_AUTH_TYPE_simple_password:
1839 case BFD_AUTH_TYPE_keyed_md5:
1841 case BFD_AUTH_TYPE_meticulous_keyed_md5:
1843 "internal error, unexpected auth_type=%d:%s",
1846 case BFD_AUTH_TYPE_keyed_sha1:
1848 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
1851 bfd_pkt_with_sha1_auth_t *with_sha1 =
1852 (bfd_pkt_with_sha1_auth_t *) pkt;
1854 clib_net_to_host_u32 (with_sha1->sha1_auth.seq_num);
1856 BFD_DBG (
"Received sequence number %u",
1866 clib_net_to_host_u32 (pkt->req_min_rx));
1868 clib_net_to_host_u32
1869 (pkt->req_min_echo_rx));
1874 BFD_DBG (
"Poll sequence terminated, bs_idx=%u", bs->
bs_idx);
1884 else if (BFD_POLL_IN_PROGRESS_AND_QUEUED == bs->
poll_state)
1890 BFD_DBG (
"Next poll sequence can commence in " BFD_CLK_FMT,
1895 (
"Poll sequence terminated, but another is needed, bs_idx=%u",
1904 BFD_DBG (
"Session is admin-down, ignoring packet, bs_idx=%u",
1948 bfd_echo_pkt_t *pkt = NULL;
1959 BFD_DBG (
"Scanning bfd echo packet, bs_idx=%d", bs->
bs_idx);
1963 if (checksum != pkt->checksum)
1965 BFD_DBG (
"Invalid echo packet, checksum mismatch");
1969 if (pkt->expire_time_nsec < now)
1971 BFD_DBG (
"Stale packet received, expire time %lu < now %lu",
1972 pkt->expire_time_nsec, now);
1986 s =
format (s,
"bs_idx=%u local-state=%s remote-state=%s\n" 1987 "%Ulocal-discriminator=%u remote-discriminator=%u\n" 1988 "%Ulocal-diag=%s echo-active=%s\n" 1989 "%Udesired-min-tx=%u required-min-rx=%u\n" 1990 "%Urequired-min-echo-rx=%u detect-mult=%u\n" 1991 "%Uremote-min-rx=%u remote-min-echo-rx=%u\n" 1992 "%Uremote-demand=%s poll-state=%s\n" 1993 "%Uauth: local-seq-num=%u remote-seq-num=%u\n" 1994 "%U is-delayed=%s\n" 2022 format (s,
"bs_idx=%u local-state=%s remote-state=%s", bs->
bs_idx,
2031 if (auth_type == BFD_AUTH_TYPE_keyed_sha1 ||
2032 auth_type == BFD_AUTH_TYPE_meticulous_keyed_sha1)
2041 u8 bfd_key_id,
u8 is_delayed)
2044 const uword *key_idx_p =
2049 "authentication key with config ID %u doesn't exist)",
2051 return VNET_API_ERROR_BFD_ENOENT;
2053 const uword key_idx = *key_idx_p;
2125 "SSL missing, cannot deactivate BFD authentication");
2126 return VNET_API_ERROR_BFD_NOTSUPP;
2132 u32 desired_min_tx_usec,
2133 u32 required_min_rx_usec,
u8 detect_mult)
2142 case BFD_POLL_NOT_NEEDED:
2154 case BFD_POLL_NEEDED:
2155 case BFD_POLL_IN_PROGRESS_AND_QUEUED:
2161 case BFD_POLL_IN_PROGRESS:
2166 BFD_DBG (
"Poll in progress, queueing extra poll, bs_idx=%u",
2187 BFD_DBG (
"Ignore parameter change - no change, bs_idx=%u", bs->
bs_idx);
2194 const u8 * key_data)
2202 "invalid authentication key length for auth_type=%d:%s " 2203 "(key_len=%u, must be non-zero, expected max=%u)",
2206 return VNET_API_ERROR_INVALID_VALUE;
2212 return VNET_API_ERROR_BFD_NOTSUPP;
2218 const uword key_idx = *key_idx_p;
2223 "authentication key with conf ID %u in use by %u BFD " 2224 "session(s) - cannot modify", conf_key_id,
2226 return VNET_API_ERROR_BFD_EINUSE;
2243 "SSL missing, cannot manipulate authentication keys");
2244 return VNET_API_ERROR_BFD_NOTSUPP;
2258 const uword key_idx = *key_idx_p;
2263 "authentication key with conf ID %u in use by %u BFD " 2264 "session(s) - cannot delete", conf_key_id,
2266 return VNET_API_ERROR_BFD_EINUSE;
2276 "authentication key with conf ID %u does not exist",
2278 return VNET_API_ERROR_BFD_ENOENT;
2283 "SSL missing, cannot manipulate authentication keys");
2284 return VNET_API_ERROR_BFD_NOTSUPP;
vlib_log_class_t vlib_log_register_class(char *class, char *subclass)
VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION(bfd_hw_interface_up_down)
static int bfd_transport_control_frame(vlib_main_t *vm, u32 bi, bfd_session_t *bs)
u8 bfd_pkt_get_auth_present(const bfd_pkt_t *pkt)
static void bfd_notify_listeners_rpc(u32 bs_idx)
u64 poll_state_start_or_timeout_nsec
helper for delayed poll sequence - marks either start of running poll sequence or timeout...
static void bfd_recalc_echo_tx_interval(bfd_main_t *bm, bfd_session_t *bs)
static void bfd_on_state_change(bfd_main_t *bm, bfd_session_t *bs, u64 now, int handling_wakeup)
bfd_session_t * bfd_get_session(bfd_main_t *bm, bfd_transport_e t)
bfd_notify_fn_t * listeners
vector of callback notification functions
void TW() tw_timer_wheel_init(TWT(tw_timer_wheel) *tw, void *expired_timer_callback, f64 timer_interval_in_seconds, u32 max_expirations)
Initialize a tw timer wheel template instance.
#define hash_set(h, key, value)
bfd_auth_type_e auth_type
authentication type for this key
u8 curr_bfd_key_id
current key ID sent out in bfd packet
static uword random_default_seed(void)
Default random seed (unix/linux user-mode)
u64 effective_required_min_rx_nsec
effective required min rx interval (nsec)
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
#define hash_unset(h, key)
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
void bfd_pkt_set_poll(bfd_pkt_t *pkt)
u64 remote_min_rx_nsec
remote min rx interval (nsec)
#define BFD_TW_TPS
timing wheel tick-rate, 1ms should be good enough
vnet_main_t * vnet_get_main(void)
void bfd_on_timeout(vlib_main_t *vm, vlib_node_runtime_t *rt, bfd_main_t *bm, bfd_session_t *bs, u64 now)
static void bfd_set_effective_desired_min_tx(bfd_main_t *bm, bfd_session_t *bs, u64 now, u64 desired_min_tx_nsec)
u64 default_desired_min_tx_nsec
default desired min tx in nsec
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
u32 * auth_key_by_conf_key_id
hashmap - index in pool auth_keys by conf_key_id
static void bfd_session_switch_auth_to_next(bfd_session_t *bs)
u8 bfd_pkt_get_diag_code(const bfd_pkt_t *pkt)
static uword bfd_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
bfd_session_t * bfd_find_session_by_disc(bfd_main_t *bm, u32 disc)
u8 * format_bfd_auth_key(u8 *s, va_list *args)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
static u64 bfd_time_now_nsec(vlib_main_t *vm, f64 *vm_time)
int bfd_verify_pkt_common(const bfd_pkt_t *pkt)
verify bfd packet - common checks
u64 remote_min_echo_rx_nsec
remote min echo rx interval (nsec)
u32 echo_secret
secret used for calculating/checking checksum of echo packets
u16 current_length
Nbytes between current data and the end of this buffer.
bfd_diag_code_e local_diag
local diagnostics
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
static u64 clib_xxhash(u64 key)
static void bfd_on_config_change(vlib_main_t *vm, vlib_node_runtime_t *rt, bfd_main_t *bm, bfd_session_t *bs, u64 now)
void bfd_put_session(bfd_main_t *bm, bfd_session_t *bs)
static int bfd_verify_pkt_auth_key(vlib_main_t *vm, const bfd_pkt_t *pkt, u32 pkt_size, bfd_session_t *bs, u8 bfd_key_id, bfd_auth_key_t *auth_key)
u8 remote_seq_number_known
set to 1 if remote sequence number is known
static void bfd_set_remote_required_min_rx(bfd_main_t *bm, bfd_session_t *bs, u64 now, u32 remote_required_min_rx_usec)
static void bfd_unlock(bfd_main_t *bm)
unsigned bfd_auth_type_supported(bfd_auth_type_e auth_type)
static void bfd_add_transport_layer(vlib_main_t *vm, u32 bi, bfd_session_t *bs)
void bfd_init_final_control_frame(vlib_main_t *vm, vlib_buffer_t *b, bfd_main_t *bm, bfd_session_t *bs, int is_local)
u32 bfd_process_node_index
background process node index
u8 bfd_pkt_get_version(const bfd_pkt_t *pkt)
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
vlib_log_class_t log_class
log class
u32 tw_id
timing wheel internal id used to manipulate timer (if set)
u64 last_rx_nsec
timestamp of last packet received
u32 remote_seq_number
remote sequence number
u64 effective_desired_min_tx_nsec
effective desired min tx interval (nsec)
int bfd_add_udp4_transport(vlib_main_t *vm, u32 bi, const bfd_session_t *bs, int is_echo)
#define clib_memcpy(d, s, n)
void bfd_session_set_flags(vlib_main_t *vm, bfd_session_t *bs, u8 admin_up_down)
vnet_api_error_t bfd_auth_deactivate(bfd_session_t *bs, u8 is_delayed)
static void bfd_lock_check(bfd_main_t *bm)
u8 key[20]
key data directly usable for bfd purposes - already padded with zeroes (so we don't need the actual l...
vl_api_interface_index_t sw_if_index
const char * bfd_poll_state_string(bfd_poll_state_e state)
u32 random_seed
for generating random numbers
#define VLIB_INIT_FUNCTION(x)
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
int bfd_transport_udp4(vlib_main_t *vm, u32 bi, const struct bfd_session_s *bs)
transport packet over udpv4
u64 remote_min_rx_usec
remote min rx interval (microseconds)
static void bfd_rpc_event_cb(const bfd_rpc_event_t *a)
void bfd_event(bfd_main_t *bm, bfd_session_t *bs)
void vl_api_rpc_call_main_thread(void *fp, u8 *data, u32 data_length)
u64 bfd_process_wakeup_event_delay_nsec
The time it took the last wakeup event to make it to handling.
bfd_auth_key_t * next_key
set to next key to use if delayed switch is enabled - in that case the key is switched when first inc...
static vlib_node_registration_t bfd_process_node
(constructor) VLIB_REGISTER_NODE (bfd_process_node)
u64 echo_last_tx_nsec
timestamp of last echo packet transmitted
#define vlib_log_debug(...)
static void bfd_set_poll_state(bfd_session_t *bs, bfd_poll_state_e state)
static u32 vlib_get_buffer_index(vlib_main_t *vm, void *p)
Translate buffer pointer into buffer index.
static void bfd_calc_next_echo_tx(bfd_main_t *bm, bfd_session_t *bs, u64 now)
bfd_session_t * bfd_find_session_by_idx(bfd_main_t *bm, uword bs_idx)
static void clib_spinlock_init(clib_spinlock_t *p)
static u64 bfd_calc_echo_checksum(u32 discriminator, u64 expire_time, u32 secret)
u8 remote_demand
1 if remote system sets demand mode, 0 otherwise
bfd_session_t * sessions
pool of bfd sessions context data
bfd_auth_key_t * auth_keys
pool of authentication keys
u64 remote_desired_min_tx_nsec
remote desired min tx interval (nsec)
bfd_transport_e transport
transport type for this session
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static clib_error_t * bfd_sw_interface_up_down(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
static void bfd_event_rpc(u32 bs_idx)
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
u32 remote_discr
remote discriminator
bfd_poll_state_e poll_state
state info regarding poll sequence
u8 bfd_pkt_get_control_plane_independent(const bfd_pkt_t *pkt)
void bfd_pkt_set_auth_present(bfd_pkt_t *pkt)
static void bfd_set_state(vlib_main_t *vm, bfd_main_t *bm, bfd_session_t *bs, bfd_state_e new_state, int handling_wakeup)
u64 echo_transmit_interval_nsec
transmit interval for echo packets
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
u32 *TW() tw_timer_expire_timers_vec(TWT(tw_timer_wheel) *tw, f64 now, u32 *vec)
#define pool_put(P, E)
Free an object E in pool P.
static void bfd_set_diag(bfd_session_t *bs, bfd_diag_code_e code)
void TW() tw_timer_update(TWT(tw_timer_wheel) *tw, u32 handle, u64 interval)
Update a tw timer.
u8 local_detect_mult
configured detect multiplier
static int bfd_is_echo_possible(bfd_session_t *bs)
vlib_thread_main_t vlib_thread_main
int bfd_transport_udp6(vlib_main_t *vm, u32 bi, const struct bfd_session_s *bs)
transport packet over udpv6
int bfd_add_udp6_transport(vlib_main_t *vm, u32 bi, const bfd_session_t *bs, int is_echo)
u8 bfd_pkt_get_final(const bfd_pkt_t *pkt)
void bfd_pkt_set_final(bfd_pkt_t *pkt)
static void bfd_notify_listeners(bfd_main_t *bm, bfd_listen_event_e event, const bfd_session_t *bs)
bfd_diag_code_e remote_diag
remote diagnostics
static void bfd_send_periodic(vlib_main_t *vm, vlib_node_runtime_t *rt, bfd_main_t *bm, bfd_session_t *bs, u64 now)
static void bfd_check_rx_timeout(vlib_main_t *vm, bfd_main_t *bm, bfd_session_t *bs, u64 now, int handling_wakeup)
#define BFD_DEFAULT_DESIRED_MIN_TX_USEC
default, slow transmission interval for BFD packets, per spec at least 1s
void bfd_session_start(bfd_main_t *bm, bfd_session_t *bs)
const char * bfd_auth_type_str(bfd_auth_type_e auth_type)
static int bfd_verify_pkt_auth_seq_num(vlib_main_t *vm, bfd_session_t *bs, u32 received_seq_num, int is_meticulous)
u8 bfd_pkt_get_multipoint(const bfd_pkt_t *pkt)
#define VLIB_REGISTER_NODE(x,...)
static_always_inline uword vlib_get_thread_index(void)
static void bfd_recalc_tx_interval(bfd_main_t *bm, bfd_session_t *bs)
u64 event_time_nsec
next event time in nsec for this session (0 if no event)
BFD protocol declarations.
static void vlib_process_signal_event_mt(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Signal event to process from any thread.
u32 config_desired_min_tx_usec
configured desired min tx interval (microseconds)
u32 bfd_max_key_len_for_auth_type(bfd_auth_type_e auth_type)
get the maximum length of key data for given auth type
static void bfd_calc_next_tx(bfd_main_t *bm, bfd_session_t *bs, u64 now)
u8 * format_bfd_session(u8 *s, va_list *args)
const char * bfd_diag_code_string(bfd_diag_code_e diag)
static void bfd_add_auth_section(vlib_buffer_t *b, bfd_session_t *bs)
u64 config_desired_min_tx_nsec
configured desired min tx interval (nsec)
static int bfd_verify_pkt_auth_key_sha1(const bfd_pkt_t *pkt, u32 pkt_size, bfd_session_t *bs, u8 bfd_key_id, bfd_auth_key_t *auth_key)
u8 bfd_pkt_get_demand(const bfd_pkt_t *pkt)
u64 echo_last_rx_nsec
timestamp of last echo packet received
vnet_api_error_t bfd_auth_activate(bfd_session_t *bs, u32 conf_key_id, u8 bfd_key_id, u8 is_delayed)
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
static void bfd_set_remote_required_min_echo_rx(bfd_main_t *bm, bfd_session_t *bs, u64 now, u32 remote_required_min_echo_rx_usec)
vlib_main_t vlib_node_runtime_t * node
u8 * bfd_input_format_trace(u8 *s, va_list *args)
void bfd_pkt_set_version(bfd_pkt_t *pkt, int version)
static void bfd_recalc_detection_time(bfd_main_t *bm, bfd_session_t *bs)
u32 vlib_log_get_indent()
int bfd_udp_is_echo_available(bfd_transport_e transport)
check if the bfd udp layer is echo-capable at this time
u64 nsec_per_tw_tick
how many nanoseconds is one timing wheel tick
u64 bfd_process_next_wakeup_nsec
When the bfd process is supposed to wake up next.
u8 echo
1 is echo function is active, 0 otherwise
u64 last_tx_nsec
timestamp of last packet transmitted
struct bfd_session_s::@142 auth
authentication information
u64 config_required_min_rx_nsec
configured required min rx interval (nsec)
int bfd_consume_echo_pkt(vlib_main_t *vm, bfd_main_t *bm, vlib_buffer_t *b)
u8 bfd_pkt_get_state(const bfd_pkt_t *pkt)
u32 local_discr
local discriminator
static f64 random_f64(u32 *seed)
Generate f64 random number in the interval [0,1].
bfd_hop_type_e hop_type
BFD hop type.
u32 conf_key_id
global configuration key ID
vnet_api_error_t bfd_auth_del_key(u32 conf_key_id)
delete existing authentication key
vlib_main_t * vlib_main
convenience variables
bfd_state_e local_state
session state
static int bfd_echo_add_transport_layer(vlib_main_t *vm, u32 bi, bfd_session_t *bs)
u32 bfd_nsec_to_usec(u64 nsec)
u32 * session_by_disc
hashmap - bfd session by discriminator
vnet_api_error_t bfd_session_set_params(bfd_main_t *bm, bfd_session_t *bs, u32 desired_min_tx_usec, u32 required_min_rx_usec, u8 detect_mult)
static u64 bfd_usec_to_nsec(u64 us)
void(* bfd_notify_fn_t)(bfd_listen_event_e, const bfd_session_t *)
session nitification call back function type
struct _vlib_node_registration vlib_node_registration_t
u32 local_seq_number
sequence number incremented occasionally or always (if meticulous)
void bfd_register_listener(bfd_notify_fn_t fn)
Register a callback function to receive session notifications.
u32 config_required_min_rx_usec
configured required min rx interval (microseconds)
u64 transmit_interval_nsec
transmit interval
static void bfd_set_timer(bfd_main_t *bm, bfd_session_t *bs, u64 now, int handling_wakeup)
int bfd_verify_pkt_auth(vlib_main_t *vm, const bfd_pkt_t *pkt, u16 pkt_size, bfd_session_t *bs)
verify bfd packet - authentication
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static void bfd_set_defaults(bfd_main_t *bm, bfd_session_t *bs)
u32 use_count
keeps track of how many sessions reference this key
#define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b)
VLIB buffer representation.
#define vlib_log_info(...)
u8 next_bfd_key_id
key ID to use when switched to next_key
#define vlib_log_crit(...)
u64 detection_time_nsec
detection time
u8 bfd_pkt_get_poll(const bfd_pkt_t *pkt)
Linear Congruential Random Number Generator.
int bfd_process_wakeup_events_in_flight
Number of event wakeup RPCs in flight.
u64 bfd_process_wakeup_event_start_nsec
The timestamp of last wakeup event being sent.
u32 bs_idx
index in bfd_main.sessions pool
u8 * format_bfd_session_brief(u8 *s, va_list *args)
static int bfd_transport_echo(vlib_main_t *vm, u32 bi, bfd_session_t *bs)
static u32 random_u32(u32 *seed)
32-bit random number generator
u32 TW() tw_timer_start(TWT(tw_timer_wheel) *tw, u32 user_id, u32 timer_id, u64 interval)
Start a Tw Timer.
u64 remote_min_echo_rx_usec
remote min echo rx interval (microseconds)
vnet_api_error_t bfd_auth_set_key(u32 conf_key_id, u8 auth_type, u8 key_len, const u8 *key_data)
create or modify bfd authentication key
vl_api_dhcp_client_state_t state
#define STRUCT_SIZE_OF(t, f)
u64 tx_timeout_nsec
next time at which to transmit a packet
#define vec_foreach(var, vec)
Vector iterator.
bfd_state_e remote_state
remote session state
const char * bfd_state_string(bfd_state_e state)
#define vlib_log_err(...)
static void vlib_buffer_free_one(vlib_main_t *vm, u32 buffer_index)
Free one buffer Shorthand to free a single buffer chain.
static void bfd_rpc_notify_listeners_cb(const bfd_rpc_notify_listeners_t *a)
u64 echo_tx_timeout_nsec
next time at which to transmit echo packet
u64 min_required_min_rx_while_echo_nsec
minimum required min rx while echo function is active - nsec
static int bfd_auth_type_is_meticulous(bfd_auth_type_e auth_type)
bfd_auth_key_t * curr_key
current key in use
clib_spinlock_t lock
lock to protect data structures
void bfd_consume_pkt(vlib_main_t *vm, bfd_main_t *bm, const bfd_pkt_t *pkt, u32 bs_idx)
static u32 vlib_buffer_alloc(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Allocate buffers into supplied array.
static void bfd_send_echo(vlib_main_t *vm, vlib_node_runtime_t *rt, bfd_main_t *bm, bfd_session_t *bs, u64 now)
void bfd_pkt_set_state(bfd_pkt_t *pkt, int value)
static clib_error_t * bfd_hw_interface_up_down(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
u8 remote_detect_mult
remote detect multiplier
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
void bfd_pkt_set_diag_code(bfd_pkt_t *pkt, int value)
#define BFD_REQUIRED_MIN_RX_USEC_WHILE_ECHO
minimum required min rx set locally when echo function is used, per spec should be set to at least 1s...
u8 is_delayed
set to 1 if delayed action is pending, which might be activation of authentication, change of key or deactivation
static void bfd_set_effective_required_min_rx(bfd_main_t *bm, bfd_session_t *bs, u64 required_min_rx_nsec)
static clib_error_t * bfd_main_init(vlib_main_t *vm)
static void bfd_lock(bfd_main_t *bm)
static void bfd_init_control_frame(bfd_main_t *bm, bfd_session_t *bs, vlib_buffer_t *b)
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(bfd_sw_interface_up_down)
static uword pool_elts(void *v)
Number of active elements in a pool.