1 files changed, 85 insertions, 25 deletions

diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c
index aea2217c56eb..25b8dbf6cfd7 100644
--- a/drivers/net/bonding/bond_alb.c
+++ b/drivers/net/bonding/bond_alb.c
@@ -128,12 +128,12 @@ static inline u8 _simple_hash(const u8 *hash_start, int hash_size)
 
 static inline void _lock_tx_hashtbl(struct bonding *bond)
 {
-        spin_lock(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
+        spin_lock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
 }
 
 static inline void _unlock_tx_hashtbl(struct bonding *bond)
 {
-        spin_unlock(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
+        spin_unlock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
 }
 
 /* Caller must hold tx_hashtbl lock */
@@ -305,12 +305,12 @@ static struct slave *tlb_choose_channel(struct bonding *bond, u32 hash_index, u3
 /*********************** rlb specific functions ***************************/
 static inline void _lock_rx_hashtbl(struct bonding *bond)
 {
-        spin_lock(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
+        spin_lock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
 }
 
 static inline void _unlock_rx_hashtbl(struct bonding *bond)
 {
-        spin_unlock(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
+        spin_unlock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
 }
 
 /* when an ARP REPLY is received from a client update its info
@@ -472,13 +472,13 @@ static void rlb_clear_slave(struct bonding *bond, struct slave *slave)
 
         _unlock_rx_hashtbl(bond);
 
-        write_lock(&bond->curr_slave_lock);
+        write_lock_bh(&bond->curr_slave_lock);
 
         if (slave != bond->curr_active_slave) {
                 rlb_teach_disabled_mac_on_primary(bond, slave->dev->dev_addr);
         }
 
-        write_unlock(&bond->curr_slave_lock);
+        write_unlock_bh(&bond->curr_slave_lock);
 }
 
 static void rlb_update_client(struct rlb_client_info *client_info)
@@ -959,19 +959,34 @@ static int alb_set_slave_mac_addr(struct slave *slave, u8 addr[], int hw)
         return 0;
 }
 
-/* Caller must hold bond lock for write or curr_slave_lock for write*/
+/*
+ * Swap MAC addresses between two slaves.
+ *
+ * Called with RTNL held, and no other locks.
+ *
+ */
+
 static void alb_swap_mac_addr(struct bonding *bond, struct slave *slave1, struct slave *slave2)
 {
-        struct slave *disabled_slave = NULL;
         u8 tmp_mac_addr[ETH_ALEN];
-        int slaves_state_differ;
-
-        slaves_state_differ = (SLAVE_IS_OK(slave1) != SLAVE_IS_OK(slave2));
 
         memcpy(tmp_mac_addr, slave1->dev->dev_addr, ETH_ALEN);
         alb_set_slave_mac_addr(slave1, slave2->dev->dev_addr, bond->alb_info.rlb_enabled);
         alb_set_slave_mac_addr(slave2, tmp_mac_addr, bond->alb_info.rlb_enabled);
 
+}
+
+/*
+ * Send learning packets after MAC address swap.
+ *
+ * Called with RTNL and bond->lock held for read.
+ */
+static void alb_fasten_mac_swap(struct bonding *bond, struct slave *slave1,
+                                struct slave *slave2)
+{
+        int slaves_state_differ = (SLAVE_IS_OK(slave1) != SLAVE_IS_OK(slave2));
+        struct slave *disabled_slave = NULL;
+
         /* fasten the change in the switch */
         if (SLAVE_IS_OK(slave1)) {
                 alb_send_learning_packets(slave1, slave1->dev->dev_addr);
@@ -1044,7 +1059,9 @@ static void alb_change_hw_addr_on_detach(struct bonding *bond, struct slave *sla
                 }
 
                 if (found) {
+                        /* locking: needs RTNL and nothing else */
                         alb_swap_mac_addr(bond, slave, tmp_slave);
+                        alb_fasten_mac_swap(bond, slave, tmp_slave);
                 }
         }
 }
@@ -1375,8 +1392,10 @@ out:
         return 0;
 }
 
-void bond_alb_monitor(struct bonding *bond)
+void bond_alb_monitor(struct work_struct *work)
 {
+        struct bonding *bond = container_of(work, struct bonding,
+                                            alb_work.work);
         struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
         struct slave *slave;
         int i;
@@ -1436,16 +1455,16 @@ void bond_alb_monitor(struct bonding *bond)
 
         /* handle rlb stuff */
         if (bond_info->rlb_enabled) {
-                /* the following code changes the promiscuity of the
-                 * the curr_active_slave. It needs to be locked with a
-                 * write lock to protect from other code that also
-                 * sets the promiscuity.
-                 */
-                write_lock_bh(&bond->curr_slave_lock);
-
                 if (bond_info->primary_is_promisc &&
                     (++bond_info->rlb_promisc_timeout_counter >= RLB_PROMISC_TIMEOUT)) {
 
+                        /*
+                         * dev_set_promiscuity requires rtnl and
+                         * nothing else.
+                         */
+                        read_unlock(&bond->lock);
+                        rtnl_lock();
+
                         bond_info->rlb_promisc_timeout_counter = 0;
 
                         /* If the primary was set to promiscuous mode
@@ -1454,9 +1473,10 @@ void bond_alb_monitor(struct bonding *bond)
                          */
                         dev_set_promiscuity(bond->curr_active_slave->dev, -1);
                         bond_info->primary_is_promisc = 0;
-                }
 
-                write_unlock_bh(&bond->curr_slave_lock);
+                        rtnl_unlock();
+                        read_lock(&bond->lock);
+                }
 
                 if (bond_info->rlb_rebalance) {
                         bond_info->rlb_rebalance = 0;
@@ -1479,7 +1499,7 @@ void bond_alb_monitor(struct bonding *bond)
         }
 
 re_arm:
-        mod_timer(&(bond_info->alb_timer), jiffies + alb_delta_in_ticks);
+        queue_delayed_work(bond->wq, &bond->alb_work, alb_delta_in_ticks);
 out:
         read_unlock(&bond->lock);
 }
@@ -1500,11 +1520,11 @@ int bond_alb_init_slave(struct bonding *bond, struct slave *slave)
         /* caller must hold the bond lock for write since the mac addresses
          * are compared and may be swapped.
          */
-        write_lock_bh(&bond->lock);
+        read_lock(&bond->lock);
 
         res = alb_handle_addr_collision_on_attach(bond, slave);
 
-        write_unlock_bh(&bond->lock);
+        read_unlock(&bond->lock);
 
         if (res) {
                 return res;
@@ -1569,13 +1589,21 @@ void bond_alb_handle_link_change(struct bonding *bond, struct slave *slave, char
  * Set the bond->curr_active_slave to @new_slave and handle
  * mac address swapping and promiscuity changes as needed.
  *
- * Caller must hold bond curr_slave_lock for write (or bond lock for write)
+ * If new_slave is NULL, caller must hold curr_slave_lock or
+ * bond->lock for write.
+ *
+ * If new_slave is not NULL, caller must hold RTNL, bond->lock for
+ * read and curr_slave_lock for write.  Processing here may sleep, so
+ * no other locks may be held.
  */
 void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave)
 {
         struct slave *swap_slave;
         int i;
 
+        if (new_slave)
+                ASSERT_RTNL();
+
         if (bond->curr_active_slave == new_slave) {
                 return;
         }
@@ -1608,6 +1636,19 @@ void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave
                 }
         }
 
+        /*
+         * Arrange for swap_slave and new_slave to temporarily be
+         * ignored so we can mess with their MAC addresses without
+         * fear of interference from transmit activity.
+         */
+        if (swap_slave) {
+                tlb_clear_slave(bond, swap_slave, 1);
+        }
+        tlb_clear_slave(bond, new_slave, 1);
+
+        write_unlock_bh(&bond->curr_slave_lock);
+        read_unlock(&bond->lock);
+
         /* curr_active_slave must be set before calling alb_swap_mac_addr */
         if (swap_slave) {
                 /* swap mac address */
@@ -1616,11 +1657,23 @@ void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave
                 /* set the new_slave to the bond mac address */
                 alb_set_slave_mac_addr(new_slave, bond->dev->dev_addr,
                                        bond->alb_info.rlb_enabled);
+        }
+
+        read_lock(&bond->lock);
+
+        if (swap_slave) {
+                alb_fasten_mac_swap(bond, swap_slave, new_slave);
+        } else {
                 /* fasten bond mac on new current slave */
                 alb_send_learning_packets(new_slave, bond->dev->dev_addr);
         }
+
+        write_lock_bh(&bond->curr_slave_lock);
 }
 
+/*
+ * Called with RTNL
+ */
 int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
 {
         struct bonding *bond = bond_dev->priv;
@@ -1657,8 +1710,12 @@ int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
                 }
         }
 
+        write_unlock_bh(&bond->curr_slave_lock);
+        read_unlock(&bond->lock);
+
         if (swap_slave) {
                 alb_swap_mac_addr(bond, swap_slave, bond->curr_active_slave);
+                alb_fasten_mac_swap(bond, swap_slave, bond->curr_active_slave);
         } else {
                 alb_set_slave_mac_addr(bond->curr_active_slave, bond_dev->dev_addr,
                                        bond->alb_info.rlb_enabled);
@@ -1670,6 +1727,9 @@ int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
                 }
         }
 
+        read_lock(&bond->lock);
+        write_lock_bh(&bond->curr_slave_lock);
+
         return 0;
 }