bond_main.c 132.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 58
#include <asm/system.h>
#include <asm/dma.h>
S
Stephen Hemminger 已提交
59
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
60 61 62
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
63
#include <linux/igmp.h>
L
Linus Torvalds 已提交
64 65 66 67 68 69 70 71 72 73 74 75 76
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <linux/rtnetlink.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.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 已提交
77
#include <linux/jiffies.h>
J
Jay Vosburgh 已提交
78
#include <net/route.h>
79
#include <net/net_namespace.h>
80
#include <net/netns/generic.h>
L
Linus Torvalds 已提交
81 82 83 84 85 86 87 88 89 90 91
#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;
92
static int num_grat_arp = 1;
93
static int num_unsol_na = 1;
L
Linus Torvalds 已提交
94
static int miimon	= BOND_LINK_MON_INTERV;
S
Stephen Hemminger 已提交
95 96
static int updelay;
static int downdelay;
L
Linus Torvalds 已提交
97
static int use_carrier	= 1;
S
Stephen Hemminger 已提交
98 99
static char *mode;
static char *primary;
100
static char *primary_reselect;
S
Stephen Hemminger 已提交
101 102 103
static char *lacp_rate;
static char *ad_select;
static char *xmit_hash_policy;
L
Linus Torvalds 已提交
104
static int arp_interval = BOND_LINK_ARP_INTERV;
S
Stephen Hemminger 已提交
105 106 107
static char *arp_ip_target[BOND_MAX_ARP_TARGETS];
static char *arp_validate;
static char *fail_over_mac;
108
static struct bond_params bonding_defaults;
L
Linus Torvalds 已提交
109 110 111

module_param(max_bonds, int, 0);
MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
112 113
module_param(num_grat_arp, int, 0644);
MODULE_PARM_DESC(num_grat_arp, "Number of gratuitous ARP packets to send on failover event");
114 115
module_param(num_unsol_na, int, 0644);
MODULE_PARM_DESC(num_unsol_na, "Number of unsolicited IPv6 Neighbor Advertisements packets to send on failover event");
L
Linus Torvalds 已提交
116 117 118 119 120
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);
121 122
MODULE_PARM_DESC(downdelay, "Delay before considering link down, "
			    "in milliseconds");
L
Linus Torvalds 已提交
123
module_param(use_carrier, int, 0);
124 125
MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; "
			      "0 for off, 1 for on (default)");
L
Linus Torvalds 已提交
126
module_param(mode, charp, 0);
127 128 129 130
MODULE_PARM_DESC(mode, "Mode of operation : 0 for balance-rr, "
		       "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 已提交
131 132
module_param(primary, charp, 0);
MODULE_PARM_DESC(primary, "Primary network device to use");
133 134 135 136 137 138 139 140
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 已提交
141
module_param(lacp_rate, charp, 0);
142 143
MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner "
			    "(slow/fast)");
144 145
module_param(ad_select, charp, 0);
MODULE_PARM_DESC(ad_select, "803.ad aggregation selection logic: stable (0, default), bandwidth (1), count (2)");
146
module_param(xmit_hash_policy, charp, 0);
147 148
MODULE_PARM_DESC(xmit_hash_policy, "XOR hashing method: 0 for layer 2 (default)"
				   ", 1 for layer 3+4");
L
Linus Torvalds 已提交
149 150 151 152
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");
153 154
module_param(arp_validate, charp, 0);
MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes: none (default), active, backup or all");
155 156
module_param(fail_over_mac, charp, 0);
MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to the same MAC.  none (default), active or follow");
L
Linus Torvalds 已提交
157 158 159

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

160
static const char * const version =
L
Linus Torvalds 已提交
161 162
	DRV_DESCRIPTION ": v" DRV_VERSION " (" DRV_RELDATE ")\n";

163
int bond_net_id __read_mostly;
L
Linus Torvalds 已提交
164

S
Stephen Hemminger 已提交
165 166
static __be32 arp_target[BOND_MAX_ARP_TARGETS];
static int arp_ip_count;
L
Linus Torvalds 已提交
167
static int bond_mode	= BOND_MODE_ROUNDROBIN;
S
Stephen Hemminger 已提交
168 169
static int xmit_hashtype = BOND_XMIT_POLICY_LAYER2;
static int lacp_fast;
170

L
Linus Torvalds 已提交
171

172
const struct bond_parm_tbl bond_lacp_tbl[] = {
L
Linus Torvalds 已提交
173 174 175 176 177
{	"slow",		AD_LACP_SLOW},
{	"fast",		AD_LACP_FAST},
{	NULL,		-1},
};

178
const struct bond_parm_tbl bond_mode_tbl[] = {
L
Linus Torvalds 已提交
179 180 181 182 183 184 185 186 187 188
{	"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},
};

189
const struct bond_parm_tbl xmit_hashtype_tbl[] = {
190 191
{	"layer2",		BOND_XMIT_POLICY_LAYER2},
{	"layer3+4",		BOND_XMIT_POLICY_LAYER34},
192
{	"layer2+3",		BOND_XMIT_POLICY_LAYER23},
193 194 195
{	NULL,			-1},
};

196
const struct bond_parm_tbl arp_validate_tbl[] = {
197 198 199 200 201 202 203
{	"none",			BOND_ARP_VALIDATE_NONE},
{	"active",		BOND_ARP_VALIDATE_ACTIVE},
{	"backup",		BOND_ARP_VALIDATE_BACKUP},
{	"all",			BOND_ARP_VALIDATE_ALL},
{	NULL,			-1},
};

204
const struct bond_parm_tbl fail_over_mac_tbl[] = {
205 206 207 208 209 210
{	"none",			BOND_FOM_NONE},
{	"active",		BOND_FOM_ACTIVE},
{	"follow",		BOND_FOM_FOLLOW},
{	NULL,			-1},
};

211 212 213 214 215 216 217
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},
};

218 219 220 221 222 223 224
struct bond_parm_tbl ad_select_tbl[] = {
{	"stable",	BOND_AD_STABLE},
{	"bandwidth",	BOND_AD_BANDWIDTH},
{	"count",	BOND_AD_COUNT},
{	NULL,		-1},
};

L
Linus Torvalds 已提交
225 226
/*-------------------------- Forward declarations ---------------------------*/

J
Jay Vosburgh 已提交
227
static void bond_send_gratuitous_arp(struct bonding *bond);
228
static int bond_init(struct net_device *bond_dev);
229
static void bond_uninit(struct net_device *bond_dev);
L
Linus Torvalds 已提交
230 231 232

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

233
static const char *bond_mode_name(int mode)
L
Linus Torvalds 已提交
234
{
235 236 237 238 239
	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 已提交
240
		[BOND_MODE_8023AD] = "IEEE 802.3ad Dynamic link aggregation",
241 242 243 244 245
		[BOND_MODE_TLB] = "transmit load balancing",
		[BOND_MODE_ALB] = "adaptive load balancing",
	};

	if (mode < 0 || mode > BOND_MODE_ALB)
L
Linus Torvalds 已提交
246
		return "unknown";
247 248

	return names[mode];
L
Linus Torvalds 已提交
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
}

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

/**
 * bond_add_vlan - add a new vlan id on bond
 * @bond: bond that got the notification
 * @vlan_id: the vlan id to add
 *
 * Returns -ENOMEM if allocation failed.
 */
static int bond_add_vlan(struct bonding *bond, unsigned short vlan_id)
{
	struct vlan_entry *vlan;

264
	pr_debug("bond: %s, vlan id %d\n",
J
Joe Perches 已提交
265
		 (bond ? bond->dev->name : "None"), vlan_id);
L
Linus Torvalds 已提交
266

267
	vlan = kzalloc(sizeof(struct vlan_entry), GFP_KERNEL);
S
Stephen Hemminger 已提交
268
	if (!vlan)
L
Linus Torvalds 已提交
269 270 271 272 273 274 275 276 277 278 279
		return -ENOMEM;

	INIT_LIST_HEAD(&vlan->vlan_list);
	vlan->vlan_id = vlan_id;

	write_lock_bh(&bond->lock);

	list_add_tail(&vlan->vlan_list, &bond->vlan_list);

	write_unlock_bh(&bond->lock);

280
	pr_debug("added VLAN ID %d on bond %s\n", vlan_id, bond->dev->name);
L
Linus Torvalds 已提交
281 282 283 284 285 286 287 288 289 290 291 292 293

	return 0;
}

/**
 * bond_del_vlan - delete a vlan id from bond
 * @bond: bond that got the notification
 * @vlan_id: the vlan id to delete
 *
 * returns -ENODEV if @vlan_id was not found in @bond.
 */
static int bond_del_vlan(struct bonding *bond, unsigned short vlan_id)
{
294
	struct vlan_entry *vlan;
L
Linus Torvalds 已提交
295 296
	int res = -ENODEV;

297
	pr_debug("bond: %s, vlan id %d\n", bond->dev->name, vlan_id);
L
Linus Torvalds 已提交
298 299 300

	write_lock_bh(&bond->lock);

301
	list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
L
Linus Torvalds 已提交
302 303 304
		if (vlan->vlan_id == vlan_id) {
			list_del(&vlan->vlan_list);

305
			if (bond_is_lb(bond))
L
Linus Torvalds 已提交
306 307
				bond_alb_clear_vlan(bond, vlan_id);

J
Joe Perches 已提交
308 309
			pr_debug("removed VLAN ID %d from bond %s\n",
				 vlan_id, bond->dev->name);
L
Linus Torvalds 已提交
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327

			kfree(vlan);

			if (list_empty(&bond->vlan_list) &&
			    (bond->slave_cnt == 0)) {
				/* Last VLAN removed and no slaves, so
				 * restore block on adding VLANs. This will
				 * be removed once new slaves that are not
				 * VLAN challenged will be added.
				 */
				bond->dev->features |= NETIF_F_VLAN_CHALLENGED;
			}

			res = 0;
			goto out;
		}
	}

J
Joe Perches 已提交
328 329
	pr_debug("couldn't find VLAN ID %d in bond %s\n",
		 vlan_id, bond->dev->name);
L
Linus Torvalds 已提交
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351

out:
	write_unlock_bh(&bond->lock);
	return res;
}

/**
 * bond_has_challenged_slaves
 * @bond: the bond we're working on
 *
 * Searches the slave list. Returns 1 if a vlan challenged slave
 * was found, 0 otherwise.
 *
 * Assumes bond->lock is held.
 */
static int bond_has_challenged_slaves(struct bonding *bond)
{
	struct slave *slave;
	int i;

	bond_for_each_slave(bond, slave, i) {
		if (slave->dev->features & NETIF_F_VLAN_CHALLENGED) {
352
			pr_debug("found VLAN challenged slave - %s\n",
J
Joe Perches 已提交
353
				 slave->dev->name);
L
Linus Torvalds 已提交
354 355 356 357
			return 1;
		}
	}

358
	pr_debug("no VLAN challenged slaves found\n");
L
Linus Torvalds 已提交
359 360 361 362 363 364 365 366 367 368
	return 0;
}

/**
 * bond_next_vlan - safely skip to the next item in the vlans list.
 * @bond: the bond we're working on
 * @curr: item we're advancing from
 *
 * Returns %NULL if list is empty, bond->next_vlan if @curr is %NULL,
 * or @curr->next otherwise (even if it is @curr itself again).
S
Stephen Hemminger 已提交
369
 *
L
Linus Torvalds 已提交
370 371 372 373 374 375
 * Caller must hold bond->lock
 */
struct vlan_entry *bond_next_vlan(struct bonding *bond, struct vlan_entry *curr)
{
	struct vlan_entry *next, *last;

S
Stephen Hemminger 已提交
376
	if (list_empty(&bond->vlan_list))
L
Linus Torvalds 已提交
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
		return NULL;

	if (!curr) {
		next = list_entry(bond->vlan_list.next,
				  struct vlan_entry, vlan_list);
	} else {
		last = list_entry(bond->vlan_list.prev,
				  struct vlan_entry, vlan_list);
		if (last == curr) {
			next = list_entry(bond->vlan_list.next,
					  struct vlan_entry, vlan_list);
		} else {
			next = list_entry(curr->vlan_list.next,
					  struct vlan_entry, vlan_list);
		}
	}

	return next;
}

/**
 * bond_dev_queue_xmit - Prepare skb for xmit.
S
Stephen Hemminger 已提交
399
 *
L
Linus Torvalds 已提交
400 401 402
 * @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 已提交
403
 *
L
Linus Torvalds 已提交
404 405 406 407 408 409 410
 * When the bond gets an skb to transmit that is
 * already hardware accelerated VLAN tagged, and it
 * needs to relay this skb to a slave that is not
 * hw accel capable, the skb needs to be "unaccelerated",
 * i.e. strip the hwaccel tag and re-insert it as part
 * of the payload.
 */
S
Stephen Hemminger 已提交
411 412
int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb,
			struct net_device *slave_dev)
L
Linus Torvalds 已提交
413
{
414
	unsigned short uninitialized_var(vlan_id);
L
Linus Torvalds 已提交
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445

	if (!list_empty(&bond->vlan_list) &&
	    !(slave_dev->features & NETIF_F_HW_VLAN_TX) &&
	    vlan_get_tag(skb, &vlan_id) == 0) {
		skb->dev = slave_dev;
		skb = vlan_put_tag(skb, vlan_id);
		if (!skb) {
			/* vlan_put_tag() frees the skb in case of error,
			 * so return success here so the calling functions
			 * won't attempt to free is again.
			 */
			return 0;
		}
	} else {
		skb->dev = slave_dev;
	}

	skb->priority = 1;
	dev_queue_xmit(skb);

	return 0;
}

/*
 * In the following 3 functions, bond_vlan_rx_register(), bond_vlan_rx_add_vid
 * and bond_vlan_rx_kill_vid, We don't protect the slave list iteration with a
 * lock because:
 * 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 已提交
446
 *
L
Linus Torvalds 已提交
447 448 449 450 451 452 453 454 455 456 457 458 459 460
 * 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_register - Propagates registration to slaves
 * @bond_dev: bonding net device that got called
 * @grp: vlan group being registered
 */
S
Stephen Hemminger 已提交
461 462
static void bond_vlan_rx_register(struct net_device *bond_dev,
				  struct vlan_group *grp)
L
Linus Torvalds 已提交
463
{
464
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
465 466 467 468 469 470 471
	struct slave *slave;
	int i;

	bond->vlgrp = grp;

	bond_for_each_slave(bond, slave, i) {
		struct net_device *slave_dev = slave->dev;
472
		const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
L
Linus Torvalds 已提交
473 474

		if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
475 476
		    slave_ops->ndo_vlan_rx_register) {
			slave_ops->ndo_vlan_rx_register(slave_dev, grp);
L
Linus Torvalds 已提交
477 478 479 480 481 482 483 484 485 486 487
		}
	}
}

/**
 * bond_vlan_rx_add_vid - Propagates adding an id to slaves
 * @bond_dev: bonding net device that got called
 * @vid: vlan id being added
 */
static void bond_vlan_rx_add_vid(struct net_device *bond_dev, uint16_t vid)
{
488
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
489 490 491 492 493
	struct slave *slave;
	int i, res;

	bond_for_each_slave(bond, slave, i) {
		struct net_device *slave_dev = slave->dev;
494
		const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
L
Linus Torvalds 已提交
495 496

		if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) &&
497 498
		    slave_ops->ndo_vlan_rx_add_vid) {
			slave_ops->ndo_vlan_rx_add_vid(slave_dev, vid);
L
Linus Torvalds 已提交
499 500 501 502 503
		}
	}

	res = bond_add_vlan(bond, vid);
	if (res) {
J
Joe Perches 已提交
504
		pr_err("%s: Error: Failed to add vlan id %d\n",
L
Linus Torvalds 已提交
505 506 507 508 509 510 511 512 513 514 515
		       bond_dev->name, vid);
	}
}

/**
 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
 * @bond_dev: bonding net device that got called
 * @vid: vlan id being removed
 */
static void bond_vlan_rx_kill_vid(struct net_device *bond_dev, uint16_t vid)
{
516
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
517 518 519 520 521 522
	struct slave *slave;
	struct net_device *vlan_dev;
	int i, res;

	bond_for_each_slave(bond, slave, i) {
		struct net_device *slave_dev = slave->dev;
523
		const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
L
Linus Torvalds 已提交
524 525

		if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) &&
526
		    slave_ops->ndo_vlan_rx_kill_vid) {
L
Linus Torvalds 已提交
527 528 529
			/* Save and then restore vlan_dev in the grp array,
			 * since the slave's driver might clear it.
			 */
D
Dan Aloni 已提交
530
			vlan_dev = vlan_group_get_device(bond->vlgrp, vid);
531
			slave_ops->ndo_vlan_rx_kill_vid(slave_dev, vid);
D
Dan Aloni 已提交
532
			vlan_group_set_device(bond->vlgrp, vid, vlan_dev);
L
Linus Torvalds 已提交
533 534 535 536 537
		}
	}

	res = bond_del_vlan(bond, vid);
	if (res) {
J
Joe Perches 已提交
538
		pr_err("%s: Error: Failed to remove vlan id %d\n",
L
Linus Torvalds 已提交
539 540 541 542 543 544 545
		       bond_dev->name, vid);
	}
}

static void bond_add_vlans_on_slave(struct bonding *bond, struct net_device *slave_dev)
{
	struct vlan_entry *vlan;
546
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
L
Linus Torvalds 已提交
547 548 549

	write_lock_bh(&bond->lock);

550
	if (list_empty(&bond->vlan_list))
L
Linus Torvalds 已提交
551 552 553
		goto out;

	if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
554 555
	    slave_ops->ndo_vlan_rx_register)
		slave_ops->ndo_vlan_rx_register(slave_dev, bond->vlgrp);
L
Linus Torvalds 已提交
556 557

	if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) ||
558
	    !(slave_ops->ndo_vlan_rx_add_vid))
L
Linus Torvalds 已提交
559 560
		goto out;

561 562
	list_for_each_entry(vlan, &bond->vlan_list, vlan_list)
		slave_ops->ndo_vlan_rx_add_vid(slave_dev, vlan->vlan_id);
L
Linus Torvalds 已提交
563 564 565 566 567

out:
	write_unlock_bh(&bond->lock);
}

S
Stephen Hemminger 已提交
568 569
static void bond_del_vlans_from_slave(struct bonding *bond,
				      struct net_device *slave_dev)
L
Linus Torvalds 已提交
570
{
571
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
L
Linus Torvalds 已提交
572 573 574 575 576
	struct vlan_entry *vlan;
	struct net_device *vlan_dev;

	write_lock_bh(&bond->lock);

577
	if (list_empty(&bond->vlan_list))
L
Linus Torvalds 已提交
578 579 580
		goto out;

	if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) ||
581
	    !(slave_ops->ndo_vlan_rx_kill_vid))
L
Linus Torvalds 已提交
582 583 584 585 586 587
		goto unreg;

	list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
		/* Save and then restore vlan_dev in the grp array,
		 * since the slave's driver might clear it.
		 */
D
Dan Aloni 已提交
588
		vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
589
		slave_ops->ndo_vlan_rx_kill_vid(slave_dev, vlan->vlan_id);
D
Dan Aloni 已提交
590
		vlan_group_set_device(bond->vlgrp, vlan->vlan_id, vlan_dev);
L
Linus Torvalds 已提交
591 592 593 594
	}

unreg:
	if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
595 596
	    slave_ops->ndo_vlan_rx_register)
		slave_ops->ndo_vlan_rx_register(slave_dev, NULL);
L
Linus Torvalds 已提交
597 598 599 600 601 602 603

out:
	write_unlock_bh(&bond->lock);
}

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

604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
/*
 * 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)
{
	struct slave *slave;
	int i;

	if (bond->slave_cnt == 0)
		goto down;

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

	bond_for_each_slave(bond, slave, i) {
		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 已提交
640 641 642 643 644 645 646 647 648 649
/*
 * Get link speed and duplex from the slave's base driver
 * using ethtool. If for some reason the call fails or the
 * values are invalid, fake speed and duplex to 100/Full
 * and return error.
 */
static int bond_update_speed_duplex(struct slave *slave)
{
	struct net_device *slave_dev = slave->dev;
	struct ethtool_cmd etool;
650
	int res;
L
Linus Torvalds 已提交
651 652 653 654 655

	/* Fake speed and duplex */
	slave->speed = SPEED_100;
	slave->duplex = DUPLEX_FULL;

656 657
	if (!slave_dev->ethtool_ops || !slave_dev->ethtool_ops->get_settings)
		return -1;
L
Linus Torvalds 已提交
658

659 660
	res = slave_dev->ethtool_ops->get_settings(slave_dev, &etool);
	if (res < 0)
L
Linus Torvalds 已提交
661 662 663 664 665 666
		return -1;

	switch (etool.speed) {
	case SPEED_10:
	case SPEED_100:
	case SPEED_1000:
667
	case SPEED_10000:
L
Linus Torvalds 已提交
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
		break;
	default:
		return -1;
	}

	switch (etool.duplex) {
	case DUPLEX_FULL:
	case DUPLEX_HALF:
		break;
	default:
		return -1;
	}

	slave->speed = etool.speed;
	slave->duplex = etool.duplex;

	return 0;
}

/*
 * 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 已提交
691
 * depending upon the setting of the use_carrier parameter.
L
Linus Torvalds 已提交
692 693 694 695 696 697 698 699 700 701 702
 *
 * 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 已提交
703 704
static int bond_check_dev_link(struct bonding *bond,
			       struct net_device *slave_dev, int reporting)
L
Linus Torvalds 已提交
705
{
706
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
707
	int (*ioctl)(struct net_device *, struct ifreq *, int);
L
Linus Torvalds 已提交
708 709 710
	struct ifreq ifr;
	struct mii_ioctl_data *mii;

711 712 713
	if (!reporting && !netif_running(slave_dev))
		return 0;

714
	if (bond->params.use_carrier)
L
Linus Torvalds 已提交
715 716
		return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;

717 718 719 720 721 722 723 724 725 726 727
	/* Try to get link status using Ethtool first. */
	if (slave_dev->ethtool_ops) {
		if (slave_dev->ethtool_ops->get_link) {
			u32 link;

			link = slave_dev->ethtool_ops->get_link(slave_dev);

			return link ? BMSR_LSTATUS : 0;
		}
	}

S
Stephen Hemminger 已提交
728
	/* Ethtool can't be used, fallback to MII ioctls. */
729
	ioctl = slave_ops->ndo_do_ioctl;
L
Linus Torvalds 已提交
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	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 已提交
748 749
			if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0)
				return mii->val_out & BMSR_LSTATUS;
L
Linus Torvalds 已提交
750 751 752 753 754
		}
	}

	/*
	 * If reporting, report that either there's no dev->do_ioctl,
755
	 * or both SIOCGMIIREG and get_link failed (meaning that we
L
Linus Torvalds 已提交
756 757 758
	 * cannot report link status).  If not reporting, pretend
	 * we're ok.
	 */
S
Stephen Hemminger 已提交
759
	return reporting ? -1 : BMSR_LSTATUS;
L
Linus Torvalds 已提交
760 761 762 763 764 765 766
}

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

/*
 * Returns 0 if dmi1 and dmi2 are the same, non-0 otherwise
 */
S
Stephen Hemminger 已提交
767 768
static inline int bond_is_dmi_same(const struct dev_mc_list *dmi1,
				   const struct dev_mc_list *dmi2)
L
Linus Torvalds 已提交
769 770 771 772 773 774 775 776
{
	return memcmp(dmi1->dmi_addr, dmi2->dmi_addr, dmi1->dmi_addrlen) == 0 &&
			dmi1->dmi_addrlen == dmi2->dmi_addrlen;
}

/*
 * returns dmi entry if found, NULL otherwise
 */
S
Stephen Hemminger 已提交
777 778
static struct dev_mc_list *bond_mc_list_find_dmi(struct dev_mc_list *dmi,
						 struct dev_mc_list *mc_list)
L
Linus Torvalds 已提交
779 780 781 782
{
	struct dev_mc_list *idmi;

	for (idmi = mc_list; idmi; idmi = idmi->next) {
S
Stephen Hemminger 已提交
783
		if (bond_is_dmi_same(dmi, idmi))
L
Linus Torvalds 已提交
784 785 786 787 788 789 790 791 792
			return idmi;
	}

	return NULL;
}

/*
 * Push the promiscuity flag down to appropriate slaves
 */
793
static int bond_set_promiscuity(struct bonding *bond, int inc)
L
Linus Torvalds 已提交
794
{
795
	int err = 0;
L
Linus Torvalds 已提交
796 797 798
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
		if (bond->curr_active_slave) {
799 800
			err = dev_set_promiscuity(bond->curr_active_slave->dev,
						  inc);
L
Linus Torvalds 已提交
801 802 803 804 805
		}
	} else {
		struct slave *slave;
		int i;
		bond_for_each_slave(bond, slave, i) {
806 807 808
			err = dev_set_promiscuity(slave->dev, inc);
			if (err)
				return err;
L
Linus Torvalds 已提交
809 810
		}
	}
811
	return err;
L
Linus Torvalds 已提交
812 813 814 815 816
}

/*
 * Push the allmulti flag down to all slaves
 */
817
static int bond_set_allmulti(struct bonding *bond, int inc)
L
Linus Torvalds 已提交
818
{
819
	int err = 0;
L
Linus Torvalds 已提交
820 821 822
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
		if (bond->curr_active_slave) {
823 824
			err = dev_set_allmulti(bond->curr_active_slave->dev,
					       inc);
L
Linus Torvalds 已提交
825 826 827 828 829
		}
	} else {
		struct slave *slave;
		int i;
		bond_for_each_slave(bond, slave, i) {
830 831 832
			err = dev_set_allmulti(slave->dev, inc);
			if (err)
				return err;
L
Linus Torvalds 已提交
833 834
		}
	}
835
	return err;
L
Linus Torvalds 已提交
836 837 838 839 840 841 842 843 844 845
}

/*
 * Add a Multicast address to slaves
 * according to mode
 */
static void bond_mc_add(struct bonding *bond, void *addr, int alen)
{
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
S
Stephen Hemminger 已提交
846
		if (bond->curr_active_slave)
L
Linus Torvalds 已提交
847 848 849 850
			dev_mc_add(bond->curr_active_slave->dev, addr, alen, 0);
	} else {
		struct slave *slave;
		int i;
S
Stephen Hemminger 已提交
851 852

		bond_for_each_slave(bond, slave, i)
L
Linus Torvalds 已提交
853 854 855 856 857 858 859 860 861 862 863 864
			dev_mc_add(slave->dev, addr, alen, 0);
	}
}

/*
 * Remove a multicast address from slave
 * according to mode
 */
static void bond_mc_delete(struct bonding *bond, void *addr, int alen)
{
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
S
Stephen Hemminger 已提交
865 866 867
		if (bond->curr_active_slave)
			dev_mc_delete(bond->curr_active_slave->dev, addr,
				      alen, 0);
L
Linus Torvalds 已提交
868 869 870 871 872 873 874 875 876
	} else {
		struct slave *slave;
		int i;
		bond_for_each_slave(bond, slave, i) {
			dev_mc_delete(slave->dev, addr, alen, 0);
		}
	}
}

877 878 879 880 881 882 883 884 885 886 887 888 889 890

/*
 * Retrieve the list of registered multicast addresses for the bonding
 * device and retransmit an IGMP JOIN request to the current active
 * slave.
 */
static void bond_resend_igmp_join_requests(struct bonding *bond)
{
	struct in_device *in_dev;
	struct ip_mc_list *im;

	rcu_read_lock();
	in_dev = __in_dev_get_rcu(bond->dev);
	if (in_dev) {
S
Stephen Hemminger 已提交
891
		for (im = in_dev->mc_list; im; im = im->next)
892 893 894 895 896 897
			ip_mc_rejoin_group(im);
	}

	rcu_read_unlock();
}

L
Linus Torvalds 已提交
898 899 900 901 902 903 904 905 906 907 908 909 910
/*
 * Totally destroys the mc_list in bond
 */
static void bond_mc_list_destroy(struct bonding *bond)
{
	struct dev_mc_list *dmi;

	dmi = bond->mc_list;
	while (dmi) {
		bond->mc_list = dmi->next;
		kfree(dmi);
		dmi = bond->mc_list;
	}
S
Stephen Hemminger 已提交
911 912

	bond->mc_list = NULL;
L
Linus Torvalds 已提交
913 914 915 916 917
}

/*
 * Copy all the Multicast addresses from src to the bonding device dst
 */
918
static int bond_mc_list_copy(struct dev_mc_list *mc_list, struct bonding *bond,
A
Al Viro 已提交
919
			     gfp_t gfp_flag)
L
Linus Torvalds 已提交
920 921 922 923
{
	struct dev_mc_list *dmi, *new_dmi;

	for (dmi = mc_list; dmi; dmi = dmi->next) {
924
		new_dmi = kmalloc(sizeof(struct dev_mc_list), gfp_flag);
L
Linus Torvalds 已提交
925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944

		if (!new_dmi) {
			/* FIXME: Potential memory leak !!! */
			return -ENOMEM;
		}

		new_dmi->next = bond->mc_list;
		bond->mc_list = new_dmi;
		new_dmi->dmi_addrlen = dmi->dmi_addrlen;
		memcpy(new_dmi->dmi_addr, dmi->dmi_addr, dmi->dmi_addrlen);
		new_dmi->dmi_users = dmi->dmi_users;
		new_dmi->dmi_gusers = dmi->dmi_gusers;
	}

	return 0;
}

/*
 * flush all members of flush->mc_list from device dev->mc_list
 */
S
Stephen Hemminger 已提交
945 946
static void bond_mc_list_flush(struct net_device *bond_dev,
			       struct net_device *slave_dev)
L
Linus Torvalds 已提交
947
{
948
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
949 950
	struct dev_mc_list *dmi;

S
Stephen Hemminger 已提交
951
	for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next)
L
Linus Torvalds 已提交
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
		dev_mc_delete(slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);

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

		dev_mc_delete(slave_dev, lacpdu_multicast, ETH_ALEN, 0);
	}
}

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

/*
 * Update the mc list and multicast-related flags for the new and
 * old active slaves (if any) according to the multicast mode, and
 * promiscuous flags unconditionally.
 */
S
Stephen Hemminger 已提交
969 970
static void bond_mc_swap(struct bonding *bond, struct slave *new_active,
			 struct slave *old_active)
L
Linus Torvalds 已提交
971 972 973
{
	struct dev_mc_list *dmi;

S
Stephen Hemminger 已提交
974
	if (!USES_PRIMARY(bond->params.mode))
L
Linus Torvalds 已提交
975 976 977 978 979 980
		/* nothing to do -  mc list is already up-to-date on
		 * all slaves
		 */
		return;

	if (old_active) {
S
Stephen Hemminger 已提交
981
		if (bond->dev->flags & IFF_PROMISC)
L
Linus Torvalds 已提交
982 983
			dev_set_promiscuity(old_active->dev, -1);

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

S
Stephen Hemminger 已提交
987 988 989
		for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next)
			dev_mc_delete(old_active->dev, dmi->dmi_addr,
				      dmi->dmi_addrlen, 0);
L
Linus Torvalds 已提交
990 991 992
	}

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

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

S
Stephen Hemminger 已提交
1000 1001 1002
		for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next)
			dev_mc_add(new_active->dev, dmi->dmi_addr,
				   dmi->dmi_addrlen, 0);
1003
		bond_resend_igmp_join_requests(bond);
L
Linus Torvalds 已提交
1004 1005 1006
	}
}

1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
/*
 * bond_do_fail_over_mac
 *
 * Perform special MAC address swapping for fail_over_mac settings
 *
 * Called with RTNL, bond->lock for read, curr_slave_lock for write_bh.
 */
static void bond_do_fail_over_mac(struct bonding *bond,
				  struct slave *new_active,
				  struct slave *old_active)
1017 1018 1019 1020
	__releases(&bond->curr_slave_lock)
	__releases(&bond->lock)
	__acquires(&bond->lock)
	__acquires(&bond->curr_slave_lock)
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
{
	u8 tmp_mac[ETH_ALEN];
	struct sockaddr saddr;
	int rv;

	switch (bond->params.fail_over_mac) {
	case BOND_FOM_ACTIVE:
		if (new_active)
			memcpy(bond->dev->dev_addr,  new_active->dev->dev_addr,
			       new_active->dev->addr_len);
		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);
		read_unlock(&bond->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 已提交
1056
			pr_err("%s: Error %d setting MAC of slave %s\n",
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
			       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 已提交
1069
			pr_err("%s: Error %d setting MAC of slave %s\n",
1070 1071 1072 1073 1074 1075
			       bond->dev->name, -rv, new_active->dev->name);
out:
		read_lock(&bond->lock);
		write_lock_bh(&bond->curr_slave_lock);
		break;
	default:
J
Joe Perches 已提交
1076
		pr_err("%s: bond_do_fail_over_mac impossible: bad policy %d\n",
1077 1078 1079 1080 1081 1082
		       bond->dev->name, bond->params.fail_over_mac);
		break;
	}

}

1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
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;
}
1102

L
Linus Torvalds 已提交
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
/**
 * find_best_interface - select the best available slave to be the active one
 * @bond: our bonding struct
 *
 * Warning: Caller must hold curr_slave_lock for writing.
 */
static struct slave *bond_find_best_slave(struct bonding *bond)
{
	struct slave *new_active, *old_active;
	struct slave *bestslave = NULL;
	int mintime = bond->params.updelay;
	int i;

1116
	new_active = bond->curr_active_slave;
L
Linus Torvalds 已提交
1117 1118

	if (!new_active) { /* there were no active slaves left */
S
Stephen Hemminger 已提交
1119
		if (bond->slave_cnt > 0)   /* found one slave */
L
Linus Torvalds 已提交
1120
			new_active = bond->first_slave;
S
Stephen Hemminger 已提交
1121
		else
L
Linus Torvalds 已提交
1122 1123 1124 1125
			return NULL; /* still no slave, return NULL */
	}

	if ((bond->primary_slave) &&
1126 1127
	    bond->primary_slave->link == BOND_LINK_UP &&
	    bond_should_change_active(bond)) {
L
Linus Torvalds 已提交
1128 1129 1130 1131 1132 1133 1134
		new_active = bond->primary_slave;
	}

	/* remember where to stop iterating over the slaves */
	old_active = new_active;

	bond_for_each_slave_from(bond, new_active, i, old_active) {
1135 1136 1137 1138 1139 1140 1141 1142
		if (new_active->link == BOND_LINK_UP) {
			return new_active;
		} else if (new_active->link == BOND_LINK_BACK &&
			   IS_UP(new_active->dev)) {
			/* link up, but waiting for stabilization */
			if (new_active->delay < mintime) {
				mintime = new_active->delay;
				bestslave = new_active;
L
Linus Torvalds 已提交
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
			}
		}
	}

	return bestslave;
}

/**
 * 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.
 *
1163 1164
 * If new_active is not NULL, caller must hold bond->lock for read and
 * curr_slave_lock for write_bh.
L
Linus Torvalds 已提交
1165
 */
1166
void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
L
Linus Torvalds 已提交
1167 1168 1169
{
	struct slave *old_active = bond->curr_active_slave;

S
Stephen Hemminger 已提交
1170
	if (old_active == new_active)
L
Linus Torvalds 已提交
1171 1172 1173
		return;

	if (new_active) {
1174 1175
		new_active->jiffies = jiffies;

L
Linus Torvalds 已提交
1176 1177
		if (new_active->link == BOND_LINK_BACK) {
			if (USES_PRIMARY(bond->params.mode)) {
J
Joe Perches 已提交
1178 1179 1180
				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 已提交
1181 1182 1183 1184 1185
			}

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

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

1189
			if (bond_is_lb(bond))
L
Linus Torvalds 已提交
1190 1191 1192
				bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
		} else {
			if (USES_PRIMARY(bond->params.mode)) {
J
Joe Perches 已提交
1193 1194
				pr_info("%s: making interface %s the new active one.\n",
					bond->dev->name, new_active->dev->name);
L
Linus Torvalds 已提交
1195 1196 1197 1198
			}
		}
	}

S
Stephen Hemminger 已提交
1199
	if (USES_PRIMARY(bond->params.mode))
L
Linus Torvalds 已提交
1200 1201
		bond_mc_swap(bond, new_active, old_active);

1202
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
1203
		bond_alb_handle_active_change(bond, new_active);
1204 1205 1206 1207
		if (old_active)
			bond_set_slave_inactive_flags(old_active);
		if (new_active)
			bond_set_slave_active_flags(new_active);
L
Linus Torvalds 已提交
1208 1209 1210
	} else {
		bond->curr_active_slave = new_active;
	}
J
Jay Vosburgh 已提交
1211 1212

	if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
S
Stephen Hemminger 已提交
1213
		if (old_active)
J
Jay Vosburgh 已提交
1214 1215 1216 1217
			bond_set_slave_inactive_flags(old_active);

		if (new_active) {
			bond_set_slave_active_flags(new_active);
1218

1219 1220 1221
			if (bond->params.fail_over_mac)
				bond_do_fail_over_mac(bond, new_active,
						      old_active);
1222

1223
			bond->send_grat_arp = bond->params.num_grat_arp;
1224
			bond_send_gratuitous_arp(bond);
1225

1226 1227 1228
			bond->send_unsol_na = bond->params.num_unsol_na;
			bond_send_unsolicited_na(bond);

1229 1230 1231
			write_unlock_bh(&bond->curr_slave_lock);
			read_unlock(&bond->lock);

1232
			netdev_bonding_change(bond->dev, NETDEV_BONDING_FAILOVER);
1233 1234 1235

			read_lock(&bond->lock);
			write_lock_bh(&bond->curr_slave_lock);
1236
		}
J
Jay Vosburgh 已提交
1237
	}
L
Linus Torvalds 已提交
1238 1239 1240 1241 1242 1243
}

/**
 * bond_select_active_slave - select a new active slave, if needed
 * @bond: our bonding struct
 *
S
Stephen Hemminger 已提交
1244
 * This functions should be called when one of the following occurs:
L
Linus Torvalds 已提交
1245 1246 1247 1248
 * - 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.
 *
1249
 * Caller must hold bond->lock for read and curr_slave_lock for write_bh.
L
Linus Torvalds 已提交
1250
 */
1251
void bond_select_active_slave(struct bonding *bond)
L
Linus Torvalds 已提交
1252 1253
{
	struct slave *best_slave;
1254
	int rv;
L
Linus Torvalds 已提交
1255 1256 1257 1258

	best_slave = bond_find_best_slave(bond);
	if (best_slave != bond->curr_active_slave) {
		bond_change_active_slave(bond, best_slave);
1259 1260 1261 1262 1263
		rv = bond_set_carrier(bond);
		if (!rv)
			return;

		if (netif_carrier_ok(bond->dev)) {
J
Joe Perches 已提交
1264 1265
			pr_info("%s: first active interface up!\n",
				bond->dev->name);
1266
		} else {
J
Joe Perches 已提交
1267 1268
			pr_info("%s: now running without any active interface !\n",
				bond->dev->name);
1269
		}
L
Linus Torvalds 已提交
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
	}
}

/*--------------------------- slave list handling ---------------------------*/

/*
 * This function attaches the slave to the end of list.
 *
 * bond->lock held for writing by caller.
 */
static void bond_attach_slave(struct bonding *bond, struct slave *new_slave)
{
	if (bond->first_slave == NULL) { /* attaching the first slave */
		new_slave->next = new_slave;
		new_slave->prev = new_slave;
		bond->first_slave = new_slave;
	} else {
		new_slave->next = bond->first_slave;
		new_slave->prev = bond->first_slave->prev;
		new_slave->next->prev = new_slave;
		new_slave->prev->next = new_slave;
	}

	bond->slave_cnt++;
}

/*
 * This function detaches the slave from the list.
 * WARNING: no check is made to verify if the slave effectively
 * belongs to <bond>.
 * Nothing is freed on return, structures are just unchained.
 * If any slave pointer in bond was pointing to <slave>,
 * it should be changed by the calling function.
 *
 * bond->lock held for writing by caller.
 */
static void bond_detach_slave(struct bonding *bond, struct slave *slave)
{
S
Stephen Hemminger 已提交
1308
	if (slave->next)
L
Linus Torvalds 已提交
1309 1310
		slave->next->prev = slave->prev;

S
Stephen Hemminger 已提交
1311
	if (slave->prev)
L
Linus Torvalds 已提交
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
		slave->prev->next = slave->next;

	if (bond->first_slave == slave) { /* slave is the first slave */
		if (bond->slave_cnt > 1) { /* there are more slave */
			bond->first_slave = slave->next;
		} else {
			bond->first_slave = NULL; /* slave was the last one */
		}
	}

	slave->next = NULL;
	slave->prev = NULL;
	bond->slave_cnt--;
}

/*---------------------------------- IOCTL ----------------------------------*/

1329 1330
static int bond_sethwaddr(struct net_device *bond_dev,
			  struct net_device *slave_dev)
L
Linus Torvalds 已提交
1331
{
1332 1333 1334
	pr_debug("bond_dev=%p\n", bond_dev);
	pr_debug("slave_dev=%p\n", slave_dev);
	pr_debug("slave_dev->addr_len=%d\n", slave_dev->addr_len);
L
Linus Torvalds 已提交
1335 1336 1337 1338
	memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
	return 0;
}

1339 1340 1341
#define BOND_VLAN_FEATURES \
	(NETIF_F_VLAN_CHALLENGED | NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_TX | \
	 NETIF_F_HW_VLAN_FILTER)
1342

S
Stephen Hemminger 已提交
1343
/*
1344
 * Compute the common dev->feature set available to all slaves.  Some
1345 1346
 * feature bits are managed elsewhere, so preserve those feature bits
 * on the master device.
1347 1348 1349 1350 1351
 */
static int bond_compute_features(struct bonding *bond)
{
	struct slave *slave;
	struct net_device *bond_dev = bond->dev;
1352
	unsigned long features = bond_dev->features;
1353
	unsigned long vlan_features = 0;
1354 1355
	unsigned short max_hard_header_len = max((u16)ETH_HLEN,
						bond_dev->hard_header_len);
1356
	int i;
1357

1358
	features &= ~(NETIF_F_ALL_CSUM | BOND_VLAN_FEATURES);
1359 1360 1361 1362 1363 1364
	features |=  NETIF_F_GSO_MASK | NETIF_F_NO_CSUM;

	if (!bond->first_slave)
		goto done;

	features &= ~NETIF_F_ONE_FOR_ALL;
1365

1366
	vlan_features = bond->first_slave->dev->vlan_features;
1367
	bond_for_each_slave(bond, slave, i) {
1368 1369 1370
		features = netdev_increment_features(features,
						     slave->dev->features,
						     NETIF_F_ONE_FOR_ALL);
1371 1372 1373
		vlan_features = netdev_increment_features(vlan_features,
							slave->dev->vlan_features,
							NETIF_F_ONE_FOR_ALL);
1374 1375 1376
		if (slave->dev->hard_header_len > max_hard_header_len)
			max_hard_header_len = slave->dev->hard_header_len;
	}
1377

1378
done:
1379
	features |= (bond_dev->features & BOND_VLAN_FEATURES);
1380
	bond_dev->features = netdev_fix_features(features, NULL);
1381
	bond_dev->vlan_features = netdev_fix_features(vlan_features, NULL);
1382
	bond_dev->hard_header_len = max_hard_header_len;
1383 1384 1385 1386

	return 0;
}

1387 1388 1389
static void bond_setup_by_slave(struct net_device *bond_dev,
				struct net_device *slave_dev)
{
1390
	struct bonding *bond = netdev_priv(bond_dev);
1391

1392
	bond_dev->header_ops	    = slave_dev->header_ops;
1393 1394 1395 1396 1397 1398 1399

	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);
1400
	bond->setup_by_slave = 1;
1401 1402
}

L
Linus Torvalds 已提交
1403
/* enslave device <slave> to bond device <master> */
1404
int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
L
Linus Torvalds 已提交
1405
{
1406
	struct bonding *bond = netdev_priv(bond_dev);
1407
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
L
Linus Torvalds 已提交
1408 1409 1410 1411 1412 1413 1414
	struct slave *new_slave = NULL;
	struct dev_mc_list *dmi;
	struct sockaddr addr;
	int link_reporting;
	int old_features = bond_dev->features;
	int res = 0;

1415
	if (!bond->params.use_carrier && slave_dev->ethtool_ops == NULL &&
1416
		slave_ops->ndo_do_ioctl == NULL) {
J
Joe Perches 已提交
1417 1418
		pr_warning("%s: Warning: no link monitoring support for %s\n",
			   bond_dev->name, slave_dev->name);
L
Linus Torvalds 已提交
1419 1420 1421 1422
	}

	/* bond must be initialized by bond_open() before enslaving */
	if (!(bond_dev->flags & IFF_UP)) {
J
Joe Perches 已提交
1423 1424
		pr_warning("%s: master_dev is not up in bond_enslave\n",
			   bond_dev->name);
L
Linus Torvalds 已提交
1425 1426 1427 1428
	}

	/* already enslaved */
	if (slave_dev->flags & IFF_SLAVE) {
1429
		pr_debug("Error, Device was already enslaved\n");
L
Linus Torvalds 已提交
1430 1431 1432 1433 1434 1435
		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) {
1436
		pr_debug("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
L
Linus Torvalds 已提交
1437
		if (!list_empty(&bond->vlan_list)) {
J
Joe Perches 已提交
1438 1439
			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 已提交
1440 1441
			return -EPERM;
		} else {
J
Joe Perches 已提交
1442 1443 1444
			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 已提交
1445 1446 1447
			bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
		}
	} else {
1448
		pr_debug("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
L
Linus Torvalds 已提交
1449 1450 1451 1452 1453 1454 1455 1456
		if (bond->slave_cnt == 0) {
			/* First slave, and it is not VLAN challenged,
			 * so remove the block of adding VLANs over the bond.
			 */
			bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED;
		}
	}

1457 1458
	/*
	 * Old ifenslave binaries are no longer supported.  These can
S
Stephen Hemminger 已提交
1459
	 * be identified with moderate accuracy by the state of the slave:
1460 1461 1462 1463
	 * 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 已提交
1464
		pr_err("%s is up. This may be due to an out of date ifenslave.\n",
1465 1466 1467 1468
		       slave_dev->name);
		res = -EPERM;
		goto err_undo_flags;
	}
L
Linus Torvalds 已提交
1469

1470 1471 1472 1473 1474 1475 1476 1477
	/* 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
	 */
	if (bond->slave_cnt == 0) {
1478 1479
		if (bond_dev->type != slave_dev->type) {
			pr_debug("%s: change device type from %d to %d\n",
J
Joe Perches 已提交
1480 1481
				 bond_dev->name,
				 bond_dev->type, slave_dev->type);
1482 1483 1484

			netdev_bonding_change(bond_dev, NETDEV_BONDING_OLDTYPE);

1485 1486 1487 1488
			if (slave_dev->type != ARPHRD_ETHER)
				bond_setup_by_slave(bond_dev, slave_dev);
			else
				ether_setup(bond_dev);
1489 1490

			netdev_bonding_change(bond_dev, NETDEV_BONDING_NEWTYPE);
1491
		}
1492
	} else if (bond_dev->type != slave_dev->type) {
J
Joe Perches 已提交
1493 1494 1495 1496 1497
		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;
1498 1499
	}

1500
	if (slave_ops->ndo_set_mac_address == NULL) {
1501
		if (bond->slave_cnt == 0) {
J
Joe Perches 已提交
1502 1503
			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);
1504 1505
			bond->params.fail_over_mac = BOND_FOM_ACTIVE;
		} else if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
J
Joe Perches 已提交
1506 1507
			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);
1508 1509 1510
			res = -EOPNOTSUPP;
			goto err_undo_flags;
		}
L
Linus Torvalds 已提交
1511 1512
	}

1513
	new_slave = kzalloc(sizeof(struct slave), GFP_KERNEL);
L
Linus Torvalds 已提交
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
	if (!new_slave) {
		res = -ENOMEM;
		goto err_undo_flags;
	}

	/* save slave's original flags before calling
	 * netdev_set_master and dev_open
	 */
	new_slave->original_flags = slave_dev->flags;

1524 1525 1526 1527 1528 1529
	/*
	 * 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 已提交
1530

1531
	if (!bond->params.fail_over_mac) {
1532 1533 1534 1535 1536 1537 1538 1539
		/*
		 * 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) {
1540
			pr_debug("Error %d calling set_mac_address\n", res);
1541 1542
			goto err_free;
		}
1543
	}
L
Linus Torvalds 已提交
1544

1545 1546
	res = netdev_set_master(slave_dev, bond_dev);
	if (res) {
1547
		pr_debug("Error %d calling netdev_set_master\n", res);
1548
		goto err_restore_mac;
1549
	}
1550 1551 1552
	/* open the slave since the application closed it */
	res = dev_open(slave_dev);
	if (res) {
S
Stephen Hemminger 已提交
1553
		pr_debug("Opening slave %s failed\n", slave_dev->name);
1554
		goto err_unset_master;
L
Linus Torvalds 已提交
1555 1556 1557
	}

	new_slave->dev = slave_dev;
1558
	slave_dev->priv_flags |= IFF_BONDING;
L
Linus Torvalds 已提交
1559

1560
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
1561 1562 1563 1564
		/* 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 已提交
1565
		if (res)
1566
			goto err_close;
L
Linus Torvalds 已提交
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
	}

	/* If the mode USES_PRIMARY, then the new slave gets the
	 * master's promisc (and mc) settings only if it becomes the
	 * curr_active_slave, and that is taken care of later when calling
	 * bond_change_active()
	 */
	if (!USES_PRIMARY(bond->params.mode)) {
		/* set promiscuity level to new slave */
		if (bond_dev->flags & IFF_PROMISC) {
1577 1578 1579
			res = dev_set_promiscuity(slave_dev, 1);
			if (res)
				goto err_close;
L
Linus Torvalds 已提交
1580 1581 1582 1583
		}

		/* set allmulti level to new slave */
		if (bond_dev->flags & IFF_ALLMULTI) {
1584 1585 1586
			res = dev_set_allmulti(slave_dev, 1);
			if (res)
				goto err_close;
L
Linus Torvalds 已提交
1587 1588
		}

1589
		netif_addr_lock_bh(bond_dev);
L
Linus Torvalds 已提交
1590
		/* upload master's mc_list to new slave */
S
Stephen Hemminger 已提交
1591 1592 1593
		for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next)
			dev_mc_add(slave_dev, dmi->dmi_addr,
				   dmi->dmi_addrlen, 0);
1594
		netif_addr_unlock_bh(bond_dev);
L
Linus Torvalds 已提交
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
	}

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

		dev_mc_add(slave_dev, lacpdu_multicast, ETH_ALEN, 0);
	}

	bond_add_vlans_on_slave(bond, slave_dev);

	write_lock_bh(&bond->lock);

	bond_attach_slave(bond, new_slave);

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

1613 1614
	bond_compute_features(bond);

1615 1616 1617 1618
	write_unlock_bh(&bond->lock);

	read_lock(&bond->lock);

1619 1620
	new_slave->last_arp_rx = jiffies;

L
Linus Torvalds 已提交
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
	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 已提交
1634
			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",
1635
			       bond_dev->name, slave_dev->name);
L
Linus Torvalds 已提交
1636 1637
		} else if (link_reporting == -1) {
			/* unable get link status using mii/ethtool */
J
Joe Perches 已提交
1638 1639
			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 已提交
1640 1641 1642 1643 1644 1645 1646
		}
	}

	/* check for initial state */
	if (!bond->params.miimon ||
	    (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS)) {
		if (bond->params.updelay) {
J
Joe Perches 已提交
1647
			pr_debug("Initial state of slave_dev is BOND_LINK_BACK\n");
L
Linus Torvalds 已提交
1648 1649 1650
			new_slave->link  = BOND_LINK_BACK;
			new_slave->delay = bond->params.updelay;
		} else {
J
Joe Perches 已提交
1651
			pr_debug("Initial state of slave_dev is BOND_LINK_UP\n");
L
Linus Torvalds 已提交
1652 1653 1654 1655
			new_slave->link  = BOND_LINK_UP;
		}
		new_slave->jiffies = jiffies;
	} else {
J
Joe Perches 已提交
1656
		pr_debug("Initial state of slave_dev is BOND_LINK_DOWN\n");
L
Linus Torvalds 已提交
1657 1658 1659 1660 1661
		new_slave->link  = BOND_LINK_DOWN;
	}

	if (bond_update_speed_duplex(new_slave) &&
	    (new_slave->link != BOND_LINK_DOWN)) {
J
Joe Perches 已提交
1662 1663
		pr_warning("%s: Warning: failed to get speed and duplex from %s, assumed to be 100Mb/sec and Full.\n",
			   bond_dev->name, new_slave->dev->name);
L
Linus Torvalds 已提交
1664 1665

		if (bond->params.mode == BOND_MODE_8023AD) {
J
Joe Perches 已提交
1666 1667
			pr_warning("%s: Warning: Operation of 802.3ad mode requires ETHTOOL support in base driver for proper aggregator selection.\n",
				   bond_dev->name);
L
Linus Torvalds 已提交
1668 1669 1670 1671 1672
		}
	}

	if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
		/* if there is a primary slave, remember it */
1673
		if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
L
Linus Torvalds 已提交
1674
			bond->primary_slave = new_slave;
1675 1676
			bond->force_primary = true;
		}
L
Linus Torvalds 已提交
1677 1678
	}

1679 1680
	write_lock_bh(&bond->curr_slave_lock);

L
Linus Torvalds 已提交
1681 1682
	switch (bond->params.mode) {
	case BOND_MODE_ACTIVEBACKUP:
1683 1684
		bond_set_slave_inactive_flags(new_slave);
		bond_select_active_slave(bond);
L
Linus Torvalds 已提交
1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
		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 */
		if (bond->slave_cnt == 1) {
			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
			 */
			bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL,
					    bond->params.lacp_fast);
		} else {
			SLAVE_AD_INFO(new_slave).id =
				SLAVE_AD_INFO(new_slave->prev).id + 1;
		}

		bond_3ad_bind_slave(new_slave);
		break;
	case BOND_MODE_TLB:
	case BOND_MODE_ALB:
		new_slave->state = BOND_STATE_ACTIVE;
1710
		bond_set_slave_inactive_flags(new_slave);
1711
		bond_select_active_slave(bond);
L
Linus Torvalds 已提交
1712 1713
		break;
	default:
1714
		pr_debug("This slave is always active in trunk mode\n");
L
Linus Torvalds 已提交
1715 1716 1717 1718 1719 1720 1721 1722

		/* always active in trunk mode */
		new_slave->state = BOND_STATE_ACTIVE;

		/* 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()
		 */
S
Stephen Hemminger 已提交
1723
		if (!bond->curr_active_slave)
L
Linus Torvalds 已提交
1724
			bond->curr_active_slave = new_slave;
S
Stephen Hemminger 已提交
1725

L
Linus Torvalds 已提交
1726 1727 1728
		break;
	} /* switch(bond_mode) */

1729 1730
	write_unlock_bh(&bond->curr_slave_lock);

1731 1732
	bond_set_carrier(bond);

1733
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
1734

1735 1736
	res = bond_create_slave_symlinks(bond_dev, slave_dev);
	if (res)
1737
		goto err_close;
1738

J
Joe Perches 已提交
1739 1740 1741 1742
	pr_info("%s: enslaving %s as a%s interface with a%s link.\n",
		bond_dev->name, slave_dev->name,
		new_slave->state == BOND_STATE_ACTIVE ? "n active" : " backup",
		new_slave->link != BOND_LINK_DOWN ? "n up" : " down");
L
Linus Torvalds 已提交
1743 1744 1745 1746 1747 1748 1749 1750

	/* enslave is successful */
	return 0;

/* Undo stages on error */
err_close:
	dev_close(slave_dev);

1751 1752 1753
err_unset_master:
	netdev_set_master(slave_dev, NULL);

L
Linus Torvalds 已提交
1754
err_restore_mac:
1755
	if (!bond->params.fail_over_mac) {
1756 1757 1758 1759
		/* 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.
		 */
1760 1761 1762 1763
		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 已提交
1764 1765 1766 1767 1768 1769

err_free:
	kfree(new_slave);

err_undo_flags:
	bond_dev->features = old_features;
S
Stephen Hemminger 已提交
1770

L
Linus Torvalds 已提交
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784
	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
 * is write-locked.
 *
 * 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.
 */
1785
int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
L
Linus Torvalds 已提交
1786
{
1787
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
1788 1789 1790 1791 1792 1793
	struct slave *slave, *oldcurrent;
	struct sockaddr addr;

	/* slave is not a slave or master is not master of this slave */
	if (!(slave_dev->flags & IFF_SLAVE) ||
	    (slave_dev->master != bond_dev)) {
J
Joe Perches 已提交
1794
		pr_err("%s: Error: cannot release %s.\n",
L
Linus Torvalds 已提交
1795 1796 1797 1798 1799 1800 1801 1802 1803
		       bond_dev->name, slave_dev->name);
		return -EINVAL;
	}

	write_lock_bh(&bond->lock);

	slave = bond_get_slave_by_dev(bond, slave_dev);
	if (!slave) {
		/* not a slave of this bond */
J
Joe Perches 已提交
1804 1805
		pr_info("%s: %s not enslaved\n",
			bond_dev->name, slave_dev->name);
1806
		write_unlock_bh(&bond->lock);
L
Linus Torvalds 已提交
1807 1808 1809
		return -EINVAL;
	}

1810
	if (!bond->params.fail_over_mac) {
1811 1812
		if (!compare_ether_addr(bond_dev->dev_addr, slave->perm_hwaddr) &&
		    bond->slave_cnt > 1)
J
Joe Perches 已提交
1813 1814 1815 1816
			pr_warning("%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);
L
Linus Torvalds 已提交
1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
	}

	/* Inform AD package of unbinding of slave. */
	if (bond->params.mode == BOND_MODE_8023AD) {
		/* must be called before the slave is
		 * detached from the list
		 */
		bond_3ad_unbind_slave(slave);
	}

J
Joe Perches 已提交
1827 1828 1829 1830
	pr_info("%s: releasing %s interface %s\n",
		bond_dev->name,
		(slave->state == BOND_STATE_ACTIVE) ? "active" : "backup",
		slave_dev->name);
L
Linus Torvalds 已提交
1831 1832 1833 1834 1835 1836 1837 1838

	oldcurrent = bond->curr_active_slave;

	bond->current_arp_slave = NULL;

	/* release the slave from its bond */
	bond_detach_slave(bond, slave);

1839 1840
	bond_compute_features(bond);

S
Stephen Hemminger 已提交
1841
	if (bond->primary_slave == slave)
L
Linus Torvalds 已提交
1842 1843
		bond->primary_slave = NULL;

S
Stephen Hemminger 已提交
1844
	if (oldcurrent == slave)
L
Linus Torvalds 已提交
1845 1846
		bond_change_active_slave(bond, NULL);

1847
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
1848 1849 1850 1851 1852
		/* 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.
		 */
1853
		write_unlock_bh(&bond->lock);
L
Linus Torvalds 已提交
1854
		bond_alb_deinit_slave(bond, slave);
1855
		write_lock_bh(&bond->lock);
L
Linus Torvalds 已提交
1856 1857
	}

1858 1859 1860 1861 1862 1863 1864 1865 1866 1867
	if (oldcurrent == slave) {
		/*
		 * Note that we hold RTNL over this sequence, so there
		 * is no concern that another slave add/remove event
		 * will interfere.
		 */
		write_unlock_bh(&bond->lock);
		read_lock(&bond->lock);
		write_lock_bh(&bond->curr_slave_lock);

L
Linus Torvalds 已提交
1868 1869
		bond_select_active_slave(bond);

1870 1871 1872 1873 1874
		write_unlock_bh(&bond->curr_slave_lock);
		read_unlock(&bond->lock);
		write_lock_bh(&bond->lock);
	}

L
Linus Torvalds 已提交
1875
	if (bond->slave_cnt == 0) {
1876 1877
		bond_set_carrier(bond);

L
Linus Torvalds 已提交
1878 1879 1880 1881 1882 1883 1884 1885 1886
		/* if the last slave was removed, zero the mac address
		 * of the master so it will be set by the application
		 * to the mac address of the first slave
		 */
		memset(bond_dev->dev_addr, 0, bond_dev->addr_len);

		if (list_empty(&bond->vlan_list)) {
			bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
		} else {
J
Joe Perches 已提交
1887 1888 1889 1890
			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 已提交
1891 1892 1893
		}
	} else if ((bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
		   !bond_has_challenged_slaves(bond)) {
J
Joe Perches 已提交
1894 1895
		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);
L
Linus Torvalds 已提交
1896 1897 1898 1899 1900
		bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED;
	}

	write_unlock_bh(&bond->lock);

1901 1902 1903
	/* must do this from outside any spinlocks */
	bond_destroy_slave_symlinks(bond_dev, slave_dev);

L
Linus Torvalds 已提交
1904 1905 1906 1907 1908 1909 1910 1911
	bond_del_vlans_from_slave(bond, slave_dev);

	/* If the mode USES_PRIMARY, then we should only remove its
	 * promisc and mc settings if it was the curr_active_slave, but that was
	 * already taken care of above when we detached the slave
	 */
	if (!USES_PRIMARY(bond->params.mode)) {
		/* unset promiscuity level from slave */
S
Stephen Hemminger 已提交
1912
		if (bond_dev->flags & IFF_PROMISC)
L
Linus Torvalds 已提交
1913 1914 1915
			dev_set_promiscuity(slave_dev, -1);

		/* unset allmulti level from slave */
S
Stephen Hemminger 已提交
1916
		if (bond_dev->flags & IFF_ALLMULTI)
L
Linus Torvalds 已提交
1917 1918 1919
			dev_set_allmulti(slave_dev, -1);

		/* flush master's mc_list from slave */
1920
		netif_addr_lock_bh(bond_dev);
L
Linus Torvalds 已提交
1921
		bond_mc_list_flush(bond_dev, slave_dev);
1922
		netif_addr_unlock_bh(bond_dev);
L
Linus Torvalds 已提交
1923 1924 1925 1926 1927 1928 1929
	}

	netdev_set_master(slave_dev, NULL);

	/* close slave before restoring its mac address */
	dev_close(slave_dev);

1930
	if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
1931 1932 1933 1934 1935
		/* 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 已提交
1936

1937
	slave_dev->priv_flags &= ~(IFF_MASTER_8023AD | IFF_MASTER_ALB |
1938 1939
				   IFF_SLAVE_INACTIVE | IFF_BONDING |
				   IFF_SLAVE_NEEDARP);
L
Linus Torvalds 已提交
1940 1941 1942 1943 1944 1945

	kfree(slave);

	return 0;  /* deletion OK */
}

1946
/*
S
Stephen Hemminger 已提交
1947
* First release a slave and than destroy the bond if no more slaves are left.
1948 1949
* Must be under rtnl_lock when this function is called.
*/
S
Stephen Hemminger 已提交
1950 1951
int  bond_release_and_destroy(struct net_device *bond_dev,
			      struct net_device *slave_dev)
1952
{
1953
	struct bonding *bond = netdev_priv(bond_dev);
1954 1955 1956 1957
	int ret;

	ret = bond_release(bond_dev, slave_dev);
	if ((ret == 0) && (bond->slave_cnt == 0)) {
J
Joe Perches 已提交
1958 1959
		pr_info("%s: destroying bond %s.\n",
			bond_dev->name, bond_dev->name);
S
Stephen Hemminger 已提交
1960
		unregister_netdevice(bond_dev);
1961 1962 1963 1964
	}
	return ret;
}

L
Linus Torvalds 已提交
1965 1966 1967 1968 1969
/*
 * This function releases all slaves.
 */
static int bond_release_all(struct net_device *bond_dev)
{
1970
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
1971 1972 1973 1974 1975 1976
	struct slave *slave;
	struct net_device *slave_dev;
	struct sockaddr addr;

	write_lock_bh(&bond->lock);

1977 1978
	netif_carrier_off(bond_dev);

S
Stephen Hemminger 已提交
1979
	if (bond->slave_cnt == 0)
L
Linus Torvalds 已提交
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
		goto out;

	bond->current_arp_slave = NULL;
	bond->primary_slave = NULL;
	bond_change_active_slave(bond, NULL);

	while ((slave = bond->first_slave) != NULL) {
		/* Inform AD package of unbinding of slave
		 * before slave is detached from the list.
		 */
S
Stephen Hemminger 已提交
1990
		if (bond->params.mode == BOND_MODE_8023AD)
L
Linus Torvalds 已提交
1991 1992 1993 1994 1995
			bond_3ad_unbind_slave(slave);

		slave_dev = slave->dev;
		bond_detach_slave(bond, slave);

1996 1997 1998 1999 2000 2001
		/* now that the slave is detached, unlock and perform
		 * all the undo steps that should not be called from
		 * within a lock.
		 */
		write_unlock_bh(&bond->lock);

2002
		if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
2003 2004 2005 2006 2007 2008
			/* must be called only after the slave
			 * has been detached from the list
			 */
			bond_alb_deinit_slave(bond, slave);
		}

2009 2010
		bond_compute_features(bond);

2011
		bond_destroy_slave_symlinks(bond_dev, slave_dev);
L
Linus Torvalds 已提交
2012 2013 2014 2015 2016 2017 2018 2019
		bond_del_vlans_from_slave(bond, slave_dev);

		/* If the mode USES_PRIMARY, then we should only remove its
		 * promisc and mc settings if it was the curr_active_slave, but that was
		 * already taken care of above when we detached the slave
		 */
		if (!USES_PRIMARY(bond->params.mode)) {
			/* unset promiscuity level from slave */
S
Stephen Hemminger 已提交
2020
			if (bond_dev->flags & IFF_PROMISC)
L
Linus Torvalds 已提交
2021 2022 2023
				dev_set_promiscuity(slave_dev, -1);

			/* unset allmulti level from slave */
S
Stephen Hemminger 已提交
2024
			if (bond_dev->flags & IFF_ALLMULTI)
L
Linus Torvalds 已提交
2025 2026 2027
				dev_set_allmulti(slave_dev, -1);

			/* flush master's mc_list from slave */
2028
			netif_addr_lock_bh(bond_dev);
L
Linus Torvalds 已提交
2029
			bond_mc_list_flush(bond_dev, slave_dev);
2030
			netif_addr_unlock_bh(bond_dev);
L
Linus Torvalds 已提交
2031 2032 2033 2034 2035 2036 2037
		}

		netdev_set_master(slave_dev, NULL);

		/* close slave before restoring its mac address */
		dev_close(slave_dev);

2038
		if (!bond->params.fail_over_mac) {
2039 2040 2041 2042 2043
			/* 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 已提交
2044

2045 2046
		slave_dev->priv_flags &= ~(IFF_MASTER_8023AD | IFF_MASTER_ALB |
					   IFF_SLAVE_INACTIVE);
L
Linus Torvalds 已提交
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059

		kfree(slave);

		/* re-acquire the lock before getting the next slave */
		write_lock_bh(&bond->lock);
	}

	/* zero the mac address of the master so it will be
	 * set by the application to the mac address of the
	 * first slave
	 */
	memset(bond_dev->dev_addr, 0, bond_dev->addr_len);

S
Stephen Hemminger 已提交
2060
	if (list_empty(&bond->vlan_list))
L
Linus Torvalds 已提交
2061
		bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
S
Stephen Hemminger 已提交
2062
	else {
J
Joe Perches 已提交
2063 2064 2065 2066
		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 已提交
2067 2068
	}

J
Joe Perches 已提交
2069
	pr_info("%s: released all slaves\n", bond_dev->name);
L
Linus Torvalds 已提交
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084

out:
	write_unlock_bh(&bond->lock);

	return 0;
}

/*
 * This function changes the active slave to slave <slave_dev>.
 * It returns -EINVAL in the following cases.
 *  - <slave_dev> is not found in the list.
 *  - There is not active slave now.
 *  - <slave_dev> is already active.
 *  - The link state of <slave_dev> is not BOND_LINK_UP.
 *  - <slave_dev> is not running.
S
Stephen Hemminger 已提交
2085 2086
 * In these cases, this function does nothing.
 * In the other cases, current_slave pointer is changed and 0 is returned.
L
Linus Torvalds 已提交
2087 2088 2089
 */
static int bond_ioctl_change_active(struct net_device *bond_dev, struct net_device *slave_dev)
{
2090
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
2091 2092 2093 2094
	struct slave *old_active = NULL;
	struct slave *new_active = NULL;
	int res = 0;

S
Stephen Hemminger 已提交
2095
	if (!USES_PRIMARY(bond->params.mode))
L
Linus Torvalds 已提交
2096 2097 2098
		return -EINVAL;

	/* Verify that master_dev is indeed the master of slave_dev */
S
Stephen Hemminger 已提交
2099
	if (!(slave_dev->flags & IFF_SLAVE) || (slave_dev->master != bond_dev))
L
Linus Torvalds 已提交
2100 2101
		return -EINVAL;

2102
	read_lock(&bond->lock);
L
Linus Torvalds 已提交
2103

2104
	read_lock(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2105
	old_active = bond->curr_active_slave;
2106 2107
	read_unlock(&bond->curr_slave_lock);

L
Linus Torvalds 已提交
2108 2109 2110 2111 2112 2113
	new_active = bond_get_slave_by_dev(bond, slave_dev);

	/*
	 * Changing to the current active: do nothing; return success.
	 */
	if (new_active && (new_active == old_active)) {
2114
		read_unlock(&bond->lock);
L
Linus Torvalds 已提交
2115 2116 2117 2118 2119 2120 2121
		return 0;
	}

	if ((new_active) &&
	    (old_active) &&
	    (new_active->link == BOND_LINK_UP) &&
	    IS_UP(new_active->dev)) {
2122
		write_lock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2123
		bond_change_active_slave(bond, new_active);
2124
		write_unlock_bh(&bond->curr_slave_lock);
S
Stephen Hemminger 已提交
2125
	} else
L
Linus Torvalds 已提交
2126 2127
		res = -EINVAL;

2128
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
2129 2130 2131 2132 2133 2134

	return res;
}

static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
{
2135
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
2136 2137 2138 2139

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

2140
	read_lock(&bond->lock);
L
Linus Torvalds 已提交
2141
	info->num_slaves = bond->slave_cnt;
2142
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
2143 2144 2145 2146 2147 2148

	return 0;
}

static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info)
{
2149
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
2150
	struct slave *slave;
2151
	int i, res = -ENODEV;
L
Linus Torvalds 已提交
2152

2153
	read_lock(&bond->lock);
L
Linus Torvalds 已提交
2154 2155 2156

	bond_for_each_slave(bond, slave, i) {
		if (i == (int)info->slave_id) {
2157 2158 2159 2160 2161
			res = 0;
			strcpy(info->slave_name, slave->dev->name);
			info->link = slave->link;
			info->state = slave->state;
			info->link_failure_count = slave->link_failure_count;
L
Linus Torvalds 已提交
2162 2163 2164 2165
			break;
		}
	}

2166
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
2167

2168
	return res;
L
Linus Torvalds 已提交
2169 2170 2171 2172 2173
}

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


J
Jay Vosburgh 已提交
2174 2175 2176 2177
static int bond_miimon_inspect(struct bonding *bond)
{
	struct slave *slave;
	int i, link_state, commit = 0;
2178 2179 2180
	bool ignore_updelay;

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

	bond_for_each_slave(bond, slave, i) {
J
Jay Vosburgh 已提交
2183
		slave->new_link = BOND_LINK_NOCHANGE;
L
Linus Torvalds 已提交
2184

J
Jay Vosburgh 已提交
2185
		link_state = bond_check_dev_link(bond, slave->dev, 0);
L
Linus Torvalds 已提交
2186 2187

		switch (slave->link) {
J
Jay Vosburgh 已提交
2188 2189 2190
		case BOND_LINK_UP:
			if (link_state)
				continue;
L
Linus Torvalds 已提交
2191

J
Jay Vosburgh 已提交
2192 2193 2194
			slave->link = BOND_LINK_FAIL;
			slave->delay = bond->params.downdelay;
			if (slave->delay) {
J
Joe Perches 已提交
2195 2196 2197 2198 2199 2200 2201 2202
				pr_info("%s: link status down for %sinterface %s, disabling it in %d ms.\n",
					bond->dev->name,
					(bond->params.mode ==
					 BOND_MODE_ACTIVEBACKUP) ?
					((slave->state == BOND_STATE_ACTIVE) ?
					 "active " : "backup ") : "",
					slave->dev->name,
					bond->params.downdelay * bond->params.miimon);
L
Linus Torvalds 已提交
2203
			}
J
Jay Vosburgh 已提交
2204 2205 2206 2207 2208 2209 2210
			/*FALLTHRU*/
		case BOND_LINK_FAIL:
			if (link_state) {
				/*
				 * recovered before downdelay expired
				 */
				slave->link = BOND_LINK_UP;
L
Linus Torvalds 已提交
2211
				slave->jiffies = jiffies;
J
Joe Perches 已提交
2212 2213 2214 2215 2216
				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 已提交
2217
				continue;
L
Linus Torvalds 已提交
2218
			}
J
Jay Vosburgh 已提交
2219 2220 2221 2222 2223

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

J
Jay Vosburgh 已提交
2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
			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 已提交
2237 2238 2239 2240 2241
				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 已提交
2242 2243 2244 2245 2246
			}
			/*FALLTHRU*/
		case BOND_LINK_BACK:
			if (!link_state) {
				slave->link = BOND_LINK_DOWN;
J
Joe Perches 已提交
2247 2248 2249 2250 2251
				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 已提交
2252 2253 2254 2255

				continue;
			}

2256 2257 2258
			if (ignore_updelay)
				slave->delay = 0;

J
Jay Vosburgh 已提交
2259 2260 2261
			if (slave->delay <= 0) {
				slave->new_link = BOND_LINK_UP;
				commit++;
2262
				ignore_updelay = false;
J
Jay Vosburgh 已提交
2263
				continue;
L
Linus Torvalds 已提交
2264
			}
J
Jay Vosburgh 已提交
2265 2266

			slave->delay--;
L
Linus Torvalds 已提交
2267
			break;
J
Jay Vosburgh 已提交
2268 2269
		}
	}
L
Linus Torvalds 已提交
2270

J
Jay Vosburgh 已提交
2271 2272
	return commit;
}
L
Linus Torvalds 已提交
2273

J
Jay Vosburgh 已提交
2274 2275 2276 2277 2278 2279 2280 2281 2282
static void bond_miimon_commit(struct bonding *bond)
{
	struct slave *slave;
	int i;

	bond_for_each_slave(bond, slave, i) {
		switch (slave->new_link) {
		case BOND_LINK_NOCHANGE:
			continue;
L
Linus Torvalds 已提交
2283

J
Jay Vosburgh 已提交
2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296
		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 */
				slave->state = BOND_STATE_BACKUP;
			} else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
				/* make it immediately active */
				slave->state = BOND_STATE_ACTIVE;
			} else if (slave != bond->primary_slave) {
				/* prevent it from being the active one */
				slave->state = BOND_STATE_BACKUP;
L
Linus Torvalds 已提交
2297 2298
			}

J
Joe Perches 已提交
2299 2300
			pr_info("%s: link status definitely up for interface %s.\n",
				bond->dev->name, slave->dev->name);
L
Linus Torvalds 已提交
2301

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

2306
			if (bond_is_lb(bond))
J
Jay Vosburgh 已提交
2307 2308
				bond_alb_handle_link_change(bond, slave,
							    BOND_LINK_UP);
L
Linus Torvalds 已提交
2309

J
Jay Vosburgh 已提交
2310 2311 2312
			if (!bond->curr_active_slave ||
			    (slave == bond->primary_slave))
				goto do_failover;
L
Linus Torvalds 已提交
2313

J
Jay Vosburgh 已提交
2314
			continue;
2315

J
Jay Vosburgh 已提交
2316
		case BOND_LINK_DOWN:
J
Jay Vosburgh 已提交
2317 2318 2319
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;

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

J
Jay Vosburgh 已提交
2322 2323 2324 2325
			if (bond->params.mode == BOND_MODE_ACTIVEBACKUP ||
			    bond->params.mode == BOND_MODE_8023AD)
				bond_set_slave_inactive_flags(slave);

J
Joe Perches 已提交
2326 2327
			pr_info("%s: link status definitely down for interface %s, disabling it\n",
				bond->dev->name, slave->dev->name);
J
Jay Vosburgh 已提交
2328 2329 2330 2331 2332

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

2333
			if (bond_is_lb(bond))
J
Jay Vosburgh 已提交
2334 2335 2336 2337 2338 2339 2340 2341 2342
				bond_alb_handle_link_change(bond, slave,
							    BOND_LINK_DOWN);

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

			continue;

		default:
J
Joe Perches 已提交
2343
			pr_err("%s: invalid new link %d on slave %s\n",
J
Jay Vosburgh 已提交
2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358
			       bond->dev->name, slave->new_link,
			       slave->dev->name);
			slave->new_link = BOND_LINK_NOCHANGE;

			continue;
		}

do_failover:
		ASSERT_RTNL();
		write_lock_bh(&bond->curr_slave_lock);
		bond_select_active_slave(bond);
		write_unlock_bh(&bond->curr_slave_lock);
	}

	bond_set_carrier(bond);
L
Linus Torvalds 已提交
2359 2360
}

2361 2362 2363 2364
/*
 * bond_mii_monitor
 *
 * Really a wrapper that splits the mii monitor into two phases: an
J
Jay Vosburgh 已提交
2365 2366 2367
 * 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.
2368 2369 2370 2371 2372 2373 2374
 */
void bond_mii_monitor(struct work_struct *work)
{
	struct bonding *bond = container_of(work, struct bonding,
					    mii_work.work);

	read_lock(&bond->lock);
J
Jay Vosburgh 已提交
2375 2376 2377 2378 2379
	if (bond->kill_timers)
		goto out;

	if (bond->slave_cnt == 0)
		goto re_arm;
2380 2381 2382 2383 2384 2385 2386

	if (bond->send_grat_arp) {
		read_lock(&bond->curr_slave_lock);
		bond_send_gratuitous_arp(bond);
		read_unlock(&bond->curr_slave_lock);
	}

2387 2388 2389 2390 2391 2392
	if (bond->send_unsol_na) {
		read_lock(&bond->curr_slave_lock);
		bond_send_unsolicited_na(bond);
		read_unlock(&bond->curr_slave_lock);
	}

J
Jay Vosburgh 已提交
2393
	if (bond_miimon_inspect(bond)) {
2394 2395 2396
		read_unlock(&bond->lock);
		rtnl_lock();
		read_lock(&bond->lock);
J
Jay Vosburgh 已提交
2397 2398 2399

		bond_miimon_commit(bond);

2400 2401 2402
		read_unlock(&bond->lock);
		rtnl_unlock();	/* might sleep, hold no other locks */
		read_lock(&bond->lock);
2403 2404
	}

J
Jay Vosburgh 已提交
2405 2406 2407 2408 2409
re_arm:
	if (bond->params.miimon)
		queue_delayed_work(bond->wq, &bond->mii_work,
				   msecs_to_jiffies(bond->params.miimon));
out:
2410 2411
	read_unlock(&bond->lock);
}
J
Jay Vosburgh 已提交
2412

2413
static __be32 bond_glean_dev_ip(struct net_device *dev)
J
Jay Vosburgh 已提交
2414 2415 2416
{
	struct in_device *idev;
	struct in_ifaddr *ifa;
A
Al Viro 已提交
2417
	__be32 addr = 0;
J
Jay Vosburgh 已提交
2418 2419 2420 2421 2422

	if (!dev)
		return 0;

	rcu_read_lock();
2423
	idev = __in_dev_get_rcu(dev);
J
Jay Vosburgh 已提交
2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
	if (!idev)
		goto out;

	ifa = idev->ifa_list;
	if (!ifa)
		goto out;

	addr = ifa->ifa_local;
out:
	rcu_read_unlock();
	return addr;
}

2437
static int bond_has_this_ip(struct bonding *bond, __be32 ip)
2438
{
2439
	struct vlan_entry *vlan;
2440 2441 2442 2443

	if (ip == bond->master_ip)
		return 1;

2444
	list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
2445 2446 2447 2448 2449 2450 2451
		if (ip == vlan->vlan_ip)
			return 1;
	}

	return 0;
}

J
Jay Vosburgh 已提交
2452 2453 2454 2455 2456
/*
 * 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.
 */
2457
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 已提交
2458 2459 2460
{
	struct sk_buff *skb;

2461
	pr_debug("arp %d on slave %s: dst %x src %x vid %d\n", arp_op,
J
Joe Perches 已提交
2462
		 slave_dev->name, dest_ip, src_ip, vlan_id);
S
Stephen Hemminger 已提交
2463

J
Jay Vosburgh 已提交
2464 2465 2466 2467
	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 已提交
2468
		pr_err("ARP packet allocation failed\n");
J
Jay Vosburgh 已提交
2469 2470 2471 2472 2473
		return;
	}
	if (vlan_id) {
		skb = vlan_put_tag(skb, vlan_id);
		if (!skb) {
J
Joe Perches 已提交
2474
			pr_err("failed to insert VLAN tag\n");
J
Jay Vosburgh 已提交
2475 2476 2477 2478 2479 2480 2481
			return;
		}
	}
	arp_xmit(skb);
}


L
Linus Torvalds 已提交
2482 2483
static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
{
J
Jay Vosburgh 已提交
2484
	int i, vlan_id, rv;
2485
	__be32 *targets = bond->params.arp_targets;
2486
	struct vlan_entry *vlan;
J
Jay Vosburgh 已提交
2487 2488 2489
	struct net_device *vlan_dev;
	struct flowi fl;
	struct rtable *rt;
L
Linus Torvalds 已提交
2490

2491 2492
	for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
		if (!targets[i])
2493
			break;
2494
		pr_debug("basa: target %x\n", targets[i]);
J
Jay Vosburgh 已提交
2495
		if (list_empty(&bond->vlan_list)) {
2496
			pr_debug("basa: empty vlan: arp_send\n");
J
Jay Vosburgh 已提交
2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510
			bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
				      bond->master_ip, 0);
			continue;
		}

		/*
		 * If VLANs are configured, we do a route lookup to
		 * determine which VLAN interface would be used, so we
		 * can tag the ARP with the proper VLAN tag.
		 */
		memset(&fl, 0, sizeof(fl));
		fl.fl4_dst = targets[i];
		fl.fl4_tos = RTO_ONLINK;

2511
		rv = ip_route_output_key(dev_net(bond->dev), &rt, &fl);
J
Jay Vosburgh 已提交
2512 2513
		if (rv) {
			if (net_ratelimit()) {
J
Joe Perches 已提交
2514 2515
				pr_warning("%s: no route to arp_ip_target %pI4\n",
					   bond->dev->name, &fl.fl4_dst);
J
Jay Vosburgh 已提交
2516 2517 2518 2519 2520 2521 2522 2523
			}
			continue;
		}

		/*
		 * This target is not on a VLAN
		 */
		if (rt->u.dst.dev == bond->dev) {
2524
			ip_rt_put(rt);
2525
			pr_debug("basa: rtdev == bond->dev: arp_send\n");
J
Jay Vosburgh 已提交
2526 2527 2528 2529 2530 2531
			bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
				      bond->master_ip, 0);
			continue;
		}

		vlan_id = 0;
2532
		list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
D
Dan Aloni 已提交
2533
			vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
J
Jay Vosburgh 已提交
2534 2535
			if (vlan_dev == rt->u.dst.dev) {
				vlan_id = vlan->vlan_id;
2536
				pr_debug("basa: vlan match on %s %d\n",
J
Jay Vosburgh 已提交
2537 2538 2539 2540 2541 2542
				       vlan_dev->name, vlan_id);
				break;
			}
		}

		if (vlan_id) {
2543
			ip_rt_put(rt);
J
Jay Vosburgh 已提交
2544 2545 2546 2547 2548 2549
			bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
				      vlan->vlan_ip, vlan_id);
			continue;
		}

		if (net_ratelimit()) {
J
Joe Perches 已提交
2550 2551 2552
			pr_warning("%s: no path to arp_ip_target %pI4 via rt.dev %s\n",
				   bond->dev->name, &fl.fl4_dst,
				   rt->u.dst.dev ? rt->u.dst.dev->name : "NULL");
J
Jay Vosburgh 已提交
2553
		}
2554
		ip_rt_put(rt);
J
Jay Vosburgh 已提交
2555 2556 2557 2558 2559 2560
	}
}

/*
 * Kick out a gratuitous ARP for an IP on the bonding master plus one
 * for each VLAN above us.
2561 2562
 *
 * Caller must hold curr_slave_lock for read or better
J
Jay Vosburgh 已提交
2563 2564 2565 2566 2567 2568 2569
 */
static void bond_send_gratuitous_arp(struct bonding *bond)
{
	struct slave *slave = bond->curr_active_slave;
	struct vlan_entry *vlan;
	struct net_device *vlan_dev;

J
Joe Perches 已提交
2570 2571
	pr_debug("bond_send_grat_arp: bond %s slave %s\n",
		 bond->dev->name, slave ? slave->dev->name : "NULL");
2572 2573 2574

	if (!slave || !bond->send_grat_arp ||
	    test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state))
J
Jay Vosburgh 已提交
2575 2576
		return;

2577 2578
	bond->send_grat_arp--;

J
Jay Vosburgh 已提交
2579 2580
	if (bond->master_ip) {
		bond_arp_send(slave->dev, ARPOP_REPLY, bond->master_ip,
2581
				bond->master_ip, 0);
J
Jay Vosburgh 已提交
2582 2583 2584
	}

	list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
D
Dan Aloni 已提交
2585
		vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
J
Jay Vosburgh 已提交
2586 2587 2588 2589
		if (vlan->vlan_ip) {
			bond_arp_send(slave->dev, ARPOP_REPLY, vlan->vlan_ip,
				      vlan->vlan_ip, vlan->vlan_id);
		}
L
Linus Torvalds 已提交
2590 2591 2592
	}
}

2593
static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip)
2594 2595
{
	int i;
2596
	__be32 *targets = bond->params.arp_targets;
2597 2598

	for (i = 0; (i < BOND_MAX_ARP_TARGETS) && targets[i]; i++) {
2599
		pr_debug("bva: sip %pI4 tip %pI4 t[%d] %pI4 bhti(tip) %d\n",
J
Joe Perches 已提交
2600 2601
			 &sip, &tip, i, &targets[i],
			 bond_has_this_ip(bond, tip));
2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615
		if (sip == targets[i]) {
			if (bond_has_this_ip(bond, tip))
				slave->last_arp_rx = jiffies;
			return;
		}
	}
}

static int bond_arp_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
{
	struct arphdr *arp;
	struct slave *slave;
	struct bonding *bond;
	unsigned char *arp_ptr;
2616
	__be32 sip, tip;
2617

2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628
	if (dev->priv_flags & IFF_802_1Q_VLAN) {
		/*
		 * When using VLANS and bonding, dev and oriv_dev may be
		 * incorrect if the physical interface supports VLAN
		 * acceleration.  With this change ARP validation now
		 * works for hosts only reachable on the VLAN interface.
		 */
		dev = vlan_dev_real_dev(dev);
		orig_dev = dev_get_by_index_rcu(dev_net(skb->dev),skb->skb_iif);
	}

2629 2630 2631
	if (!(dev->priv_flags & IFF_BONDING) || !(dev->flags & IFF_MASTER))
		goto out;

2632
	bond = netdev_priv(dev);
2633 2634
	read_lock(&bond->lock);

2635
	pr_debug("bond_arp_rcv: bond %s skb->dev %s orig_dev %s\n",
J
Joe Perches 已提交
2636 2637
		 bond->dev->name, skb->dev ? skb->dev->name : "NULL",
		 orig_dev ? orig_dev->name : "NULL");
2638 2639 2640 2641 2642

	slave = bond_get_slave_by_dev(bond, orig_dev);
	if (!slave || !slave_do_arp_validate(bond, slave))
		goto out_unlock;

2643
	if (!pskb_may_pull(skb, arp_hdr_len(dev)))
2644 2645
		goto out_unlock;

2646
	arp = arp_hdr(skb);
2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660
	if (arp->ar_hln != dev->addr_len ||
	    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);
	arp_ptr += dev->addr_len;
	memcpy(&sip, arp_ptr, 4);
	arp_ptr += 4 + dev->addr_len;
	memcpy(&tip, arp_ptr, 4);

2661
	pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
J
Joe Perches 已提交
2662 2663 2664
		 bond->dev->name, slave->dev->name, slave->state,
		 bond->params.arp_validate, slave_do_arp_validate(bond, slave),
		 &sip, &tip);
2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685

	/*
	 * 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.
	 */
	if (slave->state == BOND_STATE_ACTIVE)
		bond_validate_arp(bond, slave, sip, tip);
	else
		bond_validate_arp(bond, slave, tip, sip);

out_unlock:
	read_unlock(&bond->lock);
out:
	dev_kfree_skb(skb);
	return NET_RX_SUCCESS;
}

L
Linus Torvalds 已提交
2686 2687 2688 2689 2690 2691 2692
/*
 * 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.
 */
2693
void bond_loadbalance_arp_mon(struct work_struct *work)
L
Linus Torvalds 已提交
2694
{
2695 2696
	struct bonding *bond = container_of(work, struct bonding,
					    arp_work.work);
L
Linus Torvalds 已提交
2697 2698 2699 2700 2701 2702 2703
	struct slave *slave, *oldcurrent;
	int do_failover = 0;
	int delta_in_ticks;
	int i;

	read_lock(&bond->lock);

2704
	delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
L
Linus Torvalds 已提交
2705

S
Stephen Hemminger 已提交
2706
	if (bond->kill_timers)
L
Linus Torvalds 已提交
2707 2708
		goto out;

S
Stephen Hemminger 已提交
2709
	if (bond->slave_cnt == 0)
L
Linus Torvalds 已提交
2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725
		goto re_arm;

	read_lock(&bond->curr_slave_lock);
	oldcurrent = bond->curr_active_slave;
	read_unlock(&bond->curr_slave_lock);

	/* 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
	 */
	bond_for_each_slave(bond, slave, i) {
		if (slave->link != BOND_LINK_UP) {
2726
			if (time_before_eq(jiffies, dev_trans_start(slave->dev) + delta_in_ticks) &&
D
David Sterba 已提交
2727
			    time_before_eq(jiffies, slave->dev->last_rx + delta_in_ticks)) {
L
Linus Torvalds 已提交
2728 2729 2730 2731 2732 2733 2734 2735 2736 2737

				slave->link  = BOND_LINK_UP;
				slave->state = BOND_STATE_ACTIVE;

				/* 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 已提交
2738 2739 2740
					pr_info("%s: link status definitely up for interface %s, ",
						bond->dev->name,
						slave->dev->name);
L
Linus Torvalds 已提交
2741 2742
					do_failover = 1;
				} else {
J
Joe Perches 已提交
2743 2744 2745
					pr_info("%s: interface %s is now up\n",
						bond->dev->name,
						slave->dev->name);
L
Linus Torvalds 已提交
2746 2747 2748 2749 2750 2751 2752 2753 2754
				}
			}
		} 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
			 */
2755
			if (time_after_eq(jiffies, dev_trans_start(slave->dev) + 2*delta_in_ticks) ||
2756
			    (time_after_eq(jiffies, slave->dev->last_rx + 2*delta_in_ticks))) {
L
Linus Torvalds 已提交
2757 2758 2759 2760

				slave->link  = BOND_LINK_DOWN;
				slave->state = BOND_STATE_BACKUP;

S
Stephen Hemminger 已提交
2761
				if (slave->link_failure_count < UINT_MAX)
L
Linus Torvalds 已提交
2762 2763
					slave->link_failure_count++;

J
Joe Perches 已提交
2764 2765 2766
				pr_info("%s: interface %s is now down.\n",
					bond->dev->name,
					slave->dev->name);
L
Linus Torvalds 已提交
2767

S
Stephen Hemminger 已提交
2768
				if (slave == oldcurrent)
L
Linus Torvalds 已提交
2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779
					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 已提交
2780
		if (IS_UP(slave->dev))
L
Linus Torvalds 已提交
2781 2782 2783 2784
			bond_arp_send_all(bond, slave);
	}

	if (do_failover) {
2785
		write_lock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2786 2787 2788

		bond_select_active_slave(bond);

2789
		write_unlock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2790 2791 2792
	}

re_arm:
2793 2794
	if (bond->params.arp_interval)
		queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
L
Linus Torvalds 已提交
2795 2796 2797 2798 2799
out:
	read_unlock(&bond->lock);
}

/*
2800 2801 2802 2803 2804 2805
 * 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.
 *
 * Called with bond->lock held for read.
L
Linus Torvalds 已提交
2806
 */
2807
static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
L
Linus Torvalds 已提交
2808 2809
{
	struct slave *slave;
2810
	int i, commit = 0;
L
Linus Torvalds 已提交
2811

2812 2813
	bond_for_each_slave(bond, slave, i) {
		slave->new_link = BOND_LINK_NOCHANGE;
L
Linus Torvalds 已提交
2814

2815 2816 2817 2818 2819 2820
		if (slave->link != BOND_LINK_UP) {
			if (time_before_eq(jiffies, slave_last_rx(bond, slave) +
					   delta_in_ticks)) {
				slave->new_link = BOND_LINK_UP;
				commit++;
			}
L
Linus Torvalds 已提交
2821

2822 2823
			continue;
		}
L
Linus Torvalds 已提交
2824

2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861
		/*
		 * 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.
		 */
		if (!time_after_eq(jiffies, slave->jiffies +
				   2 * delta_in_ticks))
			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
		 */
		if (slave->state == BOND_STATE_BACKUP &&
		    !bond->current_arp_slave &&
		    time_after(jiffies, slave_last_rx(bond, slave) +
			       3 * delta_in_ticks)) {
			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)
		 */
		if ((slave->state == BOND_STATE_ACTIVE) &&
2862
		    (time_after_eq(jiffies, dev_trans_start(slave->dev) +
2863 2864 2865 2866 2867 2868
				    2 * delta_in_ticks) ||
		      (time_after_eq(jiffies, slave_last_rx(bond, slave)
				     + 2 * delta_in_ticks)))) {
			slave->new_link = BOND_LINK_DOWN;
			commit++;
		}
L
Linus Torvalds 已提交
2869 2870
	}

2871 2872
	return commit;
}
L
Linus Torvalds 已提交
2873

2874 2875 2876 2877 2878 2879 2880 2881 2882 2883
/*
 * Called to commit link state changes noted by inspection step of
 * active-backup mode ARP monitor.
 *
 * Called with RTNL and bond->lock for read.
 */
static void bond_ab_arp_commit(struct bonding *bond, int delta_in_ticks)
{
	struct slave *slave;
	int i;
L
Linus Torvalds 已提交
2884

2885 2886 2887 2888
	bond_for_each_slave(bond, slave, i) {
		switch (slave->new_link) {
		case BOND_LINK_NOCHANGE:
			continue;
2889

2890
		case BOND_LINK_UP:
2891 2892 2893 2894 2895
			if ((!bond->curr_active_slave &&
			     time_before_eq(jiffies,
					    dev_trans_start(slave->dev) +
					    delta_in_ticks)) ||
			    bond->curr_active_slave != slave) {
2896 2897 2898
				slave->link = BOND_LINK_UP;
				bond->current_arp_slave = NULL;

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

2902 2903 2904
				if (!bond->curr_active_slave ||
				    (slave == bond->primary_slave))
					goto do_failover;
L
Linus Torvalds 已提交
2905

2906
			}
L
Linus Torvalds 已提交
2907

2908
			continue;
L
Linus Torvalds 已提交
2909

2910 2911 2912 2913 2914
		case BOND_LINK_DOWN:
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;

			slave->link = BOND_LINK_DOWN;
2915
			bond_set_slave_inactive_flags(slave);
2916

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

2920
			if (slave == bond->curr_active_slave) {
2921
				bond->current_arp_slave = NULL;
2922
				goto do_failover;
L
Linus Torvalds 已提交
2923
			}
2924 2925

			continue;
2926 2927

		default:
J
Joe Perches 已提交
2928
			pr_err("%s: impossible: new_link %d on slave %s\n",
2929 2930
			       bond->dev->name, slave->new_link,
			       slave->dev->name);
2931
			continue;
L
Linus Torvalds 已提交
2932 2933
		}

2934 2935
do_failover:
		ASSERT_RTNL();
2936
		write_lock_bh(&bond->curr_slave_lock);
2937
		bond_select_active_slave(bond);
2938 2939
		write_unlock_bh(&bond->curr_slave_lock);
	}
L
Linus Torvalds 已提交
2940

2941 2942
	bond_set_carrier(bond);
}
L
Linus Torvalds 已提交
2943

2944 2945 2946 2947 2948 2949 2950 2951 2952
/*
 * Send ARP probes for active-backup mode ARP monitor.
 *
 * Called with bond->lock held for read.
 */
static void bond_ab_arp_probe(struct bonding *bond)
{
	struct slave *slave;
	int i;
L
Linus Torvalds 已提交
2953

2954
	read_lock(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
2955

2956
	if (bond->current_arp_slave && bond->curr_active_slave)
J
Joe Perches 已提交
2957 2958 2959
		pr_info("PROBE: c_arp %s && cas %s BAD\n",
			bond->current_arp_slave->dev->name,
			bond->curr_active_slave->dev->name);
L
Linus Torvalds 已提交
2960

2961 2962 2963 2964 2965
	if (bond->curr_active_slave) {
		bond_arp_send_all(bond, bond->curr_active_slave);
		read_unlock(&bond->curr_slave_lock);
		return;
	}
L
Linus Torvalds 已提交
2966

2967
	read_unlock(&bond->curr_slave_lock);
2968

2969 2970 2971 2972
	/* 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 已提交
2973

2974 2975 2976 2977 2978
	if (!bond->current_arp_slave) {
		bond->current_arp_slave = bond->first_slave;
		if (!bond->current_arp_slave)
			return;
	}
L
Linus Torvalds 已提交
2979

2980
	bond_set_slave_inactive_flags(bond->current_arp_slave);
2981

2982 2983 2984 2985 2986 2987
	/* search for next candidate */
	bond_for_each_slave_from(bond, slave, i, bond->current_arp_slave->next) {
		if (IS_UP(slave->dev)) {
			slave->link = BOND_LINK_BACK;
			bond_set_slave_active_flags(slave);
			bond_arp_send_all(bond, slave);
L
Linus Torvalds 已提交
2988
			slave->jiffies = jiffies;
2989 2990
			bond->current_arp_slave = slave;
			break;
L
Linus Torvalds 已提交
2991 2992
		}

2993 2994 2995 2996 2997 2998
		/* 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 已提交
2999
		 */
3000 3001 3002 3003
		if (slave->link == BOND_LINK_UP) {
			slave->link = BOND_LINK_DOWN;
			if (slave->link_failure_count < UINT_MAX)
				slave->link_failure_count++;
L
Linus Torvalds 已提交
3004

3005 3006
			bond_set_slave_inactive_flags(slave);

J
Joe Perches 已提交
3007 3008
			pr_info("%s: backup interface %s is now down.\n",
				bond->dev->name, slave->dev->name);
L
Linus Torvalds 已提交
3009
		}
3010 3011
	}
}
L
Linus Torvalds 已提交
3012

3013 3014 3015 3016 3017
void bond_activebackup_arp_mon(struct work_struct *work)
{
	struct bonding *bond = container_of(work, struct bonding,
					    arp_work.work);
	int delta_in_ticks;
L
Linus Torvalds 已提交
3018

3019
	read_lock(&bond->lock);
L
Linus Torvalds 已提交
3020

3021 3022
	if (bond->kill_timers)
		goto out;
L
Linus Torvalds 已提交
3023

3024
	delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
L
Linus Torvalds 已提交
3025

3026 3027 3028
	if (bond->slave_cnt == 0)
		goto re_arm;

3029 3030 3031 3032 3033 3034
	if (bond->send_grat_arp) {
		read_lock(&bond->curr_slave_lock);
		bond_send_gratuitous_arp(bond);
		read_unlock(&bond->curr_slave_lock);
	}

3035 3036 3037 3038 3039 3040
	if (bond->send_unsol_na) {
		read_lock(&bond->curr_slave_lock);
		bond_send_unsolicited_na(bond);
		read_unlock(&bond->curr_slave_lock);
	}

3041 3042 3043 3044 3045 3046 3047 3048 3049 3050
	if (bond_ab_arp_inspect(bond, delta_in_ticks)) {
		read_unlock(&bond->lock);
		rtnl_lock();
		read_lock(&bond->lock);

		bond_ab_arp_commit(bond, delta_in_ticks);

		read_unlock(&bond->lock);
		rtnl_unlock();
		read_lock(&bond->lock);
L
Linus Torvalds 已提交
3051 3052
	}

3053 3054
	bond_ab_arp_probe(bond);

L
Linus Torvalds 已提交
3055
re_arm:
S
Stephen Hemminger 已提交
3056
	if (bond->params.arp_interval)
3057
		queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
L
Linus Torvalds 已提交
3058 3059 3060 3061 3062 3063 3064 3065 3066
out:
	read_unlock(&bond->lock);
}

/*------------------------------ proc/seq_file-------------------------------*/

#ifdef CONFIG_PROC_FS

static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos)
3067 3068
	__acquires(&dev_base_lock)
	__acquires(&bond->lock)
L
Linus Torvalds 已提交
3069 3070 3071 3072 3073 3074 3075 3076
{
	struct bonding *bond = seq->private;
	loff_t off = 0;
	struct slave *slave;
	int i;

	/* make sure the bond won't be taken away */
	read_lock(&dev_base_lock);
3077
	read_lock(&bond->lock);
L
Linus Torvalds 已提交
3078

S
Stephen Hemminger 已提交
3079
	if (*pos == 0)
L
Linus Torvalds 已提交
3080 3081 3082
		return SEQ_START_TOKEN;

	bond_for_each_slave(bond, slave, i) {
S
Stephen Hemminger 已提交
3083
		if (++off == *pos)
L
Linus Torvalds 已提交
3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095
			return slave;
	}

	return NULL;
}

static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct bonding *bond = seq->private;
	struct slave *slave = v;

	++*pos;
S
Stephen Hemminger 已提交
3096
	if (v == SEQ_START_TOKEN)
L
Linus Torvalds 已提交
3097 3098 3099 3100 3101 3102 3103 3104
		return bond->first_slave;

	slave = slave->next;

	return (slave == bond->first_slave) ? NULL : slave;
}

static void bond_info_seq_stop(struct seq_file *seq, void *v)
3105 3106
	__releases(&bond->lock)
	__releases(&dev_base_lock)
L
Linus Torvalds 已提交
3107 3108 3109
{
	struct bonding *bond = seq->private;

3110
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
3111 3112 3113 3114 3115 3116 3117
	read_unlock(&dev_base_lock);
}

static void bond_info_show_master(struct seq_file *seq)
{
	struct bonding *bond = seq->private;
	struct slave *curr;
3118
	int i;
L
Linus Torvalds 已提交
3119 3120 3121 3122 3123

	read_lock(&bond->curr_slave_lock);
	curr = bond->curr_active_slave;
	read_unlock(&bond->curr_slave_lock);

3124
	seq_printf(seq, "Bonding Mode: %s",
L
Linus Torvalds 已提交
3125 3126
		   bond_mode_name(bond->params.mode));

3127 3128
	if (bond->params.mode == BOND_MODE_ACTIVEBACKUP &&
	    bond->params.fail_over_mac)
3129 3130
		seq_printf(seq, " (fail_over_mac %s)",
		   fail_over_mac_tbl[bond->params.fail_over_mac].modename);
3131 3132 3133

	seq_printf(seq, "\n");

3134 3135 3136 3137 3138 3139 3140
	if (bond->params.mode == BOND_MODE_XOR ||
		bond->params.mode == BOND_MODE_8023AD) {
		seq_printf(seq, "Transmit Hash Policy: %s (%d)\n",
			xmit_hashtype_tbl[bond->params.xmit_policy].modename,
			bond->params.xmit_policy);
	}

L
Linus Torvalds 已提交
3141
	if (USES_PRIMARY(bond->params.mode)) {
3142
		seq_printf(seq, "Primary Slave: %s",
3143 3144
			   (bond->primary_slave) ?
			   bond->primary_slave->dev->name : "None");
3145 3146 3147
		if (bond->primary_slave)
			seq_printf(seq, " (primary_reselect %s)",
		   pri_reselect_tbl[bond->params.primary_reselect].modename);
L
Linus Torvalds 已提交
3148

3149
		seq_printf(seq, "\nCurrently Active Slave: %s\n",
L
Linus Torvalds 已提交
3150 3151 3152
			   (curr) ? curr->dev->name : "None");
	}

3153 3154
	seq_printf(seq, "MII Status: %s\n", netif_carrier_ok(bond->dev) ?
		   "up" : "down");
L
Linus Torvalds 已提交
3155 3156 3157 3158 3159 3160
	seq_printf(seq, "MII Polling Interval (ms): %d\n", bond->params.miimon);
	seq_printf(seq, "Up Delay (ms): %d\n",
		   bond->params.updelay * bond->params.miimon);
	seq_printf(seq, "Down Delay (ms): %d\n",
		   bond->params.downdelay * bond->params.miimon);

3161 3162

	/* ARP information */
S
Stephen Hemminger 已提交
3163 3164
	if (bond->params.arp_interval > 0) {
		int printed = 0;
3165 3166 3167 3168 3169
		seq_printf(seq, "ARP Polling Interval (ms): %d\n",
				bond->params.arp_interval);

		seq_printf(seq, "ARP IP target/s (n.n.n.n form):");

S
Stephen Hemminger 已提交
3170
		for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
3171
			if (!bond->params.arp_targets[i])
3172
				break;
3173 3174
			if (printed)
				seq_printf(seq, ",");
3175
			seq_printf(seq, " %pI4", &bond->params.arp_targets[i]);
3176 3177 3178 3179 3180
			printed = 1;
		}
		seq_printf(seq, "\n");
	}

L
Linus Torvalds 已提交
3181 3182 3183 3184 3185 3186
	if (bond->params.mode == BOND_MODE_8023AD) {
		struct ad_info ad_info;

		seq_puts(seq, "\n802.3ad info\n");
		seq_printf(seq, "LACP rate: %s\n",
			   (bond->params.lacp_fast) ? "fast" : "slow");
3187 3188
		seq_printf(seq, "Aggregator selection policy (ad_select): %s\n",
			   ad_select_tbl[bond->params.ad_select].modename);
L
Linus Torvalds 已提交
3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203

		if (bond_3ad_get_active_agg_info(bond, &ad_info)) {
			seq_printf(seq, "bond %s has no active aggregator\n",
				   bond->dev->name);
		} else {
			seq_printf(seq, "Active Aggregator Info:\n");

			seq_printf(seq, "\tAggregator ID: %d\n",
				   ad_info.aggregator_id);
			seq_printf(seq, "\tNumber of ports: %d\n",
				   ad_info.ports);
			seq_printf(seq, "\tActor Key: %d\n",
				   ad_info.actor_key);
			seq_printf(seq, "\tPartner Key: %d\n",
				   ad_info.partner_key);
J
Johannes Berg 已提交
3204 3205
			seq_printf(seq, "\tPartner Mac Address: %pM\n",
				   ad_info.partner_system);
L
Linus Torvalds 已提交
3206 3207 3208 3209
		}
	}
}

S
Stephen Hemminger 已提交
3210 3211
static void bond_info_show_slave(struct seq_file *seq,
				 const struct slave *slave)
L
Linus Torvalds 已提交
3212 3213 3214 3215 3216 3217
{
	struct bonding *bond = seq->private;

	seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name);
	seq_printf(seq, "MII Status: %s\n",
		   (slave->link == BOND_LINK_UP) ?  "up" : "down");
3218
	seq_printf(seq, "Link Failure Count: %u\n",
L
Linus Torvalds 已提交
3219 3220
		   slave->link_failure_count);

J
Johannes Berg 已提交
3221
	seq_printf(seq, "Permanent HW addr: %pM\n", slave->perm_hwaddr);
L
Linus Torvalds 已提交
3222 3223 3224 3225 3226

	if (bond->params.mode == BOND_MODE_8023AD) {
		const struct aggregator *agg
			= SLAVE_AD_INFO(slave).port.aggregator;

S
Stephen Hemminger 已提交
3227
		if (agg)
L
Linus Torvalds 已提交
3228 3229
			seq_printf(seq, "Aggregator ID: %d\n",
				   agg->aggregator_identifier);
S
Stephen Hemminger 已提交
3230
		else
L
Linus Torvalds 已提交
3231 3232 3233 3234 3235 3236 3237 3238 3239
			seq_puts(seq, "Aggregator ID: N/A\n");
	}
}

static int bond_info_seq_show(struct seq_file *seq, void *v)
{
	if (v == SEQ_START_TOKEN) {
		seq_printf(seq, "%s\n", version);
		bond_info_show_master(seq);
S
Stephen Hemminger 已提交
3240
	} else
L
Linus Torvalds 已提交
3241 3242 3243 3244 3245
		bond_info_show_slave(seq, v);

	return 0;
}

J
Jan Engelhardt 已提交
3246
static const struct seq_operations bond_info_seq_ops = {
L
Linus Torvalds 已提交
3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269
	.start = bond_info_seq_start,
	.next  = bond_info_seq_next,
	.stop  = bond_info_seq_stop,
	.show  = bond_info_seq_show,
};

static int bond_info_open(struct inode *inode, struct file *file)
{
	struct seq_file *seq;
	struct proc_dir_entry *proc;
	int res;

	res = seq_open(file, &bond_info_seq_ops);
	if (!res) {
		/* recover the pointer buried in proc_dir_entry data */
		seq = file->private_data;
		proc = PDE(inode);
		seq->private = proc->data;
	}

	return res;
}

3270
static const struct file_operations bond_info_fops = {
L
Linus Torvalds 已提交
3271 3272 3273 3274 3275 3276 3277
	.owner   = THIS_MODULE,
	.open    = bond_info_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = seq_release,
};

3278
static void bond_create_proc_entry(struct bonding *bond)
L
Linus Torvalds 已提交
3279 3280
{
	struct net_device *bond_dev = bond->dev;
3281
	struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
L
Linus Torvalds 已提交
3282

3283
	if (bn->proc_dir) {
3284
		bond->proc_entry = proc_create_data(bond_dev->name,
3285
						    S_IRUGO, bn->proc_dir,
3286
						    &bond_info_fops, bond);
S
Stephen Hemminger 已提交
3287
		if (bond->proc_entry == NULL)
J
Joe Perches 已提交
3288 3289
			pr_warning("Warning: Cannot create /proc/net/%s/%s\n",
				   DRV_NAME, bond_dev->name);
S
Stephen Hemminger 已提交
3290
		else
L
Linus Torvalds 已提交
3291 3292 3293 3294 3295 3296
			memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ);
	}
}

static void bond_remove_proc_entry(struct bonding *bond)
{
3297 3298 3299 3300 3301
	struct net_device *bond_dev = bond->dev;
	struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);

	if (bn->proc_dir && bond->proc_entry) {
		remove_proc_entry(bond->proc_file_name, bn->proc_dir);
L
Linus Torvalds 已提交
3302 3303 3304 3305 3306 3307 3308 3309
		memset(bond->proc_file_name, 0, IFNAMSIZ);
		bond->proc_entry = NULL;
	}
}

/* Create the bonding directory under /proc/net, if doesn't exist yet.
 * Caller must hold rtnl_lock.
 */
3310
static void bond_create_proc_dir(struct bond_net *bn)
L
Linus Torvalds 已提交
3311
{
3312 3313 3314
	if (!bn->proc_dir) {
		bn->proc_dir = proc_mkdir(DRV_NAME, bn->net->proc_net);
		if (!bn->proc_dir)
J
Joe Perches 已提交
3315 3316
			pr_warning("Warning: cannot create /proc/net/%s\n",
				   DRV_NAME);
L
Linus Torvalds 已提交
3317 3318 3319 3320 3321 3322
	}
}

/* Destroy the bonding directory under /proc/net, if empty.
 * Caller must hold rtnl_lock.
 */
3323
static void bond_destroy_proc_dir(struct bond_net *bn)
L
Linus Torvalds 已提交
3324
{
3325 3326 3327
	if (bn->proc_dir) {
		remove_proc_entry(DRV_NAME, bn->net->proc_net);
		bn->proc_dir = NULL;
L
Linus Torvalds 已提交
3328 3329
	}
}
3330 3331 3332

#else /* !CONFIG_PROC_FS */

3333
static void bond_create_proc_entry(struct bonding *bond)
3334 3335 3336 3337 3338 3339 3340
{
}

static void bond_remove_proc_entry(struct bonding *bond)
{
}

3341
static void bond_create_proc_dir(struct bond_net *bn)
3342 3343 3344
{
}

3345
static void bond_destroy_proc_dir(struct bond_net *bn)
3346 3347 3348
{
}

L
Linus Torvalds 已提交
3349 3350
#endif /* CONFIG_PROC_FS */

3351

L
Linus Torvalds 已提交
3352 3353 3354 3355 3356 3357 3358 3359 3360
/*-------------------------- netdev event handling --------------------------*/

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

L
Linus Torvalds 已提交
3362 3363 3364
	return NOTIFY_DONE;
}

S
Stephen Hemminger 已提交
3365 3366
static int bond_master_netdev_event(unsigned long event,
				    struct net_device *bond_dev)
L
Linus Torvalds 已提交
3367
{
3368
	struct bonding *event_bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379

	switch (event) {
	case NETDEV_CHANGENAME:
		return bond_event_changename(event_bond);
	default:
		break;
	}

	return NOTIFY_DONE;
}

S
Stephen Hemminger 已提交
3380 3381
static int bond_slave_netdev_event(unsigned long event,
				   struct net_device *slave_dev)
L
Linus Torvalds 已提交
3382 3383
{
	struct net_device *bond_dev = slave_dev->master;
3384
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3385 3386 3387 3388

	switch (event) {
	case NETDEV_UNREGISTER:
		if (bond_dev) {
3389 3390 3391 3392
			if (bond->setup_by_slave)
				bond_release_and_destroy(bond_dev, slave_dev);
			else
				bond_release(bond_dev, slave_dev);
L
Linus Torvalds 已提交
3393 3394 3395
		}
		break;
	case NETDEV_CHANGE:
3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415
		if (bond->params.mode == BOND_MODE_8023AD || bond_is_lb(bond)) {
			struct slave *slave;

			slave = bond_get_slave_by_dev(bond, slave_dev);
			if (slave) {
				u16 old_speed = slave->speed;
				u16 old_duplex = slave->duplex;

				bond_update_speed_duplex(slave);

				if (bond_is_lb(bond))
					break;

				if (old_speed != slave->speed)
					bond_3ad_adapter_speed_changed(slave);
				if (old_duplex != slave->duplex)
					bond_3ad_adapter_duplex_changed(slave);
			}
		}

L
Linus Torvalds 已提交
3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440
		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;
3441 3442 3443
	case NETDEV_FEAT_CHANGE:
		bond_compute_features(bond);
		break;
L
Linus Torvalds 已提交
3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454
	default:
		break;
	}

	return NOTIFY_DONE;
}

/*
 * bond_netdev_event: handle netdev notifier chain events.
 *
 * This function receives events for the netdev chain.  The caller (an
3455
 * ioctl handler calling blocking_notifier_call_chain) holds the necessary
L
Linus Torvalds 已提交
3456 3457 3458
 * locks for us to safely manipulate the slave devices (RTNL lock,
 * dev_probe_lock).
 */
S
Stephen Hemminger 已提交
3459 3460
static int bond_netdev_event(struct notifier_block *this,
			     unsigned long event, void *ptr)
L
Linus Torvalds 已提交
3461 3462 3463
{
	struct net_device *event_dev = (struct net_device *)ptr;

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

3468 3469 3470
	if (!(event_dev->priv_flags & IFF_BONDING))
		return NOTIFY_DONE;

L
Linus Torvalds 已提交
3471
	if (event_dev->flags & IFF_MASTER) {
3472
		pr_debug("IFF_MASTER\n");
L
Linus Torvalds 已提交
3473 3474 3475 3476
		return bond_master_netdev_event(event, event_dev);
	}

	if (event_dev->flags & IFF_SLAVE) {
3477
		pr_debug("IFF_SLAVE\n");
L
Linus Torvalds 已提交
3478 3479 3480 3481 3482 3483
		return bond_slave_netdev_event(event, event_dev);
	}

	return NOTIFY_DONE;
}

J
Jay Vosburgh 已提交
3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495
/*
 * bond_inetaddr_event: handle inetaddr notifier chain events.
 *
 * We keep track of device IPs primarily to use as source addresses in
 * ARP monitor probes (rather than spewing out broadcasts all the time).
 *
 * We track one IP for the main device (if it has one), plus one per VLAN.
 */
static int bond_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
{
	struct in_ifaddr *ifa = ptr;
	struct net_device *vlan_dev, *event_dev = ifa->ifa_dev->dev;
3496
	struct bond_net *bn = net_generic(dev_net(event_dev), bond_net_id);
3497 3498
	struct bonding *bond;
	struct vlan_entry *vlan;
J
Jay Vosburgh 已提交
3499

3500
	list_for_each_entry(bond, &bn->dev_list, bond_list) {
J
Jay Vosburgh 已提交
3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513
		if (bond->dev == event_dev) {
			switch (event) {
			case NETDEV_UP:
				bond->master_ip = ifa->ifa_local;
				return NOTIFY_OK;
			case NETDEV_DOWN:
				bond->master_ip = bond_glean_dev_ip(bond->dev);
				return NOTIFY_OK;
			default:
				return NOTIFY_DONE;
			}
		}

3514
		list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
D
Dan Aloni 已提交
3515
			vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
J
Jay Vosburgh 已提交
3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533
			if (vlan_dev == event_dev) {
				switch (event) {
				case NETDEV_UP:
					vlan->vlan_ip = ifa->ifa_local;
					return NOTIFY_OK;
				case NETDEV_DOWN:
					vlan->vlan_ip =
						bond_glean_dev_ip(vlan_dev);
					return NOTIFY_OK;
				default:
					return NOTIFY_DONE;
				}
			}
		}
	}
	return NOTIFY_DONE;
}

L
Linus Torvalds 已提交
3534 3535 3536 3537
static struct notifier_block bond_netdev_notifier = {
	.notifier_call = bond_netdev_event,
};

J
Jay Vosburgh 已提交
3538 3539 3540 3541
static struct notifier_block bond_inetaddr_notifier = {
	.notifier_call = bond_inetaddr_event,
};

L
Linus Torvalds 已提交
3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562
/*-------------------------- Packet type handling ---------------------------*/

/* register to receive lacpdus on a bond */
static void bond_register_lacpdu(struct bonding *bond)
{
	struct packet_type *pk_type = &(BOND_AD_INFO(bond).ad_pkt_type);

	/* initialize packet type */
	pk_type->type = PKT_TYPE_LACPDU;
	pk_type->dev = bond->dev;
	pk_type->func = bond_3ad_lacpdu_recv;

	dev_add_pack(pk_type);
}

/* unregister to receive lacpdus on a bond */
static void bond_unregister_lacpdu(struct bonding *bond)
{
	dev_remove_pack(&(BOND_AD_INFO(bond).ad_pkt_type));
}

3563 3564 3565 3566
void bond_register_arp(struct bonding *bond)
{
	struct packet_type *pt = &bond->arp_mon_pt;

J
Jay Vosburgh 已提交
3567 3568 3569
	if (pt->type)
		return;

3570
	pt->type = htons(ETH_P_ARP);
J
Jay Vosburgh 已提交
3571
	pt->dev = bond->dev;
3572 3573 3574 3575 3576 3577
	pt->func = bond_arp_rcv;
	dev_add_pack(pt);
}

void bond_unregister_arp(struct bonding *bond)
{
J
Jay Vosburgh 已提交
3578 3579 3580 3581
	struct packet_type *pt = &bond->arp_mon_pt;

	dev_remove_pack(pt);
	pt->type = 0;
3582 3583
}

3584 3585
/*---------------------------- Hashing Policies -----------------------------*/

3586 3587 3588 3589
/*
 * Hash for the output device based upon layer 2 and layer 3 data. If
 * the packet is not IP mimic bond_xmit_hash_policy_l2()
 */
3590
static int bond_xmit_hash_policy_l23(struct sk_buff *skb, int count)
3591 3592 3593 3594
{
	struct ethhdr *data = (struct ethhdr *)skb->data;
	struct iphdr *iph = ip_hdr(skb);

3595
	if (skb->protocol == htons(ETH_P_IP)) {
3596
		return ((ntohl(iph->saddr ^ iph->daddr) & 0xffff) ^
3597
			(data->h_dest[5] ^ data->h_source[5])) % count;
3598 3599
	}

3600
	return (data->h_dest[5] ^ data->h_source[5]) % count;
3601 3602
}

3603
/*
3604
 * Hash for the output device based upon layer 3 and layer 4 data. If
3605 3606 3607
 * the packet is a frag or not TCP or UDP, just use layer 3 data.  If it is
 * altogether not IP, mimic bond_xmit_hash_policy_l2()
 */
3608
static int bond_xmit_hash_policy_l34(struct sk_buff *skb, int count)
3609 3610
{
	struct ethhdr *data = (struct ethhdr *)skb->data;
3611
	struct iphdr *iph = ip_hdr(skb);
3612
	__be16 *layer4hdr = (__be16 *)((u32 *)iph + iph->ihl);
3613 3614
	int layer4_xor = 0;

3615 3616
	if (skb->protocol == htons(ETH_P_IP)) {
		if (!(iph->frag_off & htons(IP_MF|IP_OFFSET)) &&
3617 3618
		    (iph->protocol == IPPROTO_TCP ||
		     iph->protocol == IPPROTO_UDP)) {
3619
			layer4_xor = ntohs((*layer4hdr ^ *(layer4hdr + 1)));
3620 3621 3622 3623 3624 3625
		}
		return (layer4_xor ^
			((ntohl(iph->saddr ^ iph->daddr)) & 0xffff)) % count;

	}

3626
	return (data->h_dest[5] ^ data->h_source[5]) % count;
3627 3628 3629 3630 3631
}

/*
 * Hash for the output device based upon layer 2 data
 */
3632
static int bond_xmit_hash_policy_l2(struct sk_buff *skb, int count)
3633 3634 3635
{
	struct ethhdr *data = (struct ethhdr *)skb->data;

3636
	return (data->h_dest[5] ^ data->h_source[5]) % count;
3637 3638
}

L
Linus Torvalds 已提交
3639 3640 3641 3642
/*-------------------------- Device entry points ----------------------------*/

static int bond_open(struct net_device *bond_dev)
{
3643
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3644 3645 3646

	bond->kill_timers = 0;

3647
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
3648 3649 3650 3651 3652 3653 3654 3655
		/* bond_alb_initialize must be called before the timer
		 * is started.
		 */
		if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB))) {
			/* something went wrong - fail the open operation */
			return -1;
		}

3656 3657
		INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
		queue_delayed_work(bond->wq, &bond->alb_work, 0);
L
Linus Torvalds 已提交
3658 3659 3660
	}

	if (bond->params.miimon) {  /* link check interval, in milliseconds. */
3661 3662
		INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor);
		queue_delayed_work(bond->wq, &bond->mii_work, 0);
L
Linus Torvalds 已提交
3663 3664 3665
	}

	if (bond->params.arp_interval) {  /* arp interval, in milliseconds. */
3666 3667 3668 3669 3670 3671 3672 3673
		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);

		queue_delayed_work(bond->wq, &bond->arp_work, 0);
3674 3675
		if (bond->params.arp_validate)
			bond_register_arp(bond);
L
Linus Torvalds 已提交
3676 3677 3678
	}

	if (bond->params.mode == BOND_MODE_8023AD) {
3679
		INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
3680
		queue_delayed_work(bond->wq, &bond->ad_work, 0);
L
Linus Torvalds 已提交
3681 3682
		/* register to receive LACPDUs */
		bond_register_lacpdu(bond);
3683
		bond_3ad_initiate_agg_selection(bond, 1);
L
Linus Torvalds 已提交
3684 3685 3686 3687 3688 3689 3690
	}

	return 0;
}

static int bond_close(struct net_device *bond_dev)
{
3691
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3692 3693 3694 3695 3696 3697

	if (bond->params.mode == BOND_MODE_8023AD) {
		/* Unregister the receive of LACPDUs */
		bond_unregister_lacpdu(bond);
	}

3698 3699 3700
	if (bond->params.arp_validate)
		bond_unregister_arp(bond);

L
Linus Torvalds 已提交
3701 3702
	write_lock_bh(&bond->lock);

3703
	bond->send_grat_arp = 0;
3704
	bond->send_unsol_na = 0;
L
Linus Torvalds 已提交
3705 3706 3707 3708 3709 3710 3711

	/* signal timers not to re-arm */
	bond->kill_timers = 1;

	write_unlock_bh(&bond->lock);

	if (bond->params.miimon) {  /* link check interval, in milliseconds. */
3712
		cancel_delayed_work(&bond->mii_work);
L
Linus Torvalds 已提交
3713 3714 3715
	}

	if (bond->params.arp_interval) {  /* arp interval, in milliseconds. */
3716
		cancel_delayed_work(&bond->arp_work);
L
Linus Torvalds 已提交
3717 3718 3719 3720
	}

	switch (bond->params.mode) {
	case BOND_MODE_8023AD:
3721
		cancel_delayed_work(&bond->ad_work);
L
Linus Torvalds 已提交
3722 3723 3724
		break;
	case BOND_MODE_TLB:
	case BOND_MODE_ALB:
3725
		cancel_delayed_work(&bond->alb_work);
L
Linus Torvalds 已提交
3726 3727 3728 3729 3730 3731
		break;
	default:
		break;
	}


3732
	if (bond_is_lb(bond)) {
L
Linus Torvalds 已提交
3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743
		/* Must be called only after all
		 * slaves have been released
		 */
		bond_alb_deinitialize(bond);
	}

	return 0;
}

static struct net_device_stats *bond_get_stats(struct net_device *bond_dev)
{
3744
	struct bonding *bond = netdev_priv(bond_dev);
3745
	struct net_device_stats *stats = &bond->stats;
3746
	struct net_device_stats local_stats;
L
Linus Torvalds 已提交
3747 3748 3749
	struct slave *slave;
	int i;

3750
	memset(&local_stats, 0, sizeof(struct net_device_stats));
L
Linus Torvalds 已提交
3751 3752 3753 3754

	read_lock_bh(&bond->lock);

	bond_for_each_slave(bond, slave, i) {
3755 3756
		const struct net_device_stats *sstats = dev_get_stats(slave->dev);

3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784
		local_stats.rx_packets += sstats->rx_packets;
		local_stats.rx_bytes += sstats->rx_bytes;
		local_stats.rx_errors += sstats->rx_errors;
		local_stats.rx_dropped += sstats->rx_dropped;

		local_stats.tx_packets += sstats->tx_packets;
		local_stats.tx_bytes += sstats->tx_bytes;
		local_stats.tx_errors += sstats->tx_errors;
		local_stats.tx_dropped += sstats->tx_dropped;

		local_stats.multicast += sstats->multicast;
		local_stats.collisions += sstats->collisions;

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

		local_stats.tx_aborted_errors += sstats->tx_aborted_errors;
		local_stats.tx_carrier_errors += sstats->tx_carrier_errors;
		local_stats.tx_fifo_errors += sstats->tx_fifo_errors;
		local_stats.tx_heartbeat_errors += sstats->tx_heartbeat_errors;
		local_stats.tx_window_errors += sstats->tx_window_errors;
	}

	memcpy(stats, &local_stats, sizeof(struct net_device_stats));
L
Linus Torvalds 已提交
3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800

	read_unlock_bh(&bond->lock);

	return stats;
}

static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
{
	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;
	int res = 0;

J
Joe Perches 已提交
3801
	pr_debug("bond_ioctl: master=%s, cmd=%d\n", bond_dev->name, cmd);
L
Linus Torvalds 已提交
3802 3803 3804 3805

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

L
Linus Torvalds 已提交
3809 3810 3811 3812 3813 3814 3815 3816
		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 已提交
3817
		if (!mii)
L
Linus Torvalds 已提交
3818
			return -EINVAL;
S
Stephen Hemminger 已提交
3819

L
Linus Torvalds 已提交
3820 3821

		if (mii->reg_num == 1) {
3822
			struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3823
			mii->val_out = 0;
3824
			read_lock(&bond->lock);
L
Linus Torvalds 已提交
3825
			read_lock(&bond->curr_slave_lock);
S
Stephen Hemminger 已提交
3826
			if (netif_carrier_ok(bond->dev))
L
Linus Torvalds 已提交
3827
				mii->val_out = BMSR_LSTATUS;
S
Stephen Hemminger 已提交
3828

L
Linus Torvalds 已提交
3829
			read_unlock(&bond->curr_slave_lock);
3830
			read_unlock(&bond->lock);
L
Linus Torvalds 已提交
3831 3832 3833 3834 3835 3836 3837
		}

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

S
Stephen Hemminger 已提交
3838
		if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond)))
L
Linus Torvalds 已提交
3839 3840 3841
			return -EFAULT;

		res = bond_info_query(bond_dev, &k_binfo);
S
Stephen Hemminger 已提交
3842 3843 3844
		if (res == 0 &&
		    copy_to_user(u_binfo, &k_binfo, sizeof(ifbond)))
			return -EFAULT;
L
Linus Torvalds 已提交
3845 3846 3847 3848 3849 3850

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

S
Stephen Hemminger 已提交
3851
		if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave)))
L
Linus Torvalds 已提交
3852 3853 3854
			return -EFAULT;

		res = bond_slave_info_query(bond_dev, &k_sinfo);
S
Stephen Hemminger 已提交
3855 3856 3857
		if (res == 0 &&
		    copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave)))
			return -EFAULT;
L
Linus Torvalds 已提交
3858 3859 3860 3861 3862 3863 3864

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

S
Stephen Hemminger 已提交
3865
	if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
3866 3867
		return -EPERM;

3868
	slave_dev = dev_get_by_name(dev_net(bond_dev), ifr->ifr_slave);
L
Linus Torvalds 已提交
3869

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

S
Stephen Hemminger 已提交
3872
	if (!slave_dev)
L
Linus Torvalds 已提交
3873
		res = -ENODEV;
S
Stephen Hemminger 已提交
3874
	else {
J
Joe Perches 已提交
3875
		pr_debug("slave_dev->name=%s:\n", slave_dev->name);
L
Linus Torvalds 已提交
3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904
		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:
			res = bond_sethwaddr(bond_dev, slave_dev);
			break;
		case BOND_CHANGE_ACTIVE_OLD:
		case SIOCBONDCHANGEACTIVE:
			res = bond_ioctl_change_active(bond_dev, slave_dev);
			break;
		default:
			res = -EOPNOTSUPP;
		}

		dev_put(slave_dev);
	}

	return res;
}

static void bond_set_multicast_list(struct net_device *bond_dev)
{
3905
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3906 3907 3908 3909 3910
	struct dev_mc_list *dmi;

	/*
	 * Do promisc before checking multicast_mode
	 */
S
Stephen Hemminger 已提交
3911
	if ((bond_dev->flags & IFF_PROMISC) && !(bond->flags & IFF_PROMISC))
3912 3913 3914 3915
		/*
		 * FIXME: Need to handle the error when one of the multi-slaves
		 * encounters error.
		 */
L
Linus Torvalds 已提交
3916 3917
		bond_set_promiscuity(bond, 1);

S
Stephen Hemminger 已提交
3918 3919

	if (!(bond_dev->flags & IFF_PROMISC) && (bond->flags & IFF_PROMISC))
L
Linus Torvalds 已提交
3920
		bond_set_promiscuity(bond, -1);
S
Stephen Hemminger 已提交
3921

L
Linus Torvalds 已提交
3922 3923

	/* set allmulti flag to slaves */
S
Stephen Hemminger 已提交
3924
	if ((bond_dev->flags & IFF_ALLMULTI) && !(bond->flags & IFF_ALLMULTI))
3925 3926 3927 3928
		/*
		 * FIXME: Need to handle the error when one of the multi-slaves
		 * encounters error.
		 */
L
Linus Torvalds 已提交
3929 3930
		bond_set_allmulti(bond, 1);

S
Stephen Hemminger 已提交
3931 3932

	if (!(bond_dev->flags & IFF_ALLMULTI) && (bond->flags & IFF_ALLMULTI))
L
Linus Torvalds 已提交
3933
		bond_set_allmulti(bond, -1);
S
Stephen Hemminger 已提交
3934

L
Linus Torvalds 已提交
3935

3936 3937
	read_lock(&bond->lock);

L
Linus Torvalds 已提交
3938 3939 3940 3941
	bond->flags = bond_dev->flags;

	/* looking for addresses to add to slaves' mc list */
	for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
S
Stephen Hemminger 已提交
3942
		if (!bond_mc_list_find_dmi(dmi, bond->mc_list))
L
Linus Torvalds 已提交
3943 3944 3945 3946 3947
			bond_mc_add(bond, dmi->dmi_addr, dmi->dmi_addrlen);
	}

	/* looking for addresses to delete from slaves' list */
	for (dmi = bond->mc_list; dmi; dmi = dmi->next) {
S
Stephen Hemminger 已提交
3948
		if (!bond_mc_list_find_dmi(dmi, bond_dev->mc_list))
L
Linus Torvalds 已提交
3949 3950 3951 3952 3953 3954 3955
			bond_mc_delete(bond, dmi->dmi_addr, dmi->dmi_addrlen);
	}

	/* save master's multicast list */
	bond_mc_list_destroy(bond);
	bond_mc_list_copy(bond_dev->mc_list, bond, GFP_ATOMIC);

3956
	read_unlock(&bond->lock);
L
Linus Torvalds 已提交
3957 3958
}

3959 3960 3961 3962 3963 3964 3965 3966 3967
static int bond_neigh_setup(struct net_device *dev, struct neigh_parms *parms)
{
	struct bonding *bond = netdev_priv(dev);
	struct slave *slave = bond->first_slave;

	if (slave) {
		const struct net_device_ops *slave_ops
			= slave->dev->netdev_ops;
		if (slave_ops->ndo_neigh_setup)
3968
			return slave_ops->ndo_neigh_setup(slave->dev, parms);
3969 3970 3971 3972
	}
	return 0;
}

L
Linus Torvalds 已提交
3973 3974 3975 3976 3977
/*
 * 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)
{
3978
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
3979 3980 3981 3982
	struct slave *slave, *stop_at;
	int res = 0;
	int i;

3983
	pr_debug("bond=%p, name=%s, new_mtu=%d\n", bond,
J
Joe Perches 已提交
3984
		 (bond_dev ? bond_dev->name : "None"), new_mtu);
L
Linus Torvalds 已提交
3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001

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

	bond_for_each_slave(bond, slave, i) {
J
Joe Perches 已提交
4002 4003 4004 4005
		pr_debug("s %p s->p %p c_m %p\n",
			 slave,
			 slave->prev,
			 slave->dev->netdev_ops->ndo_change_mtu);
4006

L
Linus Torvalds 已提交
4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017
		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.
			 */
4018
			pr_debug("err %d %s\n", res, slave->dev->name);
L
Linus Torvalds 已提交
4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
			goto unwind;
		}
	}

	bond_dev->mtu = new_mtu;

	return 0;

unwind:
	/* unwind from head to the slave that failed */
	stop_at = slave;
	bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
		int tmp_res;

		tmp_res = dev_set_mtu(slave->dev, bond_dev->mtu);
		if (tmp_res) {
J
Joe Perches 已提交
4035 4036
			pr_debug("unwind err %d dev %s\n",
				 tmp_res, slave->dev->name);
L
Linus Torvalds 已提交
4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051
		}
	}

	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)
{
4052
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
4053 4054 4055 4056 4057
	struct sockaddr *sa = addr, tmp_sa;
	struct slave *slave, *stop_at;
	int res = 0;
	int i;

4058 4059 4060 4061
	if (bond->params.mode == BOND_MODE_ALB)
		return bond_alb_set_mac_address(bond_dev, addr);


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

4065
	/*
4066 4067
	 * If fail_over_mac is set to active, do nothing and return
	 * success.  Returning an error causes ifenslave to fail.
4068
	 */
4069
	if (bond->params.fail_over_mac == BOND_FOM_ACTIVE)
4070
		return 0;
4071

S
Stephen Hemminger 已提交
4072
	if (!is_valid_ether_addr(sa->sa_data))
L
Linus Torvalds 已提交
4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090
		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.
	 */

	bond_for_each_slave(bond, slave, i) {
4091
		const struct net_device_ops *slave_ops = slave->dev->netdev_ops;
4092
		pr_debug("slave %p %s\n", slave, slave->dev->name);
L
Linus Torvalds 已提交
4093

4094
		if (slave_ops->ndo_set_mac_address == NULL) {
L
Linus Torvalds 已提交
4095
			res = -EOPNOTSUPP;
4096
			pr_debug("EOPNOTSUPP %s\n", slave->dev->name);
L
Linus Torvalds 已提交
4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107
			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...
			 */
4108
			pr_debug("err %d %s\n", res, slave->dev->name);
L
Linus Torvalds 已提交
4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127
			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 */
	stop_at = slave;
	bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
		int tmp_res;

		tmp_res = dev_set_mac_address(slave->dev, &tmp_sa);
		if (tmp_res) {
J
Joe Perches 已提交
4128 4129
			pr_debug("unwind err %d dev %s\n",
				 tmp_res, slave->dev->name);
L
Linus Torvalds 已提交
4130 4131 4132 4133 4134 4135 4136 4137
		}
	}

	return res;
}

static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
{
4138
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
4139
	struct slave *slave, *start_at;
4140
	int i, slave_no, res = 1;
L
Linus Torvalds 已提交
4141 4142 4143

	read_lock(&bond->lock);

S
Stephen Hemminger 已提交
4144
	if (!BOND_IS_OK(bond))
L
Linus Torvalds 已提交
4145 4146
		goto out;

4147 4148 4149 4150 4151
	/*
	 * Concurrent TX may collide on rr_tx_counter; we accept that
	 * as being rare enough not to justify using an atomic op here
	 */
	slave_no = bond->rr_tx_counter++ % bond->slave_cnt;
L
Linus Torvalds 已提交
4152

4153 4154
	bond_for_each_slave(bond, slave, i) {
		slave_no--;
S
Stephen Hemminger 已提交
4155
		if (slave_no < 0)
4156
			break;
L
Linus Torvalds 已提交
4157 4158
	}

4159
	start_at = slave;
L
Linus Torvalds 已提交
4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174
	bond_for_each_slave_from(bond, slave, i, start_at) {
		if (IS_UP(slave->dev) &&
		    (slave->link == BOND_LINK_UP) &&
		    (slave->state == BOND_STATE_ACTIVE)) {
			res = bond_dev_queue_xmit(bond, skb, slave->dev);
			break;
		}
	}

out:
	if (res) {
		/* no suitable interface, frame not sent */
		dev_kfree_skb(skb);
	}
	read_unlock(&bond->lock);
4175
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
4176 4177
}

4178

L
Linus Torvalds 已提交
4179 4180 4181 4182 4183 4184
/*
 * 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)
{
4185
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
4186 4187 4188 4189 4190
	int res = 1;

	read_lock(&bond->lock);
	read_lock(&bond->curr_slave_lock);

S
Stephen Hemminger 已提交
4191
	if (!BOND_IS_OK(bond))
L
Linus Torvalds 已提交
4192 4193
		goto out;

4194 4195 4196 4197 4198
	if (!bond->curr_active_slave)
		goto out;

	res = bond_dev_queue_xmit(bond, skb, bond->curr_active_slave->dev);

L
Linus Torvalds 已提交
4199
out:
S
Stephen Hemminger 已提交
4200
	if (res)
L
Linus Torvalds 已提交
4201 4202
		/* no suitable interface, frame not sent */
		dev_kfree_skb(skb);
S
Stephen Hemminger 已提交
4203

L
Linus Torvalds 已提交
4204 4205
	read_unlock(&bond->curr_slave_lock);
	read_unlock(&bond->lock);
4206
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
4207 4208 4209
}

/*
4210 4211 4212
 * In bond_xmit_xor() , we determine the output device by using a pre-
 * determined xmit_hash_policy(), If the selected device is not enabled,
 * find the next active slave.
L
Linus Torvalds 已提交
4213 4214 4215
 */
static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
{
4216
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
4217 4218 4219 4220 4221 4222 4223
	struct slave *slave, *start_at;
	int slave_no;
	int i;
	int res = 1;

	read_lock(&bond->lock);

S
Stephen Hemminger 已提交
4224
	if (!BOND_IS_OK(bond))
L
Linus Torvalds 已提交
4225 4226
		goto out;

4227
	slave_no = bond->xmit_hash_policy(skb, bond->slave_cnt);
L
Linus Torvalds 已提交
4228 4229 4230

	bond_for_each_slave(bond, slave, i) {
		slave_no--;
S
Stephen Hemminger 已提交
4231
		if (slave_no < 0)
L
Linus Torvalds 已提交
4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251
			break;
	}

	start_at = slave;

	bond_for_each_slave_from(bond, slave, i, start_at) {
		if (IS_UP(slave->dev) &&
		    (slave->link == BOND_LINK_UP) &&
		    (slave->state == BOND_STATE_ACTIVE)) {
			res = bond_dev_queue_xmit(bond, skb, slave->dev);
			break;
		}
	}

out:
	if (res) {
		/* no suitable interface, frame not sent */
		dev_kfree_skb(skb);
	}
	read_unlock(&bond->lock);
4252
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
4253 4254 4255 4256 4257 4258 4259
}

/*
 * in broadcast mode, we send everything to all usable interfaces.
 */
static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
{
4260
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
4261 4262 4263 4264 4265 4266 4267
	struct slave *slave, *start_at;
	struct net_device *tx_dev = NULL;
	int i;
	int res = 1;

	read_lock(&bond->lock);

S
Stephen Hemminger 已提交
4268
	if (!BOND_IS_OK(bond))
L
Linus Torvalds 已提交
4269 4270 4271 4272 4273 4274
		goto out;

	read_lock(&bond->curr_slave_lock);
	start_at = bond->curr_active_slave;
	read_unlock(&bond->curr_slave_lock);

S
Stephen Hemminger 已提交
4275
	if (!start_at)
L
Linus Torvalds 已提交
4276 4277 4278 4279 4280 4281 4282 4283 4284
		goto out;

	bond_for_each_slave_from(bond, slave, i, start_at) {
		if (IS_UP(slave->dev) &&
		    (slave->link == BOND_LINK_UP) &&
		    (slave->state == BOND_STATE_ACTIVE)) {
			if (tx_dev) {
				struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
				if (!skb2) {
J
Joe Perches 已提交
4285
					pr_err("%s: Error: bond_xmit_broadcast(): skb_clone() failed\n",
4286
					       bond_dev->name);
L
Linus Torvalds 已提交
4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299
					continue;
				}

				res = bond_dev_queue_xmit(bond, skb2, tx_dev);
				if (res) {
					dev_kfree_skb(skb2);
					continue;
				}
			}
			tx_dev = slave->dev;
		}
	}

S
Stephen Hemminger 已提交
4300
	if (tx_dev)
L
Linus Torvalds 已提交
4301 4302 4303
		res = bond_dev_queue_xmit(bond, skb, tx_dev);

out:
S
Stephen Hemminger 已提交
4304
	if (res)
L
Linus Torvalds 已提交
4305 4306
		/* no suitable interface, frame not sent */
		dev_kfree_skb(skb);
S
Stephen Hemminger 已提交
4307

L
Linus Torvalds 已提交
4308 4309
	/* frame sent to all suitable interfaces */
	read_unlock(&bond->lock);
4310
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
4311 4312 4313 4314
}

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

4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330
static void bond_set_xmit_hash_policy(struct bonding *bond)
{
	switch (bond->params.xmit_policy) {
	case BOND_XMIT_POLICY_LAYER23:
		bond->xmit_hash_policy = bond_xmit_hash_policy_l23;
		break;
	case BOND_XMIT_POLICY_LAYER34:
		bond->xmit_hash_policy = bond_xmit_hash_policy_l34;
		break;
	case BOND_XMIT_POLICY_LAYER2:
	default:
		bond->xmit_hash_policy = bond_xmit_hash_policy_l2;
		break;
	}
}

4331
static netdev_tx_t bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350
{
	const struct bonding *bond = netdev_priv(dev);

	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 已提交
4351 4352
		pr_err("%s: Error: Unknown bonding mode %d\n",
		       dev->name, bond->params.mode);
4353 4354 4355 4356 4357 4358 4359
		WARN_ON_ONCE(1);
		dev_kfree_skb(skb);
		return NETDEV_TX_OK;
	}
}


L
Linus Torvalds 已提交
4360 4361 4362
/*
 * set bond mode specific net device operations
 */
4363
void bond_set_mode_ops(struct bonding *bond, int mode)
L
Linus Torvalds 已提交
4364
{
4365 4366
	struct net_device *bond_dev = bond->dev;

L
Linus Torvalds 已提交
4367 4368 4369 4370 4371 4372
	switch (mode) {
	case BOND_MODE_ROUNDROBIN:
		break;
	case BOND_MODE_ACTIVEBACKUP:
		break;
	case BOND_MODE_XOR:
4373
		bond_set_xmit_hash_policy(bond);
L
Linus Torvalds 已提交
4374 4375 4376 4377
		break;
	case BOND_MODE_BROADCAST:
		break;
	case BOND_MODE_8023AD:
4378
		bond_set_master_3ad_flags(bond);
4379
		bond_set_xmit_hash_policy(bond);
L
Linus Torvalds 已提交
4380 4381
		break;
	case BOND_MODE_ALB:
4382 4383 4384
		bond_set_master_alb_flags(bond);
		/* FALLTHRU */
	case BOND_MODE_TLB:
L
Linus Torvalds 已提交
4385 4386 4387
		break;
	default:
		/* Should never happen, mode already checked */
J
Joe Perches 已提交
4388 4389
		pr_err("%s: Error: Unknown bonding mode %d\n",
		       bond_dev->name, mode);
L
Linus Torvalds 已提交
4390 4391 4392 4393
		break;
	}
}

4394 4395 4396 4397 4398 4399 4400 4401
static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
				    struct ethtool_drvinfo *drvinfo)
{
	strncpy(drvinfo->driver, DRV_NAME, 32);
	strncpy(drvinfo->version, DRV_VERSION, 32);
	snprintf(drvinfo->fw_version, 32, "%d", BOND_ABI_VERSION);
}

4402
static const struct ethtool_ops bond_ethtool_ops = {
4403
	.get_drvinfo		= bond_ethtool_get_drvinfo,
4404 4405 4406 4407 4408 4409
	.get_link		= ethtool_op_get_link,
	.get_tx_csum		= ethtool_op_get_tx_csum,
	.get_sg			= ethtool_op_get_sg,
	.get_tso		= ethtool_op_get_tso,
	.get_ufo		= ethtool_op_get_ufo,
	.get_flags		= ethtool_op_get_flags,
4410 4411
};

4412
static const struct net_device_ops bond_netdev_ops = {
4413
	.ndo_init		= bond_init,
S
Stephen Hemminger 已提交
4414
	.ndo_uninit		= bond_uninit,
4415 4416
	.ndo_open		= bond_open,
	.ndo_stop		= bond_close,
4417
	.ndo_start_xmit		= bond_start_xmit,
4418 4419 4420 4421 4422
	.ndo_get_stats		= bond_get_stats,
	.ndo_do_ioctl		= bond_do_ioctl,
	.ndo_set_multicast_list	= bond_set_multicast_list,
	.ndo_change_mtu		= bond_change_mtu,
	.ndo_set_mac_address 	= bond_set_mac_address,
4423
	.ndo_neigh_setup	= bond_neigh_setup,
4424 4425 4426 4427 4428
	.ndo_vlan_rx_register	= bond_vlan_rx_register,
	.ndo_vlan_rx_add_vid 	= bond_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid	= bond_vlan_rx_kill_vid,
};

4429
static void bond_setup(struct net_device *bond_dev)
L
Linus Torvalds 已提交
4430
{
4431
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
4432 4433 4434 4435 4436

	/* initialize rwlocks */
	rwlock_init(&bond->lock);
	rwlock_init(&bond->curr_slave_lock);

4437
	bond->params = bonding_defaults;
L
Linus Torvalds 已提交
4438 4439 4440 4441 4442 4443

	/* Initialize pointers */
	bond->dev = bond_dev;
	INIT_LIST_HEAD(&bond->vlan_list);

	/* Initialize the device entry points */
4444
	ether_setup(bond_dev);
4445
	bond_dev->netdev_ops = &bond_netdev_ops;
4446
	bond_dev->ethtool_ops = &bond_ethtool_ops;
4447
	bond_set_mode_ops(bond, bond->params.mode);
L
Linus Torvalds 已提交
4448

S
Stephen Hemminger 已提交
4449
	bond_dev->destructor = free_netdev;
L
Linus Torvalds 已提交
4450 4451 4452 4453

	/* Initialize the device options */
	bond_dev->tx_queue_len = 0;
	bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
4454
	bond_dev->priv_flags |= IFF_BONDING;
4455 4456
	bond_dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;

4457 4458
	if (bond->params.arp_interval)
		bond_dev->priv_flags |= IFF_MASTER_ARPMON;
L
Linus Torvalds 已提交
4459 4460 4461 4462 4463 4464 4465 4466

	/* 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 已提交
4467
	/* don't acquire bond device's netif_tx_lock when
L
Linus Torvalds 已提交
4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482
	 * 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
	 */
	bond_dev->features |= (NETIF_F_HW_VLAN_TX |
			       NETIF_F_HW_VLAN_RX |
			       NETIF_F_HW_VLAN_FILTER);

}

J
Jay Vosburgh 已提交
4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503
static void bond_work_cancel_all(struct bonding *bond)
{
	write_lock_bh(&bond->lock);
	bond->kill_timers = 1;
	write_unlock_bh(&bond->lock);

	if (bond->params.miimon && delayed_work_pending(&bond->mii_work))
		cancel_delayed_work(&bond->mii_work);

	if (bond->params.arp_interval && delayed_work_pending(&bond->arp_work))
		cancel_delayed_work(&bond->arp_work);

	if (bond->params.mode == BOND_MODE_ALB &&
	    delayed_work_pending(&bond->alb_work))
		cancel_delayed_work(&bond->alb_work);

	if (bond->params.mode == BOND_MODE_8023AD &&
	    delayed_work_pending(&bond->ad_work))
		cancel_delayed_work(&bond->ad_work);
}

4504 4505 4506 4507 4508
/*
* 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 已提交
4509
{
4510
	struct bonding *bond = netdev_priv(bond_dev);
J
Jay Vosburgh 已提交
4511

4512 4513 4514
	/* Release the bonded slaves */
	bond_release_all(bond_dev);

J
Jay Vosburgh 已提交
4515 4516 4517 4518 4519
	list_del(&bond->bond_list);

	bond_work_cancel_all(bond);

	bond_remove_proc_entry(bond);
4520 4521 4522 4523 4524 4525 4526

	if (bond->wq)
		destroy_workqueue(bond->wq);

	netif_addr_lock_bh(bond_dev);
	bond_mc_list_destroy(bond);
	netif_addr_unlock_bh(bond_dev);
J
Jay Vosburgh 已提交
4527 4528
}

L
Linus Torvalds 已提交
4529 4530 4531 4532
/*------------------------- Module initialization ---------------------------*/

/*
 * Convert string input module parms.  Accept either the
J
Jay Vosburgh 已提交
4533 4534 4535
 * 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 已提交
4536
 */
4537
int bond_parse_parm(const char *buf, const struct bond_parm_tbl *tbl)
L
Linus Torvalds 已提交
4538
{
4539
	int modeint = -1, i, rv;
J
Jay Vosburgh 已提交
4540
	char *p, modestr[BOND_MAX_MODENAME_LEN + 1] = { 0, };
J
Jay Vosburgh 已提交
4541

J
Jay Vosburgh 已提交
4542 4543 4544 4545 4546
	for (p = (char *)buf; *p; p++)
		if (!(isdigit(*p) || isspace(*p)))
			break;

	if (*p)
J
Jay Vosburgh 已提交
4547
		rv = sscanf(buf, "%20s", modestr);
J
Jay Vosburgh 已提交
4548
	else
4549
		rv = sscanf(buf, "%d", &modeint);
J
Jay Vosburgh 已提交
4550 4551 4552

	if (!rv)
		return -1;
L
Linus Torvalds 已提交
4553 4554

	for (i = 0; tbl[i].modename; i++) {
4555
		if (modeint == tbl[i].mode)
J
Jay Vosburgh 已提交
4556 4557
			return tbl[i].mode;
		if (strcmp(modestr, tbl[i].modename) == 0)
L
Linus Torvalds 已提交
4558 4559 4560 4561 4562 4563 4564 4565
			return tbl[i].mode;
	}

	return -1;
}

static int bond_check_params(struct bond_params *params)
{
4566
	int arp_validate_value, fail_over_mac_value, primary_reselect_value;
4567

L
Linus Torvalds 已提交
4568 4569 4570 4571 4572 4573
	/*
	 * Convert string parameters.
	 */
	if (mode) {
		bond_mode = bond_parse_parm(mode, bond_mode_tbl);
		if (bond_mode == -1) {
J
Joe Perches 已提交
4574
			pr_err("Error: Invalid bonding mode \"%s\"\n",
L
Linus Torvalds 已提交
4575 4576 4577 4578 4579
			       mode == NULL ? "NULL" : mode);
			return -EINVAL;
		}
	}

4580 4581 4582
	if (xmit_hash_policy) {
		if ((bond_mode != BOND_MODE_XOR) &&
		    (bond_mode != BOND_MODE_8023AD)) {
J
Joe Perches 已提交
4583
			pr_info("xmit_hash_policy param is irrelevant in mode %s\n",
4584 4585 4586 4587 4588
			       bond_mode_name(bond_mode));
		} else {
			xmit_hashtype = bond_parse_parm(xmit_hash_policy,
							xmit_hashtype_tbl);
			if (xmit_hashtype == -1) {
J
Joe Perches 已提交
4589
				pr_err("Error: Invalid xmit_hash_policy \"%s\"\n",
S
Stephen Hemminger 已提交
4590
				       xmit_hash_policy == NULL ? "NULL" :
4591 4592 4593 4594 4595 4596
				       xmit_hash_policy);
				return -EINVAL;
			}
		}
	}

L
Linus Torvalds 已提交
4597 4598
	if (lacp_rate) {
		if (bond_mode != BOND_MODE_8023AD) {
J
Joe Perches 已提交
4599 4600
			pr_info("lacp_rate param is irrelevant in mode %s\n",
				bond_mode_name(bond_mode));
L
Linus Torvalds 已提交
4601 4602 4603
		} else {
			lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl);
			if (lacp_fast == -1) {
J
Joe Perches 已提交
4604
				pr_err("Error: Invalid lacp rate \"%s\"\n",
L
Linus Torvalds 已提交
4605 4606 4607 4608 4609 4610
				       lacp_rate == NULL ? "NULL" : lacp_rate);
				return -EINVAL;
			}
		}
	}

4611 4612 4613
	if (ad_select) {
		params->ad_select = bond_parse_parm(ad_select, ad_select_tbl);
		if (params->ad_select == -1) {
J
Joe Perches 已提交
4614
			pr_err("Error: Invalid ad_select \"%s\"\n",
4615 4616 4617 4618 4619
			       ad_select == NULL ? "NULL" : ad_select);
			return -EINVAL;
		}

		if (bond_mode != BOND_MODE_8023AD) {
J
Joe Perches 已提交
4620
			pr_warning("ad_select param only affects 802.3ad mode\n");
4621 4622 4623 4624 4625
		}
	} else {
		params->ad_select = BOND_AD_STABLE;
	}

4626
	if (max_bonds < 0) {
J
Joe Perches 已提交
4627 4628
		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 已提交
4629 4630 4631 4632
		max_bonds = BOND_DEFAULT_MAX_BONDS;
	}

	if (miimon < 0) {
J
Joe Perches 已提交
4633 4634
		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 已提交
4635 4636 4637 4638
		miimon = BOND_LINK_MON_INTERV;
	}

	if (updelay < 0) {
J
Joe Perches 已提交
4639 4640
		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 已提交
4641 4642 4643 4644
		updelay = 0;
	}

	if (downdelay < 0) {
J
Joe Perches 已提交
4645 4646
		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 已提交
4647 4648 4649 4650
		downdelay = 0;
	}

	if ((use_carrier != 0) && (use_carrier != 1)) {
J
Joe Perches 已提交
4651 4652
		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 已提交
4653 4654 4655
		use_carrier = 1;
	}

4656
	if (num_grat_arp < 0 || num_grat_arp > 255) {
J
Joe Perches 已提交
4657 4658
		pr_warning("Warning: num_grat_arp (%d) not in range 0-255 so it was reset to 1 \n",
			   num_grat_arp);
4659 4660 4661
		num_grat_arp = 1;
	}

4662
	if (num_unsol_na < 0 || num_unsol_na > 255) {
J
Joe Perches 已提交
4663 4664
		pr_warning("Warning: num_unsol_na (%d) not in range 0-255 so it was reset to 1 \n",
			   num_unsol_na);
4665 4666 4667
		num_unsol_na = 1;
	}

L
Linus Torvalds 已提交
4668 4669 4670
	/* reset values for 802.3ad */
	if (bond_mode == BOND_MODE_8023AD) {
		if (!miimon) {
J
Joe Perches 已提交
4671
			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 已提交
4672
			pr_warning("Forcing miimon to 100msec\n");
L
Linus Torvalds 已提交
4673 4674 4675 4676 4677 4678 4679 4680
			miimon = 100;
		}
	}

	/* reset values for TLB/ALB */
	if ((bond_mode == BOND_MODE_TLB) ||
	    (bond_mode == BOND_MODE_ALB)) {
		if (!miimon) {
J
Joe Perches 已提交
4681
			pr_warning("Warning: miimon must be specified, otherwise bonding will not detect link failure and link speed which are essential for TLB/ALB load balancing\n");
S
Stephen Hemminger 已提交
4682
			pr_warning("Forcing miimon to 100msec\n");
L
Linus Torvalds 已提交
4683 4684 4685 4686 4687
			miimon = 100;
		}
	}

	if (bond_mode == BOND_MODE_ALB) {
J
Joe Perches 已提交
4688 4689
		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 已提交
4690 4691 4692 4693 4694 4695 4696
	}

	if (!miimon) {
		if (updelay || downdelay) {
			/* just warn the user the up/down delay will have
			 * no effect since miimon is zero...
			 */
J
Joe Perches 已提交
4697 4698
			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 已提交
4699 4700 4701 4702
		}
	} else {
		/* don't allow arp monitoring */
		if (arp_interval) {
J
Joe Perches 已提交
4703 4704
			pr_warning("Warning: miimon (%d) and arp_interval (%d) can't be used simultaneously, disabling ARP monitoring\n",
				   miimon, arp_interval);
L
Linus Torvalds 已提交
4705 4706 4707 4708
			arp_interval = 0;
		}

		if ((updelay % miimon) != 0) {
J
Joe Perches 已提交
4709 4710 4711
			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 已提交
4712 4713 4714 4715 4716
		}

		updelay /= miimon;

		if ((downdelay % miimon) != 0) {
J
Joe Perches 已提交
4717 4718 4719
			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 已提交
4720 4721 4722 4723 4724 4725
		}

		downdelay /= miimon;
	}

	if (arp_interval < 0) {
J
Joe Perches 已提交
4726 4727
		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 已提交
4728 4729 4730 4731 4732 4733 4734 4735 4736
		arp_interval = BOND_LINK_ARP_INTERV;
	}

	for (arp_ip_count = 0;
	     (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[arp_ip_count];
	     arp_ip_count++) {
		/* not complete check, but should be good enough to
		   catch mistakes */
		if (!isdigit(arp_ip_target[arp_ip_count][0])) {
J
Joe Perches 已提交
4737 4738
			pr_warning("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n",
				   arp_ip_target[arp_ip_count]);
L
Linus Torvalds 已提交
4739 4740
			arp_interval = 0;
		} else {
4741
			__be32 ip = in_aton(arp_ip_target[arp_ip_count]);
L
Linus Torvalds 已提交
4742 4743 4744 4745 4746 4747
			arp_target[arp_ip_count] = ip;
		}
	}

	if (arp_interval && !arp_ip_count) {
		/* don't allow arping if no arp_ip_target given... */
J
Joe Perches 已提交
4748 4749
		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 已提交
4750 4751 4752
		arp_interval = 0;
	}

4753 4754
	if (arp_validate) {
		if (bond_mode != BOND_MODE_ACTIVEBACKUP) {
J
Joe Perches 已提交
4755
			pr_err("arp_validate only supported in active-backup mode\n");
4756 4757 4758
			return -EINVAL;
		}
		if (!arp_interval) {
J
Joe Perches 已提交
4759
			pr_err("arp_validate requires arp_interval\n");
4760 4761 4762 4763 4764 4765
			return -EINVAL;
		}

		arp_validate_value = bond_parse_parm(arp_validate,
						     arp_validate_tbl);
		if (arp_validate_value == -1) {
J
Joe Perches 已提交
4766
			pr_err("Error: invalid arp_validate \"%s\"\n",
4767 4768 4769 4770 4771 4772
			       arp_validate == NULL ? "NULL" : arp_validate);
			return -EINVAL;
		}
	} else
		arp_validate_value = 0;

L
Linus Torvalds 已提交
4773
	if (miimon) {
J
Joe Perches 已提交
4774
		pr_info("MII link monitoring set to %d ms\n", miimon);
L
Linus Torvalds 已提交
4775 4776 4777
	} else if (arp_interval) {
		int i;

J
Joe Perches 已提交
4778 4779 4780 4781
		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 已提交
4782 4783

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

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

4788
	} else if (max_bonds) {
L
Linus Torvalds 已提交
4789 4790 4791
		/* miimon and arp_interval not set, we need one so things
		 * work as expected, see bonding.txt for details
		 */
J
Joe Perches 已提交
4792
		pr_warning("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 已提交
4793 4794 4795 4796 4797 4798
	}

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

4804 4805 4806 4807
	if (primary && primary_reselect) {
		primary_reselect_value = bond_parse_parm(primary_reselect,
							 pri_reselect_tbl);
		if (primary_reselect_value == -1) {
J
Joe Perches 已提交
4808
			pr_err("Error: Invalid primary_reselect \"%s\"\n",
4809 4810 4811 4812 4813 4814 4815 4816
			       primary_reselect ==
					NULL ? "NULL" : primary_reselect);
			return -EINVAL;
		}
	} else {
		primary_reselect_value = BOND_PRI_RESELECT_ALWAYS;
	}

4817 4818 4819 4820
	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 已提交
4821
			pr_err("Error: invalid fail_over_mac \"%s\"\n",
4822 4823 4824 4825 4826
			       arp_validate == NULL ? "NULL" : arp_validate);
			return -EINVAL;
		}

		if (bond_mode != BOND_MODE_ACTIVEBACKUP)
J
Joe Perches 已提交
4827
			pr_warning("Warning: fail_over_mac only affects active-backup mode.\n");
4828 4829 4830
	} else {
		fail_over_mac_value = BOND_FOM_NONE;
	}
4831

L
Linus Torvalds 已提交
4832 4833
	/* fill params struct with the proper values */
	params->mode = bond_mode;
4834
	params->xmit_policy = xmit_hashtype;
L
Linus Torvalds 已提交
4835
	params->miimon = miimon;
4836
	params->num_grat_arp = num_grat_arp;
4837
	params->num_unsol_na = num_unsol_na;
L
Linus Torvalds 已提交
4838
	params->arp_interval = arp_interval;
4839
	params->arp_validate = arp_validate_value;
L
Linus Torvalds 已提交
4840 4841 4842 4843 4844
	params->updelay = updelay;
	params->downdelay = downdelay;
	params->use_carrier = use_carrier;
	params->lacp_fast = lacp_fast;
	params->primary[0] = 0;
4845
	params->primary_reselect = primary_reselect_value;
4846
	params->fail_over_mac = fail_over_mac_value;
L
Linus Torvalds 已提交
4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857

	if (primary) {
		strncpy(params->primary, primary, IFNAMSIZ);
		params->primary[IFNAMSIZ - 1] = 0;
	}

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

	return 0;
}

4858
static struct lock_class_key bonding_netdev_xmit_lock_key;
4859
static struct lock_class_key bonding_netdev_addr_lock_key;
4860

4861 4862 4863
static void bond_set_lockdep_class_one(struct net_device *dev,
				       struct netdev_queue *txq,
				       void *_unused)
4864 4865 4866 4867 4868 4869 4870
{
	lockdep_set_class(&txq->_xmit_lock,
			  &bonding_netdev_xmit_lock_key);
}

static void bond_set_lockdep_class(struct net_device *dev)
{
4871 4872
	lockdep_set_class(&dev->addr_list_lock,
			  &bonding_netdev_addr_lock_key);
4873
	netdev_for_each_tx_queue(dev, bond_set_lockdep_class_one, NULL);
4874 4875
}

4876 4877 4878 4879 4880 4881
/*
 * Called from registration process
 */
static int bond_init(struct net_device *bond_dev)
{
	struct bonding *bond = netdev_priv(bond_dev);
4882
	struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894

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

	bond->wq = create_singlethread_workqueue(bond_dev->name);
	if (!bond->wq)
		return -ENOMEM;

	bond_set_lockdep_class(bond_dev);

	netif_carrier_off(bond_dev);

	bond_create_proc_entry(bond);
4895
	list_add_tail(&bond->bond_list, &bn->dev_list);
4896

4897
	bond_prepare_sysfs_group(bond);
4898 4899 4900
	return 0;
}

4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913
static int bond_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}
	return 0;
}

static struct rtnl_link_ops bond_link_ops __read_mostly = {
	.kind		= "bond",
4914
	.priv_size	= sizeof(struct bonding),
4915 4916 4917 4918
	.setup		= bond_setup,
	.validate	= bond_validate,
};

4919
/* Create a new bond based on the specified name and bonding parameters.
4920
 * If name is NULL, obtain a suitable "bond%d" name for us.
4921 4922 4923
 * Caller must NOT hold rtnl_lock; we need to release it here before we
 * set up our sysfs entries.
 */
4924
int bond_create(struct net *net, const char *name)
4925 4926 4927 4928 4929
{
	struct net_device *bond_dev;
	int res;

	rtnl_lock();
4930

4931
	bond_dev = alloc_netdev(sizeof(struct bonding), name ? name : "",
4932
				bond_setup);
4933
	if (!bond_dev) {
J
Joe Perches 已提交
4934
		pr_err("%s: eek! can't alloc netdev!\n", name);
4935
		res = -ENOMEM;
E
Eric W. Biederman 已提交
4936
		goto out;
4937 4938
	}

4939
	dev_net_set(bond_dev, net);
4940 4941
	bond_dev->rtnl_link_ops = &bond_link_ops;

4942 4943 4944 4945 4946 4947
	if (!name) {
		res = dev_alloc_name(bond_dev, "bond%d");
		if (res < 0)
			goto out_netdev;
	}

4948
	res = register_netdevice(bond_dev);
4949

E
Eric W. Biederman 已提交
4950
out:
4951
	rtnl_unlock();
E
Eric W. Biederman 已提交
4952
	return res;
4953 4954
out_netdev:
	free_netdev(bond_dev);
E
Eric W. Biederman 已提交
4955
	goto out;
4956 4957
}

4958 4959
static int bond_net_init(struct net *net)
{
4960
	struct bond_net *bn = net_generic(net, bond_net_id);
4961 4962 4963 4964 4965

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

	bond_create_proc_dir(bn);
4966 4967
	
	return 0;
4968 4969 4970 4971
}

static void bond_net_exit(struct net *net)
{
4972
	struct bond_net *bn = net_generic(net, bond_net_id);
4973 4974 4975 4976 4977 4978 4979

	bond_destroy_proc_dir(bn);
}

static struct pernet_operations bond_net_ops = {
	.init = bond_net_init,
	.exit = bond_net_exit,
4980 4981
	.id   = &bond_net_id,
	.size = sizeof(struct bond_net),
4982 4983
};

L
Linus Torvalds 已提交
4984 4985 4986 4987 4988
static int __init bonding_init(void)
{
	int i;
	int res;

S
Stephen Hemminger 已提交
4989
	pr_info("%s", version);
L
Linus Torvalds 已提交
4990

4991
	res = bond_check_params(&bonding_defaults);
S
Stephen Hemminger 已提交
4992
	if (res)
4993
		goto out;
L
Linus Torvalds 已提交
4994

4995
	res = register_pernet_subsys(&bond_net_ops);
4996 4997
	if (res)
		goto out;
4998

4999 5000
	res = rtnl_link_register(&bond_link_ops);
	if (res)
5001
		goto err_link;
5002

L
Linus Torvalds 已提交
5003
	for (i = 0; i < max_bonds; i++) {
5004
		res = bond_create(&init_net, NULL);
5005 5006
		if (res)
			goto err;
L
Linus Torvalds 已提交
5007 5008
	}

5009 5010 5011 5012
	res = bond_create_sysfs();
	if (res)
		goto err;

L
Linus Torvalds 已提交
5013
	register_netdevice_notifier(&bond_netdev_notifier);
J
Jay Vosburgh 已提交
5014
	register_inetaddr_notifier(&bond_inetaddr_notifier);
5015
	bond_register_ipv6_notifier();
5016
out:
L
Linus Torvalds 已提交
5017
	return res;
5018 5019
err:
	rtnl_link_unregister(&bond_link_ops);
5020
err_link:
5021
	unregister_pernet_subsys(&bond_net_ops);
5022
	goto out;
5023

L
Linus Torvalds 已提交
5024 5025 5026 5027 5028
}

static void __exit bonding_exit(void)
{
	unregister_netdevice_notifier(&bond_netdev_notifier);
J
Jay Vosburgh 已提交
5029
	unregister_inetaddr_notifier(&bond_inetaddr_notifier);
5030
	bond_unregister_ipv6_notifier();
L
Linus Torvalds 已提交
5031

5032 5033
	bond_destroy_sysfs();

5034
	rtnl_link_unregister(&bond_link_ops);
5035
	unregister_pernet_subsys(&bond_net_ops);
L
Linus Torvalds 已提交
5036 5037 5038 5039 5040 5041 5042 5043
}

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");
5044
MODULE_ALIAS_RTNL_LINK("bond");