2 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
27 #include "dynamic-string.h"
36 #include "poll-loop.h"
42 VLOG_DEFINE_THIS_MODULE(bond);
44 /* Bit-mask for hashing a flow down to a bucket.
45 * There are (BOND_MASK + 1) buckets. */
46 #define BOND_MASK 0xff
48 /* A hash bucket for mapping a flow to a slave.
49 * "struct bond" has an array of (BOND_MASK + 1) of these. */
51 struct bond_slave *slave; /* Assigned slave, NULL if unassigned. */
52 uint64_t tx_bytes; /* Count of bytes recently transmitted. */
53 struct list list_node; /* In bond_slave's 'entries' list. */
56 /* A bond slave, that is, one of the links comprising a bond. */
58 struct hmap_node hmap_node; /* In struct bond's slaves hmap. */
59 struct bond *bond; /* The bond that contains this slave. */
60 void *aux; /* Client-provided handle for this slave. */
62 struct netdev *netdev; /* Network device, owned by the client. */
63 unsigned int change_seq; /* Tracks changes in 'netdev'. */
64 char *name; /* Name (a copy of netdev_get_name(netdev)). */
67 long long delay_expires; /* Time after which 'enabled' may change. */
68 bool enabled; /* May be chosen for flows? */
69 bool may_enable; /* Client considers this slave bondable. */
71 /* Rebalancing info. Used only by bond_rebalance(). */
72 struct list bal_node; /* In bond_rebalance()'s 'bals' list. */
73 struct list entries; /* 'struct bond_entry's assigned here. */
74 uint64_t tx_bytes; /* Sum across 'tx_bytes' of entries. */
77 /* A bond, that is, a set of network devices grouped to improve performance or
80 struct hmap_node hmap_node; /* In 'all_bonds' hmap. */
81 char *name; /* Name provided by client. */
87 enum bond_mode balance; /* Balancing mode, one of BM_*. */
88 struct bond_slave *active_slave;
89 int updelay, downdelay; /* Delay before slave goes up/down, in ms. */
90 enum lacp_status lacp_status; /* Status of LACP negotiations. */
91 bool bond_revalidate; /* True if flows need revalidation. */
92 uint32_t basis; /* Basis for flow hash function. */
94 /* SLB specific bonding info. */
95 struct bond_entry *hash; /* An array of (BOND_MASK + 1) elements. */
96 int rebalance_interval; /* Interval between rebalances, in ms. */
97 long long int next_rebalance; /* Next rebalancing time. */
98 bool send_learning_packets;
100 /* Legacy compatibility. */
101 long long int next_fake_iface_update; /* LLONG_MAX if disabled. */
106 static struct ovs_rwlock rwlock = OVS_RWLOCK_INITIALIZER;
107 static struct hmap all_bonds__ = HMAP_INITIALIZER(&all_bonds__);
108 static struct hmap *const all_bonds OVS_GUARDED_BY(rwlock) = &all_bonds__;
110 static void bond_entry_reset(struct bond *) OVS_REQ_WRLOCK(rwlock);
111 static struct bond_slave *bond_slave_lookup(struct bond *, const void *slave_)
112 OVS_REQ_RDLOCK(rwlock);
113 static void bond_enable_slave(struct bond_slave *, bool enable)
114 OVS_REQ_WRLOCK(rwlock);
115 static void bond_link_status_update(struct bond_slave *)
116 OVS_REQ_WRLOCK(rwlock);
117 static void bond_choose_active_slave(struct bond *)
118 OVS_REQ_WRLOCK(rwlock);;
119 static unsigned int bond_hash_src(const uint8_t mac[ETH_ADDR_LEN],
120 uint16_t vlan, uint32_t basis);
121 static unsigned int bond_hash_tcp(const struct flow *, uint16_t vlan,
123 static struct bond_entry *lookup_bond_entry(const struct bond *,
126 OVS_REQ_RDLOCK(rwlock);
127 static struct bond_slave *choose_output_slave(const struct bond *,
129 struct flow_wildcards *,
131 OVS_REQ_RDLOCK(rwlock);
132 static void bond_update_fake_slave_stats(struct bond *)
133 OVS_REQ_RDLOCK(rwlock);
135 /* Attempts to parse 's' as the name of a bond balancing mode. If successful,
136 * stores the mode in '*balance' and returns true. Otherwise returns false
137 * without modifying '*balance'. */
139 bond_mode_from_string(enum bond_mode *balance, const char *s)
141 if (!strcmp(s, bond_mode_to_string(BM_TCP))) {
143 } else if (!strcmp(s, bond_mode_to_string(BM_SLB))) {
145 } else if (!strcmp(s, bond_mode_to_string(BM_AB))) {
153 /* Returns a string representing 'balance'. */
155 bond_mode_to_string(enum bond_mode balance) {
158 return "balance-tcp";
160 return "balance-slb";
162 return "active-backup";
168 /* Creates and returns a new bond whose configuration is initially taken from
171 * The caller should register each slave on the new bond by calling
172 * bond_slave_register(). */
174 bond_create(const struct bond_settings *s)
178 bond = xzalloc(sizeof *bond);
179 hmap_init(&bond->slaves);
180 bond->next_fake_iface_update = LLONG_MAX;
181 atomic_init(&bond->ref_cnt, 1);
183 bond_reconfigure(bond, s);
188 bond_ref(const struct bond *bond_)
190 struct bond *bond = CONST_CAST(struct bond *, bond_);
194 atomic_add(&bond->ref_cnt, 1, &orig);
195 ovs_assert(orig > 0);
202 bond_unref(struct bond *bond)
204 struct bond_slave *slave, *next_slave;
211 atomic_sub(&bond->ref_cnt, 1, &orig);
212 ovs_assert(orig > 0);
217 ovs_rwlock_wrlock(&rwlock);
218 hmap_remove(all_bonds, &bond->hmap_node);
219 ovs_rwlock_unlock(&rwlock);
221 HMAP_FOR_EACH_SAFE (slave, next_slave, hmap_node, &bond->slaves) {
222 hmap_remove(&bond->slaves, &slave->hmap_node);
223 /* Client owns 'slave->netdev'. */
227 hmap_destroy(&bond->slaves);
234 /* Updates 'bond''s overall configuration to 's'.
236 * The caller should register each slave on 'bond' by calling
237 * bond_slave_register(). This is optional if none of the slaves'
238 * configuration has changed. In any case it can't hurt.
240 * Returns true if the configuration has changed in such a way that requires
244 bond_reconfigure(struct bond *bond, const struct bond_settings *s)
246 bool revalidate = false;
248 ovs_rwlock_wrlock(&rwlock);
249 if (!bond->name || strcmp(bond->name, s->name)) {
251 hmap_remove(all_bonds, &bond->hmap_node);
254 bond->name = xstrdup(s->name);
255 hmap_insert(all_bonds, &bond->hmap_node, hash_string(bond->name, 0));
258 bond->updelay = s->up_delay;
259 bond->downdelay = s->down_delay;
261 if (bond->rebalance_interval != s->rebalance_interval) {
262 bond->rebalance_interval = s->rebalance_interval;
266 if (bond->balance != s->balance) {
267 bond->balance = s->balance;
271 if (bond->basis != s->basis) {
272 bond->basis = s->basis;
277 if (bond->next_fake_iface_update == LLONG_MAX) {
278 bond->next_fake_iface_update = time_msec();
281 bond->next_fake_iface_update = LLONG_MAX;
284 if (bond->bond_revalidate) {
286 bond->bond_revalidate = false;
289 if (bond->balance == BM_AB || !bond->hash || revalidate) {
290 bond_entry_reset(bond);
293 ovs_rwlock_unlock(&rwlock);
298 bond_slave_set_netdev__(struct bond_slave *slave, struct netdev *netdev)
299 OVS_REQ_WRLOCK(rwlock)
301 if (slave->netdev != netdev) {
302 slave->netdev = netdev;
303 slave->change_seq = 0;
307 /* Registers 'slave_' as a slave of 'bond'. The 'slave_' pointer is an
308 * arbitrary client-provided pointer that uniquely identifies a slave within a
309 * bond. If 'slave_' already exists within 'bond' then this function
310 * reconfigures the existing slave.
312 * 'netdev' must be the network device that 'slave_' represents. It is owned
313 * by the client, so the client must not close it before either unregistering
314 * 'slave_' or destroying 'bond'.
317 bond_slave_register(struct bond *bond, void *slave_, struct netdev *netdev)
319 struct bond_slave *slave;
321 ovs_rwlock_wrlock(&rwlock);
322 slave = bond_slave_lookup(bond, slave_);
324 slave = xzalloc(sizeof *slave);
326 hmap_insert(&bond->slaves, &slave->hmap_node, hash_pointer(slave_, 0));
329 slave->delay_expires = LLONG_MAX;
330 slave->name = xstrdup(netdev_get_name(netdev));
331 bond->bond_revalidate = true;
333 slave->enabled = false;
334 bond_enable_slave(slave, netdev_get_carrier(netdev));
337 bond_slave_set_netdev__(slave, netdev);
340 slave->name = xstrdup(netdev_get_name(netdev));
341 ovs_rwlock_unlock(&rwlock);
344 /* Updates the network device to be used with 'slave_' to 'netdev'.
346 * This is useful if the caller closes and re-opens the network device
347 * registered with bond_slave_register() but doesn't need to change anything
350 bond_slave_set_netdev(struct bond *bond, void *slave_, struct netdev *netdev)
352 struct bond_slave *slave;
354 ovs_rwlock_wrlock(&rwlock);
355 slave = bond_slave_lookup(bond, slave_);
357 bond_slave_set_netdev__(slave, netdev);
359 ovs_rwlock_unlock(&rwlock);
362 /* Unregisters 'slave_' from 'bond'. If 'bond' does not contain such a slave
363 * then this function has no effect.
365 * Unregistering a slave invalidates all flows. */
367 bond_slave_unregister(struct bond *bond, const void *slave_)
369 struct bond_slave *slave;
372 ovs_rwlock_wrlock(&rwlock);
373 slave = bond_slave_lookup(bond, slave_);
378 bond->bond_revalidate = true;
379 bond_enable_slave(slave, false);
381 del_active = bond->active_slave == slave;
383 struct bond_entry *e;
384 for (e = bond->hash; e <= &bond->hash[BOND_MASK]; e++) {
385 if (e->slave == slave) {
393 hmap_remove(&bond->slaves, &slave->hmap_node);
394 /* Client owns 'slave->netdev'. */
398 bond_choose_active_slave(bond);
399 bond->send_learning_packets = true;
402 ovs_rwlock_unlock(&rwlock);
405 /* Should be called on each slave in 'bond' before bond_run() to indicate
406 * whether or not 'slave_' may be enabled. This function is intended to allow
407 * other protocols to have some impact on bonding decisions. For example LACP
408 * or high level link monitoring protocols may decide that a given slave should
409 * not be able to send traffic. */
411 bond_slave_set_may_enable(struct bond *bond, void *slave_, bool may_enable)
413 ovs_rwlock_wrlock(&rwlock);
414 bond_slave_lookup(bond, slave_)->may_enable = may_enable;
415 ovs_rwlock_unlock(&rwlock);
418 /* Performs periodic maintenance on 'bond'.
420 * Returns true if the caller should revalidate its flows.
422 * The caller should check bond_should_send_learning_packets() afterward. */
424 bond_run(struct bond *bond, enum lacp_status lacp_status)
426 struct bond_slave *slave;
429 ovs_rwlock_wrlock(&rwlock);
430 if (bond->lacp_status != lacp_status) {
431 bond->lacp_status = lacp_status;
432 bond->bond_revalidate = true;
435 /* Enable slaves based on link status and LACP feedback. */
436 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
437 bond_link_status_update(slave);
438 slave->change_seq = netdev_change_seq(slave->netdev);
440 if (!bond->active_slave || !bond->active_slave->enabled) {
441 bond_choose_active_slave(bond);
444 /* Update fake bond interface stats. */
445 if (time_msec() >= bond->next_fake_iface_update) {
446 bond_update_fake_slave_stats(bond);
447 bond->next_fake_iface_update = time_msec() + 1000;
450 revalidate = bond->bond_revalidate;
451 bond->bond_revalidate = false;
452 ovs_rwlock_unlock(&rwlock);
457 /* Causes poll_block() to wake up when 'bond' needs something to be done. */
459 bond_wait(struct bond *bond)
461 struct bond_slave *slave;
463 ovs_rwlock_rdlock(&rwlock);
464 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
465 if (slave->delay_expires != LLONG_MAX) {
466 poll_timer_wait_until(slave->delay_expires);
469 if (slave->change_seq != netdev_change_seq(slave->netdev)) {
470 poll_immediate_wake();
474 if (bond->next_fake_iface_update != LLONG_MAX) {
475 poll_timer_wait_until(bond->next_fake_iface_update);
478 if (bond->bond_revalidate) {
479 poll_immediate_wake();
481 ovs_rwlock_unlock(&rwlock);
483 /* We don't wait for bond->next_rebalance because rebalancing can only run
484 * at a flow account checkpoint. ofproto does checkpointing on its own
485 * schedule and bond_rebalance() gets called afterward, so we'd just be
486 * waking up for no purpose. */
489 /* MAC learning table interaction. */
492 may_send_learning_packets(const struct bond *bond)
494 return bond->lacp_status == LACP_DISABLED
495 && (bond->balance == BM_SLB || bond->balance == BM_AB)
496 && bond->active_slave;
499 /* Returns true if 'bond' needs the client to send out packets to assist with
500 * MAC learning on 'bond'. If this function returns true, then the client
501 * should iterate through its MAC learning table for the bridge on which 'bond'
502 * is located. For each MAC that has been learned on a port other than 'bond',
503 * it should call bond_compose_learning_packet().
505 * This function will only return true if 'bond' is in SLB or active-backup
506 * mode and LACP is not negotiated. Otherwise sending learning packets isn't
509 * Calling this function resets the state that it checks. */
511 bond_should_send_learning_packets(struct bond *bond)
515 ovs_rwlock_wrlock(&rwlock);
516 send = bond->send_learning_packets && may_send_learning_packets(bond);
517 bond->send_learning_packets = false;
518 ovs_rwlock_unlock(&rwlock);
522 /* Sends a gratuitous learning packet on 'bond' from 'eth_src' on 'vlan'.
524 * See bond_should_send_learning_packets() for description of usage. The
525 * caller should send the composed packet on the port associated with
526 * port_aux and takes ownership of the returned ofpbuf. */
528 bond_compose_learning_packet(struct bond *bond,
529 const uint8_t eth_src[ETH_ADDR_LEN],
530 uint16_t vlan, void **port_aux)
532 struct bond_slave *slave;
533 struct ofpbuf *packet;
536 ovs_rwlock_rdlock(&rwlock);
537 ovs_assert(may_send_learning_packets(bond));
538 memset(&flow, 0, sizeof flow);
539 memcpy(flow.dl_src, eth_src, ETH_ADDR_LEN);
540 slave = choose_output_slave(bond, &flow, NULL, vlan);
542 packet = ofpbuf_new(0);
543 compose_rarp(packet, eth_src);
545 eth_push_vlan(packet, htons(vlan));
548 *port_aux = slave->aux;
549 ovs_rwlock_unlock(&rwlock);
553 /* Checks whether a packet that arrived on 'slave_' within 'bond', with an
554 * Ethernet destination address of 'eth_dst', should be admitted.
556 * The return value is one of the following:
558 * - BV_ACCEPT: Admit the packet.
560 * - BV_DROP: Drop the packet.
562 * - BV_DROP_IF_MOVED: Consult the MAC learning table for the packet's
563 * Ethernet source address and VLAN. If there is none, or if the packet
564 * is on the learned port, then admit the packet. If a different port has
565 * been learned, however, drop the packet (and do not use it for MAC
569 bond_check_admissibility(struct bond *bond, const void *slave_,
570 const uint8_t eth_dst[ETH_ADDR_LEN])
572 enum bond_verdict verdict = BV_DROP;
573 struct bond_slave *slave;
575 ovs_rwlock_rdlock(&rwlock);
576 slave = bond_slave_lookup(bond, slave_);
581 /* LACP bonds have very loose admissibility restrictions because we can
582 * assume the remote switch is aware of the bond and will "do the right
583 * thing". However, as a precaution we drop packets on disabled slaves
584 * because no correctly implemented partner switch should be sending
587 * If LACP is configured, but LACP negotiations have been unsuccessful, we
588 * drop all incoming traffic. */
589 switch (bond->lacp_status) {
590 case LACP_NEGOTIATED:
591 verdict = slave->enabled ? BV_ACCEPT : BV_DROP;
593 case LACP_CONFIGURED:
599 /* Drop all multicast packets on inactive slaves. */
600 if (eth_addr_is_multicast(eth_dst)) {
601 if (bond->active_slave != slave) {
606 switch (bond->balance) {
608 /* Drop all packets which arrive on backup slaves. This is similar to
609 * how Linux bonding handles active-backup bonds. */
610 if (bond->active_slave != slave) {
611 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
613 VLOG_DBG_RL(&rl, "active-backup bond received packet on backup"
614 " slave (%s) destined for " ETH_ADDR_FMT,
615 slave->name, ETH_ADDR_ARGS(eth_dst));
622 /* TCP balanced bonds require successful LACP negotiated. Based on the
623 * above check, LACP is off on this bond. Therfore, we drop all
624 * incoming traffic. */
628 /* Drop all packets for which we have learned a different input port,
629 * because we probably sent the packet on one slave and got it back on
630 * the other. Gratuitous ARP packets are an exception to this rule:
631 * the host has moved to another switch. The exception to the
632 * exception is if we locked the learning table to avoid reflections on
634 verdict = BV_DROP_IF_MOVED;
640 ovs_rwlock_unlock(&rwlock);
645 /* Returns the slave (registered on 'bond' by bond_slave_register()) to which
646 * a packet with the given 'flow' and 'vlan' should be forwarded. Returns
647 * NULL if the packet should be dropped because no slaves are enabled.
649 * 'vlan' is not necessarily the same as 'flow->vlan_tci'. First, 'vlan'
650 * should be a VID only (i.e. excluding the PCP bits). Second,
651 * 'flow->vlan_tci' is the VLAN TCI that appeared on the packet (so it will be
652 * nonzero only for trunk ports), whereas 'vlan' is the logical VLAN that the
653 * packet belongs to (so for an access port it will be the access port's VLAN).
655 * If 'wc' is non-NULL, bitwise-OR's 'wc' with the set of bits that were
656 * significant in the selection. At some point earlier, 'wc' should
657 * have been initialized (e.g., by flow_wildcards_init_catchall()).
660 bond_choose_output_slave(struct bond *bond, const struct flow *flow,
661 struct flow_wildcards *wc, uint16_t vlan)
663 struct bond_slave *slave;
666 ovs_rwlock_rdlock(&rwlock);
667 slave = choose_output_slave(bond, flow, wc, vlan);
668 aux = slave ? slave->aux : NULL;
669 ovs_rwlock_unlock(&rwlock);
677 bond_is_balanced(const struct bond *bond) OVS_REQ_RDLOCK(rwlock)
679 return bond->rebalance_interval
680 && (bond->balance == BM_SLB || bond->balance == BM_TCP);
683 /* Notifies 'bond' that 'n_bytes' bytes were sent in 'flow' within 'vlan'. */
685 bond_account(struct bond *bond, const struct flow *flow, uint16_t vlan,
688 ovs_rwlock_wrlock(&rwlock);
689 if (bond_is_balanced(bond)) {
690 lookup_bond_entry(bond, flow, vlan)->tx_bytes += n_bytes;
692 ovs_rwlock_unlock(&rwlock);
695 static struct bond_slave *
696 bond_slave_from_bal_node(struct list *bal) OVS_REQ_RDLOCK(rwlock)
698 return CONTAINER_OF(bal, struct bond_slave, bal_node);
702 log_bals(struct bond *bond, const struct list *bals)
704 if (VLOG_IS_DBG_ENABLED()) {
705 struct ds ds = DS_EMPTY_INITIALIZER;
706 const struct bond_slave *slave;
708 LIST_FOR_EACH (slave, bal_node, bals) {
710 ds_put_char(&ds, ',');
712 ds_put_format(&ds, " %s %"PRIu64"kB",
713 slave->name, slave->tx_bytes / 1024);
715 if (!slave->enabled) {
716 ds_put_cstr(&ds, " (disabled)");
718 if (!list_is_empty(&slave->entries)) {
719 struct bond_entry *e;
721 ds_put_cstr(&ds, " (");
722 LIST_FOR_EACH (e, list_node, &slave->entries) {
723 if (&e->list_node != list_front(&slave->entries)) {
724 ds_put_cstr(&ds, " + ");
726 ds_put_format(&ds, "h%td: %"PRIu64"kB",
727 e - bond->hash, e->tx_bytes / 1024);
729 ds_put_cstr(&ds, ")");
732 VLOG_DBG("bond %s:%s", bond->name, ds_cstr(&ds));
737 /* Shifts 'hash' from its current slave to 'to'. */
739 bond_shift_load(struct bond_entry *hash, struct bond_slave *to)
741 struct bond_slave *from = hash->slave;
742 struct bond *bond = from->bond;
743 uint64_t delta = hash->tx_bytes;
745 VLOG_INFO("bond %s: shift %"PRIu64"kB of load (with hash %td) "
746 "from %s to %s (now carrying %"PRIu64"kB and "
747 "%"PRIu64"kB load, respectively)",
748 bond->name, delta / 1024, hash - bond->hash,
749 from->name, to->name,
750 (from->tx_bytes - delta) / 1024,
751 (to->tx_bytes + delta) / 1024);
753 /* Shift load away from 'from' to 'to'. */
754 from->tx_bytes -= delta;
755 to->tx_bytes += delta;
757 /* Arrange for flows to be revalidated. */
758 bond->bond_revalidate = true;
761 /* Picks and returns a bond_entry to migrate from 'from' (the most heavily
762 * loaded bond slave) to a bond slave that has 'to_tx_bytes' bytes of load,
763 * given that doing so must decrease the ratio of the load on the two slaves by
764 * at least 0.1. Returns NULL if there is no appropriate entry.
766 * The list of entries isn't sorted. I don't know of a reason to prefer to
767 * shift away small hashes or large hashes. */
768 static struct bond_entry *
769 choose_entry_to_migrate(const struct bond_slave *from, uint64_t to_tx_bytes)
771 struct bond_entry *e;
773 if (list_is_short(&from->entries)) {
774 /* 'from' carries no more than one MAC hash, so shifting load away from
775 * it would be pointless. */
779 LIST_FOR_EACH (e, list_node, &from->entries) {
780 double old_ratio, new_ratio;
783 if (to_tx_bytes == 0) {
784 /* Nothing on the new slave, move it. */
789 old_ratio = (double)from->tx_bytes / to_tx_bytes;
790 new_ratio = (double)(from->tx_bytes - delta) / (to_tx_bytes + delta);
791 if (old_ratio - new_ratio > 0.1
792 && fabs(new_ratio - 1.0) < fabs(old_ratio - 1.0)) {
793 /* We're aiming for an ideal ratio of 1, meaning both the 'from'
794 and 'to' slave have the same load. Therefore, we only move an
795 entry if it decreases the load on 'from', and brings us closer
796 to equal traffic load. */
804 /* Inserts 'slave' into 'bals' so that descending order of 'tx_bytes' is
807 insert_bal(struct list *bals, struct bond_slave *slave)
809 struct bond_slave *pos;
811 LIST_FOR_EACH (pos, bal_node, bals) {
812 if (slave->tx_bytes > pos->tx_bytes) {
816 list_insert(&pos->bal_node, &slave->bal_node);
819 /* Removes 'slave' from its current list and then inserts it into 'bals' so
820 * that descending order of 'tx_bytes' is maintained. */
822 reinsert_bal(struct list *bals, struct bond_slave *slave)
824 list_remove(&slave->bal_node);
825 insert_bal(bals, slave);
828 /* If 'bond' needs rebalancing, does so.
830 * The caller should have called bond_account() for each active flow, to ensure
831 * that flow data is consistently accounted at this point. */
833 bond_rebalance(struct bond *bond)
835 struct bond_slave *slave;
836 struct bond_entry *e;
839 ovs_rwlock_wrlock(&rwlock);
840 if (!bond_is_balanced(bond) || time_msec() < bond->next_rebalance) {
841 ovs_rwlock_unlock(&rwlock);
844 bond->next_rebalance = time_msec() + bond->rebalance_interval;
846 /* Add each bond_entry to its slave's 'entries' list.
847 * Compute each slave's tx_bytes as the sum of its entries' tx_bytes. */
848 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
850 list_init(&slave->entries);
852 for (e = &bond->hash[0]; e <= &bond->hash[BOND_MASK]; e++) {
853 if (e->slave && e->tx_bytes) {
854 e->slave->tx_bytes += e->tx_bytes;
855 list_push_back(&e->slave->entries, &e->list_node);
859 /* Add enabled slaves to 'bals' in descending order of tx_bytes.
861 * XXX This is O(n**2) in the number of slaves but it could be O(n lg n)
862 * with a proper list sort algorithm. */
864 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
865 if (slave->enabled) {
866 insert_bal(&bals, slave);
869 log_bals(bond, &bals);
871 /* Shift load from the most-loaded slaves to the least-loaded slaves. */
872 while (!list_is_short(&bals)) {
873 struct bond_slave *from = bond_slave_from_bal_node(list_front(&bals));
874 struct bond_slave *to = bond_slave_from_bal_node(list_back(&bals));
877 overload = from->tx_bytes - to->tx_bytes;
878 if (overload < to->tx_bytes >> 5 || overload < 100000) {
879 /* The extra load on 'from' (and all less-loaded slaves), compared
880 * to that of 'to' (the least-loaded slave), is less than ~3%, or
881 * it is less than ~1Mbps. No point in rebalancing. */
885 /* 'from' is carrying significantly more load than 'to'. Pick a hash
886 * to move from 'from' to 'to'. */
887 e = choose_entry_to_migrate(from, to->tx_bytes);
889 bond_shift_load(e, to);
891 /* Delete element from from->entries.
893 * We don't add the element to to->hashes. That would only allow
894 * 'e' to be migrated to another slave in this rebalancing run, and
895 * there is no point in doing that. */
896 list_remove(&e->list_node);
898 /* Re-sort 'bals'. */
899 reinsert_bal(&bals, from);
900 reinsert_bal(&bals, to);
902 /* Can't usefully migrate anything away from 'from'.
903 * Don't reconsider it. */
904 list_remove(&from->bal_node);
908 /* Implement exponentially weighted moving average. A weight of 1/2 causes
909 * historical data to decay to <1% in 7 rebalancing runs. 1,000,000 bytes
910 * take 20 rebalancing runs to decay to 0 and get deleted entirely. */
911 for (e = &bond->hash[0]; e <= &bond->hash[BOND_MASK]; e++) {
917 ovs_rwlock_unlock(&rwlock);
920 /* Bonding unixctl user interface functions. */
923 bond_find(const char *name) OVS_REQ_RDLOCK(rwlock)
927 HMAP_FOR_EACH_WITH_HASH (bond, hmap_node, hash_string(name, 0),
929 if (!strcmp(bond->name, name)) {
936 static struct bond_slave *
937 bond_lookup_slave(struct bond *bond, const char *slave_name)
939 struct bond_slave *slave;
941 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
942 if (!strcmp(slave->name, slave_name)) {
950 bond_unixctl_list(struct unixctl_conn *conn,
951 int argc OVS_UNUSED, const char *argv[] OVS_UNUSED,
952 void *aux OVS_UNUSED)
954 struct ds ds = DS_EMPTY_INITIALIZER;
955 const struct bond *bond;
957 ds_put_cstr(&ds, "bond\ttype\tslaves\n");
959 ovs_rwlock_rdlock(&rwlock);
960 HMAP_FOR_EACH (bond, hmap_node, all_bonds) {
961 const struct bond_slave *slave;
964 ds_put_format(&ds, "%s\t%s\t",
965 bond->name, bond_mode_to_string(bond->balance));
968 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
970 ds_put_cstr(&ds, ", ");
972 ds_put_cstr(&ds, slave->name);
974 ds_put_char(&ds, '\n');
976 ovs_rwlock_unlock(&rwlock);
977 unixctl_command_reply(conn, ds_cstr(&ds));
982 bond_print_details(struct ds *ds, const struct bond *bond)
983 OVS_REQ_RDLOCK(rwlock)
985 struct shash slave_shash = SHASH_INITIALIZER(&slave_shash);
986 const struct shash_node **sorted_slaves = NULL;
987 const struct bond_slave *slave;
990 ds_put_format(ds, "---- %s ----\n", bond->name);
991 ds_put_format(ds, "bond_mode: %s\n",
992 bond_mode_to_string(bond->balance));
994 ds_put_format(ds, "bond-hash-basis: %"PRIu32"\n", bond->basis);
996 ds_put_format(ds, "updelay: %d ms\n", bond->updelay);
997 ds_put_format(ds, "downdelay: %d ms\n", bond->downdelay);
999 if (bond_is_balanced(bond)) {
1000 ds_put_format(ds, "next rebalance: %lld ms\n",
1001 bond->next_rebalance - time_msec());
1004 ds_put_cstr(ds, "lacp_status: ");
1005 switch (bond->lacp_status) {
1006 case LACP_NEGOTIATED:
1007 ds_put_cstr(ds, "negotiated\n");
1009 case LACP_CONFIGURED:
1010 ds_put_cstr(ds, "configured\n");
1013 ds_put_cstr(ds, "off\n");
1016 ds_put_cstr(ds, "<unknown>\n");
1020 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
1021 shash_add(&slave_shash, slave->name, slave);
1023 sorted_slaves = shash_sort(&slave_shash);
1025 for (i = 0; i < shash_count(&slave_shash); i++) {
1026 struct bond_entry *be;
1028 slave = sorted_slaves[i]->data;
1031 ds_put_format(ds, "\nslave %s: %s\n",
1032 slave->name, slave->enabled ? "enabled" : "disabled");
1033 if (slave == bond->active_slave) {
1034 ds_put_cstr(ds, "\tactive slave\n");
1036 if (slave->delay_expires != LLONG_MAX) {
1037 ds_put_format(ds, "\t%s expires in %lld ms\n",
1038 slave->enabled ? "downdelay" : "updelay",
1039 slave->delay_expires - time_msec());
1042 ds_put_format(ds, "\tmay_enable: %s\n",
1043 slave->may_enable ? "true" : "false");
1045 if (!bond_is_balanced(bond)) {
1050 for (be = bond->hash; be <= &bond->hash[BOND_MASK]; be++) {
1051 int hash = be - bond->hash;
1053 if (be->slave != slave) {
1057 ds_put_format(ds, "\thash %d: %"PRIu64" kB load\n",
1058 hash, be->tx_bytes / 1024);
1060 /* XXX How can we list the MACs assigned to hashes of SLB bonds? */
1063 shash_destroy(&slave_shash);
1064 free(sorted_slaves);
1065 ds_put_cstr(ds, "\n");
1069 bond_unixctl_show(struct unixctl_conn *conn,
1070 int argc, const char *argv[],
1071 void *aux OVS_UNUSED)
1073 struct ds ds = DS_EMPTY_INITIALIZER;
1075 ovs_rwlock_rdlock(&rwlock);
1077 const struct bond *bond = bond_find(argv[1]);
1080 unixctl_command_reply_error(conn, "no such bond");
1083 bond_print_details(&ds, bond);
1085 const struct bond *bond;
1087 HMAP_FOR_EACH (bond, hmap_node, all_bonds) {
1088 bond_print_details(&ds, bond);
1092 unixctl_command_reply(conn, ds_cstr(&ds));
1096 ovs_rwlock_unlock(&rwlock);
1100 bond_unixctl_migrate(struct unixctl_conn *conn,
1101 int argc OVS_UNUSED, const char *argv[],
1102 void *aux OVS_UNUSED)
1104 const char *bond_s = argv[1];
1105 const char *hash_s = argv[2];
1106 const char *slave_s = argv[3];
1108 struct bond_slave *slave;
1109 struct bond_entry *entry;
1112 ovs_rwlock_wrlock(&rwlock);
1113 bond = bond_find(bond_s);
1115 unixctl_command_reply_error(conn, "no such bond");
1119 if (bond->balance != BM_SLB) {
1120 unixctl_command_reply_error(conn, "not an SLB bond");
1124 if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
1125 hash = atoi(hash_s) & BOND_MASK;
1127 unixctl_command_reply_error(conn, "bad hash");
1131 slave = bond_lookup_slave(bond, slave_s);
1133 unixctl_command_reply_error(conn, "no such slave");
1137 if (!slave->enabled) {
1138 unixctl_command_reply_error(conn, "cannot migrate to disabled slave");
1142 entry = &bond->hash[hash];
1143 bond->bond_revalidate = true;
1144 entry->slave = slave;
1145 unixctl_command_reply(conn, "migrated");
1148 ovs_rwlock_unlock(&rwlock);
1152 bond_unixctl_set_active_slave(struct unixctl_conn *conn,
1153 int argc OVS_UNUSED, const char *argv[],
1154 void *aux OVS_UNUSED)
1156 const char *bond_s = argv[1];
1157 const char *slave_s = argv[2];
1159 struct bond_slave *slave;
1161 ovs_rwlock_wrlock(&rwlock);
1162 bond = bond_find(bond_s);
1164 unixctl_command_reply_error(conn, "no such bond");
1168 slave = bond_lookup_slave(bond, slave_s);
1170 unixctl_command_reply_error(conn, "no such slave");
1174 if (!slave->enabled) {
1175 unixctl_command_reply_error(conn, "cannot make disabled slave active");
1179 if (bond->active_slave != slave) {
1180 bond->bond_revalidate = true;
1181 bond->active_slave = slave;
1182 VLOG_INFO("bond %s: active interface is now %s",
1183 bond->name, slave->name);
1184 bond->send_learning_packets = true;
1185 unixctl_command_reply(conn, "done");
1187 unixctl_command_reply(conn, "no change");
1190 ovs_rwlock_unlock(&rwlock);
1194 enable_slave(struct unixctl_conn *conn, const char *argv[], bool enable)
1196 const char *bond_s = argv[1];
1197 const char *slave_s = argv[2];
1199 struct bond_slave *slave;
1201 ovs_rwlock_wrlock(&rwlock);
1202 bond = bond_find(bond_s);
1204 unixctl_command_reply_error(conn, "no such bond");
1208 slave = bond_lookup_slave(bond, slave_s);
1210 unixctl_command_reply_error(conn, "no such slave");
1214 bond_enable_slave(slave, enable);
1215 unixctl_command_reply(conn, enable ? "enabled" : "disabled");
1218 ovs_rwlock_unlock(&rwlock);
1222 bond_unixctl_enable_slave(struct unixctl_conn *conn,
1223 int argc OVS_UNUSED, const char *argv[],
1224 void *aux OVS_UNUSED)
1226 enable_slave(conn, argv, true);
1230 bond_unixctl_disable_slave(struct unixctl_conn *conn,
1231 int argc OVS_UNUSED, const char *argv[],
1232 void *aux OVS_UNUSED)
1234 enable_slave(conn, argv, false);
1238 bond_unixctl_hash(struct unixctl_conn *conn, int argc, const char *argv[],
1239 void *aux OVS_UNUSED)
1241 const char *mac_s = argv[1];
1242 const char *vlan_s = argc > 2 ? argv[2] : NULL;
1243 const char *basis_s = argc > 3 ? argv[3] : NULL;
1244 uint8_t mac[ETH_ADDR_LEN];
1251 if (sscanf(vlan_s, "%u", &vlan) != 1) {
1252 unixctl_command_reply_error(conn, "invalid vlan");
1260 if (sscanf(basis_s, "%"PRIu32, &basis) != 1) {
1261 unixctl_command_reply_error(conn, "invalid basis");
1268 if (sscanf(mac_s, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
1269 == ETH_ADDR_SCAN_COUNT) {
1270 hash = bond_hash_src(mac, vlan, basis) & BOND_MASK;
1272 hash_cstr = xasprintf("%u", hash);
1273 unixctl_command_reply(conn, hash_cstr);
1276 unixctl_command_reply_error(conn, "invalid mac");
1283 unixctl_command_register("bond/list", "", 0, 0, bond_unixctl_list, NULL);
1284 unixctl_command_register("bond/show", "[port]", 0, 1, bond_unixctl_show,
1286 unixctl_command_register("bond/migrate", "port hash slave", 3, 3,
1287 bond_unixctl_migrate, NULL);
1288 unixctl_command_register("bond/set-active-slave", "port slave", 2, 2,
1289 bond_unixctl_set_active_slave, NULL);
1290 unixctl_command_register("bond/enable-slave", "port slave", 2, 2,
1291 bond_unixctl_enable_slave, NULL);
1292 unixctl_command_register("bond/disable-slave", "port slave", 2, 2,
1293 bond_unixctl_disable_slave, NULL);
1294 unixctl_command_register("bond/hash", "mac [vlan] [basis]", 1, 3,
1295 bond_unixctl_hash, NULL);
1299 bond_entry_reset(struct bond *bond)
1301 if (bond->balance != BM_AB) {
1302 size_t hash_len = (BOND_MASK + 1) * sizeof *bond->hash;
1305 bond->hash = xmalloc(hash_len);
1307 memset(bond->hash, 0, hash_len);
1309 bond->next_rebalance = time_msec() + bond->rebalance_interval;
1316 static struct bond_slave *
1317 bond_slave_lookup(struct bond *bond, const void *slave_)
1319 struct bond_slave *slave;
1321 HMAP_FOR_EACH_IN_BUCKET (slave, hmap_node, hash_pointer(slave_, 0),
1323 if (slave->aux == slave_) {
1332 bond_enable_slave(struct bond_slave *slave, bool enable)
1334 slave->delay_expires = LLONG_MAX;
1335 if (enable != slave->enabled) {
1336 slave->bond->bond_revalidate = true;
1337 slave->enabled = enable;
1338 VLOG_INFO("interface %s: %s", slave->name,
1339 slave->enabled ? "enabled" : "disabled");
1344 bond_link_status_update(struct bond_slave *slave)
1346 struct bond *bond = slave->bond;
1349 up = netdev_get_carrier(slave->netdev) && slave->may_enable;
1350 if ((up == slave->enabled) != (slave->delay_expires == LLONG_MAX)) {
1351 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1352 VLOG_INFO_RL(&rl, "interface %s: link state %s",
1353 slave->name, up ? "up" : "down");
1354 if (up == slave->enabled) {
1355 slave->delay_expires = LLONG_MAX;
1356 VLOG_INFO_RL(&rl, "interface %s: will not be %s",
1357 slave->name, up ? "disabled" : "enabled");
1359 int delay = (bond->lacp_status != LACP_DISABLED ? 0
1360 : up ? bond->updelay : bond->downdelay);
1361 slave->delay_expires = time_msec() + delay;
1363 VLOG_INFO_RL(&rl, "interface %s: will be %s if it stays %s "
1366 up ? "enabled" : "disabled",
1373 if (time_msec() >= slave->delay_expires) {
1374 bond_enable_slave(slave, up);
1379 bond_hash_src(const uint8_t mac[ETH_ADDR_LEN], uint16_t vlan, uint32_t basis)
1381 return hash_3words(hash_bytes(mac, ETH_ADDR_LEN, 0), vlan, basis);
1385 bond_hash_tcp(const struct flow *flow, uint16_t vlan, uint32_t basis)
1387 struct flow hash_flow = *flow;
1388 hash_flow.vlan_tci = htons(vlan);
1390 /* The symmetric quality of this hash function is not required, but
1391 * flow_hash_symmetric_l4 already exists, and is sufficient for our
1392 * purposes, so we use it out of convenience. */
1393 return flow_hash_symmetric_l4(&hash_flow, basis);
1397 bond_hash(const struct bond *bond, const struct flow *flow, uint16_t vlan)
1399 ovs_assert(bond->balance == BM_TCP || bond->balance == BM_SLB);
1401 return (bond->balance == BM_TCP
1402 ? bond_hash_tcp(flow, vlan, bond->basis)
1403 : bond_hash_src(flow->dl_src, vlan, bond->basis));
1406 static struct bond_entry *
1407 lookup_bond_entry(const struct bond *bond, const struct flow *flow,
1410 return &bond->hash[bond_hash(bond, flow, vlan) & BOND_MASK];
1413 static struct bond_slave *
1414 choose_output_slave(const struct bond *bond, const struct flow *flow,
1415 struct flow_wildcards *wc, uint16_t vlan)
1417 struct bond_entry *e;
1419 if (bond->lacp_status == LACP_CONFIGURED) {
1420 /* LACP has been configured on this bond but negotiations were
1421 * unsuccussful. Drop all traffic. */
1425 switch (bond->balance) {
1427 return bond->active_slave;
1430 if (bond->lacp_status != LACP_NEGOTIATED) {
1431 /* Must have LACP negotiations for TCP balanced bonds. */
1435 flow_mask_hash_fields(flow, wc, NX_HASH_FIELDS_SYMMETRIC_L4);
1440 flow_mask_hash_fields(flow, wc, NX_HASH_FIELDS_ETH_SRC);
1442 e = lookup_bond_entry(bond, flow, vlan);
1443 if (!e->slave || !e->slave->enabled) {
1444 e->slave = CONTAINER_OF(hmap_random_node(&bond->slaves),
1445 struct bond_slave, hmap_node);
1446 if (!e->slave->enabled) {
1447 e->slave = bond->active_slave;
1457 static struct bond_slave *
1458 bond_choose_slave(const struct bond *bond)
1460 struct bond_slave *slave, *best;
1462 /* Find an enabled slave. */
1463 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
1464 if (slave->enabled) {
1469 /* All interfaces are disabled. Find an interface that will be enabled
1470 * after its updelay expires. */
1472 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
1473 if (slave->delay_expires != LLONG_MAX
1474 && slave->may_enable
1475 && (!best || slave->delay_expires < best->delay_expires)) {
1483 bond_choose_active_slave(struct bond *bond)
1485 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1486 struct bond_slave *old_active_slave = bond->active_slave;
1488 bond->active_slave = bond_choose_slave(bond);
1489 if (bond->active_slave) {
1490 if (bond->active_slave->enabled) {
1491 VLOG_INFO_RL(&rl, "bond %s: active interface is now %s",
1492 bond->name, bond->active_slave->name);
1494 VLOG_INFO_RL(&rl, "bond %s: active interface is now %s, skipping "
1495 "remaining %lld ms updelay (since no interface was "
1496 "enabled)", bond->name, bond->active_slave->name,
1497 bond->active_slave->delay_expires - time_msec());
1498 bond_enable_slave(bond->active_slave, true);
1501 bond->send_learning_packets = true;
1502 } else if (old_active_slave) {
1503 VLOG_INFO_RL(&rl, "bond %s: all interfaces disabled", bond->name);
1507 /* Attempts to make the sum of the bond slaves' statistics appear on the fake
1508 * bond interface. */
1510 bond_update_fake_slave_stats(struct bond *bond)
1512 struct netdev_stats bond_stats;
1513 struct bond_slave *slave;
1514 struct netdev *bond_dev;
1516 memset(&bond_stats, 0, sizeof bond_stats);
1518 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
1519 struct netdev_stats slave_stats;
1521 if (!netdev_get_stats(slave->netdev, &slave_stats)) {
1522 /* XXX: We swap the stats here because they are swapped back when
1523 * reported by the internal device. The reason for this is
1524 * internal devices normally represent packets going into the
1525 * system but when used as fake bond device they represent packets
1526 * leaving the system. We really should do this in the internal
1527 * device itself because changing it here reverses the counts from
1528 * the perspective of the switch. However, the internal device
1529 * doesn't know what type of device it represents so we have to do
1530 * it here for now. */
1531 bond_stats.tx_packets += slave_stats.rx_packets;
1532 bond_stats.tx_bytes += slave_stats.rx_bytes;
1533 bond_stats.rx_packets += slave_stats.tx_packets;
1534 bond_stats.rx_bytes += slave_stats.tx_bytes;
1538 if (!netdev_open(bond->name, "system", &bond_dev)) {
1539 netdev_set_stats(bond_dev, &bond_stats);
1540 netdev_close(bond_dev);