blob: f4489d65bf338b3915be7da7e05eef5d6c81ba88 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 */
33
Joe Perchesa4aee5c2009-12-13 20:06:07 -080034#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
35
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/kernel.h>
37#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#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>
Jay Vosburgh169a3e62005-06-26 17:54:11 -040044#include <net/ip.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/ip.h>
Jay Vosburgh169a3e62005-06-26 17:54:11 -040046#include <linux/tcp.h>
47#include <linux/udp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#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>
Stephen Hemminger3d632c32009-06-12 19:02:48 +000056#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include <asm/dma.h>
Stephen Hemminger3d632c32009-06-12 19:02:48 +000058#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <linux/errno.h>
60#include <linux/netdevice.h>
61#include <linux/inetdevice.h>
Jay Vosburgha816c7c2007-02-28 17:03:37 -080062#include <linux/igmp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#include <linux/etherdevice.h>
64#include <linux/skbuff.h>
65#include <net/sock.h>
66#include <linux/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#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>
David Sterbab63bb732007-12-06 23:40:33 -080074#include <linux/jiffies.h>
Neil Hormane843fa52010-10-13 16:01:50 +000075#include <linux/preempt.h>
Jay Vosburghc3ade5c2005-06-26 17:52:20 -040076#include <net/route.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020077#include <net/net_namespace.h>
Eric W. Biedermanec87fd32009-10-29 14:18:26 +000078#include <net/netns/generic.h>
Eric Dumazet5ee31c682012-06-12 06:03:51 +000079#include <net/pkt_sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#include "bonding.h"
81#include "bond_3ad.h"
82#include "bond_alb.h"
83
84/*---------------------------- Module parameters ----------------------------*/
85
86/* monitor all links that often (in milliseconds). <=0 disables monitoring */
87#define BOND_LINK_MON_INTERV 0
88#define BOND_LINK_ARP_INTERV 0
89
90static int max_bonds = BOND_DEFAULT_MAX_BONDS;
Andy Gospodarekbb1d9122010-06-02 08:40:18 +000091static int tx_queues = BOND_DEFAULT_TX_QUEUES;
Ben Hutchingsad246c92011-04-26 15:25:52 +000092static int num_peer_notif = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093static int miimon = BOND_LINK_MON_INTERV;
Stephen Hemminger3d632c32009-06-12 19:02:48 +000094static int updelay;
95static int downdelay;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096static int use_carrier = 1;
Stephen Hemminger3d632c32009-06-12 19:02:48 +000097static char *mode;
98static char *primary;
Jiri Pirkoa5499522009-09-25 03:28:09 +000099static char *primary_reselect;
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000100static char *lacp_rate;
stephen hemminger655f8912011-06-22 09:54:39 +0000101static int min_links;
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000102static char *ad_select;
103static char *xmit_hash_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104static int arp_interval = BOND_LINK_ARP_INTERV;
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000105static char *arp_ip_target[BOND_MAX_ARP_TARGETS];
106static char *arp_validate;
107static char *fail_over_mac;
Andy Gospodarekebd8e492010-06-02 08:39:21 +0000108static int all_slaves_active = 0;
Stephen Hemmingerd2991f72009-06-12 19:02:44 +0000109static struct bond_params bonding_defaults;
Flavio Leitnerc2952c32010-10-05 14:23:59 +0000110static int resend_igmp = BOND_DEFAULT_RESEND_IGMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112module_param(max_bonds, int, 0);
113MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
Andy Gospodarekbb1d9122010-06-02 08:40:18 +0000114module_param(tx_queues, int, 0);
115MODULE_PARM_DESC(tx_queues, "Max number of transmit queues (default = 16)");
Ben Hutchingsad246c92011-04-26 15:25:52 +0000116module_param_named(num_grat_arp, num_peer_notif, int, 0644);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000117MODULE_PARM_DESC(num_grat_arp, "Number of peer notifications to send on "
118 "failover event (alias of num_unsol_na)");
Ben Hutchingsad246c92011-04-26 15:25:52 +0000119module_param_named(num_unsol_na, num_peer_notif, int, 0644);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000120MODULE_PARM_DESC(num_unsol_na, "Number of peer notifications to send on "
121 "failover event (alias of num_grat_arp)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122module_param(miimon, int, 0);
123MODULE_PARM_DESC(miimon, "Link check interval in milliseconds");
124module_param(updelay, int, 0);
125MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds");
126module_param(downdelay, int, 0);
Mitch Williams2ac47662005-11-09 10:35:03 -0800127MODULE_PARM_DESC(downdelay, "Delay before considering link down, "
128 "in milliseconds");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129module_param(use_carrier, int, 0);
Mitch Williams2ac47662005-11-09 10:35:03 -0800130MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; "
131 "0 for off, 1 for on (default)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132module_param(mode, charp, 0);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000133MODULE_PARM_DESC(mode, "Mode of operation; 0 for balance-rr, "
Mitch Williams2ac47662005-11-09 10:35:03 -0800134 "1 for active-backup, 2 for balance-xor, "
135 "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, "
136 "6 for balance-alb");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137module_param(primary, charp, 0);
138MODULE_PARM_DESC(primary, "Primary network device to use");
Jiri Pirkoa5499522009-09-25 03:28:09 +0000139module_param(primary_reselect, charp, 0);
140MODULE_PARM_DESC(primary_reselect, "Reselect primary slave "
141 "once it comes up; "
142 "0 for always (default), "
143 "1 for only if speed of primary is "
144 "better, "
145 "2 for only on active slave "
146 "failure");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147module_param(lacp_rate, charp, 0);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000148MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner; "
149 "0 for slow, 1 for fast");
Jay Vosburghfd989c82008-11-04 17:51:16 -0800150module_param(ad_select, charp, 0);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000151MODULE_PARM_DESC(ad_select, "803.ad aggregation selection logic; "
152 "0 for stable (default), 1 for bandwidth, "
153 "2 for count");
stephen hemminger655f8912011-06-22 09:54:39 +0000154module_param(min_links, int, 0);
155MODULE_PARM_DESC(min_links, "Minimum number of available links before turning on carrier");
156
Jay Vosburgh169a3e62005-06-26 17:54:11 -0400157module_param(xmit_hash_policy, charp, 0);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000158MODULE_PARM_DESC(xmit_hash_policy, "balance-xor and 802.3ad hashing method; "
159 "0 for layer 2 (default), 1 for layer 3+4, "
160 "2 for layer 2+3");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161module_param(arp_interval, int, 0);
162MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds");
163module_param_array(arp_ip_target, charp, NULL, 0);
164MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form");
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700165module_param(arp_validate, charp, 0);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000166MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes; "
167 "0 for none (default), 1 for active, "
168 "2 for backup, 3 for all");
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700169module_param(fail_over_mac, charp, 0);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000170MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to "
171 "the same MAC; 0 for none (default), "
172 "1 for active, 2 for follow");
Andy Gospodarekebd8e492010-06-02 08:39:21 +0000173module_param(all_slaves_active, int, 0);
174MODULE_PARM_DESC(all_slaves_active, "Keep all frames received on an interface"
Andy Gospodarek90e62472011-05-25 04:41:59 +0000175 "by setting active flag for all slaves; "
Andy Gospodarekebd8e492010-06-02 08:39:21 +0000176 "0 for never (default), 1 for always.");
Flavio Leitnerc2952c32010-10-05 14:23:59 +0000177module_param(resend_igmp, int, 0);
Andy Gospodarek90e62472011-05-25 04:41:59 +0000178MODULE_PARM_DESC(resend_igmp, "Number of IGMP membership reports to send on "
179 "link failure");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
181/*----------------------------- Global variables ----------------------------*/
182
Neil Hormane843fa52010-10-13 16:01:50 +0000183#ifdef CONFIG_NET_POLL_CONTROLLER
Neil Hormanfb4fa762010-12-06 09:05:50 +0000184atomic_t netpoll_block_tx = ATOMIC_INIT(0);
Neil Hormane843fa52010-10-13 16:01:50 +0000185#endif
186
Eric Dumazetf99189b2009-11-17 10:42:49 +0000187int bond_net_id __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000189static __be32 arp_target[BOND_MAX_ARP_TARGETS];
190static int arp_ip_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191static int bond_mode = BOND_MODE_ROUNDROBIN;
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000192static int xmit_hashtype = BOND_XMIT_POLICY_LAYER2;
193static int lacp_fast;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Holger Eitzenbergere97fd7c2008-12-09 23:10:38 -0800195const struct bond_parm_tbl bond_lacp_tbl[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{ "slow", AD_LACP_SLOW},
197{ "fast", AD_LACP_FAST},
198{ NULL, -1},
199};
200
Holger Eitzenbergere97fd7c2008-12-09 23:10:38 -0800201const struct bond_parm_tbl bond_mode_tbl[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{ "balance-rr", BOND_MODE_ROUNDROBIN},
203{ "active-backup", BOND_MODE_ACTIVEBACKUP},
204{ "balance-xor", BOND_MODE_XOR},
205{ "broadcast", BOND_MODE_BROADCAST},
206{ "802.3ad", BOND_MODE_8023AD},
207{ "balance-tlb", BOND_MODE_TLB},
208{ "balance-alb", BOND_MODE_ALB},
209{ NULL, -1},
210};
211
Holger Eitzenbergere97fd7c2008-12-09 23:10:38 -0800212const struct bond_parm_tbl xmit_hashtype_tbl[] = {
Jay Vosburgh169a3e62005-06-26 17:54:11 -0400213{ "layer2", BOND_XMIT_POLICY_LAYER2},
214{ "layer3+4", BOND_XMIT_POLICY_LAYER34},
Jay Vosburgh6f6652b2007-12-06 23:40:34 -0800215{ "layer2+3", BOND_XMIT_POLICY_LAYER23},
Jay Vosburgh169a3e62005-06-26 17:54:11 -0400216{ NULL, -1},
217};
218
Holger Eitzenbergere97fd7c2008-12-09 23:10:38 -0800219const struct bond_parm_tbl arp_validate_tbl[] = {
Jay Vosburghf5b2b962006-09-22 21:54:53 -0700220{ "none", BOND_ARP_VALIDATE_NONE},
221{ "active", BOND_ARP_VALIDATE_ACTIVE},
222{ "backup", BOND_ARP_VALIDATE_BACKUP},
223{ "all", BOND_ARP_VALIDATE_ALL},
224{ NULL, -1},
225};
226
Holger Eitzenbergere97fd7c2008-12-09 23:10:38 -0800227const struct bond_parm_tbl fail_over_mac_tbl[] = {
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700228{ "none", BOND_FOM_NONE},
229{ "active", BOND_FOM_ACTIVE},
230{ "follow", BOND_FOM_FOLLOW},
231{ NULL, -1},
232};
233
Jiri Pirkoa5499522009-09-25 03:28:09 +0000234const struct bond_parm_tbl pri_reselect_tbl[] = {
235{ "always", BOND_PRI_RESELECT_ALWAYS},
236{ "better", BOND_PRI_RESELECT_BETTER},
237{ "failure", BOND_PRI_RESELECT_FAILURE},
238{ NULL, -1},
239};
240
Jay Vosburghfd989c82008-11-04 17:51:16 -0800241struct bond_parm_tbl ad_select_tbl[] = {
242{ "stable", BOND_AD_STABLE},
243{ "bandwidth", BOND_AD_BANDWIDTH},
244{ "count", BOND_AD_COUNT},
245{ NULL, -1},
246};
247
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248/*-------------------------- Forward declarations ---------------------------*/
249
Stephen Hemminger181470f2009-06-12 19:02:52 +0000250static int bond_init(struct net_device *bond_dev);
Eric W. Biedermanc67dfb22009-10-29 14:18:24 +0000251static void bond_uninit(struct net_device *bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253/*---------------------------- General routines -----------------------------*/
254
Amerigo Wangbd33acc2011-03-06 21:58:46 +0000255const char *bond_mode_name(int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256{
Holger Eitzenberger77afc922008-12-09 23:08:09 -0800257 static const char *names[] = {
258 [BOND_MODE_ROUNDROBIN] = "load balancing (round-robin)",
259 [BOND_MODE_ACTIVEBACKUP] = "fault-tolerance (active-backup)",
260 [BOND_MODE_XOR] = "load balancing (xor)",
261 [BOND_MODE_BROADCAST] = "fault-tolerance (broadcast)",
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000262 [BOND_MODE_8023AD] = "IEEE 802.3ad Dynamic link aggregation",
Holger Eitzenberger77afc922008-12-09 23:08:09 -0800263 [BOND_MODE_TLB] = "transmit load balancing",
264 [BOND_MODE_ALB] = "adaptive load balancing",
265 };
266
267 if (mode < 0 || mode > BOND_MODE_ALB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 return "unknown";
Holger Eitzenberger77afc922008-12-09 23:08:09 -0800269
270 return names[mode];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
272
273/*---------------------------------- VLAN -----------------------------------*/
274
275/**
276 * bond_add_vlan - add a new vlan id on bond
277 * @bond: bond that got the notification
278 * @vlan_id: the vlan id to add
279 *
280 * Returns -ENOMEM if allocation failed.
281 */
282static int bond_add_vlan(struct bonding *bond, unsigned short vlan_id)
283{
284 struct vlan_entry *vlan;
285
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -0800286 pr_debug("bond: %s, vlan id %d\n",
Joe Perchesa4aee5c2009-12-13 20:06:07 -0800287 (bond ? bond->dev->name : "None"), vlan_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Brian Haley305d5522008-11-04 17:51:14 -0800289 vlan = kzalloc(sizeof(struct vlan_entry), GFP_KERNEL);
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000290 if (!vlan)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293 INIT_LIST_HEAD(&vlan->vlan_list);
294 vlan->vlan_id = vlan_id;
295
296 write_lock_bh(&bond->lock);
297
298 list_add_tail(&vlan->vlan_list, &bond->vlan_list);
299
300 write_unlock_bh(&bond->lock);
301
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -0800302 pr_debug("added VLAN ID %d on bond %s\n", vlan_id, bond->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 return 0;
305}
306
307/**
308 * bond_del_vlan - delete a vlan id from bond
309 * @bond: bond that got the notification
310 * @vlan_id: the vlan id to delete
311 *
312 * returns -ENODEV if @vlan_id was not found in @bond.
313 */
314static int bond_del_vlan(struct bonding *bond, unsigned short vlan_id)
315{
Pavel Emelyanov0883bec2008-05-17 21:10:10 -0700316 struct vlan_entry *vlan;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 int res = -ENODEV;
318
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -0800319 pr_debug("bond: %s, vlan id %d\n", bond->dev->name, vlan_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320
Neil Hormane843fa52010-10-13 16:01:50 +0000321 block_netpoll_tx();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 write_lock_bh(&bond->lock);
323
Pavel Emelyanov0883bec2008-05-17 21:10:10 -0700324 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 if (vlan->vlan_id == vlan_id) {
326 list_del(&vlan->vlan_list);
327
Holger Eitzenberger58402052008-12-09 23:07:13 -0800328 if (bond_is_lb(bond))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 bond_alb_clear_vlan(bond, vlan_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
Joe Perchesa4aee5c2009-12-13 20:06:07 -0800331 pr_debug("removed VLAN ID %d from bond %s\n",
332 vlan_id, bond->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334 kfree(vlan);
335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 res = 0;
337 goto out;
338 }
339 }
340
Joe Perchesa4aee5c2009-12-13 20:06:07 -0800341 pr_debug("couldn't find VLAN ID %d in bond %s\n",
342 vlan_id, bond->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344out:
345 write_unlock_bh(&bond->lock);
Neil Hormane843fa52010-10-13 16:01:50 +0000346 unblock_netpoll_tx();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 return res;
348}
349
350/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 * bond_next_vlan - safely skip to the next item in the vlans list.
352 * @bond: the bond we're working on
353 * @curr: item we're advancing from
354 *
355 * Returns %NULL if list is empty, bond->next_vlan if @curr is %NULL,
356 * or @curr->next otherwise (even if it is @curr itself again).
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000357 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 * Caller must hold bond->lock
359 */
360struct vlan_entry *bond_next_vlan(struct bonding *bond, struct vlan_entry *curr)
361{
362 struct vlan_entry *next, *last;
363
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000364 if (list_empty(&bond->vlan_list))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367 if (!curr) {
368 next = list_entry(bond->vlan_list.next,
369 struct vlan_entry, vlan_list);
370 } else {
371 last = list_entry(bond->vlan_list.prev,
372 struct vlan_entry, vlan_list);
373 if (last == curr) {
374 next = list_entry(bond->vlan_list.next,
375 struct vlan_entry, vlan_list);
376 } else {
377 next = list_entry(curr->vlan_list.next,
378 struct vlan_entry, vlan_list);
379 }
380 }
381
382 return next;
383}
384
385/**
386 * bond_dev_queue_xmit - Prepare skb for xmit.
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000387 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 * @bond: bond device that got this skb for tx.
389 * @skb: hw accel VLAN tagged skb to transmit
390 * @slave_dev: slave that is supposed to xmit this skbuff
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000392int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb,
393 struct net_device *slave_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394{
Ben Hutchings83874512010-12-13 08:19:28 +0000395 skb->dev = slave_dev;
Neil Horman374eeb52011-06-03 10:35:52 +0000396
Eric Dumazet5ee31c682012-06-12 06:03:51 +0000397 BUILD_BUG_ON(sizeof(skb->queue_mapping) !=
Jiri Pirkodf4ab5b2012-07-20 02:28:49 +0000398 sizeof(qdisc_skb_cb(skb)->slave_dev_queue_mapping));
399 skb->queue_mapping = qdisc_skb_cb(skb)->slave_dev_queue_mapping;
Neil Horman374eeb52011-06-03 10:35:52 +0000400
Amerigo Wange15c3c222012-08-10 01:24:45 +0000401 if (unlikely(netpoll_tx_running(bond->dev)))
Amerigo Wang8a8efa22011-02-17 23:43:32 +0000402 bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb);
Amerigo Wang080e4132011-02-17 23:43:33 +0000403 else
WANG Congf6dc31a2010-05-06 00:48:51 -0700404 dev_queue_xmit(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406 return 0;
407}
408
409/*
Jiri Pirkocc0e4072011-07-20 04:54:46 +0000410 * In the following 2 functions, bond_vlan_rx_add_vid and bond_vlan_rx_kill_vid,
411 * We don't protect the slave list iteration with a lock because:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 * a. This operation is performed in IOCTL context,
413 * b. The operation is protected by the RTNL semaphore in the 8021q code,
414 * c. Holding a lock with BH disabled while directly calling a base driver
415 * entry point is generally a BAD idea.
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000416 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 * The design of synchronization/protection for this operation in the 8021q
418 * module is good for one or more VLAN devices over a single physical device
419 * and cannot be extended for a teaming solution like bonding, so there is a
420 * potential race condition here where a net device from the vlan group might
421 * be referenced (either by a base driver or the 8021q code) while it is being
422 * removed from the system. However, it turns out we're not making matters
423 * worse, and if it works for regular VLAN usage it will work here too.
424*/
425
426/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 * bond_vlan_rx_add_vid - Propagates adding an id to slaves
428 * @bond_dev: bonding net device that got called
429 * @vid: vlan id being added
430 */
Patrick McHardy80d5c362013-04-19 02:04:28 +0000431static int bond_vlan_rx_add_vid(struct net_device *bond_dev,
432 __be16 proto, u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433{
Wang Chen454d7c92008-11-12 23:37:49 -0800434 struct bonding *bond = netdev_priv(bond_dev);
Jiri Pirko87002b02011-12-08 04:11:17 +0000435 struct slave *slave, *stop_at;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 int i, res;
437
438 bond_for_each_slave(bond, slave, i) {
Patrick McHardy80d5c362013-04-19 02:04:28 +0000439 res = vlan_vid_add(slave->dev, proto, vid);
Jiri Pirko87002b02011-12-08 04:11:17 +0000440 if (res)
441 goto unwind;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 }
443
444 res = bond_add_vlan(bond, vid);
445 if (res) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -0800446 pr_err("%s: Error: Failed to add vlan id %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 bond_dev->name, vid);
Jiri Pirko8e586132011-12-08 19:52:37 -0500448 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 }
Jiri Pirko8e586132011-12-08 19:52:37 -0500450
451 return 0;
Jiri Pirko87002b02011-12-08 04:11:17 +0000452
453unwind:
454 /* unwind from head to the slave that failed */
455 stop_at = slave;
456 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at)
Patrick McHardy80d5c362013-04-19 02:04:28 +0000457 vlan_vid_del(slave->dev, proto, vid);
Jiri Pirko87002b02011-12-08 04:11:17 +0000458
459 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460}
461
462/**
463 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
464 * @bond_dev: bonding net device that got called
465 * @vid: vlan id being removed
466 */
Patrick McHardy80d5c362013-04-19 02:04:28 +0000467static int bond_vlan_rx_kill_vid(struct net_device *bond_dev,
468 __be16 proto, u16 vid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469{
Wang Chen454d7c92008-11-12 23:37:49 -0800470 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 struct slave *slave;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 int i, res;
473
Jiri Pirko87002b02011-12-08 04:11:17 +0000474 bond_for_each_slave(bond, slave, i)
Patrick McHardy80d5c362013-04-19 02:04:28 +0000475 vlan_vid_del(slave->dev, proto, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
477 res = bond_del_vlan(bond, vid);
478 if (res) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -0800479 pr_err("%s: Error: Failed to remove vlan id %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 bond_dev->name, vid);
Jiri Pirko8e586132011-12-08 19:52:37 -0500481 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 }
Jiri Pirko8e586132011-12-08 19:52:37 -0500483
484 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
487static void bond_add_vlans_on_slave(struct bonding *bond, struct net_device *slave_dev)
488{
489 struct vlan_entry *vlan;
Jiri Pirko87002b02011-12-08 04:11:17 +0000490 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Jiri Pirko87002b02011-12-08 04:11:17 +0000492 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
Patrick McHardy80d5c362013-04-19 02:04:28 +0000493 res = vlan_vid_add(slave_dev, htons(ETH_P_8021Q),
494 vlan->vlan_id);
Jiri Pirko87002b02011-12-08 04:11:17 +0000495 if (res)
496 pr_warning("%s: Failed to add vlan id %d to device %s\n",
497 bond->dev->name, vlan->vlan_id,
498 slave_dev->name);
499 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
501
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000502static void bond_del_vlans_from_slave(struct bonding *bond,
503 struct net_device *slave_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504{
505 struct vlan_entry *vlan;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
Jay Vosburghf35188f2010-07-21 12:14:47 +0000508 if (!vlan->vlan_id)
509 continue;
Patrick McHardy80d5c362013-04-19 02:04:28 +0000510 vlan_vid_del(slave_dev, htons(ETH_P_8021Q), vlan->vlan_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512}
513
514/*------------------------------- Link status -------------------------------*/
515
516/*
Jay Vosburghff59c452006-03-27 13:27:43 -0800517 * Set the carrier state for the master according to the state of its
518 * slaves. If any slaves are up, the master is up. In 802.3ad mode,
519 * do special 802.3ad magic.
520 *
521 * Returns zero if carrier state does not change, nonzero if it does.
522 */
523static int bond_set_carrier(struct bonding *bond)
524{
525 struct slave *slave;
526 int i;
527
528 if (bond->slave_cnt == 0)
529 goto down;
530
531 if (bond->params.mode == BOND_MODE_8023AD)
532 return bond_3ad_set_carrier(bond);
533
534 bond_for_each_slave(bond, slave, i) {
535 if (slave->link == BOND_LINK_UP) {
536 if (!netif_carrier_ok(bond->dev)) {
537 netif_carrier_on(bond->dev);
538 return 1;
539 }
540 return 0;
541 }
542 }
543
544down:
545 if (netif_carrier_ok(bond->dev)) {
546 netif_carrier_off(bond->dev);
547 return 1;
548 }
549 return 0;
550}
551
552/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 * Get link speed and duplex from the slave's base driver
554 * using ethtool. If for some reason the call fails or the
Weiping Pan98f41f62011-10-31 17:20:48 +0000555 * values are invalid, set speed and duplex to -1,
Rick Jones13b95fb2012-04-26 11:20:30 +0000556 * and return.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 */
Rick Jones13b95fb2012-04-26 11:20:30 +0000558static void bond_update_speed_duplex(struct slave *slave)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
560 struct net_device *slave_dev = slave->dev;
Jiri Pirko4bc71cb2011-09-03 03:34:30 +0000561 struct ethtool_cmd ecmd;
David Decotigny5d305302011-04-13 15:22:31 +0000562 u32 slave_speed;
Matthew Wilcox61a44b92007-07-31 14:00:02 -0700563 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
Dan Carpenter589665f2011-11-04 08:21:38 +0000565 slave->speed = SPEED_UNKNOWN;
566 slave->duplex = DUPLEX_UNKNOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Jiri Pirko4bc71cb2011-09-03 03:34:30 +0000568 res = __ethtool_get_settings(slave_dev, &ecmd);
Matthew Wilcox61a44b92007-07-31 14:00:02 -0700569 if (res < 0)
Rick Jones13b95fb2012-04-26 11:20:30 +0000570 return;
Matthew Wilcox61a44b92007-07-31 14:00:02 -0700571
Jiri Pirko4bc71cb2011-09-03 03:34:30 +0000572 slave_speed = ethtool_cmd_speed(&ecmd);
Jiri Pirko6f92c662011-06-01 10:36:33 +0000573 if (slave_speed == 0 || slave_speed == ((__u32) -1))
Rick Jones13b95fb2012-04-26 11:20:30 +0000574 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Jiri Pirko4bc71cb2011-09-03 03:34:30 +0000576 switch (ecmd.duplex) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 case DUPLEX_FULL:
578 case DUPLEX_HALF:
579 break;
580 default:
Rick Jones13b95fb2012-04-26 11:20:30 +0000581 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 }
583
David Decotigny5d305302011-04-13 15:22:31 +0000584 slave->speed = slave_speed;
Jiri Pirko4bc71cb2011-09-03 03:34:30 +0000585 slave->duplex = ecmd.duplex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
Rick Jones13b95fb2012-04-26 11:20:30 +0000587 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588}
589
590/*
591 * if <dev> supports MII link status reporting, check its link status.
592 *
593 * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(),
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000594 * depending upon the setting of the use_carrier parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 *
596 * Return either BMSR_LSTATUS, meaning that the link is up (or we
597 * can't tell and just pretend it is), or 0, meaning that the link is
598 * down.
599 *
600 * If reporting is non-zero, instead of faking link up, return -1 if
601 * both ETHTOOL and MII ioctls fail (meaning the device does not
602 * support them). If use_carrier is set, return whatever it says.
603 * It'd be nice if there was a good way to tell if a driver supports
604 * netif_carrier, but there really isn't.
605 */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000606static int bond_check_dev_link(struct bonding *bond,
607 struct net_device *slave_dev, int reporting)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
Stephen Hemmingereb7cc592008-11-19 21:56:05 -0800609 const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
Jiri Bohacd9d52832009-10-28 22:23:54 -0700610 int (*ioctl)(struct net_device *, struct ifreq *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 struct ifreq ifr;
612 struct mii_ioctl_data *mii;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
Petri Gynther6c988852009-08-28 12:05:15 +0000614 if (!reporting && !netif_running(slave_dev))
615 return 0;
616
Stephen Hemmingereb7cc592008-11-19 21:56:05 -0800617 if (bond->params.use_carrier)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
Jiri Pirko29112f42009-04-24 01:58:23 +0000620 /* Try to get link status using Ethtool first. */
Ben Hutchingsc772dde2012-12-07 06:15:32 +0000621 if (slave_dev->ethtool_ops->get_link)
622 return slave_dev->ethtool_ops->get_link(slave_dev) ?
623 BMSR_LSTATUS : 0;
Jiri Pirko29112f42009-04-24 01:58:23 +0000624
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000625 /* Ethtool can't be used, fallback to MII ioctls. */
Stephen Hemmingereb7cc592008-11-19 21:56:05 -0800626 ioctl = slave_ops->ndo_do_ioctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 if (ioctl) {
628 /* TODO: set pointer to correct ioctl on a per team member */
629 /* bases to make this more efficient. that is, once */
630 /* we determine the correct ioctl, we will always */
631 /* call it and not the others for that team */
632 /* member. */
633
634 /*
635 * We cannot assume that SIOCGMIIPHY will also read a
636 * register; not all network drivers (e.g., e100)
637 * support that.
638 */
639
640 /* Yes, the mii is overlaid on the ifreq.ifr_ifru */
641 strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
642 mii = if_mii(&ifr);
643 if (IOCTL(slave_dev, &ifr, SIOCGMIIPHY) == 0) {
644 mii->reg_num = MII_BMSR;
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000645 if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0)
646 return mii->val_out & BMSR_LSTATUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 }
648 }
649
Matthew Wilcox61a44b92007-07-31 14:00:02 -0700650 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 * If reporting, report that either there's no dev->do_ioctl,
Matthew Wilcox61a44b92007-07-31 14:00:02 -0700652 * or both SIOCGMIIREG and get_link failed (meaning that we
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 * cannot report link status). If not reporting, pretend
654 * we're ok.
655 */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000656 return reporting ? -1 : BMSR_LSTATUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657}
658
659/*----------------------------- Multicast list ------------------------------*/
660
661/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 * Push the promiscuity flag down to appropriate slaves
663 */
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700664static int bond_set_promiscuity(struct bonding *bond, int inc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700666 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 if (USES_PRIMARY(bond->params.mode)) {
668 /* write lock already acquired */
669 if (bond->curr_active_slave) {
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700670 err = dev_set_promiscuity(bond->curr_active_slave->dev,
671 inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 }
673 } else {
674 struct slave *slave;
675 int i;
676 bond_for_each_slave(bond, slave, i) {
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700677 err = dev_set_promiscuity(slave->dev, inc);
678 if (err)
679 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 }
681 }
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700682 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683}
684
685/*
686 * Push the allmulti flag down to all slaves
687 */
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700688static int bond_set_allmulti(struct bonding *bond, int inc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689{
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700690 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 if (USES_PRIMARY(bond->params.mode)) {
692 /* write lock already acquired */
693 if (bond->curr_active_slave) {
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700694 err = dev_set_allmulti(bond->curr_active_slave->dev,
695 inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
697 } else {
698 struct slave *slave;
699 int i;
700 bond_for_each_slave(bond, slave, i) {
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700701 err = dev_set_allmulti(slave->dev, inc);
702 if (err)
703 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 }
705 }
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700706 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
708
709/*
710 * Add a Multicast address to slaves
711 * according to mode
712 */
Jiri Pirko22bedad32010-04-01 21:22:57 +0000713static void bond_mc_add(struct bonding *bond, void *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
715 if (USES_PRIMARY(bond->params.mode)) {
716 /* write lock already acquired */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000717 if (bond->curr_active_slave)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000718 dev_mc_add(bond->curr_active_slave->dev, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 } else {
720 struct slave *slave;
721 int i;
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000722
723 bond_for_each_slave(bond, slave, i)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000724 dev_mc_add(slave->dev, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 }
726}
727
728/*
729 * Remove a multicast address from slave
730 * according to mode
731 */
Jiri Pirko22bedad32010-04-01 21:22:57 +0000732static void bond_mc_del(struct bonding *bond, void *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733{
734 if (USES_PRIMARY(bond->params.mode)) {
735 /* write lock already acquired */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000736 if (bond->curr_active_slave)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000737 dev_mc_del(bond->curr_active_slave->dev, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 } else {
739 struct slave *slave;
740 int i;
741 bond_for_each_slave(bond, slave, i) {
Jiri Pirko22bedad32010-04-01 21:22:57 +0000742 dev_mc_del(slave->dev, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 }
744 }
745}
746
Jay Vosburgha816c7c2007-02-28 17:03:37 -0800747
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000748static void __bond_resend_igmp_join_requests(struct net_device *dev)
749{
750 struct in_device *in_dev;
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000751
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000752 in_dev = __in_dev_get_rcu(dev);
Eric Dumazet866f3b22010-11-18 09:33:19 -0800753 if (in_dev)
David S. Miller24912422010-11-19 13:13:47 -0800754 ip_mc_rejoin_groups(in_dev);
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000755}
756
Jay Vosburgha816c7c2007-02-28 17:03:37 -0800757/*
758 * Retrieve the list of registered multicast addresses for the bonding
759 * device and retransmit an IGMP JOIN request to the current active
760 * slave.
761 */
762static void bond_resend_igmp_join_requests(struct bonding *bond)
763{
Jiri Pirko471cb5a2013-01-03 22:49:01 +0000764 struct net_device *bond_dev, *vlan_dev, *upper_dev;
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000765 struct vlan_entry *vlan;
Jay Vosburgha816c7c2007-02-28 17:03:37 -0800766
Jiri Pirko471cb5a2013-01-03 22:49:01 +0000767 rcu_read_lock();
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000768 read_lock(&bond->lock);
769
Peter Pan(潘卫平)1c3ac422012-03-17 17:23:27 +0000770 bond_dev = bond->dev;
771
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000772 /* rejoin all groups on bond device */
Peter Pan(潘卫平)1c3ac422012-03-17 17:23:27 +0000773 __bond_resend_igmp_join_requests(bond_dev);
774
775 /*
776 * if bond is enslaved to a bridge,
777 * then rejoin all groups on its master
778 */
Jiri Pirko471cb5a2013-01-03 22:49:01 +0000779 upper_dev = netdev_master_upper_dev_get_rcu(bond_dev);
780 if (upper_dev && upper_dev->priv_flags & IFF_EBRIDGE)
781 __bond_resend_igmp_join_requests(upper_dev);
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000782
783 /* rejoin all groups on vlan devices */
Jiri Pirkocc0e4072011-07-20 04:54:46 +0000784 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
Patrick McHardy1fd9b1f2013-04-19 02:04:29 +0000785 vlan_dev = __vlan_find_dev_deep(bond_dev, htons(ETH_P_8021Q),
Jiri Pirkocc0e4072011-07-20 04:54:46 +0000786 vlan->vlan_id);
Jiri Pirkocc0e4072011-07-20 04:54:46 +0000787 if (vlan_dev)
788 __bond_resend_igmp_join_requests(vlan_dev);
Jay Vosburgha816c7c2007-02-28 17:03:37 -0800789 }
790
Jay Vosburghe6d265e2011-10-28 15:42:50 +0000791 if (--bond->igmp_retrans > 0)
Flavio Leitnerc2952c32010-10-05 14:23:59 +0000792 queue_delayed_work(bond->wq, &bond->mcast_work, HZ/5);
Jay Vosburghe6d265e2011-10-28 15:42:50 +0000793
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000794 read_unlock(&bond->lock);
Jiri Pirko471cb5a2013-01-03 22:49:01 +0000795 rcu_read_unlock();
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000796}
797
stephen hemminger379b7382010-10-15 11:02:56 +0000798static void bond_resend_igmp_join_requests_delayed(struct work_struct *work)
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000799{
800 struct bonding *bond = container_of(work, struct bonding,
Flavio Leitner94265cf2011-05-25 08:38:58 +0000801 mcast_work.work);
Veaceslav Falicoad999ee2013-03-26 04:10:02 +0000802
Flavio Leitner5a37e8c2010-10-05 14:23:57 +0000803 bond_resend_igmp_join_requests(bond);
Jay Vosburgha816c7c2007-02-28 17:03:37 -0800804}
805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 * flush all members of flush->mc_list from device dev->mc_list
808 */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000809static void bond_mc_list_flush(struct net_device *bond_dev,
810 struct net_device *slave_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811{
Wang Chen454d7c92008-11-12 23:37:49 -0800812 struct bonding *bond = netdev_priv(bond_dev);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000813 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Jiri Pirko22bedad32010-04-01 21:22:57 +0000815 netdev_for_each_mc_addr(ha, bond_dev)
816 dev_mc_del(slave_dev, ha->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
818 if (bond->params.mode == BOND_MODE_8023AD) {
819 /* del lacpdu mc addr from mc list */
820 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
821
Jiri Pirko22bedad32010-04-01 21:22:57 +0000822 dev_mc_del(slave_dev, lacpdu_multicast);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 }
824}
825
826/*--------------------------- Active slave change ---------------------------*/
827
828/*
829 * Update the mc list and multicast-related flags for the new and
830 * old active slaves (if any) according to the multicast mode, and
831 * promiscuous flags unconditionally.
832 */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000833static void bond_mc_swap(struct bonding *bond, struct slave *new_active,
834 struct slave *old_active)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835{
Jiri Pirko22bedad32010-04-01 21:22:57 +0000836 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000838 if (!USES_PRIMARY(bond->params.mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 /* nothing to do - mc list is already up-to-date on
840 * all slaves
841 */
842 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
844 if (old_active) {
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000845 if (bond->dev->flags & IFF_PROMISC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 dev_set_promiscuity(old_active->dev, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000848 if (bond->dev->flags & IFF_ALLMULTI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 dev_set_allmulti(old_active->dev, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
nikolay@redhat.comd632ce92013-04-18 07:33:38 +0000851 netif_addr_lock_bh(bond->dev);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000852 netdev_for_each_mc_addr(ha, bond->dev)
853 dev_mc_del(old_active->dev, ha->addr);
nikolay@redhat.comd632ce92013-04-18 07:33:38 +0000854 netif_addr_unlock_bh(bond->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 }
856
857 if (new_active) {
Wang Chen7e1a1ac2008-07-14 20:51:36 -0700858 /* FIXME: Signal errors upstream. */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000859 if (bond->dev->flags & IFF_PROMISC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 dev_set_promiscuity(new_active->dev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000862 if (bond->dev->flags & IFF_ALLMULTI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 dev_set_allmulti(new_active->dev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
nikolay@redhat.comd632ce92013-04-18 07:33:38 +0000865 netif_addr_lock_bh(bond->dev);
Jiri Pirko22bedad32010-04-01 21:22:57 +0000866 netdev_for_each_mc_addr(ha, bond->dev)
867 dev_mc_add(new_active->dev, ha->addr);
nikolay@redhat.comd632ce92013-04-18 07:33:38 +0000868 netif_addr_unlock_bh(bond->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 }
870}
871
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700872/*
873 * bond_do_fail_over_mac
874 *
875 * Perform special MAC address swapping for fail_over_mac settings
876 *
877 * Called with RTNL, bond->lock for read, curr_slave_lock for write_bh.
878 */
879static void bond_do_fail_over_mac(struct bonding *bond,
880 struct slave *new_active,
881 struct slave *old_active)
Hannes Eder1f78d9f2009-02-14 11:15:33 +0000882 __releases(&bond->curr_slave_lock)
883 __releases(&bond->lock)
884 __acquires(&bond->lock)
885 __acquires(&bond->curr_slave_lock)
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700886{
887 u8 tmp_mac[ETH_ALEN];
888 struct sockaddr saddr;
889 int rv;
890
891 switch (bond->params.fail_over_mac) {
892 case BOND_FOM_ACTIVE:
Weiping Pan7d26bb12012-03-27 19:18:24 +0000893 if (new_active) {
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700894 memcpy(bond->dev->dev_addr, new_active->dev->dev_addr,
895 new_active->dev->addr_len);
Weiping Pan7d26bb12012-03-27 19:18:24 +0000896 write_unlock_bh(&bond->curr_slave_lock);
897 read_unlock(&bond->lock);
898 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond->dev);
899 read_lock(&bond->lock);
900 write_lock_bh(&bond->curr_slave_lock);
901 }
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700902 break;
903 case BOND_FOM_FOLLOW:
904 /*
905 * if new_active && old_active, swap them
906 * if just old_active, do nothing (going to no active slave)
907 * if just new_active, set new_active to bond's MAC
908 */
909 if (!new_active)
910 return;
911
912 write_unlock_bh(&bond->curr_slave_lock);
913 read_unlock(&bond->lock);
914
915 if (old_active) {
916 memcpy(tmp_mac, new_active->dev->dev_addr, ETH_ALEN);
917 memcpy(saddr.sa_data, old_active->dev->dev_addr,
918 ETH_ALEN);
919 saddr.sa_family = new_active->dev->type;
920 } else {
921 memcpy(saddr.sa_data, bond->dev->dev_addr, ETH_ALEN);
922 saddr.sa_family = bond->dev->type;
923 }
924
925 rv = dev_set_mac_address(new_active->dev, &saddr);
926 if (rv) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -0800927 pr_err("%s: Error %d setting MAC of slave %s\n",
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700928 bond->dev->name, -rv, new_active->dev->name);
929 goto out;
930 }
931
932 if (!old_active)
933 goto out;
934
935 memcpy(saddr.sa_data, tmp_mac, ETH_ALEN);
936 saddr.sa_family = old_active->dev->type;
937
938 rv = dev_set_mac_address(old_active->dev, &saddr);
939 if (rv)
Joe Perchesa4aee5c2009-12-13 20:06:07 -0800940 pr_err("%s: Error %d setting MAC of slave %s\n",
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700941 bond->dev->name, -rv, new_active->dev->name);
942out:
943 read_lock(&bond->lock);
944 write_lock_bh(&bond->curr_slave_lock);
945 break;
946 default:
Joe Perchesa4aee5c2009-12-13 20:06:07 -0800947 pr_err("%s: bond_do_fail_over_mac impossible: bad policy %d\n",
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700948 bond->dev->name, bond->params.fail_over_mac);
949 break;
950 }
951
952}
953
Jiri Pirkoa5499522009-09-25 03:28:09 +0000954static bool bond_should_change_active(struct bonding *bond)
955{
956 struct slave *prim = bond->primary_slave;
957 struct slave *curr = bond->curr_active_slave;
958
959 if (!prim || !curr || curr->link != BOND_LINK_UP)
960 return true;
961 if (bond->force_primary) {
962 bond->force_primary = false;
963 return true;
964 }
965 if (bond->params.primary_reselect == BOND_PRI_RESELECT_BETTER &&
966 (prim->speed < curr->speed ||
967 (prim->speed == curr->speed && prim->duplex <= curr->duplex)))
968 return false;
969 if (bond->params.primary_reselect == BOND_PRI_RESELECT_FAILURE)
970 return false;
971 return true;
972}
Jay Vosburgh3915c1e82008-05-17 21:10:14 -0700973
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974/**
975 * find_best_interface - select the best available slave to be the active one
976 * @bond: our bonding struct
977 *
978 * Warning: Caller must hold curr_slave_lock for writing.
979 */
980static struct slave *bond_find_best_slave(struct bonding *bond)
981{
982 struct slave *new_active, *old_active;
983 struct slave *bestslave = NULL;
984 int mintime = bond->params.updelay;
985 int i;
986
Nicolas de Pesloüan49b4ad92009-10-07 14:11:00 -0700987 new_active = bond->curr_active_slave;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
989 if (!new_active) { /* there were no active slaves left */
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000990 if (bond->slave_cnt > 0) /* found one slave */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 new_active = bond->first_slave;
Stephen Hemminger3d632c32009-06-12 19:02:48 +0000992 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 return NULL; /* still no slave, return NULL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 }
995
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 if ((bond->primary_slave) &&
Jiri Pirkoa5499522009-09-25 03:28:09 +0000997 bond->primary_slave->link == BOND_LINK_UP &&
998 bond_should_change_active(bond)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 new_active = bond->primary_slave;
1000 }
1001
1002 /* remember where to stop iterating over the slaves */
1003 old_active = new_active;
1004
1005 bond_for_each_slave_from(bond, new_active, i, old_active) {
Jiri Pirkob9f60252009-08-31 11:09:38 +00001006 if (new_active->link == BOND_LINK_UP) {
1007 return new_active;
1008 } else if (new_active->link == BOND_LINK_BACK &&
1009 IS_UP(new_active->dev)) {
1010 /* link up, but waiting for stabilization */
1011 if (new_active->delay < mintime) {
1012 mintime = new_active->delay;
1013 bestslave = new_active;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 }
1015 }
1016 }
1017
1018 return bestslave;
1019}
1020
Ben Hutchingsad246c92011-04-26 15:25:52 +00001021static bool bond_should_notify_peers(struct bonding *bond)
1022{
1023 struct slave *slave = bond->curr_active_slave;
1024
1025 pr_debug("bond_should_notify_peers: bond %s slave %s\n",
1026 bond->dev->name, slave ? slave->dev->name : "NULL");
1027
1028 if (!slave || !bond->send_peer_notif ||
1029 test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state))
1030 return false;
1031
1032 bond->send_peer_notif--;
1033 return true;
1034}
1035
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036/**
1037 * change_active_interface - change the active slave into the specified one
1038 * @bond: our bonding struct
1039 * @new: the new slave to make the active one
1040 *
1041 * Set the new slave to the bond's settings and unset them on the old
1042 * curr_active_slave.
1043 * Setting include flags, mc-list, promiscuity, allmulti, etc.
1044 *
1045 * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP,
1046 * because it is apparently the best available slave we have, even though its
1047 * updelay hasn't timed out yet.
1048 *
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001049 * If new_active is not NULL, caller must hold bond->lock for read and
1050 * curr_slave_lock for write_bh.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 */
Mitch Williamsa77b5322005-11-09 10:35:51 -08001052void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053{
1054 struct slave *old_active = bond->curr_active_slave;
1055
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001056 if (old_active == new_active)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
1059 if (new_active) {
Jay Vosburghb2220ca2008-05-17 21:10:13 -07001060 new_active->jiffies = jiffies;
1061
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 if (new_active->link == BOND_LINK_BACK) {
1063 if (USES_PRIMARY(bond->params.mode)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001064 pr_info("%s: making interface %s the new active one %d ms earlier.\n",
1065 bond->dev->name, new_active->dev->name,
1066 (bond->params.updelay - new_active->delay) * bond->params.miimon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 }
1068
1069 new_active->delay = 0;
1070 new_active->link = BOND_LINK_UP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001072 if (bond->params.mode == BOND_MODE_8023AD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 bond_3ad_handle_link_change(new_active, BOND_LINK_UP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
Holger Eitzenberger58402052008-12-09 23:07:13 -08001075 if (bond_is_lb(bond))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 } else {
1078 if (USES_PRIMARY(bond->params.mode)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001079 pr_info("%s: making interface %s the new active one.\n",
1080 bond->dev->name, new_active->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 }
1082 }
1083 }
1084
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001085 if (USES_PRIMARY(bond->params.mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 bond_mc_swap(bond, new_active, old_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
Holger Eitzenberger58402052008-12-09 23:07:13 -08001088 if (bond_is_lb(bond)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 bond_alb_handle_active_change(bond, new_active);
Jay Vosburgh8f903c72006-02-21 16:36:44 -08001090 if (old_active)
1091 bond_set_slave_inactive_flags(old_active);
1092 if (new_active)
1093 bond_set_slave_active_flags(new_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 } else {
1095 bond->curr_active_slave = new_active;
1096 }
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04001097
1098 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001099 if (old_active)
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04001100 bond_set_slave_inactive_flags(old_active);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04001101
1102 if (new_active) {
Ben Hutchingsad246c92011-04-26 15:25:52 +00001103 bool should_notify_peers = false;
1104
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04001105 bond_set_slave_active_flags(new_active);
Moni Shoua2ab82852007-10-09 19:43:39 -07001106
Or Gerlitz709f8a42008-06-13 18:12:01 -07001107 if (bond->params.fail_over_mac)
1108 bond_do_fail_over_mac(bond, new_active,
1109 old_active);
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001110
Ben Hutchingsad246c92011-04-26 15:25:52 +00001111 if (netif_running(bond->dev)) {
1112 bond->send_peer_notif =
1113 bond->params.num_peer_notif;
1114 should_notify_peers =
1115 bond_should_notify_peers(bond);
1116 }
1117
Or Gerlitz01f31092008-06-13 18:12:02 -07001118 write_unlock_bh(&bond->curr_slave_lock);
1119 read_unlock(&bond->lock);
1120
Amerigo Wangb7bc2a52012-08-09 22:14:57 +00001121 call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, bond->dev);
Ben Hutchingsad246c92011-04-26 15:25:52 +00001122 if (should_notify_peers)
Amerigo Wangb7bc2a52012-08-09 22:14:57 +00001123 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS,
1124 bond->dev);
Or Gerlitz01f31092008-06-13 18:12:02 -07001125
1126 read_lock(&bond->lock);
1127 write_lock_bh(&bond->curr_slave_lock);
Moni Shoua7893b242008-05-17 21:10:12 -07001128 }
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04001129 }
Andy Gospodareka2fd9402010-03-25 14:49:05 +00001130
Flavio Leitner5a37e8c2010-10-05 14:23:57 +00001131 /* resend IGMP joins since active slave has changed or
Flavio Leitner94265cf2011-05-25 08:38:58 +00001132 * all were sent on curr_active_slave.
1133 * resend only if bond is brought up with the affected
1134 * bonding modes and the retransmission is enabled */
1135 if (netif_running(bond->dev) && (bond->params.resend_igmp > 0) &&
1136 ((USES_PRIMARY(bond->params.mode) && new_active) ||
1137 bond->params.mode == BOND_MODE_ROUNDROBIN)) {
Flavio Leitnerc2952c32010-10-05 14:23:59 +00001138 bond->igmp_retrans = bond->params.resend_igmp;
Flavio Leitner5a37e8c2010-10-05 14:23:57 +00001139 queue_delayed_work(bond->wq, &bond->mcast_work, 0);
Andy Gospodareka2fd9402010-03-25 14:49:05 +00001140 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141}
1142
1143/**
1144 * bond_select_active_slave - select a new active slave, if needed
1145 * @bond: our bonding struct
1146 *
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001147 * This functions should be called when one of the following occurs:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 * - The old curr_active_slave has been released or lost its link.
1149 * - The primary_slave has got its link back.
1150 * - A slave has got its link back and there's no old curr_active_slave.
1151 *
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001152 * Caller must hold bond->lock for read and curr_slave_lock for write_bh.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 */
Mitch Williamsa77b5322005-11-09 10:35:51 -08001154void bond_select_active_slave(struct bonding *bond)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155{
1156 struct slave *best_slave;
Jay Vosburghff59c452006-03-27 13:27:43 -08001157 int rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
1159 best_slave = bond_find_best_slave(bond);
1160 if (best_slave != bond->curr_active_slave) {
1161 bond_change_active_slave(bond, best_slave);
Jay Vosburghff59c452006-03-27 13:27:43 -08001162 rv = bond_set_carrier(bond);
1163 if (!rv)
1164 return;
1165
1166 if (netif_carrier_ok(bond->dev)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001167 pr_info("%s: first active interface up!\n",
1168 bond->dev->name);
Jay Vosburghff59c452006-03-27 13:27:43 -08001169 } else {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001170 pr_info("%s: now running without any active interface !\n",
1171 bond->dev->name);
Jay Vosburghff59c452006-03-27 13:27:43 -08001172 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 }
1174}
1175
1176/*--------------------------- slave list handling ---------------------------*/
1177
1178/*
1179 * This function attaches the slave to the end of list.
1180 *
1181 * bond->lock held for writing by caller.
1182 */
1183static void bond_attach_slave(struct bonding *bond, struct slave *new_slave)
1184{
1185 if (bond->first_slave == NULL) { /* attaching the first slave */
1186 new_slave->next = new_slave;
1187 new_slave->prev = new_slave;
1188 bond->first_slave = new_slave;
1189 } else {
1190 new_slave->next = bond->first_slave;
1191 new_slave->prev = bond->first_slave->prev;
1192 new_slave->next->prev = new_slave;
1193 new_slave->prev->next = new_slave;
1194 }
1195
1196 bond->slave_cnt++;
1197}
1198
1199/*
1200 * This function detaches the slave from the list.
1201 * WARNING: no check is made to verify if the slave effectively
1202 * belongs to <bond>.
1203 * Nothing is freed on return, structures are just unchained.
1204 * If any slave pointer in bond was pointing to <slave>,
1205 * it should be changed by the calling function.
1206 *
1207 * bond->lock held for writing by caller.
1208 */
1209static void bond_detach_slave(struct bonding *bond, struct slave *slave)
1210{
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001211 if (slave->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 slave->next->prev = slave->prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001214 if (slave->prev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 slave->prev->next = slave->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216
1217 if (bond->first_slave == slave) { /* slave is the first slave */
1218 if (bond->slave_cnt > 1) { /* there are more slave */
1219 bond->first_slave = slave->next;
1220 } else {
1221 bond->first_slave = NULL; /* slave was the last one */
1222 }
1223 }
1224
1225 slave->next = NULL;
1226 slave->prev = NULL;
1227 bond->slave_cnt--;
1228}
1229
WANG Congf6dc31a2010-05-06 00:48:51 -07001230#ifdef CONFIG_NET_POLL_CONTROLLER
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001231static inline int slave_enable_netpoll(struct slave *slave)
WANG Congf6dc31a2010-05-06 00:48:51 -07001232{
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001233 struct netpoll *np;
1234 int err = 0;
WANG Congf6dc31a2010-05-06 00:48:51 -07001235
Amerigo Wang47be03a22012-08-10 01:24:37 +00001236 np = kzalloc(sizeof(*np), GFP_ATOMIC);
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001237 err = -ENOMEM;
1238 if (!np)
1239 goto out;
1240
Amerigo Wang47be03a22012-08-10 01:24:37 +00001241 err = __netpoll_setup(np, slave->dev, GFP_ATOMIC);
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001242 if (err) {
1243 kfree(np);
1244 goto out;
WANG Congf6dc31a2010-05-06 00:48:51 -07001245 }
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001246 slave->np = np;
1247out:
1248 return err;
1249}
1250static inline void slave_disable_netpoll(struct slave *slave)
1251{
1252 struct netpoll *np = slave->np;
1253
1254 if (!np)
1255 return;
1256
1257 slave->np = NULL;
Neil Horman2cde6ac2013-02-11 10:25:30 +00001258 __netpoll_free_async(np);
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001259}
1260static inline bool slave_dev_support_netpoll(struct net_device *slave_dev)
1261{
1262 if (slave_dev->priv_flags & IFF_DISABLE_NETPOLL)
1263 return false;
1264 if (!slave_dev->netdev_ops->ndo_poll_controller)
1265 return false;
1266 return true;
WANG Congf6dc31a2010-05-06 00:48:51 -07001267}
1268
1269static void bond_poll_controller(struct net_device *bond_dev)
1270{
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001271}
1272
1273static void __bond_netpoll_cleanup(struct bonding *bond)
1274{
Neil Hormanc2355e12010-10-13 16:01:49 +00001275 struct slave *slave;
1276 int i;
1277
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001278 bond_for_each_slave(bond, slave, i)
1279 if (IS_UP(slave->dev))
1280 slave_disable_netpoll(slave);
WANG Congf6dc31a2010-05-06 00:48:51 -07001281}
WANG Congf6dc31a2010-05-06 00:48:51 -07001282static void bond_netpoll_cleanup(struct net_device *bond_dev)
1283{
1284 struct bonding *bond = netdev_priv(bond_dev);
WANG Congf6dc31a2010-05-06 00:48:51 -07001285
1286 read_lock(&bond->lock);
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001287 __bond_netpoll_cleanup(bond);
WANG Congf6dc31a2010-05-06 00:48:51 -07001288 read_unlock(&bond->lock);
1289}
1290
Amerigo Wang47be03a22012-08-10 01:24:37 +00001291static int bond_netpoll_setup(struct net_device *dev, struct netpoll_info *ni, gfp_t gfp)
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001292{
1293 struct bonding *bond = netdev_priv(dev);
1294 struct slave *slave;
1295 int i, err = 0;
WANG Congf6dc31a2010-05-06 00:48:51 -07001296
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001297 read_lock(&bond->lock);
1298 bond_for_each_slave(bond, slave, i) {
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001299 err = slave_enable_netpoll(slave);
1300 if (err) {
1301 __bond_netpoll_cleanup(bond);
1302 break;
1303 }
1304 }
1305 read_unlock(&bond->lock);
1306 return err;
1307}
1308
1309static struct netpoll_info *bond_netpoll_info(struct bonding *bond)
1310{
1311 return bond->dev->npinfo;
1312}
1313
1314#else
1315static inline int slave_enable_netpoll(struct slave *slave)
1316{
1317 return 0;
1318}
1319static inline void slave_disable_netpoll(struct slave *slave)
1320{
1321}
WANG Congf6dc31a2010-05-06 00:48:51 -07001322static void bond_netpoll_cleanup(struct net_device *bond_dev)
1323{
1324}
WANG Congf6dc31a2010-05-06 00:48:51 -07001325#endif
1326
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327/*---------------------------------- IOCTL ----------------------------------*/
1328
Jiri Pirko409cc1f2013-01-30 11:08:11 +01001329static void bond_set_dev_addr(struct net_device *bond_dev,
1330 struct net_device *slave_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331{
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08001332 pr_debug("bond_dev=%p\n", bond_dev);
1333 pr_debug("slave_dev=%p\n", slave_dev);
1334 pr_debug("slave_dev->addr_len=%d\n", slave_dev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
Jiri Pirko409cc1f2013-01-30 11:08:11 +01001336 bond_dev->addr_assign_type = NET_ADDR_SET;
1337 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338}
1339
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001340static netdev_features_t bond_fix_features(struct net_device *dev,
1341 netdev_features_t features)
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001342{
1343 struct slave *slave;
1344 struct bonding *bond = netdev_priv(dev);
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001345 netdev_features_t mask;
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001346 int i;
Arthur Kepner8531c5f2005-08-23 01:34:53 -04001347
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001348 read_lock(&bond->lock);
1349
1350 if (!bond->first_slave) {
1351 /* Disable adding VLANs to empty bond. But why? --mq */
1352 features |= NETIF_F_VLAN_CHALLENGED;
1353 goto out;
1354 }
1355
1356 mask = features;
1357 features &= ~NETIF_F_ONE_FOR_ALL;
1358 features |= NETIF_F_ALL_FOR_ALL;
1359
1360 bond_for_each_slave(bond, slave, i) {
1361 features = netdev_increment_features(features,
1362 slave->dev->features,
1363 mask);
1364 }
Eric Dumazetb0ce3502013-05-16 07:34:53 +00001365 features = netdev_add_tso_features(features, mask);
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001366
1367out:
1368 read_unlock(&bond->lock);
1369 return features;
1370}
1371
Michał Mirosław62f2a3a2011-07-13 14:10:29 +00001372#define BOND_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
1373 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
1374 NETIF_F_HIGHDMA | NETIF_F_LRO)
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001375
1376static void bond_compute_features(struct bonding *bond)
Arthur Kepner8531c5f2005-08-23 01:34:53 -04001377{
Arthur Kepner8531c5f2005-08-23 01:34:53 -04001378 struct slave *slave;
1379 struct net_device *bond_dev = bond->dev;
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001380 netdev_features_t vlan_features = BOND_VLAN_FEATURES;
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001381 unsigned short max_hard_header_len = ETH_HLEN;
Sarveshwar Bandi0e376bd2012-11-21 04:35:03 +00001382 unsigned int gso_max_size = GSO_MAX_SIZE;
1383 u16 gso_max_segs = GSO_MAX_SEGS;
Jay Vosburgh8e3babc2005-11-04 18:45:45 -08001384 int i;
Eric Dumazetb6fe83e2012-07-17 12:19:48 +00001385 unsigned int flags, dst_release_flag = IFF_XMIT_DST_RELEASE;
Arthur Kepner8531c5f2005-08-23 01:34:53 -04001386
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001387 read_lock(&bond->lock);
Herbert Xub63365a2008-10-23 01:11:29 -07001388
1389 if (!bond->first_slave)
1390 goto done;
1391
Jay Vosburgh54ef3132006-09-22 21:53:39 -07001392 bond_for_each_slave(bond, slave, i) {
Jay Vosburgh278339a2009-08-28 12:05:12 +00001393 vlan_features = netdev_increment_features(vlan_features,
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001394 slave->dev->vlan_features, BOND_VLAN_FEATURES);
1395
Eric Dumazetb6fe83e2012-07-17 12:19:48 +00001396 dst_release_flag &= slave->dev->priv_flags;
Jay Vosburgh54ef3132006-09-22 21:53:39 -07001397 if (slave->dev->hard_header_len > max_hard_header_len)
1398 max_hard_header_len = slave->dev->hard_header_len;
Sarveshwar Bandi0e376bd2012-11-21 04:35:03 +00001399
1400 gso_max_size = min(gso_max_size, slave->dev->gso_max_size);
1401 gso_max_segs = min(gso_max_segs, slave->dev->gso_max_segs);
Jay Vosburgh54ef3132006-09-22 21:53:39 -07001402 }
Arthur Kepner8531c5f2005-08-23 01:34:53 -04001403
Herbert Xub63365a2008-10-23 01:11:29 -07001404done:
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001405 bond_dev->vlan_features = vlan_features;
Jay Vosburgh54ef3132006-09-22 21:53:39 -07001406 bond_dev->hard_header_len = max_hard_header_len;
Sarveshwar Bandi0e376bd2012-11-21 04:35:03 +00001407 bond_dev->gso_max_segs = gso_max_segs;
1408 netif_set_gso_max_size(bond_dev, gso_max_size);
Arthur Kepner8531c5f2005-08-23 01:34:53 -04001409
Eric Dumazetb6fe83e2012-07-17 12:19:48 +00001410 flags = bond_dev->priv_flags & ~IFF_XMIT_DST_RELEASE;
1411 bond_dev->priv_flags = flags | dst_release_flag;
1412
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001413 read_unlock(&bond->lock);
1414
1415 netdev_change_features(bond_dev);
Arthur Kepner8531c5f2005-08-23 01:34:53 -04001416}
1417
Moni Shoua872254d2007-10-09 19:43:38 -07001418static void bond_setup_by_slave(struct net_device *bond_dev,
1419 struct net_device *slave_dev)
1420{
Wang Chen454d7c92008-11-12 23:37:49 -08001421 struct bonding *bond = netdev_priv(bond_dev);
Moni Shouad90a1622007-10-09 19:43:43 -07001422
Stephen Hemminger00829822008-11-20 20:14:53 -08001423 bond_dev->header_ops = slave_dev->header_ops;
Moni Shoua872254d2007-10-09 19:43:38 -07001424
1425 bond_dev->type = slave_dev->type;
1426 bond_dev->hard_header_len = slave_dev->hard_header_len;
1427 bond_dev->addr_len = slave_dev->addr_len;
1428
1429 memcpy(bond_dev->broadcast, slave_dev->broadcast,
1430 slave_dev->addr_len);
Moni Shouad90a1622007-10-09 19:43:43 -07001431 bond->setup_by_slave = 1;
Moni Shoua872254d2007-10-09 19:43:38 -07001432}
1433
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001434/* On bonding slaves other than the currently active slave, suppress
Jiri Pirko3aba8912011-04-19 03:48:16 +00001435 * duplicates except for alb non-mcast/bcast.
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001436 */
1437static bool bond_should_deliver_exact_match(struct sk_buff *skb,
Jiri Pirko0bd80da2011-03-16 08:45:23 +00001438 struct slave *slave,
1439 struct bonding *bond)
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001440{
Jiri Pirko2d7011c2011-03-16 08:46:43 +00001441 if (bond_is_slave_inactive(slave)) {
Jiri Pirko0bd80da2011-03-16 08:45:23 +00001442 if (bond->params.mode == BOND_MODE_ALB &&
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001443 skb->pkt_type != PACKET_BROADCAST &&
1444 skb->pkt_type != PACKET_MULTICAST)
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001445 return false;
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001446 return true;
1447 }
1448 return false;
1449}
1450
Jiri Pirko8a4eb572011-03-12 03:14:39 +00001451static rx_handler_result_t bond_handle_frame(struct sk_buff **pskb)
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001452{
Jiri Pirko8a4eb572011-03-12 03:14:39 +00001453 struct sk_buff *skb = *pskb;
Jiri Pirkof1c17752011-03-12 03:14:35 +00001454 struct slave *slave;
Jiri Pirko0bd80da2011-03-16 08:45:23 +00001455 struct bonding *bond;
Eric Dumazetde063b72012-06-11 19:23:07 +00001456 int (*recv_probe)(const struct sk_buff *, struct bonding *,
1457 struct slave *);
Jiri Bohac13a8e0c2012-05-09 01:01:40 +00001458 int ret = RX_HANDLER_ANOTHER;
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001459
Jiri Pirko8a4eb572011-03-12 03:14:39 +00001460 skb = skb_share_check(skb, GFP_ATOMIC);
1461 if (unlikely(!skb))
1462 return RX_HANDLER_CONSUMED;
1463
1464 *pskb = skb;
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001465
Jiri Pirko35d48902011-03-22 02:38:12 +00001466 slave = bond_slave_get_rcu(skb->dev);
1467 bond = slave->bond;
Jiri Pirko0bd80da2011-03-16 08:45:23 +00001468
1469 if (bond->params.arp_interval)
Jiri Pirkof1c17752011-03-12 03:14:35 +00001470 slave->dev->last_rx = jiffies;
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001471
Mitsuo Hayasaka4d974802011-10-12 16:04:29 +00001472 recv_probe = ACCESS_ONCE(bond->recv_probe);
1473 if (recv_probe) {
Eric Dumazetde063b72012-06-11 19:23:07 +00001474 ret = recv_probe(skb, bond, slave);
1475 if (ret == RX_HANDLER_CONSUMED) {
1476 consume_skb(skb);
1477 return ret;
Jiri Pirko3aba8912011-04-19 03:48:16 +00001478 }
1479 }
1480
Jiri Pirko0bd80da2011-03-16 08:45:23 +00001481 if (bond_should_deliver_exact_match(skb, slave, bond)) {
Jiri Pirko8a4eb572011-03-12 03:14:39 +00001482 return RX_HANDLER_EXACT;
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001483 }
1484
Jiri Pirko35d48902011-03-22 02:38:12 +00001485 skb->dev = bond->dev;
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001486
Jiri Pirko0bd80da2011-03-16 08:45:23 +00001487 if (bond->params.mode == BOND_MODE_ALB &&
Jiri Pirko35d48902011-03-22 02:38:12 +00001488 bond->dev->priv_flags & IFF_BRIDGE_PORT &&
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001489 skb->pkt_type == PACKET_HOST) {
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001490
Changli Gao541ac7c2011-03-02 21:07:14 +00001491 if (unlikely(skb_cow_head(skb,
1492 skb->data - skb_mac_header(skb)))) {
1493 kfree_skb(skb);
Jiri Pirko8a4eb572011-03-12 03:14:39 +00001494 return RX_HANDLER_CONSUMED;
Changli Gao541ac7c2011-03-02 21:07:14 +00001495 }
Jiri Pirko35d48902011-03-22 02:38:12 +00001496 memcpy(eth_hdr(skb)->h_dest, bond->dev->dev_addr, ETH_ALEN);
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001497 }
1498
Jiri Bohac13a8e0c2012-05-09 01:01:40 +00001499 return ret;
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001500}
1501
Jiri Pirko471cb5a2013-01-03 22:49:01 +00001502static int bond_master_upper_dev_link(struct net_device *bond_dev,
1503 struct net_device *slave_dev)
1504{
1505 int err;
1506
1507 err = netdev_master_upper_dev_link(slave_dev, bond_dev);
1508 if (err)
1509 return err;
1510 slave_dev->flags |= IFF_SLAVE;
1511 rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE);
1512 return 0;
1513}
1514
1515static void bond_upper_dev_unlink(struct net_device *bond_dev,
1516 struct net_device *slave_dev)
1517{
1518 netdev_upper_dev_unlink(slave_dev, bond_dev);
1519 slave_dev->flags &= ~IFF_SLAVE;
1520 rtmsg_ifinfo(RTM_NEWLINK, slave_dev, IFF_SLAVE);
1521}
1522
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523/* enslave device <slave> to bond device <master> */
Mitch Williamsa77b5322005-11-09 10:35:51 -08001524int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525{
Wang Chen454d7c92008-11-12 23:37:49 -08001526 struct bonding *bond = netdev_priv(bond_dev);
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08001527 const struct net_device_ops *slave_ops = slave_dev->netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 struct slave *new_slave = NULL;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001529 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 struct sockaddr addr;
1531 int link_reporting;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 int res = 0;
1533
Ben Hutchingsc772dde2012-12-07 06:15:32 +00001534 if (!bond->params.use_carrier &&
1535 slave_dev->ethtool_ops->get_link == NULL &&
1536 slave_ops->ndo_do_ioctl == NULL) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001537 pr_warning("%s: Warning: no link monitoring support for %s\n",
1538 bond_dev->name, slave_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 }
1540
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 /* already enslaved */
1542 if (slave_dev->flags & IFF_SLAVE) {
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08001543 pr_debug("Error, Device was already enslaved\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 return -EBUSY;
1545 }
1546
1547 /* vlan challenged mutual exclusion */
1548 /* no need to lock since we're protected by rtnl_lock */
1549 if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) {
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08001550 pr_debug("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
Jiri Pirko55462cf2012-10-14 04:30:56 +00001551 if (vlan_uses_dev(bond_dev)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001552 pr_err("%s: Error: cannot enslave VLAN challenged slave %s on VLAN enabled bond %s\n",
1553 bond_dev->name, slave_dev->name, bond_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 return -EPERM;
1555 } else {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001556 pr_warning("%s: Warning: enslaved VLAN challenged slave %s. Adding VLANs will be blocked as long as %s is part of bond %s\n",
1557 bond_dev->name, slave_dev->name,
1558 slave_dev->name, bond_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 }
1560 } else {
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08001561 pr_debug("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 }
1563
Jay Vosburgh217df672005-09-26 16:11:50 -07001564 /*
1565 * Old ifenslave binaries are no longer supported. These can
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001566 * be identified with moderate accuracy by the state of the slave:
Jay Vosburgh217df672005-09-26 16:11:50 -07001567 * the current ifenslave will set the interface down prior to
1568 * enslaving it; the old ifenslave will not.
1569 */
1570 if ((slave_dev->flags & IFF_UP)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001571 pr_err("%s is up. This may be due to an out of date ifenslave.\n",
Jay Vosburgh217df672005-09-26 16:11:50 -07001572 slave_dev->name);
1573 res = -EPERM;
1574 goto err_undo_flags;
1575 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
Moni Shoua872254d2007-10-09 19:43:38 -07001577 /* set bonding device ether type by slave - bonding netdevices are
1578 * created with ether_setup, so when the slave type is not ARPHRD_ETHER
1579 * there is a need to override some of the type dependent attribs/funcs.
1580 *
1581 * bond ether type mutual exclusion - don't allow slaves of dissimilar
1582 * ether type (eg ARPHRD_ETHER and ARPHRD_INFINIBAND) share the same bond
1583 */
1584 if (bond->slave_cnt == 0) {
Moni Shouae36b9d12009-07-15 04:56:31 +00001585 if (bond_dev->type != slave_dev->type) {
Moni Shouae36b9d12009-07-15 04:56:31 +00001586 pr_debug("%s: change device type from %d to %d\n",
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001587 bond_dev->name,
1588 bond_dev->type, slave_dev->type);
Moni Shoua75c78502009-09-15 02:37:40 -07001589
Amerigo Wangb7bc2a52012-08-09 22:14:57 +00001590 res = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE,
1591 bond_dev);
Jiri Pirko3ca5b402010-03-10 10:29:35 +00001592 res = notifier_to_errno(res);
1593 if (res) {
1594 pr_err("%s: refused to change device type\n",
1595 bond_dev->name);
1596 res = -EBUSY;
1597 goto err_undo_flags;
1598 }
Moni Shoua75c78502009-09-15 02:37:40 -07001599
Jiri Pirko32a806c2010-03-19 04:00:23 +00001600 /* Flush unicast and multicast addresses */
Jiri Pirkoa748ee22010-04-01 21:22:09 +00001601 dev_uc_flush(bond_dev);
Jiri Pirko22bedad32010-04-01 21:22:57 +00001602 dev_mc_flush(bond_dev);
Jiri Pirko32a806c2010-03-19 04:00:23 +00001603
Moni Shouae36b9d12009-07-15 04:56:31 +00001604 if (slave_dev->type != ARPHRD_ETHER)
1605 bond_setup_by_slave(bond_dev, slave_dev);
Neil Horman550fd082011-07-26 06:05:38 +00001606 else {
Moni Shouae36b9d12009-07-15 04:56:31 +00001607 ether_setup(bond_dev);
Neil Horman550fd082011-07-26 06:05:38 +00001608 bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1609 }
Moni Shoua75c78502009-09-15 02:37:40 -07001610
Amerigo Wangb7bc2a52012-08-09 22:14:57 +00001611 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE,
1612 bond_dev);
Moni Shouae36b9d12009-07-15 04:56:31 +00001613 }
Moni Shoua872254d2007-10-09 19:43:38 -07001614 } else if (bond_dev->type != slave_dev->type) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001615 pr_err("%s ether type (%d) is different from other slaves (%d), can not enslave it.\n",
1616 slave_dev->name,
1617 slave_dev->type, bond_dev->type);
1618 res = -EINVAL;
1619 goto err_undo_flags;
Moni Shoua872254d2007-10-09 19:43:38 -07001620 }
1621
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08001622 if (slave_ops->ndo_set_mac_address == NULL) {
Moni Shoua2ab82852007-10-09 19:43:39 -07001623 if (bond->slave_cnt == 0) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001624 pr_warning("%s: Warning: The first slave device specified does not support setting the MAC address. Setting fail_over_mac to active.",
1625 bond_dev->name);
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001626 bond->params.fail_over_mac = BOND_FOM_ACTIVE;
1627 } else if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001628 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",
1629 bond_dev->name);
Moni Shoua2ab82852007-10-09 19:43:39 -07001630 res = -EOPNOTSUPP;
1631 goto err_undo_flags;
1632 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 }
1634
Amerigo Wang8d8fc292011-05-19 21:39:10 +00001635 call_netdevice_notifiers(NETDEV_JOIN, slave_dev);
1636
Jiri Pirkoc20811a2010-05-19 01:14:29 +00001637 /* If this is the first slave, then we need to set the master's hardware
1638 * address to be the same as the slave's. */
Jiri Pirko6c8c4e42013-02-25 22:26:15 +00001639 if (bond->slave_cnt == 0 && bond->dev_addr_from_first)
Jiri Pirko409cc1f2013-01-30 11:08:11 +01001640 bond_set_dev_addr(bond->dev, slave_dev);
Jiri Pirkoc20811a2010-05-19 01:14:29 +00001641
Joe Jin243cb4e2007-02-06 14:16:40 -08001642 new_slave = kzalloc(sizeof(struct slave), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 if (!new_slave) {
1644 res = -ENOMEM;
1645 goto err_undo_flags;
1646 }
1647
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00001648 /*
1649 * Set the new_slave's queue_id to be zero. Queue ID mapping
1650 * is set via sysfs or module option if desired.
1651 */
1652 new_slave->queue_id = 0;
1653
Jiri Pirkob15ba0f2010-05-18 05:42:40 +00001654 /* Save slave's original mtu and then set it to match the bond */
1655 new_slave->original_mtu = slave_dev->mtu;
1656 res = dev_set_mtu(slave_dev, bond->dev->mtu);
1657 if (res) {
1658 pr_debug("Error %d calling dev_set_mtu\n", res);
1659 goto err_free;
1660 }
1661
Jay Vosburgh217df672005-09-26 16:11:50 -07001662 /*
1663 * Save slave's original ("permanent") mac address for modes
1664 * that need it, and for restoring it upon release, and then
1665 * set it to the master's address
1666 */
1667 memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
Jay Vosburghdd957c52007-10-09 19:57:24 -07001669 if (!bond->params.fail_over_mac) {
Moni Shoua2ab82852007-10-09 19:43:39 -07001670 /*
1671 * Set slave to master's mac address. The application already
1672 * set the master's mac address to that of the first slave
1673 */
1674 memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
1675 addr.sa_family = slave_dev->type;
1676 res = dev_set_mac_address(slave_dev, &addr);
1677 if (res) {
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08001678 pr_debug("Error %d calling set_mac_address\n", res);
Jiri Pirkob15ba0f2010-05-18 05:42:40 +00001679 goto err_restore_mtu;
Moni Shoua2ab82852007-10-09 19:43:39 -07001680 }
Jay Vosburgh217df672005-09-26 16:11:50 -07001681 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682
Jiri Pirko471cb5a2013-01-03 22:49:01 +00001683 res = bond_master_upper_dev_link(bond_dev, slave_dev);
Jay Vosburghc2edacf2007-07-09 10:42:47 -07001684 if (res) {
Jiri Pirko471cb5a2013-01-03 22:49:01 +00001685 pr_debug("Error %d calling bond_master_upper_dev_link\n", res);
Jay Vosburgh569f0c42008-05-02 18:06:02 -07001686 goto err_restore_mac;
Jay Vosburghc2edacf2007-07-09 10:42:47 -07001687 }
Jiri Pirko5b2c4dd2011-02-23 09:05:42 +00001688
Jay Vosburgh217df672005-09-26 16:11:50 -07001689 /* open the slave since the application closed it */
1690 res = dev_open(slave_dev);
1691 if (res) {
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001692 pr_debug("Opening slave %s failed\n", slave_dev->name);
Jiri Pirko35d48902011-03-22 02:38:12 +00001693 goto err_unset_master;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 }
1695
Jiri Pirko35d48902011-03-22 02:38:12 +00001696 new_slave->bond = bond;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 new_slave->dev = slave_dev;
Jay Vosburgh0b680e72006-09-22 21:54:10 -07001698 slave_dev->priv_flags |= IFF_BONDING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699
Holger Eitzenberger58402052008-12-09 23:07:13 -08001700 if (bond_is_lb(bond)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 /* bond_alb_init_slave() must be called before all other stages since
1702 * it might fail and we do not want to have to undo everything
1703 */
1704 res = bond_alb_init_slave(bond, new_slave);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001705 if (res)
Jay Vosburgh569f0c42008-05-02 18:06:02 -07001706 goto err_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
1708
1709 /* If the mode USES_PRIMARY, then the new slave gets the
1710 * master's promisc (and mc) settings only if it becomes the
1711 * curr_active_slave, and that is taken care of later when calling
1712 * bond_change_active()
1713 */
1714 if (!USES_PRIMARY(bond->params.mode)) {
1715 /* set promiscuity level to new slave */
1716 if (bond_dev->flags & IFF_PROMISC) {
Wang Chen7e1a1ac2008-07-14 20:51:36 -07001717 res = dev_set_promiscuity(slave_dev, 1);
1718 if (res)
1719 goto err_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 }
1721
1722 /* set allmulti level to new slave */
1723 if (bond_dev->flags & IFF_ALLMULTI) {
Wang Chen7e1a1ac2008-07-14 20:51:36 -07001724 res = dev_set_allmulti(slave_dev, 1);
1725 if (res)
1726 goto err_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 }
1728
David S. Millerb9e40852008-07-15 00:15:08 -07001729 netif_addr_lock_bh(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 /* upload master's mc_list to new slave */
Jiri Pirko22bedad32010-04-01 21:22:57 +00001731 netdev_for_each_mc_addr(ha, bond_dev)
1732 dev_mc_add(slave_dev, ha->addr);
David S. Millerb9e40852008-07-15 00:15:08 -07001733 netif_addr_unlock_bh(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 }
1735
1736 if (bond->params.mode == BOND_MODE_8023AD) {
1737 /* add lacpdu mc addr to mc list */
1738 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
1739
Jiri Pirko22bedad32010-04-01 21:22:57 +00001740 dev_mc_add(slave_dev, lacpdu_multicast);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 }
1742
1743 bond_add_vlans_on_slave(bond, slave_dev);
1744
1745 write_lock_bh(&bond->lock);
1746
1747 bond_attach_slave(bond, new_slave);
1748
1749 new_slave->delay = 0;
1750 new_slave->link_failure_count = 0;
1751
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001752 write_unlock_bh(&bond->lock);
1753
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001754 bond_compute_features(bond);
1755
Veaceslav Falico876254a2013-03-12 06:31:32 +00001756 bond_update_speed_duplex(new_slave);
1757
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001758 read_lock(&bond->lock);
1759
Michal Kubečekf31c7932012-04-17 02:02:06 +00001760 new_slave->last_arp_rx = jiffies -
1761 (msecs_to_jiffies(bond->params.arp_interval) + 1);
Jay Vosburghf5b2b962006-09-22 21:54:53 -07001762
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 if (bond->params.miimon && !bond->params.use_carrier) {
1764 link_reporting = bond_check_dev_link(bond, slave_dev, 1);
1765
1766 if ((link_reporting == -1) && !bond->params.arp_interval) {
1767 /*
1768 * miimon is set but a bonded network driver
1769 * does not support ETHTOOL/MII and
1770 * arp_interval is not set. Note: if
1771 * use_carrier is enabled, we will never go
1772 * here (because netif_carrier is always
1773 * supported); thus, we don't need to change
1774 * the messages for netif_carrier.
1775 */
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001776 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",
Mitch Williams4e0952c2005-11-09 10:34:57 -08001777 bond_dev->name, slave_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 } else if (link_reporting == -1) {
1779 /* unable get link status using mii/ethtool */
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001780 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",
1781 bond_dev->name, slave_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 }
1783 }
1784
1785 /* check for initial state */
Michal Kubečekf31c7932012-04-17 02:02:06 +00001786 if (bond->params.miimon) {
1787 if (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS) {
1788 if (bond->params.updelay) {
1789 new_slave->link = BOND_LINK_BACK;
1790 new_slave->delay = bond->params.updelay;
1791 } else {
1792 new_slave->link = BOND_LINK_UP;
1793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 } else {
Michal Kubečekf31c7932012-04-17 02:02:06 +00001795 new_slave->link = BOND_LINK_DOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 }
Michal Kubečekf31c7932012-04-17 02:02:06 +00001797 } else if (bond->params.arp_interval) {
1798 new_slave->link = (netif_carrier_ok(slave_dev) ?
1799 BOND_LINK_UP : BOND_LINK_DOWN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 } else {
Michal Kubečekf31c7932012-04-17 02:02:06 +00001801 new_slave->link = BOND_LINK_UP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 }
1803
Michal Kubečekf31c7932012-04-17 02:02:06 +00001804 if (new_slave->link != BOND_LINK_DOWN)
1805 new_slave->jiffies = jiffies;
1806 pr_debug("Initial state of slave_dev is BOND_LINK_%s\n",
1807 new_slave->link == BOND_LINK_DOWN ? "DOWN" :
1808 (new_slave->link == BOND_LINK_UP ? "UP" : "BACK"));
1809
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
1811 /* if there is a primary slave, remember it */
Jiri Pirkoa5499522009-09-25 03:28:09 +00001812 if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 bond->primary_slave = new_slave;
Jiri Pirkoa5499522009-09-25 03:28:09 +00001814 bond->force_primary = true;
1815 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 }
1817
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001818 write_lock_bh(&bond->curr_slave_lock);
1819
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 switch (bond->params.mode) {
1821 case BOND_MODE_ACTIVEBACKUP:
Jay Vosburgh8a8e4472006-09-22 21:56:15 -07001822 bond_set_slave_inactive_flags(new_slave);
1823 bond_select_active_slave(bond);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 break;
1825 case BOND_MODE_8023AD:
1826 /* in 802.3ad mode, the internal mechanism
1827 * will activate the slaves in the selected
1828 * aggregator
1829 */
1830 bond_set_slave_inactive_flags(new_slave);
1831 /* if this is the first slave */
1832 if (bond->slave_cnt == 1) {
1833 SLAVE_AD_INFO(new_slave).id = 1;
1834 /* Initialize AD with the number of times that the AD timer is called in 1 second
1835 * can be called only after the mac address of the bond is set
1836 */
Peter Pan(潘卫平)56d00c672011-06-08 21:19:02 +00001837 bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 } else {
1839 SLAVE_AD_INFO(new_slave).id =
1840 SLAVE_AD_INFO(new_slave->prev).id + 1;
1841 }
1842
1843 bond_3ad_bind_slave(new_slave);
1844 break;
1845 case BOND_MODE_TLB:
1846 case BOND_MODE_ALB:
Jiri Pirkoe30bc062011-03-12 03:14:37 +00001847 bond_set_active_slave(new_slave);
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07001848 bond_set_slave_inactive_flags(new_slave);
Jiri Pirko5a29f782009-03-25 17:23:38 -07001849 bond_select_active_slave(bond);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 break;
1851 default:
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08001852 pr_debug("This slave is always active in trunk mode\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853
1854 /* always active in trunk mode */
Jiri Pirkoe30bc062011-03-12 03:14:37 +00001855 bond_set_active_slave(new_slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
1857 /* In trunking mode there is little meaning to curr_active_slave
1858 * anyway (it holds no special properties of the bond device),
1859 * so we can change it without calling change_active_interface()
1860 */
Michal Kubeček4e591b92012-11-22 02:48:39 +00001861 if (!bond->curr_active_slave && new_slave->link == BOND_LINK_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 bond->curr_active_slave = new_slave;
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001863
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 break;
1865 } /* switch(bond_mode) */
1866
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001867 write_unlock_bh(&bond->curr_slave_lock);
1868
Jay Vosburghff59c452006-03-27 13:27:43 -08001869 bond_set_carrier(bond);
1870
WANG Congf6dc31a2010-05-06 00:48:51 -07001871#ifdef CONFIG_NET_POLL_CONTROLLER
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001872 slave_dev->npinfo = bond_netpoll_info(bond);
1873 if (slave_dev->npinfo) {
1874 if (slave_enable_netpoll(new_slave)) {
1875 read_unlock(&bond->lock);
1876 pr_info("Error, %s: master_dev is using netpoll, "
1877 "but new slave device does not support netpoll.\n",
1878 bond_dev->name);
1879 res = -EBUSY;
stephen hemmingerf7d98212011-12-31 13:26:46 +00001880 goto err_detach;
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001881 }
WANG Congf6dc31a2010-05-06 00:48:51 -07001882 }
1883#endif
Amerigo Wang8a8efa22011-02-17 23:43:32 +00001884
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001885 read_unlock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886
Mitch Williamsb76cdba2005-11-09 10:36:41 -08001887 res = bond_create_slave_symlinks(bond_dev, slave_dev);
1888 if (res)
stephen hemmingerf7d98212011-12-31 13:26:46 +00001889 goto err_detach;
Mitch Williamsb76cdba2005-11-09 10:36:41 -08001890
Jiri Pirko35d48902011-03-22 02:38:12 +00001891 res = netdev_rx_handler_register(slave_dev, bond_handle_frame,
1892 new_slave);
1893 if (res) {
1894 pr_debug("Error %d calling netdev_rx_handler_register\n", res);
1895 goto err_dest_symlinks;
1896 }
1897
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001898 pr_info("%s: enslaving %s as a%s interface with a%s link.\n",
1899 bond_dev->name, slave_dev->name,
Jiri Pirkoe30bc062011-03-12 03:14:37 +00001900 bond_is_active_slave(new_slave) ? "n active" : " backup",
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001901 new_slave->link != BOND_LINK_DOWN ? "n up" : " down");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902
1903 /* enslave is successful */
1904 return 0;
1905
1906/* Undo stages on error */
Jiri Pirko35d48902011-03-22 02:38:12 +00001907err_dest_symlinks:
1908 bond_destroy_slave_symlinks(bond_dev, slave_dev);
1909
stephen hemmingerf7d98212011-12-31 13:26:46 +00001910err_detach:
nikolay@redhat.com25e40302013-04-18 07:33:34 +00001911 if (!USES_PRIMARY(bond->params.mode)) {
1912 netif_addr_lock_bh(bond_dev);
1913 bond_mc_list_flush(bond_dev, slave_dev);
1914 netif_addr_unlock_bh(bond_dev);
1915 }
nikolay@redhat.coma506e7b2013-04-18 07:33:35 +00001916 bond_del_vlans_from_slave(bond, slave_dev);
stephen hemmingerf7d98212011-12-31 13:26:46 +00001917 write_lock_bh(&bond->lock);
1918 bond_detach_slave(bond, new_slave);
nikolay@redhat.com3c5913b532013-04-18 07:33:36 +00001919 if (bond->primary_slave == new_slave)
1920 bond->primary_slave = NULL;
nikolay@redhat.com3c5913b532013-04-18 07:33:36 +00001921 if (bond->curr_active_slave == new_slave) {
nikolay@redhat.comc6cdcf62013-04-22 08:12:22 +00001922 bond_change_active_slave(bond, NULL);
1923 write_unlock_bh(&bond->lock);
nikolay@redhat.com3c5913b532013-04-18 07:33:36 +00001924 read_lock(&bond->lock);
1925 write_lock_bh(&bond->curr_slave_lock);
nikolay@redhat.com3c5913b532013-04-18 07:33:36 +00001926 bond_select_active_slave(bond);
1927 write_unlock_bh(&bond->curr_slave_lock);
1928 read_unlock(&bond->lock);
nikolay@redhat.comc6cdcf62013-04-22 08:12:22 +00001929 } else {
1930 write_unlock_bh(&bond->lock);
nikolay@redhat.com3c5913b532013-04-18 07:33:36 +00001931 }
nikolay@redhat.comfc7a72a2013-04-18 07:33:37 +00001932 slave_disable_netpoll(new_slave);
stephen hemmingerf7d98212011-12-31 13:26:46 +00001933
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934err_close:
nikolay@redhat.comb6a5a7b2013-04-11 09:18:56 +00001935 slave_dev->priv_flags &= ~IFF_BONDING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 dev_close(slave_dev);
1937
Jay Vosburgh569f0c42008-05-02 18:06:02 -07001938err_unset_master:
Jiri Pirko471cb5a2013-01-03 22:49:01 +00001939 bond_upper_dev_unlink(bond_dev, slave_dev);
Jay Vosburgh569f0c42008-05-02 18:06:02 -07001940
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941err_restore_mac:
Jay Vosburghdd957c52007-10-09 19:57:24 -07001942 if (!bond->params.fail_over_mac) {
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07001943 /* XXX TODO - fom follow mode needs to change master's
1944 * MAC if this slave's MAC is in use by the bond, or at
1945 * least print a warning.
1946 */
Moni Shoua2ab82852007-10-09 19:43:39 -07001947 memcpy(addr.sa_data, new_slave->perm_hwaddr, ETH_ALEN);
1948 addr.sa_family = slave_dev->type;
1949 dev_set_mac_address(slave_dev, &addr);
1950 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951
Jiri Pirkob15ba0f2010-05-18 05:42:40 +00001952err_restore_mtu:
1953 dev_set_mtu(slave_dev, new_slave->original_mtu);
1954
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955err_free:
1956 kfree(new_slave);
1957
1958err_undo_flags:
Michał Mirosławb2a103e2011-05-07 03:22:17 +00001959 bond_compute_features(bond);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00001960
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 return res;
1962}
1963
1964/*
1965 * Try to release the slave device <slave> from the bond device <master>
1966 * It is legal to access curr_active_slave without a lock because all the function
nikolay@redhat.com08963412013-02-18 14:09:42 +00001967 * is write-locked. If "all" is true it means that the function is being called
1968 * while destroying a bond interface and all slaves are being released.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 *
1970 * The rules for slave state should be:
1971 * for Active/Backup:
1972 * Active stays on all backups go down
1973 * for Bonded connections:
1974 * The first up interface should be left on and all others downed.
1975 */
nikolay@redhat.com08963412013-02-18 14:09:42 +00001976static int __bond_release_one(struct net_device *bond_dev,
1977 struct net_device *slave_dev,
1978 bool all)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979{
Wang Chen454d7c92008-11-12 23:37:49 -08001980 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 struct slave *slave, *oldcurrent;
1982 struct sockaddr addr;
Michał Mirosławc8f44af2011-11-15 15:29:55 +00001983 netdev_features_t old_features = bond_dev->features;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984
1985 /* slave is not a slave or master is not master of this slave */
1986 if (!(slave_dev->flags & IFF_SLAVE) ||
Jiri Pirko471cb5a2013-01-03 22:49:01 +00001987 !netdev_has_upper_dev(slave_dev, bond_dev)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001988 pr_err("%s: Error: cannot release %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 bond_dev->name, slave_dev->name);
1990 return -EINVAL;
1991 }
1992
Neil Hormane843fa52010-10-13 16:01:50 +00001993 block_netpoll_tx();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 write_lock_bh(&bond->lock);
1995
1996 slave = bond_get_slave_by_dev(bond, slave_dev);
1997 if (!slave) {
1998 /* not a slave of this bond */
Joe Perchesa4aee5c2009-12-13 20:06:07 -08001999 pr_info("%s: %s not enslaved\n",
2000 bond_dev->name, slave_dev->name);
Jay Vosburghf5e2a7b2006-02-07 21:17:22 -08002001 write_unlock_bh(&bond->lock);
Neil Hormane843fa52010-10-13 16:01:50 +00002002 unblock_netpoll_tx();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 return -EINVAL;
2004 }
2005
Veaceslav Falicofcd99432013-04-02 05:15:16 +00002006 write_unlock_bh(&bond->lock);
Jiri Pirko35d48902011-03-22 02:38:12 +00002007 /* unregister rx_handler early so bond_handle_frame wouldn't be called
2008 * for this slave anymore.
2009 */
2010 netdev_rx_handler_unregister(slave_dev);
Jiri Pirko35d48902011-03-22 02:38:12 +00002011 write_lock_bh(&bond->lock);
2012
nikolay@redhat.com08963412013-02-18 14:09:42 +00002013 if (!all && !bond->params.fail_over_mac) {
Joe Perches2e42e472012-05-09 17:17:46 +00002014 if (ether_addr_equal(bond_dev->dev_addr, slave->perm_hwaddr) &&
Joe Perches8e95a202009-12-03 07:58:21 +00002015 bond->slave_cnt > 1)
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002016 pr_warning("%s: Warning: the permanent HWaddr of %s - %pM - is still in use by %s. Set the HWaddr of %s to a different address to avoid conflicts.\n",
2017 bond_dev->name, slave_dev->name,
2018 slave->perm_hwaddr,
2019 bond_dev->name, slave_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 }
2021
2022 /* Inform AD package of unbinding of slave. */
2023 if (bond->params.mode == BOND_MODE_8023AD) {
2024 /* must be called before the slave is
2025 * detached from the list
2026 */
2027 bond_3ad_unbind_slave(slave);
2028 }
2029
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002030 pr_info("%s: releasing %s interface %s\n",
2031 bond_dev->name,
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002032 bond_is_active_slave(slave) ? "active" : "backup",
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002033 slave_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
2035 oldcurrent = bond->curr_active_slave;
2036
2037 bond->current_arp_slave = NULL;
2038
2039 /* release the slave from its bond */
2040 bond_detach_slave(bond, slave);
2041
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002042 if (bond->primary_slave == slave)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 bond->primary_slave = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002045 if (oldcurrent == slave)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 bond_change_active_slave(bond, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047
Holger Eitzenberger58402052008-12-09 23:07:13 -08002048 if (bond_is_lb(bond)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 /* Must be called only after the slave has been
2050 * detached from the list and the curr_active_slave
2051 * has been cleared (if our_slave == old_current),
2052 * but before a new active slave is selected.
2053 */
Jay Vosburgh25433312008-01-17 16:24:59 -08002054 write_unlock_bh(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 bond_alb_deinit_slave(bond, slave);
Jay Vosburgh25433312008-01-17 16:24:59 -08002056 write_lock_bh(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 }
2058
nikolay@redhat.com08963412013-02-18 14:09:42 +00002059 if (all) {
2060 bond->curr_active_slave = NULL;
2061 } else if (oldcurrent == slave) {
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002062 /*
2063 * Note that we hold RTNL over this sequence, so there
2064 * is no concern that another slave add/remove event
2065 * will interfere.
2066 */
2067 write_unlock_bh(&bond->lock);
2068 read_lock(&bond->lock);
2069 write_lock_bh(&bond->curr_slave_lock);
2070
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 bond_select_active_slave(bond);
2072
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002073 write_unlock_bh(&bond->curr_slave_lock);
2074 read_unlock(&bond->lock);
2075 write_lock_bh(&bond->lock);
2076 }
2077
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 if (bond->slave_cnt == 0) {
Jay Vosburghff59c452006-03-27 13:27:43 -08002079 bond_set_carrier(bond);
Jiri Pirko409cc1f2013-01-30 11:08:11 +01002080 eth_hw_addr_random(bond_dev);
2081 bond->dev_addr_from_first = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082
Jiri Pirkocc0e4072011-07-20 04:54:46 +00002083 if (bond_vlan_used(bond)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002084 pr_warning("%s: Warning: clearing HW address of %s while it still has VLANs.\n",
2085 bond_dev->name, bond_dev->name);
2086 pr_warning("%s: When re-adding slaves, make sure the bond's HW address matches its VLANs'.\n",
2087 bond_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 }
2090
2091 write_unlock_bh(&bond->lock);
Neil Hormane843fa52010-10-13 16:01:50 +00002092 unblock_netpoll_tx();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093
Veaceslav Falico80028ea2013-03-06 07:10:32 +00002094 if (bond->slave_cnt == 0) {
Shlomo Pongratz2af73d42012-04-03 22:56:19 +00002095 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond->dev);
Veaceslav Falico80028ea2013-03-06 07:10:32 +00002096 call_netdevice_notifiers(NETDEV_RELEASE, bond->dev);
2097 }
Shlomo Pongratz2af73d42012-04-03 22:56:19 +00002098
Michał Mirosławb2a103e2011-05-07 03:22:17 +00002099 bond_compute_features(bond);
2100 if (!(bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
2101 (old_features & NETIF_F_VLAN_CHALLENGED))
2102 pr_info("%s: last VLAN challenged slave %s left bond %s. VLAN blocking is removed\n",
2103 bond_dev->name, slave_dev->name, bond_dev->name);
2104
Mitch Williamsb76cdba2005-11-09 10:36:41 -08002105 /* must do this from outside any spinlocks */
2106 bond_destroy_slave_symlinks(bond_dev, slave_dev);
2107
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 bond_del_vlans_from_slave(bond, slave_dev);
2109
2110 /* If the mode USES_PRIMARY, then we should only remove its
2111 * promisc and mc settings if it was the curr_active_slave, but that was
2112 * already taken care of above when we detached the slave
2113 */
2114 if (!USES_PRIMARY(bond->params.mode)) {
2115 /* unset promiscuity level from slave */
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002116 if (bond_dev->flags & IFF_PROMISC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 dev_set_promiscuity(slave_dev, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118
2119 /* unset allmulti level from slave */
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002120 if (bond_dev->flags & IFF_ALLMULTI)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 dev_set_allmulti(slave_dev, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122
2123 /* flush master's mc_list from slave */
David S. Millerb9e40852008-07-15 00:15:08 -07002124 netif_addr_lock_bh(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 bond_mc_list_flush(bond_dev, slave_dev);
David S. Millerb9e40852008-07-15 00:15:08 -07002126 netif_addr_unlock_bh(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 }
2128
Jiri Pirko471cb5a2013-01-03 22:49:01 +00002129 bond_upper_dev_unlink(bond_dev, slave_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130
Amerigo Wang8a8efa22011-02-17 23:43:32 +00002131 slave_disable_netpoll(slave);
WANG Congf6dc31a2010-05-06 00:48:51 -07002132
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 /* close slave before restoring its mac address */
2134 dev_close(slave_dev);
2135
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07002136 if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
Moni Shoua2ab82852007-10-09 19:43:39 -07002137 /* restore original ("permanent") mac address */
2138 memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
2139 addr.sa_family = slave_dev->type;
2140 dev_set_mac_address(slave_dev, &addr);
2141 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142
Jiri Pirkob15ba0f2010-05-18 05:42:40 +00002143 dev_set_mtu(slave_dev, slave->original_mtu);
2144
Jiri Pirko2d7011c2011-03-16 08:46:43 +00002145 slave_dev->priv_flags &= ~IFF_BONDING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146
2147 kfree(slave);
2148
2149 return 0; /* deletion OK */
2150}
2151
nikolay@redhat.com08963412013-02-18 14:09:42 +00002152/* A wrapper used because of ndo_del_link */
2153int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
2154{
2155 return __bond_release_one(bond_dev, slave_dev, false);
2156}
2157
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158/*
Nicolas de Pesloüandadaa102011-03-19 13:36:18 -07002159* First release a slave and then destroy the bond if no more slaves are left.
Moni Shouad90a1622007-10-09 19:43:43 -07002160* Must be under rtnl_lock when this function is called.
2161*/
stephen hemminger26d8ee72010-10-15 05:09:34 +00002162static int bond_release_and_destroy(struct net_device *bond_dev,
2163 struct net_device *slave_dev)
Moni Shouad90a1622007-10-09 19:43:43 -07002164{
Wang Chen454d7c92008-11-12 23:37:49 -08002165 struct bonding *bond = netdev_priv(bond_dev);
Moni Shouad90a1622007-10-09 19:43:43 -07002166 int ret;
2167
2168 ret = bond_release(bond_dev, slave_dev);
2169 if ((ret == 0) && (bond->slave_cnt == 0)) {
Amerigo Wang8a8efa22011-02-17 23:43:32 +00002170 bond_dev->priv_flags |= IFF_DISABLE_NETPOLL;
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002171 pr_info("%s: destroying bond %s.\n",
2172 bond_dev->name, bond_dev->name);
Stephen Hemminger9e716262009-06-12 19:02:47 +00002173 unregister_netdevice(bond_dev);
Moni Shouad90a1622007-10-09 19:43:43 -07002174 }
2175 return ret;
2176}
2177
2178/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 * This function changes the active slave to slave <slave_dev>.
2180 * It returns -EINVAL in the following cases.
2181 * - <slave_dev> is not found in the list.
2182 * - There is not active slave now.
2183 * - <slave_dev> is already active.
2184 * - The link state of <slave_dev> is not BOND_LINK_UP.
2185 * - <slave_dev> is not running.
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002186 * In these cases, this function does nothing.
2187 * In the other cases, current_slave pointer is changed and 0 is returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 */
2189static int bond_ioctl_change_active(struct net_device *bond_dev, struct net_device *slave_dev)
2190{
Wang Chen454d7c92008-11-12 23:37:49 -08002191 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 struct slave *old_active = NULL;
2193 struct slave *new_active = NULL;
2194 int res = 0;
2195
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002196 if (!USES_PRIMARY(bond->params.mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198
Jiri Pirko471cb5a2013-01-03 22:49:01 +00002199 /* Verify that bond_dev is indeed the master of slave_dev */
2200 if (!(slave_dev->flags & IFF_SLAVE) ||
2201 !netdev_has_upper_dev(slave_dev, bond_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002204 read_lock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002206 read_lock(&bond->curr_slave_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207 old_active = bond->curr_active_slave;
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002208 read_unlock(&bond->curr_slave_lock);
2209
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 new_active = bond_get_slave_by_dev(bond, slave_dev);
2211
2212 /*
2213 * Changing to the current active: do nothing; return success.
2214 */
2215 if (new_active && (new_active == old_active)) {
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002216 read_unlock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 return 0;
2218 }
2219
2220 if ((new_active) &&
2221 (old_active) &&
2222 (new_active->link == BOND_LINK_UP) &&
2223 IS_UP(new_active->dev)) {
Neil Hormane843fa52010-10-13 16:01:50 +00002224 block_netpoll_tx();
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002225 write_lock_bh(&bond->curr_slave_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 bond_change_active_slave(bond, new_active);
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002227 write_unlock_bh(&bond->curr_slave_lock);
Neil Hormane843fa52010-10-13 16:01:50 +00002228 unblock_netpoll_tx();
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002229 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 res = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002232 read_unlock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233
2234 return res;
2235}
2236
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
2238{
Wang Chen454d7c92008-11-12 23:37:49 -08002239 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240
2241 info->bond_mode = bond->params.mode;
2242 info->miimon = bond->params.miimon;
2243
Jay Vosburgh6603a6f2007-10-17 17:37:50 -07002244 read_lock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 info->num_slaves = bond->slave_cnt;
Jay Vosburgh6603a6f2007-10-17 17:37:50 -07002246 read_unlock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247
2248 return 0;
2249}
2250
2251static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info)
2252{
Wang Chen454d7c92008-11-12 23:37:49 -08002253 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 struct slave *slave;
Eric Dumazet689c96c2009-04-23 03:39:04 +00002255 int i, res = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256
Jay Vosburgh6603a6f2007-10-17 17:37:50 -07002257 read_lock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258
2259 bond_for_each_slave(bond, slave, i) {
2260 if (i == (int)info->slave_id) {
Eric Dumazet689c96c2009-04-23 03:39:04 +00002261 res = 0;
2262 strcpy(info->slave_name, slave->dev->name);
2263 info->link = slave->link;
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002264 info->state = bond_slave_state(slave);
Eric Dumazet689c96c2009-04-23 03:39:04 +00002265 info->link_failure_count = slave->link_failure_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 break;
2267 }
2268 }
2269
Jay Vosburgh6603a6f2007-10-17 17:37:50 -07002270 read_unlock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271
Eric Dumazet689c96c2009-04-23 03:39:04 +00002272 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273}
2274
2275/*-------------------------------- Monitoring -------------------------------*/
2276
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002277
2278static int bond_miimon_inspect(struct bonding *bond)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279{
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002280 struct slave *slave;
2281 int i, link_state, commit = 0;
Jiri Pirko41f89102009-04-24 03:57:29 +00002282 bool ignore_updelay;
2283
2284 ignore_updelay = !bond->curr_active_slave ? true : false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285
2286 bond_for_each_slave(bond, slave, i) {
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002287 slave->new_link = BOND_LINK_NOCHANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002289 link_state = bond_check_dev_link(bond, slave->dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290
2291 switch (slave->link) {
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002292 case BOND_LINK_UP:
2293 if (link_state)
2294 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002296 slave->link = BOND_LINK_FAIL;
2297 slave->delay = bond->params.downdelay;
2298 if (slave->delay) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002299 pr_info("%s: link status down for %sinterface %s, disabling it in %d ms.\n",
2300 bond->dev->name,
2301 (bond->params.mode ==
2302 BOND_MODE_ACTIVEBACKUP) ?
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002303 (bond_is_active_slave(slave) ?
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002304 "active " : "backup ") : "",
2305 slave->dev->name,
2306 bond->params.downdelay * bond->params.miimon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 }
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002308 /*FALLTHRU*/
2309 case BOND_LINK_FAIL:
2310 if (link_state) {
2311 /*
2312 * recovered before downdelay expired
2313 */
2314 slave->link = BOND_LINK_UP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 slave->jiffies = jiffies;
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002316 pr_info("%s: link status up again after %d ms for interface %s.\n",
2317 bond->dev->name,
2318 (bond->params.downdelay - slave->delay) *
2319 bond->params.miimon,
2320 slave->dev->name);
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002321 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 }
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002323
2324 if (slave->delay <= 0) {
2325 slave->new_link = BOND_LINK_DOWN;
2326 commit++;
2327 continue;
2328 }
2329
2330 slave->delay--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002333 case BOND_LINK_DOWN:
2334 if (!link_state)
2335 continue;
2336
2337 slave->link = BOND_LINK_BACK;
2338 slave->delay = bond->params.updelay;
2339
2340 if (slave->delay) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002341 pr_info("%s: link status up for interface %s, enabling it in %d ms.\n",
2342 bond->dev->name, slave->dev->name,
2343 ignore_updelay ? 0 :
2344 bond->params.updelay *
2345 bond->params.miimon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 }
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002347 /*FALLTHRU*/
2348 case BOND_LINK_BACK:
2349 if (!link_state) {
2350 slave->link = BOND_LINK_DOWN;
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002351 pr_info("%s: link status down again after %d ms for interface %s.\n",
2352 bond->dev->name,
2353 (bond->params.updelay - slave->delay) *
2354 bond->params.miimon,
2355 slave->dev->name);
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002356
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002357 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 }
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002359
Jiri Pirko41f89102009-04-24 03:57:29 +00002360 if (ignore_updelay)
2361 slave->delay = 0;
2362
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002363 if (slave->delay <= 0) {
2364 slave->new_link = BOND_LINK_UP;
2365 commit++;
Jiri Pirko41f89102009-04-24 03:57:29 +00002366 ignore_updelay = false;
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002367 continue;
2368 }
2369
2370 slave->delay--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 break;
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002372 }
2373 }
2374
2375 return commit;
2376}
2377
2378static void bond_miimon_commit(struct bonding *bond)
2379{
2380 struct slave *slave;
2381 int i;
2382
2383 bond_for_each_slave(bond, slave, i) {
2384 switch (slave->new_link) {
2385 case BOND_LINK_NOCHANGE:
2386 continue;
2387
2388 case BOND_LINK_UP:
2389 slave->link = BOND_LINK_UP;
2390 slave->jiffies = jiffies;
2391
2392 if (bond->params.mode == BOND_MODE_8023AD) {
2393 /* prevent it from being the active one */
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002394 bond_set_backup_slave(slave);
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002395 } else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
2396 /* make it immediately active */
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002397 bond_set_active_slave(slave);
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002398 } else if (slave != bond->primary_slave) {
2399 /* prevent it from being the active one */
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002400 bond_set_backup_slave(slave);
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002401 }
2402
David Decotigny5d305302011-04-13 15:22:31 +00002403 pr_info("%s: link status definitely up for interface %s, %u Mbps %s duplex.\n",
Krzysztof Piotr Oledzki700c2a72010-10-06 14:25:06 -07002404 bond->dev->name, slave->dev->name,
2405 slave->speed, slave->duplex ? "full" : "half");
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002406
2407 /* notify ad that the link status has changed */
2408 if (bond->params.mode == BOND_MODE_8023AD)
2409 bond_3ad_handle_link_change(slave, BOND_LINK_UP);
2410
Holger Eitzenberger58402052008-12-09 23:07:13 -08002411 if (bond_is_lb(bond))
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002412 bond_alb_handle_link_change(bond, slave,
2413 BOND_LINK_UP);
2414
2415 if (!bond->curr_active_slave ||
2416 (slave == bond->primary_slave))
2417 goto do_failover;
2418
2419 continue;
2420
2421 case BOND_LINK_DOWN:
Jay Vosburghfba4acd2008-10-30 17:41:14 -07002422 if (slave->link_failure_count < UINT_MAX)
2423 slave->link_failure_count++;
2424
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002425 slave->link = BOND_LINK_DOWN;
2426
2427 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP ||
2428 bond->params.mode == BOND_MODE_8023AD)
2429 bond_set_slave_inactive_flags(slave);
2430
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002431 pr_info("%s: link status definitely down for interface %s, disabling it\n",
2432 bond->dev->name, slave->dev->name);
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002433
2434 if (bond->params.mode == BOND_MODE_8023AD)
2435 bond_3ad_handle_link_change(slave,
2436 BOND_LINK_DOWN);
2437
Jiri Pirkoae63e802009-05-27 05:42:36 +00002438 if (bond_is_lb(bond))
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002439 bond_alb_handle_link_change(bond, slave,
2440 BOND_LINK_DOWN);
2441
2442 if (slave == bond->curr_active_slave)
2443 goto do_failover;
2444
2445 continue;
2446
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 default:
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002448 pr_err("%s: invalid new link %d on slave %s\n",
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002449 bond->dev->name, slave->new_link,
2450 slave->dev->name);
2451 slave->new_link = BOND_LINK_NOCHANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002453 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 }
2455
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002456do_failover:
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002457 ASSERT_RTNL();
Neil Hormane843fa52010-10-13 16:01:50 +00002458 block_netpoll_tx();
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002459 write_lock_bh(&bond->curr_slave_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 bond_select_active_slave(bond);
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002461 write_unlock_bh(&bond->curr_slave_lock);
Neil Hormane843fa52010-10-13 16:01:50 +00002462 unblock_netpoll_tx();
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002463 }
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002464
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002465 bond_set_carrier(bond);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466}
2467
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002468/*
2469 * bond_mii_monitor
2470 *
2471 * Really a wrapper that splits the mii monitor into two phases: an
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002472 * inspection, then (if inspection indicates something needs to be done)
2473 * an acquisition of appropriate locks followed by a commit phase to
2474 * implement whatever link state changes are indicated.
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002475 */
2476void bond_mii_monitor(struct work_struct *work)
2477{
2478 struct bonding *bond = container_of(work, struct bonding,
2479 mii_work.work);
Ben Hutchingsad246c92011-04-26 15:25:52 +00002480 bool should_notify_peers = false;
Jay Vosburghe6d265e2011-10-28 15:42:50 +00002481 unsigned long delay;
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002482
2483 read_lock(&bond->lock);
Jay Vosburghe6d265e2011-10-28 15:42:50 +00002484
2485 delay = msecs_to_jiffies(bond->params.miimon);
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002486
2487 if (bond->slave_cnt == 0)
2488 goto re_arm;
Jay Vosburghb59f9f72008-06-13 18:12:03 -07002489
Ben Hutchingsad246c92011-04-26 15:25:52 +00002490 should_notify_peers = bond_should_notify_peers(bond);
2491
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002492 if (bond_miimon_inspect(bond)) {
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002493 read_unlock(&bond->lock);
Jay Vosburghe6d265e2011-10-28 15:42:50 +00002494
2495 /* Race avoidance with bond_close cancel of workqueue */
2496 if (!rtnl_trylock()) {
2497 read_lock(&bond->lock);
2498 delay = 1;
2499 should_notify_peers = false;
2500 goto re_arm;
2501 }
2502
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002503 read_lock(&bond->lock);
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002504
2505 bond_miimon_commit(bond);
2506
Jay Vosburgh56556622008-01-17 16:25:03 -08002507 read_unlock(&bond->lock);
2508 rtnl_unlock(); /* might sleep, hold no other locks */
2509 read_lock(&bond->lock);
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002510 }
2511
Jay Vosburghf0c76d62008-07-02 18:21:58 -07002512re_arm:
Jay Vosburghe6d265e2011-10-28 15:42:50 +00002513 if (bond->params.miimon)
2514 queue_delayed_work(bond->wq, &bond->mii_work, delay);
2515
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002516 read_unlock(&bond->lock);
Ben Hutchingsad246c92011-04-26 15:25:52 +00002517
2518 if (should_notify_peers) {
Jay Vosburghe6d265e2011-10-28 15:42:50 +00002519 if (!rtnl_trylock()) {
2520 read_lock(&bond->lock);
2521 bond->send_peer_notif++;
2522 read_unlock(&bond->lock);
2523 return;
2524 }
Amerigo Wangb7bc2a52012-08-09 22:14:57 +00002525 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
Ben Hutchingsad246c92011-04-26 15:25:52 +00002526 rtnl_unlock();
2527 }
Jay Vosburgh0b0eef62007-10-17 17:37:48 -07002528}
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002529
Al Virod3bb52b2007-08-22 20:06:58 -04002530static int bond_has_this_ip(struct bonding *bond, __be32 ip)
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002531{
Pavel Emelyanov0883bec2008-05-17 21:10:10 -07002532 struct vlan_entry *vlan;
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002533 struct net_device *vlan_dev;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002534
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002535 if (ip == bond_confirm_addr(bond->dev, 0, ip))
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002536 return 1;
2537
Pavel Emelyanov0883bec2008-05-17 21:10:10 -07002538 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002539 rcu_read_lock();
Patrick McHardy1fd9b1f2013-04-19 02:04:29 +00002540 vlan_dev = __vlan_find_dev_deep(bond->dev, htons(ETH_P_8021Q),
2541 vlan->vlan_id);
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002542 rcu_read_unlock();
2543 if (vlan_dev && ip == bond_confirm_addr(vlan_dev, 0, ip))
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002544 return 1;
2545 }
2546
2547 return 0;
2548}
2549
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002550/*
2551 * We go to the (large) trouble of VLAN tagging ARP frames because
2552 * switches in VLAN mode (especially if ports are configured as
2553 * "native" to a VLAN) might not pass non-tagged frames.
2554 */
Al Virod3bb52b2007-08-22 20:06:58 -04002555static void bond_arp_send(struct net_device *slave_dev, int arp_op, __be32 dest_ip, __be32 src_ip, unsigned short vlan_id)
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002556{
2557 struct sk_buff *skb;
2558
nikolay@redhat.comacca2672013-05-18 01:18:29 +00002559 pr_debug("arp %d on slave %s: dst %pI4 src %pI4 vid %d\n", arp_op,
2560 slave_dev->name, &dest_ip, &src_ip, vlan_id);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002561
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002562 skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip,
2563 NULL, slave_dev->dev_addr, NULL);
2564
2565 if (!skb) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002566 pr_err("ARP packet allocation failed\n");
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002567 return;
2568 }
2569 if (vlan_id) {
Patrick McHardy1fd9b1f2013-04-19 02:04:29 +00002570 skb = vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002571 if (!skb) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002572 pr_err("failed to insert VLAN tag\n");
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002573 return;
2574 }
2575 }
2576 arp_xmit(skb);
2577}
2578
2579
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
2581{
David S. Millerb23dd4f2011-03-02 14:31:35 -08002582 int i, vlan_id;
Al Virod3bb52b2007-08-22 20:06:58 -04002583 __be32 *targets = bond->params.arp_targets;
Pavel Emelyanov0883bec2008-05-17 21:10:10 -07002584 struct vlan_entry *vlan;
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002585 struct net_device *vlan_dev = NULL;
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002586 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587
Mitch Williams6b780562005-11-09 10:36:19 -08002588 for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002589 __be32 addr;
Mitch Williams6b780562005-11-09 10:36:19 -08002590 if (!targets[i])
Brian Haley5a31bec2009-04-13 00:11:30 -07002591 break;
nikolay@redhat.comacca2672013-05-18 01:18:29 +00002592 pr_debug("basa: target %pI4\n", &targets[i]);
Jiri Pirkocc0e4072011-07-20 04:54:46 +00002593 if (!bond_vlan_used(bond)) {
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08002594 pr_debug("basa: empty vlan: arp_send\n");
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002595 addr = bond_confirm_addr(bond->dev, targets[i], 0);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002596 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002597 addr, 0);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002598 continue;
2599 }
2600
2601 /*
2602 * If VLANs are configured, we do a route lookup to
2603 * determine which VLAN interface would be used, so we
2604 * can tag the ARP with the proper VLAN tag.
2605 */
David S. Miller78fbfd82011-03-12 00:00:52 -05002606 rt = ip_route_output(dev_net(bond->dev), targets[i], 0,
2607 RTO_ONLINK, 0);
David S. Millerb23dd4f2011-03-02 14:31:35 -08002608 if (IS_ERR(rt)) {
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002609 if (net_ratelimit()) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002610 pr_warning("%s: no route to arp_ip_target %pI4\n",
David S. Miller78fbfd82011-03-12 00:00:52 -05002611 bond->dev->name, &targets[i]);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002612 }
2613 continue;
2614 }
2615
2616 /*
2617 * This target is not on a VLAN
2618 */
Changli Gaod8d1f302010-06-10 23:31:35 -07002619 if (rt->dst.dev == bond->dev) {
Jay Vosburghed4b9f82005-09-14 14:52:09 -07002620 ip_rt_put(rt);
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08002621 pr_debug("basa: rtdev == bond->dev: arp_send\n");
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002622 addr = bond_confirm_addr(bond->dev, targets[i], 0);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002623 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002624 addr, 0);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002625 continue;
2626 }
2627
2628 vlan_id = 0;
Pavel Emelyanov0883bec2008-05-17 21:10:10 -07002629 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
Jiri Pirkocc0e4072011-07-20 04:54:46 +00002630 rcu_read_lock();
2631 vlan_dev = __vlan_find_dev_deep(bond->dev,
Patrick McHardy1fd9b1f2013-04-19 02:04:29 +00002632 htons(ETH_P_8021Q),
Jiri Pirkocc0e4072011-07-20 04:54:46 +00002633 vlan->vlan_id);
2634 rcu_read_unlock();
Changli Gaod8d1f302010-06-10 23:31:35 -07002635 if (vlan_dev == rt->dst.dev) {
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002636 vlan_id = vlan->vlan_id;
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08002637 pr_debug("basa: vlan match on %s %d\n",
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002638 vlan_dev->name, vlan_id);
2639 break;
2640 }
2641 }
2642
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002643 if (vlan_id && vlan_dev) {
Jay Vosburghed4b9f82005-09-14 14:52:09 -07002644 ip_rt_put(rt);
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002645 addr = bond_confirm_addr(vlan_dev, targets[i], 0);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002646 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
Andy Gospodarekeaddcd72012-03-22 16:14:29 +00002647 addr, vlan_id);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002648 continue;
2649 }
2650
2651 if (net_ratelimit()) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002652 pr_warning("%s: no path to arp_ip_target %pI4 via rt.dev %s\n",
David S. Miller78fbfd82011-03-12 00:00:52 -05002653 bond->dev->name, &targets[i],
Changli Gaod8d1f302010-06-10 23:31:35 -07002654 rt->dst.dev ? rt->dst.dev->name : "NULL");
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002655 }
Jay Vosburghed4b9f82005-09-14 14:52:09 -07002656 ip_rt_put(rt);
Jay Vosburghc3ade5c2005-06-26 17:52:20 -04002657 }
2658}
2659
Al Virod3bb52b2007-08-22 20:06:58 -04002660static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip)
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002661{
2662 int i;
Al Virod3bb52b2007-08-22 20:06:58 -04002663 __be32 *targets = bond->params.arp_targets;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002664
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002665 for (i = 0; (i < BOND_MAX_ARP_TARGETS) && targets[i]; i++) {
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08002666 pr_debug("bva: sip %pI4 tip %pI4 t[%d] %pI4 bhti(tip) %d\n",
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002667 &sip, &tip, i, &targets[i],
2668 bond_has_this_ip(bond, tip));
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002669 if (sip == targets[i]) {
2670 if (bond_has_this_ip(bond, tip))
2671 slave->last_arp_rx = jiffies;
2672 return;
2673 }
2674 }
2675}
2676
Eric Dumazetde063b72012-06-11 19:23:07 +00002677static int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond,
2678 struct slave *slave)
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002679{
Eric Dumazetde063b72012-06-11 19:23:07 +00002680 struct arphdr *arp = (struct arphdr *)skb->data;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002681 unsigned char *arp_ptr;
Al Virod3bb52b2007-08-22 20:06:58 -04002682 __be32 sip, tip;
Eric Dumazetde063b72012-06-11 19:23:07 +00002683 int alen;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002684
Jiri Pirko3aba8912011-04-19 03:48:16 +00002685 if (skb->protocol != __cpu_to_be16(ETH_P_ARP))
Jiri Bohac13a8e0c2012-05-09 01:01:40 +00002686 return RX_HANDLER_ANOTHER;
Andy Gospodarek1f3c8802009-12-14 10:48:58 +00002687
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002688 read_lock(&bond->lock);
Eric Dumazetde063b72012-06-11 19:23:07 +00002689 alen = arp_hdr_len(bond->dev);
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002690
Jiri Pirko3aba8912011-04-19 03:48:16 +00002691 pr_debug("bond_arp_rcv: bond %s skb->dev %s\n",
2692 bond->dev->name, skb->dev->name);
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002693
Eric Dumazetde063b72012-06-11 19:23:07 +00002694 if (alen > skb_headlen(skb)) {
2695 arp = kmalloc(alen, GFP_ATOMIC);
2696 if (!arp)
2697 goto out_unlock;
2698 if (skb_copy_bits(skb, 0, arp, alen) < 0)
2699 goto out_unlock;
2700 }
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002701
Jiri Pirko3aba8912011-04-19 03:48:16 +00002702 if (arp->ar_hln != bond->dev->addr_len ||
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002703 skb->pkt_type == PACKET_OTHERHOST ||
2704 skb->pkt_type == PACKET_LOOPBACK ||
2705 arp->ar_hrd != htons(ARPHRD_ETHER) ||
2706 arp->ar_pro != htons(ETH_P_IP) ||
2707 arp->ar_pln != 4)
2708 goto out_unlock;
2709
2710 arp_ptr = (unsigned char *)(arp + 1);
Jiri Pirko3aba8912011-04-19 03:48:16 +00002711 arp_ptr += bond->dev->addr_len;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002712 memcpy(&sip, arp_ptr, 4);
Jiri Pirko3aba8912011-04-19 03:48:16 +00002713 arp_ptr += 4 + bond->dev->addr_len;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002714 memcpy(&tip, arp_ptr, 4);
2715
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08002716 pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002717 bond->dev->name, slave->dev->name, bond_slave_state(slave),
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002718 bond->params.arp_validate, slave_do_arp_validate(bond, slave),
2719 &sip, &tip);
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002720
2721 /*
2722 * Backup slaves won't see the ARP reply, but do come through
2723 * here for each ARP probe (so we swap the sip/tip to validate
2724 * the probe). In a "redundant switch, common router" type of
2725 * configuration, the ARP probe will (hopefully) travel from
2726 * the active, through one switch, the router, then the other
2727 * switch before reaching the backup.
2728 */
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002729 if (bond_is_active_slave(slave))
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002730 bond_validate_arp(bond, slave, sip, tip);
2731 else
2732 bond_validate_arp(bond, slave, tip, sip);
2733
2734out_unlock:
2735 read_unlock(&bond->lock);
Eric Dumazetde063b72012-06-11 19:23:07 +00002736 if (arp != (struct arphdr *)skb->data)
2737 kfree(arp);
Jiri Bohac13a8e0c2012-05-09 01:01:40 +00002738 return RX_HANDLER_ANOTHER;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07002739}
2740
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741/*
2742 * this function is called regularly to monitor each slave's link
2743 * ensuring that traffic is being sent and received when arp monitoring
2744 * is used in load-balancing mode. if the adapter has been dormant, then an
2745 * arp is transmitted to generate traffic. see activebackup_arp_monitor for
2746 * arp monitoring in active backup mode.
2747 */
Jay Vosburgh1b76b312007-10-17 17:37:45 -07002748void bond_loadbalance_arp_mon(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749{
Jay Vosburgh1b76b312007-10-17 17:37:45 -07002750 struct bonding *bond = container_of(work, struct bonding,
2751 arp_work.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 struct slave *slave, *oldcurrent;
2753 int do_failover = 0;
Jiri Bohacda210f52012-08-30 12:02:47 +00002754 int delta_in_ticks, extra_ticks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 int i;
2756
2757 read_lock(&bond->lock);
2758
Jay Vosburgh5ce0da82008-05-17 21:10:07 -07002759 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
Jiri Bohacda210f52012-08-30 12:02:47 +00002760 extra_ticks = delta_in_ticks / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002762 if (bond->slave_cnt == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 goto re_arm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764
2765 read_lock(&bond->curr_slave_lock);
2766 oldcurrent = bond->curr_active_slave;
2767 read_unlock(&bond->curr_slave_lock);
2768
2769 /* see if any of the previous devices are up now (i.e. they have
2770 * xmt and rcv traffic). the curr_active_slave does not come into
2771 * the picture unless it is null. also, slave->jiffies is not needed
2772 * here because we send an arp on each slave and give a slave as
2773 * long as it needs to get the tx/rx within the delta.
2774 * TODO: what about up/down delay in arp mode? it wasn't here before
2775 * so it can wait
2776 */
2777 bond_for_each_slave(bond, slave, i) {
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002778 unsigned long trans_start = dev_trans_start(slave->dev);
2779
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 if (slave->link != BOND_LINK_UP) {
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002781 if (time_in_range(jiffies,
2782 trans_start - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002783 trans_start + delta_in_ticks + extra_ticks) &&
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002784 time_in_range(jiffies,
2785 slave->dev->last_rx - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002786 slave->dev->last_rx + delta_in_ticks + extra_ticks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787
2788 slave->link = BOND_LINK_UP;
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002789 bond_set_active_slave(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790
2791 /* primary_slave has no meaning in round-robin
2792 * mode. the window of a slave being up and
2793 * curr_active_slave being null after enslaving
2794 * is closed.
2795 */
2796 if (!oldcurrent) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002797 pr_info("%s: link status definitely up for interface %s, ",
2798 bond->dev->name,
2799 slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800 do_failover = 1;
2801 } else {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002802 pr_info("%s: interface %s is now up\n",
2803 bond->dev->name,
2804 slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805 }
2806 }
2807 } else {
2808 /* slave->link == BOND_LINK_UP */
2809
2810 /* not all switches will respond to an arp request
2811 * when the source ip is 0, so don't take the link down
2812 * if we don't know our ip yet
2813 */
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002814 if (!time_in_range(jiffies,
2815 trans_start - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002816 trans_start + 2 * delta_in_ticks + extra_ticks) ||
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002817 !time_in_range(jiffies,
2818 slave->dev->last_rx - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002819 slave->dev->last_rx + 2 * delta_in_ticks + extra_ticks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820
2821 slave->link = BOND_LINK_DOWN;
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002822 bond_set_backup_slave(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002824 if (slave->link_failure_count < UINT_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 slave->link_failure_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002827 pr_info("%s: interface %s is now down.\n",
2828 bond->dev->name,
2829 slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002831 if (slave == oldcurrent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 do_failover = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 }
2834 }
2835
2836 /* note: if switch is in round-robin mode, all links
2837 * must tx arp to ensure all links rx an arp - otherwise
2838 * links may oscillate or not come up at all; if switch is
2839 * in something like xor mode, there is nothing we can
2840 * do - all replies will be rx'ed on same link causing slaves
2841 * to be unstable during low/no traffic periods
2842 */
Stephen Hemminger3d632c32009-06-12 19:02:48 +00002843 if (IS_UP(slave->dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 bond_arp_send_all(bond, slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845 }
2846
2847 if (do_failover) {
Neil Hormane843fa52010-10-13 16:01:50 +00002848 block_netpoll_tx();
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002849 write_lock_bh(&bond->curr_slave_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850
2851 bond_select_active_slave(bond);
2852
Jay Vosburgh059fe7a2007-10-17 17:37:49 -07002853 write_unlock_bh(&bond->curr_slave_lock);
Neil Hormane843fa52010-10-13 16:01:50 +00002854 unblock_netpoll_tx();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 }
2856
2857re_arm:
Jay Vosburghe6d265e2011-10-28 15:42:50 +00002858 if (bond->params.arp_interval)
Jay Vosburgh1b76b312007-10-17 17:37:45 -07002859 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
Jay Vosburghe6d265e2011-10-28 15:42:50 +00002860
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 read_unlock(&bond->lock);
2862}
2863
2864/*
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002865 * Called to inspect slaves for active-backup mode ARP monitor link state
2866 * changes. Sets new_link in slaves to specify what action should take
2867 * place for the slave. Returns 0 if no changes are found, >0 if changes
2868 * to link states must be committed.
2869 *
2870 * Called with bond->lock held for read.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 */
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002872static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 struct slave *slave;
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002875 int i, commit = 0;
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002876 unsigned long trans_start;
Jiri Bohacda210f52012-08-30 12:02:47 +00002877 int extra_ticks;
2878
2879 /* All the time comparisons below need some extra time. Otherwise, on
2880 * fast networks the ARP probe/reply may arrive within the same jiffy
2881 * as it was sent. Then, the next time the ARP monitor is run, one
2882 * arp_interval will already have passed in the comparisons.
2883 */
2884 extra_ticks = delta_in_ticks / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 bond_for_each_slave(bond, slave, i) {
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002887 slave->new_link = BOND_LINK_NOCHANGE;
2888
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 if (slave->link != BOND_LINK_UP) {
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002890 if (time_in_range(jiffies,
2891 slave_last_rx(bond, slave) - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002892 slave_last_rx(bond, slave) + delta_in_ticks + extra_ticks)) {
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002893
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002894 slave->new_link = BOND_LINK_UP;
2895 commit++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002898 continue;
2899 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002901 /*
2902 * Give slaves 2*delta after being enslaved or made
2903 * active. This avoids bouncing, as the last receive
2904 * times need a full ARP monitor cycle to be updated.
2905 */
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002906 if (time_in_range(jiffies,
2907 slave->jiffies - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002908 slave->jiffies + 2 * delta_in_ticks + extra_ticks))
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002909 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002911 /*
2912 * Backup slave is down if:
2913 * - No current_arp_slave AND
2914 * - more than 3*delta since last receive AND
2915 * - the bond has an IP address
2916 *
2917 * Note: a non-null current_arp_slave indicates
2918 * the curr_active_slave went down and we are
2919 * searching for a new one; under this condition
2920 * we only take the curr_active_slave down - this
2921 * gives each slave a chance to tx/rx traffic
2922 * before being taken out
2923 */
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002924 if (!bond_is_active_slave(slave) &&
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002925 !bond->current_arp_slave &&
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002926 !time_in_range(jiffies,
2927 slave_last_rx(bond, slave) - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002928 slave_last_rx(bond, slave) + 3 * delta_in_ticks + extra_ticks)) {
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002929
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002930 slave->new_link = BOND_LINK_DOWN;
2931 commit++;
2932 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002934 /*
2935 * Active slave is down if:
2936 * - more than 2*delta since transmitting OR
2937 * - (more than 2*delta since receive AND
2938 * the bond has an IP address)
2939 */
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002940 trans_start = dev_trans_start(slave->dev);
Jiri Pirkoe30bc062011-03-12 03:14:37 +00002941 if (bond_is_active_slave(slave) &&
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002942 (!time_in_range(jiffies,
2943 trans_start - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002944 trans_start + 2 * delta_in_ticks + extra_ticks) ||
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002945 !time_in_range(jiffies,
2946 slave_last_rx(bond, slave) - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002947 slave_last_rx(bond, slave) + 2 * delta_in_ticks + extra_ticks))) {
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002948
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002949 slave->new_link = BOND_LINK_DOWN;
2950 commit++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 }
2952 }
2953
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002954 return commit;
2955}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002957/*
2958 * Called to commit link state changes noted by inspection step of
2959 * active-backup mode ARP monitor.
2960 *
2961 * Called with RTNL and bond->lock for read.
2962 */
2963static void bond_ab_arp_commit(struct bonding *bond, int delta_in_ticks)
2964{
2965 struct slave *slave;
2966 int i;
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002967 unsigned long trans_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002969 bond_for_each_slave(bond, slave, i) {
2970 switch (slave->new_link) {
2971 case BOND_LINK_NOCHANGE:
2972 continue;
2973
2974 case BOND_LINK_UP:
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002975 trans_start = dev_trans_start(slave->dev);
Jiri Pirkob9f60252009-08-31 11:09:38 +00002976 if ((!bond->curr_active_slave &&
Jiri Bohaccb32f2a2010-09-02 05:45:54 +00002977 time_in_range(jiffies,
2978 trans_start - delta_in_ticks,
Jiri Bohacda210f52012-08-30 12:02:47 +00002979 trans_start + delta_in_ticks + delta_in_ticks / 2)) ||
Jiri Pirkob9f60252009-08-31 11:09:38 +00002980 bond->curr_active_slave != slave) {
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002981 slave->link = BOND_LINK_UP;
Veaceslav Falico5a430972012-04-05 03:47:43 +00002982 if (bond->current_arp_slave) {
2983 bond_set_slave_inactive_flags(
2984 bond->current_arp_slave);
2985 bond->current_arp_slave = NULL;
2986 }
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002987
Joe Perchesa4aee5c2009-12-13 20:06:07 -08002988 pr_info("%s: link status definitely up for interface %s.\n",
Jiri Pirkob9f60252009-08-31 11:09:38 +00002989 bond->dev->name, slave->dev->name);
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002990
Jiri Pirkob9f60252009-08-31 11:09:38 +00002991 if (!bond->curr_active_slave ||
2992 (slave == bond->primary_slave))
2993 goto do_failover;
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002994
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002995 }
2996
Jiri Pirkob9f60252009-08-31 11:09:38 +00002997 continue;
Jay Vosburghb2220ca2008-05-17 21:10:13 -07002998
2999 case BOND_LINK_DOWN:
3000 if (slave->link_failure_count < UINT_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 slave->link_failure_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003003 slave->link = BOND_LINK_DOWN;
Jiri Pirkob9f60252009-08-31 11:09:38 +00003004 bond_set_slave_inactive_flags(slave);
3005
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003006 pr_info("%s: link status definitely down for interface %s, disabling it\n",
Jiri Pirkob9f60252009-08-31 11:09:38 +00003007 bond->dev->name, slave->dev->name);
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003008
3009 if (slave == bond->curr_active_slave) {
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003010 bond->current_arp_slave = NULL;
Jiri Pirkob9f60252009-08-31 11:09:38 +00003011 goto do_failover;
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003012 }
Jiri Pirkob9f60252009-08-31 11:09:38 +00003013
3014 continue;
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003015
3016 default:
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003017 pr_err("%s: impossible: new_link %d on slave %s\n",
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003018 bond->dev->name, slave->new_link,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 slave->dev->name);
Jiri Pirkob9f60252009-08-31 11:09:38 +00003020 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022
Jiri Pirkob9f60252009-08-31 11:09:38 +00003023do_failover:
3024 ASSERT_RTNL();
Neil Hormane843fa52010-10-13 16:01:50 +00003025 block_netpoll_tx();
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003026 write_lock_bh(&bond->curr_slave_lock);
Jiri Pirkob9f60252009-08-31 11:09:38 +00003027 bond_select_active_slave(bond);
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003028 write_unlock_bh(&bond->curr_slave_lock);
Neil Hormane843fa52010-10-13 16:01:50 +00003029 unblock_netpoll_tx();
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003030 }
3031
3032 bond_set_carrier(bond);
3033}
3034
3035/*
3036 * Send ARP probes for active-backup mode ARP monitor.
3037 *
3038 * Called with bond->lock held for read.
3039 */
3040static void bond_ab_arp_probe(struct bonding *bond)
3041{
3042 struct slave *slave;
3043 int i;
3044
3045 read_lock(&bond->curr_slave_lock);
3046
3047 if (bond->current_arp_slave && bond->curr_active_slave)
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003048 pr_info("PROBE: c_arp %s && cas %s BAD\n",
3049 bond->current_arp_slave->dev->name,
3050 bond->curr_active_slave->dev->name);
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003051
3052 if (bond->curr_active_slave) {
3053 bond_arp_send_all(bond, bond->curr_active_slave);
3054 read_unlock(&bond->curr_slave_lock);
3055 return;
3056 }
3057
3058 read_unlock(&bond->curr_slave_lock);
3059
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060 /* if we don't have a curr_active_slave, search for the next available
3061 * backup slave from the current_arp_slave and make it the candidate
3062 * for becoming the curr_active_slave
3063 */
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003064
3065 if (!bond->current_arp_slave) {
3066 bond->current_arp_slave = bond->first_slave;
3067 if (!bond->current_arp_slave)
3068 return;
3069 }
3070
3071 bond_set_slave_inactive_flags(bond->current_arp_slave);
3072
3073 /* search for next candidate */
3074 bond_for_each_slave_from(bond, slave, i, bond->current_arp_slave->next) {
3075 if (IS_UP(slave->dev)) {
3076 slave->link = BOND_LINK_BACK;
3077 bond_set_slave_active_flags(slave);
3078 bond_arp_send_all(bond, slave);
3079 slave->jiffies = jiffies;
3080 bond->current_arp_slave = slave;
3081 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 }
3083
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003084 /* if the link state is up at this point, we
3085 * mark it down - this can happen if we have
3086 * simultaneous link failures and
3087 * reselect_active_interface doesn't make this
3088 * one the current slave so it is still marked
3089 * up when it is actually down
3090 */
3091 if (slave->link == BOND_LINK_UP) {
3092 slave->link = BOND_LINK_DOWN;
3093 if (slave->link_failure_count < UINT_MAX)
3094 slave->link_failure_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003096 bond_set_slave_inactive_flags(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003098 pr_info("%s: backup interface %s is now down.\n",
3099 bond->dev->name, slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 }
3101 }
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003102}
3103
3104void bond_activebackup_arp_mon(struct work_struct *work)
3105{
3106 struct bonding *bond = container_of(work, struct bonding,
3107 arp_work.work);
Ben Hutchingsad246c92011-04-26 15:25:52 +00003108 bool should_notify_peers = false;
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003109 int delta_in_ticks;
3110
3111 read_lock(&bond->lock);
3112
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003113 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
3114
3115 if (bond->slave_cnt == 0)
3116 goto re_arm;
3117
Ben Hutchingsad246c92011-04-26 15:25:52 +00003118 should_notify_peers = bond_should_notify_peers(bond);
3119
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003120 if (bond_ab_arp_inspect(bond, delta_in_ticks)) {
3121 read_unlock(&bond->lock);
Jay Vosburghe6d265e2011-10-28 15:42:50 +00003122
3123 /* Race avoidance with bond_close flush of workqueue */
3124 if (!rtnl_trylock()) {
3125 read_lock(&bond->lock);
3126 delta_in_ticks = 1;
3127 should_notify_peers = false;
3128 goto re_arm;
3129 }
3130
Jay Vosburghb2220ca2008-05-17 21:10:13 -07003131 read_lock(&bond->lock);
3132
3133 bond_ab_arp_commit(bond, delta_in_ticks);
3134
3135 read_unlock(&bond->lock);
3136 rtnl_unlock();
3137 read_lock(&bond->lock);
3138 }
3139
3140 bond_ab_arp_probe(bond);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003141
3142re_arm:
Jay Vosburghe6d265e2011-10-28 15:42:50 +00003143 if (bond->params.arp_interval)
Jay Vosburgh1b76b312007-10-17 17:37:45 -07003144 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
Jay Vosburghe6d265e2011-10-28 15:42:50 +00003145
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146 read_unlock(&bond->lock);
Ben Hutchingsad246c92011-04-26 15:25:52 +00003147
3148 if (should_notify_peers) {
Jay Vosburghe6d265e2011-10-28 15:42:50 +00003149 if (!rtnl_trylock()) {
3150 read_lock(&bond->lock);
3151 bond->send_peer_notif++;
3152 read_unlock(&bond->lock);
3153 return;
3154 }
Amerigo Wangb7bc2a52012-08-09 22:14:57 +00003155 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev);
Ben Hutchingsad246c92011-04-26 15:25:52 +00003156 rtnl_unlock();
3157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158}
3159
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160/*-------------------------- netdev event handling --------------------------*/
3161
3162/*
3163 * Change device name
3164 */
3165static int bond_event_changename(struct bonding *bond)
3166{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 bond_remove_proc_entry(bond);
3168 bond_create_proc_entry(bond);
Stephen Hemminger7e083842009-06-12 19:02:46 +00003169
Taku Izumif073c7c2010-12-09 15:17:13 +00003170 bond_debug_reregister(bond);
3171
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 return NOTIFY_DONE;
3173}
3174
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003175static int bond_master_netdev_event(unsigned long event,
3176 struct net_device *bond_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177{
Wang Chen454d7c92008-11-12 23:37:49 -08003178 struct bonding *event_bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179
3180 switch (event) {
3181 case NETDEV_CHANGENAME:
3182 return bond_event_changename(event_bond);
Eric W. Biedermana64d49c2012-07-09 10:51:45 +00003183 case NETDEV_UNREGISTER:
3184 bond_remove_proc_entry(event_bond);
3185 break;
3186 case NETDEV_REGISTER:
3187 bond_create_proc_entry(event_bond);
3188 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 default:
3190 break;
3191 }
3192
3193 return NOTIFY_DONE;
3194}
3195
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003196static int bond_slave_netdev_event(unsigned long event,
3197 struct net_device *slave_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003198{
Jiri Pirko471cb5a2013-01-03 22:49:01 +00003199 struct slave *slave = bond_slave_get_rtnl(slave_dev);
nikolay@redhat.com61013912013-04-11 09:18:55 +00003200 struct bonding *bond;
3201 struct net_device *bond_dev;
Jiri Pirko471cb5a2013-01-03 22:49:01 +00003202 u32 old_speed;
3203 u8 old_duplex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204
nikolay@redhat.com61013912013-04-11 09:18:55 +00003205 /* A netdev event can be generated while enslaving a device
3206 * before netdev_rx_handler_register is called in which case
3207 * slave will be NULL
3208 */
3209 if (!slave)
3210 return NOTIFY_DONE;
3211 bond_dev = slave->bond->dev;
3212 bond = slave->bond;
3213
Linus Torvalds1da177e2005-04-16 15:20:36 -07003214 switch (event) {
3215 case NETDEV_UNREGISTER:
Jiri Pirko471cb5a2013-01-03 22:49:01 +00003216 if (bond->setup_by_slave)
3217 bond_release_and_destroy(bond_dev, slave_dev);
3218 else
3219 bond_release(bond_dev, slave_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220 break;
Weiping Pan98f41f62011-10-31 17:20:48 +00003221 case NETDEV_UP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222 case NETDEV_CHANGE:
Jiri Pirko471cb5a2013-01-03 22:49:01 +00003223 old_speed = slave->speed;
3224 old_duplex = slave->duplex;
Jay Vosburgh17d04502009-03-18 18:38:25 -07003225
Jiri Pirko471cb5a2013-01-03 22:49:01 +00003226 bond_update_speed_duplex(slave);
Jay Vosburgh17d04502009-03-18 18:38:25 -07003227
Jiri Pirko471cb5a2013-01-03 22:49:01 +00003228 if (bond->params.mode == BOND_MODE_8023AD) {
3229 if (old_speed != slave->speed)
3230 bond_3ad_adapter_speed_changed(slave);
3231 if (old_duplex != slave->duplex)
3232 bond_3ad_adapter_duplex_changed(slave);
Jay Vosburgh17d04502009-03-18 18:38:25 -07003233 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234 break;
3235 case NETDEV_DOWN:
3236 /*
3237 * ... Or is it this?
3238 */
3239 break;
3240 case NETDEV_CHANGEMTU:
3241 /*
3242 * TODO: Should slaves be allowed to
3243 * independently alter their MTU? For
3244 * an active-backup bond, slaves need
3245 * not be the same type of device, so
3246 * MTUs may vary. For other modes,
3247 * slaves arguably should have the
3248 * same MTUs. To do this, we'd need to
3249 * take over the slave's change_mtu
3250 * function for the duration of their
3251 * servitude.
3252 */
3253 break;
3254 case NETDEV_CHANGENAME:
3255 /*
3256 * TODO: handle changing the primary's name
3257 */
3258 break;
Arthur Kepner8531c5f2005-08-23 01:34:53 -04003259 case NETDEV_FEAT_CHANGE:
3260 bond_compute_features(bond);
3261 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262 default:
3263 break;
3264 }
3265
3266 return NOTIFY_DONE;
3267}
3268
3269/*
3270 * bond_netdev_event: handle netdev notifier chain events.
3271 *
3272 * This function receives events for the netdev chain. The caller (an
Alan Sterne041c682006-03-27 01:16:30 -08003273 * ioctl handler calling blocking_notifier_call_chain) holds the necessary
Linus Torvalds1da177e2005-04-16 15:20:36 -07003274 * locks for us to safely manipulate the slave devices (RTNL lock,
3275 * dev_probe_lock).
3276 */
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003277static int bond_netdev_event(struct notifier_block *this,
3278 unsigned long event, void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279{
Jiri Pirko351638e2013-05-28 01:30:21 +00003280 struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08003282 pr_debug("event_dev: %s, event: %lx\n",
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003283 event_dev ? event_dev->name : "None",
3284 event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285
Jay Vosburgh0b680e72006-09-22 21:54:10 -07003286 if (!(event_dev->priv_flags & IFF_BONDING))
3287 return NOTIFY_DONE;
3288
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 if (event_dev->flags & IFF_MASTER) {
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08003290 pr_debug("IFF_MASTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003291 return bond_master_netdev_event(event, event_dev);
3292 }
3293
3294 if (event_dev->flags & IFF_SLAVE) {
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08003295 pr_debug("IFF_SLAVE\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296 return bond_slave_netdev_event(event, event_dev);
3297 }
3298
3299 return NOTIFY_DONE;
3300}
3301
3302static struct notifier_block bond_netdev_notifier = {
3303 .notifier_call = bond_netdev_event,
3304};
3305
Jay Vosburgh169a3e62005-06-26 17:54:11 -04003306/*---------------------------- Hashing Policies -----------------------------*/
3307
3308/*
Jay Vosburgh169a3e62005-06-26 17:54:11 -04003309 * Hash for the output device based upon layer 2 data
3310 */
Jasper Spaansa361c832009-10-23 04:09:24 +00003311static int bond_xmit_hash_policy_l2(struct sk_buff *skb, int count)
Jay Vosburgh169a3e62005-06-26 17:54:11 -04003312{
3313 struct ethhdr *data = (struct ethhdr *)skb->data;
3314
John Eaglesham6b923cb2012-08-21 20:43:35 +00003315 if (skb_headlen(skb) >= offsetof(struct ethhdr, h_proto))
3316 return (data->h_dest[5] ^ data->h_source[5]) % count;
3317
3318 return 0;
3319}
3320
3321/*
3322 * Hash for the output device based upon layer 2 and layer 3 data. If
3323 * the packet is not IP, fall back on bond_xmit_hash_policy_l2()
3324 */
3325static int bond_xmit_hash_policy_l23(struct sk_buff *skb, int count)
3326{
Eric Dumazet43945422013-04-15 17:03:24 +00003327 const struct ethhdr *data;
3328 const struct iphdr *iph;
3329 const struct ipv6hdr *ipv6h;
John Eaglesham6b923cb2012-08-21 20:43:35 +00003330 u32 v6hash;
Eric Dumazet43945422013-04-15 17:03:24 +00003331 const __be32 *s, *d;
John Eaglesham6b923cb2012-08-21 20:43:35 +00003332
3333 if (skb->protocol == htons(ETH_P_IP) &&
Eric Dumazet43945422013-04-15 17:03:24 +00003334 pskb_network_may_pull(skb, sizeof(*iph))) {
John Eaglesham6b923cb2012-08-21 20:43:35 +00003335 iph = ip_hdr(skb);
Eric Dumazet43945422013-04-15 17:03:24 +00003336 data = (struct ethhdr *)skb->data;
John Eaglesham6b923cb2012-08-21 20:43:35 +00003337 return ((ntohl(iph->saddr ^ iph->daddr) & 0xffff) ^
3338 (data->h_dest[5] ^ data->h_source[5])) % count;
3339 } else if (skb->protocol == htons(ETH_P_IPV6) &&
Eric Dumazet43945422013-04-15 17:03:24 +00003340 pskb_network_may_pull(skb, sizeof(*ipv6h))) {
John Eaglesham6b923cb2012-08-21 20:43:35 +00003341 ipv6h = ipv6_hdr(skb);
Eric Dumazet43945422013-04-15 17:03:24 +00003342 data = (struct ethhdr *)skb->data;
John Eaglesham6b923cb2012-08-21 20:43:35 +00003343 s = &ipv6h->saddr.s6_addr32[0];
3344 d = &ipv6h->daddr.s6_addr32[0];
3345 v6hash = (s[1] ^ d[1]) ^ (s[2] ^ d[2]) ^ (s[3] ^ d[3]);
3346 v6hash ^= (v6hash >> 24) ^ (v6hash >> 16) ^ (v6hash >> 8);
3347 return (v6hash ^ data->h_dest[5] ^ data->h_source[5]) % count;
3348 }
3349
3350 return bond_xmit_hash_policy_l2(skb, count);
3351}
3352
3353/*
3354 * Hash for the output device based upon layer 3 and layer 4 data. If
3355 * the packet is a frag or not TCP or UDP, just use layer 3 data. If it is
3356 * altogether not IP, fall back on bond_xmit_hash_policy_l2()
3357 */
3358static int bond_xmit_hash_policy_l34(struct sk_buff *skb, int count)
3359{
3360 u32 layer4_xor = 0;
Eric Dumazet43945422013-04-15 17:03:24 +00003361 const struct iphdr *iph;
3362 const struct ipv6hdr *ipv6h;
3363 const __be32 *s, *d;
3364 const __be16 *l4 = NULL;
3365 __be16 _l4[2];
3366 int noff = skb_network_offset(skb);
3367 int poff;
John Eaglesham6b923cb2012-08-21 20:43:35 +00003368
3369 if (skb->protocol == htons(ETH_P_IP) &&
Eric Dumazet43945422013-04-15 17:03:24 +00003370 pskb_may_pull(skb, noff + sizeof(*iph))) {
John Eaglesham6b923cb2012-08-21 20:43:35 +00003371 iph = ip_hdr(skb);
Eric Dumazet43945422013-04-15 17:03:24 +00003372 poff = proto_ports_offset(iph->protocol);
3373
3374 if (!ip_is_fragment(iph) && poff >= 0) {
3375 l4 = skb_header_pointer(skb, noff + (iph->ihl << 2) + poff,
3376 sizeof(_l4), &_l4);
3377 if (l4)
3378 layer4_xor = ntohs(l4[0] ^ l4[1]);
John Eaglesham6b923cb2012-08-21 20:43:35 +00003379 }
3380 return (layer4_xor ^
3381 ((ntohl(iph->saddr ^ iph->daddr)) & 0xffff)) % count;
3382 } else if (skb->protocol == htons(ETH_P_IPV6) &&
Eric Dumazet43945422013-04-15 17:03:24 +00003383 pskb_may_pull(skb, noff + sizeof(*ipv6h))) {
John Eaglesham6b923cb2012-08-21 20:43:35 +00003384 ipv6h = ipv6_hdr(skb);
Eric Dumazet43945422013-04-15 17:03:24 +00003385 poff = proto_ports_offset(ipv6h->nexthdr);
3386 if (poff >= 0) {
3387 l4 = skb_header_pointer(skb, noff + sizeof(*ipv6h) + poff,
3388 sizeof(_l4), &_l4);
3389 if (l4)
3390 layer4_xor = ntohs(l4[0] ^ l4[1]);
John Eaglesham6b923cb2012-08-21 20:43:35 +00003391 }
3392 s = &ipv6h->saddr.s6_addr32[0];
3393 d = &ipv6h->daddr.s6_addr32[0];
3394 layer4_xor ^= (s[1] ^ d[1]) ^ (s[2] ^ d[2]) ^ (s[3] ^ d[3]);
3395 layer4_xor ^= (layer4_xor >> 24) ^ (layer4_xor >> 16) ^
3396 (layer4_xor >> 8);
3397 return layer4_xor % count;
3398 }
3399
3400 return bond_xmit_hash_policy_l2(skb, count);
Jay Vosburgh169a3e62005-06-26 17:54:11 -04003401}
3402
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403/*-------------------------- Device entry points ----------------------------*/
3404
nikolay@redhat.comfbb0c412012-11-29 01:31:31 +00003405static void bond_work_init_all(struct bonding *bond)
3406{
3407 INIT_DELAYED_WORK(&bond->mcast_work,
3408 bond_resend_igmp_join_requests_delayed);
3409 INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
3410 INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor);
3411 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
3412 INIT_DELAYED_WORK(&bond->arp_work, bond_activebackup_arp_mon);
3413 else
3414 INIT_DELAYED_WORK(&bond->arp_work, bond_loadbalance_arp_mon);
3415 INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
3416}
3417
3418static void bond_work_cancel_all(struct bonding *bond)
3419{
3420 cancel_delayed_work_sync(&bond->mii_work);
3421 cancel_delayed_work_sync(&bond->arp_work);
3422 cancel_delayed_work_sync(&bond->alb_work);
3423 cancel_delayed_work_sync(&bond->ad_work);
3424 cancel_delayed_work_sync(&bond->mcast_work);
3425}
3426
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427static int bond_open(struct net_device *bond_dev)
3428{
Wang Chen454d7c92008-11-12 23:37:49 -08003429 struct bonding *bond = netdev_priv(bond_dev);
Peter Pan(潘卫平)ba3211c2011-08-15 15:57:35 +00003430 struct slave *slave;
3431 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003432
Peter Pan(潘卫平)ba3211c2011-08-15 15:57:35 +00003433 /* reset slave->backup and slave->inactive */
3434 read_lock(&bond->lock);
3435 if (bond->slave_cnt > 0) {
3436 read_lock(&bond->curr_slave_lock);
3437 bond_for_each_slave(bond, slave, i) {
3438 if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
3439 && (slave != bond->curr_active_slave)) {
3440 bond_set_slave_inactive_flags(slave);
3441 } else {
3442 bond_set_slave_active_flags(slave);
3443 }
3444 }
3445 read_unlock(&bond->curr_slave_lock);
3446 }
3447 read_unlock(&bond->lock);
3448
nikolay@redhat.comfbb0c412012-11-29 01:31:31 +00003449 bond_work_init_all(bond);
Flavio Leitner5a37e8c2010-10-05 14:23:57 +00003450
Holger Eitzenberger58402052008-12-09 23:07:13 -08003451 if (bond_is_lb(bond)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452 /* bond_alb_initialize must be called before the timer
3453 * is started.
3454 */
nikolay@redhat.comfbb0c412012-11-29 01:31:31 +00003455 if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB)))
stephen hemmingerb4739462010-01-25 23:34:15 +00003456 return -ENOMEM;
Jay Vosburgh1b76b312007-10-17 17:37:45 -07003457 queue_delayed_work(bond->wq, &bond->alb_work, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003458 }
3459
nikolay@redhat.comfbb0c412012-11-29 01:31:31 +00003460 if (bond->params.miimon) /* link check interval, in milliseconds. */
Jay Vosburgh1b76b312007-10-17 17:37:45 -07003461 queue_delayed_work(bond->wq, &bond->mii_work, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462
3463 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
Jay Vosburgh1b76b312007-10-17 17:37:45 -07003464 queue_delayed_work(bond->wq, &bond->arp_work, 0);
Jay Vosburghf5b2b962006-09-22 21:54:53 -07003465 if (bond->params.arp_validate)
Jiri Pirko3aba8912011-04-19 03:48:16 +00003466 bond->recv_probe = bond_arp_rcv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003467 }
3468
3469 if (bond->params.mode == BOND_MODE_8023AD) {
Jay Vosburgh1b76b312007-10-17 17:37:45 -07003470 queue_delayed_work(bond->wq, &bond->ad_work, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003471 /* register to receive LACPDUs */
Jiri Pirko3aba8912011-04-19 03:48:16 +00003472 bond->recv_probe = bond_3ad_lacpdu_recv;
Jay Vosburghfd989c82008-11-04 17:51:16 -08003473 bond_3ad_initiate_agg_selection(bond, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474 }
3475
3476 return 0;
3477}
3478
3479static int bond_close(struct net_device *bond_dev)
3480{
Wang Chen454d7c92008-11-12 23:37:49 -08003481 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483 write_lock_bh(&bond->lock);
Ben Hutchingsad246c92011-04-26 15:25:52 +00003484 bond->send_peer_notif = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485 write_unlock_bh(&bond->lock);
3486
nikolay@redhat.comfbb0c412012-11-29 01:31:31 +00003487 bond_work_cancel_all(bond);
Holger Eitzenberger58402052008-12-09 23:07:13 -08003488 if (bond_is_lb(bond)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489 /* Must be called only after all
3490 * slaves have been released
3491 */
3492 bond_alb_deinitialize(bond);
3493 }
Jiri Pirko3aba8912011-04-19 03:48:16 +00003494 bond->recv_probe = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495
3496 return 0;
3497}
3498
Eric Dumazet28172732010-07-07 14:58:56 -07003499static struct rtnl_link_stats64 *bond_get_stats(struct net_device *bond_dev,
3500 struct rtnl_link_stats64 *stats)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003501{
Wang Chen454d7c92008-11-12 23:37:49 -08003502 struct bonding *bond = netdev_priv(bond_dev);
Eric Dumazet28172732010-07-07 14:58:56 -07003503 struct rtnl_link_stats64 temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003504 struct slave *slave;
3505 int i;
3506
Eric Dumazet28172732010-07-07 14:58:56 -07003507 memset(stats, 0, sizeof(*stats));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003508
3509 read_lock_bh(&bond->lock);
3510
3511 bond_for_each_slave(bond, slave, i) {
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +00003512 const struct rtnl_link_stats64 *sstats =
Eric Dumazet28172732010-07-07 14:58:56 -07003513 dev_get_stats(slave->dev, &temp);
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -08003514
Eric Dumazet28172732010-07-07 14:58:56 -07003515 stats->rx_packets += sstats->rx_packets;
3516 stats->rx_bytes += sstats->rx_bytes;
3517 stats->rx_errors += sstats->rx_errors;
3518 stats->rx_dropped += sstats->rx_dropped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519
Eric Dumazet28172732010-07-07 14:58:56 -07003520 stats->tx_packets += sstats->tx_packets;
3521 stats->tx_bytes += sstats->tx_bytes;
3522 stats->tx_errors += sstats->tx_errors;
3523 stats->tx_dropped += sstats->tx_dropped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003524
Eric Dumazet28172732010-07-07 14:58:56 -07003525 stats->multicast += sstats->multicast;
3526 stats->collisions += sstats->collisions;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527
Eric Dumazet28172732010-07-07 14:58:56 -07003528 stats->rx_length_errors += sstats->rx_length_errors;
3529 stats->rx_over_errors += sstats->rx_over_errors;
3530 stats->rx_crc_errors += sstats->rx_crc_errors;
3531 stats->rx_frame_errors += sstats->rx_frame_errors;
3532 stats->rx_fifo_errors += sstats->rx_fifo_errors;
3533 stats->rx_missed_errors += sstats->rx_missed_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003534
Eric Dumazet28172732010-07-07 14:58:56 -07003535 stats->tx_aborted_errors += sstats->tx_aborted_errors;
3536 stats->tx_carrier_errors += sstats->tx_carrier_errors;
3537 stats->tx_fifo_errors += sstats->tx_fifo_errors;
3538 stats->tx_heartbeat_errors += sstats->tx_heartbeat_errors;
3539 stats->tx_window_errors += sstats->tx_window_errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003540 }
3541
3542 read_unlock_bh(&bond->lock);
3543
3544 return stats;
3545}
3546
3547static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
3548{
3549 struct net_device *slave_dev = NULL;
3550 struct ifbond k_binfo;
3551 struct ifbond __user *u_binfo = NULL;
3552 struct ifslave k_sinfo;
3553 struct ifslave __user *u_sinfo = NULL;
3554 struct mii_ioctl_data *mii = NULL;
Gao feng387ff9112013-01-31 16:31:00 +00003555 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003556 int res = 0;
3557
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003558 pr_debug("bond_ioctl: master=%s, cmd=%d\n", bond_dev->name, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003559
3560 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561 case SIOCGMIIPHY:
3562 mii = if_mii(ifr);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003563 if (!mii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564 return -EINVAL;
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003565
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566 mii->phy_id = 0;
3567 /* Fall Through */
3568 case SIOCGMIIREG:
3569 /*
3570 * We do this again just in case we were called by SIOCGMIIREG
3571 * instead of SIOCGMIIPHY.
3572 */
3573 mii = if_mii(ifr);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003574 if (!mii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003575 return -EINVAL;
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003576
Linus Torvalds1da177e2005-04-16 15:20:36 -07003577
3578 if (mii->reg_num == 1) {
Wang Chen454d7c92008-11-12 23:37:49 -08003579 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003580 mii->val_out = 0;
Jay Vosburgh6603a6f2007-10-17 17:37:50 -07003581 read_lock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 read_lock(&bond->curr_slave_lock);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003583 if (netif_carrier_ok(bond->dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003584 mii->val_out = BMSR_LSTATUS;
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003585
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586 read_unlock(&bond->curr_slave_lock);
Jay Vosburgh6603a6f2007-10-17 17:37:50 -07003587 read_unlock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588 }
3589
3590 return 0;
3591 case BOND_INFO_QUERY_OLD:
3592 case SIOCBONDINFOQUERY:
3593 u_binfo = (struct ifbond __user *)ifr->ifr_data;
3594
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003595 if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003597
3598 res = bond_info_query(bond_dev, &k_binfo);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003599 if (res == 0 &&
3600 copy_to_user(u_binfo, &k_binfo, sizeof(ifbond)))
3601 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003602
3603 return res;
3604 case BOND_SLAVE_INFO_QUERY_OLD:
3605 case SIOCBONDSLAVEINFOQUERY:
3606 u_sinfo = (struct ifslave __user *)ifr->ifr_data;
3607
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003608 if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003609 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003610
3611 res = bond_slave_info_query(bond_dev, &k_sinfo);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003612 if (res == 0 &&
3613 copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave)))
3614 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003615
3616 return res;
3617 default:
3618 /* Go on */
3619 break;
3620 }
3621
Gao feng387ff9112013-01-31 16:31:00 +00003622 net = dev_net(bond_dev);
3623
3624 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003625 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003626
Gao feng387ff9112013-01-31 16:31:00 +00003627 slave_dev = dev_get_by_name(net, ifr->ifr_slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003629 pr_debug("slave_dev=%p:\n", slave_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003630
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003631 if (!slave_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003632 res = -ENODEV;
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003633 else {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003634 pr_debug("slave_dev->name=%s:\n", slave_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003635 switch (cmd) {
3636 case BOND_ENSLAVE_OLD:
3637 case SIOCBONDENSLAVE:
3638 res = bond_enslave(bond_dev, slave_dev);
3639 break;
3640 case BOND_RELEASE_OLD:
3641 case SIOCBONDRELEASE:
3642 res = bond_release(bond_dev, slave_dev);
3643 break;
3644 case BOND_SETHWADDR_OLD:
3645 case SIOCBONDSETHWADDR:
Jiri Pirko409cc1f2013-01-30 11:08:11 +01003646 bond_set_dev_addr(bond_dev, slave_dev);
3647 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003648 break;
3649 case BOND_CHANGE_ACTIVE_OLD:
3650 case SIOCBONDCHANGEACTIVE:
3651 res = bond_ioctl_change_active(bond_dev, slave_dev);
3652 break;
3653 default:
3654 res = -EOPNOTSUPP;
3655 }
3656
3657 dev_put(slave_dev);
3658 }
3659
Linus Torvalds1da177e2005-04-16 15:20:36 -07003660 return res;
3661}
3662
Jiri Pirko22bedad32010-04-01 21:22:57 +00003663static bool bond_addr_in_mc_list(unsigned char *addr,
3664 struct netdev_hw_addr_list *list,
3665 int addrlen)
3666{
3667 struct netdev_hw_addr *ha;
3668
3669 netdev_hw_addr_list_for_each(ha, list)
3670 if (!memcmp(ha->addr, addr, addrlen))
3671 return true;
3672
3673 return false;
3674}
3675
Jiri Pirkod03462b2011-08-16 03:15:04 +00003676static void bond_change_rx_flags(struct net_device *bond_dev, int change)
3677{
3678 struct bonding *bond = netdev_priv(bond_dev);
3679
3680 if (change & IFF_PROMISC)
3681 bond_set_promiscuity(bond,
3682 bond_dev->flags & IFF_PROMISC ? 1 : -1);
3683
3684 if (change & IFF_ALLMULTI)
3685 bond_set_allmulti(bond,
3686 bond_dev->flags & IFF_ALLMULTI ? 1 : -1);
3687}
3688
Linus Torvalds1da177e2005-04-16 15:20:36 -07003689static void bond_set_multicast_list(struct net_device *bond_dev)
3690{
Wang Chen454d7c92008-11-12 23:37:49 -08003691 struct bonding *bond = netdev_priv(bond_dev);
Jiri Pirko22bedad32010-04-01 21:22:57 +00003692 struct netdev_hw_addr *ha;
3693 bool found;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003694
Jay Vosburgh80ee5ad2008-01-29 18:07:44 -08003695 read_lock(&bond->lock);
3696
Linus Torvalds1da177e2005-04-16 15:20:36 -07003697 /* looking for addresses to add to slaves' mc list */
Jiri Pirko22bedad32010-04-01 21:22:57 +00003698 netdev_for_each_mc_addr(ha, bond_dev) {
3699 found = bond_addr_in_mc_list(ha->addr, &bond->mc_list,
3700 bond_dev->addr_len);
3701 if (!found)
3702 bond_mc_add(bond, ha->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003703 }
3704
3705 /* looking for addresses to delete from slaves' list */
Jiri Pirko22bedad32010-04-01 21:22:57 +00003706 netdev_hw_addr_list_for_each(ha, &bond->mc_list) {
3707 found = bond_addr_in_mc_list(ha->addr, &bond_dev->mc,
3708 bond_dev->addr_len);
3709 if (!found)
3710 bond_mc_del(bond, ha->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003711 }
3712
3713 /* save master's multicast list */
Jiri Pirko22bedad32010-04-01 21:22:57 +00003714 __hw_addr_flush(&bond->mc_list);
3715 __hw_addr_add_multiple(&bond->mc_list, &bond_dev->mc,
3716 bond_dev->addr_len, NETDEV_HW_ADDR_T_MULTICAST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003717
Jay Vosburgh80ee5ad2008-01-29 18:07:44 -08003718 read_unlock(&bond->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003719}
3720
Shlomo Pongratz234bcf82012-04-03 22:56:20 +00003721static int bond_neigh_init(struct neighbour *n)
Stephen Hemminger00829822008-11-20 20:14:53 -08003722{
Shlomo Pongratz234bcf82012-04-03 22:56:20 +00003723 struct bonding *bond = netdev_priv(n->dev);
Stephen Hemminger00829822008-11-20 20:14:53 -08003724 struct slave *slave = bond->first_slave;
Shlomo Pongratz234bcf82012-04-03 22:56:20 +00003725 const struct net_device_ops *slave_ops;
3726 struct neigh_parms parms;
3727 int ret;
Stephen Hemminger00829822008-11-20 20:14:53 -08003728
Shlomo Pongratz234bcf82012-04-03 22:56:20 +00003729 if (!slave)
3730 return 0;
3731
3732 slave_ops = slave->dev->netdev_ops;
3733
3734 if (!slave_ops->ndo_neigh_setup)
3735 return 0;
3736
3737 parms.neigh_setup = NULL;
3738 parms.neigh_cleanup = NULL;
3739 ret = slave_ops->ndo_neigh_setup(slave->dev, &parms);
3740 if (ret)
3741 return ret;
3742
3743 /*
3744 * Assign slave's neigh_cleanup to neighbour in case cleanup is called
3745 * after the last slave has been detached. Assumes that all slaves
3746 * utilize the same neigh_cleanup (true at this writing as only user
3747 * is ipoib).
3748 */
3749 n->parms->neigh_cleanup = parms.neigh_cleanup;
3750
3751 if (!parms.neigh_setup)
3752 return 0;
3753
3754 return parms.neigh_setup(n);
3755}
3756
3757/*
3758 * The bonding ndo_neigh_setup is called at init time beofre any
3759 * slave exists. So we must declare proxy setup function which will
3760 * be used at run time to resolve the actual slave neigh param setup.
3761 */
3762static int bond_neigh_setup(struct net_device *dev,
3763 struct neigh_parms *parms)
3764{
3765 parms->neigh_setup = bond_neigh_init;
3766
Stephen Hemminger00829822008-11-20 20:14:53 -08003767 return 0;
3768}
3769
Linus Torvalds1da177e2005-04-16 15:20:36 -07003770/*
3771 * Change the MTU of all of a master's slaves to match the master
3772 */
3773static int bond_change_mtu(struct net_device *bond_dev, int new_mtu)
3774{
Wang Chen454d7c92008-11-12 23:37:49 -08003775 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776 struct slave *slave, *stop_at;
3777 int res = 0;
3778 int i;
3779
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08003780 pr_debug("bond=%p, name=%s, new_mtu=%d\n", bond,
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003781 (bond_dev ? bond_dev->name : "None"), new_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003782
3783 /* Can't hold bond->lock with bh disabled here since
3784 * some base drivers panic. On the other hand we can't
3785 * hold bond->lock without bh disabled because we'll
3786 * deadlock. The only solution is to rely on the fact
3787 * that we're under rtnl_lock here, and the slaves
3788 * list won't change. This doesn't solve the problem
3789 * of setting the slave's MTU while it is
3790 * transmitting, but the assumption is that the base
3791 * driver can handle that.
3792 *
3793 * TODO: figure out a way to safely iterate the slaves
3794 * list, but without holding a lock around the actual
3795 * call to the base driver.
3796 */
3797
3798 bond_for_each_slave(bond, slave, i) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003799 pr_debug("s %p s->p %p c_m %p\n",
3800 slave,
3801 slave->prev,
3802 slave->dev->netdev_ops->ndo_change_mtu);
Mitch Williamse944ef72005-11-09 10:36:50 -08003803
Linus Torvalds1da177e2005-04-16 15:20:36 -07003804 res = dev_set_mtu(slave->dev, new_mtu);
3805
3806 if (res) {
3807 /* If we failed to set the slave's mtu to the new value
3808 * we must abort the operation even in ACTIVE_BACKUP
3809 * mode, because if we allow the backup slaves to have
3810 * different mtu values than the active slave we'll
3811 * need to change their mtu when doing a failover. That
3812 * means changing their mtu from timer context, which
3813 * is probably not a good idea.
3814 */
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08003815 pr_debug("err %d %s\n", res, slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003816 goto unwind;
3817 }
3818 }
3819
3820 bond_dev->mtu = new_mtu;
3821
3822 return 0;
3823
3824unwind:
3825 /* unwind from head to the slave that failed */
3826 stop_at = slave;
3827 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
3828 int tmp_res;
3829
3830 tmp_res = dev_set_mtu(slave->dev, bond_dev->mtu);
3831 if (tmp_res) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003832 pr_debug("unwind err %d dev %s\n",
3833 tmp_res, slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003834 }
3835 }
3836
3837 return res;
3838}
3839
3840/*
3841 * Change HW address
3842 *
3843 * Note that many devices must be down to change the HW address, and
3844 * downing the master releases all slaves. We can make bonds full of
3845 * bonding devices to test this, however.
3846 */
3847static int bond_set_mac_address(struct net_device *bond_dev, void *addr)
3848{
Wang Chen454d7c92008-11-12 23:37:49 -08003849 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850 struct sockaddr *sa = addr, tmp_sa;
3851 struct slave *slave, *stop_at;
3852 int res = 0;
3853 int i;
3854
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08003855 if (bond->params.mode == BOND_MODE_ALB)
3856 return bond_alb_set_mac_address(bond_dev, addr);
3857
3858
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003859 pr_debug("bond=%p, name=%s\n",
3860 bond, bond_dev ? bond_dev->name : "None");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003861
Jay Vosburghdd957c52007-10-09 19:57:24 -07003862 /*
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07003863 * If fail_over_mac is set to active, do nothing and return
3864 * success. Returning an error causes ifenslave to fail.
Jay Vosburghdd957c52007-10-09 19:57:24 -07003865 */
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07003866 if (bond->params.fail_over_mac == BOND_FOM_ACTIVE)
Jay Vosburghdd957c52007-10-09 19:57:24 -07003867 return 0;
Moni Shoua2ab82852007-10-09 19:43:39 -07003868
Stephen Hemminger3d632c32009-06-12 19:02:48 +00003869 if (!is_valid_ether_addr(sa->sa_data))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003870 return -EADDRNOTAVAIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003871
3872 /* Can't hold bond->lock with bh disabled here since
3873 * some base drivers panic. On the other hand we can't
3874 * hold bond->lock without bh disabled because we'll
3875 * deadlock. The only solution is to rely on the fact
3876 * that we're under rtnl_lock here, and the slaves
3877 * list won't change. This doesn't solve the problem
3878 * of setting the slave's hw address while it is
3879 * transmitting, but the assumption is that the base
3880 * driver can handle that.
3881 *
3882 * TODO: figure out a way to safely iterate the slaves
3883 * list, but without holding a lock around the actual
3884 * call to the base driver.
3885 */
3886
3887 bond_for_each_slave(bond, slave, i) {
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08003888 const struct net_device_ops *slave_ops = slave->dev->netdev_ops;
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08003889 pr_debug("slave %p %s\n", slave, slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003890
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08003891 if (slave_ops->ndo_set_mac_address == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003892 res = -EOPNOTSUPP;
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08003893 pr_debug("EOPNOTSUPP %s\n", slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894 goto unwind;
3895 }
3896
3897 res = dev_set_mac_address(slave->dev, addr);
3898 if (res) {
3899 /* TODO: consider downing the slave
3900 * and retry ?
3901 * User should expect communications
3902 * breakage anyway until ARP finish
3903 * updating, so...
3904 */
Holger Eitzenberger5a03cdb2008-12-09 23:09:22 -08003905 pr_debug("err %d %s\n", res, slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003906 goto unwind;
3907 }
3908 }
3909
3910 /* success */
3911 memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);
3912 return 0;
3913
3914unwind:
3915 memcpy(tmp_sa.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
3916 tmp_sa.sa_family = bond_dev->type;
3917
3918 /* unwind from head to the slave that failed */
3919 stop_at = slave;
3920 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
3921 int tmp_res;
3922
3923 tmp_res = dev_set_mac_address(slave->dev, &tmp_sa);
3924 if (tmp_res) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08003925 pr_debug("unwind err %d dev %s\n",
3926 tmp_res, slave->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003927 }
3928 }
3929
3930 return res;
3931}
3932
3933static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
3934{
Wang Chen454d7c92008-11-12 23:37:49 -08003935 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003936 struct slave *slave, *start_at;
Jay Vosburghcf5f9042007-10-17 17:37:47 -07003937 int i, slave_no, res = 1;
Andy Gospodareka2fd9402010-03-25 14:49:05 +00003938 struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003939
Jay Vosburghcf5f9042007-10-17 17:37:47 -07003940 /*
Andy Gospodareka2fd9402010-03-25 14:49:05 +00003941 * Start with the curr_active_slave that joined the bond as the
3942 * default for sending IGMP traffic. For failover purposes one
3943 * needs to maintain some consistency for the interface that will
3944 * send the join/membership reports. The curr_active_slave found
3945 * will send all of this type of traffic.
Jay Vosburghcf5f9042007-10-17 17:37:47 -07003946 */
Eric Dumazet00ae7022010-03-30 23:08:37 +00003947 if ((iph->protocol == IPPROTO_IGMP) &&
Andy Gospodareka2fd9402010-03-25 14:49:05 +00003948 (skb->protocol == htons(ETH_P_IP))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949
Andy Gospodareka2fd9402010-03-25 14:49:05 +00003950 read_lock(&bond->curr_slave_lock);
3951 slave = bond->curr_active_slave;
3952 read_unlock(&bond->curr_slave_lock);
3953
3954 if (!slave)
3955 goto out;
3956 } else {
3957 /*
3958 * Concurrent TX may collide on rr_tx_counter; we accept
3959 * that as being rare enough not to justify using an
3960 * atomic op here.
3961 */
3962 slave_no = bond->rr_tx_counter++ % bond->slave_cnt;
3963
3964 bond_for_each_slave(bond, slave, i) {
3965 slave_no--;
3966 if (slave_no < 0)
3967 break;
3968 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969 }
3970
Jay Vosburghcf5f9042007-10-17 17:37:47 -07003971 start_at = slave;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972 bond_for_each_slave_from(bond, slave, i, start_at) {
3973 if (IS_UP(slave->dev) &&
3974 (slave->link == BOND_LINK_UP) &&
Jiri Pirkoe30bc062011-03-12 03:14:37 +00003975 bond_is_active_slave(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003976 res = bond_dev_queue_xmit(bond, skb, slave->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003977 break;
3978 }
3979 }
3980
Linus Torvalds1da177e2005-04-16 15:20:36 -07003981out:
3982 if (res) {
3983 /* no suitable interface, frame not sent */
Eric Dumazet04502432012-06-13 05:30:07 +00003984 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003985 }
Michał Mirosław0693e882011-05-07 01:48:02 +00003986
Patrick McHardyec634fe2009-07-05 19:23:38 -07003987 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003988}
3989
John W. Linville075897c2005-09-28 17:50:53 -04003990
Linus Torvalds1da177e2005-04-16 15:20:36 -07003991/*
3992 * in active-backup mode, we know that bond->curr_active_slave is always valid if
3993 * the bond has a usable interface.
3994 */
3995static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_dev)
3996{
Wang Chen454d7c92008-11-12 23:37:49 -08003997 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003998 int res = 1;
3999
Linus Torvalds1da177e2005-04-16 15:20:36 -07004000 read_lock(&bond->curr_slave_lock);
4001
Michał Mirosław0693e882011-05-07 01:48:02 +00004002 if (bond->curr_active_slave)
4003 res = bond_dev_queue_xmit(bond, skb,
4004 bond->curr_active_slave->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004005
Eric Dumazet04502432012-06-13 05:30:07 +00004006 read_unlock(&bond->curr_slave_lock);
4007
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004008 if (res)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004009 /* no suitable interface, frame not sent */
Eric Dumazet04502432012-06-13 05:30:07 +00004010 kfree_skb(skb);
Michał Mirosław0693e882011-05-07 01:48:02 +00004011
Patrick McHardyec634fe2009-07-05 19:23:38 -07004012 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004013}
4014
4015/*
Jay Vosburgh169a3e62005-06-26 17:54:11 -04004016 * In bond_xmit_xor() , we determine the output device by using a pre-
4017 * determined xmit_hash_policy(), If the selected device is not enabled,
4018 * find the next active slave.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004019 */
4020static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
4021{
Wang Chen454d7c92008-11-12 23:37:49 -08004022 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004023 struct slave *slave, *start_at;
4024 int slave_no;
4025 int i;
4026 int res = 1;
4027
Jasper Spaansa361c832009-10-23 04:09:24 +00004028 slave_no = bond->xmit_hash_policy(skb, bond->slave_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004029
4030 bond_for_each_slave(bond, slave, i) {
4031 slave_no--;
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004032 if (slave_no < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004033 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004034 }
4035
4036 start_at = slave;
4037
4038 bond_for_each_slave_from(bond, slave, i, start_at) {
4039 if (IS_UP(slave->dev) &&
4040 (slave->link == BOND_LINK_UP) &&
Jiri Pirkoe30bc062011-03-12 03:14:37 +00004041 bond_is_active_slave(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004042 res = bond_dev_queue_xmit(bond, skb, slave->dev);
4043 break;
4044 }
4045 }
4046
Linus Torvalds1da177e2005-04-16 15:20:36 -07004047 if (res) {
4048 /* no suitable interface, frame not sent */
Eric Dumazet04502432012-06-13 05:30:07 +00004049 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004050 }
Michał Mirosław0693e882011-05-07 01:48:02 +00004051
Patrick McHardyec634fe2009-07-05 19:23:38 -07004052 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004053}
4054
4055/*
4056 * in broadcast mode, we send everything to all usable interfaces.
4057 */
4058static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
4059{
Wang Chen454d7c92008-11-12 23:37:49 -08004060 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004061 struct slave *slave, *start_at;
4062 struct net_device *tx_dev = NULL;
4063 int i;
4064 int res = 1;
4065
Linus Torvalds1da177e2005-04-16 15:20:36 -07004066 read_lock(&bond->curr_slave_lock);
4067 start_at = bond->curr_active_slave;
4068 read_unlock(&bond->curr_slave_lock);
4069
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004070 if (!start_at)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004071 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004072
4073 bond_for_each_slave_from(bond, slave, i, start_at) {
4074 if (IS_UP(slave->dev) &&
4075 (slave->link == BOND_LINK_UP) &&
Jiri Pirkoe30bc062011-03-12 03:14:37 +00004076 bond_is_active_slave(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004077 if (tx_dev) {
4078 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
4079 if (!skb2) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004080 pr_err("%s: Error: bond_xmit_broadcast(): skb_clone() failed\n",
Mitch Williams4e0952c2005-11-09 10:34:57 -08004081 bond_dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004082 continue;
4083 }
4084
4085 res = bond_dev_queue_xmit(bond, skb2, tx_dev);
4086 if (res) {
Eric Dumazet04502432012-06-13 05:30:07 +00004087 kfree_skb(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004088 continue;
4089 }
4090 }
4091 tx_dev = slave->dev;
4092 }
4093 }
4094
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004095 if (tx_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004096 res = bond_dev_queue_xmit(bond, skb, tx_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004097
4098out:
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004099 if (res)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100 /* no suitable interface, frame not sent */
Eric Dumazet04502432012-06-13 05:30:07 +00004101 kfree_skb(skb);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004102
Linus Torvalds1da177e2005-04-16 15:20:36 -07004103 /* frame sent to all suitable interfaces */
Patrick McHardyec634fe2009-07-05 19:23:38 -07004104 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004105}
4106
4107/*------------------------- Device initialization ---------------------------*/
4108
Jay Vosburgh6f6652b2007-12-06 23:40:34 -08004109static void bond_set_xmit_hash_policy(struct bonding *bond)
4110{
4111 switch (bond->params.xmit_policy) {
4112 case BOND_XMIT_POLICY_LAYER23:
4113 bond->xmit_hash_policy = bond_xmit_hash_policy_l23;
4114 break;
4115 case BOND_XMIT_POLICY_LAYER34:
4116 bond->xmit_hash_policy = bond_xmit_hash_policy_l34;
4117 break;
4118 case BOND_XMIT_POLICY_LAYER2:
4119 default:
4120 bond->xmit_hash_policy = bond_xmit_hash_policy_l2;
4121 break;
4122 }
4123}
4124
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004125/*
4126 * Lookup the slave that corresponds to a qid
4127 */
4128static inline int bond_slave_override(struct bonding *bond,
4129 struct sk_buff *skb)
4130{
4131 int i, res = 1;
4132 struct slave *slave = NULL;
4133 struct slave *check_slave;
4134
Michał Mirosław0693e882011-05-07 01:48:02 +00004135 if (!skb->queue_mapping)
4136 return 1;
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004137
4138 /* Find out if any slaves have the same mapping as this skb. */
4139 bond_for_each_slave(bond, check_slave, i) {
4140 if (check_slave->queue_id == skb->queue_mapping) {
4141 slave = check_slave;
4142 break;
4143 }
4144 }
4145
4146 /* If the slave isn't UP, use default transmit policy. */
4147 if (slave && slave->queue_id && IS_UP(slave->dev) &&
4148 (slave->link == BOND_LINK_UP)) {
4149 res = bond_dev_queue_xmit(bond, skb, slave->dev);
4150 }
4151
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004152 return res;
4153}
4154
Neil Horman374eeb52011-06-03 10:35:52 +00004155
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004156static u16 bond_select_queue(struct net_device *dev, struct sk_buff *skb)
4157{
4158 /*
4159 * This helper function exists to help dev_pick_tx get the correct
Phil Oesterfd0e4352011-03-14 06:22:04 +00004160 * destination queue. Using a helper function skips a call to
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004161 * skb_tx_hash and will put the skbs in the queue we expect on their
4162 * way down to the bonding driver.
4163 */
Phil Oesterfd0e4352011-03-14 06:22:04 +00004164 u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
4165
Neil Horman374eeb52011-06-03 10:35:52 +00004166 /*
4167 * Save the original txq to restore before passing to the driver
4168 */
Jiri Pirkodf4ab5b2012-07-20 02:28:49 +00004169 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
Neil Horman374eeb52011-06-03 10:35:52 +00004170
Phil Oesterfd0e4352011-03-14 06:22:04 +00004171 if (unlikely(txq >= dev->real_num_tx_queues)) {
David Decotignyd30ee672011-04-13 15:22:29 +00004172 do {
Phil Oesterfd0e4352011-03-14 06:22:04 +00004173 txq -= dev->real_num_tx_queues;
David Decotignyd30ee672011-04-13 15:22:29 +00004174 } while (txq >= dev->real_num_tx_queues);
Phil Oesterfd0e4352011-03-14 06:22:04 +00004175 }
4176 return txq;
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004177}
4178
Michał Mirosław0693e882011-05-07 01:48:02 +00004179static netdev_tx_t __bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
Stephen Hemminger00829822008-11-20 20:14:53 -08004180{
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004181 struct bonding *bond = netdev_priv(dev);
4182
4183 if (TX_QUEUE_OVERRIDE(bond->params.mode)) {
4184 if (!bond_slave_override(bond, skb))
4185 return NETDEV_TX_OK;
4186 }
Stephen Hemminger00829822008-11-20 20:14:53 -08004187
4188 switch (bond->params.mode) {
4189 case BOND_MODE_ROUNDROBIN:
4190 return bond_xmit_roundrobin(skb, dev);
4191 case BOND_MODE_ACTIVEBACKUP:
4192 return bond_xmit_activebackup(skb, dev);
4193 case BOND_MODE_XOR:
4194 return bond_xmit_xor(skb, dev);
4195 case BOND_MODE_BROADCAST:
4196 return bond_xmit_broadcast(skb, dev);
4197 case BOND_MODE_8023AD:
4198 return bond_3ad_xmit_xor(skb, dev);
4199 case BOND_MODE_ALB:
4200 case BOND_MODE_TLB:
4201 return bond_alb_xmit(skb, dev);
4202 default:
4203 /* Should never happen, mode already checked */
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004204 pr_err("%s: Error: Unknown bonding mode %d\n",
4205 dev->name, bond->params.mode);
Stephen Hemminger00829822008-11-20 20:14:53 -08004206 WARN_ON_ONCE(1);
Eric Dumazet04502432012-06-13 05:30:07 +00004207 kfree_skb(skb);
Stephen Hemminger00829822008-11-20 20:14:53 -08004208 return NETDEV_TX_OK;
4209 }
4210}
4211
Michał Mirosław0693e882011-05-07 01:48:02 +00004212static netdev_tx_t bond_start_xmit(struct sk_buff *skb, struct net_device *dev)
4213{
4214 struct bonding *bond = netdev_priv(dev);
4215 netdev_tx_t ret = NETDEV_TX_OK;
4216
4217 /*
4218 * If we risk deadlock from transmitting this in the
4219 * netpoll path, tell netpoll to queue the frame for later tx
4220 */
4221 if (is_netpoll_tx_blocked(dev))
4222 return NETDEV_TX_BUSY;
4223
4224 read_lock(&bond->lock);
4225
4226 if (bond->slave_cnt)
4227 ret = __bond_start_xmit(skb, dev);
4228 else
Eric Dumazet04502432012-06-13 05:30:07 +00004229 kfree_skb(skb);
Michał Mirosław0693e882011-05-07 01:48:02 +00004230
4231 read_unlock(&bond->lock);
4232
4233 return ret;
4234}
Stephen Hemminger00829822008-11-20 20:14:53 -08004235
Linus Torvalds1da177e2005-04-16 15:20:36 -07004236/*
4237 * set bond mode specific net device operations
4238 */
Mitch Williamsa77b5322005-11-09 10:35:51 -08004239void bond_set_mode_ops(struct bonding *bond, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004240{
Jay Vosburgh169a3e62005-06-26 17:54:11 -04004241 struct net_device *bond_dev = bond->dev;
4242
Linus Torvalds1da177e2005-04-16 15:20:36 -07004243 switch (mode) {
4244 case BOND_MODE_ROUNDROBIN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004245 break;
4246 case BOND_MODE_ACTIVEBACKUP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004247 break;
4248 case BOND_MODE_XOR:
Jay Vosburgh6f6652b2007-12-06 23:40:34 -08004249 bond_set_xmit_hash_policy(bond);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004250 break;
4251 case BOND_MODE_BROADCAST:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004252 break;
4253 case BOND_MODE_8023AD:
Jay Vosburgh6f6652b2007-12-06 23:40:34 -08004254 bond_set_xmit_hash_policy(bond);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004255 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004256 case BOND_MODE_ALB:
Jay Vosburgh8f903c72006-02-21 16:36:44 -08004257 /* FALLTHRU */
4258 case BOND_MODE_TLB:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004259 break;
4260 default:
4261 /* Should never happen, mode already checked */
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004262 pr_err("%s: Error: Unknown bonding mode %d\n",
4263 bond_dev->name, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004264 break;
4265 }
4266}
4267
Andy Gospodarekbb5b0522013-04-16 14:46:00 +00004268static int bond_ethtool_get_settings(struct net_device *bond_dev,
4269 struct ethtool_cmd *ecmd)
4270{
4271 struct bonding *bond = netdev_priv(bond_dev);
4272 struct slave *slave;
4273 int i;
4274 unsigned long speed = 0;
4275
4276 ecmd->duplex = DUPLEX_UNKNOWN;
4277 ecmd->port = PORT_OTHER;
4278
4279 /* Since SLAVE_IS_OK returns false for all inactive or down slaves, we
4280 * do not need to check mode. Though link speed might not represent
4281 * the true receive or transmit bandwidth (not all modes are symmetric)
4282 * this is an accurate maximum.
4283 */
4284 read_lock(&bond->lock);
4285 bond_for_each_slave(bond, slave, i) {
4286 if (SLAVE_IS_OK(slave)) {
4287 if (slave->speed != SPEED_UNKNOWN)
4288 speed += slave->speed;
4289 if (ecmd->duplex == DUPLEX_UNKNOWN &&
4290 slave->duplex != DUPLEX_UNKNOWN)
4291 ecmd->duplex = slave->duplex;
4292 }
4293 }
4294 ethtool_cmd_speed_set(ecmd, speed ? : SPEED_UNKNOWN);
4295 read_unlock(&bond->lock);
4296 return 0;
4297}
4298
Jay Vosburgh217df672005-09-26 16:11:50 -07004299static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
Jiri Pirko7826d432013-01-06 00:44:26 +00004300 struct ethtool_drvinfo *drvinfo)
Jay Vosburgh217df672005-09-26 16:11:50 -07004301{
Jiri Pirko7826d432013-01-06 00:44:26 +00004302 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
4303 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
4304 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "%d",
4305 BOND_ABI_VERSION);
Jay Vosburgh217df672005-09-26 16:11:50 -07004306}
4307
Jeff Garzik7282d492006-09-13 14:30:00 -04004308static const struct ethtool_ops bond_ethtool_ops = {
Jay Vosburgh217df672005-09-26 16:11:50 -07004309 .get_drvinfo = bond_ethtool_get_drvinfo,
Andy Gospodarekbb5b0522013-04-16 14:46:00 +00004310 .get_settings = bond_ethtool_get_settings,
Stephen Hemmingerfa53eba2008-09-13 21:17:09 -04004311 .get_link = ethtool_op_get_link,
Arthur Kepner8531c5f2005-08-23 01:34:53 -04004312};
4313
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08004314static const struct net_device_ops bond_netdev_ops = {
Stephen Hemminger181470f2009-06-12 19:02:52 +00004315 .ndo_init = bond_init,
Stephen Hemminger9e716262009-06-12 19:02:47 +00004316 .ndo_uninit = bond_uninit,
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08004317 .ndo_open = bond_open,
4318 .ndo_stop = bond_close,
Stephen Hemminger00829822008-11-20 20:14:53 -08004319 .ndo_start_xmit = bond_start_xmit,
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004320 .ndo_select_queue = bond_select_queue,
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +00004321 .ndo_get_stats64 = bond_get_stats,
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08004322 .ndo_do_ioctl = bond_do_ioctl,
Jiri Pirkod03462b2011-08-16 03:15:04 +00004323 .ndo_change_rx_flags = bond_change_rx_flags,
Jiri Pirkoafc4b132011-08-16 06:29:01 +00004324 .ndo_set_rx_mode = bond_set_multicast_list,
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08004325 .ndo_change_mtu = bond_change_mtu,
Jiri Pirkocc0e4072011-07-20 04:54:46 +00004326 .ndo_set_mac_address = bond_set_mac_address,
Stephen Hemminger00829822008-11-20 20:14:53 -08004327 .ndo_neigh_setup = bond_neigh_setup,
Jiri Pirkocc0e4072011-07-20 04:54:46 +00004328 .ndo_vlan_rx_add_vid = bond_vlan_rx_add_vid,
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08004329 .ndo_vlan_rx_kill_vid = bond_vlan_rx_kill_vid,
WANG Congf6dc31a2010-05-06 00:48:51 -07004330#ifdef CONFIG_NET_POLL_CONTROLLER
Amerigo Wang8a8efa22011-02-17 23:43:32 +00004331 .ndo_netpoll_setup = bond_netpoll_setup,
WANG Congf6dc31a2010-05-06 00:48:51 -07004332 .ndo_netpoll_cleanup = bond_netpoll_cleanup,
4333 .ndo_poll_controller = bond_poll_controller,
4334#endif
Jiri Pirko9232ecc2011-02-13 09:33:01 +00004335 .ndo_add_slave = bond_enslave,
4336 .ndo_del_slave = bond_release,
Michał Mirosławb2a103e2011-05-07 03:22:17 +00004337 .ndo_fix_features = bond_fix_features,
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08004338};
4339
Doug Goldsteinb3f92b62013-02-18 14:59:23 +00004340static const struct device_type bond_type = {
4341 .name = "bond",
4342};
4343
Amerigo Wang9e2e61f2010-03-31 21:30:52 +00004344static void bond_destructor(struct net_device *bond_dev)
4345{
4346 struct bonding *bond = netdev_priv(bond_dev);
4347 if (bond->wq)
4348 destroy_workqueue(bond->wq);
4349 free_netdev(bond_dev);
4350}
4351
Stephen Hemminger181470f2009-06-12 19:02:52 +00004352static void bond_setup(struct net_device *bond_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004353{
Wang Chen454d7c92008-11-12 23:37:49 -08004354 struct bonding *bond = netdev_priv(bond_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004355
Linus Torvalds1da177e2005-04-16 15:20:36 -07004356 /* initialize rwlocks */
4357 rwlock_init(&bond->lock);
4358 rwlock_init(&bond->curr_slave_lock);
4359
Stephen Hemmingerd2991f72009-06-12 19:02:44 +00004360 bond->params = bonding_defaults;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004361
4362 /* Initialize pointers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004363 bond->dev = bond_dev;
4364 INIT_LIST_HEAD(&bond->vlan_list);
4365
4366 /* Initialize the device entry points */
Stephen Hemminger181470f2009-06-12 19:02:52 +00004367 ether_setup(bond_dev);
Stephen Hemmingereb7cc592008-11-19 21:56:05 -08004368 bond_dev->netdev_ops = &bond_netdev_ops;
Arthur Kepner8531c5f2005-08-23 01:34:53 -04004369 bond_dev->ethtool_ops = &bond_ethtool_ops;
Jay Vosburgh169a3e62005-06-26 17:54:11 -04004370 bond_set_mode_ops(bond, bond->params.mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004371
Amerigo Wang9e2e61f2010-03-31 21:30:52 +00004372 bond_dev->destructor = bond_destructor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004373
Doug Goldsteinb3f92b62013-02-18 14:59:23 +00004374 SET_NETDEV_DEVTYPE(bond_dev, &bond_type);
4375
Linus Torvalds1da177e2005-04-16 15:20:36 -07004376 /* Initialize the device options */
4377 bond_dev->tx_queue_len = 0;
4378 bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
Jay Vosburgh0b680e72006-09-22 21:54:10 -07004379 bond_dev->priv_flags |= IFF_BONDING;
Neil Horman550fd082011-07-26 06:05:38 +00004380 bond_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
Stephen Hemminger181470f2009-06-12 19:02:52 +00004381
Linus Torvalds1da177e2005-04-16 15:20:36 -07004382 /* At first, we block adding VLANs. That's the only way to
4383 * prevent problems that occur when adding VLANs over an
4384 * empty bond. The block will be removed once non-challenged
4385 * slaves are enslaved.
4386 */
4387 bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
4388
Herbert Xu932ff272006-06-09 12:20:56 -07004389 /* don't acquire bond device's netif_tx_lock when
Linus Torvalds1da177e2005-04-16 15:20:36 -07004390 * transmitting */
4391 bond_dev->features |= NETIF_F_LLTX;
4392
4393 /* By default, we declare the bond to be fully
4394 * VLAN hardware accelerated capable. Special
4395 * care is taken in the various xmit functions
4396 * when there are slaves that are not hw accel
4397 * capable
4398 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004399
Michał Mirosławb2a103e2011-05-07 03:22:17 +00004400 bond_dev->hw_features = BOND_VLAN_FEATURES |
Patrick McHardyf6469682013-04-19 02:04:27 +00004401 NETIF_F_HW_VLAN_CTAG_TX |
4402 NETIF_F_HW_VLAN_CTAG_RX |
4403 NETIF_F_HW_VLAN_CTAG_FILTER;
Michał Mirosławb2a103e2011-05-07 03:22:17 +00004404
Michał Mirosław34324dc2011-11-15 15:29:55 +00004405 bond_dev->hw_features &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_HW_CSUM);
Michał Mirosławb2a103e2011-05-07 03:22:17 +00004406 bond_dev->features |= bond_dev->hw_features;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004407}
4408
Eric W. Biedermanc67dfb22009-10-29 14:18:24 +00004409/*
4410* Destroy a bonding device.
4411* Must be under rtnl_lock when this function is called.
4412*/
4413static void bond_uninit(struct net_device *bond_dev)
Jay Vosburgha434e432008-10-30 17:41:15 -07004414{
Wang Chen454d7c92008-11-12 23:37:49 -08004415 struct bonding *bond = netdev_priv(bond_dev);
Jay Vosburghf35188f2010-07-21 12:14:47 +00004416 struct vlan_entry *vlan, *tmp;
Jay Vosburgha434e432008-10-30 17:41:15 -07004417
WANG Congf6dc31a2010-05-06 00:48:51 -07004418 bond_netpoll_cleanup(bond_dev);
4419
Eric W. Biedermanc67dfb22009-10-29 14:18:24 +00004420 /* Release the bonded slaves */
nikolay@redhat.com08963412013-02-18 14:09:42 +00004421 while (bond->first_slave != NULL)
4422 __bond_release_one(bond_dev, bond->first_slave->dev, true);
4423 pr_info("%s: released all slaves\n", bond_dev->name);
Eric W. Biedermanc67dfb22009-10-29 14:18:24 +00004424
Jay Vosburgha434e432008-10-30 17:41:15 -07004425 list_del(&bond->bond_list);
4426
Taku Izumif073c7c2010-12-09 15:17:13 +00004427 bond_debug_unregister(bond);
4428
Jiri Pirko22bedad32010-04-01 21:22:57 +00004429 __hw_addr_flush(&bond->mc_list);
Jay Vosburghf35188f2010-07-21 12:14:47 +00004430
4431 list_for_each_entry_safe(vlan, tmp, &bond->vlan_list, vlan_list) {
4432 list_del(&vlan->vlan_list);
4433 kfree(vlan);
4434 }
Jay Vosburgha434e432008-10-30 17:41:15 -07004435}
4436
Linus Torvalds1da177e2005-04-16 15:20:36 -07004437/*------------------------- Module initialization ---------------------------*/
4438
4439/*
4440 * Convert string input module parms. Accept either the
Jay Vosburghece95f72008-01-17 16:25:01 -08004441 * number of the mode or its string name. A bit complicated because
4442 * some mode names are substrings of other names, and calls from sysfs
4443 * may have whitespace in the name (trailing newlines, for example).
Linus Torvalds1da177e2005-04-16 15:20:36 -07004444 */
Holger Eitzenberger325dcf72008-12-09 23:10:17 -08004445int bond_parse_parm(const char *buf, const struct bond_parm_tbl *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004446{
Hannes Eder54b87322009-02-14 11:15:49 +00004447 int modeint = -1, i, rv;
Jay Vosburgha42e5342008-01-29 18:07:43 -08004448 char *p, modestr[BOND_MAX_MODENAME_LEN + 1] = { 0, };
Jay Vosburghece95f72008-01-17 16:25:01 -08004449
Jay Vosburgha42e5342008-01-29 18:07:43 -08004450 for (p = (char *)buf; *p; p++)
4451 if (!(isdigit(*p) || isspace(*p)))
4452 break;
4453
4454 if (*p)
Jay Vosburghece95f72008-01-17 16:25:01 -08004455 rv = sscanf(buf, "%20s", modestr);
Jay Vosburgha42e5342008-01-29 18:07:43 -08004456 else
Hannes Eder54b87322009-02-14 11:15:49 +00004457 rv = sscanf(buf, "%d", &modeint);
Jay Vosburgha42e5342008-01-29 18:07:43 -08004458
4459 if (!rv)
4460 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004461
4462 for (i = 0; tbl[i].modename; i++) {
Hannes Eder54b87322009-02-14 11:15:49 +00004463 if (modeint == tbl[i].mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004464 return tbl[i].mode;
Jay Vosburghece95f72008-01-17 16:25:01 -08004465 if (strcmp(modestr, tbl[i].modename) == 0)
4466 return tbl[i].mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004467 }
4468
4469 return -1;
4470}
4471
4472static int bond_check_params(struct bond_params *params)
4473{
nikolay@redhat.com5a5c5fd2013-05-18 01:18:30 +00004474 int arp_validate_value, fail_over_mac_value, primary_reselect_value, i;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07004475
Linus Torvalds1da177e2005-04-16 15:20:36 -07004476 /*
4477 * Convert string parameters.
4478 */
4479 if (mode) {
4480 bond_mode = bond_parse_parm(mode, bond_mode_tbl);
4481 if (bond_mode == -1) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004482 pr_err("Error: Invalid bonding mode \"%s\"\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004483 mode == NULL ? "NULL" : mode);
4484 return -EINVAL;
4485 }
4486 }
4487
Jay Vosburgh169a3e62005-06-26 17:54:11 -04004488 if (xmit_hash_policy) {
4489 if ((bond_mode != BOND_MODE_XOR) &&
4490 (bond_mode != BOND_MODE_8023AD)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004491 pr_info("xmit_hash_policy param is irrelevant in mode %s\n",
Jay Vosburgh169a3e62005-06-26 17:54:11 -04004492 bond_mode_name(bond_mode));
4493 } else {
4494 xmit_hashtype = bond_parse_parm(xmit_hash_policy,
4495 xmit_hashtype_tbl);
4496 if (xmit_hashtype == -1) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004497 pr_err("Error: Invalid xmit_hash_policy \"%s\"\n",
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004498 xmit_hash_policy == NULL ? "NULL" :
Jay Vosburgh169a3e62005-06-26 17:54:11 -04004499 xmit_hash_policy);
4500 return -EINVAL;
4501 }
4502 }
4503 }
4504
Linus Torvalds1da177e2005-04-16 15:20:36 -07004505 if (lacp_rate) {
4506 if (bond_mode != BOND_MODE_8023AD) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004507 pr_info("lacp_rate param is irrelevant in mode %s\n",
4508 bond_mode_name(bond_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004509 } else {
4510 lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl);
4511 if (lacp_fast == -1) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004512 pr_err("Error: Invalid lacp rate \"%s\"\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004513 lacp_rate == NULL ? "NULL" : lacp_rate);
4514 return -EINVAL;
4515 }
4516 }
4517 }
4518
Jay Vosburghfd989c82008-11-04 17:51:16 -08004519 if (ad_select) {
4520 params->ad_select = bond_parse_parm(ad_select, ad_select_tbl);
4521 if (params->ad_select == -1) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004522 pr_err("Error: Invalid ad_select \"%s\"\n",
Jay Vosburghfd989c82008-11-04 17:51:16 -08004523 ad_select == NULL ? "NULL" : ad_select);
4524 return -EINVAL;
4525 }
4526
4527 if (bond_mode != BOND_MODE_8023AD) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004528 pr_warning("ad_select param only affects 802.3ad mode\n");
Jay Vosburghfd989c82008-11-04 17:51:16 -08004529 }
4530 } else {
4531 params->ad_select = BOND_AD_STABLE;
4532 }
4533
Nicolas de Pesloüanf5841302009-08-28 13:18:34 +00004534 if (max_bonds < 0) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004535 pr_warning("Warning: max_bonds (%d) not in range %d-%d, so it was reset to BOND_DEFAULT_MAX_BONDS (%d)\n",
4536 max_bonds, 0, INT_MAX, BOND_DEFAULT_MAX_BONDS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004537 max_bonds = BOND_DEFAULT_MAX_BONDS;
4538 }
4539
4540 if (miimon < 0) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004541 pr_warning("Warning: miimon module parameter (%d), not in range 0-%d, so it was reset to %d\n",
4542 miimon, INT_MAX, BOND_LINK_MON_INTERV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004543 miimon = BOND_LINK_MON_INTERV;
4544 }
4545
4546 if (updelay < 0) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004547 pr_warning("Warning: updelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
4548 updelay, INT_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004549 updelay = 0;
4550 }
4551
4552 if (downdelay < 0) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004553 pr_warning("Warning: downdelay module parameter (%d), not in range 0-%d, so it was reset to 0\n",
4554 downdelay, INT_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004555 downdelay = 0;
4556 }
4557
4558 if ((use_carrier != 0) && (use_carrier != 1)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004559 pr_warning("Warning: use_carrier module parameter (%d), not of valid value (0/1), so it was set to 1\n",
4560 use_carrier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004561 use_carrier = 1;
4562 }
4563
Ben Hutchingsad246c92011-04-26 15:25:52 +00004564 if (num_peer_notif < 0 || num_peer_notif > 255) {
4565 pr_warning("Warning: num_grat_arp/num_unsol_na (%d) not in range 0-255 so it was reset to 1\n",
4566 num_peer_notif);
4567 num_peer_notif = 1;
4568 }
4569
Linus Torvalds1da177e2005-04-16 15:20:36 -07004570 /* reset values for 802.3ad */
4571 if (bond_mode == BOND_MODE_8023AD) {
4572 if (!miimon) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004573 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");
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004574 pr_warning("Forcing miimon to 100msec\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004575 miimon = 100;
4576 }
4577 }
4578
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004579 if (tx_queues < 1 || tx_queues > 255) {
4580 pr_warning("Warning: tx_queues (%d) should be between "
4581 "1 and 255, resetting to %d\n",
4582 tx_queues, BOND_DEFAULT_TX_QUEUES);
4583 tx_queues = BOND_DEFAULT_TX_QUEUES;
4584 }
4585
Andy Gospodarekebd8e492010-06-02 08:39:21 +00004586 if ((all_slaves_active != 0) && (all_slaves_active != 1)) {
4587 pr_warning("Warning: all_slaves_active module parameter (%d), "
4588 "not of valid value (0/1), so it was set to "
4589 "0\n", all_slaves_active);
4590 all_slaves_active = 0;
4591 }
4592
Flavio Leitnerc2952c32010-10-05 14:23:59 +00004593 if (resend_igmp < 0 || resend_igmp > 255) {
4594 pr_warning("Warning: resend_igmp (%d) should be between "
4595 "0 and 255, resetting to %d\n",
4596 resend_igmp, BOND_DEFAULT_RESEND_IGMP);
4597 resend_igmp = BOND_DEFAULT_RESEND_IGMP;
4598 }
4599
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600 /* reset values for TLB/ALB */
4601 if ((bond_mode == BOND_MODE_TLB) ||
4602 (bond_mode == BOND_MODE_ALB)) {
4603 if (!miimon) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004604 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");
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004605 pr_warning("Forcing miimon to 100msec\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004606 miimon = 100;
4607 }
4608 }
4609
4610 if (bond_mode == BOND_MODE_ALB) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004611 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",
4612 updelay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004613 }
4614
4615 if (!miimon) {
4616 if (updelay || downdelay) {
4617 /* just warn the user the up/down delay will have
4618 * no effect since miimon is zero...
4619 */
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004620 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",
4621 updelay, downdelay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004622 }
4623 } else {
4624 /* don't allow arp monitoring */
4625 if (arp_interval) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004626 pr_warning("Warning: miimon (%d) and arp_interval (%d) can't be used simultaneously, disabling ARP monitoring\n",
4627 miimon, arp_interval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004628 arp_interval = 0;
4629 }
4630
4631 if ((updelay % miimon) != 0) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004632 pr_warning("Warning: updelay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n",
4633 updelay, miimon,
4634 (updelay / miimon) * miimon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004635 }
4636
4637 updelay /= miimon;
4638
4639 if ((downdelay % miimon) != 0) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004640 pr_warning("Warning: downdelay (%d) is not a multiple of miimon (%d), downdelay rounded to %d ms\n",
4641 downdelay, miimon,
4642 (downdelay / miimon) * miimon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004643 }
4644
4645 downdelay /= miimon;
4646 }
4647
4648 if (arp_interval < 0) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004649 pr_warning("Warning: arp_interval module parameter (%d) , not in range 0-%d, so it was reset to %d\n",
4650 arp_interval, INT_MAX, BOND_LINK_ARP_INTERV);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004651 arp_interval = BOND_LINK_ARP_INTERV;
4652 }
4653
nikolay@redhat.com5a5c5fd2013-05-18 01:18:30 +00004654 for (arp_ip_count = 0, i = 0;
4655 (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[i]; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004656 /* not complete check, but should be good enough to
4657 catch mistakes */
nikolay@redhat.com5a5c5fd2013-05-18 01:18:30 +00004658 __be32 ip = in_aton(arp_ip_target[i]);
4659 if (!isdigit(arp_ip_target[i][0]) || ip == 0 ||
4660 ip == htonl(INADDR_BROADCAST)) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004661 pr_warning("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n",
nikolay@redhat.com5a5c5fd2013-05-18 01:18:30 +00004662 arp_ip_target[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004663 arp_interval = 0;
4664 } else {
nikolay@redhat.com5a5c5fd2013-05-18 01:18:30 +00004665 arp_target[arp_ip_count++] = ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004666 }
4667 }
4668
4669 if (arp_interval && !arp_ip_count) {
4670 /* don't allow arping if no arp_ip_target given... */
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004671 pr_warning("Warning: arp_interval module parameter (%d) specified without providing an arp_ip_target parameter, arp_interval was reset to 0\n",
4672 arp_interval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673 arp_interval = 0;
4674 }
4675
Jay Vosburghf5b2b962006-09-22 21:54:53 -07004676 if (arp_validate) {
4677 if (bond_mode != BOND_MODE_ACTIVEBACKUP) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004678 pr_err("arp_validate only supported in active-backup mode\n");
Jay Vosburghf5b2b962006-09-22 21:54:53 -07004679 return -EINVAL;
4680 }
4681 if (!arp_interval) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004682 pr_err("arp_validate requires arp_interval\n");
Jay Vosburghf5b2b962006-09-22 21:54:53 -07004683 return -EINVAL;
4684 }
4685
4686 arp_validate_value = bond_parse_parm(arp_validate,
4687 arp_validate_tbl);
4688 if (arp_validate_value == -1) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004689 pr_err("Error: invalid arp_validate \"%s\"\n",
Jay Vosburghf5b2b962006-09-22 21:54:53 -07004690 arp_validate == NULL ? "NULL" : arp_validate);
4691 return -EINVAL;
4692 }
4693 } else
4694 arp_validate_value = 0;
4695
Linus Torvalds1da177e2005-04-16 15:20:36 -07004696 if (miimon) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004697 pr_info("MII link monitoring set to %d ms\n", miimon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004698 } else if (arp_interval) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004699 pr_info("ARP monitoring set to %d ms, validate %s, with %d target(s):",
4700 arp_interval,
4701 arp_validate_tbl[arp_validate_value].modename,
4702 arp_ip_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004703
4704 for (i = 0; i < arp_ip_count; i++)
Jiri Pirkoe5e2a8f2009-08-13 04:11:52 +00004705 pr_info(" %s", arp_ip_target[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004706
Jiri Pirkoe5e2a8f2009-08-13 04:11:52 +00004707 pr_info("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004708
Jay Vosburghb8a97872008-06-13 18:12:04 -07004709 } else if (max_bonds) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004710 /* miimon and arp_interval not set, we need one so things
4711 * work as expected, see bonding.txt for details
4712 */
Andy Gospodarekb2730f42011-07-27 10:09:26 +00004713 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004714 }
4715
4716 if (primary && !USES_PRIMARY(bond_mode)) {
4717 /* currently, using a primary only makes sense
4718 * in active backup, TLB or ALB modes
4719 */
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004720 pr_warning("Warning: %s primary device specified but has no effect in %s mode\n",
4721 primary, bond_mode_name(bond_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004722 primary = NULL;
4723 }
4724
Jiri Pirkoa5499522009-09-25 03:28:09 +00004725 if (primary && primary_reselect) {
4726 primary_reselect_value = bond_parse_parm(primary_reselect,
4727 pri_reselect_tbl);
4728 if (primary_reselect_value == -1) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004729 pr_err("Error: Invalid primary_reselect \"%s\"\n",
Jiri Pirkoa5499522009-09-25 03:28:09 +00004730 primary_reselect ==
4731 NULL ? "NULL" : primary_reselect);
4732 return -EINVAL;
4733 }
4734 } else {
4735 primary_reselect_value = BOND_PRI_RESELECT_ALWAYS;
4736 }
4737
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07004738 if (fail_over_mac) {
4739 fail_over_mac_value = bond_parse_parm(fail_over_mac,
4740 fail_over_mac_tbl);
4741 if (fail_over_mac_value == -1) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004742 pr_err("Error: invalid fail_over_mac \"%s\"\n",
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07004743 arp_validate == NULL ? "NULL" : arp_validate);
4744 return -EINVAL;
4745 }
4746
4747 if (bond_mode != BOND_MODE_ACTIVEBACKUP)
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004748 pr_warning("Warning: fail_over_mac only affects active-backup mode.\n");
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07004749 } else {
4750 fail_over_mac_value = BOND_FOM_NONE;
4751 }
Jay Vosburghdd957c52007-10-09 19:57:24 -07004752
Linus Torvalds1da177e2005-04-16 15:20:36 -07004753 /* fill params struct with the proper values */
4754 params->mode = bond_mode;
Jay Vosburgh169a3e62005-06-26 17:54:11 -04004755 params->xmit_policy = xmit_hashtype;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004756 params->miimon = miimon;
Ben Hutchingsad246c92011-04-26 15:25:52 +00004757 params->num_peer_notif = num_peer_notif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004758 params->arp_interval = arp_interval;
Jay Vosburghf5b2b962006-09-22 21:54:53 -07004759 params->arp_validate = arp_validate_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004760 params->updelay = updelay;
4761 params->downdelay = downdelay;
4762 params->use_carrier = use_carrier;
4763 params->lacp_fast = lacp_fast;
4764 params->primary[0] = 0;
Jiri Pirkoa5499522009-09-25 03:28:09 +00004765 params->primary_reselect = primary_reselect_value;
Jay Vosburgh3915c1e82008-05-17 21:10:14 -07004766 params->fail_over_mac = fail_over_mac_value;
Andy Gospodarekbb1d9122010-06-02 08:40:18 +00004767 params->tx_queues = tx_queues;
Andy Gospodarekebd8e492010-06-02 08:39:21 +00004768 params->all_slaves_active = all_slaves_active;
Flavio Leitnerc2952c32010-10-05 14:23:59 +00004769 params->resend_igmp = resend_igmp;
stephen hemminger655f8912011-06-22 09:54:39 +00004770 params->min_links = min_links;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004771
4772 if (primary) {
4773 strncpy(params->primary, primary, IFNAMSIZ);
4774 params->primary[IFNAMSIZ - 1] = 0;
4775 }
4776
4777 memcpy(params->arp_targets, arp_target, sizeof(arp_target));
4778
4779 return 0;
4780}
4781
Peter Zijlstra0daa23032006-11-08 19:51:01 -08004782static struct lock_class_key bonding_netdev_xmit_lock_key;
David S. Millercf508b12008-07-22 14:16:42 -07004783static struct lock_class_key bonding_netdev_addr_lock_key;
Eric Dumazet49ee4922012-10-03 23:05:26 +00004784static struct lock_class_key bonding_tx_busylock_key;
Peter Zijlstra0daa23032006-11-08 19:51:01 -08004785
David S. Millere8a04642008-07-17 00:34:19 -07004786static void bond_set_lockdep_class_one(struct net_device *dev,
4787 struct netdev_queue *txq,
4788 void *_unused)
David S. Millerc773e842008-07-08 23:13:53 -07004789{
4790 lockdep_set_class(&txq->_xmit_lock,
4791 &bonding_netdev_xmit_lock_key);
4792}
4793
4794static void bond_set_lockdep_class(struct net_device *dev)
4795{
David S. Millercf508b12008-07-22 14:16:42 -07004796 lockdep_set_class(&dev->addr_list_lock,
4797 &bonding_netdev_addr_lock_key);
David S. Millere8a04642008-07-17 00:34:19 -07004798 netdev_for_each_tx_queue(dev, bond_set_lockdep_class_one, NULL);
Eric Dumazet49ee4922012-10-03 23:05:26 +00004799 dev->qdisc_tx_busylock = &bonding_tx_busylock_key;
David S. Millerc773e842008-07-08 23:13:53 -07004800}
4801
Stephen Hemminger181470f2009-06-12 19:02:52 +00004802/*
4803 * Called from registration process
4804 */
4805static int bond_init(struct net_device *bond_dev)
4806{
4807 struct bonding *bond = netdev_priv(bond_dev);
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004808 struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
Neil Horman9fe06172011-05-25 08:13:01 +00004809 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
Stephen Hemminger181470f2009-06-12 19:02:52 +00004810
4811 pr_debug("Begin bond_init for %s\n", bond_dev->name);
4812
Neil Horman9fe06172011-05-25 08:13:01 +00004813 /*
4814 * Initialize locks that may be required during
4815 * en/deslave operations. All of the bond_open work
4816 * (of which this is part) should really be moved to
4817 * a phase prior to dev_open
4818 */
4819 spin_lock_init(&(bond_info->tx_hashtbl_lock));
4820 spin_lock_init(&(bond_info->rx_hashtbl_lock));
4821
Stephen Hemminger181470f2009-06-12 19:02:52 +00004822 bond->wq = create_singlethread_workqueue(bond_dev->name);
4823 if (!bond->wq)
4824 return -ENOMEM;
4825
4826 bond_set_lockdep_class(bond_dev);
4827
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004828 list_add_tail(&bond->bond_list, &bn->dev_list);
Stephen Hemminger181470f2009-06-12 19:02:52 +00004829
Eric W. Biederman6151b3d2009-10-29 14:18:22 +00004830 bond_prepare_sysfs_group(bond);
Jiri Pirko22bedad32010-04-01 21:22:57 +00004831
Taku Izumif073c7c2010-12-09 15:17:13 +00004832 bond_debug_register(bond);
4833
Jiri Pirko409cc1f2013-01-30 11:08:11 +01004834 /* Ensure valid dev_addr */
4835 if (is_zero_ether_addr(bond_dev->dev_addr) &&
4836 bond_dev->addr_assign_type == NET_ADDR_PERM) {
4837 eth_hw_addr_random(bond_dev);
4838 bond->dev_addr_from_first = true;
4839 }
4840
Jiri Pirko22bedad32010-04-01 21:22:57 +00004841 __hw_addr_init(&bond->mc_list);
Stephen Hemminger181470f2009-06-12 19:02:52 +00004842 return 0;
4843}
4844
Eric W. Biederman88ead972009-10-29 14:18:25 +00004845static int bond_validate(struct nlattr *tb[], struct nlattr *data[])
4846{
4847 if (tb[IFLA_ADDRESS]) {
4848 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
4849 return -EINVAL;
4850 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
4851 return -EADDRNOTAVAIL;
4852 }
4853 return 0;
4854}
4855
Jiri Pirkod40156a2012-07-20 02:28:47 +00004856static unsigned int bond_get_num_tx_queues(void)
Jiri Pirkod5da4512011-08-10 06:09:44 +00004857{
stephen hemmingerefacb302012-04-10 18:34:43 +00004858 return tx_queues;
Jiri Pirkod5da4512011-08-10 06:09:44 +00004859}
4860
Eric W. Biederman88ead972009-10-29 14:18:25 +00004861static struct rtnl_link_ops bond_link_ops __read_mostly = {
Jiri Pirkod40156a2012-07-20 02:28:47 +00004862 .kind = "bond",
4863 .priv_size = sizeof(struct bonding),
4864 .setup = bond_setup,
4865 .validate = bond_validate,
4866 .get_num_tx_queues = bond_get_num_tx_queues,
4867 .get_num_rx_queues = bond_get_num_tx_queues, /* Use the same number
4868 as for TX queues */
Eric W. Biederman88ead972009-10-29 14:18:25 +00004869};
4870
Mitch Williamsdfe60392005-11-09 10:36:04 -08004871/* Create a new bond based on the specified name and bonding parameters.
Jay Vosburghe4b91c42007-01-19 18:15:31 -08004872 * If name is NULL, obtain a suitable "bond%d" name for us.
Mitch Williamsdfe60392005-11-09 10:36:04 -08004873 * Caller must NOT hold rtnl_lock; we need to release it here before we
4874 * set up our sysfs entries.
4875 */
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004876int bond_create(struct net *net, const char *name)
Mitch Williamsdfe60392005-11-09 10:36:04 -08004877{
4878 struct net_device *bond_dev;
4879 int res;
4880
4881 rtnl_lock();
Jay Vosburgh027ea042008-01-17 16:25:02 -08004882
Jiri Pirko1c5cae82011-04-30 01:21:32 +00004883 bond_dev = alloc_netdev_mq(sizeof(struct bonding),
4884 name ? name : "bond%d",
4885 bond_setup, tx_queues);
Mitch Williamsdfe60392005-11-09 10:36:04 -08004886 if (!bond_dev) {
Joe Perchesa4aee5c2009-12-13 20:06:07 -08004887 pr_err("%s: eek! can't alloc netdev!\n", name);
Amerigo Wang9e2e61f2010-03-31 21:30:52 +00004888 rtnl_unlock();
4889 return -ENOMEM;
Mitch Williamsdfe60392005-11-09 10:36:04 -08004890 }
4891
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004892 dev_net_set(bond_dev, net);
Eric W. Biederman88ead972009-10-29 14:18:25 +00004893 bond_dev->rtnl_link_ops = &bond_link_ops;
4894
Mitch Williamsdfe60392005-11-09 10:36:04 -08004895 res = register_netdevice(bond_dev);
Peter Zijlstra0daa23032006-11-08 19:51:01 -08004896
Phil Oestere826eaf2011-03-14 06:22:05 +00004897 netif_carrier_off(bond_dev);
4898
Mitch Williamsdfe60392005-11-09 10:36:04 -08004899 rtnl_unlock();
Amerigo Wang9e2e61f2010-03-31 21:30:52 +00004900 if (res < 0)
4901 bond_destructor(bond_dev);
Mitch Williamsdfe60392005-11-09 10:36:04 -08004902 return res;
4903}
4904
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00004905static int __net_init bond_net_init(struct net *net)
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004906{
Eric W. Biederman15449742009-11-29 15:46:04 +00004907 struct bond_net *bn = net_generic(net, bond_net_id);
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004908
4909 bn->net = net;
4910 INIT_LIST_HEAD(&bn->dev_list);
4911
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004912 bond_create_proc_dir(bn);
Eric W. Biederman4c224002011-10-12 21:56:25 +00004913 bond_create_sysfs(bn);
Eric W. Biederman15449742009-11-29 15:46:04 +00004914
4915 return 0;
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004916}
4917
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00004918static void __net_exit bond_net_exit(struct net *net)
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004919{
Eric W. Biederman15449742009-11-29 15:46:04 +00004920 struct bond_net *bn = net_generic(net, bond_net_id);
nikolay@redhat.com69b02162013-04-06 00:54:38 +00004921 struct bonding *bond, *tmp_bond;
4922 LIST_HEAD(list);
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004923
Eric W. Biederman4c224002011-10-12 21:56:25 +00004924 bond_destroy_sysfs(bn);
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004925 bond_destroy_proc_dir(bn);
nikolay@redhat.com69b02162013-04-06 00:54:38 +00004926
4927 /* Kill off any bonds created after unregistering bond rtnl ops */
4928 rtnl_lock();
4929 list_for_each_entry_safe(bond, tmp_bond, &bn->dev_list, bond_list)
4930 unregister_netdevice_queue(bond->dev, &list);
4931 unregister_netdevice_many(&list);
4932 rtnl_unlock();
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004933}
4934
4935static struct pernet_operations bond_net_ops = {
4936 .init = bond_net_init,
4937 .exit = bond_net_exit,
Eric W. Biederman15449742009-11-29 15:46:04 +00004938 .id = &bond_net_id,
4939 .size = sizeof(struct bond_net),
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004940};
4941
Linus Torvalds1da177e2005-04-16 15:20:36 -07004942static int __init bonding_init(void)
4943{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004944 int i;
4945 int res;
4946
Amerigo Wangbd33acc2011-03-06 21:58:46 +00004947 pr_info("%s", bond_version);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004948
Mitch Williamsdfe60392005-11-09 10:36:04 -08004949 res = bond_check_params(&bonding_defaults);
Stephen Hemminger3d632c32009-06-12 19:02:48 +00004950 if (res)
Mitch Williamsdfe60392005-11-09 10:36:04 -08004951 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004952
Eric W. Biederman15449742009-11-29 15:46:04 +00004953 res = register_pernet_subsys(&bond_net_ops);
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004954 if (res)
4955 goto out;
Jay Vosburgh027ea042008-01-17 16:25:02 -08004956
Eric W. Biederman88ead972009-10-29 14:18:25 +00004957 res = rtnl_link_register(&bond_link_ops);
4958 if (res)
Eric W. Biederman66391042009-10-29 23:58:54 +00004959 goto err_link;
Eric W. Biederman88ead972009-10-29 14:18:25 +00004960
Taku Izumif073c7c2010-12-09 15:17:13 +00004961 bond_create_debugfs();
4962
Linus Torvalds1da177e2005-04-16 15:20:36 -07004963 for (i = 0; i < max_bonds; i++) {
Eric W. Biedermanec87fd32009-10-29 14:18:26 +00004964 res = bond_create(&init_net, NULL);
Mitch Williamsdfe60392005-11-09 10:36:04 -08004965 if (res)
4966 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004967 }
4968
Linus Torvalds1da177e2005-04-16 15:20:36 -07004969 register_netdevice_notifier(&bond_netdev_notifier);
Mitch Williamsdfe60392005-11-09 10:36:04 -08004970out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004971 return res;
Eric W. Biederman88ead972009-10-29 14:18:25 +00004972err:
4973 rtnl_link_unregister(&bond_link_ops);
Eric W. Biederman66391042009-10-29 23:58:54 +00004974err_link:
Eric W. Biederman15449742009-11-29 15:46:04 +00004975 unregister_pernet_subsys(&bond_net_ops);
Eric W. Biederman88ead972009-10-29 14:18:25 +00004976 goto out;
Mitch Williamsdfe60392005-11-09 10:36:04 -08004977
Linus Torvalds1da177e2005-04-16 15:20:36 -07004978}
4979
4980static void __exit bonding_exit(void)
4981{
4982 unregister_netdevice_notifier(&bond_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004983
Taku Izumif073c7c2010-12-09 15:17:13 +00004984 bond_destroy_debugfs();
Pavel Emelyanovae68c392008-05-02 17:49:39 -07004985
Veaceslav Falico4de79c72013-04-03 05:46:33 +00004986 rtnl_link_unregister(&bond_link_ops);
nikolay@redhat.comffcdedb2013-04-06 00:54:37 +00004987 unregister_pernet_subsys(&bond_net_ops);
Neil Hormane843fa52010-10-13 16:01:50 +00004988
4989#ifdef CONFIG_NET_POLL_CONTROLLER
Neil Hormanfb4fa762010-12-06 09:05:50 +00004990 /*
4991 * Make sure we don't have an imbalance on our netpoll blocking
4992 */
4993 WARN_ON(atomic_read(&netpoll_block_tx));
Neil Hormane843fa52010-10-13 16:01:50 +00004994#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07004995}
4996
4997module_init(bonding_init);
4998module_exit(bonding_exit);
4999MODULE_LICENSE("GPL");
5000MODULE_VERSION(DRV_VERSION);
5001MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION);
5002MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others");
Eric W. Biederman88ead972009-10-29 14:18:25 +00005003MODULE_ALIAS_RTNL_LINK("bond");