bond_main.c 122.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/*
 * originally based on the dummy device.
 *
 * Copyright 1999, Thomas Davis, tadavis@lbl.gov.
 * Licensed under the GPL. Based on dummy.c, and eql.c devices.
 *
 * bonding.c: an Ethernet Bonding driver
 *
 * This is useful to talk to a Cisco EtherChannel compatible equipment:
 *	Cisco 5500
 *	Sun Trunking (Solaris)
 *	Alteon AceDirector Trunks
 *	Linux Bonding
 *	and probably many L2 switches ...
 *
 * How it works:
 *    ifconfig bond0 ipaddress netmask up
 *      will setup a network device, with an ip address.  No mac address
 *	will be assigned at this time.  The hw mac address will come from
 *	the first slave bonded to the channel.  All slaves will then use
 *	this hw mac address.
 *
 *    ifconfig bond0 down
 *         will release all slaves, marking them as down.
 *
 *    ifenslave bond0 eth0
 *	will attach eth0 to bond0 as a slave.  eth0 hw mac address will either
 *	a: be used as initial mac address
 *	b: if a hw mac address already is there, eth0's hw mac address
 *	   will then be set from bond0.
 *
 */

J
Joe Perches 已提交
34 35
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/in.h>
44
#include <net/ip.h>
L
Linus Torvalds 已提交
45
#include <linux/ip.h>
46 47
#include <linux/tcp.h>
#include <linux/udp.h>
L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/timer.h>
#include <linux/socket.h>
#include <linux/ctype.h>
#include <linux/inet.h>
#include <linux/bitops.h>
S
Stephen Hemminger 已提交
56
#include <linux/io.h>
L
Linus Torvalds 已提交
57
#include <asm/dma.h>
S
Stephen Hemminger 已提交
58
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
59 60 61
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
62
#include <linux/igmp.h>
L
Linus Torvalds 已提交
63 64 65 66 67 68 69 70 71 72 73
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <linux/rtnetlink.h>
#include <linux/smp.h>
#include <linux/if_ether.h>
#include <net/arp.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/if_vlan.h>
#include <linux/if_bonding.h>
D
David Sterba 已提交
74
#include <linux/jiffies.h>
75
#include <linux/preempt.h>
J
Jay Vosburgh 已提交
76
#include <net/route.h>
77
#include <net/net_namespace.h>
78
#include <net/netns/generic.h>
79
#include <net/pkt_sched.h>
80
#include <linux/rculist.h>
81
#include <net/flow_keys.h>
L
Linus Torvalds 已提交
82 83 84 85 86 87 88 89 90
#include "bonding.h"
#include "bond_3ad.h"
#include "bond_alb.h"

/*---------------------------- Module parameters ----------------------------*/

/* monitor all links that often (in milliseconds). <=0 disables monitoring */

static int max_bonds	= BOND_DEFAULT_MAX_BONDS;
91
static int tx_queues	= BOND_DEFAULT_TX_QUEUES;
92
static int num_peer_notif = 1;
93
static int miimon;
S
Stephen Hemminger 已提交
94 95
static int updelay;
static int downdelay;
L
Linus Torvalds 已提交
96
static int use_carrier	= 1;
S
Stephen Hemminger 已提交
97 98
static char *mode;
static char *primary;
99
static char *primary_reselect;
S
Stephen Hemminger 已提交
100
static char *lacp_rate;
101
static int min_links;
S
Stephen Hemminger 已提交
102 103
static char *ad_select;
static char *xmit_hash_policy;
104
static int arp_interval;
S
Stephen Hemminger 已提交
105 106
static char *arp_ip_target[BOND_MAX_ARP_TARGETS];
static char *arp_validate;
107
static char *arp_all_targets;
S
Stephen Hemminger 已提交
108
static char *fail_over_mac;
109
static int all_slaves_active;
110
static struct bond_params bonding_defaults;
111
static int resend_igmp = BOND_DEFAULT_RESEND_IGMP;
112
static int packets_per_slave = 1;
113
static int lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL;
L
Linus Torvalds 已提交
114 115 116

module_param(max_bonds, int, 0);
MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
117 118
module_param(tx_queues, int, 0);
MODULE_PARM_DESC(tx_queues, "Max number of transmit queues (default = 16)");
119
module_param_named(num_grat_arp, num_peer_notif, int, 0644);
120 121
MODULE_PARM_DESC(num_grat_arp, "Number of peer notifications to send on "
			       "failover event (alias of num_unsol_na)");
122
module_param_named(num_unsol_na, num_peer_notif, int, 0644);
123 124
MODULE_PARM_DESC(num_unsol_na, "Number of peer notifications to send on "
			       "failover event (alias of num_grat_arp)");
L
Linus Torvalds 已提交
125 126 127 128 129
module_param(miimon, int, 0);
MODULE_PARM_DESC(miimon, "Link check interval in milliseconds");
module_param(updelay, int, 0);
MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds");
module_param(downdelay, int, 0);
130 131
MODULE_PARM_DESC(downdelay, "Delay before considering link down, "
			    "in milliseconds");
L
Linus Torvalds 已提交
132
module_param(use_carrier, int, 0);
133 134
MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; "
			      "0 for off, 1 for on (default)");
L
Linus Torvalds 已提交
135
module_param(mode, charp, 0);
136
MODULE_PARM_DESC(mode, "Mode of operation; 0 for balance-rr, "
137 138 139
		       "1 for active-backup, 2 for balance-xor, "
		       "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, "
		       "6 for balance-alb");
L
Linus Torvalds 已提交
140 141
module_param(primary, charp, 0);
MODULE_PARM_DESC(primary, "Primary network device to use");
142 143 144 145 146 147 148 149
module_param(primary_reselect, charp, 0);
MODULE_PARM_DESC(primary_reselect, "Reselect primary slave "
				   "once it comes up; "
				   "0 for always (default), "
				   "1 for only if speed of primary is "
				   "better, "
				   "2 for only on active slave "
				   "failure");
L
Linus Torvalds 已提交
150
module_param(lacp_rate, charp, 0);
151 152
MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner; "
			    "0 for slow, 1 for fast");
153
module_param(ad_select, charp, 0);
154 155 156
MODULE_PARM_DESC(ad_select, "803.ad aggregation selection logic; "
			    "0 for stable (default), 1 for bandwidth, "
			    "2 for count");
157 158 159
module_param(min_links, int, 0);
MODULE_PARM_DESC(min_links, "Minimum number of available links before turning on carrier");

160
module_param(xmit_hash_policy, charp, 0);
161 162
MODULE_PARM_DESC(xmit_hash_policy, "balance-xor and 802.3ad hashing method; "
				   "0 for layer 2 (default), 1 for layer 3+4, "
163 164
				   "2 for layer 2+3, 3 for encap layer 2+3, "
				   "4 for encap layer 3+4");
L
Linus Torvalds 已提交
165 166 167 168
module_param(arp_interval, int, 0);
MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds");
module_param_array(arp_ip_target, charp, NULL, 0);
MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form");
169
module_param(arp_validate, charp, 0);
170 171 172
MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes; "
			       "0 for none (default), 1 for active, "
			       "2 for backup, 3 for all");
173 174
module_param(arp_all_targets, charp, 0);
MODULE_PARM_DESC(arp_all_targets, "fail on any/all arp targets timeout; 0 for any (default), 1 for all");
175
module_param(fail_over_mac, charp, 0);
176 177 178
MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to "
				"the same MAC; 0 for none (default), "
				"1 for active, 2 for follow");
179 180
module_param(all_slaves_active, int, 0);
MODULE_PARM_DESC(all_slaves_active, "Keep all frames received on an interface"
181
				     "by setting active flag for all slaves; "
182
				     "0 for never (default), 1 for always.");
183
module_param(resend_igmp, int, 0);
184 185
MODULE_PARM_DESC(resend_igmp, "Number of IGMP membership reports to send on "
			      "link failure");
186 187 188 189
module_param(packets_per_slave, int, 0);
MODULE_PARM_DESC(packets_per_slave, "Packets to send per slave in balance-rr "
				    "mode; 0 for a random slave, 1 packet per "
				    "slave (default), >1 packets per slave.");
190 191 192 193
module_param(lp_interval, uint, 0);
MODULE_PARM_DESC(lp_interval, "The number of seconds between instances where "
			      "the bonding driver sends learning packets to "
			      "each slaves peer switch. The default is 1.");
L
Linus Torvalds 已提交
194 195 196

/*----------------------------- Global variables ----------------------------*/

197
#ifdef CONFIG_NET_POLL_CONTROLLER
198
atomic_t netpoll_block_tx = ATOMIC_INIT(0);
199 200
#endif

201
int bond_net_id __read_mostly;
L
Linus Torvalds 已提交
202

S
Stephen Hemminger 已提交
203 204
static __be32 arp_target[BOND_MAX_ARP_TARGETS];
static int arp_ip_count;
L
Linus Torvalds 已提交
205
static int bond_mode	= BOND_MODE_ROUNDROBIN;
S
Stephen Hemminger 已提交
206 207
static int xmit_hashtype = BOND_XMIT_POLICY_LAYER2;
static int lacp_fast;
L
Linus Torvalds 已提交
208 209 210

/*-------------------------- Forward declarations ---------------------------*/

211
static int bond_init(struct net_device *bond_dev);
212
static void bond_uninit(struct net_device *bond_dev);
L
Linus Torvalds 已提交
213 214 215

/*---------------------------- General routines -----------------------------*/

216
const char *bond_mode_name(int mode)
L
Linus Torvalds 已提交
217
{
218 219 220 221 222
	static const char *names[] = {
		[BOND_MODE_ROUNDROBIN] = "load balancing (round-robin)",
		[BOND_MODE_ACTIVEBACKUP] = "fault-tolerance (active-backup)",
		[BOND_MODE_XOR] = "load balancing (xor)",
		[BOND_MODE_BROADCAST] = "fault-tolerance (broadcast)",
S
Stephen Hemminger 已提交
223
		[BOND_MODE_8023AD] = "IEEE 802.3ad Dynamic link aggregation",
224 225 226 227
		[BOND_MODE_TLB] = "transmit load balancing",
		[BOND_MODE_ALB] = "adaptive load balancing",
	};

228
	if (mode < BOND_MODE_ROUNDROBIN || mode > BOND_MODE_ALB)
L
Linus Torvalds 已提交
229
		return "unknown";
230 231

	return names[mode];
L
Linus Torvalds 已提交
232 233 234 235 236 237
}

/*---------------------------------- VLAN -----------------------------------*/

/**
 * bond_dev_queue_xmit - Prepare skb for xmit.
S
Stephen Hemminger 已提交
238
 *
L
Linus Torvalds 已提交
239 240 241 242
 * @bond: bond device that got this skb for tx.
 * @skb: hw accel VLAN tagged skb to transmit
 * @slave_dev: slave that is supposed to xmit this skbuff
 */
243
void bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb,
S
Stephen Hemminger 已提交
244
			struct net_device *slave_dev)
L
Linus Torvalds 已提交
245
{
246
	skb->dev = slave_dev;
247

248
	BUILD_BUG_ON(sizeof(skb->queue_mapping) !=
249 250
		     sizeof(qdisc_skb_cb(skb)->slave_dev_queue_mapping));
	skb->queue_mapping = qdisc_skb_cb(skb)->slave_dev_queue_mapping;
251

252
	if (unlikely(netpoll_tx_running(bond->dev)))
253
		bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb);
254
	else
255
		dev_queue_xmit(skb);
L
Linus Torvalds 已提交
256 257 258
}

/*
J
Jiri Pirko 已提交
259 260
 * In the following 2 functions, bond_vlan_rx_add_vid and bond_vlan_rx_kill_vid,
 * We don't protect the slave list iteration with a lock because:
L
Linus Torvalds 已提交
261 262 263 264
 * a. This operation is performed in IOCTL context,
 * b. The operation is protected by the RTNL semaphore in the 8021q code,
 * c. Holding a lock with BH disabled while directly calling a base driver
 *    entry point is generally a BAD idea.
S
Stephen Hemminger 已提交
265
 *
L
Linus Torvalds 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279
 * The design of synchronization/protection for this operation in the 8021q
 * module is good for one or more VLAN devices over a single physical device
 * and cannot be extended for a teaming solution like bonding, so there is a
 * potential race condition here where a net device from the vlan group might
 * be referenced (either by a base driver or the 8021q code) while it is being
 * removed from the system. However, it turns out we're not making matters
 * worse, and if it works for regular VLAN usage it will work here too.
*/

/**
 * bond_vlan_rx_add_vid - Propagates adding an id to slaves
 * @bond_dev: bonding net device that got called
 * @vid: vlan id being added
 */
280 281
static int bond_vlan_rx_add_vid(struct net_device *bond_dev,
				__be16 proto, u16 vid)
L
Linus Torvalds 已提交
282
{
283
	struct bonding *bond = netdev_priv(bond_dev);
284
	struct slave *slave, *rollback_slave;
285
	struct list_head *iter;
286
	int res;
L
Linus Torvalds 已提交
287

288
	bond_for_each_slave(bond, slave, iter) {
289
		res = vlan_vid_add(slave->dev, proto, vid);
290 291
		if (res)
			goto unwind;
L
Linus Torvalds 已提交
292 293
	}

294
	return 0;
295 296

unwind:
297
	/* unwind to the slave that failed */
298
	bond_for_each_slave(bond, rollback_slave, iter) {
299 300 301 302 303
		if (rollback_slave == slave)
			break;

		vlan_vid_del(rollback_slave->dev, proto, vid);
	}
304 305

	return res;
L
Linus Torvalds 已提交
306 307 308 309 310 311 312
}

/**
 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
 * @bond_dev: bonding net device that got called
 * @vid: vlan id being removed
 */
313 314
static int bond_vlan_rx_kill_vid(struct net_device *bond_dev,
				 __be16 proto, u16 vid)
L
Linus Torvalds 已提交
315
{
316
	struct bonding *bond = netdev_priv(bond_dev);
317
	struct list_head *iter;
L
Linus Torvalds 已提交
318 319
	struct slave *slave;

320
	bond_for_each_slave(bond, slave, iter)
321
		vlan_vid_del(slave->dev, proto, vid);
L
Linus Torvalds 已提交
322

323 324
	if (bond_is_lb(bond))
		bond_alb_clear_vlan(bond, vid);
325 326

	return 0;
L
Linus Torvalds 已提交
327 328 329 330
}

/*------------------------------- Link status -------------------------------*/

331 332 333 334 335 336 337 338 339
/*
 * Set the carrier state for the master according to the state of its
 * slaves.  If any slaves are up, the master is up.  In 802.3ad mode,
 * do special 802.3ad magic.
 *
 * Returns zero if carrier state does not change, nonzero if it does.
 */
static int bond_set_carrier(struct bonding *bond)
{
340
	struct list_head *iter;
341 342
	struct slave *slave;

343
	if (!bond_has_slaves(bond))
344 345 346 347 348
		goto down;

	if (bond->params.mode == BOND_MODE_8023AD)
		return bond_3ad_set_carrier(bond);

349
	bond_for_each_slave(bond, slave, iter) {
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
		if (slave->link == BOND_LINK_UP) {
			if (!netif_carrier_ok(bond->dev)) {
				netif_carrier_on(bond->dev);
				return 1;
			}
			return 0;
		}
	}

down:
	if (netif_carrier_ok(bond->dev)) {
		netif_carrier_off(bond->dev);
		return 1;
	}
	return 0;
}

L
Linus Torvalds 已提交
367 368 369
/*
 * Get link speed and duplex from the slave's base driver
 * using ethtool. If for some reason the call fails or the
370
 * values are invalid, set speed and duplex to -1,
371
 * and return.
L
Linus Torvalds 已提交
372
 */
373
static void bond_update_speed_duplex(struct slave *slave)
L
Linus Torvalds 已提交
374 375
{
	struct net_device *slave_dev = slave->dev;
376
	struct ethtool_cmd ecmd;
377
	u32 slave_speed;
378
	int res;
L
Linus Torvalds 已提交
379

380 381
	slave->speed = SPEED_UNKNOWN;
	slave->duplex = DUPLEX_UNKNOWN;
L
Linus Torvalds 已提交
382

383
	res = __ethtool_get_settings(slave_dev, &ecmd);
384
	if (res < 0)
385
		return;
L
Linus Torvalds 已提交
386

387
	slave_speed = ethtool_cmd_speed(&ecmd);
J
Jiri Pirko 已提交
388
	if (slave_speed == 0 || slave_speed == ((__u32) -1))
389
		return;
L
Linus Torvalds 已提交
390

391
	switch (ecmd.duplex) {
L
Linus Torvalds 已提交
392 393 394 395
	case DUPLEX_FULL:
	case DUPLEX_HALF:
		break;
	default:
396
		return;
L
Linus Torvalds 已提交
397 398
	}

399
	slave->speed = slave_speed;
400
	slave->duplex = ecmd.duplex;
L
Linus Torvalds 已提交
401

402
	return;
L
Linus Torvalds 已提交
403 404
}

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
const char *bond_slave_link_status(s8 link)
{
	switch (link) {
	case BOND_LINK_UP:
		return "up";
	case BOND_LINK_FAIL:
		return "going down";
	case BOND_LINK_DOWN:
		return "down";
	case BOND_LINK_BACK:
		return "going back";
	default:
		return "unknown";
	}
}

L
Linus Torvalds 已提交
421 422 423 424
/*
 * if <dev> supports MII link status reporting, check its link status.
 *
 * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(),
S
Stephen Hemminger 已提交
425
 * depending upon the setting of the use_carrier parameter.
L
Linus Torvalds 已提交
426 427 428 429 430 431 432 433 434 435 436
 *
 * Return either BMSR_LSTATUS, meaning that the link is up (or we
 * can't tell and just pretend it is), or 0, meaning that the link is
 * down.
 *
 * If reporting is non-zero, instead of faking link up, return -1 if
 * both ETHTOOL and MII ioctls fail (meaning the device does not
 * support them).  If use_carrier is set, return whatever it says.
 * It'd be nice if there was a good way to tell if a driver supports
 * netif_carrier, but there really isn't.
 */
S
Stephen Hemminger 已提交
437 438
static int bond_check_dev_link(struct bonding *bond,
			       struct net_device *slave_dev, int reporting)
L
Linus Torvalds 已提交
439
{
440
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
441
	int (*ioctl)(struct net_device *, struct ifreq *, int);
L
Linus Torvalds 已提交
442 443 444
	struct ifreq ifr;
	struct mii_ioctl_data *mii;

445 446 447
	if (!reporting && !netif_running(slave_dev))
		return 0;

448
	if (bond->params.use_carrier)
L
Linus Torvalds 已提交
449 450
		return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;

451
	/* Try to get link status using Ethtool first. */
452 453 454
	if (slave_dev->ethtool_ops->get_link)
		return slave_dev->ethtool_ops->get_link(slave_dev) ?
			BMSR_LSTATUS : 0;
455

S
Stephen Hemminger 已提交
456
	/* Ethtool can't be used, fallback to MII ioctls. */
457
	ioctl = slave_ops->ndo_do_ioctl;
L
Linus Torvalds 已提交
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
	if (ioctl) {
		/* TODO: set pointer to correct ioctl on a per team member */
		/*       bases to make this more efficient. that is, once  */
		/*       we determine the correct ioctl, we will always    */
		/*       call it and not the others for that team          */
		/*       member.                                           */

		/*
		 * We cannot assume that SIOCGMIIPHY will also read a
		 * register; not all network drivers (e.g., e100)
		 * support that.
		 */

		/* Yes, the mii is overlaid on the ifreq.ifr_ifru */
		strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
		mii = if_mii(&ifr);
		if (IOCTL(slave_dev, &ifr, SIOCGMIIPHY) == 0) {
			mii->reg_num = MII_BMSR;
S
Stephen Hemminger 已提交
476 477
			if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0)
				return mii->val_out & BMSR_LSTATUS;
L
Linus Torvalds 已提交
478 479 480 481 482
		}
	}

	/*
	 * If reporting, report that either there's no dev->do_ioctl,
483
	 * or both SIOCGMIIREG and get_link failed (meaning that we
L
Linus Torvalds 已提交
484 485 486
	 * cannot report link status).  If not reporting, pretend
	 * we're ok.
	 */
S
Stephen Hemminger 已提交
487
	return reporting ? -1 : BMSR_LSTATUS;
L
Linus Torvalds 已提交
488 489 490 491 492 493 494
}

/*----------------------------- Multicast list ------------------------------*/

/*
 * Push the promiscuity flag down to appropriate slaves
 */
495
static int bond_set_promiscuity(struct bonding *bond, int inc)
L
Linus Torvalds 已提交
496
{
497
	struct list_head *iter;
498
	int err = 0;
499

L
Linus Torvalds 已提交
500 501 502
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
		if (bond->curr_active_slave) {
503 504
			err = dev_set_promiscuity(bond->curr_active_slave->dev,
						  inc);
L
Linus Torvalds 已提交
505 506 507
		}
	} else {
		struct slave *slave;
508

509
		bond_for_each_slave(bond, slave, iter) {
510 511 512
			err = dev_set_promiscuity(slave->dev, inc);
			if (err)
				return err;
L
Linus Torvalds 已提交
513 514
		}
	}
515
	return err;
L
Linus Torvalds 已提交
516 517 518 519 520
}

/*
 * Push the allmulti flag down to all slaves
 */
521
static int bond_set_allmulti(struct bonding *bond, int inc)
L
Linus Torvalds 已提交
522
{
523
	struct list_head *iter;
524
	int err = 0;
525

L
Linus Torvalds 已提交
526 527 528
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
		if (bond->curr_active_slave) {
529 530
			err = dev_set_allmulti(bond->curr_active_slave->dev,
					       inc);
L
Linus Torvalds 已提交
531 532 533
		}
	} else {
		struct slave *slave;
534

535
		bond_for_each_slave(bond, slave, iter) {
536 537 538
			err = dev_set_allmulti(slave->dev, inc);
			if (err)
				return err;
L
Linus Torvalds 已提交
539 540
		}
	}
541
	return err;
L
Linus Torvalds 已提交
542 543
}

544 545 546 547 548
/*
 * Retrieve the list of registered multicast addresses for the bonding
 * device and retransmit an IGMP JOIN request to the current active
 * slave.
 */
549
static void bond_resend_igmp_join_requests_delayed(struct work_struct *work)
550
{
551 552 553
	struct bonding *bond = container_of(work, struct bonding,
					    mcast_work.work);

554
	if (!rtnl_trylock()) {
555
		queue_delayed_work(bond->wq, &bond->mcast_work, 1);
556
		return;
557
	}
558
	call_netdevice_notifiers(NETDEV_RESEND_IGMP, bond->dev);
559

560 561
	if (bond->igmp_retrans > 1) {
		bond->igmp_retrans--;
562
		queue_delayed_work(bond->wq, &bond->mcast_work, HZ/5);
563
	}
564
	rtnl_unlock();
565 566
}

567
/* Flush bond's hardware addresses from slave
L
Linus Torvalds 已提交
568
 */
569
static void bond_hw_addr_flush(struct net_device *bond_dev,
S
Stephen Hemminger 已提交
570
			       struct net_device *slave_dev)
L
Linus Torvalds 已提交
571
{
572
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
573

574 575
	dev_uc_unsync(slave_dev, bond_dev);
	dev_mc_unsync(slave_dev, bond_dev);
L
Linus Torvalds 已提交
576 577 578 579 580

	if (bond->params.mode == BOND_MODE_8023AD) {
		/* del lacpdu mc addr from mc list */
		u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;

581
		dev_mc_del(slave_dev, lacpdu_multicast);
L
Linus Torvalds 已提交
582 583 584 585 586
	}
}

/*--------------------------- Active slave change ---------------------------*/

587 588 589 590
/* Update the hardware address list and promisc/allmulti for the new and
 * old active slaves (if any).  Modes that are !USES_PRIMARY keep all
 * slaves up date at all times; only the USES_PRIMARY modes need to call
 * this function to swap these settings during a failover.
L
Linus Torvalds 已提交
591
 */
592 593
static void bond_hw_addr_swap(struct bonding *bond, struct slave *new_active,
			      struct slave *old_active)
L
Linus Torvalds 已提交
594
{
595 596
	ASSERT_RTNL();

L
Linus Torvalds 已提交
597
	if (old_active) {
S
Stephen Hemminger 已提交
598
		if (bond->dev->flags & IFF_PROMISC)
L
Linus Torvalds 已提交
599 600
			dev_set_promiscuity(old_active->dev, -1);

S
Stephen Hemminger 已提交
601
		if (bond->dev->flags & IFF_ALLMULTI)
L
Linus Torvalds 已提交
602 603
			dev_set_allmulti(old_active->dev, -1);

604
		bond_hw_addr_flush(bond->dev, old_active->dev);
L
Linus Torvalds 已提交
605 606 607
	}

	if (new_active) {
608
		/* FIXME: Signal errors upstream. */
S
Stephen Hemminger 已提交
609
		if (bond->dev->flags & IFF_PROMISC)
L
Linus Torvalds 已提交
610 611
			dev_set_promiscuity(new_active->dev, 1);

S
Stephen Hemminger 已提交
612
		if (bond->dev->flags & IFF_ALLMULTI)
L
Linus Torvalds 已提交
613 614
			dev_set_allmulti(new_active->dev, 1);

615
		netif_addr_lock_bh(bond->dev);
616 617
		dev_uc_sync(new_active->dev, bond->dev);
		dev_mc_sync(new_active->dev, bond->dev);
618
		netif_addr_unlock_bh(bond->dev);
L
Linus Torvalds 已提交
619 620 621
	}
}

622 623 624 625 626 627 628 629 630 631
/**
 * bond_set_dev_addr - clone slave's address to bond
 * @bond_dev: bond net device
 * @slave_dev: slave net device
 *
 * Should be called with RTNL held.
 */
static void bond_set_dev_addr(struct net_device *bond_dev,
			      struct net_device *slave_dev)
{
632 633
	pr_debug("bond_dev=%p slave_dev=%p slave_dev->addr_len=%d\n",
		 bond_dev, slave_dev, slave_dev->addr_len);
634 635 636 637 638
	memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
	bond_dev->addr_assign_type = NET_ADDR_STOLEN;
	call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev);
}

639 640 641 642 643
/*
 * bond_do_fail_over_mac
 *
 * Perform special MAC address swapping for fail_over_mac settings
 *
644
 * Called with RTNL, curr_slave_lock for write_bh.
645 646 647 648
 */
static void bond_do_fail_over_mac(struct bonding *bond,
				  struct slave *new_active,
				  struct slave *old_active)
649 650
	__releases(&bond->curr_slave_lock)
	__acquires(&bond->curr_slave_lock)
651 652 653 654 655 656 657
{
	u8 tmp_mac[ETH_ALEN];
	struct sockaddr saddr;
	int rv;

	switch (bond->params.fail_over_mac) {
	case BOND_FOM_ACTIVE:
658 659
		if (new_active) {
			write_unlock_bh(&bond->curr_slave_lock);
660
			bond_set_dev_addr(bond->dev, new_active->dev);
661 662
			write_lock_bh(&bond->curr_slave_lock);
		}
663 664 665 666 667 668 669 670 671 672 673 674 675
		break;
	case BOND_FOM_FOLLOW:
		/*
		 * if new_active && old_active, swap them
		 * if just old_active, do nothing (going to no active slave)
		 * if just new_active, set new_active to bond's MAC
		 */
		if (!new_active)
			return;

		write_unlock_bh(&bond->curr_slave_lock);

		if (old_active) {
676
			ether_addr_copy(tmp_mac, new_active->dev->dev_addr);
677 678 679 680
			memcpy(saddr.sa_data, old_active->dev->dev_addr,
			       ETH_ALEN);
			saddr.sa_family = new_active->dev->type;
		} else {
681
			ether_addr_copy(saddr.sa_data, bond->dev->dev_addr);
682 683 684 685 686
			saddr.sa_family = bond->dev->type;
		}

		rv = dev_set_mac_address(new_active->dev, &saddr);
		if (rv) {
J
Joe Perches 已提交
687
			pr_err("%s: Error %d setting MAC of slave %s\n",
688 689 690 691 692 693 694
			       bond->dev->name, -rv, new_active->dev->name);
			goto out;
		}

		if (!old_active)
			goto out;

695
		ether_addr_copy(saddr.sa_data, tmp_mac);
696 697 698 699
		saddr.sa_family = old_active->dev->type;

		rv = dev_set_mac_address(old_active->dev, &saddr);
		if (rv)
J
Joe Perches 已提交
700
			pr_err("%s: Error %d setting MAC of slave %s\n",
701 702 703 704 705
			       bond->dev->name, -rv, new_active->dev->name);
out:
		write_lock_bh(&bond->curr_slave_lock);
		break;
	default:
J
Joe Perches 已提交
706
		pr_err("%s: bond_do_fail_over_mac impossible: bad policy %d\n",
707 708 709 710 711 712
		       bond->dev->name, bond->params.fail_over_mac);
		break;
	}

}

713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
static bool bond_should_change_active(struct bonding *bond)
{
	struct slave *prim = bond->primary_slave;
	struct slave *curr = bond->curr_active_slave;

	if (!prim || !curr || curr->link != BOND_LINK_UP)
		return true;
	if (bond->force_primary) {
		bond->force_primary = false;
		return true;
	}
	if (bond->params.primary_reselect == BOND_PRI_RESELECT_BETTER &&
	    (prim->speed < curr->speed ||
	     (prim->speed == curr->speed && prim->duplex <= curr->duplex)))
		return false;
	if (bond->params.primary_reselect == BOND_PRI_RESELECT_FAILURE)
		return false;
	return true;
}
732

L
Linus Torvalds 已提交
733 734 735 736 737 738
/**
 * find_best_interface - select the best available slave to be the active one
 * @bond: our bonding struct
 */
static struct slave *bond_find_best_slave(struct bonding *bond)
{
739 740
	struct slave *slave, *bestslave = NULL;
	struct list_head *iter;
L
Linus Torvalds 已提交
741 742
	int mintime = bond->params.updelay;

743 744 745
	if (bond->primary_slave && bond->primary_slave->link == BOND_LINK_UP &&
	    bond_should_change_active(bond))
		return bond->primary_slave;
L
Linus Torvalds 已提交
746

747 748 749 750 751 752 753
	bond_for_each_slave(bond, slave, iter) {
		if (slave->link == BOND_LINK_UP)
			return slave;
		if (slave->link == BOND_LINK_BACK && IS_UP(slave->dev) &&
		    slave->delay < mintime) {
			mintime = slave->delay;
			bestslave = slave;
L
Linus Torvalds 已提交
754 755 756 757 758 759
		}
	}

	return bestslave;
}

760 761
static bool bond_should_notify_peers(struct bonding *bond)
{
762 763 764 765 766
	struct slave *slave;

	rcu_read_lock();
	slave = rcu_dereference(bond->curr_active_slave);
	rcu_read_unlock();
767 768 769 770 771 772 773 774 775 776 777

	pr_debug("bond_should_notify_peers: bond %s slave %s\n",
		 bond->dev->name, slave ? slave->dev->name : "NULL");

	if (!slave || !bond->send_peer_notif ||
	    test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state))
		return false;

	return true;
}

L
Linus Torvalds 已提交
778 779 780 781 782 783 784 785 786 787 788 789 790
/**
 * change_active_interface - change the active slave into the specified one
 * @bond: our bonding struct
 * @new: the new slave to make the active one
 *
 * Set the new slave to the bond's settings and unset them on the old
 * curr_active_slave.
 * Setting include flags, mc-list, promiscuity, allmulti, etc.
 *
 * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP,
 * because it is apparently the best available slave we have, even though its
 * updelay hasn't timed out yet.
 *
791
 * If new_active is not NULL, caller must hold curr_slave_lock for write_bh.
L
Linus Torvalds 已提交
792
 */
793
void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
L
Linus Torvalds 已提交
794 795 796
{
	struct slave *old_active = bond->curr_active_slave;

S
Stephen Hemminger 已提交
797
	if (old_active == new_active)
L
Linus Torvalds 已提交
798 799 800
		return;

	if (new_active) {
801 802
		new_active->jiffies = jiffies;

L
Linus Torvalds 已提交
803 804
		if (new_active->link == BOND_LINK_BACK) {
			if (USES_PRIMARY(bond->params.mode)) {
J
Joe Perches 已提交
805
				pr_info("%s: making interface %s the new active one %d ms earlier\n",
J
Joe Perches 已提交
806 807
					bond->dev->name, new_active->dev->name,
					(bond->params.updelay - new_active->delay) * bond->params.miimon);
L
Linus Torvalds 已提交
808 809 810 811 812
			}

			new_active->delay = 0;
			new_active->link = BOND_LINK_UP;

S
Stephen Hemminger 已提交
813
			if (bond->params.mode == BOND_MODE_8023AD)
L
Linus Torvalds 已提交
814 815
				bond_3ad_handle_link_change(new_active, BOND_LINK_UP);

816
			if (bond_is_lb(bond))
L
Linus Torvalds 已提交
817 818 819
				bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
		} else {
			if (USES_PRIMARY(bond->params.mode)) {
J
Joe Perches 已提交
820
				pr_info("%s: making interface %s the new active one\n",
J
Joe Perches 已提交
821
					bond->dev->name, new_active->dev->name);
L
Linus Torvalds 已提交
822 823 824 825
			}
		}
	}

S
Stephen Hemminger 已提交
826
	if (USES_PRIMARY(bond->params.mode))
827
		bond_hw_addr_swap(bond, new_active, old_active);
L
Linus Torvalds 已提交
828

829
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
830
		bond_alb_handle_active_change(bond, new_active);
831 832 833 834
		if (old_active)
			bond_set_slave_inactive_flags(old_active);
		if (new_active)
			bond_set_slave_active_flags(new_active);
L
Linus Torvalds 已提交
835
	} else {
836
		rcu_assign_pointer(bond->curr_active_slave, new_active);
L
Linus Torvalds 已提交
837
	}
J
Jay Vosburgh 已提交
838 839

	if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
S
Stephen Hemminger 已提交
840
		if (old_active)
J
Jay Vosburgh 已提交
841 842 843
			bond_set_slave_inactive_flags(old_active);

		if (new_active) {
844 845
			bool should_notify_peers = false;

J
Jay Vosburgh 已提交
846
			bond_set_slave_active_flags(new_active);
847

848 849 850
			if (bond->params.fail_over_mac)
				bond_do_fail_over_mac(bond, new_active,
						      old_active);
851

852 853 854 855 856 857 858
			if (netif_running(bond->dev)) {
				bond->send_peer_notif =
					bond->params.num_peer_notif;
				should_notify_peers =
					bond_should_notify_peers(bond);
			}

859 860
			write_unlock_bh(&bond->curr_slave_lock);

861
			call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, bond->dev);
862
			if (should_notify_peers)
863 864
				call_netdevice_notifiers(NETDEV_NOTIFY_PEERS,
							 bond->dev);
865 866

			write_lock_bh(&bond->curr_slave_lock);
867
		}
J
Jay Vosburgh 已提交
868
	}
869

870
	/* resend IGMP joins since active slave has changed or
871 872 873 874 875 876
	 * all were sent on curr_active_slave.
	 * resend only if bond is brought up with the affected
	 * bonding modes and the retransmission is enabled */
	if (netif_running(bond->dev) && (bond->params.resend_igmp > 0) &&
	    ((USES_PRIMARY(bond->params.mode) && new_active) ||
	     bond->params.mode == BOND_MODE_ROUNDROBIN)) {
877
		bond->igmp_retrans = bond->params.resend_igmp;
878
		queue_delayed_work(bond->wq, &bond->mcast_work, 1);
879
	}
L
Linus Torvalds 已提交
880 881 882 883 884 885
}

/**
 * bond_select_active_slave - select a new active slave, if needed
 * @bond: our bonding struct
 *
S
Stephen Hemminger 已提交
886
 * This functions should be called when one of the following occurs:
L
Linus Torvalds 已提交
887 888 889 890
 * - The old curr_active_slave has been released or lost its link.
 * - The primary_slave has got its link back.
 * - A slave has got its link back and there's no old curr_active_slave.
 *
891
 * Caller must hold curr_slave_lock for write_bh.
L
Linus Torvalds 已提交
892
 */
893
void bond_select_active_slave(struct bonding *bond)
L
Linus Torvalds 已提交
894 895
{
	struct slave *best_slave;
896
	int rv;
L
Linus Torvalds 已提交
897 898 899 900

	best_slave = bond_find_best_slave(bond);
	if (best_slave != bond->curr_active_slave) {
		bond_change_active_slave(bond, best_slave);
901 902 903 904 905
		rv = bond_set_carrier(bond);
		if (!rv)
			return;

		if (netif_carrier_ok(bond->dev)) {
J
Joe Perches 已提交
906 907
			pr_info("%s: first active interface up!\n",
				bond->dev->name);
908
		} else {
J
Joe Perches 已提交
909
			pr_info("%s: now running without any active interface!\n",
J
Joe Perches 已提交
910
				bond->dev->name);
911
		}
L
Linus Torvalds 已提交
912 913 914
	}
}

915
#ifdef CONFIG_NET_POLL_CONTROLLER
916
static inline int slave_enable_netpoll(struct slave *slave)
917
{
918 919
	struct netpoll *np;
	int err = 0;
920

921
	np = kzalloc(sizeof(*np), GFP_ATOMIC);
922 923 924 925
	err = -ENOMEM;
	if (!np)
		goto out;

926
	err = __netpoll_setup(np, slave->dev, GFP_ATOMIC);
927 928 929
	if (err) {
		kfree(np);
		goto out;
930
	}
931 932 933 934 935 936 937 938 939 940 941 942
	slave->np = np;
out:
	return err;
}
static inline void slave_disable_netpoll(struct slave *slave)
{
	struct netpoll *np = slave->np;

	if (!np)
		return;

	slave->np = NULL;
943
	__netpoll_free_async(np);
944 945 946 947 948 949 950 951
}
static inline bool slave_dev_support_netpoll(struct net_device *slave_dev)
{
	if (slave_dev->priv_flags & IFF_DISABLE_NETPOLL)
		return false;
	if (!slave_dev->netdev_ops->ndo_poll_controller)
		return false;
	return true;
952 953 954 955
}

static void bond_poll_controller(struct net_device *bond_dev)
{
956 957
}

958
static void bond_netpoll_cleanup(struct net_device *bond_dev)
959
{
960
	struct bonding *bond = netdev_priv(bond_dev);
961
	struct list_head *iter;
962 963
	struct slave *slave;

964
	bond_for_each_slave(bond, slave, iter)
965 966
		if (IS_UP(slave->dev))
			slave_disable_netpoll(slave);
967
}
968

969
static int bond_netpoll_setup(struct net_device *dev, struct netpoll_info *ni, gfp_t gfp)
970 971
{
	struct bonding *bond = netdev_priv(dev);
972
	struct list_head *iter;
973
	struct slave *slave;
974
	int err = 0;
975

976
	bond_for_each_slave(bond, slave, iter) {
977 978
		err = slave_enable_netpoll(slave);
		if (err) {
979
			bond_netpoll_cleanup(dev);
980
			break;
981 982
		}
	}
983
	return err;
984
}
985 986 987 988 989 990 991 992
#else
static inline int slave_enable_netpoll(struct slave *slave)
{
	return 0;
}
static inline void slave_disable_netpoll(struct slave *slave)
{
}
993 994 995 996 997
static void bond_netpoll_cleanup(struct net_device *bond_dev)
{
}
#endif

L
Linus Torvalds 已提交
998 999
/*---------------------------------- IOCTL ----------------------------------*/

1000
static netdev_features_t bond_fix_features(struct net_device *dev,
1001
					   netdev_features_t features)
1002
{
1003
	struct bonding *bond = netdev_priv(dev);
1004
	struct list_head *iter;
1005
	netdev_features_t mask;
1006
	struct slave *slave;
1007

1008
	if (!bond_has_slaves(bond)) {
1009 1010
		/* Disable adding VLANs to empty bond. But why? --mq */
		features |= NETIF_F_VLAN_CHALLENGED;
1011
		return features;
1012
	}
1013

1014
	mask = features;
1015
	features &= ~NETIF_F_ONE_FOR_ALL;
1016
	features |= NETIF_F_ALL_FOR_ALL;
1017

1018
	bond_for_each_slave(bond, slave, iter) {
1019 1020
		features = netdev_increment_features(features,
						     slave->dev->features,
1021 1022
						     mask);
	}
1023
	features = netdev_add_tso_features(features, mask);
1024 1025 1026 1027

	return features;
}

1028 1029 1030
#define BOND_VLAN_FEATURES	(NETIF_F_ALL_CSUM | NETIF_F_SG | \
				 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
				 NETIF_F_HIGHDMA | NETIF_F_LRO)
1031 1032 1033

static void bond_compute_features(struct bonding *bond)
{
1034
	unsigned int flags, dst_release_flag = IFF_XMIT_DST_RELEASE;
1035
	netdev_features_t vlan_features = BOND_VLAN_FEATURES;
1036 1037 1038
	struct net_device *bond_dev = bond->dev;
	struct list_head *iter;
	struct slave *slave;
1039
	unsigned short max_hard_header_len = ETH_HLEN;
1040 1041
	unsigned int gso_max_size = GSO_MAX_SIZE;
	u16 gso_max_segs = GSO_MAX_SEGS;
1042

1043
	if (!bond_has_slaves(bond))
1044 1045
		goto done;

1046
	bond_for_each_slave(bond, slave, iter) {
1047
		vlan_features = netdev_increment_features(vlan_features,
1048 1049
			slave->dev->vlan_features, BOND_VLAN_FEATURES);

1050
		dst_release_flag &= slave->dev->priv_flags;
1051 1052
		if (slave->dev->hard_header_len > max_hard_header_len)
			max_hard_header_len = slave->dev->hard_header_len;
1053 1054 1055

		gso_max_size = min(gso_max_size, slave->dev->gso_max_size);
		gso_max_segs = min(gso_max_segs, slave->dev->gso_max_segs);
1056
	}
1057

1058
done:
1059
	bond_dev->vlan_features = vlan_features;
1060
	bond_dev->hard_header_len = max_hard_header_len;
1061 1062
	bond_dev->gso_max_segs = gso_max_segs;
	netif_set_gso_max_size(bond_dev, gso_max_size);
1063

1064 1065 1066
	flags = bond_dev->priv_flags & ~IFF_XMIT_DST_RELEASE;
	bond_dev->priv_flags = flags | dst_release_flag;

1067
	netdev_change_features(bond_dev);
1068 1069
}

1070 1071 1072
static void bond_setup_by_slave(struct net_device *bond_dev,
				struct net_device *slave_dev)
{
1073
	bond_dev->header_ops	    = slave_dev->header_ops;
1074 1075 1076 1077 1078 1079 1080 1081 1082

	bond_dev->type		    = slave_dev->type;
	bond_dev->hard_header_len   = slave_dev->hard_header_len;
	bond_dev->addr_len	    = slave_dev->addr_len;

	memcpy(bond_dev->broadcast, slave_dev->broadcast,
		slave_dev->addr_len);
}

1083
/* On bonding slaves other than the currently active slave, suppress
1084
 * duplicates except for alb non-mcast/bcast.
1085 1086
 */
static bool bond_should_deliver_exact_match(struct sk_buff *skb,
1087 1088
					    struct slave *slave,
					    struct bonding *bond)
1089
{
1090
	if (bond_is_slave_inactive(slave)) {
1091
		if (bond->params.mode == BOND_MODE_ALB &&
1092 1093 1094 1095 1096 1097 1098 1099
		    skb->pkt_type != PACKET_BROADCAST &&
		    skb->pkt_type != PACKET_MULTICAST)
			return false;
		return true;
	}
	return false;
}

1100
static rx_handler_result_t bond_handle_frame(struct sk_buff **pskb)
1101
{
1102
	struct sk_buff *skb = *pskb;
1103
	struct slave *slave;
1104
	struct bonding *bond;
1105 1106
	int (*recv_probe)(const struct sk_buff *, struct bonding *,
			  struct slave *);
1107
	int ret = RX_HANDLER_ANOTHER;
1108

1109 1110 1111 1112 1113
	skb = skb_share_check(skb, GFP_ATOMIC);
	if (unlikely(!skb))
		return RX_HANDLER_CONSUMED;

	*pskb = skb;
1114

J
Jiri Pirko 已提交
1115 1116
	slave = bond_slave_get_rcu(skb->dev);
	bond = slave->bond;
1117 1118

	if (bond->params.arp_interval)
1119
		slave->dev->last_rx = jiffies;
1120

1121 1122
	recv_probe = ACCESS_ONCE(bond->recv_probe);
	if (recv_probe) {
1123 1124 1125 1126
		ret = recv_probe(skb, bond, slave);
		if (ret == RX_HANDLER_CONSUMED) {
			consume_skb(skb);
			return ret;
1127 1128 1129
		}
	}

1130
	if (bond_should_deliver_exact_match(skb, slave, bond)) {
1131
		return RX_HANDLER_EXACT;
1132 1133
	}

J
Jiri Pirko 已提交
1134
	skb->dev = bond->dev;
1135

1136
	if (bond->params.mode == BOND_MODE_ALB &&
J
Jiri Pirko 已提交
1137
	    bond->dev->priv_flags & IFF_BRIDGE_PORT &&
1138 1139
	    skb->pkt_type == PACKET_HOST) {

1140 1141 1142
		if (unlikely(skb_cow_head(skb,
					  skb->data - skb_mac_header(skb)))) {
			kfree_skb(skb);
1143
			return RX_HANDLER_CONSUMED;
1144
		}
J
Jiri Pirko 已提交
1145
		memcpy(eth_hdr(skb)->h_dest, bond->dev->dev_addr, ETH_ALEN);
1146 1147
	}

1148
	return ret;
1149 1150
}

1151
static int bond_master_upper_dev_link(struct net_device *bond_dev,
1152 1153
				      struct net_device *slave_dev,
				      struct slave *slave)
1154 1155 1156
{
	int err;

1157
	err = netdev_master_upper_dev_link_private(slave_dev, bond_dev, slave);
1158 1159 1160
	if (err)
		return err;
	slave_dev->flags |= IFF_SLAVE;
1161
	rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE, GFP_KERNEL);
1162 1163 1164 1165 1166 1167 1168 1169
	return 0;
}

static void bond_upper_dev_unlink(struct net_device *bond_dev,
				  struct net_device *slave_dev)
{
	netdev_upper_dev_unlink(slave_dev, bond_dev);
	slave_dev->flags &= ~IFF_SLAVE;
1170
	rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE, GFP_KERNEL);
1171 1172
}

L
Linus Torvalds 已提交
1173
/* enslave device <slave> to bond device <master> */
1174
int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
L
Linus Torvalds 已提交
1175
{
1176
	struct bonding *bond = netdev_priv(bond_dev);
1177
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
1178
	struct slave *new_slave = NULL, *prev_slave;
L
Linus Torvalds 已提交
1179 1180
	struct sockaddr addr;
	int link_reporting;
1181
	int res = 0, i;
L
Linus Torvalds 已提交
1182

1183 1184 1185
	if (!bond->params.use_carrier &&
	    slave_dev->ethtool_ops->get_link == NULL &&
	    slave_ops->ndo_do_ioctl == NULL) {
1186 1187
		pr_warn("%s: Warning: no link monitoring support for %s\n",
			bond_dev->name, slave_dev->name);
L
Linus Torvalds 已提交
1188 1189 1190 1191
	}

	/* already enslaved */
	if (slave_dev->flags & IFF_SLAVE) {
J
Joe Perches 已提交
1192
		pr_debug("Error: Device was already enslaved\n");
L
Linus Torvalds 已提交
1193 1194 1195 1196 1197 1198
		return -EBUSY;
	}

	/* vlan challenged mutual exclusion */
	/* no need to lock since we're protected by rtnl_lock */
	if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) {
1199
		pr_debug("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
1200
		if (vlan_uses_dev(bond_dev)) {
J
Joe Perches 已提交
1201 1202
			pr_err("%s: Error: cannot enslave VLAN challenged slave %s on VLAN enabled bond %s\n",
			       bond_dev->name, slave_dev->name, bond_dev->name);
L
Linus Torvalds 已提交
1203 1204
			return -EPERM;
		} else {
1205 1206 1207
			pr_warn("%s: Warning: enslaved VLAN challenged slave %s. Adding VLANs will be blocked as long as %s is part of bond %s\n",
				bond_dev->name, slave_dev->name,
				slave_dev->name, bond_dev->name);
L
Linus Torvalds 已提交
1208 1209
		}
	} else {
1210
		pr_debug("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
L
Linus Torvalds 已提交
1211 1212
	}

1213 1214
	/*
	 * Old ifenslave binaries are no longer supported.  These can
S
Stephen Hemminger 已提交
1215
	 * be identified with moderate accuracy by the state of the slave:
1216 1217 1218 1219
	 * the current ifenslave will set the interface down prior to
	 * enslaving it; the old ifenslave will not.
	 */
	if ((slave_dev->flags & IFF_UP)) {
J
Joe Perches 已提交
1220
		pr_err("%s is up - this may be due to an out of date ifenslave\n",
1221 1222 1223 1224
		       slave_dev->name);
		res = -EPERM;
		goto err_undo_flags;
	}
L
Linus Torvalds 已提交
1225

1226 1227 1228 1229 1230 1231 1232
	/* set bonding device ether type by slave - bonding netdevices are
	 * created with ether_setup, so when the slave type is not ARPHRD_ETHER
	 * there is a need to override some of the type dependent attribs/funcs.
	 *
	 * bond ether type mutual exclusion - don't allow slaves of dissimilar
	 * ether type (eg ARPHRD_ETHER and ARPHRD_INFINIBAND) share the same bond
	 */
1233
	if (!bond_has_slaves(bond)) {
1234 1235
		if (bond_dev->type != slave_dev->type) {
			pr_debug("%s: change device type from %d to %d\n",
J
Joe Perches 已提交
1236 1237
				 bond_dev->name,
				 bond_dev->type, slave_dev->type);
1238

1239 1240
			res = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE,
						       bond_dev);
1241 1242 1243 1244 1245 1246 1247
			res = notifier_to_errno(res);
			if (res) {
				pr_err("%s: refused to change device type\n",
				       bond_dev->name);
				res = -EBUSY;
				goto err_undo_flags;
			}
1248

1249
			/* Flush unicast and multicast addresses */
1250
			dev_uc_flush(bond_dev);
1251
			dev_mc_flush(bond_dev);
1252

1253 1254
			if (slave_dev->type != ARPHRD_ETHER)
				bond_setup_by_slave(bond_dev, slave_dev);
1255
			else {
1256
				ether_setup(bond_dev);
1257 1258
				bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING;
			}
1259

1260 1261
			call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE,
						 bond_dev);
1262
		}
1263
	} else if (bond_dev->type != slave_dev->type) {
J
Joe Perches 已提交
1264 1265
		pr_err("%s ether type (%d) is different from other slaves (%d), can not enslave it\n",
		       slave_dev->name, slave_dev->type, bond_dev->type);
J
Joe Perches 已提交
1266 1267
		res = -EINVAL;
		goto err_undo_flags;
1268 1269
	}

1270
	if (slave_ops->ndo_set_mac_address == NULL) {
1271
		if (!bond_has_slaves(bond)) {
J
Joe Perches 已提交
1272
			pr_warn("%s: Warning: The first slave device specified does not support setting the MAC address\n",
1273 1274 1275
				bond_dev->name);
			if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
				bond->params.fail_over_mac = BOND_FOM_ACTIVE;
J
Joe Perches 已提交
1276
				pr_warn("%s: Setting fail_over_mac to active for active-backup mode\n",
1277 1278
					bond_dev->name);
			}
1279
		} else if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
J
Joe Perches 已提交
1280
			pr_err("%s: Error: The slave device specified does not support setting the MAC address, but fail_over_mac is not set to active\n",
J
Joe Perches 已提交
1281
			       bond_dev->name);
1282 1283 1284
			res = -EOPNOTSUPP;
			goto err_undo_flags;
		}
L
Linus Torvalds 已提交
1285 1286
	}

1287 1288
	call_netdevice_notifiers(NETDEV_JOIN, slave_dev);

1289 1290
	/* If this is the first slave, then we need to set the master's hardware
	 * address to be the same as the slave's. */
1291
	if (!bond_has_slaves(bond) &&
1292
	    bond->dev->addr_assign_type == NET_ADDR_RANDOM)
1293
		bond_set_dev_addr(bond->dev, slave_dev);
1294

1295
	new_slave = kzalloc(sizeof(struct slave), GFP_KERNEL);
L
Linus Torvalds 已提交
1296 1297 1298 1299
	if (!new_slave) {
		res = -ENOMEM;
		goto err_undo_flags;
	}
1300 1301 1302 1303 1304 1305
	/*
	 * Set the new_slave's queue_id to be zero.  Queue ID mapping
	 * is set via sysfs or module option if desired.
	 */
	new_slave->queue_id = 0;

1306 1307 1308 1309 1310 1311 1312 1313
	/* Save slave's original mtu and then set it to match the bond */
	new_slave->original_mtu = slave_dev->mtu;
	res = dev_set_mtu(slave_dev, bond->dev->mtu);
	if (res) {
		pr_debug("Error %d calling dev_set_mtu\n", res);
		goto err_free;
	}

1314 1315 1316 1317 1318
	/*
	 * Save slave's original ("permanent") mac address for modes
	 * that need it, and for restoring it upon release, and then
	 * set it to the master's address
	 */
1319
	ether_addr_copy(new_slave->perm_hwaddr, slave_dev->dev_addr);
L
Linus Torvalds 已提交
1320

1321 1322
	if (!bond->params.fail_over_mac ||
	    bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
1323 1324 1325 1326 1327 1328 1329 1330
		/*
		 * Set slave to master's mac address.  The application already
		 * set the master's mac address to that of the first slave
		 */
		memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
		addr.sa_family = slave_dev->type;
		res = dev_set_mac_address(slave_dev, &addr);
		if (res) {
1331
			pr_debug("Error %d calling set_mac_address\n", res);
1332
			goto err_restore_mtu;
1333
		}
1334
	}
L
Linus Torvalds 已提交
1335

1336 1337 1338
	/* open the slave since the application closed it */
	res = dev_open(slave_dev);
	if (res) {
S
Stephen Hemminger 已提交
1339
		pr_debug("Opening slave %s failed\n", slave_dev->name);
1340
		goto err_restore_mac;
L
Linus Torvalds 已提交
1341 1342
	}

J
Jiri Pirko 已提交
1343
	new_slave->bond = bond;
L
Linus Torvalds 已提交
1344
	new_slave->dev = slave_dev;
1345
	slave_dev->priv_flags |= IFF_BONDING;
L
Linus Torvalds 已提交
1346

1347
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
1348 1349 1350 1351
		/* bond_alb_init_slave() must be called before all other stages since
		 * it might fail and we do not want to have to undo everything
		 */
		res = bond_alb_init_slave(bond, new_slave);
S
Stephen Hemminger 已提交
1352
		if (res)
1353
			goto err_close;
L
Linus Torvalds 已提交
1354 1355
	}

1356 1357
	/* If the mode USES_PRIMARY, then the following is handled by
	 * bond_change_active_slave().
L
Linus Torvalds 已提交
1358 1359 1360 1361
	 */
	if (!USES_PRIMARY(bond->params.mode)) {
		/* set promiscuity level to new slave */
		if (bond_dev->flags & IFF_PROMISC) {
1362 1363 1364
			res = dev_set_promiscuity(slave_dev, 1);
			if (res)
				goto err_close;
L
Linus Torvalds 已提交
1365 1366 1367 1368
		}

		/* set allmulti level to new slave */
		if (bond_dev->flags & IFF_ALLMULTI) {
1369 1370 1371
			res = dev_set_allmulti(slave_dev, 1);
			if (res)
				goto err_close;
L
Linus Torvalds 已提交
1372 1373
		}

1374
		netif_addr_lock_bh(bond_dev);
1375 1376 1377 1378

		dev_mc_sync_multiple(slave_dev, bond_dev);
		dev_uc_sync_multiple(slave_dev, bond_dev);

1379
		netif_addr_unlock_bh(bond_dev);
L
Linus Torvalds 已提交
1380 1381 1382 1383 1384 1385
	}

	if (bond->params.mode == BOND_MODE_8023AD) {
		/* add lacpdu mc addr to mc list */
		u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;

1386
		dev_mc_add(slave_dev, lacpdu_multicast);
L
Linus Torvalds 已提交
1387 1388
	}

1389 1390
	res = vlan_vids_add_by_dev(slave_dev, bond_dev);
	if (res) {
1391 1392 1393 1394
		pr_err("%s: Error: Couldn't add bond vlan ids to %s\n",
		       bond_dev->name, slave_dev->name);
		goto err_close;
	}
L
Linus Torvalds 已提交
1395

1396
	prev_slave = bond_last_slave(bond);
L
Linus Torvalds 已提交
1397 1398 1399 1400

	new_slave->delay = 0;
	new_slave->link_failure_count = 0;

1401 1402
	bond_update_speed_duplex(new_slave);

1403 1404
	new_slave->last_arp_rx = jiffies -
		(msecs_to_jiffies(bond->params.arp_interval) + 1);
1405 1406
	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
		new_slave->target_last_arp_rx[i] = new_slave->last_arp_rx;
1407

L
Linus Torvalds 已提交
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
	if (bond->params.miimon && !bond->params.use_carrier) {
		link_reporting = bond_check_dev_link(bond, slave_dev, 1);

		if ((link_reporting == -1) && !bond->params.arp_interval) {
			/*
			 * miimon is set but a bonded network driver
			 * does not support ETHTOOL/MII and
			 * arp_interval is not set.  Note: if
			 * use_carrier is enabled, we will never go
			 * here (because netif_carrier is always
			 * supported); thus, we don't need to change
			 * the messages for netif_carrier.
			 */
1421 1422
			pr_warn("%s: Warning: 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",
				bond_dev->name, slave_dev->name);
L
Linus Torvalds 已提交
1423 1424
		} else if (link_reporting == -1) {
			/* unable get link status using mii/ethtool */
1425 1426
			pr_warn("%s: Warning: 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",
				bond_dev->name, slave_dev->name);
L
Linus Torvalds 已提交
1427 1428 1429 1430
		}
	}

	/* check for initial state */
1431 1432 1433 1434 1435 1436 1437 1438
	if (bond->params.miimon) {
		if (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS) {
			if (bond->params.updelay) {
				new_slave->link = BOND_LINK_BACK;
				new_slave->delay = bond->params.updelay;
			} else {
				new_slave->link = BOND_LINK_UP;
			}
L
Linus Torvalds 已提交
1439
		} else {
1440
			new_slave->link = BOND_LINK_DOWN;
L
Linus Torvalds 已提交
1441
		}
1442 1443 1444
	} else if (bond->params.arp_interval) {
		new_slave->link = (netif_carrier_ok(slave_dev) ?
			BOND_LINK_UP : BOND_LINK_DOWN);
L
Linus Torvalds 已提交
1445
	} else {
1446
		new_slave->link = BOND_LINK_UP;
L
Linus Torvalds 已提交
1447 1448
	}

1449 1450 1451
	if (new_slave->link != BOND_LINK_DOWN)
		new_slave->jiffies = jiffies;
	pr_debug("Initial state of slave_dev is BOND_LINK_%s\n",
J
Joe Perches 已提交
1452 1453
		 new_slave->link == BOND_LINK_DOWN ? "DOWN" :
		 (new_slave->link == BOND_LINK_UP ? "UP" : "BACK"));
1454

L
Linus Torvalds 已提交
1455 1456
	if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
		/* if there is a primary slave, remember it */
1457
		if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
L
Linus Torvalds 已提交
1458
			bond->primary_slave = new_slave;
1459 1460
			bond->force_primary = true;
		}
L
Linus Torvalds 已提交
1461 1462 1463 1464
	}

	switch (bond->params.mode) {
	case BOND_MODE_ACTIVEBACKUP:
1465
		bond_set_slave_inactive_flags(new_slave);
L
Linus Torvalds 已提交
1466 1467 1468 1469 1470 1471 1472 1473
		break;
	case BOND_MODE_8023AD:
		/* in 802.3ad mode, the internal mechanism
		 * will activate the slaves in the selected
		 * aggregator
		 */
		bond_set_slave_inactive_flags(new_slave);
		/* if this is the first slave */
1474
		if (!prev_slave) {
L
Linus Torvalds 已提交
1475 1476 1477 1478
			SLAVE_AD_INFO(new_slave).id = 1;
			/* Initialize AD with the number of times that the AD timer is called in 1 second
			 * can be called only after the mac address of the bond is set
			 */
1479
			bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL);
L
Linus Torvalds 已提交
1480 1481
		} else {
			SLAVE_AD_INFO(new_slave).id =
1482
				SLAVE_AD_INFO(prev_slave).id + 1;
L
Linus Torvalds 已提交
1483 1484 1485 1486 1487 1488
		}

		bond_3ad_bind_slave(new_slave);
		break;
	case BOND_MODE_TLB:
	case BOND_MODE_ALB:
J
Jiri Pirko 已提交
1489
		bond_set_active_slave(new_slave);
1490
		bond_set_slave_inactive_flags(new_slave);
L
Linus Torvalds 已提交
1491 1492
		break;
	default:
1493
		pr_debug("This slave is always active in trunk mode\n");
L
Linus Torvalds 已提交
1494 1495

		/* always active in trunk mode */
J
Jiri Pirko 已提交
1496
		bond_set_active_slave(new_slave);
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501

		/* In trunking mode there is little meaning to curr_active_slave
		 * anyway (it holds no special properties of the bond device),
		 * so we can change it without calling change_active_interface()
		 */
1502
		if (!bond->curr_active_slave && new_slave->link == BOND_LINK_UP)
1503
			rcu_assign_pointer(bond->curr_active_slave, new_slave);
S
Stephen Hemminger 已提交
1504

L
Linus Torvalds 已提交
1505 1506 1507
		break;
	} /* switch(bond_mode) */

1508
#ifdef CONFIG_NET_POLL_CONTROLLER
S
stephen hemminger 已提交
1509
	slave_dev->npinfo = bond->dev->npinfo;
1510 1511
	if (slave_dev->npinfo) {
		if (slave_enable_netpoll(new_slave)) {
J
Joe Perches 已提交
1512 1513
			pr_info("Error, %s: master_dev is using netpoll, but new slave device does not support netpoll\n",
				bond_dev->name);
1514
			res = -EBUSY;
1515
			goto err_detach;
1516
		}
1517 1518
	}
#endif
1519

J
Jiri Pirko 已提交
1520 1521 1522 1523
	res = netdev_rx_handler_register(slave_dev, bond_handle_frame,
					 new_slave);
	if (res) {
		pr_debug("Error %d calling netdev_rx_handler_register\n", res);
1524
		goto err_detach;
J
Jiri Pirko 已提交
1525 1526
	}

1527 1528 1529 1530 1531 1532
	res = bond_master_upper_dev_link(bond_dev, slave_dev, new_slave);
	if (res) {
		pr_debug("Error %d calling bond_master_upper_dev_link\n", res);
		goto err_unregister;
	}

1533 1534 1535 1536 1537 1538
	res = bond_sysfs_slave_add(new_slave);
	if (res) {
		pr_debug("Error %d calling bond_sysfs_slave_add\n", res);
		goto err_upper_unlink;
	}

1539 1540 1541 1542 1543 1544 1545 1546 1547
	bond->slave_cnt++;
	bond_compute_features(bond);
	bond_set_carrier(bond);

	if (USES_PRIMARY(bond->params.mode)) {
		write_lock_bh(&bond->curr_slave_lock);
		bond_select_active_slave(bond);
		write_unlock_bh(&bond->curr_slave_lock);
	}
1548

J
Joe Perches 已提交
1549
	pr_info("%s: Enslaving %s as %s interface with %s link\n",
J
Joe Perches 已提交
1550
		bond_dev->name, slave_dev->name,
J
Joe Perches 已提交
1551 1552
		bond_is_active_slave(new_slave) ? "an active" : "a backup",
		new_slave->link != BOND_LINK_DOWN ? "an up" : "a down");
L
Linus Torvalds 已提交
1553 1554 1555 1556 1557

	/* enslave is successful */
	return 0;

/* Undo stages on error */
1558 1559 1560
err_upper_unlink:
	bond_upper_dev_unlink(bond_dev, slave_dev);

1561 1562 1563
err_unregister:
	netdev_rx_handler_unregister(slave_dev);

1564
err_detach:
1565 1566 1567
	if (!USES_PRIMARY(bond->params.mode))
		bond_hw_addr_flush(bond_dev, slave_dev);

1568
	vlan_vids_del_by_dev(slave_dev, bond_dev);
1569 1570 1571 1572
	if (bond->primary_slave == new_slave)
		bond->primary_slave = NULL;
	if (bond->curr_active_slave == new_slave) {
		write_lock_bh(&bond->curr_slave_lock);
1573
		bond_change_active_slave(bond, NULL);
1574 1575 1576
		bond_select_active_slave(bond);
		write_unlock_bh(&bond->curr_slave_lock);
	}
1577
	slave_disable_netpoll(new_slave);
1578

L
Linus Torvalds 已提交
1579
err_close:
1580
	slave_dev->priv_flags &= ~IFF_BONDING;
L
Linus Torvalds 已提交
1581 1582 1583
	dev_close(slave_dev);

err_restore_mac:
1584 1585
	if (!bond->params.fail_over_mac ||
	    bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
1586 1587 1588 1589
		/* XXX TODO - fom follow mode needs to change master's
		 * MAC if this slave's MAC is in use by the bond, or at
		 * least print a warning.
		 */
1590
		ether_addr_copy(addr.sa_data, new_slave->perm_hwaddr);
1591 1592 1593
		addr.sa_family = slave_dev->type;
		dev_set_mac_address(slave_dev, &addr);
	}
L
Linus Torvalds 已提交
1594

1595 1596 1597
err_restore_mtu:
	dev_set_mtu(slave_dev, new_slave->original_mtu);

L
Linus Torvalds 已提交
1598 1599 1600 1601
err_free:
	kfree(new_slave);

err_undo_flags:
1602
	/* Enslave of first slave has failed and we need to fix master's mac */
1603
	if (!bond_has_slaves(bond) &&
1604
	    ether_addr_equal_64bits(bond_dev->dev_addr, slave_dev->dev_addr))
1605
		eth_hw_addr_random(bond_dev);
S
Stephen Hemminger 已提交
1606

L
Linus Torvalds 已提交
1607 1608 1609 1610 1611 1612
	return res;
}

/*
 * Try to release the slave device <slave> from the bond device <master>
 * It is legal to access curr_active_slave without a lock because all the function
1613 1614
 * is write-locked. If "all" is true it means that the function is being called
 * while destroying a bond interface and all slaves are being released.
L
Linus Torvalds 已提交
1615 1616 1617 1618 1619 1620 1621
 *
 * The rules for slave state should be:
 *   for Active/Backup:
 *     Active stays on all backups go down
 *   for Bonded connections:
 *     The first up interface should be left on and all others downed.
 */
1622 1623 1624
static int __bond_release_one(struct net_device *bond_dev,
			      struct net_device *slave_dev,
			      bool all)
L
Linus Torvalds 已提交
1625
{
1626
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
1627 1628
	struct slave *slave, *oldcurrent;
	struct sockaddr addr;
1629
	int old_flags = bond_dev->flags;
1630
	netdev_features_t old_features = bond_dev->features;
L
Linus Torvalds 已提交
1631 1632 1633

	/* slave is not a slave or master is not master of this slave */
	if (!(slave_dev->flags & IFF_SLAVE) ||
1634
	    !netdev_has_upper_dev(slave_dev, bond_dev)) {
J
Joe Perches 已提交
1635
		pr_err("%s: Error: cannot release %s\n",
L
Linus Torvalds 已提交
1636 1637 1638 1639
		       bond_dev->name, slave_dev->name);
		return -EINVAL;
	}

1640
	block_netpoll_tx();
L
Linus Torvalds 已提交
1641 1642 1643 1644

	slave = bond_get_slave_by_dev(bond, slave_dev);
	if (!slave) {
		/* not a slave of this bond */
J
Joe Perches 已提交
1645 1646
		pr_info("%s: %s not enslaved\n",
			bond_dev->name, slave_dev->name);
1647
		unblock_netpoll_tx();
L
Linus Torvalds 已提交
1648 1649 1650
		return -EINVAL;
	}

1651 1652 1653
	/* release the slave from its bond */
	bond->slave_cnt--;

1654 1655
	bond_sysfs_slave_del(slave);

1656
	bond_upper_dev_unlink(bond_dev, slave_dev);
J
Jiri Pirko 已提交
1657 1658 1659 1660 1661 1662
	/* unregister rx_handler early so bond_handle_frame wouldn't be called
	 * for this slave anymore.
	 */
	netdev_rx_handler_unregister(slave_dev);
	write_lock_bh(&bond->lock);

L
Linus Torvalds 已提交
1663
	/* Inform AD package of unbinding of slave. */
1664
	if (bond->params.mode == BOND_MODE_8023AD)
L
Linus Torvalds 已提交
1665
		bond_3ad_unbind_slave(slave);
1666

1667
	write_unlock_bh(&bond->lock);
L
Linus Torvalds 已提交
1668

J
Joe Perches 已提交
1669
	pr_info("%s: Releasing %s interface %s\n",
J
Joe Perches 已提交
1670
		bond_dev->name,
J
Jiri Pirko 已提交
1671
		bond_is_active_slave(slave) ? "active" : "backup",
J
Joe Perches 已提交
1672
		slave_dev->name);
L
Linus Torvalds 已提交
1673 1674 1675 1676 1677

	oldcurrent = bond->curr_active_slave;

	bond->current_arp_slave = NULL;

1678 1679
	if (!all && (!bond->params.fail_over_mac ||
		     bond->params.mode != BOND_MODE_ACTIVEBACKUP)) {
1680
		if (ether_addr_equal_64bits(bond_dev->dev_addr, slave->perm_hwaddr) &&
1681
		    bond_has_slaves(bond))
J
Joe Perches 已提交
1682 1683 1684 1685
			pr_warn("%s: Warning: 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",
				bond_dev->name, slave_dev->name,
				slave->perm_hwaddr,
				bond_dev->name, slave_dev->name);
1686 1687
	}

S
Stephen Hemminger 已提交
1688
	if (bond->primary_slave == slave)
L
Linus Torvalds 已提交
1689 1690
		bond->primary_slave = NULL;

1691 1692
	if (oldcurrent == slave) {
		write_lock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
1693
		bond_change_active_slave(bond, NULL);
1694 1695
		write_unlock_bh(&bond->curr_slave_lock);
	}
L
Linus Torvalds 已提交
1696

1697
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
1698 1699 1700 1701 1702 1703 1704 1705
		/* Must be called only after the slave has been
		 * detached from the list and the curr_active_slave
		 * has been cleared (if our_slave == old_current),
		 * but before a new active slave is selected.
		 */
		bond_alb_deinit_slave(bond, slave);
	}

1706
	if (all) {
1707
		RCU_INIT_POINTER(bond->curr_active_slave, NULL);
1708
	} else if (oldcurrent == slave) {
1709 1710 1711 1712 1713 1714 1715
		/*
		 * Note that we hold RTNL over this sequence, so there
		 * is no concern that another slave add/remove event
		 * will interfere.
		 */
		write_lock_bh(&bond->curr_slave_lock);

L
Linus Torvalds 已提交
1716 1717
		bond_select_active_slave(bond);

1718 1719 1720
		write_unlock_bh(&bond->curr_slave_lock);
	}

1721
	if (!bond_has_slaves(bond)) {
1722
		bond_set_carrier(bond);
1723
		eth_hw_addr_random(bond_dev);
L
Linus Torvalds 已提交
1724

1725
		if (vlan_uses_dev(bond_dev)) {
1726 1727 1728 1729
			pr_warn("%s: Warning: clearing HW address of %s while it still has VLANs\n",
				bond_dev->name, bond_dev->name);
			pr_warn("%s: When re-adding slaves, make sure the bond's HW address matches its VLANs\n",
				bond_dev->name);
L
Linus Torvalds 已提交
1730 1731 1732
		}
	}

1733
	unblock_netpoll_tx();
1734
	synchronize_rcu();
L
Linus Torvalds 已提交
1735

1736
	if (!bond_has_slaves(bond)) {
1737
		call_netdevice_notifiers(NETDEV_CHANGEADDR, bond->dev);
1738 1739
		call_netdevice_notifiers(NETDEV_RELEASE, bond->dev);
	}
1740

1741 1742 1743
	bond_compute_features(bond);
	if (!(bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
	    (old_features & NETIF_F_VLAN_CHALLENGED))
J
Joe Perches 已提交
1744
		pr_info("%s: last VLAN challenged slave %s left bond %s - VLAN blocking is removed\n",
1745 1746
			bond_dev->name, slave_dev->name, bond_dev->name);

1747
	/* must do this from outside any spinlocks */
1748
	vlan_vids_del_by_dev(slave_dev, bond_dev);
L
Linus Torvalds 已提交
1749

1750 1751
	/* If the mode USES_PRIMARY, then this cases was handled above by
	 * bond_change_active_slave(..., NULL)
L
Linus Torvalds 已提交
1752 1753
	 */
	if (!USES_PRIMARY(bond->params.mode)) {
1754 1755 1756 1757 1758 1759 1760 1761
		/* unset promiscuity level from slave
		 * NOTE: The NETDEV_CHANGEADDR call above may change the value
		 * of the IFF_PROMISC flag in the bond_dev, but we need the
		 * value of that flag before that change, as that was the value
		 * when this slave was attached, so we cache at the start of the
		 * function and use it here. Same goes for ALLMULTI below
		 */
		if (old_flags & IFF_PROMISC)
L
Linus Torvalds 已提交
1762 1763 1764
			dev_set_promiscuity(slave_dev, -1);

		/* unset allmulti level from slave */
1765
		if (old_flags & IFF_ALLMULTI)
L
Linus Torvalds 已提交
1766 1767
			dev_set_allmulti(slave_dev, -1);

1768
		bond_hw_addr_flush(bond_dev, slave_dev);
L
Linus Torvalds 已提交
1769 1770
	}

1771
	slave_disable_netpoll(slave);
1772

L
Linus Torvalds 已提交
1773 1774 1775
	/* close slave before restoring its mac address */
	dev_close(slave_dev);

1776 1777
	if (bond->params.fail_over_mac != BOND_FOM_ACTIVE ||
	    bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
1778
		/* restore original ("permanent") mac address */
1779
		ether_addr_copy(addr.sa_data, slave->perm_hwaddr);
1780 1781 1782
		addr.sa_family = slave_dev->type;
		dev_set_mac_address(slave_dev, &addr);
	}
L
Linus Torvalds 已提交
1783

1784 1785
	dev_set_mtu(slave_dev, slave->original_mtu);

1786
	slave_dev->priv_flags &= ~IFF_BONDING;
L
Linus Torvalds 已提交
1787 1788 1789 1790 1791 1792

	kfree(slave);

	return 0;  /* deletion OK */
}

1793 1794 1795 1796 1797 1798
/* A wrapper used because of ndo_del_link */
int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
{
	return __bond_release_one(bond_dev, slave_dev, false);
}

1799
/*
1800
* First release a slave and then destroy the bond if no more slaves are left.
1801 1802
* Must be under rtnl_lock when this function is called.
*/
1803 1804
static int  bond_release_and_destroy(struct net_device *bond_dev,
				     struct net_device *slave_dev)
1805
{
1806
	struct bonding *bond = netdev_priv(bond_dev);
1807 1808 1809
	int ret;

	ret = bond_release(bond_dev, slave_dev);
1810
	if (ret == 0 && !bond_has_slaves(bond)) {
1811
		bond_dev->priv_flags |= IFF_DISABLE_NETPOLL;
J
Joe Perches 已提交
1812
		pr_info("%s: Destroying bond %s\n",
J
Joe Perches 已提交
1813
			bond_dev->name, bond_dev->name);
S
Stephen Hemminger 已提交
1814
		unregister_netdevice(bond_dev);
1815 1816 1817 1818
	}
	return ret;
}

L
Linus Torvalds 已提交
1819 1820
static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
{
1821
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
1822 1823 1824 1825

	info->bond_mode = bond->params.mode;
	info->miimon = bond->params.miimon;

1826
	read_lock(&bond->lock);
L
Linus Torvalds 已提交
1827
	info->num_slaves = bond->slave_cnt;
1828
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
1829 1830 1831 1832 1833 1834

	return 0;
}

static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info)
{
1835
	struct bonding *bond = netdev_priv(bond_dev);
1836
	struct list_head *iter;
1837
	int i = 0, res = -ENODEV;
L
Linus Torvalds 已提交
1838 1839
	struct slave *slave;

1840
	read_lock(&bond->lock);
1841
	bond_for_each_slave(bond, slave, iter) {
1842
		if (i++ == (int)info->slave_id) {
1843 1844 1845
			res = 0;
			strcpy(info->slave_name, slave->dev->name);
			info->link = slave->link;
J
Jiri Pirko 已提交
1846
			info->state = bond_slave_state(slave);
1847
			info->link_failure_count = slave->link_failure_count;
L
Linus Torvalds 已提交
1848 1849 1850
			break;
		}
	}
1851
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
1852

1853
	return res;
L
Linus Torvalds 已提交
1854 1855 1856 1857 1858
}

/*-------------------------------- Monitoring -------------------------------*/


J
Jay Vosburgh 已提交
1859 1860
static int bond_miimon_inspect(struct bonding *bond)
{
1861
	int link_state, commit = 0;
1862
	struct list_head *iter;
J
Jay Vosburgh 已提交
1863
	struct slave *slave;
1864 1865 1866
	bool ignore_updelay;

	ignore_updelay = !bond->curr_active_slave ? true : false;
L
Linus Torvalds 已提交
1867

1868
	bond_for_each_slave_rcu(bond, slave, iter) {
J
Jay Vosburgh 已提交
1869
		slave->new_link = BOND_LINK_NOCHANGE;
L
Linus Torvalds 已提交
1870

J
Jay Vosburgh 已提交
1871
		link_state = bond_check_dev_link(bond, slave->dev, 0);
L
Linus Torvalds 已提交
1872 1873

		switch (slave->link) {
J
Jay Vosburgh 已提交
1874 1875 1876
		case BOND_LINK_UP:
			if (link_state)
				continue;
L
Linus Torvalds 已提交
1877

J
Jay Vosburgh 已提交
1878 1879 1880
			slave->link = BOND_LINK_FAIL;
			slave->delay = bond->params.downdelay;
			if (slave->delay) {
J
Joe Perches 已提交
1881
				pr_info("%s: link status down for %sinterface %s, disabling it in %d ms\n",
J
Joe Perches 已提交
1882 1883 1884
					bond->dev->name,
					(bond->params.mode ==
					 BOND_MODE_ACTIVEBACKUP) ?
J
Jiri Pirko 已提交
1885
					(bond_is_active_slave(slave) ?
J
Joe Perches 已提交
1886 1887 1888
					 "active " : "backup ") : "",
					slave->dev->name,
					bond->params.downdelay * bond->params.miimon);
L
Linus Torvalds 已提交
1889
			}
J
Jay Vosburgh 已提交
1890 1891 1892 1893 1894 1895 1896
			/*FALLTHRU*/
		case BOND_LINK_FAIL:
			if (link_state) {
				/*
				 * recovered before downdelay expired
				 */
				slave->link = BOND_LINK_UP;
L
Linus Torvalds 已提交
1897
				slave->jiffies = jiffies;
J
Joe Perches 已提交
1898
				pr_info("%s: link status up again after %d ms for interface %s\n",
J
Joe Perches 已提交
1899 1900 1901 1902
					bond->dev->name,
					(bond->params.downdelay - slave->delay) *
					bond->params.miimon,
					slave->dev->name);
J
Jay Vosburgh 已提交
1903
				continue;
L
Linus Torvalds 已提交
1904
			}
J
Jay Vosburgh 已提交
1905 1906 1907 1908 1909

			if (slave->delay <= 0) {
				slave->new_link = BOND_LINK_DOWN;
				commit++;
				continue;
L
Linus Torvalds 已提交
1910 1911
			}

J
Jay Vosburgh 已提交
1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
			slave->delay--;
			break;

		case BOND_LINK_DOWN:
			if (!link_state)
				continue;

			slave->link = BOND_LINK_BACK;
			slave->delay = bond->params.updelay;

			if (slave->delay) {
J
Joe Perches 已提交
1923
				pr_info("%s: link status up for interface %s, enabling it in %d ms\n",
J
Joe Perches 已提交
1924 1925 1926 1927
					bond->dev->name, slave->dev->name,
					ignore_updelay ? 0 :
					bond->params.updelay *
					bond->params.miimon);
J
Jay Vosburgh 已提交
1928 1929 1930 1931 1932
			}
			/*FALLTHRU*/
		case BOND_LINK_BACK:
			if (!link_state) {
				slave->link = BOND_LINK_DOWN;
J
Joe Perches 已提交
1933
				pr_info("%s: link status down again after %d ms for interface %s\n",
J
Joe Perches 已提交
1934 1935 1936 1937
					bond->dev->name,
					(bond->params.updelay - slave->delay) *
					bond->params.miimon,
					slave->dev->name);
J
Jay Vosburgh 已提交
1938 1939 1940 1941

				continue;
			}

1942 1943 1944
			if (ignore_updelay)
				slave->delay = 0;

J
Jay Vosburgh 已提交
1945 1946 1947
			if (slave->delay <= 0) {
				slave->new_link = BOND_LINK_UP;
				commit++;
1948
				ignore_updelay = false;
J
Jay Vosburgh 已提交
1949
				continue;
L
Linus Torvalds 已提交
1950
			}
J
Jay Vosburgh 已提交
1951 1952

			slave->delay--;
L
Linus Torvalds 已提交
1953
			break;
J
Jay Vosburgh 已提交
1954 1955
		}
	}
L
Linus Torvalds 已提交
1956

J
Jay Vosburgh 已提交
1957 1958
	return commit;
}
L
Linus Torvalds 已提交
1959

J
Jay Vosburgh 已提交
1960 1961
static void bond_miimon_commit(struct bonding *bond)
{
1962
	struct list_head *iter;
J
Jay Vosburgh 已提交
1963 1964
	struct slave *slave;

1965
	bond_for_each_slave(bond, slave, iter) {
J
Jay Vosburgh 已提交
1966 1967 1968
		switch (slave->new_link) {
		case BOND_LINK_NOCHANGE:
			continue;
L
Linus Torvalds 已提交
1969

J
Jay Vosburgh 已提交
1970 1971 1972 1973 1974 1975
		case BOND_LINK_UP:
			slave->link = BOND_LINK_UP;
			slave->jiffies = jiffies;

			if (bond->params.mode == BOND_MODE_8023AD) {
				/* prevent it from being the active one */
J
Jiri Pirko 已提交
1976
				bond_set_backup_slave(slave);
J
Jay Vosburgh 已提交
1977 1978
			} else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
				/* make it immediately active */
J
Jiri Pirko 已提交
1979
				bond_set_active_slave(slave);
J
Jay Vosburgh 已提交
1980 1981
			} else if (slave != bond->primary_slave) {
				/* prevent it from being the active one */
J
Jiri Pirko 已提交
1982
				bond_set_backup_slave(slave);
L
Linus Torvalds 已提交
1983 1984
			}

J
Joe Perches 已提交
1985
			pr_info("%s: link status definitely up for interface %s, %u Mbps %s duplex\n",
1986
				bond->dev->name, slave->dev->name,
1987 1988
				slave->speed == SPEED_UNKNOWN ? 0 : slave->speed,
				slave->duplex ? "full" : "half");
L
Linus Torvalds 已提交
1989

J
Jay Vosburgh 已提交
1990 1991 1992
			/* notify ad that the link status has changed */
			if (bond->params.mode == BOND_MODE_8023AD)
				bond_3ad_handle_link_change(slave, BOND_LINK_UP);
1993

1994
			if (bond_is_lb(bond))
J
Jay Vosburgh 已提交
1995 1996
				bond_alb_handle_link_change(bond, slave,
							    BOND_LINK_UP);
L
Linus Torvalds 已提交
1997

J
Jay Vosburgh 已提交
1998 1999 2000
			if (!bond->curr_active_slave ||
			    (slave == bond->primary_slave))
				goto do_failover;
L
Linus Torvalds 已提交
2001

J
Jay Vosburgh 已提交
2002
			continue;
2003

J
Jay Vosburgh 已提交
2004
		case BOND_LINK_DOWN:
J
Jay Vosburgh 已提交
2005 2006 2007
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;

J
Jay Vosburgh 已提交
2008
			slave->link = BOND_LINK_DOWN;
L
Linus Torvalds 已提交
2009

J
Jay Vosburgh 已提交
2010 2011 2012 2013
			if (bond->params.mode == BOND_MODE_ACTIVEBACKUP ||
			    bond->params.mode == BOND_MODE_8023AD)
				bond_set_slave_inactive_flags(slave);

J
Joe Perches 已提交
2014 2015
			pr_info("%s: link status definitely down for interface %s, disabling it\n",
				bond->dev->name, slave->dev->name);
J
Jay Vosburgh 已提交
2016 2017 2018 2019 2020

			if (bond->params.mode == BOND_MODE_8023AD)
				bond_3ad_handle_link_change(slave,
							    BOND_LINK_DOWN);

2021
			if (bond_is_lb(bond))
J
Jay Vosburgh 已提交
2022 2023 2024 2025 2026 2027 2028 2029 2030
				bond_alb_handle_link_change(bond, slave,
							    BOND_LINK_DOWN);

			if (slave == bond->curr_active_slave)
				goto do_failover;

			continue;

		default:
J
Joe Perches 已提交
2031
			pr_err("%s: invalid new link %d on slave %s\n",
J
Jay Vosburgh 已提交
2032 2033 2034 2035 2036 2037 2038 2039 2040
			       bond->dev->name, slave->new_link,
			       slave->dev->name);
			slave->new_link = BOND_LINK_NOCHANGE;

			continue;
		}

do_failover:
		ASSERT_RTNL();
2041
		block_netpoll_tx();
J
Jay Vosburgh 已提交
2042 2043 2044
		write_lock_bh(&bond->curr_slave_lock);
		bond_select_active_slave(bond);
		write_unlock_bh(&bond->curr_slave_lock);
2045
		unblock_netpoll_tx();
J
Jay Vosburgh 已提交
2046 2047 2048
	}

	bond_set_carrier(bond);
L
Linus Torvalds 已提交
2049 2050
}

2051 2052 2053 2054
/*
 * bond_mii_monitor
 *
 * Really a wrapper that splits the mii monitor into two phases: an
J
Jay Vosburgh 已提交
2055 2056 2057
 * inspection, then (if inspection indicates something needs to be done)
 * an acquisition of appropriate locks followed by a commit phase to
 * implement whatever link state changes are indicated.
2058
 */
2059
static void bond_mii_monitor(struct work_struct *work)
2060 2061 2062
{
	struct bonding *bond = container_of(work, struct bonding,
					    mii_work.work);
2063
	bool should_notify_peers = false;
2064
	unsigned long delay;
2065

2066 2067 2068
	delay = msecs_to_jiffies(bond->params.miimon);

	if (!bond_has_slaves(bond))
J
Jay Vosburgh 已提交
2069
		goto re_arm;
2070

2071 2072
	rcu_read_lock();

2073 2074
	should_notify_peers = bond_should_notify_peers(bond);

2075
	if (bond_miimon_inspect(bond)) {
2076
		rcu_read_unlock();
J
Jay Vosburgh 已提交
2077

2078 2079 2080 2081 2082 2083
		/* Race avoidance with bond_close cancel of workqueue */
		if (!rtnl_trylock()) {
			delay = 1;
			should_notify_peers = false;
			goto re_arm;
		}
2084

2085 2086 2087
		bond_miimon_commit(bond);

		rtnl_unlock();	/* might sleep, hold no other locks */
2088 2089
	} else
		rcu_read_unlock();
2090

J
Jay Vosburgh 已提交
2091
re_arm:
2092
	if (bond->params.miimon)
2093 2094 2095 2096 2097 2098 2099 2100
		queue_delayed_work(bond->wq, &bond->mii_work, delay);

	if (should_notify_peers) {
		if (!rtnl_trylock())
			return;
		call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
		rtnl_unlock();
	}
2101
}
J
Jay Vosburgh 已提交
2102

2103
static bool bond_has_this_ip(struct bonding *bond, __be32 ip)
2104
{
2105 2106 2107
	struct net_device *upper;
	struct list_head *iter;
	bool ret = false;
2108

2109
	if (ip == bond_confirm_addr(bond->dev, 0, ip))
2110
		return true;
2111

2112
	rcu_read_lock();
2113
	netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
2114 2115 2116 2117
		if (ip == bond_confirm_addr(upper, 0, ip)) {
			ret = true;
			break;
		}
2118
	}
2119
	rcu_read_unlock();
2120

2121
	return ret;
2122 2123
}

J
Jay Vosburgh 已提交
2124 2125 2126 2127 2128
/*
 * We go to the (large) trouble of VLAN tagging ARP frames because
 * switches in VLAN mode (especially if ports are configured as
 * "native" to a VLAN) might not pass non-tagged frames.
 */
2129
static void bond_arp_send(struct net_device *slave_dev, int arp_op, __be32 dest_ip, __be32 src_ip, unsigned short vlan_id)
J
Jay Vosburgh 已提交
2130 2131 2132
{
	struct sk_buff *skb;

J
Joe Perches 已提交
2133 2134
	pr_debug("arp %d on slave %s: dst %pI4 src %pI4 vid %d\n",
		 arp_op, slave_dev->name, &dest_ip, &src_ip, vlan_id);
S
Stephen Hemminger 已提交
2135

J
Jay Vosburgh 已提交
2136 2137 2138 2139
	skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip,
			 NULL, slave_dev->dev_addr, NULL);

	if (!skb) {
J
Joe Perches 已提交
2140
		pr_err("ARP packet allocation failed\n");
J
Jay Vosburgh 已提交
2141 2142 2143
		return;
	}
	if (vlan_id) {
2144
		skb = vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
J
Jay Vosburgh 已提交
2145
		if (!skb) {
J
Joe Perches 已提交
2146
			pr_err("failed to insert VLAN tag\n");
J
Jay Vosburgh 已提交
2147 2148 2149 2150 2151 2152 2153
			return;
		}
	}
	arp_xmit(skb);
}


L
Linus Torvalds 已提交
2154 2155
static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
{
2156 2157
	struct net_device *upper, *vlan_upper;
	struct list_head *iter, *vlan_iter;
J
Jay Vosburgh 已提交
2158
	struct rtable *rt;
2159 2160
	__be32 *targets = bond->params.arp_targets, addr;
	int i, vlan_id;
L
Linus Torvalds 已提交
2161

2162
	for (i = 0; i < BOND_MAX_ARP_TARGETS && targets[i]; i++) {
2163
		pr_debug("basa: target %pI4\n", &targets[i]);
J
Jay Vosburgh 已提交
2164

2165
		/* Find out through which dev should the packet go */
2166 2167
		rt = ip_route_output(dev_net(bond->dev), targets[i], 0,
				     RTO_ONLINK, 0);
2168
		if (IS_ERR(rt)) {
2169 2170
			pr_debug("%s: no route to arp_ip_target %pI4\n",
				 bond->dev->name, &targets[i]);
J
Jay Vosburgh 已提交
2171 2172 2173 2174
			continue;
		}

		vlan_id = 0;
2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187

		/* bond device itself */
		if (rt->dst.dev == bond->dev)
			goto found;

		rcu_read_lock();
		/* first we search only for vlan devices. for every vlan
		 * found we verify its upper dev list, searching for the
		 * rt->dst.dev. If found we save the tag of the vlan and
		 * proceed to send the packet.
		 *
		 * TODO: QinQ?
		 */
2188 2189
		netdev_for_each_all_upper_dev_rcu(bond->dev, vlan_upper,
						  vlan_iter) {
2190 2191
			if (!is_vlan_dev(vlan_upper))
				continue;
2192 2193
			netdev_for_each_all_upper_dev_rcu(vlan_upper, upper,
							  iter) {
2194 2195 2196 2197 2198
				if (upper == rt->dst.dev) {
					vlan_id = vlan_dev_vlan_id(vlan_upper);
					rcu_read_unlock();
					goto found;
				}
J
Jay Vosburgh 已提交
2199 2200 2201
			}
		}

2202 2203 2204 2205
		/* if the device we're looking for is not on top of any of
		 * our upper vlans, then just search for any dev that
		 * matches, and in case it's a vlan - save the id
		 */
2206
		netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
2207 2208 2209 2210 2211 2212 2213 2214
			if (upper == rt->dst.dev) {
				/* if it's a vlan - get its VID */
				if (is_vlan_dev(upper))
					vlan_id = vlan_dev_vlan_id(upper);

				rcu_read_unlock();
				goto found;
			}
J
Jay Vosburgh 已提交
2215
		}
2216
		rcu_read_unlock();
J
Jay Vosburgh 已提交
2217

2218
		/* Not our device - skip */
2219 2220 2221 2222
		pr_debug("%s: no path to arp_ip_target %pI4 via rt.dev %s\n",
			 bond->dev->name, &targets[i],
			 rt->dst.dev ? rt->dst.dev->name : "NULL");

2223
		ip_rt_put(rt);
2224 2225 2226 2227 2228 2229 2230
		continue;

found:
		addr = bond_confirm_addr(rt->dst.dev, targets[i], 0);
		ip_rt_put(rt);
		bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
			      addr, vlan_id);
J
Jay Vosburgh 已提交
2231 2232 2233
	}
}

2234
static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip)
2235
{
2236 2237
	int i;

2238 2239 2240 2241
	if (!sip || !bond_has_this_ip(bond, tip)) {
		pr_debug("bva: sip %pI4 tip %pI4 not found\n", &sip, &tip);
		return;
	}
2242

2243 2244
	i = bond_get_targets_ip(bond->params.arp_targets, sip);
	if (i == -1) {
2245 2246
		pr_debug("bva: sip %pI4 not found in targets\n", &sip);
		return;
2247
	}
2248
	slave->last_arp_rx = jiffies;
2249
	slave->target_last_arp_rx[i] = jiffies;
2250 2251
}

2252 2253
int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond,
		 struct slave *slave)
2254
{
2255
	struct arphdr *arp = (struct arphdr *)skb->data;
2256
	unsigned char *arp_ptr;
2257
	__be32 sip, tip;
2258
	int alen;
2259

2260 2261
	slave->last_arp_rx = jiffies;

2262
	if (skb->protocol != __cpu_to_be16(ETH_P_ARP))
2263
		return RX_HANDLER_ANOTHER;
2264

2265 2266 2267
	if (!slave_do_arp_validate(bond, slave))
		goto out_unlock;

2268
	alen = arp_hdr_len(bond->dev);
2269

2270 2271
	pr_debug("bond_arp_rcv: bond %s skb->dev %s\n",
		 bond->dev->name, skb->dev->name);
2272

2273 2274 2275 2276 2277 2278 2279
	if (alen > skb_headlen(skb)) {
		arp = kmalloc(alen, GFP_ATOMIC);
		if (!arp)
			goto out_unlock;
		if (skb_copy_bits(skb, 0, arp, alen) < 0)
			goto out_unlock;
	}
2280

2281
	if (arp->ar_hln != bond->dev->addr_len ||
2282 2283 2284 2285 2286 2287 2288 2289
	    skb->pkt_type == PACKET_OTHERHOST ||
	    skb->pkt_type == PACKET_LOOPBACK ||
	    arp->ar_hrd != htons(ARPHRD_ETHER) ||
	    arp->ar_pro != htons(ETH_P_IP) ||
	    arp->ar_pln != 4)
		goto out_unlock;

	arp_ptr = (unsigned char *)(arp + 1);
2290
	arp_ptr += bond->dev->addr_len;
2291
	memcpy(&sip, arp_ptr, 4);
2292
	arp_ptr += 4 + bond->dev->addr_len;
2293 2294
	memcpy(&tip, arp_ptr, 4);

2295
	pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
J
Jiri Pirko 已提交
2296
		 bond->dev->name, slave->dev->name, bond_slave_state(slave),
J
Joe Perches 已提交
2297 2298
		 bond->params.arp_validate, slave_do_arp_validate(bond, slave),
		 &sip, &tip);
2299 2300 2301 2302 2303 2304 2305 2306

	/*
	 * Backup slaves won't see the ARP reply, but do come through
	 * here for each ARP probe (so we swap the sip/tip to validate
	 * the probe).  In a "redundant switch, common router" type of
	 * configuration, the ARP probe will (hopefully) travel from
	 * the active, through one switch, the router, then the other
	 * switch before reaching the backup.
2307 2308 2309 2310 2311
	 *
	 * We 'trust' the arp requests if there is an active slave and
	 * it received valid arp reply(s) after it became active. This
	 * is done to avoid endless looping when we can't reach the
	 * arp_ip_target and fool ourselves with our own arp requests.
2312
	 */
J
Jiri Pirko 已提交
2313
	if (bond_is_active_slave(slave))
2314
		bond_validate_arp(bond, slave, sip, tip);
2315 2316 2317
	else if (bond->curr_active_slave &&
		 time_after(slave_last_rx(bond, bond->curr_active_slave),
			    bond->curr_active_slave->jiffies))
2318 2319 2320
		bond_validate_arp(bond, slave, tip, sip);

out_unlock:
2321 2322
	if (arp != (struct arphdr *)skb->data)
		kfree(arp);
2323
	return RX_HANDLER_ANOTHER;
2324 2325
}

2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339
/* function to verify if we're in the arp_interval timeslice, returns true if
 * (last_act - arp_interval) <= jiffies <= (last_act + mod * arp_interval +
 * arp_interval/2) . the arp_interval/2 is needed for really fast networks.
 */
static bool bond_time_in_interval(struct bonding *bond, unsigned long last_act,
				  int mod)
{
	int delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);

	return time_in_range(jiffies,
			     last_act - delta_in_ticks,
			     last_act + mod * delta_in_ticks + delta_in_ticks/2);
}

L
Linus Torvalds 已提交
2340 2341 2342 2343 2344 2345 2346
/*
 * this function is called regularly to monitor each slave's link
 * ensuring that traffic is being sent and received when arp monitoring
 * is used in load-balancing mode. if the adapter has been dormant, then an
 * arp is transmitted to generate traffic. see activebackup_arp_monitor for
 * arp monitoring in active backup mode.
 */
2347
static void bond_loadbalance_arp_mon(struct work_struct *work)
L
Linus Torvalds 已提交
2348
{
2349 2350
	struct bonding *bond = container_of(work, struct bonding,
					    arp_work.work);
L
Linus Torvalds 已提交
2351
	struct slave *slave, *oldcurrent;
2352
	struct list_head *iter;
2353
	int do_failover = 0, slave_state_changed = 0;
L
Linus Torvalds 已提交
2354

2355
	if (!bond_has_slaves(bond))
L
Linus Torvalds 已提交
2356 2357
		goto re_arm;

2358 2359 2360
	rcu_read_lock();

	oldcurrent = ACCESS_ONCE(bond->curr_active_slave);
L
Linus Torvalds 已提交
2361 2362 2363 2364 2365 2366 2367 2368
	/* see if any of the previous devices are up now (i.e. they have
	 * xmt and rcv traffic). the curr_active_slave does not come into
	 * the picture unless it is null. also, slave->jiffies is not needed
	 * here because we send an arp on each slave and give a slave as
	 * long as it needs to get the tx/rx within the delta.
	 * TODO: what about up/down delay in arp mode? it wasn't here before
	 *       so it can wait
	 */
2369
	bond_for_each_slave_rcu(bond, slave, iter) {
2370 2371
		unsigned long trans_start = dev_trans_start(slave->dev);

L
Linus Torvalds 已提交
2372
		if (slave->link != BOND_LINK_UP) {
2373 2374
			if (bond_time_in_interval(bond, trans_start, 1) &&
			    bond_time_in_interval(bond, slave->dev->last_rx, 1)) {
L
Linus Torvalds 已提交
2375 2376

				slave->link  = BOND_LINK_UP;
2377
				slave_state_changed = 1;
L
Linus Torvalds 已提交
2378 2379 2380 2381 2382 2383 2384

				/* primary_slave has no meaning in round-robin
				 * mode. the window of a slave being up and
				 * curr_active_slave being null after enslaving
				 * is closed.
				 */
				if (!oldcurrent) {
J
Joe Perches 已提交
2385
					pr_info("%s: link status definitely up for interface %s\n",
J
Joe Perches 已提交
2386 2387
						bond->dev->name,
						slave->dev->name);
L
Linus Torvalds 已提交
2388 2389
					do_failover = 1;
				} else {
J
Joe Perches 已提交
2390 2391 2392
					pr_info("%s: interface %s is now up\n",
						bond->dev->name,
						slave->dev->name);
L
Linus Torvalds 已提交
2393 2394 2395 2396 2397 2398 2399 2400 2401
				}
			}
		} else {
			/* slave->link == BOND_LINK_UP */

			/* not all switches will respond to an arp request
			 * when the source ip is 0, so don't take the link down
			 * if we don't know our ip yet
			 */
2402 2403
			if (!bond_time_in_interval(bond, trans_start, 2) ||
			    !bond_time_in_interval(bond, slave->dev->last_rx, 2)) {
L
Linus Torvalds 已提交
2404 2405

				slave->link  = BOND_LINK_DOWN;
2406
				slave_state_changed = 1;
L
Linus Torvalds 已提交
2407

S
Stephen Hemminger 已提交
2408
				if (slave->link_failure_count < UINT_MAX)
L
Linus Torvalds 已提交
2409 2410
					slave->link_failure_count++;

J
Joe Perches 已提交
2411 2412
				pr_info("%s: interface %s is now down\n",
					bond->dev->name, slave->dev->name);
L
Linus Torvalds 已提交
2413

S
Stephen Hemminger 已提交
2414
				if (slave == oldcurrent)
L
Linus Torvalds 已提交
2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425
					do_failover = 1;
			}
		}

		/* note: if switch is in round-robin mode, all links
		 * must tx arp to ensure all links rx an arp - otherwise
		 * links may oscillate or not come up at all; if switch is
		 * in something like xor mode, there is nothing we can
		 * do - all replies will be rx'ed on same link causing slaves
		 * to be unstable during low/no traffic periods
		 */
S
Stephen Hemminger 已提交
2426
		if (IS_UP(slave->dev))
L
Linus Torvalds 已提交
2427 2428 2429
			bond_arp_send_all(bond, slave);
	}

2430 2431
	rcu_read_unlock();

2432
	if (do_failover || slave_state_changed) {
2433 2434
		if (!rtnl_trylock())
			goto re_arm;
L
Linus Torvalds 已提交
2435

2436 2437 2438 2439 2440 2441 2442 2443
		if (slave_state_changed) {
			bond_slave_state_change(bond);
		} else if (do_failover) {
			/* the bond_select_active_slave must hold RTNL
			 * and curr_slave_lock for write.
			 */
			block_netpoll_tx();
			write_lock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2444

2445 2446 2447 2448 2449
			bond_select_active_slave(bond);

			write_unlock_bh(&bond->curr_slave_lock);
			unblock_netpoll_tx();
		}
2450
		rtnl_unlock();
L
Linus Torvalds 已提交
2451 2452 2453
	}

re_arm:
2454
	if (bond->params.arp_interval)
2455 2456
		queue_delayed_work(bond->wq, &bond->arp_work,
				   msecs_to_jiffies(bond->params.arp_interval));
L
Linus Torvalds 已提交
2457 2458 2459
}

/*
2460 2461 2462 2463 2464
 * Called to inspect slaves for active-backup mode ARP monitor link state
 * changes.  Sets new_link in slaves to specify what action should take
 * place for the slave.  Returns 0 if no changes are found, >0 if changes
 * to link states must be committed.
 *
2465
 * Called with rcu_read_lock hold.
L
Linus Torvalds 已提交
2466
 */
2467
static int bond_ab_arp_inspect(struct bonding *bond)
L
Linus Torvalds 已提交
2468
{
2469
	unsigned long trans_start, last_rx;
2470
	struct list_head *iter;
2471 2472
	struct slave *slave;
	int commit = 0;
2473

2474
	bond_for_each_slave_rcu(bond, slave, iter) {
2475
		slave->new_link = BOND_LINK_NOCHANGE;
2476
		last_rx = slave_last_rx(bond, slave);
L
Linus Torvalds 已提交
2477

2478
		if (slave->link != BOND_LINK_UP) {
2479
			if (bond_time_in_interval(bond, last_rx, 1)) {
2480 2481 2482 2483 2484
				slave->new_link = BOND_LINK_UP;
				commit++;
			}
			continue;
		}
L
Linus Torvalds 已提交
2485

2486 2487 2488 2489 2490
		/*
		 * Give slaves 2*delta after being enslaved or made
		 * active.  This avoids bouncing, as the last receive
		 * times need a full ARP monitor cycle to be updated.
		 */
2491
		if (bond_time_in_interval(bond, slave->jiffies, 2))
2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506
			continue;

		/*
		 * Backup slave is down if:
		 * - No current_arp_slave AND
		 * - more than 3*delta since last receive AND
		 * - the bond has an IP address
		 *
		 * Note: a non-null current_arp_slave indicates
		 * the curr_active_slave went down and we are
		 * searching for a new one; under this condition
		 * we only take the curr_active_slave down - this
		 * gives each slave a chance to tx/rx traffic
		 * before being taken out
		 */
J
Jiri Pirko 已提交
2507
		if (!bond_is_active_slave(slave) &&
2508
		    !bond->current_arp_slave &&
2509
		    !bond_time_in_interval(bond, last_rx, 3)) {
2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
			slave->new_link = BOND_LINK_DOWN;
			commit++;
		}

		/*
		 * Active slave is down if:
		 * - more than 2*delta since transmitting OR
		 * - (more than 2*delta since receive AND
		 *    the bond has an IP address)
		 */
2520
		trans_start = dev_trans_start(slave->dev);
J
Jiri Pirko 已提交
2521
		if (bond_is_active_slave(slave) &&
2522 2523
		    (!bond_time_in_interval(bond, trans_start, 2) ||
		     !bond_time_in_interval(bond, last_rx, 2))) {
2524 2525 2526
			slave->new_link = BOND_LINK_DOWN;
			commit++;
		}
L
Linus Torvalds 已提交
2527 2528
	}

2529 2530
	return commit;
}
L
Linus Torvalds 已提交
2531

2532 2533 2534 2535
/*
 * Called to commit link state changes noted by inspection step of
 * active-backup mode ARP monitor.
 *
2536
 * Called with RTNL hold.
2537
 */
2538
static void bond_ab_arp_commit(struct bonding *bond)
2539
{
2540
	unsigned long trans_start;
2541
	struct list_head *iter;
2542
	struct slave *slave;
L
Linus Torvalds 已提交
2543

2544
	bond_for_each_slave(bond, slave, iter) {
2545 2546 2547
		switch (slave->new_link) {
		case BOND_LINK_NOCHANGE:
			continue;
2548

2549
		case BOND_LINK_UP:
2550
			trans_start = dev_trans_start(slave->dev);
2551 2552 2553
			if (bond->curr_active_slave != slave ||
			    (!bond->curr_active_slave &&
			     bond_time_in_interval(bond, trans_start, 1))) {
2554
				slave->link = BOND_LINK_UP;
2555 2556 2557 2558 2559
				if (bond->current_arp_slave) {
					bond_set_slave_inactive_flags(
						bond->current_arp_slave);
					bond->current_arp_slave = NULL;
				}
2560

J
Joe Perches 已提交
2561
				pr_info("%s: link status definitely up for interface %s\n",
2562
					bond->dev->name, slave->dev->name);
2563

2564 2565 2566
				if (!bond->curr_active_slave ||
				    (slave == bond->primary_slave))
					goto do_failover;
L
Linus Torvalds 已提交
2567

2568
			}
L
Linus Torvalds 已提交
2569

2570
			continue;
L
Linus Torvalds 已提交
2571

2572 2573 2574 2575 2576
		case BOND_LINK_DOWN:
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;

			slave->link = BOND_LINK_DOWN;
2577
			bond_set_slave_inactive_flags(slave);
2578

J
Joe Perches 已提交
2579
			pr_info("%s: link status definitely down for interface %s, disabling it\n",
2580
				bond->dev->name, slave->dev->name);
2581

2582
			if (slave == bond->curr_active_slave) {
2583
				bond->current_arp_slave = NULL;
2584
				goto do_failover;
L
Linus Torvalds 已提交
2585
			}
2586 2587

			continue;
2588 2589

		default:
J
Joe Perches 已提交
2590
			pr_err("%s: impossible: new_link %d on slave %s\n",
2591 2592
			       bond->dev->name, slave->new_link,
			       slave->dev->name);
2593
			continue;
L
Linus Torvalds 已提交
2594 2595
		}

2596 2597
do_failover:
		ASSERT_RTNL();
2598
		block_netpoll_tx();
2599
		write_lock_bh(&bond->curr_slave_lock);
2600
		bond_select_active_slave(bond);
2601
		write_unlock_bh(&bond->curr_slave_lock);
2602
		unblock_netpoll_tx();
2603
	}
L
Linus Torvalds 已提交
2604

2605 2606
	bond_set_carrier(bond);
}
L
Linus Torvalds 已提交
2607

2608 2609 2610
/*
 * Send ARP probes for active-backup mode ARP monitor.
 */
2611
static bool bond_ab_arp_probe(struct bonding *bond)
2612
{
2613
	struct slave *slave, *before = NULL, *new_slave = NULL,
2614
		     *curr_arp_slave, *curr_active_slave;
2615 2616
	struct list_head *iter;
	bool found = false;
L
Linus Torvalds 已提交
2617

2618 2619 2620 2621
	rcu_read_lock();
	curr_arp_slave = rcu_dereference(bond->current_arp_slave);
	curr_active_slave = rcu_dereference(bond->curr_active_slave);

2622
	if (curr_arp_slave && curr_active_slave)
J
Joe Perches 已提交
2623
		pr_info("PROBE: c_arp %s && cas %s BAD\n",
2624
			curr_arp_slave->dev->name,
2625
			curr_active_slave->dev->name);
L
Linus Torvalds 已提交
2626

2627 2628
	if (curr_active_slave) {
		bond_arp_send_all(bond, curr_active_slave);
2629 2630
		rcu_read_unlock();
		return true;
2631
	}
2632
	rcu_read_unlock();
L
Linus Torvalds 已提交
2633

2634 2635 2636 2637
	/* if we don't have a curr_active_slave, search for the next available
	 * backup slave from the current_arp_slave and make it the candidate
	 * for becoming the curr_active_slave
	 */
L
Linus Torvalds 已提交
2638

2639 2640 2641 2642 2643
	if (!rtnl_trylock())
		return false;
	/* curr_arp_slave might have gone away */
	curr_arp_slave = ACCESS_ONCE(bond->current_arp_slave);

2644
	if (!curr_arp_slave) {
2645 2646 2647 2648 2649
		curr_arp_slave = bond_first_slave(bond);
		if (!curr_arp_slave) {
			rtnl_unlock();
			return true;
		}
2650
	}
L
Linus Torvalds 已提交
2651

2652
	bond_set_slave_inactive_flags(curr_arp_slave);
2653

2654
	bond_for_each_slave(bond, slave, iter) {
2655 2656
		if (!found && !before && IS_UP(slave->dev))
			before = slave;
L
Linus Torvalds 已提交
2657

2658 2659
		if (found && !new_slave && IS_UP(slave->dev))
			new_slave = slave;
2660 2661 2662 2663 2664 2665
		/* if the link state is up at this point, we
		 * mark it down - this can happen if we have
		 * simultaneous link failures and
		 * reselect_active_interface doesn't make this
		 * one the current slave so it is still marked
		 * up when it is actually down
L
Linus Torvalds 已提交
2666
		 */
2667
		if (!IS_UP(slave->dev) && slave->link == BOND_LINK_UP) {
2668 2669 2670
			slave->link = BOND_LINK_DOWN;
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;
L
Linus Torvalds 已提交
2671

2672 2673
			bond_set_slave_inactive_flags(slave);

J
Joe Perches 已提交
2674
			pr_info("%s: backup interface %s is now down\n",
J
Joe Perches 已提交
2675
				bond->dev->name, slave->dev->name);
L
Linus Torvalds 已提交
2676
		}
2677
		if (slave == curr_arp_slave)
2678
			found = true;
2679
	}
2680 2681 2682 2683

	if (!new_slave && before)
		new_slave = before;

2684 2685 2686 2687
	if (!new_slave) {
		rtnl_unlock();
		return true;
	}
2688 2689 2690 2691 2692

	new_slave->link = BOND_LINK_BACK;
	bond_set_slave_active_flags(new_slave);
	bond_arp_send_all(bond, new_slave);
	new_slave->jiffies = jiffies;
2693
	rcu_assign_pointer(bond->current_arp_slave, new_slave);
2694 2695 2696
	rtnl_unlock();

	return true;
2697
}
L
Linus Torvalds 已提交
2698

2699
static void bond_activebackup_arp_mon(struct work_struct *work)
2700 2701 2702
{
	struct bonding *bond = container_of(work, struct bonding,
					    arp_work.work);
2703
	bool should_notify_peers = false, should_commit = false;
2704
	int delta_in_ticks;
L
Linus Torvalds 已提交
2705

2706 2707 2708
	delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);

	if (!bond_has_slaves(bond))
2709 2710
		goto re_arm;

2711
	rcu_read_lock();
2712
	should_notify_peers = bond_should_notify_peers(bond);
2713 2714
	should_commit = bond_ab_arp_inspect(bond);
	rcu_read_unlock();
2715

2716
	if (should_commit) {
2717 2718 2719 2720 2721 2722
		/* Race avoidance with bond_close flush of workqueue */
		if (!rtnl_trylock()) {
			delta_in_ticks = 1;
			should_notify_peers = false;
			goto re_arm;
		}
2723

2724 2725 2726 2727
		bond_ab_arp_commit(bond);
		rtnl_unlock();
	}

2728 2729 2730 2731 2732
	if (!bond_ab_arp_probe(bond)) {
		/* rtnl locking failed, re-arm */
		delta_in_ticks = 1;
		should_notify_peers = false;
	}
2733

2734 2735
re_arm:
	if (bond->params.arp_interval)
2736 2737 2738 2739 2740 2741 2742 2743
		queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);

	if (should_notify_peers) {
		if (!rtnl_trylock())
			return;
		call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
		rtnl_unlock();
	}
L
Linus Torvalds 已提交
2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754
}

/*-------------------------- netdev event handling --------------------------*/

/*
 * Change device name
 */
static int bond_event_changename(struct bonding *bond)
{
	bond_remove_proc_entry(bond);
	bond_create_proc_entry(bond);
2755

2756 2757
	bond_debug_reregister(bond);

L
Linus Torvalds 已提交
2758 2759 2760
	return NOTIFY_DONE;
}

S
Stephen Hemminger 已提交
2761 2762
static int bond_master_netdev_event(unsigned long event,
				    struct net_device *bond_dev)
L
Linus Torvalds 已提交
2763
{
2764
	struct bonding *event_bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
2765 2766 2767 2768

	switch (event) {
	case NETDEV_CHANGENAME:
		return bond_event_changename(event_bond);
2769 2770 2771 2772 2773 2774
	case NETDEV_UNREGISTER:
		bond_remove_proc_entry(event_bond);
		break;
	case NETDEV_REGISTER:
		bond_create_proc_entry(event_bond);
		break;
2775 2776 2777 2778
	case NETDEV_NOTIFY_PEERS:
		if (event_bond->send_peer_notif)
			event_bond->send_peer_notif--;
		break;
L
Linus Torvalds 已提交
2779 2780 2781 2782 2783 2784 2785
	default:
		break;
	}

	return NOTIFY_DONE;
}

S
Stephen Hemminger 已提交
2786 2787
static int bond_slave_netdev_event(unsigned long event,
				   struct net_device *slave_dev)
L
Linus Torvalds 已提交
2788
{
2789
	struct slave *slave = bond_slave_get_rtnl(slave_dev);
2790 2791
	struct bonding *bond;
	struct net_device *bond_dev;
2792 2793
	u32 old_speed;
	u8 old_duplex;
L
Linus Torvalds 已提交
2794

2795 2796 2797 2798 2799 2800 2801 2802 2803
	/* A netdev event can be generated while enslaving a device
	 * before netdev_rx_handler_register is called in which case
	 * slave will be NULL
	 */
	if (!slave)
		return NOTIFY_DONE;
	bond_dev = slave->bond->dev;
	bond = slave->bond;

L
Linus Torvalds 已提交
2804 2805
	switch (event) {
	case NETDEV_UNREGISTER:
2806
		if (bond_dev->type != ARPHRD_ETHER)
2807 2808 2809
			bond_release_and_destroy(bond_dev, slave_dev);
		else
			bond_release(bond_dev, slave_dev);
L
Linus Torvalds 已提交
2810
		break;
2811
	case NETDEV_UP:
L
Linus Torvalds 已提交
2812
	case NETDEV_CHANGE:
2813 2814
		old_speed = slave->speed;
		old_duplex = slave->duplex;
2815

2816
		bond_update_speed_duplex(slave);
2817

2818 2819 2820 2821 2822
		if (bond->params.mode == BOND_MODE_8023AD) {
			if (old_speed != slave->speed)
				bond_3ad_adapter_speed_changed(slave);
			if (old_duplex != slave->duplex)
				bond_3ad_adapter_duplex_changed(slave);
2823
		}
L
Linus Torvalds 已提交
2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
		break;
	case NETDEV_DOWN:
		/*
		 * ... Or is it this?
		 */
		break;
	case NETDEV_CHANGEMTU:
		/*
		 * TODO: Should slaves be allowed to
		 * independently alter their MTU?  For
		 * an active-backup bond, slaves need
		 * not be the same type of device, so
		 * MTUs may vary.  For other modes,
		 * slaves arguably should have the
		 * same MTUs. To do this, we'd need to
		 * take over the slave's change_mtu
		 * function for the duration of their
		 * servitude.
		 */
		break;
	case NETDEV_CHANGENAME:
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
		/* we don't care if we don't have primary set */
		if (!USES_PRIMARY(bond->params.mode) ||
		    !bond->params.primary[0])
			break;

		if (slave == bond->primary_slave) {
			/* slave's name changed - he's no longer primary */
			bond->primary_slave = NULL;
		} else if (!strcmp(slave_dev->name, bond->params.primary)) {
			/* we have a new primary slave */
			bond->primary_slave = slave;
		} else { /* we didn't change primary - exit */
			break;
		}

J
Joe Perches 已提交
2860 2861 2862
		pr_info("%s: Primary slave changed to %s, reselecting active slave\n",
			bond->dev->name,
			bond->primary_slave ? slave_dev->name : "none");
2863 2864 2865
		write_lock_bh(&bond->curr_slave_lock);
		bond_select_active_slave(bond);
		write_unlock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2866
		break;
2867 2868 2869
	case NETDEV_FEAT_CHANGE:
		bond_compute_features(bond);
		break;
2870 2871 2872 2873
	case NETDEV_RESEND_IGMP:
		/* Propagate to master device */
		call_netdevice_notifiers(event, slave->bond->dev);
		break;
L
Linus Torvalds 已提交
2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884
	default:
		break;
	}

	return NOTIFY_DONE;
}

/*
 * bond_netdev_event: handle netdev notifier chain events.
 *
 * This function receives events for the netdev chain.  The caller (an
2885
 * ioctl handler calling blocking_notifier_call_chain) holds the necessary
L
Linus Torvalds 已提交
2886 2887 2888
 * locks for us to safely manipulate the slave devices (RTNL lock,
 * dev_probe_lock).
 */
S
Stephen Hemminger 已提交
2889 2890
static int bond_netdev_event(struct notifier_block *this,
			     unsigned long event, void *ptr)
L
Linus Torvalds 已提交
2891
{
2892
	struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
L
Linus Torvalds 已提交
2893

2894
	pr_debug("event_dev: %s, event: %lx\n",
J
Joe Perches 已提交
2895
		 event_dev ? event_dev->name : "None", event);
L
Linus Torvalds 已提交
2896

2897 2898 2899
	if (!(event_dev->priv_flags & IFF_BONDING))
		return NOTIFY_DONE;

L
Linus Torvalds 已提交
2900
	if (event_dev->flags & IFF_MASTER) {
2901
		pr_debug("IFF_MASTER\n");
L
Linus Torvalds 已提交
2902 2903 2904 2905
		return bond_master_netdev_event(event, event_dev);
	}

	if (event_dev->flags & IFF_SLAVE) {
2906
		pr_debug("IFF_SLAVE\n");
L
Linus Torvalds 已提交
2907 2908 2909 2910 2911 2912 2913 2914 2915 2916
		return bond_slave_netdev_event(event, event_dev);
	}

	return NOTIFY_DONE;
}

static struct notifier_block bond_netdev_notifier = {
	.notifier_call = bond_netdev_event,
};

2917 2918
/*---------------------------- Hashing Policies -----------------------------*/

2919 2920
/* L2 hash helper */
static inline u32 bond_eth_hash(struct sk_buff *skb)
2921 2922 2923 2924
{
	struct ethhdr *data = (struct ethhdr *)skb->data;

	if (skb_headlen(skb) >= offsetof(struct ethhdr, h_proto))
2925
		return data->h_dest[5] ^ data->h_source[5];
2926 2927 2928 2929

	return 0;
}

2930 2931 2932
/* Extract the appropriate headers based on bond's xmit policy */
static bool bond_flow_dissect(struct bonding *bond, struct sk_buff *skb,
			      struct flow_keys *fk)
2933
{
2934
	const struct ipv6hdr *iph6;
2935
	const struct iphdr *iph;
2936
	int noff, proto = -1;
2937

2938 2939 2940 2941 2942 2943 2944 2945
	if (bond->params.xmit_policy > BOND_XMIT_POLICY_LAYER23)
		return skb_flow_dissect(skb, fk);

	fk->ports = 0;
	noff = skb_network_offset(skb);
	if (skb->protocol == htons(ETH_P_IP)) {
		if (!pskb_may_pull(skb, noff + sizeof(*iph)))
			return false;
2946
		iph = ip_hdr(skb);
2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961
		fk->src = iph->saddr;
		fk->dst = iph->daddr;
		noff += iph->ihl << 2;
		if (!ip_is_fragment(iph))
			proto = iph->protocol;
	} else if (skb->protocol == htons(ETH_P_IPV6)) {
		if (!pskb_may_pull(skb, noff + sizeof(*iph6)))
			return false;
		iph6 = ipv6_hdr(skb);
		fk->src = (__force __be32)ipv6_addr_hash(&iph6->saddr);
		fk->dst = (__force __be32)ipv6_addr_hash(&iph6->daddr);
		noff += sizeof(*iph6);
		proto = iph6->nexthdr;
	} else {
		return false;
2962
	}
2963 2964
	if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34 && proto >= 0)
		fk->ports = skb_flow_get_ports(skb, noff, proto);
2965

2966
	return true;
2967 2968
}

2969 2970 2971 2972 2973 2974 2975 2976 2977
/**
 * bond_xmit_hash - generate a hash value based on the xmit policy
 * @bond: bonding device
 * @skb: buffer to use for headers
 * @count: modulo value
 *
 * This function will extract the necessary headers from the skb buffer and use
 * them to generate a hash based on the xmit_policy set in the bonding device
 * which will be reduced modulo count before returning.
2978
 */
2979
int bond_xmit_hash(struct bonding *bond, struct sk_buff *skb, int count)
2980
{
2981 2982
	struct flow_keys flow;
	u32 hash;
2983

2984 2985 2986
	if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER2 ||
	    !bond_flow_dissect(bond, skb, &flow))
		return bond_eth_hash(skb) % count;
2987

2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
	if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER23 ||
	    bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP23)
		hash = bond_eth_hash(skb);
	else
		hash = (__force u32)flow.ports;
	hash ^= (__force u32)flow.dst ^ (__force u32)flow.src;
	hash ^= (hash >> 16);
	hash ^= (hash >> 8);

	return hash % count;
2998 2999
}

L
Linus Torvalds 已提交
3000 3001
/*-------------------------- Device entry points ----------------------------*/

3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023
static void bond_work_init_all(struct bonding *bond)
{
	INIT_DELAYED_WORK(&bond->mcast_work,
			  bond_resend_igmp_join_requests_delayed);
	INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
	INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor);
	if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
		INIT_DELAYED_WORK(&bond->arp_work, bond_activebackup_arp_mon);
	else
		INIT_DELAYED_WORK(&bond->arp_work, bond_loadbalance_arp_mon);
	INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
}

static void bond_work_cancel_all(struct bonding *bond)
{
	cancel_delayed_work_sync(&bond->mii_work);
	cancel_delayed_work_sync(&bond->arp_work);
	cancel_delayed_work_sync(&bond->alb_work);
	cancel_delayed_work_sync(&bond->ad_work);
	cancel_delayed_work_sync(&bond->mcast_work);
}

L
Linus Torvalds 已提交
3024 3025
static int bond_open(struct net_device *bond_dev)
{
3026
	struct bonding *bond = netdev_priv(bond_dev);
3027
	struct list_head *iter;
3028
	struct slave *slave;
L
Linus Torvalds 已提交
3029

3030 3031
	/* reset slave->backup and slave->inactive */
	read_lock(&bond->lock);
3032
	if (bond_has_slaves(bond)) {
3033
		read_lock(&bond->curr_slave_lock);
3034
		bond_for_each_slave(bond, slave, iter) {
3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045
			if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
				&& (slave != bond->curr_active_slave)) {
				bond_set_slave_inactive_flags(slave);
			} else {
				bond_set_slave_active_flags(slave);
			}
		}
		read_unlock(&bond->curr_slave_lock);
	}
	read_unlock(&bond->lock);

3046
	bond_work_init_all(bond);
3047

3048
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
3049 3050 3051
		/* bond_alb_initialize must be called before the timer
		 * is started.
		 */
3052
		if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB)))
3053
			return -ENOMEM;
3054
		queue_delayed_work(bond->wq, &bond->alb_work, 0);
L
Linus Torvalds 已提交
3055 3056
	}

3057
	if (bond->params.miimon)  /* link check interval, in milliseconds. */
3058
		queue_delayed_work(bond->wq, &bond->mii_work, 0);
L
Linus Torvalds 已提交
3059 3060

	if (bond->params.arp_interval) {  /* arp interval, in milliseconds. */
3061
		queue_delayed_work(bond->wq, &bond->arp_work, 0);
3062
		bond->recv_probe = bond_arp_rcv;
L
Linus Torvalds 已提交
3063 3064 3065
	}

	if (bond->params.mode == BOND_MODE_8023AD) {
3066
		queue_delayed_work(bond->wq, &bond->ad_work, 0);
L
Linus Torvalds 已提交
3067
		/* register to receive LACPDUs */
3068
		bond->recv_probe = bond_3ad_lacpdu_recv;
3069
		bond_3ad_initiate_agg_selection(bond, 1);
L
Linus Torvalds 已提交
3070 3071 3072 3073 3074 3075 3076
	}

	return 0;
}

static int bond_close(struct net_device *bond_dev)
{
3077
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3078

3079
	bond_work_cancel_all(bond);
3080
	bond->send_peer_notif = 0;
3081
	if (bond_is_lb(bond))
L
Linus Torvalds 已提交
3082
		bond_alb_deinitialize(bond);
3083
	bond->recv_probe = NULL;
L
Linus Torvalds 已提交
3084 3085 3086 3087

	return 0;
}

3088 3089
static struct rtnl_link_stats64 *bond_get_stats(struct net_device *bond_dev,
						struct rtnl_link_stats64 *stats)
L
Linus Torvalds 已提交
3090
{
3091
	struct bonding *bond = netdev_priv(bond_dev);
3092
	struct rtnl_link_stats64 temp;
3093
	struct list_head *iter;
L
Linus Torvalds 已提交
3094 3095
	struct slave *slave;

3096
	memset(stats, 0, sizeof(*stats));
L
Linus Torvalds 已提交
3097 3098

	read_lock_bh(&bond->lock);
3099
	bond_for_each_slave(bond, slave, iter) {
3100
		const struct rtnl_link_stats64 *sstats =
3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127
			dev_get_stats(slave->dev, &temp);

		stats->rx_packets += sstats->rx_packets;
		stats->rx_bytes += sstats->rx_bytes;
		stats->rx_errors += sstats->rx_errors;
		stats->rx_dropped += sstats->rx_dropped;

		stats->tx_packets += sstats->tx_packets;
		stats->tx_bytes += sstats->tx_bytes;
		stats->tx_errors += sstats->tx_errors;
		stats->tx_dropped += sstats->tx_dropped;

		stats->multicast += sstats->multicast;
		stats->collisions += sstats->collisions;

		stats->rx_length_errors += sstats->rx_length_errors;
		stats->rx_over_errors += sstats->rx_over_errors;
		stats->rx_crc_errors += sstats->rx_crc_errors;
		stats->rx_frame_errors += sstats->rx_frame_errors;
		stats->rx_fifo_errors += sstats->rx_fifo_errors;
		stats->rx_missed_errors += sstats->rx_missed_errors;

		stats->tx_aborted_errors += sstats->tx_aborted_errors;
		stats->tx_carrier_errors += sstats->tx_carrier_errors;
		stats->tx_fifo_errors += sstats->tx_fifo_errors;
		stats->tx_heartbeat_errors += sstats->tx_heartbeat_errors;
		stats->tx_window_errors += sstats->tx_window_errors;
3128
	}
L
Linus Torvalds 已提交
3129 3130 3131 3132 3133 3134 3135
	read_unlock_bh(&bond->lock);

	return stats;
}

static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
{
3136
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3137 3138 3139 3140 3141 3142
	struct net_device *slave_dev = NULL;
	struct ifbond k_binfo;
	struct ifbond __user *u_binfo = NULL;
	struct ifslave k_sinfo;
	struct ifslave __user *u_sinfo = NULL;
	struct mii_ioctl_data *mii = NULL;
3143
	struct bond_opt_value newval;
3144
	struct net *net;
L
Linus Torvalds 已提交
3145 3146
	int res = 0;

J
Joe Perches 已提交
3147
	pr_debug("bond_ioctl: master=%s, cmd=%d\n", bond_dev->name, cmd);
L
Linus Torvalds 已提交
3148 3149 3150 3151

	switch (cmd) {
	case SIOCGMIIPHY:
		mii = if_mii(ifr);
S
Stephen Hemminger 已提交
3152
		if (!mii)
L
Linus Torvalds 已提交
3153
			return -EINVAL;
S
Stephen Hemminger 已提交
3154

L
Linus Torvalds 已提交
3155 3156 3157 3158 3159 3160 3161 3162
		mii->phy_id = 0;
		/* Fall Through */
	case SIOCGMIIREG:
		/*
		 * We do this again just in case we were called by SIOCGMIIREG
		 * instead of SIOCGMIIPHY.
		 */
		mii = if_mii(ifr);
S
Stephen Hemminger 已提交
3163
		if (!mii)
L
Linus Torvalds 已提交
3164
			return -EINVAL;
S
Stephen Hemminger 已提交
3165

L
Linus Torvalds 已提交
3166 3167 3168

		if (mii->reg_num == 1) {
			mii->val_out = 0;
3169
			read_lock(&bond->lock);
L
Linus Torvalds 已提交
3170
			read_lock(&bond->curr_slave_lock);
S
Stephen Hemminger 已提交
3171
			if (netif_carrier_ok(bond->dev))
L
Linus Torvalds 已提交
3172
				mii->val_out = BMSR_LSTATUS;
S
Stephen Hemminger 已提交
3173

L
Linus Torvalds 已提交
3174
			read_unlock(&bond->curr_slave_lock);
3175
			read_unlock(&bond->lock);
L
Linus Torvalds 已提交
3176 3177 3178 3179 3180 3181 3182
		}

		return 0;
	case BOND_INFO_QUERY_OLD:
	case SIOCBONDINFOQUERY:
		u_binfo = (struct ifbond __user *)ifr->ifr_data;

S
Stephen Hemminger 已提交
3183
		if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond)))
L
Linus Torvalds 已提交
3184 3185 3186
			return -EFAULT;

		res = bond_info_query(bond_dev, &k_binfo);
S
Stephen Hemminger 已提交
3187 3188 3189
		if (res == 0 &&
		    copy_to_user(u_binfo, &k_binfo, sizeof(ifbond)))
			return -EFAULT;
L
Linus Torvalds 已提交
3190 3191 3192 3193 3194 3195

		return res;
	case BOND_SLAVE_INFO_QUERY_OLD:
	case SIOCBONDSLAVEINFOQUERY:
		u_sinfo = (struct ifslave __user *)ifr->ifr_data;

S
Stephen Hemminger 已提交
3196
		if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave)))
L
Linus Torvalds 已提交
3197 3198 3199
			return -EFAULT;

		res = bond_slave_info_query(bond_dev, &k_sinfo);
S
Stephen Hemminger 已提交
3200 3201 3202
		if (res == 0 &&
		    copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave)))
			return -EFAULT;
L
Linus Torvalds 已提交
3203 3204 3205 3206 3207 3208 3209

		return res;
	default:
		/* Go on */
		break;
	}

3210 3211 3212
	net = dev_net(bond_dev);

	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
3213 3214
		return -EPERM;

3215
	slave_dev = __dev_get_by_name(net, ifr->ifr_slave);
L
Linus Torvalds 已提交
3216

J
Joe Perches 已提交
3217
	pr_debug("slave_dev=%p:\n", slave_dev);
L
Linus Torvalds 已提交
3218

S
Stephen Hemminger 已提交
3219
	if (!slave_dev)
3220
		return -ENODEV;
L
Linus Torvalds 已提交
3221

3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238
	pr_debug("slave_dev->name=%s:\n", slave_dev->name);
	switch (cmd) {
	case BOND_ENSLAVE_OLD:
	case SIOCBONDENSLAVE:
		res = bond_enslave(bond_dev, slave_dev);
		break;
	case BOND_RELEASE_OLD:
	case SIOCBONDRELEASE:
		res = bond_release(bond_dev, slave_dev);
		break;
	case BOND_SETHWADDR_OLD:
	case SIOCBONDSETHWADDR:
		bond_set_dev_addr(bond_dev, slave_dev);
		res = 0;
		break;
	case BOND_CHANGE_ACTIVE_OLD:
	case SIOCBONDCHANGEACTIVE:
3239 3240
		bond_opt_initstr(&newval, slave_dev->name);
		res = __bond_opt_set(bond, BOND_OPT_ACTIVE_SLAVE, &newval);
3241 3242 3243
		break;
	default:
		res = -EOPNOTSUPP;
L
Linus Torvalds 已提交
3244 3245 3246 3247 3248
	}

	return res;
}

3249
static void bond_change_rx_flags(struct net_device *bond_dev, int change)
L
Linus Torvalds 已提交
3250
{
3251
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3252

3253 3254 3255
	if (change & IFF_PROMISC)
		bond_set_promiscuity(bond,
				     bond_dev->flags & IFF_PROMISC ? 1 : -1);
S
Stephen Hemminger 已提交
3256

3257 3258 3259 3260
	if (change & IFF_ALLMULTI)
		bond_set_allmulti(bond,
				  bond_dev->flags & IFF_ALLMULTI ? 1 : -1);
}
L
Linus Torvalds 已提交
3261

3262
static void bond_set_rx_mode(struct net_device *bond_dev)
3263 3264
{
	struct bonding *bond = netdev_priv(bond_dev);
3265
	struct list_head *iter;
3266
	struct slave *slave;
L
Linus Torvalds 已提交
3267

3268

3269
	rcu_read_lock();
3270
	if (USES_PRIMARY(bond->params.mode)) {
3271
		slave = rcu_dereference(bond->curr_active_slave);
3272 3273 3274 3275 3276
		if (slave) {
			dev_uc_sync(slave->dev, bond_dev);
			dev_mc_sync(slave->dev, bond_dev);
		}
	} else {
3277
		bond_for_each_slave_rcu(bond, slave, iter) {
3278 3279 3280
			dev_uc_sync_multiple(slave->dev, bond_dev);
			dev_mc_sync_multiple(slave->dev, bond_dev);
		}
L
Linus Torvalds 已提交
3281
	}
3282
	rcu_read_unlock();
L
Linus Torvalds 已提交
3283 3284
}

3285
static int bond_neigh_init(struct neighbour *n)
3286
{
3287 3288 3289
	struct bonding *bond = netdev_priv(n->dev);
	const struct net_device_ops *slave_ops;
	struct neigh_parms parms;
3290
	struct slave *slave;
3291 3292
	int ret;

3293
	slave = bond_first_slave(bond);
3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323
	if (!slave)
		return 0;
	slave_ops = slave->dev->netdev_ops;
	if (!slave_ops->ndo_neigh_setup)
		return 0;

	parms.neigh_setup = NULL;
	parms.neigh_cleanup = NULL;
	ret = slave_ops->ndo_neigh_setup(slave->dev, &parms);
	if (ret)
		return ret;

	/*
	 * Assign slave's neigh_cleanup to neighbour in case cleanup is called
	 * after the last slave has been detached.  Assumes that all slaves
	 * utilize the same neigh_cleanup (true at this writing as only user
	 * is ipoib).
	 */
	n->parms->neigh_cleanup = parms.neigh_cleanup;

	if (!parms.neigh_setup)
		return 0;

	return parms.neigh_setup(n);
}

/*
 * The bonding ndo_neigh_setup is called at init time beofre any
 * slave exists. So we must declare proxy setup function which will
 * be used at run time to resolve the actual slave neigh param setup.
3324 3325 3326 3327
 *
 * It's also called by master devices (such as vlans) to setup their
 * underlying devices. In that case - do nothing, we're already set up from
 * our init.
3328 3329 3330 3331
 */
static int bond_neigh_setup(struct net_device *dev,
			    struct neigh_parms *parms)
{
3332 3333 3334
	/* modify only our neigh_parms */
	if (parms->dev == dev)
		parms->neigh_setup = bond_neigh_init;
3335 3336 3337 3338

	return 0;
}

L
Linus Torvalds 已提交
3339 3340 3341 3342 3343
/*
 * Change the MTU of all of a master's slaves to match the master
 */
static int bond_change_mtu(struct net_device *bond_dev, int new_mtu)
{
3344
	struct bonding *bond = netdev_priv(bond_dev);
3345
	struct slave *slave, *rollback_slave;
3346
	struct list_head *iter;
L
Linus Torvalds 已提交
3347 3348
	int res = 0;

J
Joe Perches 已提交
3349 3350
	pr_debug("bond=%p, name=%s, new_mtu=%d\n",
		 bond, bond_dev ? bond_dev->name : "None", new_mtu);
L
Linus Torvalds 已提交
3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366

	/* Can't hold bond->lock with bh disabled here since
	 * some base drivers panic. On the other hand we can't
	 * hold bond->lock without bh disabled because we'll
	 * deadlock. The only solution is to rely on the fact
	 * that we're under rtnl_lock here, and the slaves
	 * list won't change. This doesn't solve the problem
	 * of setting the slave's MTU while it is
	 * transmitting, but the assumption is that the base
	 * driver can handle that.
	 *
	 * TODO: figure out a way to safely iterate the slaves
	 * list, but without holding a lock around the actual
	 * call to the base driver.
	 */

3367
	bond_for_each_slave(bond, slave, iter) {
3368
		pr_debug("s %p c_m %p\n",
J
Joe Perches 已提交
3369
			 slave, slave->dev->netdev_ops->ndo_change_mtu);
3370

L
Linus Torvalds 已提交
3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381
		res = dev_set_mtu(slave->dev, new_mtu);

		if (res) {
			/* If we failed to set the slave's mtu to the new value
			 * we must abort the operation even in ACTIVE_BACKUP
			 * mode, because if we allow the backup slaves to have
			 * different mtu values than the active slave we'll
			 * need to change their mtu when doing a failover. That
			 * means changing their mtu from timer context, which
			 * is probably not a good idea.
			 */
3382
			pr_debug("err %d %s\n", res, slave->dev->name);
L
Linus Torvalds 已提交
3383 3384 3385 3386 3387 3388 3389 3390 3391 3392
			goto unwind;
		}
	}

	bond_dev->mtu = new_mtu;

	return 0;

unwind:
	/* unwind from head to the slave that failed */
3393
	bond_for_each_slave(bond, rollback_slave, iter) {
L
Linus Torvalds 已提交
3394 3395
		int tmp_res;

3396 3397 3398 3399
		if (rollback_slave == slave)
			break;

		tmp_res = dev_set_mtu(rollback_slave->dev, bond_dev->mtu);
L
Linus Torvalds 已提交
3400
		if (tmp_res) {
J
Joe Perches 已提交
3401
			pr_debug("unwind err %d dev %s\n",
3402
				 tmp_res, rollback_slave->dev->name);
L
Linus Torvalds 已提交
3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417
		}
	}

	return res;
}

/*
 * Change HW address
 *
 * Note that many devices must be down to change the HW address, and
 * downing the master releases all slaves.  We can make bonds full of
 * bonding devices to test this, however.
 */
static int bond_set_mac_address(struct net_device *bond_dev, void *addr)
{
3418
	struct bonding *bond = netdev_priv(bond_dev);
3419
	struct slave *slave, *rollback_slave;
L
Linus Torvalds 已提交
3420
	struct sockaddr *sa = addr, tmp_sa;
3421
	struct list_head *iter;
L
Linus Torvalds 已提交
3422 3423
	int res = 0;

3424 3425 3426 3427
	if (bond->params.mode == BOND_MODE_ALB)
		return bond_alb_set_mac_address(bond_dev, addr);


J
Joe Perches 已提交
3428 3429
	pr_debug("bond=%p, name=%s\n",
		 bond, bond_dev ? bond_dev->name : "None");
L
Linus Torvalds 已提交
3430

3431 3432
	/* If fail_over_mac is enabled, do nothing and return success.
	 * Returning an error causes ifenslave to fail.
3433
	 */
3434 3435
	if (bond->params.fail_over_mac &&
	    bond->params.mode == BOND_MODE_ACTIVEBACKUP)
3436
		return 0;
3437

S
Stephen Hemminger 已提交
3438
	if (!is_valid_ether_addr(sa->sa_data))
L
Linus Torvalds 已提交
3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455
		return -EADDRNOTAVAIL;

	/* Can't hold bond->lock with bh disabled here since
	 * some base drivers panic. On the other hand we can't
	 * hold bond->lock without bh disabled because we'll
	 * deadlock. The only solution is to rely on the fact
	 * that we're under rtnl_lock here, and the slaves
	 * list won't change. This doesn't solve the problem
	 * of setting the slave's hw address while it is
	 * transmitting, but the assumption is that the base
	 * driver can handle that.
	 *
	 * TODO: figure out a way to safely iterate the slaves
	 * list, but without holding a lock around the actual
	 * call to the base driver.
	 */

3456
	bond_for_each_slave(bond, slave, iter) {
3457
		pr_debug("slave %p %s\n", slave, slave->dev->name);
L
Linus Torvalds 已提交
3458 3459 3460 3461 3462 3463 3464 3465
		res = dev_set_mac_address(slave->dev, addr);
		if (res) {
			/* TODO: consider downing the slave
			 * and retry ?
			 * User should expect communications
			 * breakage anyway until ARP finish
			 * updating, so...
			 */
3466
			pr_debug("err %d %s\n", res, slave->dev->name);
L
Linus Torvalds 已提交
3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479
			goto unwind;
		}
	}

	/* success */
	memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);
	return 0;

unwind:
	memcpy(tmp_sa.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
	tmp_sa.sa_family = bond_dev->type;

	/* unwind from head to the slave that failed */
3480
	bond_for_each_slave(bond, rollback_slave, iter) {
L
Linus Torvalds 已提交
3481 3482
		int tmp_res;

3483 3484 3485 3486
		if (rollback_slave == slave)
			break;

		tmp_res = dev_set_mac_address(rollback_slave->dev, &tmp_sa);
L
Linus Torvalds 已提交
3487
		if (tmp_res) {
J
Joe Perches 已提交
3488
			pr_debug("unwind err %d dev %s\n",
3489
				 tmp_res, rollback_slave->dev->name);
L
Linus Torvalds 已提交
3490 3491 3492 3493 3494 3495
		}
	}

	return res;
}

3496 3497 3498 3499 3500 3501 3502 3503 3504 3505
/**
 * bond_xmit_slave_id - transmit skb through slave with slave_id
 * @bond: bonding device that is transmitting
 * @skb: buffer to transmit
 * @slave_id: slave id up to slave_cnt-1 through which to transmit
 *
 * This function tries to transmit through slave with slave_id but in case
 * it fails, it tries to find the first available slave for transmission.
 * The skb is consumed in all cases, thus the function is void.
 */
3506
static void bond_xmit_slave_id(struct bonding *bond, struct sk_buff *skb, int slave_id)
3507
{
3508
	struct list_head *iter;
3509 3510 3511 3512
	struct slave *slave;
	int i = slave_id;

	/* Here we start from the slave with slave_id */
3513
	bond_for_each_slave_rcu(bond, slave, iter) {
3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
		if (--i < 0) {
			if (slave_can_tx(slave)) {
				bond_dev_queue_xmit(bond, skb, slave->dev);
				return;
			}
		}
	}

	/* Here we start from the first slave up to slave_id */
	i = slave_id;
3524
	bond_for_each_slave_rcu(bond, slave, iter) {
3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535
		if (--i < 0)
			break;
		if (slave_can_tx(slave)) {
			bond_dev_queue_xmit(bond, skb, slave->dev);
			return;
		}
	}
	/* no slave that can tx has been found */
	kfree_skb(skb);
}

3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546
/**
 * bond_rr_gen_slave_id - generate slave id based on packets_per_slave
 * @bond: bonding device to use
 *
 * Based on the value of the bonding device's packets_per_slave parameter
 * this function generates a slave id, which is usually used as the next
 * slave to transmit through.
 */
static u32 bond_rr_gen_slave_id(struct bonding *bond)
{
	u32 slave_id;
3547 3548
	struct reciprocal_value reciprocal_packets_per_slave;
	int packets_per_slave = bond->params.packets_per_slave;
3549 3550 3551 3552 3553 3554 3555 3556 3557

	switch (packets_per_slave) {
	case 0:
		slave_id = prandom_u32();
		break;
	case 1:
		slave_id = bond->rr_tx_counter;
		break;
	default:
3558 3559
		reciprocal_packets_per_slave =
			bond->params.reciprocal_packets_per_slave;
3560
		slave_id = reciprocal_divide(bond->rr_tx_counter,
3561
					     reciprocal_packets_per_slave);
3562 3563 3564 3565 3566 3567 3568
		break;
	}
	bond->rr_tx_counter++;

	return slave_id;
}

L
Linus Torvalds 已提交
3569 3570
static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
{
3571
	struct bonding *bond = netdev_priv(bond_dev);
3572
	struct iphdr *iph = ip_hdr(skb);
3573
	struct slave *slave;
3574
	u32 slave_id;
L
Linus Torvalds 已提交
3575

3576
	/* Start with the curr_active_slave that joined the bond as the
3577 3578 3579 3580
	 * default for sending IGMP traffic.  For failover purposes one
	 * needs to maintain some consistency for the interface that will
	 * send the join/membership reports.  The curr_active_slave found
	 * will send all of this type of traffic.
3581
	 */
3582
	if (iph->protocol == IPPROTO_IGMP && skb->protocol == htons(ETH_P_IP)) {
3583
		slave = rcu_dereference(bond->curr_active_slave);
3584 3585 3586 3587
		if (slave && slave_can_tx(slave))
			bond_dev_queue_xmit(bond, skb, slave->dev);
		else
			bond_xmit_slave_id(bond, skb, 0);
3588
	} else {
3589 3590
		slave_id = bond_rr_gen_slave_id(bond);
		bond_xmit_slave_id(bond, skb, slave_id % bond->slave_cnt);
L
Linus Torvalds 已提交
3591
	}
3592

3593
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
3594 3595 3596 3597 3598 3599 3600 3601
}

/*
 * in active-backup mode, we know that bond->curr_active_slave is always valid if
 * the bond has a usable interface.
 */
static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_dev)
{
3602
	struct bonding *bond = netdev_priv(bond_dev);
3603
	struct slave *slave;
L
Linus Torvalds 已提交
3604

3605
	slave = rcu_dereference(bond->curr_active_slave);
3606
	if (slave)
3607 3608
		bond_dev_queue_xmit(bond, skb, slave->dev);
	else
E
Eric Dumazet 已提交
3609
		kfree_skb(skb);
3610

3611
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
3612 3613
}

3614
/* In bond_xmit_xor() , we determine the output device by using a pre-
3615 3616
 * determined xmit_hash_policy(), If the selected device is not enabled,
 * find the next active slave.
L
Linus Torvalds 已提交
3617 3618 3619
 */
static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
{
3620
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3621

3622
	bond_xmit_slave_id(bond, skb, bond_xmit_hash(bond, skb, bond->slave_cnt));
3623

3624
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
3625 3626
}

3627
/* in broadcast mode, we send everything to all usable interfaces. */
L
Linus Torvalds 已提交
3628 3629
static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
{
3630
	struct bonding *bond = netdev_priv(bond_dev);
3631
	struct slave *slave = NULL;
3632
	struct list_head *iter;
L
Linus Torvalds 已提交
3633

3634
	bond_for_each_slave_rcu(bond, slave, iter) {
3635 3636 3637 3638
		if (bond_is_last_slave(bond, slave))
			break;
		if (IS_UP(slave->dev) && slave->link == BOND_LINK_UP) {
			struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
L
Linus Torvalds 已提交
3639

3640 3641 3642 3643
			if (!skb2) {
				pr_err("%s: Error: bond_xmit_broadcast(): skb_clone() failed\n",
				       bond_dev->name);
				continue;
L
Linus Torvalds 已提交
3644
			}
3645 3646
			/* bond_dev_queue_xmit always returns 0 */
			bond_dev_queue_xmit(bond, skb2, slave->dev);
L
Linus Torvalds 已提交
3647 3648
		}
	}
3649 3650 3651
	if (slave && IS_UP(slave->dev) && slave->link == BOND_LINK_UP)
		bond_dev_queue_xmit(bond, skb, slave->dev);
	else
E
Eric Dumazet 已提交
3652
		kfree_skb(skb);
S
Stephen Hemminger 已提交
3653

3654
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
3655 3656 3657 3658
}

/*------------------------- Device initialization ---------------------------*/

3659 3660 3661 3662 3663 3664 3665
/*
 * Lookup the slave that corresponds to a qid
 */
static inline int bond_slave_override(struct bonding *bond,
				      struct sk_buff *skb)
{
	struct slave *slave = NULL;
3666
	struct list_head *iter;
3667

3668 3669
	if (!skb->queue_mapping)
		return 1;
3670 3671

	/* Find out if any slaves have the same mapping as this skb. */
3672 3673 3674 3675 3676 3677 3678
	bond_for_each_slave_rcu(bond, slave, iter) {
		if (slave->queue_id == skb->queue_mapping) {
			if (slave_can_tx(slave)) {
				bond_dev_queue_xmit(bond, skb, slave->dev);
				return 0;
			}
			/* If the slave isn't UP, use default transmit policy. */
3679 3680 3681 3682
			break;
		}
	}

3683
	return 1;
3684 3685
}

3686

3687 3688
static u16 bond_select_queue(struct net_device *dev, struct sk_buff *skb,
			     void *accel_priv)
3689 3690 3691
{
	/*
	 * This helper function exists to help dev_pick_tx get the correct
P
Phil Oester 已提交
3692
	 * destination queue.  Using a helper function skips a call to
3693 3694 3695
	 * skb_tx_hash and will put the skbs in the queue we expect on their
	 * way down to the bonding driver.
	 */
P
Phil Oester 已提交
3696 3697
	u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;

3698 3699 3700
	/*
	 * Save the original txq to restore before passing to the driver
	 */
3701
	qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
3702

P
Phil Oester 已提交
3703
	if (unlikely(txq >= dev->real_num_tx_queues)) {
3704
		do {
P
Phil Oester 已提交
3705
			txq -= dev->real_num_tx_queues;
3706
		} while (txq >= dev->real_num_tx_queues);
P
Phil Oester 已提交
3707 3708
	}
	return txq;
3709 3710
}

3711
static netdev_tx_t __bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
3712
{
3713 3714 3715 3716 3717 3718
	struct bonding *bond = netdev_priv(dev);

	if (TX_QUEUE_OVERRIDE(bond->params.mode)) {
		if (!bond_slave_override(bond, skb))
			return NETDEV_TX_OK;
	}
3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735

	switch (bond->params.mode) {
	case BOND_MODE_ROUNDROBIN:
		return bond_xmit_roundrobin(skb, dev);
	case BOND_MODE_ACTIVEBACKUP:
		return bond_xmit_activebackup(skb, dev);
	case BOND_MODE_XOR:
		return bond_xmit_xor(skb, dev);
	case BOND_MODE_BROADCAST:
		return bond_xmit_broadcast(skb, dev);
	case BOND_MODE_8023AD:
		return bond_3ad_xmit_xor(skb, dev);
	case BOND_MODE_ALB:
	case BOND_MODE_TLB:
		return bond_alb_xmit(skb, dev);
	default:
		/* Should never happen, mode already checked */
J
Joe Perches 已提交
3736 3737
		pr_err("%s: Error: Unknown bonding mode %d\n",
		       dev->name, bond->params.mode);
3738
		WARN_ON_ONCE(1);
E
Eric Dumazet 已提交
3739
		kfree_skb(skb);
3740 3741 3742 3743
		return NETDEV_TX_OK;
	}
}

3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755
static netdev_tx_t bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct bonding *bond = netdev_priv(dev);
	netdev_tx_t ret = NETDEV_TX_OK;

	/*
	 * If we risk deadlock from transmitting this in the
	 * netpoll path, tell netpoll to queue the frame for later tx
	 */
	if (is_netpoll_tx_blocked(dev))
		return NETDEV_TX_BUSY;

3756
	rcu_read_lock();
3757
	if (bond_has_slaves(bond))
3758 3759
		ret = __bond_start_xmit(skb, dev);
	else
E
Eric Dumazet 已提交
3760
		kfree_skb(skb);
3761
	rcu_read_unlock();
3762 3763 3764

	return ret;
}
3765

3766 3767 3768 3769 3770
static int bond_ethtool_get_settings(struct net_device *bond_dev,
				     struct ethtool_cmd *ecmd)
{
	struct bonding *bond = netdev_priv(bond_dev);
	unsigned long speed = 0;
3771
	struct list_head *iter;
3772
	struct slave *slave;
3773 3774 3775 3776 3777 3778 3779 3780 3781 3782

	ecmd->duplex = DUPLEX_UNKNOWN;
	ecmd->port = PORT_OTHER;

	/* Since SLAVE_IS_OK returns false for all inactive or down slaves, we
	 * do not need to check mode.  Though link speed might not represent
	 * the true receive or transmit bandwidth (not all modes are symmetric)
	 * this is an accurate maximum.
	 */
	read_lock(&bond->lock);
3783
	bond_for_each_slave(bond, slave, iter) {
3784 3785 3786 3787 3788 3789 3790 3791 3792 3793
		if (SLAVE_IS_OK(slave)) {
			if (slave->speed != SPEED_UNKNOWN)
				speed += slave->speed;
			if (ecmd->duplex == DUPLEX_UNKNOWN &&
			    slave->duplex != DUPLEX_UNKNOWN)
				ecmd->duplex = slave->duplex;
		}
	}
	ethtool_cmd_speed_set(ecmd, speed ? : SPEED_UNKNOWN);
	read_unlock(&bond->lock);
3794

3795 3796 3797
	return 0;
}

3798
static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
3799
				     struct ethtool_drvinfo *drvinfo)
3800
{
3801 3802 3803 3804
	strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
	strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
	snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "%d",
		 BOND_ABI_VERSION);
3805 3806
}

3807
static const struct ethtool_ops bond_ethtool_ops = {
3808
	.get_drvinfo		= bond_ethtool_get_drvinfo,
3809
	.get_settings		= bond_ethtool_get_settings,
3810
	.get_link		= ethtool_op_get_link,
3811 3812
};

3813
static const struct net_device_ops bond_netdev_ops = {
3814
	.ndo_init		= bond_init,
S
Stephen Hemminger 已提交
3815
	.ndo_uninit		= bond_uninit,
3816 3817
	.ndo_open		= bond_open,
	.ndo_stop		= bond_close,
3818
	.ndo_start_xmit		= bond_start_xmit,
3819
	.ndo_select_queue	= bond_select_queue,
3820
	.ndo_get_stats64	= bond_get_stats,
3821
	.ndo_do_ioctl		= bond_do_ioctl,
3822
	.ndo_change_rx_flags	= bond_change_rx_flags,
3823
	.ndo_set_rx_mode	= bond_set_rx_mode,
3824
	.ndo_change_mtu		= bond_change_mtu,
J
Jiri Pirko 已提交
3825
	.ndo_set_mac_address	= bond_set_mac_address,
3826
	.ndo_neigh_setup	= bond_neigh_setup,
J
Jiri Pirko 已提交
3827
	.ndo_vlan_rx_add_vid	= bond_vlan_rx_add_vid,
3828
	.ndo_vlan_rx_kill_vid	= bond_vlan_rx_kill_vid,
3829
#ifdef CONFIG_NET_POLL_CONTROLLER
3830
	.ndo_netpoll_setup	= bond_netpoll_setup,
3831 3832 3833
	.ndo_netpoll_cleanup	= bond_netpoll_cleanup,
	.ndo_poll_controller	= bond_poll_controller,
#endif
J
Jiri Pirko 已提交
3834 3835
	.ndo_add_slave		= bond_enslave,
	.ndo_del_slave		= bond_release,
3836
	.ndo_fix_features	= bond_fix_features,
3837 3838
};

3839 3840 3841 3842
static const struct device_type bond_type = {
	.name = "bond",
};

3843 3844 3845 3846 3847 3848 3849 3850
static void bond_destructor(struct net_device *bond_dev)
{
	struct bonding *bond = netdev_priv(bond_dev);
	if (bond->wq)
		destroy_workqueue(bond->wq);
	free_netdev(bond_dev);
}

3851
void bond_setup(struct net_device *bond_dev)
L
Linus Torvalds 已提交
3852
{
3853
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3854 3855 3856 3857

	/* initialize rwlocks */
	rwlock_init(&bond->lock);
	rwlock_init(&bond->curr_slave_lock);
3858
	bond->params = bonding_defaults;
L
Linus Torvalds 已提交
3859 3860 3861 3862 3863

	/* Initialize pointers */
	bond->dev = bond_dev;

	/* Initialize the device entry points */
3864
	ether_setup(bond_dev);
3865
	bond_dev->netdev_ops = &bond_netdev_ops;
3866
	bond_dev->ethtool_ops = &bond_ethtool_ops;
L
Linus Torvalds 已提交
3867

3868
	bond_dev->destructor = bond_destructor;
L
Linus Torvalds 已提交
3869

3870 3871
	SET_NETDEV_DEVTYPE(bond_dev, &bond_type);

L
Linus Torvalds 已提交
3872 3873 3874
	/* Initialize the device options */
	bond_dev->tx_queue_len = 0;
	bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
3875
	bond_dev->priv_flags |= IFF_BONDING;
3876
	bond_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
3877

L
Linus Torvalds 已提交
3878 3879 3880 3881 3882 3883 3884
	/* At first, we block adding VLANs. That's the only way to
	 * prevent problems that occur when adding VLANs over an
	 * empty bond. The block will be removed once non-challenged
	 * slaves are enslaved.
	 */
	bond_dev->features |= NETIF_F_VLAN_CHALLENGED;

H
Herbert Xu 已提交
3885
	/* don't acquire bond device's netif_tx_lock when
L
Linus Torvalds 已提交
3886 3887 3888 3889 3890 3891 3892 3893 3894 3895
	 * transmitting */
	bond_dev->features |= NETIF_F_LLTX;

	/* By default, we declare the bond to be fully
	 * VLAN hardware accelerated capable. Special
	 * care is taken in the various xmit functions
	 * when there are slaves that are not hw accel
	 * capable
	 */

3896 3897 3898
	/* Don't allow bond devices to change network namespaces. */
	bond_dev->features |= NETIF_F_NETNS_LOCAL;

3899
	bond_dev->hw_features = BOND_VLAN_FEATURES |
3900 3901 3902
				NETIF_F_HW_VLAN_CTAG_TX |
				NETIF_F_HW_VLAN_CTAG_RX |
				NETIF_F_HW_VLAN_CTAG_FILTER;
3903

3904
	bond_dev->hw_features &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_HW_CSUM);
3905
	bond_dev->features |= bond_dev->hw_features;
L
Linus Torvalds 已提交
3906 3907
}

3908 3909 3910 3911 3912
/*
* Destroy a bonding device.
* Must be under rtnl_lock when this function is called.
*/
static void bond_uninit(struct net_device *bond_dev)
J
Jay Vosburgh 已提交
3913
{
3914
	struct bonding *bond = netdev_priv(bond_dev);
3915 3916
	struct list_head *iter;
	struct slave *slave;
J
Jay Vosburgh 已提交
3917

3918 3919
	bond_netpoll_cleanup(bond_dev);

3920
	/* Release the bonded slaves */
3921
	bond_for_each_slave(bond, slave, iter)
3922
		__bond_release_one(bond_dev, slave->dev, true);
J
Joe Perches 已提交
3923
	pr_info("%s: Released all slaves\n", bond_dev->name);
3924

J
Jay Vosburgh 已提交
3925 3926
	list_del(&bond->bond_list);

3927
	bond_debug_unregister(bond);
J
Jay Vosburgh 已提交
3928 3929
}

L
Linus Torvalds 已提交
3930 3931
/*------------------------- Module initialization ---------------------------*/

3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954
int bond_parm_tbl_lookup(int mode, const struct bond_parm_tbl *tbl)
{
	int i;

	for (i = 0; tbl[i].modename; i++)
		if (mode == tbl[i].mode)
			return tbl[i].mode;

	return -1;
}

static int bond_parm_tbl_lookup_name(const char *modename,
				     const struct bond_parm_tbl *tbl)
{
	int i;

	for (i = 0; tbl[i].modename; i++)
		if (strcmp(modename, tbl[i].modename) == 0)
			return tbl[i].mode;

	return -1;
}

L
Linus Torvalds 已提交
3955 3956
/*
 * Convert string input module parms.  Accept either the
J
Jay Vosburgh 已提交
3957 3958 3959
 * number of the mode or its string name.  A bit complicated because
 * some mode names are substrings of other names, and calls from sysfs
 * may have whitespace in the name (trailing newlines, for example).
L
Linus Torvalds 已提交
3960
 */
3961
int bond_parse_parm(const char *buf, const struct bond_parm_tbl *tbl)
L
Linus Torvalds 已提交
3962
{
3963 3964
	int modeint;
	char *p, modestr[BOND_MAX_MODENAME_LEN + 1];
J
Jay Vosburgh 已提交
3965

J
Jay Vosburgh 已提交
3966 3967 3968 3969
	for (p = (char *)buf; *p; p++)
		if (!(isdigit(*p) || isspace(*p)))
			break;

3970 3971 3972 3973
	if (*p && sscanf(buf, "%20s", modestr) != 0)
		return bond_parm_tbl_lookup_name(modestr, tbl);
	else if (sscanf(buf, "%d", &modeint) != 0)
		return bond_parm_tbl_lookup(modeint, tbl);
L
Linus Torvalds 已提交
3974 3975 3976 3977 3978 3979

	return -1;
}

static int bond_check_params(struct bond_params *params)
{
3980
	int arp_validate_value, fail_over_mac_value, primary_reselect_value, i;
3981
	struct bond_opt_value newval, *valptr;
3982
	int arp_all_targets_value;
3983

L
Linus Torvalds 已提交
3984 3985 3986 3987
	/*
	 * Convert string parameters.
	 */
	if (mode) {
3988 3989 3990 3991
		bond_opt_initstr(&newval, mode);
		valptr = bond_opt_parse(bond_opt_get(BOND_OPT_MODE), &newval);
		if (!valptr) {
			pr_err("Error: Invalid bonding mode \"%s\"\n", mode);
L
Linus Torvalds 已提交
3992 3993
			return -EINVAL;
		}
3994
		bond_mode = valptr->value;
L
Linus Torvalds 已提交
3995 3996
	}

3997 3998 3999
	if (xmit_hash_policy) {
		if ((bond_mode != BOND_MODE_XOR) &&
		    (bond_mode != BOND_MODE_8023AD)) {
J
Joe Perches 已提交
4000
			pr_info("xmit_hash_policy param is irrelevant in mode %s\n",
J
Joe Perches 已提交
4001
				bond_mode_name(bond_mode));
4002
		} else {
4003 4004 4005 4006
			bond_opt_initstr(&newval, xmit_hash_policy);
			valptr = bond_opt_parse(bond_opt_get(BOND_OPT_XMIT_HASH),
						&newval);
			if (!valptr) {
J
Joe Perches 已提交
4007
				pr_err("Error: Invalid xmit_hash_policy \"%s\"\n",
4008 4009 4010
				       xmit_hash_policy);
				return -EINVAL;
			}
4011
			xmit_hashtype = valptr->value;
4012 4013 4014
		}
	}

L
Linus Torvalds 已提交
4015 4016
	if (lacp_rate) {
		if (bond_mode != BOND_MODE_8023AD) {
J
Joe Perches 已提交
4017 4018
			pr_info("lacp_rate param is irrelevant in mode %s\n",
				bond_mode_name(bond_mode));
L
Linus Torvalds 已提交
4019
		} else {
4020 4021 4022 4023
			bond_opt_initstr(&newval, lacp_rate);
			valptr = bond_opt_parse(bond_opt_get(BOND_OPT_LACP_RATE),
						&newval);
			if (!valptr) {
J
Joe Perches 已提交
4024
				pr_err("Error: Invalid lacp rate \"%s\"\n",
4025
				       lacp_rate);
L
Linus Torvalds 已提交
4026 4027
				return -EINVAL;
			}
4028
			lacp_fast = valptr->value;
L
Linus Torvalds 已提交
4029 4030 4031
		}
	}

4032
	if (ad_select) {
4033 4034 4035 4036 4037
		bond_opt_initstr(&newval, lacp_rate);
		valptr = bond_opt_parse(bond_opt_get(BOND_OPT_AD_SELECT),
					&newval);
		if (!valptr) {
			pr_err("Error: Invalid ad_select \"%s\"\n", ad_select);
4038 4039
			return -EINVAL;
		}
4040 4041
		params->ad_select = valptr->value;
		if (bond_mode != BOND_MODE_8023AD)
4042
			pr_warn("ad_select param only affects 802.3ad mode\n");
4043 4044 4045 4046
	} else {
		params->ad_select = BOND_AD_STABLE;
	}

4047
	if (max_bonds < 0) {
4048 4049
		pr_warn("Warning: max_bonds (%d) not in range %d-%d, so it was reset to BOND_DEFAULT_MAX_BONDS (%d)\n",
			max_bonds, 0, INT_MAX, BOND_DEFAULT_MAX_BONDS);
L
Linus Torvalds 已提交
4050 4051 4052 4053
		max_bonds = BOND_DEFAULT_MAX_BONDS;
	}

	if (miimon < 0) {
4054 4055
		pr_warn("Warning: miimon module parameter (%d), not in range 0-%d, so it was reset to 0\n",
			miimon, INT_MAX);
4056
		miimon = 0;
L
Linus Torvalds 已提交
4057 4058 4059
	}

	if (updelay < 0) {
4060 4061
		pr_warn("Warning: updelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
			updelay, INT_MAX);
L
Linus Torvalds 已提交
4062 4063 4064 4065
		updelay = 0;
	}

	if (downdelay < 0) {
4066 4067
		pr_warn("Warning: downdelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
			downdelay, INT_MAX);
L
Linus Torvalds 已提交
4068 4069 4070 4071
		downdelay = 0;
	}

	if ((use_carrier != 0) && (use_carrier != 1)) {
4072 4073
		pr_warn("Warning: use_carrier module parameter (%d), not of valid value (0/1), so it was set to 1\n",
			use_carrier);
L
Linus Torvalds 已提交
4074 4075 4076
		use_carrier = 1;
	}

4077
	if (num_peer_notif < 0 || num_peer_notif > 255) {
4078 4079
		pr_warn("Warning: num_grat_arp/num_unsol_na (%d) not in range 0-255 so it was reset to 1\n",
			num_peer_notif);
4080 4081 4082
		num_peer_notif = 1;
	}

4083 4084
	/* reset values for 802.3ad/TLB/ALB */
	if (BOND_NO_USES_ARP(bond_mode)) {
L
Linus Torvalds 已提交
4085
		if (!miimon) {
4086 4087
			pr_warn("Warning: miimon must be specified, otherwise bonding will not detect link failure, speed and duplex which are essential for 802.3ad operation\n");
			pr_warn("Forcing miimon to 100msec\n");
4088
			miimon = BOND_DEFAULT_MIIMON;
L
Linus Torvalds 已提交
4089 4090 4091
		}
	}

4092
	if (tx_queues < 1 || tx_queues > 255) {
4093 4094
		pr_warn("Warning: tx_queues (%d) should be between 1 and 255, resetting to %d\n",
			tx_queues, BOND_DEFAULT_TX_QUEUES);
4095 4096 4097
		tx_queues = BOND_DEFAULT_TX_QUEUES;
	}

4098
	if ((all_slaves_active != 0) && (all_slaves_active != 1)) {
4099 4100
		pr_warn("Warning: all_slaves_active module parameter (%d), not of valid value (0/1), so it was set to 0\n",
			all_slaves_active);
4101 4102 4103
		all_slaves_active = 0;
	}

4104
	if (resend_igmp < 0 || resend_igmp > 255) {
4105 4106
		pr_warn("Warning: resend_igmp (%d) should be between 0 and 255, resetting to %d\n",
			resend_igmp, BOND_DEFAULT_RESEND_IGMP);
4107 4108 4109
		resend_igmp = BOND_DEFAULT_RESEND_IGMP;
	}

4110 4111
	bond_opt_initval(&newval, packets_per_slave);
	if (!bond_opt_parse(bond_opt_get(BOND_OPT_PACKETS_PER_SLAVE), &newval)) {
4112 4113 4114 4115 4116
		pr_warn("Warning: packets_per_slave (%d) should be between 0 and %u resetting to 1\n",
			packets_per_slave, USHRT_MAX);
		packets_per_slave = 1;
	}

L
Linus Torvalds 已提交
4117
	if (bond_mode == BOND_MODE_ALB) {
J
Joe Perches 已提交
4118 4119
		pr_notice("In ALB mode you might experience client disconnections upon reconnection of a link if the bonding module updelay parameter (%d msec) is incompatible with the forwarding delay time of the switch\n",
			  updelay);
L
Linus Torvalds 已提交
4120 4121 4122 4123 4124 4125 4126
	}

	if (!miimon) {
		if (updelay || downdelay) {
			/* just warn the user the up/down delay will have
			 * no effect since miimon is zero...
			 */
4127 4128
			pr_warn("Warning: miimon module parameter not set and updelay (%d) or downdelay (%d) module parameter is set; updelay and downdelay have no effect unless miimon is set\n",
				updelay, downdelay);
L
Linus Torvalds 已提交
4129 4130 4131 4132
		}
	} else {
		/* don't allow arp monitoring */
		if (arp_interval) {
4133 4134
			pr_warn("Warning: miimon (%d) and arp_interval (%d) can't be used simultaneously, disabling ARP monitoring\n",
				miimon, arp_interval);
L
Linus Torvalds 已提交
4135 4136 4137 4138
			arp_interval = 0;
		}

		if ((updelay % miimon) != 0) {
4139 4140
			pr_warn("Warning: updelay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n",
				updelay, miimon, (updelay / miimon) * miimon);
L
Linus Torvalds 已提交
4141 4142 4143 4144 4145
		}

		updelay /= miimon;

		if ((downdelay % miimon) != 0) {
4146 4147 4148
			pr_warn("Warning: downdelay (%d) is not a multiple of miimon (%d), downdelay rounded to %d ms\n",
				downdelay, miimon,
				(downdelay / miimon) * miimon);
L
Linus Torvalds 已提交
4149 4150 4151 4152 4153 4154
		}

		downdelay /= miimon;
	}

	if (arp_interval < 0) {
4155 4156
		pr_warn("Warning: arp_interval module parameter (%d), not in range 0-%d, so it was reset to 0\n",
			arp_interval, INT_MAX);
4157
		arp_interval = 0;
L
Linus Torvalds 已提交
4158 4159
	}

4160 4161
	for (arp_ip_count = 0, i = 0;
	     (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[i]; i++) {
L
Linus Torvalds 已提交
4162 4163
		/* not complete check, but should be good enough to
		   catch mistakes */
4164 4165 4166
		__be32 ip;
		if (!in4_pton(arp_ip_target[i], -1, (u8 *)&ip, -1, NULL) ||
		    IS_IP_TARGET_UNUSABLE_ADDRESS(ip)) {
4167 4168
			pr_warn("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n",
				arp_ip_target[i]);
L
Linus Torvalds 已提交
4169 4170
			arp_interval = 0;
		} else {
4171 4172 4173
			if (bond_get_targets_ip(arp_target, ip) == -1)
				arp_target[arp_ip_count++] = ip;
			else
4174 4175
				pr_warn("Warning: duplicate address %pI4 in arp_ip_target, skipping\n",
					&ip);
L
Linus Torvalds 已提交
4176 4177 4178 4179 4180
		}
	}

	if (arp_interval && !arp_ip_count) {
		/* don't allow arping if no arp_ip_target given... */
4181 4182
		pr_warn("Warning: arp_interval module parameter (%d) specified without providing an arp_ip_target parameter, arp_interval was reset to 0\n",
			arp_interval);
L
Linus Torvalds 已提交
4183 4184 4185
		arp_interval = 0;
	}

4186 4187
	if (arp_validate) {
		if (!arp_interval) {
J
Joe Perches 已提交
4188
			pr_err("arp_validate requires arp_interval\n");
4189 4190 4191
			return -EINVAL;
		}

4192 4193 4194 4195
		bond_opt_initstr(&newval, arp_validate);
		valptr = bond_opt_parse(bond_opt_get(BOND_OPT_ARP_VALIDATE),
					&newval);
		if (!valptr) {
J
Joe Perches 已提交
4196
			pr_err("Error: invalid arp_validate \"%s\"\n",
4197
			       arp_validate);
4198 4199
			return -EINVAL;
		}
4200 4201
		arp_validate_value = valptr->value;
	} else {
4202
		arp_validate_value = 0;
4203
	}
4204

4205 4206
	arp_all_targets_value = 0;
	if (arp_all_targets) {
4207 4208 4209 4210
		bond_opt_initstr(&newval, arp_all_targets);
		valptr = bond_opt_parse(bond_opt_get(BOND_OPT_ARP_ALL_TARGETS),
					&newval);
		if (!valptr) {
4211 4212 4213
			pr_err("Error: invalid arp_all_targets_value \"%s\"\n",
			       arp_all_targets);
			arp_all_targets_value = 0;
4214 4215
		} else {
			arp_all_targets_value = valptr->value;
4216 4217 4218
		}
	}

L
Linus Torvalds 已提交
4219
	if (miimon) {
J
Joe Perches 已提交
4220
		pr_info("MII link monitoring set to %d ms\n", miimon);
L
Linus Torvalds 已提交
4221
	} else if (arp_interval) {
4222 4223
		valptr = bond_opt_get_val(BOND_OPT_ARP_VALIDATE,
					  arp_validate_value);
J
Joe Perches 已提交
4224
		pr_info("ARP monitoring set to %d ms, validate %s, with %d target(s):",
4225
			arp_interval, valptr->string, arp_ip_count);
L
Linus Torvalds 已提交
4226 4227

		for (i = 0; i < arp_ip_count; i++)
J
Joe Perches 已提交
4228
			pr_cont(" %s", arp_ip_target[i]);
L
Linus Torvalds 已提交
4229

J
Joe Perches 已提交
4230
		pr_cont("\n");
L
Linus Torvalds 已提交
4231

4232
	} else if (max_bonds) {
L
Linus Torvalds 已提交
4233 4234 4235
		/* miimon and arp_interval not set, we need one so things
		 * work as expected, see bonding.txt for details
		 */
J
Joe Perches 已提交
4236
		pr_debug("Warning: either miimon or arp_interval and arp_ip_target module parameters must be specified, otherwise bonding will not detect link failures! see bonding.txt for details\n");
L
Linus Torvalds 已提交
4237 4238 4239 4240 4241 4242
	}

	if (primary && !USES_PRIMARY(bond_mode)) {
		/* currently, using a primary only makes sense
		 * in active backup, TLB or ALB modes
		 */
4243 4244
		pr_warn("Warning: %s primary device specified but has no effect in %s mode\n",
			primary, bond_mode_name(bond_mode));
L
Linus Torvalds 已提交
4245 4246 4247
		primary = NULL;
	}

4248
	if (primary && primary_reselect) {
4249 4250 4251 4252
		bond_opt_initstr(&newval, primary_reselect);
		valptr = bond_opt_parse(bond_opt_get(BOND_OPT_PRIMARY_RESELECT),
					&newval);
		if (!valptr) {
J
Joe Perches 已提交
4253
			pr_err("Error: Invalid primary_reselect \"%s\"\n",
4254
			       primary_reselect);
4255 4256
			return -EINVAL;
		}
4257
		primary_reselect_value = valptr->value;
4258 4259 4260 4261
	} else {
		primary_reselect_value = BOND_PRI_RESELECT_ALWAYS;
	}

4262
	if (fail_over_mac) {
4263 4264 4265 4266
		bond_opt_initstr(&newval, fail_over_mac);
		valptr = bond_opt_parse(bond_opt_get(BOND_OPT_FAIL_OVER_MAC),
					&newval);
		if (!valptr) {
J
Joe Perches 已提交
4267
			pr_err("Error: invalid fail_over_mac \"%s\"\n",
4268
			       fail_over_mac);
4269 4270
			return -EINVAL;
		}
4271
		fail_over_mac_value = valptr->value;
4272
		if (bond_mode != BOND_MODE_ACTIVEBACKUP)
4273
			pr_warn("Warning: fail_over_mac only affects active-backup mode\n");
4274 4275 4276
	} else {
		fail_over_mac_value = BOND_FOM_NONE;
	}
4277

4278
	if (lp_interval == 0) {
4279 4280
		pr_warn("Warning: ip_interval must be between 1 and %d, so it was reset to %d\n",
			INT_MAX, BOND_ALB_DEFAULT_LP_INTERVAL);
4281 4282 4283
		lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL;
	}

L
Linus Torvalds 已提交
4284 4285
	/* fill params struct with the proper values */
	params->mode = bond_mode;
4286
	params->xmit_policy = xmit_hashtype;
L
Linus Torvalds 已提交
4287
	params->miimon = miimon;
4288
	params->num_peer_notif = num_peer_notif;
L
Linus Torvalds 已提交
4289
	params->arp_interval = arp_interval;
4290
	params->arp_validate = arp_validate_value;
4291
	params->arp_all_targets = arp_all_targets_value;
L
Linus Torvalds 已提交
4292 4293 4294 4295 4296
	params->updelay = updelay;
	params->downdelay = downdelay;
	params->use_carrier = use_carrier;
	params->lacp_fast = lacp_fast;
	params->primary[0] = 0;
4297
	params->primary_reselect = primary_reselect_value;
4298
	params->fail_over_mac = fail_over_mac_value;
4299
	params->tx_queues = tx_queues;
4300
	params->all_slaves_active = all_slaves_active;
4301
	params->resend_igmp = resend_igmp;
4302
	params->min_links = min_links;
4303
	params->lp_interval = lp_interval;
4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315
	params->packets_per_slave = packets_per_slave;
	if (packets_per_slave > 0) {
		params->reciprocal_packets_per_slave =
			reciprocal_value(packets_per_slave);
	} else {
		/* reciprocal_packets_per_slave is unused if
		 * packets_per_slave is 0 or 1, just initialize it
		 */
		params->reciprocal_packets_per_slave =
			(struct reciprocal_value) { 0 };
	}

L
Linus Torvalds 已提交
4316 4317 4318 4319 4320 4321 4322 4323 4324 4325
	if (primary) {
		strncpy(params->primary, primary, IFNAMSIZ);
		params->primary[IFNAMSIZ - 1] = 0;
	}

	memcpy(params->arp_targets, arp_target, sizeof(arp_target));

	return 0;
}

4326
static struct lock_class_key bonding_netdev_xmit_lock_key;
4327
static struct lock_class_key bonding_netdev_addr_lock_key;
4328
static struct lock_class_key bonding_tx_busylock_key;
4329

4330 4331 4332
static void bond_set_lockdep_class_one(struct net_device *dev,
				       struct netdev_queue *txq,
				       void *_unused)
4333 4334 4335 4336 4337 4338 4339
{
	lockdep_set_class(&txq->_xmit_lock,
			  &bonding_netdev_xmit_lock_key);
}

static void bond_set_lockdep_class(struct net_device *dev)
{
4340 4341
	lockdep_set_class(&dev->addr_list_lock,
			  &bonding_netdev_addr_lock_key);
4342
	netdev_for_each_tx_queue(dev, bond_set_lockdep_class_one, NULL);
4343
	dev->qdisc_tx_busylock = &bonding_tx_busylock_key;
4344 4345
}

4346 4347 4348 4349 4350 4351
/*
 * Called from registration process
 */
static int bond_init(struct net_device *bond_dev)
{
	struct bonding *bond = netdev_priv(bond_dev);
4352
	struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
4353
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
4354 4355 4356

	pr_debug("Begin bond_init for %s\n", bond_dev->name);

4357 4358 4359 4360 4361 4362 4363 4364 4365
	/*
	 * Initialize locks that may be required during
	 * en/deslave operations.  All of the bond_open work
	 * (of which this is part) should really be moved to
	 * a phase prior to dev_open
	 */
	spin_lock_init(&(bond_info->tx_hashtbl_lock));
	spin_lock_init(&(bond_info->rx_hashtbl_lock));

4366 4367 4368 4369 4370 4371
	bond->wq = create_singlethread_workqueue(bond_dev->name);
	if (!bond->wq)
		return -ENOMEM;

	bond_set_lockdep_class(bond_dev);

4372
	list_add_tail(&bond->bond_list, &bn->dev_list);
4373

4374
	bond_prepare_sysfs_group(bond);
4375

4376 4377
	bond_debug_register(bond);

4378 4379
	/* Ensure valid dev_addr */
	if (is_zero_ether_addr(bond_dev->dev_addr) &&
4380
	    bond_dev->addr_assign_type == NET_ADDR_PERM)
4381 4382
		eth_hw_addr_random(bond_dev);

4383 4384 4385
	return 0;
}

4386
unsigned int bond_get_num_tx_queues(void)
4387
{
4388
	return tx_queues;
4389 4390
}

4391
/* Create a new bond based on the specified name and bonding parameters.
4392
 * If name is NULL, obtain a suitable "bond%d" name for us.
4393 4394 4395
 * Caller must NOT hold rtnl_lock; we need to release it here before we
 * set up our sysfs entries.
 */
4396
int bond_create(struct net *net, const char *name)
4397 4398 4399 4400 4401
{
	struct net_device *bond_dev;
	int res;

	rtnl_lock();
4402

4403 4404 4405
	bond_dev = alloc_netdev_mq(sizeof(struct bonding),
				   name ? name : "bond%d",
				   bond_setup, tx_queues);
4406
	if (!bond_dev) {
J
Joe Perches 已提交
4407
		pr_err("%s: eek! can't alloc netdev!\n", name);
4408 4409
		rtnl_unlock();
		return -ENOMEM;
4410 4411
	}

4412
	dev_net_set(bond_dev, net);
4413 4414
	bond_dev->rtnl_link_ops = &bond_link_ops;

4415
	res = register_netdevice(bond_dev);
4416

4417 4418
	netif_carrier_off(bond_dev);

4419
	rtnl_unlock();
4420 4421
	if (res < 0)
		bond_destructor(bond_dev);
E
Eric W. Biederman 已提交
4422
	return res;
4423 4424
}

4425
static int __net_init bond_net_init(struct net *net)
4426
{
4427
	struct bond_net *bn = net_generic(net, bond_net_id);
4428 4429 4430 4431 4432

	bn->net = net;
	INIT_LIST_HEAD(&bn->dev_list);

	bond_create_proc_dir(bn);
4433
	bond_create_sysfs(bn);
4434

4435
	return 0;
4436 4437
}

4438
static void __net_exit bond_net_exit(struct net *net)
4439
{
4440
	struct bond_net *bn = net_generic(net, bond_net_id);
4441 4442
	struct bonding *bond, *tmp_bond;
	LIST_HEAD(list);
4443

4444
	bond_destroy_sysfs(bn);
4445
	bond_destroy_proc_dir(bn);
4446 4447 4448 4449 4450 4451 4452

	/* Kill off any bonds created after unregistering bond rtnl ops */
	rtnl_lock();
	list_for_each_entry_safe(bond, tmp_bond, &bn->dev_list, bond_list)
		unregister_netdevice_queue(bond->dev, &list);
	unregister_netdevice_many(&list);
	rtnl_unlock();
4453 4454 4455 4456 4457
}

static struct pernet_operations bond_net_ops = {
	.init = bond_net_init,
	.exit = bond_net_exit,
4458 4459
	.id   = &bond_net_id,
	.size = sizeof(struct bond_net),
4460 4461
};

L
Linus Torvalds 已提交
4462 4463 4464 4465 4466
static int __init bonding_init(void)
{
	int i;
	int res;

4467
	pr_info("%s", bond_version);
L
Linus Torvalds 已提交
4468

4469
	res = bond_check_params(&bonding_defaults);
S
Stephen Hemminger 已提交
4470
	if (res)
4471
		goto out;
L
Linus Torvalds 已提交
4472

4473
	res = register_pernet_subsys(&bond_net_ops);
4474 4475
	if (res)
		goto out;
4476

4477
	res = bond_netlink_init();
4478
	if (res)
4479
		goto err_link;
4480

4481 4482
	bond_create_debugfs();

L
Linus Torvalds 已提交
4483
	for (i = 0; i < max_bonds; i++) {
4484
		res = bond_create(&init_net, NULL);
4485 4486
		if (res)
			goto err;
L
Linus Torvalds 已提交
4487 4488 4489
	}

	register_netdevice_notifier(&bond_netdev_notifier);
4490
out:
L
Linus Torvalds 已提交
4491
	return res;
4492
err:
4493
	bond_netlink_fini();
4494
err_link:
4495
	unregister_pernet_subsys(&bond_net_ops);
4496
	goto out;
4497

L
Linus Torvalds 已提交
4498 4499 4500 4501 4502 4503
}

static void __exit bonding_exit(void)
{
	unregister_netdevice_notifier(&bond_netdev_notifier);

4504
	bond_destroy_debugfs();
4505

4506
	bond_netlink_fini();
4507
	unregister_pernet_subsys(&bond_net_ops);
4508 4509

#ifdef CONFIG_NET_POLL_CONTROLLER
4510 4511 4512 4513
	/*
	 * Make sure we don't have an imbalance on our netpoll blocking
	 */
	WARN_ON(atomic_read(&netpoll_block_tx));
4514
#endif
L
Linus Torvalds 已提交
4515 4516 4517 4518 4519 4520 4521 4522
}

module_init(bonding_init);
module_exit(bonding_exit);
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);
MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION);
MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others");