bond_main.c 122.2 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>
82
#include <linux/reciprocal_div.h>
L
Linus Torvalds 已提交
83 84 85 86 87 88 89 90 91 92 93
#include "bonding.h"
#include "bond_3ad.h"
#include "bond_alb.h"

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

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

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

module_param(max_bonds, int, 0);
MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
120 121
module_param(tx_queues, int, 0);
MODULE_PARM_DESC(tx_queues, "Max number of transmit queues (default = 16)");
122
module_param_named(num_grat_arp, num_peer_notif, int, 0644);
123 124
MODULE_PARM_DESC(num_grat_arp, "Number of peer notifications to send on "
			       "failover event (alias of num_unsol_na)");
125
module_param_named(num_unsol_na, num_peer_notif, int, 0644);
126 127
MODULE_PARM_DESC(num_unsol_na, "Number of peer notifications to send on "
			       "failover event (alias of num_grat_arp)");
L
Linus Torvalds 已提交
128 129 130 131 132
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);
133 134
MODULE_PARM_DESC(downdelay, "Delay before considering link down, "
			    "in milliseconds");
L
Linus Torvalds 已提交
135
module_param(use_carrier, int, 0);
136 137
MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; "
			      "0 for off, 1 for on (default)");
L
Linus Torvalds 已提交
138
module_param(mode, charp, 0);
139
MODULE_PARM_DESC(mode, "Mode of operation; 0 for balance-rr, "
140 141 142
		       "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 已提交
143 144
module_param(primary, charp, 0);
MODULE_PARM_DESC(primary, "Primary network device to use");
145 146 147 148 149 150 151 152
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 已提交
153
module_param(lacp_rate, charp, 0);
154 155
MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner; "
			    "0 for slow, 1 for fast");
156
module_param(ad_select, charp, 0);
157 158 159
MODULE_PARM_DESC(ad_select, "803.ad aggregation selection logic; "
			    "0 for stable (default), 1 for bandwidth, "
			    "2 for count");
160 161 162
module_param(min_links, int, 0);
MODULE_PARM_DESC(min_links, "Minimum number of available links before turning on carrier");

163
module_param(xmit_hash_policy, charp, 0);
164 165
MODULE_PARM_DESC(xmit_hash_policy, "balance-xor and 802.3ad hashing method; "
				   "0 for layer 2 (default), 1 for layer 3+4, "
166 167
				   "2 for layer 2+3, 3 for encap layer 2+3, "
				   "4 for encap layer 3+4");
L
Linus Torvalds 已提交
168 169 170 171
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");
172
module_param(arp_validate, charp, 0);
173 174 175
MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes; "
			       "0 for none (default), 1 for active, "
			       "2 for backup, 3 for all");
176 177
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");
178
module_param(fail_over_mac, charp, 0);
179 180 181
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");
182 183
module_param(all_slaves_active, int, 0);
MODULE_PARM_DESC(all_slaves_active, "Keep all frames received on an interface"
184
				     "by setting active flag for all slaves; "
185
				     "0 for never (default), 1 for always.");
186
module_param(resend_igmp, int, 0);
187 188
MODULE_PARM_DESC(resend_igmp, "Number of IGMP membership reports to send on "
			      "link failure");
189 190 191 192
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.");
193 194 195 196
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 已提交
197 198 199

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

200
#ifdef CONFIG_NET_POLL_CONTROLLER
201
atomic_t netpoll_block_tx = ATOMIC_INIT(0);
202 203
#endif

204
int bond_net_id __read_mostly;
L
Linus Torvalds 已提交
205

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

212
const struct bond_parm_tbl bond_lacp_tbl[] = {
L
Linus Torvalds 已提交
213 214 215 216 217
{	"slow",		AD_LACP_SLOW},
{	"fast",		AD_LACP_FAST},
{	NULL,		-1},
};

218
const struct bond_parm_tbl bond_mode_tbl[] = {
L
Linus Torvalds 已提交
219 220 221 222 223 224 225 226 227 228
{	"balance-rr",		BOND_MODE_ROUNDROBIN},
{	"active-backup",	BOND_MODE_ACTIVEBACKUP},
{	"balance-xor",		BOND_MODE_XOR},
{	"broadcast",		BOND_MODE_BROADCAST},
{	"802.3ad",		BOND_MODE_8023AD},
{	"balance-tlb",		BOND_MODE_TLB},
{	"balance-alb",		BOND_MODE_ALB},
{	NULL,			-1},
};

229
const struct bond_parm_tbl xmit_hashtype_tbl[] = {
230 231
{	"layer2",		BOND_XMIT_POLICY_LAYER2},
{	"layer3+4",		BOND_XMIT_POLICY_LAYER34},
232
{	"layer2+3",		BOND_XMIT_POLICY_LAYER23},
233 234
{	"encap2+3",		BOND_XMIT_POLICY_ENCAP23},
{	"encap3+4",		BOND_XMIT_POLICY_ENCAP34},
235 236 237
{	NULL,			-1},
};

238 239 240 241 242 243
const struct bond_parm_tbl arp_all_targets_tbl[] = {
{	"any",			BOND_ARP_TARGETS_ANY},
{	"all",			BOND_ARP_TARGETS_ALL},
{	NULL,			-1},
};

244
const struct bond_parm_tbl arp_validate_tbl[] = {
245 246 247 248 249 250 251
{	"none",			BOND_ARP_VALIDATE_NONE},
{	"active",		BOND_ARP_VALIDATE_ACTIVE},
{	"backup",		BOND_ARP_VALIDATE_BACKUP},
{	"all",			BOND_ARP_VALIDATE_ALL},
{	NULL,			-1},
};

252
const struct bond_parm_tbl fail_over_mac_tbl[] = {
253 254 255 256 257 258
{	"none",			BOND_FOM_NONE},
{	"active",		BOND_FOM_ACTIVE},
{	"follow",		BOND_FOM_FOLLOW},
{	NULL,			-1},
};

259 260 261 262 263 264 265
const struct bond_parm_tbl pri_reselect_tbl[] = {
{	"always",		BOND_PRI_RESELECT_ALWAYS},
{	"better",		BOND_PRI_RESELECT_BETTER},
{	"failure",		BOND_PRI_RESELECT_FAILURE},
{	NULL,			-1},
};

266 267 268 269 270 271 272
struct bond_parm_tbl ad_select_tbl[] = {
{	"stable",	BOND_AD_STABLE},
{	"bandwidth",	BOND_AD_BANDWIDTH},
{	"count",	BOND_AD_COUNT},
{	NULL,		-1},
};

L
Linus Torvalds 已提交
273 274
/*-------------------------- Forward declarations ---------------------------*/

275
static int bond_init(struct net_device *bond_dev);
276
static void bond_uninit(struct net_device *bond_dev);
L
Linus Torvalds 已提交
277 278 279

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

280
const char *bond_mode_name(int mode)
L
Linus Torvalds 已提交
281
{
282 283 284 285 286
	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 已提交
287
		[BOND_MODE_8023AD] = "IEEE 802.3ad Dynamic link aggregation",
288 289 290 291
		[BOND_MODE_TLB] = "transmit load balancing",
		[BOND_MODE_ALB] = "adaptive load balancing",
	};

292
	if (mode < BOND_MODE_ROUNDROBIN || mode > BOND_MODE_ALB)
L
Linus Torvalds 已提交
293
		return "unknown";
294 295

	return names[mode];
L
Linus Torvalds 已提交
296 297 298 299 300 301
}

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

/**
 * bond_dev_queue_xmit - Prepare skb for xmit.
S
Stephen Hemminger 已提交
302
 *
L
Linus Torvalds 已提交
303 304 305 306
 * @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
 */
S
Stephen Hemminger 已提交
307 308
int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb,
			struct net_device *slave_dev)
L
Linus Torvalds 已提交
309
{
310
	skb->dev = slave_dev;
311

312
	BUILD_BUG_ON(sizeof(skb->queue_mapping) !=
313 314
		     sizeof(qdisc_skb_cb(skb)->slave_dev_queue_mapping));
	skb->queue_mapping = qdisc_skb_cb(skb)->slave_dev_queue_mapping;
315

316
	if (unlikely(netpoll_tx_running(bond->dev)))
317
		bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb);
318
	else
319
		dev_queue_xmit(skb);
L
Linus Torvalds 已提交
320 321 322 323 324

	return 0;
}

/*
J
Jiri Pirko 已提交
325 326
 * 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 已提交
327 328 329 330
 * 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 已提交
331
 *
L
Linus Torvalds 已提交
332 333 334 335 336 337 338 339 340 341 342 343 344 345
 * 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
 */
346 347
static int bond_vlan_rx_add_vid(struct net_device *bond_dev,
				__be16 proto, u16 vid)
L
Linus Torvalds 已提交
348
{
349
	struct bonding *bond = netdev_priv(bond_dev);
350
	struct slave *slave, *rollback_slave;
351
	struct list_head *iter;
352
	int res;
L
Linus Torvalds 已提交
353

354
	bond_for_each_slave(bond, slave, iter) {
355
		res = vlan_vid_add(slave->dev, proto, vid);
356 357
		if (res)
			goto unwind;
L
Linus Torvalds 已提交
358 359
	}

360
	return 0;
361 362

unwind:
363
	/* unwind to the slave that failed */
364
	bond_for_each_slave(bond, rollback_slave, iter) {
365 366 367 368 369
		if (rollback_slave == slave)
			break;

		vlan_vid_del(rollback_slave->dev, proto, vid);
	}
370 371

	return res;
L
Linus Torvalds 已提交
372 373 374 375 376 377 378
}

/**
 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
 * @bond_dev: bonding net device that got called
 * @vid: vlan id being removed
 */
379 380
static int bond_vlan_rx_kill_vid(struct net_device *bond_dev,
				 __be16 proto, u16 vid)
L
Linus Torvalds 已提交
381
{
382
	struct bonding *bond = netdev_priv(bond_dev);
383
	struct list_head *iter;
L
Linus Torvalds 已提交
384 385
	struct slave *slave;

386
	bond_for_each_slave(bond, slave, iter)
387
		vlan_vid_del(slave->dev, proto, vid);
L
Linus Torvalds 已提交
388

389 390
	if (bond_is_lb(bond))
		bond_alb_clear_vlan(bond, vid);
391 392

	return 0;
L
Linus Torvalds 已提交
393 394 395 396
}

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

397 398 399 400 401 402 403 404 405
/*
 * 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)
{
406
	struct list_head *iter;
407 408
	struct slave *slave;

409
	if (!bond_has_slaves(bond))
410 411 412 413 414
		goto down;

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

415
	bond_for_each_slave(bond, slave, iter) {
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
		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 已提交
433 434 435
/*
 * Get link speed and duplex from the slave's base driver
 * using ethtool. If for some reason the call fails or the
436
 * values are invalid, set speed and duplex to -1,
437
 * and return.
L
Linus Torvalds 已提交
438
 */
439
static void bond_update_speed_duplex(struct slave *slave)
L
Linus Torvalds 已提交
440 441
{
	struct net_device *slave_dev = slave->dev;
442
	struct ethtool_cmd ecmd;
443
	u32 slave_speed;
444
	int res;
L
Linus Torvalds 已提交
445

446 447
	slave->speed = SPEED_UNKNOWN;
	slave->duplex = DUPLEX_UNKNOWN;
L
Linus Torvalds 已提交
448

449
	res = __ethtool_get_settings(slave_dev, &ecmd);
450
	if (res < 0)
451
		return;
L
Linus Torvalds 已提交
452

453
	slave_speed = ethtool_cmd_speed(&ecmd);
J
Jiri Pirko 已提交
454
	if (slave_speed == 0 || slave_speed == ((__u32) -1))
455
		return;
L
Linus Torvalds 已提交
456

457
	switch (ecmd.duplex) {
L
Linus Torvalds 已提交
458 459 460 461
	case DUPLEX_FULL:
	case DUPLEX_HALF:
		break;
	default:
462
		return;
L
Linus Torvalds 已提交
463 464
	}

465
	slave->speed = slave_speed;
466
	slave->duplex = ecmd.duplex;
L
Linus Torvalds 已提交
467

468
	return;
L
Linus Torvalds 已提交
469 470 471 472 473 474
}

/*
 * 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 已提交
475
 * depending upon the setting of the use_carrier parameter.
L
Linus Torvalds 已提交
476 477 478 479 480 481 482 483 484 485 486
 *
 * 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 已提交
487 488
static int bond_check_dev_link(struct bonding *bond,
			       struct net_device *slave_dev, int reporting)
L
Linus Torvalds 已提交
489
{
490
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
491
	int (*ioctl)(struct net_device *, struct ifreq *, int);
L
Linus Torvalds 已提交
492 493 494
	struct ifreq ifr;
	struct mii_ioctl_data *mii;

495 496 497
	if (!reporting && !netif_running(slave_dev))
		return 0;

498
	if (bond->params.use_carrier)
L
Linus Torvalds 已提交
499 500
		return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;

501
	/* Try to get link status using Ethtool first. */
502 503 504
	if (slave_dev->ethtool_ops->get_link)
		return slave_dev->ethtool_ops->get_link(slave_dev) ?
			BMSR_LSTATUS : 0;
505

S
Stephen Hemminger 已提交
506
	/* Ethtool can't be used, fallback to MII ioctls. */
507
	ioctl = slave_ops->ndo_do_ioctl;
L
Linus Torvalds 已提交
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
	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 已提交
526 527
			if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0)
				return mii->val_out & BMSR_LSTATUS;
L
Linus Torvalds 已提交
528 529 530 531 532
		}
	}

	/*
	 * If reporting, report that either there's no dev->do_ioctl,
533
	 * or both SIOCGMIIREG and get_link failed (meaning that we
L
Linus Torvalds 已提交
534 535 536
	 * cannot report link status).  If not reporting, pretend
	 * we're ok.
	 */
S
Stephen Hemminger 已提交
537
	return reporting ? -1 : BMSR_LSTATUS;
L
Linus Torvalds 已提交
538 539 540 541 542 543 544
}

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

/*
 * Push the promiscuity flag down to appropriate slaves
 */
545
static int bond_set_promiscuity(struct bonding *bond, int inc)
L
Linus Torvalds 已提交
546
{
547
	struct list_head *iter;
548
	int err = 0;
549

L
Linus Torvalds 已提交
550 551 552
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
		if (bond->curr_active_slave) {
553 554
			err = dev_set_promiscuity(bond->curr_active_slave->dev,
						  inc);
L
Linus Torvalds 已提交
555 556 557
		}
	} else {
		struct slave *slave;
558

559
		bond_for_each_slave(bond, slave, iter) {
560 561 562
			err = dev_set_promiscuity(slave->dev, inc);
			if (err)
				return err;
L
Linus Torvalds 已提交
563 564
		}
	}
565
	return err;
L
Linus Torvalds 已提交
566 567 568 569 570
}

/*
 * Push the allmulti flag down to all slaves
 */
571
static int bond_set_allmulti(struct bonding *bond, int inc)
L
Linus Torvalds 已提交
572
{
573
	struct list_head *iter;
574
	int err = 0;
575

L
Linus Torvalds 已提交
576 577 578
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
		if (bond->curr_active_slave) {
579 580
			err = dev_set_allmulti(bond->curr_active_slave->dev,
					       inc);
L
Linus Torvalds 已提交
581 582 583
		}
	} else {
		struct slave *slave;
584

585
		bond_for_each_slave(bond, slave, iter) {
586 587 588
			err = dev_set_allmulti(slave->dev, inc);
			if (err)
				return err;
L
Linus Torvalds 已提交
589 590
		}
	}
591
	return err;
L
Linus Torvalds 已提交
592 593
}

594 595 596 597 598
/*
 * Retrieve the list of registered multicast addresses for the bonding
 * device and retransmit an IGMP JOIN request to the current active
 * slave.
 */
599
static void bond_resend_igmp_join_requests_delayed(struct work_struct *work)
600
{
601 602 603
	struct bonding *bond = container_of(work, struct bonding,
					    mcast_work.work);

604
	if (!rtnl_trylock()) {
605
		queue_delayed_work(bond->wq, &bond->mcast_work, 1);
606
		return;
607
	}
608
	call_netdevice_notifiers(NETDEV_RESEND_IGMP, bond->dev);
609

610 611
	if (bond->igmp_retrans > 1) {
		bond->igmp_retrans--;
612
		queue_delayed_work(bond->wq, &bond->mcast_work, HZ/5);
613
	}
614
	rtnl_unlock();
615 616
}

617
/* Flush bond's hardware addresses from slave
L
Linus Torvalds 已提交
618
 */
619
static void bond_hw_addr_flush(struct net_device *bond_dev,
S
Stephen Hemminger 已提交
620
			       struct net_device *slave_dev)
L
Linus Torvalds 已提交
621
{
622
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
623

624 625
	dev_uc_unsync(slave_dev, bond_dev);
	dev_mc_unsync(slave_dev, bond_dev);
L
Linus Torvalds 已提交
626 627 628 629 630

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

631
		dev_mc_del(slave_dev, lacpdu_multicast);
L
Linus Torvalds 已提交
632 633 634 635 636
	}
}

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

637 638 639 640
/* 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 已提交
641
 */
642 643
static void bond_hw_addr_swap(struct bonding *bond, struct slave *new_active,
			      struct slave *old_active)
L
Linus Torvalds 已提交
644
{
645 646
	ASSERT_RTNL();

L
Linus Torvalds 已提交
647
	if (old_active) {
S
Stephen Hemminger 已提交
648
		if (bond->dev->flags & IFF_PROMISC)
L
Linus Torvalds 已提交
649 650
			dev_set_promiscuity(old_active->dev, -1);

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

654
		bond_hw_addr_flush(bond->dev, old_active->dev);
L
Linus Torvalds 已提交
655 656 657
	}

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

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

665
		netif_addr_lock_bh(bond->dev);
666 667
		dev_uc_sync(new_active->dev, bond->dev);
		dev_mc_sync(new_active->dev, bond->dev);
668
		netif_addr_unlock_bh(bond->dev);
L
Linus Torvalds 已提交
669 670 671
	}
}

672 673 674 675 676 677 678 679 680 681
/**
 * 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)
{
682 683
	pr_debug("bond_dev=%p slave_dev=%p slave_dev->addr_len=%d\n",
		 bond_dev, slave_dev, slave_dev->addr_len);
684 685 686 687 688
	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);
}

689 690 691 692 693
/*
 * bond_do_fail_over_mac
 *
 * Perform special MAC address swapping for fail_over_mac settings
 *
694
 * Called with RTNL, curr_slave_lock for write_bh.
695 696 697 698
 */
static void bond_do_fail_over_mac(struct bonding *bond,
				  struct slave *new_active,
				  struct slave *old_active)
699 700
	__releases(&bond->curr_slave_lock)
	__acquires(&bond->curr_slave_lock)
701 702 703 704 705 706 707
{
	u8 tmp_mac[ETH_ALEN];
	struct sockaddr saddr;
	int rv;

	switch (bond->params.fail_over_mac) {
	case BOND_FOM_ACTIVE:
708 709
		if (new_active) {
			write_unlock_bh(&bond->curr_slave_lock);
710
			bond_set_dev_addr(bond->dev, new_active->dev);
711 712
			write_lock_bh(&bond->curr_slave_lock);
		}
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
		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) {
			memcpy(tmp_mac, new_active->dev->dev_addr, ETH_ALEN);
			memcpy(saddr.sa_data, old_active->dev->dev_addr,
			       ETH_ALEN);
			saddr.sa_family = new_active->dev->type;
		} else {
			memcpy(saddr.sa_data, bond->dev->dev_addr, ETH_ALEN);
			saddr.sa_family = bond->dev->type;
		}

		rv = dev_set_mac_address(new_active->dev, &saddr);
		if (rv) {
J
Joe Perches 已提交
737
			pr_err("%s: Error %d setting MAC of slave %s\n",
738 739 740 741 742 743 744 745 746 747 748 749
			       bond->dev->name, -rv, new_active->dev->name);
			goto out;
		}

		if (!old_active)
			goto out;

		memcpy(saddr.sa_data, tmp_mac, ETH_ALEN);
		saddr.sa_family = old_active->dev->type;

		rv = dev_set_mac_address(old_active->dev, &saddr);
		if (rv)
J
Joe Perches 已提交
750
			pr_err("%s: Error %d setting MAC of slave %s\n",
751 752 753 754 755
			       bond->dev->name, -rv, new_active->dev->name);
out:
		write_lock_bh(&bond->curr_slave_lock);
		break;
	default:
J
Joe Perches 已提交
756
		pr_err("%s: bond_do_fail_over_mac impossible: bad policy %d\n",
757 758 759 760 761 762
		       bond->dev->name, bond->params.fail_over_mac);
		break;
	}

}

763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
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;
}
782

L
Linus Torvalds 已提交
783 784 785 786 787 788
/**
 * 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)
{
789 790
	struct slave *slave, *bestslave = NULL;
	struct list_head *iter;
L
Linus Torvalds 已提交
791 792
	int mintime = bond->params.updelay;

793 794 795
	if (bond->primary_slave && bond->primary_slave->link == BOND_LINK_UP &&
	    bond_should_change_active(bond))
		return bond->primary_slave;
L
Linus Torvalds 已提交
796

797 798 799 800 801 802 803
	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 已提交
804 805 806 807 808 809
		}
	}

	return bestslave;
}

810 811
static bool bond_should_notify_peers(struct bonding *bond)
{
812 813 814 815 816
	struct slave *slave;

	rcu_read_lock();
	slave = rcu_dereference(bond->curr_active_slave);
	rcu_read_unlock();
817 818 819 820 821 822 823 824 825 826 827

	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 已提交
828 829 830 831 832 833 834 835 836 837 838 839 840
/**
 * 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.
 *
841
 * If new_active is not NULL, caller must hold curr_slave_lock for write_bh.
L
Linus Torvalds 已提交
842
 */
843
void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
L
Linus Torvalds 已提交
844 845 846
{
	struct slave *old_active = bond->curr_active_slave;

S
Stephen Hemminger 已提交
847
	if (old_active == new_active)
L
Linus Torvalds 已提交
848 849 850
		return;

	if (new_active) {
851 852
		new_active->jiffies = jiffies;

L
Linus Torvalds 已提交
853 854
		if (new_active->link == BOND_LINK_BACK) {
			if (USES_PRIMARY(bond->params.mode)) {
J
Joe Perches 已提交
855 856 857
				pr_info("%s: making interface %s the new active one %d ms earlier.\n",
					bond->dev->name, new_active->dev->name,
					(bond->params.updelay - new_active->delay) * bond->params.miimon);
L
Linus Torvalds 已提交
858 859 860 861 862
			}

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

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

866
			if (bond_is_lb(bond))
L
Linus Torvalds 已提交
867 868 869
				bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
		} else {
			if (USES_PRIMARY(bond->params.mode)) {
J
Joe Perches 已提交
870 871
				pr_info("%s: making interface %s the new active one.\n",
					bond->dev->name, new_active->dev->name);
L
Linus Torvalds 已提交
872 873 874 875
			}
		}
	}

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

879
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
880
		bond_alb_handle_active_change(bond, new_active);
881 882 883 884
		if (old_active)
			bond_set_slave_inactive_flags(old_active);
		if (new_active)
			bond_set_slave_active_flags(new_active);
L
Linus Torvalds 已提交
885
	} else {
886
		rcu_assign_pointer(bond->curr_active_slave, new_active);
L
Linus Torvalds 已提交
887
	}
J
Jay Vosburgh 已提交
888 889

	if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
S
Stephen Hemminger 已提交
890
		if (old_active)
J
Jay Vosburgh 已提交
891 892 893
			bond_set_slave_inactive_flags(old_active);

		if (new_active) {
894 895
			bool should_notify_peers = false;

J
Jay Vosburgh 已提交
896
			bond_set_slave_active_flags(new_active);
897

898 899 900
			if (bond->params.fail_over_mac)
				bond_do_fail_over_mac(bond, new_active,
						      old_active);
901

902 903 904 905 906 907 908
			if (netif_running(bond->dev)) {
				bond->send_peer_notif =
					bond->params.num_peer_notif;
				should_notify_peers =
					bond_should_notify_peers(bond);
			}

909 910
			write_unlock_bh(&bond->curr_slave_lock);

911
			call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, bond->dev);
912
			if (should_notify_peers)
913 914
				call_netdevice_notifiers(NETDEV_NOTIFY_PEERS,
							 bond->dev);
915 916

			write_lock_bh(&bond->curr_slave_lock);
917
		}
J
Jay Vosburgh 已提交
918
	}
919

920
	/* resend IGMP joins since active slave has changed or
921 922 923 924 925 926
	 * 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)) {
927
		bond->igmp_retrans = bond->params.resend_igmp;
928
		queue_delayed_work(bond->wq, &bond->mcast_work, 1);
929
	}
L
Linus Torvalds 已提交
930 931 932 933 934 935
}

/**
 * bond_select_active_slave - select a new active slave, if needed
 * @bond: our bonding struct
 *
S
Stephen Hemminger 已提交
936
 * This functions should be called when one of the following occurs:
L
Linus Torvalds 已提交
937 938 939 940
 * - 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.
 *
941
 * Caller must hold curr_slave_lock for write_bh.
L
Linus Torvalds 已提交
942
 */
943
void bond_select_active_slave(struct bonding *bond)
L
Linus Torvalds 已提交
944 945
{
	struct slave *best_slave;
946
	int rv;
L
Linus Torvalds 已提交
947 948 949 950

	best_slave = bond_find_best_slave(bond);
	if (best_slave != bond->curr_active_slave) {
		bond_change_active_slave(bond, best_slave);
951 952 953 954 955
		rv = bond_set_carrier(bond);
		if (!rv)
			return;

		if (netif_carrier_ok(bond->dev)) {
J
Joe Perches 已提交
956 957
			pr_info("%s: first active interface up!\n",
				bond->dev->name);
958
		} else {
J
Joe Perches 已提交
959 960
			pr_info("%s: now running without any active interface !\n",
				bond->dev->name);
961
		}
L
Linus Torvalds 已提交
962 963 964
	}
}

965
#ifdef CONFIG_NET_POLL_CONTROLLER
966
static inline int slave_enable_netpoll(struct slave *slave)
967
{
968 969
	struct netpoll *np;
	int err = 0;
970

971
	np = kzalloc(sizeof(*np), GFP_ATOMIC);
972 973 974 975
	err = -ENOMEM;
	if (!np)
		goto out;

976
	err = __netpoll_setup(np, slave->dev, GFP_ATOMIC);
977 978 979
	if (err) {
		kfree(np);
		goto out;
980
	}
981 982 983 984 985 986 987 988 989 990 991 992
	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;
993
	__netpoll_free_async(np);
994 995 996 997 998 999 1000 1001
}
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;
1002 1003 1004 1005
}

static void bond_poll_controller(struct net_device *bond_dev)
{
1006 1007
}

1008
static void bond_netpoll_cleanup(struct net_device *bond_dev)
1009
{
1010
	struct bonding *bond = netdev_priv(bond_dev);
1011
	struct list_head *iter;
1012 1013
	struct slave *slave;

1014
	bond_for_each_slave(bond, slave, iter)
1015 1016
		if (IS_UP(slave->dev))
			slave_disable_netpoll(slave);
1017
}
1018

1019
static int bond_netpoll_setup(struct net_device *dev, struct netpoll_info *ni, gfp_t gfp)
1020 1021
{
	struct bonding *bond = netdev_priv(dev);
1022
	struct list_head *iter;
1023
	struct slave *slave;
1024
	int err = 0;
1025

1026
	bond_for_each_slave(bond, slave, iter) {
1027 1028
		err = slave_enable_netpoll(slave);
		if (err) {
1029
			bond_netpoll_cleanup(dev);
1030
			break;
1031 1032
		}
	}
1033
	return err;
1034
}
1035 1036 1037 1038 1039 1040 1041 1042
#else
static inline int slave_enable_netpoll(struct slave *slave)
{
	return 0;
}
static inline void slave_disable_netpoll(struct slave *slave)
{
}
1043 1044 1045 1046 1047
static void bond_netpoll_cleanup(struct net_device *bond_dev)
{
}
#endif

L
Linus Torvalds 已提交
1048 1049
/*---------------------------------- IOCTL ----------------------------------*/

1050
static netdev_features_t bond_fix_features(struct net_device *dev,
1051
					   netdev_features_t features)
1052
{
1053
	struct bonding *bond = netdev_priv(dev);
1054
	struct list_head *iter;
1055
	netdev_features_t mask;
1056
	struct slave *slave;
1057

1058
	if (!bond_has_slaves(bond)) {
1059 1060
		/* Disable adding VLANs to empty bond. But why? --mq */
		features |= NETIF_F_VLAN_CHALLENGED;
1061
		return features;
1062
	}
1063

1064
	mask = features;
1065
	features &= ~NETIF_F_ONE_FOR_ALL;
1066
	features |= NETIF_F_ALL_FOR_ALL;
1067

1068
	bond_for_each_slave(bond, slave, iter) {
1069 1070
		features = netdev_increment_features(features,
						     slave->dev->features,
1071 1072
						     mask);
	}
1073
	features = netdev_add_tso_features(features, mask);
1074 1075 1076 1077

	return features;
}

1078 1079 1080
#define BOND_VLAN_FEATURES	(NETIF_F_ALL_CSUM | NETIF_F_SG | \
				 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
				 NETIF_F_HIGHDMA | NETIF_F_LRO)
1081 1082 1083

static void bond_compute_features(struct bonding *bond)
{
1084
	unsigned int flags, dst_release_flag = IFF_XMIT_DST_RELEASE;
1085
	netdev_features_t vlan_features = BOND_VLAN_FEATURES;
1086 1087 1088
	struct net_device *bond_dev = bond->dev;
	struct list_head *iter;
	struct slave *slave;
1089
	unsigned short max_hard_header_len = ETH_HLEN;
1090 1091
	unsigned int gso_max_size = GSO_MAX_SIZE;
	u16 gso_max_segs = GSO_MAX_SEGS;
1092

1093
	if (!bond_has_slaves(bond))
1094 1095
		goto done;

1096
	bond_for_each_slave(bond, slave, iter) {
1097
		vlan_features = netdev_increment_features(vlan_features,
1098 1099
			slave->dev->vlan_features, BOND_VLAN_FEATURES);

1100
		dst_release_flag &= slave->dev->priv_flags;
1101 1102
		if (slave->dev->hard_header_len > max_hard_header_len)
			max_hard_header_len = slave->dev->hard_header_len;
1103 1104 1105

		gso_max_size = min(gso_max_size, slave->dev->gso_max_size);
		gso_max_segs = min(gso_max_segs, slave->dev->gso_max_segs);
1106
	}
1107

1108
done:
1109
	bond_dev->vlan_features = vlan_features;
1110
	bond_dev->hard_header_len = max_hard_header_len;
1111 1112
	bond_dev->gso_max_segs = gso_max_segs;
	netif_set_gso_max_size(bond_dev, gso_max_size);
1113

1114 1115 1116
	flags = bond_dev->priv_flags & ~IFF_XMIT_DST_RELEASE;
	bond_dev->priv_flags = flags | dst_release_flag;

1117
	netdev_change_features(bond_dev);
1118 1119
}

1120 1121 1122
static void bond_setup_by_slave(struct net_device *bond_dev,
				struct net_device *slave_dev)
{
1123
	bond_dev->header_ops	    = slave_dev->header_ops;
1124 1125 1126 1127 1128 1129 1130 1131 1132

	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);
}

1133
/* On bonding slaves other than the currently active slave, suppress
1134
 * duplicates except for alb non-mcast/bcast.
1135 1136
 */
static bool bond_should_deliver_exact_match(struct sk_buff *skb,
1137 1138
					    struct slave *slave,
					    struct bonding *bond)
1139
{
1140
	if (bond_is_slave_inactive(slave)) {
1141
		if (bond->params.mode == BOND_MODE_ALB &&
1142 1143 1144 1145 1146 1147 1148 1149
		    skb->pkt_type != PACKET_BROADCAST &&
		    skb->pkt_type != PACKET_MULTICAST)
			return false;
		return true;
	}
	return false;
}

1150
static rx_handler_result_t bond_handle_frame(struct sk_buff **pskb)
1151
{
1152
	struct sk_buff *skb = *pskb;
1153
	struct slave *slave;
1154
	struct bonding *bond;
1155 1156
	int (*recv_probe)(const struct sk_buff *, struct bonding *,
			  struct slave *);
1157
	int ret = RX_HANDLER_ANOTHER;
1158

1159 1160 1161 1162 1163
	skb = skb_share_check(skb, GFP_ATOMIC);
	if (unlikely(!skb))
		return RX_HANDLER_CONSUMED;

	*pskb = skb;
1164

J
Jiri Pirko 已提交
1165 1166
	slave = bond_slave_get_rcu(skb->dev);
	bond = slave->bond;
1167 1168

	if (bond->params.arp_interval)
1169
		slave->dev->last_rx = jiffies;
1170

1171 1172
	recv_probe = ACCESS_ONCE(bond->recv_probe);
	if (recv_probe) {
1173 1174 1175 1176
		ret = recv_probe(skb, bond, slave);
		if (ret == RX_HANDLER_CONSUMED) {
			consume_skb(skb);
			return ret;
1177 1178 1179
		}
	}

1180
	if (bond_should_deliver_exact_match(skb, slave, bond)) {
1181
		return RX_HANDLER_EXACT;
1182 1183
	}

J
Jiri Pirko 已提交
1184
	skb->dev = bond->dev;
1185

1186
	if (bond->params.mode == BOND_MODE_ALB &&
J
Jiri Pirko 已提交
1187
	    bond->dev->priv_flags & IFF_BRIDGE_PORT &&
1188 1189
	    skb->pkt_type == PACKET_HOST) {

1190 1191 1192
		if (unlikely(skb_cow_head(skb,
					  skb->data - skb_mac_header(skb)))) {
			kfree_skb(skb);
1193
			return RX_HANDLER_CONSUMED;
1194
		}
J
Jiri Pirko 已提交
1195
		memcpy(eth_hdr(skb)->h_dest, bond->dev->dev_addr, ETH_ALEN);
1196 1197
	}

1198
	return ret;
1199 1200
}

1201
static int bond_master_upper_dev_link(struct net_device *bond_dev,
1202 1203
				      struct net_device *slave_dev,
				      struct slave *slave)
1204 1205 1206
{
	int err;

1207
	err = netdev_master_upper_dev_link_private(slave_dev, bond_dev, slave);
1208 1209 1210
	if (err)
		return err;
	slave_dev->flags |= IFF_SLAVE;
1211
	rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE, GFP_KERNEL);
1212 1213 1214 1215 1216 1217 1218 1219
	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;
1220
	rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE, GFP_KERNEL);
1221 1222
}

L
Linus Torvalds 已提交
1223
/* enslave device <slave> to bond device <master> */
1224
int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
L
Linus Torvalds 已提交
1225
{
1226
	struct bonding *bond = netdev_priv(bond_dev);
1227
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
1228
	struct slave *new_slave = NULL, *prev_slave;
L
Linus Torvalds 已提交
1229 1230
	struct sockaddr addr;
	int link_reporting;
1231
	int res = 0, i;
L
Linus Torvalds 已提交
1232

1233 1234 1235
	if (!bond->params.use_carrier &&
	    slave_dev->ethtool_ops->get_link == NULL &&
	    slave_ops->ndo_do_ioctl == NULL) {
J
Joe Perches 已提交
1236 1237
		pr_warning("%s: Warning: no link monitoring support for %s\n",
			   bond_dev->name, slave_dev->name);
L
Linus Torvalds 已提交
1238 1239 1240 1241
	}

	/* already enslaved */
	if (slave_dev->flags & IFF_SLAVE) {
1242
		pr_debug("Error, Device was already enslaved\n");
L
Linus Torvalds 已提交
1243 1244 1245 1246 1247 1248
		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) {
1249
		pr_debug("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
1250
		if (vlan_uses_dev(bond_dev)) {
J
Joe Perches 已提交
1251 1252
			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 已提交
1253 1254
			return -EPERM;
		} else {
J
Joe Perches 已提交
1255 1256 1257
			pr_warning("%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 已提交
1258 1259
		}
	} else {
1260
		pr_debug("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
L
Linus Torvalds 已提交
1261 1262
	}

1263 1264
	/*
	 * Old ifenslave binaries are no longer supported.  These can
S
Stephen Hemminger 已提交
1265
	 * be identified with moderate accuracy by the state of the slave:
1266 1267 1268 1269
	 * 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 已提交
1270
		pr_err("%s is up. This may be due to an out of date ifenslave.\n",
1271 1272 1273 1274
		       slave_dev->name);
		res = -EPERM;
		goto err_undo_flags;
	}
L
Linus Torvalds 已提交
1275

1276 1277 1278 1279 1280 1281 1282
	/* 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
	 */
1283
	if (!bond_has_slaves(bond)) {
1284 1285
		if (bond_dev->type != slave_dev->type) {
			pr_debug("%s: change device type from %d to %d\n",
J
Joe Perches 已提交
1286 1287
				 bond_dev->name,
				 bond_dev->type, slave_dev->type);
1288

1289 1290
			res = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE,
						       bond_dev);
1291 1292 1293 1294 1295 1296 1297
			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;
			}
1298

1299
			/* Flush unicast and multicast addresses */
1300
			dev_uc_flush(bond_dev);
1301
			dev_mc_flush(bond_dev);
1302

1303 1304
			if (slave_dev->type != ARPHRD_ETHER)
				bond_setup_by_slave(bond_dev, slave_dev);
1305
			else {
1306
				ether_setup(bond_dev);
1307 1308
				bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING;
			}
1309

1310 1311
			call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE,
						 bond_dev);
1312
		}
1313
	} else if (bond_dev->type != slave_dev->type) {
J
Joe Perches 已提交
1314 1315 1316 1317 1318
		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);
		res = -EINVAL;
		goto err_undo_flags;
1319 1320
	}

1321
	if (slave_ops->ndo_set_mac_address == NULL) {
1322
		if (!bond_has_slaves(bond)) {
J
Joe Perches 已提交
1323 1324
			pr_warning("%s: Warning: The first slave device specified does not support setting the MAC address. Setting fail_over_mac to active.",
				   bond_dev->name);
1325 1326
			bond->params.fail_over_mac = BOND_FOM_ACTIVE;
		} else if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
J
Joe Perches 已提交
1327 1328
			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",
			       bond_dev->name);
1329 1330 1331
			res = -EOPNOTSUPP;
			goto err_undo_flags;
		}
L
Linus Torvalds 已提交
1332 1333
	}

1334 1335
	call_netdevice_notifiers(NETDEV_JOIN, slave_dev);

1336 1337
	/* If this is the first slave, then we need to set the master's hardware
	 * address to be the same as the slave's. */
1338
	if (!bond_has_slaves(bond) &&
1339
	    bond->dev->addr_assign_type == NET_ADDR_RANDOM)
1340
		bond_set_dev_addr(bond->dev, slave_dev);
1341

1342
	new_slave = kzalloc(sizeof(struct slave), GFP_KERNEL);
L
Linus Torvalds 已提交
1343 1344 1345 1346
	if (!new_slave) {
		res = -ENOMEM;
		goto err_undo_flags;
	}
1347 1348 1349 1350 1351 1352
	/*
	 * 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;

1353 1354 1355 1356 1357 1358 1359 1360
	/* 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;
	}

1361 1362 1363 1364 1365 1366
	/*
	 * 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
	 */
	memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN);
L
Linus Torvalds 已提交
1367

1368
	if (!bond->params.fail_over_mac) {
1369 1370 1371 1372 1373 1374 1375 1376
		/*
		 * 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) {
1377
			pr_debug("Error %d calling set_mac_address\n", res);
1378
			goto err_restore_mtu;
1379
		}
1380
	}
L
Linus Torvalds 已提交
1381

1382 1383 1384
	/* open the slave since the application closed it */
	res = dev_open(slave_dev);
	if (res) {
S
Stephen Hemminger 已提交
1385
		pr_debug("Opening slave %s failed\n", slave_dev->name);
1386
		goto err_restore_mac;
L
Linus Torvalds 已提交
1387 1388
	}

J
Jiri Pirko 已提交
1389
	new_slave->bond = bond;
L
Linus Torvalds 已提交
1390
	new_slave->dev = slave_dev;
1391
	slave_dev->priv_flags |= IFF_BONDING;
L
Linus Torvalds 已提交
1392

1393
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
1394 1395 1396 1397
		/* 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 已提交
1398
		if (res)
1399
			goto err_close;
L
Linus Torvalds 已提交
1400 1401
	}

1402 1403
	/* If the mode USES_PRIMARY, then the following is handled by
	 * bond_change_active_slave().
L
Linus Torvalds 已提交
1404 1405 1406 1407
	 */
	if (!USES_PRIMARY(bond->params.mode)) {
		/* set promiscuity level to new slave */
		if (bond_dev->flags & IFF_PROMISC) {
1408 1409 1410
			res = dev_set_promiscuity(slave_dev, 1);
			if (res)
				goto err_close;
L
Linus Torvalds 已提交
1411 1412 1413 1414
		}

		/* set allmulti level to new slave */
		if (bond_dev->flags & IFF_ALLMULTI) {
1415 1416 1417
			res = dev_set_allmulti(slave_dev, 1);
			if (res)
				goto err_close;
L
Linus Torvalds 已提交
1418 1419
		}

1420
		netif_addr_lock_bh(bond_dev);
1421 1422 1423 1424

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

1425
		netif_addr_unlock_bh(bond_dev);
L
Linus Torvalds 已提交
1426 1427 1428 1429 1430 1431
	}

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

1432
		dev_mc_add(slave_dev, lacpdu_multicast);
L
Linus Torvalds 已提交
1433 1434
	}

1435 1436
	res = vlan_vids_add_by_dev(slave_dev, bond_dev);
	if (res) {
1437 1438 1439 1440
		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 已提交
1441

1442
	prev_slave = bond_last_slave(bond);
L
Linus Torvalds 已提交
1443 1444 1445 1446

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

1447 1448
	bond_update_speed_duplex(new_slave);

1449 1450
	new_slave->last_arp_rx = jiffies -
		(msecs_to_jiffies(bond->params.arp_interval) + 1);
1451 1452
	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
		new_slave->target_last_arp_rx[i] = new_slave->last_arp_rx;
1453

L
Linus Torvalds 已提交
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
	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.
			 */
J
Joe Perches 已提交
1467
			pr_warning("%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",
1468
			       bond_dev->name, slave_dev->name);
L
Linus Torvalds 已提交
1469 1470
		} else if (link_reporting == -1) {
			/* unable get link status using mii/ethtool */
J
Joe Perches 已提交
1471 1472
			pr_warning("%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 已提交
1473 1474 1475 1476
		}
	}

	/* check for initial state */
1477 1478 1479 1480 1481 1482 1483 1484
	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 已提交
1485
		} else {
1486
			new_slave->link = BOND_LINK_DOWN;
L
Linus Torvalds 已提交
1487
		}
1488 1489 1490
	} else if (bond->params.arp_interval) {
		new_slave->link = (netif_carrier_ok(slave_dev) ?
			BOND_LINK_UP : BOND_LINK_DOWN);
L
Linus Torvalds 已提交
1491
	} else {
1492
		new_slave->link = BOND_LINK_UP;
L
Linus Torvalds 已提交
1493 1494
	}

1495 1496 1497 1498 1499 1500
	if (new_slave->link != BOND_LINK_DOWN)
		new_slave->jiffies = jiffies;
	pr_debug("Initial state of slave_dev is BOND_LINK_%s\n",
		new_slave->link == BOND_LINK_DOWN ? "DOWN" :
			(new_slave->link == BOND_LINK_UP ? "UP" : "BACK"));

L
Linus Torvalds 已提交
1501 1502
	if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
		/* if there is a primary slave, remember it */
1503
		if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
L
Linus Torvalds 已提交
1504
			bond->primary_slave = new_slave;
1505 1506
			bond->force_primary = true;
		}
L
Linus Torvalds 已提交
1507 1508 1509 1510
	}

	switch (bond->params.mode) {
	case BOND_MODE_ACTIVEBACKUP:
1511
		bond_set_slave_inactive_flags(new_slave);
L
Linus Torvalds 已提交
1512 1513 1514 1515 1516 1517 1518 1519
		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 */
1520
		if (!prev_slave) {
L
Linus Torvalds 已提交
1521 1522 1523 1524
			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
			 */
1525
			bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL);
L
Linus Torvalds 已提交
1526 1527
		} else {
			SLAVE_AD_INFO(new_slave).id =
1528
				SLAVE_AD_INFO(prev_slave).id + 1;
L
Linus Torvalds 已提交
1529 1530 1531 1532 1533 1534
		}

		bond_3ad_bind_slave(new_slave);
		break;
	case BOND_MODE_TLB:
	case BOND_MODE_ALB:
J
Jiri Pirko 已提交
1535
		bond_set_active_slave(new_slave);
1536
		bond_set_slave_inactive_flags(new_slave);
L
Linus Torvalds 已提交
1537 1538
		break;
	default:
1539
		pr_debug("This slave is always active in trunk mode\n");
L
Linus Torvalds 已提交
1540 1541

		/* always active in trunk mode */
J
Jiri Pirko 已提交
1542
		bond_set_active_slave(new_slave);
L
Linus Torvalds 已提交
1543 1544 1545 1546 1547

		/* 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()
		 */
1548
		if (!bond->curr_active_slave && new_slave->link == BOND_LINK_UP)
1549
			rcu_assign_pointer(bond->curr_active_slave, new_slave);
S
Stephen Hemminger 已提交
1550

L
Linus Torvalds 已提交
1551 1552 1553
		break;
	} /* switch(bond_mode) */

1554
#ifdef CONFIG_NET_POLL_CONTROLLER
S
stephen hemminger 已提交
1555
	slave_dev->npinfo = bond->dev->npinfo;
1556 1557 1558 1559 1560 1561 1562
	if (slave_dev->npinfo) {
		if (slave_enable_netpoll(new_slave)) {
			read_unlock(&bond->lock);
			pr_info("Error, %s: master_dev is using netpoll, "
				 "but new slave device does not support netpoll.\n",
				 bond_dev->name);
			res = -EBUSY;
1563
			goto err_detach;
1564
		}
1565 1566
	}
#endif
1567

J
Jiri Pirko 已提交
1568 1569 1570 1571
	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);
1572
		goto err_detach;
J
Jiri Pirko 已提交
1573 1574
	}

1575 1576 1577 1578 1579 1580
	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;
	}

1581 1582 1583 1584 1585 1586 1587 1588 1589
	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);
	}
1590

J
Joe Perches 已提交
1591 1592
	pr_info("%s: enslaving %s as a%s interface with a%s link.\n",
		bond_dev->name, slave_dev->name,
J
Jiri Pirko 已提交
1593
		bond_is_active_slave(new_slave) ? "n active" : " backup",
J
Joe Perches 已提交
1594
		new_slave->link != BOND_LINK_DOWN ? "n up" : " down");
L
Linus Torvalds 已提交
1595 1596 1597 1598 1599

	/* enslave is successful */
	return 0;

/* Undo stages on error */
1600 1601 1602
err_unregister:
	netdev_rx_handler_unregister(slave_dev);

1603
err_detach:
1604 1605 1606
	if (!USES_PRIMARY(bond->params.mode))
		bond_hw_addr_flush(bond_dev, slave_dev);

1607
	vlan_vids_del_by_dev(slave_dev, bond_dev);
1608 1609 1610 1611
	if (bond->primary_slave == new_slave)
		bond->primary_slave = NULL;
	if (bond->curr_active_slave == new_slave) {
		write_lock_bh(&bond->curr_slave_lock);
1612
		bond_change_active_slave(bond, NULL);
1613 1614 1615
		bond_select_active_slave(bond);
		write_unlock_bh(&bond->curr_slave_lock);
	}
1616
	slave_disable_netpoll(new_slave);
1617

L
Linus Torvalds 已提交
1618
err_close:
1619
	slave_dev->priv_flags &= ~IFF_BONDING;
L
Linus Torvalds 已提交
1620 1621 1622
	dev_close(slave_dev);

err_restore_mac:
1623
	if (!bond->params.fail_over_mac) {
1624 1625 1626 1627
		/* 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.
		 */
1628 1629 1630 1631
		memcpy(addr.sa_data, new_slave->perm_hwaddr, ETH_ALEN);
		addr.sa_family = slave_dev->type;
		dev_set_mac_address(slave_dev, &addr);
	}
L
Linus Torvalds 已提交
1632

1633 1634 1635
err_restore_mtu:
	dev_set_mtu(slave_dev, new_slave->original_mtu);

L
Linus Torvalds 已提交
1636 1637 1638 1639
err_free:
	kfree(new_slave);

err_undo_flags:
1640
	/* Enslave of first slave has failed and we need to fix master's mac */
1641
	if (!bond_has_slaves(bond) &&
1642 1643
	    ether_addr_equal(bond_dev->dev_addr, slave_dev->dev_addr))
		eth_hw_addr_random(bond_dev);
S
Stephen Hemminger 已提交
1644

L
Linus Torvalds 已提交
1645 1646 1647 1648 1649 1650
	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
1651 1652
 * 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 已提交
1653 1654 1655 1656 1657 1658 1659
 *
 * 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.
 */
1660 1661 1662
static int __bond_release_one(struct net_device *bond_dev,
			      struct net_device *slave_dev,
			      bool all)
L
Linus Torvalds 已提交
1663
{
1664
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
1665 1666
	struct slave *slave, *oldcurrent;
	struct sockaddr addr;
1667
	int old_flags = bond_dev->flags;
1668
	netdev_features_t old_features = bond_dev->features;
L
Linus Torvalds 已提交
1669 1670 1671

	/* slave is not a slave or master is not master of this slave */
	if (!(slave_dev->flags & IFF_SLAVE) ||
1672
	    !netdev_has_upper_dev(slave_dev, bond_dev)) {
J
Joe Perches 已提交
1673
		pr_err("%s: Error: cannot release %s.\n",
L
Linus Torvalds 已提交
1674 1675 1676 1677
		       bond_dev->name, slave_dev->name);
		return -EINVAL;
	}

1678
	block_netpoll_tx();
L
Linus Torvalds 已提交
1679 1680 1681 1682

	slave = bond_get_slave_by_dev(bond, slave_dev);
	if (!slave) {
		/* not a slave of this bond */
J
Joe Perches 已提交
1683 1684
		pr_info("%s: %s not enslaved\n",
			bond_dev->name, slave_dev->name);
1685
		unblock_netpoll_tx();
L
Linus Torvalds 已提交
1686 1687 1688
		return -EINVAL;
	}

1689 1690 1691
	/* release the slave from its bond */
	bond->slave_cnt--;

1692
	bond_upper_dev_unlink(bond_dev, slave_dev);
J
Jiri Pirko 已提交
1693 1694 1695 1696 1697 1698
	/* 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 已提交
1699
	/* Inform AD package of unbinding of slave. */
1700
	if (bond->params.mode == BOND_MODE_8023AD)
L
Linus Torvalds 已提交
1701
		bond_3ad_unbind_slave(slave);
1702

1703
	write_unlock_bh(&bond->lock);
L
Linus Torvalds 已提交
1704

J
Joe Perches 已提交
1705 1706
	pr_info("%s: releasing %s interface %s\n",
		bond_dev->name,
J
Jiri Pirko 已提交
1707
		bond_is_active_slave(slave) ? "active" : "backup",
J
Joe Perches 已提交
1708
		slave_dev->name);
L
Linus Torvalds 已提交
1709 1710 1711 1712 1713

	oldcurrent = bond->curr_active_slave;

	bond->current_arp_slave = NULL;

1714 1715
	if (!all && !bond->params.fail_over_mac) {
		if (ether_addr_equal(bond_dev->dev_addr, slave->perm_hwaddr) &&
1716
		    bond_has_slaves(bond))
1717 1718 1719 1720 1721 1722
			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);
	}

S
Stephen Hemminger 已提交
1723
	if (bond->primary_slave == slave)
L
Linus Torvalds 已提交
1724 1725
		bond->primary_slave = NULL;

1726 1727
	if (oldcurrent == slave) {
		write_lock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
1728
		bond_change_active_slave(bond, NULL);
1729 1730
		write_unlock_bh(&bond->curr_slave_lock);
	}
L
Linus Torvalds 已提交
1731

1732
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
1733 1734 1735 1736 1737 1738 1739 1740
		/* 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);
	}

1741
	if (all) {
1742
		rcu_assign_pointer(bond->curr_active_slave, NULL);
1743
	} else if (oldcurrent == slave) {
1744 1745 1746 1747 1748 1749 1750
		/*
		 * 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 已提交
1751 1752
		bond_select_active_slave(bond);

1753 1754 1755
		write_unlock_bh(&bond->curr_slave_lock);
	}

1756
	if (!bond_has_slaves(bond)) {
1757
		bond_set_carrier(bond);
1758
		eth_hw_addr_random(bond_dev);
L
Linus Torvalds 已提交
1759

1760
		if (vlan_uses_dev(bond_dev)) {
J
Joe Perches 已提交
1761 1762 1763 1764
			pr_warning("%s: Warning: clearing HW address of %s while it still has VLANs.\n",
				   bond_dev->name, bond_dev->name);
			pr_warning("%s: When re-adding slaves, make sure the bond's HW address matches its VLANs'.\n",
				   bond_dev->name);
L
Linus Torvalds 已提交
1765 1766 1767
		}
	}

1768
	unblock_netpoll_tx();
1769
	synchronize_rcu();
L
Linus Torvalds 已提交
1770

1771
	if (!bond_has_slaves(bond)) {
1772
		call_netdevice_notifiers(NETDEV_CHANGEADDR, bond->dev);
1773 1774
		call_netdevice_notifiers(NETDEV_RELEASE, bond->dev);
	}
1775

1776 1777 1778 1779 1780 1781
	bond_compute_features(bond);
	if (!(bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
	    (old_features & NETIF_F_VLAN_CHALLENGED))
		pr_info("%s: last VLAN challenged slave %s left bond %s. VLAN blocking is removed\n",
			bond_dev->name, slave_dev->name, bond_dev->name);

1782
	/* must do this from outside any spinlocks */
1783
	vlan_vids_del_by_dev(slave_dev, bond_dev);
L
Linus Torvalds 已提交
1784

1785 1786
	/* If the mode USES_PRIMARY, then this cases was handled above by
	 * bond_change_active_slave(..., NULL)
L
Linus Torvalds 已提交
1787 1788
	 */
	if (!USES_PRIMARY(bond->params.mode)) {
1789 1790 1791 1792 1793 1794 1795 1796
		/* 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 已提交
1797 1798 1799
			dev_set_promiscuity(slave_dev, -1);

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

1803
		bond_hw_addr_flush(bond_dev, slave_dev);
L
Linus Torvalds 已提交
1804 1805
	}

1806
	slave_disable_netpoll(slave);
1807

L
Linus Torvalds 已提交
1808 1809 1810
	/* close slave before restoring its mac address */
	dev_close(slave_dev);

1811
	if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
1812 1813 1814 1815 1816
		/* restore original ("permanent") mac address */
		memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
		addr.sa_family = slave_dev->type;
		dev_set_mac_address(slave_dev, &addr);
	}
L
Linus Torvalds 已提交
1817

1818 1819
	dev_set_mtu(slave_dev, slave->original_mtu);

1820
	slave_dev->priv_flags &= ~IFF_BONDING;
L
Linus Torvalds 已提交
1821 1822 1823 1824 1825 1826

	kfree(slave);

	return 0;  /* deletion OK */
}

1827 1828 1829 1830 1831 1832
/* 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);
}

1833
/*
1834
* First release a slave and then destroy the bond if no more slaves are left.
1835 1836
* Must be under rtnl_lock when this function is called.
*/
1837 1838
static int  bond_release_and_destroy(struct net_device *bond_dev,
				     struct net_device *slave_dev)
1839
{
1840
	struct bonding *bond = netdev_priv(bond_dev);
1841 1842 1843
	int ret;

	ret = bond_release(bond_dev, slave_dev);
1844
	if (ret == 0 && !bond_has_slaves(bond)) {
1845
		bond_dev->priv_flags |= IFF_DISABLE_NETPOLL;
J
Joe Perches 已提交
1846 1847
		pr_info("%s: destroying bond %s.\n",
			bond_dev->name, bond_dev->name);
S
Stephen Hemminger 已提交
1848
		unregister_netdevice(bond_dev);
1849 1850 1851 1852
	}
	return ret;
}

L
Linus Torvalds 已提交
1853 1854
static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
{
1855
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
1856 1857 1858 1859

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

1860
	read_lock(&bond->lock);
L
Linus Torvalds 已提交
1861
	info->num_slaves = bond->slave_cnt;
1862
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
1863 1864 1865 1866 1867 1868

	return 0;
}

static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info)
{
1869
	struct bonding *bond = netdev_priv(bond_dev);
1870
	struct list_head *iter;
1871
	int i = 0, res = -ENODEV;
L
Linus Torvalds 已提交
1872 1873
	struct slave *slave;

1874
	read_lock(&bond->lock);
1875
	bond_for_each_slave(bond, slave, iter) {
1876
		if (i++ == (int)info->slave_id) {
1877 1878 1879
			res = 0;
			strcpy(info->slave_name, slave->dev->name);
			info->link = slave->link;
J
Jiri Pirko 已提交
1880
			info->state = bond_slave_state(slave);
1881
			info->link_failure_count = slave->link_failure_count;
L
Linus Torvalds 已提交
1882 1883 1884
			break;
		}
	}
1885
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
1886

1887
	return res;
L
Linus Torvalds 已提交
1888 1889 1890 1891 1892
}

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


J
Jay Vosburgh 已提交
1893 1894
static int bond_miimon_inspect(struct bonding *bond)
{
1895
	int link_state, commit = 0;
1896
	struct list_head *iter;
J
Jay Vosburgh 已提交
1897
	struct slave *slave;
1898 1899 1900
	bool ignore_updelay;

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

1902
	bond_for_each_slave_rcu(bond, slave, iter) {
J
Jay Vosburgh 已提交
1903
		slave->new_link = BOND_LINK_NOCHANGE;
L
Linus Torvalds 已提交
1904

J
Jay Vosburgh 已提交
1905
		link_state = bond_check_dev_link(bond, slave->dev, 0);
L
Linus Torvalds 已提交
1906 1907

		switch (slave->link) {
J
Jay Vosburgh 已提交
1908 1909 1910
		case BOND_LINK_UP:
			if (link_state)
				continue;
L
Linus Torvalds 已提交
1911

J
Jay Vosburgh 已提交
1912 1913 1914
			slave->link = BOND_LINK_FAIL;
			slave->delay = bond->params.downdelay;
			if (slave->delay) {
J
Joe Perches 已提交
1915 1916 1917 1918
				pr_info("%s: link status down for %sinterface %s, disabling it in %d ms.\n",
					bond->dev->name,
					(bond->params.mode ==
					 BOND_MODE_ACTIVEBACKUP) ?
J
Jiri Pirko 已提交
1919
					(bond_is_active_slave(slave) ?
J
Joe Perches 已提交
1920 1921 1922
					 "active " : "backup ") : "",
					slave->dev->name,
					bond->params.downdelay * bond->params.miimon);
L
Linus Torvalds 已提交
1923
			}
J
Jay Vosburgh 已提交
1924 1925 1926 1927 1928 1929 1930
			/*FALLTHRU*/
		case BOND_LINK_FAIL:
			if (link_state) {
				/*
				 * recovered before downdelay expired
				 */
				slave->link = BOND_LINK_UP;
L
Linus Torvalds 已提交
1931
				slave->jiffies = jiffies;
J
Joe Perches 已提交
1932 1933 1934 1935 1936
				pr_info("%s: link status up again after %d ms for interface %s.\n",
					bond->dev->name,
					(bond->params.downdelay - slave->delay) *
					bond->params.miimon,
					slave->dev->name);
J
Jay Vosburgh 已提交
1937
				continue;
L
Linus Torvalds 已提交
1938
			}
J
Jay Vosburgh 已提交
1939 1940 1941 1942 1943

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

J
Jay Vosburgh 已提交
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
			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 已提交
1957 1958 1959 1960 1961
				pr_info("%s: link status up for interface %s, enabling it in %d ms.\n",
					bond->dev->name, slave->dev->name,
					ignore_updelay ? 0 :
					bond->params.updelay *
					bond->params.miimon);
J
Jay Vosburgh 已提交
1962 1963 1964 1965 1966
			}
			/*FALLTHRU*/
		case BOND_LINK_BACK:
			if (!link_state) {
				slave->link = BOND_LINK_DOWN;
J
Joe Perches 已提交
1967 1968 1969 1970 1971
				pr_info("%s: link status down again after %d ms for interface %s.\n",
					bond->dev->name,
					(bond->params.updelay - slave->delay) *
					bond->params.miimon,
					slave->dev->name);
J
Jay Vosburgh 已提交
1972 1973 1974 1975

				continue;
			}

1976 1977 1978
			if (ignore_updelay)
				slave->delay = 0;

J
Jay Vosburgh 已提交
1979 1980 1981
			if (slave->delay <= 0) {
				slave->new_link = BOND_LINK_UP;
				commit++;
1982
				ignore_updelay = false;
J
Jay Vosburgh 已提交
1983
				continue;
L
Linus Torvalds 已提交
1984
			}
J
Jay Vosburgh 已提交
1985 1986

			slave->delay--;
L
Linus Torvalds 已提交
1987
			break;
J
Jay Vosburgh 已提交
1988 1989
		}
	}
L
Linus Torvalds 已提交
1990

J
Jay Vosburgh 已提交
1991 1992
	return commit;
}
L
Linus Torvalds 已提交
1993

J
Jay Vosburgh 已提交
1994 1995
static void bond_miimon_commit(struct bonding *bond)
{
1996
	struct list_head *iter;
J
Jay Vosburgh 已提交
1997 1998
	struct slave *slave;

1999
	bond_for_each_slave(bond, slave, iter) {
J
Jay Vosburgh 已提交
2000 2001 2002
		switch (slave->new_link) {
		case BOND_LINK_NOCHANGE:
			continue;
L
Linus Torvalds 已提交
2003

J
Jay Vosburgh 已提交
2004 2005 2006 2007 2008 2009
		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 已提交
2010
				bond_set_backup_slave(slave);
J
Jay Vosburgh 已提交
2011 2012
			} else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
				/* make it immediately active */
J
Jiri Pirko 已提交
2013
				bond_set_active_slave(slave);
J
Jay Vosburgh 已提交
2014 2015
			} else if (slave != bond->primary_slave) {
				/* prevent it from being the active one */
J
Jiri Pirko 已提交
2016
				bond_set_backup_slave(slave);
L
Linus Torvalds 已提交
2017 2018
			}

2019
			pr_info("%s: link status definitely up for interface %s, %u Mbps %s duplex.\n",
2020
				bond->dev->name, slave->dev->name,
2021 2022
				slave->speed == SPEED_UNKNOWN ? 0 : slave->speed,
				slave->duplex ? "full" : "half");
L
Linus Torvalds 已提交
2023

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

2028
			if (bond_is_lb(bond))
J
Jay Vosburgh 已提交
2029 2030
				bond_alb_handle_link_change(bond, slave,
							    BOND_LINK_UP);
L
Linus Torvalds 已提交
2031

J
Jay Vosburgh 已提交
2032 2033 2034
			if (!bond->curr_active_slave ||
			    (slave == bond->primary_slave))
				goto do_failover;
L
Linus Torvalds 已提交
2035

J
Jay Vosburgh 已提交
2036
			continue;
2037

J
Jay Vosburgh 已提交
2038
		case BOND_LINK_DOWN:
J
Jay Vosburgh 已提交
2039 2040 2041
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;

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

J
Jay Vosburgh 已提交
2044 2045 2046 2047
			if (bond->params.mode == BOND_MODE_ACTIVEBACKUP ||
			    bond->params.mode == BOND_MODE_8023AD)
				bond_set_slave_inactive_flags(slave);

J
Joe Perches 已提交
2048 2049
			pr_info("%s: link status definitely down for interface %s, disabling it\n",
				bond->dev->name, slave->dev->name);
J
Jay Vosburgh 已提交
2050 2051 2052 2053 2054

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

2055
			if (bond_is_lb(bond))
J
Jay Vosburgh 已提交
2056 2057 2058 2059 2060 2061 2062 2063 2064
				bond_alb_handle_link_change(bond, slave,
							    BOND_LINK_DOWN);

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

			continue;

		default:
J
Joe Perches 已提交
2065
			pr_err("%s: invalid new link %d on slave %s\n",
J
Jay Vosburgh 已提交
2066 2067 2068 2069 2070 2071 2072 2073 2074
			       bond->dev->name, slave->new_link,
			       slave->dev->name);
			slave->new_link = BOND_LINK_NOCHANGE;

			continue;
		}

do_failover:
		ASSERT_RTNL();
2075
		block_netpoll_tx();
J
Jay Vosburgh 已提交
2076 2077 2078
		write_lock_bh(&bond->curr_slave_lock);
		bond_select_active_slave(bond);
		write_unlock_bh(&bond->curr_slave_lock);
2079
		unblock_netpoll_tx();
J
Jay Vosburgh 已提交
2080 2081 2082
	}

	bond_set_carrier(bond);
L
Linus Torvalds 已提交
2083 2084
}

2085 2086 2087 2088
/*
 * bond_mii_monitor
 *
 * Really a wrapper that splits the mii monitor into two phases: an
J
Jay Vosburgh 已提交
2089 2090 2091
 * 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.
2092 2093 2094 2095 2096
 */
void bond_mii_monitor(struct work_struct *work)
{
	struct bonding *bond = container_of(work, struct bonding,
					    mii_work.work);
2097
	bool should_notify_peers = false;
2098
	unsigned long delay;
2099

2100 2101 2102
	delay = msecs_to_jiffies(bond->params.miimon);

	if (!bond_has_slaves(bond))
J
Jay Vosburgh 已提交
2103
		goto re_arm;
2104

2105 2106
	rcu_read_lock();

2107 2108
	should_notify_peers = bond_should_notify_peers(bond);

2109
	if (bond_miimon_inspect(bond)) {
2110
		rcu_read_unlock();
J
Jay Vosburgh 已提交
2111

2112 2113 2114 2115 2116 2117
		/* Race avoidance with bond_close cancel of workqueue */
		if (!rtnl_trylock()) {
			delay = 1;
			should_notify_peers = false;
			goto re_arm;
		}
2118

2119 2120 2121
		bond_miimon_commit(bond);

		rtnl_unlock();	/* might sleep, hold no other locks */
2122 2123
	} else
		rcu_read_unlock();
2124

J
Jay Vosburgh 已提交
2125
re_arm:
2126
	if (bond->params.miimon)
2127 2128 2129 2130 2131 2132 2133 2134
		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();
	}
2135
}
J
Jay Vosburgh 已提交
2136

2137
static bool bond_has_this_ip(struct bonding *bond, __be32 ip)
2138
{
2139 2140 2141
	struct net_device *upper;
	struct list_head *iter;
	bool ret = false;
2142

2143
	if (ip == bond_confirm_addr(bond->dev, 0, ip))
2144
		return true;
2145

2146
	rcu_read_lock();
2147
	netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
2148 2149 2150 2151
		if (ip == bond_confirm_addr(upper, 0, ip)) {
			ret = true;
			break;
		}
2152
	}
2153
	rcu_read_unlock();
2154

2155
	return ret;
2156 2157
}

J
Jay Vosburgh 已提交
2158 2159 2160 2161 2162
/*
 * 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.
 */
2163
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 已提交
2164 2165 2166
{
	struct sk_buff *skb;

2167 2168
	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 已提交
2169

J
Jay Vosburgh 已提交
2170 2171 2172 2173
	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 已提交
2174
		pr_err("ARP packet allocation failed\n");
J
Jay Vosburgh 已提交
2175 2176 2177
		return;
	}
	if (vlan_id) {
2178
		skb = vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
J
Jay Vosburgh 已提交
2179
		if (!skb) {
J
Joe Perches 已提交
2180
			pr_err("failed to insert VLAN tag\n");
J
Jay Vosburgh 已提交
2181 2182 2183 2184 2185 2186 2187
			return;
		}
	}
	arp_xmit(skb);
}


L
Linus Torvalds 已提交
2188 2189
static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
{
2190 2191
	struct net_device *upper, *vlan_upper;
	struct list_head *iter, *vlan_iter;
J
Jay Vosburgh 已提交
2192
	struct rtable *rt;
2193 2194
	__be32 *targets = bond->params.arp_targets, addr;
	int i, vlan_id;
L
Linus Torvalds 已提交
2195

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

2199
		/* Find out through which dev should the packet go */
2200 2201
		rt = ip_route_output(dev_net(bond->dev), targets[i], 0,
				     RTO_ONLINK, 0);
2202
		if (IS_ERR(rt)) {
2203 2204
			pr_debug("%s: no route to arp_ip_target %pI4\n",
				 bond->dev->name, &targets[i]);
J
Jay Vosburgh 已提交
2205 2206 2207 2208
			continue;
		}

		vlan_id = 0;
2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221

		/* 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?
		 */
2222 2223
		netdev_for_each_all_upper_dev_rcu(bond->dev, vlan_upper,
						  vlan_iter) {
2224 2225
			if (!is_vlan_dev(vlan_upper))
				continue;
2226 2227
			netdev_for_each_all_upper_dev_rcu(vlan_upper, upper,
							  iter) {
2228 2229 2230 2231 2232
				if (upper == rt->dst.dev) {
					vlan_id = vlan_dev_vlan_id(vlan_upper);
					rcu_read_unlock();
					goto found;
				}
J
Jay Vosburgh 已提交
2233 2234 2235
			}
		}

2236 2237 2238 2239
		/* 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
		 */
2240
		netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
2241 2242 2243 2244 2245 2246 2247 2248
			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 已提交
2249
		}
2250
		rcu_read_unlock();
J
Jay Vosburgh 已提交
2251

2252
		/* Not our device - skip */
2253 2254 2255 2256
		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");

2257
		ip_rt_put(rt);
2258 2259 2260 2261 2262 2263 2264
		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 已提交
2265 2266 2267
	}
}

2268
static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip)
2269
{
2270 2271
	int i;

2272 2273 2274 2275
	if (!sip || !bond_has_this_ip(bond, tip)) {
		pr_debug("bva: sip %pI4 tip %pI4 not found\n", &sip, &tip);
		return;
	}
2276

2277 2278
	i = bond_get_targets_ip(bond->params.arp_targets, sip);
	if (i == -1) {
2279 2280
		pr_debug("bva: sip %pI4 not found in targets\n", &sip);
		return;
2281
	}
2282
	slave->last_arp_rx = jiffies;
2283
	slave->target_last_arp_rx[i] = jiffies;
2284 2285
}

2286 2287
int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond,
		 struct slave *slave)
2288
{
2289
	struct arphdr *arp = (struct arphdr *)skb->data;
2290
	unsigned char *arp_ptr;
2291
	__be32 sip, tip;
2292
	int alen;
2293

2294
	if (skb->protocol != __cpu_to_be16(ETH_P_ARP))
2295
		return RX_HANDLER_ANOTHER;
2296 2297

	read_lock(&bond->lock);
2298 2299 2300 2301

	if (!slave_do_arp_validate(bond, slave))
		goto out_unlock;

2302
	alen = arp_hdr_len(bond->dev);
2303

2304 2305
	pr_debug("bond_arp_rcv: bond %s skb->dev %s\n",
		 bond->dev->name, skb->dev->name);
2306

2307 2308 2309 2310 2311 2312 2313
	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;
	}
2314

2315
	if (arp->ar_hln != bond->dev->addr_len ||
2316 2317 2318 2319 2320 2321 2322 2323
	    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);
2324
	arp_ptr += bond->dev->addr_len;
2325
	memcpy(&sip, arp_ptr, 4);
2326
	arp_ptr += 4 + bond->dev->addr_len;
2327 2328
	memcpy(&tip, arp_ptr, 4);

2329
	pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
J
Jiri Pirko 已提交
2330
		 bond->dev->name, slave->dev->name, bond_slave_state(slave),
J
Joe Perches 已提交
2331 2332
		 bond->params.arp_validate, slave_do_arp_validate(bond, slave),
		 &sip, &tip);
2333 2334 2335 2336 2337 2338 2339 2340

	/*
	 * 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.
2341 2342 2343 2344 2345
	 *
	 * 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.
2346
	 */
J
Jiri Pirko 已提交
2347
	if (bond_is_active_slave(slave))
2348
		bond_validate_arp(bond, slave, sip, tip);
2349 2350 2351
	else if (bond->curr_active_slave &&
		 time_after(slave_last_rx(bond, bond->curr_active_slave),
			    bond->curr_active_slave->jiffies))
2352 2353 2354 2355
		bond_validate_arp(bond, slave, tip, sip);

out_unlock:
	read_unlock(&bond->lock);
2356 2357
	if (arp != (struct arphdr *)skb->data)
		kfree(arp);
2358
	return RX_HANDLER_ANOTHER;
2359 2360
}

2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374
/* 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 已提交
2375 2376 2377 2378 2379 2380 2381
/*
 * 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.
 */
2382
void bond_loadbalance_arp_mon(struct work_struct *work)
L
Linus Torvalds 已提交
2383
{
2384 2385
	struct bonding *bond = container_of(work, struct bonding,
					    arp_work.work);
L
Linus Torvalds 已提交
2386
	struct slave *slave, *oldcurrent;
2387
	struct list_head *iter;
L
Linus Torvalds 已提交
2388 2389
	int do_failover = 0;

2390
	if (!bond_has_slaves(bond))
L
Linus Torvalds 已提交
2391 2392
		goto re_arm;

2393 2394 2395
	rcu_read_lock();

	oldcurrent = ACCESS_ONCE(bond->curr_active_slave);
L
Linus Torvalds 已提交
2396 2397 2398 2399 2400 2401 2402 2403
	/* 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
	 */
2404
	bond_for_each_slave_rcu(bond, slave, iter) {
2405 2406
		unsigned long trans_start = dev_trans_start(slave->dev);

L
Linus Torvalds 已提交
2407
		if (slave->link != BOND_LINK_UP) {
2408 2409
			if (bond_time_in_interval(bond, trans_start, 1) &&
			    bond_time_in_interval(bond, slave->dev->last_rx, 1)) {
L
Linus Torvalds 已提交
2410 2411

				slave->link  = BOND_LINK_UP;
J
Jiri Pirko 已提交
2412
				bond_set_active_slave(slave);
L
Linus Torvalds 已提交
2413 2414 2415 2416 2417 2418 2419

				/* 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 已提交
2420 2421 2422
					pr_info("%s: link status definitely up for interface %s, ",
						bond->dev->name,
						slave->dev->name);
L
Linus Torvalds 已提交
2423 2424
					do_failover = 1;
				} else {
J
Joe Perches 已提交
2425 2426 2427
					pr_info("%s: interface %s is now up\n",
						bond->dev->name,
						slave->dev->name);
L
Linus Torvalds 已提交
2428 2429 2430 2431 2432 2433 2434 2435 2436
				}
			}
		} 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
			 */
2437 2438
			if (!bond_time_in_interval(bond, trans_start, 2) ||
			    !bond_time_in_interval(bond, slave->dev->last_rx, 2)) {
L
Linus Torvalds 已提交
2439 2440

				slave->link  = BOND_LINK_DOWN;
J
Jiri Pirko 已提交
2441
				bond_set_backup_slave(slave);
L
Linus Torvalds 已提交
2442

S
Stephen Hemminger 已提交
2443
				if (slave->link_failure_count < UINT_MAX)
L
Linus Torvalds 已提交
2444 2445
					slave->link_failure_count++;

J
Joe Perches 已提交
2446 2447 2448
				pr_info("%s: interface %s is now down.\n",
					bond->dev->name,
					slave->dev->name);
L
Linus Torvalds 已提交
2449

S
Stephen Hemminger 已提交
2450
				if (slave == oldcurrent)
L
Linus Torvalds 已提交
2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461
					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 已提交
2462
		if (IS_UP(slave->dev))
L
Linus Torvalds 已提交
2463 2464 2465
			bond_arp_send_all(bond, slave);
	}

2466 2467
	rcu_read_unlock();

L
Linus Torvalds 已提交
2468
	if (do_failover) {
2469 2470 2471 2472 2473
		/* the bond_select_active_slave must hold RTNL
		 * and curr_slave_lock for write.
		 */
		if (!rtnl_trylock())
			goto re_arm;
2474
		block_netpoll_tx();
2475
		write_lock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2476 2477 2478

		bond_select_active_slave(bond);

2479
		write_unlock_bh(&bond->curr_slave_lock);
2480
		unblock_netpoll_tx();
2481
		rtnl_unlock();
L
Linus Torvalds 已提交
2482 2483 2484
	}

re_arm:
2485
	if (bond->params.arp_interval)
2486 2487
		queue_delayed_work(bond->wq, &bond->arp_work,
				   msecs_to_jiffies(bond->params.arp_interval));
L
Linus Torvalds 已提交
2488 2489 2490
}

/*
2491 2492 2493 2494 2495
 * 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.
 *
2496
 * Called with rcu_read_lock hold.
L
Linus Torvalds 已提交
2497
 */
2498
static int bond_ab_arp_inspect(struct bonding *bond)
L
Linus Torvalds 已提交
2499
{
2500
	unsigned long trans_start, last_rx;
2501
	struct list_head *iter;
2502 2503
	struct slave *slave;
	int commit = 0;
2504

2505
	bond_for_each_slave_rcu(bond, slave, iter) {
2506
		slave->new_link = BOND_LINK_NOCHANGE;
2507
		last_rx = slave_last_rx(bond, slave);
L
Linus Torvalds 已提交
2508

2509
		if (slave->link != BOND_LINK_UP) {
2510
			if (bond_time_in_interval(bond, last_rx, 1)) {
2511 2512 2513 2514 2515
				slave->new_link = BOND_LINK_UP;
				commit++;
			}
			continue;
		}
L
Linus Torvalds 已提交
2516

2517 2518 2519 2520 2521
		/*
		 * 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.
		 */
2522
		if (bond_time_in_interval(bond, slave->jiffies, 2))
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537
			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 已提交
2538
		if (!bond_is_active_slave(slave) &&
2539
		    !bond->current_arp_slave &&
2540
		    !bond_time_in_interval(bond, last_rx, 3)) {
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
			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)
		 */
2551
		trans_start = dev_trans_start(slave->dev);
J
Jiri Pirko 已提交
2552
		if (bond_is_active_slave(slave) &&
2553 2554
		    (!bond_time_in_interval(bond, trans_start, 2) ||
		     !bond_time_in_interval(bond, last_rx, 2))) {
2555 2556 2557
			slave->new_link = BOND_LINK_DOWN;
			commit++;
		}
L
Linus Torvalds 已提交
2558 2559
	}

2560 2561
	return commit;
}
L
Linus Torvalds 已提交
2562

2563 2564 2565 2566
/*
 * Called to commit link state changes noted by inspection step of
 * active-backup mode ARP monitor.
 *
2567
 * Called with RTNL hold.
2568
 */
2569
static void bond_ab_arp_commit(struct bonding *bond)
2570
{
2571
	unsigned long trans_start;
2572
	struct list_head *iter;
2573
	struct slave *slave;
L
Linus Torvalds 已提交
2574

2575
	bond_for_each_slave(bond, slave, iter) {
2576 2577 2578
		switch (slave->new_link) {
		case BOND_LINK_NOCHANGE:
			continue;
2579

2580
		case BOND_LINK_UP:
2581
			trans_start = dev_trans_start(slave->dev);
2582 2583 2584
			if (bond->curr_active_slave != slave ||
			    (!bond->curr_active_slave &&
			     bond_time_in_interval(bond, trans_start, 1))) {
2585
				slave->link = BOND_LINK_UP;
2586 2587 2588 2589 2590
				if (bond->current_arp_slave) {
					bond_set_slave_inactive_flags(
						bond->current_arp_slave);
					bond->current_arp_slave = NULL;
				}
2591

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

2595 2596 2597
				if (!bond->curr_active_slave ||
				    (slave == bond->primary_slave))
					goto do_failover;
L
Linus Torvalds 已提交
2598

2599
			}
L
Linus Torvalds 已提交
2600

2601
			continue;
L
Linus Torvalds 已提交
2602

2603 2604 2605 2606 2607
		case BOND_LINK_DOWN:
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;

			slave->link = BOND_LINK_DOWN;
2608
			bond_set_slave_inactive_flags(slave);
2609

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

2613
			if (slave == bond->curr_active_slave) {
2614
				bond->current_arp_slave = NULL;
2615
				goto do_failover;
L
Linus Torvalds 已提交
2616
			}
2617 2618

			continue;
2619 2620

		default:
J
Joe Perches 已提交
2621
			pr_err("%s: impossible: new_link %d on slave %s\n",
2622 2623
			       bond->dev->name, slave->new_link,
			       slave->dev->name);
2624
			continue;
L
Linus Torvalds 已提交
2625 2626
		}

2627 2628
do_failover:
		ASSERT_RTNL();
2629
		block_netpoll_tx();
2630
		write_lock_bh(&bond->curr_slave_lock);
2631
		bond_select_active_slave(bond);
2632
		write_unlock_bh(&bond->curr_slave_lock);
2633
		unblock_netpoll_tx();
2634
	}
L
Linus Torvalds 已提交
2635

2636 2637
	bond_set_carrier(bond);
}
L
Linus Torvalds 已提交
2638

2639 2640 2641
/*
 * Send ARP probes for active-backup mode ARP monitor.
 *
2642
 * Called with rcu_read_lock hold.
2643 2644 2645
 */
static void bond_ab_arp_probe(struct bonding *bond)
{
2646 2647
	struct slave *slave, *before = NULL, *new_slave = NULL,
		     *curr_arp_slave = rcu_dereference(bond->current_arp_slave);
2648 2649
	struct list_head *iter;
	bool found = false;
L
Linus Torvalds 已提交
2650

2651
	read_lock(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2652

2653
	if (curr_arp_slave && bond->curr_active_slave)
J
Joe Perches 已提交
2654
		pr_info("PROBE: c_arp %s && cas %s BAD\n",
2655
			curr_arp_slave->dev->name,
J
Joe Perches 已提交
2656
			bond->curr_active_slave->dev->name);
L
Linus Torvalds 已提交
2657

2658 2659 2660 2661 2662
	if (bond->curr_active_slave) {
		bond_arp_send_all(bond, bond->curr_active_slave);
		read_unlock(&bond->curr_slave_lock);
		return;
	}
L
Linus Torvalds 已提交
2663

2664
	read_unlock(&bond->curr_slave_lock);
2665

2666 2667 2668 2669
	/* 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 已提交
2670

2671 2672 2673
	if (!curr_arp_slave) {
		curr_arp_slave = bond_first_slave_rcu(bond);
		if (!curr_arp_slave)
2674 2675
			return;
	}
L
Linus Torvalds 已提交
2676

2677
	bond_set_slave_inactive_flags(curr_arp_slave);
2678

2679
	bond_for_each_slave_rcu(bond, slave, iter) {
2680 2681
		if (!found && !before && IS_UP(slave->dev))
			before = slave;
L
Linus Torvalds 已提交
2682

2683 2684
		if (found && !new_slave && IS_UP(slave->dev))
			new_slave = slave;
2685 2686 2687 2688 2689 2690
		/* 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 已提交
2691
		 */
2692
		if (!IS_UP(slave->dev) && slave->link == BOND_LINK_UP) {
2693 2694 2695
			slave->link = BOND_LINK_DOWN;
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;
L
Linus Torvalds 已提交
2696

2697 2698
			bond_set_slave_inactive_flags(slave);

J
Joe Perches 已提交
2699 2700
			pr_info("%s: backup interface %s is now down.\n",
				bond->dev->name, slave->dev->name);
L
Linus Torvalds 已提交
2701
		}
2702
		if (slave == curr_arp_slave)
2703
			found = true;
2704
	}
2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715

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

	if (!new_slave)
		return;

	new_slave->link = BOND_LINK_BACK;
	bond_set_slave_active_flags(new_slave);
	bond_arp_send_all(bond, new_slave);
	new_slave->jiffies = jiffies;
2716
	rcu_assign_pointer(bond->current_arp_slave, new_slave);
2717
}
L
Linus Torvalds 已提交
2718

2719 2720 2721 2722
void bond_activebackup_arp_mon(struct work_struct *work)
{
	struct bonding *bond = container_of(work, struct bonding,
					    arp_work.work);
2723
	bool should_notify_peers = false;
2724
	int delta_in_ticks;
L
Linus Torvalds 已提交
2725

2726 2727 2728
	delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);

	if (!bond_has_slaves(bond))
2729 2730
		goto re_arm;

2731 2732
	rcu_read_lock();

2733 2734
	should_notify_peers = bond_should_notify_peers(bond);

2735
	if (bond_ab_arp_inspect(bond)) {
2736
		rcu_read_unlock();
2737

2738 2739 2740 2741 2742 2743
		/* Race avoidance with bond_close flush of workqueue */
		if (!rtnl_trylock()) {
			delta_in_ticks = 1;
			should_notify_peers = false;
			goto re_arm;
		}
2744

2745 2746 2747
		bond_ab_arp_commit(bond);

		rtnl_unlock();
2748
		rcu_read_lock();
2749 2750 2751
	}

	bond_ab_arp_probe(bond);
2752
	rcu_read_unlock();
2753

2754 2755
re_arm:
	if (bond->params.arp_interval)
2756 2757 2758 2759 2760 2761 2762 2763
		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 已提交
2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774
}

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

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

2776 2777
	bond_debug_reregister(bond);

L
Linus Torvalds 已提交
2778 2779 2780
	return NOTIFY_DONE;
}

S
Stephen Hemminger 已提交
2781 2782
static int bond_master_netdev_event(unsigned long event,
				    struct net_device *bond_dev)
L
Linus Torvalds 已提交
2783
{
2784
	struct bonding *event_bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
2785 2786 2787 2788

	switch (event) {
	case NETDEV_CHANGENAME:
		return bond_event_changename(event_bond);
2789 2790 2791 2792 2793 2794
	case NETDEV_UNREGISTER:
		bond_remove_proc_entry(event_bond);
		break;
	case NETDEV_REGISTER:
		bond_create_proc_entry(event_bond);
		break;
2795 2796 2797 2798
	case NETDEV_NOTIFY_PEERS:
		if (event_bond->send_peer_notif)
			event_bond->send_peer_notif--;
		break;
L
Linus Torvalds 已提交
2799 2800 2801 2802 2803 2804 2805
	default:
		break;
	}

	return NOTIFY_DONE;
}

S
Stephen Hemminger 已提交
2806 2807
static int bond_slave_netdev_event(unsigned long event,
				   struct net_device *slave_dev)
L
Linus Torvalds 已提交
2808
{
2809
	struct slave *slave = bond_slave_get_rtnl(slave_dev);
2810 2811
	struct bonding *bond;
	struct net_device *bond_dev;
2812 2813
	u32 old_speed;
	u8 old_duplex;
L
Linus Torvalds 已提交
2814

2815 2816 2817 2818 2819 2820 2821 2822 2823
	/* 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 已提交
2824 2825
	switch (event) {
	case NETDEV_UNREGISTER:
2826
		if (bond_dev->type != ARPHRD_ETHER)
2827 2828 2829
			bond_release_and_destroy(bond_dev, slave_dev);
		else
			bond_release(bond_dev, slave_dev);
L
Linus Torvalds 已提交
2830
		break;
2831
	case NETDEV_UP:
L
Linus Torvalds 已提交
2832
	case NETDEV_CHANGE:
2833 2834
		old_speed = slave->speed;
		old_duplex = slave->duplex;
2835

2836
		bond_update_speed_duplex(slave);
2837

2838 2839 2840 2841 2842
		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);
2843
		}
L
Linus Torvalds 已提交
2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
		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:
		/*
		 * TODO: handle changing the primary's name
		 */
		break;
2869 2870 2871
	case NETDEV_FEAT_CHANGE:
		bond_compute_features(bond);
		break;
2872 2873 2874 2875
	case NETDEV_RESEND_IGMP:
		/* Propagate to master device */
		call_netdevice_notifiers(event, slave->bond->dev);
		break;
L
Linus Torvalds 已提交
2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886
	default:
		break;
	}

	return NOTIFY_DONE;
}

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

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

2900 2901 2902
	if (!(event_dev->priv_flags & IFF_BONDING))
		return NOTIFY_DONE;

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

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

	return NOTIFY_DONE;
}

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

2920 2921
/*---------------------------- Hashing Policies -----------------------------*/

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

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

	return 0;
}

2933 2934 2935
/* 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)
2936
{
2937
	const struct ipv6hdr *iph6;
2938
	const struct iphdr *iph;
2939
	int noff, proto = -1;
2940

2941 2942 2943 2944 2945 2946 2947 2948
	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;
2949
		iph = ip_hdr(skb);
2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964
		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;
2965
	}
2966 2967
	if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34 && proto >= 0)
		fk->ports = skb_flow_get_ports(skb, noff, proto);
2968

2969
	return true;
2970 2971
}

2972 2973 2974 2975 2976 2977 2978 2979 2980
/**
 * 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.
2981
 */
2982
int bond_xmit_hash(struct bonding *bond, struct sk_buff *skb, int count)
2983
{
2984 2985
	struct flow_keys flow;
	u32 hash;
2986

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

2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
	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;
3001 3002
}

L
Linus Torvalds 已提交
3003 3004
/*-------------------------- Device entry points ----------------------------*/

3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026
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 已提交
3027 3028
static int bond_open(struct net_device *bond_dev)
{
3029
	struct bonding *bond = netdev_priv(bond_dev);
3030
	struct list_head *iter;
3031
	struct slave *slave;
L
Linus Torvalds 已提交
3032

3033 3034
	/* reset slave->backup and slave->inactive */
	read_lock(&bond->lock);
3035
	if (bond_has_slaves(bond)) {
3036
		read_lock(&bond->curr_slave_lock);
3037
		bond_for_each_slave(bond, slave, iter) {
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
			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);

3049
	bond_work_init_all(bond);
3050

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

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

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

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

	return 0;
}

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

3083
	bond_work_cancel_all(bond);
3084
	bond->send_peer_notif = 0;
3085
	if (bond_is_lb(bond))
L
Linus Torvalds 已提交
3086
		bond_alb_deinitialize(bond);
3087
	bond->recv_probe = NULL;
L
Linus Torvalds 已提交
3088 3089 3090 3091

	return 0;
}

3092 3093
static struct rtnl_link_stats64 *bond_get_stats(struct net_device *bond_dev,
						struct rtnl_link_stats64 *stats)
L
Linus Torvalds 已提交
3094
{
3095
	struct bonding *bond = netdev_priv(bond_dev);
3096
	struct rtnl_link_stats64 temp;
3097
	struct list_head *iter;
L
Linus Torvalds 已提交
3098 3099
	struct slave *slave;

3100
	memset(stats, 0, sizeof(*stats));
L
Linus Torvalds 已提交
3101 3102

	read_lock_bh(&bond->lock);
3103
	bond_for_each_slave(bond, slave, iter) {
3104
		const struct rtnl_link_stats64 *sstats =
3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131
			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;
3132
	}
L
Linus Torvalds 已提交
3133 3134 3135 3136 3137 3138 3139
	read_unlock_bh(&bond->lock);

	return stats;
}

static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
{
3140
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3141 3142 3143 3144 3145 3146
	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;
3147
	struct net *net;
L
Linus Torvalds 已提交
3148 3149
	int res = 0;

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

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

L
Linus Torvalds 已提交
3158 3159 3160 3161 3162 3163 3164 3165
		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 已提交
3166
		if (!mii)
L
Linus Torvalds 已提交
3167
			return -EINVAL;
S
Stephen Hemminger 已提交
3168

L
Linus Torvalds 已提交
3169 3170 3171

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

L
Linus Torvalds 已提交
3177
			read_unlock(&bond->curr_slave_lock);
3178
			read_unlock(&bond->lock);
L
Linus Torvalds 已提交
3179 3180 3181 3182 3183 3184 3185
		}

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

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

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

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

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

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

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

3213 3214 3215
	net = dev_net(bond_dev);

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

3218
	slave_dev = dev_get_by_name(net, ifr->ifr_slave);
L
Linus Torvalds 已提交
3219

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

S
Stephen Hemminger 已提交
3222
	if (!slave_dev)
L
Linus Torvalds 已提交
3223
		res = -ENODEV;
S
Stephen Hemminger 已提交
3224
	else {
J
Joe Perches 已提交
3225
		pr_debug("slave_dev->name=%s:\n", slave_dev->name);
L
Linus Torvalds 已提交
3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236
		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:
3237 3238
			bond_set_dev_addr(bond_dev, slave_dev);
			res = 0;
L
Linus Torvalds 已提交
3239 3240 3241
			break;
		case BOND_CHANGE_ACTIVE_OLD:
		case SIOCBONDCHANGEACTIVE:
3242
			res = bond_option_active_slave_set(bond, slave_dev);
L
Linus Torvalds 已提交
3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253
			break;
		default:
			res = -EOPNOTSUPP;
		}

		dev_put(slave_dev);
	}

	return res;
}

3254
static void bond_change_rx_flags(struct net_device *bond_dev, int change)
L
Linus Torvalds 已提交
3255
{
3256
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3257

3258 3259 3260
	if (change & IFF_PROMISC)
		bond_set_promiscuity(bond,
				     bond_dev->flags & IFF_PROMISC ? 1 : -1);
S
Stephen Hemminger 已提交
3261

3262 3263 3264 3265
	if (change & IFF_ALLMULTI)
		bond_set_allmulti(bond,
				  bond_dev->flags & IFF_ALLMULTI ? 1 : -1);
}
L
Linus Torvalds 已提交
3266

3267
static void bond_set_rx_mode(struct net_device *bond_dev)
3268 3269
{
	struct bonding *bond = netdev_priv(bond_dev);
3270
	struct list_head *iter;
3271
	struct slave *slave;
L
Linus Torvalds 已提交
3272

3273

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

3290
static int bond_neigh_init(struct neighbour *n)
3291
{
3292 3293 3294
	struct bonding *bond = netdev_priv(n->dev);
	const struct net_device_ops *slave_ops;
	struct neigh_parms parms;
3295
	struct slave *slave;
3296 3297
	int ret;

3298
	slave = bond_first_slave(bond);
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 3324 3325 3326 3327 3328
	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.
3329 3330 3331 3332
 *
 * 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.
3333 3334 3335 3336
 */
static int bond_neigh_setup(struct net_device *dev,
			    struct neigh_parms *parms)
{
3337 3338 3339
	/* modify only our neigh_parms */
	if (parms->dev == dev)
		parms->neigh_setup = bond_neigh_init;
3340 3341 3342 3343

	return 0;
}

L
Linus Torvalds 已提交
3344 3345 3346 3347 3348
/*
 * 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)
{
3349
	struct bonding *bond = netdev_priv(bond_dev);
3350
	struct slave *slave, *rollback_slave;
3351
	struct list_head *iter;
L
Linus Torvalds 已提交
3352 3353
	int res = 0;

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

	/* 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.
	 */

3372
	bond_for_each_slave(bond, slave, iter) {
3373
		pr_debug("s %p c_m %p\n",
J
Joe Perches 已提交
3374 3375
			 slave,
			 slave->dev->netdev_ops->ndo_change_mtu);
3376

L
Linus Torvalds 已提交
3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
		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.
			 */
3388
			pr_debug("err %d %s\n", res, slave->dev->name);
L
Linus Torvalds 已提交
3389 3390 3391 3392 3393 3394 3395 3396 3397 3398
			goto unwind;
		}
	}

	bond_dev->mtu = new_mtu;

	return 0;

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

3402 3403 3404 3405
		if (rollback_slave == slave)
			break;

		tmp_res = dev_set_mtu(rollback_slave->dev, bond_dev->mtu);
L
Linus Torvalds 已提交
3406
		if (tmp_res) {
J
Joe Perches 已提交
3407
			pr_debug("unwind err %d dev %s\n",
3408
				 tmp_res, rollback_slave->dev->name);
L
Linus Torvalds 已提交
3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423
		}
	}

	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)
{
3424
	struct bonding *bond = netdev_priv(bond_dev);
3425
	struct slave *slave, *rollback_slave;
L
Linus Torvalds 已提交
3426
	struct sockaddr *sa = addr, tmp_sa;
3427
	struct list_head *iter;
L
Linus Torvalds 已提交
3428 3429
	int res = 0;

3430 3431 3432 3433
	if (bond->params.mode == BOND_MODE_ALB)
		return bond_alb_set_mac_address(bond_dev, addr);


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

3437 3438
	/* If fail_over_mac is enabled, do nothing and return success.
	 * Returning an error causes ifenslave to fail.
3439
	 */
3440
	if (bond->params.fail_over_mac)
3441
		return 0;
3442

S
Stephen Hemminger 已提交
3443
	if (!is_valid_ether_addr(sa->sa_data))
L
Linus Torvalds 已提交
3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460
		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.
	 */

3461
	bond_for_each_slave(bond, slave, iter) {
3462
		const struct net_device_ops *slave_ops = slave->dev->netdev_ops;
3463
		pr_debug("slave %p %s\n", slave, slave->dev->name);
L
Linus Torvalds 已提交
3464

3465
		if (slave_ops->ndo_set_mac_address == NULL) {
L
Linus Torvalds 已提交
3466
			res = -EOPNOTSUPP;
3467
			pr_debug("EOPNOTSUPP %s\n", slave->dev->name);
L
Linus Torvalds 已提交
3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478
			goto unwind;
		}

		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...
			 */
3479
			pr_debug("err %d %s\n", res, slave->dev->name);
L
Linus Torvalds 已提交
3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492
			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 */
3493
	bond_for_each_slave(bond, rollback_slave, iter) {
L
Linus Torvalds 已提交
3494 3495
		int tmp_res;

3496 3497 3498 3499
		if (rollback_slave == slave)
			break;

		tmp_res = dev_set_mac_address(rollback_slave->dev, &tmp_sa);
L
Linus Torvalds 已提交
3500
		if (tmp_res) {
J
Joe Perches 已提交
3501
			pr_debug("unwind err %d dev %s\n",
3502
				 tmp_res, rollback_slave->dev->name);
L
Linus Torvalds 已提交
3503 3504 3505 3506 3507 3508
		}
	}

	return res;
}

3509 3510 3511 3512 3513 3514 3515 3516 3517 3518
/**
 * 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.
 */
3519
static void bond_xmit_slave_id(struct bonding *bond, struct sk_buff *skb, int slave_id)
3520
{
3521
	struct list_head *iter;
3522 3523 3524 3525
	struct slave *slave;
	int i = slave_id;

	/* Here we start from the slave with slave_id */
3526
	bond_for_each_slave_rcu(bond, slave, iter) {
3527 3528 3529 3530 3531 3532 3533 3534 3535 3536
		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;
3537
	bond_for_each_slave_rcu(bond, slave, iter) {
3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548
		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);
}

3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578
/**
 * 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)
{
	int packets_per_slave = bond->params.packets_per_slave;
	u32 slave_id;

	switch (packets_per_slave) {
	case 0:
		slave_id = prandom_u32();
		break;
	case 1:
		slave_id = bond->rr_tx_counter;
		break;
	default:
		slave_id = reciprocal_divide(bond->rr_tx_counter,
					     packets_per_slave);
		break;
	}
	bond->rr_tx_counter++;

	return slave_id;
}

L
Linus Torvalds 已提交
3579 3580
static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
{
3581
	struct bonding *bond = netdev_priv(bond_dev);
3582
	struct iphdr *iph = ip_hdr(skb);
3583
	struct slave *slave;
3584
	u32 slave_id;
L
Linus Torvalds 已提交
3585

3586
	/* Start with the curr_active_slave that joined the bond as the
3587 3588 3589 3590
	 * 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.
3591
	 */
3592
	if (iph->protocol == IPPROTO_IGMP && skb->protocol == htons(ETH_P_IP)) {
3593
		slave = rcu_dereference(bond->curr_active_slave);
3594 3595 3596 3597
		if (slave && slave_can_tx(slave))
			bond_dev_queue_xmit(bond, skb, slave->dev);
		else
			bond_xmit_slave_id(bond, skb, 0);
3598
	} else {
3599 3600
		slave_id = bond_rr_gen_slave_id(bond);
		bond_xmit_slave_id(bond, skb, slave_id % bond->slave_cnt);
L
Linus Torvalds 已提交
3601
	}
3602

3603
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
3604 3605 3606 3607 3608 3609 3610 3611
}

/*
 * 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)
{
3612
	struct bonding *bond = netdev_priv(bond_dev);
3613
	struct slave *slave;
L
Linus Torvalds 已提交
3614

3615
	slave = rcu_dereference(bond->curr_active_slave);
3616
	if (slave)
3617 3618
		bond_dev_queue_xmit(bond, skb, slave->dev);
	else
E
Eric Dumazet 已提交
3619
		kfree_skb(skb);
3620

3621
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
3622 3623
}

3624
/* In bond_xmit_xor() , we determine the output device by using a pre-
3625 3626
 * determined xmit_hash_policy(), If the selected device is not enabled,
 * find the next active slave.
L
Linus Torvalds 已提交
3627 3628 3629
 */
static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
{
3630
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3631

3632
	bond_xmit_slave_id(bond, skb, bond_xmit_hash(bond, skb, bond->slave_cnt));
3633

3634
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
3635 3636
}

3637
/* in broadcast mode, we send everything to all usable interfaces. */
L
Linus Torvalds 已提交
3638 3639
static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
{
3640
	struct bonding *bond = netdev_priv(bond_dev);
3641
	struct slave *slave = NULL;
3642
	struct list_head *iter;
L
Linus Torvalds 已提交
3643

3644
	bond_for_each_slave_rcu(bond, slave, iter) {
3645 3646 3647 3648
		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 已提交
3649

3650 3651 3652 3653
			if (!skb2) {
				pr_err("%s: Error: bond_xmit_broadcast(): skb_clone() failed\n",
				       bond_dev->name);
				continue;
L
Linus Torvalds 已提交
3654
			}
3655 3656
			/* bond_dev_queue_xmit always returns 0 */
			bond_dev_queue_xmit(bond, skb2, slave->dev);
L
Linus Torvalds 已提交
3657 3658
		}
	}
3659 3660 3661
	if (slave && IS_UP(slave->dev) && slave->link == BOND_LINK_UP)
		bond_dev_queue_xmit(bond, skb, slave->dev);
	else
E
Eric Dumazet 已提交
3662
		kfree_skb(skb);
S
Stephen Hemminger 已提交
3663

3664
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
3665 3666 3667 3668
}

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

3669 3670 3671 3672 3673 3674 3675
/*
 * 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;
3676
	struct list_head *iter;
3677

3678 3679
	if (!skb->queue_mapping)
		return 1;
3680 3681

	/* Find out if any slaves have the same mapping as this skb. */
3682 3683 3684 3685 3686 3687 3688
	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. */
3689 3690 3691 3692
			break;
		}
	}

3693
	return 1;
3694 3695
}

3696

3697 3698 3699 3700
static u16 bond_select_queue(struct net_device *dev, struct sk_buff *skb)
{
	/*
	 * This helper function exists to help dev_pick_tx get the correct
P
Phil Oester 已提交
3701
	 * destination queue.  Using a helper function skips a call to
3702 3703 3704
	 * skb_tx_hash and will put the skbs in the queue we expect on their
	 * way down to the bonding driver.
	 */
P
Phil Oester 已提交
3705 3706
	u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;

3707 3708 3709
	/*
	 * Save the original txq to restore before passing to the driver
	 */
3710
	qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
3711

P
Phil Oester 已提交
3712
	if (unlikely(txq >= dev->real_num_tx_queues)) {
3713
		do {
P
Phil Oester 已提交
3714
			txq -= dev->real_num_tx_queues;
3715
		} while (txq >= dev->real_num_tx_queues);
P
Phil Oester 已提交
3716 3717
	}
	return txq;
3718 3719
}

3720
static netdev_tx_t __bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
3721
{
3722 3723 3724 3725 3726 3727
	struct bonding *bond = netdev_priv(dev);

	if (TX_QUEUE_OVERRIDE(bond->params.mode)) {
		if (!bond_slave_override(bond, skb))
			return NETDEV_TX_OK;
	}
3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744

	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 已提交
3745 3746
		pr_err("%s: Error: Unknown bonding mode %d\n",
		       dev->name, bond->params.mode);
3747
		WARN_ON_ONCE(1);
E
Eric Dumazet 已提交
3748
		kfree_skb(skb);
3749 3750 3751 3752
		return NETDEV_TX_OK;
	}
}

3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764
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;

3765
	rcu_read_lock();
3766
	if (bond_has_slaves(bond))
3767 3768
		ret = __bond_start_xmit(skb, dev);
	else
E
Eric Dumazet 已提交
3769
		kfree_skb(skb);
3770
	rcu_read_unlock();
3771 3772 3773

	return ret;
}
3774

3775 3776 3777 3778 3779
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;
3780
	struct list_head *iter;
3781
	struct slave *slave;
3782 3783 3784 3785 3786 3787 3788 3789 3790 3791

	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);
3792
	bond_for_each_slave(bond, slave, iter) {
3793 3794 3795 3796 3797 3798 3799 3800 3801 3802
		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);
3803

3804 3805 3806
	return 0;
}

3807
static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
3808
				     struct ethtool_drvinfo *drvinfo)
3809
{
3810 3811 3812 3813
	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);
3814 3815
}

3816
static const struct ethtool_ops bond_ethtool_ops = {
3817
	.get_drvinfo		= bond_ethtool_get_drvinfo,
3818
	.get_settings		= bond_ethtool_get_settings,
3819
	.get_link		= ethtool_op_get_link,
3820 3821
};

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

3848 3849 3850 3851
static const struct device_type bond_type = {
	.name = "bond",
};

3852 3853 3854 3855 3856 3857 3858 3859
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);
}

3860
void bond_setup(struct net_device *bond_dev)
L
Linus Torvalds 已提交
3861
{
3862
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3863 3864 3865 3866

	/* initialize rwlocks */
	rwlock_init(&bond->lock);
	rwlock_init(&bond->curr_slave_lock);
3867
	bond->params = bonding_defaults;
L
Linus Torvalds 已提交
3868 3869 3870 3871 3872

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

	/* Initialize the device entry points */
3873
	ether_setup(bond_dev);
3874
	bond_dev->netdev_ops = &bond_netdev_ops;
3875
	bond_dev->ethtool_ops = &bond_ethtool_ops;
L
Linus Torvalds 已提交
3876

3877
	bond_dev->destructor = bond_destructor;
L
Linus Torvalds 已提交
3878

3879 3880
	SET_NETDEV_DEVTYPE(bond_dev, &bond_type);

L
Linus Torvalds 已提交
3881 3882 3883
	/* Initialize the device options */
	bond_dev->tx_queue_len = 0;
	bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
3884
	bond_dev->priv_flags |= IFF_BONDING;
3885
	bond_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
3886

L
Linus Torvalds 已提交
3887 3888 3889 3890 3891 3892 3893
	/* 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 已提交
3894
	/* don't acquire bond device's netif_tx_lock when
L
Linus Torvalds 已提交
3895 3896 3897 3898 3899 3900 3901 3902 3903 3904
	 * 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
	 */

3905
	bond_dev->hw_features = BOND_VLAN_FEATURES |
3906 3907 3908
				NETIF_F_HW_VLAN_CTAG_TX |
				NETIF_F_HW_VLAN_CTAG_RX |
				NETIF_F_HW_VLAN_CTAG_FILTER;
3909

3910
	bond_dev->hw_features &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_HW_CSUM);
3911
	bond_dev->features |= bond_dev->hw_features;
L
Linus Torvalds 已提交
3912 3913
}

3914 3915 3916 3917 3918
/*
* 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 已提交
3919
{
3920
	struct bonding *bond = netdev_priv(bond_dev);
3921 3922
	struct list_head *iter;
	struct slave *slave;
J
Jay Vosburgh 已提交
3923

3924 3925
	bond_netpoll_cleanup(bond_dev);

3926
	/* Release the bonded slaves */
3927
	bond_for_each_slave(bond, slave, iter)
3928
		__bond_release_one(bond_dev, slave->dev, true);
3929
	pr_info("%s: released all slaves\n", bond_dev->name);
3930

J
Jay Vosburgh 已提交
3931 3932
	list_del(&bond->bond_list);

3933
	bond_debug_unregister(bond);
J
Jay Vosburgh 已提交
3934 3935
}

L
Linus Torvalds 已提交
3936 3937 3938 3939
/*------------------------- Module initialization ---------------------------*/

/*
 * Convert string input module parms.  Accept either the
J
Jay Vosburgh 已提交
3940 3941 3942
 * 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 已提交
3943
 */
3944
int bond_parse_parm(const char *buf, const struct bond_parm_tbl *tbl)
L
Linus Torvalds 已提交
3945
{
3946
	int modeint = -1, i, rv;
J
Jay Vosburgh 已提交
3947
	char *p, modestr[BOND_MAX_MODENAME_LEN + 1] = { 0, };
J
Jay Vosburgh 已提交
3948

J
Jay Vosburgh 已提交
3949 3950 3951 3952 3953
	for (p = (char *)buf; *p; p++)
		if (!(isdigit(*p) || isspace(*p)))
			break;

	if (*p)
J
Jay Vosburgh 已提交
3954
		rv = sscanf(buf, "%20s", modestr);
J
Jay Vosburgh 已提交
3955
	else
3956
		rv = sscanf(buf, "%d", &modeint);
J
Jay Vosburgh 已提交
3957 3958 3959

	if (!rv)
		return -1;
L
Linus Torvalds 已提交
3960 3961

	for (i = 0; tbl[i].modename; i++) {
3962
		if (modeint == tbl[i].mode)
J
Jay Vosburgh 已提交
3963 3964
			return tbl[i].mode;
		if (strcmp(modestr, tbl[i].modename) == 0)
L
Linus Torvalds 已提交
3965 3966 3967 3968 3969 3970 3971 3972
			return tbl[i].mode;
	}

	return -1;
}

static int bond_check_params(struct bond_params *params)
{
3973
	int arp_validate_value, fail_over_mac_value, primary_reselect_value, i;
3974
	int arp_all_targets_value;
3975

L
Linus Torvalds 已提交
3976 3977 3978 3979 3980 3981
	/*
	 * Convert string parameters.
	 */
	if (mode) {
		bond_mode = bond_parse_parm(mode, bond_mode_tbl);
		if (bond_mode == -1) {
J
Joe Perches 已提交
3982
			pr_err("Error: Invalid bonding mode \"%s\"\n",
L
Linus Torvalds 已提交
3983 3984 3985 3986 3987
			       mode == NULL ? "NULL" : mode);
			return -EINVAL;
		}
	}

3988 3989 3990
	if (xmit_hash_policy) {
		if ((bond_mode != BOND_MODE_XOR) &&
		    (bond_mode != BOND_MODE_8023AD)) {
J
Joe Perches 已提交
3991
			pr_info("xmit_hash_policy param is irrelevant in mode %s\n",
3992 3993 3994 3995 3996
			       bond_mode_name(bond_mode));
		} else {
			xmit_hashtype = bond_parse_parm(xmit_hash_policy,
							xmit_hashtype_tbl);
			if (xmit_hashtype == -1) {
J
Joe Perches 已提交
3997
				pr_err("Error: Invalid xmit_hash_policy \"%s\"\n",
S
Stephen Hemminger 已提交
3998
				       xmit_hash_policy == NULL ? "NULL" :
3999 4000 4001 4002 4003 4004
				       xmit_hash_policy);
				return -EINVAL;
			}
		}
	}

L
Linus Torvalds 已提交
4005 4006
	if (lacp_rate) {
		if (bond_mode != BOND_MODE_8023AD) {
J
Joe Perches 已提交
4007 4008
			pr_info("lacp_rate param is irrelevant in mode %s\n",
				bond_mode_name(bond_mode));
L
Linus Torvalds 已提交
4009 4010 4011
		} else {
			lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl);
			if (lacp_fast == -1) {
J
Joe Perches 已提交
4012
				pr_err("Error: Invalid lacp rate \"%s\"\n",
L
Linus Torvalds 已提交
4013 4014 4015 4016 4017 4018
				       lacp_rate == NULL ? "NULL" : lacp_rate);
				return -EINVAL;
			}
		}
	}

4019 4020 4021
	if (ad_select) {
		params->ad_select = bond_parse_parm(ad_select, ad_select_tbl);
		if (params->ad_select == -1) {
J
Joe Perches 已提交
4022
			pr_err("Error: Invalid ad_select \"%s\"\n",
4023 4024 4025 4026 4027
			       ad_select == NULL ? "NULL" : ad_select);
			return -EINVAL;
		}

		if (bond_mode != BOND_MODE_8023AD) {
J
Joe Perches 已提交
4028
			pr_warning("ad_select param only affects 802.3ad mode\n");
4029 4030 4031 4032 4033
		}
	} else {
		params->ad_select = BOND_AD_STABLE;
	}

4034
	if (max_bonds < 0) {
J
Joe Perches 已提交
4035 4036
		pr_warning("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 已提交
4037 4038 4039 4040
		max_bonds = BOND_DEFAULT_MAX_BONDS;
	}

	if (miimon < 0) {
J
Joe Perches 已提交
4041 4042
		pr_warning("Warning: miimon module parameter (%d), not in range 0-%d, so it was reset to %d\n",
			   miimon, INT_MAX, BOND_LINK_MON_INTERV);
L
Linus Torvalds 已提交
4043 4044 4045 4046
		miimon = BOND_LINK_MON_INTERV;
	}

	if (updelay < 0) {
J
Joe Perches 已提交
4047 4048
		pr_warning("Warning: updelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
			   updelay, INT_MAX);
L
Linus Torvalds 已提交
4049 4050 4051 4052
		updelay = 0;
	}

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

	if ((use_carrier != 0) && (use_carrier != 1)) {
J
Joe Perches 已提交
4059 4060
		pr_warning("Warning: use_carrier module parameter (%d), not of valid value (0/1), so it was set to 1\n",
			   use_carrier);
L
Linus Torvalds 已提交
4061 4062 4063
		use_carrier = 1;
	}

4064 4065 4066 4067 4068 4069
	if (num_peer_notif < 0 || num_peer_notif > 255) {
		pr_warning("Warning: num_grat_arp/num_unsol_na (%d) not in range 0-255 so it was reset to 1\n",
			   num_peer_notif);
		num_peer_notif = 1;
	}

4070 4071
	/* reset values for 802.3ad/TLB/ALB */
	if (BOND_NO_USES_ARP(bond_mode)) {
L
Linus Torvalds 已提交
4072
		if (!miimon) {
J
Joe Perches 已提交
4073
			pr_warning("Warning: miimon must be specified, otherwise bonding will not detect link failure, speed and duplex which are essential for 802.3ad operation\n");
S
Stephen Hemminger 已提交
4074
			pr_warning("Forcing miimon to 100msec\n");
4075
			miimon = BOND_DEFAULT_MIIMON;
L
Linus Torvalds 已提交
4076 4077 4078
		}
	}

4079 4080 4081 4082 4083 4084 4085
	if (tx_queues < 1 || tx_queues > 255) {
		pr_warning("Warning: tx_queues (%d) should be between "
			   "1 and 255, resetting to %d\n",
			   tx_queues, BOND_DEFAULT_TX_QUEUES);
		tx_queues = BOND_DEFAULT_TX_QUEUES;
	}

4086 4087 4088 4089 4090 4091 4092
	if ((all_slaves_active != 0) && (all_slaves_active != 1)) {
		pr_warning("Warning: all_slaves_active module parameter (%d), "
			   "not of valid value (0/1), so it was set to "
			   "0\n", all_slaves_active);
		all_slaves_active = 0;
	}

4093 4094 4095 4096 4097 4098 4099
	if (resend_igmp < 0 || resend_igmp > 255) {
		pr_warning("Warning: resend_igmp (%d) should be between "
			   "0 and 255, resetting to %d\n",
			   resend_igmp, BOND_DEFAULT_RESEND_IGMP);
		resend_igmp = BOND_DEFAULT_RESEND_IGMP;
	}

4100 4101 4102 4103 4104 4105
	if (packets_per_slave < 0 || packets_per_slave > USHRT_MAX) {
		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 已提交
4106
	if (bond_mode == BOND_MODE_ALB) {
J
Joe Perches 已提交
4107 4108
		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 已提交
4109 4110 4111 4112 4113 4114 4115
	}

	if (!miimon) {
		if (updelay || downdelay) {
			/* just warn the user the up/down delay will have
			 * no effect since miimon is zero...
			 */
J
Joe Perches 已提交
4116 4117
			pr_warning("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 已提交
4118 4119 4120 4121
		}
	} else {
		/* don't allow arp monitoring */
		if (arp_interval) {
J
Joe Perches 已提交
4122 4123
			pr_warning("Warning: miimon (%d) and arp_interval (%d) can't be used simultaneously, disabling ARP monitoring\n",
				   miimon, arp_interval);
L
Linus Torvalds 已提交
4124 4125 4126 4127
			arp_interval = 0;
		}

		if ((updelay % miimon) != 0) {
J
Joe Perches 已提交
4128 4129 4130
			pr_warning("Warning: updelay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n",
				   updelay, miimon,
				   (updelay / miimon) * miimon);
L
Linus Torvalds 已提交
4131 4132 4133 4134 4135
		}

		updelay /= miimon;

		if ((downdelay % miimon) != 0) {
J
Joe Perches 已提交
4136 4137 4138
			pr_warning("Warning: downdelay (%d) is not a multiple of miimon (%d), downdelay rounded to %d ms\n",
				   downdelay, miimon,
				   (downdelay / miimon) * miimon);
L
Linus Torvalds 已提交
4139 4140 4141 4142 4143 4144
		}

		downdelay /= miimon;
	}

	if (arp_interval < 0) {
J
Joe Perches 已提交
4145 4146
		pr_warning("Warning: arp_interval module parameter (%d) , not in range 0-%d, so it was reset to %d\n",
			   arp_interval, INT_MAX, BOND_LINK_ARP_INTERV);
L
Linus Torvalds 已提交
4147 4148 4149
		arp_interval = BOND_LINK_ARP_INTERV;
	}

4150 4151
	for (arp_ip_count = 0, i = 0;
	     (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[i]; i++) {
L
Linus Torvalds 已提交
4152 4153
		/* not complete check, but should be good enough to
		   catch mistakes */
4154 4155 4156
		__be32 ip;
		if (!in4_pton(arp_ip_target[i], -1, (u8 *)&ip, -1, NULL) ||
		    IS_IP_TARGET_UNUSABLE_ADDRESS(ip)) {
J
Joe Perches 已提交
4157
			pr_warning("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n",
4158
				   arp_ip_target[i]);
L
Linus Torvalds 已提交
4159 4160
			arp_interval = 0;
		} else {
4161 4162 4163 4164 4165
			if (bond_get_targets_ip(arp_target, ip) == -1)
				arp_target[arp_ip_count++] = ip;
			else
				pr_warning("Warning: duplicate address %pI4 in arp_ip_target, skipping\n",
					   &ip);
L
Linus Torvalds 已提交
4166 4167 4168 4169 4170
		}
	}

	if (arp_interval && !arp_ip_count) {
		/* don't allow arping if no arp_ip_target given... */
J
Joe Perches 已提交
4171 4172
		pr_warning("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 已提交
4173 4174 4175
		arp_interval = 0;
	}

4176 4177
	if (arp_validate) {
		if (bond_mode != BOND_MODE_ACTIVEBACKUP) {
J
Joe Perches 已提交
4178
			pr_err("arp_validate only supported in active-backup mode\n");
4179 4180 4181
			return -EINVAL;
		}
		if (!arp_interval) {
J
Joe Perches 已提交
4182
			pr_err("arp_validate requires arp_interval\n");
4183 4184 4185 4186 4187 4188
			return -EINVAL;
		}

		arp_validate_value = bond_parse_parm(arp_validate,
						     arp_validate_tbl);
		if (arp_validate_value == -1) {
J
Joe Perches 已提交
4189
			pr_err("Error: invalid arp_validate \"%s\"\n",
4190 4191 4192 4193 4194 4195
			       arp_validate == NULL ? "NULL" : arp_validate);
			return -EINVAL;
		}
	} else
		arp_validate_value = 0;

4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207
	arp_all_targets_value = 0;
	if (arp_all_targets) {
		arp_all_targets_value = bond_parse_parm(arp_all_targets,
							arp_all_targets_tbl);

		if (arp_all_targets_value == -1) {
			pr_err("Error: invalid arp_all_targets_value \"%s\"\n",
			       arp_all_targets);
			arp_all_targets_value = 0;
		}
	}

L
Linus Torvalds 已提交
4208
	if (miimon) {
J
Joe Perches 已提交
4209
		pr_info("MII link monitoring set to %d ms\n", miimon);
L
Linus Torvalds 已提交
4210
	} else if (arp_interval) {
J
Joe Perches 已提交
4211 4212 4213 4214
		pr_info("ARP monitoring set to %d ms, validate %s, with %d target(s):",
			arp_interval,
			arp_validate_tbl[arp_validate_value].modename,
			arp_ip_count);
L
Linus Torvalds 已提交
4215 4216

		for (i = 0; i < arp_ip_count; i++)
J
Jiri Pirko 已提交
4217
			pr_info(" %s", arp_ip_target[i]);
L
Linus Torvalds 已提交
4218

J
Jiri Pirko 已提交
4219
		pr_info("\n");
L
Linus Torvalds 已提交
4220

4221
	} else if (max_bonds) {
L
Linus Torvalds 已提交
4222 4223 4224
		/* miimon and arp_interval not set, we need one so things
		 * work as expected, see bonding.txt for details
		 */
4225
		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 已提交
4226 4227 4228 4229 4230 4231
	}

	if (primary && !USES_PRIMARY(bond_mode)) {
		/* currently, using a primary only makes sense
		 * in active backup, TLB or ALB modes
		 */
J
Joe Perches 已提交
4232 4233
		pr_warning("Warning: %s primary device specified but has no effect in %s mode\n",
			   primary, bond_mode_name(bond_mode));
L
Linus Torvalds 已提交
4234 4235 4236
		primary = NULL;
	}

4237 4238 4239 4240
	if (primary && primary_reselect) {
		primary_reselect_value = bond_parse_parm(primary_reselect,
							 pri_reselect_tbl);
		if (primary_reselect_value == -1) {
J
Joe Perches 已提交
4241
			pr_err("Error: Invalid primary_reselect \"%s\"\n",
4242 4243 4244 4245 4246 4247 4248 4249
			       primary_reselect ==
					NULL ? "NULL" : primary_reselect);
			return -EINVAL;
		}
	} else {
		primary_reselect_value = BOND_PRI_RESELECT_ALWAYS;
	}

4250 4251 4252 4253
	if (fail_over_mac) {
		fail_over_mac_value = bond_parse_parm(fail_over_mac,
						      fail_over_mac_tbl);
		if (fail_over_mac_value == -1) {
J
Joe Perches 已提交
4254
			pr_err("Error: invalid fail_over_mac \"%s\"\n",
4255 4256 4257 4258 4259
			       arp_validate == NULL ? "NULL" : arp_validate);
			return -EINVAL;
		}

		if (bond_mode != BOND_MODE_ACTIVEBACKUP)
J
Joe Perches 已提交
4260
			pr_warning("Warning: fail_over_mac only affects active-backup mode.\n");
4261 4262 4263
	} else {
		fail_over_mac_value = BOND_FOM_NONE;
	}
4264

4265 4266 4267 4268 4269 4270
	if (lp_interval == 0) {
		pr_warning("Warning: ip_interval must be between 1 and %d, so it was reset to %d\n",
			   INT_MAX, BOND_ALB_DEFAULT_LP_INTERVAL);
		lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL;
	}

L
Linus Torvalds 已提交
4271 4272
	/* fill params struct with the proper values */
	params->mode = bond_mode;
4273
	params->xmit_policy = xmit_hashtype;
L
Linus Torvalds 已提交
4274
	params->miimon = miimon;
4275
	params->num_peer_notif = num_peer_notif;
L
Linus Torvalds 已提交
4276
	params->arp_interval = arp_interval;
4277
	params->arp_validate = arp_validate_value;
4278
	params->arp_all_targets = arp_all_targets_value;
L
Linus Torvalds 已提交
4279 4280 4281 4282 4283
	params->updelay = updelay;
	params->downdelay = downdelay;
	params->use_carrier = use_carrier;
	params->lacp_fast = lacp_fast;
	params->primary[0] = 0;
4284
	params->primary_reselect = primary_reselect_value;
4285
	params->fail_over_mac = fail_over_mac_value;
4286
	params->tx_queues = tx_queues;
4287
	params->all_slaves_active = all_slaves_active;
4288
	params->resend_igmp = resend_igmp;
4289
	params->min_links = min_links;
4290
	params->lp_interval = lp_interval;
4291 4292 4293 4294
	if (packets_per_slave > 1)
		params->packets_per_slave = reciprocal_value(packets_per_slave);
	else
		params->packets_per_slave = packets_per_slave;
L
Linus Torvalds 已提交
4295 4296 4297 4298 4299 4300 4301 4302 4303 4304
	if (primary) {
		strncpy(params->primary, primary, IFNAMSIZ);
		params->primary[IFNAMSIZ - 1] = 0;
	}

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

	return 0;
}

4305
static struct lock_class_key bonding_netdev_xmit_lock_key;
4306
static struct lock_class_key bonding_netdev_addr_lock_key;
4307
static struct lock_class_key bonding_tx_busylock_key;
4308

4309 4310 4311
static void bond_set_lockdep_class_one(struct net_device *dev,
				       struct netdev_queue *txq,
				       void *_unused)
4312 4313 4314 4315 4316 4317 4318
{
	lockdep_set_class(&txq->_xmit_lock,
			  &bonding_netdev_xmit_lock_key);
}

static void bond_set_lockdep_class(struct net_device *dev)
{
4319 4320
	lockdep_set_class(&dev->addr_list_lock,
			  &bonding_netdev_addr_lock_key);
4321
	netdev_for_each_tx_queue(dev, bond_set_lockdep_class_one, NULL);
4322
	dev->qdisc_tx_busylock = &bonding_tx_busylock_key;
4323 4324
}

4325 4326 4327 4328 4329 4330
/*
 * Called from registration process
 */
static int bond_init(struct net_device *bond_dev)
{
	struct bonding *bond = netdev_priv(bond_dev);
4331
	struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
4332
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
4333 4334 4335

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

4336 4337 4338 4339 4340 4341 4342 4343 4344
	/*
	 * 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));

4345 4346 4347 4348 4349 4350
	bond->wq = create_singlethread_workqueue(bond_dev->name);
	if (!bond->wq)
		return -ENOMEM;

	bond_set_lockdep_class(bond_dev);

4351
	list_add_tail(&bond->bond_list, &bn->dev_list);
4352

4353
	bond_prepare_sysfs_group(bond);
4354

4355 4356
	bond_debug_register(bond);

4357 4358
	/* Ensure valid dev_addr */
	if (is_zero_ether_addr(bond_dev->dev_addr) &&
4359
	    bond_dev->addr_assign_type == NET_ADDR_PERM)
4360 4361
		eth_hw_addr_random(bond_dev);

4362 4363 4364
	return 0;
}

4365
unsigned int bond_get_num_tx_queues(void)
4366
{
4367
	return tx_queues;
4368 4369
}

4370
/* Create a new bond based on the specified name and bonding parameters.
4371
 * If name is NULL, obtain a suitable "bond%d" name for us.
4372 4373 4374
 * Caller must NOT hold rtnl_lock; we need to release it here before we
 * set up our sysfs entries.
 */
4375
int bond_create(struct net *net, const char *name)
4376 4377 4378 4379 4380
{
	struct net_device *bond_dev;
	int res;

	rtnl_lock();
4381

4382 4383 4384
	bond_dev = alloc_netdev_mq(sizeof(struct bonding),
				   name ? name : "bond%d",
				   bond_setup, tx_queues);
4385
	if (!bond_dev) {
J
Joe Perches 已提交
4386
		pr_err("%s: eek! can't alloc netdev!\n", name);
4387 4388
		rtnl_unlock();
		return -ENOMEM;
4389 4390
	}

4391
	dev_net_set(bond_dev, net);
4392 4393
	bond_dev->rtnl_link_ops = &bond_link_ops;

4394
	res = register_netdevice(bond_dev);
4395

4396 4397
	netif_carrier_off(bond_dev);

4398
	rtnl_unlock();
4399 4400
	if (res < 0)
		bond_destructor(bond_dev);
E
Eric W. Biederman 已提交
4401
	return res;
4402 4403
}

4404
static int __net_init bond_net_init(struct net *net)
4405
{
4406
	struct bond_net *bn = net_generic(net, bond_net_id);
4407 4408 4409 4410 4411

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

	bond_create_proc_dir(bn);
4412
	bond_create_sysfs(bn);
4413

4414
	return 0;
4415 4416
}

4417
static void __net_exit bond_net_exit(struct net *net)
4418
{
4419
	struct bond_net *bn = net_generic(net, bond_net_id);
4420 4421
	struct bonding *bond, *tmp_bond;
	LIST_HEAD(list);
4422

4423
	bond_destroy_sysfs(bn);
4424
	bond_destroy_proc_dir(bn);
4425 4426 4427 4428 4429 4430 4431

	/* 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();
4432 4433 4434 4435 4436
}

static struct pernet_operations bond_net_ops = {
	.init = bond_net_init,
	.exit = bond_net_exit,
4437 4438
	.id   = &bond_net_id,
	.size = sizeof(struct bond_net),
4439 4440
};

L
Linus Torvalds 已提交
4441 4442 4443 4444 4445
static int __init bonding_init(void)
{
	int i;
	int res;

4446
	pr_info("%s", bond_version);
L
Linus Torvalds 已提交
4447

4448
	res = bond_check_params(&bonding_defaults);
S
Stephen Hemminger 已提交
4449
	if (res)
4450
		goto out;
L
Linus Torvalds 已提交
4451

4452
	res = register_pernet_subsys(&bond_net_ops);
4453 4454
	if (res)
		goto out;
4455

4456
	res = bond_netlink_init();
4457
	if (res)
4458
		goto err_link;
4459

4460 4461
	bond_create_debugfs();

L
Linus Torvalds 已提交
4462
	for (i = 0; i < max_bonds; i++) {
4463
		res = bond_create(&init_net, NULL);
4464 4465
		if (res)
			goto err;
L
Linus Torvalds 已提交
4466 4467 4468
	}

	register_netdevice_notifier(&bond_netdev_notifier);
4469
out:
L
Linus Torvalds 已提交
4470
	return res;
4471
err:
4472
	bond_netlink_fini();
4473
err_link:
4474
	unregister_pernet_subsys(&bond_net_ops);
4475
	goto out;
4476

L
Linus Torvalds 已提交
4477 4478 4479 4480 4481 4482
}

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

4483
	bond_destroy_debugfs();
4484

4485
	bond_netlink_fini();
4486
	unregister_pernet_subsys(&bond_net_ops);
4487 4488

#ifdef CONFIG_NET_POLL_CONTROLLER
4489 4490 4491 4492
	/*
	 * Make sure we don't have an imbalance on our netpoll blocking
	 */
	WARN_ON(atomic_read(&netpoll_block_tx));
4493
#endif
L
Linus Torvalds 已提交
4494 4495 4496 4497 4498 4499 4500 4501
}

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");