X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fbfd.c;h=115053beea84d418ffb81ad50c52214c53b214e7;hb=2431be1b68d386bd616378d2c528242775c4d54a;hp=7c7c0b740a604cf43005f0358e2c4385557f1af1;hpb=70e575d980df7b272c51853204bf403551f8b200;p=sliver-openvswitch.git diff --git a/lib/bfd.c b/lib/bfd.c index 7c7c0b740..115053bee 100644 --- a/lib/bfd.c +++ b/lib/bfd.c @@ -15,6 +15,7 @@ #include #include "bfd.h" +#include #include #include #include @@ -27,6 +28,7 @@ #include "hash.h" #include "hmap.h" #include "list.h" +#include "netdev.h" #include "netlink.h" #include "odp-util.h" #include "ofpbuf.h" @@ -37,6 +39,7 @@ #include "random.h" #include "smap.h" #include "timeval.h" +#include "unaligned.h" #include "unixctl.h" #include "util.h" #include "vlog.h" @@ -150,6 +153,9 @@ struct bfd { 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. */ @@ -185,6 +191,21 @@ struct bfd { 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; @@ -207,6 +228,11 @@ static void bfd_set_state(struct bfd *, enum state, enum diag) static uint32_t generate_discriminator(void) OVS_REQUIRES(mutex); static void bfd_put_details(struct ds *, const struct bfd *) 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 *, @@ -254,14 +280,17 @@ bfd_get_status(const struct bfd *bfd, struct smap *smap) * 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]; @@ -291,6 +320,9 @@ bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg) 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 @@ -315,7 +347,7 @@ bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg) || (!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); @@ -326,7 +358,23 @@ bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg) || (!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); @@ -335,7 +383,7 @@ bfd_configure(struct bfd *bfd, const char *name, const struct smap *cfg) if (bfd->diag == DIAG_NONE || bfd->diag == DIAG_CPATH_DOWN) { bfd_set_state(bfd, bfd->state, DIAG_NONE); } - bfd_poll(bfd); + need_poll = true; } hwaddr = smap_get(cfg, "bfd_dst_mac"); @@ -347,6 +395,19 @@ 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); + } ovs_mutex_unlock(&mutex); return bfd; } @@ -374,6 +435,7 @@ bfd_unref(struct bfd *bfd) OVS_EXCLUDED(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); @@ -384,27 +446,59 @@ 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 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); @@ -457,8 +551,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); @@ -497,10 +592,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; @@ -516,7 +613,7 @@ bfd_should_process_flow(const struct bfd *bfd, const struct flow *flow, return (flow->dl_type == htons(ETH_TYPE_IP) && flow->nw_proto == IPPROTO_UDP && flow->tp_dst == htons(BFD_DEST_PORT) - && (check_tnl_key || flow->tunnel.tun_id == htonll(0))); + && (!check_tnl_key || flow->tunnel.tun_id == htonll(0))); } void @@ -532,6 +629,9 @@ bfd_process_packet(struct bfd *bfd, const struct flow *flow, /* 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; @@ -681,18 +781,43 @@ bfd_process_packet(struct bfd *bfd, const struct flow *flow, 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); +} + 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. */ @@ -708,7 +833,7 @@ 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); @@ -881,10 +1006,90 @@ bfd_set_state(struct bfd *bfd, enum state state, enum diag diag) 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) {