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);
777 memset (auth, 0,
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);
863 memset (pkt, 0,
sizeof (*pkt));
868 pkt->head.length = bfd_length;
883 pkt->req_min_echo_rx = clib_host_to_net_u32 (1);
914 memset (pkt, 0,
sizeof (*pkt));
916 pkt->expire_time_clocks =
924 BFD_ERR (
"cannot send echo packet out, turning echo off");
931 BFD_ERR (
"cannot send echo packet out, turning echo off");
942 (
"No need to send echo packet now, now is %lu, tx_timeout is %lu",
953 BFD_DBG (
"Remote min rx interval is zero, not sending periodic control " 966 BFD_DBG (
"Remote demand is set, not sending periodic control frame");
990 case BFD_POLL_NEEDED:
991 if (now < bs->poll_state_start_or_timeout_clocks)
993 BFD_DBG (
"Cannot start a poll sequence yet, need to wait " 1002 case BFD_POLL_IN_PROGRESS:
1003 case BFD_POLL_IN_PROGRESS_AND_QUEUED:
1005 BFD_DBG (
"Setting poll bit in packet, bs_idx=%u", bs->
bs_idx);
1007 case BFD_POLL_NOT_NEEDED:
1023 (
"No need to send control frame now, now is %lu, tx_timeout is %lu",
1033 BFD_DBG (
"Send final control frame for bs_idx=%lu", bs->
bs_idx);
1049 int handling_wakeup)
1058 BFD_DBG (
"Rx timeout, session goes down");
1070 else if (bs->
echo &&
1075 BFD_DBG (
"Echo rx timeout, session goes down");
1088 case BFD_STATE_admin_down:
1091 case BFD_STATE_down:
1094 case BFD_STATE_init:
1104 BFD_DBG (
"Switching on echo function, bs_idx=%u", bs->
bs_idx);
1131 uword event_type, *event_data = 0;
1141 BFD_DBG (
"timing_wheel_next_expiring_elt_time(%p) returns %lu",
1142 &bm->
wheel, next_expire);
1144 (
i64) next_expire >= 0 ? next_expire : ~0;
1146 if ((
i64) next_expire < 0)
1148 BFD_DBG (
"wait for event without timeout");
1155 BFD_DBG (
"wait for event with timeout %.02f", timeout);
1158 BFD_DBG (
"negative timeout, already expired, skipping wait");
1168 uword *session_index;
1196 BFD_DBG (
"Ignoring event for non-existent session index %u",
1197 (
u32) * session_index);
1214 BFD_DBG (
"Ignoring event for non-existent session index %u",
1215 (
u32) * session_index);
1224 BFD_DBG (
"advancing wheel, now is %lu", now);
1225 BFD_DBG (
"timing_wheel_advance (%p, %lu, %p, 0);", &bm->
wheel, now,
1233 const u32 bs_idx = *p;
1244 _vec_len (expired) = 0;
1248 _vec_len (event_data) = 0;
1262 .name =
"bfd-process",
1312 setbuf (stdout,
NULL);
1331 if (n_vlib_mains > 1)
1346 memset (result, 0,
sizeof (*result));
1349 const unsigned limit = 1000;
1350 unsigned counter = 0;
1354 if (counter > limit)
1357 "couldn't allocate unused session discriminator even " 1358 "after %u tries!", limit);
1428 BFD_ERR (
"BFD verification failed - unexpected version: '%d'",
1432 if (pkt->head.length < sizeof (bfd_pkt_t) ||
1434 pkt->head.length < sizeof (bfd_pkt_with_common_auth_t)))
1436 BFD_ERR (
"BFD verification failed - unexpected length: '%d' (auth " 1441 if (!pkt->head.detect_mult)
1443 BFD_ERR (
"BFD verification failed - unexpected detect-mult: '%d'",
1444 pkt->head.detect_mult);
1449 BFD_ERR (
"BFD verification failed - unexpected multipoint: '%d'",
1455 BFD_ERR (
"BFD verification failed - unexpected my-disc: '%d'",
1459 if (!pkt->your_disc)
1462 if (pkt_state != BFD_STATE_down && pkt_state != BFD_STATE_admin_down)
1464 BFD_ERR (
"BFD verification failed - unexpected state: '%s' " 1475 BFD_DBG (
"Switching authentication key from %U to %U for bs_idx=%u",
1491 if (BFD_AUTH_TYPE_meticulous_keyed_md5 == auth_type ||
1492 BFD_AUTH_TYPE_meticulous_keyed_sha1 == auth_type)
1501 u32 received_seq_num,
int is_meticulous)
1512 BFD_DBG (
"BFD peer unresponsive for %lu clocks, which is > 2 * " 1513 "detection_time=%u clocks, resetting remote_seq_number_known " 1521 const u32 max_u32 = 0xffffffff;
1540 if (received_seq_num > x &&
1541 received_seq_num < bs->auth.remote_seq_number + is_meticulous)
1544 (
"Recvd sequence number=%u out of ranges <0, %u>, <%u, %u>",
1545 received_seq_num, x,
1556 if (received_seq_num < min || received_seq_num > max)
1558 BFD_ERR (
"Recvd sequence number=%u out of range <%u, %u>",
1559 received_seq_num, min, max);
1573 auth_key->
auth_type == BFD_AUTH_TYPE_meticulous_keyed_sha1);
1575 u8 result[SHA_DIGEST_LENGTH];
1576 bfd_pkt_with_common_auth_t *with_common = (
void *) pkt;
1577 if (pkt_size <
sizeof (*with_common))
1579 BFD_ERR (
"Packet size too small to hold authentication common header");
1582 if (with_common->common_auth.type != auth_key->
auth_type)
1584 BFD_ERR (
"BFD auth type mismatch, packet auth=%d:%s doesn't match " 1585 "in-use auth=%d:%s",
1586 with_common->common_auth.type,
1591 bfd_pkt_with_sha1_auth_t *with_sha1 = (
void *) pkt;
1592 if (pkt_size <
sizeof (*with_sha1) ||
1593 with_sha1->sha1_auth.type_len.len <
sizeof (with_sha1->sha1_auth))
1596 (
"BFD size mismatch, payload size=%u, expected=%u, auth_len=%u, " 1597 "expected=%u", pkt_size,
sizeof (*with_sha1),
1598 with_sha1->sha1_auth.type_len.len, sizeof (with_sha1->sha1_auth));
1601 if (with_sha1->sha1_auth.key_id != bfd_key_id)
1604 (
"BFD key ID mismatch, packet key ID=%u doesn't match key ID=%u%s",
1605 with_sha1->sha1_auth.key_id, bfd_key_id,
1607 auth.
is_delayed ?
" (but a delayed auth change is scheduled)" :
"");
1611 if (!SHA1_Init (&ctx))
1617 if (!SHA1_Update (&ctx, with_sha1,
1618 sizeof (*with_sha1) -
sizeof (with_sha1->sha1_auth.hash)))
1620 BFD_ERR (
"SHA1_Update failed");
1623 if (!SHA1_Update (&ctx, auth_key->
key, sizeof (auth_key->
key)))
1625 BFD_ERR (
"SHA1_Update failed");
1628 if (!SHA1_Final (result, &ctx))
1630 BFD_ERR (
"SHA1_Final failed");
1633 if (0 == memcmp (result, with_sha1->sha1_auth.hash, SHA_DIGEST_LENGTH))
1637 BFD_ERR (
"SHA1 hash: %U doesn't match the expected value: %U",
1651 case BFD_AUTH_TYPE_reserved:
1653 "internal error, unexpected auth_type=%d:%s",
1657 case BFD_AUTH_TYPE_simple_password:
1659 "internal error, not implemented, unexpected auth_type=%d:%s",
1663 case BFD_AUTH_TYPE_keyed_md5:
1665 case BFD_AUTH_TYPE_meticulous_keyed_md5:
1668 "internal error, not implemented, unexpected auth_type=%d:%s",
1671 case BFD_AUTH_TYPE_keyed_sha1:
1673 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
1677 const u32 seq_num = clib_net_to_host_u32 (((bfd_pkt_with_sha1_auth_t
1690 "internal error, attempt to use SHA1 without SSL support");
1757 if (pkt_size >
sizeof (*pkt))
1759 BFD_ERR (
"BFD verification failed - unexpected packet size '%d' " 1760 "(auth not present)", pkt_size);
1788 if (!bs || (pkt->your_disc && pkt->your_disc != bs->
local_discr))
1802 ((bfd_pkt_with_common_auth_t *) (pkt))->common_auth.type;
1805 case BFD_AUTH_TYPE_reserved:
1807 case BFD_AUTH_TYPE_simple_password:
1809 case BFD_AUTH_TYPE_keyed_md5:
1811 case BFD_AUTH_TYPE_meticulous_keyed_md5:
1813 "internal error, unexpected auth_type=%d:%s",
1816 case BFD_AUTH_TYPE_keyed_sha1:
1818 case BFD_AUTH_TYPE_meticulous_keyed_sha1:
1821 bfd_pkt_with_sha1_auth_t *with_sha1 =
1822 (bfd_pkt_with_sha1_auth_t *) pkt;
1824 clib_net_to_host_u32 (with_sha1->sha1_auth.seq_num);
1826 BFD_DBG (
"Received sequence number %u",
1836 clib_net_to_host_u32 (pkt->req_min_rx));
1838 clib_net_to_host_u32
1839 (pkt->req_min_echo_rx));
1844 BFD_DBG (
"Poll sequence terminated, bs_idx=%u", bs->
bs_idx);
1854 else if (BFD_POLL_IN_PROGRESS_AND_QUEUED == bs->
poll_state)
1860 BFD_DBG (
"Next poll sequence can commence in " BFD_CLK_FMT,
1866 (
"Poll sequence terminated, but another is needed, bs_idx=%u",
1875 BFD_DBG (
"Session is admin-down, ignoring packet, bs_idx=%u",
1919 bfd_echo_pkt_t *pkt =
NULL;
1930 BFD_DBG (
"Scanning bfd echo packet, bs_idx=%d", bs->
bs_idx);
1934 if (checksum != pkt->checksum)
1936 BFD_DBG (
"Invalid echo packet, checksum mismatch");
1940 if (pkt->expire_time_clocks < now)
1942 BFD_DBG (
"Stale packet received, expire time %lu < now %lu",
1943 pkt->expire_time_clocks, now);
1957 s =
format (s,
"bs_idx=%u local-state=%s remote-state=%s\n" 1958 "%Ulocal-discriminator=%u remote-discriminator=%u\n" 1959 "%Ulocal-diag=%s echo-active=%s\n" 1960 "%Udesired-min-tx=%u required-min-rx=%u\n" 1961 "%Urequired-min-echo-rx=%u detect-mult=%u\n" 1962 "%Uremote-min-rx=%u remote-min-echo-rx=%u\n" 1963 "%Uremote-demand=%s poll-state=%s\n" 1964 "%Uauth: local-seq-num=%u remote-seq-num=%u\n" 1965 "%U is-delayed=%s\n" 1993 format (s,
"bs_idx=%u local-state=%s remote-state=%s", bs->
bs_idx,
2002 if (auth_type == BFD_AUTH_TYPE_keyed_sha1 ||
2003 auth_type == BFD_AUTH_TYPE_meticulous_keyed_sha1)
2012 u8 bfd_key_id,
u8 is_delayed)
2015 const uword *key_idx_p =
2020 "authentication key with config ID %u doesn't exist)",
2022 return VNET_API_ERROR_BFD_ENOENT;
2024 const uword key_idx = *key_idx_p;
2096 "SSL missing, cannot deactivate BFD authentication");
2097 return VNET_API_ERROR_BFD_NOTSUPP;
2103 u32 desired_min_tx_usec,
2104 u32 required_min_rx_usec,
u8 detect_mult)
2113 case BFD_POLL_NOT_NEEDED:
2125 case BFD_POLL_NEEDED:
2126 case BFD_POLL_IN_PROGRESS_AND_QUEUED:
2132 case BFD_POLL_IN_PROGRESS:
2137 BFD_DBG (
"Poll in progress, queueing extra poll, bs_idx=%u",
2159 BFD_DBG (
"Ignore parameter change - no change, bs_idx=%u", bs->
bs_idx);
2166 const u8 * key_data)
2174 "invalid authentication key length for auth_type=%d:%s " 2175 "(key_len=%u, must be non-zero, expected max=%u)",
2178 return VNET_API_ERROR_INVALID_VALUE;
2184 return VNET_API_ERROR_BFD_NOTSUPP;
2190 const uword key_idx = *key_idx_p;
2195 "authentication key with conf ID %u in use by %u BFD " 2196 "session(s) - cannot modify", conf_key_id,
2198 return VNET_API_ERROR_BFD_EINUSE;
2215 "SSL missing, cannot manipulate authentication keys");
2216 return VNET_API_ERROR_BFD_NOTSUPP;
2230 const uword key_idx = *key_idx_p;
2235 "authentication key with conf ID %u in use by %u BFD " 2236 "session(s) - cannot delete", conf_key_id,
2238 return VNET_API_ERROR_BFD_EINUSE;
2241 memset (auth_key, 0,
sizeof (*auth_key));
2248 "authentication key with conf ID %u does not exist",
2250 return VNET_API_ERROR_BFD_ENOENT;
2255 "SSL missing, cannot manipulate authentication keys");
2256 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)
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)
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)
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
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)
struct bfd_session_s::@50 auth
authentication information
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)
#define VNET_HW_INTERFACE_FLAG_LINK_UP
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)
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...
memset(h->entries, 0, sizeof(h->entries[0])*entries)
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
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)
vhost_vring_state_t state
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)
u16 current_length
Nbytes between current data and the end of this buffer.
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)
#define clib_memcpy(a, b, c)
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
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)
#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
#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)