/*********************** tlb specific functions ***************************/
 
-static inline void _lock_tx_hashtbl_bh(struct bonding *bond)
-{
-       spin_lock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
-}
-
-static inline void _unlock_tx_hashtbl_bh(struct bonding *bond)
-{
-       spin_unlock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
-}
-
-static inline void _lock_tx_hashtbl(struct bonding *bond)
-{
-       spin_lock(&(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));
-}
-
-/* Caller must hold tx_hashtbl lock */
 static inline void tlb_init_table_entry(struct tlb_client_info *entry, int save_load)
 {
        if (save_load) {
 static void tlb_clear_slave(struct bonding *bond, struct slave *slave,
                         int save_load)
 {
-       _lock_tx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
        __tlb_clear_slave(bond, slave, save_load);
-       _unlock_tx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 }
 
 /* Must be called before starting the monitor timer */
        if (!new_hashtbl)
                return -1;
 
-       _lock_tx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        bond_info->tx_hashtbl = new_hashtbl;
 
        for (i = 0; i < TLB_HASH_TABLE_SIZE; i++)
                tlb_init_table_entry(&bond_info->tx_hashtbl[i], 0);
 
-       _unlock_tx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 
        return 0;
 }
        struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
        struct tlb_up_slave *arr;
 
-       _lock_tx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        kfree(bond_info->tx_hashtbl);
        bond_info->tx_hashtbl = NULL;
 
-       _unlock_tx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 
        arr = rtnl_dereference(bond_info->slave_arr);
        if (arr)
        return assigned_slave;
 }
 
-/* Caller must hold bond lock for read */
 static struct slave *tlb_choose_channel(struct bonding *bond, u32 hash_index,
                                        u32 skb_len)
 {
         * tlb_choose_channel() is only called by bond_alb_xmit()
         * which already has softirq disabled.
         */
-       _lock_tx_hashtbl(bond);
+       spin_lock(&bond->mode_lock);
        tx_slave = __tlb_choose_channel(bond, hash_index, skb_len);
-       _unlock_tx_hashtbl(bond);
+       spin_unlock(&bond->mode_lock);
        return tx_slave;
 }
 
 /*********************** rlb specific functions ***************************/
-static inline void _lock_rx_hashtbl_bh(struct bonding *bond)
-{
-       spin_lock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
-}
-
-static inline void _unlock_rx_hashtbl_bh(struct bonding *bond)
-{
-       spin_unlock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
-}
-
-static inline void _lock_rx_hashtbl(struct bonding *bond)
-{
-       spin_lock(&(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));
-}
 
 /* when an ARP REPLY is received from a client update its info
  * in the rx_hashtbl
        struct rlb_client_info *client_info;
        u32 hash_index;
 
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        hash_index = _simple_hash((u8 *)&(arp->ip_src), sizeof(arp->ip_src));
        client_info = &(bond_info->rx_hashtbl[hash_index]);
                bond_info->rx_ntt = 1;
        }
 
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 }
 
 static int rlb_arp_recv(const struct sk_buff *skb, struct bonding *bond,
        u32 index, next_index;
 
        /* clear slave from rx_hashtbl */
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        rx_hash_table = bond_info->rx_hashtbl;
        index = bond_info->rx_hashtbl_used_head;
                }
        }
 
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 
        if (slave != rtnl_dereference(bond->curr_active_slave))
                rlb_teach_disabled_mac_on_primary(bond, slave->dev->dev_addr);
        struct rlb_client_info *client_info;
        u32 hash_index;
 
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        hash_index = bond_info->rx_hashtbl_used_head;
        for (; hash_index != RLB_NULL_INDEX;
         */
        bond_info->rlb_update_delay_counter = RLB_UPDATE_DELAY;
 
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 }
 
 /* The slave was assigned a new mac address - update the clients */
        int ntt = 0;
        u32 hash_index;
 
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        hash_index = bond_info->rx_hashtbl_used_head;
        for (; hash_index != RLB_NULL_INDEX;
                bond_info->rlb_update_retry_counter = RLB_UPDATE_RETRY;
        }
 
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 }
 
 /* mark all clients using src_ip to be updated */
        struct rlb_client_info *client_info;
        u32 hash_index;
 
-       _lock_rx_hashtbl(bond);
+       spin_lock(&bond->mode_lock);
 
        hash_index = bond_info->rx_hashtbl_used_head;
        for (; hash_index != RLB_NULL_INDEX;
                }
        }
 
-       _unlock_rx_hashtbl(bond);
+       spin_unlock(&bond->mode_lock);
 }
 
-/* Caller must hold both bond and ptr locks for read */
 static struct slave *rlb_choose_channel(struct sk_buff *skb, struct bonding *bond)
 {
        struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
        struct rlb_client_info *client_info;
        u32 hash_index = 0;
 
-       _lock_rx_hashtbl(bond);
+       spin_lock(&bond->mode_lock);
 
        curr_active_slave = rcu_dereference(bond->curr_active_slave);
 
 
                        assigned_slave = client_info->slave;
                        if (assigned_slave) {
-                               _unlock_rx_hashtbl(bond);
+                               spin_unlock(&bond->mode_lock);
                                return assigned_slave;
                        }
                } else {
                }
        }
 
-       _unlock_rx_hashtbl(bond);
+       spin_unlock(&bond->mode_lock);
 
        return assigned_slave;
 }
        int ntt;
        u32 hash_index;
 
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        ntt = 0;
        hash_index = bond_info->rx_hashtbl_used_head;
        /* update the team's flag only after the whole iteration */
        if (ntt)
                bond_info->rx_ntt = 1;
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 }
 
 /* Caller must hold rx_hashtbl lock */
        u32 ip_src_hash = _simple_hash((u8 *)&(arp->ip_src), sizeof(arp->ip_src));
        u32 index;
 
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        index = bond_info->rx_hashtbl[ip_src_hash].src_first;
        while (index != RLB_NULL_INDEX) {
                                rlb_delete_table_entry(bond, index);
                index = next_index;
        }
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 }
 
 static int rlb_initialize(struct bonding *bond)
        if (!new_hashtbl)
                return -1;
 
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        bond_info->rx_hashtbl = new_hashtbl;
 
        for (i = 0; i < RLB_HASH_TABLE_SIZE; i++)
                rlb_init_table_entry(bond_info->rx_hashtbl + i);
 
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 
        /* register to receive ARPs */
        bond->recv_probe = rlb_arp_recv;
 {
        struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
 
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        kfree(bond_info->rx_hashtbl);
        bond_info->rx_hashtbl = NULL;
        bond_info->rx_hashtbl_used_head = RLB_NULL_INDEX;
 
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 }
 
 static void rlb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
        struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
        u32 curr_index;
 
-       _lock_rx_hashtbl_bh(bond);
+       spin_lock_bh(&bond->mode_lock);
 
        curr_index = bond_info->rx_hashtbl_used_head;
        while (curr_index != RLB_NULL_INDEX) {
                curr_index = next_index;
        }
 
-       _unlock_rx_hashtbl_bh(bond);
+       spin_unlock_bh(&bond->mode_lock);
 }
 
 /*********************** tlb/rlb shared functions *********************/
        }
 
        if (tx_slave && bond->params.tlb_dynamic_lb) {
-               _lock_tx_hashtbl(bond);
+               spin_lock(&bond->mode_lock);
                __tlb_clear_slave(bond, tx_slave, 0);
-               _unlock_tx_hashtbl(bond);
+               spin_unlock(&bond->mode_lock);
        }
 
        /* no suitable interface, frame not sent */