bond_main.c 126 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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.
 *
 */

34
35
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
45
#include <linux/ip.h>
46
47
#include <linux/tcp.h>
#include <linux/udp.h>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Stephen Hemminger's avatar
Stephen Hemminger committed
56
#include <linux/io.h>
Linus Torvalds's avatar
Linus Torvalds committed
57
#include <asm/dma.h>
Stephen Hemminger's avatar
Stephen Hemminger committed
58
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
59
60
61
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
62
#include <linux/igmp.h>
Linus Torvalds's avatar
Linus Torvalds committed
63
64
65
66
67
68
69
70
71
72
73
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <linux/rtnetlink.h>
#include <linux/smp.h>
#include <linux/if_ether.h>
#include <net/arp.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/if_vlan.h>
#include <linux/if_bonding.h>
David Sterba's avatar
David Sterba committed
74
#include <linux/jiffies.h>
75
#include <linux/preempt.h>
Jay Vosburgh's avatar
Jay Vosburgh committed
76
#include <net/route.h>
77
#include <net/net_namespace.h>
78
#include <net/netns/generic.h>
79
#include <net/pkt_sched.h>
80
#include <linux/rculist.h>
Linus Torvalds's avatar
Linus Torvalds committed
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 tx_queues	= BOND_DEFAULT_TX_QUEUES;
93
static int num_peer_notif = 1;
Linus Torvalds's avatar
Linus Torvalds committed
94
static int miimon	= BOND_LINK_MON_INTERV;
Stephen Hemminger's avatar
Stephen Hemminger committed
95
96
static int updelay;
static int downdelay;
Linus Torvalds's avatar
Linus Torvalds committed
97
static int use_carrier	= 1;
Stephen Hemminger's avatar
Stephen Hemminger committed
98
99
static char *mode;
static char *primary;
100
static char *primary_reselect;
Stephen Hemminger's avatar
Stephen Hemminger committed
101
static char *lacp_rate;
102
static int min_links;
Stephen Hemminger's avatar
Stephen Hemminger committed
103
104
static char *ad_select;
static char *xmit_hash_policy;
Linus Torvalds's avatar
Linus Torvalds committed
105
static int arp_interval = BOND_LINK_ARP_INTERV;
Stephen Hemminger's avatar
Stephen Hemminger committed
106
107
static char *arp_ip_target[BOND_MAX_ARP_TARGETS];
static char *arp_validate;
108
static char *arp_all_targets;
Stephen Hemminger's avatar
Stephen Hemminger committed
109
static char *fail_over_mac;
110
static int all_slaves_active;
111
static struct bond_params bonding_defaults;
112
static int resend_igmp = BOND_DEFAULT_RESEND_IGMP;
Linus Torvalds's avatar
Linus Torvalds committed
113
114
115

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

159
module_param(xmit_hash_policy, charp, 0);
160
161
162
MODULE_PARM_DESC(xmit_hash_policy, "balance-xor and 802.3ad hashing method; "
				   "0 for layer 2 (default), 1 for layer 3+4, "
				   "2 for layer 2+3");
Linus Torvalds's avatar
Linus Torvalds committed
163
164
165
166
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");
167
module_param(arp_validate, charp, 0);
168
169
170
MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes; "
			       "0 for none (default), 1 for active, "
			       "2 for backup, 3 for all");
171
172
module_param(arp_all_targets, charp, 0);
MODULE_PARM_DESC(arp_all_targets, "fail on any/all arp targets timeout; 0 for any (default), 1 for all");
173
module_param(fail_over_mac, charp, 0);
174
175
176
MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to "
				"the same MAC; 0 for none (default), "
				"1 for active, 2 for follow");
177
178
module_param(all_slaves_active, int, 0);
MODULE_PARM_DESC(all_slaves_active, "Keep all frames received on an interface"
179
				     "by setting active flag for all slaves; "
180
				     "0 for never (default), 1 for always.");
181
module_param(resend_igmp, int, 0);
182
183
MODULE_PARM_DESC(resend_igmp, "Number of IGMP membership reports to send on "
			      "link failure");
Linus Torvalds's avatar
Linus Torvalds committed
184
185
186

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

187
#ifdef CONFIG_NET_POLL_CONTROLLER
188
atomic_t netpoll_block_tx = ATOMIC_INIT(0);
189
190
#endif

191
int bond_net_id __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
192

Stephen Hemminger's avatar
Stephen Hemminger committed
193
194
static __be32 arp_target[BOND_MAX_ARP_TARGETS];
static int arp_ip_count;
Linus Torvalds's avatar
Linus Torvalds committed
195
static int bond_mode	= BOND_MODE_ROUNDROBIN;
Stephen Hemminger's avatar
Stephen Hemminger committed
196
197
static int xmit_hashtype = BOND_XMIT_POLICY_LAYER2;
static int lacp_fast;
Linus Torvalds's avatar
Linus Torvalds committed
198

199
const struct bond_parm_tbl bond_lacp_tbl[] = {
Linus Torvalds's avatar
Linus Torvalds committed
200
201
202
203
204
{	"slow",		AD_LACP_SLOW},
{	"fast",		AD_LACP_FAST},
{	NULL,		-1},
};

205
const struct bond_parm_tbl bond_mode_tbl[] = {
Linus Torvalds's avatar
Linus Torvalds committed
206
207
208
209
210
211
212
213
214
215
{	"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},
};

216
const struct bond_parm_tbl xmit_hashtype_tbl[] = {
217
218
{	"layer2",		BOND_XMIT_POLICY_LAYER2},
{	"layer3+4",		BOND_XMIT_POLICY_LAYER34},
219
{	"layer2+3",		BOND_XMIT_POLICY_LAYER23},
220
221
222
{	NULL,			-1},
};

223
224
225
226
227
228
const struct bond_parm_tbl arp_all_targets_tbl[] = {
{	"any",			BOND_ARP_TARGETS_ANY},
{	"all",			BOND_ARP_TARGETS_ALL},
{	NULL,			-1},
};

229
const struct bond_parm_tbl arp_validate_tbl[] = {
230
231
232
233
234
235
236
{	"none",			BOND_ARP_VALIDATE_NONE},
{	"active",		BOND_ARP_VALIDATE_ACTIVE},
{	"backup",		BOND_ARP_VALIDATE_BACKUP},
{	"all",			BOND_ARP_VALIDATE_ALL},
{	NULL,			-1},
};

237
const struct bond_parm_tbl fail_over_mac_tbl[] = {
238
239
240
241
242
243
{	"none",			BOND_FOM_NONE},
{	"active",		BOND_FOM_ACTIVE},
{	"follow",		BOND_FOM_FOLLOW},
{	NULL,			-1},
};

244
245
246
247
248
249
250
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},
};

251
252
253
254
255
256
257
struct bond_parm_tbl ad_select_tbl[] = {
{	"stable",	BOND_AD_STABLE},
{	"bandwidth",	BOND_AD_BANDWIDTH},
{	"count",	BOND_AD_COUNT},
{	NULL,		-1},
};

Linus Torvalds's avatar
Linus Torvalds committed
258
259
/*-------------------------- Forward declarations ---------------------------*/

260
static int bond_init(struct net_device *bond_dev);
261
static void bond_uninit(struct net_device *bond_dev);
Linus Torvalds's avatar
Linus Torvalds committed
262
263
264

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

265
const char *bond_mode_name(int mode)
Linus Torvalds's avatar
Linus Torvalds committed
266
{
267
268
269
270
271
	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)",
Stephen Hemminger's avatar
Stephen Hemminger committed
272
		[BOND_MODE_8023AD] = "IEEE 802.3ad Dynamic link aggregation",
273
274
275
276
		[BOND_MODE_TLB] = "transmit load balancing",
		[BOND_MODE_ALB] = "adaptive load balancing",
	};

277
	if (mode < BOND_MODE_ROUNDROBIN || mode > BOND_MODE_ALB)
Linus Torvalds's avatar
Linus Torvalds committed
278
		return "unknown";
279
280

	return names[mode];
Linus Torvalds's avatar
Linus Torvalds committed
281
282
283
284
285
286
}

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

/**
 * bond_dev_queue_xmit - Prepare skb for xmit.
Stephen Hemminger's avatar
Stephen Hemminger committed
287
 *
Linus Torvalds's avatar
Linus Torvalds committed
288
289
290
291
 * @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
 */
Stephen Hemminger's avatar
Stephen Hemminger committed
292
293
int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb,
			struct net_device *slave_dev)
Linus Torvalds's avatar
Linus Torvalds committed
294
{
295
	skb->dev = slave_dev;
296

297
	BUILD_BUG_ON(sizeof(skb->queue_mapping) !=
298
299
		     sizeof(qdisc_skb_cb(skb)->slave_dev_queue_mapping));
	skb->queue_mapping = qdisc_skb_cb(skb)->slave_dev_queue_mapping;
300

301
	if (unlikely(netpoll_tx_running(bond->dev)))
302
		bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb);
303
	else
304
		dev_queue_xmit(skb);
Linus Torvalds's avatar
Linus Torvalds committed
305
306
307
308
309

	return 0;
}

/*
Jiri Pirko's avatar
Jiri Pirko committed
310
311
 * In the following 2 functions, bond_vlan_rx_add_vid and bond_vlan_rx_kill_vid,
 * We don't protect the slave list iteration with a lock because:
Linus Torvalds's avatar
Linus Torvalds committed
312
313
314
315
 * 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.
Stephen Hemminger's avatar
Stephen Hemminger committed
316
 *
Linus Torvalds's avatar
Linus Torvalds committed
317
318
319
320
321
322
323
324
325
326
327
328
329
330
 * The design of synchronization/protection for this operation in the 8021q
 * module is good for one or more VLAN devices over a single physical device
 * and cannot be extended for a teaming solution like bonding, so there is a
 * potential race condition here where a net device from the vlan group might
 * be referenced (either by a base driver or the 8021q code) while it is being
 * removed from the system. However, it turns out we're not making matters
 * worse, and if it works for regular VLAN usage it will work here too.
*/

/**
 * bond_vlan_rx_add_vid - Propagates adding an id to slaves
 * @bond_dev: bonding net device that got called
 * @vid: vlan id being added
 */
331
332
static int bond_vlan_rx_add_vid(struct net_device *bond_dev,
				__be16 proto, u16 vid)
Linus Torvalds's avatar
Linus Torvalds committed
333
{
334
	struct bonding *bond = netdev_priv(bond_dev);
335
	struct slave *slave, *rollback_slave;
336
	struct list_head *iter;
337
	int res;
Linus Torvalds's avatar
Linus Torvalds committed
338

339
	bond_for_each_slave(bond, slave, iter) {
340
		res = vlan_vid_add(slave->dev, proto, vid);
341
342
		if (res)
			goto unwind;
Linus Torvalds's avatar
Linus Torvalds committed
343
344
	}

345
	return 0;
346
347

unwind:
348
	/* unwind to the slave that failed */
349
	bond_for_each_slave(bond, rollback_slave, iter) {
350
351
352
353
354
		if (rollback_slave == slave)
			break;

		vlan_vid_del(rollback_slave->dev, proto, vid);
	}
355
356

	return res;
Linus Torvalds's avatar
Linus Torvalds committed
357
358
359
360
361
362
363
}

/**
 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
 * @bond_dev: bonding net device that got called
 * @vid: vlan id being removed
 */
364
365
static int bond_vlan_rx_kill_vid(struct net_device *bond_dev,
				 __be16 proto, u16 vid)
Linus Torvalds's avatar
Linus Torvalds committed
366
{
367
	struct bonding *bond = netdev_priv(bond_dev);
368
	struct list_head *iter;
Linus Torvalds's avatar
Linus Torvalds committed
369
370
	struct slave *slave;

371
	bond_for_each_slave(bond, slave, iter)
372
		vlan_vid_del(slave->dev, proto, vid);
Linus Torvalds's avatar
Linus Torvalds committed
373

374
375
	if (bond_is_lb(bond))
		bond_alb_clear_vlan(bond, vid);
376
377

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
378
379
380
381
}

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

382
383
384
385
386
387
388
389
390
/*
 * 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)
{
391
	struct list_head *iter;
392
393
	struct slave *slave;

394
	if (!bond_has_slaves(bond))
395
396
397
398
399
		goto down;

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

400
	bond_for_each_slave(bond, slave, iter) {
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
		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;
}

Linus Torvalds's avatar
Linus Torvalds committed
418
419
420
/*
 * Get link speed and duplex from the slave's base driver
 * using ethtool. If for some reason the call fails or the
421
 * values are invalid, set speed and duplex to -1,
422
 * and return.
Linus Torvalds's avatar
Linus Torvalds committed
423
 */
424
static void bond_update_speed_duplex(struct slave *slave)
Linus Torvalds's avatar
Linus Torvalds committed
425
426
{
	struct net_device *slave_dev = slave->dev;
427
	struct ethtool_cmd ecmd;
428
	u32 slave_speed;
429
	int res;
Linus Torvalds's avatar
Linus Torvalds committed
430

431
432
	slave->speed = SPEED_UNKNOWN;
	slave->duplex = DUPLEX_UNKNOWN;
Linus Torvalds's avatar
Linus Torvalds committed
433

434
	res = __ethtool_get_settings(slave_dev, &ecmd);
435
	if (res < 0)
436
		return;
Linus Torvalds's avatar
Linus Torvalds committed
437

438
	slave_speed = ethtool_cmd_speed(&ecmd);
Jiri Pirko's avatar
Jiri Pirko committed
439
	if (slave_speed == 0 || slave_speed == ((__u32) -1))
440
		return;
Linus Torvalds's avatar
Linus Torvalds committed
441

442
	switch (ecmd.duplex) {
Linus Torvalds's avatar
Linus Torvalds committed
443
444
445
446
	case DUPLEX_FULL:
	case DUPLEX_HALF:
		break;
	default:
447
		return;
Linus Torvalds's avatar
Linus Torvalds committed
448
449
	}

450
	slave->speed = slave_speed;
451
	slave->duplex = ecmd.duplex;
Linus Torvalds's avatar
Linus Torvalds committed
452

453
	return;
Linus Torvalds's avatar
Linus Torvalds committed
454
455
456
457
458
459
}

/*
 * if <dev> supports MII link status reporting, check its link status.
 *
 * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(),
Stephen Hemminger's avatar
Stephen Hemminger committed
460
 * depending upon the setting of the use_carrier parameter.
Linus Torvalds's avatar
Linus Torvalds committed
461
462
463
464
465
466
467
468
469
470
471
 *
 * 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.
 */
Stephen Hemminger's avatar
Stephen Hemminger committed
472
473
static int bond_check_dev_link(struct bonding *bond,
			       struct net_device *slave_dev, int reporting)
Linus Torvalds's avatar
Linus Torvalds committed
474
{
475
	const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
476
	int (*ioctl)(struct net_device *, struct ifreq *, int);
Linus Torvalds's avatar
Linus Torvalds committed
477
478
479
	struct ifreq ifr;
	struct mii_ioctl_data *mii;

480
481
482
	if (!reporting && !netif_running(slave_dev))
		return 0;

483
	if (bond->params.use_carrier)
Linus Torvalds's avatar
Linus Torvalds committed
484
485
		return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;

486
	/* Try to get link status using Ethtool first. */
487
488
489
	if (slave_dev->ethtool_ops->get_link)
		return slave_dev->ethtool_ops->get_link(slave_dev) ?
			BMSR_LSTATUS : 0;
490

Stephen Hemminger's avatar
Stephen Hemminger committed
491
	/* Ethtool can't be used, fallback to MII ioctls. */
492
	ioctl = slave_ops->ndo_do_ioctl;
Linus Torvalds's avatar
Linus Torvalds committed
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
	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;
Stephen Hemminger's avatar
Stephen Hemminger committed
511
512
			if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0)
				return mii->val_out & BMSR_LSTATUS;
Linus Torvalds's avatar
Linus Torvalds committed
513
514
515
516
517
		}
	}

	/*
	 * If reporting, report that either there's no dev->do_ioctl,
518
	 * or both SIOCGMIIREG and get_link failed (meaning that we
Linus Torvalds's avatar
Linus Torvalds committed
519
520
521
	 * cannot report link status).  If not reporting, pretend
	 * we're ok.
	 */
Stephen Hemminger's avatar
Stephen Hemminger committed
522
	return reporting ? -1 : BMSR_LSTATUS;
Linus Torvalds's avatar
Linus Torvalds committed
523
524
525
526
527
528
529
}

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

/*
 * Push the promiscuity flag down to appropriate slaves
 */
530
static int bond_set_promiscuity(struct bonding *bond, int inc)
Linus Torvalds's avatar
Linus Torvalds committed
531
{
532
	struct list_head *iter;
533
	int err = 0;
534

Linus Torvalds's avatar
Linus Torvalds committed
535
536
537
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
		if (bond->curr_active_slave) {
538
539
			err = dev_set_promiscuity(bond->curr_active_slave->dev,
						  inc);
Linus Torvalds's avatar
Linus Torvalds committed
540
541
542
		}
	} else {
		struct slave *slave;
543

544
		bond_for_each_slave(bond, slave, iter) {
545
546
547
			err = dev_set_promiscuity(slave->dev, inc);
			if (err)
				return err;
Linus Torvalds's avatar
Linus Torvalds committed
548
549
		}
	}
550
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
551
552
553
554
555
}

/*
 * Push the allmulti flag down to all slaves
 */
556
static int bond_set_allmulti(struct bonding *bond, int inc)
Linus Torvalds's avatar
Linus Torvalds committed
557
{
558
	struct list_head *iter;
559
	int err = 0;
560

Linus Torvalds's avatar
Linus Torvalds committed
561
562
563
	if (USES_PRIMARY(bond->params.mode)) {
		/* write lock already acquired */
		if (bond->curr_active_slave) {
564
565
			err = dev_set_allmulti(bond->curr_active_slave->dev,
					       inc);
Linus Torvalds's avatar
Linus Torvalds committed
566
567
568
		}
	} else {
		struct slave *slave;
569

570
		bond_for_each_slave(bond, slave, iter) {
571
572
573
			err = dev_set_allmulti(slave->dev, inc);
			if (err)
				return err;
Linus Torvalds's avatar
Linus Torvalds committed
574
575
		}
	}
576
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
577
578
}

579
580
581
582
583
584
585
/*
 * 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)
{
586
	if (!rtnl_trylock()) {
587
		queue_delayed_work(bond->wq, &bond->mcast_work, 1);
588
		return;
589
	}
590
591
	call_netdevice_notifiers(NETDEV_RESEND_IGMP, bond->dev);
	rtnl_unlock();
592

593
594
595
596
597
598
599
	/* We use curr_slave_lock to protect against concurrent access to
	 * igmp_retrans from multiple running instances of this function and
	 * bond_change_active_slave
	 */
	write_lock_bh(&bond->curr_slave_lock);
	if (bond->igmp_retrans > 1) {
		bond->igmp_retrans--;
600
		queue_delayed_work(bond->wq, &bond->mcast_work, HZ/5);
601
602
	}
	write_unlock_bh(&bond->curr_slave_lock);
603
604
}

605
static void bond_resend_igmp_join_requests_delayed(struct work_struct *work)
606
607
{
	struct bonding *bond = container_of(work, struct bonding,
608
					    mcast_work.work);
609

610
611
612
	bond_resend_igmp_join_requests(bond);
}

613
/* Flush bond's hardware addresses from slave
Linus Torvalds's avatar
Linus Torvalds committed
614
 */
615
static void bond_hw_addr_flush(struct net_device *bond_dev,
Stephen Hemminger's avatar
Stephen Hemminger committed
616
			       struct net_device *slave_dev)
Linus Torvalds's avatar
Linus Torvalds committed
617
{
618
	struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds's avatar
Linus Torvalds committed
619

620
621
	dev_uc_unsync(slave_dev, bond_dev);
	dev_mc_unsync(slave_dev, bond_dev);
Linus Torvalds's avatar
Linus Torvalds committed
622
623
624
625
626

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

627
		dev_mc_del(slave_dev, lacpdu_multicast);
Linus Torvalds's avatar
Linus Torvalds committed
628
629
630
631
632
	}
}

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

633
634
635
636
/* Update the hardware address list and promisc/allmulti for the new and
 * old active slaves (if any).  Modes that are !USES_PRIMARY keep all
 * slaves up date at all times; only the USES_PRIMARY modes need to call
 * this function to swap these settings during a failover.
Linus Torvalds's avatar
Linus Torvalds committed
637
 */
638
639
static void bond_hw_addr_swap(struct bonding *bond, struct slave *new_active,
			      struct slave *old_active)
Linus Torvalds's avatar
Linus Torvalds committed
640
{
641
642
	ASSERT_RTNL();

Linus Torvalds's avatar
Linus Torvalds committed
643
	if (old_active) {
Stephen Hemminger's avatar
Stephen Hemminger committed
644
		if (bond->dev->flags & IFF_PROMISC)
Linus Torvalds's avatar
Linus Torvalds committed
645
646
			dev_set_promiscuity(old_active->dev, -1);

Stephen Hemminger's avatar
Stephen Hemminger committed
647
		if (bond->dev->flags & IFF_ALLMULTI)
Linus Torvalds's avatar
Linus Torvalds committed
648
649
			dev_set_allmulti(old_active->dev, -1);

650
		bond_hw_addr_flush(bond->dev, old_active->dev);
Linus Torvalds's avatar
Linus Torvalds committed
651
652
653
	}

	if (new_active) {
654
		/* FIXME: Signal errors upstream. */
Stephen Hemminger's avatar
Stephen Hemminger committed
655
		if (bond->dev->flags & IFF_PROMISC)
Linus Torvalds's avatar
Linus Torvalds committed
656
657
			dev_set_promiscuity(new_active->dev, 1);

Stephen Hemminger's avatar
Stephen Hemminger committed
658
		if (bond->dev->flags & IFF_ALLMULTI)
Linus Torvalds's avatar
Linus Torvalds committed
659
660
			dev_set_allmulti(new_active->dev, 1);

661
		netif_addr_lock_bh(bond->dev);
662
663
		dev_uc_sync(new_active->dev, bond->dev);
		dev_mc_sync(new_active->dev, bond->dev);
664
		netif_addr_unlock_bh(bond->dev);
Linus Torvalds's avatar
Linus Torvalds committed
665
666
667
	}
}

668
669
670
671
672
673
674
675
676
677
/**
 * bond_set_dev_addr - clone slave's address to bond
 * @bond_dev: bond net device
 * @slave_dev: slave net device
 *
 * Should be called with RTNL held.
 */
static void bond_set_dev_addr(struct net_device *bond_dev,
			      struct net_device *slave_dev)
{
678
679
	pr_debug("bond_dev=%p slave_dev=%p slave_dev->addr_len=%d\n",
		 bond_dev, slave_dev, slave_dev->addr_len);
680
681
682
683
684
	memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
	bond_dev->addr_assign_type = NET_ADDR_STOLEN;
	call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev);
}

685
686
687
688
689
690
691
692
693
694
/*
 * 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)
695
696
697
698
	__releases(&bond->curr_slave_lock)
	__releases(&bond->lock)
	__acquires(&bond->lock)
	__acquires(&bond->curr_slave_lock)
699
700
701
702
703
704
705
{
	u8 tmp_mac[ETH_ALEN];
	struct sockaddr saddr;
	int rv;

	switch (bond->params.fail_over_mac) {
	case BOND_FOM_ACTIVE:
706
707
708
		if (new_active) {
			write_unlock_bh(&bond->curr_slave_lock);
			read_unlock(&bond->lock);
709
			bond_set_dev_addr(bond->dev, new_active->dev);
710
711
712
			read_lock(&bond->lock);
			write_lock_bh(&bond->curr_slave_lock);
		}
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
		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) {
738
			pr_err("%s: Error %d setting MAC of slave %s\n",
739
740
741
742
743
744
745
746
747
748
749
750
			       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)
751
			pr_err("%s: Error %d setting MAC of slave %s\n",
752
753
754
755
756
757
			       bond->dev->name, -rv, new_active->dev->name);
out:
		read_lock(&bond->lock);
		write_lock_bh(&bond->curr_slave_lock);
		break;
	default:
758
		pr_err("%s: bond_do_fail_over_mac impossible: bad policy %d\n",
759
760
761
762
763
764
		       bond->dev->name, bond->params.fail_over_mac);
		break;
	}

}

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

Linus Torvalds's avatar
Linus Torvalds committed
785
786
787
788
789
790
/**
 * find_best_interface - select the best available slave to be the active one
 * @bond: our bonding struct
 */
static struct slave *bond_find_best_slave(struct bonding *bond)
{
791
792
	struct slave *slave, *bestslave = NULL;
	struct list_head *iter;
Linus Torvalds's avatar
Linus Torvalds committed
793
794
	int mintime = bond->params.updelay;

795
796
797
	if (bond->primary_slave && bond->primary_slave->link == BOND_LINK_UP &&
	    bond_should_change_active(bond))
		return bond->primary_slave;
Linus Torvalds's avatar
Linus Torvalds committed
798

799
800
801
802
803
804
805
	bond_for_each_slave(bond, slave, iter) {
		if (slave->link == BOND_LINK_UP)
			return slave;
		if (slave->link == BOND_LINK_BACK && IS_UP(slave->dev) &&
		    slave->delay < mintime) {
			mintime = slave->delay;
			bestslave = slave;
Linus Torvalds's avatar
Linus Torvalds committed
806
807
808
809
810
811
		}
	}

	return bestslave;
}

812
813
814
815
816
817
818
819
820
821
822
823
824
825
static bool bond_should_notify_peers(struct bonding *bond)
{
	struct slave *slave = bond->curr_active_slave;

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

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

	return true;
}

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

Stephen Hemminger's avatar
Stephen Hemminger committed
846
	if (old_active == new_active)
Linus Torvalds's avatar
Linus Torvalds committed
847
848
849
		return;

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

Linus Torvalds's avatar
Linus Torvalds committed
852
853
		if (new_active->link == BOND_LINK_BACK) {
			if (USES_PRIMARY(bond->params.mode)) {
854
855
856
				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);
Linus Torvalds's avatar
Linus Torvalds committed
857
858
859
860
861
			}

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

Stephen Hemminger's avatar
Stephen Hemminger committed
862
			if (bond->params.mode == BOND_MODE_8023AD)
Linus Torvalds's avatar
Linus Torvalds committed
863
864
				bond_3ad_handle_link_change(new_active, BOND_LINK_UP);

865
			if (bond_is_lb(bond))
Linus Torvalds's avatar
Linus Torvalds committed
866
867
868
				bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
		} else {
			if (USES_PRIMARY(bond->params.mode)) {
869
870
				pr_info("%s: making interface %s the new active one.\n",
					bond->dev->name, new_active->dev->name);
Linus Torvalds's avatar
Linus Torvalds committed
871
872
873
874
			}
		}
	}

Stephen Hemminger's avatar
Stephen Hemminger committed
875
	if (USES_PRIMARY(bond->params.mode))
876
		bond_hw_addr_swap(bond, new_active, old_active);
Linus Torvalds's avatar
Linus Torvalds committed
877

878
	if (bond_is_lb(bond)) {
Linus Torvalds's avatar
Linus Torvalds committed
879
		bond_alb_handle_active_change(bond, new_active);
880
881
882
883
		if (old_active)
			bond_set_slave_inactive_flags(old_active);
		if (new_active)
			bond_set_slave_active_flags(new_active);
Linus Torvalds's avatar
Linus Torvalds committed
884
	} else {
885
		rcu_assign_pointer(bond->curr_active_slave, new_active);
Linus Torvalds's avatar
Linus Torvalds committed
886
	}
Jay Vosburgh's avatar
Jay Vosburgh committed
887
888

	if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
Stephen Hemminger's avatar
Stephen Hemminger committed
889
		if (old_active)
Jay Vosburgh's avatar
Jay Vosburgh committed
890
891
892
			bond_set_slave_inactive_flags(old_active);

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

Jay Vosburgh's avatar
Jay Vosburgh committed
895
			bond_set_slave_active_flags(new_active);
896

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

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

908
909
910
			write_unlock_bh(&bond->curr_slave_lock);
			read_unlock(&bond->lock);

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

			read_lock(&bond->lock);
			write_lock_bh(&bond->curr_slave_lock);
918
		}
Jay Vosburgh's avatar
Jay Vosburgh committed
919
	}
920

921
	/* resend IGMP joins since active slave has changed or
922
923
924
925
926
927
	 * all were sent on curr_active_slave.
	 * resend only if bond is brought up with the affected
	 * bonding modes and the retransmission is enabled */
	if (netif_running(bond->dev) && (bond->params.resend_igmp > 0) &&
	    ((USES_PRIMARY(bond->params.mode) && new_active) ||
	     bond->params.mode == BOND_MODE_ROUNDROBIN)) {
928
		bond->igmp_retrans = bond->params.resend_igmp;
929
		queue_delayed_work(bond->wq, &bond->mcast_work, 1);
930
	}
Linus Torvalds's avatar
Linus Torvalds committed
931
932
933
934
935
936
}

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

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

		if (netif_carrier_ok(bond->dev)) {
957
958
			pr_info("%s: first active interface up!\n",
				bond->dev->name);
959
		} else {
960
961
			pr_info("%s: now running without any active interface !\n",
				bond->dev->name);
962
		}
Linus Torvalds's avatar
Linus Torvalds committed
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
	}
}

/*--------------------------- 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)
{
	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)
{
	bond->slave_cnt--;
}

993
#ifdef CONFIG_NET_POLL_CONTROLLER
994
static inline int slave_enable_netpoll(struct slave *slave)
995
{
996
997
	struct netpoll *np;
	int err = 0;
998

999
	np = kzalloc(sizeof(*np), GFP_ATOMIC);
1000
1001
1002
1003
	err = -ENOMEM;
	if (!np)
		goto out;

1004
	err = __netpoll_setup(np, slave->dev, GFP_ATOMIC);
1005
1006
1007
	if (err) {
		kfree(np);
		goto out;
1008
	}
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
	slave->np = np;
out:
	return err;
}
static inline void slave_disable_netpoll(struct slave *slave)
{
	struct netpoll *np = slave->np;

	if (!np)
		return;

	slave->np = NULL;
1021
	__netpoll_free_async(np);
1022
1023
1024
1025
1026
1027
1028
1029
}
static inline bool slave_dev_support_netpoll(struct net_device *slave_dev)
{
	if (slave_dev->priv_flags & IFF_DISABLE_NETPOLL)
		return false;
	if (!slave_dev->netdev_ops->ndo_poll_controller)
		return false;
	return true;
1030
1031
1032
1033
}

static void bond_poll_controller(struct net_device *bond_dev)
{
1034
1035
}

1036
static void bond_netpoll_cleanup(struct net_device *bond_dev)
1037
{
1038
	struct bonding *bond = netdev_priv(bond_dev);
1039
	struct list_head *iter;
1040
1041
	struct slave *slave;

1042
	bond_for_each_slave(bond, slave, iter)
1043
1044
		if (IS_UP(slave->dev))
			slave_disable_netpoll(slave);
1045
}
1046

1047
static int bond_netpoll_setup(struct net_device *dev, struct netpoll_info *ni, gfp_t gfp)
1048
1049
{
	struct bonding *bond = netdev_priv(dev);
1050
	struct list_head *iter;
1051
	struct slave *slave;
1052
	int err = 0;
1053

1054
	bond_for_each_slave(bond, slave, iter) {
1055
1056
		err = slave_enable_netpoll(slave);
		if (err) {
1057
			bond_netpoll_cleanup(dev);
1058
			break;
1059
1060
		}
	}
1061
	return err;
1062
}
1063
1064
1065
1066
1067
1068
1069
1070
#else
static inline int slave_enable_netpoll(struct slave *slave)
{
	return 0;
}
static inline void slave_disable_netpoll(struct slave *slave)
{
}
1071
1072
1073
1074
1075
static void bond_netpoll_cleanup(struct net_device *bond_dev)
{
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1076
1077
/*---------------------------------- IOCTL ----------------------------------*/

1078
static netdev_features_t bond_fix_features(struct net_device *dev,
1079
					   netdev_features_t features)
1080
{
1081
	struct bonding *bond = netdev_priv(dev);
1082
	struct list_head *iter;
1083
	netdev_features_t mask;
1084
	struct slave *slave;
1085

1086
	if (!bond_has_slaves(bond)) {
1087
1088
		/* Disable adding VLANs to empty bond. But why? --mq */
		features |= NETIF_F_VLAN_CHALLENGED;
1089
		return features;
1090
	}
1091

1092
	mask = features;
1093
	features &= ~NETIF_F_ONE_FOR_ALL;
1094
	features |= NETIF_F_ALL_FOR_ALL;
1095