#include <config.h>
#include "bfd.h"
+#include <sys/types.h>
#include <arpa/inet.h>
+#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include "byte-order.h"
#include "hash.h"
#include "hmap.h"
#include "list.h"
+#include "netdev.h"
#include "netlink.h"
#include "odp-util.h"
#include "ofpbuf.h"
#include "random.h"
#include "smap.h"
#include "timeval.h"
+#include "unaligned.h"
#include "unixctl.h"
#include "util.h"
#include "vlog.h"
bool cpath_down; /* Concatenated Path Down. */
uint8_t mult; /* bfd.DetectMult. */
+ struct netdev *netdev;
+ uint64_t rx_packets; /* Packets received by 'netdev'. */
+
enum state state; /* bfd.SessionState. */
enum state rmt_state; /* bfd.RemoteSessionState. */
uint32_t rmt_disc; /* bfd.RemoteDiscr. */
+ uint8_t eth_dst[ETH_ADDR_LEN];/* Ethernet destination address. */
+ bool eth_dst_set; /* 'eth_dst' set through database. */
+
uint16_t udp_src; /* UDP source port. */
/* All timers in milliseconds. */
atomic_bool check_tnl_key; /* Verify tunnel key of inbound packets? */
atomic_int ref_cnt;
+
+ /* When forward_if_rx is true, bfd_forwarding() will return
+ * true as long as there are incoming packets received.
+ * Note, forwarding_override still has higher priority. */
+ bool forwarding_if_rx;
+ long long int forwarding_if_rx_detect_time;
+
+ /* BFD decay related variables. */
+ bool in_decay; /* True when bfd is in decay. */
+ int decay_min_rx; /* min_rx is set to decay_min_rx when */
+ /* in decay. */
+ int decay_rx_ctl; /* Count bfd packets received within decay */
+ /* detect interval. */
+ uint64_t decay_rx_packets; /* Packets received by 'netdev'. */
+ long long int decay_detect_time; /* Decay detection time. */
};
static struct ovs_mutex mutex = OVS_MUTEX_INITIALIZER;
static struct hmap all_bfds__ = HMAP_INITIALIZER(&all_bfds__);
static struct hmap *const all_bfds OVS_GUARDED_BY(mutex) = &all_bfds__;
-static bool bfd_forwarding__(const struct bfd *) OVS_REQ_WRLOCK(mutex);
-static bool bfd_in_poll(const struct bfd *) OVS_REQ_WRLOCK(&mutex);
-static void bfd_poll(struct bfd *bfd) OVS_REQ_WRLOCK(&mutex);
-static const char *bfd_diag_str(enum diag) OVS_REQ_WRLOCK(&mutex);
-static const char *bfd_state_str(enum state) OVS_REQ_WRLOCK(&mutex);
-static long long int bfd_min_tx(const struct bfd *) OVS_REQ_WRLOCK(&mutex);
+static bool bfd_forwarding__(const struct bfd *) OVS_REQUIRES(mutex);
+static bool bfd_in_poll(const struct bfd *) OVS_REQUIRES(mutex);
+static void bfd_poll(struct bfd *bfd) OVS_REQUIRES(mutex);
+static const char *bfd_diag_str(enum diag) OVS_REQUIRES(mutex);
+static const char *bfd_state_str(enum state) OVS_REQUIRES(mutex);
+static long long int bfd_min_tx(const struct bfd *) OVS_REQUIRES(mutex);
static long long int bfd_tx_interval(const struct bfd *)
- OVS_REQ_WRLOCK(&mutex);
+ OVS_REQUIRES(mutex);
static long long int bfd_rx_interval(const struct bfd *)
- OVS_REQ_WRLOCK(&mutex);
-static void bfd_set_next_tx(struct bfd *) OVS_REQ_WRLOCK(&mutex);
+ OVS_REQUIRES(mutex);
+static void bfd_set_next_tx(struct bfd *) OVS_REQUIRES(mutex);
static void bfd_set_state(struct bfd *, enum state, enum diag)
- OVS_REQ_WRLOCK(&mutex);
-static uint32_t generate_discriminator(void) OVS_REQ_WRLOCK(&mutex);
+ OVS_REQUIRES(mutex);
+static uint32_t generate_discriminator(void) OVS_REQUIRES(mutex);
static void bfd_put_details(struct ds *, const struct bfd *)
- OVS_REQ_WRLOCK(&mutex);
+ OVS_REQUIRES(mutex);
+static uint64_t bfd_rx_packets(const struct bfd *) OVS_REQUIRES(mutex);
+static void bfd_try_decay(struct bfd *) OVS_REQUIRES(mutex);
+static void bfd_decay_update(struct bfd *) OVS_REQUIRES(mutex);
+static void bfd_check_rx(struct bfd *) OVS_REQUIRES(mutex);
+static void bfd_forwarding_if_rx_update(struct bfd *) OVS_REQUIRES(mutex);
static void bfd_unixctl_show(struct unixctl_conn *, int argc,
const char *argv[], void *aux OVS_UNUSED);
static void bfd_unixctl_set_forwarding_override(struct unixctl_conn *,
int argc, const char *argv[],
void *aux OVS_UNUSED);
static void log_msg(enum vlog_level, const struct msg *, const char *message,
- const struct bfd *) OVS_REQ_WRLOCK(&mutex);
+ const struct bfd *) OVS_REQUIRES(mutex);
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(20, 20);
* handle for the session, or NULL if BFD is not enabled according to 'cfg'.
* Also returns NULL if cfg is NULL. */
struct bfd *
-bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg)
- OVS_EXCLUDED(mutex)
+bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg,
+ struct netdev *netdev) OVS_EXCLUDED(mutex)
{
static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
static atomic_uint16_t udp_src = ATOMIC_VAR_INIT(0);
+ int decay_min_rx;
long long int min_tx, min_rx;
- bool cpath_down;
+ bool need_poll = false;
+ bool cfg_min_rx_changed = false;
+ bool cpath_down, forwarding_if_rx;
+ const char *hwaddr;
+ uint8_t ea[ETH_ADDR_LEN];
if (ovsthread_once_start(&once)) {
unixctl_command_register("bfd/show", "[interface]", 0, 1,
bfd->min_tx = 1000;
bfd->mult = 3;
atomic_init(&bfd->ref_cnt, 1);
+ bfd->netdev = netdev_ref(netdev);
+ bfd->rx_packets = bfd_rx_packets(bfd);
+ bfd->in_decay = false;
/* RFC 5881 section 4
* The source port MUST be in the range 49152 through 65535. The same
bfd->udp_src = (bfd->udp_src % 16384) + 49152;
bfd_set_state(bfd, STATE_DOWN, DIAG_NONE);
+
+ memcpy(bfd->eth_dst, eth_addr_bfd, ETH_ADDR_LEN);
}
atomic_store(&bfd->check_tnl_key,
|| (!bfd_in_poll(bfd) && bfd->cfg_min_tx < bfd->min_tx)) {
bfd->min_tx = bfd->cfg_min_tx;
}
- bfd_poll(bfd);
+ need_poll = true;
}
min_rx = smap_get_int(cfg, "min_rx", 1000);
|| (!bfd_in_poll(bfd) && bfd->cfg_min_rx > bfd->min_rx)) {
bfd->min_rx = bfd->cfg_min_rx;
}
- bfd_poll(bfd);
+ cfg_min_rx_changed = true;
+ need_poll = true;
+ }
+
+ decay_min_rx = smap_get_int(cfg, "decay_min_rx", 0);
+ if (bfd->decay_min_rx != decay_min_rx || cfg_min_rx_changed) {
+ if (decay_min_rx > 0 && decay_min_rx < bfd->cfg_min_rx) {
+ VLOG_WARN("%s: decay_min_rx cannot be less than %lld ms",
+ bfd->name, bfd->cfg_min_rx);
+ bfd->decay_min_rx = 0;
+ } else {
+ bfd->decay_min_rx = decay_min_rx;
+ }
+ /* Resets decay. */
+ bfd->in_decay = false;
+ bfd_decay_update(bfd);
+ need_poll = true;
}
cpath_down = smap_get_bool(cfg, "cpath_down", false);
if (bfd->diag == DIAG_NONE || bfd->diag == DIAG_CPATH_DOWN) {
bfd_set_state(bfd, bfd->state, DIAG_NONE);
}
+ need_poll = true;
+ }
+
+ hwaddr = smap_get(cfg, "bfd_dst_mac");
+ if (hwaddr && eth_addr_from_string(hwaddr, ea) && !eth_addr_is_zero(ea)) {
+ memcpy(bfd->eth_dst, ea, ETH_ADDR_LEN);
+ bfd->eth_dst_set = true;
+ } else if (bfd->eth_dst_set) {
+ memcpy(bfd->eth_dst, eth_addr_bfd, ETH_ADDR_LEN);
+ bfd->eth_dst_set = false;
+ }
+
+ forwarding_if_rx = smap_get_bool(cfg, "forwarding_if_rx", false);
+ if (bfd->forwarding_if_rx != forwarding_if_rx) {
+ bfd->forwarding_if_rx = forwarding_if_rx;
+ if (bfd->state == STATE_UP && bfd->forwarding_if_rx) {
+ bfd_forwarding_if_rx_update(bfd);
+ } else {
+ bfd->forwarding_if_rx_detect_time = 0;
+ }
+ }
+
+ if (need_poll) {
bfd_poll(bfd);
}
ovs_mutex_unlock(&mutex);
if (orig == 1) {
ovs_mutex_lock(&mutex);
hmap_remove(all_bfds, &bfd->node);
+ netdev_close(bfd->netdev);
free(bfd->name);
free(bfd);
ovs_mutex_unlock(&mutex);
void
bfd_run(struct bfd *bfd) OVS_EXCLUDED(mutex)
{
+ long long int now;
+ bool old_in_decay;
+
ovs_mutex_lock(&mutex);
- if (bfd->state > STATE_DOWN && time_msec() >= bfd->detect_time) {
+ now = time_msec();
+ old_in_decay = bfd->in_decay;
+
+ if (bfd->state > STATE_DOWN && now >= bfd->detect_time) {
bfd_set_state(bfd, STATE_DOWN, DIAG_EXPIRED);
}
- if (bfd->min_tx != bfd->cfg_min_tx || bfd->min_rx != bfd->cfg_min_rx) {
+ /* Decay may only happen when state is STATE_UP, bfd->decay_min_rx is
+ * configured, and decay_detect_time is reached. */
+ if (bfd->state == STATE_UP && bfd->decay_min_rx > 0
+ && now >= bfd->decay_detect_time) {
+ bfd_try_decay(bfd);
+ }
+
+ /* Always checks the reception of any packet. */
+ bfd_check_rx(bfd);
+
+ if (bfd->min_tx != bfd->cfg_min_tx
+ || (bfd->min_rx != bfd->cfg_min_rx && bfd->min_rx != bfd->decay_min_rx)
+ || bfd->in_decay != old_in_decay) {
bfd_poll(bfd);
}
ovs_mutex_unlock(&mutex);
ofpbuf_reserve(p, 2); /* Properly align after the ethernet header. */
eth = ofpbuf_put_uninit(p, sizeof *eth);
- memcpy(eth->eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
+ memcpy(eth->eth_dst, bfd->eth_dst, ETH_ADDR_LEN);
eth->eth_type = htons(ETH_TYPE_IP);
ip = ofpbuf_put_zeros(p, sizeof *ip);
ip->ip_ttl = MAXTTL;
ip->ip_tos = IPTOS_LOWDELAY | IPTOS_THROUGHPUT;
ip->ip_proto = IPPROTO_UDP;
- ip->ip_src = htonl(0xA9FE0100); /* 169.254.1.0 Link Local. */
- ip->ip_dst = htonl(0xA9FE0101); /* 169.254.1.1 Link Local. */
+ /* Use link local addresses: */
+ put_16aligned_be32(&ip->ip_src, htonl(0xA9FE0100)); /* 169.254.1.0. */
+ put_16aligned_be32(&ip->ip_dst, htonl(0xA9FE0101)); /* 169.254.1.1. */
ip->ip_csum = csum(ip, sizeof *ip);
udp = ofpbuf_put_zeros(p, sizeof *udp);
}
bool
-bfd_should_process_flow(const struct bfd *bfd, const struct flow *flow,
+bfd_should_process_flow(const struct bfd *bfd_, const struct flow *flow,
struct flow_wildcards *wc)
{
+ struct bfd *bfd = CONST_CAST(struct bfd *, bfd_);
bool check_tnl_key;
+ memset(&wc->masks.dl_dst, 0xff, sizeof wc->masks.dl_dst);
+ if (bfd->eth_dst_set && memcmp(bfd->eth_dst, flow->dl_dst, ETH_ADDR_LEN)) {
+ return false;
+ }
+
memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto);
memset(&wc->masks.tp_dst, 0xff, sizeof wc->masks.tp_dst);
}
return (flow->dl_type == htons(ETH_TYPE_IP)
&& flow->nw_proto == IPPROTO_UDP
- && flow->tp_dst == htons(3784)
- && (check_tnl_key || flow->tunnel.tun_id == htonll(0)));
+ && flow->tp_dst == htons(BFD_DEST_PORT)
+ && (!check_tnl_key || flow->tunnel.tun_id == htonll(0)));
}
void
/* This function is designed to follow section RFC 5880 6.8.6 closely. */
ovs_mutex_lock(&mutex);
+ /* Increments the decay rx counter. */
+ bfd->decay_rx_ctl++;
+
if (flow->nw_ttl != 255) {
/* XXX Should drop in the kernel to prevent DOS. */
goto out;
out:
ovs_mutex_unlock(&mutex);
}
+
+/* Must be called when the netdev owned by 'bfd' should change. */
+void
+bfd_set_netdev(struct bfd *bfd, const struct netdev *netdev)
+ OVS_EXCLUDED(mutex)
+{
+ ovs_mutex_lock(&mutex);
+ if (bfd->netdev != netdev) {
+ netdev_close(bfd->netdev);
+ bfd->netdev = netdev_ref(netdev);
+ if (bfd->decay_min_rx && bfd->state == STATE_UP) {
+ bfd_decay_update(bfd);
+ }
+ if (bfd->forwarding_if_rx && bfd->state == STATE_UP) {
+ bfd_forwarding_if_rx_update(bfd);
+ }
+ bfd->rx_packets = bfd_rx_packets(bfd);
+ }
+ ovs_mutex_unlock(&mutex);
+}
+
\f
static bool
-bfd_forwarding__(const struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+bfd_forwarding__(const struct bfd *bfd) OVS_REQUIRES(mutex)
{
+ long long int time;
+
if (bfd->forwarding_override != -1) {
return bfd->forwarding_override == 1;
}
- return bfd->state == STATE_UP
- && bfd->rmt_diag != DIAG_PATH_DOWN
- && bfd->rmt_diag != DIAG_CPATH_DOWN
- && bfd->rmt_diag != DIAG_RCPATH_DOWN;
+ time = bfd->forwarding_if_rx_detect_time;
+ return (bfd->state == STATE_UP
+ || (bfd->forwarding_if_rx && time > time_msec()))
+ && bfd->rmt_diag != DIAG_PATH_DOWN
+ && bfd->rmt_diag != DIAG_CPATH_DOWN
+ && bfd->rmt_diag != DIAG_RCPATH_DOWN;
}
/* Helpers. */
static bool
-bfd_in_poll(const struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+bfd_in_poll(const struct bfd *bfd) OVS_REQUIRES(mutex)
{
return (bfd->flags & FLAG_POLL) != 0;
}
static void
-bfd_poll(struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+bfd_poll(struct bfd *bfd) OVS_REQUIRES(mutex)
{
if (bfd->state > STATE_DOWN && !bfd_in_poll(bfd)
&& !(bfd->flags & FLAG_FINAL)) {
bfd->poll_min_tx = bfd->cfg_min_tx;
- bfd->poll_min_rx = bfd->cfg_min_rx;
+ bfd->poll_min_rx = bfd->in_decay ? bfd->decay_min_rx : bfd->cfg_min_rx;
bfd->flags |= FLAG_POLL;
bfd->next_tx = 0;
VLOG_INFO_RL(&rl, "%s: Initiating poll sequence", bfd->name);
}
static long long int
-bfd_min_tx(const struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+bfd_min_tx(const struct bfd *bfd) OVS_REQUIRES(mutex)
{
/* RFC 5880 Section 6.8.3
* When bfd.SessionState is not Up, the system MUST set
}
static long long int
-bfd_tx_interval(const struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+bfd_tx_interval(const struct bfd *bfd) OVS_REQUIRES(mutex)
{
long long int interval = bfd_min_tx(bfd);
return MAX(interval, bfd->rmt_min_rx);
}
static long long int
-bfd_rx_interval(const struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+bfd_rx_interval(const struct bfd *bfd) OVS_REQUIRES(mutex)
{
return MAX(bfd->min_rx, bfd->rmt_min_tx);
}
static void
-bfd_set_next_tx(struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+bfd_set_next_tx(struct bfd *bfd) OVS_REQUIRES(mutex)
{
long long int interval = bfd_tx_interval(bfd);
interval -= interval * random_range(26) / 100;
ds_put_cstr(&ds, "poll ");
}
+ /* Do not copy the trailing whitespace. */
+ ds_chomp(&ds, ' ');
ovs_strlcpy(flag_str, ds_cstr(&ds), sizeof flag_str);
ds_destroy(&ds);
return flag_str;
static void
log_msg(enum vlog_level level, const struct msg *p, const char *message,
- const struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+ const struct bfd *bfd) OVS_REQUIRES(mutex)
{
struct ds ds = DS_EMPTY_INITIALIZER;
static void
bfd_set_state(struct bfd *bfd, enum state state, enum diag diag)
- OVS_REQ_WRLOCK(mutex)
+ OVS_REQUIRES(mutex)
{
if (diag == DIAG_NONE && bfd->cpath_down) {
diag = DIAG_CPATH_DOWN;
bfd->rmt_flags = 0;
bfd->rmt_disc = 0;
bfd->rmt_min_tx = 0;
+ /* Resets the min_rx if in_decay. */
+ if (bfd->in_decay) {
+ bfd->min_rx = bfd->cfg_min_rx;
+ bfd->in_decay = false;
+ }
+ }
+ /* Resets the decay when state changes to STATE_UP
+ * and decay_min_rx is configured. */
+ if (bfd->state == STATE_UP && bfd->decay_min_rx) {
+ bfd_decay_update(bfd);
}
}
}
+static uint64_t
+bfd_rx_packets(const struct bfd *bfd) OVS_REQUIRES(mutex)
+{
+ struct netdev_stats stats;
+
+ if (!netdev_get_stats(bfd->netdev, &stats)) {
+ return stats.rx_packets;
+ } else {
+ return 0;
+ }
+}
+
+/* Decays the bfd->min_rx to bfd->decay_min_rx when 'diff' is less than
+ * the 'expect' value. */
+static void
+bfd_try_decay(struct bfd *bfd) OVS_REQUIRES(mutex)
+{
+ int64_t diff, expect;
+
+ /* The 'diff' is the difference between current interface rx_packets
+ * stats and last-time check. The 'expect' is the recorded number of
+ * bfd control packets received within an approximately decay_min_rx
+ * (2000 ms if decay_min_rx is less than 2000 ms) interval.
+ *
+ * Since the update of rx_packets stats at interface happens
+ * asynchronously to the bfd_rx_packets() function, the 'diff' value
+ * can be jittered. Thusly, we double the decay_rx_ctl to provide
+ * more wiggle room. */
+ diff = bfd_rx_packets(bfd) - bfd->decay_rx_packets;
+ expect = 2 * MAX(bfd->decay_rx_ctl, 1);
+ bfd->in_decay = diff <= expect ? true : false;
+ bfd_decay_update(bfd);
+}
+
+/* Updates the rx_packets, decay_rx_ctl and decay_detect_time. */
+static void
+bfd_decay_update(struct bfd * bfd) OVS_REQUIRES(mutex)
+{
+ bfd->decay_rx_packets = bfd_rx_packets(bfd);
+ bfd->decay_rx_ctl = 0;
+ bfd->decay_detect_time = MAX(bfd->decay_min_rx, 2000) + time_msec();
+}
+
+/* Checks if there are packets received during the time since last call.
+ * If forwarding_if_rx is enabled and packets are received, updates the
+ * forwarding_if_rx_detect_time. */
+static void
+bfd_check_rx(struct bfd *bfd) OVS_REQUIRES(mutex)
+{
+ uint64_t rx_packets = bfd_rx_packets(bfd);
+ int64_t diff;
+
+ diff = rx_packets - bfd->rx_packets;
+ bfd->rx_packets = rx_packets;
+ if (diff < 0) {
+ VLOG_INFO_RL(&rl, "rx_packets count is smaller than last time.");
+ }
+ if (bfd->forwarding_if_rx && diff > 0) {
+ bfd_forwarding_if_rx_update(bfd);
+ }
+}
+
+/* Updates the forwarding_if_rx_detect_time. */
+static void
+bfd_forwarding_if_rx_update(struct bfd *bfd) OVS_REQUIRES(mutex)
+{
+ int64_t incr = bfd_rx_interval(bfd) * bfd->mult;
+ bfd->forwarding_if_rx_detect_time = MAX(incr, 2000) + time_msec();
+}
+
static uint32_t
generate_discriminator(void)
{
}
static struct bfd *
-bfd_find_by_name(const char *name) OVS_REQ_WRLOCK(mutex)
+bfd_find_by_name(const char *name) OVS_REQUIRES(mutex)
{
struct bfd *bfd;
}
static void
-bfd_put_details(struct ds *ds, const struct bfd *bfd) OVS_REQ_WRLOCK(mutex)
+bfd_put_details(struct ds *ds, const struct bfd *bfd) OVS_REQUIRES(mutex)
{
ds_put_format(ds, "\tForwarding: %s\n",
bfd_forwarding__(bfd) ? "true" : "false");