projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
be2net: add support for ndo_busy_poll
[deliverable/linux.git] / drivers / net / bonding / bond_main.c
CommitLineData
1da177e4
LT		 1/*
2 * originally based on the dummy device.
3 *
4 * Copyright 1999, Thomas Davis, tadavis@lbl.gov.
5 * Licensed under the GPL. Based on dummy.c, and eql.c devices.
6 *
7 * bonding.c: an Ethernet Bonding driver
8 *
9 * This is useful to talk to a Cisco EtherChannel compatible equipment:
10 * Cisco 5500
11 * Sun Trunking (Solaris)
12 * Alteon AceDirector Trunks
13 * Linux Bonding
14 * and probably many L2 switches ...
15 *
16 * How it works:
17 * ifconfig bond0 ipaddress netmask up
18 * will setup a network device, with an ip address. No mac address
19 * will be assigned at this time. The hw mac address will come from
20 * the first slave bonded to the channel. All slaves will then use
21 * this hw mac address.
22 *
23 * ifconfig bond0 down
24 * will release all slaves, marking them as down.
25 *
26 * ifenslave bond0 eth0
27 * will attach eth0 to bond0 as a slave. eth0 hw mac address will either
28 * a: be used as initial mac address
29 * b: if a hw mac address already is there, eth0's hw mac address
30 * will then be set from bond0.
31 *
1da177e4
LT		 32 */
33
a4aee5c8
JP		 34#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
35
1da177e4
LT		 36#include <linux/kernel.h>
37#include <linux/module.h>
1da177e4
LT		 38#include <linux/types.h>
39#include <linux/fcntl.h>
40#include <linux/interrupt.h>
41#include <linux/ptrace.h>
42#include <linux/ioport.h>
43#include <linux/in.h>
169a3e66 44#include <net/ip.h>
1da177e4 45#include <linux/ip.h>
169a3e66
JV		 46#include <linux/tcp.h>
47#include <linux/udp.h>
1da177e4
LT		 48#include <linux/slab.h>
49#include <linux/string.h>
50#include <linux/init.h>
51#include <linux/timer.h>
52#include <linux/socket.h>
53#include <linux/ctype.h>
54#include <linux/inet.h>
55#include <linux/bitops.h>
3d632c3f 56#include <linux/io.h>
1da177e4 57#include <asm/dma.h>
3d632c3f 58#include <linux/uaccess.h>
1da177e4
LT		 59#include <linux/errno.h>
60#include <linux/netdevice.h>
61#include <linux/inetdevice.h>
a816c7c7 62#include <linux/igmp.h>
1da177e4
LT		 63#include <linux/etherdevice.h>
64#include <linux/skbuff.h>
65#include <net/sock.h>
66#include <linux/rtnetlink.h>
1da177e4
LT		 67#include <linux/smp.h>
68#include <linux/if_ether.h>
69#include <net/arp.h>
70#include <linux/mii.h>
71#include <linux/ethtool.h>
72#include <linux/if_vlan.h>
73#include <linux/if_bonding.h>
b63bb739 74#include <linux/jiffies.h>
e843fa50 75#include <linux/preempt.h>
c3ade5ca 76#include <net/route.h>
457c4cbc 77#include <net/net_namespace.h>
ec87fd3b 78#include <net/netns/generic.h>
5ee31c68 79#include <net/pkt_sched.h>
278b2083 80#include <linux/rculist.h>
32819dc1 81#include <net/flow_keys.h>
1da177e4
LT		 82#include "bonding.h"
83#include "bond_3ad.h"
84#include "bond_alb.h"
85
86/*---------------------------- Module parameters ----------------------------*/
87
88/* monitor all links that often (in milliseconds). <=0 disables monitoring */
89#define BOND_LINK_MON_INTERV 0
90#define BOND_LINK_ARP_INTERV 0
91
92static int max_bonds = BOND_DEFAULT_MAX_BONDS;
bb1d9123 93static int tx_queues = BOND_DEFAULT_TX_QUEUES;
ad246c99 94static int num_peer_notif = 1;
1da177e4 95static int miimon = BOND_LINK_MON_INTERV;
3d632c3f
SH		 96static int updelay;
97static int downdelay;
1da177e4 98static int use_carrier = 1;
3d632c3f
SH		 99static char *mode;
100static char *primary;
a549952a 101static char *primary_reselect;
3d632c3f 102static char *lacp_rate;
655f8919 103static int min_links;
3d632c3f
SH		 104static char *ad_select;
105static char *xmit_hash_policy;
1da177e4 106static int arp_interval = BOND_LINK_ARP_INTERV;
3d632c3f
SH		 107static char *arp_ip_target[BOND_MAX_ARP_TARGETS];
108static char *arp_validate;
8599b52e 109static char *arp_all_targets;
3d632c3f 110static char *fail_over_mac;
b07ea07b 111static int all_slaves_active;
d2991f75 112static struct bond_params bonding_defaults;
c2952c31 113static int resend_igmp = BOND_DEFAULT_RESEND_IGMP;
1da177e4
LT		 114
115module_param(max_bonds, int, 0);
116MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
bb1d9123
AG		 117module_param(tx_queues, int, 0);
118MODULE_PARM_DESC(tx_queues, "Max number of transmit queues (default = 16)");
ad246c99 119module_param_named(num_grat_arp, num_peer_notif, int, 0644);
90e62474
AG		 120MODULE_PARM_DESC(num_grat_arp, "Number of peer notifications to send on "
121 "failover event (alias of num_unsol_na)");
ad246c99 122module_param_named(num_unsol_na, num_peer_notif, int, 0644);
90e62474
AG		 123MODULE_PARM_DESC(num_unsol_na, "Number of peer notifications to send on "
124 "failover event (alias of num_grat_arp)");
1da177e4
LT		 125module_param(miimon, int, 0);
126MODULE_PARM_DESC(miimon, "Link check interval in milliseconds");
127module_param(updelay, int, 0);
128MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds");
129module_param(downdelay, int, 0);
2ac47660
MW		 130MODULE_PARM_DESC(downdelay, "Delay before considering link down, "
131 "in milliseconds");
1da177e4 132module_param(use_carrier, int, 0);
2ac47660
MW		 133MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; "
134 "0 for off, 1 for on (default)");
1da177e4 135module_param(mode, charp, 0);
90e62474 136MODULE_PARM_DESC(mode, "Mode of operation; 0 for balance-rr, "
2ac47660
MW		 137 "1 for active-backup, 2 for balance-xor, "
138 "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, "
139 "6 for balance-alb");
1da177e4
LT		 140module_param(primary, charp, 0);
141MODULE_PARM_DESC(primary, "Primary network device to use");
a549952a
JP		 142module_param(primary_reselect, charp, 0);
143MODULE_PARM_DESC(primary_reselect, "Reselect primary slave "
144 "once it comes up; "
145 "0 for always (default), "
146 "1 for only if speed of primary is "
147 "better, "
148 "2 for only on active slave "
149 "failure");
1da177e4 150module_param(lacp_rate, charp, 0);
90e62474
AG		 151MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner; "
152 "0 for slow, 1 for fast");
fd989c83 153module_param(ad_select, charp, 0);
90e62474
AG		 154MODULE_PARM_DESC(ad_select, "803.ad aggregation selection logic; "
155 "0 for stable (default), 1 for bandwidth, "
156 "2 for count");
655f8919 157module_param(min_links, int, 0);
158MODULE_PARM_DESC(min_links, "Minimum number of available links before turning on carrier");
159
169a3e66 160module_param(xmit_hash_policy, charp, 0);
90e62474
AG		 161MODULE_PARM_DESC(xmit_hash_policy, "balance-xor and 802.3ad hashing method; "
162 "0 for layer 2 (default), 1 for layer 3+4, "
32819dc1
NA		 163 "2 for layer 2+3, 3 for encap layer 2+3, "
164 "4 for encap layer 3+4");
1da177e4
LT		 165module_param(arp_interval, int, 0);
166MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds");
167module_param_array(arp_ip_target, charp, NULL, 0);
168MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form");
f5b2b966 169module_param(arp_validate, charp, 0);
90e62474
AG		 170MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes; "
171 "0 for none (default), 1 for active, "
172 "2 for backup, 3 for all");
8599b52e
VF		 173module_param(arp_all_targets, charp, 0);
174MODULE_PARM_DESC(arp_all_targets, "fail on any/all arp targets timeout; 0 for any (default), 1 for all");
3915c1e8 175module_param(fail_over_mac, charp, 0);
90e62474
AG		 176MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to "
177 "the same MAC; 0 for none (default), "
178 "1 for active, 2 for follow");
ebd8e497
AG		 179module_param(all_slaves_active, int, 0);
180MODULE_PARM_DESC(all_slaves_active, "Keep all frames received on an interface"
90e62474 181 "by setting active flag for all slaves; "
ebd8e497 182 "0 for never (default), 1 for always.");
c2952c31 183module_param(resend_igmp, int, 0);
90e62474
AG		 184MODULE_PARM_DESC(resend_igmp, "Number of IGMP membership reports to send on "
185 "link failure");
1da177e4
LT		 186
187/*----------------------------- Global variables ----------------------------*/
188
e843fa50 189#ifdef CONFIG_NET_POLL_CONTROLLER
fb4fa76a 190atomic_t netpoll_block_tx = ATOMIC_INIT(0);
e843fa50
NH		 191#endif
192
f99189b1 193int bond_net_id __read_mostly;
1da177e4 194
3d632c3f
SH		 195static __be32 arp_target[BOND_MAX_ARP_TARGETS];
196static int arp_ip_count;
1da177e4 197static int bond_mode = BOND_MODE_ROUNDROBIN;
3d632c3f
SH		 198static int xmit_hashtype = BOND_XMIT_POLICY_LAYER2;
199static int lacp_fast;
1da177e4 200
e97fd7c6 201const struct bond_parm_tbl bond_lacp_tbl[] = {
1da177e4
LT		 202{ "slow", AD_LACP_SLOW},
203{ "fast", AD_LACP_FAST},
204{ NULL, -1},
205};
206
e97fd7c6 207const struct bond_parm_tbl bond_mode_tbl[] = {
1da177e4
LT		 208{ "balance-rr", BOND_MODE_ROUNDROBIN},
209{ "active-backup", BOND_MODE_ACTIVEBACKUP},
210{ "balance-xor", BOND_MODE_XOR},
211{ "broadcast", BOND_MODE_BROADCAST},
212{ "802.3ad", BOND_MODE_8023AD},
213{ "balance-tlb", BOND_MODE_TLB},
214{ "balance-alb", BOND_MODE_ALB},
215{ NULL, -1},
216};
217
e97fd7c6 218const struct bond_parm_tbl xmit_hashtype_tbl[] = {
169a3e66
JV		 219{ "layer2", BOND_XMIT_POLICY_LAYER2},
220{ "layer3+4", BOND_XMIT_POLICY_LAYER34},
6f6652be 221{ "layer2+3", BOND_XMIT_POLICY_LAYER23},
32819dc1
NA		 222{ "encap2+3", BOND_XMIT_POLICY_ENCAP23},
223{ "encap3+4", BOND_XMIT_POLICY_ENCAP34},
169a3e66
JV		 224{ NULL, -1},
225};
226
8599b52e
VF		 227const struct bond_parm_tbl arp_all_targets_tbl[] = {
228{ "any", BOND_ARP_TARGETS_ANY},
229{ "all", BOND_ARP_TARGETS_ALL},
230{ NULL, -1},
231};
232
e97fd7c6 233const struct bond_parm_tbl arp_validate_tbl[] = {
f5b2b966
JV		 234{ "none", BOND_ARP_VALIDATE_NONE},
235{ "active", BOND_ARP_VALIDATE_ACTIVE},
236{ "backup", BOND_ARP_VALIDATE_BACKUP},
237{ "all", BOND_ARP_VALIDATE_ALL},
238{ NULL, -1},
239};
240
e97fd7c6 241const struct bond_parm_tbl fail_over_mac_tbl[] = {
3915c1e8
JV		 242{ "none", BOND_FOM_NONE},
243{ "active", BOND_FOM_ACTIVE},
244{ "follow", BOND_FOM_FOLLOW},
245{ NULL, -1},
246};
247
a549952a
JP		 248const struct bond_parm_tbl pri_reselect_tbl[] = {
249{ "always", BOND_PRI_RESELECT_ALWAYS},
250{ "better", BOND_PRI_RESELECT_BETTER},
251{ "failure", BOND_PRI_RESELECT_FAILURE},
252{ NULL, -1},
253};
254
fd989c83
JV		 255struct bond_parm_tbl ad_select_tbl[] = {
256{ "stable", BOND_AD_STABLE},
257{ "bandwidth", BOND_AD_BANDWIDTH},
258{ "count", BOND_AD_COUNT},
259{ NULL, -1},
260};
261
1da177e4
LT		 262/*-------------------------- Forward declarations ---------------------------*/
263
181470fc 264static int bond_init(struct net_device *bond_dev);
c67dfb29 265static void bond_uninit(struct net_device *bond_dev);
1da177e4
LT		 266
267/*---------------------------- General routines -----------------------------*/
268
bd33acc3 269const char *bond_mode_name(int mode)
1da177e4 270{
77afc92b
HE		 271 static const char *names[] = {
272 [BOND_MODE_ROUNDROBIN] = "load balancing (round-robin)",
273 [BOND_MODE_ACTIVEBACKUP] = "fault-tolerance (active-backup)",
274 [BOND_MODE_XOR] = "load balancing (xor)",
275 [BOND_MODE_BROADCAST] = "fault-tolerance (broadcast)",
3d632c3f 276 [BOND_MODE_8023AD] = "IEEE 802.3ad Dynamic link aggregation",
77afc92b
HE		 277 [BOND_MODE_TLB] = "transmit load balancing",
278 [BOND_MODE_ALB] = "adaptive load balancing",
279 };
280
f5280948 281 if (mode < BOND_MODE_ROUNDROBIN || mode > BOND_MODE_ALB)
1da177e4 282 return "unknown";
77afc92b
HE		 283
284 return names[mode];
1da177e4
LT		 285}
286
287/*---------------------------------- VLAN -----------------------------------*/
288
1da177e4
LT		 289/**
290 * bond_dev_queue_xmit - Prepare skb for xmit.
3d632c3f 291 *
1da177e4
LT		 292 * @bond: bond device that got this skb for tx.
293 * @skb: hw accel VLAN tagged skb to transmit
294 * @slave_dev: slave that is supposed to xmit this skbuff
1da177e4 295 */
3d632c3f
SH		 296int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb,
297 struct net_device *slave_dev)
1da177e4 298{
8387451e 299 skb->dev = slave_dev;
374eeb5a 300
5ee31c68 301 BUILD_BUG_ON(sizeof(skb->queue_mapping) !=
df4ab5b3
JP		 302 sizeof(qdisc_skb_cb(skb)->slave_dev_queue_mapping));
303 skb->queue_mapping = qdisc_skb_cb(skb)->slave_dev_queue_mapping;
374eeb5a 304
e15c3c22 305 if (unlikely(netpoll_tx_running(bond->dev)))
8a8efa22 306 bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb);
080e4130 307 else
f6dc31a8 308 dev_queue_xmit(skb);
1da177e4
LT		 309
310 return 0;
311}
312
313/*
cc0e4070
JP		 314 * In the following 2 functions, bond_vlan_rx_add_vid and bond_vlan_rx_kill_vid,
315 * We don't protect the slave list iteration with a lock because:
1da177e4
LT		 316 * a. This operation is performed in IOCTL context,
317 * b. The operation is protected by the RTNL semaphore in the 8021q code,
318 * c. Holding a lock with BH disabled while directly calling a base driver
319 * entry point is generally a BAD idea.
3d632c3f 320 *
1da177e4
LT		 321 * The design of synchronization/protection for this operation in the 8021q
322 * module is good for one or more VLAN devices over a single physical device
323 * and cannot be extended for a teaming solution like bonding, so there is a
324 * potential race condition here where a net device from the vlan group might
325 * be referenced (either by a base driver or the 8021q code) while it is being
326 * removed from the system. However, it turns out we're not making matters
327 * worse, and if it works for regular VLAN usage it will work here too.
328*/
329
1da177e4
LT		 330/**
331 * bond_vlan_rx_add_vid - Propagates adding an id to slaves
332 * @bond_dev: bonding net device that got called
333 * @vid: vlan id being added
334 */
80d5c368
PM		 335static int bond_vlan_rx_add_vid(struct net_device *bond_dev,
336 __be16 proto, u16 vid)
1da177e4 337{
454d7c9b 338 struct bonding *bond = netdev_priv(bond_dev);
81f23b13 339 struct slave *slave, *rollback_slave;
9caff1e7 340 struct list_head *iter;
dec1e90e 341 int res;
1da177e4 342
9caff1e7 343 bond_for_each_slave(bond, slave, iter) {
80d5c368 344 res = vlan_vid_add(slave->dev, proto, vid);
87002b03
JP		 345 if (res)
346 goto unwind;
1da177e4
LT		 347 }
348
8e586137 349 return 0;
87002b03
JP		 350
351unwind:
81f23b13 352 /* unwind to the slave that failed */
9caff1e7 353 bond_for_each_slave(bond, rollback_slave, iter) {
81f23b13
VF		 354 if (rollback_slave == slave)
355 break;
356
357 vlan_vid_del(rollback_slave->dev, proto, vid);
358 }
87002b03
JP		 359
360 return res;
1da177e4
LT		 361}
362
363/**
364 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
365 * @bond_dev: bonding net device that got called
366 * @vid: vlan id being removed
367 */
80d5c368
PM		 368static int bond_vlan_rx_kill_vid(struct net_device *bond_dev,
369 __be16 proto, u16 vid)
1da177e4 370{
454d7c9b 371 struct bonding *bond = netdev_priv(bond_dev);
9caff1e7 372 struct list_head *iter;
1da177e4 373 struct slave *slave;
1da177e4 374
9caff1e7 375 bond_for_each_slave(bond, slave, iter)
80d5c368 376 vlan_vid_del(slave->dev, proto, vid);
1da177e4 377
e868b0c9
VF		 378 if (bond_is_lb(bond))
379 bond_alb_clear_vlan(bond, vid);
8e586137
JP		 380
381 return 0;
1da177e4
LT		 382}
383
1da177e4
LT		 384/*------------------------------- Link status -------------------------------*/
385
ff59c456
JV		 386/*
387 * Set the carrier state for the master according to the state of its
388 * slaves. If any slaves are up, the master is up. In 802.3ad mode,
389 * do special 802.3ad magic.
390 *
391 * Returns zero if carrier state does not change, nonzero if it does.
392 */
393static int bond_set_carrier(struct bonding *bond)
394{
9caff1e7 395 struct list_head *iter;
ff59c456 396 struct slave *slave;
ff59c456 397
0965a1f3 398 if (!bond_has_slaves(bond))
ff59c456
JV		 399 goto down;
400
401 if (bond->params.mode == BOND_MODE_8023AD)
402 return bond_3ad_set_carrier(bond);
403
9caff1e7 404 bond_for_each_slave(bond, slave, iter) {
ff59c456
JV		 405 if (slave->link == BOND_LINK_UP) {
406 if (!netif_carrier_ok(bond->dev)) {
407 netif_carrier_on(bond->dev);
408 return 1;
409 }
410 return 0;
411 }
412 }
413
414down:
415 if (netif_carrier_ok(bond->dev)) {
416 netif_carrier_off(bond->dev);
417 return 1;
418 }
419 return 0;
420}
421
1da177e4
LT		 422/*
423 * Get link speed and duplex from the slave's base driver
424 * using ethtool. If for some reason the call fails or the
98f41f69 425 * values are invalid, set speed and duplex to -1,
13b95fb7 426 * and return.
1da177e4 427 */
13b95fb7 428static void bond_update_speed_duplex(struct slave *slave)
1da177e4
LT		 429{
430 struct net_device *slave_dev = slave->dev;
4bc71cb9 431 struct ethtool_cmd ecmd;
5d30530e 432 u32 slave_speed;
61a44b9c 433 int res;
1da177e4 434
589665f5
DC		 435 slave->speed = SPEED_UNKNOWN;
436 slave->duplex = DUPLEX_UNKNOWN;
1da177e4 437
4bc71cb9 438 res = __ethtool_get_settings(slave_dev, &ecmd);
61a44b9c 439 if (res < 0)
13b95fb7 440 return;
1da177e4 441
4bc71cb9 442 slave_speed = ethtool_cmd_speed(&ecmd);
6f92c66f 443 if (slave_speed == 0 || slave_speed == ((__u32) -1))
13b95fb7 444 return;
1da177e4 445
4bc71cb9 446 switch (ecmd.duplex) {
1da177e4
LT		 447 case DUPLEX_FULL:
448 case DUPLEX_HALF:
449 break;
450 default:
13b95fb7 451 return;
1da177e4
LT		 452 }
453
5d30530e 454 slave->speed = slave_speed;
4bc71cb9 455 slave->duplex = ecmd.duplex;
1da177e4 456
13b95fb7 457 return;
1da177e4
LT		 458}
459
460/*
461 * if <dev> supports MII link status reporting, check its link status.
462 *
463 * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(),
3d632c3f 464 * depending upon the setting of the use_carrier parameter.
1da177e4
LT		 465 *
466 * Return either BMSR_LSTATUS, meaning that the link is up (or we
467 * can't tell and just pretend it is), or 0, meaning that the link is
468 * down.
469 *
470 * If reporting is non-zero, instead of faking link up, return -1 if
471 * both ETHTOOL and MII ioctls fail (meaning the device does not
472 * support them). If use_carrier is set, return whatever it says.
473 * It'd be nice if there was a good way to tell if a driver supports
474 * netif_carrier, but there really isn't.
475 */
3d632c3f
SH		 476static int bond_check_dev_link(struct bonding *bond,
477 struct net_device *slave_dev, int reporting)
1da177e4 478{
eb7cc59a 479 const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
d9d52832 480 int (*ioctl)(struct net_device *, struct ifreq *, int);
1da177e4
LT		 481 struct ifreq ifr;
482 struct mii_ioctl_data *mii;
1da177e4 483
6c988853
PG		 484 if (!reporting && !netif_running(slave_dev))
485 return 0;
486
eb7cc59a 487 if (bond->params.use_carrier)
1da177e4 488 return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;
1da177e4 489
29112f4e 490 /* Try to get link status using Ethtool first. */
c772dde3
BH		 491 if (slave_dev->ethtool_ops->get_link)
492 return slave_dev->ethtool_ops->get_link(slave_dev) ?
493 BMSR_LSTATUS : 0;
29112f4e 494
3d632c3f 495 /* Ethtool can't be used, fallback to MII ioctls. */
eb7cc59a 496 ioctl = slave_ops->ndo_do_ioctl;
1da177e4
LT		 497 if (ioctl) {
498 /* TODO: set pointer to correct ioctl on a per team member */
499 /* bases to make this more efficient. that is, once */
500 /* we determine the correct ioctl, we will always */
501 /* call it and not the others for that team */
502 /* member. */
503
504 /*
505 * We cannot assume that SIOCGMIIPHY will also read a
506 * register; not all network drivers (e.g., e100)
507 * support that.
508 */
509
510 /* Yes, the mii is overlaid on the ifreq.ifr_ifru */
511 strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
512 mii = if_mii(&ifr);
513 if (IOCTL(slave_dev, &ifr, SIOCGMIIPHY) == 0) {
514 mii->reg_num = MII_BMSR;
3d632c3f
SH		 515 if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0)
516 return mii->val_out & BMSR_LSTATUS;
1da177e4
LT		 517 }
518 }
519
1da177e4
LT		 520 /*
521 * If reporting, report that either there's no dev->do_ioctl,
61a44b9c 522 * or both SIOCGMIIREG and get_link failed (meaning that we
1da177e4
LT		 523 * cannot report link status). If not reporting, pretend
524 * we're ok.
525 */
3d632c3f 526 return reporting ? -1 : BMSR_LSTATUS;
1da177e4
LT		 527}
528
529/*----------------------------- Multicast list ------------------------------*/
530
1da177e4
LT		 531/*
532 * Push the promiscuity flag down to appropriate slaves
533 */
7e1a1ac1 534static int bond_set_promiscuity(struct bonding *bond, int inc)
1da177e4 535{
9caff1e7 536 struct list_head *iter;
7e1a1ac1 537 int err = 0;
9caff1e7 538
1da177e4
LT		 539 if (USES_PRIMARY(bond->params.mode)) {
540 /* write lock already acquired */
541 if (bond->curr_active_slave) {
7e1a1ac1
WC		 542 err = dev_set_promiscuity(bond->curr_active_slave->dev,
543 inc);
1da177e4
LT		 544 }
545 } else {
546 struct slave *slave;
dec1e90e 547
9caff1e7 548 bond_for_each_slave(bond, slave, iter) {
7e1a1ac1
WC		 549 err = dev_set_promiscuity(slave->dev, inc);
550 if (err)
551 return err;
1da177e4
LT		 552 }
553 }
7e1a1ac1 554 return err;
1da177e4
LT		 555}
556
557/*
558 * Push the allmulti flag down to all slaves
559 */
7e1a1ac1 560static int bond_set_allmulti(struct bonding *bond, int inc)
1da177e4 561{
9caff1e7 562 struct list_head *iter;
7e1a1ac1 563 int err = 0;
9caff1e7 564
1da177e4
LT		 565 if (USES_PRIMARY(bond->params.mode)) {
566 /* write lock already acquired */
567 if (bond->curr_active_slave) {
7e1a1ac1
WC		 568 err = dev_set_allmulti(bond->curr_active_slave->dev,
569 inc);
1da177e4
LT		 570 }
571 } else {
572 struct slave *slave;
dec1e90e 573
9caff1e7 574 bond_for_each_slave(bond, slave, iter) {
7e1a1ac1
WC		 575 err = dev_set_allmulti(slave->dev, inc);
576 if (err)
577 return err;
1da177e4
LT		 578 }
579 }
7e1a1ac1 580 return err;
1da177e4
LT		 581}
582
5a37e8ca
FL		 583/*
584 * Retrieve the list of registered multicast addresses for the bonding
585 * device and retransmit an IGMP JOIN request to the current active
586 * slave.
587 */
588static void bond_resend_igmp_join_requests(struct bonding *bond)
589{
4aa5dee4 590 if (!rtnl_trylock()) {
4beac029 591 queue_delayed_work(bond->wq, &bond->mcast_work, 1);
4aa5dee4 592 return;
5a37e8ca 593 }
4aa5dee4
JP		 594 call_netdevice_notifiers(NETDEV_RESEND_IGMP, bond->dev);
595 rtnl_unlock();
5a37e8ca 596
4f5474e7
NA		 597 /* We use curr_slave_lock to protect against concurrent access to
598 * igmp_retrans from multiple running instances of this function and
599 * bond_change_active_slave
600 */
601 write_lock_bh(&bond->curr_slave_lock);
602 if (bond->igmp_retrans > 1) {
603 bond->igmp_retrans--;
c2952c31 604 queue_delayed_work(bond->wq, &bond->mcast_work, HZ/5);
4f5474e7
NA		 605 }
606 write_unlock_bh(&bond->curr_slave_lock);
5a37e8ca
FL		 607}
608
379b7383 609static void bond_resend_igmp_join_requests_delayed(struct work_struct *work)
5a37e8ca
FL		 610{
611 struct bonding *bond = container_of(work, struct bonding,
94265cf5 612 mcast_work.work);
ad999eee 613
5a37e8ca
FL		 614 bond_resend_igmp_join_requests(bond);
615}
616
303d1cbf 617/* Flush bond's hardware addresses from slave
1da177e4 618 */
303d1cbf 619static void bond_hw_addr_flush(struct net_device *bond_dev,
3d632c3f 620 struct net_device *slave_dev)
1da177e4 621{
454d7c9b 622 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 623
303d1cbf
JV		 624 dev_uc_unsync(slave_dev, bond_dev);
625 dev_mc_unsync(slave_dev, bond_dev);
1da177e4
LT		 626
627 if (bond->params.mode == BOND_MODE_8023AD) {
628 /* del lacpdu mc addr from mc list */
629 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
630
22bedad3 631 dev_mc_del(slave_dev, lacpdu_multicast);
1da177e4
LT		 632 }
633}
634
635/*--------------------------- Active slave change ---------------------------*/
636
303d1cbf
JV		 637/* Update the hardware address list and promisc/allmulti for the new and
638 * old active slaves (if any). Modes that are !USES_PRIMARY keep all
639 * slaves up date at all times; only the USES_PRIMARY modes need to call
640 * this function to swap these settings during a failover.
1da177e4 641 */
303d1cbf
JV		 642static void bond_hw_addr_swap(struct bonding *bond, struct slave *new_active,
643 struct slave *old_active)
1da177e4 644{
7864a1ad
VF		 645 ASSERT_RTNL();
646
1da177e4 647 if (old_active) {
3d632c3f 648 if (bond->dev->flags & IFF_PROMISC)
1da177e4 649 dev_set_promiscuity(old_active->dev, -1);
1da177e4 650
3d632c3f 651 if (bond->dev->flags & IFF_ALLMULTI)
1da177e4 652 dev_set_allmulti(old_active->dev, -1);
1da177e4 653
303d1cbf 654 bond_hw_addr_flush(bond->dev, old_active->dev);
1da177e4
LT		 655 }
656
657 if (new_active) {
7e1a1ac1 658 /* FIXME: Signal errors upstream. */
3d632c3f 659 if (bond->dev->flags & IFF_PROMISC)
1da177e4 660 dev_set_promiscuity(new_active->dev, 1);
1da177e4 661
3d632c3f 662 if (bond->dev->flags & IFF_ALLMULTI)
1da177e4 663 dev_set_allmulti(new_active->dev, 1);
1da177e4 664
d632ce98 665 netif_addr_lock_bh(bond->dev);
303d1cbf
JV		 666 dev_uc_sync(new_active->dev, bond->dev);
667 dev_mc_sync(new_active->dev, bond->dev);
d632ce98 668 netif_addr_unlock_bh(bond->dev);
1da177e4
LT		 669 }
670}
671
ae0d6750 672/**
673 * bond_set_dev_addr - clone slave's address to bond
674 * @bond_dev: bond net device
675 * @slave_dev: slave net device
676 *
677 * Should be called with RTNL held.
678 */
679static void bond_set_dev_addr(struct net_device *bond_dev,
680 struct net_device *slave_dev)
681{
008aebde
NA		 682 pr_debug("bond_dev=%p slave_dev=%p slave_dev->addr_len=%d\n",
683 bond_dev, slave_dev, slave_dev->addr_len);
ae0d6750 684 memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
685 bond_dev->addr_assign_type = NET_ADDR_STOLEN;
686 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev);
687}
688
3915c1e8
JV		 689/*
690 * bond_do_fail_over_mac
691 *
692 * Perform special MAC address swapping for fail_over_mac settings
693 *
694 * Called with RTNL, bond->lock for read, curr_slave_lock for write_bh.
695 */
696static void bond_do_fail_over_mac(struct bonding *bond,
697 struct slave *new_active,
698 struct slave *old_active)
1f78d9f9
HE		 699 __releases(&bond->curr_slave_lock)
700 __releases(&bond->lock)
701 __acquires(&bond->lock)
702 __acquires(&bond->curr_slave_lock)
3915c1e8
JV		 703{
704 u8 tmp_mac[ETH_ALEN];
705 struct sockaddr saddr;
706 int rv;
707
708 switch (bond->params.fail_over_mac) {
709 case BOND_FOM_ACTIVE:
7d26bb10 710 if (new_active) {
7d26bb10
WP		 711 write_unlock_bh(&bond->curr_slave_lock);
712 read_unlock(&bond->lock);
ae0d6750 713 bond_set_dev_addr(bond->dev, new_active->dev);
7d26bb10
WP		 714 read_lock(&bond->lock);
715 write_lock_bh(&bond->curr_slave_lock);
716 }
3915c1e8
JV		 717 break;
718 case BOND_FOM_FOLLOW:
719 /*
720 * if new_active && old_active, swap them
721 * if just old_active, do nothing (going to no active slave)
722 * if just new_active, set new_active to bond's MAC
723 */
724 if (!new_active)
725 return;
726
727 write_unlock_bh(&bond->curr_slave_lock);
728 read_unlock(&bond->lock);
729
730 if (old_active) {
731 memcpy(tmp_mac, new_active->dev->dev_addr, ETH_ALEN);
732 memcpy(saddr.sa_data, old_active->dev->dev_addr,
733 ETH_ALEN);
734 saddr.sa_family = new_active->dev->type;
735 } else {
736 memcpy(saddr.sa_data, bond->dev->dev_addr, ETH_ALEN);
737 saddr.sa_family = bond->dev->type;
738 }
739
740 rv = dev_set_mac_address(new_active->dev, &saddr);
741 if (rv) {
a4aee5c8 742 pr_err("%s: Error %d setting MAC of slave %s\n",
3915c1e8
JV		 743 bond->dev->name, -rv, new_active->dev->name);
744 goto out;
745 }
746
747 if (!old_active)
748 goto out;
749
750 memcpy(saddr.sa_data, tmp_mac, ETH_ALEN);
751 saddr.sa_family = old_active->dev->type;
752
753 rv = dev_set_mac_address(old_active->dev, &saddr);
754 if (rv)
a4aee5c8 755 pr_err("%s: Error %d setting MAC of slave %s\n",
3915c1e8
JV		 756 bond->dev->name, -rv, new_active->dev->name);
757out:
758 read_lock(&bond->lock);
759 write_lock_bh(&bond->curr_slave_lock);
760 break;
761 default:
a4aee5c8 762 pr_err("%s: bond_do_fail_over_mac impossible: bad policy %d\n",
3915c1e8
JV		 763 bond->dev->name, bond->params.fail_over_mac);
764 break;
765 }
766
767}
768
a549952a
JP		 769static bool bond_should_change_active(struct bonding *bond)
770{
771 struct slave *prim = bond->primary_slave;
772 struct slave *curr = bond->curr_active_slave;
773
774 if (!prim || !curr || curr->link != BOND_LINK_UP)
775 return true;
776 if (bond->force_primary) {
777 bond->force_primary = false;
778 return true;
779 }
780 if (bond->params.primary_reselect == BOND_PRI_RESELECT_BETTER &&
781 (prim->speed < curr->speed ||
782 (prim->speed == curr->speed && prim->duplex <= curr->duplex)))
783 return false;
784 if (bond->params.primary_reselect == BOND_PRI_RESELECT_FAILURE)
785 return false;
786 return true;
787}
3915c1e8 788
1da177e4
LT		 789/**
790 * find_best_interface - select the best available slave to be the active one
791 * @bond: our bonding struct
1da177e4
LT		 792 */
793static struct slave *bond_find_best_slave(struct bonding *bond)
794{
77140d29
VF		 795 struct slave *slave, *bestslave = NULL;
796 struct list_head *iter;
1da177e4 797 int mintime = bond->params.updelay;
1da177e4 798
77140d29
VF		 799 if (bond->primary_slave && bond->primary_slave->link == BOND_LINK_UP &&
800 bond_should_change_active(bond))
801 return bond->primary_slave;
1da177e4 802
77140d29
VF		 803 bond_for_each_slave(bond, slave, iter) {
804 if (slave->link == BOND_LINK_UP)
805 return slave;
806 if (slave->link == BOND_LINK_BACK && IS_UP(slave->dev) &&
807 slave->delay < mintime) {
808 mintime = slave->delay;
809 bestslave = slave;
1da177e4
LT		 810 }
811 }
812
813 return bestslave;
814}
815
ad246c99
BH		 816static bool bond_should_notify_peers(struct bonding *bond)
817{
818 struct slave *slave = bond->curr_active_slave;
819
820 pr_debug("bond_should_notify_peers: bond %s slave %s\n",
821 bond->dev->name, slave ? slave->dev->name : "NULL");
822
823 if (!slave || !bond->send_peer_notif ||
824 test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state))
825 return false;
826
ad246c99
BH		 827 return true;
828}
829
1da177e4
LT		 830/**
831 * change_active_interface - change the active slave into the specified one
832 * @bond: our bonding struct
833 * @new: the new slave to make the active one
834 *
835 * Set the new slave to the bond's settings and unset them on the old
836 * curr_active_slave.
837 * Setting include flags, mc-list, promiscuity, allmulti, etc.
838 *
839 * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP,
840 * because it is apparently the best available slave we have, even though its
841 * updelay hasn't timed out yet.
842 *
3915c1e8
JV		 843 * If new_active is not NULL, caller must hold bond->lock for read and
844 * curr_slave_lock for write_bh.
1da177e4 845 */
a77b5325 846void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
1da177e4
LT		 847{
848 struct slave *old_active = bond->curr_active_slave;
849
3d632c3f 850 if (old_active == new_active)
1da177e4 851 return;
1da177e4
LT		 852
853 if (new_active) {
b2220cad
JV		 854 new_active->jiffies = jiffies;
855
1da177e4
LT		 856 if (new_active->link == BOND_LINK_BACK) {
857 if (USES_PRIMARY(bond->params.mode)) {
a4aee5c8
JP		 858 pr_info("%s: making interface %s the new active one %d ms earlier.\n",
859 bond->dev->name, new_active->dev->name,
860 (bond->params.updelay - new_active->delay) * bond->params.miimon);
1da177e4
LT		 861 }
862
863 new_active->delay = 0;
864 new_active->link = BOND_LINK_UP;
1da177e4 865
3d632c3f 866 if (bond->params.mode == BOND_MODE_8023AD)
1da177e4 867 bond_3ad_handle_link_change(new_active, BOND_LINK_UP);
1da177e4 868
58402054 869 if (bond_is_lb(bond))
1da177e4 870 bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
1da177e4
LT		 871 } else {
872 if (USES_PRIMARY(bond->params.mode)) {
a4aee5c8
JP		 873 pr_info("%s: making interface %s the new active one.\n",
874 bond->dev->name, new_active->dev->name);
1da177e4
LT		 875 }
876 }
877 }
878
3d632c3f 879 if (USES_PRIMARY(bond->params.mode))
303d1cbf 880 bond_hw_addr_swap(bond, new_active, old_active);
1da177e4 881
58402054 882 if (bond_is_lb(bond)) {
1da177e4 883 bond_alb_handle_active_change(bond, new_active);
8f903c70
JV		 884 if (old_active)
885 bond_set_slave_inactive_flags(old_active);
886 if (new_active)
887 bond_set_slave_active_flags(new_active);
1da177e4 888 } else {
278b2083 889 rcu_assign_pointer(bond->curr_active_slave, new_active);
1da177e4 890 }
c3ade5ca
JV		 891
892 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
3d632c3f 893 if (old_active)
c3ade5ca 894 bond_set_slave_inactive_flags(old_active);
c3ade5ca
JV		 895
896 if (new_active) {
ad246c99
BH		 897 bool should_notify_peers = false;
898
c3ade5ca 899 bond_set_slave_active_flags(new_active);
2ab82852 900
709f8a45
OG		 901 if (bond->params.fail_over_mac)
902 bond_do_fail_over_mac(bond, new_active,
903 old_active);
3915c1e8 904
ad246c99
BH		 905 if (netif_running(bond->dev)) {
906 bond->send_peer_notif =
907 bond->params.num_peer_notif;
908 should_notify_peers =
909 bond_should_notify_peers(bond);
910 }
911
01f3109d
OG		 912 write_unlock_bh(&bond->curr_slave_lock);
913 read_unlock(&bond->lock);
914
b7bc2a5b 915 call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, bond->dev);
ad246c99 916 if (should_notify_peers)
b7bc2a5b
AW		 917 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS,
918 bond->dev);
01f3109d
OG		 919
920 read_lock(&bond->lock);
921 write_lock_bh(&bond->curr_slave_lock);
7893b249 922 }
c3ade5ca 923 }
a2fd940f 924
5a37e8ca 925 /* resend IGMP joins since active slave has changed or
94265cf5
FL		 926 * all were sent on curr_active_slave.
927 * resend only if bond is brought up with the affected
928 * bonding modes and the retransmission is enabled */
929 if (netif_running(bond->dev) && (bond->params.resend_igmp > 0) &&
930 ((USES_PRIMARY(bond->params.mode) && new_active) ||
931 bond->params.mode == BOND_MODE_ROUNDROBIN)) {
c2952c31 932 bond->igmp_retrans = bond->params.resend_igmp;
4beac029 933 queue_delayed_work(bond->wq, &bond->mcast_work, 1);
a2fd940f 934 }
1da177e4
LT		 935}
936
937/**
938 * bond_select_active_slave - select a new active slave, if needed
939 * @bond: our bonding struct
940 *
3d632c3f 941 * This functions should be called when one of the following occurs:
1da177e4
LT		 942 * - The old curr_active_slave has been released or lost its link.
943 * - The primary_slave has got its link back.
944 * - A slave has got its link back and there's no old curr_active_slave.
945 *
3915c1e8 946 * Caller must hold bond->lock for read and curr_slave_lock for write_bh.
1da177e4 947 */
a77b5325 948void bond_select_active_slave(struct bonding *bond)
1da177e4
LT		 949{
950 struct slave *best_slave;
ff59c456 951 int rv;
1da177e4
LT		 952
953 best_slave = bond_find_best_slave(bond);
954 if (best_slave != bond->curr_active_slave) {
955 bond_change_active_slave(bond, best_slave);
ff59c456
JV		 956 rv = bond_set_carrier(bond);
957 if (!rv)
958 return;
959
960 if (netif_carrier_ok(bond->dev)) {
a4aee5c8
JP		 961 pr_info("%s: first active interface up!\n",
962 bond->dev->name);
ff59c456 963 } else {
a4aee5c8
JP		 964 pr_info("%s: now running without any active interface !\n",
965 bond->dev->name);
ff59c456 966 }
1da177e4
LT		 967 }
968}
969
f6dc31a8 970#ifdef CONFIG_NET_POLL_CONTROLLER
8a8efa22 971static inline int slave_enable_netpoll(struct slave *slave)
f6dc31a8 972{
8a8efa22
AW		 973 struct netpoll *np;
974 int err = 0;
f6dc31a8 975
47be03a2 976 np = kzalloc(sizeof(*np), GFP_ATOMIC);
8a8efa22
AW		 977 err = -ENOMEM;
978 if (!np)
979 goto out;
980
47be03a2 981 err = __netpoll_setup(np, slave->dev, GFP_ATOMIC);
8a8efa22
AW		 982 if (err) {
983 kfree(np);
984 goto out;
f6dc31a8 985 }
8a8efa22
AW		 986 slave->np = np;
987out:
988 return err;
989}
990static inline void slave_disable_netpoll(struct slave *slave)
991{
992 struct netpoll *np = slave->np;
993
994 if (!np)
995 return;
996
997 slave->np = NULL;
2cde6acd 998 __netpoll_free_async(np);
8a8efa22
AW		 999}
1000static inline bool slave_dev_support_netpoll(struct net_device *slave_dev)
1001{
1002 if (slave_dev->priv_flags & IFF_DISABLE_NETPOLL)
1003 return false;
1004 if (!slave_dev->netdev_ops->ndo_poll_controller)
1005 return false;
1006 return true;
f6dc31a8
WC		 1007}
1008
1009static void bond_poll_controller(struct net_device *bond_dev)
1010{
8a8efa22
AW		 1011}
1012
c4cdef9b 1013static void bond_netpoll_cleanup(struct net_device *bond_dev)
8a8efa22 1014{
c4cdef9b 1015 struct bonding *bond = netdev_priv(bond_dev);
9caff1e7 1016 struct list_head *iter;
c2355e1a 1017 struct slave *slave;
c2355e1a 1018
9caff1e7 1019 bond_for_each_slave(bond, slave, iter)
8a8efa22
AW		 1020 if (IS_UP(slave->dev))
1021 slave_disable_netpoll(slave);
f6dc31a8 1022}
8a8efa22 1023
47be03a2 1024static int bond_netpoll_setup(struct net_device *dev, struct netpoll_info *ni, gfp_t gfp)
8a8efa22
AW		 1025{
1026 struct bonding *bond = netdev_priv(dev);
9caff1e7 1027 struct list_head *iter;
f6dc31a8 1028 struct slave *slave;
dec1e90e 1029 int err = 0;
f6dc31a8 1030
9caff1e7 1031 bond_for_each_slave(bond, slave, iter) {
8a8efa22
AW		 1032 err = slave_enable_netpoll(slave);
1033 if (err) {
c4cdef9b 1034 bond_netpoll_cleanup(dev);
8a8efa22 1035 break;
f6dc31a8
WC		 1036 }
1037 }
8a8efa22 1038 return err;
f6dc31a8 1039}
8a8efa22
AW		 1040#else
1041static inline int slave_enable_netpoll(struct slave *slave)
1042{
1043 return 0;
1044}
1045static inline void slave_disable_netpoll(struct slave *slave)
1046{
1047}
f6dc31a8
WC		 1048static void bond_netpoll_cleanup(struct net_device *bond_dev)
1049{
1050}
f6dc31a8
WC		 1051#endif
1052
1da177e4
LT		 1053/*---------------------------------- IOCTL ----------------------------------*/
1054
c8f44aff 1055static netdev_features_t bond_fix_features(struct net_device *dev,
9b7b165a 1056 netdev_features_t features)
8531c5ff 1057{
b2a103e6 1058 struct bonding *bond = netdev_priv(dev);
9caff1e7 1059 struct list_head *iter;
c8f44aff 1060 netdev_features_t mask;
9b7b165a 1061 struct slave *slave;
b63365a2 1062
0965a1f3 1063 if (!bond_has_slaves(bond)) {
b2a103e6
MM		 1064 /* Disable adding VLANs to empty bond. But why? --mq */
1065 features |= NETIF_F_VLAN_CHALLENGED;
9b7b165a 1066 return features;
b2a103e6 1067 }
b63365a2 1068
b2a103e6 1069 mask = features;
b63365a2 1070 features &= ~NETIF_F_ONE_FOR_ALL;
b2a103e6 1071 features |= NETIF_F_ALL_FOR_ALL;
7f353bf2 1072
9caff1e7 1073 bond_for_each_slave(bond, slave, iter) {
b63365a2
HX		 1074 features = netdev_increment_features(features,
1075 slave->dev->features,
b2a103e6
MM		 1076 mask);
1077 }
b0ce3508 1078 features = netdev_add_tso_features(features, mask);
b2a103e6 1079
b2a103e6
MM		 1080 return features;
1081}
1082
62f2a3a4
MM		 1083#define BOND_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
1084 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
1085 NETIF_F_HIGHDMA | NETIF_F_LRO)
b2a103e6
MM		 1086
1087static void bond_compute_features(struct bonding *bond)
1088{
c4826861 1089 unsigned int flags, dst_release_flag = IFF_XMIT_DST_RELEASE;
c8f44aff 1090 netdev_features_t vlan_features = BOND_VLAN_FEATURES;
9caff1e7
VF		 1091 struct net_device *bond_dev = bond->dev;
1092 struct list_head *iter;
1093 struct slave *slave;
b2a103e6 1094 unsigned short max_hard_header_len = ETH_HLEN;
0e376bd0
SB		 1095 unsigned int gso_max_size = GSO_MAX_SIZE;
1096 u16 gso_max_segs = GSO_MAX_SEGS;
b2a103e6 1097
0965a1f3 1098 if (!bond_has_slaves(bond))
b2a103e6
MM		 1099 goto done;
1100
9caff1e7 1101 bond_for_each_slave(bond, slave, iter) {
278339a4 1102 vlan_features = netdev_increment_features(vlan_features,
b2a103e6
MM		 1103 slave->dev->vlan_features, BOND_VLAN_FEATURES);
1104
b6fe83e9 1105 dst_release_flag &= slave->dev->priv_flags;
54ef3137
JV		 1106 if (slave->dev->hard_header_len > max_hard_header_len)
1107 max_hard_header_len = slave->dev->hard_header_len;
0e376bd0
SB		 1108
1109 gso_max_size = min(gso_max_size, slave->dev->gso_max_size);
1110 gso_max_segs = min(gso_max_segs, slave->dev->gso_max_segs);
54ef3137 1111 }
8531c5ff 1112
b63365a2 1113done:
b2a103e6 1114 bond_dev->vlan_features = vlan_features;
54ef3137 1115 bond_dev->hard_header_len = max_hard_header_len;
0e376bd0
SB		 1116 bond_dev->gso_max_segs = gso_max_segs;
1117 netif_set_gso_max_size(bond_dev, gso_max_size);
8531c5ff 1118
b6fe83e9
ED		 1119 flags = bond_dev->priv_flags & ~IFF_XMIT_DST_RELEASE;
1120 bond_dev->priv_flags = flags | dst_release_flag;
1121
b2a103e6 1122 netdev_change_features(bond_dev);
8531c5ff
AK		 1123}
1124
872254dd
MS		 1125static void bond_setup_by_slave(struct net_device *bond_dev,
1126 struct net_device *slave_dev)
1127{
00829823 1128 bond_dev->header_ops = slave_dev->header_ops;
872254dd
MS		 1129
1130 bond_dev->type = slave_dev->type;
1131 bond_dev->hard_header_len = slave_dev->hard_header_len;
1132 bond_dev->addr_len = slave_dev->addr_len;
1133
1134 memcpy(bond_dev->broadcast, slave_dev->broadcast,
1135 slave_dev->addr_len);
1136}
1137
5b2c4dd2 1138/* On bonding slaves other than the currently active slave, suppress
3aba891d 1139 * duplicates except for alb non-mcast/bcast.
5b2c4dd2
JP		 1140 */
1141static bool bond_should_deliver_exact_match(struct sk_buff *skb,
0bd80dad
JP		 1142 struct slave *slave,
1143 struct bonding *bond)
5b2c4dd2 1144{
2d7011ca 1145 if (bond_is_slave_inactive(slave)) {
0bd80dad 1146 if (bond->params.mode == BOND_MODE_ALB &&
5b2c4dd2
JP		 1147 skb->pkt_type != PACKET_BROADCAST &&
1148 skb->pkt_type != PACKET_MULTICAST)
5b2c4dd2 1149 return false;
5b2c4dd2
JP		 1150 return true;
1151 }
1152 return false;
1153}
1154
8a4eb573 1155static rx_handler_result_t bond_handle_frame(struct sk_buff **pskb)
5b2c4dd2 1156{
8a4eb573 1157 struct sk_buff *skb = *pskb;
f1c1775a 1158 struct slave *slave;
0bd80dad 1159 struct bonding *bond;
de063b70
ED		 1160 int (*recv_probe)(const struct sk_buff *, struct bonding *,
1161 struct slave *);
13a8e0c8 1162 int ret = RX_HANDLER_ANOTHER;
5b2c4dd2 1163
8a4eb573
JP		 1164 skb = skb_share_check(skb, GFP_ATOMIC);
1165 if (unlikely(!skb))
1166 return RX_HANDLER_CONSUMED;
1167
1168 *pskb = skb;
5b2c4dd2 1169
35d48903
JP		 1170 slave = bond_slave_get_rcu(skb->dev);
1171 bond = slave->bond;
0bd80dad
JP		 1172
1173 if (bond->params.arp_interval)
f1c1775a 1174 slave->dev->last_rx = jiffies;
5b2c4dd2 1175
4d97480b
MH		 1176 recv_probe = ACCESS_ONCE(bond->recv_probe);
1177 if (recv_probe) {
de063b70
ED		 1178 ret = recv_probe(skb, bond, slave);
1179 if (ret == RX_HANDLER_CONSUMED) {
1180 consume_skb(skb);
1181 return ret;
3aba891d
JP		 1182 }
1183 }
1184
0bd80dad 1185 if (bond_should_deliver_exact_match(skb, slave, bond)) {
8a4eb573 1186 return RX_HANDLER_EXACT;
5b2c4dd2
JP		 1187 }
1188
35d48903 1189 skb->dev = bond->dev;
5b2c4dd2 1190
0bd80dad 1191 if (bond->params.mode == BOND_MODE_ALB &&
35d48903 1192 bond->dev->priv_flags & IFF_BRIDGE_PORT &&
5b2c4dd2 1193 skb->pkt_type == PACKET_HOST) {
5b2c4dd2 1194
541ac7c9
CG		 1195 if (unlikely(skb_cow_head(skb,
1196 skb->data - skb_mac_header(skb)))) {
1197 kfree_skb(skb);
8a4eb573 1198 return RX_HANDLER_CONSUMED;
541ac7c9 1199 }
35d48903 1200 memcpy(eth_hdr(skb)->h_dest, bond->dev->dev_addr, ETH_ALEN);
5b2c4dd2
JP		 1201 }
1202
13a8e0c8 1203 return ret;
5b2c4dd2
JP		 1204}
1205
471cb5a3 1206static int bond_master_upper_dev_link(struct net_device *bond_dev,
1f718f0f
VF		 1207 struct net_device *slave_dev,
1208 struct slave *slave)
471cb5a3
JP		 1209{
1210 int err;
1211
1f718f0f 1212 err = netdev_master_upper_dev_link_private(slave_dev, bond_dev, slave);
471cb5a3
JP		 1213 if (err)
1214 return err;
1215 slave_dev->flags |= IFF_SLAVE;
7f294054 1216 rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE, GFP_KERNEL);
471cb5a3
JP		 1217 return 0;
1218}
1219
1220static void bond_upper_dev_unlink(struct net_device *bond_dev,
1221 struct net_device *slave_dev)
1222{
1223 netdev_upper_dev_unlink(slave_dev, bond_dev);
1224 slave_dev->flags &= ~IFF_SLAVE;
7f294054 1225 rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE, GFP_KERNEL);
471cb5a3
JP		 1226}
1227
1da177e4 1228/* enslave device <slave> to bond device <master> */
a77b5325 1229int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
1da177e4 1230{
454d7c9b 1231 struct bonding *bond = netdev_priv(bond_dev);
eb7cc59a 1232 const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
c8c23903 1233 struct slave *new_slave = NULL, *prev_slave;
1da177e4
LT		 1234 struct sockaddr addr;
1235 int link_reporting;
8599b52e 1236 int res = 0, i;
1da177e4 1237
c772dde3
BH		 1238 if (!bond->params.use_carrier &&
1239 slave_dev->ethtool_ops->get_link == NULL &&
1240 slave_ops->ndo_do_ioctl == NULL) {
a4aee5c8
JP		 1241 pr_warning("%s: Warning: no link monitoring support for %s\n",
1242 bond_dev->name, slave_dev->name);
1da177e4
LT		 1243 }
1244
1da177e4
LT		 1245 /* already enslaved */
1246 if (slave_dev->flags & IFF_SLAVE) {
5a03cdb7 1247 pr_debug("Error, Device was already enslaved\n");
1da177e4
LT		 1248 return -EBUSY;
1249 }
1250
1251 /* vlan challenged mutual exclusion */
1252 /* no need to lock since we're protected by rtnl_lock */
1253 if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) {
5a03cdb7 1254 pr_debug("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
55462cf3 1255 if (vlan_uses_dev(bond_dev)) {
a4aee5c8
JP		 1256 pr_err("%s: Error: cannot enslave VLAN challenged slave %s on VLAN enabled bond %s\n",
1257 bond_dev->name, slave_dev->name, bond_dev->name);
1da177e4
LT		 1258 return -EPERM;
1259 } else {
a4aee5c8
JP		 1260 pr_warning("%s: Warning: enslaved VLAN challenged slave %s. Adding VLANs will be blocked as long as %s is part of bond %s\n",
1261 bond_dev->name, slave_dev->name,
1262 slave_dev->name, bond_dev->name);
1da177e4
LT		 1263 }
1264 } else {
5a03cdb7 1265 pr_debug("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
1da177e4
LT		 1266 }
1267
217df670
JV		 1268 /*
1269 * Old ifenslave binaries are no longer supported. These can
3d632c3f 1270 * be identified with moderate accuracy by the state of the slave:
217df670
JV		 1271 * the current ifenslave will set the interface down prior to
1272 * enslaving it; the old ifenslave will not.
1273 */
1274 if ((slave_dev->flags & IFF_UP)) {
a4aee5c8 1275 pr_err("%s is up. This may be due to an out of date ifenslave.\n",
217df670
JV		 1276 slave_dev->name);
1277 res = -EPERM;
1278 goto err_undo_flags;
1279 }
1da177e4 1280
872254dd
MS		 1281 /* set bonding device ether type by slave - bonding netdevices are
1282 * created with ether_setup, so when the slave type is not ARPHRD_ETHER
1283 * there is a need to override some of the type dependent attribs/funcs.
1284 *
1285 * bond ether type mutual exclusion - don't allow slaves of dissimilar
1286 * ether type (eg ARPHRD_ETHER and ARPHRD_INFINIBAND) share the same bond
1287 */
0965a1f3 1288 if (!bond_has_slaves(bond)) {
e36b9d16 1289 if (bond_dev->type != slave_dev->type) {
e36b9d16 1290 pr_debug("%s: change device type from %d to %d\n",
a4aee5c8
JP		 1291 bond_dev->name,
1292 bond_dev->type, slave_dev->type);
75c78500 1293
b7bc2a5b
AW		 1294 res = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE,
1295 bond_dev);
3ca5b404
JP		 1296 res = notifier_to_errno(res);
1297 if (res) {
1298 pr_err("%s: refused to change device type\n",
1299 bond_dev->name);
1300 res = -EBUSY;
1301 goto err_undo_flags;
1302 }
75c78500 1303
32a806c1 1304 /* Flush unicast and multicast addresses */
a748ee24 1305 dev_uc_flush(bond_dev);
22bedad3 1306 dev_mc_flush(bond_dev);
32a806c1 1307
e36b9d16
MS		 1308 if (slave_dev->type != ARPHRD_ETHER)
1309 bond_setup_by_slave(bond_dev, slave_dev);
550fd08c 1310 else {
e36b9d16 1311 ether_setup(bond_dev);
550fd08c
NH		 1312 bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1313 }
75c78500 1314
b7bc2a5b
AW		 1315 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE,
1316 bond_dev);
e36b9d16 1317 }
872254dd 1318 } else if (bond_dev->type != slave_dev->type) {
a4aee5c8
JP		 1319 pr_err("%s ether type (%d) is different from other slaves (%d), can not enslave it.\n",
1320 slave_dev->name,
1321 slave_dev->type, bond_dev->type);
1322 res = -EINVAL;
1323 goto err_undo_flags;
872254dd
MS		 1324 }
1325
eb7cc59a 1326 if (slave_ops->ndo_set_mac_address == NULL) {
0965a1f3 1327 if (!bond_has_slaves(bond)) {
a4aee5c8
JP		 1328 pr_warning("%s: Warning: The first slave device specified does not support setting the MAC address. Setting fail_over_mac to active.",
1329 bond_dev->name);
3915c1e8
JV		 1330 bond->params.fail_over_mac = BOND_FOM_ACTIVE;
1331 } else if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
a4aee5c8
JP		 1332 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",
1333 bond_dev->name);
2ab82852
MS		 1334 res = -EOPNOTSUPP;
1335 goto err_undo_flags;
1336 }
1da177e4
LT		 1337 }
1338
8d8fc29d
AW		 1339 call_netdevice_notifiers(NETDEV_JOIN, slave_dev);
1340
c20811a7
JP		 1341 /* If this is the first slave, then we need to set the master's hardware
1342 * address to be the same as the slave's. */
0965a1f3 1343 if (!bond_has_slaves(bond) &&
dec1e90e 1344 bond->dev->addr_assign_type == NET_ADDR_RANDOM)
409cc1f8 1345 bond_set_dev_addr(bond->dev, slave_dev);
c20811a7 1346
243cb4e5 1347 new_slave = kzalloc(sizeof(struct slave), GFP_KERNEL);
1da177e4
LT		 1348 if (!new_slave) {
1349 res = -ENOMEM;
1350 goto err_undo_flags;
1351 }
bb1d9123
AG		 1352 /*
1353 * Set the new_slave's queue_id to be zero. Queue ID mapping
1354 * is set via sysfs or module option if desired.
1355 */
1356 new_slave->queue_id = 0;
1357
b15ba0fb
JP		 1358 /* Save slave's original mtu and then set it to match the bond */
1359 new_slave->original_mtu = slave_dev->mtu;
1360 res = dev_set_mtu(slave_dev, bond->dev->mtu);
1361 if (res) {
1362 pr_debug("Error %d calling dev_set_mtu\n", res);
1363 goto err_free;
1364 }
1365
217df670
JV		 1366 /*
1367 * Save slave's original ("permanent") mac address for modes
1368 * that need it, and for restoring it upon release, and then
1369 * set it to the master's address
1370 */
1371 memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN);
1da177e4 1372
dd957c57 1373 if (!bond->params.fail_over_mac) {
2ab82852
MS		 1374 /*
1375 * Set slave to master's mac address. The application already
1376 * set the master's mac address to that of the first slave
1377 */
1378 memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
1379 addr.sa_family = slave_dev->type;
1380 res = dev_set_mac_address(slave_dev, &addr);
1381 if (res) {
5a03cdb7 1382 pr_debug("Error %d calling set_mac_address\n", res);
b15ba0fb 1383 goto err_restore_mtu;
2ab82852 1384 }
217df670 1385 }
1da177e4 1386
217df670
JV		 1387 /* open the slave since the application closed it */
1388 res = dev_open(slave_dev);
1389 if (res) {
3d632c3f 1390 pr_debug("Opening slave %s failed\n", slave_dev->name);
1f718f0f 1391 goto err_restore_mac;
1da177e4
LT		 1392 }
1393
35d48903 1394 new_slave->bond = bond;
1da177e4 1395 new_slave->dev = slave_dev;
0b680e75 1396 slave_dev->priv_flags |= IFF_BONDING;
1da177e4 1397
58402054 1398 if (bond_is_lb(bond)) {
1da177e4
LT		 1399 /* bond_alb_init_slave() must be called before all other stages since
1400 * it might fail and we do not want to have to undo everything
1401 */
1402 res = bond_alb_init_slave(bond, new_slave);
3d632c3f 1403 if (res)
569f0c4d 1404 goto err_close;
1da177e4
LT		 1405 }
1406
303d1cbf
JV		 1407 /* If the mode USES_PRIMARY, then the following is handled by
1408 * bond_change_active_slave().
1da177e4
LT		 1409 */
1410 if (!USES_PRIMARY(bond->params.mode)) {
1411 /* set promiscuity level to new slave */
1412 if (bond_dev->flags & IFF_PROMISC) {
7e1a1ac1
WC		 1413 res = dev_set_promiscuity(slave_dev, 1);
1414 if (res)
1415 goto err_close;
1da177e4
LT		 1416 }
1417
1418 /* set allmulti level to new slave */
1419 if (bond_dev->flags & IFF_ALLMULTI) {
7e1a1ac1
WC		 1420 res = dev_set_allmulti(slave_dev, 1);
1421 if (res)
1422 goto err_close;
1da177e4
LT		 1423 }
1424
b9e40857 1425 netif_addr_lock_bh(bond_dev);
303d1cbf
JV		 1426
1427 dev_mc_sync_multiple(slave_dev, bond_dev);
1428 dev_uc_sync_multiple(slave_dev, bond_dev);
1429
b9e40857 1430 netif_addr_unlock_bh(bond_dev);
1da177e4
LT		 1431 }
1432
1433 if (bond->params.mode == BOND_MODE_8023AD) {
1434 /* add lacpdu mc addr to mc list */
1435 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
1436
22bedad3 1437 dev_mc_add(slave_dev, lacpdu_multicast);
1da177e4
LT		 1438 }
1439
b8e2fde4
WY		 1440 res = vlan_vids_add_by_dev(slave_dev, bond_dev);
1441 if (res) {
1ff412ad 1442 pr_err("%s: Error: Couldn't add bond vlan ids to %s\n",
1443 bond_dev->name, slave_dev->name);
1444 goto err_close;
1445 }
1da177e4 1446
c8c23903 1447 prev_slave = bond_last_slave(bond);
1da177e4
LT		 1448
1449 new_slave->delay = 0;
1450 new_slave->link_failure_count = 0;
1451
876254ae
VF		 1452 bond_update_speed_duplex(new_slave);
1453
f31c7937
MK		 1454 new_slave->last_arp_rx = jiffies -
1455 (msecs_to_jiffies(bond->params.arp_interval) + 1);
8599b52e
VF		 1456 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
1457 new_slave->target_last_arp_rx[i] = new_slave->last_arp_rx;
f5b2b966 1458
1da177e4
LT		 1459 if (bond->params.miimon && !bond->params.use_carrier) {
1460 link_reporting = bond_check_dev_link(bond, slave_dev, 1);
1461
1462 if ((link_reporting == -1) && !bond->params.arp_interval) {
1463 /*
1464 * miimon is set but a bonded network driver
1465 * does not support ETHTOOL/MII and
1466 * arp_interval is not set. Note: if
1467 * use_carrier is enabled, we will never go
1468 * here (because netif_carrier is always
1469 * supported); thus, we don't need to change
1470 * the messages for netif_carrier.
1471 */
a4aee5c8 1472 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",
4e0952c7 1473 bond_dev->name, slave_dev->name);
1da177e4
LT		 1474 } else if (link_reporting == -1) {
1475 /* unable get link status using mii/ethtool */
a4aee5c8
JP		 1476 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",
1477 bond_dev->name, slave_dev->name);
1da177e4
LT		 1478 }
1479 }
1480
1481 /* check for initial state */
f31c7937
MK		 1482 if (bond->params.miimon) {
1483 if (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS) {
1484 if (bond->params.updelay) {
1485 new_slave->link = BOND_LINK_BACK;
1486 new_slave->delay = bond->params.updelay;
1487 } else {
1488 new_slave->link = BOND_LINK_UP;
1489 }
1da177e4 1490 } else {
f31c7937 1491 new_slave->link = BOND_LINK_DOWN;
1da177e4 1492 }
f31c7937
MK		 1493 } else if (bond->params.arp_interval) {
1494 new_slave->link = (netif_carrier_ok(slave_dev) ?
1495 BOND_LINK_UP : BOND_LINK_DOWN);
1da177e4 1496 } else {
f31c7937 1497 new_slave->link = BOND_LINK_UP;
1da177e4
LT		 1498 }
1499
f31c7937
MK		 1500 if (new_slave->link != BOND_LINK_DOWN)
1501 new_slave->jiffies = jiffies;
1502 pr_debug("Initial state of slave_dev is BOND_LINK_%s\n",
1503 new_slave->link == BOND_LINK_DOWN ? "DOWN" :
1504 (new_slave->link == BOND_LINK_UP ? "UP" : "BACK"));
1505
1da177e4
LT		 1506 if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
1507 /* if there is a primary slave, remember it */
a549952a 1508 if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
1da177e4 1509 bond->primary_slave = new_slave;
a549952a
JP		 1510 bond->force_primary = true;
1511 }
1da177e4
LT		 1512 }
1513
1514 switch (bond->params.mode) {
1515 case BOND_MODE_ACTIVEBACKUP:
8a8e447b 1516 bond_set_slave_inactive_flags(new_slave);
1da177e4
LT		 1517 break;
1518 case BOND_MODE_8023AD:
1519 /* in 802.3ad mode, the internal mechanism
1520 * will activate the slaves in the selected
1521 * aggregator
1522 */
1523 bond_set_slave_inactive_flags(new_slave);
1524 /* if this is the first slave */
23c147e0 1525 if (!prev_slave) {
1da177e4
LT		 1526 SLAVE_AD_INFO(new_slave).id = 1;
1527 /* Initialize AD with the number of times that the AD timer is called in 1 second
1528 * can be called only after the mac address of the bond is set
1529 */
56d00c67 1530 bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL);
1da177e4
LT		 1531 } else {
1532 SLAVE_AD_INFO(new_slave).id =
dec1e90e 1533 SLAVE_AD_INFO(prev_slave).id + 1;
1da177e4
LT		 1534 }
1535
1536 bond_3ad_bind_slave(new_slave);
1537 break;
1538 case BOND_MODE_TLB:
1539 case BOND_MODE_ALB:
e30bc066 1540 bond_set_active_slave(new_slave);
059fe7a5 1541 bond_set_slave_inactive_flags(new_slave);
1da177e4
LT		 1542 break;
1543 default:
5a03cdb7 1544 pr_debug("This slave is always active in trunk mode\n");
1da177e4
LT		 1545
1546 /* always active in trunk mode */
e30bc066 1547 bond_set_active_slave(new_slave);
1da177e4
LT		 1548
1549 /* In trunking mode there is little meaning to curr_active_slave
1550 * anyway (it holds no special properties of the bond device),
1551 * so we can change it without calling change_active_interface()
1552 */
4e591b93 1553 if (!bond->curr_active_slave && new_slave->link == BOND_LINK_UP)
278b2083 1554 rcu_assign_pointer(bond->curr_active_slave, new_slave);
3d632c3f 1555
1da177e4
LT		 1556 break;
1557 } /* switch(bond_mode) */
1558
f6dc31a8 1559#ifdef CONFIG_NET_POLL_CONTROLLER
10eccb46 1560 slave_dev->npinfo = bond->dev->npinfo;
8a8efa22
AW		 1561 if (slave_dev->npinfo) {
1562 if (slave_enable_netpoll(new_slave)) {
1563 read_unlock(&bond->lock);
1564 pr_info("Error, %s: master_dev is using netpoll, "
1565 "but new slave device does not support netpoll.\n",
1566 bond_dev->name);
1567 res = -EBUSY;
f7d9821a 1568 goto err_detach;
8a8efa22 1569 }
f6dc31a8
WC		 1570 }
1571#endif
8a8efa22 1572
35d48903
JP		 1573 res = netdev_rx_handler_register(slave_dev, bond_handle_frame,
1574 new_slave);
1575 if (res) {
1576 pr_debug("Error %d calling netdev_rx_handler_register\n", res);
5831d66e 1577 goto err_detach;
35d48903
JP		 1578 }
1579
1f718f0f
VF		 1580 res = bond_master_upper_dev_link(bond_dev, slave_dev, new_slave);
1581 if (res) {
1582 pr_debug("Error %d calling bond_master_upper_dev_link\n", res);
1583 goto err_unregister;
1584 }
1585
5378c2e6
VF		 1586 bond->slave_cnt++;
1587 bond_compute_features(bond);
1588 bond_set_carrier(bond);
1589
1590 if (USES_PRIMARY(bond->params.mode)) {
1591 read_lock(&bond->lock);
1592 write_lock_bh(&bond->curr_slave_lock);
1593 bond_select_active_slave(bond);
1594 write_unlock_bh(&bond->curr_slave_lock);
1595 read_unlock(&bond->lock);
1596 }
1f718f0f 1597
a4aee5c8
JP		 1598 pr_info("%s: enslaving %s as a%s interface with a%s link.\n",
1599 bond_dev->name, slave_dev->name,
e30bc066 1600 bond_is_active_slave(new_slave) ? "n active" : " backup",
a4aee5c8 1601 new_slave->link != BOND_LINK_DOWN ? "n up" : " down");
1da177e4
LT		 1602
1603 /* enslave is successful */
1604 return 0;
1605
1606/* Undo stages on error */
1f718f0f
VF		 1607err_unregister:
1608 netdev_rx_handler_unregister(slave_dev);
1609
f7d9821a 1610err_detach:
303d1cbf
JV		 1611 if (!USES_PRIMARY(bond->params.mode))
1612 bond_hw_addr_flush(bond_dev, slave_dev);
1613
1ff412ad 1614 vlan_vids_del_by_dev(slave_dev, bond_dev);
f7d9821a 1615 write_lock_bh(&bond->lock);
3c5913b5 1616 if (bond->primary_slave == new_slave)
1617 bond->primary_slave = NULL;
3c5913b5 1618 if (bond->curr_active_slave == new_slave) {
c6cdcf6d 1619 bond_change_active_slave(bond, NULL);
1620 write_unlock_bh(&bond->lock);
3c5913b5 1621 read_lock(&bond->lock);
1622 write_lock_bh(&bond->curr_slave_lock);
3c5913b5 1623 bond_select_active_slave(bond);
1624 write_unlock_bh(&bond->curr_slave_lock);
1625 read_unlock(&bond->lock);
c6cdcf6d 1626 } else {
1627 write_unlock_bh(&bond->lock);
3c5913b5 1628 }
fc7a72ac 1629 slave_disable_netpoll(new_slave);
f7d9821a 1630
1da177e4 1631err_close:
b6a5a7b9 1632 slave_dev->priv_flags &= ~IFF_BONDING;
1da177e4
LT		 1633 dev_close(slave_dev);
1634
1635err_restore_mac:
dd957c57 1636 if (!bond->params.fail_over_mac) {
3915c1e8
JV		 1637 /* XXX TODO - fom follow mode needs to change master's
1638 * MAC if this slave's MAC is in use by the bond, or at
1639 * least print a warning.
1640 */
2ab82852
MS		 1641 memcpy(addr.sa_data, new_slave->perm_hwaddr, ETH_ALEN);
1642 addr.sa_family = slave_dev->type;
1643 dev_set_mac_address(slave_dev, &addr);
1644 }
1da177e4 1645
b15ba0fb
JP		 1646err_restore_mtu:
1647 dev_set_mtu(slave_dev, new_slave->original_mtu);
1648
1da177e4
LT		 1649err_free:
1650 kfree(new_slave);
1651
1652err_undo_flags:
b8fad459 1653 /* Enslave of first slave has failed and we need to fix master's mac */
0965a1f3 1654 if (!bond_has_slaves(bond) &&
b8fad459
NA		 1655 ether_addr_equal(bond_dev->dev_addr, slave_dev->dev_addr))
1656 eth_hw_addr_random(bond_dev);
3d632c3f 1657
1da177e4
LT		 1658 return res;
1659}
1660
1661/*
1662 * Try to release the slave device <slave> from the bond device <master>
1663 * It is legal to access curr_active_slave without a lock because all the function
0896341a 1664 * is write-locked. If "all" is true it means that the function is being called
1665 * while destroying a bond interface and all slaves are being released.
1da177e4
LT		 1666 *
1667 * The rules for slave state should be:
1668 * for Active/Backup:
1669 * Active stays on all backups go down
1670 * for Bonded connections:
1671 * The first up interface should be left on and all others downed.
1672 */
0896341a 1673static int __bond_release_one(struct net_device *bond_dev,
1674 struct net_device *slave_dev,
1675 bool all)
1da177e4 1676{
454d7c9b 1677 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 1678 struct slave *slave, *oldcurrent;
1679 struct sockaddr addr;
5a0068de 1680 int old_flags = bond_dev->flags;
c8f44aff 1681 netdev_features_t old_features = bond_dev->features;
1da177e4
LT		 1682
1683 /* slave is not a slave or master is not master of this slave */
1684 if (!(slave_dev->flags & IFF_SLAVE) ||
471cb5a3 1685 !netdev_has_upper_dev(slave_dev, bond_dev)) {
a4aee5c8 1686 pr_err("%s: Error: cannot release %s.\n",
1da177e4
LT		 1687 bond_dev->name, slave_dev->name);
1688 return -EINVAL;
1689 }
1690
e843fa50 1691 block_netpoll_tx();
1da177e4
LT		 1692 write_lock_bh(&bond->lock);
1693
1694 slave = bond_get_slave_by_dev(bond, slave_dev);
1695 if (!slave) {
1696 /* not a slave of this bond */
a4aee5c8
JP		 1697 pr_info("%s: %s not enslaved\n",
1698 bond_dev->name, slave_dev->name);
f5e2a7b2 1699 write_unlock_bh(&bond->lock);
e843fa50 1700 unblock_netpoll_tx();
1da177e4
LT		 1701 return -EINVAL;
1702 }
1703
fcd99434 1704 write_unlock_bh(&bond->lock);
1f718f0f 1705
5378c2e6
VF		 1706 /* release the slave from its bond */
1707 bond->slave_cnt--;
1708
1f718f0f 1709 bond_upper_dev_unlink(bond_dev, slave_dev);
35d48903
JP		 1710 /* unregister rx_handler early so bond_handle_frame wouldn't be called
1711 * for this slave anymore.
1712 */
1713 netdev_rx_handler_unregister(slave_dev);
35d48903
JP		 1714 write_lock_bh(&bond->lock);
1715
1da177e4
LT		 1716 /* Inform AD package of unbinding of slave. */
1717 if (bond->params.mode == BOND_MODE_8023AD) {
1718 /* must be called before the slave is
1719 * detached from the list
1720 */
1721 bond_3ad_unbind_slave(slave);
1722 }
1723
a4aee5c8
JP		 1724 pr_info("%s: releasing %s interface %s\n",
1725 bond_dev->name,
e30bc066 1726 bond_is_active_slave(slave) ? "active" : "backup",
a4aee5c8 1727 slave_dev->name);
1da177e4
LT		 1728
1729 oldcurrent = bond->curr_active_slave;
1730
1731 bond->current_arp_slave = NULL;
1732
dec1e90e 1733 if (!all && !bond->params.fail_over_mac) {
1734 if (ether_addr_equal(bond_dev->dev_addr, slave->perm_hwaddr) &&
0965a1f3 1735 bond_has_slaves(bond))
dec1e90e 1736 pr_warn("%s: Warning: the permanent HWaddr of %s - %pM - is still in use by %s. Set the HWaddr of %s to a different address to avoid conflicts.\n",
1737 bond_dev->name, slave_dev->name,
1738 slave->perm_hwaddr,
1739 bond_dev->name, slave_dev->name);
1740 }
1741
3d632c3f 1742 if (bond->primary_slave == slave)
1da177e4 1743 bond->primary_slave = NULL;
1da177e4 1744
3d632c3f 1745 if (oldcurrent == slave)
1da177e4 1746 bond_change_active_slave(bond, NULL);
1da177e4 1747
58402054 1748 if (bond_is_lb(bond)) {
1da177e4
LT		 1749 /* Must be called only after the slave has been
1750 * detached from the list and the curr_active_slave
1751 * has been cleared (if our_slave == old_current),
1752 * but before a new active slave is selected.
1753 */
2543331d 1754 write_unlock_bh(&bond->lock);
1da177e4 1755 bond_alb_deinit_slave(bond, slave);
2543331d 1756 write_lock_bh(&bond->lock);
1da177e4
LT		 1757 }
1758
0896341a 1759 if (all) {
278b2083 1760 rcu_assign_pointer(bond->curr_active_slave, NULL);
0896341a 1761 } else if (oldcurrent == slave) {
059fe7a5
JV		 1762 /*
1763 * Note that we hold RTNL over this sequence, so there
1764 * is no concern that another slave add/remove event
1765 * will interfere.
1766 */
1767 write_unlock_bh(&bond->lock);
1768 read_lock(&bond->lock);
1769 write_lock_bh(&bond->curr_slave_lock);
1770
1da177e4
LT		 1771 bond_select_active_slave(bond);
1772
059fe7a5
JV		 1773 write_unlock_bh(&bond->curr_slave_lock);
1774 read_unlock(&bond->lock);
1775 write_lock_bh(&bond->lock);
1776 }
1777
0965a1f3 1778 if (!bond_has_slaves(bond)) {
ff59c456 1779 bond_set_carrier(bond);
409cc1f8 1780 eth_hw_addr_random(bond_dev);
1da177e4 1781
a59d3d21 1782 if (vlan_uses_dev(bond_dev)) {
a4aee5c8
JP		 1783 pr_warning("%s: Warning: clearing HW address of %s while it still has VLANs.\n",
1784 bond_dev->name, bond_dev->name);
1785 pr_warning("%s: When re-adding slaves, make sure the bond's HW address matches its VLANs'.\n",
1786 bond_dev->name);
1da177e4 1787 }
1da177e4
LT		 1788 }
1789
1790 write_unlock_bh(&bond->lock);
e843fa50 1791 unblock_netpoll_tx();
278b2083 1792 synchronize_rcu();
1da177e4 1793
0965a1f3 1794 if (!bond_has_slaves(bond)) {
2af73d4b 1795 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond->dev);
80028ea1
VF		 1796 call_netdevice_notifiers(NETDEV_RELEASE, bond->dev);
1797 }
2af73d4b 1798
b2a103e6
MM		 1799 bond_compute_features(bond);
1800 if (!(bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
1801 (old_features & NETIF_F_VLAN_CHALLENGED))
1802 pr_info("%s: last VLAN challenged slave %s left bond %s. VLAN blocking is removed\n",
1803 bond_dev->name, slave_dev->name, bond_dev->name);
1804
b76cdba9 1805 /* must do this from outside any spinlocks */
1ff412ad 1806 vlan_vids_del_by_dev(slave_dev, bond_dev);
1da177e4 1807
303d1cbf
JV		 1808 /* If the mode USES_PRIMARY, then this cases was handled above by
1809 * bond_change_active_slave(..., NULL)
1da177e4
LT		 1810 */
1811 if (!USES_PRIMARY(bond->params.mode)) {
5a0068de
NH		 1812 /* unset promiscuity level from slave
1813 * NOTE: The NETDEV_CHANGEADDR call above may change the value
1814 * of the IFF_PROMISC flag in the bond_dev, but we need the
1815 * value of that flag before that change, as that was the value
1816 * when this slave was attached, so we cache at the start of the
1817 * function and use it here. Same goes for ALLMULTI below
1818 */
1819 if (old_flags & IFF_PROMISC)
1da177e4 1820 dev_set_promiscuity(slave_dev, -1);
1da177e4
LT		 1821
1822 /* unset allmulti level from slave */
5a0068de 1823 if (old_flags & IFF_ALLMULTI)
1da177e4 1824 dev_set_allmulti(slave_dev, -1);
1da177e4 1825
303d1cbf 1826 bond_hw_addr_flush(bond_dev, slave_dev);
1da177e4
LT		 1827 }
1828
8a8efa22 1829 slave_disable_netpoll(slave);
f6dc31a8 1830
1da177e4
LT		 1831 /* close slave before restoring its mac address */
1832 dev_close(slave_dev);
1833
3915c1e8 1834 if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
2ab82852
MS		 1835 /* restore original ("permanent") mac address */
1836 memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
1837 addr.sa_family = slave_dev->type;
1838 dev_set_mac_address(slave_dev, &addr);
1839 }
1da177e4 1840
b15ba0fb
JP		 1841 dev_set_mtu(slave_dev, slave->original_mtu);
1842
2d7011ca 1843 slave_dev->priv_flags &= ~IFF_BONDING;
1da177e4
LT		 1844
1845 kfree(slave);
1846
1847 return 0; /* deletion OK */
1848}
1849
0896341a 1850/* A wrapper used because of ndo_del_link */
1851int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
1852{
1853 return __bond_release_one(bond_dev, slave_dev, false);
1854}
1855
d90a162a 1856/*
dadaa10b 1857* First release a slave and then destroy the bond if no more slaves are left.
d90a162a
MS		 1858* Must be under rtnl_lock when this function is called.
1859*/
26d8ee75 1860static int bond_release_and_destroy(struct net_device *bond_dev,
1861 struct net_device *slave_dev)
d90a162a 1862{
454d7c9b 1863 struct bonding *bond = netdev_priv(bond_dev);
d90a162a
MS		 1864 int ret;
1865
1866 ret = bond_release(bond_dev, slave_dev);
0965a1f3 1867 if (ret == 0 && !bond_has_slaves(bond)) {
8a8efa22 1868 bond_dev->priv_flags |= IFF_DISABLE_NETPOLL;
a4aee5c8
JP		 1869 pr_info("%s: destroying bond %s.\n",
1870 bond_dev->name, bond_dev->name);
9e71626c 1871 unregister_netdevice(bond_dev);
d90a162a
MS		 1872 }
1873 return ret;
1874}
1875
1da177e4
LT		 1876static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
1877{
454d7c9b 1878 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 1879
1880 info->bond_mode = bond->params.mode;
1881 info->miimon = bond->params.miimon;
1882
6603a6f2 1883 read_lock(&bond->lock);
1da177e4 1884 info->num_slaves = bond->slave_cnt;
6603a6f2 1885 read_unlock(&bond->lock);
1da177e4
LT		 1886
1887 return 0;
1888}
1889
1890static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info)
1891{
454d7c9b 1892 struct bonding *bond = netdev_priv(bond_dev);
9caff1e7 1893 struct list_head *iter;
dec1e90e 1894 int i = 0, res = -ENODEV;
1da177e4 1895 struct slave *slave;
1da177e4 1896
6603a6f2 1897 read_lock(&bond->lock);
9caff1e7 1898 bond_for_each_slave(bond, slave, iter) {
dec1e90e 1899 if (i++ == (int)info->slave_id) {
689c96cc
ED		 1900 res = 0;
1901 strcpy(info->slave_name, slave->dev->name);
1902 info->link = slave->link;
e30bc066 1903 info->state = bond_slave_state(slave);
689c96cc 1904 info->link_failure_count = slave->link_failure_count;
1da177e4
LT		 1905 break;
1906 }
1907 }
6603a6f2 1908 read_unlock(&bond->lock);
1da177e4 1909
689c96cc 1910 return res;
1da177e4
LT		 1911}
1912
1913/*-------------------------------- Monitoring -------------------------------*/
1914
1da177e4 1915
f0c76d61
JV		 1916static int bond_miimon_inspect(struct bonding *bond)
1917{
dec1e90e 1918 int link_state, commit = 0;
9caff1e7 1919 struct list_head *iter;
f0c76d61 1920 struct slave *slave;
41f89100
JP		 1921 bool ignore_updelay;
1922
1923 ignore_updelay = !bond->curr_active_slave ? true : false;
1da177e4 1924
9caff1e7 1925 bond_for_each_slave(bond, slave, iter) {
f0c76d61 1926 slave->new_link = BOND_LINK_NOCHANGE;
1da177e4 1927
f0c76d61 1928 link_state = bond_check_dev_link(bond, slave->dev, 0);
1da177e4
LT		 1929
1930 switch (slave->link) {
f0c76d61
JV		 1931 case BOND_LINK_UP:
1932 if (link_state)
1933 continue;
1da177e4 1934
f0c76d61
JV		 1935 slave->link = BOND_LINK_FAIL;
1936 slave->delay = bond->params.downdelay;
1937 if (slave->delay) {
a4aee5c8
JP		 1938 pr_info("%s: link status down for %sinterface %s, disabling it in %d ms.\n",
1939 bond->dev->name,
1940 (bond->params.mode ==
1941 BOND_MODE_ACTIVEBACKUP) ?
e30bc066 1942 (bond_is_active_slave(slave) ?
a4aee5c8
JP		 1943 "active " : "backup ") : "",
1944 slave->dev->name,
1945 bond->params.downdelay * bond->params.miimon);
1da177e4 1946 }
f0c76d61
JV		 1947 /*FALLTHRU*/
1948 case BOND_LINK_FAIL:
1949 if (link_state) {
1950 /*
1951 * recovered before downdelay expired
1952 */
1953 slave->link = BOND_LINK_UP;
1da177e4 1954 slave->jiffies = jiffies;
a4aee5c8
JP		 1955 pr_info("%s: link status up again after %d ms for interface %s.\n",
1956 bond->dev->name,
1957 (bond->params.downdelay - slave->delay) *
1958 bond->params.miimon,
1959 slave->dev->name);
f0c76d61 1960 continue;
1da177e4 1961 }
f0c76d61
JV		 1962
1963 if (slave->delay <= 0) {
1964 slave->new_link = BOND_LINK_DOWN;
1965 commit++;
1966 continue;
1da177e4 1967 }
1da177e4 1968
f0c76d61
JV		 1969 slave->delay--;
1970 break;
1971
1972 case BOND_LINK_DOWN:
1973 if (!link_state)
1974 continue;
1975
1976 slave->link = BOND_LINK_BACK;
1977 slave->delay = bond->params.updelay;
1978
1979 if (slave->delay) {
a4aee5c8
JP		 1980 pr_info("%s: link status up for interface %s, enabling it in %d ms.\n",
1981 bond->dev->name, slave->dev->name,
1982 ignore_updelay ? 0 :
1983 bond->params.updelay *
1984 bond->params.miimon);
f0c76d61
JV		 1985 }
1986 /*FALLTHRU*/
1987 case BOND_LINK_BACK:
1988 if (!link_state) {
1989 slave->link = BOND_LINK_DOWN;
a4aee5c8
JP		 1990 pr_info("%s: link status down again after %d ms for interface %s.\n",
1991 bond->dev->name,
1992 (bond->params.updelay - slave->delay) *
1993 bond->params.miimon,
1994 slave->dev->name);
f0c76d61
JV		 1995
1996 continue;
1997 }
1998
41f89100
JP		 1999 if (ignore_updelay)
2000 slave->delay = 0;
2001
f0c76d61
JV		 2002 if (slave->delay <= 0) {
2003 slave->new_link = BOND_LINK_UP;
2004 commit++;
41f89100 2005 ignore_updelay = false;
f0c76d61 2006 continue;
1da177e4 2007 }
f0c76d61
JV		 2008
2009 slave->delay--;
1da177e4 2010 break;
f0c76d61
JV		 2011 }
2012 }
1da177e4 2013
f0c76d61
JV		 2014 return commit;
2015}
1da177e4 2016
f0c76d61
JV		 2017static void bond_miimon_commit(struct bonding *bond)
2018{
9caff1e7 2019 struct list_head *iter;
f0c76d61 2020 struct slave *slave;
f0c76d61 2021
9caff1e7 2022 bond_for_each_slave(bond, slave, iter) {
f0c76d61
JV		 2023 switch (slave->new_link) {
2024 case BOND_LINK_NOCHANGE:
2025 continue;
1da177e4 2026
f0c76d61
JV		 2027 case BOND_LINK_UP:
2028 slave->link = BOND_LINK_UP;
2029 slave->jiffies = jiffies;
2030
2031 if (bond->params.mode == BOND_MODE_8023AD) {
2032 /* prevent it from being the active one */
e30bc066 2033 bond_set_backup_slave(slave);
f0c76d61
JV		 2034 } else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
2035 /* make it immediately active */
e30bc066 2036 bond_set_active_slave(slave);
f0c76d61
JV		 2037 } else if (slave != bond->primary_slave) {
2038 /* prevent it from being the active one */
e30bc066 2039 bond_set_backup_slave(slave);
1da177e4 2040 }
1da177e4 2041
5d30530e 2042 pr_info("%s: link status definitely up for interface %s, %u Mbps %s duplex.\n",
700c2a77 2043 bond->dev->name, slave->dev->name,
db4e9b2b
NA		 2044 slave->speed == SPEED_UNKNOWN ? 0 : slave->speed,
2045 slave->duplex ? "full" : "half");
1da177e4 2046
f0c76d61
JV		 2047 /* notify ad that the link status has changed */
2048 if (bond->params.mode == BOND_MODE_8023AD)
2049 bond_3ad_handle_link_change(slave, BOND_LINK_UP);
059fe7a5 2050
58402054 2051 if (bond_is_lb(bond))
f0c76d61
JV		 2052 bond_alb_handle_link_change(bond, slave,
2053 BOND_LINK_UP);
1da177e4 2054
f0c76d61
JV		 2055 if (!bond->curr_active_slave ||
2056 (slave == bond->primary_slave))
2057 goto do_failover;
1da177e4 2058
f0c76d61 2059 continue;
059fe7a5 2060
f0c76d61 2061 case BOND_LINK_DOWN:
fba4acda
JV		 2062 if (slave->link_failure_count < UINT_MAX)
2063 slave->link_failure_count++;
2064
f0c76d61 2065 slave->link = BOND_LINK_DOWN;
1da177e4 2066
f0c76d61
JV		 2067 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP ||
2068 bond->params.mode == BOND_MODE_8023AD)
2069 bond_set_slave_inactive_flags(slave);
2070
a4aee5c8
JP		 2071 pr_info("%s: link status definitely down for interface %s, disabling it\n",
2072 bond->dev->name, slave->dev->name);
f0c76d61
JV		 2073
2074 if (bond->params.mode == BOND_MODE_8023AD)
2075 bond_3ad_handle_link_change(slave,
2076 BOND_LINK_DOWN);
2077
ae63e808 2078 if (bond_is_lb(bond))
f0c76d61
JV		 2079 bond_alb_handle_link_change(bond, slave,
2080 BOND_LINK_DOWN);
2081
2082 if (slave == bond->curr_active_slave)
2083 goto do_failover;
2084
2085 continue;
2086
2087 default:
a4aee5c8 2088 pr_err("%s: invalid new link %d on slave %s\n",
f0c76d61
JV		 2089 bond->dev->name, slave->new_link,
2090 slave->dev->name);
2091 slave->new_link = BOND_LINK_NOCHANGE;
2092
2093 continue;
2094 }
2095
2096do_failover:
2097 ASSERT_RTNL();
e843fa50 2098 block_netpoll_tx();
f0c76d61
JV		 2099 write_lock_bh(&bond->curr_slave_lock);
2100 bond_select_active_slave(bond);
2101 write_unlock_bh(&bond->curr_slave_lock);
e843fa50 2102 unblock_netpoll_tx();
f0c76d61
JV		 2103 }
2104
2105 bond_set_carrier(bond);
1da177e4
LT		 2106}
2107
0b0eef66
JV		 2108/*
2109 * bond_mii_monitor
2110 *
2111 * Really a wrapper that splits the mii monitor into two phases: an
f0c76d61
JV		 2112 * inspection, then (if inspection indicates something needs to be done)
2113 * an acquisition of appropriate locks followed by a commit phase to
2114 * implement whatever link state changes are indicated.
0b0eef66
JV		 2115 */
2116void bond_mii_monitor(struct work_struct *work)
2117{
2118 struct bonding *bond = container_of(work, struct bonding,
2119 mii_work.work);
ad246c99 2120 bool should_notify_peers = false;
0b0eef66 2121
6b6c5261 2122 if (!rtnl_trylock())
2123 goto re_arm;
f0c76d61 2124
6b6c5261 2125 if (!bond_has_slaves(bond)) {
2126 rtnl_unlock();
f0c76d61 2127 goto re_arm;
6b6c5261 2128 }
b59f9f74 2129
ad246c99
BH		 2130 should_notify_peers = bond_should_notify_peers(bond);
2131
6b6c5261 2132 if (bond_miimon_inspect(bond))
f0c76d61
JV		 2133 bond_miimon_commit(bond);
2134
6b6c5261 2135 if (should_notify_peers)
2136 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
2137
2138 rtnl_unlock();
0b0eef66 2139
f0c76d61 2140re_arm:
e6d265e8 2141 if (bond->params.miimon)
6b6c5261 2142 queue_delayed_work(bond->wq, &bond->mii_work,
2143 msecs_to_jiffies(bond->params.miimon));
0b0eef66 2144}
c3ade5ca 2145
50223ce4 2146static bool bond_has_this_ip(struct bonding *bond, __be32 ip)
f5b2b966 2147{
50223ce4
VF		 2148 struct net_device *upper;
2149 struct list_head *iter;
2150 bool ret = false;
f5b2b966 2151
eaddcd76 2152 if (ip == bond_confirm_addr(bond->dev, 0, ip))
50223ce4 2153 return true;
f5b2b966 2154
50223ce4 2155 rcu_read_lock();
2f268f12 2156 netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
50223ce4
VF		 2157 if (ip == bond_confirm_addr(upper, 0, ip)) {
2158 ret = true;
2159 break;
2160 }
f5b2b966 2161 }
50223ce4 2162 rcu_read_unlock();
f5b2b966 2163
50223ce4 2164 return ret;
f5b2b966
JV		 2165}
2166
c3ade5ca
JV		 2167/*
2168 * We go to the (large) trouble of VLAN tagging ARP frames because
2169 * switches in VLAN mode (especially if ports are configured as
2170 * "native" to a VLAN) might not pass non-tagged frames.
2171 */
d3bb52b0 2172static void bond_arp_send(struct net_device *slave_dev, int arp_op, __be32 dest_ip, __be32 src_ip, unsigned short vlan_id)
c3ade5ca
JV		 2173{
2174 struct sk_buff *skb;
2175
acca2674 2176 pr_debug("arp %d on slave %s: dst %pI4 src %pI4 vid %d\n", arp_op,
2177 slave_dev->name, &dest_ip, &src_ip, vlan_id);
3d632c3f 2178
c3ade5ca
JV		 2179 skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip,
2180 NULL, slave_dev->dev_addr, NULL);
2181
2182 if (!skb) {
a4aee5c8 2183 pr_err("ARP packet allocation failed\n");
c3ade5ca
JV		 2184 return;
2185 }
2186 if (vlan_id) {
1fd9b1fc 2187 skb = vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
c3ade5ca 2188 if (!skb) {
a4aee5c8 2189 pr_err("failed to insert VLAN tag\n");
c3ade5ca
JV		 2190 return;
2191 }
2192 }
2193 arp_xmit(skb);
2194}
2195
2196
1da177e4
LT		 2197static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
2198{
27bc11e6
VF		 2199 struct net_device *upper, *vlan_upper;
2200 struct list_head *iter, *vlan_iter;
c3ade5ca 2201 struct rtable *rt;
27bc11e6
VF		 2202 __be32 *targets = bond->params.arp_targets, addr;
2203 int i, vlan_id;
1da177e4 2204
27bc11e6 2205 for (i = 0; i < BOND_MAX_ARP_TARGETS && targets[i]; i++) {
acca2674 2206 pr_debug("basa: target %pI4\n", &targets[i]);
c3ade5ca 2207
27bc11e6 2208 /* Find out through which dev should the packet go */
78fbfd8a
DM		 2209 rt = ip_route_output(dev_net(bond->dev), targets[i], 0,
2210 RTO_ONLINK, 0);
b23dd4fe 2211 if (IS_ERR(rt)) {
3e32582f
VF		 2212 pr_debug("%s: no route to arp_ip_target %pI4\n",
2213 bond->dev->name, &targets[i]);
c3ade5ca
JV		 2214 continue;
2215 }
2216
c3ade5ca 2217 vlan_id = 0;
27bc11e6
VF		 2218
2219 /* bond device itself */
2220 if (rt->dst.dev == bond->dev)
2221 goto found;
2222
2223 rcu_read_lock();
2224 /* first we search only for vlan devices. for every vlan
2225 * found we verify its upper dev list, searching for the
2226 * rt->dst.dev. If found we save the tag of the vlan and
2227 * proceed to send the packet.
2228 *
2229 * TODO: QinQ?
2230 */
2f268f12
VF		 2231 netdev_for_each_all_upper_dev_rcu(bond->dev, vlan_upper,
2232 vlan_iter) {
27bc11e6
VF		 2233 if (!is_vlan_dev(vlan_upper))
2234 continue;
2f268f12
VF		 2235 netdev_for_each_all_upper_dev_rcu(vlan_upper, upper,
2236 iter) {
27bc11e6
VF		 2237 if (upper == rt->dst.dev) {
2238 vlan_id = vlan_dev_vlan_id(vlan_upper);
2239 rcu_read_unlock();
2240 goto found;
2241 }
c3ade5ca
JV		 2242 }
2243 }
2244
27bc11e6
VF		 2245 /* if the device we're looking for is not on top of any of
2246 * our upper vlans, then just search for any dev that
2247 * matches, and in case it's a vlan - save the id
2248 */
2f268f12 2249 netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
27bc11e6
VF		 2250 if (upper == rt->dst.dev) {
2251 /* if it's a vlan - get its VID */
2252 if (is_vlan_dev(upper))
2253 vlan_id = vlan_dev_vlan_id(upper);
2254
2255 rcu_read_unlock();
2256 goto found;
2257 }
c3ade5ca 2258 }
27bc11e6 2259 rcu_read_unlock();
c3ade5ca 2260
27bc11e6 2261 /* Not our device - skip */
3e32582f
VF		 2262 pr_debug("%s: no path to arp_ip_target %pI4 via rt.dev %s\n",
2263 bond->dev->name, &targets[i],
2264 rt->dst.dev ? rt->dst.dev->name : "NULL");
2265
ed4b9f80 2266 ip_rt_put(rt);
27bc11e6
VF		 2267 continue;
2268
2269found:
2270 addr = bond_confirm_addr(rt->dst.dev, targets[i], 0);
2271 ip_rt_put(rt);
2272 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
2273 addr, vlan_id);
c3ade5ca
JV		 2274 }
2275}
2276
d3bb52b0 2277static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip)
f5b2b966 2278{
8599b52e
VF		 2279 int i;
2280
87a7b84b
VF		 2281 if (!sip || !bond_has_this_ip(bond, tip)) {
2282 pr_debug("bva: sip %pI4 tip %pI4 not found\n", &sip, &tip);
2283 return;
2284 }
f5b2b966 2285
8599b52e
VF		 2286 i = bond_get_targets_ip(bond->params.arp_targets, sip);
2287 if (i == -1) {
87a7b84b
VF		 2288 pr_debug("bva: sip %pI4 not found in targets\n", &sip);
2289 return;
f5b2b966 2290 }
87a7b84b 2291 slave->last_arp_rx = jiffies;
8599b52e 2292 slave->target_last_arp_rx[i] = jiffies;
f5b2b966
JV		 2293}
2294
5bb9e0b5 2295int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond,
2296 struct slave *slave)
f5b2b966 2297{
de063b70 2298 struct arphdr *arp = (struct arphdr *)skb->data;
f5b2b966 2299 unsigned char *arp_ptr;
d3bb52b0 2300 __be32 sip, tip;
de063b70 2301 int alen;
f5b2b966 2302
3aba891d 2303 if (skb->protocol != __cpu_to_be16(ETH_P_ARP))
13a8e0c8 2304 return RX_HANDLER_ANOTHER;
f5b2b966 2305
f5b2b966 2306 read_lock(&bond->lock);
2c146102
VF		 2307
2308 if (!slave_do_arp_validate(bond, slave))
2309 goto out_unlock;
2310
de063b70 2311 alen = arp_hdr_len(bond->dev);
f5b2b966 2312
3aba891d
JP		 2313 pr_debug("bond_arp_rcv: bond %s skb->dev %s\n",
2314 bond->dev->name, skb->dev->name);
f5b2b966 2315
de063b70
ED		 2316 if (alen > skb_headlen(skb)) {
2317 arp = kmalloc(alen, GFP_ATOMIC);
2318 if (!arp)
2319 goto out_unlock;
2320 if (skb_copy_bits(skb, 0, arp, alen) < 0)
2321 goto out_unlock;
2322 }
f5b2b966 2323
3aba891d 2324 if (arp->ar_hln != bond->dev->addr_len ||
f5b2b966
JV		 2325 skb->pkt_type == PACKET_OTHERHOST ||
2326 skb->pkt_type == PACKET_LOOPBACK ||
2327 arp->ar_hrd != htons(ARPHRD_ETHER) ||
2328 arp->ar_pro != htons(ETH_P_IP) ||
2329 arp->ar_pln != 4)
2330 goto out_unlock;
2331
2332 arp_ptr = (unsigned char *)(arp + 1);
3aba891d 2333 arp_ptr += bond->dev->addr_len;
f5b2b966 2334 memcpy(&sip, arp_ptr, 4);
3aba891d 2335 arp_ptr += 4 + bond->dev->addr_len;
f5b2b966
JV		 2336 memcpy(&tip, arp_ptr, 4);
2337
5a03cdb7 2338 pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
e30bc066 2339 bond->dev->name, slave->dev->name, bond_slave_state(slave),
a4aee5c8
JP		 2340 bond->params.arp_validate, slave_do_arp_validate(bond, slave),
2341 &sip, &tip);
f5b2b966
JV		 2342
2343 /*
2344 * Backup slaves won't see the ARP reply, but do come through
2345 * here for each ARP probe (so we swap the sip/tip to validate
2346 * the probe). In a "redundant switch, common router" type of
2347 * configuration, the ARP probe will (hopefully) travel from
2348 * the active, through one switch, the router, then the other
2349 * switch before reaching the backup.
aeea64ac
VF		 2350 *
2351 * We 'trust' the arp requests if there is an active slave and
2352 * it received valid arp reply(s) after it became active. This
2353 * is done to avoid endless looping when we can't reach the
2354 * arp_ip_target and fool ourselves with our own arp requests.
f5b2b966 2355 */
e30bc066 2356 if (bond_is_active_slave(slave))
f5b2b966 2357 bond_validate_arp(bond, slave, sip, tip);
aeea64ac
VF		 2358 else if (bond->curr_active_slave &&
2359 time_after(slave_last_rx(bond, bond->curr_active_slave),
2360 bond->curr_active_slave->jiffies))
f5b2b966
JV		 2361 bond_validate_arp(bond, slave, tip, sip);
2362
2363out_unlock:
2364 read_unlock(&bond->lock);
de063b70
ED		 2365 if (arp != (struct arphdr *)skb->data)
2366 kfree(arp);
13a8e0c8 2367 return RX_HANDLER_ANOTHER;
f5b2b966
JV		 2368}
2369
e7f63f1d
VF		 2370/* function to verify if we're in the arp_interval timeslice, returns true if
2371 * (last_act - arp_interval) <= jiffies <= (last_act + mod * arp_interval +
2372 * arp_interval/2) . the arp_interval/2 is needed for really fast networks.
2373 */
2374static bool bond_time_in_interval(struct bonding *bond, unsigned long last_act,
2375 int mod)
2376{
2377 int delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
2378
2379 return time_in_range(jiffies,
2380 last_act - delta_in_ticks,
2381 last_act + mod * delta_in_ticks + delta_in_ticks/2);
2382}
2383
1da177e4
LT		 2384/*
2385 * this function is called regularly to monitor each slave's link
2386 * ensuring that traffic is being sent and received when arp monitoring
2387 * is used in load-balancing mode. if the adapter has been dormant, then an
2388 * arp is transmitted to generate traffic. see activebackup_arp_monitor for
2389 * arp monitoring in active backup mode.
2390 */
1b76b316 2391void bond_loadbalance_arp_mon(struct work_struct *work)
1da177e4 2392{
1b76b316
JV		 2393 struct bonding *bond = container_of(work, struct bonding,
2394 arp_work.work);
1da177e4 2395 struct slave *slave, *oldcurrent;
9caff1e7 2396 struct list_head *iter;
1da177e4 2397 int do_failover = 0;
1da177e4 2398
7f1bb571 2399 if (!rtnl_trylock())
2400 goto re_arm;
1da177e4 2401
7f1bb571 2402 if (!bond_has_slaves(bond)) {
2403 rtnl_unlock();
1da177e4 2404 goto re_arm;
7f1bb571 2405 }
1da177e4 2406
1da177e4 2407 oldcurrent = bond->curr_active_slave;
1da177e4
LT		 2408 /* see if any of the previous devices are up now (i.e. they have
2409 * xmt and rcv traffic). the curr_active_slave does not come into
2410 * the picture unless it is null. also, slave->jiffies is not needed
2411 * here because we send an arp on each slave and give a slave as
2412 * long as it needs to get the tx/rx within the delta.
2413 * TODO: what about up/down delay in arp mode? it wasn't here before
2414 * so it can wait
2415 */
9caff1e7 2416 bond_for_each_slave(bond, slave, iter) {
cb32f2a0
JB		 2417 unsigned long trans_start = dev_trans_start(slave->dev);
2418
1da177e4 2419 if (slave->link != BOND_LINK_UP) {
e7f63f1d
VF		 2420 if (bond_time_in_interval(bond, trans_start, 1) &&
2421 bond_time_in_interval(bond, slave->dev->last_rx, 1)) {
1da177e4
LT		 2422
2423 slave->link = BOND_LINK_UP;
e30bc066 2424 bond_set_active_slave(slave);
1da177e4
LT		 2425
2426 /* primary_slave has no meaning in round-robin
2427 * mode. the window of a slave being up and
2428 * curr_active_slave being null after enslaving
2429 * is closed.
2430 */
2431 if (!oldcurrent) {
a4aee5c8
JP		 2432 pr_info("%s: link status definitely up for interface %s, ",
2433 bond->dev->name,
2434 slave->dev->name);
1da177e4
LT		 2435 do_failover = 1;
2436 } else {
a4aee5c8
JP		 2437 pr_info("%s: interface %s is now up\n",
2438 bond->dev->name,
2439 slave->dev->name);
1da177e4
LT		 2440 }
2441 }
2442 } else {
2443 /* slave->link == BOND_LINK_UP */
2444
2445 /* not all switches will respond to an arp request
2446 * when the source ip is 0, so don't take the link down
2447 * if we don't know our ip yet
2448 */
e7f63f1d
VF		 2449 if (!bond_time_in_interval(bond, trans_start, 2) ||
2450 !bond_time_in_interval(bond, slave->dev->last_rx, 2)) {
1da177e4
LT		 2451
2452 slave->link = BOND_LINK_DOWN;
e30bc066 2453 bond_set_backup_slave(slave);
1da177e4 2454
3d632c3f 2455 if (slave->link_failure_count < UINT_MAX)
1da177e4 2456 slave->link_failure_count++;
1da177e4 2457
a4aee5c8
JP		 2458 pr_info("%s: interface %s is now down.\n",
2459 bond->dev->name,
2460 slave->dev->name);
1da177e4 2461
3d632c3f 2462 if (slave == oldcurrent)
1da177e4 2463 do_failover = 1;
1da177e4
LT		 2464 }
2465 }
2466
2467 /* note: if switch is in round-robin mode, all links
2468 * must tx arp to ensure all links rx an arp - otherwise
2469 * links may oscillate or not come up at all; if switch is
2470 * in something like xor mode, there is nothing we can
2471 * do - all replies will be rx'ed on same link causing slaves
2472 * to be unstable during low/no traffic periods
2473 */
3d632c3f 2474 if (IS_UP(slave->dev))
1da177e4 2475 bond_arp_send_all(bond, slave);
1da177e4
LT		 2476 }
2477
2478 if (do_failover) {
e843fa50 2479 block_netpoll_tx();
059fe7a5 2480 write_lock_bh(&bond->curr_slave_lock);
1da177e4
LT		 2481
2482 bond_select_active_slave(bond);
2483
059fe7a5 2484 write_unlock_bh(&bond->curr_slave_lock);
e843fa50 2485 unblock_netpoll_tx();
1da177e4 2486 }
7f1bb571 2487 rtnl_unlock();
1da177e4
LT		 2488
2489re_arm:
e6d265e8 2490 if (bond->params.arp_interval)
e7f63f1d
VF		 2491 queue_delayed_work(bond->wq, &bond->arp_work,
2492 msecs_to_jiffies(bond->params.arp_interval));
1da177e4
LT		 2493}
2494
2495/*
b2220cad
JV		 2496 * Called to inspect slaves for active-backup mode ARP monitor link state
2497 * changes. Sets new_link in slaves to specify what action should take
2498 * place for the slave. Returns 0 if no changes are found, >0 if changes
2499 * to link states must be committed.
2500 *
2501 * Called with bond->lock held for read.
1da177e4 2502 */
e7f63f1d 2503static int bond_ab_arp_inspect(struct bonding *bond)
1da177e4 2504{
def4460c 2505 unsigned long trans_start, last_rx;
9caff1e7 2506 struct list_head *iter;
dec1e90e 2507 struct slave *slave;
dec1e90e 2508 int commit = 0;
da210f55 2509
9caff1e7 2510 bond_for_each_slave(bond, slave, iter) {
b2220cad 2511 slave->new_link = BOND_LINK_NOCHANGE;
def4460c 2512 last_rx = slave_last_rx(bond, slave);
1da177e4 2513
b2220cad 2514 if (slave->link != BOND_LINK_UP) {
e7f63f1d 2515 if (bond_time_in_interval(bond, last_rx, 1)) {
b2220cad
JV		 2516 slave->new_link = BOND_LINK_UP;
2517 commit++;
2518 }
b2220cad
JV		 2519 continue;
2520 }
1da177e4 2521
b2220cad
JV		 2522 /*
2523 * Give slaves 2*delta after being enslaved or made
2524 * active. This avoids bouncing, as the last receive
2525 * times need a full ARP monitor cycle to be updated.
2526 */
e7f63f1d 2527 if (bond_time_in_interval(bond, slave->jiffies, 2))
b2220cad
JV		 2528 continue;
2529
2530 /*
2531 * Backup slave is down if:
2532 * - No current_arp_slave AND
2533 * - more than 3*delta since last receive AND
2534 * - the bond has an IP address
2535 *
2536 * Note: a non-null current_arp_slave indicates
2537 * the curr_active_slave went down and we are
2538 * searching for a new one; under this condition
2539 * we only take the curr_active_slave down - this
2540 * gives each slave a chance to tx/rx traffic
2541 * before being taken out
2542 */
e30bc066 2543 if (!bond_is_active_slave(slave) &&
b2220cad 2544 !bond->current_arp_slave &&
e7f63f1d 2545 !bond_time_in_interval(bond, last_rx, 3)) {
b2220cad
JV		 2546 slave->new_link = BOND_LINK_DOWN;
2547 commit++;
2548 }
2549
2550 /*
2551 * Active slave is down if:
2552 * - more than 2*delta since transmitting OR
2553 * - (more than 2*delta since receive AND
2554 * the bond has an IP address)
2555 */
cb32f2a0 2556 trans_start = dev_trans_start(slave->dev);
e30bc066 2557 if (bond_is_active_slave(slave) &&
e7f63f1d
VF		 2558 (!bond_time_in_interval(bond, trans_start, 2) ||
2559 !bond_time_in_interval(bond, last_rx, 2))) {
b2220cad
JV		 2560 slave->new_link = BOND_LINK_DOWN;
2561 commit++;
2562 }
1da177e4
LT		 2563 }
2564
b2220cad
JV		 2565 return commit;
2566}
1da177e4 2567
b2220cad
JV		 2568/*
2569 * Called to commit link state changes noted by inspection step of
2570 * active-backup mode ARP monitor.
2571 *
2572 * Called with RTNL and bond->lock for read.
2573 */
e7f63f1d 2574static void bond_ab_arp_commit(struct bonding *bond)
b2220cad 2575{
cb32f2a0 2576 unsigned long trans_start;
9caff1e7 2577 struct list_head *iter;
dec1e90e 2578 struct slave *slave;
1da177e4 2579
9caff1e7 2580 bond_for_each_slave(bond, slave, iter) {
b2220cad
JV		 2581 switch (slave->new_link) {
2582 case BOND_LINK_NOCHANGE:
2583 continue;
ff59c456 2584
b2220cad 2585 case BOND_LINK_UP:
cb32f2a0 2586 trans_start = dev_trans_start(slave->dev);
e7f63f1d
VF		 2587 if (bond->curr_active_slave != slave ||
2588 (!bond->curr_active_slave &&
2589 bond_time_in_interval(bond, trans_start, 1))) {
b2220cad 2590 slave->link = BOND_LINK_UP;
5a430974
VF		 2591 if (bond->current_arp_slave) {
2592 bond_set_slave_inactive_flags(
2593 bond->current_arp_slave);
2594 bond->current_arp_slave = NULL;
2595 }
b2220cad 2596
a4aee5c8 2597 pr_info("%s: link status definitely up for interface %s.\n",
b9f60253 2598 bond->dev->name, slave->dev->name);
b2220cad 2599
b9f60253
JP		 2600 if (!bond->curr_active_slave ||
2601 (slave == bond->primary_slave))
2602 goto do_failover;
1da177e4 2603
b9f60253 2604 }
1da177e4 2605
b9f60253 2606 continue;
1da177e4 2607
b2220cad
JV		 2608 case BOND_LINK_DOWN:
2609 if (slave->link_failure_count < UINT_MAX)
2610 slave->link_failure_count++;
2611
2612 slave->link = BOND_LINK_DOWN;
b9f60253 2613 bond_set_slave_inactive_flags(slave);
b2220cad 2614
a4aee5c8 2615 pr_info("%s: link status definitely down for interface %s, disabling it\n",
b9f60253 2616 bond->dev->name, slave->dev->name);
b2220cad 2617
b9f60253 2618 if (slave == bond->curr_active_slave) {
b2220cad 2619 bond->current_arp_slave = NULL;
b9f60253 2620 goto do_failover;
1da177e4 2621 }
b9f60253
JP		 2622
2623 continue;
b2220cad
JV		 2624
2625 default:
a4aee5c8 2626 pr_err("%s: impossible: new_link %d on slave %s\n",
b2220cad
JV		 2627 bond->dev->name, slave->new_link,
2628 slave->dev->name);
b9f60253 2629 continue;
1da177e4 2630 }
1da177e4 2631
b9f60253
JP		 2632do_failover:
2633 ASSERT_RTNL();
e843fa50 2634 block_netpoll_tx();
b2220cad 2635 write_lock_bh(&bond->curr_slave_lock);
b9f60253 2636 bond_select_active_slave(bond);
b2220cad 2637 write_unlock_bh(&bond->curr_slave_lock);
e843fa50 2638 unblock_netpoll_tx();
b2220cad 2639 }
1da177e4 2640
b2220cad
JV		 2641 bond_set_carrier(bond);
2642}
1da177e4 2643
b2220cad
JV		 2644/*
2645 * Send ARP probes for active-backup mode ARP monitor.
2646 *
2647 * Called with bond->lock held for read.
2648 */
2649static void bond_ab_arp_probe(struct bonding *bond)
2650{
4087df87
VF		 2651 struct slave *slave, *before = NULL, *new_slave = NULL;
2652 struct list_head *iter;
2653 bool found = false;
1da177e4 2654
b2220cad 2655 read_lock(&bond->curr_slave_lock);
1da177e4 2656
b2220cad 2657 if (bond->current_arp_slave && bond->curr_active_slave)
a4aee5c8
JP		 2658 pr_info("PROBE: c_arp %s && cas %s BAD\n",
2659 bond->current_arp_slave->dev->name,
2660 bond->curr_active_slave->dev->name);
1da177e4 2661
b2220cad
JV		 2662 if (bond->curr_active_slave) {
2663 bond_arp_send_all(bond, bond->curr_active_slave);
2664 read_unlock(&bond->curr_slave_lock);
2665 return;
2666 }
1da177e4 2667
b2220cad 2668 read_unlock(&bond->curr_slave_lock);
059fe7a5 2669
b2220cad
JV		 2670 /* if we don't have a curr_active_slave, search for the next available
2671 * backup slave from the current_arp_slave and make it the candidate
2672 * for becoming the curr_active_slave
2673 */
1da177e4 2674
b2220cad 2675 if (!bond->current_arp_slave) {
dec1e90e 2676 bond->current_arp_slave = bond_first_slave(bond);
b2220cad
JV		 2677 if (!bond->current_arp_slave)
2678 return;
2679 }
1da177e4 2680
b2220cad 2681 bond_set_slave_inactive_flags(bond->current_arp_slave);
059fe7a5 2682
4087df87
VF		 2683 bond_for_each_slave(bond, slave, iter) {
2684 if (!found && !before && IS_UP(slave->dev))
2685 before = slave;
1da177e4 2686
4087df87
VF		 2687 if (found && !new_slave && IS_UP(slave->dev))
2688 new_slave = slave;
b2220cad
JV		 2689 /* if the link state is up at this point, we
2690 * mark it down - this can happen if we have
2691 * simultaneous link failures and
2692 * reselect_active_interface doesn't make this
2693 * one the current slave so it is still marked
2694 * up when it is actually down
1da177e4 2695 */
4087df87 2696 if (!IS_UP(slave->dev) && slave->link == BOND_LINK_UP) {
b2220cad
JV		 2697 slave->link = BOND_LINK_DOWN;
2698 if (slave->link_failure_count < UINT_MAX)
2699 slave->link_failure_count++;
1da177e4 2700
b2220cad
JV		 2701 bond_set_slave_inactive_flags(slave);
2702
a4aee5c8
JP		 2703 pr_info("%s: backup interface %s is now down.\n",
2704 bond->dev->name, slave->dev->name);
1da177e4 2705 }
4087df87
VF		 2706 if (slave == bond->current_arp_slave)
2707 found = true;
b2220cad 2708 }
4087df87
VF		 2709
2710 if (!new_slave && before)
2711 new_slave = before;
2712
2713 if (!new_slave)
2714 return;
2715
2716 new_slave->link = BOND_LINK_BACK;
2717 bond_set_slave_active_flags(new_slave);
2718 bond_arp_send_all(bond, new_slave);
2719 new_slave->jiffies = jiffies;
2720 bond->current_arp_slave = new_slave;
2721
b2220cad 2722}
1da177e4 2723
b2220cad
JV		 2724void bond_activebackup_arp_mon(struct work_struct *work)
2725{
2726 struct bonding *bond = container_of(work, struct bonding,
2727 arp_work.work);
ad246c99 2728 bool should_notify_peers = false;
1da177e4 2729
80b9d236 2730 if (!rtnl_trylock())
2731 goto re_arm;
1da177e4 2732
80b9d236 2733 if (!bond_has_slaves(bond)) {
2734 rtnl_unlock();
b2220cad 2735 goto re_arm;
80b9d236 2736 }
b2220cad 2737
ad246c99
BH		 2738 should_notify_peers = bond_should_notify_peers(bond);
2739
80b9d236 2740 if (bond_ab_arp_inspect(bond))
e7f63f1d 2741 bond_ab_arp_commit(bond);
b2220cad 2742
b2220cad
JV		 2743 bond_ab_arp_probe(bond);
2744
80b9d236 2745 if (should_notify_peers)
2746 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
e6d265e8 2747
80b9d236 2748 rtnl_unlock();
ad246c99 2749
80b9d236 2750re_arm:
2751 if (bond->params.arp_interval)
2752 queue_delayed_work(bond->wq, &bond->arp_work,
2753 msecs_to_jiffies(bond->params.arp_interval));
1da177e4
LT		 2754}
2755
1da177e4
LT		 2756/*-------------------------- netdev event handling --------------------------*/
2757
2758/*
2759 * Change device name
2760 */
2761static int bond_event_changename(struct bonding *bond)
2762{
1da177e4
LT		 2763 bond_remove_proc_entry(bond);
2764 bond_create_proc_entry(bond);
7e083840 2765
f073c7ca
TI		 2766 bond_debug_reregister(bond);
2767
1da177e4
LT		 2768 return NOTIFY_DONE;
2769}
2770
3d632c3f
SH		 2771static int bond_master_netdev_event(unsigned long event,
2772 struct net_device *bond_dev)
1da177e4 2773{
454d7c9b 2774 struct bonding *event_bond = netdev_priv(bond_dev);
1da177e4
LT		 2775
2776 switch (event) {
2777 case NETDEV_CHANGENAME:
2778 return bond_event_changename(event_bond);
a64d49c3
EB		 2779 case NETDEV_UNREGISTER:
2780 bond_remove_proc_entry(event_bond);
2781 break;
2782 case NETDEV_REGISTER:
2783 bond_create_proc_entry(event_bond);
2784 break;
6c8d23f7 2785 case NETDEV_NOTIFY_PEERS:
2786 if (event_bond->send_peer_notif)
2787 event_bond->send_peer_notif--;
2788 break;
1da177e4
LT		 2789 default:
2790 break;
2791 }
2792
2793 return NOTIFY_DONE;
2794}
2795
3d632c3f
SH		 2796static int bond_slave_netdev_event(unsigned long event,
2797 struct net_device *slave_dev)
1da177e4 2798{
471cb5a3 2799 struct slave *slave = bond_slave_get_rtnl(slave_dev);
6101391d 2800 struct bonding *bond;
2801 struct net_device *bond_dev;
471cb5a3
JP		 2802 u32 old_speed;
2803 u8 old_duplex;
1da177e4 2804
6101391d 2805 /* A netdev event can be generated while enslaving a device
2806 * before netdev_rx_handler_register is called in which case
2807 * slave will be NULL
2808 */
2809 if (!slave)
2810 return NOTIFY_DONE;
2811 bond_dev = slave->bond->dev;
2812 bond = slave->bond;
2813
1da177e4
LT		 2814 switch (event) {
2815 case NETDEV_UNREGISTER:
8d2ada77 2816 if (bond_dev->type != ARPHRD_ETHER)
471cb5a3
JP		 2817 bond_release_and_destroy(bond_dev, slave_dev);
2818 else
2819 bond_release(bond_dev, slave_dev);
1da177e4 2820 break;
98f41f69 2821 case NETDEV_UP:
1da177e4 2822 case NETDEV_CHANGE:
471cb5a3
JP		 2823 old_speed = slave->speed;
2824 old_duplex = slave->duplex;
17d04500 2825
471cb5a3 2826 bond_update_speed_duplex(slave);
17d04500 2827
471cb5a3
JP		 2828 if (bond->params.mode == BOND_MODE_8023AD) {
2829 if (old_speed != slave->speed)
2830 bond_3ad_adapter_speed_changed(slave);
2831 if (old_duplex != slave->duplex)
2832 bond_3ad_adapter_duplex_changed(slave);
17d04500 2833 }
1da177e4
LT		 2834 break;
2835 case NETDEV_DOWN:
2836 /*
2837 * ... Or is it this?
2838 */
2839 break;
2840 case NETDEV_CHANGEMTU:
2841 /*
2842 * TODO: Should slaves be allowed to
2843 * independently alter their MTU? For
2844 * an active-backup bond, slaves need
2845 * not be the same type of device, so
2846 * MTUs may vary. For other modes,
2847 * slaves arguably should have the
2848 * same MTUs. To do this, we'd need to
2849 * take over the slave's change_mtu
2850 * function for the duration of their
2851 * servitude.
2852 */
2853 break;
2854 case NETDEV_CHANGENAME:
2855 /*
2856 * TODO: handle changing the primary's name
2857 */
2858 break;
8531c5ff
AK		 2859 case NETDEV_FEAT_CHANGE:
2860 bond_compute_features(bond);
2861 break;
4aa5dee4
JP		 2862 case NETDEV_RESEND_IGMP:
2863 /* Propagate to master device */
2864 call_netdevice_notifiers(event, slave->bond->dev);
2865 break;
1da177e4
LT		 2866 default:
2867 break;
2868 }
2869
2870 return NOTIFY_DONE;
2871}
2872
2873/*
2874 * bond_netdev_event: handle netdev notifier chain events.
2875 *
2876 * This function receives events for the netdev chain. The caller (an
e041c683 2877 * ioctl handler calling blocking_notifier_call_chain) holds the necessary
1da177e4
LT		 2878 * locks for us to safely manipulate the slave devices (RTNL lock,
2879 * dev_probe_lock).
2880 */
3d632c3f
SH		 2881static int bond_netdev_event(struct notifier_block *this,
2882 unsigned long event, void *ptr)
1da177e4 2883{
351638e7 2884 struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
1da177e4 2885
5a03cdb7 2886 pr_debug("event_dev: %s, event: %lx\n",
a4aee5c8
JP		 2887 event_dev ? event_dev->name : "None",
2888 event);
1da177e4 2889
0b680e75
JV		 2890 if (!(event_dev->priv_flags & IFF_BONDING))
2891 return NOTIFY_DONE;
2892
1da177e4 2893 if (event_dev->flags & IFF_MASTER) {
5a03cdb7 2894 pr_debug("IFF_MASTER\n");
1da177e4
LT		 2895 return bond_master_netdev_event(event, event_dev);
2896 }
2897
2898 if (event_dev->flags & IFF_SLAVE) {
5a03cdb7 2899 pr_debug("IFF_SLAVE\n");
1da177e4
LT		 2900 return bond_slave_netdev_event(event, event_dev);
2901 }
2902
2903 return NOTIFY_DONE;
2904}
2905
2906static struct notifier_block bond_netdev_notifier = {
2907 .notifier_call = bond_netdev_event,
2908};
2909
169a3e66
JV		 2910/*---------------------------- Hashing Policies -----------------------------*/
2911
32819dc1
NA		 2912/* L2 hash helper */
2913static inline u32 bond_eth_hash(struct sk_buff *skb)
6b923cb7
JE		 2914{
2915 struct ethhdr *data = (struct ethhdr *)skb->data;
2916
2917 if (skb_headlen(skb) >= offsetof(struct ethhdr, h_proto))
32819dc1 2918 return data->h_dest[5] ^ data->h_source[5];
6b923cb7
JE		 2919
2920 return 0;
2921}
2922
32819dc1
NA		 2923/* Extract the appropriate headers based on bond's xmit policy */
2924static bool bond_flow_dissect(struct bonding *bond, struct sk_buff *skb,
2925 struct flow_keys *fk)
6f6652be 2926{
32819dc1 2927 const struct ipv6hdr *iph6;
4394542c 2928 const struct iphdr *iph;
32819dc1 2929 int noff, proto = -1;
6b923cb7 2930
32819dc1
NA		 2931 if (bond->params.xmit_policy > BOND_XMIT_POLICY_LAYER23)
2932 return skb_flow_dissect(skb, fk);
2933
2934 fk->ports = 0;
2935 noff = skb_network_offset(skb);
2936 if (skb->protocol == htons(ETH_P_IP)) {
2937 if (!pskb_may_pull(skb, noff + sizeof(*iph)))
2938 return false;
6b923cb7 2939 iph = ip_hdr(skb);
32819dc1
NA		 2940 fk->src = iph->saddr;
2941 fk->dst = iph->daddr;
2942 noff += iph->ihl << 2;
2943 if (!ip_is_fragment(iph))
2944 proto = iph->protocol;
2945 } else if (skb->protocol == htons(ETH_P_IPV6)) {
2946 if (!pskb_may_pull(skb, noff + sizeof(*iph6)))
2947 return false;
2948 iph6 = ipv6_hdr(skb);
2949 fk->src = (__force __be32)ipv6_addr_hash(&iph6->saddr);
2950 fk->dst = (__force __be32)ipv6_addr_hash(&iph6->daddr);
2951 noff += sizeof(*iph6);
2952 proto = iph6->nexthdr;
2953 } else {
2954 return false;
6f6652be 2955 }
32819dc1
NA		 2956 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34 && proto >= 0)
2957 fk->ports = skb_flow_get_ports(skb, noff, proto);
6f6652be 2958
32819dc1 2959 return true;
6f6652be
JV		 2960}
2961
32819dc1
NA		 2962/**
2963 * bond_xmit_hash - generate a hash value based on the xmit policy
2964 * @bond: bonding device
2965 * @skb: buffer to use for headers
2966 * @count: modulo value
2967 *
2968 * This function will extract the necessary headers from the skb buffer and use
2969 * them to generate a hash based on the xmit_policy set in the bonding device
2970 * which will be reduced modulo count before returning.
169a3e66 2971 */
32819dc1 2972int bond_xmit_hash(struct bonding *bond, struct sk_buff *skb, int count)
169a3e66 2973{
32819dc1
NA		 2974 struct flow_keys flow;
2975 u32 hash;
4394542c 2976
32819dc1
NA		 2977 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER2 ||
2978 !bond_flow_dissect(bond, skb, &flow))
2979 return bond_eth_hash(skb) % count;
169a3e66 2980
32819dc1
NA		 2981 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER23 ||
2982 bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP23)
2983 hash = bond_eth_hash(skb);
2984 else
2985 hash = (__force u32)flow.ports;
2986 hash ^= (__force u32)flow.dst ^ (__force u32)flow.src;
2987 hash ^= (hash >> 16);
2988 hash ^= (hash >> 8);
2989
2990 return hash % count;
169a3e66
JV		 2991}
2992
1da177e4
LT		 2993/*-------------------------- Device entry points ----------------------------*/
2994
fbb0c41b 2995static void bond_work_init_all(struct bonding *bond)
2996{
2997 INIT_DELAYED_WORK(&bond->mcast_work,
2998 bond_resend_igmp_join_requests_delayed);
2999 INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
3000 INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor);
3001 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
3002 INIT_DELAYED_WORK(&bond->arp_work, bond_activebackup_arp_mon);
3003 else
3004 INIT_DELAYED_WORK(&bond->arp_work, bond_loadbalance_arp_mon);
3005 INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
3006}
3007
3008static void bond_work_cancel_all(struct bonding *bond)
3009{
3010 cancel_delayed_work_sync(&bond->mii_work);
3011 cancel_delayed_work_sync(&bond->arp_work);
3012 cancel_delayed_work_sync(&bond->alb_work);
3013 cancel_delayed_work_sync(&bond->ad_work);
3014 cancel_delayed_work_sync(&bond->mcast_work);
3015}
3016
1da177e4
LT		 3017static int bond_open(struct net_device *bond_dev)
3018{
454d7c9b 3019 struct bonding *bond = netdev_priv(bond_dev);
9caff1e7 3020 struct list_head *iter;
ba3211cc 3021 struct slave *slave;
1da177e4 3022
ba3211cc
PP		 3023 /* reset slave->backup and slave->inactive */
3024 read_lock(&bond->lock);
0965a1f3 3025 if (bond_has_slaves(bond)) {
ba3211cc 3026 read_lock(&bond->curr_slave_lock);
9caff1e7 3027 bond_for_each_slave(bond, slave, iter) {
ba3211cc
PP		 3028 if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
3029 && (slave != bond->curr_active_slave)) {
3030 bond_set_slave_inactive_flags(slave);
3031 } else {
3032 bond_set_slave_active_flags(slave);
3033 }
3034 }
3035 read_unlock(&bond->curr_slave_lock);
3036 }
3037 read_unlock(&bond->lock);
3038
fbb0c41b 3039 bond_work_init_all(bond);
5a37e8ca 3040
58402054 3041 if (bond_is_lb(bond)) {
1da177e4
LT		 3042 /* bond_alb_initialize must be called before the timer
3043 * is started.
3044 */
fbb0c41b 3045 if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB)))
b473946a 3046 return -ENOMEM;
1b76b316 3047 queue_delayed_work(bond->wq, &bond->alb_work, 0);
1da177e4
LT		 3048 }
3049
fbb0c41b 3050 if (bond->params.miimon) /* link check interval, in milliseconds. */
1b76b316 3051 queue_delayed_work(bond->wq, &bond->mii_work, 0);
1da177e4
LT		 3052
3053 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
1b76b316 3054 queue_delayed_work(bond->wq, &bond->arp_work, 0);
f5b2b966 3055 if (bond->params.arp_validate)
3aba891d 3056 bond->recv_probe = bond_arp_rcv;
1da177e4
LT		 3057 }
3058
3059 if (bond->params.mode == BOND_MODE_8023AD) {
1b76b316 3060 queue_delayed_work(bond->wq, &bond->ad_work, 0);
1da177e4 3061 /* register to receive LACPDUs */
3aba891d 3062 bond->recv_probe = bond_3ad_lacpdu_recv;
fd989c83 3063 bond_3ad_initiate_agg_selection(bond, 1);
1da177e4
LT		 3064 }
3065
3066 return 0;
3067}
3068
3069static int bond_close(struct net_device *bond_dev)
3070{
454d7c9b 3071 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3072
fbb0c41b 3073 bond_work_cancel_all(bond);
6c8d23f7 3074 bond->send_peer_notif = 0;
ee8487c0 3075 if (bond_is_lb(bond))
1da177e4 3076 bond_alb_deinitialize(bond);
3aba891d 3077 bond->recv_probe = NULL;
1da177e4
LT		 3078
3079 return 0;
3080}
3081
28172739
ED		 3082static struct rtnl_link_stats64 *bond_get_stats(struct net_device *bond_dev,
3083 struct rtnl_link_stats64 *stats)
1da177e4 3084{
454d7c9b 3085 struct bonding *bond = netdev_priv(bond_dev);
28172739 3086 struct rtnl_link_stats64 temp;
9caff1e7 3087 struct list_head *iter;
1da177e4 3088 struct slave *slave;
1da177e4 3089
28172739 3090 memset(stats, 0, sizeof(*stats));
1da177e4
LT		 3091
3092 read_lock_bh(&bond->lock);
9caff1e7 3093 bond_for_each_slave(bond, slave, iter) {
be1f3c2c 3094 const struct rtnl_link_stats64 *sstats =
28172739
ED		 3095 dev_get_stats(slave->dev, &temp);
3096
3097 stats->rx_packets += sstats->rx_packets;
3098 stats->rx_bytes += sstats->rx_bytes;
3099 stats->rx_errors += sstats->rx_errors;
3100 stats->rx_dropped += sstats->rx_dropped;
3101
3102 stats->tx_packets += sstats->tx_packets;
3103 stats->tx_bytes += sstats->tx_bytes;
3104 stats->tx_errors += sstats->tx_errors;
3105 stats->tx_dropped += sstats->tx_dropped;
3106
3107 stats->multicast += sstats->multicast;
3108 stats->collisions += sstats->collisions;
3109
3110 stats->rx_length_errors += sstats->rx_length_errors;
3111 stats->rx_over_errors += sstats->rx_over_errors;
3112 stats->rx_crc_errors += sstats->rx_crc_errors;
3113 stats->rx_frame_errors += sstats->rx_frame_errors;
3114 stats->rx_fifo_errors += sstats->rx_fifo_errors;
3115 stats->rx_missed_errors += sstats->rx_missed_errors;
3116
3117 stats->tx_aborted_errors += sstats->tx_aborted_errors;
3118 stats->tx_carrier_errors += sstats->tx_carrier_errors;
3119 stats->tx_fifo_errors += sstats->tx_fifo_errors;
3120 stats->tx_heartbeat_errors += sstats->tx_heartbeat_errors;
3121 stats->tx_window_errors += sstats->tx_window_errors;
2439f9eb 3122 }
1da177e4
LT		 3123 read_unlock_bh(&bond->lock);
3124
3125 return stats;
3126}
3127
3128static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
3129{
080a06e1 3130 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 3131 struct net_device *slave_dev = NULL;
3132 struct ifbond k_binfo;
3133 struct ifbond __user *u_binfo = NULL;
3134 struct ifslave k_sinfo;
3135 struct ifslave __user *u_sinfo = NULL;
3136 struct mii_ioctl_data *mii = NULL;
387ff911 3137 struct net *net;
1da177e4
LT		 3138 int res = 0;
3139
a4aee5c8 3140 pr_debug("bond_ioctl: master=%s, cmd=%d\n", bond_dev->name, cmd);
1da177e4
LT		 3141
3142 switch (cmd) {
1da177e4
LT		 3143 case SIOCGMIIPHY:
3144 mii = if_mii(ifr);
3d632c3f 3145 if (!mii)
1da177e4 3146 return -EINVAL;
3d632c3f 3147
1da177e4
LT		 3148 mii->phy_id = 0;
3149 /* Fall Through */
3150 case SIOCGMIIREG:
3151 /*
3152 * We do this again just in case we were called by SIOCGMIIREG
3153 * instead of SIOCGMIIPHY.
3154 */
3155 mii = if_mii(ifr);
3d632c3f 3156 if (!mii)
1da177e4 3157 return -EINVAL;
3d632c3f 3158
1da177e4
LT		 3159
3160 if (mii->reg_num == 1) {
1da177e4 3161 mii->val_out = 0;
6603a6f2 3162 read_lock(&bond->lock);
1da177e4 3163 read_lock(&bond->curr_slave_lock);
3d632c3f 3164 if (netif_carrier_ok(bond->dev))
1da177e4 3165 mii->val_out = BMSR_LSTATUS;
3d632c3f 3166
1da177e4 3167 read_unlock(&bond->curr_slave_lock);
6603a6f2 3168 read_unlock(&bond->lock);
1da177e4
LT		 3169 }
3170
3171 return 0;
3172 case BOND_INFO_QUERY_OLD:
3173 case SIOCBONDINFOQUERY:
3174 u_binfo = (struct ifbond __user *)ifr->ifr_data;
3175
3d632c3f 3176 if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond)))
1da177e4 3177 return -EFAULT;
1da177e4
LT		 3178
3179 res = bond_info_query(bond_dev, &k_binfo);
3d632c3f
SH		 3180 if (res == 0 &&
3181 copy_to_user(u_binfo, &k_binfo, sizeof(ifbond)))
3182 return -EFAULT;
1da177e4
LT		 3183
3184 return res;
3185 case BOND_SLAVE_INFO_QUERY_OLD:
3186 case SIOCBONDSLAVEINFOQUERY:
3187 u_sinfo = (struct ifslave __user *)ifr->ifr_data;
3188
3d632c3f 3189 if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave)))
1da177e4 3190 return -EFAULT;
1da177e4
LT		 3191
3192 res = bond_slave_info_query(bond_dev, &k_sinfo);
3d632c3f
SH		 3193 if (res == 0 &&
3194 copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave)))
3195 return -EFAULT;
1da177e4
LT		 3196
3197 return res;
3198 default:
3199 /* Go on */
3200 break;
3201 }
3202
387ff911
G		 3203 net = dev_net(bond_dev);
3204
3205 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1da177e4 3206 return -EPERM;
1da177e4 3207
387ff911 3208 slave_dev = dev_get_by_name(net, ifr->ifr_slave);
1da177e4 3209
a4aee5c8 3210 pr_debug("slave_dev=%p:\n", slave_dev);
1da177e4 3211
3d632c3f 3212 if (!slave_dev)
1da177e4 3213 res = -ENODEV;
3d632c3f 3214 else {
a4aee5c8 3215 pr_debug("slave_dev->name=%s:\n", slave_dev->name);
1da177e4
LT		 3216 switch (cmd) {
3217 case BOND_ENSLAVE_OLD:
3218 case SIOCBONDENSLAVE:
3219 res = bond_enslave(bond_dev, slave_dev);
3220 break;
3221 case BOND_RELEASE_OLD:
3222 case SIOCBONDRELEASE:
3223 res = bond_release(bond_dev, slave_dev);
3224 break;
3225 case BOND_SETHWADDR_OLD:
3226 case SIOCBONDSETHWADDR:
409cc1f8
JP		 3227 bond_set_dev_addr(bond_dev, slave_dev);
3228 res = 0;
1da177e4
LT		 3229 break;
3230 case BOND_CHANGE_ACTIVE_OLD:
3231 case SIOCBONDCHANGEACTIVE:
080a06e1 3232 res = bond_option_active_slave_set(bond, slave_dev);
1da177e4
LT		 3233 break;
3234 default:
3235 res = -EOPNOTSUPP;
3236 }
3237
3238 dev_put(slave_dev);
3239 }
3240
1da177e4
LT		 3241 return res;
3242}
3243
d03462b9 3244static void bond_change_rx_flags(struct net_device *bond_dev, int change)
1da177e4 3245{
454d7c9b 3246 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3247
d03462b9
JP		 3248 if (change & IFF_PROMISC)
3249 bond_set_promiscuity(bond,
3250 bond_dev->flags & IFF_PROMISC ? 1 : -1);
3d632c3f 3251
d03462b9
JP		 3252 if (change & IFF_ALLMULTI)
3253 bond_set_allmulti(bond,
3254 bond_dev->flags & IFF_ALLMULTI ? 1 : -1);
3255}
1da177e4 3256
303d1cbf 3257static void bond_set_rx_mode(struct net_device *bond_dev)
d03462b9
JP		 3258{
3259 struct bonding *bond = netdev_priv(bond_dev);
9caff1e7 3260 struct list_head *iter;
303d1cbf 3261 struct slave *slave;
1da177e4 3262
80ee5ad2 3263
b3241870 3264 rcu_read_lock();
303d1cbf 3265 if (USES_PRIMARY(bond->params.mode)) {
b3241870 3266 slave = rcu_dereference(bond->curr_active_slave);
303d1cbf
JV		 3267 if (slave) {
3268 dev_uc_sync(slave->dev, bond_dev);
3269 dev_mc_sync(slave->dev, bond_dev);
3270 }
303d1cbf 3271 } else {
b3241870 3272 bond_for_each_slave_rcu(bond, slave, iter) {
303d1cbf
JV		 3273 dev_uc_sync_multiple(slave->dev, bond_dev);
3274 dev_mc_sync_multiple(slave->dev, bond_dev);
3275 }
1da177e4 3276 }
b3241870 3277 rcu_read_unlock();
1da177e4
LT		 3278}
3279
234bcf8a 3280static int bond_neigh_init(struct neighbour *n)
00829823 3281{
234bcf8a 3282 struct bonding *bond = netdev_priv(n->dev);
234bcf8a
SP		 3283 const struct net_device_ops *slave_ops;
3284 struct neigh_parms parms;
dec1e90e 3285 struct slave *slave;
234bcf8a
SP		 3286 int ret;
3287
dec1e90e 3288 slave = bond_first_slave(bond);
234bcf8a
SP		 3289 if (!slave)
3290 return 0;
234bcf8a 3291 slave_ops = slave->dev->netdev_ops;
234bcf8a
SP		 3292 if (!slave_ops->ndo_neigh_setup)
3293 return 0;
3294
3295 parms.neigh_setup = NULL;
3296 parms.neigh_cleanup = NULL;
3297 ret = slave_ops->ndo_neigh_setup(slave->dev, &parms);
3298 if (ret)
3299 return ret;
3300
3301 /*
3302 * Assign slave's neigh_cleanup to neighbour in case cleanup is called
3303 * after the last slave has been detached. Assumes that all slaves
3304 * utilize the same neigh_cleanup (true at this writing as only user
3305 * is ipoib).
3306 */
3307 n->parms->neigh_cleanup = parms.neigh_cleanup;
3308
3309 if (!parms.neigh_setup)
3310 return 0;
3311
3312 return parms.neigh_setup(n);
3313}
3314
3315/*
3316 * The bonding ndo_neigh_setup is called at init time beofre any
3317 * slave exists. So we must declare proxy setup function which will
3318 * be used at run time to resolve the actual slave neigh param setup.
9918d5bf
VF		 3319 *
3320 * It's also called by master devices (such as vlans) to setup their
3321 * underlying devices. In that case - do nothing, we're already set up from
3322 * our init.
234bcf8a
SP		 3323 */
3324static int bond_neigh_setup(struct net_device *dev,
3325 struct neigh_parms *parms)
3326{
9918d5bf
VF		 3327 /* modify only our neigh_parms */
3328 if (parms->dev == dev)
3329 parms->neigh_setup = bond_neigh_init;
00829823 3330
00829823
SH		 3331 return 0;
3332}
3333
1da177e4
LT		 3334/*
3335 * Change the MTU of all of a master's slaves to match the master
3336 */
3337static int bond_change_mtu(struct net_device *bond_dev, int new_mtu)
3338{
454d7c9b 3339 struct bonding *bond = netdev_priv(bond_dev);
81f23b13 3340 struct slave *slave, *rollback_slave;
9caff1e7 3341 struct list_head *iter;
1da177e4 3342 int res = 0;
1da177e4 3343
5a03cdb7 3344 pr_debug("bond=%p, name=%s, new_mtu=%d\n", bond,
a4aee5c8 3345 (bond_dev ? bond_dev->name : "None"), new_mtu);
1da177e4
LT		 3346
3347 /* Can't hold bond->lock with bh disabled here since
3348 * some base drivers panic. On the other hand we can't
3349 * hold bond->lock without bh disabled because we'll
3350 * deadlock. The only solution is to rely on the fact
3351 * that we're under rtnl_lock here, and the slaves
3352 * list won't change. This doesn't solve the problem
3353 * of setting the slave's MTU while it is
3354 * transmitting, but the assumption is that the base
3355 * driver can handle that.
3356 *
3357 * TODO: figure out a way to safely iterate the slaves
3358 * list, but without holding a lock around the actual
3359 * call to the base driver.
3360 */
3361
9caff1e7 3362 bond_for_each_slave(bond, slave, iter) {
c8c23903 3363 pr_debug("s %p c_m %p\n",
a4aee5c8 3364 slave,
a4aee5c8 3365 slave->dev->netdev_ops->ndo_change_mtu);
e944ef79 3366
1da177e4
LT		 3367 res = dev_set_mtu(slave->dev, new_mtu);
3368
3369 if (res) {
3370 /* If we failed to set the slave's mtu to the new value
3371 * we must abort the operation even in ACTIVE_BACKUP
3372 * mode, because if we allow the backup slaves to have
3373 * different mtu values than the active slave we'll
3374 * need to change their mtu when doing a failover. That
3375 * means changing their mtu from timer context, which
3376 * is probably not a good idea.
3377 */
5a03cdb7 3378 pr_debug("err %d %s\n", res, slave->dev->name);
1da177e4
LT		 3379 goto unwind;
3380 }
3381 }
3382
3383 bond_dev->mtu = new_mtu;
3384
3385 return 0;
3386
3387unwind:
3388 /* unwind from head to the slave that failed */
9caff1e7 3389 bond_for_each_slave(bond, rollback_slave, iter) {
1da177e4
LT		 3390 int tmp_res;
3391
81f23b13
VF		 3392 if (rollback_slave == slave)
3393 break;
3394
3395 tmp_res = dev_set_mtu(rollback_slave->dev, bond_dev->mtu);
1da177e4 3396 if (tmp_res) {
a4aee5c8 3397 pr_debug("unwind err %d dev %s\n",
81f23b13 3398 tmp_res, rollback_slave->dev->name);
1da177e4
LT		 3399 }
3400 }
3401
3402 return res;
3403}
3404
3405/*
3406 * Change HW address
3407 *
3408 * Note that many devices must be down to change the HW address, and
3409 * downing the master releases all slaves. We can make bonds full of
3410 * bonding devices to test this, however.
3411 */
3412static int bond_set_mac_address(struct net_device *bond_dev, void *addr)
3413{
454d7c9b 3414 struct bonding *bond = netdev_priv(bond_dev);
81f23b13 3415 struct slave *slave, *rollback_slave;
1da177e4 3416 struct sockaddr *sa = addr, tmp_sa;
9caff1e7 3417 struct list_head *iter;
1da177e4 3418 int res = 0;
1da177e4 3419
eb7cc59a
SH		 3420 if (bond->params.mode == BOND_MODE_ALB)
3421 return bond_alb_set_mac_address(bond_dev, addr);
3422
3423
a4aee5c8
JP		 3424 pr_debug("bond=%p, name=%s\n",
3425 bond, bond_dev ? bond_dev->name : "None");
1da177e4 3426
1b5acd29
JV		 3427 /* If fail_over_mac is enabled, do nothing and return success.
3428 * Returning an error causes ifenslave to fail.
dd957c57 3429 */
1b5acd29 3430 if (bond->params.fail_over_mac)
dd957c57 3431 return 0;
2ab82852 3432
3d632c3f 3433 if (!is_valid_ether_addr(sa->sa_data))
1da177e4 3434 return -EADDRNOTAVAIL;
1da177e4
LT		 3435
3436 /* Can't hold bond->lock with bh disabled here since
3437 * some base drivers panic. On the other hand we can't
3438 * hold bond->lock without bh disabled because we'll
3439 * deadlock. The only solution is to rely on the fact
3440 * that we're under rtnl_lock here, and the slaves
3441 * list won't change. This doesn't solve the problem
3442 * of setting the slave's hw address while it is
3443 * transmitting, but the assumption is that the base
3444 * driver can handle that.
3445 *
3446 * TODO: figure out a way to safely iterate the slaves
3447 * list, but without holding a lock around the actual
3448 * call to the base driver.
3449 */
3450
9caff1e7 3451 bond_for_each_slave(bond, slave, iter) {
eb7cc59a 3452 const struct net_device_ops *slave_ops = slave->dev->netdev_ops;
5a03cdb7 3453 pr_debug("slave %p %s\n", slave, slave->dev->name);
1da177e4 3454
eb7cc59a 3455 if (slave_ops->ndo_set_mac_address == NULL) {
1da177e4 3456 res = -EOPNOTSUPP;
5a03cdb7 3457 pr_debug("EOPNOTSUPP %s\n", slave->dev->name);
1da177e4
LT		 3458 goto unwind;
3459 }
3460
3461 res = dev_set_mac_address(slave->dev, addr);
3462 if (res) {
3463 /* TODO: consider downing the slave
3464 * and retry ?
3465 * User should expect communications
3466 * breakage anyway until ARP finish
3467 * updating, so...
3468 */
5a03cdb7 3469 pr_debug("err %d %s\n", res, slave->dev->name);
1da177e4
LT		 3470 goto unwind;
3471 }
3472 }
3473
3474 /* success */
3475 memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);
3476 return 0;
3477
3478unwind:
3479 memcpy(tmp_sa.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
3480 tmp_sa.sa_family = bond_dev->type;
3481
3482 /* unwind from head to the slave that failed */
9caff1e7 3483 bond_for_each_slave(bond, rollback_slave, iter) {
1da177e4
LT		 3484 int tmp_res;
3485
81f23b13
VF		 3486 if (rollback_slave == slave)
3487 break;
3488
3489 tmp_res = dev_set_mac_address(rollback_slave->dev, &tmp_sa);
1da177e4 3490 if (tmp_res) {
a4aee5c8 3491 pr_debug("unwind err %d dev %s\n",
81f23b13 3492 tmp_res, rollback_slave->dev->name);
1da177e4
LT		 3493 }
3494 }
3495
3496 return res;
3497}
3498
15077228
NA		 3499/**
3500 * bond_xmit_slave_id - transmit skb through slave with slave_id
3501 * @bond: bonding device that is transmitting
3502 * @skb: buffer to transmit
3503 * @slave_id: slave id up to slave_cnt-1 through which to transmit
3504 *
3505 * This function tries to transmit through slave with slave_id but in case
3506 * it fails, it tries to find the first available slave for transmission.
3507 * The skb is consumed in all cases, thus the function is void.
3508 */
3509void bond_xmit_slave_id(struct bonding *bond, struct sk_buff *skb, int slave_id)
3510{
9caff1e7 3511 struct list_head *iter;
15077228
NA		 3512 struct slave *slave;
3513 int i = slave_id;
3514
3515 /* Here we start from the slave with slave_id */
9caff1e7 3516 bond_for_each_slave_rcu(bond, slave, iter) {
15077228
NA		 3517 if (--i < 0) {
3518 if (slave_can_tx(slave)) {
3519 bond_dev_queue_xmit(bond, skb, slave->dev);
3520 return;
3521 }
3522 }
3523 }
3524
3525 /* Here we start from the first slave up to slave_id */
3526 i = slave_id;
9caff1e7 3527 bond_for_each_slave_rcu(bond, slave, iter) {
15077228
NA		 3528 if (--i < 0)
3529 break;
3530 if (slave_can_tx(slave)) {
3531 bond_dev_queue_xmit(bond, skb, slave->dev);
3532 return;
3533 }
3534 }
3535 /* no slave that can tx has been found */
3536 kfree_skb(skb);
3537}
3538
1da177e4
LT		 3539static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
3540{
454d7c9b 3541 struct bonding *bond = netdev_priv(bond_dev);
a2fd940f 3542 struct iphdr *iph = ip_hdr(skb);
15077228 3543 struct slave *slave;
1da177e4 3544
cf5f9044 3545 /*
a2fd940f
AG		 3546 * Start with the curr_active_slave that joined the bond as the
3547 * default for sending IGMP traffic. For failover purposes one
3548 * needs to maintain some consistency for the interface that will
3549 * send the join/membership reports. The curr_active_slave found
3550 * will send all of this type of traffic.
cf5f9044 3551 */
15077228 3552 if (iph->protocol == IPPROTO_IGMP && skb->protocol == htons(ETH_P_IP)) {
278b2083 3553 slave = rcu_dereference(bond->curr_active_slave);
15077228
NA		 3554 if (slave && slave_can_tx(slave))
3555 bond_dev_queue_xmit(bond, skb, slave->dev);
3556 else
3557 bond_xmit_slave_id(bond, skb, 0);
a2fd940f 3558 } else {
15077228
NA		 3559 bond_xmit_slave_id(bond, skb,
3560 bond->rr_tx_counter++ % bond->slave_cnt);
1da177e4 3561 }
0693e88e 3562
ec634fe3 3563 return NETDEV_TX_OK;
1da177e4
LT		 3564}
3565
3566/*
3567 * in active-backup mode, we know that bond->curr_active_slave is always valid if
3568 * the bond has a usable interface.
3569 */
3570static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_dev)
3571{
454d7c9b 3572 struct bonding *bond = netdev_priv(bond_dev);
71bc3b2d 3573 struct slave *slave;
1da177e4 3574
278b2083 3575 slave = rcu_dereference(bond->curr_active_slave);
71bc3b2d 3576 if (slave)
15077228
NA		 3577 bond_dev_queue_xmit(bond, skb, slave->dev);
3578 else
04502430 3579 kfree_skb(skb);
0693e88e 3580
ec634fe3 3581 return NETDEV_TX_OK;
1da177e4
LT		 3582}
3583
32819dc1 3584/* In bond_xmit_xor() , we determine the output device by using a pre-
169a3e66
JV		 3585 * determined xmit_hash_policy(), If the selected device is not enabled,
3586 * find the next active slave.
1da177e4
LT		 3587 */
3588static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
3589{
454d7c9b 3590 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3591
32819dc1 3592 bond_xmit_slave_id(bond, skb, bond_xmit_hash(bond, skb, bond->slave_cnt));
0693e88e 3593
ec634fe3 3594 return NETDEV_TX_OK;
1da177e4
LT		 3595}
3596
78a646ce 3597/* in broadcast mode, we send everything to all usable interfaces. */
1da177e4
LT		 3598static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
3599{
454d7c9b 3600 struct bonding *bond = netdev_priv(bond_dev);
78a646ce 3601 struct slave *slave = NULL;
9caff1e7 3602 struct list_head *iter;
1da177e4 3603
9caff1e7 3604 bond_for_each_slave_rcu(bond, slave, iter) {
78a646ce
NA		 3605 if (bond_is_last_slave(bond, slave))
3606 break;
3607 if (IS_UP(slave->dev) && slave->link == BOND_LINK_UP) {
3608 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1da177e4 3609
78a646ce
NA		 3610 if (!skb2) {
3611 pr_err("%s: Error: bond_xmit_broadcast(): skb_clone() failed\n",
3612 bond_dev->name);
3613 continue;
1da177e4 3614 }
78a646ce
NA		 3615 /* bond_dev_queue_xmit always returns 0 */
3616 bond_dev_queue_xmit(bond, skb2, slave->dev);
1da177e4
LT		 3617 }
3618 }
78a646ce
NA		 3619 if (slave && IS_UP(slave->dev) && slave->link == BOND_LINK_UP)
3620 bond_dev_queue_xmit(bond, skb, slave->dev);
3621 else
04502430 3622 kfree_skb(skb);
3d632c3f 3623
ec634fe3 3624 return NETDEV_TX_OK;
1da177e4
LT		 3625}
3626
3627/*------------------------- Device initialization ---------------------------*/
3628
bb1d9123
AG		 3629/*
3630 * Lookup the slave that corresponds to a qid
3631 */
3632static inline int bond_slave_override(struct bonding *bond,
3633 struct sk_buff *skb)
3634{
bb1d9123
AG		 3635 struct slave *slave = NULL;
3636 struct slave *check_slave;
9caff1e7 3637 struct list_head *iter;
dec1e90e 3638 int res = 1;
bb1d9123 3639
0693e88e
MM		 3640 if (!skb->queue_mapping)
3641 return 1;
bb1d9123
AG		 3642
3643 /* Find out if any slaves have the same mapping as this skb. */
9caff1e7 3644 bond_for_each_slave_rcu(bond, check_slave, iter) {
bb1d9123
AG		 3645 if (check_slave->queue_id == skb->queue_mapping) {
3646 slave = check_slave;
3647 break;
3648 }
3649 }
3650
3651 /* If the slave isn't UP, use default transmit policy. */
3652 if (slave && slave->queue_id && IS_UP(slave->dev) &&
3653 (slave->link == BOND_LINK_UP)) {
3654 res = bond_dev_queue_xmit(bond, skb, slave->dev);
3655 }
3656
bb1d9123
AG		 3657 return res;
3658}
3659
374eeb5a 3660
bb1d9123
AG		 3661static u16 bond_select_queue(struct net_device *dev, struct sk_buff *skb)
3662{
3663 /*
3664 * This helper function exists to help dev_pick_tx get the correct
fd0e435b 3665 * destination queue. Using a helper function skips a call to
bb1d9123
AG		 3666 * skb_tx_hash and will put the skbs in the queue we expect on their
3667 * way down to the bonding driver.
3668 */
fd0e435b
PO		 3669 u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
3670
374eeb5a
NH		 3671 /*
3672 * Save the original txq to restore before passing to the driver
3673 */
df4ab5b3 3674 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
374eeb5a 3675
fd0e435b 3676 if (unlikely(txq >= dev->real_num_tx_queues)) {
d30ee670 3677 do {
fd0e435b 3678 txq -= dev->real_num_tx_queues;
d30ee670 3679 } while (txq >= dev->real_num_tx_queues);
fd0e435b
PO		 3680 }
3681 return txq;
bb1d9123
AG		 3682}
3683
0693e88e 3684static netdev_tx_t __bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
00829823 3685{
bb1d9123
AG		 3686 struct bonding *bond = netdev_priv(dev);
3687
3688 if (TX_QUEUE_OVERRIDE(bond->params.mode)) {
3689 if (!bond_slave_override(bond, skb))
3690 return NETDEV_TX_OK;
3691 }
00829823
SH		 3692
3693 switch (bond->params.mode) {
3694 case BOND_MODE_ROUNDROBIN:
3695 return bond_xmit_roundrobin(skb, dev);
3696 case BOND_MODE_ACTIVEBACKUP:
3697 return bond_xmit_activebackup(skb, dev);
3698 case BOND_MODE_XOR:
3699 return bond_xmit_xor(skb, dev);
3700 case BOND_MODE_BROADCAST:
3701 return bond_xmit_broadcast(skb, dev);
3702 case BOND_MODE_8023AD:
3703 return bond_3ad_xmit_xor(skb, dev);
3704 case BOND_MODE_ALB:
3705 case BOND_MODE_TLB:
3706 return bond_alb_xmit(skb, dev);
3707 default:
3708 /* Should never happen, mode already checked */
a4aee5c8
JP		 3709 pr_err("%s: Error: Unknown bonding mode %d\n",
3710 dev->name, bond->params.mode);
00829823 3711 WARN_ON_ONCE(1);
04502430 3712 kfree_skb(skb);
00829823
SH		 3713 return NETDEV_TX_OK;
3714 }
3715}
3716
0693e88e
MM		 3717static netdev_tx_t bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
3718{
3719 struct bonding *bond = netdev_priv(dev);
3720 netdev_tx_t ret = NETDEV_TX_OK;
3721
3722 /*
3723 * If we risk deadlock from transmitting this in the
3724 * netpoll path, tell netpoll to queue the frame for later tx
3725 */
3726 if (is_netpoll_tx_blocked(dev))
3727 return NETDEV_TX_BUSY;
3728
278b2083 3729 rcu_read_lock();
0965a1f3 3730 if (bond_has_slaves(bond))
0693e88e
MM		 3731 ret = __bond_start_xmit(skb, dev);
3732 else
04502430 3733 kfree_skb(skb);
278b2083 3734 rcu_read_unlock();
0693e88e
MM		 3735
3736 return ret;
3737}
00829823 3738
bb5b052f
AG		 3739static int bond_ethtool_get_settings(struct net_device *bond_dev,
3740 struct ethtool_cmd *ecmd)
3741{
3742 struct bonding *bond = netdev_priv(bond_dev);
bb5b052f 3743 unsigned long speed = 0;
9caff1e7 3744 struct list_head *iter;
dec1e90e 3745 struct slave *slave;
bb5b052f
AG		 3746
3747 ecmd->duplex = DUPLEX_UNKNOWN;
3748 ecmd->port = PORT_OTHER;
3749
3750 /* Since SLAVE_IS_OK returns false for all inactive or down slaves, we
3751 * do not need to check mode. Though link speed might not represent
3752 * the true receive or transmit bandwidth (not all modes are symmetric)
3753 * this is an accurate maximum.
3754 */
3755 read_lock(&bond->lock);
9caff1e7 3756 bond_for_each_slave(bond, slave, iter) {
bb5b052f
AG		 3757 if (SLAVE_IS_OK(slave)) {
3758 if (slave->speed != SPEED_UNKNOWN)
3759 speed += slave->speed;
3760 if (ecmd->duplex == DUPLEX_UNKNOWN &&
3761 slave->duplex != DUPLEX_UNKNOWN)
3762 ecmd->duplex = slave->duplex;
3763 }
3764 }
3765 ethtool_cmd_speed_set(ecmd, speed ? : SPEED_UNKNOWN);
3766 read_unlock(&bond->lock);
dec1e90e 3767
bb5b052f
AG		 3768 return 0;
3769}
3770
217df670 3771static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
7826d43f 3772 struct ethtool_drvinfo *drvinfo)
217df670 3773{
7826d43f
JP		 3774 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
3775 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
3776 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "%d",
3777 BOND_ABI_VERSION);
217df670
JV		 3778}
3779
7282d491 3780static const struct ethtool_ops bond_ethtool_ops = {
217df670 3781 .get_drvinfo = bond_ethtool_get_drvinfo,
bb5b052f 3782 .get_settings = bond_ethtool_get_settings,
fa53ebac 3783 .get_link = ethtool_op_get_link,
8531c5ff
AK		 3784};
3785
eb7cc59a 3786static const struct net_device_ops bond_netdev_ops = {
181470fc 3787 .ndo_init = bond_init,
9e71626c 3788 .ndo_uninit = bond_uninit,
eb7cc59a
SH		 3789 .ndo_open = bond_open,
3790 .ndo_stop = bond_close,
00829823 3791 .ndo_start_xmit = bond_start_xmit,
bb1d9123 3792 .ndo_select_queue = bond_select_queue,
be1f3c2c 3793 .ndo_get_stats64 = bond_get_stats,
eb7cc59a 3794 .ndo_do_ioctl = bond_do_ioctl,
d03462b9 3795 .ndo_change_rx_flags = bond_change_rx_flags,
303d1cbf 3796 .ndo_set_rx_mode = bond_set_rx_mode,
eb7cc59a 3797 .ndo_change_mtu = bond_change_mtu,
cc0e4070 3798 .ndo_set_mac_address = bond_set_mac_address,
00829823 3799 .ndo_neigh_setup = bond_neigh_setup,
cc0e4070 3800 .ndo_vlan_rx_add_vid = bond_vlan_rx_add_vid,
eb7cc59a 3801 .ndo_vlan_rx_kill_vid = bond_vlan_rx_kill_vid,
f6dc31a8 3802#ifdef CONFIG_NET_POLL_CONTROLLER
8a8efa22 3803 .ndo_netpoll_setup = bond_netpoll_setup,
f6dc31a8
WC		 3804 .ndo_netpoll_cleanup = bond_netpoll_cleanup,
3805 .ndo_poll_controller = bond_poll_controller,
3806#endif
9232ecca
JP		 3807 .ndo_add_slave = bond_enslave,
3808 .ndo_del_slave = bond_release,
b2a103e6 3809 .ndo_fix_features = bond_fix_features,
eb7cc59a
SH		 3810};
3811
b3f92b63
DG		 3812static const struct device_type bond_type = {
3813 .name = "bond",
3814};
3815
9e2e61fb
AW		 3816static void bond_destructor(struct net_device *bond_dev)
3817{
3818 struct bonding *bond = netdev_priv(bond_dev);
3819 if (bond->wq)
3820 destroy_workqueue(bond->wq);
3821 free_netdev(bond_dev);
3822}
3823
0a2a78c4 3824void bond_setup(struct net_device *bond_dev)
1da177e4 3825{
454d7c9b 3826 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3827
1da177e4
LT		 3828 /* initialize rwlocks */
3829 rwlock_init(&bond->lock);
3830 rwlock_init(&bond->curr_slave_lock);
d2991f75 3831 bond->params = bonding_defaults;
1da177e4
LT		 3832
3833 /* Initialize pointers */
1da177e4 3834 bond->dev = bond_dev;
1da177e4
LT		 3835
3836 /* Initialize the device entry points */
181470fc 3837 ether_setup(bond_dev);
eb7cc59a 3838 bond_dev->netdev_ops = &bond_netdev_ops;
8531c5ff 3839 bond_dev->ethtool_ops = &bond_ethtool_ops;
1da177e4 3840
9e2e61fb 3841 bond_dev->destructor = bond_destructor;
1da177e4 3842
b3f92b63
DG		 3843 SET_NETDEV_DEVTYPE(bond_dev, &bond_type);
3844
1da177e4
LT		 3845 /* Initialize the device options */
3846 bond_dev->tx_queue_len = 0;
3847 bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
0b680e75 3848 bond_dev->priv_flags |= IFF_BONDING;
550fd08c 3849 bond_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
181470fc 3850
1da177e4
LT		 3851 /* At first, we block adding VLANs. That's the only way to
3852 * prevent problems that occur when adding VLANs over an
3853 * empty bond. The block will be removed once non-challenged
3854 * slaves are enslaved.
3855 */
3856 bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
3857
932ff279 3858 /* don't acquire bond device's netif_tx_lock when
1da177e4
LT		 3859 * transmitting */
3860 bond_dev->features |= NETIF_F_LLTX;
3861
3862 /* By default, we declare the bond to be fully
3863 * VLAN hardware accelerated capable. Special
3864 * care is taken in the various xmit functions
3865 * when there are slaves that are not hw accel
3866 * capable
3867 */
1da177e4 3868
b2a103e6 3869 bond_dev->hw_features = BOND_VLAN_FEATURES |
f646968f
PM		 3870 NETIF_F_HW_VLAN_CTAG_TX |
3871 NETIF_F_HW_VLAN_CTAG_RX |
3872 NETIF_F_HW_VLAN_CTAG_FILTER;
b2a103e6 3873
34324dc2 3874 bond_dev->hw_features &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_HW_CSUM);
b2a103e6 3875 bond_dev->features |= bond_dev->hw_features;
1da177e4
LT		 3876}
3877
c67dfb29
EB		 3878/*
3879* Destroy a bonding device.
3880* Must be under rtnl_lock when this function is called.
3881*/
3882static void bond_uninit(struct net_device *bond_dev)
a434e43f 3883{
454d7c9b 3884 struct bonding *bond = netdev_priv(bond_dev);
544a028e
VF		 3885 struct list_head *iter;
3886 struct slave *slave;
a434e43f 3887
f6dc31a8
WC		 3888 bond_netpoll_cleanup(bond_dev);
3889
c67dfb29 3890 /* Release the bonded slaves */
544a028e 3891 bond_for_each_slave(bond, slave, iter)
dec1e90e 3892 __bond_release_one(bond_dev, slave->dev, true);
0896341a 3893 pr_info("%s: released all slaves\n", bond_dev->name);
c67dfb29 3894
a434e43f
JV		 3895 list_del(&bond->bond_list);
3896
f073c7ca 3897 bond_debug_unregister(bond);
a434e43f
JV		 3898}
3899
1da177e4
LT		 3900/*------------------------- Module initialization ---------------------------*/
3901
3902/*
3903 * Convert string input module parms. Accept either the
ece95f7f
JV		 3904 * number of the mode or its string name. A bit complicated because
3905 * some mode names are substrings of other names, and calls from sysfs
3906 * may have whitespace in the name (trailing newlines, for example).
1da177e4 3907 */
325dcf7a 3908int bond_parse_parm(const char *buf, const struct bond_parm_tbl *tbl)
1da177e4 3909{
54b87323 3910 int modeint = -1, i, rv;
a42e534f 3911 char *p, modestr[BOND_MAX_MODENAME_LEN + 1] = { 0, };
ece95f7f 3912
a42e534f
JV		 3913 for (p = (char *)buf; *p; p++)
3914 if (!(isdigit(*p) || isspace(*p)))
3915 break;
3916
3917 if (*p)
ece95f7f 3918 rv = sscanf(buf, "%20s", modestr);
a42e534f 3919 else
54b87323 3920 rv = sscanf(buf, "%d", &modeint);
a42e534f
JV		 3921
3922 if (!rv)
3923 return -1;
1da177e4
LT		 3924
3925 for (i = 0; tbl[i].modename; i++) {
54b87323 3926 if (modeint == tbl[i].mode)
ece95f7f
JV		 3927 return tbl[i].mode;
3928 if (strcmp(modestr, tbl[i].modename) == 0)
1da177e4 3929 return tbl[i].mode;
1da177e4
LT		 3930 }
3931
3932 return -1;
3933}
3934
3935static int bond_check_params(struct bond_params *params)
3936{
5a5c5fd4 3937 int arp_validate_value, fail_over_mac_value, primary_reselect_value, i;
8599b52e 3938 int arp_all_targets_value;
f5b2b966 3939
1da177e4
LT		 3940 /*
3941 * Convert string parameters.
3942 */
3943 if (mode) {
3944 bond_mode = bond_parse_parm(mode, bond_mode_tbl);
3945 if (bond_mode == -1) {
a4aee5c8 3946 pr_err("Error: Invalid bonding mode \"%s\"\n",
1da177e4
LT		 3947 mode == NULL ? "NULL" : mode);
3948 return -EINVAL;
3949 }
3950 }
3951
169a3e66
JV		 3952 if (xmit_hash_policy) {
3953 if ((bond_mode != BOND_MODE_XOR) &&
3954 (bond_mode != BOND_MODE_8023AD)) {
a4aee5c8 3955 pr_info("xmit_hash_policy param is irrelevant in mode %s\n",
169a3e66
JV		 3956 bond_mode_name(bond_mode));
3957 } else {
3958 xmit_hashtype = bond_parse_parm(xmit_hash_policy,
3959 xmit_hashtype_tbl);
3960 if (xmit_hashtype == -1) {
a4aee5c8 3961 pr_err("Error: Invalid xmit_hash_policy \"%s\"\n",
3d632c3f 3962 xmit_hash_policy == NULL ? "NULL" :
169a3e66
JV		 3963 xmit_hash_policy);
3964 return -EINVAL;
3965 }
3966 }
3967 }
3968
1da177e4
LT		 3969 if (lacp_rate) {
3970 if (bond_mode != BOND_MODE_8023AD) {
a4aee5c8
JP		 3971 pr_info("lacp_rate param is irrelevant in mode %s\n",
3972 bond_mode_name(bond_mode));
1da177e4
LT		 3973 } else {
3974 lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl);
3975 if (lacp_fast == -1) {
a4aee5c8 3976 pr_err("Error: Invalid lacp rate \"%s\"\n",
1da177e4
LT		 3977 lacp_rate == NULL ? "NULL" : lacp_rate);
3978 return -EINVAL;
3979 }
3980 }
3981 }
3982
fd989c83
JV		 3983 if (ad_select) {
3984 params->ad_select = bond_parse_parm(ad_select, ad_select_tbl);
3985 if (params->ad_select == -1) {
a4aee5c8 3986 pr_err("Error: Invalid ad_select \"%s\"\n",
fd989c83
JV		 3987 ad_select == NULL ? "NULL" : ad_select);
3988 return -EINVAL;
3989 }
3990
3991 if (bond_mode != BOND_MODE_8023AD) {
a4aee5c8 3992 pr_warning("ad_select param only affects 802.3ad mode\n");
fd989c83
JV		 3993 }
3994 } else {
3995 params->ad_select = BOND_AD_STABLE;
3996 }
3997
f5841306 3998 if (max_bonds < 0) {
a4aee5c8
JP		 3999 pr_warning("Warning: max_bonds (%d) not in range %d-%d, so it was reset to BOND_DEFAULT_MAX_BONDS (%d)\n",
4000 max_bonds, 0, INT_MAX, BOND_DEFAULT_MAX_BONDS);
1da177e4
LT		 4001 max_bonds = BOND_DEFAULT_MAX_BONDS;
4002 }
4003
4004 if (miimon < 0) {
a4aee5c8
JP		 4005 pr_warning("Warning: miimon module parameter (%d), not in range 0-%d, so it was reset to %d\n",
4006 miimon, INT_MAX, BOND_LINK_MON_INTERV);
1da177e4
LT		 4007 miimon = BOND_LINK_MON_INTERV;
4008 }
4009
4010 if (updelay < 0) {
a4aee5c8
JP		 4011 pr_warning("Warning: updelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
4012 updelay, INT_MAX);
1da177e4
LT		 4013 updelay = 0;
4014 }
4015
4016 if (downdelay < 0) {
a4aee5c8
JP		 4017 pr_warning("Warning: downdelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
4018 downdelay, INT_MAX);
1da177e4
LT		 4019 downdelay = 0;
4020 }
4021
4022 if ((use_carrier != 0) && (use_carrier != 1)) {
a4aee5c8
JP		 4023 pr_warning("Warning: use_carrier module parameter (%d), not of valid value (0/1), so it was set to 1\n",
4024 use_carrier);
1da177e4
LT		 4025 use_carrier = 1;
4026 }
4027
ad246c99
BH		 4028 if (num_peer_notif < 0 || num_peer_notif > 255) {
4029 pr_warning("Warning: num_grat_arp/num_unsol_na (%d) not in range 0-255 so it was reset to 1\n",
4030 num_peer_notif);
4031 num_peer_notif = 1;
4032 }
4033
1da177e4
LT		 4034 /* reset values for 802.3ad */
4035 if (bond_mode == BOND_MODE_8023AD) {
4036 if (!miimon) {
a4aee5c8 4037 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");
3d632c3f 4038 pr_warning("Forcing miimon to 100msec\n");
1da177e4
LT		 4039 miimon = 100;
4040 }
4041 }
4042
bb1d9123
AG		 4043 if (tx_queues < 1 || tx_queues > 255) {
4044 pr_warning("Warning: tx_queues (%d) should be between "
4045 "1 and 255, resetting to %d\n",
4046 tx_queues, BOND_DEFAULT_TX_QUEUES);
4047 tx_queues = BOND_DEFAULT_TX_QUEUES;
4048 }
4049
ebd8e497
AG		 4050 if ((all_slaves_active != 0) && (all_slaves_active != 1)) {
4051 pr_warning("Warning: all_slaves_active module parameter (%d), "
4052 "not of valid value (0/1), so it was set to "
4053 "0\n", all_slaves_active);
4054 all_slaves_active = 0;
4055 }
4056
c2952c31
FL		 4057 if (resend_igmp < 0 || resend_igmp > 255) {
4058 pr_warning("Warning: resend_igmp (%d) should be between "
4059 "0 and 255, resetting to %d\n",
4060 resend_igmp, BOND_DEFAULT_RESEND_IGMP);
4061 resend_igmp = BOND_DEFAULT_RESEND_IGMP;
4062 }
4063
1da177e4
LT		 4064 /* reset values for TLB/ALB */
4065 if ((bond_mode == BOND_MODE_TLB) ||
4066 (bond_mode == BOND_MODE_ALB)) {
4067 if (!miimon) {
a4aee5c8 4068 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");
3d632c3f 4069 pr_warning("Forcing miimon to 100msec\n");
1da177e4
LT		 4070 miimon = 100;
4071 }
4072 }
4073
4074 if (bond_mode == BOND_MODE_ALB) {
a4aee5c8
JP		 4075 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",
4076 updelay);
1da177e4
LT		 4077 }
4078
4079 if (!miimon) {
4080 if (updelay || downdelay) {
4081 /* just warn the user the up/down delay will have
4082 * no effect since miimon is zero...
4083 */
a4aee5c8
JP		 4084 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",
4085 updelay, downdelay);
1da177e4
LT		 4086 }
4087 } else {
4088 /* don't allow arp monitoring */
4089 if (arp_interval) {
a4aee5c8
JP		 4090 pr_warning("Warning: miimon (%d) and arp_interval (%d) can't be used simultaneously, disabling ARP monitoring\n",
4091 miimon, arp_interval);
1da177e4
LT		 4092 arp_interval = 0;
4093 }
4094
4095 if ((updelay % miimon) != 0) {
a4aee5c8
JP		 4096 pr_warning("Warning: updelay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n",
4097 updelay, miimon,
4098 (updelay / miimon) * miimon);
1da177e4
LT		 4099 }
4100
4101 updelay /= miimon;
4102
4103 if ((downdelay % miimon) != 0) {
a4aee5c8
JP		 4104 pr_warning("Warning: downdelay (%d) is not a multiple of miimon (%d), downdelay rounded to %d ms\n",
4105 downdelay, miimon,
4106 (downdelay / miimon) * miimon);
1da177e4
LT		 4107 }
4108
4109 downdelay /= miimon;
4110 }
4111
4112 if (arp_interval < 0) {
a4aee5c8
JP		 4113 pr_warning("Warning: arp_interval module parameter (%d) , not in range 0-%d, so it was reset to %d\n",
4114 arp_interval, INT_MAX, BOND_LINK_ARP_INTERV);
1da177e4
LT		 4115 arp_interval = BOND_LINK_ARP_INTERV;
4116 }
4117
5a5c5fd4 4118 for (arp_ip_count = 0, i = 0;
4119 (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[i]; i++) {
1da177e4
LT		 4120 /* not complete check, but should be good enough to
4121 catch mistakes */
5a5c5fd4 4122 __be32 ip = in_aton(arp_ip_target[i]);
4123 if (!isdigit(arp_ip_target[i][0]) || ip == 0 ||
4124 ip == htonl(INADDR_BROADCAST)) {
a4aee5c8 4125 pr_warning("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n",
5a5c5fd4 4126 arp_ip_target[i]);
1da177e4
LT		 4127 arp_interval = 0;
4128 } else {
0afee4e8
VF		 4129 if (bond_get_targets_ip(arp_target, ip) == -1)
4130 arp_target[arp_ip_count++] = ip;
4131 else
4132 pr_warning("Warning: duplicate address %pI4 in arp_ip_target, skipping\n",
4133 &ip);
1da177e4
LT		 4134 }
4135 }
4136
4137 if (arp_interval && !arp_ip_count) {
4138 /* don't allow arping if no arp_ip_target given... */
a4aee5c8
JP		 4139 pr_warning("Warning: arp_interval module parameter (%d) specified without providing an arp_ip_target parameter, arp_interval was reset to 0\n",
4140 arp_interval);
1da177e4
LT		 4141 arp_interval = 0;
4142 }
4143
f5b2b966
JV		 4144 if (arp_validate) {
4145 if (bond_mode != BOND_MODE_ACTIVEBACKUP) {
a4aee5c8 4146 pr_err("arp_validate only supported in active-backup mode\n");
f5b2b966
JV		 4147 return -EINVAL;
4148 }
4149 if (!arp_interval) {
a4aee5c8 4150 pr_err("arp_validate requires arp_interval\n");
f5b2b966
JV		 4151 return -EINVAL;
4152 }
4153
4154 arp_validate_value = bond_parse_parm(arp_validate,
4155 arp_validate_tbl);
4156 if (arp_validate_value == -1) {
a4aee5c8 4157 pr_err("Error: invalid arp_validate \"%s\"\n",
f5b2b966
JV		 4158 arp_validate == NULL ? "NULL" : arp_validate);
4159 return -EINVAL;
4160 }
4161 } else
4162 arp_validate_value = 0;
4163
8599b52e
VF		 4164 arp_all_targets_value = 0;
4165 if (arp_all_targets) {
4166 arp_all_targets_value = bond_parse_parm(arp_all_targets,
4167 arp_all_targets_tbl);
4168
4169 if (arp_all_targets_value == -1) {
4170 pr_err("Error: invalid arp_all_targets_value \"%s\"\n",
4171 arp_all_targets);
4172 arp_all_targets_value = 0;
4173 }
4174 }
4175
1da177e4 4176 if (miimon) {
a4aee5c8 4177 pr_info("MII link monitoring set to %d ms\n", miimon);
1da177e4 4178 } else if (arp_interval) {
a4aee5c8
JP		 4179 pr_info("ARP monitoring set to %d ms, validate %s, with %d target(s):",
4180 arp_interval,
4181 arp_validate_tbl[arp_validate_value].modename,
4182 arp_ip_count);
1da177e4
LT		 4183
4184 for (i = 0; i < arp_ip_count; i++)
e5e2a8fd 4185 pr_info(" %s", arp_ip_target[i]);
1da177e4 4186
e5e2a8fd 4187 pr_info("\n");
1da177e4 4188
b8a9787e 4189 } else if (max_bonds) {
1da177e4
LT		 4190 /* miimon and arp_interval not set, we need one so things
4191 * work as expected, see bonding.txt for details
4192 */
b2730f4f 4193 pr_debug("Warning: either miimon or arp_interval and arp_ip_target module parameters must be specified, otherwise bonding will not detect link failures! see bonding.txt for details.\n");
1da177e4
LT		 4194 }
4195
4196 if (primary && !USES_PRIMARY(bond_mode)) {
4197 /* currently, using a primary only makes sense
4198 * in active backup, TLB or ALB modes
4199 */
a4aee5c8
JP		 4200 pr_warning("Warning: %s primary device specified but has no effect in %s mode\n",
4201 primary, bond_mode_name(bond_mode));
1da177e4
LT		 4202 primary = NULL;
4203 }
4204
a549952a
JP		 4205 if (primary && primary_reselect) {
4206 primary_reselect_value = bond_parse_parm(primary_reselect,
4207 pri_reselect_tbl);
4208 if (primary_reselect_value == -1) {
a4aee5c8 4209 pr_err("Error: Invalid primary_reselect \"%s\"\n",
a549952a
JP		 4210 primary_reselect ==
4211 NULL ? "NULL" : primary_reselect);
4212 return -EINVAL;
4213 }
4214 } else {
4215 primary_reselect_value = BOND_PRI_RESELECT_ALWAYS;
4216 }
4217
3915c1e8
JV		 4218 if (fail_over_mac) {
4219 fail_over_mac_value = bond_parse_parm(fail_over_mac,
4220 fail_over_mac_tbl);
4221 if (fail_over_mac_value == -1) {
a4aee5c8 4222 pr_err("Error: invalid fail_over_mac \"%s\"\n",
3915c1e8
JV		 4223 arp_validate == NULL ? "NULL" : arp_validate);
4224 return -EINVAL;
4225 }
4226
4227 if (bond_mode != BOND_MODE_ACTIVEBACKUP)
a4aee5c8 4228 pr_warning("Warning: fail_over_mac only affects active-backup mode.\n");
3915c1e8
JV		 4229 } else {
4230 fail_over_mac_value = BOND_FOM_NONE;
4231 }
dd957c57 4232
1da177e4
LT		 4233 /* fill params struct with the proper values */
4234 params->mode = bond_mode;
169a3e66 4235 params->xmit_policy = xmit_hashtype;
1da177e4 4236 params->miimon = miimon;
ad246c99 4237 params->num_peer_notif = num_peer_notif;
1da177e4 4238 params->arp_interval = arp_interval;
f5b2b966 4239 params->arp_validate = arp_validate_value;
8599b52e 4240 params->arp_all_targets = arp_all_targets_value;
1da177e4
LT		 4241 params->updelay = updelay;
4242 params->downdelay = downdelay;
4243 params->use_carrier = use_carrier;
4244 params->lacp_fast = lacp_fast;
4245 params->primary[0] = 0;
a549952a 4246 params->primary_reselect = primary_reselect_value;
3915c1e8 4247 params->fail_over_mac = fail_over_mac_value;
bb1d9123 4248 params->tx_queues = tx_queues;
ebd8e497 4249 params->all_slaves_active = all_slaves_active;
c2952c31 4250 params->resend_igmp = resend_igmp;
655f8919 4251 params->min_links = min_links;
7eacd038 4252 params->lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL;
1da177e4
LT		 4253
4254 if (primary) {
4255 strncpy(params->primary, primary, IFNAMSIZ);
4256 params->primary[IFNAMSIZ - 1] = 0;
4257 }
4258
4259 memcpy(params->arp_targets, arp_target, sizeof(arp_target));
4260
4261 return 0;
4262}
4263
0daa2303 4264static struct lock_class_key bonding_netdev_xmit_lock_key;
cf508b12 4265static struct lock_class_key bonding_netdev_addr_lock_key;
49ee4920 4266static struct lock_class_key bonding_tx_busylock_key;
0daa2303 4267
e8a0464c
DM		 4268static void bond_set_lockdep_class_one(struct net_device *dev,
4269 struct netdev_queue *txq,
4270 void *_unused)
c773e847
DM		 4271{
4272 lockdep_set_class(&txq->_xmit_lock,
4273 &bonding_netdev_xmit_lock_key);
4274}
4275
4276static void bond_set_lockdep_class(struct net_device *dev)
4277{
cf508b12
DM		 4278 lockdep_set_class(&dev->addr_list_lock,
4279 &bonding_netdev_addr_lock_key);
e8a0464c 4280 netdev_for_each_tx_queue(dev, bond_set_lockdep_class_one, NULL);
49ee4920 4281 dev->qdisc_tx_busylock = &bonding_tx_busylock_key;
c773e847
DM		 4282}
4283
181470fc
SH		 4284/*
4285 * Called from registration process
4286 */
4287static int bond_init(struct net_device *bond_dev)
4288{
4289 struct bonding *bond = netdev_priv(bond_dev);
ec87fd3b 4290 struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
9fe0617d 4291 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
181470fc
SH		 4292
4293 pr_debug("Begin bond_init for %s\n", bond_dev->name);
4294
9fe0617d
NH		 4295 /*
4296 * Initialize locks that may be required during
4297 * en/deslave operations. All of the bond_open work
4298 * (of which this is part) should really be moved to
4299 * a phase prior to dev_open
4300 */
4301 spin_lock_init(&(bond_info->tx_hashtbl_lock));
4302 spin_lock_init(&(bond_info->rx_hashtbl_lock));
4303
181470fc
SH		 4304 bond->wq = create_singlethread_workqueue(bond_dev->name);
4305 if (!bond->wq)
4306 return -ENOMEM;
4307
4308 bond_set_lockdep_class(bond_dev);
4309
ec87fd3b 4310 list_add_tail(&bond->bond_list, &bn->dev_list);
181470fc 4311
6151b3d4 4312 bond_prepare_sysfs_group(bond);
22bedad3 4313
f073c7ca
TI		 4314 bond_debug_register(bond);
4315
409cc1f8
JP		 4316 /* Ensure valid dev_addr */
4317 if (is_zero_ether_addr(bond_dev->dev_addr) &&
97a1e639 4318 bond_dev->addr_assign_type == NET_ADDR_PERM)
409cc1f8 4319 eth_hw_addr_random(bond_dev);
409cc1f8 4320
181470fc
SH		 4321 return 0;
4322}
4323
0a2a78c4 4324unsigned int bond_get_num_tx_queues(void)
d5da4510 4325{
efacb309 4326 return tx_queues;
d5da4510
JP		 4327}
4328
dfe60397 4329/* Create a new bond based on the specified name and bonding parameters.
e4b91c48 4330 * If name is NULL, obtain a suitable "bond%d" name for us.
dfe60397
MW		 4331 * Caller must NOT hold rtnl_lock; we need to release it here before we
4332 * set up our sysfs entries.
4333 */
ec87fd3b 4334int bond_create(struct net *net, const char *name)
dfe60397
MW		 4335{
4336 struct net_device *bond_dev;
4337 int res;
4338
4339 rtnl_lock();
027ea041 4340
1c5cae81
JP		 4341 bond_dev = alloc_netdev_mq(sizeof(struct bonding),
4342 name ? name : "bond%d",
4343 bond_setup, tx_queues);
dfe60397 4344 if (!bond_dev) {
a4aee5c8 4345 pr_err("%s: eek! can't alloc netdev!\n", name);
9e2e61fb
AW		 4346 rtnl_unlock();
4347 return -ENOMEM;
dfe60397
MW		 4348 }
4349
ec87fd3b 4350 dev_net_set(bond_dev, net);
88ead977
EB		 4351 bond_dev->rtnl_link_ops = &bond_link_ops;
4352
dfe60397 4353 res = register_netdevice(bond_dev);
0daa2303 4354
e826eafa
PO		 4355 netif_carrier_off(bond_dev);
4356
7e083840 4357 rtnl_unlock();
9e2e61fb
AW		 4358 if (res < 0)
4359 bond_destructor(bond_dev);
30c15ba9 4360 return res;
dfe60397
MW		 4361}
4362
2c8c1e72 4363static int __net_init bond_net_init(struct net *net)
ec87fd3b 4364{
15449745 4365 struct bond_net *bn = net_generic(net, bond_net_id);
ec87fd3b
EB		 4366
4367 bn->net = net;
4368 INIT_LIST_HEAD(&bn->dev_list);
4369
ec87fd3b 4370 bond_create_proc_dir(bn);
4c22400a 4371 bond_create_sysfs(bn);
87a7b84b 4372
15449745 4373 return 0;
ec87fd3b
EB		 4374}
4375
2c8c1e72 4376static void __net_exit bond_net_exit(struct net *net)
ec87fd3b 4377{
15449745 4378 struct bond_net *bn = net_generic(net, bond_net_id);
69b0216a 4379 struct bonding *bond, *tmp_bond;
4380 LIST_HEAD(list);
ec87fd3b 4381
4c22400a 4382 bond_destroy_sysfs(bn);
ec87fd3b 4383 bond_destroy_proc_dir(bn);
69b0216a 4384
4385 /* Kill off any bonds created after unregistering bond rtnl ops */
4386 rtnl_lock();
4387 list_for_each_entry_safe(bond, tmp_bond, &bn->dev_list, bond_list)
4388 unregister_netdevice_queue(bond->dev, &list);
4389 unregister_netdevice_many(&list);
4390 rtnl_unlock();
ec87fd3b
EB		 4391}
4392
4393static struct pernet_operations bond_net_ops = {
4394 .init = bond_net_init,
4395 .exit = bond_net_exit,
15449745
EB		 4396 .id = &bond_net_id,
4397 .size = sizeof(struct bond_net),
ec87fd3b
EB		 4398};
4399
1da177e4
LT		 4400static int __init bonding_init(void)
4401{
1da177e4
LT		 4402 int i;
4403 int res;
4404
bd33acc3 4405 pr_info("%s", bond_version);
1da177e4 4406
dfe60397 4407 res = bond_check_params(&bonding_defaults);
3d632c3f 4408 if (res)
dfe60397 4409 goto out;
1da177e4 4410
15449745 4411 res = register_pernet_subsys(&bond_net_ops);
ec87fd3b
EB		 4412 if (res)
4413 goto out;
027ea041 4414
0a2a78c4 4415 res = bond_netlink_init();
88ead977 4416 if (res)
6639104b 4417 goto err_link;
88ead977 4418
f073c7ca
TI		 4419 bond_create_debugfs();
4420
1da177e4 4421 for (i = 0; i < max_bonds; i++) {
ec87fd3b 4422 res = bond_create(&init_net, NULL);
dfe60397
MW		 4423 if (res)
4424 goto err;
1da177e4
LT		 4425 }
4426
1da177e4 4427 register_netdevice_notifier(&bond_netdev_notifier);
dfe60397 4428out:
1da177e4 4429 return res;
88ead977 4430err:
0a2a78c4 4431 bond_netlink_fini();
6639104b 4432err_link:
15449745 4433 unregister_pernet_subsys(&bond_net_ops);
88ead977 4434 goto out;
dfe60397 4435
1da177e4
LT		 4436}
4437
4438static void __exit bonding_exit(void)
4439{
4440 unregister_netdevice_notifier(&bond_netdev_notifier);
4441
f073c7ca 4442 bond_destroy_debugfs();
ae68c398 4443
0a2a78c4 4444 bond_netlink_fini();
ffcdedb6 4445 unregister_pernet_subsys(&bond_net_ops);
e843fa50
NH		 4446
4447#ifdef CONFIG_NET_POLL_CONTROLLER
fb4fa76a
NH		 4448 /*
4449 * Make sure we don't have an imbalance on our netpoll blocking
4450 */
4451 WARN_ON(atomic_read(&netpoll_block_tx));
e843fa50 4452#endif
1da177e4
LT		 4453}
4454
4455module_init(bonding_init);
4456module_exit(bonding_exit);
4457MODULE_LICENSE("GPL");
4458MODULE_VERSION(DRV_VERSION);
4459MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION);
4460MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others");
Linux kernel - Deliverables
This page took 1.523234 seconds and 5 git commands to generate.