X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fbfd.c;h=1df5acd05f78a8b28432b67fd09d5d16a5ccb6af;hb=6b4b2f598246e87237342a9179a0d29e202ebe65;hp=4f3c8ef9830db7e22f32f5b40dab5fafdd726243;hpb=c1c4e8c76912a597a6ad964f7b80fc9f63caa7f3;p=sliver-openvswitch.git diff --git a/lib/bfd.c b/lib/bfd.c index 4f3c8ef98..1df5acd05 100644 --- a/lib/bfd.c +++ b/lib/bfd.c @@ -39,6 +39,7 @@ #include "random.h" #include "smap.h" #include "timeval.h" +#include "unaligned.h" #include "unixctl.h" #include "util.h" #include "vlog.h" @@ -186,25 +187,35 @@ struct bfd { long long int next_tx; /* Next TX time. */ long long int detect_time; /* RFC 5880 6.8.4 Detection time. */ + bool last_forwarding; /* Last calculation of forwarding flag. */ int forwarding_override; /* Manual override of 'forwarding' status. */ 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. */ + + uint64_t flap_count; /* Counts bfd forwarding flaps. */ }; 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_REQUIRES(mutex); +static bool bfd_forwarding__(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); @@ -223,6 +234,8 @@ static void bfd_put_details(struct ds *, const struct bfd *) 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_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 *, @@ -236,7 +249,7 @@ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(20, 20); /* Returns true if the interface on which 'bfd' is running may be used to * forward traffic according to the BFD session state. */ bool -bfd_forwarding(const struct bfd *bfd) OVS_EXCLUDED(mutex) +bfd_forwarding(struct bfd *bfd) OVS_EXCLUDED(mutex) { bool ret; @@ -246,6 +259,20 @@ bfd_forwarding(const struct bfd *bfd) OVS_EXCLUDED(mutex) return ret; } +/* When forwarding_if_rx is enabled, if there are packets received, + * updates forwarding_if_rx_detect_time. */ +void +bfd_account_rx(struct bfd *bfd, const struct dpif_flow_stats *stats) +{ + if (stats->n_packets && bfd->forwarding_if_rx) { + ovs_mutex_lock(&mutex); + bfd_forwarding__(bfd); + bfd_forwarding_if_rx_update(bfd); + bfd_forwarding__(bfd); + ovs_mutex_unlock(&mutex); + } +} + /* Returns a 'smap' of key value pairs representing the status of 'bfd' * intended for the OVS database. */ void @@ -253,9 +280,12 @@ bfd_get_status(const struct bfd *bfd, struct smap *smap) OVS_EXCLUDED(mutex) { ovs_mutex_lock(&mutex); - smap_add(smap, "forwarding", bfd_forwarding__(bfd)? "true" : "false"); + smap_add(smap, "forwarding", + bfd_forwarding__(CONST_CAST(struct bfd *, bfd)) + ? "true" : "false"); smap_add(smap, "state", bfd_state_str(bfd->state)); smap_add(smap, "diagnostic", bfd_diag_str(bfd->diag)); + smap_add_format(smap, "flap_count", "%"PRIu64, bfd->flap_count); if (bfd->state != STATE_DOWN) { smap_add(smap, "remote_state", bfd_state_str(bfd->rmt_state)); @@ -280,7 +310,7 @@ bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg, 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]; @@ -311,7 +341,9 @@ bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg, 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; + bfd->flap_count = 0; /* RFC 5881 section 4 * The source port MUST be in the range 49152 through 65535. The same @@ -384,6 +416,16 @@ bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg, 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); } @@ -425,16 +467,30 @@ bfd_unref(struct bfd *bfd) OVS_EXCLUDED(mutex) 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 @@ -449,6 +505,7 @@ bfd_run(struct bfd *bfd) OVS_EXCLUDED(mutex) if (bfd->state > STATE_DOWN && now >= bfd->detect_time) { bfd_set_state(bfd, STATE_DOWN, DIAG_EXPIRED); + bfd_forwarding__(bfd); } /* Decay may only happen when state is STATE_UP, bfd->decay_min_rx is @@ -513,8 +570,9 @@ bfd_put_packet(struct bfd *bfd, struct ofpbuf *p, 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); @@ -553,10 +611,12 @@ bfd_put_packet(struct bfd *bfd, struct ofpbuf *p, } 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; @@ -591,6 +651,8 @@ bfd_process_packet(struct bfd *bfd, const struct flow *flow, /* Increments the decay rx counter. */ bfd->decay_rx_ctl++; + bfd_forwarding__(bfd); + if (flow->nw_ttl != 255) { /* XXX Should drop in the kernel to prevent DOS. */ goto out; @@ -598,8 +660,10 @@ bfd_process_packet(struct bfd *bfd, const struct flow *flow, 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 " + "%"PRIdPTR" bytes long, at least %d required).", + bfd->name, (uint8_t *) ofpbuf_tail(p) - (uint8_t *) p->l7, + BFD_PACKET_LEN); goto out; } @@ -738,6 +802,7 @@ bfd_process_packet(struct bfd *bfd, const struct flow *flow, /* XXX: RFC 5880 Section 6.8.6 Demand mode related calculations here. */ out: + bfd_forwarding__(bfd); ovs_mutex_unlock(&mutex); } @@ -750,25 +815,44 @@ bfd_set_netdev(struct bfd *bfd, const struct netdev *netdev) 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); } +/* Updates the forwarding flag. If override is not configured and + * the forwarding flag value changes, increments the flap count. + * + * Note this function may be called multiple times in a function + * (e.g. bfd_account_rx) before and after the bfd state or status + * change. This is to capture any forwarding flag flap. */ static bool -bfd_forwarding__(const struct bfd *bfd) OVS_REQUIRES(mutex) +bfd_forwarding__(struct bfd *bfd) OVS_REQUIRES(mutex) { + long long int time; + bool last_forwarding = bfd->last_forwarding; + 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; + bfd->last_forwarding = (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; + if (bfd->last_forwarding != last_forwarding) { + bfd->flap_count++; + } + return bfd->last_forwarding; } /* Helpers. */ @@ -999,7 +1083,7 @@ bfd_try_decay(struct bfd *bfd) OVS_REQUIRES(mutex) * 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); @@ -1009,11 +1093,18 @@ bfd_try_decay(struct bfd *bfd) OVS_REQUIRES(mutex) 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(); } +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) { @@ -1058,7 +1149,8 @@ static void 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"); + bfd_forwarding__(CONST_CAST(struct bfd *, bfd)) + ? "true" : "false"); ds_put_format(ds, "\tDetect Multiplier: %d\n", bfd->mult); ds_put_format(ds, "\tConcatenated Path Down: %s\n", bfd->cpath_down ? "true" : "false");