#include "random.h"
#include "smap.h"
#include "timeval.h"
+#include "unaligned.h"
#include "unixctl.h"
#include "util.h"
#include "vlog.h"
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 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 *,
long long int min_tx, min_rx;
bool need_poll = false;
bool cfg_min_rx_changed = false;
- bool cpath_down;
+ bool cpath_down, forwarding_if_rx;
const char *hwaddr;
uint8_t ea[ETH_ADDR_LEN];
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
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);
}
void
bfd_wait(const struct bfd *bfd) OVS_EXCLUDED(mutex)
{
- ovs_mutex_lock(&mutex);
- if (bfd->flags & FLAG_FINAL) {
- poll_immediate_wake();
+ poll_timer_wait_until(bfd_wake_time(bfd));
+}
+
+/* Returns the next wake up time. */
+long long int
+bfd_wake_time(const struct bfd *bfd) OVS_EXCLUDED(mutex)
+{
+ long long int retval;
+
+ if (!bfd) {
+ return LLONG_MAX;
}
- poll_timer_wait_until(bfd->next_tx);
- if (bfd->state > STATE_DOWN) {
- poll_timer_wait_until(bfd->detect_time);
+ ovs_mutex_lock(&mutex);
+ if (bfd->flags & FLAG_FINAL) {
+ retval = 0;
+ } else {
+ retval = bfd->next_tx;
+ if (bfd->state > STATE_DOWN) {
+ retval = MIN(bfd->detect_time, retval);
+ }
}
ovs_mutex_unlock(&mutex);
+ return retval;
}
void
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) {
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);
msg = ofpbuf_at(p, (uint8_t *)p->l7 - (uint8_t *)p->data, BFD_PACKET_LEN);
if (!msg) {
- VLOG_INFO_RL(&rl, "%s: Received unparseable BFD control message.",
- bfd->name);
+ VLOG_INFO_RL(&rl, "%s: Received too-short BFD control message (only "
+ "%td bytes long, at least %d required).",
+ bfd->name, (uint8_t *) ofpbuf_tail(p) - (uint8_t *) p->l7,
+ BFD_PACKET_LEN);
goto out;
}
if (bfd->netdev != netdev) {
netdev_close(bfd->netdev);
bfd->netdev = netdev_ref(netdev);
- if (bfd->decay_min_rx) {
+ 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);
}
static bool
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. */
* 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->rx_packets;
+ 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);
static void
bfd_decay_update(struct bfd * bfd) OVS_REQUIRES(mutex)
{
- bfd->rx_packets = bfd_rx_packets(bfd);
+ 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)
{
git://git.onelab.eu / sliver-openvswitch.git / blobdiff