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;
665 ovs_rwlock_rdlock(&rwlock);
666 slave = choose_output_slave(bond, flow, wc, vlan);
667 ovs_rwlock_unlock(&rwlock);
674 bond_is_balanced(const struct bond *bond) OVS_REQ_RDLOCK(rwlock)
676 return bond->rebalance_interval
677 && (bond->balance == BM_SLB || bond->balance == BM_TCP);
680 /* Notifies 'bond' that 'n_bytes' bytes were sent in 'flow' within 'vlan'. */
682 bond_account(struct bond *bond, const struct flow *flow, uint16_t vlan,
685 ovs_rwlock_wrlock(&rwlock);
686 if (bond_is_balanced(bond)) {
687 lookup_bond_entry(bond, flow, vlan)->tx_bytes += n_bytes;
689 ovs_rwlock_unlock(&rwlock);
692 static struct bond_slave *
693 bond_slave_from_bal_node(struct list *bal) OVS_REQ_RDLOCK(rwlock)
695 return CONTAINER_OF(bal, struct bond_slave, bal_node);
699 log_bals(struct bond *bond, const struct list *bals)
701 if (VLOG_IS_DBG_ENABLED()) {
702 struct ds ds = DS_EMPTY_INITIALIZER;
703 const struct bond_slave *slave;
705 LIST_FOR_EACH (slave, bal_node, bals) {
707 ds_put_char(&ds, ',');
709 ds_put_format(&ds, " %s %"PRIu64"kB",
710 slave->name, slave->tx_bytes / 1024);
712 if (!slave->enabled) {
713 ds_put_cstr(&ds, " (disabled)");
715 if (!list_is_empty(&slave->entries)) {
716 struct bond_entry *e;
718 ds_put_cstr(&ds, " (");
719 LIST_FOR_EACH (e, list_node, &slave->entries) {
720 if (&e->list_node != list_front(&slave->entries)) {
721 ds_put_cstr(&ds, " + ");
723 ds_put_format(&ds, "h%td: %"PRIu64"kB",
724 e - bond->hash, e->tx_bytes / 1024);
726 ds_put_cstr(&ds, ")");
729 VLOG_DBG("bond %s:%s", bond->name, ds_cstr(&ds));
734 /* Shifts 'hash' from its current slave to 'to'. */
736 bond_shift_load(struct bond_entry *hash, struct bond_slave *to)
738 struct bond_slave *from = hash->slave;
739 struct bond *bond = from->bond;
740 uint64_t delta = hash->tx_bytes;
742 VLOG_INFO("bond %s: shift %"PRIu64"kB of load (with hash %td) "
743 "from %s to %s (now carrying %"PRIu64"kB and "
744 "%"PRIu64"kB load, respectively)",
745 bond->name, delta / 1024, hash - bond->hash,
746 from->name, to->name,
747 (from->tx_bytes - delta) / 1024,
748 (to->tx_bytes + delta) / 1024);
750 /* Shift load away from 'from' to 'to'. */
751 from->tx_bytes -= delta;
752 to->tx_bytes += delta;
754 /* Arrange for flows to be revalidated. */
755 bond->bond_revalidate = true;
758 /* Picks and returns a bond_entry to migrate from 'from' (the most heavily
759 * loaded bond slave) to a bond slave that has 'to_tx_bytes' bytes of load,
760 * given that doing so must decrease the ratio of the load on the two slaves by
761 * at least 0.1. Returns NULL if there is no appropriate entry.
763 * The list of entries isn't sorted. I don't know of a reason to prefer to
764 * shift away small hashes or large hashes. */
765 static struct bond_entry *
766 choose_entry_to_migrate(const struct bond_slave *from, uint64_t to_tx_bytes)
768 struct bond_entry *e;
770 if (list_is_short(&from->entries)) {
771 /* 'from' carries no more than one MAC hash, so shifting load away from
772 * it would be pointless. */
776 LIST_FOR_EACH (e, list_node, &from->entries) {
777 double old_ratio, new_ratio;
780 if (to_tx_bytes == 0) {
781 /* Nothing on the new slave, move it. */
786 old_ratio = (double)from->tx_bytes / to_tx_bytes;
787 new_ratio = (double)(from->tx_bytes - delta) / (to_tx_bytes + delta);
788 if (old_ratio - new_ratio > 0.1
789 && fabs(new_ratio - 1.0) < fabs(old_ratio - 1.0)) {
790 /* We're aiming for an ideal ratio of 1, meaning both the 'from'
791 and 'to' slave have the same load. Therefore, we only move an
792 entry if it decreases the load on 'from', and brings us closer
793 to equal traffic load. */
801 /* Inserts 'slave' into 'bals' so that descending order of 'tx_bytes' is
804 insert_bal(struct list *bals, struct bond_slave *slave)
806 struct bond_slave *pos;
808 LIST_FOR_EACH (pos, bal_node, bals) {
809 if (slave->tx_bytes > pos->tx_bytes) {
813 list_insert(&pos->bal_node, &slave->bal_node);
816 /* Removes 'slave' from its current list and then inserts it into 'bals' so
817 * that descending order of 'tx_bytes' is maintained. */
819 reinsert_bal(struct list *bals, struct bond_slave *slave)
821 list_remove(&slave->bal_node);
822 insert_bal(bals, slave);
825 /* If 'bond' needs rebalancing, does so.
827 * The caller should have called bond_account() for each active flow, to ensure
828 * that flow data is consistently accounted at this point. */
830 bond_rebalance(struct bond *bond)
832 struct bond_slave *slave;
833 struct bond_entry *e;
836 ovs_rwlock_wrlock(&rwlock);
837 if (!bond_is_balanced(bond) || time_msec() < bond->next_rebalance) {
838 ovs_rwlock_unlock(&rwlock);
841 bond->next_rebalance = time_msec() + bond->rebalance_interval;
843 /* Add each bond_entry to its slave's 'entries' list.
844 * Compute each slave's tx_bytes as the sum of its entries' tx_bytes. */
845 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
847 list_init(&slave->entries);
849 for (e = &bond->hash[0]; e <= &bond->hash[BOND_MASK]; e++) {
850 if (e->slave && e->tx_bytes) {
851 e->slave->tx_bytes += e->tx_bytes;
852 list_push_back(&e->slave->entries, &e->list_node);
856 /* Add enabled slaves to 'bals' in descending order of tx_bytes.
858 * XXX This is O(n**2) in the number of slaves but it could be O(n lg n)
859 * with a proper list sort algorithm. */
861 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
862 if (slave->enabled) {
863 insert_bal(&bals, slave);
866 log_bals(bond, &bals);
868 /* Shift load from the most-loaded slaves to the least-loaded slaves. */
869 while (!list_is_short(&bals)) {
870 struct bond_slave *from = bond_slave_from_bal_node(list_front(&bals));
871 struct bond_slave *to = bond_slave_from_bal_node(list_back(&bals));
874 overload = from->tx_bytes - to->tx_bytes;
875 if (overload < to->tx_bytes >> 5 || overload < 100000) {
876 /* The extra load on 'from' (and all less-loaded slaves), compared
877 * to that of 'to' (the least-loaded slave), is less than ~3%, or
878 * it is less than ~1Mbps. No point in rebalancing. */
882 /* 'from' is carrying significantly more load than 'to'. Pick a hash
883 * to move from 'from' to 'to'. */
884 e = choose_entry_to_migrate(from, to->tx_bytes);
886 bond_shift_load(e, to);
888 /* Delete element from from->entries.
890 * We don't add the element to to->hashes. That would only allow
891 * 'e' to be migrated to another slave in this rebalancing run, and
892 * there is no point in doing that. */
893 list_remove(&e->list_node);
895 /* Re-sort 'bals'. */
896 reinsert_bal(&bals, from);
897 reinsert_bal(&bals, to);
899 /* Can't usefully migrate anything away from 'from'.
900 * Don't reconsider it. */
901 list_remove(&from->bal_node);
905 /* Implement exponentially weighted moving average. A weight of 1/2 causes
906 * historical data to decay to <1% in 7 rebalancing runs. 1,000,000 bytes
907 * take 20 rebalancing runs to decay to 0 and get deleted entirely. */
908 for (e = &bond->hash[0]; e <= &bond->hash[BOND_MASK]; e++) {
914 ovs_rwlock_unlock(&rwlock);
917 /* Bonding unixctl user interface functions. */
920 bond_find(const char *name) OVS_REQ_RDLOCK(rwlock)
924 HMAP_FOR_EACH_WITH_HASH (bond, hmap_node, hash_string(name, 0),
926 if (!strcmp(bond->name, name)) {
933 static struct bond_slave *
934 bond_lookup_slave(struct bond *bond, const char *slave_name)
936 struct bond_slave *slave;
938 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
939 if (!strcmp(slave->name, slave_name)) {
947 bond_unixctl_list(struct unixctl_conn *conn,
948 int argc OVS_UNUSED, const char *argv[] OVS_UNUSED,
949 void *aux OVS_UNUSED)
951 struct ds ds = DS_EMPTY_INITIALIZER;
952 const struct bond *bond;
954 ds_put_cstr(&ds, "bond\ttype\tslaves\n");
956 ovs_rwlock_rdlock(&rwlock);
957 HMAP_FOR_EACH (bond, hmap_node, all_bonds) {
958 const struct bond_slave *slave;
961 ds_put_format(&ds, "%s\t%s\t",
962 bond->name, bond_mode_to_string(bond->balance));
965 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
967 ds_put_cstr(&ds, ", ");
969 ds_put_cstr(&ds, slave->name);
971 ds_put_char(&ds, '\n');
973 ovs_rwlock_unlock(&rwlock);
974 unixctl_command_reply(conn, ds_cstr(&ds));
979 bond_print_details(struct ds *ds, const struct bond *bond)
980 OVS_REQ_RDLOCK(rwlock)
982 struct shash slave_shash = SHASH_INITIALIZER(&slave_shash);
983 const struct shash_node **sorted_slaves = NULL;
984 const struct bond_slave *slave;
987 ds_put_format(ds, "---- %s ----\n", bond->name);
988 ds_put_format(ds, "bond_mode: %s\n",
989 bond_mode_to_string(bond->balance));
991 ds_put_format(ds, "bond-hash-basis: %"PRIu32"\n", bond->basis);
993 ds_put_format(ds, "updelay: %d ms\n", bond->updelay);
994 ds_put_format(ds, "downdelay: %d ms\n", bond->downdelay);
996 if (bond_is_balanced(bond)) {
997 ds_put_format(ds, "next rebalance: %lld ms\n",
998 bond->next_rebalance - time_msec());
1001 ds_put_cstr(ds, "lacp_status: ");
1002 switch (bond->lacp_status) {
1003 case LACP_NEGOTIATED:
1004 ds_put_cstr(ds, "negotiated\n");
1006 case LACP_CONFIGURED:
1007 ds_put_cstr(ds, "configured\n");
1010 ds_put_cstr(ds, "off\n");
1013 ds_put_cstr(ds, "<unknown>\n");
1017 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
1018 shash_add(&slave_shash, slave->name, slave);
1020 sorted_slaves = shash_sort(&slave_shash);
1022 for (i = 0; i < shash_count(&slave_shash); i++) {
1023 struct bond_entry *be;
1025 slave = sorted_slaves[i]->data;
1028 ds_put_format(ds, "\nslave %s: %s\n",
1029 slave->name, slave->enabled ? "enabled" : "disabled");
1030 if (slave == bond->active_slave) {
1031 ds_put_cstr(ds, "\tactive slave\n");
1033 if (slave->delay_expires != LLONG_MAX) {
1034 ds_put_format(ds, "\t%s expires in %lld ms\n",
1035 slave->enabled ? "downdelay" : "updelay",
1036 slave->delay_expires - time_msec());
1039 ds_put_format(ds, "\tmay_enable: %s\n",
1040 slave->may_enable ? "true" : "false");
1042 if (!bond_is_balanced(bond)) {
1047 for (be = bond->hash; be <= &bond->hash[BOND_MASK]; be++) {
1048 int hash = be - bond->hash;
1050 if (be->slave != slave) {
1054 ds_put_format(ds, "\thash %d: %"PRIu64" kB load\n",
1055 hash, be->tx_bytes / 1024);
1057 /* XXX How can we list the MACs assigned to hashes of SLB bonds? */
1060 shash_destroy(&slave_shash);
1061 free(sorted_slaves);
1062 ds_put_cstr(ds, "\n");
1066 bond_unixctl_show(struct unixctl_conn *conn,
1067 int argc, const char *argv[],
1068 void *aux OVS_UNUSED)
1070 struct ds ds = DS_EMPTY_INITIALIZER;
1072 ovs_rwlock_rdlock(&rwlock);
1074 const struct bond *bond = bond_find(argv[1]);
1077 unixctl_command_reply_error(conn, "no such bond");
1080 bond_print_details(&ds, bond);
1082 const struct bond *bond;
1084 HMAP_FOR_EACH (bond, hmap_node, all_bonds) {
1085 bond_print_details(&ds, bond);
1089 unixctl_command_reply(conn, ds_cstr(&ds));
1093 ovs_rwlock_unlock(&rwlock);
1097 bond_unixctl_migrate(struct unixctl_conn *conn,
1098 int argc OVS_UNUSED, const char *argv[],
1099 void *aux OVS_UNUSED)
1101 const char *bond_s = argv[1];
1102 const char *hash_s = argv[2];
1103 const char *slave_s = argv[3];
1105 struct bond_slave *slave;
1106 struct bond_entry *entry;
1109 ovs_rwlock_wrlock(&rwlock);
1110 bond = bond_find(bond_s);
1112 unixctl_command_reply_error(conn, "no such bond");
1116 if (bond->balance != BM_SLB) {
1117 unixctl_command_reply_error(conn, "not an SLB bond");
1121 if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
1122 hash = atoi(hash_s) & BOND_MASK;
1124 unixctl_command_reply_error(conn, "bad hash");
1128 slave = bond_lookup_slave(bond, slave_s);
1130 unixctl_command_reply_error(conn, "no such slave");
1134 if (!slave->enabled) {
1135 unixctl_command_reply_error(conn, "cannot migrate to disabled slave");
1139 entry = &bond->hash[hash];
1140 bond->bond_revalidate = true;
1141 entry->slave = slave;
1142 unixctl_command_reply(conn, "migrated");
1145 ovs_rwlock_unlock(&rwlock);
1149 bond_unixctl_set_active_slave(struct unixctl_conn *conn,
1150 int argc OVS_UNUSED, const char *argv[],
1151 void *aux OVS_UNUSED)
1153 const char *bond_s = argv[1];
1154 const char *slave_s = argv[2];
1156 struct bond_slave *slave;
1158 ovs_rwlock_wrlock(&rwlock);
1159 bond = bond_find(bond_s);
1161 unixctl_command_reply_error(conn, "no such bond");
1165 slave = bond_lookup_slave(bond, slave_s);
1167 unixctl_command_reply_error(conn, "no such slave");
1171 if (!slave->enabled) {
1172 unixctl_command_reply_error(conn, "cannot make disabled slave active");
1176 if (bond->active_slave != slave) {
1177 bond->bond_revalidate = true;
1178 bond->active_slave = slave;
1179 VLOG_INFO("bond %s: active interface is now %s",
1180 bond->name, slave->name);
1181 bond->send_learning_packets = true;
1182 unixctl_command_reply(conn, "done");
1184 unixctl_command_reply(conn, "no change");
1187 ovs_rwlock_unlock(&rwlock);
1191 enable_slave(struct unixctl_conn *conn, const char *argv[], bool enable)
1193 const char *bond_s = argv[1];
1194 const char *slave_s = argv[2];
1196 struct bond_slave *slave;
1198 ovs_rwlock_wrlock(&rwlock);
1199 bond = bond_find(bond_s);
1201 unixctl_command_reply_error(conn, "no such bond");
1205 slave = bond_lookup_slave(bond, slave_s);
1207 unixctl_command_reply_error(conn, "no such slave");
1211 bond_enable_slave(slave, enable);
1212 unixctl_command_reply(conn, enable ? "enabled" : "disabled");
1215 ovs_rwlock_unlock(&rwlock);
1219 bond_unixctl_enable_slave(struct unixctl_conn *conn,
1220 int argc OVS_UNUSED, const char *argv[],
1221 void *aux OVS_UNUSED)
1223 enable_slave(conn, argv, true);
1227 bond_unixctl_disable_slave(struct unixctl_conn *conn,
1228 int argc OVS_UNUSED, const char *argv[],
1229 void *aux OVS_UNUSED)
1231 enable_slave(conn, argv, false);
1235 bond_unixctl_hash(struct unixctl_conn *conn, int argc, const char *argv[],
1236 void *aux OVS_UNUSED)
1238 const char *mac_s = argv[1];
1239 const char *vlan_s = argc > 2 ? argv[2] : NULL;
1240 const char *basis_s = argc > 3 ? argv[3] : NULL;
1241 uint8_t mac[ETH_ADDR_LEN];
1248 if (sscanf(vlan_s, "%u", &vlan) != 1) {
1249 unixctl_command_reply_error(conn, "invalid vlan");
1257 if (sscanf(basis_s, "%"PRIu32, &basis) != 1) {
1258 unixctl_command_reply_error(conn, "invalid basis");
1265 if (sscanf(mac_s, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
1266 == ETH_ADDR_SCAN_COUNT) {
1267 hash = bond_hash_src(mac, vlan, basis) & BOND_MASK;
1269 hash_cstr = xasprintf("%u", hash);
1270 unixctl_command_reply(conn, hash_cstr);
1273 unixctl_command_reply_error(conn, "invalid mac");
1280 unixctl_command_register("bond/list", "", 0, 0, bond_unixctl_list, NULL);
1281 unixctl_command_register("bond/show", "[port]", 0, 1, bond_unixctl_show,
1283 unixctl_command_register("bond/migrate", "port hash slave", 3, 3,
1284 bond_unixctl_migrate, NULL);
1285 unixctl_command_register("bond/set-active-slave", "port slave", 2, 2,
1286 bond_unixctl_set_active_slave, NULL);
1287 unixctl_command_register("bond/enable-slave", "port slave", 2, 2,
1288 bond_unixctl_enable_slave, NULL);
1289 unixctl_command_register("bond/disable-slave", "port slave", 2, 2,
1290 bond_unixctl_disable_slave, NULL);
1291 unixctl_command_register("bond/hash", "mac [vlan] [basis]", 1, 3,
1292 bond_unixctl_hash, NULL);
1296 bond_entry_reset(struct bond *bond)
1298 if (bond->balance != BM_AB) {
1299 size_t hash_len = (BOND_MASK + 1) * sizeof *bond->hash;
1302 bond->hash = xmalloc(hash_len);
1304 memset(bond->hash, 0, hash_len);
1306 bond->next_rebalance = time_msec() + bond->rebalance_interval;
1313 static struct bond_slave *
1314 bond_slave_lookup(struct bond *bond, const void *slave_)
1316 struct bond_slave *slave;
1318 HMAP_FOR_EACH_IN_BUCKET (slave, hmap_node, hash_pointer(slave_, 0),
1320 if (slave->aux == slave_) {
1329 bond_enable_slave(struct bond_slave *slave, bool enable)
1331 slave->delay_expires = LLONG_MAX;
1332 if (enable != slave->enabled) {
1333 slave->bond->bond_revalidate = true;
1334 slave->enabled = enable;
1335 VLOG_INFO("interface %s: %s", slave->name,
1336 slave->enabled ? "enabled" : "disabled");
1341 bond_link_status_update(struct bond_slave *slave)
1343 struct bond *bond = slave->bond;
1346 up = netdev_get_carrier(slave->netdev) && slave->may_enable;
1347 if ((up == slave->enabled) != (slave->delay_expires == LLONG_MAX)) {
1348 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1349 VLOG_INFO_RL(&rl, "interface %s: link state %s",
1350 slave->name, up ? "up" : "down");
1351 if (up == slave->enabled) {
1352 slave->delay_expires = LLONG_MAX;
1353 VLOG_INFO_RL(&rl, "interface %s: will not be %s",
1354 slave->name, up ? "disabled" : "enabled");
1356 int delay = (bond->lacp_status != LACP_DISABLED ? 0
1357 : up ? bond->updelay : bond->downdelay);
1358 slave->delay_expires = time_msec() + delay;
1360 VLOG_INFO_RL(&rl, "interface %s: will be %s if it stays %s "
1363 up ? "enabled" : "disabled",
1370 if (time_msec() >= slave->delay_expires) {
1371 bond_enable_slave(slave, up);
1376 bond_hash_src(const uint8_t mac[ETH_ADDR_LEN], uint16_t vlan, uint32_t basis)
1378 return hash_3words(hash_bytes(mac, ETH_ADDR_LEN, 0), vlan, basis);
1382 bond_hash_tcp(const struct flow *flow, uint16_t vlan, uint32_t basis)
1384 struct flow hash_flow = *flow;
1385 hash_flow.vlan_tci = htons(vlan);
1387 /* The symmetric quality of this hash function is not required, but
1388 * flow_hash_symmetric_l4 already exists, and is sufficient for our
1389 * purposes, so we use it out of convenience. */
1390 return flow_hash_symmetric_l4(&hash_flow, basis);
1394 bond_hash(const struct bond *bond, const struct flow *flow, uint16_t vlan)
1396 ovs_assert(bond->balance == BM_TCP || bond->balance == BM_SLB);
1398 return (bond->balance == BM_TCP
1399 ? bond_hash_tcp(flow, vlan, bond->basis)
1400 : bond_hash_src(flow->dl_src, vlan, bond->basis));
1403 static struct bond_entry *
1404 lookup_bond_entry(const struct bond *bond, const struct flow *flow,
1407 return &bond->hash[bond_hash(bond, flow, vlan) & BOND_MASK];
1410 static struct bond_slave *
1411 choose_output_slave(const struct bond *bond, const struct flow *flow,
1412 struct flow_wildcards *wc, uint16_t vlan)
1414 struct bond_entry *e;
1416 if (bond->lacp_status == LACP_CONFIGURED) {
1417 /* LACP has been configured on this bond but negotiations were
1418 * unsuccussful. Drop all traffic. */
1422 switch (bond->balance) {
1424 return bond->active_slave;
1427 if (bond->lacp_status != LACP_NEGOTIATED) {
1428 /* Must have LACP negotiations for TCP balanced bonds. */
1432 flow_mask_hash_fields(flow, wc, NX_HASH_FIELDS_SYMMETRIC_L4);
1437 flow_mask_hash_fields(flow, wc, NX_HASH_FIELDS_ETH_SRC);
1439 e = lookup_bond_entry(bond, flow, vlan);
1440 if (!e->slave || !e->slave->enabled) {
1441 e->slave = CONTAINER_OF(hmap_random_node(&bond->slaves),
1442 struct bond_slave, hmap_node);
1443 if (!e->slave->enabled) {
1444 e->slave = bond->active_slave;
1454 static struct bond_slave *
1455 bond_choose_slave(const struct bond *bond)
1457 struct bond_slave *slave, *best;
1459 /* Find an enabled slave. */
1460 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
1461 if (slave->enabled) {
1466 /* All interfaces are disabled. Find an interface that will be enabled
1467 * after its updelay expires. */
1469 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
1470 if (slave->delay_expires != LLONG_MAX
1471 && slave->may_enable
1472 && (!best || slave->delay_expires < best->delay_expires)) {
1480 bond_choose_active_slave(struct bond *bond)
1482 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1483 struct bond_slave *old_active_slave = bond->active_slave;
1485 bond->active_slave = bond_choose_slave(bond);
1486 if (bond->active_slave) {
1487 if (bond->active_slave->enabled) {
1488 VLOG_INFO_RL(&rl, "bond %s: active interface is now %s",
1489 bond->name, bond->active_slave->name);
1491 VLOG_INFO_RL(&rl, "bond %s: active interface is now %s, skipping "
1492 "remaining %lld ms updelay (since no interface was "
1493 "enabled)", bond->name, bond->active_slave->name,
1494 bond->active_slave->delay_expires - time_msec());
1495 bond_enable_slave(bond->active_slave, true);
1498 bond->send_learning_packets = true;
1499 } else if (old_active_slave) {
1500 VLOG_INFO_RL(&rl, "bond %s: all interfaces disabled", bond->name);
1504 /* Attempts to make the sum of the bond slaves' statistics appear on the fake
1505 * bond interface. */
1507 bond_update_fake_slave_stats(struct bond *bond)
1509 struct netdev_stats bond_stats;
1510 struct bond_slave *slave;
1511 struct netdev *bond_dev;
1513 memset(&bond_stats, 0, sizeof bond_stats);
1515 HMAP_FOR_EACH (slave, hmap_node, &bond->slaves) {
1516 struct netdev_stats slave_stats;
1518 if (!netdev_get_stats(slave->netdev, &slave_stats)) {
1519 /* XXX: We swap the stats here because they are swapped back when
1520 * reported by the internal device. The reason for this is
1521 * internal devices normally represent packets going into the
1522 * system but when used as fake bond device they represent packets
1523 * leaving the system. We really should do this in the internal
1524 * device itself because changing it here reverses the counts from
1525 * the perspective of the switch. However, the internal device
1526 * doesn't know what type of device it represents so we have to do
1527 * it here for now. */
1528 bond_stats.tx_packets += slave_stats.rx_packets;
1529 bond_stats.tx_bytes += slave_stats.rx_bytes;
1530 bond_stats.rx_packets += slave_stats.tx_packets;
1531 bond_stats.rx_bytes += slave_stats.tx_bytes;
1535 if (!netdev_open(bond->name, "system", &bond_dev)) {
1536 netdev_set_stats(bond_dev, &bond_stats);
1537 netdev_close(bond_dev);