Commit 5d6dd5bf authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'bonding_rtnl' 



Ding Tianhong says:

====================
Fix RTNL: assertion failed at net/core/rtnetlink.c

The commit 1d3ee88a
(bonding: add netlink attributes to slave link dev)
make the bond_set_active_slave() and bond_set_backup_slave()
use rtmsg_ifinfo to send slave's states and this functions
should be called in RTNL.

But the 902.3ad and ARP monitor did not hold the RTNL when calling
thses two functions, so fix them.

v1->v2: Add new micro to indicate that the notification should be send
        later, not never.
        And add a new patch to fix the same problem for ARP mode.

v2->v3: modify the bond_should_notify to should_notify_rtnl, it is more
	reasonable, and	use bool for should_notify_rtnl.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents bc90d291 b0929915

drivers/net/bonding/bond_3ad.c

+14 −2
Original line number Diff line number Diff line
@@ -181,7 +181,7 @@ static inline int __agg_has_partner(struct aggregator *agg) 
 */

static inline void __disable_port(struct port *port)

{

	bond_set_slave_inactive_flags(port->slave);

	bond_set_slave_inactive_flags(port->slave, BOND_SLAVE_NOTIFY_LATER);

}



/**
@@ -193,7 +193,7 @@ static inline void __enable_port(struct port *port) 
	struct slave *slave = port->slave;



	if ((slave->link == BOND_LINK_UP) && IS_UP(slave->dev))

		bond_set_slave_active_flags(slave);

		bond_set_slave_active_flags(slave, BOND_SLAVE_NOTIFY_LATER);

}



/**
@@ -2062,6 +2062,7 @@ void bond_3ad_state_machine_handler(struct work_struct *work) 
	struct list_head *iter;

	struct slave *slave;

	struct port *port;

	bool should_notify_rtnl = BOND_SLAVE_NOTIFY_LATER;



	read_lock(&bond->lock);

	rcu_read_lock();
@@ -2119,8 +2120,19 @@ void bond_3ad_state_machine_handler(struct work_struct *work) 
	}



re_arm:

	bond_for_each_slave_rcu(bond, slave, iter) {

		if (slave->should_notify) {

			should_notify_rtnl = BOND_SLAVE_NOTIFY_NOW;

			break;

		}

	}

	rcu_read_unlock();

	read_unlock(&bond->lock);



	if (should_notify_rtnl && rtnl_trylock()) {

		bond_slave_state_notify(bond);

		rtnl_unlock();

	}

	queue_delayed_work(bond->wq, &bond->ad_work, ad_delta_in_ticks);

}

drivers/net/bonding/bond_main.c

+64 −51
Original line number Diff line number Diff line
@@ -829,21 +829,25 @@ void bond_change_active_slave(struct bonding *bond, struct slave *new_active) 
	if (bond_is_lb(bond)) {

		bond_alb_handle_active_change(bond, new_active);

		if (old_active)

			bond_set_slave_inactive_flags(old_active);

			bond_set_slave_inactive_flags(old_active,

						      BOND_SLAVE_NOTIFY_NOW);

		if (new_active)

			bond_set_slave_active_flags(new_active);

			bond_set_slave_active_flags(new_active,

						    BOND_SLAVE_NOTIFY_NOW);

	} else {

		rcu_assign_pointer(bond->curr_active_slave, new_active);

	}



	if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {

		if (old_active)

			bond_set_slave_inactive_flags(old_active);

			bond_set_slave_inactive_flags(old_active,

						      BOND_SLAVE_NOTIFY_NOW);



		if (new_active) {

			bool should_notify_peers = false;



			bond_set_slave_active_flags(new_active);

			bond_set_slave_active_flags(new_active,

						    BOND_SLAVE_NOTIFY_NOW);



			if (bond->params.fail_over_mac)

				bond_do_fail_over_mac(bond, new_active,
@@ -1463,14 +1467,15 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) 


	switch (bond->params.mode) {

	case BOND_MODE_ACTIVEBACKUP:

		bond_set_slave_inactive_flags(new_slave);

		bond_set_slave_inactive_flags(new_slave,

					      BOND_SLAVE_NOTIFY_NOW);

		break;

	case BOND_MODE_8023AD:

		/* in 802.3ad mode, the internal mechanism

		 * will activate the slaves in the selected

		 * aggregator

		 */

		bond_set_slave_inactive_flags(new_slave);

		bond_set_slave_inactive_flags(new_slave, BOND_SLAVE_NOTIFY_NOW);

		/* if this is the first slave */

		if (!prev_slave) {

			SLAVE_AD_INFO(new_slave).id = 1;
@@ -1488,7 +1493,7 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) 
	case BOND_MODE_TLB:

	case BOND_MODE_ALB:

		bond_set_active_slave(new_slave);

		bond_set_slave_inactive_flags(new_slave);

		bond_set_slave_inactive_flags(new_slave, BOND_SLAVE_NOTIFY_NOW);

		break;

	default:

		pr_debug("This slave is always active in trunk mode\n");
@@ -2015,7 +2020,8 @@ static void bond_miimon_commit(struct bonding *bond) 


			if (bond->params.mode == BOND_MODE_ACTIVEBACKUP ||

			    bond->params.mode == BOND_MODE_8023AD)

				bond_set_slave_inactive_flags(slave);

				bond_set_slave_inactive_flags(slave,

							      BOND_SLAVE_NOTIFY_NOW);



			pr_info("%s: link status definitely down for interface %s, disabling it\n",

				bond->dev->name, slave->dev->name);
@@ -2562,7 +2568,8 @@ static void bond_ab_arp_commit(struct bonding *bond) 
				slave->link = BOND_LINK_UP;

				if (bond->current_arp_slave) {

					bond_set_slave_inactive_flags(

						bond->current_arp_slave);

						bond->current_arp_slave,

						BOND_SLAVE_NOTIFY_NOW);

					bond->current_arp_slave = NULL;

				}
@@ -2582,7 +2589,8 @@ static void bond_ab_arp_commit(struct bonding *bond) 
				slave->link_failure_count++;



			slave->link = BOND_LINK_DOWN;

			bond_set_slave_inactive_flags(slave);

			bond_set_slave_inactive_flags(slave,

						      BOND_SLAVE_NOTIFY_NOW);



			pr_info("%s: link status definitely down for interface %s, disabling it\n",

				bond->dev->name, slave->dev->name);
@@ -2615,17 +2623,17 @@ do_failover: 


/*

 * Send ARP probes for active-backup mode ARP monitor.

 *

 * Called with rcu_read_lock hold.

 */

static bool bond_ab_arp_probe(struct bonding *bond)

{

	struct slave *slave, *before = NULL, *new_slave = NULL,

		     *curr_arp_slave, *curr_active_slave;

		     *curr_arp_slave = rcu_dereference(bond->current_arp_slave),

		     *curr_active_slave = rcu_dereference(bond->curr_active_slave);

	struct list_head *iter;

	bool found = false;



	rcu_read_lock();

	curr_arp_slave = rcu_dereference(bond->current_arp_slave);

	curr_active_slave = rcu_dereference(bond->curr_active_slave);

	bool should_notify_rtnl = BOND_SLAVE_NOTIFY_LATER;



	if (curr_arp_slave && curr_active_slave)

		pr_info("PROBE: c_arp %s && cas %s BAD\n",
@@ -2634,32 +2642,23 @@ static bool bond_ab_arp_probe(struct bonding *bond) 


	if (curr_active_slave) {

		bond_arp_send_all(bond, curr_active_slave);

		rcu_read_unlock();

		return true;

		return should_notify_rtnl;

	}

	rcu_read_unlock();



	/* if we don't have a curr_active_slave, search for the next available

	 * backup slave from the current_arp_slave and make it the candidate

	 * for becoming the curr_active_slave

	 */



	if (!rtnl_trylock())

		return false;

	/* curr_arp_slave might have gone away */

	curr_arp_slave = ACCESS_ONCE(bond->current_arp_slave);



	if (!curr_arp_slave) {

		curr_arp_slave = bond_first_slave(bond);

	if (!curr_arp_slave) {

			rtnl_unlock();

			return true;

		}

		curr_arp_slave = bond_first_slave_rcu(bond);

		if (!curr_arp_slave)

			return should_notify_rtnl;

	}



	bond_set_slave_inactive_flags(curr_arp_slave);

	bond_set_slave_inactive_flags(curr_arp_slave, BOND_SLAVE_NOTIFY_LATER);



	bond_for_each_slave(bond, slave, iter) {

	bond_for_each_slave_rcu(bond, slave, iter) {

		if (!found && !before && IS_UP(slave->dev))

			before = slave;
@@ -2677,7 +2676,8 @@ static bool bond_ab_arp_probe(struct bonding *bond) 
			if (slave->link_failure_count < UINT_MAX)

				slave->link_failure_count++;



			bond_set_slave_inactive_flags(slave);

			bond_set_slave_inactive_flags(slave,

						      BOND_SLAVE_NOTIFY_LATER);



			pr_info("%s: backup interface %s is now down.\n",

				bond->dev->name, slave->dev->name);
@@ -2689,26 +2689,31 @@ static bool bond_ab_arp_probe(struct bonding *bond) 
	if (!new_slave && before)

		new_slave = before;



	if (!new_slave) {

		rtnl_unlock();

		return true;

	}

	if (!new_slave)

		goto check_state;



	new_slave->link = BOND_LINK_BACK;

	bond_set_slave_active_flags(new_slave);

	bond_set_slave_active_flags(new_slave, BOND_SLAVE_NOTIFY_LATER);

	bond_arp_send_all(bond, new_slave);

	new_slave->jiffies = jiffies;

	rcu_assign_pointer(bond->current_arp_slave, new_slave);

	rtnl_unlock();



	return true;

check_state:

	bond_for_each_slave_rcu(bond, slave, iter) {

		if (slave->should_notify) {

			should_notify_rtnl = BOND_SLAVE_NOTIFY_NOW;

			break;

		}

	}

	return should_notify_rtnl;

}



static void bond_activebackup_arp_mon(struct work_struct *work)

{

	struct bonding *bond = container_of(work, struct bonding,

					    arp_work.work);

	bool should_notify_peers = false, should_commit = false;

	bool should_notify_peers = false;

	bool should_notify_rtnl = false;

	int delta_in_ticks;



	delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
@@ -2717,11 +2722,12 @@ static void bond_activebackup_arp_mon(struct work_struct *work) 
		goto re_arm;



	rcu_read_lock();



	should_notify_peers = bond_should_notify_peers(bond);

	should_commit = bond_ab_arp_inspect(bond);



	if (bond_ab_arp_inspect(bond)) {

		rcu_read_unlock();



	if (should_commit) {

		/* Race avoidance with bond_close flush of workqueue */

		if (!rtnl_trylock()) {

			delta_in_ticks = 1;
@@ -2730,23 +2736,28 @@ static void bond_activebackup_arp_mon(struct work_struct *work) 
		}



		bond_ab_arp_commit(bond);



		rtnl_unlock();

		rcu_read_lock();

	}



	if (!bond_ab_arp_probe(bond)) {

		/* rtnl locking failed, re-arm */

		delta_in_ticks = 1;

		should_notify_peers = false;

	}

	should_notify_rtnl = bond_ab_arp_probe(bond);

	rcu_read_unlock();



re_arm:

	if (bond->params.arp_interval)

		queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);



	if (should_notify_peers) {

	if (should_notify_peers || should_notify_rtnl) {

		if (!rtnl_trylock())

			return;

		call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);



		if (should_notify_peers)

			call_netdevice_notifiers(NETDEV_NOTIFY_PEERS,

						 bond->dev);

		if (should_notify_rtnl)

			bond_slave_state_notify(bond);



		rtnl_unlock();

	}

}
@@ -3046,9 +3057,11 @@ static int bond_open(struct net_device *bond_dev) 
		bond_for_each_slave(bond, slave, iter) {

			if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)

				&& (slave != bond->curr_active_slave)) {

				bond_set_slave_inactive_flags(slave);

				bond_set_slave_inactive_flags(slave,

							      BOND_SLAVE_NOTIFY_NOW);

			} else {

				bond_set_slave_active_flags(slave);

				bond_set_slave_active_flags(slave,

							    BOND_SLAVE_NOTIFY_NOW);

			}

		}

		read_unlock(&bond->curr_slave_lock);

drivers/net/bonding/bonding.h

+42 −5
Original line number Diff line number Diff line
@@ -195,7 +195,8 @@ struct slave { 
	s8     new_link;

	u8     backup:1,   /* indicates backup slave. Value corresponds with

			      BOND_STATE_ACTIVE and BOND_STATE_BACKUP */

	       inactive:1; /* indicates inactive slave */

	       inactive:1, /* indicates inactive slave */

	       should_notify:1; /* indicateds whether the state changed */

	u8     duplex;

	u32    original_mtu;

	u32    link_failure_count;
@@ -303,6 +304,24 @@ static inline void bond_set_backup_slave(struct slave *slave) 
	}

}



static inline void bond_set_slave_state(struct slave *slave,

					int slave_state, bool notify)

{

	if (slave->backup == slave_state)

		return;



	slave->backup = slave_state;

	if (notify) {

		rtmsg_ifinfo(RTM_NEWLINK, slave->dev, 0, GFP_KERNEL);

		slave->should_notify = 0;

	} else {

		if (slave->should_notify)

			slave->should_notify = 0;

		else

			slave->should_notify = 1;

	}

}



static inline void bond_slave_state_change(struct bonding *bond)

{

	struct list_head *iter;
@@ -316,6 +335,19 @@ static inline void bond_slave_state_change(struct bonding *bond) 
	}

}



static inline void bond_slave_state_notify(struct bonding *bond)

{

	struct list_head *iter;

	struct slave *tmp;



	bond_for_each_slave(bond, tmp, iter) {

		if (tmp->should_notify) {

			rtmsg_ifinfo(RTM_NEWLINK, tmp->dev, 0, GFP_KERNEL);

			tmp->should_notify = 0;

		}

	}

}



static inline int bond_slave_state(struct slave *slave)

{

	return slave->backup;
@@ -343,6 +375,9 @@ static inline bool bond_is_active_slave(struct slave *slave) 
#define BOND_ARP_VALIDATE_ALL		(BOND_ARP_VALIDATE_ACTIVE | \

					 BOND_ARP_VALIDATE_BACKUP)



#define BOND_SLAVE_NOTIFY_NOW		true

#define BOND_SLAVE_NOTIFY_LATER		false



static inline int slave_do_arp_validate(struct bonding *bond,

					struct slave *slave)

{
@@ -394,17 +429,19 @@ static inline void bond_netpoll_send_skb(const struct slave *slave, 
}

#endif



static inline void bond_set_slave_inactive_flags(struct slave *slave)

static inline void bond_set_slave_inactive_flags(struct slave *slave,

						 bool notify)

{

	if (!bond_is_lb(slave->bond))

		bond_set_backup_slave(slave);

		bond_set_slave_state(slave, BOND_STATE_BACKUP, notify);

	if (!slave->bond->params.all_slaves_active)

		slave->inactive = 1;

}



static inline void bond_set_slave_active_flags(struct slave *slave)

static inline void bond_set_slave_active_flags(struct slave *slave,

					       bool notify)

{

	bond_set_active_slave(slave);

	bond_set_slave_state(slave, BOND_STATE_ACTIVE, notify);

	slave->inactive = 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE