#include <vnet/bfd/bfd_debug.h>
#include <vnet/bfd/bfd_protocol.h>
#include <vnet/bfd/bfd_main.h>
+#include <vlib/log.h>
static u64
bfd_calc_echo_checksum (u32 discriminator, u64 expire_time, u32 secret)
{
u64 checksum = 0;
-#if __SSE4_2__
- checksum = _mm_crc32_u64 (0, discriminator);
- checksum = _mm_crc32_u64 (checksum, expire_time);
- checksum = _mm_crc32_u64 (checksum, secret);
+#if defined(clib_crc32c_uses_intrinsics) && !defined (__i386__)
+ checksum = crc32_u64 (0, discriminator);
+ checksum = crc32_u64 (checksum, expire_time);
+ checksum = crc32_u64 (checksum, secret);
#else
checksum = clib_xxhash (discriminator ^ expire_time ^ secret);
#endif
bs->local_diag = BFD_DIAG_CODE_no_diag;
bs->remote_state = BFD_STATE_down;
bs->remote_discr = 0;
+ bs->hop_type = BFD_HOP_TYPE_SINGLE;
bs->config_desired_min_tx_usec = BFD_DEFAULT_DESIRED_MIN_TX_USEC;
bs->config_desired_min_tx_clocks = bm->default_desired_min_tx_clocks;
bs->effective_desired_min_tx_clocks = bm->default_desired_min_tx_clocks;
}
}
+static void
+bfd_notify_listeners (bfd_main_t * bm,
+ bfd_listen_event_e event, const bfd_session_t * bs)
+{
+ bfd_notify_fn_t *fn;
+ vec_foreach (fn, bm->listeners)
+ {
+ (*fn) (event, bs);
+ }
+}
+
void
bfd_session_start (bfd_main_t * bm, bfd_session_t * bs)
{
BFD_DBG ("\nStarting session: %U", format_bfd_session, bs);
+ vlib_log_info (bm->log_class, "start BFD session: %U",
+ format_bfd_session_brief, bs);
bfd_set_effective_required_min_rx (bm, bs,
bs->config_required_min_rx_clocks);
bfd_recalc_tx_interval (bm, bs);
vlib_process_signal_event (bm->vlib_main, bm->bfd_process_node_index,
BFD_EVENT_NEW_SESSION, bs->bs_idx);
+ bfd_notify_listeners (bm, BFD_LISTEN_EVENT_CREATE, bs);
}
void
if (admin_up_down)
{
BFD_DBG ("Session set admin-up, bs-idx=%u", bs->bs_idx);
+ vlib_log_info (bm->log_class, "set session admin-up: %U",
+ format_bfd_session_brief, bs);
bfd_set_state (bm, bs, BFD_STATE_down, 0);
bfd_set_diag (bs, BFD_DIAG_CODE_no_diag);
bfd_calc_next_tx (bm, bs, now);
else
{
BFD_DBG ("Session set admin-down, bs-idx=%u", bs->bs_idx);
+ vlib_log_info (bm->log_class, "set session admin-down: %U",
+ format_bfd_session_brief, bs);
bfd_set_diag (bs, BFD_DIAG_CODE_admin_down);
bfd_set_state (bm, bs, BFD_STATE_admin_down, 0);
bfd_calc_next_tx (bm, bs, now);
bfd_set_timer (bm, bs, now, handling_wakeup);
break;
}
+ bfd_notify_listeners (bm, BFD_LISTEN_EVENT_UPDATE, bs);
}
static void
static void
bfd_add_auth_section (vlib_buffer_t * b, bfd_session_t * bs)
{
+ bfd_main_t *bm = &bfd_main;
if (bs->auth.curr_key)
{
const bfd_auth_type_e auth_type = bs->auth.curr_key->auth_type;
case BFD_AUTH_TYPE_keyed_md5:
/* fallthrough */
case BFD_AUTH_TYPE_meticulous_keyed_md5:
- clib_warning ("Internal error, unexpected BFD auth type '%d'",
- auth_type);
+ vlib_log_crit (bm->log_class,
+ "internal error, unexpected BFD auth type '%d'",
+ auth_type);
break;
#if WITH_LIBSSL > 0
case BFD_AUTH_TYPE_keyed_sha1:
case BFD_AUTH_TYPE_keyed_sha1:
/* fallthrough */
case BFD_AUTH_TYPE_meticulous_keyed_sha1:
- clib_warning ("Internal error, unexpected BFD auth type '%d'",
- auth_type);
+ vlib_log_crit (bm->log_class,
+ "internal error, unexpected BFD auth type '%d'",
+ auth_type);
break;
#endif
}
u32 bi;
if (vlib_buffer_alloc (vm, &bi, 1) != 1)
{
- clib_warning ("buffer allocation failure");
+ vlib_log_crit (bm->log_class, "buffer allocation failure");
return;
}
vlib_buffer_t *b = vlib_get_buffer (vm, bi);
u32 bi;
if (vlib_buffer_alloc (vm, &bi, 1) != 1)
{
- clib_warning ("buffer allocation failure");
+ vlib_log_crit (bm->log_class, "buffer allocation failure");
return;
}
vlib_buffer_t *b = vlib_get_buffer (vm, bi);
}
break;
default:
- clib_warning ("BUG: event type 0x%wx", event_type);
+ vlib_log_err (bm->log_class, "BUG: event type 0x%wx", event_type);
break;
}
BFD_DBG ("advancing wheel, now is %lu", now);
VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION (bfd_hw_interface_up_down);
+void
+bfd_register_listener (bfd_notify_fn_t fn)
+{
+ bfd_main_t *bm = &bfd_main;
+
+ vec_add1 (bm->listeners, fn);
+}
+
/*
* setup function
*/
const u64 now = clib_cpu_time_now ();
timing_wheel_init (&bm->wheel, now, bm->cpu_cps);
bm->wheel_inaccuracy = 2 << bm->wheel.log2_clocks_per_bin;
+ bm->log_class = vlib_log_register_class ("bfd", 0);
+ vlib_log_debug (bm->log_class, "initialized");
return 0;
}
result->local_discr = random_u32 (&bm->random_seed);
if (counter > limit)
{
- clib_warning ("Couldn't allocate unused session discriminator even "
- "after %u tries!", limit);
+ vlib_log_crit (bm->log_class,
+ "couldn't allocate unused session discriminator even "
+ "after %u tries!", limit);
pool_put (bm->sessions, result);
return NULL;
}
void
bfd_put_session (bfd_main_t * bm, bfd_session_t * bs)
{
+ vlib_log_info (bm->log_class, "delete session: %U",
+ format_bfd_session_brief, bs);
+ bfd_notify_listeners (bm, BFD_LISTEN_EVENT_DELETE, bs);
if (bs->auth.curr_key)
{
--bs->auth.curr_key->use_count;
bfd_session_t * bs, u8 bfd_key_id,
bfd_auth_key_t * auth_key)
{
+ bfd_main_t *bm = &bfd_main;
switch (auth_key->auth_type)
{
case BFD_AUTH_TYPE_reserved:
- clib_warning ("Internal error, unexpected auth_type=%d:%s",
+ vlib_log_err (bm->log_class,
+ "internal error, unexpected auth_type=%d:%s",
auth_key->auth_type,
bfd_auth_type_str (auth_key->auth_type));
return 0;
case BFD_AUTH_TYPE_simple_password:
- clib_warning
- ("Internal error, not implemented, unexpected auth_type=%d:%s",
- auth_key->auth_type, bfd_auth_type_str (auth_key->auth_type));
+ vlib_log_err (bm->log_class,
+ "internal error, not implemented, unexpected auth_type=%d:%s",
+ auth_key->auth_type,
+ bfd_auth_type_str (auth_key->auth_type));
return 0;
case BFD_AUTH_TYPE_keyed_md5:
/* fallthrough */
case BFD_AUTH_TYPE_meticulous_keyed_md5:
- clib_warning
- ("Internal error, not implemented, unexpected auth_type=%d:%s",
+ vlib_log_err
+ (bm->log_class,
+ "internal error, not implemented, unexpected auth_type=%d:%s",
auth_key->auth_type, bfd_auth_type_str (auth_key->auth_type));
return 0;
case BFD_AUTH_TYPE_keyed_sha1:
}
while (0);
#else
- clib_warning
- ("Internal error, attempt to use SHA1 without SSL support");
+ vlib_log_err
+ (bm->log_class,
+ "internal error, attempt to use SHA1 without SSL support");
return 0;
#endif
}
case BFD_AUTH_TYPE_keyed_md5:
/* fallthrough */
case BFD_AUTH_TYPE_meticulous_keyed_md5:
- clib_warning ("Internal error, unexpected auth_type=%d:%s",
- auth_type, bfd_auth_type_str (auth_type));
+ vlib_log_crit (bm->log_class,
+ "internal error, unexpected auth_type=%d:%s",
+ auth_type, bfd_auth_type_str (auth_type));
break;
case BFD_AUTH_TYPE_keyed_sha1:
/* fallthrough */
format_bfd_session (u8 * s, va_list * args)
{
const bfd_session_t *bs = va_arg (*args, bfd_session_t *);
- uword indent = format_get_indent (s);
+ u32 indent = format_get_indent (s) + vlib_log_get_indent ();
s = format (s, "bs_idx=%u local-state=%s remote-state=%s\n"
"%Ulocal-discriminator=%u remote-discriminator=%u\n"
"%Ulocal-diag=%s echo-active=%s\n"
return s;
}
+u8 *
+format_bfd_session_brief (u8 * s, va_list * args)
+{
+ const bfd_session_t *bs = va_arg (*args, bfd_session_t *);
+ s =
+ format (s, "bs_idx=%u local-state=%s remote-state=%s", bs->bs_idx,
+ bfd_state_string (bs->local_state),
+ bfd_state_string (bs->remote_state));
+ return s;
+}
+
unsigned
bfd_auth_type_supported (bfd_auth_type_e auth_type)
{
hash_get (bm->auth_key_by_conf_key_id, conf_key_id);
if (!key_idx_p)
{
- clib_warning ("Authentication key with config ID %u doesn't exist)",
+ vlib_log_err (bm->log_class,
+ "authentication key with config ID %u doesn't exist)",
conf_key_id);
return VNET_API_ERROR_BFD_ENOENT;
}
}
++key->use_count;
BFD_DBG ("\nSession auth modified: %U", format_bfd_session, bs);
+ vlib_log_info (bm->log_class, "session auth modified: %U",
+ format_bfd_session_brief, bs);
return 0;
}
vnet_api_error_t
bfd_auth_deactivate (bfd_session_t * bs, u8 is_delayed)
{
+ bfd_main_t *bm = &bfd_main;
#if WITH_LIBSSL > 0
if (!is_delayed)
{
bs->auth.next_key = NULL;
}
BFD_DBG ("\nSession auth modified: %U", format_bfd_session, bs);
+ vlib_log_info (bm->log_class, "session auth modified: %U",
+ format_bfd_session_brief, bs);
return 0;
#else
- clib_warning ("SSL missing, cannot deactivate BFD authentication");
+ vlib_log_err (bm->log_class,
+ "SSL missing, cannot deactivate BFD authentication");
return VNET_API_ERROR_BFD_NOTSUPP;
#endif
}
bfd_usec_to_clocks (bm, required_min_rx_usec);
BFD_DBG ("\nChanged session params: %U", format_bfd_session, bs);
+ vlib_log_info (bm->log_class, "changed session params: %U",
+ format_bfd_session_brief, bs);
vlib_process_signal_event (bm->vlib_main, bm->bfd_process_node_index,
BFD_EVENT_CONFIG_CHANGED, bs->bs_idx);
}
bfd_auth_set_key (u32 conf_key_id, u8 auth_type, u8 key_len,
const u8 * key_data)
{
+ bfd_main_t *bm = &bfd_main;
#if WITH_LIBSSL > 0
bfd_auth_key_t *auth_key = NULL;
if (!key_len || key_len > bfd_max_key_len_for_auth_type (auth_type))
{
- clib_warning ("Invalid authentication key length for auth_type=%d:%s "
- "(key_len=%u, must be "
- "non-zero, expected max=%u)",
+ vlib_log_err (bm->log_class,
+ "invalid authentication key length for auth_type=%d:%s "
+ "(key_len=%u, must be non-zero, expected max=%u)",
auth_type, bfd_auth_type_str (auth_type), key_len,
(u32) bfd_max_key_len_for_auth_type (auth_type));
return VNET_API_ERROR_INVALID_VALUE;
}
if (!bfd_auth_type_supported (auth_type))
{
- clib_warning ("Unsupported auth type=%d:%s", auth_type,
+ vlib_log_err (bm->log_class, "unsupported auth type=%d:%s", auth_type,
bfd_auth_type_str (auth_type));
return VNET_API_ERROR_BFD_NOTSUPP;
}
- bfd_main_t *bm = &bfd_main;
uword *key_idx_p = hash_get (bm->auth_key_by_conf_key_id, conf_key_id);
if (key_idx_p)
{
auth_key = pool_elt_at_index (bm->auth_keys, key_idx);
if (auth_key->use_count > 0)
{
- clib_warning ("Authentication key with conf ID %u in use by %u BFD "
- "session(s) - cannot modify",
- conf_key_id, auth_key->use_count);
+ vlib_log_err (bm->log_class,
+ "authentication key with conf ID %u in use by %u BFD "
+ "session(s) - cannot modify", conf_key_id,
+ auth_key->use_count);
return VNET_API_ERROR_BFD_EINUSE;
}
}
clib_memcpy (auth_key->key, key_data, key_len);
return 0;
#else
- clib_warning ("SSL missing, cannot manipulate authentication keys");
+ vlib_log_err (bm->log_class,
+ "SSL missing, cannot manipulate authentication keys");
return VNET_API_ERROR_BFD_NOTSUPP;
#endif
}
auth_key = pool_elt_at_index (bm->auth_keys, key_idx);
if (auth_key->use_count > 0)
{
- clib_warning ("Authentication key with conf ID %u in use by %u BFD "
- "session(s) - cannot delete",
- conf_key_id, auth_key->use_count);
+ vlib_log_err (bm->log_class,
+ "authentication key with conf ID %u in use by %u BFD "
+ "session(s) - cannot delete", conf_key_id,
+ auth_key->use_count);
return VNET_API_ERROR_BFD_EINUSE;
}
hash_unset (bm->auth_key_by_conf_key_id, conf_key_id);
else
{
/* no such key */
- clib_warning ("Authentication key with conf ID %u does not exist",
+ vlib_log_err (bm->log_class,
+ "authentication key with conf ID %u does not exist",
conf_key_id);
return VNET_API_ERROR_BFD_ENOENT;
}
return 0;
#else
- clib_warning ("SSL missing, cannot manipulate authentication keys");
+ vlib_log_err (bm->log_class,
+ "SSL missing, cannot manipulate authentication keys");
return VNET_API_ERROR_BFD_NOTSUPP;
#endif
}