~hc/RK356X_SDK_RELEASE.git

..	..	@@ -41,6 +41,8 @@
41	41	#include <linux/in.h>
42	42	#include <net/ip.h>
43	43	#include <linux/ip.h>
	44	+#include <linux/icmp.h>
	45	+#include <linux/icmpv6.h>
44	46	#include <linux/tcp.h>
45	47	#include <linux/udp.h>
46	48	#include <linux/slab.h>
..	..	@@ -77,7 +79,7 @@
77	79	#include <net/pkt_sched.h>
78	80	#include <linux/rculist.h>
79	81	#include <net/flow_dissector.h>
80		-#include <net/switchdev.h>
	82	+#include <net/xfrm.h>
81	83	#include <net/bonding.h>
82	84	#include <net/bond_3ad.h>
83	85	#include <net/bond_alb.h>
..	..	@@ -201,6 +203,51 @@
201	203
202	204	unsigned int bond_net_id __read_mostly;
203	205
	206	+static const struct flow_dissector_key flow_keys_bonding_keys[] = {
	207	+ {
	208	+ .key_id = FLOW_DISSECTOR_KEY_CONTROL,
	209	+ .offset = offsetof(struct flow_keys, control),
	210	+ },
	211	+ {
	212	+ .key_id = FLOW_DISSECTOR_KEY_BASIC,
	213	+ .offset = offsetof(struct flow_keys, basic),
	214	+ },
	215	+ {
	216	+ .key_id = FLOW_DISSECTOR_KEY_IPV4_ADDRS,
	217	+ .offset = offsetof(struct flow_keys, addrs.v4addrs),
	218	+ },
	219	+ {
	220	+ .key_id = FLOW_DISSECTOR_KEY_IPV6_ADDRS,
	221	+ .offset = offsetof(struct flow_keys, addrs.v6addrs),
	222	+ },
	223	+ {
	224	+ .key_id = FLOW_DISSECTOR_KEY_TIPC,
	225	+ .offset = offsetof(struct flow_keys, addrs.tipckey),
	226	+ },
	227	+ {
	228	+ .key_id = FLOW_DISSECTOR_KEY_PORTS,
	229	+ .offset = offsetof(struct flow_keys, ports),
	230	+ },
	231	+ {
	232	+ .key_id = FLOW_DISSECTOR_KEY_ICMP,
	233	+ .offset = offsetof(struct flow_keys, icmp),
	234	+ },
	235	+ {
	236	+ .key_id = FLOW_DISSECTOR_KEY_VLAN,
	237	+ .offset = offsetof(struct flow_keys, vlan),
	238	+ },
	239	+ {
	240	+ .key_id = FLOW_DISSECTOR_KEY_FLOW_LABEL,
	241	+ .offset = offsetof(struct flow_keys, tags),
	242	+ },
	243	+ {
	244	+ .key_id = FLOW_DISSECTOR_KEY_GRE_KEYID,
	245	+ .offset = offsetof(struct flow_keys, keyid),
	246	+ },
	247	+};
	248	+
	249	+static struct flow_dissector flow_keys_bonding __read_mostly;
	250	+
204	251	/-------------------------- Forward declarations ---------------------------/
205	252
206	253	static int bond_init(struct net_device *bond_dev);
..	..	@@ -232,8 +279,6 @@
232	279	return names[mode];
233	280	}
234	281
235		-/---------------------------------- VLAN -----------------------------------/
236		-
237	282	/**
238	283	* bond_dev_queue_xmit - Prepare skb for xmit.
239	284	*
..	..	@@ -241,7 +286,7 @@
241	286	* @skb: hw accel VLAN tagged skb to transmit
242	287	* @slave_dev: slave that is supposed to xmit this skbuff
243	288	*/
244		-void bond_dev_queue_xmit(struct bonding bond, struct sk_buff skb,
	289	+netdev_tx_t bond_dev_queue_xmit(struct bonding bond, struct sk_buff skb,
245	290	struct net_device *slave_dev)
246	291	{
247	292	skb->dev = slave_dev;
..	..	@@ -251,10 +296,12 @@
251	296	skb_set_queue_mapping(skb, qdisc_skb_cb(skb)->slave_dev_queue_mapping);
252	297
253	298	if (unlikely(netpoll_tx_running(bond->dev)))
254		- bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb);
255		- else
256		- dev_queue_xmit(skb);
	299	+ return bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb);
	300	+
	301	+ return dev_queue_xmit(skb);
257	302	}
	303	+
	304	+/---------------------------------- VLAN -----------------------------------/
258	305
259	306	/* In the following 2 functions, bond_vlan_rx_add_vid and bond_vlan_rx_kill_vid,
260	307	* We don't protect the slave list iteration with a lock because:
..	..	@@ -275,6 +322,7 @@
275	322	/**
276	323	* bond_vlan_rx_add_vid - Propagates adding an id to slaves
277	324	* @bond_dev: bonding net device that got called
	325	+ * @proto: network protocol ID
278	326	* @vid: vlan id being added
279	327	*/
280	328	static int bond_vlan_rx_add_vid(struct net_device *bond_dev,
..	..	@@ -308,6 +356,7 @@
308	356	/**
309	357	* bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
310	358	* @bond_dev: bonding net device that got called
	359	+ * @proto: network protocol ID
311	360	* @vid: vlan id being removed
312	361	*/
313	362	static int bond_vlan_rx_kill_vid(struct net_device *bond_dev,
..	..	@@ -325,6 +374,225 @@
325	374
326	375	return 0;
327	376	}
	377	+
	378	+/---------------------------------- XFRM -----------------------------------/
	379	+
	380	+#ifdef CONFIG_XFRM_OFFLOAD
	381	+/**
	382	+ * bond_ipsec_add_sa - program device with a security association
	383	+ * @xs: pointer to transformer state struct
	384	+ **/
	385	+static int bond_ipsec_add_sa(struct xfrm_state *xs)
	386	+{
	387	+ struct net_device *bond_dev = xs->xso.dev;
	388	+ struct bond_ipsec *ipsec;
	389	+ struct bonding *bond;
	390	+ struct slave *slave;
	391	+ int err;
	392	+
	393	+ if (!bond_dev)
	394	+ return -EINVAL;
	395	+
	396	+ rcu_read_lock();
	397	+ bond = netdev_priv(bond_dev);
	398	+ slave = rcu_dereference(bond->curr_active_slave);
	399	+ if (!slave) {
	400	+ rcu_read_unlock();
	401	+ return -ENODEV;
	402	+ }
	403	+
	404	+ if (!slave->dev->xfrmdev_ops \|\|
	405	+ !slave->dev->xfrmdev_ops->xdo_dev_state_add \|\|
	406	+ netif_is_bond_master(slave->dev)) {
	407	+ slave_warn(bond_dev, slave->dev, "Slave does not support ipsec offload\n");
	408	+ rcu_read_unlock();
	409	+ return -EINVAL;
	410	+ }
	411	+
	412	+ ipsec = kmalloc(sizeof(*ipsec), GFP_ATOMIC);
	413	+ if (!ipsec) {
	414	+ rcu_read_unlock();
	415	+ return -ENOMEM;
	416	+ }
	417	+ xs->xso.real_dev = slave->dev;
	418	+
	419	+ err = slave->dev->xfrmdev_ops->xdo_dev_state_add(xs);
	420	+ if (!err) {
	421	+ ipsec->xs = xs;
	422	+ INIT_LIST_HEAD(&ipsec->list);
	423	+ spin_lock_bh(&bond->ipsec_lock);
	424	+ list_add(&ipsec->list, &bond->ipsec_list);
	425	+ spin_unlock_bh(&bond->ipsec_lock);
	426	+ } else {
	427	+ kfree(ipsec);
	428	+ }
	429	+ rcu_read_unlock();
	430	+ return err;
	431	+}
	432	+
	433	+static void bond_ipsec_add_sa_all(struct bonding *bond)
	434	+{
	435	+ struct net_device *bond_dev = bond->dev;
	436	+ struct bond_ipsec *ipsec;
	437	+ struct slave *slave;
	438	+
	439	+ rcu_read_lock();
	440	+ slave = rcu_dereference(bond->curr_active_slave);
	441	+ if (!slave)
	442	+ goto out;
	443	+
	444	+ if (!slave->dev->xfrmdev_ops \|\|
	445	+ !slave->dev->xfrmdev_ops->xdo_dev_state_add \|\|
	446	+ netif_is_bond_master(slave->dev)) {
	447	+ spin_lock_bh(&bond->ipsec_lock);
	448	+ if (!list_empty(&bond->ipsec_list))
	449	+ slave_warn(bond_dev, slave->dev,
	450	+ "%s: no slave xdo_dev_state_add\n",
	451	+ __func__);
	452	+ spin_unlock_bh(&bond->ipsec_lock);
	453	+ goto out;
	454	+ }
	455	+
	456	+ spin_lock_bh(&bond->ipsec_lock);
	457	+ list_for_each_entry(ipsec, &bond->ipsec_list, list) {
	458	+ ipsec->xs->xso.real_dev = slave->dev;
	459	+ if (slave->dev->xfrmdev_ops->xdo_dev_state_add(ipsec->xs)) {
	460	+ slave_warn(bond_dev, slave->dev, "%s: failed to add SA\n", __func__);
	461	+ ipsec->xs->xso.real_dev = NULL;
	462	+ }
	463	+ }
	464	+ spin_unlock_bh(&bond->ipsec_lock);
	465	+out:
	466	+ rcu_read_unlock();
	467	+}
	468	+
	469	+/**
	470	+ * bond_ipsec_del_sa - clear out this specific SA
	471	+ * @xs: pointer to transformer state struct
	472	+ **/
	473	+static void bond_ipsec_del_sa(struct xfrm_state *xs)
	474	+{
	475	+ struct net_device *bond_dev = xs->xso.dev;
	476	+ struct bond_ipsec *ipsec;
	477	+ struct bonding *bond;
	478	+ struct slave *slave;
	479	+
	480	+ if (!bond_dev)
	481	+ return;
	482	+
	483	+ rcu_read_lock();
	484	+ bond = netdev_priv(bond_dev);
	485	+ slave = rcu_dereference(bond->curr_active_slave);
	486	+
	487	+ if (!slave)
	488	+ goto out;
	489	+
	490	+ if (!xs->xso.real_dev)
	491	+ goto out;
	492	+
	493	+ WARN_ON(xs->xso.real_dev != slave->dev);
	494	+
	495	+ if (!slave->dev->xfrmdev_ops \|\|
	496	+ !slave->dev->xfrmdev_ops->xdo_dev_state_delete \|\|
	497	+ netif_is_bond_master(slave->dev)) {
	498	+ slave_warn(bond_dev, slave->dev, "%s: no slave xdo_dev_state_delete\n", __func__);
	499	+ goto out;
	500	+ }
	501	+
	502	+ slave->dev->xfrmdev_ops->xdo_dev_state_delete(xs);
	503	+out:
	504	+ spin_lock_bh(&bond->ipsec_lock);
	505	+ list_for_each_entry(ipsec, &bond->ipsec_list, list) {
	506	+ if (ipsec->xs == xs) {
	507	+ list_del(&ipsec->list);
	508	+ kfree(ipsec);
	509	+ break;
	510	+ }
	511	+ }
	512	+ spin_unlock_bh(&bond->ipsec_lock);
	513	+ rcu_read_unlock();
	514	+}
	515	+
	516	+static void bond_ipsec_del_sa_all(struct bonding *bond)
	517	+{
	518	+ struct net_device *bond_dev = bond->dev;
	519	+ struct bond_ipsec *ipsec;
	520	+ struct slave *slave;
	521	+
	522	+ rcu_read_lock();
	523	+ slave = rcu_dereference(bond->curr_active_slave);
	524	+ if (!slave) {
	525	+ rcu_read_unlock();
	526	+ return;
	527	+ }
	528	+
	529	+ spin_lock_bh(&bond->ipsec_lock);
	530	+ list_for_each_entry(ipsec, &bond->ipsec_list, list) {
	531	+ if (!ipsec->xs->xso.real_dev)
	532	+ continue;
	533	+
	534	+ if (!slave->dev->xfrmdev_ops \|\|
	535	+ !slave->dev->xfrmdev_ops->xdo_dev_state_delete \|\|
	536	+ netif_is_bond_master(slave->dev)) {
	537	+ slave_warn(bond_dev, slave->dev,
	538	+ "%s: no slave xdo_dev_state_delete\n",
	539	+ __func__);
	540	+ } else {
	541	+ slave->dev->xfrmdev_ops->xdo_dev_state_delete(ipsec->xs);
	542	+ }
	543	+ ipsec->xs->xso.real_dev = NULL;
	544	+ }
	545	+ spin_unlock_bh(&bond->ipsec_lock);
	546	+ rcu_read_unlock();
	547	+}
	548	+
	549	+/**
	550	+ * bond_ipsec_offload_ok - can this packet use the xfrm hw offload
	551	+ * @skb: current data packet
	552	+ * @xs: pointer to transformer state struct
	553	+ **/
	554	+static bool bond_ipsec_offload_ok(struct sk_buff skb, struct xfrm_state xs)
	555	+{
	556	+ struct net_device *bond_dev = xs->xso.dev;
	557	+ struct net_device *real_dev;
	558	+ struct slave *curr_active;
	559	+ struct bonding *bond;
	560	+ int err;
	561	+
	562	+ bond = netdev_priv(bond_dev);
	563	+ rcu_read_lock();
	564	+ curr_active = rcu_dereference(bond->curr_active_slave);
	565	+ real_dev = curr_active->dev;
	566	+
	567	+ if (BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) {
	568	+ err = false;
	569	+ goto out;
	570	+ }
	571	+
	572	+ if (!xs->xso.real_dev) {
	573	+ err = false;
	574	+ goto out;
	575	+ }
	576	+
	577	+ if (!real_dev->xfrmdev_ops \|\|
	578	+ !real_dev->xfrmdev_ops->xdo_dev_offload_ok \|\|
	579	+ netif_is_bond_master(real_dev)) {
	580	+ err = false;
	581	+ goto out;
	582	+ }
	583	+
	584	+ err = real_dev->xfrmdev_ops->xdo_dev_offload_ok(skb, xs);
	585	+out:
	586	+ rcu_read_unlock();
	587	+ return err;
	588	+}
	589	+
	590	+static const struct xfrmdev_ops bond_xfrmdev_ops = {
	591	+ .xdo_dev_state_add = bond_ipsec_add_sa,
	592	+ .xdo_dev_state_delete = bond_ipsec_del_sa,
	593	+ .xdo_dev_offload_ok = bond_ipsec_offload_ok,
	594	+};
	595	+#endif /* CONFIG_XFRM_OFFLOAD */
328	596
329	597	/------------------------------- Link status -------------------------------/
330	598
..	..	@@ -559,12 +827,8 @@
559	827	dev_uc_unsync(slave_dev, bond_dev);
560	828	dev_mc_unsync(slave_dev, bond_dev);
561	829
562		- if (BOND_MODE(bond) == BOND_MODE_8023AD) {
563		- /* del lacpdu mc addr from mc list */
564		- u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
565		-
566		- dev_mc_del(slave_dev, lacpdu_multicast);
567		- }
	830	+ if (BOND_MODE(bond) == BOND_MODE_8023AD)
	831	+ dev_mc_del(slave_dev, lacpdu_mcast_addr);
568	832	}
569	833
570	834	/--------------------------- Active slave change ---------------------------/
..	..	@@ -584,7 +848,8 @@
584	848	if (bond->dev->flags & IFF_ALLMULTI)
585	849	dev_set_allmulti(old_active->dev, -1);
586	850
587		- bond_hw_addr_flush(bond->dev, old_active->dev);
	851	+ if (bond->dev->flags & IFF_UP)
	852	+ bond_hw_addr_flush(bond->dev, old_active->dev);
588	853	}
589	854
590	855	if (new_active) {
..	..	@@ -595,10 +860,12 @@
595	860	if (bond->dev->flags & IFF_ALLMULTI)
596	861	dev_set_allmulti(new_active->dev, 1);
597	862
598		- netif_addr_lock_bh(bond->dev);
599		- dev_uc_sync(new_active->dev, bond->dev);
600		- dev_mc_sync(new_active->dev, bond->dev);
601		- netif_addr_unlock_bh(bond->dev);
	863	+ if (bond->dev->flags & IFF_UP) {
	864	+ netif_addr_lock_bh(bond->dev);
	865	+ dev_uc_sync(new_active->dev, bond->dev);
	866	+ dev_mc_sync(new_active->dev, bond->dev);
	867	+ netif_addr_unlock_bh(bond->dev);
	868	+ }
602	869	}
603	870	}
604	871
..	..	@@ -609,14 +876,21 @@
609	876	*
610	877	* Should be called with RTNL held.
611	878	*/
612		-static void bond_set_dev_addr(struct net_device *bond_dev,
613		- struct net_device *slave_dev)
	879	+static int bond_set_dev_addr(struct net_device *bond_dev,
	880	+ struct net_device *slave_dev)
614	881	{
615		- netdev_dbg(bond_dev, "bond_dev=%p slave_dev=%p slave_dev->name=%s slave_dev->addr_len=%d\n",
616		- bond_dev, slave_dev, slave_dev->name, slave_dev->addr_len);
	882	+ int err;
	883	+
	884	+ slave_dbg(bond_dev, slave_dev, "bond_dev=%p slave_dev=%p slave_dev->addr_len=%d\n",
	885	+ bond_dev, slave_dev, slave_dev->addr_len);
	886	+ err = dev_pre_changeaddr_notify(bond_dev, slave_dev->dev_addr, NULL);
	887	+ if (err)
	888	+ return err;
	889	+
617	890	memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
618	891	bond_dev->addr_assign_type = NET_ADDR_STOLEN;
619	892	call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev);
	893	+ return 0;
620	894	}
621	895
622	896	static struct slave bond_get_old_active(struct bonding bond,
..	..	@@ -652,8 +926,12 @@
652	926
653	927	switch (bond->params.fail_over_mac) {
654	928	case BOND_FOM_ACTIVE:
655		- if (new_active)
656		- bond_set_dev_addr(bond->dev, new_active->dev);
	929	+ if (new_active) {
	930	+ rv = bond_set_dev_addr(bond->dev, new_active->dev);
	931	+ if (rv)
	932	+ slave_err(bond->dev, new_active->dev, "Error %d setting bond MAC from slave\n",
	933	+ -rv);
	934	+ }
657	935	break;
658	936	case BOND_FOM_FOLLOW:
659	937	/* if new_active && old_active, swap them
..	..	@@ -680,10 +958,10 @@
680	958	}
681	959
682	960	rv = dev_set_mac_address(new_active->dev,
683		- (struct sockaddr *)&ss);
	961	+ (struct sockaddr *)&ss, NULL);
684	962	if (rv) {
685		- netdev_err(bond->dev, "Error %d setting MAC of slave %s\n",
686		- -rv, new_active->dev->name);
	963	+ slave_err(bond->dev, new_active->dev, "Error %d setting MAC of new active slave\n",
	964	+ -rv);
687	965	goto out;
688	966	}
689	967
..	..	@@ -695,10 +973,10 @@
695	973	ss.ss_family = old_active->dev->type;
696	974
697	975	rv = dev_set_mac_address(old_active->dev,
698		- (struct sockaddr *)&ss);
	976	+ (struct sockaddr *)&ss, NULL);
699	977	if (rv)
700		- netdev_err(bond->dev, "Error %d setting MAC of slave %s\n",
701		- -rv, new_active->dev->name);
	978	+ slave_err(bond->dev, old_active->dev, "Error %d setting MAC of old active slave\n",
	979	+ -rv);
702	980	out:
703	981	break;
704	982	default:
..	..	@@ -783,6 +1061,8 @@
783	1061	rcu_read_unlock();
784	1062
785	1063	if (!slave \|\| !bond->send_peer_notif \|\|
	1064	+ bond->send_peer_notif %
	1065	+ max(1, bond->params.peer_notif_delay) != 0 \|\|
786	1066	!netif_carrier_ok(bond->dev) \|\|
787	1067	test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state))
788	1068	return false;
..	..	@@ -796,7 +1076,7 @@
796	1076	/**
797	1077	* change_active_interface - change the active slave into the specified one
798	1078	* @bond: our bonding struct
799		- * @new: the new slave to make the active one
	1079	+ * @new_active: the new slave to make the active one
800	1080	*
801	1081	* Set the new slave to the bond's settings and unset them on the old
802	1082	* curr_active_slave.
..	..	@@ -819,14 +1099,17 @@
819	1099	if (old_active == new_active)
820	1100	return;
821	1101
	1102	+#ifdef CONFIG_XFRM_OFFLOAD
	1103	+ bond_ipsec_del_sa_all(bond);
	1104	+#endif /* CONFIG_XFRM_OFFLOAD */
	1105	+
822	1106	if (new_active) {
823	1107	new_active->last_link_up = jiffies;
824	1108
825	1109	if (new_active->link == BOND_LINK_BACK) {
826	1110	if (bond_uses_primary(bond)) {
827		- netdev_info(bond->dev, "making interface %s the new active one %d ms earlier\n",
828		- new_active->dev->name,
829		- (bond->params.updelay - new_active->delay) * bond->params.miimon);
	1111	+ slave_info(bond->dev, new_active->dev, "making interface the new active one %d ms earlier\n",
	1112	+ (bond->params.updelay - new_active->delay) * bond->params.miimon);
830	1113	}
831	1114
832	1115	new_active->delay = 0;
..	..	@@ -840,8 +1123,7 @@
840	1123	bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
841	1124	} else {
842	1125	if (bond_uses_primary(bond)) {
843		- netdev_info(bond->dev, "making interface %s the new active one\n",
844		- new_active->dev->name);
	1126	+ slave_info(bond->dev, new_active->dev, "making interface the new active one\n");
845	1127	}
846	1128	}
847	1129	}
..	..	@@ -878,17 +1160,24 @@
878	1160
879	1161	if (netif_running(bond->dev)) {
880	1162	bond->send_peer_notif =
881		- bond->params.num_peer_notif;
	1163	+ bond->params.num_peer_notif *
	1164	+ max(1, bond->params.peer_notif_delay);
882	1165	should_notify_peers =
883	1166	bond_should_notify_peers(bond);
884	1167	}
885	1168
886	1169	call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, bond->dev);
887		- if (should_notify_peers)
	1170	+ if (should_notify_peers) {
	1171	+ bond->send_peer_notif--;
888	1172	call_netdevice_notifiers(NETDEV_NOTIFY_PEERS,
889	1173	bond->dev);
	1174	+ }
890	1175	}
891	1176	}
	1177	+
	1178	+#ifdef CONFIG_XFRM_OFFLOAD
	1179	+ bond_ipsec_add_sa_all(bond);
	1180	+#endif /* CONFIG_XFRM_OFFLOAD */
892	1181
893	1182	/* resend IGMP joins since active slave has changed or
894	1183	* all were sent on curr_active_slave.
..	..	@@ -929,7 +1218,7 @@
929	1218	return;
930	1219
931	1220	if (netif_carrier_ok(bond->dev))
932		- netdev_info(bond->dev, "first active interface up!\n");
	1221	+ netdev_info(bond->dev, "active interface up!\n");
933	1222	else
934	1223	netdev_info(bond->dev, "now running without any active interface!\n");
935	1224	}
..	..	@@ -963,7 +1252,8 @@
963	1252	return;
964	1253
965	1254	slave->np = NULL;
966		- __netpoll_free_async(np);
	1255	+
	1256	+ __netpoll_free(np);
967	1257	}
968	1258
969	1259	static void bond_poll_controller(struct net_device *bond_dev)
..	..	@@ -1066,12 +1356,20 @@
1066	1356	#define BOND_ENC_FEATURES (NETIF_F_HW_CSUM \| NETIF_F_SG \| \
1067	1357	NETIF_F_RXCSUM \| NETIF_F_ALL_TSO)
1068	1358
	1359	+#define BOND_MPLS_FEATURES (NETIF_F_HW_CSUM \| NETIF_F_SG \| \
	1360	+ NETIF_F_ALL_TSO)
	1361	+
	1362	+
1069	1363	static void bond_compute_features(struct bonding *bond)
1070	1364	{
1071	1365	unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE \|
1072	1366	IFF_XMIT_DST_RELEASE_PERM;
1073	1367	netdev_features_t vlan_features = BOND_VLAN_FEATURES;
1074	1368	netdev_features_t enc_features = BOND_ENC_FEATURES;
	1369	+#ifdef CONFIG_XFRM_OFFLOAD
	1370	+ netdev_features_t xfrm_features = BOND_XFRM_FEATURES;
	1371	+#endif /* CONFIG_XFRM_OFFLOAD */
	1372	+ netdev_features_t mpls_features = BOND_MPLS_FEATURES;
1075	1373	struct net_device *bond_dev = bond->dev;
1076	1374	struct list_head *iter;
1077	1375	struct slave *slave;
..	..	@@ -1082,6 +1380,7 @@
1082	1380	if (!bond_has_slaves(bond))
1083	1381	goto done;
1084	1382	vlan_features &= NETIF_F_ALL_FOR_ALL;
	1383	+ mpls_features &= NETIF_F_ALL_FOR_ALL;
1085	1384
1086	1385	bond_for_each_slave(bond, slave, iter) {
1087	1386	vlan_features = netdev_increment_features(vlan_features,
..	..	@@ -1090,6 +1389,17 @@
1090	1389	enc_features = netdev_increment_features(enc_features,
1091	1390	slave->dev->hw_enc_features,
1092	1391	BOND_ENC_FEATURES);
	1392	+
	1393	+#ifdef CONFIG_XFRM_OFFLOAD
	1394	+ xfrm_features = netdev_increment_features(xfrm_features,
	1395	+ slave->dev->hw_enc_features,
	1396	+ BOND_XFRM_FEATURES);
	1397	+#endif /* CONFIG_XFRM_OFFLOAD */
	1398	+
	1399	+ mpls_features = netdev_increment_features(mpls_features,
	1400	+ slave->dev->mpls_features,
	1401	+ BOND_MPLS_FEATURES);
	1402	+
1093	1403	dst_release_flag &= slave->dev->priv_flags;
1094	1404	if (slave->dev->hard_header_len > max_hard_header_len)
1095	1405	max_hard_header_len = slave->dev->hard_header_len;
..	..	@@ -1105,6 +1415,10 @@
1105	1415	NETIF_F_HW_VLAN_CTAG_TX \|
1106	1416	NETIF_F_HW_VLAN_STAG_TX \|
1107	1417	NETIF_F_GSO_UDP_L4;
	1418	+#ifdef CONFIG_XFRM_OFFLOAD
	1419	+ bond_dev->hw_enc_features \|= xfrm_features;
	1420	+#endif /* CONFIG_XFRM_OFFLOAD */
	1421	+ bond_dev->mpls_features = mpls_features;
1108	1422	bond_dev->gso_max_segs = gso_max_segs;
1109	1423	netif_set_gso_max_size(bond_dev, gso_max_size);
1110	1424
..	..	@@ -1128,6 +1442,11 @@
1128	1442
1129	1443	memcpy(bond_dev->broadcast, slave_dev->broadcast,
1130	1444	slave_dev->addr_len);
	1445	+
	1446	+ if (slave_dev->flags & IFF_POINTOPOINT) {
	1447	+ bond_dev->flags &= ~(IFF_BROADCAST \| IFF_MULTICAST);
	1448	+ bond_dev->flags \|= (IFF_POINTOPOINT \| IFF_NOARP);
	1449	+ }
1131	1450	}
1132	1451
1133	1452	/* On bonding slaves other than the currently active slave, suppress
..	..	@@ -1194,7 +1513,7 @@
1194	1513	skb->dev = bond->dev;
1195	1514
1196	1515	if (BOND_MODE(bond) == BOND_MODE_ALB &&
1197		- bond->dev->priv_flags & IFF_BRIDGE_PORT &&
	1516	+ netif_is_bridge_port(bond->dev) &&
1198	1517	skb->pkt_type == PACKET_HOST) {
1199	1518
1200	1519	if (unlikely(skb_cow_head(skb,
..	..	@@ -1388,15 +1707,14 @@
1388	1707	if (!bond->params.use_carrier &&
1389	1708	slave_dev->ethtool_ops->get_link == NULL &&
1390	1709	slave_ops->ndo_do_ioctl == NULL) {
1391		- netdev_warn(bond_dev, "no link monitoring support for %s\n",
1392		- slave_dev->name);
	1710	+ slave_warn(bond_dev, slave_dev, "no link monitoring support\n");
1393	1711	}
1394	1712
1395	1713	/* already in-use? */
1396	1714	if (netdev_is_rx_handler_busy(slave_dev)) {
1397	1715	NL_SET_ERR_MSG(extack, "Device is in use and cannot be enslaved");
1398		- netdev_err(bond_dev,
1399		- "Error: Device is in use and cannot be enslaved\n");
	1716	+ slave_err(bond_dev, slave_dev,
	1717	+ "Error: Device is in use and cannot be enslaved\n");
1400	1718	return -EBUSY;
1401	1719	}
1402	1720
..	..	@@ -1409,22 +1727,20 @@
1409	1727	/* vlan challenged mutual exclusion */
1410	1728	/* no need to lock since we're protected by rtnl_lock */
1411	1729	if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) {
1412		- netdev_dbg(bond_dev, "%s is NETIF_F_VLAN_CHALLENGED\n",
1413		- slave_dev->name);
	1730	+ slave_dbg(bond_dev, slave_dev, "is NETIF_F_VLAN_CHALLENGED\n");
1414	1731	if (vlan_uses_dev(bond_dev)) {
1415	1732	NL_SET_ERR_MSG(extack, "Can not enslave VLAN challenged device to VLAN enabled bond");
1416		- netdev_err(bond_dev, "Error: cannot enslave VLAN challenged slave %s on VLAN enabled bond %s\n",
1417		- slave_dev->name, bond_dev->name);
	1733	+ slave_err(bond_dev, slave_dev, "Error: cannot enslave VLAN challenged slave on VLAN enabled bond\n");
1418	1734	return -EPERM;
1419	1735	} else {
1420		- netdev_warn(bond_dev, "enslaved VLAN challenged slave %s. Adding VLANs will be blocked as long as %s is part of bond %s\n",
1421		- slave_dev->name, slave_dev->name,
1422		- bond_dev->name);
	1736	+ slave_warn(bond_dev, slave_dev, "enslaved VLAN challenged slave. Adding VLANs will be blocked as long as it is part of bond.\n");
1423	1737	}
1424	1738	} else {
1425		- netdev_dbg(bond_dev, "%s is !NETIF_F_VLAN_CHALLENGED\n",
1426		- slave_dev->name);
	1739	+ slave_dbg(bond_dev, slave_dev, "is !NETIF_F_VLAN_CHALLENGED\n");
1427	1740	}
	1741	+
	1742	+ if (slave_dev->features & NETIF_F_HW_ESP)
	1743	+ slave_dbg(bond_dev, slave_dev, "is esp-hw-offload capable\n");
1428	1744
1429	1745	/* Old ifenslave binaries are no longer supported. These can
1430	1746	* be identified with moderate accuracy by the state of the slave:
..	..	@@ -1433,8 +1749,7 @@
1433	1749	*/
1434	1750	if (slave_dev->flags & IFF_UP) {
1435	1751	NL_SET_ERR_MSG(extack, "Device can not be enslaved while up");
1436		- netdev_err(bond_dev, "%s is up - this may be due to an out of date ifenslave\n",
1437		- slave_dev->name);
	1752	+ slave_err(bond_dev, slave_dev, "slave is up - this may be due to an out of date ifenslave\n");
1438	1753	return -EPERM;
1439	1754	}
1440	1755
..	..	@@ -1447,14 +1762,14 @@
1447	1762	*/
1448	1763	if (!bond_has_slaves(bond)) {
1449	1764	if (bond_dev->type != slave_dev->type) {
1450		- netdev_dbg(bond_dev, "change device type from %d to %d\n",
1451		- bond_dev->type, slave_dev->type);
	1765	+ slave_dbg(bond_dev, slave_dev, "change device type from %d to %d\n",
	1766	+ bond_dev->type, slave_dev->type);
1452	1767
1453	1768	res = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE,
1454	1769	bond_dev);
1455	1770	res = notifier_to_errno(res);
1456	1771	if (res) {
1457		- netdev_err(bond_dev, "refused to change device type\n");
	1772	+ slave_err(bond_dev, slave_dev, "refused to change device type\n");
1458	1773	return -EBUSY;
1459	1774	}
1460	1775
..	..	@@ -1474,31 +1789,31 @@
1474	1789	}
1475	1790	} else if (bond_dev->type != slave_dev->type) {
1476	1791	NL_SET_ERR_MSG(extack, "Device type is different from other slaves");
1477		- netdev_err(bond_dev, "%s ether type (%d) is different from other slaves (%d), can not enslave it\n",
1478		- slave_dev->name, slave_dev->type, bond_dev->type);
	1792	+ slave_err(bond_dev, slave_dev, "ether type (%d) is different from other slaves (%d), can not enslave it\n",
	1793	+ slave_dev->type, bond_dev->type);
1479	1794	return -EINVAL;
1480	1795	}
1481	1796
1482	1797	if (slave_dev->type == ARPHRD_INFINIBAND &&
1483	1798	BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) {
1484	1799	NL_SET_ERR_MSG(extack, "Only active-backup mode is supported for infiniband slaves");
1485		- netdev_warn(bond_dev, "Type (%d) supports only active-backup mode\n",
1486		- slave_dev->type);
	1800	+ slave_warn(bond_dev, slave_dev, "Type (%d) supports only active-backup mode\n",
	1801	+ slave_dev->type);
1487	1802	res = -EOPNOTSUPP;
1488	1803	goto err_undo_flags;
1489	1804	}
1490	1805
1491	1806	if (!slave_ops->ndo_set_mac_address \|\|
1492	1807	slave_dev->type == ARPHRD_INFINIBAND) {
1493		- netdev_warn(bond_dev, "The slave device specified does not support setting the MAC address\n");
	1808	+ slave_warn(bond_dev, slave_dev, "The slave device specified does not support setting the MAC address\n");
1494	1809	if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP &&
1495	1810	bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
1496	1811	if (!bond_has_slaves(bond)) {
1497	1812	bond->params.fail_over_mac = BOND_FOM_ACTIVE;
1498		- netdev_warn(bond_dev, "Setting fail_over_mac to active for active-backup mode\n");
	1813	+ slave_warn(bond_dev, slave_dev, "Setting fail_over_mac to active for active-backup mode\n");
1499	1814	} else {
1500	1815	NL_SET_ERR_MSG(extack, "Slave device does not support setting the MAC address, but fail_over_mac is not set to active");
1501		- netdev_err(bond_dev, "The slave device specified does not support setting the MAC address, but fail_over_mac is not set to active\n");
	1816	+ slave_err(bond_dev, slave_dev, "The slave device specified does not support setting the MAC address, but fail_over_mac is not set to active\n");
1502	1817	res = -EOPNOTSUPP;
1503	1818	goto err_undo_flags;
1504	1819	}
..	..	@@ -1511,8 +1826,11 @@
1511	1826	* address to be the same as the slave's.
1512	1827	*/
1513	1828	if (!bond_has_slaves(bond) &&
1514		- bond->dev->addr_assign_type == NET_ADDR_RANDOM)
1515		- bond_set_dev_addr(bond->dev, slave_dev);
	1829	+ bond->dev->addr_assign_type == NET_ADDR_RANDOM) {
	1830	+ res = bond_set_dev_addr(bond->dev, slave_dev);
	1831	+ if (res)
	1832	+ goto err_undo_flags;
	1833	+ }
1516	1834
1517	1835	new_slave = bond_alloc_slave(bond, slave_dev);
1518	1836	if (!new_slave) {
..	..	@@ -1529,7 +1847,7 @@
1529	1847	new_slave->original_mtu = slave_dev->mtu;
1530	1848	res = dev_set_mtu(slave_dev, bond->dev->mtu);
1531	1849	if (res) {
1532		- netdev_dbg(bond_dev, "Error %d calling dev_set_mtu\n", res);
	1850	+ slave_err(bond_dev, slave_dev, "Error %d calling dev_set_mtu\n", res);
1533	1851	goto err_free;
1534	1852	}
1535	1853
..	..	@@ -1547,9 +1865,10 @@
1547	1865	*/
1548	1866	memcpy(ss.__data, bond_dev->dev_addr, bond_dev->addr_len);
1549	1867	ss.ss_family = slave_dev->type;
1550		- res = dev_set_mac_address(slave_dev, (struct sockaddr *)&ss);
	1868	+ res = dev_set_mac_address(slave_dev, (struct sockaddr *)&ss,
	1869	+ extack);
1551	1870	if (res) {
1552		- netdev_dbg(bond_dev, "Error %d calling set_mac_address\n", res);
	1871	+ slave_err(bond_dev, slave_dev, "Error %d calling set_mac_address\n", res);
1553	1872	goto err_restore_mtu;
1554	1873	}
1555	1874	}
..	..	@@ -1558,9 +1877,9 @@
1558	1877	slave_dev->flags \|= IFF_SLAVE;
1559	1878
1560	1879	/* open the slave since the application closed it */
1561		- res = dev_open(slave_dev);
	1880	+ res = dev_open(slave_dev, extack);
1562	1881	if (res) {
1563		- netdev_dbg(bond_dev, "Opening slave %s failed\n", slave_dev->name);
	1882	+ slave_err(bond_dev, slave_dev, "Opening slave failed\n");
1564	1883	goto err_restore_mac;
1565	1884	}
1566	1885
..	..	@@ -1579,8 +1898,7 @@
1579	1898
1580	1899	res = vlan_vids_add_by_dev(slave_dev, bond_dev);
1581	1900	if (res) {
1582		- netdev_err(bond_dev, "Couldn't add bond vlan ids to %s\n",
1583		- slave_dev->name);
	1901	+ slave_err(bond_dev, slave_dev, "Couldn't add bond vlan ids\n");
1584	1902	goto err_close;
1585	1903	}
1586	1904
..	..	@@ -1610,12 +1928,10 @@
1610	1928	* supported); thus, we don't need to change
1611	1929	* the messages for netif_carrier.
1612	1930	*/
1613		- netdev_warn(bond_dev, "MII and ETHTOOL support not available for interface %s, and arp_interval/arp_ip_target module parameters not specified, thus bonding will not detect link failures! see bonding.txt for details\n",
1614		- slave_dev->name);
	1931	+ slave_warn(bond_dev, slave_dev, "MII and ETHTOOL support not available for slave, and arp_interval/arp_ip_target module parameters not specified, thus bonding will not detect link failures! see bonding.txt for details\n");
1615	1932	} else if (link_reporting == -1) {
1616	1933	/* unable get link status using mii/ethtool */
1617		- netdev_warn(bond_dev, "can't get link status from interface %s; the network driver associated with this interface does not support MII or ETHTOOL link status reporting, thus miimon has no effect on this interface\n",
1618		- slave_dev->name);
	1934	+ slave_warn(bond_dev, slave_dev, "can't get link status from slave; the network driver associated with this interface does not support MII or ETHTOOL link status reporting, thus miimon has no effect on this interface\n");
1619	1935	}
1620	1936	}
1621	1937
..	..	@@ -1649,9 +1965,9 @@
1649	1965
1650	1966	if (new_slave->link != BOND_LINK_DOWN)
1651	1967	new_slave->last_link_up = jiffies;
1652		- netdev_dbg(bond_dev, "Initial state of slave_dev is BOND_LINK_%s\n",
1653		- new_slave->link == BOND_LINK_DOWN ? "DOWN" :
1654		- (new_slave->link == BOND_LINK_UP ? "UP" : "BACK"));
	1968	+ slave_dbg(bond_dev, slave_dev, "Initial state of slave is BOND_LINK_%s\n",
	1969	+ new_slave->link == BOND_LINK_DOWN ? "DOWN" :
	1970	+ (new_slave->link == BOND_LINK_UP ? "UP" : "BACK"));
1655	1971
1656	1972	if (bond_uses_primary(bond) && bond->params.primary[0]) {
1657	1973	/* if there is a primary slave, remember it */
..	..	@@ -1692,7 +2008,7 @@
1692	2008	bond_set_slave_inactive_flags(new_slave, BOND_SLAVE_NOTIFY_NOW);
1693	2009	break;
1694	2010	default:
1695		- netdev_dbg(bond_dev, "This slave is always active in trunk mode\n");
	2011	+ slave_dbg(bond_dev, slave_dev, "This slave is always active in trunk mode\n");
1696	2012
1697	2013	/* always active in trunk mode */
1698	2014	bond_set_active_slave(new_slave);
..	..	@@ -1711,7 +2027,7 @@
1711	2027	#ifdef CONFIG_NET_POLL_CONTROLLER
1712	2028	if (bond->dev->npinfo) {
1713	2029	if (slave_enable_netpoll(new_slave)) {
1714		- netdev_info(bond_dev, "master_dev is using netpoll, but new slave device does not support netpoll\n");
	2030	+ slave_info(bond_dev, slave_dev, "master_dev is using netpoll, but new slave device does not support netpoll\n");
1715	2031	res = -EBUSY;
1716	2032	goto err_detach;
1717	2033	}
..	..	@@ -1724,23 +2040,21 @@
1724	2040	res = netdev_rx_handler_register(slave_dev, bond_handle_frame,
1725	2041	new_slave);
1726	2042	if (res) {
1727		- netdev_dbg(bond_dev, "Error %d calling netdev_rx_handler_register\n", res);
	2043	+ slave_dbg(bond_dev, slave_dev, "Error %d calling netdev_rx_handler_register\n", res);
1728	2044	goto err_detach;
1729	2045	}
1730	2046
1731	2047	res = bond_master_upper_dev_link(bond, new_slave, extack);
1732	2048	if (res) {
1733		- netdev_dbg(bond_dev, "Error %d calling bond_master_upper_dev_link\n", res);
	2049	+ slave_dbg(bond_dev, slave_dev, "Error %d calling bond_master_upper_dev_link\n", res);
1734	2050	goto err_unregister;
1735	2051	}
1736	2052
1737	2053	res = bond_sysfs_slave_add(new_slave);
1738	2054	if (res) {
1739		- netdev_dbg(bond_dev, "Error %d calling bond_sysfs_slave_add\n", res);
	2055	+ slave_dbg(bond_dev, slave_dev, "Error %d calling bond_sysfs_slave_add\n", res);
1740	2056	goto err_upper_unlink;
1741	2057	}
1742		-
1743		- bond->nest_level = dev_get_nest_level(bond_dev) + 1;
1744	2058
1745	2059	/* If the mode uses primary, then the following is handled by
1746	2060	* bond_change_active_slave().
..	..	@@ -1763,16 +2077,14 @@
1763	2077	}
1764	2078	}
1765	2079
1766		- netif_addr_lock_bh(bond_dev);
1767		- dev_mc_sync_multiple(slave_dev, bond_dev);
1768		- dev_uc_sync_multiple(slave_dev, bond_dev);
1769		- netif_addr_unlock_bh(bond_dev);
	2080	+ if (bond_dev->flags & IFF_UP) {
	2081	+ netif_addr_lock_bh(bond_dev);
	2082	+ dev_mc_sync_multiple(slave_dev, bond_dev);
	2083	+ dev_uc_sync_multiple(slave_dev, bond_dev);
	2084	+ netif_addr_unlock_bh(bond_dev);
1770	2085
1771		- if (BOND_MODE(bond) == BOND_MODE_8023AD) {
1772		- /* add lacpdu mc addr to mc list */
1773		- u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
1774		-
1775		- dev_mc_add(slave_dev, lacpdu_multicast);
	2086	+ if (BOND_MODE(bond) == BOND_MODE_8023AD)
	2087	+ dev_mc_add(slave_dev, lacpdu_mcast_addr);
1776	2088	}
1777	2089	}
1778	2090
..	..	@@ -1790,10 +2102,9 @@
1790	2102	bond_update_slave_arr(bond, NULL);
1791	2103
1792	2104
1793		- netdev_info(bond_dev, "Enslaving %s as %s interface with %s link\n",
1794		- slave_dev->name,
1795		- bond_is_active_slave(new_slave) ? "an active" : "a backup",
1796		- new_slave->link != BOND_LINK_DOWN ? "an up" : "a down");
	2105	+ slave_info(bond_dev, slave_dev, "Enslaving as %s interface with %s link\n",
	2106	+ bond_is_active_slave(new_slave) ? "an active" : "a backup",
	2107	+ new_slave->link != BOND_LINK_DOWN ? "an up" : "a down");
1797	2108
1798	2109	/* enslave is successful */
1799	2110	bond_queue_slave_event(new_slave);
..	..	@@ -1839,7 +2150,7 @@
1839	2150	bond_hw_addr_copy(ss.__data, new_slave->perm_hwaddr,
1840	2151	new_slave->dev->addr_len);
1841	2152	ss.ss_family = slave_dev->type;
1842		- dev_set_mac_address(slave_dev, (struct sockaddr *)&ss);
	2153	+ dev_set_mac_address(slave_dev, (struct sockaddr *)&ss, NULL);
1843	2154	}
1844	2155
1845	2156	err_restore_mtu:
..	..	@@ -1889,8 +2200,7 @@
1889	2200	/* slave is not a slave or master is not master of this slave */
1890	2201	if (!(slave_dev->flags & IFF_SLAVE) \|\|
1891	2202	!netdev_has_upper_dev(slave_dev, bond_dev)) {
1892		- netdev_dbg(bond_dev, "cannot release %s\n",
1893		- slave_dev->name);
	2203	+ slave_dbg(bond_dev, slave_dev, "cannot release slave\n");
1894	2204	return -EINVAL;
1895	2205	}
1896	2206
..	..	@@ -1899,8 +2209,7 @@
1899	2209	slave = bond_get_slave_by_dev(bond, slave_dev);
1900	2210	if (!slave) {
1901	2211	/* not a slave of this bond */
1902		- netdev_info(bond_dev, "%s not enslaved\n",
1903		- slave_dev->name);
	2212	+ slave_info(bond_dev, slave_dev, "interface not enslaved\n");
1904	2213	unblock_netpoll_tx();
1905	2214	return -EINVAL;
1906	2215	}
..	..	@@ -1925,9 +2234,8 @@
1925	2234	if (bond_mode_can_use_xmit_hash(bond))
1926	2235	bond_update_slave_arr(bond, slave);
1927	2236
1928		- netdev_info(bond_dev, "Releasing %s interface %s\n",
1929		- bond_is_active_slave(slave) ? "active" : "backup",
1930		- slave_dev->name);
	2237	+ slave_info(bond_dev, slave_dev, "Releasing %s interface\n",
	2238	+ bond_is_active_slave(slave) ? "active" : "backup");
1931	2239
1932	2240	oldcurrent = rcu_access_pointer(bond->curr_active_slave);
1933	2241
..	..	@@ -1937,9 +2245,8 @@
1937	2245	BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP)) {
1938	2246	if (ether_addr_equal_64bits(bond_dev->dev_addr, slave->perm_hwaddr) &&
1939	2247	bond_has_slaves(bond))
1940		- netdev_warn(bond_dev, "the permanent HWaddr of %s - %pM - is still in use by %s - set the HWaddr of %s to a different address to avoid conflicts\n",
1941		- slave_dev->name, slave->perm_hwaddr,
1942		- bond_dev->name, slave_dev->name);
	2248	+ slave_warn(bond_dev, slave_dev, "the permanent HWaddr of slave - %pM - is still in use by bond - set the HWaddr of slave to a different address to avoid conflicts\n",
	2249	+ slave->perm_hwaddr);
1943	2250	}
1944	2251
1945	2252	if (rtnl_dereference(bond->primary_slave) == slave)
..	..	@@ -1967,13 +2274,9 @@
1967	2274	bond_select_active_slave(bond);
1968	2275	}
1969	2276
1970		- if (!bond_has_slaves(bond)) {
1971		- bond_set_carrier(bond);
	2277	+ bond_set_carrier(bond);
	2278	+ if (!bond_has_slaves(bond))
1972	2279	eth_hw_addr_random(bond_dev);
1973		- bond->nest_level = SINGLE_DEPTH_NESTING;
1974		- } else {
1975		- bond->nest_level = dev_get_nest_level(bond_dev) + 1;
1976		- }
1977	2280
1978	2281	unblock_netpoll_tx();
1979	2282	synchronize_rcu();
..	..	@@ -1987,8 +2290,7 @@
1987	2290	bond_compute_features(bond);
1988	2291	if (!(bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
1989	2292	(old_features & NETIF_F_VLAN_CHALLENGED))
1990		- netdev_info(bond_dev, "last VLAN challenged slave %s left bond %s - VLAN blocking is removed\n",
1991		- slave_dev->name, bond_dev->name);
	2293	+ slave_info(bond_dev, slave_dev, "last VLAN challenged slave left bond - VLAN blocking is removed\n");
1992	2294
1993	2295	vlan_vids_del_by_dev(slave_dev, bond_dev);
1994	2296
..	..	@@ -2010,7 +2312,8 @@
2010	2312	if (old_flags & IFF_ALLMULTI)
2011	2313	dev_set_allmulti(slave_dev, -1);
2012	2314
2013		- bond_hw_addr_flush(bond_dev, slave_dev);
	2315	+ if (old_flags & IFF_UP)
	2316	+ bond_hw_addr_flush(bond_dev, slave_dev);
2014	2317	}
2015	2318
2016	2319	slave_disable_netpoll(slave);
..	..	@@ -2024,7 +2327,7 @@
2024	2327	bond_hw_addr_copy(ss.__data, slave->perm_hwaddr,
2025	2328	slave->dev->addr_len);
2026	2329	ss.ss_family = slave_dev->type;
2027		- dev_set_mac_address(slave_dev, (struct sockaddr *)&ss);
	2330	+ dev_set_mac_address(slave_dev, (struct sockaddr *)&ss, NULL);
2028	2331	}
2029	2332
2030	2333	if (unregister)
..	..	@@ -2049,8 +2352,8 @@
2049	2352	/* First release a slave and then destroy the bond if no more slaves are left.
2050	2353	* Must be under rtnl_lock when this function is called.
2051	2354	*/
2052		-static int bond_release_and_destroy(struct net_device *bond_dev,
2053		- struct net_device *slave_dev)
	2355	+static int bond_release_and_destroy(struct net_device *bond_dev,
	2356	+ struct net_device *slave_dev)
2054	2357	{
2055	2358	struct bonding *bond = netdev_priv(bond_dev);
2056	2359	int ret;
..	..	@@ -2059,8 +2362,7 @@
2059	2362	if (ret == 0 && !bond_has_slaves(bond) &&
2060	2363	bond_dev->reg_state != NETREG_UNREGISTERING) {
2061	2364	bond_dev->priv_flags \|= IFF_DISABLE_NETPOLL;
2062		- netdev_info(bond_dev, "Destroying bond %s\n",
2063		- bond_dev->name);
	2365	+ netdev_info(bond_dev, "Destroying bond\n");
2064	2366	bond_remove_proc_entry(bond);
2065	2367	unregister_netdevice(bond_dev);
2066	2368	}
..	..	@@ -2096,12 +2398,21 @@
2096	2398	/* called with rcu_read_lock() */
2097	2399	static int bond_miimon_inspect(struct bonding *bond)
2098	2400	{
	2401	+ bool ignore_updelay = false;
2099	2402	int link_state, commit = 0;
2100	2403	struct list_head *iter;
2101	2404	struct slave *slave;
2102		- bool ignore_updelay;
2103	2405
2104		- ignore_updelay = !rcu_dereference(bond->curr_active_slave);
	2406	+ if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) {
	2407	+ ignore_updelay = !rcu_dereference(bond->curr_active_slave);
	2408	+ } else {
	2409	+ struct bond_up_slave *usable_slaves;
	2410	+
	2411	+ usable_slaves = rcu_dereference(bond->usable_slaves);
	2412	+
	2413	+ if (usable_slaves && usable_slaves->count == 0)
	2414	+ ignore_updelay = true;
	2415	+ }
2105	2416
2106	2417	bond_for_each_slave_rcu(bond, slave, iter) {
2107	2418	bond_propose_link_state(slave, BOND_LINK_NOCHANGE);
..	..	@@ -2117,24 +2428,22 @@
2117	2428	commit++;
2118	2429	slave->delay = bond->params.downdelay;
2119	2430	if (slave->delay) {
2120		- netdev_info(bond->dev, "link status down for %sinterface %s, disabling it in %d ms\n",
2121		- (BOND_MODE(bond) ==
2122		- BOND_MODE_ACTIVEBACKUP) ?
2123		- (bond_is_active_slave(slave) ?
2124		- "active " : "backup ") : "",
2125		- slave->dev->name,
2126		- bond->params.downdelay * bond->params.miimon);
	2431	+ slave_info(bond->dev, slave->dev, "link status down for %sinterface, disabling it in %d ms\n",
	2432	+ (BOND_MODE(bond) ==
	2433	+ BOND_MODE_ACTIVEBACKUP) ?
	2434	+ (bond_is_active_slave(slave) ?
	2435	+ "active " : "backup ") : "",
	2436	+ bond->params.downdelay * bond->params.miimon);
2127	2437	}
2128		- /FALLTHRU/
	2438	+ fallthrough;
2129	2439	case BOND_LINK_FAIL:
2130	2440	if (link_state) {
2131	2441	/* recovered before downdelay expired */
2132	2442	bond_propose_link_state(slave, BOND_LINK_UP);
2133	2443	slave->last_link_up = jiffies;
2134		- netdev_info(bond->dev, "link status up again after %d ms for interface %s\n",
2135		- (bond->params.downdelay - slave->delay) *
2136		- bond->params.miimon,
2137		- slave->dev->name);
	2444	+ slave_info(bond->dev, slave->dev, "link status up again after %d ms\n",
	2445	+ (bond->params.downdelay - slave->delay) *
	2446	+ bond->params.miimon);
2138	2447	commit++;
2139	2448	continue;
2140	2449	}
..	..	@@ -2157,20 +2466,18 @@
2157	2466	slave->delay = bond->params.updelay;
2158	2467
2159	2468	if (slave->delay) {
2160		- netdev_info(bond->dev, "link status up for interface %s, enabling it in %d ms\n",
2161		- slave->dev->name,
2162		- ignore_updelay ? 0 :
2163		- bond->params.updelay *
2164		- bond->params.miimon);
	2469	+ slave_info(bond->dev, slave->dev, "link status up, enabling it in %d ms\n",
	2470	+ ignore_updelay ? 0 :
	2471	+ bond->params.updelay *
	2472	+ bond->params.miimon);
2165	2473	}
2166		- /FALLTHRU/
	2474	+ fallthrough;
2167	2475	case BOND_LINK_BACK:
2168	2476	if (!link_state) {
2169	2477	bond_propose_link_state(slave, BOND_LINK_DOWN);
2170		- netdev_info(bond->dev, "link status down again after %d ms for interface %s\n",
2171		- (bond->params.updelay - slave->delay) *
2172		- bond->params.miimon,
2173		- slave->dev->name);
	2478	+ slave_info(bond->dev, slave->dev, "link status down again after %d ms\n",
	2479	+ (bond->params.updelay - slave->delay) *
	2480	+ bond->params.miimon);
2174	2481	commit++;
2175	2482	continue;
2176	2483	}
..	..	@@ -2235,9 +2542,8 @@
2235	2542	bond_needs_speed_duplex(bond)) {
2236	2543	slave->link = BOND_LINK_DOWN;
2237	2544	if (net_ratelimit())
2238		- netdev_warn(bond->dev,
2239		- "failed to get link speed/duplex for %s\n",
2240		- slave->dev->name);
	2545	+ slave_warn(bond->dev, slave->dev,
	2546	+ "failed to get link speed/duplex\n");
2241	2547	continue;
2242	2548	}
2243	2549	bond_set_slave_link_state(slave, BOND_LINK_UP,
..	..	@@ -2253,10 +2559,9 @@
2253	2559	bond_set_active_slave(slave);
2254	2560	}
2255	2561
2256		- netdev_info(bond->dev, "link status definitely up for interface %s, %u Mbps %s duplex\n",
2257		- slave->dev->name,
2258		- slave->speed == SPEED_UNKNOWN ? 0 : slave->speed,
2259		- slave->duplex ? "full" : "half");
	2562	+ slave_info(bond->dev, slave->dev, "link status definitely up, %u Mbps %s duplex\n",
	2563	+ slave->speed == SPEED_UNKNOWN ? 0 : slave->speed,
	2564	+ slave->duplex ? "full" : "half");
2260	2565
2261	2566	bond_miimon_link_change(bond, slave, BOND_LINK_UP);
2262	2567
..	..	@@ -2277,8 +2582,7 @@
2277	2582	bond_set_slave_inactive_flags(slave,
2278	2583	BOND_SLAVE_NOTIFY_NOW);
2279	2584
2280		- netdev_info(bond->dev, "link status definitely down for interface %s, disabling it\n",
2281		- slave->dev->name);
	2585	+ slave_info(bond->dev, slave->dev, "link status definitely down, disabling slave\n");
2282	2586
2283	2587	bond_miimon_link_change(bond, slave, BOND_LINK_DOWN);
2284	2588
..	..	@@ -2288,8 +2592,8 @@
2288	2592	continue;
2289	2593
2290	2594	default:
2291		- netdev_err(bond->dev, "invalid new link %d on slave %s\n",
2292		- slave->link_new_state, slave->dev->name);
	2595	+ slave_err(bond->dev, slave->dev, "invalid new link %d on slave\n",
	2596	+ slave->link_new_state);
2293	2597	bond_propose_link_state(slave, BOND_LINK_NOCHANGE);
2294	2598
2295	2599	continue;
..	..	@@ -2316,6 +2620,7 @@
2316	2620	struct bonding *bond = container_of(work, struct bonding,
2317	2621	mii_work.work);
2318	2622	bool should_notify_peers = false;
	2623	+ bool commit;
2319	2624	unsigned long delay;
2320	2625	struct slave *slave;
2321	2626	struct list_head *iter;
..	..	@@ -2326,12 +2631,19 @@
2326	2631	goto re_arm;
2327	2632
2328	2633	rcu_read_lock();
2329		-
2330	2634	should_notify_peers = bond_should_notify_peers(bond);
2331		-
2332		- if (bond_miimon_inspect(bond)) {
	2635	+ commit = !!bond_miimon_inspect(bond);
	2636	+ if (bond->send_peer_notif) {
2333	2637	rcu_read_unlock();
	2638	+ if (rtnl_trylock()) {
	2639	+ bond->send_peer_notif--;
	2640	+ rtnl_unlock();
	2641	+ }
	2642	+ } else {
	2643	+ rcu_read_unlock();
	2644	+ }
2334	2645
	2646	+ if (commit) {
2335	2647	/* Race avoidance with bond_close cancel of workqueue */
2336	2648	if (!rtnl_trylock()) {
2337	2649	delay = 1;
..	..	@@ -2345,8 +2657,7 @@
2345	2657	bond_miimon_commit(bond);
2346	2658
2347	2659	rtnl_unlock(); /* might sleep, hold no other locks */
2348		- } else
2349		- rcu_read_unlock();
	2660	+ }
2350	2661
2351	2662	re_arm:
2352	2663	if (bond->params.miimon)
..	..	@@ -2360,22 +2671,26 @@
2360	2671	}
2361	2672	}
2362	2673
2363		-static int bond_upper_dev_walk(struct net_device upper, void data)
	2674	+static int bond_upper_dev_walk(struct net_device *upper,
	2675	+ struct netdev_nested_priv *priv)
2364	2676	{
2365		- __be32 ip = ((__be32 )data);
	2677	+ __be32 ip = (__be32 )priv->data;
2366	2678
2367	2679	return ip == bond_confirm_addr(upper, 0, ip);
2368	2680	}
2369	2681
2370	2682	static bool bond_has_this_ip(struct bonding *bond, __be32 ip)
2371	2683	{
	2684	+ struct netdev_nested_priv priv = {
	2685	+ .data = (void *)&ip,
	2686	+ };
2372	2687	bool ret = false;
2373	2688
2374	2689	if (ip == bond_confirm_addr(bond->dev, 0, ip))
2375	2690	return true;
2376	2691
2377	2692	rcu_read_lock();
2378		- if (netdev_walk_all_upper_dev_rcu(bond->dev, bond_upper_dev_walk, &ip))
	2693	+ if (netdev_walk_all_upper_dev_rcu(bond->dev, bond_upper_dev_walk, &priv))
2379	2694	ret = true;
2380	2695	rcu_read_unlock();
2381	2696
..	..	@@ -2386,15 +2701,16 @@
2386	2701	* switches in VLAN mode (especially if ports are configured as
2387	2702	* "native" to a VLAN) might not pass non-tagged frames.
2388	2703	*/
2389		-static void bond_arp_send(struct net_device *slave_dev, int arp_op,
2390		- __be32 dest_ip, __be32 src_ip,
2391		- struct bond_vlan_tag *tags)
	2704	+static void bond_arp_send(struct slave *slave, int arp_op, __be32 dest_ip,
	2705	+ __be32 src_ip, struct bond_vlan_tag *tags)
2392	2706	{
2393	2707	struct sk_buff *skb;
2394	2708	struct bond_vlan_tag *outer_tag = tags;
	2709	+ struct net_device *slave_dev = slave->dev;
	2710	+ struct net_device *bond_dev = slave->bond->dev;
2395	2711
2396		- netdev_dbg(slave_dev, "arp %d on slave %s: dst %pI4 src %pI4\n",
2397		- arp_op, slave_dev->name, &dest_ip, &src_ip);
	2712	+ slave_dbg(bond_dev, slave_dev, "arp %d on slave: dst %pI4 src %pI4\n",
	2713	+ arp_op, &dest_ip, &src_ip);
2398	2714
2399	2715	skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip,
2400	2716	NULL, slave_dev->dev_addr, NULL);
..	..	@@ -2416,8 +2732,8 @@
2416	2732	continue;
2417	2733	}
2418	2734
2419		- netdev_dbg(slave_dev, "inner tag: proto %X vid %X\n",
2420		- ntohs(outer_tag->vlan_proto), tags->vlan_id);
	2735	+ slave_dbg(bond_dev, slave_dev, "inner tag: proto %X vid %X\n",
	2736	+ ntohs(outer_tag->vlan_proto), tags->vlan_id);
2421	2737	skb = vlan_insert_tag_set_proto(skb, tags->vlan_proto,
2422	2738	tags->vlan_id);
2423	2739	if (!skb) {
..	..	@@ -2429,8 +2745,8 @@
2429	2745	}
2430	2746	/* Set the outer tag */
2431	2747	if (outer_tag->vlan_id) {
2432		- netdev_dbg(slave_dev, "outer tag: proto %X vid %X\n",
2433		- ntohs(outer_tag->vlan_proto), outer_tag->vlan_id);
	2748	+ slave_dbg(bond_dev, slave_dev, "outer tag: proto %X vid %X\n",
	2749	+ ntohs(outer_tag->vlan_proto), outer_tag->vlan_id);
2434	2750	__vlan_hwaccel_put_tag(skb, outer_tag->vlan_proto,
2435	2751	outer_tag->vlan_id);
2436	2752	}
..	..	@@ -2487,7 +2803,8 @@
2487	2803	int i;
2488	2804
2489	2805	for (i = 0; i < BOND_MAX_ARP_TARGETS && targets[i]; i++) {
2490		- netdev_dbg(bond->dev, "basa: target %pI4\n", &targets[i]);
	2806	+ slave_dbg(bond->dev, slave->dev, "%s: target %pI4\n",
	2807	+ __func__, &targets[i]);
2491	2808	tags = NULL;
2492	2809
2493	2810	/* Find out through which dev should the packet go */
..	..	@@ -2501,7 +2818,7 @@
2501	2818	net_warn_ratelimited("%s: no route to arp_ip_target %pI4 and arp_validate is set\n",
2502	2819	bond->dev->name,
2503	2820	&targets[i]);
2504		- bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
	2821	+ bond_arp_send(slave, ARPOP_REQUEST, targets[i],
2505	2822	0, tags);
2506	2823	continue;
2507	2824	}
..	..	@@ -2518,7 +2835,7 @@
2518	2835	goto found;
2519	2836
2520	2837	/* Not our device - skip */
2521		- netdev_dbg(bond->dev, "no path to arp_ip_target %pI4 via rt.dev %s\n",
	2838	+ slave_dbg(bond->dev, slave->dev, "no path to arp_ip_target %pI4 via rt.dev %s\n",
2522	2839	&targets[i], rt->dst.dev ? rt->dst.dev->name : "NULL");
2523	2840
2524	2841	ip_rt_put(rt);
..	..	@@ -2527,8 +2844,7 @@
2527	2844	found:
2528	2845	addr = bond_confirm_addr(rt->dst.dev, targets[i], 0);
2529	2846	ip_rt_put(rt);
2530		- bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
2531		- addr, tags);
	2847	+ bond_arp_send(slave, ARPOP_REQUEST, targets[i], addr, tags);
2532	2848	kfree(tags);
2533	2849	}
2534	2850	}
..	..	@@ -2538,15 +2854,15 @@
2538	2854	int i;
2539	2855
2540	2856	if (!sip \|\| !bond_has_this_ip(bond, tip)) {
2541		- netdev_dbg(bond->dev, "bva: sip %pI4 tip %pI4 not found\n",
2542		- &sip, &tip);
	2857	+ slave_dbg(bond->dev, slave->dev, "%s: sip %pI4 tip %pI4 not found\n",
	2858	+ __func__, &sip, &tip);
2543	2859	return;
2544	2860	}
2545	2861
2546	2862	i = bond_get_targets_ip(bond->params.arp_targets, sip);
2547	2863	if (i == -1) {
2548		- netdev_dbg(bond->dev, "bva: sip %pI4 not found in targets\n",
2549		- &sip);
	2864	+ slave_dbg(bond->dev, slave->dev, "%s: sip %pI4 not found in targets\n",
	2865	+ __func__, &sip);
2550	2866	return;
2551	2867	}
2552	2868	slave->last_rx = jiffies;
..	..	@@ -2574,8 +2890,8 @@
2574	2890
2575	2891	alen = arp_hdr_len(bond->dev);
2576	2892
2577		- netdev_dbg(bond->dev, "bond_arp_rcv: skb->dev %s\n",
2578		- skb->dev->name);
	2893	+ slave_dbg(bond->dev, slave->dev, "%s: skb->dev %s\n",
	2894	+ __func__, skb->dev->name);
2579	2895
2580	2896	if (alen > skb_headlen(skb)) {
2581	2897	arp = kmalloc(alen, GFP_ATOMIC);
..	..	@@ -2599,10 +2915,10 @@
2599	2915	arp_ptr += 4 + bond->dev->addr_len;
2600	2916	memcpy(&tip, arp_ptr, 4);
2601	2917
2602		- netdev_dbg(bond->dev, "bond_arp_rcv: %s/%d av %d sv %d sip %pI4 tip %pI4\n",
2603		- slave->dev->name, bond_slave_state(slave),
2604		- bond->params.arp_validate, slave_do_arp_validate(bond, slave),
2605		- &sip, &tip);
	2918	+ slave_dbg(bond->dev, slave->dev, "%s: %s/%d av %d sv %d sip %pI4 tip %pI4\n",
	2919	+ __func__, slave->dev->name, bond_slave_state(slave),
	2920	+ bond->params.arp_validate, slave_do_arp_validate(bond, slave),
	2921	+ &sip, &tip);
2606	2922
2607	2923	curr_active_slave = rcu_dereference(bond->curr_active_slave);
2608	2924	curr_arp_slave = rcu_dereference(bond->current_arp_slave);
..	..	@@ -2705,12 +3021,10 @@
2705	3021	* is closed.
2706	3022	*/
2707	3023	if (!oldcurrent) {
2708		- netdev_info(bond->dev, "link status definitely up for interface %s\n",
2709		- slave->dev->name);
	3024	+ slave_info(bond->dev, slave->dev, "link status definitely up\n");
2710	3025	do_failover = 1;
2711	3026	} else {
2712		- netdev_info(bond->dev, "interface %s is now up\n",
2713		- slave->dev->name);
	3027	+ slave_info(bond->dev, slave->dev, "interface is now up\n");
2714	3028	}
2715	3029	}
2716	3030	} else {
..	..	@@ -2729,8 +3043,7 @@
2729	3043	if (slave->link_failure_count < UINT_MAX)
2730	3044	slave->link_failure_count++;
2731	3045
2732		- netdev_info(bond->dev, "interface %s is now down\n",
2733		- slave->dev->name);
	3046	+ slave_info(bond->dev, slave->dev, "interface is now down\n");
2734	3047
2735	3048	if (slave == oldcurrent)
2736	3049	do_failover = 1;
..	..	@@ -2883,8 +3196,7 @@
2883	3196	RCU_INIT_POINTER(bond->current_arp_slave, NULL);
2884	3197	}
2885	3198
2886		- netdev_info(bond->dev, "link status definitely up for interface %s\n",
2887		- slave->dev->name);
	3199	+ slave_info(bond->dev, slave->dev, "link status definitely up\n");
2888	3200
2889	3201	if (!rtnl_dereference(bond->curr_active_slave) \|\|
2890	3202	slave == rtnl_dereference(bond->primary_slave))
..	..	@@ -2903,8 +3215,7 @@
2903	3215	bond_set_slave_inactive_flags(slave,
2904	3216	BOND_SLAVE_NOTIFY_NOW);
2905	3217
2906		- netdev_info(bond->dev, "link status definitely down for interface %s, disabling it\n",
2907		- slave->dev->name);
	3218	+ slave_info(bond->dev, slave->dev, "link status definitely down, disabling slave\n");
2908	3219
2909	3220	if (slave == rtnl_dereference(bond->curr_active_slave)) {
2910	3221	RCU_INIT_POINTER(bond->current_arp_slave, NULL);
..	..	@@ -2927,8 +3238,9 @@
2927	3238	continue;
2928	3239
2929	3240	default:
2930		- netdev_err(bond->dev, "impossible: new_link %d on slave %s\n",
2931		- slave->link_new_state, slave->dev->name);
	3241	+ slave_err(bond->dev, slave->dev,
	3242	+ "impossible: link_new_state %d on slave\n",
	3243	+ slave->link_new_state);
2932	3244	continue;
2933	3245	}
2934	3246
..	..	@@ -2997,8 +3309,7 @@
2997	3309	bond_set_slave_inactive_flags(slave,
2998	3310	BOND_SLAVE_NOTIFY_LATER);
2999	3311
3000		- netdev_info(bond->dev, "backup interface %s is now down\n",
3001		- slave->dev->name);
	3312	+ slave_info(bond->dev, slave->dev, "backup interface is now down\n");
3002	3313	}
3003	3314	if (slave == curr_arp_slave)
3004	3315	found = true;
..	..	@@ -3069,9 +3380,11 @@
3069	3380	if (!rtnl_trylock())
3070	3381	return;
3071	3382
3072		- if (should_notify_peers)
	3383	+ if (should_notify_peers) {
	3384	+ bond->send_peer_notif--;
3073	3385	call_netdevice_notifiers(NETDEV_NOTIFY_PEERS,
3074	3386	bond->dev);
	3387	+ }
3075	3388	if (should_notify_rtnl) {
3076	3389	bond_slave_state_notify(bond);
3077	3390	bond_slave_link_notify(bond);
..	..	@@ -3110,18 +3423,19 @@
3110	3423	{
3111	3424	struct bonding *event_bond = netdev_priv(bond_dev);
3112	3425
	3426	+ netdev_dbg(bond_dev, "%s called\n", __func__);
	3427	+
3113	3428	switch (event) {
3114	3429	case NETDEV_CHANGENAME:
3115	3430	return bond_event_changename(event_bond);
3116	3431	case NETDEV_UNREGISTER:
3117	3432	bond_remove_proc_entry(event_bond);
	3433	+#ifdef CONFIG_XFRM_OFFLOAD
	3434	+ xfrm_dev_state_flush(dev_net(bond_dev), bond_dev, true);
	3435	+#endif /* CONFIG_XFRM_OFFLOAD */
3118	3436	break;
3119	3437	case NETDEV_REGISTER:
3120	3438	bond_create_proc_entry(event_bond);
3121		- break;
3122		- case NETDEV_NOTIFY_PEERS:
3123		- if (event_bond->send_peer_notif)
3124		- event_bond->send_peer_notif--;
3125	3439	break;
3126	3440	default:
3127	3441	break;
..	..	@@ -3141,11 +3455,16 @@
3141	3455	* before netdev_rx_handler_register is called in which case
3142	3456	* slave will be NULL
3143	3457	*/
3144		- if (!slave)
	3458	+ if (!slave) {
	3459	+ netdev_dbg(slave_dev, "%s called on NULL slave\n", __func__);
3145	3460	return NOTIFY_DONE;
	3461	+ }
	3462	+
3146	3463	bond_dev = slave->bond->dev;
3147	3464	bond = slave->bond;
3148	3465	primary = rtnl_dereference(bond->primary_slave);
	3466	+
	3467	+ slave_dbg(bond_dev, slave_dev, "%s called\n", __func__);
3149	3468
3150	3469	switch (event) {
3151	3470	case NETDEV_UNREGISTER:
..	..	@@ -3173,7 +3492,7 @@
3173	3492
3174	3493	if (BOND_MODE(bond) == BOND_MODE_8023AD)
3175	3494	bond_3ad_adapter_speed_duplex_changed(slave);
3176		- /* Fallthrough */
	3495	+ fallthrough;
3177	3496	case NETDEV_DOWN:
3178	3497	/* Refresh slave-array if applicable!
3179	3498	* If the setup does not use miimon or arpmon (mode-specific!),
..	..	@@ -3223,7 +3542,11 @@
3223	3542	unblock_netpoll_tx();
3224	3543	break;
3225	3544	case NETDEV_FEAT_CHANGE:
3226		- bond_compute_features(bond);
	3545	+ if (!bond->notifier_ctx) {
	3546	+ bond->notifier_ctx = true;
	3547	+ bond_compute_features(bond);
	3548	+ bond->notifier_ctx = false;
	3549	+ }
3227	3550	break;
3228	3551	case NETDEV_RESEND_IGMP:
3229	3552	/* Propagate to master device */
..	..	@@ -3248,7 +3571,8 @@
3248	3571	{
3249	3572	struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
3250	3573
3251		- netdev_dbg(event_dev, "event: %lx\n", event);
	3574	+ netdev_dbg(event_dev, "%s received %s\n",
	3575	+ __func__, netdev_cmd_to_name(event));
3252	3576
3253	3577	if (!(event_dev->priv_flags & IFF_BONDING))
3254	3578	return NOTIFY_DONE;
..	..	@@ -3256,16 +3580,13 @@
3256	3580	if (event_dev->flags & IFF_MASTER) {
3257	3581	int ret;
3258	3582
3259		- netdev_dbg(event_dev, "IFF_MASTER\n");
3260	3583	ret = bond_master_netdev_event(event, event_dev);
3261	3584	if (ret != NOTIFY_DONE)
3262	3585	return ret;
3263	3586	}
3264	3587
3265		- if (event_dev->flags & IFF_SLAVE) {
3266		- netdev_dbg(event_dev, "IFF_SLAVE\n");
	3588	+ if (event_dev->flags & IFF_SLAVE)
3267	3589	return bond_slave_netdev_event(event, event_dev);
3268		- }
3269	3590
3270	3591	return NOTIFY_DONE;
3271	3592	}
..	..	@@ -3287,39 +3608,78 @@
3287	3608	return 0;
3288	3609	}
3289	3610
	3611	+static bool bond_flow_ip(struct sk_buff skb, struct flow_keys fk,
	3612	+ int noff, int proto, bool l34)
	3613	+{
	3614	+ const struct ipv6hdr *iph6;
	3615	+ const struct iphdr *iph;
	3616	+
	3617	+ if (skb->protocol == htons(ETH_P_IP)) {
	3618	+ if (unlikely(!pskb_may_pull(skb, noff + sizeof(iph))))
	3619	+ return false;
	3620	+ iph = (const struct iphdr )(skb->data + noff);
	3621	+ iph_to_flow_copy_v4addrs(fk, iph);
	3622	+ *noff += iph->ihl << 2;
	3623	+ if (!ip_is_fragment(iph))
	3624	+ *proto = iph->protocol;
	3625	+ } else if (skb->protocol == htons(ETH_P_IPV6)) {
	3626	+ if (unlikely(!pskb_may_pull(skb, noff + sizeof(iph6))))
	3627	+ return false;
	3628	+ iph6 = (const struct ipv6hdr )(skb->data + noff);
	3629	+ iph_to_flow_copy_v6addrs(fk, iph6);
	3630	+ noff += sizeof(iph6);
	3631	+ *proto = iph6->nexthdr;
	3632	+ } else {
	3633	+ return false;
	3634	+ }
	3635	+
	3636	+ if (l34 && *proto >= 0)
	3637	+ fk->ports.ports = skb_flow_get_ports(skb, noff, proto);
	3638	+
	3639	+ return true;
	3640	+}
	3641	+
3290	3642	/* Extract the appropriate headers based on bond's xmit policy */
3291	3643	static bool bond_flow_dissect(struct bonding bond, struct sk_buff skb,
3292	3644	struct flow_keys *fk)
3293	3645	{
3294		- const struct ipv6hdr *iph6;
3295		- const struct iphdr *iph;
	3646	+ bool l34 = bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34;
3296	3647	int noff, proto = -1;
3297	3648
3298		- if (bond->params.xmit_policy > BOND_XMIT_POLICY_LAYER23)
3299		- return skb_flow_dissect_flow_keys(skb, fk, 0);
	3649	+ if (bond->params.xmit_policy > BOND_XMIT_POLICY_LAYER23) {
	3650	+ memset(fk, 0, sizeof(*fk));
	3651	+ return __skb_flow_dissect(NULL, skb, &flow_keys_bonding,
	3652	+ fk, NULL, 0, 0, 0, 0);
	3653	+ }
3300	3654
3301	3655	fk->ports.ports = 0;
	3656	+ memset(&fk->icmp, 0, sizeof(fk->icmp));
3302	3657	noff = skb_network_offset(skb);
3303		- if (skb->protocol == htons(ETH_P_IP)) {
3304		- if (unlikely(!pskb_may_pull(skb, noff + sizeof(*iph))))
3305		- return false;
3306		- iph = ip_hdr(skb);
3307		- iph_to_flow_copy_v4addrs(fk, iph);
3308		- noff += iph->ihl << 2;
3309		- if (!ip_is_fragment(iph))
3310		- proto = iph->protocol;
3311		- } else if (skb->protocol == htons(ETH_P_IPV6)) {
3312		- if (unlikely(!pskb_may_pull(skb, noff + sizeof(*iph6))))
3313		- return false;
3314		- iph6 = ipv6_hdr(skb);
3315		- iph_to_flow_copy_v6addrs(fk, iph6);
3316		- noff += sizeof(*iph6);
3317		- proto = iph6->nexthdr;
3318		- } else {
	3658	+ if (!bond_flow_ip(skb, fk, &noff, &proto, l34))
3319	3659	return false;
	3660	+
	3661	+ /* ICMP error packets contains at least 8 bytes of the header
	3662	+ * of the packet which generated the error. Use this information
	3663	+ * to correlate ICMP error packets within the same flow which
	3664	+ * generated the error.
	3665	+ */
	3666	+ if (proto == IPPROTO_ICMP \|\| proto == IPPROTO_ICMPV6) {
	3667	+ skb_flow_get_icmp_tci(skb, &fk->icmp, skb->data,
	3668	+ skb_transport_offset(skb),
	3669	+ skb_headlen(skb));
	3670	+ if (proto == IPPROTO_ICMP) {
	3671	+ if (!icmp_is_err(fk->icmp.type))
	3672	+ return true;
	3673	+
	3674	+ noff += sizeof(struct icmphdr);
	3675	+ } else if (proto == IPPROTO_ICMPV6) {
	3676	+ if (!icmpv6_is_err(fk->icmp.type))
	3677	+ return true;
	3678	+
	3679	+ noff += sizeof(struct icmp6hdr);
	3680	+ }
	3681	+ return bond_flow_ip(skb, fk, &noff, &proto, l34);
3320	3682	}
3321		- if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34 && proto >= 0)
3322		- fk->ports.ports = skb_flow_get_ports(skb, noff, proto);
3323	3683
3324	3684	return true;
3325	3685	}
..	..	@@ -3346,10 +3706,14 @@
3346	3706	return bond_eth_hash(skb);
3347	3707
3348	3708	if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER23 \|\|
3349		- bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP23)
	3709	+ bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP23) {
3350	3710	hash = bond_eth_hash(skb);
3351		- else
3352		- hash = (__force u32)flow.ports.ports;
	3711	+ } else {
	3712	+ if (flow.icmp.id)
	3713	+ memcpy(&hash, &flow.icmp, sizeof(hash));
	3714	+ else
	3715	+ memcpy(&hash, &flow.ports.ports, sizeof(hash));
	3716	+ }
3353	3717	hash ^= (__force u32)flow_get_u32_dst(&flow) ^
3354	3718	(__force u32)flow_get_u32_src(&flow);
3355	3719	hash ^= (hash >> 16);
..	..	@@ -3424,6 +3788,9 @@
3424	3788	/* register to receive LACPDUs */
3425	3789	bond->recv_probe = bond_3ad_lacpdu_recv;
3426	3790	bond_3ad_initiate_agg_selection(bond, 1);
	3791	+
	3792	+ bond_for_each_slave(bond, slave, iter)
	3793	+ dev_mc_add(slave->dev, lacpdu_mcast_addr);
3427	3794	}
3428	3795
3429	3796	if (bond_mode_can_use_xmit_hash(bond))
..	..	@@ -3435,12 +3802,26 @@
3435	3802	static int bond_close(struct net_device *bond_dev)
3436	3803	{
3437	3804	struct bonding *bond = netdev_priv(bond_dev);
	3805	+ struct slave *slave;
3438	3806
3439	3807	bond_work_cancel_all(bond);
3440	3808	bond->send_peer_notif = 0;
3441	3809	if (bond_is_lb(bond))
3442	3810	bond_alb_deinitialize(bond);
3443	3811	bond->recv_probe = NULL;
	3812	+
	3813	+ if (bond_uses_primary(bond)) {
	3814	+ rcu_read_lock();
	3815	+ slave = rcu_dereference(bond->curr_active_slave);
	3816	+ if (slave)
	3817	+ bond_hw_addr_flush(bond_dev, slave->dev);
	3818	+ rcu_read_unlock();
	3819	+ } else {
	3820	+ struct list_head *iter;
	3821	+
	3822	+ bond_for_each_slave(bond, slave, iter)
	3823	+ bond_hw_addr_flush(bond_dev, slave->dev);
	3824	+ }
3444	3825
3445	3826	return 0;
3446	3827	}
..	..	@@ -3474,12 +3855,46 @@
3474	3855	}
3475	3856	}
3476	3857
3477		-static int bond_get_nest_level(struct net_device *bond_dev)
	3858	+#ifdef CONFIG_LOCKDEP
	3859	+static int bond_get_lowest_level_rcu(struct net_device *dev)
3478	3860	{
3479		- struct bonding *bond = netdev_priv(bond_dev);
	3861	+ struct net_device ldev, next, now, dev_stack[MAX_NEST_DEV + 1];
	3862	+ struct list_head niter, iter, *iter_stack[MAX_NEST_DEV + 1];
	3863	+ int cur = 0, max = 0;
3480	3864
3481		- return bond->nest_level;
	3865	+ now = dev;
	3866	+ iter = &dev->adj_list.lower;
	3867	+
	3868	+ while (1) {
	3869	+ next = NULL;
	3870	+ while (1) {
	3871	+ ldev = netdev_next_lower_dev_rcu(now, &iter);
	3872	+ if (!ldev)
	3873	+ break;
	3874	+
	3875	+ next = ldev;
	3876	+ niter = &ldev->adj_list.lower;
	3877	+ dev_stack[cur] = now;
	3878	+ iter_stack[cur++] = iter;
	3879	+ if (max <= cur)
	3880	+ max = cur;
	3881	+ break;
	3882	+ }
	3883	+
	3884	+ if (!next) {
	3885	+ if (!cur)
	3886	+ return max;
	3887	+ next = dev_stack[--cur];
	3888	+ niter = iter_stack[cur];
	3889	+ }
	3890	+
	3891	+ now = next;
	3892	+ iter = niter;
	3893	+ }
	3894	+
	3895	+ return max;
3482	3896	}
	3897	+#endif
3483	3898
3484	3899	static void bond_get_stats(struct net_device *bond_dev,
3485	3900	struct rtnl_link_stats64 *stats)
..	..	@@ -3488,11 +3903,17 @@
3488	3903	struct rtnl_link_stats64 temp;
3489	3904	struct list_head *iter;
3490	3905	struct slave *slave;
	3906	+ int nest_level = 0;
3491	3907
3492		- spin_lock_nested(&bond->stats_lock, bond_get_nest_level(bond_dev));
3493		- memcpy(stats, &bond->bond_stats, sizeof(*stats));
3494	3908
3495	3909	rcu_read_lock();
	3910	+#ifdef CONFIG_LOCKDEP
	3911	+ nest_level = bond_get_lowest_level_rcu(bond_dev);
	3912	+#endif
	3913	+
	3914	+ spin_lock_nested(&bond->stats_lock, nest_level);
	3915	+ memcpy(stats, &bond->bond_stats, sizeof(*stats));
	3916	+
3496	3917	bond_for_each_slave_rcu(bond, slave, iter) {
3497	3918	const struct rtnl_link_stats64 *new =
3498	3919	dev_get_stats(slave->dev, &temp);
..	..	@@ -3502,10 +3923,10 @@
3502	3923	/* save off the slave stats for the next run */
3503	3924	memcpy(&slave->slave_stats, new, sizeof(*new));
3504	3925	}
3505		- rcu_read_unlock();
3506	3926
3507	3927	memcpy(&bond->bond_stats, stats, sizeof(*stats));
3508	3928	spin_unlock(&bond->stats_lock);
	3929	+ rcu_read_unlock();
3509	3930	}
3510	3931
3511	3932	static int bond_do_ioctl(struct net_device bond_dev, struct ifreq ifr, int cmd)
..	..	@@ -3530,7 +3951,7 @@
3530	3951	return -EINVAL;
3531	3952
3532	3953	mii->phy_id = 0;
3533		- /* Fall Through */
	3954	+ fallthrough;
3534	3955	case SIOCGMIIREG:
3535	3956	/* We do this again just in case we were called by SIOCGMIIREG
3536	3957	* instead of SIOCGMIIPHY.
..	..	@@ -3582,12 +4003,11 @@
3582	4003
3583	4004	slave_dev = __dev_get_by_name(net, ifr->ifr_slave);
3584	4005
3585		- netdev_dbg(bond_dev, "slave_dev=%p:\n", slave_dev);
	4006	+ slave_dbg(bond_dev, slave_dev, "slave_dev=%p:\n", slave_dev);
3586	4007
3587	4008	if (!slave_dev)
3588	4009	return -ENODEV;
3589	4010
3590		- netdev_dbg(bond_dev, "slave_dev->name=%s:\n", slave_dev->name);
3591	4011	switch (cmd) {
3592	4012	case BOND_ENSLAVE_OLD:
3593	4013	case SIOCBONDENSLAVE:
..	..	@@ -3599,8 +4019,7 @@
3599	4019	break;
3600	4020	case BOND_SETHWADDR_OLD:
3601	4021	case SIOCBONDSETHWADDR:
3602		- bond_set_dev_addr(bond_dev, slave_dev);
3603		- res = 0;
	4022	+ res = bond_set_dev_addr(bond_dev, slave_dev);
3604	4023	break;
3605	4024	case BOND_CHANGE_ACTIVE_OLD:
3606	4025	case SIOCBONDCHANGEACTIVE:
..	..	@@ -3656,32 +4075,35 @@
3656	4075	const struct net_device_ops *slave_ops;
3657	4076	struct neigh_parms parms;
3658	4077	struct slave *slave;
3659		- int ret;
	4078	+ int ret = 0;
3660	4079
3661		- slave = bond_first_slave(bond);
	4080	+ rcu_read_lock();
	4081	+ slave = bond_first_slave_rcu(bond);
3662	4082	if (!slave)
3663		- return 0;
	4083	+ goto out;
3664	4084	slave_ops = slave->dev->netdev_ops;
3665	4085	if (!slave_ops->ndo_neigh_setup)
3666		- return 0;
	4086	+ goto out;
3667	4087
3668		- parms.neigh_setup = NULL;
3669		- parms.neigh_cleanup = NULL;
3670		- ret = slave_ops->ndo_neigh_setup(slave->dev, &parms);
3671		- if (ret)
3672		- return ret;
3673		-
3674		- /* Assign slave's neigh_cleanup to neighbour in case cleanup is called
3675		- * after the last slave has been detached. Assumes that all slaves
3676		- * utilize the same neigh_cleanup (true at this writing as only user
3677		- * is ipoib).
	4088	+ /* TODO: find another way [1] to implement this.
	4089	+ * Passing a zeroed structure is fragile,
	4090	+ * but at least we do not pass garbage.
	4091	+ *
	4092	+ * [1] One way would be that ndo_neigh_setup() never touch
	4093	+ * struct neigh_parms, but propagate the new neigh_setup()
	4094	+ * back to ___neigh_create() / neigh_parms_alloc()
3678	4095	*/
3679		- n->parms->neigh_cleanup = parms.neigh_cleanup;
	4096	+ memset(&parms, 0, sizeof(parms));
	4097	+ ret = slave_ops->ndo_neigh_setup(slave->dev, &parms);
3680	4098
3681		- if (!parms.neigh_setup)
3682		- return 0;
	4099	+ if (ret)
	4100	+ goto out;
3683	4101
3684		- return parms.neigh_setup(n);
	4102	+ if (parms.neigh_setup)
	4103	+ ret = parms.neigh_setup(n);
	4104	+out:
	4105	+ rcu_read_unlock();
	4106	+ return ret;
3685	4107	}
3686	4108
3687	4109	/* The bonding ndo_neigh_setup is called at init time beofre any
..	..	@@ -3713,7 +4135,7 @@
3713	4135	netdev_dbg(bond_dev, "bond=%p, new_mtu=%d\n", bond, new_mtu);
3714	4136
3715	4137	bond_for_each_slave(bond, slave, iter) {
3716		- netdev_dbg(bond_dev, "s %p c_m %p\n",
	4138	+ slave_dbg(bond_dev, slave->dev, "s %p c_m %p\n",
3717	4139	slave, slave->dev->netdev_ops->ndo_change_mtu);
3718	4140
3719	4141	res = dev_set_mtu(slave->dev, new_mtu);
..	..	@@ -3727,8 +4149,8 @@
3727	4149	* means changing their mtu from timer context, which
3728	4150	* is probably not a good idea.
3729	4151	*/
3730		- netdev_dbg(bond_dev, "err %d %s\n", res,
3731		- slave->dev->name);
	4152	+ slave_dbg(bond_dev, slave->dev, "err %d setting mtu to %d\n",
	4153	+ res, new_mtu);
3732	4154	goto unwind;
3733	4155	}
3734	4156	}
..	..	@@ -3746,10 +4168,9 @@
3746	4168	break;
3747	4169
3748	4170	tmp_res = dev_set_mtu(rollback_slave->dev, bond_dev->mtu);
3749		- if (tmp_res) {
3750		- netdev_dbg(bond_dev, "unwind err %d dev %s\n",
3751		- tmp_res, rollback_slave->dev->name);
3752		- }
	4171	+ if (tmp_res)
	4172	+ slave_dbg(bond_dev, rollback_slave->dev, "unwind err %d\n",
	4173	+ tmp_res);
3753	4174	}
3754	4175
3755	4176	return res;
..	..	@@ -3773,7 +4194,7 @@
3773	4194	return bond_alb_set_mac_address(bond_dev, addr);
3774	4195
3775	4196
3776		- netdev_dbg(bond_dev, "bond=%p\n", bond);
	4197	+ netdev_dbg(bond_dev, "%s: bond=%p\n", __func__, bond);
3777	4198
3778	4199	/* If fail_over_mac is enabled, do nothing and return success.
3779	4200	* Returning an error causes ifenslave to fail.
..	..	@@ -3786,8 +4207,9 @@
3786	4207	return -EADDRNOTAVAIL;
3787	4208
3788	4209	bond_for_each_slave(bond, slave, iter) {
3789		- netdev_dbg(bond_dev, "slave %p %s\n", slave, slave->dev->name);
3790		- res = dev_set_mac_address(slave->dev, addr);
	4210	+ slave_dbg(bond_dev, slave->dev, "%s: slave=%p\n",
	4211	+ __func__, slave);
	4212	+ res = dev_set_mac_address(slave->dev, addr, NULL);
3791	4213	if (res) {
3792	4214	/* TODO: consider downing the slave
3793	4215	* and retry ?
..	..	@@ -3795,7 +4217,8 @@
3795	4217	* breakage anyway until ARP finish
3796	4218	* updating, so...
3797	4219	*/
3798		- netdev_dbg(bond_dev, "err %d %s\n", res, slave->dev->name);
	4220	+ slave_dbg(bond_dev, slave->dev, "%s: err %d\n",
	4221	+ __func__, res);
3799	4222	goto unwind;
3800	4223	}
3801	4224	}
..	..	@@ -3816,10 +4239,10 @@
3816	4239	break;
3817	4240
3818	4241	tmp_res = dev_set_mac_address(rollback_slave->dev,
3819		- (struct sockaddr *)&tmp_ss);
	4242	+ (struct sockaddr *)&tmp_ss, NULL);
3820	4243	if (tmp_res) {
3821		- netdev_dbg(bond_dev, "unwind err %d dev %s\n",
3822		- tmp_res, rollback_slave->dev->name);
	4244	+ slave_dbg(bond_dev, rollback_slave->dev, "%s: unwind err %d\n",
	4245	+ __func__, tmp_res);
3823	4246	}
3824	4247	}
3825	4248
..	..	@@ -3827,16 +4250,15 @@
3827	4250	}
3828	4251
3829	4252	/**
3830		- * bond_xmit_slave_id - transmit skb through slave with slave_id
	4253	+ * bond_get_slave_by_id - get xmit slave with slave_id
3831	4254	* @bond: bonding device that is transmitting
3832		- * @skb: buffer to transmit
3833	4255	* @slave_id: slave id up to slave_cnt-1 through which to transmit
3834	4256	*
3835		- * This function tries to transmit through slave with slave_id but in case
	4257	+ * This function tries to get slave with slave_id but in case
3836	4258	* it fails, it tries to find the first available slave for transmission.
3837		- * The skb is consumed in all cases, thus the function is void.
3838	4259	*/
3839		-static void bond_xmit_slave_id(struct bonding bond, struct sk_buff skb, int slave_id)
	4260	+static struct slave bond_get_slave_by_id(struct bonding bond,
	4261	+ int slave_id)
3840	4262	{
3841	4263	struct list_head *iter;
3842	4264	struct slave *slave;
..	..	@@ -3845,10 +4267,8 @@
3845	4267	/* Here we start from the slave with slave_id */
3846	4268	bond_for_each_slave_rcu(bond, slave, iter) {
3847	4269	if (--i < 0) {
3848		- if (bond_slave_can_tx(slave)) {
3849		- bond_dev_queue_xmit(bond, skb, slave->dev);
3850		- return;
3851		- }
	4270	+ if (bond_slave_can_tx(slave))
	4271	+ return slave;
3852	4272	}
3853	4273	}
3854	4274
..	..	@@ -3857,13 +4277,11 @@
3857	4277	bond_for_each_slave_rcu(bond, slave, iter) {
3858	4278	if (--i < 0)
3859	4279	break;
3860		- if (bond_slave_can_tx(slave)) {
3861		- bond_dev_queue_xmit(bond, skb, slave->dev);
3862		- return;
3863		- }
	4280	+ if (bond_slave_can_tx(slave))
	4281	+ return slave;
3864	4282	}
3865	4283	/* no slave that can tx has been found */
3866		- bond_tx_drop(bond->dev, skb);
	4284	+ return NULL;
3867	4285	}
3868	4286
3869	4287	/**
..	..	@@ -3899,10 +4317,9 @@
3899	4317	return slave_id;
3900	4318	}
3901	4319
3902		-static netdev_tx_t bond_xmit_roundrobin(struct sk_buff *skb,
3903		- struct net_device *bond_dev)
	4320	+static struct slave bond_xmit_roundrobin_slave_get(struct bonding bond,
	4321	+ struct sk_buff *skb)
3904	4322	{
3905		- struct bonding *bond = netdev_priv(bond_dev);
3906	4323	struct slave *slave;
3907	4324	int slave_cnt;
3908	4325	u32 slave_id;
..	..	@@ -3924,22 +4341,37 @@
3924	4341	if (iph->protocol == IPPROTO_IGMP) {
3925	4342	slave = rcu_dereference(bond->curr_active_slave);
3926	4343	if (slave)
3927		- bond_dev_queue_xmit(bond, skb, slave->dev);
3928		- else
3929		- bond_xmit_slave_id(bond, skb, 0);
3930		- return NETDEV_TX_OK;
	4344	+ return slave;
	4345	+ return bond_get_slave_by_id(bond, 0);
3931	4346	}
3932	4347	}
3933	4348
3934	4349	non_igmp:
3935	4350	slave_cnt = READ_ONCE(bond->slave_cnt);
3936	4351	if (likely(slave_cnt)) {
3937		- slave_id = bond_rr_gen_slave_id(bond);
3938		- bond_xmit_slave_id(bond, skb, slave_id % slave_cnt);
3939		- } else {
3940		- bond_tx_drop(bond_dev, skb);
	4352	+ slave_id = bond_rr_gen_slave_id(bond) % slave_cnt;
	4353	+ return bond_get_slave_by_id(bond, slave_id);
3941	4354	}
3942		- return NETDEV_TX_OK;
	4355	+ return NULL;
	4356	+}
	4357	+
	4358	+static netdev_tx_t bond_xmit_roundrobin(struct sk_buff *skb,
	4359	+ struct net_device *bond_dev)
	4360	+{
	4361	+ struct bonding *bond = netdev_priv(bond_dev);
	4362	+ struct slave *slave;
	4363	+
	4364	+ slave = bond_xmit_roundrobin_slave_get(bond, skb);
	4365	+ if (likely(slave))
	4366	+ return bond_dev_queue_xmit(bond, skb, slave->dev);
	4367	+
	4368	+ return bond_tx_drop(bond_dev, skb);
	4369	+}
	4370	+
	4371	+static struct slave bond_xmit_activebackup_slave_get(struct bonding bond,
	4372	+ struct sk_buff *skb)
	4373	+{
	4374	+ return rcu_dereference(bond->curr_active_slave);
3943	4375	}
3944	4376
3945	4377	/* In active-backup mode, we know that bond->curr_active_slave is always valid if
..	..	@@ -3951,13 +4383,11 @@
3951	4383	struct bonding *bond = netdev_priv(bond_dev);
3952	4384	struct slave *slave;
3953	4385
3954		- slave = rcu_dereference(bond->curr_active_slave);
	4386	+ slave = bond_xmit_activebackup_slave_get(bond, skb);
3955	4387	if (slave)
3956		- bond_dev_queue_xmit(bond, skb, slave->dev);
3957		- else
3958		- bond_tx_drop(bond_dev, skb);
	4388	+ return bond_dev_queue_xmit(bond, skb, slave->dev);
3959	4389
3960		- return NETDEV_TX_OK;
	4390	+ return bond_tx_drop(bond_dev, skb);
3961	4391	}
3962	4392
3963	4393	/* Use this to update slave_array when (a) it's not appropriate to update
..	..	@@ -3991,6 +4421,61 @@
3991	4421	bond_slave_arr_work_rearm(bond, 1);
3992	4422	}
3993	4423
	4424	+static void bond_skip_slave(struct bond_up_slave *slaves,
	4425	+ struct slave *skipslave)
	4426	+{
	4427	+ int idx;
	4428	+
	4429	+ /* Rare situation where caller has asked to skip a specific
	4430	+ * slave but allocation failed (most likely!). BTW this is
	4431	+ * only possible when the call is initiated from
	4432	+ * __bond_release_one(). In this situation; overwrite the
	4433	+ * skipslave entry in the array with the last entry from the
	4434	+ * array to avoid a situation where the xmit path may choose
	4435	+ * this to-be-skipped slave to send a packet out.
	4436	+ */
	4437	+ for (idx = 0; slaves && idx < slaves->count; idx++) {
	4438	+ if (skipslave == slaves->arr[idx]) {
	4439	+ slaves->arr[idx] =
	4440	+ slaves->arr[slaves->count - 1];
	4441	+ slaves->count--;
	4442	+ break;
	4443	+ }
	4444	+ }
	4445	+}
	4446	+
	4447	+static void bond_set_slave_arr(struct bonding *bond,
	4448	+ struct bond_up_slave *usable_slaves,
	4449	+ struct bond_up_slave *all_slaves)
	4450	+{
	4451	+ struct bond_up_slave usable, all;
	4452	+
	4453	+ usable = rtnl_dereference(bond->usable_slaves);
	4454	+ rcu_assign_pointer(bond->usable_slaves, usable_slaves);
	4455	+ kfree_rcu(usable, rcu);
	4456	+
	4457	+ all = rtnl_dereference(bond->all_slaves);
	4458	+ rcu_assign_pointer(bond->all_slaves, all_slaves);
	4459	+ kfree_rcu(all, rcu);
	4460	+}
	4461	+
	4462	+static void bond_reset_slave_arr(struct bonding *bond)
	4463	+{
	4464	+ struct bond_up_slave usable, all;
	4465	+
	4466	+ usable = rtnl_dereference(bond->usable_slaves);
	4467	+ if (usable) {
	4468	+ RCU_INIT_POINTER(bond->usable_slaves, NULL);
	4469	+ kfree_rcu(usable, rcu);
	4470	+ }
	4471	+
	4472	+ all = rtnl_dereference(bond->all_slaves);
	4473	+ if (all) {
	4474	+ RCU_INIT_POINTER(bond->all_slaves, NULL);
	4475	+ kfree_rcu(all, rcu);
	4476	+ }
	4477	+}
	4478	+
3994	4479	/* Build the usable slaves array in control path for modes that use xmit-hash
3995	4480	* to determine the slave interface -
3996	4481	* (a) BOND_MODE_8023AD
..	..	@@ -4001,9 +4486,9 @@
4001	4486	*/
4002	4487	int bond_update_slave_arr(struct bonding bond, struct slave skipslave)
4003	4488	{
	4489	+ struct bond_up_slave usable_slaves = NULL, all_slaves = NULL;
4004	4490	struct slave *slave;
4005	4491	struct list_head *iter;
4006		- struct bond_up_slave new_arr, old_arr;
4007	4492	int agg_id = 0;
4008	4493	int ret = 0;
4009	4494
..	..	@@ -4011,11 +4496,12 @@
4011	4496	WARN_ON(lockdep_is_held(&bond->mode_lock));
4012	4497	#endif
4013	4498
4014		- new_arr = kzalloc(offsetof(struct bond_up_slave, arr[bond->slave_cnt]),
4015		- GFP_KERNEL);
4016		- if (!new_arr) {
	4499	+ usable_slaves = kzalloc(struct_size(usable_slaves, arr,
	4500	+ bond->slave_cnt), GFP_KERNEL);
	4501	+ all_slaves = kzalloc(struct_size(all_slaves, arr,
	4502	+ bond->slave_cnt), GFP_KERNEL);
	4503	+ if (!usable_slaves \|\| !all_slaves) {
4017	4504	ret = -ENOMEM;
4018		- pr_err("Failed to build slave-array.\n");
4019	4505	goto out;
4020	4506	}
4021	4507	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
..	..	@@ -4023,20 +4509,19 @@
4023	4509
4024	4510	if (bond_3ad_get_active_agg_info(bond, &ad_info)) {
4025	4511	pr_debug("bond_3ad_get_active_agg_info failed\n");
4026		- kfree_rcu(new_arr, rcu);
4027	4512	/* No active aggragator means it's not safe to use
4028	4513	* the previous array.
4029	4514	*/
4030		- old_arr = rtnl_dereference(bond->slave_arr);
4031		- if (old_arr) {
4032		- RCU_INIT_POINTER(bond->slave_arr, NULL);
4033		- kfree_rcu(old_arr, rcu);
4034		- }
	4515	+ bond_reset_slave_arr(bond);
4035	4516	goto out;
4036	4517	}
4037	4518	agg_id = ad_info.aggregator_id;
4038	4519	}
4039	4520	bond_for_each_slave(bond, slave, iter) {
	4521	+ if (skipslave == slave)
	4522	+ continue;
	4523	+
	4524	+ all_slaves->arr[all_slaves->count++] = slave;
4040	4525	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
4041	4526	struct aggregator *agg;
4042	4527
..	..	@@ -4046,43 +4531,43 @@
4046	4531	}
4047	4532	if (!bond_slave_can_tx(slave))
4048	4533	continue;
4049		- if (skipslave == slave)
4050		- continue;
4051	4534
4052		- netdev_dbg(bond->dev,
4053		- "Adding slave dev %s to tx hash array[%d]\n",
4054		- slave->dev->name, new_arr->count);
	4535	+ slave_dbg(bond->dev, slave->dev, "Adding slave to tx hash array[%d]\n",
	4536	+ usable_slaves->count);
4055	4537
4056		- new_arr->arr[new_arr->count++] = slave;
	4538	+ usable_slaves->arr[usable_slaves->count++] = slave;
4057	4539	}
4058	4540
4059		- old_arr = rtnl_dereference(bond->slave_arr);
4060		- rcu_assign_pointer(bond->slave_arr, new_arr);
4061		- if (old_arr)
4062		- kfree_rcu(old_arr, rcu);
	4541	+ bond_set_slave_arr(bond, usable_slaves, all_slaves);
	4542	+ return ret;
4063	4543	out:
4064	4544	if (ret != 0 && skipslave) {
4065		- int idx;
4066		-
4067		- /* Rare situation where caller has asked to skip a specific
4068		- * slave but allocation failed (most likely!). BTW this is
4069		- * only possible when the call is initiated from
4070		- * __bond_release_one(). In this situation; overwrite the
4071		- * skipslave entry in the array with the last entry from the
4072		- * array to avoid a situation where the xmit path may choose
4073		- * this to-be-skipped slave to send a packet out.
4074		- */
4075		- old_arr = rtnl_dereference(bond->slave_arr);
4076		- for (idx = 0; old_arr != NULL && idx < old_arr->count; idx++) {
4077		- if (skipslave == old_arr->arr[idx]) {
4078		- old_arr->arr[idx] =
4079		- old_arr->arr[old_arr->count-1];
4080		- old_arr->count--;
4081		- break;
4082		- }
4083		- }
	4545	+ bond_skip_slave(rtnl_dereference(bond->all_slaves),
	4546	+ skipslave);
	4547	+ bond_skip_slave(rtnl_dereference(bond->usable_slaves),
	4548	+ skipslave);
4084	4549	}
	4550	+ kfree_rcu(all_slaves, rcu);
	4551	+ kfree_rcu(usable_slaves, rcu);
	4552	+
4085	4553	return ret;
	4554	+}
	4555	+
	4556	+static struct slave bond_xmit_3ad_xor_slave_get(struct bonding bond,
	4557	+ struct sk_buff *skb,
	4558	+ struct bond_up_slave *slaves)
	4559	+{
	4560	+ struct slave *slave;
	4561	+ unsigned int count;
	4562	+ u32 hash;
	4563	+
	4564	+ hash = bond_xmit_hash(bond, skb);
	4565	+ count = slaves ? READ_ONCE(slaves->count) : 0;
	4566	+ if (unlikely(!count))
	4567	+ return NULL;
	4568	+
	4569	+ slave = slaves->arr[hash % count];
	4570	+ return slave;
4086	4571	}
4087	4572
4088	4573	/* Use this Xmit function for 3AD as well as XOR modes. The current
..	..	@@ -4093,20 +4578,15 @@
4093	4578	struct net_device *dev)
4094	4579	{
4095	4580	struct bonding *bond = netdev_priv(dev);
4096		- struct slave *slave;
4097	4581	struct bond_up_slave *slaves;
4098		- unsigned int count;
	4582	+ struct slave *slave;
4099	4583
4100		- slaves = rcu_dereference(bond->slave_arr);
4101		- count = slaves ? READ_ONCE(slaves->count) : 0;
4102		- if (likely(count)) {
4103		- slave = slaves->arr[bond_xmit_hash(bond, skb) % count];
4104		- bond_dev_queue_xmit(bond, skb, slave->dev);
4105		- } else {
4106		- bond_tx_drop(dev, skb);
4107		- }
	4584	+ slaves = rcu_dereference(bond->usable_slaves);
	4585	+ slave = bond_xmit_3ad_xor_slave_get(bond, skb, slaves);
	4586	+ if (likely(slave))
	4587	+ return bond_dev_queue_xmit(bond, skb, slave->dev);
4108	4588
4109		- return NETDEV_TX_OK;
	4589	+ return bond_tx_drop(dev, skb);
4110	4590	}
4111	4591
4112	4592	/* in broadcast mode, we send everything to all usable interfaces. */
..	..	@@ -4116,27 +4596,39 @@
4116	4596	struct bonding *bond = netdev_priv(bond_dev);
4117	4597	struct slave *slave = NULL;
4118	4598	struct list_head *iter;
	4599	+ bool xmit_suc = false;
	4600	+ bool skb_used = false;
4119	4601
4120	4602	bond_for_each_slave_rcu(bond, slave, iter) {
4121		- if (bond_is_last_slave(bond, slave))
4122		- break;
4123		- if (bond_slave_is_up(slave) && slave->link == BOND_LINK_UP) {
4124		- struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
	4603	+ struct sk_buff *skb2;
4125	4604
	4605	+ if (!(bond_slave_is_up(slave) && slave->link == BOND_LINK_UP))
	4606	+ continue;
	4607	+
	4608	+ if (bond_is_last_slave(bond, slave)) {
	4609	+ skb2 = skb;
	4610	+ skb_used = true;
	4611	+ } else {
	4612	+ skb2 = skb_clone(skb, GFP_ATOMIC);
4126	4613	if (!skb2) {
4127	4614	net_err_ratelimited("%s: Error: %s: skb_clone() failed\n",
4128	4615	bond_dev->name, __func__);
4129	4616	continue;
4130	4617	}
4131		- bond_dev_queue_xmit(bond, skb2, slave->dev);
4132	4618	}
4133		- }
4134		- if (slave && bond_slave_is_up(slave) && slave->link == BOND_LINK_UP)
4135		- bond_dev_queue_xmit(bond, skb, slave->dev);
4136		- else
4137		- bond_tx_drop(bond_dev, skb);
4138	4619
4139		- return NETDEV_TX_OK;
	4620	+ if (bond_dev_queue_xmit(bond, skb2, slave->dev) == NETDEV_TX_OK)
	4621	+ xmit_suc = true;
	4622	+ }
	4623	+
	4624	+ if (!skb_used)
	4625	+ dev_kfree_skb_any(skb);
	4626	+
	4627	+ if (xmit_suc)
	4628	+ return NETDEV_TX_OK;
	4629	+
	4630	+ atomic_long_inc(&bond_dev->tx_dropped);
	4631	+ return NET_XMIT_DROP;
4140	4632	}
4141	4633
4142	4634	/------------------------- Device initialization ---------------------------/
..	..	@@ -4169,8 +4661,7 @@
4169	4661
4170	4662
4171	4663	static u16 bond_select_queue(struct net_device dev, struct sk_buff skb,
4172		- struct net_device *sb_dev,
4173		- select_queue_fallback_t fallback)
	4664	+ struct net_device *sb_dev)
4174	4665	{
4175	4666	/* This helper function exists to help dev_pick_tx get the correct
4176	4667	* destination queue. Using a helper function skips a call to
..	..	@@ -4188,6 +4679,48 @@
4188	4679	} while (txq >= dev->real_num_tx_queues);
4189	4680	}
4190	4681	return txq;
	4682	+}
	4683	+
	4684	+static struct net_device bond_xmit_get_slave(struct net_device master_dev,
	4685	+ struct sk_buff *skb,
	4686	+ bool all_slaves)
	4687	+{
	4688	+ struct bonding *bond = netdev_priv(master_dev);
	4689	+ struct bond_up_slave *slaves;
	4690	+ struct slave *slave = NULL;
	4691	+
	4692	+ switch (BOND_MODE(bond)) {
	4693	+ case BOND_MODE_ROUNDROBIN:
	4694	+ slave = bond_xmit_roundrobin_slave_get(bond, skb);
	4695	+ break;
	4696	+ case BOND_MODE_ACTIVEBACKUP:
	4697	+ slave = bond_xmit_activebackup_slave_get(bond, skb);
	4698	+ break;
	4699	+ case BOND_MODE_8023AD:
	4700	+ case BOND_MODE_XOR:
	4701	+ if (all_slaves)
	4702	+ slaves = rcu_dereference(bond->all_slaves);
	4703	+ else
	4704	+ slaves = rcu_dereference(bond->usable_slaves);
	4705	+ slave = bond_xmit_3ad_xor_slave_get(bond, skb, slaves);
	4706	+ break;
	4707	+ case BOND_MODE_BROADCAST:
	4708	+ break;
	4709	+ case BOND_MODE_ALB:
	4710	+ slave = bond_xmit_alb_slave_get(bond, skb);
	4711	+ break;
	4712	+ case BOND_MODE_TLB:
	4713	+ slave = bond_xmit_tlb_slave_get(bond, skb);
	4714	+ break;
	4715	+ default:
	4716	+ /* Should never happen, mode already checked */
	4717	+ WARN_ONCE(true, "Unknown bonding mode");
	4718	+ break;
	4719	+ }
	4720	+
	4721	+ if (slave)
	4722	+ return slave->dev;
	4723	+ return NULL;
4191	4724	}
4192	4725
4193	4726	static netdev_tx_t __bond_start_xmit(struct sk_buff skb, struct net_device dev)
..	..	@@ -4216,8 +4749,7 @@
4216	4749	/* Should never happen, mode already checked */
4217	4750	netdev_err(dev, "Unknown bonding mode %d\n", BOND_MODE(bond));
4218	4751	WARN_ON_ONCE(1);
4219		- bond_tx_drop(dev, skb);
4220		- return NETDEV_TX_OK;
	4752	+ return bond_tx_drop(dev, skb);
4221	4753	}
4222	4754	}
4223	4755
..	..	@@ -4236,7 +4768,7 @@
4236	4768	if (bond_has_slaves(bond))
4237	4769	ret = __bond_start_xmit(skb, dev);
4238	4770	else
4239		- bond_tx_drop(dev, skb);
	4771	+ ret = bond_tx_drop(dev, skb);
4240	4772	rcu_read_unlock();
4241	4773
4242	4774	return ret;
..	..	@@ -4291,7 +4823,6 @@
4291	4823	struct ethtool_drvinfo *drvinfo)
4292	4824	{
4293	4825	strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
4294		- strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
4295	4826	snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "%d",
4296	4827	BOND_ABI_VERSION);
4297	4828	}
..	..	@@ -4318,7 +4849,6 @@
4318	4849	.ndo_neigh_setup = bond_neigh_setup,
4319	4850	.ndo_vlan_rx_add_vid = bond_vlan_rx_add_vid,
4320	4851	.ndo_vlan_rx_kill_vid = bond_vlan_rx_kill_vid,
4321		- .ndo_get_lock_subclass = bond_get_nest_level,
4322	4852	#ifdef CONFIG_NET_POLL_CONTROLLER
4323	4853	.ndo_netpoll_setup = bond_netpoll_setup,
4324	4854	.ndo_netpoll_cleanup = bond_netpoll_cleanup,
..	..	@@ -4328,6 +4858,7 @@
4328	4858	.ndo_del_slave = bond_release,
4329	4859	.ndo_fix_features = bond_fix_features,
4330	4860	.ndo_features_check = passthru_features_check,
	4861	+ .ndo_get_xmit_slave = bond_xmit_get_slave,
4331	4862	};
4332	4863
4333	4864	static const struct device_type bond_type = {
..	..	@@ -4346,7 +4877,6 @@
4346	4877	struct bonding *bond = netdev_priv(bond_dev);
4347	4878
4348	4879	spin_lock_init(&bond->mode_lock);
4349		- spin_lock_init(&bond->stats_lock);
4350	4880	bond->params = bonding_defaults;
4351	4881
4352	4882	/* Initialize pointers */
..	..	@@ -4368,6 +4898,13 @@
4368	4898	bond_dev->priv_flags \|= IFF_BONDING \| IFF_UNICAST_FLT \| IFF_NO_QUEUE;
4369	4899	bond_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE \| IFF_TX_SKB_SHARING);
4370	4900
	4901	+#ifdef CONFIG_XFRM_OFFLOAD
	4902	+ /* set up xfrm device ops (only supported in active-backup right now) */
	4903	+ bond_dev->xfrmdev_ops = &bond_xfrmdev_ops;
	4904	+ INIT_LIST_HEAD(&bond->ipsec_list);
	4905	+ spin_lock_init(&bond->ipsec_lock);
	4906	+#endif /* CONFIG_XFRM_OFFLOAD */
	4907	+
4371	4908	/* don't acquire bond device's netif_tx_lock when transmitting */
4372	4909	bond_dev->features \|= NETIF_F_LLTX;
4373	4910
..	..	@@ -4383,11 +4920,21 @@
4383	4920
4384	4921	bond_dev->hw_features = BOND_VLAN_FEATURES \|
4385	4922	NETIF_F_HW_VLAN_CTAG_RX \|
4386		- NETIF_F_HW_VLAN_CTAG_FILTER;
	4923	+ NETIF_F_HW_VLAN_CTAG_FILTER \|
	4924	+ NETIF_F_HW_VLAN_STAG_RX \|
	4925	+ NETIF_F_HW_VLAN_STAG_FILTER;
4387	4926
4388	4927	bond_dev->hw_features \|= NETIF_F_GSO_ENCAP_ALL \| NETIF_F_GSO_UDP_L4;
	4928	+#ifdef CONFIG_XFRM_OFFLOAD
	4929	+ bond_dev->hw_features \|= BOND_XFRM_FEATURES;
	4930	+#endif /* CONFIG_XFRM_OFFLOAD */
4389	4931	bond_dev->features \|= bond_dev->hw_features;
4390	4932	bond_dev->features \|= NETIF_F_HW_VLAN_CTAG_TX \| NETIF_F_HW_VLAN_STAG_TX;
	4933	+#ifdef CONFIG_XFRM_OFFLOAD
	4934	+ /* Disable XFRM features if this isn't an active-backup config */
	4935	+ if (BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP)
	4936	+ bond_dev->features &= ~BOND_XFRM_FEATURES;
	4937	+#endif /* CONFIG_XFRM_OFFLOAD */
4391	4938	}
4392	4939
4393	4940	/* Destroy a bonding device.
..	..	@@ -4396,9 +4943,9 @@
4396	4943	static void bond_uninit(struct net_device *bond_dev)
4397	4944	{
4398	4945	struct bonding *bond = netdev_priv(bond_dev);
	4946	+ struct bond_up_slave usable, all;
4399	4947	struct list_head *iter;
4400	4948	struct slave *slave;
4401		- struct bond_up_slave *arr;
4402	4949
4403	4950	bond_netpoll_cleanup(bond_dev);
4404	4951
..	..	@@ -4407,10 +4954,16 @@
4407	4954	__bond_release_one(bond_dev, slave->dev, true, true);
4408	4955	netdev_info(bond_dev, "Released all slaves\n");
4409	4956
4410		- arr = rtnl_dereference(bond->slave_arr);
4411		- if (arr) {
4412		- RCU_INIT_POINTER(bond->slave_arr, NULL);
4413		- kfree_rcu(arr, rcu);
	4957	+ usable = rtnl_dereference(bond->usable_slaves);
	4958	+ if (usable) {
	4959	+ RCU_INIT_POINTER(bond->usable_slaves, NULL);
	4960	+ kfree_rcu(usable, rcu);
	4961	+ }
	4962	+
	4963	+ all = rtnl_dereference(bond->all_slaves);
	4964	+ if (all) {
	4965	+ RCU_INIT_POINTER(bond->all_slaves, NULL);
	4966	+ kfree_rcu(all, rcu);
4414	4967	}
4415	4968
4416	4969	list_del(&bond->bond_list);
..	..	@@ -4769,6 +5322,7 @@
4769	5322	params->arp_all_targets = arp_all_targets_value;
4770	5323	params->updelay = updelay;
4771	5324	params->downdelay = downdelay;
	5325	+ params->peer_notif_delay = 0;
4772	5326	params->use_carrier = use_carrier;
4773	5327	params->lacp_fast = lacp_fast;
4774	5328	params->primary[0] = 0;
..	..	@@ -4817,7 +5371,9 @@
4817	5371	if (!bond->wq)
4818	5372	return -ENOMEM;
4819	5373
4820		- bond->nest_level = SINGLE_DEPTH_NESTING;
	5374	+ bond->notifier_ctx = false;
	5375	+
	5376	+ spin_lock_init(&bond->stats_lock);
4821	5377	netdev_lockdep_set_classes(bond_dev);
4822	5378
4823	5379	list_add_tail(&bond->bond_list, &bn->dev_list);
..	..	@@ -4932,8 +5488,6 @@
4932	5488	int i;
4933	5489	int res;
4934	5490
4935		- pr_info("%s", bond_version);
4936		-
4937	5491	res = bond_check_params(&bonding_defaults);
4938	5492	if (res)
4939	5493	goto out;
..	..	@@ -4953,6 +5507,10 @@
4953	5507	if (res)
4954	5508	goto err;
4955	5509	}
	5510	+
	5511	+ skb_flow_dissector_init(&flow_keys_bonding,
	5512	+ flow_keys_bonding_keys,
	5513	+ ARRAY_SIZE(flow_keys_bonding_keys));
4956	5514
4957	5515	register_netdevice_notifier(&bond_netdev_notifier);
4958	5516	out:
..	..	@@ -4984,6 +5542,5 @@
4984	5542	module_init(bonding_init);
4985	5543	module_exit(bonding_exit);
4986	5544	MODULE_LICENSE("GPL");
4987		-MODULE_VERSION(DRV_VERSION);
4988		-MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION);
	5545	+MODULE_DESCRIPTION(DRV_DESCRIPTION);
4989	5546	MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others");