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);
74 s =
format (s,
"{auth-type=%u:%s, conf-key-id=%u, use-count=%u}, ",
126 BFD_DBG (
"set local_diag, bs_idx=%d: '%d:%s'", bs->
bs_idx, code,
153 return "BFD_POLL_" #x; 165 BFD_DBG (
"Setting poll state=%s, bs_idx=%u",
176 BFD_DBG (
"Recalculated transmit interval " BFD_CLK_FMT,
186 BFD_DBG (
"Recalculated echo transmit interval " BFD_CLK_FMT,
205 BFD_DBG (
"Missed %lu transmit events (now is %lu, calc " 206 "tx_timeout is %lu)",
224 BFD_DBG (
"Missed %lu transmit events (now is %lu, calc " 225 "tx_timeout is %lu)",
233 BFD_DBG (
"Next transmit in %lu clocks/%.02fs@%lu",
248 BFD_DBG (
"Missed %lu echo transmit events (now is %lu, calc tx_timeout " 255 BFD_DBG (
"Next echo transmit in %lu clocks/%.02fs@%lu",
270 BFD_DBG (
"Recalculated detection time %lu clocks/%.2fs",
293 if (tx_timeout && rx_timeout)
295 next =
clib_min (tx_timeout, rx_timeout);
309 BFD_DBG (
"bs_idx=%u, tx_timeout=%lu, echo_tx_timeout=%lu, rx_timeout=%lu, " 321 BFD_DBG (
"timing_wheel_insert(%p, %lu (%ld clocks/%.2fs in the " 330 if (!handling_wakeup)
369 u64 desired_min_tx_clocks)
372 BFD_DBG (
"Set effective desired min tx to " BFD_CLK_FMT,
383 u64 required_min_rx_clocks)
386 BFD_DBG (
"Set effective required min rx to " BFD_CLK_FMT,
393 u64 now,
u32 remote_required_min_rx_usec)
400 BFD_DBG (
"Set remote min rx to " BFD_CLK_FMT,
410 u32 remote_required_min_echo_rx_usec)
417 BFD_DBG (
"Set remote min echo rx to " BFD_CLK_FMT,
481 const bfd_pkt_t *pkt = (bfd_pkt_t *) t->
data;
484 s =
format (s,
"BFD v%u, diag=%u(%s), state=%u(%s),\n" 485 " flags=(P:%u, F:%u, C:%u, A:%u, D:%u, M:%u), " 486 "detect_mult=%u, length=%u\n",
496 if (t->
len >= sizeof (bfd_pkt_t) &&
497 pkt->head.length >= sizeof (bfd_pkt_t))
499 s =
format (s,
" my discriminator: %u\n",
500 clib_net_to_host_u32 (pkt->my_disc));
501 s =
format (s,
" your discriminator: %u\n",
502 clib_net_to_host_u32 (pkt->your_disc));
503 s =
format (s,
" desired min tx interval: %u\n",
504 clib_net_to_host_u32 (pkt->des_min_tx));
505 s =
format (s,
" required min rx interval: %u\n",
506 clib_net_to_host_u32 (pkt->req_min_rx));
507 s =
format (s,
" required min echo rx interval: %u",
508 clib_net_to_host_u32 (pkt->req_min_echo_rx));
510 if (t->
len >= sizeof (bfd_pkt_with_common_auth_t) &&
511 pkt->head.length >= sizeof (bfd_pkt_with_common_auth_t) &&
514 const bfd_pkt_with_common_auth_t *with_auth = (
void *) pkt;
515 const bfd_auth_common_t *common = &with_auth->common_auth;
516 s =
format (s,
"\n auth len: %u\n", common->len);
517 s =
format (s,
" auth type: %u:%s\n", common->type,
519 if (t->
len >= sizeof (bfd_pkt_with_sha1_auth_t) &&
520 pkt->head.length >= sizeof (bfd_pkt_with_sha1_auth_t) &&
521 (BFD_AUTH_TYPE_keyed_sha1 == common->type ||
522 BFD_AUTH_TYPE_meticulous_keyed_sha1 == common->type))
524 const bfd_pkt_with_sha1_auth_t *with_sha1 = (
void *) pkt;
525 const bfd_auth_sha1_t *sha1 = &with_sha1->sha1_auth;
526 s =
format (s,
" seq num: %u\n",
527 clib_net_to_host_u32 (sha1->seq_num));
528 s =
format (s,
" key id: %u\n", sha1->key_id);
530 sizeof (sha1->hash));
564 BFD_DBG (
"Ignoring event RPC for non-existent session index %u",
602 BFD_DBG (
"Ignoring notify RPC for non-existent session index %u",
636 case BFD_STATE_admin_down:
706 case BFD_TRANSPORT_UDP4:
710 case BFD_TRANSPORT_UDP6:
722 case BFD_TRANSPORT_UDP4:
726 case BFD_TRANSPORT_UDP6:
739 case BFD_TRANSPORT_UDP4:
740 BFD_DBG (
"Transport bfd echo via udp4, bs_idx=%u", bs->
bs_idx);
743 case BFD_TRANSPORT_UDP6:
744 BFD_DBG (
"Transport bfd echo via udp6, bs_idx=%u", bs->
bs_idx);
756 case BFD_TRANSPORT_UDP4:
757 BFD_DBG (
"Transport bfd echo via udp4, bs_idx=%u", bs->
bs_idx);
760 case BFD_TRANSPORT_UDP6:
761 BFD_DBG (
"Transport bfd echo via udp6, bs_idx=%u", bs->
bs_idx);
773 bfd_auth_sha1_t *auth = &pkt->sha1_auth;
775 pkt->pkt.head.length +=
sizeof (*auth);
784 auth->type_len.len =
sizeof (bfd_auth_sha1_t);
793 unsigned char hash[
sizeof (auth->hash)];
794 SHA1 ((
unsigned char *) pkt,
sizeof (*pkt), hash);
809 case BFD_AUTH_TYPE_reserved:
811 case BFD_AUTH_TYPE_simple_password:
813 case BFD_AUTH_TYPE_keyed_md5:
815 case BFD_AUTH_TYPE_meticulous_keyed_md5:
817 "internal error, unexpected BFD auth type '%d'",
821 case BFD_AUTH_TYPE_keyed_sha1:
823 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
824 bfd_add_sha1_auth_section (b, bs);
827 case BFD_AUTH_TYPE_keyed_sha1:
829 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
831 "internal error, unexpected BFD auth type '%d'",
847 case BFD_TRANSPORT_UDP4:
849 case BFD_TRANSPORT_UDP6:
862 bfd_length =
sizeof (bfd_pkt_t);
868 pkt->head.length = bfd_length;
883 pkt->req_min_echo_rx = clib_host_to_net_u32 (1);
915 pkt->expire_time_clocks =
923 BFD_ERR (
"cannot send echo packet out, turning echo off");
930 BFD_ERR (
"cannot send echo packet out, turning echo off");
941 (
"No need to send echo packet now, now is %lu, tx_timeout is %lu",
952 BFD_DBG (
"Remote min rx interval is zero, not sending periodic control " 965 BFD_DBG (
"Remote demand is set, not sending periodic control frame");
988 case BFD_POLL_NEEDED:
989 if (now < bs->poll_state_start_or_timeout_clocks)
991 BFD_DBG (
"Cannot start a poll sequence yet, need to wait " 1000 case BFD_POLL_IN_PROGRESS:
1001 case BFD_POLL_IN_PROGRESS_AND_QUEUED:
1003 BFD_DBG (
"Setting poll bit in packet, bs_idx=%u", bs->
bs_idx);
1005 case BFD_POLL_NOT_NEEDED:
1021 (
"No need to send control frame now, now is %lu, tx_timeout is %lu",
1031 BFD_DBG (
"Send final control frame for bs_idx=%lu", bs->
bs_idx);
1047 int handling_wakeup)
1056 BFD_DBG (
"Rx timeout, session goes down");
1068 else if (bs->
echo &&
1073 BFD_DBG (
"Echo rx timeout, session goes down");
1086 case BFD_STATE_admin_down:
1089 case BFD_STATE_down:
1092 case BFD_STATE_init:
1102 BFD_DBG (
"Switching on echo function, bs_idx=%u", bs->
bs_idx);
1129 uword event_type, *event_data = 0;
1139 BFD_DBG (
"timing_wheel_next_expiring_elt_time(%p) returns %lu",
1140 &bm->
wheel, next_expire);
1142 (
i64) next_expire >= 0 ? next_expire : ~0;
1144 if ((
i64) next_expire < 0)
1146 BFD_DBG (
"wait for event without timeout");
1153 BFD_DBG (
"wait for event with timeout %.02f", timeout);
1156 BFD_DBG (
"negative timeout, already expired, skipping wait");
1166 uword *session_index;
1194 BFD_DBG (
"Ignoring event for non-existent session index %u",
1195 (
u32) * session_index);
1212 BFD_DBG (
"Ignoring event for non-existent session index %u",
1213 (
u32) * session_index);
1222 BFD_DBG (
"advancing wheel, now is %lu", now);
1223 BFD_DBG (
"timing_wheel_advance (%p, %lu, %p, 0);", &bm->
wheel, now,
1231 const u32 bs_idx = *p;
1242 _vec_len (expired) = 0;
1246 _vec_len (event_data) = 0;
1260 .name =
"bfd-process",
1310 setbuf (stdout,
NULL);
1329 if (n_vlib_mains > 1)
1347 const unsigned limit = 1000;
1348 unsigned counter = 0;
1352 if (counter > limit)
1355 "couldn't allocate unused session discriminator even " 1356 "after %u tries!", limit);
1426 BFD_ERR (
"BFD verification failed - unexpected version: '%d'",
1430 if (pkt->head.length < sizeof (bfd_pkt_t) ||
1432 pkt->head.length < sizeof (bfd_pkt_with_common_auth_t)))
1434 BFD_ERR (
"BFD verification failed - unexpected length: '%d' (auth " 1439 if (!pkt->head.detect_mult)
1441 BFD_ERR (
"BFD verification failed - unexpected detect-mult: '%d'",
1442 pkt->head.detect_mult);
1447 BFD_ERR (
"BFD verification failed - unexpected multipoint: '%d'",
1453 BFD_ERR (
"BFD verification failed - unexpected my-disc: '%d'",
1457 if (!pkt->your_disc)
1460 if (pkt_state != BFD_STATE_down && pkt_state != BFD_STATE_admin_down)
1462 BFD_ERR (
"BFD verification failed - unexpected state: '%s' " 1473 BFD_DBG (
"Switching authentication key from %U to %U for bs_idx=%u",
1489 if (BFD_AUTH_TYPE_meticulous_keyed_md5 == auth_type ||
1490 BFD_AUTH_TYPE_meticulous_keyed_sha1 == auth_type)
1499 u32 received_seq_num,
int is_meticulous)
1510 BFD_DBG (
"BFD peer unresponsive for %lu clocks, which is > 2 * " 1511 "detection_time=%u clocks, resetting remote_seq_number_known " 1519 const u32 max_u32 = 0xffffffff;
1538 if (received_seq_num > x &&
1539 received_seq_num < bs->auth.remote_seq_number + is_meticulous)
1542 (
"Recvd sequence number=%u out of ranges <0, %u>, <%u, %u>",
1543 received_seq_num, x,
1554 if (received_seq_num < min || received_seq_num > max)
1556 BFD_ERR (
"Recvd sequence number=%u out of range <%u, %u>",
1557 received_seq_num, min, max);
1571 auth_key->
auth_type == BFD_AUTH_TYPE_meticulous_keyed_sha1);
1573 u8 result[SHA_DIGEST_LENGTH];
1574 bfd_pkt_with_common_auth_t *with_common = (
void *) pkt;
1575 if (pkt_size <
sizeof (*with_common))
1577 BFD_ERR (
"Packet size too small to hold authentication common header");
1580 if (with_common->common_auth.type != auth_key->
auth_type)
1582 BFD_ERR (
"BFD auth type mismatch, packet auth=%d:%s doesn't match " 1583 "in-use auth=%d:%s",
1584 with_common->common_auth.type,
1589 bfd_pkt_with_sha1_auth_t *with_sha1 = (
void *) pkt;
1590 if (pkt_size <
sizeof (*with_sha1) ||
1591 with_sha1->sha1_auth.type_len.len <
sizeof (with_sha1->sha1_auth))
1594 (
"BFD size mismatch, payload size=%u, expected=%u, auth_len=%u, " 1595 "expected=%u", pkt_size,
sizeof (*with_sha1),
1596 with_sha1->sha1_auth.type_len.len, sizeof (with_sha1->sha1_auth));
1599 if (with_sha1->sha1_auth.key_id != bfd_key_id)
1602 (
"BFD key ID mismatch, packet key ID=%u doesn't match key ID=%u%s",
1603 with_sha1->sha1_auth.key_id, bfd_key_id,
1605 auth.
is_delayed ?
" (but a delayed auth change is scheduled)" :
"");
1609 if (!SHA1_Init (&ctx))
1615 if (!SHA1_Update (&ctx, with_sha1,
1616 sizeof (*with_sha1) -
sizeof (with_sha1->sha1_auth.hash)))
1618 BFD_ERR (
"SHA1_Update failed");
1621 if (!SHA1_Update (&ctx, auth_key->
key, sizeof (auth_key->
key)))
1623 BFD_ERR (
"SHA1_Update failed");
1626 if (!SHA1_Final (result, &ctx))
1628 BFD_ERR (
"SHA1_Final failed");
1631 if (0 == memcmp (result, with_sha1->sha1_auth.hash, SHA_DIGEST_LENGTH))
1635 BFD_ERR (
"SHA1 hash: %U doesn't match the expected value: %U",
1649 case BFD_AUTH_TYPE_reserved:
1651 "internal error, unexpected auth_type=%d:%s",
1655 case BFD_AUTH_TYPE_simple_password:
1657 "internal error, not implemented, unexpected auth_type=%d:%s",
1661 case BFD_AUTH_TYPE_keyed_md5:
1663 case BFD_AUTH_TYPE_meticulous_keyed_md5:
1666 "internal error, not implemented, unexpected auth_type=%d:%s",
1669 case BFD_AUTH_TYPE_keyed_sha1:
1671 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
1675 const u32 seq_num = clib_net_to_host_u32 (((bfd_pkt_with_sha1_auth_t
1688 "internal error, attempt to use SHA1 without SSL support");
1755 if (pkt_size >
sizeof (*pkt))
1757 BFD_ERR (
"BFD verification failed - unexpected packet size '%d' " 1758 "(auth not present)", pkt_size);
1786 if (!bs || (pkt->your_disc && pkt->your_disc != bs->
local_discr))
1800 ((bfd_pkt_with_common_auth_t *) (pkt))->common_auth.type;
1803 case BFD_AUTH_TYPE_reserved:
1805 case BFD_AUTH_TYPE_simple_password:
1807 case BFD_AUTH_TYPE_keyed_md5:
1809 case BFD_AUTH_TYPE_meticulous_keyed_md5:
1811 "internal error, unexpected auth_type=%d:%s",
1814 case BFD_AUTH_TYPE_keyed_sha1:
1816 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
1819 bfd_pkt_with_sha1_auth_t *with_sha1 =
1820 (bfd_pkt_with_sha1_auth_t *) pkt;
1822 clib_net_to_host_u32 (with_sha1->sha1_auth.seq_num);
1824 BFD_DBG (
"Received sequence number %u",
1834 clib_net_to_host_u32 (pkt->req_min_rx));
1836 clib_net_to_host_u32
1837 (pkt->req_min_echo_rx));
1842 BFD_DBG (
"Poll sequence terminated, bs_idx=%u", bs->
bs_idx);
1852 else if (BFD_POLL_IN_PROGRESS_AND_QUEUED == bs->
poll_state)
1858 BFD_DBG (
"Next poll sequence can commence in " BFD_CLK_FMT,
1864 (
"Poll sequence terminated, but another is needed, bs_idx=%u",
1873 BFD_DBG (
"Session is admin-down, ignoring packet, bs_idx=%u",
1917 bfd_echo_pkt_t *pkt =
NULL;
1928 BFD_DBG (
"Scanning bfd echo packet, bs_idx=%d", bs->
bs_idx);
1932 if (checksum != pkt->checksum)
1934 BFD_DBG (
"Invalid echo packet, checksum mismatch");
1938 if (pkt->expire_time_clocks < now)
1940 BFD_DBG (
"Stale packet received, expire time %lu < now %lu",
1941 pkt->expire_time_clocks, now);
1955 s =
format (s,
"bs_idx=%u local-state=%s remote-state=%s\n" 1956 "%Ulocal-discriminator=%u remote-discriminator=%u\n" 1957 "%Ulocal-diag=%s echo-active=%s\n" 1958 "%Udesired-min-tx=%u required-min-rx=%u\n" 1959 "%Urequired-min-echo-rx=%u detect-mult=%u\n" 1960 "%Uremote-min-rx=%u remote-min-echo-rx=%u\n" 1961 "%Uremote-demand=%s poll-state=%s\n" 1962 "%Uauth: local-seq-num=%u remote-seq-num=%u\n" 1963 "%U is-delayed=%s\n" 1991 format (s,
"bs_idx=%u local-state=%s remote-state=%s", bs->
bs_idx,
2000 if (auth_type == BFD_AUTH_TYPE_keyed_sha1 ||
2001 auth_type == BFD_AUTH_TYPE_meticulous_keyed_sha1)
2010 u8 bfd_key_id,
u8 is_delayed)
2013 const uword *key_idx_p =
2018 "authentication key with config ID %u doesn't exist)",
2020 return VNET_API_ERROR_BFD_ENOENT;
2022 const uword key_idx = *key_idx_p;
2094 "SSL missing, cannot deactivate BFD authentication");
2095 return VNET_API_ERROR_BFD_NOTSUPP;
2101 u32 desired_min_tx_usec,
2102 u32 required_min_rx_usec,
u8 detect_mult)
2111 case BFD_POLL_NOT_NEEDED:
2123 case BFD_POLL_NEEDED:
2124 case BFD_POLL_IN_PROGRESS_AND_QUEUED:
2130 case BFD_POLL_IN_PROGRESS:
2135 BFD_DBG (
"Poll in progress, queueing extra poll, bs_idx=%u",
2157 BFD_DBG (
"Ignore parameter change - no change, bs_idx=%u", bs->
bs_idx);
2164 const u8 * key_data)
2172 "invalid authentication key length for auth_type=%d:%s " 2173 "(key_len=%u, must be non-zero, expected max=%u)",
2176 return VNET_API_ERROR_INVALID_VALUE;
2182 return VNET_API_ERROR_BFD_NOTSUPP;
2188 const uword key_idx = *key_idx_p;
2193 "authentication key with conf ID %u in use by %u BFD " 2194 "session(s) - cannot modify", conf_key_id,
2196 return VNET_API_ERROR_BFD_EINUSE;
2213 "SSL missing, cannot manipulate authentication keys");
2214 return VNET_API_ERROR_BFD_NOTSUPP;
2228 const uword key_idx = *key_idx_p;
2233 "authentication key with conf ID %u in use by %u BFD " 2234 "session(s) - cannot delete", conf_key_id,
2236 return VNET_API_ERROR_BFD_EINUSE;
2246 "authentication key with conf ID %u does not exist",
2248 return VNET_API_ERROR_BFD_ENOENT;
2253 "SSL missing, cannot manipulate authentication keys");
2254 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 u64 bfd_usec_to_clocks(const bfd_main_t *bm, u64 us)
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)
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)
struct bfd_session_s::@124 auth
authentication information
bfd_session_t * bfd_get_session(bfd_main_t *bm, bfd_transport_e t)
bfd_notify_fn_t * listeners
vector of callback notification functions
#define hash_set(h, key, value)
bfd_auth_type_e auth_type
authentication type for this key
void bfd_consume_pkt(bfd_main_t *bm, const bfd_pkt_t *pkt, u32 bs_idx)
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)
static void bfd_set_effective_required_min_rx(bfd_main_t *bm, bfd_session_t *bs, u64 required_min_rx_clocks)
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)
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)
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)
void timing_wheel_init(timing_wheel_t *w, u64 current_cpu_time, f64 cpu_clocks_per_second)
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)
u64 timing_wheel_next_expiring_elt_time(timing_wheel_t *w)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
u64 echo_last_rx_clocks
timestamp of last echo packet received
int bfd_verify_pkt_common(const bfd_pkt_t *pkt)
verify bfd packet - common checks
static void bfd_set_state(bfd_main_t *bm, bfd_session_t *bs, bfd_state_e new_state, int handling_wakeup)
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_cpu_time_now(void)
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)
u64 last_tx_clocks
timestamp of last packet transmitted
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)
u64 remote_min_echo_rx_clocks
remote min echo rx interval (clocks)
void timing_wheel_insert(timing_wheel_t *w, u64 insert_cpu_time, u32 user_data)
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
u64 effective_required_min_rx_clocks
effective required min rx interval (clocks)
vlib_log_class_t log_class
log class
u32 remote_seq_number
remote sequence number
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)
timing_wheel_t wheel
timing wheel for scheduling timeouts
vnet_api_error_t bfd_auth_deactivate(bfd_session_t *bs, u8 is_delayed)
static int bfd_verify_pkt_auth_seq_num(bfd_session_t *bs, u32 received_seq_num, int is_meticulous)
u64 effective_desired_min_tx_clocks
effective desired min tx interval (clocks)
static void bfd_lock_check(bfd_main_t *bm)
u32 bfd_clocks_to_usec(const bfd_main_t *bm, u64 clocks)
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)
u64 bfd_process_next_wakeup_clocks
When the bfd process is supposed to wake up next.
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)
u64 tx_timeout_clocks
next time at which to transmit a packet
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 config_required_min_rx_clocks
configured required min rx interval (clocks)
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)
#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
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
u64 default_desired_min_tx_clocks
default desired min tx in clocks
u64 echo_last_tx_clocks
timestamp of last echo packet transmitted
bfd_poll_state_e poll_state
state info regarding poll sequence
u8 bfd_pkt_get_control_plane_independent(const bfd_pkt_t *pkt)
f64 cpu_cps
cpu clocks per second
void bfd_pkt_set_auth_present(bfd_pkt_t *pkt)
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
#define pool_put(P, E)
Free an object E in pool P.
u64 echo_tx_timeout_clocks
next time at which to transmit echo packet
static void bfd_set_diag(bfd_session_t *bs, bfd_diag_code_e code)
u8 local_detect_mult
configured detect multiplier
static int bfd_is_echo_possible(bfd_session_t *bs)
u64 last_rx_clocks
timestamp of last packet received
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)
#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)
u64 transmit_interval_clocks
transmit interval
u8 bfd_pkt_get_multipoint(const bfd_pkt_t *pkt)
static void bfd_set_effective_desired_min_tx(bfd_main_t *bm, bfd_session_t *bs, u64 now, u64 desired_min_tx_clocks)
#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)
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)
u32 * timing_wheel_advance(timing_wheel_t *w, u64 advance_cpu_time, u32 *expired_user_data, u64 *next_expiring_element_cpu_time)
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)
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)
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)
u64 poll_state_start_or_timeout_clocks
helper for delayed poll sequence - marks either start of running poll sequence or timeout...
u64 detection_time_clocks
detection time
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)
u64 config_desired_min_tx_clocks
configured desired min tx interval (clocks)
u64 bfd_process_wakeup_event_start_clocks
The timestamp of last wakeup event being sent.
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
u8 echo
1 is echo function is active, 0 otherwise
u64 wheel_time_clocks
set to value of timer in timing wheel, 0 if never set
u64 remote_desired_min_tx_clocks
remote desired min tx interval (clocks)
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 * session_by_disc
hashmap - bfd session by discriminator
int bfd_consume_echo_pkt(bfd_main_t *bm, vlib_buffer_t *b)
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)
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
u64 echo_transmit_interval_clocks
transmit interval for echo packets
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)
static void bfd_set_timer(bfd_main_t *bm, bfd_session_t *bs, u64 now, int handling_wakeup)
#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
static int bfd_verify_pkt_auth_key(const bfd_pkt_t *pkt, u32 pkt_size, bfd_session_t *bs, u8 bfd_key_id, bfd_auth_key_t *auth_key)
#define vlib_log_crit(...)
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_delay_clocks
The time it took the last wakeup event to make it to handling.
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
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)
#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(...)
u64 min_required_min_rx_while_echo_clocks
minimum required min rx while echo function is active - clocks
int bfd_verify_pkt_auth(const bfd_pkt_t *pkt, u16 pkt_size, bfd_session_t *bs)
verify bfd packet - authentication
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)
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
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...
u64 remote_min_rx_clocks
remote min rx interval (clocks)
u8 is_delayed
set to 1 if delayed action is pending, which might be activation of authentication, change of key or deactivation
static clib_error_t * bfd_main_init(vlib_main_t *vm)
static void bfd_lock(bfd_main_t *bm)
u64 wheel_inaccuracy
timing wheel inaccuracy, in clocks
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)
void bfd_session_set_flags(bfd_session_t *bs, u8 admin_up_down)
static void bfd_check_rx_timeout(bfd_main_t *bm, bfd_session_t *bs, u64 now, int handling_wakeup)