projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: initialize hashrnd in flow_dissector with net_get_random_once
[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;
1216 rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE);
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;
1225 rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE);
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;
e6d265e8 2121 unsigned long delay;
0b0eef66
JV		 2122
2123 read_lock(&bond->lock);
e6d265e8
JV		 2124
2125 delay = msecs_to_jiffies(bond->params.miimon);
f0c76d61 2126
0965a1f3 2127 if (!bond_has_slaves(bond))
f0c76d61 2128 goto re_arm;
b59f9f74 2129
ad246c99
BH		 2130 should_notify_peers = bond_should_notify_peers(bond);
2131
f0c76d61 2132 if (bond_miimon_inspect(bond)) {
0b0eef66 2133 read_unlock(&bond->lock);
e6d265e8
JV		 2134
2135 /* Race avoidance with bond_close cancel of workqueue */
2136 if (!rtnl_trylock()) {
2137 read_lock(&bond->lock);
2138 delay = 1;
2139 should_notify_peers = false;
2140 goto re_arm;
2141 }
2142
0b0eef66 2143 read_lock(&bond->lock);
f0c76d61
JV		 2144
2145 bond_miimon_commit(bond);
2146
5655662d
JV		 2147 read_unlock(&bond->lock);
2148 rtnl_unlock(); /* might sleep, hold no other locks */
2149 read_lock(&bond->lock);
0b0eef66
JV		 2150 }
2151
f0c76d61 2152re_arm:
e6d265e8
JV		 2153 if (bond->params.miimon)
2154 queue_delayed_work(bond->wq, &bond->mii_work, delay);
2155
0b0eef66 2156 read_unlock(&bond->lock);
ad246c99
BH		 2157
2158 if (should_notify_peers) {
6c8d23f7 2159 if (!rtnl_trylock())
e6d265e8 2160 return;
b7bc2a5b 2161 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
ad246c99
BH		 2162 rtnl_unlock();
2163 }
0b0eef66 2164}
c3ade5ca 2165
50223ce4 2166static bool bond_has_this_ip(struct bonding *bond, __be32 ip)
f5b2b966 2167{
50223ce4
VF		 2168 struct net_device *upper;
2169 struct list_head *iter;
2170 bool ret = false;
f5b2b966 2171
eaddcd76 2172 if (ip == bond_confirm_addr(bond->dev, 0, ip))
50223ce4 2173 return true;
f5b2b966 2174
50223ce4 2175 rcu_read_lock();
2f268f12 2176 netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
50223ce4
VF		 2177 if (ip == bond_confirm_addr(upper, 0, ip)) {
2178 ret = true;
2179 break;
2180 }
f5b2b966 2181 }
50223ce4 2182 rcu_read_unlock();
f5b2b966 2183
50223ce4 2184 return ret;
f5b2b966
JV		 2185}
2186
c3ade5ca
JV		 2187/*
2188 * We go to the (large) trouble of VLAN tagging ARP frames because
2189 * switches in VLAN mode (especially if ports are configured as
2190 * "native" to a VLAN) might not pass non-tagged frames.
2191 */
d3bb52b0 2192static void bond_arp_send(struct net_device *slave_dev, int arp_op, __be32 dest_ip, __be32 src_ip, unsigned short vlan_id)
c3ade5ca
JV		 2193{
2194 struct sk_buff *skb;
2195
acca2674 2196 pr_debug("arp %d on slave %s: dst %pI4 src %pI4 vid %d\n", arp_op,
2197 slave_dev->name, &dest_ip, &src_ip, vlan_id);
3d632c3f 2198
c3ade5ca
JV		 2199 skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip,
2200 NULL, slave_dev->dev_addr, NULL);
2201
2202 if (!skb) {
a4aee5c8 2203 pr_err("ARP packet allocation failed\n");
c3ade5ca
JV		 2204 return;
2205 }
2206 if (vlan_id) {
1fd9b1fc 2207 skb = vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
c3ade5ca 2208 if (!skb) {
a4aee5c8 2209 pr_err("failed to insert VLAN tag\n");
c3ade5ca
JV		 2210 return;
2211 }
2212 }
2213 arp_xmit(skb);
2214}
2215
2216
1da177e4
LT		 2217static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
2218{
27bc11e6
VF		 2219 struct net_device *upper, *vlan_upper;
2220 struct list_head *iter, *vlan_iter;
c3ade5ca 2221 struct rtable *rt;
27bc11e6
VF		 2222 __be32 *targets = bond->params.arp_targets, addr;
2223 int i, vlan_id;
1da177e4 2224
27bc11e6 2225 for (i = 0; i < BOND_MAX_ARP_TARGETS && targets[i]; i++) {
acca2674 2226 pr_debug("basa: target %pI4\n", &targets[i]);
c3ade5ca 2227
27bc11e6 2228 /* Find out through which dev should the packet go */
78fbfd8a
DM		 2229 rt = ip_route_output(dev_net(bond->dev), targets[i], 0,
2230 RTO_ONLINK, 0);
b23dd4fe 2231 if (IS_ERR(rt)) {
3e32582f
VF		 2232 pr_debug("%s: no route to arp_ip_target %pI4\n",
2233 bond->dev->name, &targets[i]);
c3ade5ca
JV		 2234 continue;
2235 }
2236
c3ade5ca 2237 vlan_id = 0;
27bc11e6
VF		 2238
2239 /* bond device itself */
2240 if (rt->dst.dev == bond->dev)
2241 goto found;
2242
2243 rcu_read_lock();
2244 /* first we search only for vlan devices. for every vlan
2245 * found we verify its upper dev list, searching for the
2246 * rt->dst.dev. If found we save the tag of the vlan and
2247 * proceed to send the packet.
2248 *
2249 * TODO: QinQ?
2250 */
2f268f12
VF		 2251 netdev_for_each_all_upper_dev_rcu(bond->dev, vlan_upper,
2252 vlan_iter) {
27bc11e6
VF		 2253 if (!is_vlan_dev(vlan_upper))
2254 continue;
2f268f12
VF		 2255 netdev_for_each_all_upper_dev_rcu(vlan_upper, upper,
2256 iter) {
27bc11e6
VF		 2257 if (upper == rt->dst.dev) {
2258 vlan_id = vlan_dev_vlan_id(vlan_upper);
2259 rcu_read_unlock();
2260 goto found;
2261 }
c3ade5ca
JV		 2262 }
2263 }
2264
27bc11e6
VF		 2265 /* if the device we're looking for is not on top of any of
2266 * our upper vlans, then just search for any dev that
2267 * matches, and in case it's a vlan - save the id
2268 */
2f268f12 2269 netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
27bc11e6
VF		 2270 if (upper == rt->dst.dev) {
2271 /* if it's a vlan - get its VID */
2272 if (is_vlan_dev(upper))
2273 vlan_id = vlan_dev_vlan_id(upper);
2274
2275 rcu_read_unlock();
2276 goto found;
2277 }
c3ade5ca 2278 }
27bc11e6 2279 rcu_read_unlock();
c3ade5ca 2280
27bc11e6 2281 /* Not our device - skip */
3e32582f
VF		 2282 pr_debug("%s: no path to arp_ip_target %pI4 via rt.dev %s\n",
2283 bond->dev->name, &targets[i],
2284 rt->dst.dev ? rt->dst.dev->name : "NULL");
2285
ed4b9f80 2286 ip_rt_put(rt);
27bc11e6
VF		 2287 continue;
2288
2289found:
2290 addr = bond_confirm_addr(rt->dst.dev, targets[i], 0);
2291 ip_rt_put(rt);
2292 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
2293 addr, vlan_id);
c3ade5ca
JV		 2294 }
2295}
2296
d3bb52b0 2297static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip)
f5b2b966 2298{
8599b52e
VF		 2299 int i;
2300
87a7b84b
VF		 2301 if (!sip || !bond_has_this_ip(bond, tip)) {
2302 pr_debug("bva: sip %pI4 tip %pI4 not found\n", &sip, &tip);
2303 return;
2304 }
f5b2b966 2305
8599b52e
VF		 2306 i = bond_get_targets_ip(bond->params.arp_targets, sip);
2307 if (i == -1) {
87a7b84b
VF		 2308 pr_debug("bva: sip %pI4 not found in targets\n", &sip);
2309 return;
f5b2b966 2310 }
87a7b84b 2311 slave->last_arp_rx = jiffies;
8599b52e 2312 slave->target_last_arp_rx[i] = jiffies;
f5b2b966
JV		 2313}
2314
5bb9e0b5 2315int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond,
2316 struct slave *slave)
f5b2b966 2317{
de063b70 2318 struct arphdr *arp = (struct arphdr *)skb->data;
f5b2b966 2319 unsigned char *arp_ptr;
d3bb52b0 2320 __be32 sip, tip;
de063b70 2321 int alen;
f5b2b966 2322
3aba891d 2323 if (skb->protocol != __cpu_to_be16(ETH_P_ARP))
13a8e0c8 2324 return RX_HANDLER_ANOTHER;
f5b2b966 2325
f5b2b966 2326 read_lock(&bond->lock);
2c146102
VF		 2327
2328 if (!slave_do_arp_validate(bond, slave))
2329 goto out_unlock;
2330
de063b70 2331 alen = arp_hdr_len(bond->dev);
f5b2b966 2332
3aba891d
JP		 2333 pr_debug("bond_arp_rcv: bond %s skb->dev %s\n",
2334 bond->dev->name, skb->dev->name);
f5b2b966 2335
de063b70
ED		 2336 if (alen > skb_headlen(skb)) {
2337 arp = kmalloc(alen, GFP_ATOMIC);
2338 if (!arp)
2339 goto out_unlock;
2340 if (skb_copy_bits(skb, 0, arp, alen) < 0)
2341 goto out_unlock;
2342 }
f5b2b966 2343
3aba891d 2344 if (arp->ar_hln != bond->dev->addr_len ||
f5b2b966
JV		 2345 skb->pkt_type == PACKET_OTHERHOST ||
2346 skb->pkt_type == PACKET_LOOPBACK ||
2347 arp->ar_hrd != htons(ARPHRD_ETHER) ||
2348 arp->ar_pro != htons(ETH_P_IP) ||
2349 arp->ar_pln != 4)
2350 goto out_unlock;
2351
2352 arp_ptr = (unsigned char *)(arp + 1);
3aba891d 2353 arp_ptr += bond->dev->addr_len;
f5b2b966 2354 memcpy(&sip, arp_ptr, 4);
3aba891d 2355 arp_ptr += 4 + bond->dev->addr_len;
f5b2b966
JV		 2356 memcpy(&tip, arp_ptr, 4);
2357
5a03cdb7 2358 pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
e30bc066 2359 bond->dev->name, slave->dev->name, bond_slave_state(slave),
a4aee5c8
JP		 2360 bond->params.arp_validate, slave_do_arp_validate(bond, slave),
2361 &sip, &tip);
f5b2b966
JV		 2362
2363 /*
2364 * Backup slaves won't see the ARP reply, but do come through
2365 * here for each ARP probe (so we swap the sip/tip to validate
2366 * the probe). In a "redundant switch, common router" type of
2367 * configuration, the ARP probe will (hopefully) travel from
2368 * the active, through one switch, the router, then the other
2369 * switch before reaching the backup.
aeea64ac
VF		 2370 *
2371 * We 'trust' the arp requests if there is an active slave and
2372 * it received valid arp reply(s) after it became active. This
2373 * is done to avoid endless looping when we can't reach the
2374 * arp_ip_target and fool ourselves with our own arp requests.
f5b2b966 2375 */
e30bc066 2376 if (bond_is_active_slave(slave))
f5b2b966 2377 bond_validate_arp(bond, slave, sip, tip);
aeea64ac
VF		 2378 else if (bond->curr_active_slave &&
2379 time_after(slave_last_rx(bond, bond->curr_active_slave),
2380 bond->curr_active_slave->jiffies))
f5b2b966
JV		 2381 bond_validate_arp(bond, slave, tip, sip);
2382
2383out_unlock:
2384 read_unlock(&bond->lock);
de063b70
ED		 2385 if (arp != (struct arphdr *)skb->data)
2386 kfree(arp);
13a8e0c8 2387 return RX_HANDLER_ANOTHER;
f5b2b966
JV		 2388}
2389
e7f63f1d
VF		 2390/* function to verify if we're in the arp_interval timeslice, returns true if
2391 * (last_act - arp_interval) <= jiffies <= (last_act + mod * arp_interval +
2392 * arp_interval/2) . the arp_interval/2 is needed for really fast networks.
2393 */
2394static bool bond_time_in_interval(struct bonding *bond, unsigned long last_act,
2395 int mod)
2396{
2397 int delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
2398
2399 return time_in_range(jiffies,
2400 last_act - delta_in_ticks,
2401 last_act + mod * delta_in_ticks + delta_in_ticks/2);
2402}
2403
1da177e4
LT		 2404/*
2405 * this function is called regularly to monitor each slave's link
2406 * ensuring that traffic is being sent and received when arp monitoring
2407 * is used in load-balancing mode. if the adapter has been dormant, then an
2408 * arp is transmitted to generate traffic. see activebackup_arp_monitor for
2409 * arp monitoring in active backup mode.
2410 */
1b76b316 2411void bond_loadbalance_arp_mon(struct work_struct *work)
1da177e4 2412{
1b76b316
JV		 2413 struct bonding *bond = container_of(work, struct bonding,
2414 arp_work.work);
1da177e4 2415 struct slave *slave, *oldcurrent;
9caff1e7 2416 struct list_head *iter;
1da177e4 2417 int do_failover = 0;
1da177e4
LT		 2418
2419 read_lock(&bond->lock);
2420
0965a1f3 2421 if (!bond_has_slaves(bond))
1da177e4 2422 goto re_arm;
1da177e4 2423
1da177e4 2424 oldcurrent = bond->curr_active_slave;
1da177e4
LT		 2425 /* see if any of the previous devices are up now (i.e. they have
2426 * xmt and rcv traffic). the curr_active_slave does not come into
2427 * the picture unless it is null. also, slave->jiffies is not needed
2428 * here because we send an arp on each slave and give a slave as
2429 * long as it needs to get the tx/rx within the delta.
2430 * TODO: what about up/down delay in arp mode? it wasn't here before
2431 * so it can wait
2432 */
9caff1e7 2433 bond_for_each_slave(bond, slave, iter) {
cb32f2a0
JB		 2434 unsigned long trans_start = dev_trans_start(slave->dev);
2435
1da177e4 2436 if (slave->link != BOND_LINK_UP) {
e7f63f1d
VF		 2437 if (bond_time_in_interval(bond, trans_start, 1) &&
2438 bond_time_in_interval(bond, slave->dev->last_rx, 1)) {
1da177e4
LT		 2439
2440 slave->link = BOND_LINK_UP;
e30bc066 2441 bond_set_active_slave(slave);
1da177e4
LT		 2442
2443 /* primary_slave has no meaning in round-robin
2444 * mode. the window of a slave being up and
2445 * curr_active_slave being null after enslaving
2446 * is closed.
2447 */
2448 if (!oldcurrent) {
a4aee5c8
JP		 2449 pr_info("%s: link status definitely up for interface %s, ",
2450 bond->dev->name,
2451 slave->dev->name);
1da177e4
LT		 2452 do_failover = 1;
2453 } else {
a4aee5c8
JP		 2454 pr_info("%s: interface %s is now up\n",
2455 bond->dev->name,
2456 slave->dev->name);
1da177e4
LT		 2457 }
2458 }
2459 } else {
2460 /* slave->link == BOND_LINK_UP */
2461
2462 /* not all switches will respond to an arp request
2463 * when the source ip is 0, so don't take the link down
2464 * if we don't know our ip yet
2465 */
e7f63f1d
VF		 2466 if (!bond_time_in_interval(bond, trans_start, 2) ||
2467 !bond_time_in_interval(bond, slave->dev->last_rx, 2)) {
1da177e4
LT		 2468
2469 slave->link = BOND_LINK_DOWN;
e30bc066 2470 bond_set_backup_slave(slave);
1da177e4 2471
3d632c3f 2472 if (slave->link_failure_count < UINT_MAX)
1da177e4 2473 slave->link_failure_count++;
1da177e4 2474
a4aee5c8
JP		 2475 pr_info("%s: interface %s is now down.\n",
2476 bond->dev->name,
2477 slave->dev->name);
1da177e4 2478
3d632c3f 2479 if (slave == oldcurrent)
1da177e4 2480 do_failover = 1;
1da177e4
LT		 2481 }
2482 }
2483
2484 /* note: if switch is in round-robin mode, all links
2485 * must tx arp to ensure all links rx an arp - otherwise
2486 * links may oscillate or not come up at all; if switch is
2487 * in something like xor mode, there is nothing we can
2488 * do - all replies will be rx'ed on same link causing slaves
2489 * to be unstable during low/no traffic periods
2490 */
3d632c3f 2491 if (IS_UP(slave->dev))
1da177e4 2492 bond_arp_send_all(bond, slave);
1da177e4
LT		 2493 }
2494
2495 if (do_failover) {
e843fa50 2496 block_netpoll_tx();
059fe7a5 2497 write_lock_bh(&bond->curr_slave_lock);
1da177e4
LT		 2498
2499 bond_select_active_slave(bond);
2500
059fe7a5 2501 write_unlock_bh(&bond->curr_slave_lock);
e843fa50 2502 unblock_netpoll_tx();
1da177e4
LT		 2503 }
2504
2505re_arm:
e6d265e8 2506 if (bond->params.arp_interval)
e7f63f1d
VF		 2507 queue_delayed_work(bond->wq, &bond->arp_work,
2508 msecs_to_jiffies(bond->params.arp_interval));
e6d265e8 2509
1da177e4
LT		 2510 read_unlock(&bond->lock);
2511}
2512
2513/*
b2220cad
JV		 2514 * Called to inspect slaves for active-backup mode ARP monitor link state
2515 * changes. Sets new_link in slaves to specify what action should take
2516 * place for the slave. Returns 0 if no changes are found, >0 if changes
2517 * to link states must be committed.
2518 *
2519 * Called with bond->lock held for read.
1da177e4 2520 */
e7f63f1d 2521static int bond_ab_arp_inspect(struct bonding *bond)
1da177e4 2522{
def4460c 2523 unsigned long trans_start, last_rx;
9caff1e7 2524 struct list_head *iter;
dec1e90e 2525 struct slave *slave;
dec1e90e 2526 int commit = 0;
da210f55 2527
9caff1e7 2528 bond_for_each_slave(bond, slave, iter) {
b2220cad 2529 slave->new_link = BOND_LINK_NOCHANGE;
def4460c 2530 last_rx = slave_last_rx(bond, slave);
1da177e4 2531
b2220cad 2532 if (slave->link != BOND_LINK_UP) {
e7f63f1d 2533 if (bond_time_in_interval(bond, last_rx, 1)) {
b2220cad
JV		 2534 slave->new_link = BOND_LINK_UP;
2535 commit++;
2536 }
b2220cad
JV		 2537 continue;
2538 }
1da177e4 2539
b2220cad
JV		 2540 /*
2541 * Give slaves 2*delta after being enslaved or made
2542 * active. This avoids bouncing, as the last receive
2543 * times need a full ARP monitor cycle to be updated.
2544 */
e7f63f1d 2545 if (bond_time_in_interval(bond, slave->jiffies, 2))
b2220cad
JV		 2546 continue;
2547
2548 /*
2549 * Backup slave is down if:
2550 * - No current_arp_slave AND
2551 * - more than 3*delta since last receive AND
2552 * - the bond has an IP address
2553 *
2554 * Note: a non-null current_arp_slave indicates
2555 * the curr_active_slave went down and we are
2556 * searching for a new one; under this condition
2557 * we only take the curr_active_slave down - this
2558 * gives each slave a chance to tx/rx traffic
2559 * before being taken out
2560 */
e30bc066 2561 if (!bond_is_active_slave(slave) &&
b2220cad 2562 !bond->current_arp_slave &&
e7f63f1d 2563 !bond_time_in_interval(bond, last_rx, 3)) {
b2220cad
JV		 2564 slave->new_link = BOND_LINK_DOWN;
2565 commit++;
2566 }
2567
2568 /*
2569 * Active slave is down if:
2570 * - more than 2*delta since transmitting OR
2571 * - (more than 2*delta since receive AND
2572 * the bond has an IP address)
2573 */
cb32f2a0 2574 trans_start = dev_trans_start(slave->dev);
e30bc066 2575 if (bond_is_active_slave(slave) &&
e7f63f1d
VF		 2576 (!bond_time_in_interval(bond, trans_start, 2) ||
2577 !bond_time_in_interval(bond, last_rx, 2))) {
b2220cad
JV		 2578 slave->new_link = BOND_LINK_DOWN;
2579 commit++;
2580 }
1da177e4
LT		 2581 }
2582
b2220cad
JV		 2583 return commit;
2584}
1da177e4 2585
b2220cad
JV		 2586/*
2587 * Called to commit link state changes noted by inspection step of
2588 * active-backup mode ARP monitor.
2589 *
2590 * Called with RTNL and bond->lock for read.
2591 */
e7f63f1d 2592static void bond_ab_arp_commit(struct bonding *bond)
b2220cad 2593{
cb32f2a0 2594 unsigned long trans_start;
9caff1e7 2595 struct list_head *iter;
dec1e90e 2596 struct slave *slave;
1da177e4 2597
9caff1e7 2598 bond_for_each_slave(bond, slave, iter) {
b2220cad
JV		 2599 switch (slave->new_link) {
2600 case BOND_LINK_NOCHANGE:
2601 continue;
ff59c456 2602
b2220cad 2603 case BOND_LINK_UP:
cb32f2a0 2604 trans_start = dev_trans_start(slave->dev);
e7f63f1d
VF		 2605 if (bond->curr_active_slave != slave ||
2606 (!bond->curr_active_slave &&
2607 bond_time_in_interval(bond, trans_start, 1))) {
b2220cad 2608 slave->link = BOND_LINK_UP;
5a430974
VF		 2609 if (bond->current_arp_slave) {
2610 bond_set_slave_inactive_flags(
2611 bond->current_arp_slave);
2612 bond->current_arp_slave = NULL;
2613 }
b2220cad 2614
a4aee5c8 2615 pr_info("%s: link status definitely up for interface %s.\n",
b9f60253 2616 bond->dev->name, slave->dev->name);
b2220cad 2617
b9f60253
JP		 2618 if (!bond->curr_active_slave ||
2619 (slave == bond->primary_slave))
2620 goto do_failover;
1da177e4 2621
b9f60253 2622 }
1da177e4 2623
b9f60253 2624 continue;
1da177e4 2625
b2220cad
JV		 2626 case BOND_LINK_DOWN:
2627 if (slave->link_failure_count < UINT_MAX)
2628 slave->link_failure_count++;
2629
2630 slave->link = BOND_LINK_DOWN;
b9f60253 2631 bond_set_slave_inactive_flags(slave);
b2220cad 2632
a4aee5c8 2633 pr_info("%s: link status definitely down for interface %s, disabling it\n",
b9f60253 2634 bond->dev->name, slave->dev->name);
b2220cad 2635
b9f60253 2636 if (slave == bond->curr_active_slave) {
b2220cad 2637 bond->current_arp_slave = NULL;
b9f60253 2638 goto do_failover;
1da177e4 2639 }
b9f60253
JP		 2640
2641 continue;
b2220cad
JV		 2642
2643 default:
a4aee5c8 2644 pr_err("%s: impossible: new_link %d on slave %s\n",
b2220cad
JV		 2645 bond->dev->name, slave->new_link,
2646 slave->dev->name);
b9f60253 2647 continue;
1da177e4 2648 }
1da177e4 2649
b9f60253
JP		 2650do_failover:
2651 ASSERT_RTNL();
e843fa50 2652 block_netpoll_tx();
b2220cad 2653 write_lock_bh(&bond->curr_slave_lock);
b9f60253 2654 bond_select_active_slave(bond);
b2220cad 2655 write_unlock_bh(&bond->curr_slave_lock);
e843fa50 2656 unblock_netpoll_tx();
b2220cad 2657 }
1da177e4 2658
b2220cad
JV		 2659 bond_set_carrier(bond);
2660}
1da177e4 2661
b2220cad
JV		 2662/*
2663 * Send ARP probes for active-backup mode ARP monitor.
2664 *
2665 * Called with bond->lock held for read.
2666 */
2667static void bond_ab_arp_probe(struct bonding *bond)
2668{
4087df87
VF		 2669 struct slave *slave, *before = NULL, *new_slave = NULL;
2670 struct list_head *iter;
2671 bool found = false;
1da177e4 2672
b2220cad 2673 read_lock(&bond->curr_slave_lock);
1da177e4 2674
b2220cad 2675 if (bond->current_arp_slave && bond->curr_active_slave)
a4aee5c8
JP		 2676 pr_info("PROBE: c_arp %s && cas %s BAD\n",
2677 bond->current_arp_slave->dev->name,
2678 bond->curr_active_slave->dev->name);
1da177e4 2679
b2220cad
JV		 2680 if (bond->curr_active_slave) {
2681 bond_arp_send_all(bond, bond->curr_active_slave);
2682 read_unlock(&bond->curr_slave_lock);
2683 return;
2684 }
1da177e4 2685
b2220cad 2686 read_unlock(&bond->curr_slave_lock);
059fe7a5 2687
b2220cad
JV		 2688 /* if we don't have a curr_active_slave, search for the next available
2689 * backup slave from the current_arp_slave and make it the candidate
2690 * for becoming the curr_active_slave
2691 */
1da177e4 2692
b2220cad 2693 if (!bond->current_arp_slave) {
dec1e90e 2694 bond->current_arp_slave = bond_first_slave(bond);
b2220cad
JV		 2695 if (!bond->current_arp_slave)
2696 return;
2697 }
1da177e4 2698
b2220cad 2699 bond_set_slave_inactive_flags(bond->current_arp_slave);
059fe7a5 2700
4087df87
VF		 2701 bond_for_each_slave(bond, slave, iter) {
2702 if (!found && !before && IS_UP(slave->dev))
2703 before = slave;
1da177e4 2704
4087df87
VF		 2705 if (found && !new_slave && IS_UP(slave->dev))
2706 new_slave = slave;
b2220cad
JV		 2707 /* if the link state is up at this point, we
2708 * mark it down - this can happen if we have
2709 * simultaneous link failures and
2710 * reselect_active_interface doesn't make this
2711 * one the current slave so it is still marked
2712 * up when it is actually down
1da177e4 2713 */
4087df87 2714 if (!IS_UP(slave->dev) && slave->link == BOND_LINK_UP) {
b2220cad
JV		 2715 slave->link = BOND_LINK_DOWN;
2716 if (slave->link_failure_count < UINT_MAX)
2717 slave->link_failure_count++;
1da177e4 2718
b2220cad
JV		 2719 bond_set_slave_inactive_flags(slave);
2720
a4aee5c8
JP		 2721 pr_info("%s: backup interface %s is now down.\n",
2722 bond->dev->name, slave->dev->name);
1da177e4 2723 }
4087df87
VF		 2724 if (slave == bond->current_arp_slave)
2725 found = true;
b2220cad 2726 }
4087df87
VF		 2727
2728 if (!new_slave && before)
2729 new_slave = before;
2730
2731 if (!new_slave)
2732 return;
2733
2734 new_slave->link = BOND_LINK_BACK;
2735 bond_set_slave_active_flags(new_slave);
2736 bond_arp_send_all(bond, new_slave);
2737 new_slave->jiffies = jiffies;
2738 bond->current_arp_slave = new_slave;
2739
b2220cad 2740}
1da177e4 2741
b2220cad
JV		 2742void bond_activebackup_arp_mon(struct work_struct *work)
2743{
2744 struct bonding *bond = container_of(work, struct bonding,
2745 arp_work.work);
ad246c99 2746 bool should_notify_peers = false;
b2220cad 2747 int delta_in_ticks;
1da177e4 2748
b2220cad 2749 read_lock(&bond->lock);
1da177e4 2750
b2220cad 2751 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
1da177e4 2752
0965a1f3 2753 if (!bond_has_slaves(bond))
b2220cad
JV		 2754 goto re_arm;
2755
ad246c99
BH		 2756 should_notify_peers = bond_should_notify_peers(bond);
2757
e7f63f1d 2758 if (bond_ab_arp_inspect(bond)) {
b2220cad 2759 read_unlock(&bond->lock);
e6d265e8
JV		 2760
2761 /* Race avoidance with bond_close flush of workqueue */
2762 if (!rtnl_trylock()) {
2763 read_lock(&bond->lock);
2764 delta_in_ticks = 1;
2765 should_notify_peers = false;
2766 goto re_arm;
2767 }
2768
b2220cad
JV		 2769 read_lock(&bond->lock);
2770
e7f63f1d 2771 bond_ab_arp_commit(bond);
b2220cad
JV		 2772
2773 read_unlock(&bond->lock);
2774 rtnl_unlock();
2775 read_lock(&bond->lock);
1da177e4
LT		 2776 }
2777
b2220cad
JV		 2778 bond_ab_arp_probe(bond);
2779
1da177e4 2780re_arm:
e6d265e8 2781 if (bond->params.arp_interval)
1b76b316 2782 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
e6d265e8 2783
1da177e4 2784 read_unlock(&bond->lock);
ad246c99
BH		 2785
2786 if (should_notify_peers) {
6c8d23f7 2787 if (!rtnl_trylock())
e6d265e8 2788 return;
b7bc2a5b 2789 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
ad246c99
BH		 2790 rtnl_unlock();
2791 }
1da177e4
LT		 2792}
2793
1da177e4
LT		 2794/*-------------------------- netdev event handling --------------------------*/
2795
2796/*
2797 * Change device name
2798 */
2799static int bond_event_changename(struct bonding *bond)
2800{
1da177e4
LT		 2801 bond_remove_proc_entry(bond);
2802 bond_create_proc_entry(bond);
7e083840 2803
f073c7ca
TI		 2804 bond_debug_reregister(bond);
2805
1da177e4
LT		 2806 return NOTIFY_DONE;
2807}
2808
3d632c3f
SH		 2809static int bond_master_netdev_event(unsigned long event,
2810 struct net_device *bond_dev)
1da177e4 2811{
454d7c9b 2812 struct bonding *event_bond = netdev_priv(bond_dev);
1da177e4
LT		 2813
2814 switch (event) {
2815 case NETDEV_CHANGENAME:
2816 return bond_event_changename(event_bond);
a64d49c3
EB		 2817 case NETDEV_UNREGISTER:
2818 bond_remove_proc_entry(event_bond);
2819 break;
2820 case NETDEV_REGISTER:
2821 bond_create_proc_entry(event_bond);
2822 break;
6c8d23f7 2823 case NETDEV_NOTIFY_PEERS:
2824 if (event_bond->send_peer_notif)
2825 event_bond->send_peer_notif--;
2826 break;
1da177e4
LT		 2827 default:
2828 break;
2829 }
2830
2831 return NOTIFY_DONE;
2832}
2833
3d632c3f
SH		 2834static int bond_slave_netdev_event(unsigned long event,
2835 struct net_device *slave_dev)
1da177e4 2836{
471cb5a3 2837 struct slave *slave = bond_slave_get_rtnl(slave_dev);
6101391d 2838 struct bonding *bond;
2839 struct net_device *bond_dev;
471cb5a3
JP		 2840 u32 old_speed;
2841 u8 old_duplex;
1da177e4 2842
6101391d 2843 /* A netdev event can be generated while enslaving a device
2844 * before netdev_rx_handler_register is called in which case
2845 * slave will be NULL
2846 */
2847 if (!slave)
2848 return NOTIFY_DONE;
2849 bond_dev = slave->bond->dev;
2850 bond = slave->bond;
2851
1da177e4
LT		 2852 switch (event) {
2853 case NETDEV_UNREGISTER:
8d2ada77 2854 if (bond_dev->type != ARPHRD_ETHER)
471cb5a3
JP		 2855 bond_release_and_destroy(bond_dev, slave_dev);
2856 else
2857 bond_release(bond_dev, slave_dev);
1da177e4 2858 break;
98f41f69 2859 case NETDEV_UP:
1da177e4 2860 case NETDEV_CHANGE:
471cb5a3
JP		 2861 old_speed = slave->speed;
2862 old_duplex = slave->duplex;
17d04500 2863
471cb5a3 2864 bond_update_speed_duplex(slave);
17d04500 2865
471cb5a3
JP		 2866 if (bond->params.mode == BOND_MODE_8023AD) {
2867 if (old_speed != slave->speed)
2868 bond_3ad_adapter_speed_changed(slave);
2869 if (old_duplex != slave->duplex)
2870 bond_3ad_adapter_duplex_changed(slave);
17d04500 2871 }
1da177e4
LT		 2872 break;
2873 case NETDEV_DOWN:
2874 /*
2875 * ... Or is it this?
2876 */
2877 break;
2878 case NETDEV_CHANGEMTU:
2879 /*
2880 * TODO: Should slaves be allowed to
2881 * independently alter their MTU? For
2882 * an active-backup bond, slaves need
2883 * not be the same type of device, so
2884 * MTUs may vary. For other modes,
2885 * slaves arguably should have the
2886 * same MTUs. To do this, we'd need to
2887 * take over the slave's change_mtu
2888 * function for the duration of their
2889 * servitude.
2890 */
2891 break;
2892 case NETDEV_CHANGENAME:
2893 /*
2894 * TODO: handle changing the primary's name
2895 */
2896 break;
8531c5ff
AK		 2897 case NETDEV_FEAT_CHANGE:
2898 bond_compute_features(bond);
2899 break;
4aa5dee4
JP		 2900 case NETDEV_RESEND_IGMP:
2901 /* Propagate to master device */
2902 call_netdevice_notifiers(event, slave->bond->dev);
2903 break;
1da177e4
LT		 2904 default:
2905 break;
2906 }
2907
2908 return NOTIFY_DONE;
2909}
2910
2911/*
2912 * bond_netdev_event: handle netdev notifier chain events.
2913 *
2914 * This function receives events for the netdev chain. The caller (an
e041c683 2915 * ioctl handler calling blocking_notifier_call_chain) holds the necessary
1da177e4
LT		 2916 * locks for us to safely manipulate the slave devices (RTNL lock,
2917 * dev_probe_lock).
2918 */
3d632c3f
SH		 2919static int bond_netdev_event(struct notifier_block *this,
2920 unsigned long event, void *ptr)
1da177e4 2921{
351638e7 2922 struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
1da177e4 2923
5a03cdb7 2924 pr_debug("event_dev: %s, event: %lx\n",
a4aee5c8
JP		 2925 event_dev ? event_dev->name : "None",
2926 event);
1da177e4 2927
0b680e75
JV		 2928 if (!(event_dev->priv_flags & IFF_BONDING))
2929 return NOTIFY_DONE;
2930
1da177e4 2931 if (event_dev->flags & IFF_MASTER) {
5a03cdb7 2932 pr_debug("IFF_MASTER\n");
1da177e4
LT		 2933 return bond_master_netdev_event(event, event_dev);
2934 }
2935
2936 if (event_dev->flags & IFF_SLAVE) {
5a03cdb7 2937 pr_debug("IFF_SLAVE\n");
1da177e4
LT		 2938 return bond_slave_netdev_event(event, event_dev);
2939 }
2940
2941 return NOTIFY_DONE;
2942}
2943
2944static struct notifier_block bond_netdev_notifier = {
2945 .notifier_call = bond_netdev_event,
2946};
2947
169a3e66
JV		 2948/*---------------------------- Hashing Policies -----------------------------*/
2949
32819dc1
NA		 2950/* L2 hash helper */
2951static inline u32 bond_eth_hash(struct sk_buff *skb)
6b923cb7
JE		 2952{
2953 struct ethhdr *data = (struct ethhdr *)skb->data;
2954
2955 if (skb_headlen(skb) >= offsetof(struct ethhdr, h_proto))
32819dc1 2956 return data->h_dest[5] ^ data->h_source[5];
6b923cb7
JE		 2957
2958 return 0;
2959}
2960
32819dc1
NA		 2961/* Extract the appropriate headers based on bond's xmit policy */
2962static bool bond_flow_dissect(struct bonding *bond, struct sk_buff *skb,
2963 struct flow_keys *fk)
6f6652be 2964{
32819dc1 2965 const struct ipv6hdr *iph6;
4394542c 2966 const struct iphdr *iph;
32819dc1 2967 int noff, proto = -1;
6b923cb7 2968
32819dc1
NA		 2969 if (bond->params.xmit_policy > BOND_XMIT_POLICY_LAYER23)
2970 return skb_flow_dissect(skb, fk);
2971
2972 fk->ports = 0;
2973 noff = skb_network_offset(skb);
2974 if (skb->protocol == htons(ETH_P_IP)) {
2975 if (!pskb_may_pull(skb, noff + sizeof(*iph)))
2976 return false;
6b923cb7 2977 iph = ip_hdr(skb);
32819dc1
NA		 2978 fk->src = iph->saddr;
2979 fk->dst = iph->daddr;
2980 noff += iph->ihl << 2;
2981 if (!ip_is_fragment(iph))
2982 proto = iph->protocol;
2983 } else if (skb->protocol == htons(ETH_P_IPV6)) {
2984 if (!pskb_may_pull(skb, noff + sizeof(*iph6)))
2985 return false;
2986 iph6 = ipv6_hdr(skb);
2987 fk->src = (__force __be32)ipv6_addr_hash(&iph6->saddr);
2988 fk->dst = (__force __be32)ipv6_addr_hash(&iph6->daddr);
2989 noff += sizeof(*iph6);
2990 proto = iph6->nexthdr;
2991 } else {
2992 return false;
6f6652be 2993 }
32819dc1
NA		 2994 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34 && proto >= 0)
2995 fk->ports = skb_flow_get_ports(skb, noff, proto);
6f6652be 2996
32819dc1 2997 return true;
6f6652be
JV		 2998}
2999
32819dc1
NA		 3000/**
3001 * bond_xmit_hash - generate a hash value based on the xmit policy
3002 * @bond: bonding device
3003 * @skb: buffer to use for headers
3004 * @count: modulo value
3005 *
3006 * This function will extract the necessary headers from the skb buffer and use
3007 * them to generate a hash based on the xmit_policy set in the bonding device
3008 * which will be reduced modulo count before returning.
169a3e66 3009 */
32819dc1 3010int bond_xmit_hash(struct bonding *bond, struct sk_buff *skb, int count)
169a3e66 3011{
32819dc1
NA		 3012 struct flow_keys flow;
3013 u32 hash;
4394542c 3014
32819dc1
NA		 3015 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER2 ||
3016 !bond_flow_dissect(bond, skb, &flow))
3017 return bond_eth_hash(skb) % count;
169a3e66 3018
32819dc1
NA		 3019 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER23 ||
3020 bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP23)
3021 hash = bond_eth_hash(skb);
3022 else
3023 hash = (__force u32)flow.ports;
3024 hash ^= (__force u32)flow.dst ^ (__force u32)flow.src;
3025 hash ^= (hash >> 16);
3026 hash ^= (hash >> 8);
3027
3028 return hash % count;
169a3e66
JV		 3029}
3030
1da177e4
LT		 3031/*-------------------------- Device entry points ----------------------------*/
3032
fbb0c41b 3033static void bond_work_init_all(struct bonding *bond)
3034{
3035 INIT_DELAYED_WORK(&bond->mcast_work,
3036 bond_resend_igmp_join_requests_delayed);
3037 INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
3038 INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor);
3039 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
3040 INIT_DELAYED_WORK(&bond->arp_work, bond_activebackup_arp_mon);
3041 else
3042 INIT_DELAYED_WORK(&bond->arp_work, bond_loadbalance_arp_mon);
3043 INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
3044}
3045
3046static void bond_work_cancel_all(struct bonding *bond)
3047{
3048 cancel_delayed_work_sync(&bond->mii_work);
3049 cancel_delayed_work_sync(&bond->arp_work);
3050 cancel_delayed_work_sync(&bond->alb_work);
3051 cancel_delayed_work_sync(&bond->ad_work);
3052 cancel_delayed_work_sync(&bond->mcast_work);
3053}
3054
1da177e4
LT		 3055static int bond_open(struct net_device *bond_dev)
3056{
454d7c9b 3057 struct bonding *bond = netdev_priv(bond_dev);
9caff1e7 3058 struct list_head *iter;
ba3211cc 3059 struct slave *slave;
1da177e4 3060
ba3211cc
PP		 3061 /* reset slave->backup and slave->inactive */
3062 read_lock(&bond->lock);
0965a1f3 3063 if (bond_has_slaves(bond)) {
ba3211cc 3064 read_lock(&bond->curr_slave_lock);
9caff1e7 3065 bond_for_each_slave(bond, slave, iter) {
ba3211cc
PP		 3066 if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
3067 && (slave != bond->curr_active_slave)) {
3068 bond_set_slave_inactive_flags(slave);
3069 } else {
3070 bond_set_slave_active_flags(slave);
3071 }
3072 }
3073 read_unlock(&bond->curr_slave_lock);
3074 }
3075 read_unlock(&bond->lock);
3076
fbb0c41b 3077 bond_work_init_all(bond);
5a37e8ca 3078
58402054 3079 if (bond_is_lb(bond)) {
1da177e4
LT		 3080 /* bond_alb_initialize must be called before the timer
3081 * is started.
3082 */
fbb0c41b 3083 if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB)))
b473946a 3084 return -ENOMEM;
1b76b316 3085 queue_delayed_work(bond->wq, &bond->alb_work, 0);
1da177e4
LT		 3086 }
3087
fbb0c41b 3088 if (bond->params.miimon) /* link check interval, in milliseconds. */
1b76b316 3089 queue_delayed_work(bond->wq, &bond->mii_work, 0);
1da177e4
LT		 3090
3091 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
1b76b316 3092 queue_delayed_work(bond->wq, &bond->arp_work, 0);
f5b2b966 3093 if (bond->params.arp_validate)
3aba891d 3094 bond->recv_probe = bond_arp_rcv;
1da177e4
LT		 3095 }
3096
3097 if (bond->params.mode == BOND_MODE_8023AD) {
1b76b316 3098 queue_delayed_work(bond->wq, &bond->ad_work, 0);
1da177e4 3099 /* register to receive LACPDUs */
3aba891d 3100 bond->recv_probe = bond_3ad_lacpdu_recv;
fd989c83 3101 bond_3ad_initiate_agg_selection(bond, 1);
1da177e4
LT		 3102 }
3103
3104 return 0;
3105}
3106
3107static int bond_close(struct net_device *bond_dev)
3108{
454d7c9b 3109 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3110
fbb0c41b 3111 bond_work_cancel_all(bond);
6c8d23f7 3112 bond->send_peer_notif = 0;
ee8487c0 3113 if (bond_is_lb(bond))
1da177e4 3114 bond_alb_deinitialize(bond);
3aba891d 3115 bond->recv_probe = NULL;
1da177e4
LT		 3116
3117 return 0;
3118}
3119
28172739
ED		 3120static struct rtnl_link_stats64 *bond_get_stats(struct net_device *bond_dev,
3121 struct rtnl_link_stats64 *stats)
1da177e4 3122{
454d7c9b 3123 struct bonding *bond = netdev_priv(bond_dev);
28172739 3124 struct rtnl_link_stats64 temp;
9caff1e7 3125 struct list_head *iter;
1da177e4 3126 struct slave *slave;
1da177e4 3127
28172739 3128 memset(stats, 0, sizeof(*stats));
1da177e4
LT		 3129
3130 read_lock_bh(&bond->lock);
9caff1e7 3131 bond_for_each_slave(bond, slave, iter) {
be1f3c2c 3132 const struct rtnl_link_stats64 *sstats =
28172739
ED		 3133 dev_get_stats(slave->dev, &temp);
3134
3135 stats->rx_packets += sstats->rx_packets;
3136 stats->rx_bytes += sstats->rx_bytes;
3137 stats->rx_errors += sstats->rx_errors;
3138 stats->rx_dropped += sstats->rx_dropped;
3139
3140 stats->tx_packets += sstats->tx_packets;
3141 stats->tx_bytes += sstats->tx_bytes;
3142 stats->tx_errors += sstats->tx_errors;
3143 stats->tx_dropped += sstats->tx_dropped;
3144
3145 stats->multicast += sstats->multicast;
3146 stats->collisions += sstats->collisions;
3147
3148 stats->rx_length_errors += sstats->rx_length_errors;
3149 stats->rx_over_errors += sstats->rx_over_errors;
3150 stats->rx_crc_errors += sstats->rx_crc_errors;
3151 stats->rx_frame_errors += sstats->rx_frame_errors;
3152 stats->rx_fifo_errors += sstats->rx_fifo_errors;
3153 stats->rx_missed_errors += sstats->rx_missed_errors;
3154
3155 stats->tx_aborted_errors += sstats->tx_aborted_errors;
3156 stats->tx_carrier_errors += sstats->tx_carrier_errors;
3157 stats->tx_fifo_errors += sstats->tx_fifo_errors;
3158 stats->tx_heartbeat_errors += sstats->tx_heartbeat_errors;
3159 stats->tx_window_errors += sstats->tx_window_errors;
2439f9eb 3160 }
1da177e4
LT		 3161 read_unlock_bh(&bond->lock);
3162
3163 return stats;
3164}
3165
3166static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
3167{
080a06e1 3168 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 3169 struct net_device *slave_dev = NULL;
3170 struct ifbond k_binfo;
3171 struct ifbond __user *u_binfo = NULL;
3172 struct ifslave k_sinfo;
3173 struct ifslave __user *u_sinfo = NULL;
3174 struct mii_ioctl_data *mii = NULL;
387ff911 3175 struct net *net;
1da177e4
LT		 3176 int res = 0;
3177
a4aee5c8 3178 pr_debug("bond_ioctl: master=%s, cmd=%d\n", bond_dev->name, cmd);
1da177e4
LT		 3179
3180 switch (cmd) {
1da177e4
LT		 3181 case SIOCGMIIPHY:
3182 mii = if_mii(ifr);
3d632c3f 3183 if (!mii)
1da177e4 3184 return -EINVAL;
3d632c3f 3185
1da177e4
LT		 3186 mii->phy_id = 0;
3187 /* Fall Through */
3188 case SIOCGMIIREG:
3189 /*
3190 * We do this again just in case we were called by SIOCGMIIREG
3191 * instead of SIOCGMIIPHY.
3192 */
3193 mii = if_mii(ifr);
3d632c3f 3194 if (!mii)
1da177e4 3195 return -EINVAL;
3d632c3f 3196
1da177e4
LT		 3197
3198 if (mii->reg_num == 1) {
1da177e4 3199 mii->val_out = 0;
6603a6f2 3200 read_lock(&bond->lock);
1da177e4 3201 read_lock(&bond->curr_slave_lock);
3d632c3f 3202 if (netif_carrier_ok(bond->dev))
1da177e4 3203 mii->val_out = BMSR_LSTATUS;
3d632c3f 3204
1da177e4 3205 read_unlock(&bond->curr_slave_lock);
6603a6f2 3206 read_unlock(&bond->lock);
1da177e4
LT		 3207 }
3208
3209 return 0;
3210 case BOND_INFO_QUERY_OLD:
3211 case SIOCBONDINFOQUERY:
3212 u_binfo = (struct ifbond __user *)ifr->ifr_data;
3213
3d632c3f 3214 if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond)))
1da177e4 3215 return -EFAULT;
1da177e4
LT		 3216
3217 res = bond_info_query(bond_dev, &k_binfo);
3d632c3f
SH		 3218 if (res == 0 &&
3219 copy_to_user(u_binfo, &k_binfo, sizeof(ifbond)))
3220 return -EFAULT;
1da177e4
LT		 3221
3222 return res;
3223 case BOND_SLAVE_INFO_QUERY_OLD:
3224 case SIOCBONDSLAVEINFOQUERY:
3225 u_sinfo = (struct ifslave __user *)ifr->ifr_data;
3226
3d632c3f 3227 if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave)))
1da177e4 3228 return -EFAULT;
1da177e4
LT		 3229
3230 res = bond_slave_info_query(bond_dev, &k_sinfo);
3d632c3f
SH		 3231 if (res == 0 &&
3232 copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave)))
3233 return -EFAULT;
1da177e4
LT		 3234
3235 return res;
3236 default:
3237 /* Go on */
3238 break;
3239 }
3240
387ff911
G		 3241 net = dev_net(bond_dev);
3242
3243 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1da177e4 3244 return -EPERM;
1da177e4 3245
387ff911 3246 slave_dev = dev_get_by_name(net, ifr->ifr_slave);
1da177e4 3247
a4aee5c8 3248 pr_debug("slave_dev=%p:\n", slave_dev);
1da177e4 3249
3d632c3f 3250 if (!slave_dev)
1da177e4 3251 res = -ENODEV;
3d632c3f 3252 else {
a4aee5c8 3253 pr_debug("slave_dev->name=%s:\n", slave_dev->name);
1da177e4
LT		 3254 switch (cmd) {
3255 case BOND_ENSLAVE_OLD:
3256 case SIOCBONDENSLAVE:
3257 res = bond_enslave(bond_dev, slave_dev);
3258 break;
3259 case BOND_RELEASE_OLD:
3260 case SIOCBONDRELEASE:
3261 res = bond_release(bond_dev, slave_dev);
3262 break;
3263 case BOND_SETHWADDR_OLD:
3264 case SIOCBONDSETHWADDR:
409cc1f8
JP		 3265 bond_set_dev_addr(bond_dev, slave_dev);
3266 res = 0;
1da177e4
LT		 3267 break;
3268 case BOND_CHANGE_ACTIVE_OLD:
3269 case SIOCBONDCHANGEACTIVE:
080a06e1 3270 res = bond_option_active_slave_set(bond, slave_dev);
1da177e4
LT		 3271 break;
3272 default:
3273 res = -EOPNOTSUPP;
3274 }
3275
3276 dev_put(slave_dev);
3277 }
3278
1da177e4
LT		 3279 return res;
3280}
3281
d03462b9 3282static void bond_change_rx_flags(struct net_device *bond_dev, int change)
1da177e4 3283{
454d7c9b 3284 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3285
d03462b9
JP		 3286 if (change & IFF_PROMISC)
3287 bond_set_promiscuity(bond,
3288 bond_dev->flags & IFF_PROMISC ? 1 : -1);
3d632c3f 3289
d03462b9
JP		 3290 if (change & IFF_ALLMULTI)
3291 bond_set_allmulti(bond,
3292 bond_dev->flags & IFF_ALLMULTI ? 1 : -1);
3293}
1da177e4 3294
303d1cbf 3295static void bond_set_rx_mode(struct net_device *bond_dev)
d03462b9
JP		 3296{
3297 struct bonding *bond = netdev_priv(bond_dev);
9caff1e7 3298 struct list_head *iter;
303d1cbf 3299 struct slave *slave;
1da177e4 3300
80ee5ad2 3301
b3241870 3302 rcu_read_lock();
303d1cbf 3303 if (USES_PRIMARY(bond->params.mode)) {
b3241870 3304 slave = rcu_dereference(bond->curr_active_slave);
303d1cbf
JV		 3305 if (slave) {
3306 dev_uc_sync(slave->dev, bond_dev);
3307 dev_mc_sync(slave->dev, bond_dev);
3308 }
303d1cbf 3309 } else {
b3241870 3310 bond_for_each_slave_rcu(bond, slave, iter) {
303d1cbf
JV		 3311 dev_uc_sync_multiple(slave->dev, bond_dev);
3312 dev_mc_sync_multiple(slave->dev, bond_dev);
3313 }
1da177e4 3314 }
b3241870 3315 rcu_read_unlock();
1da177e4
LT		 3316}
3317
234bcf8a 3318static int bond_neigh_init(struct neighbour *n)
00829823 3319{
234bcf8a 3320 struct bonding *bond = netdev_priv(n->dev);
234bcf8a
SP		 3321 const struct net_device_ops *slave_ops;
3322 struct neigh_parms parms;
dec1e90e 3323 struct slave *slave;
234bcf8a
SP		 3324 int ret;
3325
dec1e90e 3326 slave = bond_first_slave(bond);
234bcf8a
SP		 3327 if (!slave)
3328 return 0;
234bcf8a 3329 slave_ops = slave->dev->netdev_ops;
234bcf8a
SP		 3330 if (!slave_ops->ndo_neigh_setup)
3331 return 0;
3332
3333 parms.neigh_setup = NULL;
3334 parms.neigh_cleanup = NULL;
3335 ret = slave_ops->ndo_neigh_setup(slave->dev, &parms);
3336 if (ret)
3337 return ret;
3338
3339 /*
3340 * Assign slave's neigh_cleanup to neighbour in case cleanup is called
3341 * after the last slave has been detached. Assumes that all slaves
3342 * utilize the same neigh_cleanup (true at this writing as only user
3343 * is ipoib).
3344 */
3345 n->parms->neigh_cleanup = parms.neigh_cleanup;
3346
3347 if (!parms.neigh_setup)
3348 return 0;
3349
3350 return parms.neigh_setup(n);
3351}
3352
3353/*
3354 * The bonding ndo_neigh_setup is called at init time beofre any
3355 * slave exists. So we must declare proxy setup function which will
3356 * be used at run time to resolve the actual slave neigh param setup.
9918d5bf
VF		 3357 *
3358 * It's also called by master devices (such as vlans) to setup their
3359 * underlying devices. In that case - do nothing, we're already set up from
3360 * our init.
234bcf8a
SP		 3361 */
3362static int bond_neigh_setup(struct net_device *dev,
3363 struct neigh_parms *parms)
3364{
9918d5bf
VF		 3365 /* modify only our neigh_parms */
3366 if (parms->dev == dev)
3367 parms->neigh_setup = bond_neigh_init;
00829823 3368
00829823
SH		 3369 return 0;
3370}
3371
1da177e4
LT		 3372/*
3373 * Change the MTU of all of a master's slaves to match the master
3374 */
3375static int bond_change_mtu(struct net_device *bond_dev, int new_mtu)
3376{
454d7c9b 3377 struct bonding *bond = netdev_priv(bond_dev);
81f23b13 3378 struct slave *slave, *rollback_slave;
9caff1e7 3379 struct list_head *iter;
1da177e4 3380 int res = 0;
1da177e4 3381
5a03cdb7 3382 pr_debug("bond=%p, name=%s, new_mtu=%d\n", bond,
a4aee5c8 3383 (bond_dev ? bond_dev->name : "None"), new_mtu);
1da177e4
LT		 3384
3385 /* Can't hold bond->lock with bh disabled here since
3386 * some base drivers panic. On the other hand we can't
3387 * hold bond->lock without bh disabled because we'll
3388 * deadlock. The only solution is to rely on the fact
3389 * that we're under rtnl_lock here, and the slaves
3390 * list won't change. This doesn't solve the problem
3391 * of setting the slave's MTU while it is
3392 * transmitting, but the assumption is that the base
3393 * driver can handle that.
3394 *
3395 * TODO: figure out a way to safely iterate the slaves
3396 * list, but without holding a lock around the actual
3397 * call to the base driver.
3398 */
3399
9caff1e7 3400 bond_for_each_slave(bond, slave, iter) {
c8c23903 3401 pr_debug("s %p c_m %p\n",
a4aee5c8 3402 slave,
a4aee5c8 3403 slave->dev->netdev_ops->ndo_change_mtu);
e944ef79 3404
1da177e4
LT		 3405 res = dev_set_mtu(slave->dev, new_mtu);
3406
3407 if (res) {
3408 /* If we failed to set the slave's mtu to the new value
3409 * we must abort the operation even in ACTIVE_BACKUP
3410 * mode, because if we allow the backup slaves to have
3411 * different mtu values than the active slave we'll
3412 * need to change their mtu when doing a failover. That
3413 * means changing their mtu from timer context, which
3414 * is probably not a good idea.
3415 */
5a03cdb7 3416 pr_debug("err %d %s\n", res, slave->dev->name);
1da177e4
LT		 3417 goto unwind;
3418 }
3419 }
3420
3421 bond_dev->mtu = new_mtu;
3422
3423 return 0;
3424
3425unwind:
3426 /* unwind from head to the slave that failed */
9caff1e7 3427 bond_for_each_slave(bond, rollback_slave, iter) {
1da177e4
LT		 3428 int tmp_res;
3429
81f23b13
VF		 3430 if (rollback_slave == slave)
3431 break;
3432
3433 tmp_res = dev_set_mtu(rollback_slave->dev, bond_dev->mtu);
1da177e4 3434 if (tmp_res) {
a4aee5c8 3435 pr_debug("unwind err %d dev %s\n",
81f23b13 3436 tmp_res, rollback_slave->dev->name);
1da177e4
LT		 3437 }
3438 }
3439
3440 return res;
3441}
3442
3443/*
3444 * Change HW address
3445 *
3446 * Note that many devices must be down to change the HW address, and
3447 * downing the master releases all slaves. We can make bonds full of
3448 * bonding devices to test this, however.
3449 */
3450static int bond_set_mac_address(struct net_device *bond_dev, void *addr)
3451{
454d7c9b 3452 struct bonding *bond = netdev_priv(bond_dev);
81f23b13 3453 struct slave *slave, *rollback_slave;
1da177e4 3454 struct sockaddr *sa = addr, tmp_sa;
9caff1e7 3455 struct list_head *iter;
1da177e4 3456 int res = 0;
1da177e4 3457
eb7cc59a
SH		 3458 if (bond->params.mode == BOND_MODE_ALB)
3459 return bond_alb_set_mac_address(bond_dev, addr);
3460
3461
a4aee5c8
JP		 3462 pr_debug("bond=%p, name=%s\n",
3463 bond, bond_dev ? bond_dev->name : "None");
1da177e4 3464
1b5acd29
JV		 3465 /* If fail_over_mac is enabled, do nothing and return success.
3466 * Returning an error causes ifenslave to fail.
dd957c57 3467 */
1b5acd29 3468 if (bond->params.fail_over_mac)
dd957c57 3469 return 0;
2ab82852 3470
3d632c3f 3471 if (!is_valid_ether_addr(sa->sa_data))
1da177e4 3472 return -EADDRNOTAVAIL;
1da177e4
LT		 3473
3474 /* Can't hold bond->lock with bh disabled here since
3475 * some base drivers panic. On the other hand we can't
3476 * hold bond->lock without bh disabled because we'll
3477 * deadlock. The only solution is to rely on the fact
3478 * that we're under rtnl_lock here, and the slaves
3479 * list won't change. This doesn't solve the problem
3480 * of setting the slave's hw address while it is
3481 * transmitting, but the assumption is that the base
3482 * driver can handle that.
3483 *
3484 * TODO: figure out a way to safely iterate the slaves
3485 * list, but without holding a lock around the actual
3486 * call to the base driver.
3487 */
3488
9caff1e7 3489 bond_for_each_slave(bond, slave, iter) {
eb7cc59a 3490 const struct net_device_ops *slave_ops = slave->dev->netdev_ops;
5a03cdb7 3491 pr_debug("slave %p %s\n", slave, slave->dev->name);
1da177e4 3492
eb7cc59a 3493 if (slave_ops->ndo_set_mac_address == NULL) {
1da177e4 3494 res = -EOPNOTSUPP;
5a03cdb7 3495 pr_debug("EOPNOTSUPP %s\n", slave->dev->name);
1da177e4
LT		 3496 goto unwind;
3497 }
3498
3499 res = dev_set_mac_address(slave->dev, addr);
3500 if (res) {
3501 /* TODO: consider downing the slave
3502 * and retry ?
3503 * User should expect communications
3504 * breakage anyway until ARP finish
3505 * updating, so...
3506 */
5a03cdb7 3507 pr_debug("err %d %s\n", res, slave->dev->name);
1da177e4
LT		 3508 goto unwind;
3509 }
3510 }
3511
3512 /* success */
3513 memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);
3514 return 0;
3515
3516unwind:
3517 memcpy(tmp_sa.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
3518 tmp_sa.sa_family = bond_dev->type;
3519
3520 /* unwind from head to the slave that failed */
9caff1e7 3521 bond_for_each_slave(bond, rollback_slave, iter) {
1da177e4
LT		 3522 int tmp_res;
3523
81f23b13
VF		 3524 if (rollback_slave == slave)
3525 break;
3526
3527 tmp_res = dev_set_mac_address(rollback_slave->dev, &tmp_sa);
1da177e4 3528 if (tmp_res) {
a4aee5c8 3529 pr_debug("unwind err %d dev %s\n",
81f23b13 3530 tmp_res, rollback_slave->dev->name);
1da177e4
LT		 3531 }
3532 }
3533
3534 return res;
3535}
3536
15077228
NA		 3537/**
3538 * bond_xmit_slave_id - transmit skb through slave with slave_id
3539 * @bond: bonding device that is transmitting
3540 * @skb: buffer to transmit
3541 * @slave_id: slave id up to slave_cnt-1 through which to transmit
3542 *
3543 * This function tries to transmit through slave with slave_id but in case
3544 * it fails, it tries to find the first available slave for transmission.
3545 * The skb is consumed in all cases, thus the function is void.
3546 */
3547void bond_xmit_slave_id(struct bonding *bond, struct sk_buff *skb, int slave_id)
3548{
9caff1e7 3549 struct list_head *iter;
15077228
NA		 3550 struct slave *slave;
3551 int i = slave_id;
3552
3553 /* Here we start from the slave with slave_id */
9caff1e7 3554 bond_for_each_slave_rcu(bond, slave, iter) {
15077228
NA		 3555 if (--i < 0) {
3556 if (slave_can_tx(slave)) {
3557 bond_dev_queue_xmit(bond, skb, slave->dev);
3558 return;
3559 }
3560 }
3561 }
3562
3563 /* Here we start from the first slave up to slave_id */
3564 i = slave_id;
9caff1e7 3565 bond_for_each_slave_rcu(bond, slave, iter) {
15077228
NA		 3566 if (--i < 0)
3567 break;
3568 if (slave_can_tx(slave)) {
3569 bond_dev_queue_xmit(bond, skb, slave->dev);
3570 return;
3571 }
3572 }
3573 /* no slave that can tx has been found */
3574 kfree_skb(skb);
3575}
3576
1da177e4
LT		 3577static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
3578{
454d7c9b 3579 struct bonding *bond = netdev_priv(bond_dev);
a2fd940f 3580 struct iphdr *iph = ip_hdr(skb);
15077228 3581 struct slave *slave;
1da177e4 3582
cf5f9044 3583 /*
a2fd940f
AG		 3584 * Start with the curr_active_slave that joined the bond as the
3585 * default for sending IGMP traffic. For failover purposes one
3586 * needs to maintain some consistency for the interface that will
3587 * send the join/membership reports. The curr_active_slave found
3588 * will send all of this type of traffic.
cf5f9044 3589 */
15077228 3590 if (iph->protocol == IPPROTO_IGMP && skb->protocol == htons(ETH_P_IP)) {
278b2083 3591 slave = rcu_dereference(bond->curr_active_slave);
15077228
NA		 3592 if (slave && slave_can_tx(slave))
3593 bond_dev_queue_xmit(bond, skb, slave->dev);
3594 else
3595 bond_xmit_slave_id(bond, skb, 0);
a2fd940f 3596 } else {
15077228
NA		 3597 bond_xmit_slave_id(bond, skb,
3598 bond->rr_tx_counter++ % bond->slave_cnt);
1da177e4 3599 }
0693e88e 3600
ec634fe3 3601 return NETDEV_TX_OK;
1da177e4
LT		 3602}
3603
3604/*
3605 * in active-backup mode, we know that bond->curr_active_slave is always valid if
3606 * the bond has a usable interface.
3607 */
3608static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_dev)
3609{
454d7c9b 3610 struct bonding *bond = netdev_priv(bond_dev);
71bc3b2d 3611 struct slave *slave;
1da177e4 3612
278b2083 3613 slave = rcu_dereference(bond->curr_active_slave);
71bc3b2d 3614 if (slave)
15077228
NA		 3615 bond_dev_queue_xmit(bond, skb, slave->dev);
3616 else
04502430 3617 kfree_skb(skb);
0693e88e 3618
ec634fe3 3619 return NETDEV_TX_OK;
1da177e4
LT		 3620}
3621
32819dc1 3622/* In bond_xmit_xor() , we determine the output device by using a pre-
169a3e66
JV		 3623 * determined xmit_hash_policy(), If the selected device is not enabled,
3624 * find the next active slave.
1da177e4
LT		 3625 */
3626static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
3627{
454d7c9b 3628 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3629
32819dc1 3630 bond_xmit_slave_id(bond, skb, bond_xmit_hash(bond, skb, bond->slave_cnt));
0693e88e 3631
ec634fe3 3632 return NETDEV_TX_OK;
1da177e4
LT		 3633}
3634
78a646ce 3635/* in broadcast mode, we send everything to all usable interfaces. */
1da177e4
LT		 3636static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
3637{
454d7c9b 3638 struct bonding *bond = netdev_priv(bond_dev);
78a646ce 3639 struct slave *slave = NULL;
9caff1e7 3640 struct list_head *iter;
1da177e4 3641
9caff1e7 3642 bond_for_each_slave_rcu(bond, slave, iter) {
78a646ce
NA		 3643 if (bond_is_last_slave(bond, slave))
3644 break;
3645 if (IS_UP(slave->dev) && slave->link == BOND_LINK_UP) {
3646 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1da177e4 3647
78a646ce
NA		 3648 if (!skb2) {
3649 pr_err("%s: Error: bond_xmit_broadcast(): skb_clone() failed\n",
3650 bond_dev->name);
3651 continue;
1da177e4 3652 }
78a646ce
NA		 3653 /* bond_dev_queue_xmit always returns 0 */
3654 bond_dev_queue_xmit(bond, skb2, slave->dev);
1da177e4
LT		 3655 }
3656 }
78a646ce
NA		 3657 if (slave && IS_UP(slave->dev) && slave->link == BOND_LINK_UP)
3658 bond_dev_queue_xmit(bond, skb, slave->dev);
3659 else
04502430 3660 kfree_skb(skb);
3d632c3f 3661
ec634fe3 3662 return NETDEV_TX_OK;
1da177e4
LT		 3663}
3664
3665/*------------------------- Device initialization ---------------------------*/
3666
bb1d9123
AG		 3667/*
3668 * Lookup the slave that corresponds to a qid
3669 */
3670static inline int bond_slave_override(struct bonding *bond,
3671 struct sk_buff *skb)
3672{
bb1d9123
AG		 3673 struct slave *slave = NULL;
3674 struct slave *check_slave;
9caff1e7 3675 struct list_head *iter;
dec1e90e 3676 int res = 1;
bb1d9123 3677
0693e88e
MM		 3678 if (!skb->queue_mapping)
3679 return 1;
bb1d9123
AG		 3680
3681 /* Find out if any slaves have the same mapping as this skb. */
9caff1e7 3682 bond_for_each_slave_rcu(bond, check_slave, iter) {
bb1d9123
AG		 3683 if (check_slave->queue_id == skb->queue_mapping) {
3684 slave = check_slave;
3685 break;
3686 }
3687 }
3688
3689 /* If the slave isn't UP, use default transmit policy. */
3690 if (slave && slave->queue_id && IS_UP(slave->dev) &&
3691 (slave->link == BOND_LINK_UP)) {
3692 res = bond_dev_queue_xmit(bond, skb, slave->dev);
3693 }
3694
bb1d9123
AG		 3695 return res;
3696}
3697
374eeb5a 3698
bb1d9123
AG		 3699static u16 bond_select_queue(struct net_device *dev, struct sk_buff *skb)
3700{
3701 /*
3702 * This helper function exists to help dev_pick_tx get the correct
fd0e435b 3703 * destination queue. Using a helper function skips a call to
bb1d9123
AG		 3704 * skb_tx_hash and will put the skbs in the queue we expect on their
3705 * way down to the bonding driver.
3706 */
fd0e435b
PO		 3707 u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
3708
374eeb5a
NH		 3709 /*
3710 * Save the original txq to restore before passing to the driver
3711 */
df4ab5b3 3712 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
374eeb5a 3713
fd0e435b 3714 if (unlikely(txq >= dev->real_num_tx_queues)) {
d30ee670 3715 do {
fd0e435b 3716 txq -= dev->real_num_tx_queues;
d30ee670 3717 } while (txq >= dev->real_num_tx_queues);
fd0e435b
PO		 3718 }
3719 return txq;
bb1d9123
AG		 3720}
3721
0693e88e 3722static netdev_tx_t __bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
00829823 3723{
bb1d9123
AG		 3724 struct bonding *bond = netdev_priv(dev);
3725
3726 if (TX_QUEUE_OVERRIDE(bond->params.mode)) {
3727 if (!bond_slave_override(bond, skb))
3728 return NETDEV_TX_OK;
3729 }
00829823
SH		 3730
3731 switch (bond->params.mode) {
3732 case BOND_MODE_ROUNDROBIN:
3733 return bond_xmit_roundrobin(skb, dev);
3734 case BOND_MODE_ACTIVEBACKUP:
3735 return bond_xmit_activebackup(skb, dev);
3736 case BOND_MODE_XOR:
3737 return bond_xmit_xor(skb, dev);
3738 case BOND_MODE_BROADCAST:
3739 return bond_xmit_broadcast(skb, dev);
3740 case BOND_MODE_8023AD:
3741 return bond_3ad_xmit_xor(skb, dev);
3742 case BOND_MODE_ALB:
3743 case BOND_MODE_TLB:
3744 return bond_alb_xmit(skb, dev);
3745 default:
3746 /* Should never happen, mode already checked */
a4aee5c8
JP		 3747 pr_err("%s: Error: Unknown bonding mode %d\n",
3748 dev->name, bond->params.mode);
00829823 3749 WARN_ON_ONCE(1);
04502430 3750 kfree_skb(skb);
00829823
SH		 3751 return NETDEV_TX_OK;
3752 }
3753}
3754
0693e88e
MM		 3755static netdev_tx_t bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
3756{
3757 struct bonding *bond = netdev_priv(dev);
3758 netdev_tx_t ret = NETDEV_TX_OK;
3759
3760 /*
3761 * If we risk deadlock from transmitting this in the
3762 * netpoll path, tell netpoll to queue the frame for later tx
3763 */
3764 if (is_netpoll_tx_blocked(dev))
3765 return NETDEV_TX_BUSY;
3766
278b2083 3767 rcu_read_lock();
0965a1f3 3768 if (bond_has_slaves(bond))
0693e88e
MM		 3769 ret = __bond_start_xmit(skb, dev);
3770 else
04502430 3771 kfree_skb(skb);
278b2083 3772 rcu_read_unlock();
0693e88e
MM		 3773
3774 return ret;
3775}
00829823 3776
bb5b052f
AG		 3777static int bond_ethtool_get_settings(struct net_device *bond_dev,
3778 struct ethtool_cmd *ecmd)
3779{
3780 struct bonding *bond = netdev_priv(bond_dev);
bb5b052f 3781 unsigned long speed = 0;
9caff1e7 3782 struct list_head *iter;
dec1e90e 3783 struct slave *slave;
bb5b052f
AG		 3784
3785 ecmd->duplex = DUPLEX_UNKNOWN;
3786 ecmd->port = PORT_OTHER;
3787
3788 /* Since SLAVE_IS_OK returns false for all inactive or down slaves, we
3789 * do not need to check mode. Though link speed might not represent
3790 * the true receive or transmit bandwidth (not all modes are symmetric)
3791 * this is an accurate maximum.
3792 */
3793 read_lock(&bond->lock);
9caff1e7 3794 bond_for_each_slave(bond, slave, iter) {
bb5b052f
AG		 3795 if (SLAVE_IS_OK(slave)) {
3796 if (slave->speed != SPEED_UNKNOWN)
3797 speed += slave->speed;
3798 if (ecmd->duplex == DUPLEX_UNKNOWN &&
3799 slave->duplex != DUPLEX_UNKNOWN)
3800 ecmd->duplex = slave->duplex;
3801 }
3802 }
3803 ethtool_cmd_speed_set(ecmd, speed ? : SPEED_UNKNOWN);
3804 read_unlock(&bond->lock);
dec1e90e 3805
bb5b052f
AG		 3806 return 0;
3807}
3808
217df670 3809static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
7826d43f 3810 struct ethtool_drvinfo *drvinfo)
217df670 3811{
7826d43f
JP		 3812 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
3813 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
3814 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "%d",
3815 BOND_ABI_VERSION);
217df670
JV		 3816}
3817
7282d491 3818static const struct ethtool_ops bond_ethtool_ops = {
217df670 3819 .get_drvinfo = bond_ethtool_get_drvinfo,
bb5b052f 3820 .get_settings = bond_ethtool_get_settings,
fa53ebac 3821 .get_link = ethtool_op_get_link,
8531c5ff
AK		 3822};
3823
eb7cc59a 3824static const struct net_device_ops bond_netdev_ops = {
181470fc 3825 .ndo_init = bond_init,
9e71626c 3826 .ndo_uninit = bond_uninit,
eb7cc59a
SH		 3827 .ndo_open = bond_open,
3828 .ndo_stop = bond_close,
00829823 3829 .ndo_start_xmit = bond_start_xmit,
bb1d9123 3830 .ndo_select_queue = bond_select_queue,
be1f3c2c 3831 .ndo_get_stats64 = bond_get_stats,
eb7cc59a 3832 .ndo_do_ioctl = bond_do_ioctl,
d03462b9 3833 .ndo_change_rx_flags = bond_change_rx_flags,
303d1cbf 3834 .ndo_set_rx_mode = bond_set_rx_mode,
eb7cc59a 3835 .ndo_change_mtu = bond_change_mtu,
cc0e4070 3836 .ndo_set_mac_address = bond_set_mac_address,
00829823 3837 .ndo_neigh_setup = bond_neigh_setup,
cc0e4070 3838 .ndo_vlan_rx_add_vid = bond_vlan_rx_add_vid,
eb7cc59a 3839 .ndo_vlan_rx_kill_vid = bond_vlan_rx_kill_vid,
f6dc31a8 3840#ifdef CONFIG_NET_POLL_CONTROLLER
8a8efa22 3841 .ndo_netpoll_setup = bond_netpoll_setup,
f6dc31a8
WC		 3842 .ndo_netpoll_cleanup = bond_netpoll_cleanup,
3843 .ndo_poll_controller = bond_poll_controller,
3844#endif
9232ecca
JP		 3845 .ndo_add_slave = bond_enslave,
3846 .ndo_del_slave = bond_release,
b2a103e6 3847 .ndo_fix_features = bond_fix_features,
eb7cc59a
SH		 3848};
3849
b3f92b63
DG		 3850static const struct device_type bond_type = {
3851 .name = "bond",
3852};
3853
9e2e61fb
AW		 3854static void bond_destructor(struct net_device *bond_dev)
3855{
3856 struct bonding *bond = netdev_priv(bond_dev);
3857 if (bond->wq)
3858 destroy_workqueue(bond->wq);
3859 free_netdev(bond_dev);
3860}
3861
0a2a78c4 3862void bond_setup(struct net_device *bond_dev)
1da177e4 3863{
454d7c9b 3864 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3865
1da177e4
LT		 3866 /* initialize rwlocks */
3867 rwlock_init(&bond->lock);
3868 rwlock_init(&bond->curr_slave_lock);
d2991f75 3869 bond->params = bonding_defaults;
1da177e4
LT		 3870
3871 /* Initialize pointers */
1da177e4 3872 bond->dev = bond_dev;
1da177e4
LT		 3873
3874 /* Initialize the device entry points */
181470fc 3875 ether_setup(bond_dev);
eb7cc59a 3876 bond_dev->netdev_ops = &bond_netdev_ops;
8531c5ff 3877 bond_dev->ethtool_ops = &bond_ethtool_ops;
1da177e4 3878
9e2e61fb 3879 bond_dev->destructor = bond_destructor;
1da177e4 3880
b3f92b63
DG		 3881 SET_NETDEV_DEVTYPE(bond_dev, &bond_type);
3882
1da177e4
LT		 3883 /* Initialize the device options */
3884 bond_dev->tx_queue_len = 0;
3885 bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
0b680e75 3886 bond_dev->priv_flags |= IFF_BONDING;
550fd08c 3887 bond_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
181470fc 3888
1da177e4
LT		 3889 /* At first, we block adding VLANs. That's the only way to
3890 * prevent problems that occur when adding VLANs over an
3891 * empty bond. The block will be removed once non-challenged
3892 * slaves are enslaved.
3893 */
3894 bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
3895
932ff279 3896 /* don't acquire bond device's netif_tx_lock when
1da177e4
LT		 3897 * transmitting */
3898 bond_dev->features |= NETIF_F_LLTX;
3899
3900 /* By default, we declare the bond to be fully
3901 * VLAN hardware accelerated capable. Special
3902 * care is taken in the various xmit functions
3903 * when there are slaves that are not hw accel
3904 * capable
3905 */
1da177e4 3906
b2a103e6 3907 bond_dev->hw_features = BOND_VLAN_FEATURES |
f646968f
PM		 3908 NETIF_F_HW_VLAN_CTAG_TX |
3909 NETIF_F_HW_VLAN_CTAG_RX |
3910 NETIF_F_HW_VLAN_CTAG_FILTER;
b2a103e6 3911
34324dc2 3912 bond_dev->hw_features &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_HW_CSUM);
b2a103e6 3913 bond_dev->features |= bond_dev->hw_features;
1da177e4
LT		 3914}
3915
c67dfb29
EB		 3916/*
3917* Destroy a bonding device.
3918* Must be under rtnl_lock when this function is called.
3919*/
3920static void bond_uninit(struct net_device *bond_dev)
a434e43f 3921{
454d7c9b 3922 struct bonding *bond = netdev_priv(bond_dev);
544a028e
VF		 3923 struct list_head *iter;
3924 struct slave *slave;
a434e43f 3925
f6dc31a8
WC		 3926 bond_netpoll_cleanup(bond_dev);
3927
c67dfb29 3928 /* Release the bonded slaves */
544a028e 3929 bond_for_each_slave(bond, slave, iter)
dec1e90e 3930 __bond_release_one(bond_dev, slave->dev, true);
0896341a 3931 pr_info("%s: released all slaves\n", bond_dev->name);
c67dfb29 3932
a434e43f
JV		 3933 list_del(&bond->bond_list);
3934
f073c7ca 3935 bond_debug_unregister(bond);
a434e43f
JV		 3936}
3937
1da177e4
LT		 3938/*------------------------- Module initialization ---------------------------*/
3939
3940/*
3941 * Convert string input module parms. Accept either the
ece95f7f
JV		 3942 * number of the mode or its string name. A bit complicated because
3943 * some mode names are substrings of other names, and calls from sysfs
3944 * may have whitespace in the name (trailing newlines, for example).
1da177e4 3945 */
325dcf7a 3946int bond_parse_parm(const char *buf, const struct bond_parm_tbl *tbl)
1da177e4 3947{
54b87323 3948 int modeint = -1, i, rv;
a42e534f 3949 char *p, modestr[BOND_MAX_MODENAME_LEN + 1] = { 0, };
ece95f7f 3950
a42e534f
JV		 3951 for (p = (char *)buf; *p; p++)
3952 if (!(isdigit(*p) || isspace(*p)))
3953 break;
3954
3955 if (*p)
ece95f7f 3956 rv = sscanf(buf, "%20s", modestr);
a42e534f 3957 else
54b87323 3958 rv = sscanf(buf, "%d", &modeint);
a42e534f
JV		 3959
3960 if (!rv)
3961 return -1;
1da177e4
LT		 3962
3963 for (i = 0; tbl[i].modename; i++) {
54b87323 3964 if (modeint == tbl[i].mode)
ece95f7f
JV		 3965 return tbl[i].mode;
3966 if (strcmp(modestr, tbl[i].modename) == 0)
1da177e4 3967 return tbl[i].mode;
1da177e4
LT		 3968 }
3969
3970 return -1;
3971}
3972
3973static int bond_check_params(struct bond_params *params)
3974{
5a5c5fd4 3975 int arp_validate_value, fail_over_mac_value, primary_reselect_value, i;
8599b52e 3976 int arp_all_targets_value;
f5b2b966 3977
1da177e4
LT		 3978 /*
3979 * Convert string parameters.
3980 */
3981 if (mode) {
3982 bond_mode = bond_parse_parm(mode, bond_mode_tbl);
3983 if (bond_mode == -1) {
a4aee5c8 3984 pr_err("Error: Invalid bonding mode \"%s\"\n",
1da177e4
LT		 3985 mode == NULL ? "NULL" : mode);
3986 return -EINVAL;
3987 }
3988 }
3989
169a3e66
JV		 3990 if (xmit_hash_policy) {
3991 if ((bond_mode != BOND_MODE_XOR) &&
3992 (bond_mode != BOND_MODE_8023AD)) {
a4aee5c8 3993 pr_info("xmit_hash_policy param is irrelevant in mode %s\n",
169a3e66
JV		 3994 bond_mode_name(bond_mode));
3995 } else {
3996 xmit_hashtype = bond_parse_parm(xmit_hash_policy,
3997 xmit_hashtype_tbl);
3998 if (xmit_hashtype == -1) {
a4aee5c8 3999 pr_err("Error: Invalid xmit_hash_policy \"%s\"\n",
3d632c3f 4000 xmit_hash_policy == NULL ? "NULL" :
169a3e66
JV		 4001 xmit_hash_policy);
4002 return -EINVAL;
4003 }
4004 }
4005 }
4006
1da177e4
LT		 4007 if (lacp_rate) {
4008 if (bond_mode != BOND_MODE_8023AD) {
a4aee5c8
JP		 4009 pr_info("lacp_rate param is irrelevant in mode %s\n",
4010 bond_mode_name(bond_mode));
1da177e4
LT		 4011 } else {
4012 lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl);
4013 if (lacp_fast == -1) {
a4aee5c8 4014 pr_err("Error: Invalid lacp rate \"%s\"\n",
1da177e4
LT		 4015 lacp_rate == NULL ? "NULL" : lacp_rate);
4016 return -EINVAL;
4017 }
4018 }
4019 }
4020
fd989c83
JV		 4021 if (ad_select) {
4022 params->ad_select = bond_parse_parm(ad_select, ad_select_tbl);
4023 if (params->ad_select == -1) {
a4aee5c8 4024 pr_err("Error: Invalid ad_select \"%s\"\n",
fd989c83
JV		 4025 ad_select == NULL ? "NULL" : ad_select);
4026 return -EINVAL;
4027 }
4028
4029 if (bond_mode != BOND_MODE_8023AD) {
a4aee5c8 4030 pr_warning("ad_select param only affects 802.3ad mode\n");
fd989c83
JV		 4031 }
4032 } else {
4033 params->ad_select = BOND_AD_STABLE;
4034 }
4035
f5841306 4036 if (max_bonds < 0) {
a4aee5c8
JP		 4037 pr_warning("Warning: max_bonds (%d) not in range %d-%d, so it was reset to BOND_DEFAULT_MAX_BONDS (%d)\n",
4038 max_bonds, 0, INT_MAX, BOND_DEFAULT_MAX_BONDS);
1da177e4
LT		 4039 max_bonds = BOND_DEFAULT_MAX_BONDS;
4040 }
4041
4042 if (miimon < 0) {
a4aee5c8
JP		 4043 pr_warning("Warning: miimon module parameter (%d), not in range 0-%d, so it was reset to %d\n",
4044 miimon, INT_MAX, BOND_LINK_MON_INTERV);
1da177e4
LT		 4045 miimon = BOND_LINK_MON_INTERV;
4046 }
4047
4048 if (updelay < 0) {
a4aee5c8
JP		 4049 pr_warning("Warning: updelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
4050 updelay, INT_MAX);
1da177e4
LT		 4051 updelay = 0;
4052 }
4053
4054 if (downdelay < 0) {
a4aee5c8
JP		 4055 pr_warning("Warning: downdelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
4056 downdelay, INT_MAX);
1da177e4
LT		 4057 downdelay = 0;
4058 }
4059
4060 if ((use_carrier != 0) && (use_carrier != 1)) {
a4aee5c8
JP		 4061 pr_warning("Warning: use_carrier module parameter (%d), not of valid value (0/1), so it was set to 1\n",
4062 use_carrier);
1da177e4
LT		 4063 use_carrier = 1;
4064 }
4065
ad246c99
BH		 4066 if (num_peer_notif < 0 || num_peer_notif > 255) {
4067 pr_warning("Warning: num_grat_arp/num_unsol_na (%d) not in range 0-255 so it was reset to 1\n",
4068 num_peer_notif);
4069 num_peer_notif = 1;
4070 }
4071
1da177e4
LT		 4072 /* reset values for 802.3ad */
4073 if (bond_mode == BOND_MODE_8023AD) {
4074 if (!miimon) {
a4aee5c8 4075 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 4076 pr_warning("Forcing miimon to 100msec\n");
1da177e4
LT		 4077 miimon = 100;
4078 }
4079 }
4080
bb1d9123
AG		 4081 if (tx_queues < 1 || tx_queues > 255) {
4082 pr_warning("Warning: tx_queues (%d) should be between "
4083 "1 and 255, resetting to %d\n",
4084 tx_queues, BOND_DEFAULT_TX_QUEUES);
4085 tx_queues = BOND_DEFAULT_TX_QUEUES;
4086 }
4087
ebd8e497
AG		 4088 if ((all_slaves_active != 0) && (all_slaves_active != 1)) {
4089 pr_warning("Warning: all_slaves_active module parameter (%d), "
4090 "not of valid value (0/1), so it was set to "
4091 "0\n", all_slaves_active);
4092 all_slaves_active = 0;
4093 }
4094
c2952c31
FL		 4095 if (resend_igmp < 0 || resend_igmp > 255) {
4096 pr_warning("Warning: resend_igmp (%d) should be between "
4097 "0 and 255, resetting to %d\n",
4098 resend_igmp, BOND_DEFAULT_RESEND_IGMP);
4099 resend_igmp = BOND_DEFAULT_RESEND_IGMP;
4100 }
4101
1da177e4
LT		 4102 /* reset values for TLB/ALB */
4103 if ((bond_mode == BOND_MODE_TLB) ||
4104 (bond_mode == BOND_MODE_ALB)) {
4105 if (!miimon) {
a4aee5c8 4106 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 4107 pr_warning("Forcing miimon to 100msec\n");
1da177e4
LT		 4108 miimon = 100;
4109 }
4110 }
4111
4112 if (bond_mode == BOND_MODE_ALB) {
a4aee5c8
JP		 4113 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",
4114 updelay);
1da177e4
LT		 4115 }
4116
4117 if (!miimon) {
4118 if (updelay || downdelay) {
4119 /* just warn the user the up/down delay will have
4120 * no effect since miimon is zero...
4121 */
a4aee5c8
JP		 4122 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",
4123 updelay, downdelay);
1da177e4
LT		 4124 }
4125 } else {
4126 /* don't allow arp monitoring */
4127 if (arp_interval) {
a4aee5c8
JP		 4128 pr_warning("Warning: miimon (%d) and arp_interval (%d) can't be used simultaneously, disabling ARP monitoring\n",
4129 miimon, arp_interval);
1da177e4
LT		 4130 arp_interval = 0;
4131 }
4132
4133 if ((updelay % miimon) != 0) {
a4aee5c8
JP		 4134 pr_warning("Warning: updelay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n",
4135 updelay, miimon,
4136 (updelay / miimon) * miimon);
1da177e4
LT		 4137 }
4138
4139 updelay /= miimon;
4140
4141 if ((downdelay % miimon) != 0) {
a4aee5c8
JP		 4142 pr_warning("Warning: downdelay (%d) is not a multiple of miimon (%d), downdelay rounded to %d ms\n",
4143 downdelay, miimon,
4144 (downdelay / miimon) * miimon);
1da177e4
LT		 4145 }
4146
4147 downdelay /= miimon;
4148 }
4149
4150 if (arp_interval < 0) {
a4aee5c8
JP		 4151 pr_warning("Warning: arp_interval module parameter (%d) , not in range 0-%d, so it was reset to %d\n",
4152 arp_interval, INT_MAX, BOND_LINK_ARP_INTERV);
1da177e4
LT		 4153 arp_interval = BOND_LINK_ARP_INTERV;
4154 }
4155
5a5c5fd4 4156 for (arp_ip_count = 0, i = 0;
4157 (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[i]; i++) {
1da177e4
LT		 4158 /* not complete check, but should be good enough to
4159 catch mistakes */
5a5c5fd4 4160 __be32 ip = in_aton(arp_ip_target[i]);
4161 if (!isdigit(arp_ip_target[i][0]) || ip == 0 ||
4162 ip == htonl(INADDR_BROADCAST)) {
a4aee5c8 4163 pr_warning("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n",
5a5c5fd4 4164 arp_ip_target[i]);
1da177e4
LT		 4165 arp_interval = 0;
4166 } else {
0afee4e8
VF		 4167 if (bond_get_targets_ip(arp_target, ip) == -1)
4168 arp_target[arp_ip_count++] = ip;
4169 else
4170 pr_warning("Warning: duplicate address %pI4 in arp_ip_target, skipping\n",
4171 &ip);
1da177e4
LT		 4172 }
4173 }
4174
4175 if (arp_interval && !arp_ip_count) {
4176 /* don't allow arping if no arp_ip_target given... */
a4aee5c8
JP		 4177 pr_warning("Warning: arp_interval module parameter (%d) specified without providing an arp_ip_target parameter, arp_interval was reset to 0\n",
4178 arp_interval);
1da177e4
LT		 4179 arp_interval = 0;
4180 }
4181
f5b2b966
JV		 4182 if (arp_validate) {
4183 if (bond_mode != BOND_MODE_ACTIVEBACKUP) {
a4aee5c8 4184 pr_err("arp_validate only supported in active-backup mode\n");
f5b2b966
JV		 4185 return -EINVAL;
4186 }
4187 if (!arp_interval) {
a4aee5c8 4188 pr_err("arp_validate requires arp_interval\n");
f5b2b966
JV		 4189 return -EINVAL;
4190 }
4191
4192 arp_validate_value = bond_parse_parm(arp_validate,
4193 arp_validate_tbl);
4194 if (arp_validate_value == -1) {
a4aee5c8 4195 pr_err("Error: invalid arp_validate \"%s\"\n",
f5b2b966
JV		 4196 arp_validate == NULL ? "NULL" : arp_validate);
4197 return -EINVAL;
4198 }
4199 } else
4200 arp_validate_value = 0;
4201
8599b52e
VF		 4202 arp_all_targets_value = 0;
4203 if (arp_all_targets) {
4204 arp_all_targets_value = bond_parse_parm(arp_all_targets,
4205 arp_all_targets_tbl);
4206
4207 if (arp_all_targets_value == -1) {
4208 pr_err("Error: invalid arp_all_targets_value \"%s\"\n",
4209 arp_all_targets);
4210 arp_all_targets_value = 0;
4211 }
4212 }
4213
1da177e4 4214 if (miimon) {
a4aee5c8 4215 pr_info("MII link monitoring set to %d ms\n", miimon);
1da177e4 4216 } else if (arp_interval) {
a4aee5c8
JP		 4217 pr_info("ARP monitoring set to %d ms, validate %s, with %d target(s):",
4218 arp_interval,
4219 arp_validate_tbl[arp_validate_value].modename,
4220 arp_ip_count);
1da177e4
LT		 4221
4222 for (i = 0; i < arp_ip_count; i++)
e5e2a8fd 4223 pr_info(" %s", arp_ip_target[i]);
1da177e4 4224
e5e2a8fd 4225 pr_info("\n");
1da177e4 4226
b8a9787e 4227 } else if (max_bonds) {
1da177e4
LT		 4228 /* miimon and arp_interval not set, we need one so things
4229 * work as expected, see bonding.txt for details
4230 */
b2730f4f 4231 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		 4232 }
4233
4234 if (primary && !USES_PRIMARY(bond_mode)) {
4235 /* currently, using a primary only makes sense
4236 * in active backup, TLB or ALB modes
4237 */
a4aee5c8
JP		 4238 pr_warning("Warning: %s primary device specified but has no effect in %s mode\n",
4239 primary, bond_mode_name(bond_mode));
1da177e4
LT		 4240 primary = NULL;
4241 }
4242
a549952a
JP		 4243 if (primary && primary_reselect) {
4244 primary_reselect_value = bond_parse_parm(primary_reselect,
4245 pri_reselect_tbl);
4246 if (primary_reselect_value == -1) {
a4aee5c8 4247 pr_err("Error: Invalid primary_reselect \"%s\"\n",
a549952a
JP		 4248 primary_reselect ==
4249 NULL ? "NULL" : primary_reselect);
4250 return -EINVAL;
4251 }
4252 } else {
4253 primary_reselect_value = BOND_PRI_RESELECT_ALWAYS;
4254 }
4255
3915c1e8
JV		 4256 if (fail_over_mac) {
4257 fail_over_mac_value = bond_parse_parm(fail_over_mac,
4258 fail_over_mac_tbl);
4259 if (fail_over_mac_value == -1) {
a4aee5c8 4260 pr_err("Error: invalid fail_over_mac \"%s\"\n",
3915c1e8
JV		 4261 arp_validate == NULL ? "NULL" : arp_validate);
4262 return -EINVAL;
4263 }
4264
4265 if (bond_mode != BOND_MODE_ACTIVEBACKUP)
a4aee5c8 4266 pr_warning("Warning: fail_over_mac only affects active-backup mode.\n");
3915c1e8
JV		 4267 } else {
4268 fail_over_mac_value = BOND_FOM_NONE;
4269 }
dd957c57 4270
1da177e4
LT		 4271 /* fill params struct with the proper values */
4272 params->mode = bond_mode;
169a3e66 4273 params->xmit_policy = xmit_hashtype;
1da177e4 4274 params->miimon = miimon;
ad246c99 4275 params->num_peer_notif = num_peer_notif;
1da177e4 4276 params->arp_interval = arp_interval;
f5b2b966 4277 params->arp_validate = arp_validate_value;
8599b52e 4278 params->arp_all_targets = arp_all_targets_value;
1da177e4
LT		 4279 params->updelay = updelay;
4280 params->downdelay = downdelay;
4281 params->use_carrier = use_carrier;
4282 params->lacp_fast = lacp_fast;
4283 params->primary[0] = 0;
a549952a 4284 params->primary_reselect = primary_reselect_value;
3915c1e8 4285 params->fail_over_mac = fail_over_mac_value;
bb1d9123 4286 params->tx_queues = tx_queues;
ebd8e497 4287 params->all_slaves_active = all_slaves_active;
c2952c31 4288 params->resend_igmp = resend_igmp;
655f8919 4289 params->min_links = min_links;
7eacd038 4290 params->lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL;
1da177e4
LT		 4291
4292 if (primary) {
4293 strncpy(params->primary, primary, IFNAMSIZ);
4294 params->primary[IFNAMSIZ - 1] = 0;
4295 }
4296
4297 memcpy(params->arp_targets, arp_target, sizeof(arp_target));
4298
4299 return 0;
4300}
4301
0daa2303 4302static struct lock_class_key bonding_netdev_xmit_lock_key;
cf508b12 4303static struct lock_class_key bonding_netdev_addr_lock_key;
49ee4920 4304static struct lock_class_key bonding_tx_busylock_key;
0daa2303 4305
e8a0464c
DM		 4306static void bond_set_lockdep_class_one(struct net_device *dev,
4307 struct netdev_queue *txq,
4308 void *_unused)
c773e847
DM		 4309{
4310 lockdep_set_class(&txq->_xmit_lock,
4311 &bonding_netdev_xmit_lock_key);
4312}
4313
4314static void bond_set_lockdep_class(struct net_device *dev)
4315{
cf508b12
DM		 4316 lockdep_set_class(&dev->addr_list_lock,
4317 &bonding_netdev_addr_lock_key);
e8a0464c 4318 netdev_for_each_tx_queue(dev, bond_set_lockdep_class_one, NULL);
49ee4920 4319 dev->qdisc_tx_busylock = &bonding_tx_busylock_key;
c773e847
DM		 4320}
4321
181470fc
SH		 4322/*
4323 * Called from registration process
4324 */
4325static int bond_init(struct net_device *bond_dev)
4326{
4327 struct bonding *bond = netdev_priv(bond_dev);
ec87fd3b 4328 struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
9fe0617d 4329 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
181470fc
SH		 4330
4331 pr_debug("Begin bond_init for %s\n", bond_dev->name);
4332
9fe0617d
NH		 4333 /*
4334 * Initialize locks that may be required during
4335 * en/deslave operations. All of the bond_open work
4336 * (of which this is part) should really be moved to
4337 * a phase prior to dev_open
4338 */
4339 spin_lock_init(&(bond_info->tx_hashtbl_lock));
4340 spin_lock_init(&(bond_info->rx_hashtbl_lock));
4341
181470fc
SH		 4342 bond->wq = create_singlethread_workqueue(bond_dev->name);
4343 if (!bond->wq)
4344 return -ENOMEM;
4345
4346 bond_set_lockdep_class(bond_dev);
4347
ec87fd3b 4348 list_add_tail(&bond->bond_list, &bn->dev_list);
181470fc 4349
6151b3d4 4350 bond_prepare_sysfs_group(bond);
22bedad3 4351
f073c7ca
TI		 4352 bond_debug_register(bond);
4353
409cc1f8
JP		 4354 /* Ensure valid dev_addr */
4355 if (is_zero_ether_addr(bond_dev->dev_addr) &&
97a1e639 4356 bond_dev->addr_assign_type == NET_ADDR_PERM)
409cc1f8 4357 eth_hw_addr_random(bond_dev);
409cc1f8 4358
181470fc
SH		 4359 return 0;
4360}
4361
0a2a78c4 4362unsigned int bond_get_num_tx_queues(void)
d5da4510 4363{
efacb309 4364 return tx_queues;
d5da4510
JP		 4365}
4366
dfe60397 4367/* Create a new bond based on the specified name and bonding parameters.
e4b91c48 4368 * If name is NULL, obtain a suitable "bond%d" name for us.
dfe60397
MW		 4369 * Caller must NOT hold rtnl_lock; we need to release it here before we
4370 * set up our sysfs entries.
4371 */
ec87fd3b 4372int bond_create(struct net *net, const char *name)
dfe60397
MW		 4373{
4374 struct net_device *bond_dev;
4375 int res;
4376
4377 rtnl_lock();
027ea041 4378
1c5cae81
JP		 4379 bond_dev = alloc_netdev_mq(sizeof(struct bonding),
4380 name ? name : "bond%d",
4381 bond_setup, tx_queues);
dfe60397 4382 if (!bond_dev) {
a4aee5c8 4383 pr_err("%s: eek! can't alloc netdev!\n", name);
9e2e61fb
AW		 4384 rtnl_unlock();
4385 return -ENOMEM;
dfe60397
MW		 4386 }
4387
ec87fd3b 4388 dev_net_set(bond_dev, net);
88ead977
EB		 4389 bond_dev->rtnl_link_ops = &bond_link_ops;
4390
dfe60397 4391 res = register_netdevice(bond_dev);
0daa2303 4392
e826eafa
PO		 4393 netif_carrier_off(bond_dev);
4394
7e083840 4395 rtnl_unlock();
9e2e61fb
AW		 4396 if (res < 0)
4397 bond_destructor(bond_dev);
30c15ba9 4398 return res;
dfe60397
MW		 4399}
4400
2c8c1e72 4401static int __net_init bond_net_init(struct net *net)
ec87fd3b 4402{
15449745 4403 struct bond_net *bn = net_generic(net, bond_net_id);
ec87fd3b
EB		 4404
4405 bn->net = net;
4406 INIT_LIST_HEAD(&bn->dev_list);
4407
ec87fd3b 4408 bond_create_proc_dir(bn);
4c22400a 4409 bond_create_sysfs(bn);
87a7b84b 4410
15449745 4411 return 0;
ec87fd3b
EB		 4412}
4413
2c8c1e72 4414static void __net_exit bond_net_exit(struct net *net)
ec87fd3b 4415{
15449745 4416 struct bond_net *bn = net_generic(net, bond_net_id);
69b0216a 4417 struct bonding *bond, *tmp_bond;
4418 LIST_HEAD(list);
ec87fd3b 4419
4c22400a 4420 bond_destroy_sysfs(bn);
ec87fd3b 4421 bond_destroy_proc_dir(bn);
69b0216a 4422
4423 /* Kill off any bonds created after unregistering bond rtnl ops */
4424 rtnl_lock();
4425 list_for_each_entry_safe(bond, tmp_bond, &bn->dev_list, bond_list)
4426 unregister_netdevice_queue(bond->dev, &list);
4427 unregister_netdevice_many(&list);
4428 rtnl_unlock();
ec87fd3b
EB		 4429}
4430
4431static struct pernet_operations bond_net_ops = {
4432 .init = bond_net_init,
4433 .exit = bond_net_exit,
15449745
EB		 4434 .id = &bond_net_id,
4435 .size = sizeof(struct bond_net),
ec87fd3b
EB		 4436};
4437
1da177e4
LT		 4438static int __init bonding_init(void)
4439{
1da177e4
LT		 4440 int i;
4441 int res;
4442
bd33acc3 4443 pr_info("%s", bond_version);
1da177e4 4444
dfe60397 4445 res = bond_check_params(&bonding_defaults);
3d632c3f 4446 if (res)
dfe60397 4447 goto out;
1da177e4 4448
15449745 4449 res = register_pernet_subsys(&bond_net_ops);
ec87fd3b
EB		 4450 if (res)
4451 goto out;
027ea041 4452
0a2a78c4 4453 res = bond_netlink_init();
88ead977 4454 if (res)
6639104b 4455 goto err_link;
88ead977 4456
f073c7ca
TI		 4457 bond_create_debugfs();
4458
1da177e4 4459 for (i = 0; i < max_bonds; i++) {
ec87fd3b 4460 res = bond_create(&init_net, NULL);
dfe60397
MW		 4461 if (res)
4462 goto err;
1da177e4
LT		 4463 }
4464
1da177e4 4465 register_netdevice_notifier(&bond_netdev_notifier);
dfe60397 4466out:
1da177e4 4467 return res;
88ead977 4468err:
0a2a78c4 4469 bond_netlink_fini();
6639104b 4470err_link:
15449745 4471 unregister_pernet_subsys(&bond_net_ops);
88ead977 4472 goto out;
dfe60397 4473
1da177e4
LT		 4474}
4475
4476static void __exit bonding_exit(void)
4477{
4478 unregister_netdevice_notifier(&bond_netdev_notifier);
4479
f073c7ca 4480 bond_destroy_debugfs();
ae68c398 4481
0a2a78c4 4482 bond_netlink_fini();
ffcdedb6 4483 unregister_pernet_subsys(&bond_net_ops);
e843fa50
NH		 4484
4485#ifdef CONFIG_NET_POLL_CONTROLLER
fb4fa76a
NH		 4486 /*
4487 * Make sure we don't have an imbalance on our netpoll blocking
4488 */
4489 WARN_ON(atomic_read(&netpoll_block_tx));
e843fa50 4490#endif
1da177e4
LT		 4491}
4492
4493module_init(bonding_init);
4494module_exit(bonding_exit);
4495MODULE_LICENSE("GPL");
4496MODULE_VERSION(DRV_VERSION);
4497MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION);
4498MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others");
Linux kernel - Deliverables
This page took 2.567778 seconds and 5 git commands to generate.