]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/net/bonding/bond_main.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
vlan: convert to net_device_ops
[net-next-2.6.git] / drivers / net / bonding / bond_main.c
CommitLineData
1da177e4
LT		 1/*
2 * originally based on the dummy device.
3 *
4 * Copyright 1999, Thomas Davis, tadavis@lbl.gov.
5 * Licensed under the GPL. Based on dummy.c, and eql.c devices.
6 *
7 * bonding.c: an Ethernet Bonding driver
8 *
9 * This is useful to talk to a Cisco EtherChannel compatible equipment:
10 * Cisco 5500
11 * Sun Trunking (Solaris)
12 * Alteon AceDirector Trunks
13 * Linux Bonding
14 * and probably many L2 switches ...
15 *
16 * How it works:
17 * ifconfig bond0 ipaddress netmask up
18 * will setup a network device, with an ip address. No mac address
19 * will be assigned at this time. The hw mac address will come from
20 * the first slave bonded to the channel. All slaves will then use
21 * this hw mac address.
22 *
23 * ifconfig bond0 down
24 * will release all slaves, marking them as down.
25 *
26 * ifenslave bond0 eth0
27 * will attach eth0 to bond0 as a slave. eth0 hw mac address will either
28 * a: be used as initial mac address
29 * b: if a hw mac address already is there, eth0's hw mac address
30 * will then be set from bond0.
31 *
1da177e4
LT		 32 */
33
34//#define BONDING_DEBUG 1
35
1da177e4
LT		 36#include <linux/kernel.h>
37#include <linux/module.h>
1da177e4
LT		 38#include <linux/types.h>
39#include <linux/fcntl.h>
40#include <linux/interrupt.h>
41#include <linux/ptrace.h>
42#include <linux/ioport.h>
43#include <linux/in.h>
169a3e66 44#include <net/ip.h>
1da177e4 45#include <linux/ip.h>
169a3e66
JV		 46#include <linux/tcp.h>
47#include <linux/udp.h>
1da177e4
LT		 48#include <linux/slab.h>
49#include <linux/string.h>
50#include <linux/init.h>
51#include <linux/timer.h>
52#include <linux/socket.h>
53#include <linux/ctype.h>
54#include <linux/inet.h>
55#include <linux/bitops.h>
56#include <asm/system.h>
57#include <asm/io.h>
58#include <asm/dma.h>
59#include <asm/uaccess.h>
60#include <linux/errno.h>
61#include <linux/netdevice.h>
62#include <linux/inetdevice.h>
a816c7c7 63#include <linux/igmp.h>
1da177e4
LT		 64#include <linux/etherdevice.h>
65#include <linux/skbuff.h>
66#include <net/sock.h>
67#include <linux/rtnetlink.h>
68#include <linux/proc_fs.h>
69#include <linux/seq_file.h>
70#include <linux/smp.h>
71#include <linux/if_ether.h>
72#include <net/arp.h>
73#include <linux/mii.h>
74#include <linux/ethtool.h>
75#include <linux/if_vlan.h>
76#include <linux/if_bonding.h>
b63bb739 77#include <linux/jiffies.h>
c3ade5ca 78#include <net/route.h>
457c4cbc 79#include <net/net_namespace.h>
1da177e4
LT		 80#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;
7893b249 91static int num_grat_arp = 1;
305d552a 92static int num_unsol_na = 1;
1da177e4
LT		 93static int miimon = BOND_LINK_MON_INTERV;
94static int updelay = 0;
95static int downdelay = 0;
96static int use_carrier = 1;
97static char *mode = NULL;
98static char *primary = NULL;
99static char *lacp_rate = NULL;
fd989c83 100static char *ad_select = NULL;
169a3e66 101static char *xmit_hash_policy = NULL;
1da177e4
LT		 102static int arp_interval = BOND_LINK_ARP_INTERV;
103static char *arp_ip_target[BOND_MAX_ARP_TARGETS] = { NULL, };
f5b2b966 104static char *arp_validate = NULL;
3915c1e8 105static char *fail_over_mac = NULL;
12479f9a 106struct bond_params bonding_defaults;
1da177e4
LT		 107
108module_param(max_bonds, int, 0);
109MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
7893b249
MS		 110module_param(num_grat_arp, int, 0644);
111MODULE_PARM_DESC(num_grat_arp, "Number of gratuitous ARP packets to send on failover event");
305d552a
BH		 112module_param(num_unsol_na, int, 0644);
113MODULE_PARM_DESC(num_unsol_na, "Number of unsolicited IPv6 Neighbor Advertisements packets to send on failover event");
1da177e4
LT		 114module_param(miimon, int, 0);
115MODULE_PARM_DESC(miimon, "Link check interval in milliseconds");
116module_param(updelay, int, 0);
117MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds");
118module_param(downdelay, int, 0);
2ac47660
MW		 119MODULE_PARM_DESC(downdelay, "Delay before considering link down, "
120 "in milliseconds");
1da177e4 121module_param(use_carrier, int, 0);
2ac47660
MW		 122MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; "
123 "0 for off, 1 for on (default)");
1da177e4 124module_param(mode, charp, 0);
2ac47660
MW		 125MODULE_PARM_DESC(mode, "Mode of operation : 0 for balance-rr, "
126 "1 for active-backup, 2 for balance-xor, "
127 "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, "
128 "6 for balance-alb");
1da177e4
LT		 129module_param(primary, charp, 0);
130MODULE_PARM_DESC(primary, "Primary network device to use");
131module_param(lacp_rate, charp, 0);
2ac47660
MW		 132MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner "
133 "(slow/fast)");
fd989c83
JV		 134module_param(ad_select, charp, 0);
135MODULE_PARM_DESC(ad_select, "803.ad aggregation selection logic: stable (0, default), bandwidth (1), count (2)");
169a3e66 136module_param(xmit_hash_policy, charp, 0);
2ac47660
MW		 137MODULE_PARM_DESC(xmit_hash_policy, "XOR hashing method: 0 for layer 2 (default)"
138 ", 1 for layer 3+4");
1da177e4
LT		 139module_param(arp_interval, int, 0);
140MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds");
141module_param_array(arp_ip_target, charp, NULL, 0);
142MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form");
f5b2b966
JV		 143module_param(arp_validate, charp, 0);
144MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes: none (default), active, backup or all");
3915c1e8
JV		 145module_param(fail_over_mac, charp, 0);
146MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to the same MAC. none (default), active or follow");
1da177e4
LT		 147
148/*----------------------------- Global variables ----------------------------*/
149
f71e1309 150static const char * const version =
1da177e4
LT		 151 DRV_DESCRIPTION ": v" DRV_VERSION " (" DRV_RELDATE ")\n";
152
12479f9a 153LIST_HEAD(bond_dev_list);
1da177e4
LT		 154
155#ifdef CONFIG_PROC_FS
156static struct proc_dir_entry *bond_proc_dir = NULL;
157#endif
158
b76cdba9 159extern struct rw_semaphore bonding_rwsem;
d3bb52b0 160static __be32 arp_target[BOND_MAX_ARP_TARGETS] = { 0, } ;
1da177e4 161static int arp_ip_count = 0;
1da177e4 162static int bond_mode = BOND_MODE_ROUNDROBIN;
169a3e66 163static int xmit_hashtype= BOND_XMIT_POLICY_LAYER2;
1da177e4 164static int lacp_fast = 0;
217df670 165
1da177e4 166
12479f9a 167struct bond_parm_tbl bond_lacp_tbl[] = {
1da177e4
LT		 168{ "slow", AD_LACP_SLOW},
169{ "fast", AD_LACP_FAST},
170{ NULL, -1},
171};
172
12479f9a 173struct bond_parm_tbl bond_mode_tbl[] = {
1da177e4
LT		 174{ "balance-rr", BOND_MODE_ROUNDROBIN},
175{ "active-backup", BOND_MODE_ACTIVEBACKUP},
176{ "balance-xor", BOND_MODE_XOR},
177{ "broadcast", BOND_MODE_BROADCAST},
178{ "802.3ad", BOND_MODE_8023AD},
179{ "balance-tlb", BOND_MODE_TLB},
180{ "balance-alb", BOND_MODE_ALB},
181{ NULL, -1},
182};
183
12479f9a 184struct bond_parm_tbl xmit_hashtype_tbl[] = {
169a3e66
JV		 185{ "layer2", BOND_XMIT_POLICY_LAYER2},
186{ "layer3+4", BOND_XMIT_POLICY_LAYER34},
6f6652be 187{ "layer2+3", BOND_XMIT_POLICY_LAYER23},
169a3e66
JV		 188{ NULL, -1},
189};
190
f5b2b966
JV		 191struct bond_parm_tbl arp_validate_tbl[] = {
192{ "none", BOND_ARP_VALIDATE_NONE},
193{ "active", BOND_ARP_VALIDATE_ACTIVE},
194{ "backup", BOND_ARP_VALIDATE_BACKUP},
195{ "all", BOND_ARP_VALIDATE_ALL},
196{ NULL, -1},
197};
198
3915c1e8
JV		 199struct bond_parm_tbl fail_over_mac_tbl[] = {
200{ "none", BOND_FOM_NONE},
201{ "active", BOND_FOM_ACTIVE},
202{ "follow", BOND_FOM_FOLLOW},
203{ NULL, -1},
204};
205
fd989c83
JV		 206struct bond_parm_tbl ad_select_tbl[] = {
207{ "stable", BOND_AD_STABLE},
208{ "bandwidth", BOND_AD_BANDWIDTH},
209{ "count", BOND_AD_COUNT},
210{ NULL, -1},
211};
212
1da177e4
LT		 213/*-------------------------- Forward declarations ---------------------------*/
214
c3ade5ca 215static void bond_send_gratuitous_arp(struct bonding *bond);
c50b85d0 216static void bond_deinit(struct net_device *bond_dev);
1da177e4
LT		 217
218/*---------------------------- General routines -----------------------------*/
219
4ad072c9 220static const char *bond_mode_name(int mode)
1da177e4
LT		 221{
222 switch (mode) {
223 case BOND_MODE_ROUNDROBIN :
224 return "load balancing (round-robin)";
225 case BOND_MODE_ACTIVEBACKUP :
226 return "fault-tolerance (active-backup)";
227 case BOND_MODE_XOR :
228 return "load balancing (xor)";
229 case BOND_MODE_BROADCAST :
230 return "fault-tolerance (broadcast)";
231 case BOND_MODE_8023AD:
232 return "IEEE 802.3ad Dynamic link aggregation";
233 case BOND_MODE_TLB:
234 return "transmit load balancing";
235 case BOND_MODE_ALB:
236 return "adaptive load balancing";
237 default:
238 return "unknown";
239 }
240}
241
242/*---------------------------------- VLAN -----------------------------------*/
243
244/**
245 * bond_add_vlan - add a new vlan id on bond
246 * @bond: bond that got the notification
247 * @vlan_id: the vlan id to add
248 *
249 * Returns -ENOMEM if allocation failed.
250 */
251static int bond_add_vlan(struct bonding *bond, unsigned short vlan_id)
252{
253 struct vlan_entry *vlan;
254
255 dprintk("bond: %s, vlan id %d\n",
256 (bond ? bond->dev->name: "None"), vlan_id);
257
305d552a 258 vlan = kzalloc(sizeof(struct vlan_entry), GFP_KERNEL);
1da177e4
LT		 259 if (!vlan) {
260 return -ENOMEM;
261 }
262
263 INIT_LIST_HEAD(&vlan->vlan_list);
264 vlan->vlan_id = vlan_id;
265
266 write_lock_bh(&bond->lock);
267
268 list_add_tail(&vlan->vlan_list, &bond->vlan_list);
269
270 write_unlock_bh(&bond->lock);
271
272 dprintk("added VLAN ID %d on bond %s\n", vlan_id, bond->dev->name);
273
274 return 0;
275}
276
277/**
278 * bond_del_vlan - delete a vlan id from bond
279 * @bond: bond that got the notification
280 * @vlan_id: the vlan id to delete
281 *
282 * returns -ENODEV if @vlan_id was not found in @bond.
283 */
284static int bond_del_vlan(struct bonding *bond, unsigned short vlan_id)
285{
0883beca 286 struct vlan_entry *vlan;
1da177e4
LT		 287 int res = -ENODEV;
288
289 dprintk("bond: %s, vlan id %d\n", bond->dev->name, vlan_id);
290
291 write_lock_bh(&bond->lock);
292
0883beca 293 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
1da177e4
LT		 294 if (vlan->vlan_id == vlan_id) {
295 list_del(&vlan->vlan_list);
296
297 if ((bond->params.mode == BOND_MODE_TLB) ||
298 (bond->params.mode == BOND_MODE_ALB)) {
299 bond_alb_clear_vlan(bond, vlan_id);
300 }
301
302 dprintk("removed VLAN ID %d from bond %s\n", vlan_id,
303 bond->dev->name);
304
305 kfree(vlan);
306
307 if (list_empty(&bond->vlan_list) &&
308 (bond->slave_cnt == 0)) {
309 /* Last VLAN removed and no slaves, so
310 * restore block on adding VLANs. This will
311 * be removed once new slaves that are not
312 * VLAN challenged will be added.
313 */
314 bond->dev->features |= NETIF_F_VLAN_CHALLENGED;
315 }
316
317 res = 0;
318 goto out;
319 }
320 }
321
322 dprintk("couldn't find VLAN ID %d in bond %s\n", vlan_id,
323 bond->dev->name);
324
325out:
326 write_unlock_bh(&bond->lock);
327 return res;
328}
329
330/**
331 * bond_has_challenged_slaves
332 * @bond: the bond we're working on
333 *
334 * Searches the slave list. Returns 1 if a vlan challenged slave
335 * was found, 0 otherwise.
336 *
337 * Assumes bond->lock is held.
338 */
339static int bond_has_challenged_slaves(struct bonding *bond)
340{
341 struct slave *slave;
342 int i;
343
344 bond_for_each_slave(bond, slave, i) {
345 if (slave->dev->features & NETIF_F_VLAN_CHALLENGED) {
346 dprintk("found VLAN challenged slave - %s\n",
347 slave->dev->name);
348 return 1;
349 }
350 }
351
352 dprintk("no VLAN challenged slaves found\n");
353 return 0;
354}
355
356/**
357 * bond_next_vlan - safely skip to the next item in the vlans list.
358 * @bond: the bond we're working on
359 * @curr: item we're advancing from
360 *
361 * Returns %NULL if list is empty, bond->next_vlan if @curr is %NULL,
362 * or @curr->next otherwise (even if it is @curr itself again).
363 *
364 * Caller must hold bond->lock
365 */
366struct vlan_entry *bond_next_vlan(struct bonding *bond, struct vlan_entry *curr)
367{
368 struct vlan_entry *next, *last;
369
370 if (list_empty(&bond->vlan_list)) {
371 return NULL;
372 }
373
374 if (!curr) {
375 next = list_entry(bond->vlan_list.next,
376 struct vlan_entry, vlan_list);
377 } else {
378 last = list_entry(bond->vlan_list.prev,
379 struct vlan_entry, vlan_list);
380 if (last == curr) {
381 next = list_entry(bond->vlan_list.next,
382 struct vlan_entry, vlan_list);
383 } else {
384 next = list_entry(curr->vlan_list.next,
385 struct vlan_entry, vlan_list);
386 }
387 }
388
389 return next;
390}
391
392/**
393 * bond_dev_queue_xmit - Prepare skb for xmit.
394 *
395 * @bond: bond device that got this skb for tx.
396 * @skb: hw accel VLAN tagged skb to transmit
397 * @slave_dev: slave that is supposed to xmit this skbuff
398 *
399 * When the bond gets an skb to transmit that is
400 * already hardware accelerated VLAN tagged, and it
401 * needs to relay this skb to a slave that is not
402 * hw accel capable, the skb needs to be "unaccelerated",
403 * i.e. strip the hwaccel tag and re-insert it as part
404 * of the payload.
405 */
406int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev)
407{
966bc6f4 408 unsigned short uninitialized_var(vlan_id);
1da177e4
LT		 409
410 if (!list_empty(&bond->vlan_list) &&
411 !(slave_dev->features & NETIF_F_HW_VLAN_TX) &&
412 vlan_get_tag(skb, &vlan_id) == 0) {
413 skb->dev = slave_dev;
414 skb = vlan_put_tag(skb, vlan_id);
415 if (!skb) {
416 /* vlan_put_tag() frees the skb in case of error,
417 * so return success here so the calling functions
418 * won't attempt to free is again.
419 */
420 return 0;
421 }
422 } else {
423 skb->dev = slave_dev;
424 }
425
426 skb->priority = 1;
427 dev_queue_xmit(skb);
428
429 return 0;
430}
431
432/*
433 * In the following 3 functions, bond_vlan_rx_register(), bond_vlan_rx_add_vid
434 * and bond_vlan_rx_kill_vid, We don't protect the slave list iteration with a
435 * lock because:
436 * a. This operation is performed in IOCTL context,
437 * b. The operation is protected by the RTNL semaphore in the 8021q code,
438 * c. Holding a lock with BH disabled while directly calling a base driver
439 * entry point is generally a BAD idea.
440 *
441 * The design of synchronization/protection for this operation in the 8021q
442 * module is good for one or more VLAN devices over a single physical device
443 * and cannot be extended for a teaming solution like bonding, so there is a
444 * potential race condition here where a net device from the vlan group might
445 * be referenced (either by a base driver or the 8021q code) while it is being
446 * removed from the system. However, it turns out we're not making matters
447 * worse, and if it works for regular VLAN usage it will work here too.
448*/
449
450/**
451 * bond_vlan_rx_register - Propagates registration to slaves
452 * @bond_dev: bonding net device that got called
453 * @grp: vlan group being registered
454 */
455static void bond_vlan_rx_register(struct net_device *bond_dev, struct vlan_group *grp)
456{
454d7c9b 457 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 458 struct slave *slave;
459 int i;
460
461 bond->vlgrp = grp;
462
463 bond_for_each_slave(bond, slave, i) {
464 struct net_device *slave_dev = slave->dev;
465
466 if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
467 slave_dev->vlan_rx_register) {
468 slave_dev->vlan_rx_register(slave_dev, grp);
469 }
470 }
471}
472
473/**
474 * bond_vlan_rx_add_vid - Propagates adding an id to slaves
475 * @bond_dev: bonding net device that got called
476 * @vid: vlan id being added
477 */
478static void bond_vlan_rx_add_vid(struct net_device *bond_dev, uint16_t vid)
479{
454d7c9b 480 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 481 struct slave *slave;
482 int i, res;
483
484 bond_for_each_slave(bond, slave, i) {
485 struct net_device *slave_dev = slave->dev;
486
487 if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) &&
488 slave_dev->vlan_rx_add_vid) {
489 slave_dev->vlan_rx_add_vid(slave_dev, vid);
490 }
491 }
492
493 res = bond_add_vlan(bond, vid);
494 if (res) {
495 printk(KERN_ERR DRV_NAME
4e0952c7 496 ": %s: Error: Failed to add vlan id %d\n",
1da177e4
LT		 497 bond_dev->name, vid);
498 }
499}
500
501/**
502 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
503 * @bond_dev: bonding net device that got called
504 * @vid: vlan id being removed
505 */
506static void bond_vlan_rx_kill_vid(struct net_device *bond_dev, uint16_t vid)
507{
454d7c9b 508 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 509 struct slave *slave;
510 struct net_device *vlan_dev;
511 int i, res;
512
513 bond_for_each_slave(bond, slave, i) {
514 struct net_device *slave_dev = slave->dev;
515
516 if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) &&
517 slave_dev->vlan_rx_kill_vid) {
518 /* Save and then restore vlan_dev in the grp array,
519 * since the slave's driver might clear it.
520 */
5c15bdec 521 vlan_dev = vlan_group_get_device(bond->vlgrp, vid);
1da177e4 522 slave_dev->vlan_rx_kill_vid(slave_dev, vid);
5c15bdec 523 vlan_group_set_device(bond->vlgrp, vid, vlan_dev);
1da177e4
LT		 524 }
525 }
526
527 res = bond_del_vlan(bond, vid);
528 if (res) {
529 printk(KERN_ERR DRV_NAME
4e0952c7 530 ": %s: Error: Failed to remove vlan id %d\n",
1da177e4
LT		 531 bond_dev->name, vid);
532 }
533}
534
535static void bond_add_vlans_on_slave(struct bonding *bond, struct net_device *slave_dev)
536{
537 struct vlan_entry *vlan;
538
539 write_lock_bh(&bond->lock);
540
541 if (list_empty(&bond->vlan_list)) {
542 goto out;
543 }
544
545 if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
546 slave_dev->vlan_rx_register) {
547 slave_dev->vlan_rx_register(slave_dev, bond->vlgrp);
548 }
549
550 if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) ||
551 !(slave_dev->vlan_rx_add_vid)) {
552 goto out;
553 }
554
555 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
556 slave_dev->vlan_rx_add_vid(slave_dev, vlan->vlan_id);
557 }
558
559out:
560 write_unlock_bh(&bond->lock);
561}
562
563static void bond_del_vlans_from_slave(struct bonding *bond, struct net_device *slave_dev)
564{
565 struct vlan_entry *vlan;
566 struct net_device *vlan_dev;
567
568 write_lock_bh(&bond->lock);
569
570 if (list_empty(&bond->vlan_list)) {
571 goto out;
572 }
573
574 if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) ||
575 !(slave_dev->vlan_rx_kill_vid)) {
576 goto unreg;
577 }
578
579 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
580 /* Save and then restore vlan_dev in the grp array,
581 * since the slave's driver might clear it.
582 */
5c15bdec 583 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
1da177e4 584 slave_dev->vlan_rx_kill_vid(slave_dev, vlan->vlan_id);
5c15bdec 585 vlan_group_set_device(bond->vlgrp, vlan->vlan_id, vlan_dev);
1da177e4
LT		 586 }
587
588unreg:
589 if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
590 slave_dev->vlan_rx_register) {
591 slave_dev->vlan_rx_register(slave_dev, NULL);
592 }
593
594out:
595 write_unlock_bh(&bond->lock);
596}
597
598/*------------------------------- Link status -------------------------------*/
599
ff59c456
JV		 600/*
601 * Set the carrier state for the master according to the state of its
602 * slaves. If any slaves are up, the master is up. In 802.3ad mode,
603 * do special 802.3ad magic.
604 *
605 * Returns zero if carrier state does not change, nonzero if it does.
606 */
607static int bond_set_carrier(struct bonding *bond)
608{
609 struct slave *slave;
610 int i;
611
612 if (bond->slave_cnt == 0)
613 goto down;
614
615 if (bond->params.mode == BOND_MODE_8023AD)
616 return bond_3ad_set_carrier(bond);
617
618 bond_for_each_slave(bond, slave, i) {
619 if (slave->link == BOND_LINK_UP) {
620 if (!netif_carrier_ok(bond->dev)) {
621 netif_carrier_on(bond->dev);
622 return 1;
623 }
624 return 0;
625 }
626 }
627
628down:
629 if (netif_carrier_ok(bond->dev)) {
630 netif_carrier_off(bond->dev);
631 return 1;
632 }
633 return 0;
634}
635
1da177e4
LT		 636/*
637 * Get link speed and duplex from the slave's base driver
638 * using ethtool. If for some reason the call fails or the
639 * values are invalid, fake speed and duplex to 100/Full
640 * and return error.
641 */
642static int bond_update_speed_duplex(struct slave *slave)
643{
644 struct net_device *slave_dev = slave->dev;
1da177e4 645 struct ethtool_cmd etool;
61a44b9c 646 int res;
1da177e4
LT		 647
648 /* Fake speed and duplex */
649 slave->speed = SPEED_100;
650 slave->duplex = DUPLEX_FULL;
651
61a44b9c
MW		 652 if (!slave_dev->ethtool_ops || !slave_dev->ethtool_ops->get_settings)
653 return -1;
1da177e4 654
61a44b9c
MW		 655 res = slave_dev->ethtool_ops->get_settings(slave_dev, &etool);
656 if (res < 0)
1da177e4 657 return -1;
1da177e4 658
1da177e4
LT		 659 switch (etool.speed) {
660 case SPEED_10:
661 case SPEED_100:
662 case SPEED_1000:
94dbffd5 663 case SPEED_10000:
1da177e4
LT		 664 break;
665 default:
666 return -1;
667 }
668
669 switch (etool.duplex) {
670 case DUPLEX_FULL:
671 case DUPLEX_HALF:
672 break;
673 default:
674 return -1;
675 }
676
677 slave->speed = etool.speed;
678 slave->duplex = etool.duplex;
679
680 return 0;
681}
682
683/*
684 * if <dev> supports MII link status reporting, check its link status.
685 *
686 * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(),
687 * depening upon the setting of the use_carrier parameter.
688 *
689 * Return either BMSR_LSTATUS, meaning that the link is up (or we
690 * can't tell and just pretend it is), or 0, meaning that the link is
691 * down.
692 *
693 * If reporting is non-zero, instead of faking link up, return -1 if
694 * both ETHTOOL and MII ioctls fail (meaning the device does not
695 * support them). If use_carrier is set, return whatever it says.
696 * It'd be nice if there was a good way to tell if a driver supports
697 * netif_carrier, but there really isn't.
698 */
699static int bond_check_dev_link(struct bonding *bond, struct net_device *slave_dev, int reporting)
700{
701 static int (* ioctl)(struct net_device *, struct ifreq *, int);
702 struct ifreq ifr;
703 struct mii_ioctl_data *mii;
1da177e4
LT		 704
705 if (bond->params.use_carrier) {
706 return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;
707 }
708
709 ioctl = slave_dev->do_ioctl;
710 if (ioctl) {
711 /* TODO: set pointer to correct ioctl on a per team member */
712 /* bases to make this more efficient. that is, once */
713 /* we determine the correct ioctl, we will always */
714 /* call it and not the others for that team */
715 /* member. */
716
717 /*
718 * We cannot assume that SIOCGMIIPHY will also read a
719 * register; not all network drivers (e.g., e100)
720 * support that.
721 */
722
723 /* Yes, the mii is overlaid on the ifreq.ifr_ifru */
724 strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
725 mii = if_mii(&ifr);
726 if (IOCTL(slave_dev, &ifr, SIOCGMIIPHY) == 0) {
727 mii->reg_num = MII_BMSR;
728 if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0) {
729 return (mii->val_out & BMSR_LSTATUS);
730 }
731 }
732 }
733
61a44b9c
MW		 734 /*
735 * Some drivers cache ETHTOOL_GLINK for a period of time so we only
736 * attempt to get link status from it if the above MII ioctls fail.
737 */
1da177e4
LT		 738 if (slave_dev->ethtool_ops) {
739 if (slave_dev->ethtool_ops->get_link) {
740 u32 link;
741
742 link = slave_dev->ethtool_ops->get_link(slave_dev);
743
744 return link ? BMSR_LSTATUS : 0;
745 }
746 }
747
1da177e4
LT		 748 /*
749 * If reporting, report that either there's no dev->do_ioctl,
61a44b9c 750 * or both SIOCGMIIREG and get_link failed (meaning that we
1da177e4
LT		 751 * cannot report link status). If not reporting, pretend
752 * we're ok.
753 */
754 return (reporting ? -1 : BMSR_LSTATUS);
755}
756
757/*----------------------------- Multicast list ------------------------------*/
758
759/*
760 * Returns 0 if dmi1 and dmi2 are the same, non-0 otherwise
761 */
762static inline int bond_is_dmi_same(struct dev_mc_list *dmi1, struct dev_mc_list *dmi2)
763{
764 return memcmp(dmi1->dmi_addr, dmi2->dmi_addr, dmi1->dmi_addrlen) == 0 &&
765 dmi1->dmi_addrlen == dmi2->dmi_addrlen;
766}
767
768/*
769 * returns dmi entry if found, NULL otherwise
770 */
771static struct dev_mc_list *bond_mc_list_find_dmi(struct dev_mc_list *dmi, struct dev_mc_list *mc_list)
772{
773 struct dev_mc_list *idmi;
774
775 for (idmi = mc_list; idmi; idmi = idmi->next) {
776 if (bond_is_dmi_same(dmi, idmi)) {
777 return idmi;
778 }
779 }
780
781 return NULL;
782}
783
784/*
785 * Push the promiscuity flag down to appropriate slaves
786 */
7e1a1ac1 787static int bond_set_promiscuity(struct bonding *bond, int inc)
1da177e4 788{
7e1a1ac1 789 int err = 0;
1da177e4
LT		 790 if (USES_PRIMARY(bond->params.mode)) {
791 /* write lock already acquired */
792 if (bond->curr_active_slave) {
7e1a1ac1
WC		 793 err = dev_set_promiscuity(bond->curr_active_slave->dev,
794 inc);
1da177e4
LT		 795 }
796 } else {
797 struct slave *slave;
798 int i;
799 bond_for_each_slave(bond, slave, i) {
7e1a1ac1
WC		 800 err = dev_set_promiscuity(slave->dev, inc);
801 if (err)
802 return err;
1da177e4
LT		 803 }
804 }
7e1a1ac1 805 return err;
1da177e4
LT		 806}
807
808/*
809 * Push the allmulti flag down to all slaves
810 */
7e1a1ac1 811static int bond_set_allmulti(struct bonding *bond, int inc)
1da177e4 812{
7e1a1ac1 813 int err = 0;
1da177e4
LT		 814 if (USES_PRIMARY(bond->params.mode)) {
815 /* write lock already acquired */
816 if (bond->curr_active_slave) {
7e1a1ac1
WC		 817 err = dev_set_allmulti(bond->curr_active_slave->dev,
818 inc);
1da177e4
LT		 819 }
820 } else {
821 struct slave *slave;
822 int i;
823 bond_for_each_slave(bond, slave, i) {
7e1a1ac1
WC		 824 err = dev_set_allmulti(slave->dev, inc);
825 if (err)
826 return err;
1da177e4
LT		 827 }
828 }
7e1a1ac1 829 return err;
1da177e4
LT		 830}
831
832/*
833 * Add a Multicast address to slaves
834 * according to mode
835 */
836static void bond_mc_add(struct bonding *bond, void *addr, int alen)
837{
838 if (USES_PRIMARY(bond->params.mode)) {
839 /* write lock already acquired */
840 if (bond->curr_active_slave) {
841 dev_mc_add(bond->curr_active_slave->dev, addr, alen, 0);
842 }
843 } else {
844 struct slave *slave;
845 int i;
846 bond_for_each_slave(bond, slave, i) {
847 dev_mc_add(slave->dev, addr, alen, 0);
848 }
849 }
850}
851
852/*
853 * Remove a multicast address from slave
854 * according to mode
855 */
856static void bond_mc_delete(struct bonding *bond, void *addr, int alen)
857{
858 if (USES_PRIMARY(bond->params.mode)) {
859 /* write lock already acquired */
860 if (bond->curr_active_slave) {
861 dev_mc_delete(bond->curr_active_slave->dev, addr, alen, 0);
862 }
863 } else {
864 struct slave *slave;
865 int i;
866 bond_for_each_slave(bond, slave, i) {
867 dev_mc_delete(slave->dev, addr, alen, 0);
868 }
869 }
870}
871
a816c7c7
JV		 872
873/*
874 * Retrieve the list of registered multicast addresses for the bonding
875 * device and retransmit an IGMP JOIN request to the current active
876 * slave.
877 */
878static void bond_resend_igmp_join_requests(struct bonding *bond)
879{
880 struct in_device *in_dev;
881 struct ip_mc_list *im;
882
883 rcu_read_lock();
884 in_dev = __in_dev_get_rcu(bond->dev);
885 if (in_dev) {
886 for (im = in_dev->mc_list; im; im = im->next) {
887 ip_mc_rejoin_group(im);
888 }
889 }
890
891 rcu_read_unlock();
892}
893
1da177e4
LT		 894/*
895 * Totally destroys the mc_list in bond
896 */
897static void bond_mc_list_destroy(struct bonding *bond)
898{
899 struct dev_mc_list *dmi;
900
901 dmi = bond->mc_list;
902 while (dmi) {
903 bond->mc_list = dmi->next;
904 kfree(dmi);
905 dmi = bond->mc_list;
906 }
a816c7c7 907 bond->mc_list = NULL;
1da177e4
LT		 908}
909
910/*
911 * Copy all the Multicast addresses from src to the bonding device dst
912 */
de54f390 913static int bond_mc_list_copy(struct dev_mc_list *mc_list, struct bonding *bond,
dd0fc66f 914 gfp_t gfp_flag)
1da177e4
LT		 915{
916 struct dev_mc_list *dmi, *new_dmi;
917
918 for (dmi = mc_list; dmi; dmi = dmi->next) {
de54f390 919 new_dmi = kmalloc(sizeof(struct dev_mc_list), gfp_flag);
1da177e4
LT		 920
921 if (!new_dmi) {
922 /* FIXME: Potential memory leak !!! */
923 return -ENOMEM;
924 }
925
926 new_dmi->next = bond->mc_list;
927 bond->mc_list = new_dmi;
928 new_dmi->dmi_addrlen = dmi->dmi_addrlen;
929 memcpy(new_dmi->dmi_addr, dmi->dmi_addr, dmi->dmi_addrlen);
930 new_dmi->dmi_users = dmi->dmi_users;
931 new_dmi->dmi_gusers = dmi->dmi_gusers;
932 }
933
934 return 0;
935}
936
937/*
938 * flush all members of flush->mc_list from device dev->mc_list
939 */
940static void bond_mc_list_flush(struct net_device *bond_dev, struct net_device *slave_dev)
941{
454d7c9b 942 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 943 struct dev_mc_list *dmi;
944
945 for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
946 dev_mc_delete(slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
947 }
948
949 if (bond->params.mode == BOND_MODE_8023AD) {
950 /* del lacpdu mc addr from mc list */
951 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
952
953 dev_mc_delete(slave_dev, lacpdu_multicast, ETH_ALEN, 0);
954 }
955}
956
957/*--------------------------- Active slave change ---------------------------*/
958
959/*
960 * Update the mc list and multicast-related flags for the new and
961 * old active slaves (if any) according to the multicast mode, and
962 * promiscuous flags unconditionally.
963 */
964static void bond_mc_swap(struct bonding *bond, struct slave *new_active, struct slave *old_active)
965{
966 struct dev_mc_list *dmi;
967
968 if (!USES_PRIMARY(bond->params.mode)) {
969 /* nothing to do - mc list is already up-to-date on
970 * all slaves
971 */
972 return;
973 }
974
975 if (old_active) {
976 if (bond->dev->flags & IFF_PROMISC) {
977 dev_set_promiscuity(old_active->dev, -1);
978 }
979
980 if (bond->dev->flags & IFF_ALLMULTI) {
981 dev_set_allmulti(old_active->dev, -1);
982 }
983
984 for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) {
985 dev_mc_delete(old_active->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
986 }
987 }
988
989 if (new_active) {
7e1a1ac1 990 /* FIXME: Signal errors upstream. */
1da177e4
LT		 991 if (bond->dev->flags & IFF_PROMISC) {
992 dev_set_promiscuity(new_active->dev, 1);
993 }
994
995 if (bond->dev->flags & IFF_ALLMULTI) {
996 dev_set_allmulti(new_active->dev, 1);
997 }
998
999 for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) {
1000 dev_mc_add(new_active->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
1001 }
a816c7c7 1002 bond_resend_igmp_join_requests(bond);
1da177e4
LT		 1003 }
1004}
1005
3915c1e8
JV		 1006/*
1007 * bond_do_fail_over_mac
1008 *
1009 * Perform special MAC address swapping for fail_over_mac settings
1010 *
1011 * Called with RTNL, bond->lock for read, curr_slave_lock for write_bh.
1012 */
1013static void bond_do_fail_over_mac(struct bonding *bond,
1014 struct slave *new_active,
1015 struct slave *old_active)
1016{
1017 u8 tmp_mac[ETH_ALEN];
1018 struct sockaddr saddr;
1019 int rv;
1020
1021 switch (bond->params.fail_over_mac) {
1022 case BOND_FOM_ACTIVE:
1023 if (new_active)
1024 memcpy(bond->dev->dev_addr, new_active->dev->dev_addr,
1025 new_active->dev->addr_len);
1026 break;
1027 case BOND_FOM_FOLLOW:
1028 /*
1029 * if new_active && old_active, swap them
1030 * if just old_active, do nothing (going to no active slave)
1031 * if just new_active, set new_active to bond's MAC
1032 */
1033 if (!new_active)
1034 return;
1035
1036 write_unlock_bh(&bond->curr_slave_lock);
1037 read_unlock(&bond->lock);
1038
1039 if (old_active) {
1040 memcpy(tmp_mac, new_active->dev->dev_addr, ETH_ALEN);
1041 memcpy(saddr.sa_data, old_active->dev->dev_addr,
1042 ETH_ALEN);
1043 saddr.sa_family = new_active->dev->type;
1044 } else {
1045 memcpy(saddr.sa_data, bond->dev->dev_addr, ETH_ALEN);
1046 saddr.sa_family = bond->dev->type;
1047 }
1048
1049 rv = dev_set_mac_address(new_active->dev, &saddr);
1050 if (rv) {
1051 printk(KERN_ERR DRV_NAME
1052 ": %s: Error %d setting MAC of slave %s\n",
1053 bond->dev->name, -rv, new_active->dev->name);
1054 goto out;
1055 }
1056
1057 if (!old_active)
1058 goto out;
1059
1060 memcpy(saddr.sa_data, tmp_mac, ETH_ALEN);
1061 saddr.sa_family = old_active->dev->type;
1062
1063 rv = dev_set_mac_address(old_active->dev, &saddr);
1064 if (rv)
1065 printk(KERN_ERR DRV_NAME
1066 ": %s: Error %d setting MAC of slave %s\n",
1067 bond->dev->name, -rv, new_active->dev->name);
1068out:
1069 read_lock(&bond->lock);
1070 write_lock_bh(&bond->curr_slave_lock);
1071 break;
1072 default:
1073 printk(KERN_ERR DRV_NAME
1074 ": %s: bond_do_fail_over_mac impossible: bad policy %d\n",
1075 bond->dev->name, bond->params.fail_over_mac);
1076 break;
1077 }
1078
1079}
1080
1081
1da177e4
LT		 1082/**
1083 * find_best_interface - select the best available slave to be the active one
1084 * @bond: our bonding struct
1085 *
1086 * Warning: Caller must hold curr_slave_lock for writing.
1087 */
1088static struct slave *bond_find_best_slave(struct bonding *bond)
1089{
1090 struct slave *new_active, *old_active;
1091 struct slave *bestslave = NULL;
1092 int mintime = bond->params.updelay;
1093 int i;
1094
1095 new_active = old_active = bond->curr_active_slave;
1096
1097 if (!new_active) { /* there were no active slaves left */
1098 if (bond->slave_cnt > 0) { /* found one slave */
1099 new_active = bond->first_slave;
1100 } else {
1101 return NULL; /* still no slave, return NULL */
1102 }
1103 }
1104
1105 /* first try the primary link; if arping, a link must tx/rx traffic
1106 * before it can be considered the curr_active_slave - also, we would skip
1107 * slaves between the curr_active_slave and primary_slave that may be up
1108 * and able to arp
1109 */
1110 if ((bond->primary_slave) &&
1111 (!bond->params.arp_interval) &&
1112 (IS_UP(bond->primary_slave->dev))) {
1113 new_active = bond->primary_slave;
1114 }
1115
1116 /* remember where to stop iterating over the slaves */
1117 old_active = new_active;
1118
1119 bond_for_each_slave_from(bond, new_active, i, old_active) {
1120 if (IS_UP(new_active->dev)) {
1121 if (new_active->link == BOND_LINK_UP) {
1122 return new_active;
1123 } else if (new_active->link == BOND_LINK_BACK) {
1124 /* link up, but waiting for stabilization */
1125 if (new_active->delay < mintime) {
1126 mintime = new_active->delay;
1127 bestslave = new_active;
1128 }
1129 }
1130 }
1131 }
1132
1133 return bestslave;
1134}
1135
1136/**
1137 * change_active_interface - change the active slave into the specified one
1138 * @bond: our bonding struct
1139 * @new: the new slave to make the active one
1140 *
1141 * Set the new slave to the bond's settings and unset them on the old
1142 * curr_active_slave.
1143 * Setting include flags, mc-list, promiscuity, allmulti, etc.
1144 *
1145 * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP,
1146 * because it is apparently the best available slave we have, even though its
1147 * updelay hasn't timed out yet.
1148 *
3915c1e8
JV		 1149 * If new_active is not NULL, caller must hold bond->lock for read and
1150 * curr_slave_lock for write_bh.
1da177e4 1151 */
a77b5325 1152void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
1da177e4
LT		 1153{
1154 struct slave *old_active = bond->curr_active_slave;
1155
1156 if (old_active == new_active) {
1157 return;
1158 }
1159
1160 if (new_active) {
b2220cad
JV		 1161 new_active->jiffies = jiffies;
1162
1da177e4
LT		 1163 if (new_active->link == BOND_LINK_BACK) {
1164 if (USES_PRIMARY(bond->params.mode)) {
1165 printk(KERN_INFO DRV_NAME
1166 ": %s: making interface %s the new "
1167 "active one %d ms earlier.\n",
1168 bond->dev->name, new_active->dev->name,
1169 (bond->params.updelay - new_active->delay) * bond->params.miimon);
1170 }
1171
1172 new_active->delay = 0;
1173 new_active->link = BOND_LINK_UP;
1da177e4
LT		 1174
1175 if (bond->params.mode == BOND_MODE_8023AD) {
1176 bond_3ad_handle_link_change(new_active, BOND_LINK_UP);
1177 }
1178
1179 if ((bond->params.mode == BOND_MODE_TLB) ||
1180 (bond->params.mode == BOND_MODE_ALB)) {
1181 bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
1182 }
1183 } else {
1184 if (USES_PRIMARY(bond->params.mode)) {
1185 printk(KERN_INFO DRV_NAME
1186 ": %s: making interface %s the new "
1187 "active one.\n",
1188 bond->dev->name, new_active->dev->name);
1189 }
1190 }
1191 }
1192
1da177e4
LT		 1193 if (USES_PRIMARY(bond->params.mode)) {
1194 bond_mc_swap(bond, new_active, old_active);
1195 }
1196
1197 if ((bond->params.mode == BOND_MODE_TLB) ||
1198 (bond->params.mode == BOND_MODE_ALB)) {
1199 bond_alb_handle_active_change(bond, new_active);
8f903c70
JV		 1200 if (old_active)
1201 bond_set_slave_inactive_flags(old_active);
1202 if (new_active)
1203 bond_set_slave_active_flags(new_active);
1da177e4
LT		 1204 } else {
1205 bond->curr_active_slave = new_active;
1206 }
c3ade5ca
JV		 1207
1208 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
1209 if (old_active) {
1210 bond_set_slave_inactive_flags(old_active);
1211 }
1212
1213 if (new_active) {
1214 bond_set_slave_active_flags(new_active);
2ab82852 1215
709f8a45
OG		 1216 if (bond->params.fail_over_mac)
1217 bond_do_fail_over_mac(bond, new_active,
1218 old_active);
3915c1e8 1219
709f8a45 1220 bond->send_grat_arp = bond->params.num_grat_arp;
b59f9f74 1221 bond_send_gratuitous_arp(bond);
01f3109d 1222
305d552a
BH		 1223 bond->send_unsol_na = bond->params.num_unsol_na;
1224 bond_send_unsolicited_na(bond);
1225
01f3109d
OG		 1226 write_unlock_bh(&bond->curr_slave_lock);
1227 read_unlock(&bond->lock);
1228
1229 netdev_bonding_change(bond->dev);
1230
1231 read_lock(&bond->lock);
1232 write_lock_bh(&bond->curr_slave_lock);
7893b249 1233 }
c3ade5ca 1234 }
1da177e4
LT		 1235}
1236
1237/**
1238 * bond_select_active_slave - select a new active slave, if needed
1239 * @bond: our bonding struct
1240 *
1241 * This functions shoud be called when one of the following occurs:
1242 * - The old curr_active_slave has been released or lost its link.
1243 * - The primary_slave has got its link back.
1244 * - A slave has got its link back and there's no old curr_active_slave.
1245 *
3915c1e8 1246 * Caller must hold bond->lock for read and curr_slave_lock for write_bh.
1da177e4 1247 */
a77b5325 1248void bond_select_active_slave(struct bonding *bond)
1da177e4
LT		 1249{
1250 struct slave *best_slave;
ff59c456 1251 int rv;
1da177e4
LT		 1252
1253 best_slave = bond_find_best_slave(bond);
1254 if (best_slave != bond->curr_active_slave) {
1255 bond_change_active_slave(bond, best_slave);
ff59c456
JV		 1256 rv = bond_set_carrier(bond);
1257 if (!rv)
1258 return;
1259
1260 if (netif_carrier_ok(bond->dev)) {
1261 printk(KERN_INFO DRV_NAME
1262 ": %s: first active interface up!\n",
1263 bond->dev->name);
1264 } else {
1265 printk(KERN_INFO DRV_NAME ": %s: "
1266 "now running without any active interface !\n",
1267 bond->dev->name);
1268 }
1da177e4
LT		 1269 }
1270}
1271
1272/*--------------------------- slave list handling ---------------------------*/
1273
1274/*
1275 * This function attaches the slave to the end of list.
1276 *
1277 * bond->lock held for writing by caller.
1278 */
1279static void bond_attach_slave(struct bonding *bond, struct slave *new_slave)
1280{
1281 if (bond->first_slave == NULL) { /* attaching the first slave */
1282 new_slave->next = new_slave;
1283 new_slave->prev = new_slave;
1284 bond->first_slave = new_slave;
1285 } else {
1286 new_slave->next = bond->first_slave;
1287 new_slave->prev = bond->first_slave->prev;
1288 new_slave->next->prev = new_slave;
1289 new_slave->prev->next = new_slave;
1290 }
1291
1292 bond->slave_cnt++;
1293}
1294
1295/*
1296 * This function detaches the slave from the list.
1297 * WARNING: no check is made to verify if the slave effectively
1298 * belongs to <bond>.
1299 * Nothing is freed on return, structures are just unchained.
1300 * If any slave pointer in bond was pointing to <slave>,
1301 * it should be changed by the calling function.
1302 *
1303 * bond->lock held for writing by caller.
1304 */
1305static void bond_detach_slave(struct bonding *bond, struct slave *slave)
1306{
1307 if (slave->next) {
1308 slave->next->prev = slave->prev;
1309 }
1310
1311 if (slave->prev) {
1312 slave->prev->next = slave->next;
1313 }
1314
1315 if (bond->first_slave == slave) { /* slave is the first slave */
1316 if (bond->slave_cnt > 1) { /* there are more slave */
1317 bond->first_slave = slave->next;
1318 } else {
1319 bond->first_slave = NULL; /* slave was the last one */
1320 }
1321 }
1322
1323 slave->next = NULL;
1324 slave->prev = NULL;
1325 bond->slave_cnt--;
1326}
1327
1328/*---------------------------------- IOCTL ----------------------------------*/
1329
4ad072c9
AB		 1330static int bond_sethwaddr(struct net_device *bond_dev,
1331 struct net_device *slave_dev)
1da177e4
LT		 1332{
1333 dprintk("bond_dev=%p\n", bond_dev);
1334 dprintk("slave_dev=%p\n", slave_dev);
1335 dprintk("slave_dev->addr_len=%d\n", slave_dev->addr_len);
1336 memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
1337 return 0;
1338}
1339
7f353bf2
HX		 1340#define BOND_VLAN_FEATURES \
1341 (NETIF_F_VLAN_CHALLENGED | NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_TX | \
1342 NETIF_F_HW_VLAN_FILTER)
8531c5ff
AK		 1343
1344/*
8e3babcd 1345 * Compute the common dev->feature set available to all slaves. Some
7f353bf2
HX		 1346 * feature bits are managed elsewhere, so preserve those feature bits
1347 * on the master device.
8531c5ff
AK		 1348 */
1349static int bond_compute_features(struct bonding *bond)
1350{
8531c5ff
AK		 1351 struct slave *slave;
1352 struct net_device *bond_dev = bond->dev;
7f353bf2 1353 unsigned long features = bond_dev->features;
3158bf7d
MS		 1354 unsigned short max_hard_header_len = max((u16)ETH_HLEN,
1355 bond_dev->hard_header_len);
8e3babcd 1356 int i;
8531c5ff 1357
7f353bf2 1358 features &= ~(NETIF_F_ALL_CSUM | BOND_VLAN_FEATURES);
b63365a2
HX		 1359 features |= NETIF_F_GSO_MASK | NETIF_F_NO_CSUM;
1360
1361 if (!bond->first_slave)
1362 goto done;
1363
1364 features &= ~NETIF_F_ONE_FOR_ALL;
7f353bf2 1365
54ef3137 1366 bond_for_each_slave(bond, slave, i) {
b63365a2
HX		 1367 features = netdev_increment_features(features,
1368 slave->dev->features,
1369 NETIF_F_ONE_FOR_ALL);
54ef3137
JV		 1370 if (slave->dev->hard_header_len > max_hard_header_len)
1371 max_hard_header_len = slave->dev->hard_header_len;
1372 }
8531c5ff 1373
b63365a2 1374done:
7f353bf2 1375 features |= (bond_dev->features & BOND_VLAN_FEATURES);
b63365a2 1376 bond_dev->features = netdev_fix_features(features, NULL);
54ef3137 1377 bond_dev->hard_header_len = max_hard_header_len;
8531c5ff
AK		 1378
1379 return 0;
1380}
1381
872254dd
MS		 1382
1383static void bond_setup_by_slave(struct net_device *bond_dev,
1384 struct net_device *slave_dev)
1385{
454d7c9b 1386 struct bonding *bond = netdev_priv(bond_dev);
d90a162a 1387
872254dd 1388 bond_dev->neigh_setup = slave_dev->neigh_setup;
1284cd3a 1389 bond_dev->header_ops = slave_dev->header_ops;
872254dd
MS		 1390
1391 bond_dev->type = slave_dev->type;
1392 bond_dev->hard_header_len = slave_dev->hard_header_len;
1393 bond_dev->addr_len = slave_dev->addr_len;
1394
1395 memcpy(bond_dev->broadcast, slave_dev->broadcast,
1396 slave_dev->addr_len);
d90a162a 1397 bond->setup_by_slave = 1;
872254dd
MS		 1398}
1399
1da177e4 1400/* enslave device <slave> to bond device <master> */
a77b5325 1401int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
1da177e4 1402{
454d7c9b 1403 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 1404 struct slave *new_slave = NULL;
1405 struct dev_mc_list *dmi;
1406 struct sockaddr addr;
1407 int link_reporting;
1408 int old_features = bond_dev->features;
1409 int res = 0;
1410
552709d5 1411 if (!bond->params.use_carrier && slave_dev->ethtool_ops == NULL &&
1412 slave_dev->do_ioctl == NULL) {
1da177e4 1413 printk(KERN_WARNING DRV_NAME
4e0952c7
MW		 1414 ": %s: Warning: no link monitoring support for %s\n",
1415 bond_dev->name, slave_dev->name);
1da177e4
LT		 1416 }
1417
1418 /* bond must be initialized by bond_open() before enslaving */
1419 if (!(bond_dev->flags & IFF_UP)) {
6b1bf096
MS		 1420 printk(KERN_WARNING DRV_NAME
1421 " %s: master_dev is not up in bond_enslave\n",
1422 bond_dev->name);
1da177e4
LT		 1423 }
1424
1425 /* already enslaved */
1426 if (slave_dev->flags & IFF_SLAVE) {
1427 dprintk("Error, Device was already enslaved\n");
1428 return -EBUSY;
1429 }
1430
1431 /* vlan challenged mutual exclusion */
1432 /* no need to lock since we're protected by rtnl_lock */
1433 if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) {
1434 dprintk("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
1435 if (!list_empty(&bond->vlan_list)) {
1436 printk(KERN_ERR DRV_NAME
4e0952c7 1437 ": %s: Error: cannot enslave VLAN "
1da177e4 1438 "challenged slave %s on VLAN enabled "
4e0952c7 1439 "bond %s\n", bond_dev->name, slave_dev->name,
1da177e4
LT		 1440 bond_dev->name);
1441 return -EPERM;
1442 } else {
1443 printk(KERN_WARNING DRV_NAME
4e0952c7 1444 ": %s: Warning: enslaved VLAN challenged "
1da177e4
LT		 1445 "slave %s. Adding VLANs will be blocked as "
1446 "long as %s is part of bond %s\n",
4e0952c7 1447 bond_dev->name, slave_dev->name, slave_dev->name,
1da177e4
LT		 1448 bond_dev->name);
1449 bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
1450 }
1451 } else {
1452 dprintk("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
1453 if (bond->slave_cnt == 0) {
1454 /* First slave, and it is not VLAN challenged,
1455 * so remove the block of adding VLANs over the bond.
1456 */
1457 bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED;
1458 }
1459 }
1460
217df670
JV		 1461 /*
1462 * Old ifenslave binaries are no longer supported. These can
1463 * be identified with moderate accurary by the state of the slave:
1464 * the current ifenslave will set the interface down prior to
1465 * enslaving it; the old ifenslave will not.
1466 */
1467 if ((slave_dev->flags & IFF_UP)) {
1468 printk(KERN_ERR DRV_NAME ": %s is up. "
1469 "This may be due to an out of date ifenslave.\n",
1470 slave_dev->name);
1471 res = -EPERM;
1472 goto err_undo_flags;
1473 }
1da177e4 1474
872254dd
MS		 1475 /* set bonding device ether type by slave - bonding netdevices are
1476 * created with ether_setup, so when the slave type is not ARPHRD_ETHER
1477 * there is a need to override some of the type dependent attribs/funcs.
1478 *
1479 * bond ether type mutual exclusion - don't allow slaves of dissimilar
1480 * ether type (eg ARPHRD_ETHER and ARPHRD_INFINIBAND) share the same bond
1481 */
1482 if (bond->slave_cnt == 0) {
1483 if (slave_dev->type != ARPHRD_ETHER)
1484 bond_setup_by_slave(bond_dev, slave_dev);
1485 } else if (bond_dev->type != slave_dev->type) {
1486 printk(KERN_ERR DRV_NAME ": %s ether type (%d) is different "
1487 "from other slaves (%d), can not enslave it.\n",
1488 slave_dev->name,
1489 slave_dev->type, bond_dev->type);
1490 res = -EINVAL;
1491 goto err_undo_flags;
1492 }
1493
217df670 1494 if (slave_dev->set_mac_address == NULL) {
2ab82852
MS		 1495 if (bond->slave_cnt == 0) {
1496 printk(KERN_WARNING DRV_NAME
dd957c57
JV		 1497 ": %s: Warning: The first slave device "
1498 "specified does not support setting the MAC "
3915c1e8 1499 "address. Setting fail_over_mac to active.",
dd957c57 1500 bond_dev->name);
3915c1e8
JV		 1501 bond->params.fail_over_mac = BOND_FOM_ACTIVE;
1502 } else if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
2ab82852 1503 printk(KERN_ERR DRV_NAME
dd957c57
JV		 1504 ": %s: Error: The slave device specified "
1505 "does not support setting the MAC address, "
3915c1e8 1506 "but fail_over_mac is not set to active.\n"
2ab82852
MS		 1507 , bond_dev->name);
1508 res = -EOPNOTSUPP;
1509 goto err_undo_flags;
1510 }
1da177e4
LT		 1511 }
1512
243cb4e5 1513 new_slave = kzalloc(sizeof(struct slave), GFP_KERNEL);
1da177e4
LT		 1514 if (!new_slave) {
1515 res = -ENOMEM;
1516 goto err_undo_flags;
1517 }
1518
1da177e4
LT		 1519 /* save slave's original flags before calling
1520 * netdev_set_master and dev_open
1521 */
1522 new_slave->original_flags = slave_dev->flags;
1523
217df670
JV		 1524 /*
1525 * Save slave's original ("permanent") mac address for modes
1526 * that need it, and for restoring it upon release, and then
1527 * set it to the master's address
1528 */
1529 memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN);
1da177e4 1530
dd957c57 1531 if (!bond->params.fail_over_mac) {
2ab82852
MS		 1532 /*
1533 * Set slave to master's mac address. The application already
1534 * set the master's mac address to that of the first slave
1535 */
1536 memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
1537 addr.sa_family = slave_dev->type;
1538 res = dev_set_mac_address(slave_dev, &addr);
1539 if (res) {
1540 dprintk("Error %d calling set_mac_address\n", res);
1541 goto err_free;
1542 }
217df670 1543 }
1da177e4 1544
c2edacf8
JV		 1545 res = netdev_set_master(slave_dev, bond_dev);
1546 if (res) {
1547 dprintk("Error %d calling netdev_set_master\n", res);
569f0c4d 1548 goto err_restore_mac;
c2edacf8 1549 }
217df670
JV		 1550 /* open the slave since the application closed it */
1551 res = dev_open(slave_dev);
1552 if (res) {
1553 dprintk("Openning slave %s failed\n", slave_dev->name);
569f0c4d 1554 goto err_unset_master;
1da177e4
LT		 1555 }
1556
1da177e4 1557 new_slave->dev = slave_dev;
0b680e75 1558 slave_dev->priv_flags |= IFF_BONDING;
1da177e4
LT		 1559
1560 if ((bond->params.mode == BOND_MODE_TLB) ||
1561 (bond->params.mode == BOND_MODE_ALB)) {
1562 /* bond_alb_init_slave() must be called before all other stages since
1563 * it might fail and we do not want to have to undo everything
1564 */
1565 res = bond_alb_init_slave(bond, new_slave);
1566 if (res) {
569f0c4d 1567 goto err_close;
1da177e4
LT		 1568 }
1569 }
1570
1571 /* If the mode USES_PRIMARY, then the new slave gets the
1572 * master's promisc (and mc) settings only if it becomes the
1573 * curr_active_slave, and that is taken care of later when calling
1574 * bond_change_active()
1575 */
1576 if (!USES_PRIMARY(bond->params.mode)) {
1577 /* set promiscuity level to new slave */
1578 if (bond_dev->flags & IFF_PROMISC) {
7e1a1ac1
WC		 1579 res = dev_set_promiscuity(slave_dev, 1);
1580 if (res)
1581 goto err_close;
1da177e4
LT		 1582 }
1583
1584 /* set allmulti level to new slave */
1585 if (bond_dev->flags & IFF_ALLMULTI) {
7e1a1ac1
WC		 1586 res = dev_set_allmulti(slave_dev, 1);
1587 if (res)
1588 goto err_close;
1da177e4
LT		 1589 }
1590
b9e40857 1591 netif_addr_lock_bh(bond_dev);
1da177e4
LT		 1592 /* upload master's mc_list to new slave */
1593 for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
1594 dev_mc_add (slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
1595 }
b9e40857 1596 netif_addr_unlock_bh(bond_dev);
1da177e4
LT		 1597 }
1598
1599 if (bond->params.mode == BOND_MODE_8023AD) {
1600 /* add lacpdu mc addr to mc list */
1601 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
1602
1603 dev_mc_add(slave_dev, lacpdu_multicast, ETH_ALEN, 0);
1604 }
1605
1606 bond_add_vlans_on_slave(bond, slave_dev);
1607
1608 write_lock_bh(&bond->lock);
1609
1610 bond_attach_slave(bond, new_slave);
1611
1612 new_slave->delay = 0;
1613 new_slave->link_failure_count = 0;
1614
8531c5ff
AK		 1615 bond_compute_features(bond);
1616
3915c1e8
JV		 1617 write_unlock_bh(&bond->lock);
1618
1619 read_lock(&bond->lock);
1620
f5b2b966
JV		 1621 new_slave->last_arp_rx = jiffies;
1622
1da177e4
LT		 1623 if (bond->params.miimon && !bond->params.use_carrier) {
1624 link_reporting = bond_check_dev_link(bond, slave_dev, 1);
1625
1626 if ((link_reporting == -1) && !bond->params.arp_interval) {
1627 /*
1628 * miimon is set but a bonded network driver
1629 * does not support ETHTOOL/MII and
1630 * arp_interval is not set. Note: if
1631 * use_carrier is enabled, we will never go
1632 * here (because netif_carrier is always
1633 * supported); thus, we don't need to change
1634 * the messages for netif_carrier.
1635 */
1636 printk(KERN_WARNING DRV_NAME
4e0952c7 1637 ": %s: Warning: MII and ETHTOOL support not "
1da177e4
LT		 1638 "available for interface %s, and "
1639 "arp_interval/arp_ip_target module parameters "
1640 "not specified, thus bonding will not detect "
1641 "link failures! see bonding.txt for details.\n",
4e0952c7 1642 bond_dev->name, slave_dev->name);
1da177e4
LT		 1643 } else if (link_reporting == -1) {
1644 /* unable get link status using mii/ethtool */
1645 printk(KERN_WARNING DRV_NAME
4e0952c7 1646 ": %s: Warning: can't get link status from "
1da177e4
LT		 1647 "interface %s; the network driver associated "
1648 "with this interface does not support MII or "
1649 "ETHTOOL link status reporting, thus miimon "
1650 "has no effect on this interface.\n",
4e0952c7 1651 bond_dev->name, slave_dev->name);
1da177e4
LT		 1652 }
1653 }
1654
1655 /* check for initial state */
1656 if (!bond->params.miimon ||
1657 (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS)) {
1658 if (bond->params.updelay) {
1659 dprintk("Initial state of slave_dev is "
1660 "BOND_LINK_BACK\n");
1661 new_slave->link = BOND_LINK_BACK;
1662 new_slave->delay = bond->params.updelay;
1663 } else {
1664 dprintk("Initial state of slave_dev is "
1665 "BOND_LINK_UP\n");
1666 new_slave->link = BOND_LINK_UP;
1667 }
1668 new_slave->jiffies = jiffies;
1669 } else {
1670 dprintk("Initial state of slave_dev is "
1671 "BOND_LINK_DOWN\n");
1672 new_slave->link = BOND_LINK_DOWN;
1673 }
1674
1675 if (bond_update_speed_duplex(new_slave) &&
1676 (new_slave->link != BOND_LINK_DOWN)) {
1677 printk(KERN_WARNING DRV_NAME
4e0952c7 1678 ": %s: Warning: failed to get speed and duplex from %s, "
1da177e4 1679 "assumed to be 100Mb/sec and Full.\n",
4e0952c7 1680 bond_dev->name, new_slave->dev->name);
1da177e4
LT		 1681
1682 if (bond->params.mode == BOND_MODE_8023AD) {
4e0952c7
MW		 1683 printk(KERN_WARNING DRV_NAME
1684 ": %s: Warning: Operation of 802.3ad mode requires ETHTOOL "
1da177e4 1685 "support in base driver for proper aggregator "
4e0952c7 1686 "selection.\n", bond_dev->name);
1da177e4
LT		 1687 }
1688 }
1689
1690 if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
1691 /* if there is a primary slave, remember it */
1692 if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
1693 bond->primary_slave = new_slave;
1694 }
1695 }
1696
3915c1e8
JV		 1697 write_lock_bh(&bond->curr_slave_lock);
1698
1da177e4
LT		 1699 switch (bond->params.mode) {
1700 case BOND_MODE_ACTIVEBACKUP:
8a8e447b
JV		 1701 bond_set_slave_inactive_flags(new_slave);
1702 bond_select_active_slave(bond);
1da177e4
LT		 1703 break;
1704 case BOND_MODE_8023AD:
1705 /* in 802.3ad mode, the internal mechanism
1706 * will activate the slaves in the selected
1707 * aggregator
1708 */
1709 bond_set_slave_inactive_flags(new_slave);
1710 /* if this is the first slave */
1711 if (bond->slave_cnt == 1) {
1712 SLAVE_AD_INFO(new_slave).id = 1;
1713 /* Initialize AD with the number of times that the AD timer is called in 1 second
1714 * can be called only after the mac address of the bond is set
1715 */
1716 bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL,
1717 bond->params.lacp_fast);
1718 } else {
1719 SLAVE_AD_INFO(new_slave).id =
1720 SLAVE_AD_INFO(new_slave->prev).id + 1;
1721 }
1722
1723 bond_3ad_bind_slave(new_slave);
1724 break;
1725 case BOND_MODE_TLB:
1726 case BOND_MODE_ALB:
1727 new_slave->state = BOND_STATE_ACTIVE;
059fe7a5 1728 bond_set_slave_inactive_flags(new_slave);
1da177e4
LT		 1729 break;
1730 default:
1731 dprintk("This slave is always active in trunk mode\n");
1732
1733 /* always active in trunk mode */
1734 new_slave->state = BOND_STATE_ACTIVE;
1735
1736 /* In trunking mode there is little meaning to curr_active_slave
1737 * anyway (it holds no special properties of the bond device),
1738 * so we can change it without calling change_active_interface()
1739 */
1740 if (!bond->curr_active_slave) {
1741 bond->curr_active_slave = new_slave;
1742 }
1743 break;
1744 } /* switch(bond_mode) */
1745
3915c1e8
JV		 1746 write_unlock_bh(&bond->curr_slave_lock);
1747
ff59c456
JV		 1748 bond_set_carrier(bond);
1749
3915c1e8 1750 read_unlock(&bond->lock);
1da177e4 1751
b76cdba9
MW		 1752 res = bond_create_slave_symlinks(bond_dev, slave_dev);
1753 if (res)
569f0c4d 1754 goto err_close;
b76cdba9 1755
1da177e4
LT		 1756 printk(KERN_INFO DRV_NAME
1757 ": %s: enslaving %s as a%s interface with a%s link.\n",
1758 bond_dev->name, slave_dev->name,
1759 new_slave->state == BOND_STATE_ACTIVE ? "n active" : " backup",
1760 new_slave->link != BOND_LINK_DOWN ? "n up" : " down");
1761
1762 /* enslave is successful */
1763 return 0;
1764
1765/* Undo stages on error */
1da177e4
LT		 1766err_close:
1767 dev_close(slave_dev);
1768
569f0c4d
JV		 1769err_unset_master:
1770 netdev_set_master(slave_dev, NULL);
1771
1da177e4 1772err_restore_mac:
dd957c57 1773 if (!bond->params.fail_over_mac) {
3915c1e8
JV		 1774 /* XXX TODO - fom follow mode needs to change master's
1775 * MAC if this slave's MAC is in use by the bond, or at
1776 * least print a warning.
1777 */
2ab82852
MS		 1778 memcpy(addr.sa_data, new_slave->perm_hwaddr, ETH_ALEN);
1779 addr.sa_family = slave_dev->type;
1780 dev_set_mac_address(slave_dev, &addr);
1781 }
1da177e4
LT		 1782
1783err_free:
1784 kfree(new_slave);
1785
1786err_undo_flags:
1787 bond_dev->features = old_features;
8531c5ff 1788
1da177e4
LT		 1789 return res;
1790}
1791
1792/*
1793 * Try to release the slave device <slave> from the bond device <master>
1794 * It is legal to access curr_active_slave without a lock because all the function
1795 * is write-locked.
1796 *
1797 * The rules for slave state should be:
1798 * for Active/Backup:
1799 * Active stays on all backups go down
1800 * for Bonded connections:
1801 * The first up interface should be left on and all others downed.
1802 */
a77b5325 1803int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
1da177e4 1804{
454d7c9b 1805 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 1806 struct slave *slave, *oldcurrent;
1807 struct sockaddr addr;
1808 int mac_addr_differ;
1809
1810 /* slave is not a slave or master is not master of this slave */
1811 if (!(slave_dev->flags & IFF_SLAVE) ||
1812 (slave_dev->master != bond_dev)) {
1813 printk(KERN_ERR DRV_NAME
4e0952c7 1814 ": %s: Error: cannot release %s.\n",
1da177e4
LT		 1815 bond_dev->name, slave_dev->name);
1816 return -EINVAL;
1817 }
1818
1819 write_lock_bh(&bond->lock);
1820
1821 slave = bond_get_slave_by_dev(bond, slave_dev);
1822 if (!slave) {
1823 /* not a slave of this bond */
1824 printk(KERN_INFO DRV_NAME
1825 ": %s: %s not enslaved\n",
1826 bond_dev->name, slave_dev->name);
f5e2a7b2 1827 write_unlock_bh(&bond->lock);
1da177e4
LT		 1828 return -EINVAL;
1829 }
1830
3915c1e8
JV		 1831 if (!bond->params.fail_over_mac) {
1832 mac_addr_differ = memcmp(bond_dev->dev_addr, slave->perm_hwaddr,
1833 ETH_ALEN);
1834 if (!mac_addr_differ && (bond->slave_cnt > 1))
1835 printk(KERN_WARNING DRV_NAME
1836 ": %s: Warning: the permanent HWaddr of %s - "
e174961c 1837 "%pM - is still in use by %s. "
3915c1e8
JV		 1838 "Set the HWaddr of %s to a different address "
1839 "to avoid conflicts.\n",
1840 bond_dev->name, slave_dev->name,
e174961c 1841 slave->perm_hwaddr,
3915c1e8 1842 bond_dev->name, slave_dev->name);
1da177e4
LT		 1843 }
1844
1845 /* Inform AD package of unbinding of slave. */
1846 if (bond->params.mode == BOND_MODE_8023AD) {
1847 /* must be called before the slave is
1848 * detached from the list
1849 */
1850 bond_3ad_unbind_slave(slave);
1851 }
1852
1853 printk(KERN_INFO DRV_NAME
1854 ": %s: releasing %s interface %s\n",
1855 bond_dev->name,
1856 (slave->state == BOND_STATE_ACTIVE)
1857 ? "active" : "backup",
1858 slave_dev->name);
1859
1860 oldcurrent = bond->curr_active_slave;
1861
1862 bond->current_arp_slave = NULL;
1863
1864 /* release the slave from its bond */
1865 bond_detach_slave(bond, slave);
1866
8531c5ff
AK		 1867 bond_compute_features(bond);
1868
1da177e4
LT		 1869 if (bond->primary_slave == slave) {
1870 bond->primary_slave = NULL;
1871 }
1872
1873 if (oldcurrent == slave) {
1874 bond_change_active_slave(bond, NULL);
1875 }
1876
1877 if ((bond->params.mode == BOND_MODE_TLB) ||
1878 (bond->params.mode == BOND_MODE_ALB)) {
1879 /* Must be called only after the slave has been
1880 * detached from the list and the curr_active_slave
1881 * has been cleared (if our_slave == old_current),
1882 * but before a new active slave is selected.
1883 */
2543331d 1884 write_unlock_bh(&bond->lock);
1da177e4 1885 bond_alb_deinit_slave(bond, slave);
2543331d 1886 write_lock_bh(&bond->lock);
1da177e4
LT		 1887 }
1888
059fe7a5
JV		 1889 if (oldcurrent == slave) {
1890 /*
1891 * Note that we hold RTNL over this sequence, so there
1892 * is no concern that another slave add/remove event
1893 * will interfere.
1894 */
1895 write_unlock_bh(&bond->lock);
1896 read_lock(&bond->lock);
1897 write_lock_bh(&bond->curr_slave_lock);
1898
1da177e4
LT		 1899 bond_select_active_slave(bond);
1900
059fe7a5
JV		 1901 write_unlock_bh(&bond->curr_slave_lock);
1902 read_unlock(&bond->lock);
1903 write_lock_bh(&bond->lock);
1904 }
1905
1da177e4 1906 if (bond->slave_cnt == 0) {
ff59c456
JV		 1907 bond_set_carrier(bond);
1908
1da177e4
LT		 1909 /* if the last slave was removed, zero the mac address
1910 * of the master so it will be set by the application
1911 * to the mac address of the first slave
1912 */
1913 memset(bond_dev->dev_addr, 0, bond_dev->addr_len);
1914
1915 if (list_empty(&bond->vlan_list)) {
1916 bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
1917 } else {
1918 printk(KERN_WARNING DRV_NAME
4e0952c7 1919 ": %s: Warning: clearing HW address of %s while it "
1da177e4 1920 "still has VLANs.\n",
4e0952c7 1921 bond_dev->name, bond_dev->name);
1da177e4 1922 printk(KERN_WARNING DRV_NAME
4e0952c7
MW		 1923 ": %s: When re-adding slaves, make sure the bond's "
1924 "HW address matches its VLANs'.\n",
1925 bond_dev->name);
1da177e4
LT		 1926 }
1927 } else if ((bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
1928 !bond_has_challenged_slaves(bond)) {
1929 printk(KERN_INFO DRV_NAME
4e0952c7 1930 ": %s: last VLAN challenged slave %s "
1da177e4 1931 "left bond %s. VLAN blocking is removed\n",
4e0952c7 1932 bond_dev->name, slave_dev->name, bond_dev->name);
1da177e4
LT		 1933 bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED;
1934 }
1935
1936 write_unlock_bh(&bond->lock);
1937
b76cdba9
MW		 1938 /* must do this from outside any spinlocks */
1939 bond_destroy_slave_symlinks(bond_dev, slave_dev);
1940
1da177e4
LT		 1941 bond_del_vlans_from_slave(bond, slave_dev);
1942
1943 /* If the mode USES_PRIMARY, then we should only remove its
1944 * promisc and mc settings if it was the curr_active_slave, but that was
1945 * already taken care of above when we detached the slave
1946 */
1947 if (!USES_PRIMARY(bond->params.mode)) {
1948 /* unset promiscuity level from slave */
1949 if (bond_dev->flags & IFF_PROMISC) {
1950 dev_set_promiscuity(slave_dev, -1);
1951 }
1952
1953 /* unset allmulti level from slave */
1954 if (bond_dev->flags & IFF_ALLMULTI) {
1955 dev_set_allmulti(slave_dev, -1);
1956 }
1957
1958 /* flush master's mc_list from slave */
b9e40857 1959 netif_addr_lock_bh(bond_dev);
1da177e4 1960 bond_mc_list_flush(bond_dev, slave_dev);
b9e40857 1961 netif_addr_unlock_bh(bond_dev);
1da177e4
LT		 1962 }
1963
1964 netdev_set_master(slave_dev, NULL);
1965
1966 /* close slave before restoring its mac address */
1967 dev_close(slave_dev);
1968
3915c1e8 1969 if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) {
2ab82852
MS		 1970 /* restore original ("permanent") mac address */
1971 memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
1972 addr.sa_family = slave_dev->type;
1973 dev_set_mac_address(slave_dev, &addr);
1974 }
1da177e4 1975
8f903c70 1976 slave_dev->priv_flags &= ~(IFF_MASTER_8023AD | IFF_MASTER_ALB |
f5b2b966
JV		 1977 IFF_SLAVE_INACTIVE | IFF_BONDING |
1978 IFF_SLAVE_NEEDARP);
1da177e4
LT		 1979
1980 kfree(slave);
1981
1982 return 0; /* deletion OK */
1983}
1984
d90a162a
MS		 1985/*
1986* Destroy a bonding device.
1987* Must be under rtnl_lock when this function is called.
1988*/
1989void bond_destroy(struct bonding *bond)
1990{
1991 bond_deinit(bond->dev);
1992 bond_destroy_sysfs_entry(bond);
8cbdeec6 1993 unregister_netdevice(bond->dev);
d90a162a
MS		 1994}
1995
a434e43f
JV		 1996static void bond_destructor(struct net_device *bond_dev)
1997{
1998 struct bonding *bond = bond_dev->priv;
1999
2000 if (bond->wq)
2001 destroy_workqueue(bond->wq);
2002
2003 netif_addr_lock_bh(bond_dev);
2004 bond_mc_list_destroy(bond);
2005 netif_addr_unlock_bh(bond_dev);
2006
2007 free_netdev(bond_dev);
2008}
2009
d90a162a
MS		 2010/*
2011* First release a slave and than destroy the bond if no more slaves iare left.
2012* Must be under rtnl_lock when this function is called.
2013*/
2014int bond_release_and_destroy(struct net_device *bond_dev, struct net_device *slave_dev)
2015{
454d7c9b 2016 struct bonding *bond = netdev_priv(bond_dev);
d90a162a
MS		 2017 int ret;
2018
2019 ret = bond_release(bond_dev, slave_dev);
2020 if ((ret == 0) && (bond->slave_cnt == 0)) {
2021 printk(KERN_INFO DRV_NAME ": %s: destroying bond %s.\n",
2022 bond_dev->name, bond_dev->name);
2023 bond_destroy(bond);
2024 }
2025 return ret;
2026}
2027
1da177e4
LT		 2028/*
2029 * This function releases all slaves.
2030 */
2031static int bond_release_all(struct net_device *bond_dev)
2032{
454d7c9b 2033 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 2034 struct slave *slave;
2035 struct net_device *slave_dev;
2036 struct sockaddr addr;
2037
2038 write_lock_bh(&bond->lock);
2039
ff59c456
JV		 2040 netif_carrier_off(bond_dev);
2041
1da177e4
LT		 2042 if (bond->slave_cnt == 0) {
2043 goto out;
2044 }
2045
2046 bond->current_arp_slave = NULL;
2047 bond->primary_slave = NULL;
2048 bond_change_active_slave(bond, NULL);
2049
2050 while ((slave = bond->first_slave) != NULL) {
2051 /* Inform AD package of unbinding of slave
2052 * before slave is detached from the list.
2053 */
2054 if (bond->params.mode == BOND_MODE_8023AD) {
2055 bond_3ad_unbind_slave(slave);
2056 }
2057
2058 slave_dev = slave->dev;
2059 bond_detach_slave(bond, slave);
2060
2543331d
JV		 2061 /* now that the slave is detached, unlock and perform
2062 * all the undo steps that should not be called from
2063 * within a lock.
2064 */
2065 write_unlock_bh(&bond->lock);
2066
1da177e4
LT		 2067 if ((bond->params.mode == BOND_MODE_TLB) ||
2068 (bond->params.mode == BOND_MODE_ALB)) {
2069 /* must be called only after the slave
2070 * has been detached from the list
2071 */
2072 bond_alb_deinit_slave(bond, slave);
2073 }
2074
8531c5ff
AK		 2075 bond_compute_features(bond);
2076
b76cdba9 2077 bond_destroy_slave_symlinks(bond_dev, slave_dev);
1da177e4
LT		 2078 bond_del_vlans_from_slave(bond, slave_dev);
2079
2080 /* If the mode USES_PRIMARY, then we should only remove its
2081 * promisc and mc settings if it was the curr_active_slave, but that was
2082 * already taken care of above when we detached the slave
2083 */
2084 if (!USES_PRIMARY(bond->params.mode)) {
2085 /* unset promiscuity level from slave */
2086 if (bond_dev->flags & IFF_PROMISC) {
2087 dev_set_promiscuity(slave_dev, -1);
2088 }
2089
2090 /* unset allmulti level from slave */
2091 if (bond_dev->flags & IFF_ALLMULTI) {
2092 dev_set_allmulti(slave_dev, -1);
2093 }
2094
2095 /* flush master's mc_list from slave */
b9e40857 2096 netif_addr_lock_bh(bond_dev);
1da177e4 2097 bond_mc_list_flush(bond_dev, slave_dev);
b9e40857 2098 netif_addr_unlock_bh(bond_dev);
1da177e4
LT		 2099 }
2100
2101 netdev_set_master(slave_dev, NULL);
2102
2103 /* close slave before restoring its mac address */
2104 dev_close(slave_dev);
2105
dd957c57 2106 if (!bond->params.fail_over_mac) {
2ab82852
MS		 2107 /* restore original ("permanent") mac address*/
2108 memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
2109 addr.sa_family = slave_dev->type;
2110 dev_set_mac_address(slave_dev, &addr);
2111 }
1da177e4 2112
8f903c70
JV		 2113 slave_dev->priv_flags &= ~(IFF_MASTER_8023AD | IFF_MASTER_ALB |
2114 IFF_SLAVE_INACTIVE);
1da177e4
LT		 2115
2116 kfree(slave);
2117
2118 /* re-acquire the lock before getting the next slave */
2119 write_lock_bh(&bond->lock);
2120 }
2121
2122 /* zero the mac address of the master so it will be
2123 * set by the application to the mac address of the
2124 * first slave
2125 */
2126 memset(bond_dev->dev_addr, 0, bond_dev->addr_len);
2127
2128 if (list_empty(&bond->vlan_list)) {
2129 bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
2130 } else {
2131 printk(KERN_WARNING DRV_NAME
4e0952c7 2132 ": %s: Warning: clearing HW address of %s while it "
1da177e4 2133 "still has VLANs.\n",
4e0952c7 2134 bond_dev->name, bond_dev->name);
1da177e4 2135 printk(KERN_WARNING DRV_NAME
4e0952c7
MW		 2136 ": %s: When re-adding slaves, make sure the bond's "
2137 "HW address matches its VLANs'.\n",
2138 bond_dev->name);
1da177e4
LT		 2139 }
2140
2141 printk(KERN_INFO DRV_NAME
2142 ": %s: released all slaves\n",
2143 bond_dev->name);
2144
2145out:
2146 write_unlock_bh(&bond->lock);
2147
2148 return 0;
2149}
2150
2151/*
2152 * This function changes the active slave to slave <slave_dev>.
2153 * It returns -EINVAL in the following cases.
2154 * - <slave_dev> is not found in the list.
2155 * - There is not active slave now.
2156 * - <slave_dev> is already active.
2157 * - The link state of <slave_dev> is not BOND_LINK_UP.
2158 * - <slave_dev> is not running.
2159 * In these cases, this fuction does nothing.
2160 * In the other cases, currnt_slave pointer is changed and 0 is returned.
2161 */
2162static int bond_ioctl_change_active(struct net_device *bond_dev, struct net_device *slave_dev)
2163{
454d7c9b 2164 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 2165 struct slave *old_active = NULL;
2166 struct slave *new_active = NULL;
2167 int res = 0;
2168
2169 if (!USES_PRIMARY(bond->params.mode)) {
2170 return -EINVAL;
2171 }
2172
2173 /* Verify that master_dev is indeed the master of slave_dev */
2174 if (!(slave_dev->flags & IFF_SLAVE) ||
2175 (slave_dev->master != bond_dev)) {
2176 return -EINVAL;
2177 }
2178
059fe7a5 2179 read_lock(&bond->lock);
1da177e4 2180
059fe7a5 2181 read_lock(&bond->curr_slave_lock);
1da177e4 2182 old_active = bond->curr_active_slave;
059fe7a5
JV		 2183 read_unlock(&bond->curr_slave_lock);
2184
1da177e4
LT		 2185 new_active = bond_get_slave_by_dev(bond, slave_dev);
2186
2187 /*
2188 * Changing to the current active: do nothing; return success.
2189 */
2190 if (new_active && (new_active == old_active)) {
059fe7a5 2191 read_unlock(&bond->lock);
1da177e4
LT		 2192 return 0;
2193 }
2194
2195 if ((new_active) &&
2196 (old_active) &&
2197 (new_active->link == BOND_LINK_UP) &&
2198 IS_UP(new_active->dev)) {
059fe7a5 2199 write_lock_bh(&bond->curr_slave_lock);
1da177e4 2200 bond_change_active_slave(bond, new_active);
059fe7a5 2201 write_unlock_bh(&bond->curr_slave_lock);
1da177e4
LT		 2202 } else {
2203 res = -EINVAL;
2204 }
2205
059fe7a5 2206 read_unlock(&bond->lock);
1da177e4
LT		 2207
2208 return res;
2209}
2210
1da177e4
LT		 2211static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
2212{
454d7c9b 2213 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 2214
2215 info->bond_mode = bond->params.mode;
2216 info->miimon = bond->params.miimon;
2217
6603a6f2 2218 read_lock(&bond->lock);
1da177e4 2219 info->num_slaves = bond->slave_cnt;
6603a6f2 2220 read_unlock(&bond->lock);
1da177e4
LT		 2221
2222 return 0;
2223}
2224
2225static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info)
2226{
454d7c9b 2227 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 2228 struct slave *slave;
2229 int i, found = 0;
2230
2231 if (info->slave_id < 0) {
2232 return -ENODEV;
2233 }
2234
6603a6f2 2235 read_lock(&bond->lock);
1da177e4
LT		 2236
2237 bond_for_each_slave(bond, slave, i) {
2238 if (i == (int)info->slave_id) {
2239 found = 1;
2240 break;
2241 }
2242 }
2243
6603a6f2 2244 read_unlock(&bond->lock);
1da177e4
LT		 2245
2246 if (found) {
2247 strcpy(info->slave_name, slave->dev->name);
2248 info->link = slave->link;
2249 info->state = slave->state;
2250 info->link_failure_count = slave->link_failure_count;
2251 } else {
2252 return -ENODEV;
2253 }
2254
2255 return 0;
2256}
2257
2258/*-------------------------------- Monitoring -------------------------------*/
2259
1da177e4 2260
f0c76d61
JV		 2261static int bond_miimon_inspect(struct bonding *bond)
2262{
2263 struct slave *slave;
2264 int i, link_state, commit = 0;
1da177e4
LT		 2265
2266 bond_for_each_slave(bond, slave, i) {
f0c76d61 2267 slave->new_link = BOND_LINK_NOCHANGE;
1da177e4 2268
f0c76d61 2269 link_state = bond_check_dev_link(bond, slave->dev, 0);
1da177e4
LT		 2270
2271 switch (slave->link) {
f0c76d61
JV		 2272 case BOND_LINK_UP:
2273 if (link_state)
2274 continue;
1da177e4 2275
f0c76d61
JV		 2276 slave->link = BOND_LINK_FAIL;
2277 slave->delay = bond->params.downdelay;
2278 if (slave->delay) {
2279 printk(KERN_INFO DRV_NAME
2280 ": %s: link status down for %s"
2281 "interface %s, disabling it in %d ms.\n",
2282 bond->dev->name,
2283 (bond->params.mode ==
2284 BOND_MODE_ACTIVEBACKUP) ?
2285 ((slave->state == BOND_STATE_ACTIVE) ?
2286 "active " : "backup ") : "",
2287 slave->dev->name,
2288 bond->params.downdelay * bond->params.miimon);
1da177e4 2289 }
f0c76d61
JV		 2290 /*FALLTHRU*/
2291 case BOND_LINK_FAIL:
2292 if (link_state) {
2293 /*
2294 * recovered before downdelay expired
2295 */
2296 slave->link = BOND_LINK_UP;
1da177e4
LT		 2297 slave->jiffies = jiffies;
2298 printk(KERN_INFO DRV_NAME
2299 ": %s: link status up again after %d "
2300 "ms for interface %s.\n",
1b76b316 2301 bond->dev->name,
f0c76d61
JV		 2302 (bond->params.downdelay - slave->delay) *
2303 bond->params.miimon,
2304 slave->dev->name);
2305 continue;
1da177e4 2306 }
f0c76d61
JV		 2307
2308 if (slave->delay <= 0) {
2309 slave->new_link = BOND_LINK_DOWN;
2310 commit++;
2311 continue;
1da177e4 2312 }
1da177e4 2313
f0c76d61
JV		 2314 slave->delay--;
2315 break;
2316
2317 case BOND_LINK_DOWN:
2318 if (!link_state)
2319 continue;
2320
2321 slave->link = BOND_LINK_BACK;
2322 slave->delay = bond->params.updelay;
2323
2324 if (slave->delay) {
2325 printk(KERN_INFO DRV_NAME
2326 ": %s: link status up for "
2327 "interface %s, enabling it in %d ms.\n",
2328 bond->dev->name, slave->dev->name,
2329 bond->params.updelay *
2330 bond->params.miimon);
2331 }
2332 /*FALLTHRU*/
2333 case BOND_LINK_BACK:
2334 if (!link_state) {
2335 slave->link = BOND_LINK_DOWN;
1da177e4
LT		 2336 printk(KERN_INFO DRV_NAME
2337 ": %s: link status down again after %d "
2338 "ms for interface %s.\n",
1b76b316 2339 bond->dev->name,
f0c76d61
JV		 2340 (bond->params.updelay - slave->delay) *
2341 bond->params.miimon,
2342 slave->dev->name);
2343
2344 continue;
2345 }
2346
2347 if (slave->delay <= 0) {
2348 slave->new_link = BOND_LINK_UP;
2349 commit++;
2350 continue;
1da177e4 2351 }
f0c76d61
JV		 2352
2353 slave->delay--;
1da177e4 2354 break;
f0c76d61
JV		 2355 }
2356 }
1da177e4 2357
f0c76d61
JV		 2358 return commit;
2359}
1da177e4 2360
f0c76d61
JV		 2361static void bond_miimon_commit(struct bonding *bond)
2362{
2363 struct slave *slave;
2364 int i;
2365
2366 bond_for_each_slave(bond, slave, i) {
2367 switch (slave->new_link) {
2368 case BOND_LINK_NOCHANGE:
2369 continue;
1da177e4 2370
f0c76d61
JV		 2371 case BOND_LINK_UP:
2372 slave->link = BOND_LINK_UP;
2373 slave->jiffies = jiffies;
2374
2375 if (bond->params.mode == BOND_MODE_8023AD) {
2376 /* prevent it from being the active one */
2377 slave->state = BOND_STATE_BACKUP;
2378 } else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
2379 /* make it immediately active */
2380 slave->state = BOND_STATE_ACTIVE;
2381 } else if (slave != bond->primary_slave) {
2382 /* prevent it from being the active one */
2383 slave->state = BOND_STATE_BACKUP;
1da177e4 2384 }
1da177e4 2385
f0c76d61
JV		 2386 printk(KERN_INFO DRV_NAME
2387 ": %s: link status definitely "
2388 "up for interface %s.\n",
2389 bond->dev->name, slave->dev->name);
1da177e4 2390
f0c76d61
JV		 2391 /* notify ad that the link status has changed */
2392 if (bond->params.mode == BOND_MODE_8023AD)
2393 bond_3ad_handle_link_change(slave, BOND_LINK_UP);
059fe7a5 2394
f0c76d61
JV		 2395 if ((bond->params.mode == BOND_MODE_TLB) ||
2396 (bond->params.mode == BOND_MODE_ALB))
2397 bond_alb_handle_link_change(bond, slave,
2398 BOND_LINK_UP);
1da177e4 2399
f0c76d61
JV		 2400 if (!bond->curr_active_slave ||
2401 (slave == bond->primary_slave))
2402 goto do_failover;
1da177e4 2403
f0c76d61 2404 continue;
059fe7a5 2405
f0c76d61 2406 case BOND_LINK_DOWN:
fba4acda
JV		 2407 if (slave->link_failure_count < UINT_MAX)
2408 slave->link_failure_count++;
2409
f0c76d61 2410 slave->link = BOND_LINK_DOWN;
1da177e4 2411
f0c76d61
JV		 2412 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP ||
2413 bond->params.mode == BOND_MODE_8023AD)
2414 bond_set_slave_inactive_flags(slave);
2415
2416 printk(KERN_INFO DRV_NAME
2417 ": %s: link status definitely down for "
2418 "interface %s, disabling it\n",
2419 bond->dev->name, slave->dev->name);
2420
2421 if (bond->params.mode == BOND_MODE_8023AD)
2422 bond_3ad_handle_link_change(slave,
2423 BOND_LINK_DOWN);
2424
2425 if (bond->params.mode == BOND_MODE_TLB ||
2426 bond->params.mode == BOND_MODE_ALB)
2427 bond_alb_handle_link_change(bond, slave,
2428 BOND_LINK_DOWN);
2429
2430 if (slave == bond->curr_active_slave)
2431 goto do_failover;
2432
2433 continue;
2434
2435 default:
2436 printk(KERN_ERR DRV_NAME
2437 ": %s: invalid new link %d on slave %s\n",
2438 bond->dev->name, slave->new_link,
2439 slave->dev->name);
2440 slave->new_link = BOND_LINK_NOCHANGE;
2441
2442 continue;
2443 }
2444
2445do_failover:
2446 ASSERT_RTNL();
2447 write_lock_bh(&bond->curr_slave_lock);
2448 bond_select_active_slave(bond);
2449 write_unlock_bh(&bond->curr_slave_lock);
2450 }
2451
2452 bond_set_carrier(bond);
1da177e4
LT		 2453}
2454
0b0eef66
JV		 2455/*
2456 * bond_mii_monitor
2457 *
2458 * Really a wrapper that splits the mii monitor into two phases: an
f0c76d61
JV		 2459 * inspection, then (if inspection indicates something needs to be done)
2460 * an acquisition of appropriate locks followed by a commit phase to
2461 * implement whatever link state changes are indicated.
0b0eef66
JV		 2462 */
2463void bond_mii_monitor(struct work_struct *work)
2464{
2465 struct bonding *bond = container_of(work, struct bonding,
2466 mii_work.work);
0b0eef66
JV		 2467
2468 read_lock(&bond->lock);
f0c76d61
JV		 2469 if (bond->kill_timers)
2470 goto out;
2471
2472 if (bond->slave_cnt == 0)
2473 goto re_arm;
b59f9f74
JV		 2474
2475 if (bond->send_grat_arp) {
2476 read_lock(&bond->curr_slave_lock);
2477 bond_send_gratuitous_arp(bond);
2478 read_unlock(&bond->curr_slave_lock);
2479 }
2480
305d552a
BH		 2481 if (bond->send_unsol_na) {
2482 read_lock(&bond->curr_slave_lock);
2483 bond_send_unsolicited_na(bond);
2484 read_unlock(&bond->curr_slave_lock);
2485 }
2486
f0c76d61 2487 if (bond_miimon_inspect(bond)) {
0b0eef66
JV		 2488 read_unlock(&bond->lock);
2489 rtnl_lock();
2490 read_lock(&bond->lock);
f0c76d61
JV		 2491
2492 bond_miimon_commit(bond);
2493
5655662d
JV		 2494 read_unlock(&bond->lock);
2495 rtnl_unlock(); /* might sleep, hold no other locks */
2496 read_lock(&bond->lock);
0b0eef66
JV		 2497 }
2498
f0c76d61
JV		 2499re_arm:
2500 if (bond->params.miimon)
2501 queue_delayed_work(bond->wq, &bond->mii_work,
2502 msecs_to_jiffies(bond->params.miimon));
2503out:
0b0eef66 2504 read_unlock(&bond->lock);
0b0eef66 2505}
c3ade5ca 2506
d3bb52b0 2507static __be32 bond_glean_dev_ip(struct net_device *dev)
c3ade5ca
JV		 2508{
2509 struct in_device *idev;
2510 struct in_ifaddr *ifa;
a144ea4b 2511 __be32 addr = 0;
c3ade5ca
JV		 2512
2513 if (!dev)
2514 return 0;
2515
2516 rcu_read_lock();
e5ed6399 2517 idev = __in_dev_get_rcu(dev);
c3ade5ca
JV		 2518 if (!idev)
2519 goto out;
2520
2521 ifa = idev->ifa_list;
2522 if (!ifa)
2523 goto out;
2524
2525 addr = ifa->ifa_local;
2526out:
2527 rcu_read_unlock();
2528 return addr;
2529}
2530
d3bb52b0 2531static int bond_has_this_ip(struct bonding *bond, __be32 ip)
f5b2b966 2532{
0883beca 2533 struct vlan_entry *vlan;
f5b2b966
JV		 2534
2535 if (ip == bond->master_ip)
2536 return 1;
2537
0883beca 2538 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
f5b2b966
JV		 2539 if (ip == vlan->vlan_ip)
2540 return 1;
2541 }
2542
2543 return 0;
2544}
2545
c3ade5ca
JV		 2546/*
2547 * We go to the (large) trouble of VLAN tagging ARP frames because
2548 * switches in VLAN mode (especially if ports are configured as
2549 * "native" to a VLAN) might not pass non-tagged frames.
2550 */
d3bb52b0 2551static void bond_arp_send(struct net_device *slave_dev, int arp_op, __be32 dest_ip, __be32 src_ip, unsigned short vlan_id)
c3ade5ca
JV		 2552{
2553 struct sk_buff *skb;
2554
2555 dprintk("arp %d on slave %s: dst %x src %x vid %d\n", arp_op,
2556 slave_dev->name, dest_ip, src_ip, vlan_id);
2557
2558 skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip,
2559 NULL, slave_dev->dev_addr, NULL);
2560
2561 if (!skb) {
2562 printk(KERN_ERR DRV_NAME ": ARP packet allocation failed\n");
2563 return;
2564 }
2565 if (vlan_id) {
2566 skb = vlan_put_tag(skb, vlan_id);
2567 if (!skb) {
2568 printk(KERN_ERR DRV_NAME ": failed to insert VLAN tag\n");
2569 return;
2570 }
2571 }
2572 arp_xmit(skb);
2573}
2574
2575
1da177e4
LT		 2576static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
2577{
c3ade5ca 2578 int i, vlan_id, rv;
d3bb52b0 2579 __be32 *targets = bond->params.arp_targets;
0883beca 2580 struct vlan_entry *vlan;
c3ade5ca
JV		 2581 struct net_device *vlan_dev;
2582 struct flowi fl;
2583 struct rtable *rt;
1da177e4 2584
6b780567
MW		 2585 for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
2586 if (!targets[i])
2587 continue;
c3ade5ca
JV		 2588 dprintk("basa: target %x\n", targets[i]);
2589 if (list_empty(&bond->vlan_list)) {
2590 dprintk("basa: empty vlan: arp_send\n");
2591 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
2592 bond->master_ip, 0);
2593 continue;
2594 }
2595
2596 /*
2597 * If VLANs are configured, we do a route lookup to
2598 * determine which VLAN interface would be used, so we
2599 * can tag the ARP with the proper VLAN tag.
2600 */
2601 memset(&fl, 0, sizeof(fl));
2602 fl.fl4_dst = targets[i];
2603 fl.fl4_tos = RTO_ONLINK;
2604
f206351a 2605 rv = ip_route_output_key(&init_net, &rt, &fl);
c3ade5ca
JV		 2606 if (rv) {
2607 if (net_ratelimit()) {
2608 printk(KERN_WARNING DRV_NAME
63779436
HH		 2609 ": %s: no route to arp_ip_target %pI4\n",
2610 bond->dev->name, &fl.fl4_dst);
c3ade5ca
JV		 2611 }
2612 continue;
2613 }
2614
2615 /*
2616 * This target is not on a VLAN
2617 */
2618 if (rt->u.dst.dev == bond->dev) {
ed4b9f80 2619 ip_rt_put(rt);
c3ade5ca
JV		 2620 dprintk("basa: rtdev == bond->dev: arp_send\n");
2621 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
2622 bond->master_ip, 0);
2623 continue;
2624 }
2625
2626 vlan_id = 0;
0883beca 2627 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
5c15bdec 2628 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
c3ade5ca
JV		 2629 if (vlan_dev == rt->u.dst.dev) {
2630 vlan_id = vlan->vlan_id;
2631 dprintk("basa: vlan match on %s %d\n",
2632 vlan_dev->name, vlan_id);
2633 break;
2634 }
2635 }
2636
2637 if (vlan_id) {
ed4b9f80 2638 ip_rt_put(rt);
c3ade5ca
JV		 2639 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
2640 vlan->vlan_ip, vlan_id);
2641 continue;
2642 }
2643
2644 if (net_ratelimit()) {
2645 printk(KERN_WARNING DRV_NAME
63779436
HH		 2646 ": %s: no path to arp_ip_target %pI4 via rt.dev %s\n",
2647 bond->dev->name, &fl.fl4_dst,
c3ade5ca
JV		 2648 rt->u.dst.dev ? rt->u.dst.dev->name : "NULL");
2649 }
ed4b9f80 2650 ip_rt_put(rt);
c3ade5ca
JV		 2651 }
2652}
2653
2654/*
2655 * Kick out a gratuitous ARP for an IP on the bonding master plus one
2656 * for each VLAN above us.
b59f9f74
JV		 2657 *
2658 * Caller must hold curr_slave_lock for read or better
c3ade5ca
JV		 2659 */
2660static void bond_send_gratuitous_arp(struct bonding *bond)
2661{
2662 struct slave *slave = bond->curr_active_slave;
2663 struct vlan_entry *vlan;
2664 struct net_device *vlan_dev;
2665
2666 dprintk("bond_send_grat_arp: bond %s slave %s\n", bond->dev->name,
2667 slave ? slave->dev->name : "NULL");
b59f9f74
JV		 2668
2669 if (!slave || !bond->send_grat_arp ||
2670 test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state))
c3ade5ca
JV		 2671 return;
2672
b59f9f74
JV		 2673 bond->send_grat_arp--;
2674
c3ade5ca
JV		 2675 if (bond->master_ip) {
2676 bond_arp_send(slave->dev, ARPOP_REPLY, bond->master_ip,
1053f62c 2677 bond->master_ip, 0);
c3ade5ca
JV		 2678 }
2679
2680 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
5c15bdec 2681 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
c3ade5ca
JV		 2682 if (vlan->vlan_ip) {
2683 bond_arp_send(slave->dev, ARPOP_REPLY, vlan->vlan_ip,
2684 vlan->vlan_ip, vlan->vlan_id);
2685 }
1da177e4
LT		 2686 }
2687}
2688
d3bb52b0 2689static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip)
f5b2b966
JV		 2690{
2691 int i;
d3bb52b0 2692 __be32 *targets = bond->params.arp_targets;
f5b2b966
JV		 2693
2694 targets = bond->params.arp_targets;
2695 for (i = 0; (i < BOND_MAX_ARP_TARGETS) && targets[i]; i++) {
63779436
HH		 2696 dprintk("bva: sip %pI4 tip %pI4 t[%d] %pI4 bhti(tip) %d\n",
2697 &sip, &tip, i, &targets[i], bond_has_this_ip(bond, tip));
f5b2b966
JV		 2698 if (sip == targets[i]) {
2699 if (bond_has_this_ip(bond, tip))
2700 slave->last_arp_rx = jiffies;
2701 return;
2702 }
2703 }
2704}
2705
2706static int bond_arp_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
2707{
2708 struct arphdr *arp;
2709 struct slave *slave;
2710 struct bonding *bond;
2711 unsigned char *arp_ptr;
d3bb52b0 2712 __be32 sip, tip;
f5b2b966 2713
c346dca1 2714 if (dev_net(dev) != &init_net)
e730c155
EB		 2715 goto out;
2716
f5b2b966
JV		 2717 if (!(dev->priv_flags & IFF_BONDING) || !(dev->flags & IFF_MASTER))
2718 goto out;
2719
454d7c9b 2720 bond = netdev_priv(dev);
f5b2b966
JV		 2721 read_lock(&bond->lock);
2722
2723 dprintk("bond_arp_rcv: bond %s skb->dev %s orig_dev %s\n",
2724 bond->dev->name, skb->dev ? skb->dev->name : "NULL",
2725 orig_dev ? orig_dev->name : "NULL");
2726
2727 slave = bond_get_slave_by_dev(bond, orig_dev);
2728 if (!slave || !slave_do_arp_validate(bond, slave))
2729 goto out_unlock;
2730
988b7050 2731 if (!pskb_may_pull(skb, arp_hdr_len(dev)))
f5b2b966
JV		 2732 goto out_unlock;
2733
d0a92be0 2734 arp = arp_hdr(skb);
f5b2b966
JV		 2735 if (arp->ar_hln != dev->addr_len ||
2736 skb->pkt_type == PACKET_OTHERHOST ||
2737 skb->pkt_type == PACKET_LOOPBACK ||
2738 arp->ar_hrd != htons(ARPHRD_ETHER) ||
2739 arp->ar_pro != htons(ETH_P_IP) ||
2740 arp->ar_pln != 4)
2741 goto out_unlock;
2742
2743 arp_ptr = (unsigned char *)(arp + 1);
2744 arp_ptr += dev->addr_len;
2745 memcpy(&sip, arp_ptr, 4);
2746 arp_ptr += 4 + dev->addr_len;
2747 memcpy(&tip, arp_ptr, 4);
2748
63779436
HH		 2749 dprintk("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
2750 bond->dev->name, slave->dev->name, slave->state,
2751 bond->params.arp_validate, slave_do_arp_validate(bond, slave),
2752 &sip, &tip);
f5b2b966
JV		 2753
2754 /*
2755 * Backup slaves won't see the ARP reply, but do come through
2756 * here for each ARP probe (so we swap the sip/tip to validate
2757 * the probe). In a "redundant switch, common router" type of
2758 * configuration, the ARP probe will (hopefully) travel from
2759 * the active, through one switch, the router, then the other
2760 * switch before reaching the backup.
2761 */
2762 if (slave->state == BOND_STATE_ACTIVE)
2763 bond_validate_arp(bond, slave, sip, tip);
2764 else
2765 bond_validate_arp(bond, slave, tip, sip);
2766
2767out_unlock:
2768 read_unlock(&bond->lock);
2769out:
2770 dev_kfree_skb(skb);
2771 return NET_RX_SUCCESS;
2772}
2773
1da177e4
LT		 2774/*
2775 * this function is called regularly to monitor each slave's link
2776 * ensuring that traffic is being sent and received when arp monitoring
2777 * is used in load-balancing mode. if the adapter has been dormant, then an
2778 * arp is transmitted to generate traffic. see activebackup_arp_monitor for
2779 * arp monitoring in active backup mode.
2780 */
1b76b316 2781void bond_loadbalance_arp_mon(struct work_struct *work)
1da177e4 2782{
1b76b316
JV		 2783 struct bonding *bond = container_of(work, struct bonding,
2784 arp_work.work);
1da177e4
LT		 2785 struct slave *slave, *oldcurrent;
2786 int do_failover = 0;
2787 int delta_in_ticks;
2788 int i;
2789
2790 read_lock(&bond->lock);
2791
5ce0da8f 2792 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
1da177e4
LT		 2793
2794 if (bond->kill_timers) {
2795 goto out;
2796 }
2797
2798 if (bond->slave_cnt == 0) {
2799 goto re_arm;
2800 }
2801
2802 read_lock(&bond->curr_slave_lock);
2803 oldcurrent = bond->curr_active_slave;
2804 read_unlock(&bond->curr_slave_lock);
2805
2806 /* see if any of the previous devices are up now (i.e. they have
2807 * xmt and rcv traffic). the curr_active_slave does not come into
2808 * the picture unless it is null. also, slave->jiffies is not needed
2809 * here because we send an arp on each slave and give a slave as
2810 * long as it needs to get the tx/rx within the delta.
2811 * TODO: what about up/down delay in arp mode? it wasn't here before
2812 * so it can wait
2813 */
2814 bond_for_each_slave(bond, slave, i) {
2815 if (slave->link != BOND_LINK_UP) {
b63bb739
DS		 2816 if (time_before_eq(jiffies, slave->dev->trans_start + delta_in_ticks) &&
2817 time_before_eq(jiffies, slave->dev->last_rx + delta_in_ticks)) {
1da177e4
LT		 2818
2819 slave->link = BOND_LINK_UP;
2820 slave->state = BOND_STATE_ACTIVE;
2821
2822 /* primary_slave has no meaning in round-robin
2823 * mode. the window of a slave being up and
2824 * curr_active_slave being null after enslaving
2825 * is closed.
2826 */
2827 if (!oldcurrent) {
2828 printk(KERN_INFO DRV_NAME
2829 ": %s: link status definitely "
2830 "up for interface %s, ",
1b76b316 2831 bond->dev->name,
1da177e4
LT		 2832 slave->dev->name);
2833 do_failover = 1;
2834 } else {
2835 printk(KERN_INFO DRV_NAME
2836 ": %s: interface %s is now up\n",
1b76b316 2837 bond->dev->name,
1da177e4
LT		 2838 slave->dev->name);
2839 }
2840 }
2841 } else {
2842 /* slave->link == BOND_LINK_UP */
2843
2844 /* not all switches will respond to an arp request
2845 * when the source ip is 0, so don't take the link down
2846 * if we don't know our ip yet
2847 */
b63bb739 2848 if (time_after_eq(jiffies, slave->dev->trans_start + 2*delta_in_ticks) ||
4b8a9239 2849 (time_after_eq(jiffies, slave->dev->last_rx + 2*delta_in_ticks))) {
1da177e4
LT		 2850
2851 slave->link = BOND_LINK_DOWN;
2852 slave->state = BOND_STATE_BACKUP;
2853
2854 if (slave->link_failure_count < UINT_MAX) {
2855 slave->link_failure_count++;
2856 }
2857
2858 printk(KERN_INFO DRV_NAME
2859 ": %s: interface %s is now down.\n",
1b76b316 2860 bond->dev->name,
1da177e4
LT		 2861 slave->dev->name);
2862
2863 if (slave == oldcurrent) {
2864 do_failover = 1;
2865 }
2866 }
2867 }
2868
2869 /* note: if switch is in round-robin mode, all links
2870 * must tx arp to ensure all links rx an arp - otherwise
2871 * links may oscillate or not come up at all; if switch is
2872 * in something like xor mode, there is nothing we can
2873 * do - all replies will be rx'ed on same link causing slaves
2874 * to be unstable during low/no traffic periods
2875 */
2876 if (IS_UP(slave->dev)) {
2877 bond_arp_send_all(bond, slave);
2878 }
2879 }
2880
2881 if (do_failover) {
059fe7a5 2882 write_lock_bh(&bond->curr_slave_lock);
1da177e4
LT		 2883
2884 bond_select_active_slave(bond);
2885
059fe7a5 2886 write_unlock_bh(&bond->curr_slave_lock);
1da177e4
LT		 2887 }
2888
2889re_arm:
1b76b316
JV		 2890 if (bond->params.arp_interval)
2891 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
1da177e4
LT		 2892out:
2893 read_unlock(&bond->lock);
2894}
2895
2896/*
b2220cad
JV		 2897 * Called to inspect slaves for active-backup mode ARP monitor link state
2898 * changes. Sets new_link in slaves to specify what action should take
2899 * place for the slave. Returns 0 if no changes are found, >0 if changes
2900 * to link states must be committed.
2901 *
2902 * Called with bond->lock held for read.
1da177e4 2903 */
b2220cad 2904static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
1da177e4 2905{
1da177e4 2906 struct slave *slave;
b2220cad 2907 int i, commit = 0;
1da177e4 2908
b2220cad
JV		 2909 bond_for_each_slave(bond, slave, i) {
2910 slave->new_link = BOND_LINK_NOCHANGE;
1da177e4 2911
b2220cad
JV		 2912 if (slave->link != BOND_LINK_UP) {
2913 if (time_before_eq(jiffies, slave_last_rx(bond, slave) +
2914 delta_in_ticks)) {
2915 slave->new_link = BOND_LINK_UP;
2916 commit++;
2917 }
1da177e4 2918
b2220cad
JV		 2919 continue;
2920 }
1da177e4 2921
b2220cad
JV		 2922 /*
2923 * Give slaves 2*delta after being enslaved or made
2924 * active. This avoids bouncing, as the last receive
2925 * times need a full ARP monitor cycle to be updated.
2926 */
2927 if (!time_after_eq(jiffies, slave->jiffies +
2928 2 * delta_in_ticks))
2929 continue;
2930
2931 /*
2932 * Backup slave is down if:
2933 * - No current_arp_slave AND
2934 * - more than 3*delta since last receive AND
2935 * - the bond has an IP address
2936 *
2937 * Note: a non-null current_arp_slave indicates
2938 * the curr_active_slave went down and we are
2939 * searching for a new one; under this condition
2940 * we only take the curr_active_slave down - this
2941 * gives each slave a chance to tx/rx traffic
2942 * before being taken out
2943 */
2944 if (slave->state == BOND_STATE_BACKUP &&
2945 !bond->current_arp_slave &&
2946 time_after(jiffies, slave_last_rx(bond, slave) +
2947 3 * delta_in_ticks)) {
2948 slave->new_link = BOND_LINK_DOWN;
2949 commit++;
2950 }
2951
2952 /*
2953 * Active slave is down if:
2954 * - more than 2*delta since transmitting OR
2955 * - (more than 2*delta since receive AND
2956 * the bond has an IP address)
2957 */
2958 if ((slave->state == BOND_STATE_ACTIVE) &&
2959 (time_after_eq(jiffies, slave->dev->trans_start +
2960 2 * delta_in_ticks) ||
2961 (time_after_eq(jiffies, slave_last_rx(bond, slave)
2962 + 2 * delta_in_ticks)))) {
2963 slave->new_link = BOND_LINK_DOWN;
2964 commit++;
2965 }
1da177e4
LT		 2966 }
2967
b2220cad
JV		 2968 read_lock(&bond->curr_slave_lock);
2969
2970 /*
2971 * Trigger a commit if the primary option setting has changed.
1da177e4 2972 */
b2220cad
JV		 2973 if (bond->primary_slave &&
2974 (bond->primary_slave != bond->curr_active_slave) &&
2975 (bond->primary_slave->link == BOND_LINK_UP))
2976 commit++;
1da177e4 2977
b2220cad 2978 read_unlock(&bond->curr_slave_lock);
1da177e4 2979
b2220cad
JV		 2980 return commit;
2981}
1da177e4 2982
b2220cad
JV		 2983/*
2984 * Called to commit link state changes noted by inspection step of
2985 * active-backup mode ARP monitor.
2986 *
2987 * Called with RTNL and bond->lock for read.
2988 */
2989static void bond_ab_arp_commit(struct bonding *bond, int delta_in_ticks)
2990{
2991 struct slave *slave;
2992 int i;
1da177e4 2993
b2220cad
JV		 2994 bond_for_each_slave(bond, slave, i) {
2995 switch (slave->new_link) {
2996 case BOND_LINK_NOCHANGE:
2997 continue;
ff59c456 2998
b2220cad
JV		 2999 case BOND_LINK_UP:
3000 write_lock_bh(&bond->curr_slave_lock);
1da177e4 3001
b2220cad
JV		 3002 if (!bond->curr_active_slave &&
3003 time_before_eq(jiffies, slave->dev->trans_start +
3004 delta_in_ticks)) {
3005 slave->link = BOND_LINK_UP;
3006 bond_change_active_slave(bond, slave);
3007 bond->current_arp_slave = NULL;
3008
3009 printk(KERN_INFO DRV_NAME
3010 ": %s: %s is up and now the "
3011 "active interface\n",
3012 bond->dev->name, slave->dev->name);
3013
3014 } else if (bond->curr_active_slave != slave) {
3015 /* this slave has just come up but we
3016 * already have a current slave; this can
3017 * also happen if bond_enslave adds a new
3018 * slave that is up while we are searching
3019 * for a new slave
1da177e4 3020 */
b2220cad
JV		 3021 slave->link = BOND_LINK_UP;
3022 bond_set_slave_inactive_flags(slave);
3023 bond->current_arp_slave = NULL;
3024
3025 printk(KERN_INFO DRV_NAME
3026 ": %s: backup interface %s is now up\n",
3027 bond->dev->name, slave->dev->name);
3028 }
1da177e4 3029
b2220cad 3030 write_unlock_bh(&bond->curr_slave_lock);
1da177e4 3031
b2220cad 3032 break;
1da177e4 3033
b2220cad
JV		 3034 case BOND_LINK_DOWN:
3035 if (slave->link_failure_count < UINT_MAX)
3036 slave->link_failure_count++;
3037
3038 slave->link = BOND_LINK_DOWN;
3039
3040 if (slave == bond->curr_active_slave) {
3041 printk(KERN_INFO DRV_NAME
3042 ": %s: link status down for active "
3043 "interface %s, disabling it\n",
3044 bond->dev->name, slave->dev->name);
1da177e4
LT		 3045
3046 bond_set_slave_inactive_flags(slave);
3047
b2220cad
JV		 3048 write_lock_bh(&bond->curr_slave_lock);
3049
3050 bond_select_active_slave(bond);
3051 if (bond->curr_active_slave)
3052 bond->curr_active_slave->jiffies =
3053 jiffies;
3054
3055 write_unlock_bh(&bond->curr_slave_lock);
3056
3057 bond->current_arp_slave = NULL;
3058
3059 } else if (slave->state == BOND_STATE_BACKUP) {
1da177e4
LT		 3060 printk(KERN_INFO DRV_NAME
3061 ": %s: backup interface %s is now down\n",
b2220cad
JV		 3062 bond->dev->name, slave->dev->name);
3063
3064 bond_set_slave_inactive_flags(slave);
1da177e4 3065 }
b2220cad
JV		 3066 break;
3067
3068 default:
3069 printk(KERN_ERR DRV_NAME
3070 ": %s: impossible: new_link %d on slave %s\n",
3071 bond->dev->name, slave->new_link,
3072 slave->dev->name);
1da177e4
LT		 3073 }
3074 }
3075
b2220cad
JV		 3076 /*
3077 * No race with changes to primary via sysfs, as we hold rtnl.
3078 */
3079 if (bond->primary_slave &&
3080 (bond->primary_slave != bond->curr_active_slave) &&
3081 (bond->primary_slave->link == BOND_LINK_UP)) {
3082 write_lock_bh(&bond->curr_slave_lock);
3083 bond_change_active_slave(bond, bond->primary_slave);
3084 write_unlock_bh(&bond->curr_slave_lock);
3085 }
1da177e4 3086
b2220cad
JV		 3087 bond_set_carrier(bond);
3088}
1da177e4 3089
b2220cad
JV		 3090/*
3091 * Send ARP probes for active-backup mode ARP monitor.
3092 *
3093 * Called with bond->lock held for read.
3094 */
3095static void bond_ab_arp_probe(struct bonding *bond)
3096{
3097 struct slave *slave;
3098 int i;
1da177e4 3099
b2220cad 3100 read_lock(&bond->curr_slave_lock);
1da177e4 3101
b2220cad
JV		 3102 if (bond->current_arp_slave && bond->curr_active_slave)
3103 printk("PROBE: c_arp %s && cas %s BAD\n",
3104 bond->current_arp_slave->dev->name,
3105 bond->curr_active_slave->dev->name);
1da177e4 3106
b2220cad
JV		 3107 if (bond->curr_active_slave) {
3108 bond_arp_send_all(bond, bond->curr_active_slave);
3109 read_unlock(&bond->curr_slave_lock);
3110 return;
3111 }
1da177e4 3112
b2220cad 3113 read_unlock(&bond->curr_slave_lock);
059fe7a5 3114
b2220cad
JV		 3115 /* if we don't have a curr_active_slave, search for the next available
3116 * backup slave from the current_arp_slave and make it the candidate
3117 * for becoming the curr_active_slave
3118 */
1da177e4 3119
b2220cad
JV		 3120 if (!bond->current_arp_slave) {
3121 bond->current_arp_slave = bond->first_slave;
3122 if (!bond->current_arp_slave)
3123 return;
3124 }
1da177e4 3125
b2220cad 3126 bond_set_slave_inactive_flags(bond->current_arp_slave);
059fe7a5 3127
b2220cad
JV		 3128 /* search for next candidate */
3129 bond_for_each_slave_from(bond, slave, i, bond->current_arp_slave->next) {
3130 if (IS_UP(slave->dev)) {
3131 slave->link = BOND_LINK_BACK;
3132 bond_set_slave_active_flags(slave);
3133 bond_arp_send_all(bond, slave);
1da177e4 3134 slave->jiffies = jiffies;
b2220cad
JV		 3135 bond->current_arp_slave = slave;
3136 break;
1da177e4
LT		 3137 }
3138
b2220cad
JV		 3139 /* if the link state is up at this point, we
3140 * mark it down - this can happen if we have
3141 * simultaneous link failures and
3142 * reselect_active_interface doesn't make this
3143 * one the current slave so it is still marked
3144 * up when it is actually down
1da177e4 3145 */
b2220cad
JV		 3146 if (slave->link == BOND_LINK_UP) {
3147 slave->link = BOND_LINK_DOWN;
3148 if (slave->link_failure_count < UINT_MAX)
3149 slave->link_failure_count++;
1da177e4 3150
b2220cad
JV		 3151 bond_set_slave_inactive_flags(slave);
3152
3153 printk(KERN_INFO DRV_NAME
3154 ": %s: backup interface %s is now down.\n",
3155 bond->dev->name, slave->dev->name);
1da177e4 3156 }
b2220cad
JV		 3157 }
3158}
1da177e4 3159
b2220cad
JV		 3160void bond_activebackup_arp_mon(struct work_struct *work)
3161{
3162 struct bonding *bond = container_of(work, struct bonding,
3163 arp_work.work);
3164 int delta_in_ticks;
1da177e4 3165
b2220cad 3166 read_lock(&bond->lock);
1da177e4 3167
b2220cad
JV		 3168 if (bond->kill_timers)
3169 goto out;
1da177e4 3170
b2220cad 3171 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval);
1da177e4 3172
b2220cad
JV		 3173 if (bond->slave_cnt == 0)
3174 goto re_arm;
3175
b59f9f74
JV		 3176 if (bond->send_grat_arp) {
3177 read_lock(&bond->curr_slave_lock);
3178 bond_send_gratuitous_arp(bond);
3179 read_unlock(&bond->curr_slave_lock);
3180 }
3181
305d552a
BH		 3182 if (bond->send_unsol_na) {
3183 read_lock(&bond->curr_slave_lock);
3184 bond_send_unsolicited_na(bond);
3185 read_unlock(&bond->curr_slave_lock);
3186 }
3187
b2220cad
JV		 3188 if (bond_ab_arp_inspect(bond, delta_in_ticks)) {
3189 read_unlock(&bond->lock);
3190 rtnl_lock();
3191 read_lock(&bond->lock);
3192
3193 bond_ab_arp_commit(bond, delta_in_ticks);
3194
3195 read_unlock(&bond->lock);
3196 rtnl_unlock();
3197 read_lock(&bond->lock);
1da177e4
LT		 3198 }
3199
b2220cad
JV		 3200 bond_ab_arp_probe(bond);
3201
1da177e4
LT		 3202re_arm:
3203 if (bond->params.arp_interval) {
1b76b316 3204 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
1da177e4
LT		 3205 }
3206out:
3207 read_unlock(&bond->lock);
3208}
3209
3210/*------------------------------ proc/seq_file-------------------------------*/
3211
3212#ifdef CONFIG_PROC_FS
3213
1da177e4
LT		 3214static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos)
3215{
3216 struct bonding *bond = seq->private;
3217 loff_t off = 0;
3218 struct slave *slave;
3219 int i;
3220
3221 /* make sure the bond won't be taken away */
3222 read_lock(&dev_base_lock);
6603a6f2 3223 read_lock(&bond->lock);
1da177e4
LT		 3224
3225 if (*pos == 0) {
3226 return SEQ_START_TOKEN;
3227 }
3228
3229 bond_for_each_slave(bond, slave, i) {
3230 if (++off == *pos) {
3231 return slave;
3232 }
3233 }
3234
3235 return NULL;
3236}
3237
3238static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3239{
3240 struct bonding *bond = seq->private;
3241 struct slave *slave = v;
3242
3243 ++*pos;
3244 if (v == SEQ_START_TOKEN) {
3245 return bond->first_slave;
3246 }
3247
3248 slave = slave->next;
3249
3250 return (slave == bond->first_slave) ? NULL : slave;
3251}
3252
3253static void bond_info_seq_stop(struct seq_file *seq, void *v)
3254{
3255 struct bonding *bond = seq->private;
3256
6603a6f2 3257 read_unlock(&bond->lock);
1da177e4
LT		 3258 read_unlock(&dev_base_lock);
3259}
3260
3261static void bond_info_show_master(struct seq_file *seq)
3262{
3263 struct bonding *bond = seq->private;
3264 struct slave *curr;
4756b02f 3265 int i;
1da177e4
LT		 3266
3267 read_lock(&bond->curr_slave_lock);
3268 curr = bond->curr_active_slave;
3269 read_unlock(&bond->curr_slave_lock);
3270
dd957c57 3271 seq_printf(seq, "Bonding Mode: %s",
1da177e4
LT		 3272 bond_mode_name(bond->params.mode));
3273
dd957c57
JV		 3274 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP &&
3275 bond->params.fail_over_mac)
3915c1e8
JV		 3276 seq_printf(seq, " (fail_over_mac %s)",
3277 fail_over_mac_tbl[bond->params.fail_over_mac].modename);
dd957c57
JV		 3278
3279 seq_printf(seq, "\n");
3280
c61b75ad
MW		 3281 if (bond->params.mode == BOND_MODE_XOR ||
3282 bond->params.mode == BOND_MODE_8023AD) {
3283 seq_printf(seq, "Transmit Hash Policy: %s (%d)\n",
3284 xmit_hashtype_tbl[bond->params.xmit_policy].modename,
3285 bond->params.xmit_policy);
3286 }
3287
1da177e4
LT		 3288 if (USES_PRIMARY(bond->params.mode)) {
3289 seq_printf(seq, "Primary Slave: %s\n",
0f418b2a
MW		 3290 (bond->primary_slave) ?
3291 bond->primary_slave->dev->name : "None");
1da177e4
LT		 3292
3293 seq_printf(seq, "Currently Active Slave: %s\n",
3294 (curr) ? curr->dev->name : "None");
3295 }
3296
ff59c456
JV		 3297 seq_printf(seq, "MII Status: %s\n", netif_carrier_ok(bond->dev) ?
3298 "up" : "down");
1da177e4
LT		 3299 seq_printf(seq, "MII Polling Interval (ms): %d\n", bond->params.miimon);
3300 seq_printf(seq, "Up Delay (ms): %d\n",
3301 bond->params.updelay * bond->params.miimon);
3302 seq_printf(seq, "Down Delay (ms): %d\n",
3303 bond->params.downdelay * bond->params.miimon);
3304
4756b02f
MW		 3305
3306 /* ARP information */
3307 if(bond->params.arp_interval > 0) {
3308 int printed=0;
3309 seq_printf(seq, "ARP Polling Interval (ms): %d\n",
3310 bond->params.arp_interval);
3311
3312 seq_printf(seq, "ARP IP target/s (n.n.n.n form):");
3313
3314 for(i = 0; (i < BOND_MAX_ARP_TARGETS) ;i++) {
3315 if (!bond->params.arp_targets[i])
3316 continue;
3317 if (printed)
3318 seq_printf(seq, ",");
8cf14e38 3319 seq_printf(seq, " %pI4", &bond->params.arp_targets[i]);
4756b02f
MW		 3320 printed = 1;
3321 }
3322 seq_printf(seq, "\n");
3323 }
3324
1da177e4
LT		 3325 if (bond->params.mode == BOND_MODE_8023AD) {
3326 struct ad_info ad_info;
3327
3328 seq_puts(seq, "\n802.3ad info\n");
3329 seq_printf(seq, "LACP rate: %s\n",
3330 (bond->params.lacp_fast) ? "fast" : "slow");
fd989c83
JV		 3331 seq_printf(seq, "Aggregator selection policy (ad_select): %s\n",
3332 ad_select_tbl[bond->params.ad_select].modename);
1da177e4
LT		 3333
3334 if (bond_3ad_get_active_agg_info(bond, &ad_info)) {
3335 seq_printf(seq, "bond %s has no active aggregator\n",
3336 bond->dev->name);
3337 } else {
3338 seq_printf(seq, "Active Aggregator Info:\n");
3339
3340 seq_printf(seq, "\tAggregator ID: %d\n",
3341 ad_info.aggregator_id);
3342 seq_printf(seq, "\tNumber of ports: %d\n",
3343 ad_info.ports);
3344 seq_printf(seq, "\tActor Key: %d\n",
3345 ad_info.actor_key);
3346 seq_printf(seq, "\tPartner Key: %d\n",
3347 ad_info.partner_key);
e174961c
JB		 3348 seq_printf(seq, "\tPartner Mac Address: %pM\n",
3349 ad_info.partner_system);
1da177e4
LT		 3350 }
3351 }
3352}
3353
3354static void bond_info_show_slave(struct seq_file *seq, const struct slave *slave)
3355{
3356 struct bonding *bond = seq->private;
3357
3358 seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name);
3359 seq_printf(seq, "MII Status: %s\n",
3360 (slave->link == BOND_LINK_UP) ? "up" : "down");
65509645 3361 seq_printf(seq, "Link Failure Count: %u\n",
1da177e4
LT		 3362 slave->link_failure_count);
3363
e174961c 3364 seq_printf(seq, "Permanent HW addr: %pM\n", slave->perm_hwaddr);
1da177e4
LT		 3365
3366 if (bond->params.mode == BOND_MODE_8023AD) {
3367 const struct aggregator *agg
3368 = SLAVE_AD_INFO(slave).port.aggregator;
3369
3370 if (agg) {
3371 seq_printf(seq, "Aggregator ID: %d\n",
3372 agg->aggregator_identifier);
3373 } else {
3374 seq_puts(seq, "Aggregator ID: N/A\n");
3375 }
3376 }
3377}
3378
3379static int bond_info_seq_show(struct seq_file *seq, void *v)
3380{
3381 if (v == SEQ_START_TOKEN) {
3382 seq_printf(seq, "%s\n", version);
3383 bond_info_show_master(seq);
3384 } else {
3385 bond_info_show_slave(seq, v);
3386 }
3387
3388 return 0;
3389}
3390
3391static struct seq_operations bond_info_seq_ops = {
3392 .start = bond_info_seq_start,
3393 .next = bond_info_seq_next,
3394 .stop = bond_info_seq_stop,
3395 .show = bond_info_seq_show,
3396};
3397
3398static int bond_info_open(struct inode *inode, struct file *file)
3399{
3400 struct seq_file *seq;
3401 struct proc_dir_entry *proc;
3402 int res;
3403
3404 res = seq_open(file, &bond_info_seq_ops);
3405 if (!res) {
3406 /* recover the pointer buried in proc_dir_entry data */
3407 seq = file->private_data;
3408 proc = PDE(inode);
3409 seq->private = proc->data;
3410 }
3411
3412 return res;
3413}
3414
d54b1fdb 3415static const struct file_operations bond_info_fops = {
1da177e4
LT		 3416 .owner = THIS_MODULE,
3417 .open = bond_info_open,
3418 .read = seq_read,
3419 .llseek = seq_lseek,
3420 .release = seq_release,
3421};
3422
3423static int bond_create_proc_entry(struct bonding *bond)
3424{
3425 struct net_device *bond_dev = bond->dev;
3426
3427 if (bond_proc_dir) {
a95609cb
DL		 3428 bond->proc_entry = proc_create_data(bond_dev->name,
3429 S_IRUGO, bond_proc_dir,
3430 &bond_info_fops, bond);
1da177e4
LT		 3431 if (bond->proc_entry == NULL) {
3432 printk(KERN_WARNING DRV_NAME
3433 ": Warning: Cannot create /proc/net/%s/%s\n",
3434 DRV_NAME, bond_dev->name);
3435 } else {
1da177e4
LT		 3436 memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ);
3437 }
3438 }
3439
3440 return 0;
3441}
3442
3443static void bond_remove_proc_entry(struct bonding *bond)
3444{
3445 if (bond_proc_dir && bond->proc_entry) {
3446 remove_proc_entry(bond->proc_file_name, bond_proc_dir);
3447 memset(bond->proc_file_name, 0, IFNAMSIZ);
3448 bond->proc_entry = NULL;
3449 }
3450}
3451
3452/* Create the bonding directory under /proc/net, if doesn't exist yet.
3453 * Caller must hold rtnl_lock.
3454 */
3455static void bond_create_proc_dir(void)
3456{
3457 int len = strlen(DRV_NAME);
3458
457c4cbc 3459 for (bond_proc_dir = init_net.proc_net->subdir; bond_proc_dir;
1da177e4
LT		 3460 bond_proc_dir = bond_proc_dir->next) {
3461 if ((bond_proc_dir->namelen == len) &&
3462 !memcmp(bond_proc_dir->name, DRV_NAME, len)) {
3463 break;
3464 }
3465 }
3466
3467 if (!bond_proc_dir) {
457c4cbc 3468 bond_proc_dir = proc_mkdir(DRV_NAME, init_net.proc_net);
1da177e4
LT		 3469 if (bond_proc_dir) {
3470 bond_proc_dir->owner = THIS_MODULE;
3471 } else {
3472 printk(KERN_WARNING DRV_NAME
3473 ": Warning: cannot create /proc/net/%s\n",
3474 DRV_NAME);
3475 }
3476 }
3477}
3478
3479/* Destroy the bonding directory under /proc/net, if empty.
3480 * Caller must hold rtnl_lock.
3481 */
3482static void bond_destroy_proc_dir(void)
3483{
3484 struct proc_dir_entry *de;
3485
3486 if (!bond_proc_dir) {
3487 return;
3488 }
3489
3490 /* verify that the /proc dir is empty */
3491 for (de = bond_proc_dir->subdir; de; de = de->next) {
3492 /* ignore . and .. */
3493 if (*(de->name) != '.') {
3494 break;
3495 }
3496 }
3497
3498 if (de) {
3499 if (bond_proc_dir->owner == THIS_MODULE) {
3500 bond_proc_dir->owner = NULL;
3501 }
3502 } else {
457c4cbc 3503 remove_proc_entry(DRV_NAME, init_net.proc_net);
1da177e4
LT		 3504 bond_proc_dir = NULL;
3505 }
3506}
3507#endif /* CONFIG_PROC_FS */
3508
3509/*-------------------------- netdev event handling --------------------------*/
3510
3511/*
3512 * Change device name
3513 */
3514static int bond_event_changename(struct bonding *bond)
3515{
3516#ifdef CONFIG_PROC_FS
3517 bond_remove_proc_entry(bond);
3518 bond_create_proc_entry(bond);
3519#endif
b76cdba9
MW		 3520 down_write(&(bonding_rwsem));
3521 bond_destroy_sysfs_entry(bond);
3522 bond_create_sysfs_entry(bond);
3523 up_write(&(bonding_rwsem));
1da177e4
LT		 3524 return NOTIFY_DONE;
3525}
3526
3527static int bond_master_netdev_event(unsigned long event, struct net_device *bond_dev)
3528{
454d7c9b 3529 struct bonding *event_bond = netdev_priv(bond_dev);
1da177e4
LT		 3530
3531 switch (event) {
3532 case NETDEV_CHANGENAME:
3533 return bond_event_changename(event_bond);
3534 case NETDEV_UNREGISTER:
3b96c858 3535 bond_release_all(event_bond->dev);
1da177e4
LT		 3536 break;
3537 default:
3538 break;
3539 }
3540
3541 return NOTIFY_DONE;
3542}
3543
3544static int bond_slave_netdev_event(unsigned long event, struct net_device *slave_dev)
3545{
3546 struct net_device *bond_dev = slave_dev->master;
454d7c9b 3547 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 3548
3549 switch (event) {
3550 case NETDEV_UNREGISTER:
3551 if (bond_dev) {
1284cd3a
JV		 3552 if (bond->setup_by_slave)
3553 bond_release_and_destroy(bond_dev, slave_dev);
3554 else
3555 bond_release(bond_dev, slave_dev);
1da177e4
LT		 3556 }
3557 break;
3558 case NETDEV_CHANGE:
3559 /*
3560 * TODO: is this what we get if somebody
3561 * sets up a hierarchical bond, then rmmod's
3562 * one of the slave bonding devices?
3563 */
3564 break;
3565 case NETDEV_DOWN:
3566 /*
3567 * ... Or is it this?
3568 */
3569 break;
3570 case NETDEV_CHANGEMTU:
3571 /*
3572 * TODO: Should slaves be allowed to
3573 * independently alter their MTU? For
3574 * an active-backup bond, slaves need
3575 * not be the same type of device, so
3576 * MTUs may vary. For other modes,
3577 * slaves arguably should have the
3578 * same MTUs. To do this, we'd need to
3579 * take over the slave's change_mtu
3580 * function for the duration of their
3581 * servitude.
3582 */
3583 break;
3584 case NETDEV_CHANGENAME:
3585 /*
3586 * TODO: handle changing the primary's name
3587 */
3588 break;
8531c5ff
AK		 3589 case NETDEV_FEAT_CHANGE:
3590 bond_compute_features(bond);
3591 break;
1da177e4
LT		 3592 default:
3593 break;
3594 }
3595
3596 return NOTIFY_DONE;
3597}
3598
3599/*
3600 * bond_netdev_event: handle netdev notifier chain events.
3601 *
3602 * This function receives events for the netdev chain. The caller (an
e041c683 3603 * ioctl handler calling blocking_notifier_call_chain) holds the necessary
1da177e4
LT		 3604 * locks for us to safely manipulate the slave devices (RTNL lock,
3605 * dev_probe_lock).
3606 */
3607static int bond_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
3608{
3609 struct net_device *event_dev = (struct net_device *)ptr;
3610
c346dca1 3611 if (dev_net(event_dev) != &init_net)
e9dc8653
EB		 3612 return NOTIFY_DONE;
3613
1da177e4
LT		 3614 dprintk("event_dev: %s, event: %lx\n",
3615 (event_dev ? event_dev->name : "None"),
3616 event);
3617
0b680e75
JV		 3618 if (!(event_dev->priv_flags & IFF_BONDING))
3619 return NOTIFY_DONE;
3620
1da177e4
LT		 3621 if (event_dev->flags & IFF_MASTER) {
3622 dprintk("IFF_MASTER\n");
3623 return bond_master_netdev_event(event, event_dev);
3624 }
3625
3626 if (event_dev->flags & IFF_SLAVE) {
3627 dprintk("IFF_SLAVE\n");
3628 return bond_slave_netdev_event(event, event_dev);
3629 }
3630
3631 return NOTIFY_DONE;
3632}
3633
c3ade5ca
JV		 3634/*
3635 * bond_inetaddr_event: handle inetaddr notifier chain events.
3636 *
3637 * We keep track of device IPs primarily to use as source addresses in
3638 * ARP monitor probes (rather than spewing out broadcasts all the time).
3639 *
3640 * We track one IP for the main device (if it has one), plus one per VLAN.
3641 */
3642static int bond_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
3643{
3644 struct in_ifaddr *ifa = ptr;
3645 struct net_device *vlan_dev, *event_dev = ifa->ifa_dev->dev;
0883beca
PE		 3646 struct bonding *bond;
3647 struct vlan_entry *vlan;
c3ade5ca 3648
c346dca1 3649 if (dev_net(ifa->ifa_dev->dev) != &init_net)
6133fb1a
DL		 3650 return NOTIFY_DONE;
3651
0883beca 3652 list_for_each_entry(bond, &bond_dev_list, bond_list) {
c3ade5ca
JV		 3653 if (bond->dev == event_dev) {
3654 switch (event) {
3655 case NETDEV_UP:
3656 bond->master_ip = ifa->ifa_local;
3657 return NOTIFY_OK;
3658 case NETDEV_DOWN:
3659 bond->master_ip = bond_glean_dev_ip(bond->dev);
3660 return NOTIFY_OK;
3661 default:
3662 return NOTIFY_DONE;
3663 }
3664 }
3665
0883beca 3666 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
5c15bdec 3667 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
c3ade5ca
JV		 3668 if (vlan_dev == event_dev) {
3669 switch (event) {
3670 case NETDEV_UP:
3671 vlan->vlan_ip = ifa->ifa_local;
3672 return NOTIFY_OK;
3673 case NETDEV_DOWN:
3674 vlan->vlan_ip =
3675 bond_glean_dev_ip(vlan_dev);
3676 return NOTIFY_OK;
3677 default:
3678 return NOTIFY_DONE;
3679 }
3680 }
3681 }
3682 }
3683 return NOTIFY_DONE;
3684}
3685
1da177e4
LT		 3686static struct notifier_block bond_netdev_notifier = {
3687 .notifier_call = bond_netdev_event,
3688};
3689
c3ade5ca
JV		 3690static struct notifier_block bond_inetaddr_notifier = {
3691 .notifier_call = bond_inetaddr_event,
3692};
3693
1da177e4
LT		 3694/*-------------------------- Packet type handling ---------------------------*/
3695
3696/* register to receive lacpdus on a bond */
3697static void bond_register_lacpdu(struct bonding *bond)
3698{
3699 struct packet_type *pk_type = &(BOND_AD_INFO(bond).ad_pkt_type);
3700
3701 /* initialize packet type */
3702 pk_type->type = PKT_TYPE_LACPDU;
3703 pk_type->dev = bond->dev;
3704 pk_type->func = bond_3ad_lacpdu_recv;
3705
3706 dev_add_pack(pk_type);
3707}
3708
3709/* unregister to receive lacpdus on a bond */
3710static void bond_unregister_lacpdu(struct bonding *bond)
3711{
3712 dev_remove_pack(&(BOND_AD_INFO(bond).ad_pkt_type));
3713}
3714
f5b2b966
JV		 3715void bond_register_arp(struct bonding *bond)
3716{
3717 struct packet_type *pt = &bond->arp_mon_pt;
3718
c4f283b1
JV		 3719 if (pt->type)
3720 return;
3721
f5b2b966 3722 pt->type = htons(ETH_P_ARP);
e245cb71 3723 pt->dev = bond->dev;
f5b2b966
JV		 3724 pt->func = bond_arp_rcv;
3725 dev_add_pack(pt);
3726}
3727
3728void bond_unregister_arp(struct bonding *bond)
3729{
c4f283b1
JV		 3730 struct packet_type *pt = &bond->arp_mon_pt;
3731
3732 dev_remove_pack(pt);
3733 pt->type = 0;
f5b2b966
JV		 3734}
3735
169a3e66
JV		 3736/*---------------------------- Hashing Policies -----------------------------*/
3737
6f6652be
JV		 3738/*
3739 * Hash for the output device based upon layer 2 and layer 3 data. If
3740 * the packet is not IP mimic bond_xmit_hash_policy_l2()
3741 */
3742static int bond_xmit_hash_policy_l23(struct sk_buff *skb,
3743 struct net_device *bond_dev, int count)
3744{
3745 struct ethhdr *data = (struct ethhdr *)skb->data;
3746 struct iphdr *iph = ip_hdr(skb);
3747
f14c4e4e 3748 if (skb->protocol == htons(ETH_P_IP)) {
6f6652be
JV		 3749 return ((ntohl(iph->saddr ^ iph->daddr) & 0xffff) ^
3750 (data->h_dest[5] ^ bond_dev->dev_addr[5])) % count;
3751 }
3752
3753 return (data->h_dest[5] ^ bond_dev->dev_addr[5]) % count;
3754}
3755
169a3e66 3756/*
59c51591 3757 * Hash for the output device based upon layer 3 and layer 4 data. If
169a3e66
JV		 3758 * the packet is a frag or not TCP or UDP, just use layer 3 data. If it is
3759 * altogether not IP, mimic bond_xmit_hash_policy_l2()
3760 */
3761static int bond_xmit_hash_policy_l34(struct sk_buff *skb,
3762 struct net_device *bond_dev, int count)
3763{
3764 struct ethhdr *data = (struct ethhdr *)skb->data;
eddc9ec5 3765 struct iphdr *iph = ip_hdr(skb);
d3bb52b0 3766 __be16 *layer4hdr = (__be16 *)((u32 *)iph + iph->ihl);
169a3e66
JV		 3767 int layer4_xor = 0;
3768
f14c4e4e
BH		 3769 if (skb->protocol == htons(ETH_P_IP)) {
3770 if (!(iph->frag_off & htons(IP_MF|IP_OFFSET)) &&
169a3e66
JV		 3771 (iph->protocol == IPPROTO_TCP ||
3772 iph->protocol == IPPROTO_UDP)) {
d3bb52b0 3773 layer4_xor = ntohs((*layer4hdr ^ *(layer4hdr + 1)));
169a3e66
JV		 3774 }
3775 return (layer4_xor ^
3776 ((ntohl(iph->saddr ^ iph->daddr)) & 0xffff)) % count;
3777
3778 }
3779
3780 return (data->h_dest[5] ^ bond_dev->dev_addr[5]) % count;
3781}
3782
3783/*
3784 * Hash for the output device based upon layer 2 data
3785 */
3786static int bond_xmit_hash_policy_l2(struct sk_buff *skb,
3787 struct net_device *bond_dev, int count)
3788{
3789 struct ethhdr *data = (struct ethhdr *)skb->data;
3790
3791 return (data->h_dest[5] ^ bond_dev->dev_addr[5]) % count;
3792}
3793
1da177e4
LT		 3794/*-------------------------- Device entry points ----------------------------*/
3795
3796static int bond_open(struct net_device *bond_dev)
3797{
454d7c9b 3798 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 3799
3800 bond->kill_timers = 0;
3801
3802 if ((bond->params.mode == BOND_MODE_TLB) ||
3803 (bond->params.mode == BOND_MODE_ALB)) {
1da177e4
LT		 3804 /* bond_alb_initialize must be called before the timer
3805 * is started.
3806 */
3807 if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB))) {
3808 /* something went wrong - fail the open operation */
3809 return -1;
3810 }
3811
1b76b316
JV		 3812 INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
3813 queue_delayed_work(bond->wq, &bond->alb_work, 0);
1da177e4
LT		 3814 }
3815
3816 if (bond->params.miimon) { /* link check interval, in milliseconds. */
1b76b316
JV		 3817 INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor);
3818 queue_delayed_work(bond->wq, &bond->mii_work, 0);
1da177e4
LT		 3819 }
3820
3821 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
1b76b316
JV		 3822 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
3823 INIT_DELAYED_WORK(&bond->arp_work,
3824 bond_activebackup_arp_mon);
3825 else
3826 INIT_DELAYED_WORK(&bond->arp_work,
3827 bond_loadbalance_arp_mon);
3828
3829 queue_delayed_work(bond->wq, &bond->arp_work, 0);
f5b2b966
JV		 3830 if (bond->params.arp_validate)
3831 bond_register_arp(bond);
1da177e4
LT		 3832 }
3833
3834 if (bond->params.mode == BOND_MODE_8023AD) {
a40745f5 3835 INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
1b76b316 3836 queue_delayed_work(bond->wq, &bond->ad_work, 0);
1da177e4
LT		 3837 /* register to receive LACPDUs */
3838 bond_register_lacpdu(bond);
fd989c83 3839 bond_3ad_initiate_agg_selection(bond, 1);
1da177e4
LT		 3840 }
3841
3842 return 0;
3843}
3844
3845static int bond_close(struct net_device *bond_dev)
3846{
454d7c9b 3847 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 3848
3849 if (bond->params.mode == BOND_MODE_8023AD) {
3850 /* Unregister the receive of LACPDUs */
3851 bond_unregister_lacpdu(bond);
3852 }
3853
f5b2b966
JV		 3854 if (bond->params.arp_validate)
3855 bond_unregister_arp(bond);
3856
1da177e4
LT		 3857 write_lock_bh(&bond->lock);
3858
b59f9f74 3859 bond->send_grat_arp = 0;
305d552a 3860 bond->send_unsol_na = 0;
1da177e4
LT		 3861
3862 /* signal timers not to re-arm */
3863 bond->kill_timers = 1;
3864
3865 write_unlock_bh(&bond->lock);
3866
1da177e4 3867 if (bond->params.miimon) { /* link check interval, in milliseconds. */
1b76b316 3868 cancel_delayed_work(&bond->mii_work);
1da177e4
LT		 3869 }
3870
3871 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
1b76b316 3872 cancel_delayed_work(&bond->arp_work);
1da177e4
LT		 3873 }
3874
3875 switch (bond->params.mode) {
3876 case BOND_MODE_8023AD:
1b76b316 3877 cancel_delayed_work(&bond->ad_work);
1da177e4
LT		 3878 break;
3879 case BOND_MODE_TLB:
3880 case BOND_MODE_ALB:
1b76b316 3881 cancel_delayed_work(&bond->alb_work);
1da177e4
LT		 3882 break;
3883 default:
3884 break;
3885 }
3886
1da177e4
LT		 3887
3888 if ((bond->params.mode == BOND_MODE_TLB) ||
3889 (bond->params.mode == BOND_MODE_ALB)) {
3890 /* Must be called only after all
3891 * slaves have been released
3892 */
3893 bond_alb_deinitialize(bond);
3894 }
3895
3896 return 0;
3897}
3898
3899static struct net_device_stats *bond_get_stats(struct net_device *bond_dev)
3900{
454d7c9b 3901 struct bonding *bond = netdev_priv(bond_dev);
eeda3fd6 3902 struct net_device_stats *stats = &bond->stats;
2439f9eb 3903 struct net_device_stats local_stats;
1da177e4
LT		 3904 struct slave *slave;
3905 int i;
3906
2439f9eb 3907 memset(&local_stats, 0, sizeof(struct net_device_stats));
1da177e4
LT		 3908
3909 read_lock_bh(&bond->lock);
3910
3911 bond_for_each_slave(bond, slave, i) {
eeda3fd6
SH		 3912 const struct net_device_stats *sstats = dev_get_stats(slave->dev);
3913
2439f9eb
AG		 3914 local_stats.rx_packets += sstats->rx_packets;
3915 local_stats.rx_bytes += sstats->rx_bytes;
3916 local_stats.rx_errors += sstats->rx_errors;
3917 local_stats.rx_dropped += sstats->rx_dropped;
3918
3919 local_stats.tx_packets += sstats->tx_packets;
3920 local_stats.tx_bytes += sstats->tx_bytes;
3921 local_stats.tx_errors += sstats->tx_errors;
3922 local_stats.tx_dropped += sstats->tx_dropped;
3923
3924 local_stats.multicast += sstats->multicast;
3925 local_stats.collisions += sstats->collisions;
3926
3927 local_stats.rx_length_errors += sstats->rx_length_errors;
3928 local_stats.rx_over_errors += sstats->rx_over_errors;
3929 local_stats.rx_crc_errors += sstats->rx_crc_errors;
3930 local_stats.rx_frame_errors += sstats->rx_frame_errors;
3931 local_stats.rx_fifo_errors += sstats->rx_fifo_errors;
3932 local_stats.rx_missed_errors += sstats->rx_missed_errors;
3933
3934 local_stats.tx_aborted_errors += sstats->tx_aborted_errors;
3935 local_stats.tx_carrier_errors += sstats->tx_carrier_errors;
3936 local_stats.tx_fifo_errors += sstats->tx_fifo_errors;
3937 local_stats.tx_heartbeat_errors += sstats->tx_heartbeat_errors;
3938 local_stats.tx_window_errors += sstats->tx_window_errors;
3939 }
3940
3941 memcpy(stats, &local_stats, sizeof(struct net_device_stats));
1da177e4
LT		 3942
3943 read_unlock_bh(&bond->lock);
3944
3945 return stats;
3946}
3947
3948static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
3949{
3950 struct net_device *slave_dev = NULL;
3951 struct ifbond k_binfo;
3952 struct ifbond __user *u_binfo = NULL;
3953 struct ifslave k_sinfo;
3954 struct ifslave __user *u_sinfo = NULL;
3955 struct mii_ioctl_data *mii = NULL;
1da177e4
LT		 3956 int res = 0;
3957
3958 dprintk("bond_ioctl: master=%s, cmd=%d\n",
3959 bond_dev->name, cmd);
3960
3961 switch (cmd) {
1da177e4
LT		 3962 case SIOCGMIIPHY:
3963 mii = if_mii(ifr);
3964 if (!mii) {
3965 return -EINVAL;
3966 }
3967 mii->phy_id = 0;
3968 /* Fall Through */
3969 case SIOCGMIIREG:
3970 /*
3971 * We do this again just in case we were called by SIOCGMIIREG
3972 * instead of SIOCGMIIPHY.
3973 */
3974 mii = if_mii(ifr);
3975 if (!mii) {
3976 return -EINVAL;
3977 }
3978
3979 if (mii->reg_num == 1) {
454d7c9b 3980 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 3981 mii->val_out = 0;
6603a6f2 3982 read_lock(&bond->lock);
1da177e4 3983 read_lock(&bond->curr_slave_lock);
4e140079 3984 if (netif_carrier_ok(bond->dev)) {
1da177e4
LT		 3985 mii->val_out = BMSR_LSTATUS;
3986 }
3987 read_unlock(&bond->curr_slave_lock);
6603a6f2 3988 read_unlock(&bond->lock);
1da177e4
LT		 3989 }
3990
3991 return 0;
3992 case BOND_INFO_QUERY_OLD:
3993 case SIOCBONDINFOQUERY:
3994 u_binfo = (struct ifbond __user *)ifr->ifr_data;
3995
3996 if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond))) {
3997 return -EFAULT;
3998 }
3999
4000 res = bond_info_query(bond_dev, &k_binfo);
4001 if (res == 0) {
4002 if (copy_to_user(u_binfo, &k_binfo, sizeof(ifbond))) {
4003 return -EFAULT;
4004 }
4005 }
4006
4007 return res;
4008 case BOND_SLAVE_INFO_QUERY_OLD:
4009 case SIOCBONDSLAVEINFOQUERY:
4010 u_sinfo = (struct ifslave __user *)ifr->ifr_data;
4011
4012 if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave))) {
4013 return -EFAULT;
4014 }
4015
4016 res = bond_slave_info_query(bond_dev, &k_sinfo);
4017 if (res == 0) {
4018 if (copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave))) {
4019 return -EFAULT;
4020 }
4021 }
4022
4023 return res;
4024 default:
4025 /* Go on */
4026 break;
4027 }
4028
4029 if (!capable(CAP_NET_ADMIN)) {
4030 return -EPERM;
4031 }
4032
b76cdba9 4033 down_write(&(bonding_rwsem));
881d966b 4034 slave_dev = dev_get_by_name(&init_net, ifr->ifr_slave);
1da177e4
LT		 4035
4036 dprintk("slave_dev=%p: \n", slave_dev);
4037
4038 if (!slave_dev) {
4039 res = -ENODEV;
4040 } else {
4041 dprintk("slave_dev->name=%s: \n", slave_dev->name);
4042 switch (cmd) {
4043 case BOND_ENSLAVE_OLD:
4044 case SIOCBONDENSLAVE:
4045 res = bond_enslave(bond_dev, slave_dev);
4046 break;
4047 case BOND_RELEASE_OLD:
4048 case SIOCBONDRELEASE:
4049 res = bond_release(bond_dev, slave_dev);
4050 break;
4051 case BOND_SETHWADDR_OLD:
4052 case SIOCBONDSETHWADDR:
4053 res = bond_sethwaddr(bond_dev, slave_dev);
4054 break;
4055 case BOND_CHANGE_ACTIVE_OLD:
4056 case SIOCBONDCHANGEACTIVE:
4057 res = bond_ioctl_change_active(bond_dev, slave_dev);
4058 break;
4059 default:
4060 res = -EOPNOTSUPP;
4061 }
4062
4063 dev_put(slave_dev);
4064 }
4065
b76cdba9 4066 up_write(&(bonding_rwsem));
1da177e4
LT		 4067 return res;
4068}
4069
4070static void bond_set_multicast_list(struct net_device *bond_dev)
4071{
454d7c9b 4072 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 4073 struct dev_mc_list *dmi;
4074
1da177e4
LT		 4075 /*
4076 * Do promisc before checking multicast_mode
4077 */
4078 if ((bond_dev->flags & IFF_PROMISC) && !(bond->flags & IFF_PROMISC)) {
7e1a1ac1
WC		 4079 /*
4080 * FIXME: Need to handle the error when one of the multi-slaves
4081 * encounters error.
4082 */
1da177e4
LT		 4083 bond_set_promiscuity(bond, 1);
4084 }
4085
4086 if (!(bond_dev->flags & IFF_PROMISC) && (bond->flags & IFF_PROMISC)) {
4087 bond_set_promiscuity(bond, -1);
4088 }
4089
4090 /* set allmulti flag to slaves */
4091 if ((bond_dev->flags & IFF_ALLMULTI) && !(bond->flags & IFF_ALLMULTI)) {
7e1a1ac1
WC		 4092 /*
4093 * FIXME: Need to handle the error when one of the multi-slaves
4094 * encounters error.
4095 */
1da177e4
LT		 4096 bond_set_allmulti(bond, 1);
4097 }
4098
4099 if (!(bond_dev->flags & IFF_ALLMULTI) && (bond->flags & IFF_ALLMULTI)) {
4100 bond_set_allmulti(bond, -1);
4101 }
4102
80ee5ad2
JV		 4103 read_lock(&bond->lock);
4104
1da177e4
LT		 4105 bond->flags = bond_dev->flags;
4106
4107 /* looking for addresses to add to slaves' mc list */
4108 for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
4109 if (!bond_mc_list_find_dmi(dmi, bond->mc_list)) {
4110 bond_mc_add(bond, dmi->dmi_addr, dmi->dmi_addrlen);
4111 }
4112 }
4113
4114 /* looking for addresses to delete from slaves' list */
4115 for (dmi = bond->mc_list; dmi; dmi = dmi->next) {
4116 if (!bond_mc_list_find_dmi(dmi, bond_dev->mc_list)) {
4117 bond_mc_delete(bond, dmi->dmi_addr, dmi->dmi_addrlen);
4118 }
4119 }
4120
4121 /* save master's multicast list */
4122 bond_mc_list_destroy(bond);
4123 bond_mc_list_copy(bond_dev->mc_list, bond, GFP_ATOMIC);
4124
80ee5ad2 4125 read_unlock(&bond->lock);
1da177e4
LT		 4126}
4127
4128/*
4129 * Change the MTU of all of a master's slaves to match the master
4130 */
4131static int bond_change_mtu(struct net_device *bond_dev, int new_mtu)
4132{
454d7c9b 4133 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 4134 struct slave *slave, *stop_at;
4135 int res = 0;
4136 int i;
4137
4138 dprintk("bond=%p, name=%s, new_mtu=%d\n", bond,
4139 (bond_dev ? bond_dev->name : "None"), new_mtu);
4140
4141 /* Can't hold bond->lock with bh disabled here since
4142 * some base drivers panic. On the other hand we can't
4143 * hold bond->lock without bh disabled because we'll
4144 * deadlock. The only solution is to rely on the fact
4145 * that we're under rtnl_lock here, and the slaves
4146 * list won't change. This doesn't solve the problem
4147 * of setting the slave's MTU while it is
4148 * transmitting, but the assumption is that the base
4149 * driver can handle that.
4150 *
4151 * TODO: figure out a way to safely iterate the slaves
4152 * list, but without holding a lock around the actual
4153 * call to the base driver.
4154 */
4155
4156 bond_for_each_slave(bond, slave, i) {
4157 dprintk("s %p s->p %p c_m %p\n", slave,
4158 slave->prev, slave->dev->change_mtu);
e944ef79 4159
1da177e4
LT		 4160 res = dev_set_mtu(slave->dev, new_mtu);
4161
4162 if (res) {
4163 /* If we failed to set the slave's mtu to the new value
4164 * we must abort the operation even in ACTIVE_BACKUP
4165 * mode, because if we allow the backup slaves to have
4166 * different mtu values than the active slave we'll
4167 * need to change their mtu when doing a failover. That
4168 * means changing their mtu from timer context, which
4169 * is probably not a good idea.
4170 */
4171 dprintk("err %d %s\n", res, slave->dev->name);
4172 goto unwind;
4173 }
4174 }
4175
4176 bond_dev->mtu = new_mtu;
4177
4178 return 0;
4179
4180unwind:
4181 /* unwind from head to the slave that failed */
4182 stop_at = slave;
4183 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
4184 int tmp_res;
4185
4186 tmp_res = dev_set_mtu(slave->dev, bond_dev->mtu);
4187 if (tmp_res) {
4188 dprintk("unwind err %d dev %s\n", tmp_res,
4189 slave->dev->name);
4190 }
4191 }
4192
4193 return res;
4194}
4195
4196/*
4197 * Change HW address
4198 *
4199 * Note that many devices must be down to change the HW address, and
4200 * downing the master releases all slaves. We can make bonds full of
4201 * bonding devices to test this, however.
4202 */
4203static int bond_set_mac_address(struct net_device *bond_dev, void *addr)
4204{
454d7c9b 4205 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 4206 struct sockaddr *sa = addr, tmp_sa;
4207 struct slave *slave, *stop_at;
4208 int res = 0;
4209 int i;
4210
4211 dprintk("bond=%p, name=%s\n", bond, (bond_dev ? bond_dev->name : "None"));
4212
dd957c57 4213 /*
3915c1e8
JV		 4214 * If fail_over_mac is set to active, do nothing and return
4215 * success. Returning an error causes ifenslave to fail.
dd957c57 4216 */
3915c1e8 4217 if (bond->params.fail_over_mac == BOND_FOM_ACTIVE)
dd957c57 4218 return 0;
2ab82852 4219
1da177e4
LT		 4220 if (!is_valid_ether_addr(sa->sa_data)) {
4221 return -EADDRNOTAVAIL;
4222 }
4223
4224 /* Can't hold bond->lock with bh disabled here since
4225 * some base drivers panic. On the other hand we can't
4226 * hold bond->lock without bh disabled because we'll
4227 * deadlock. The only solution is to rely on the fact
4228 * that we're under rtnl_lock here, and the slaves
4229 * list won't change. This doesn't solve the problem
4230 * of setting the slave's hw address while it is
4231 * transmitting, but the assumption is that the base
4232 * driver can handle that.
4233 *
4234 * TODO: figure out a way to safely iterate the slaves
4235 * list, but without holding a lock around the actual
4236 * call to the base driver.
4237 */
4238
4239 bond_for_each_slave(bond, slave, i) {
4240 dprintk("slave %p %s\n", slave, slave->dev->name);
4241
4242 if (slave->dev->set_mac_address == NULL) {
4243 res = -EOPNOTSUPP;
4244 dprintk("EOPNOTSUPP %s\n", slave->dev->name);
4245 goto unwind;
4246 }
4247
4248 res = dev_set_mac_address(slave->dev, addr);
4249 if (res) {
4250 /* TODO: consider downing the slave
4251 * and retry ?
4252 * User should expect communications
4253 * breakage anyway until ARP finish
4254 * updating, so...
4255 */
4256 dprintk("err %d %s\n", res, slave->dev->name);
4257 goto unwind;
4258 }
4259 }
4260
4261 /* success */
4262 memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);
4263 return 0;
4264
4265unwind:
4266 memcpy(tmp_sa.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
4267 tmp_sa.sa_family = bond_dev->type;
4268
4269 /* unwind from head to the slave that failed */
4270 stop_at = slave;
4271 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
4272 int tmp_res;
4273
4274 tmp_res = dev_set_mac_address(slave->dev, &tmp_sa);
4275 if (tmp_res) {
4276 dprintk("unwind err %d dev %s\n", tmp_res,
4277 slave->dev->name);
4278 }
4279 }
4280
4281 return res;
4282}
4283
4284static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
4285{
454d7c9b 4286 struct bonding *bond = netdev_priv(bond_dev);
1da177e4 4287 struct slave *slave, *start_at;
cf5f9044 4288 int i, slave_no, res = 1;
1da177e4
LT		 4289
4290 read_lock(&bond->lock);
4291
4292 if (!BOND_IS_OK(bond)) {
4293 goto out;
4294 }
4295
cf5f9044
JV		 4296 /*
4297 * Concurrent TX may collide on rr_tx_counter; we accept that
4298 * as being rare enough not to justify using an atomic op here
4299 */
4300 slave_no = bond->rr_tx_counter++ % bond->slave_cnt;
1da177e4 4301
cf5f9044
JV		 4302 bond_for_each_slave(bond, slave, i) {
4303 slave_no--;
4304 if (slave_no < 0) {
4305 break;
4306 }
1da177e4
LT		 4307 }
4308
cf5f9044 4309 start_at = slave;
1da177e4
LT		 4310 bond_for_each_slave_from(bond, slave, i, start_at) {
4311 if (IS_UP(slave->dev) &&
4312 (slave->link == BOND_LINK_UP) &&
4313 (slave->state == BOND_STATE_ACTIVE)) {
4314 res = bond_dev_queue_xmit(bond, skb, slave->dev);
1da177e4
LT		 4315 break;
4316 }
4317 }
4318
1da177e4
LT		 4319out:
4320 if (res) {
4321 /* no suitable interface, frame not sent */
4322 dev_kfree_skb(skb);
4323 }
4324 read_unlock(&bond->lock);
4325 return 0;
4326}
4327
075897ce 4328
1da177e4
LT		 4329/*
4330 * in active-backup mode, we know that bond->curr_active_slave is always valid if
4331 * the bond has a usable interface.
4332 */
4333static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_dev)
4334{
454d7c9b 4335 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 4336 int res = 1;
4337
1da177e4
LT		 4338 read_lock(&bond->lock);
4339 read_lock(&bond->curr_slave_lock);
4340
4341 if (!BOND_IS_OK(bond)) {
4342 goto out;
4343 }
4344
075897ce
JL		 4345 if (!bond->curr_active_slave)
4346 goto out;
4347
075897ce
JL		 4348 res = bond_dev_queue_xmit(bond, skb, bond->curr_active_slave->dev);
4349
1da177e4
LT		 4350out:
4351 if (res) {
4352 /* no suitable interface, frame not sent */
4353 dev_kfree_skb(skb);
4354 }
4355 read_unlock(&bond->curr_slave_lock);
4356 read_unlock(&bond->lock);
4357 return 0;
4358}
4359
4360/*
169a3e66
JV		 4361 * In bond_xmit_xor() , we determine the output device by using a pre-
4362 * determined xmit_hash_policy(), If the selected device is not enabled,
4363 * find the next active slave.
1da177e4
LT		 4364 */
4365static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
4366{
454d7c9b 4367 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 4368 struct slave *slave, *start_at;
4369 int slave_no;
4370 int i;
4371 int res = 1;
4372
4373 read_lock(&bond->lock);
4374
4375 if (!BOND_IS_OK(bond)) {
4376 goto out;
4377 }
4378
169a3e66 4379 slave_no = bond->xmit_hash_policy(skb, bond_dev, bond->slave_cnt);
1da177e4
LT		 4380
4381 bond_for_each_slave(bond, slave, i) {
4382 slave_no--;
4383 if (slave_no < 0) {
4384 break;
4385 }
4386 }
4387
4388 start_at = slave;
4389
4390 bond_for_each_slave_from(bond, slave, i, start_at) {
4391 if (IS_UP(slave->dev) &&
4392 (slave->link == BOND_LINK_UP) &&
4393 (slave->state == BOND_STATE_ACTIVE)) {
4394 res = bond_dev_queue_xmit(bond, skb, slave->dev);
4395 break;
4396 }
4397 }
4398
4399out:
4400 if (res) {
4401 /* no suitable interface, frame not sent */
4402 dev_kfree_skb(skb);
4403 }
4404 read_unlock(&bond->lock);
4405 return 0;
4406}
4407
4408/*
4409 * in broadcast mode, we send everything to all usable interfaces.
4410 */
4411static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
4412{
454d7c9b 4413 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 4414 struct slave *slave, *start_at;
4415 struct net_device *tx_dev = NULL;
4416 int i;
4417 int res = 1;
4418
4419 read_lock(&bond->lock);
4420
4421 if (!BOND_IS_OK(bond)) {
4422 goto out;
4423 }
4424
4425 read_lock(&bond->curr_slave_lock);
4426 start_at = bond->curr_active_slave;
4427 read_unlock(&bond->curr_slave_lock);
4428
4429 if (!start_at) {
4430 goto out;
4431 }
4432
4433 bond_for_each_slave_from(bond, slave, i, start_at) {
4434 if (IS_UP(slave->dev) &&
4435 (slave->link == BOND_LINK_UP) &&
4436 (slave->state == BOND_STATE_ACTIVE)) {
4437 if (tx_dev) {
4438 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
4439 if (!skb2) {
4440 printk(KERN_ERR DRV_NAME
4e0952c7
MW		 4441 ": %s: Error: bond_xmit_broadcast(): "
4442 "skb_clone() failed\n",
4443 bond_dev->name);
1da177e4
LT		 4444 continue;
4445 }
4446
4447 res = bond_dev_queue_xmit(bond, skb2, tx_dev);
4448 if (res) {
4449 dev_kfree_skb(skb2);
4450 continue;
4451 }
4452 }
4453 tx_dev = slave->dev;
4454 }
4455 }
4456
4457 if (tx_dev) {
4458 res = bond_dev_queue_xmit(bond, skb, tx_dev);
4459 }
4460
4461out:
4462 if (res) {
4463 /* no suitable interface, frame not sent */
4464 dev_kfree_skb(skb);
4465 }
4466 /* frame sent to all suitable interfaces */
4467 read_unlock(&bond->lock);
4468 return 0;
4469}
4470
4471/*------------------------- Device initialization ---------------------------*/
4472
6f6652be
JV		 4473static void bond_set_xmit_hash_policy(struct bonding *bond)
4474{
4475 switch (bond->params.xmit_policy) {
4476 case BOND_XMIT_POLICY_LAYER23:
4477 bond->xmit_hash_policy = bond_xmit_hash_policy_l23;
4478 break;
4479 case BOND_XMIT_POLICY_LAYER34:
4480 bond->xmit_hash_policy = bond_xmit_hash_policy_l34;
4481 break;
4482 case BOND_XMIT_POLICY_LAYER2:
4483 default:
4484 bond->xmit_hash_policy = bond_xmit_hash_policy_l2;
4485 break;
4486 }
4487}
4488
1da177e4
LT		 4489/*
4490 * set bond mode specific net device operations
4491 */
a77b5325 4492void bond_set_mode_ops(struct bonding *bond, int mode)
1da177e4 4493{
169a3e66
JV		 4494 struct net_device *bond_dev = bond->dev;
4495
1da177e4
LT		 4496 switch (mode) {
4497 case BOND_MODE_ROUNDROBIN:
4498 bond_dev->hard_start_xmit = bond_xmit_roundrobin;
4499 break;
4500 case BOND_MODE_ACTIVEBACKUP:
4501 bond_dev->hard_start_xmit = bond_xmit_activebackup;
4502 break;
4503 case BOND_MODE_XOR:
4504 bond_dev->hard_start_xmit = bond_xmit_xor;
6f6652be 4505 bond_set_xmit_hash_policy(bond);
1da177e4
LT		 4506 break;
4507 case BOND_MODE_BROADCAST:
4508 bond_dev->hard_start_xmit = bond_xmit_broadcast;
4509 break;
4510 case BOND_MODE_8023AD:
8f903c70 4511 bond_set_master_3ad_flags(bond);
1da177e4 4512 bond_dev->hard_start_xmit = bond_3ad_xmit_xor;
6f6652be 4513 bond_set_xmit_hash_policy(bond);
1da177e4 4514 break;
1da177e4 4515 case BOND_MODE_ALB:
8f903c70
JV		 4516 bond_set_master_alb_flags(bond);
4517 /* FALLTHRU */
4518 case BOND_MODE_TLB:
1da177e4
LT		 4519 bond_dev->hard_start_xmit = bond_alb_xmit;
4520 bond_dev->set_mac_address = bond_alb_set_mac_address;
4521 break;
4522 default:
4523 /* Should never happen, mode already checked */
4524 printk(KERN_ERR DRV_NAME
4e0952c7
MW		 4525 ": %s: Error: Unknown bonding mode %d\n",
4526 bond_dev->name,
1da177e4
LT		 4527 mode);
4528 break;
4529 }
4530}
4531
217df670
JV		 4532static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
4533 struct ethtool_drvinfo *drvinfo)
4534{
4535 strncpy(drvinfo->driver, DRV_NAME, 32);
4536 strncpy(drvinfo->version, DRV_VERSION, 32);
4537 snprintf(drvinfo->fw_version, 32, "%d", BOND_ABI_VERSION);
4538}
4539
7282d491 4540static const struct ethtool_ops bond_ethtool_ops = {
217df670 4541 .get_drvinfo = bond_ethtool_get_drvinfo,
fa53ebac
SH		 4542 .get_link = ethtool_op_get_link,
4543 .get_tx_csum = ethtool_op_get_tx_csum,
4544 .get_sg = ethtool_op_get_sg,
4545 .get_tso = ethtool_op_get_tso,
4546 .get_ufo = ethtool_op_get_ufo,
4547 .get_flags = ethtool_op_get_flags,
8531c5ff
AK		 4548};
4549
1da177e4
LT		 4550/*
4551 * Does not allocate but creates a /proc entry.
4552 * Allowed to fail.
4553 */
3c535952 4554static int bond_init(struct net_device *bond_dev, struct bond_params *params)
1da177e4 4555{
454d7c9b 4556 struct bonding *bond = netdev_priv(bond_dev);
1da177e4
LT		 4557
4558 dprintk("Begin bond_init for %s\n", bond_dev->name);
4559
4560 /* initialize rwlocks */
4561 rwlock_init(&bond->lock);
4562 rwlock_init(&bond->curr_slave_lock);
4563
4564 bond->params = *params; /* copy params struct */
4565
1b76b316
JV		 4566 bond->wq = create_singlethread_workqueue(bond_dev->name);
4567 if (!bond->wq)
4568 return -ENOMEM;
4569
1da177e4
LT		 4570 /* Initialize pointers */
4571 bond->first_slave = NULL;
4572 bond->curr_active_slave = NULL;
4573 bond->current_arp_slave = NULL;
4574 bond->primary_slave = NULL;
4575 bond->dev = bond_dev;
1053f62c 4576 bond->send_grat_arp = 0;
305d552a 4577 bond->send_unsol_na = 0;
d90a162a 4578 bond->setup_by_slave = 0;
1da177e4
LT		 4579 INIT_LIST_HEAD(&bond->vlan_list);
4580
4581 /* Initialize the device entry points */
4582 bond_dev->open = bond_open;
4583 bond_dev->stop = bond_close;
4584 bond_dev->get_stats = bond_get_stats;
4585 bond_dev->do_ioctl = bond_do_ioctl;
8531c5ff 4586 bond_dev->ethtool_ops = &bond_ethtool_ops;
1da177e4
LT		 4587 bond_dev->set_multicast_list = bond_set_multicast_list;
4588 bond_dev->change_mtu = bond_change_mtu;
4589 bond_dev->set_mac_address = bond_set_mac_address;
3a1521b7 4590 bond_dev->validate_addr = NULL;
1da177e4 4591
169a3e66 4592 bond_set_mode_ops(bond, bond->params.mode);
1da177e4 4593
a434e43f 4594 bond_dev->destructor = bond_destructor;
1da177e4
LT		 4595
4596 /* Initialize the device options */
4597 bond_dev->tx_queue_len = 0;
4598 bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
0b680e75 4599 bond_dev->priv_flags |= IFF_BONDING;
6cf3f41e
JV		 4600 if (bond->params.arp_interval)
4601 bond_dev->priv_flags |= IFF_MASTER_ARPMON;
1da177e4
LT		 4602
4603 /* At first, we block adding VLANs. That's the only way to
4604 * prevent problems that occur when adding VLANs over an
4605 * empty bond. The block will be removed once non-challenged
4606 * slaves are enslaved.
4607 */
4608 bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
4609
932ff279 4610 /* don't acquire bond device's netif_tx_lock when
1da177e4
LT		 4611 * transmitting */
4612 bond_dev->features |= NETIF_F_LLTX;
4613
4614 /* By default, we declare the bond to be fully
4615 * VLAN hardware accelerated capable. Special
4616 * care is taken in the various xmit functions
4617 * when there are slaves that are not hw accel
4618 * capable
4619 */
4620 bond_dev->vlan_rx_register = bond_vlan_rx_register;
4621 bond_dev->vlan_rx_add_vid = bond_vlan_rx_add_vid;
4622 bond_dev->vlan_rx_kill_vid = bond_vlan_rx_kill_vid;
4623 bond_dev->features |= (NETIF_F_HW_VLAN_TX |
4624 NETIF_F_HW_VLAN_RX |
4625 NETIF_F_HW_VLAN_FILTER);
4626
4627#ifdef CONFIG_PROC_FS
4628 bond_create_proc_entry(bond);
4629#endif
1da177e4
LT		 4630 list_add_tail(&bond->bond_list, &bond_dev_list);
4631
4632 return 0;
4633}
4634
fdaea7a9
JV		 4635static void bond_work_cancel_all(struct bonding *bond)
4636{
4637 write_lock_bh(&bond->lock);
4638 bond->kill_timers = 1;
4639 write_unlock_bh(&bond->lock);
4640
4641 if (bond->params.miimon && delayed_work_pending(&bond->mii_work))
4642 cancel_delayed_work(&bond->mii_work);
4643
4644 if (bond->params.arp_interval && delayed_work_pending(&bond->arp_work))
4645 cancel_delayed_work(&bond->arp_work);
4646
4647 if (bond->params.mode == BOND_MODE_ALB &&
4648 delayed_work_pending(&bond->alb_work))
4649 cancel_delayed_work(&bond->alb_work);
4650
4651 if (bond->params.mode == BOND_MODE_8023AD &&
4652 delayed_work_pending(&bond->ad_work))
4653 cancel_delayed_work(&bond->ad_work);
4654}
4655
a434e43f
JV		 4656/* De-initialize device specific data.
4657 * Caller must hold rtnl_lock.
4658 */
4659static void bond_deinit(struct net_device *bond_dev)
4660{
454d7c9b 4661 struct bonding *bond = netdev_priv(bond_dev);
a434e43f
JV		 4662
4663 list_del(&bond->bond_list);
4664
4665 bond_work_cancel_all(bond);
4666
4667#ifdef CONFIG_PROC_FS
4668 bond_remove_proc_entry(bond);
4669#endif
4670}
4671
1da177e4
LT		 4672/* Unregister and free all bond devices.
4673 * Caller must hold rtnl_lock.
4674 */
4675static void bond_free_all(void)
4676{
4677 struct bonding *bond, *nxt;
4678
4679 list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list) {
4680 struct net_device *bond_dev = bond->dev;
4681
fdaea7a9 4682 bond_work_cancel_all(bond);
70298705 4683 /* Release the bonded slaves */
4684 bond_release_all(bond_dev);
92b41daa 4685 bond_destroy(bond);
1da177e4
LT		 4686 }
4687
4688#ifdef CONFIG_PROC_FS
4689 bond_destroy_proc_dir();
4690#endif
4691}
4692
4693/*------------------------- Module initialization ---------------------------*/
4694
4695/*
4696 * Convert string input module parms. Accept either the
ece95f7f
JV		 4697 * number of the mode or its string name. A bit complicated because
4698 * some mode names are substrings of other names, and calls from sysfs
4699 * may have whitespace in the name (trailing newlines, for example).
1da177e4 4700 */
ece95f7f 4701int bond_parse_parm(const char *buf, struct bond_parm_tbl *tbl)
1da177e4 4702{
ece95f7f 4703 int mode = -1, i, rv;
a42e534f 4704 char *p, modestr[BOND_MAX_MODENAME_LEN + 1] = { 0, };
ece95f7f 4705
a42e534f
JV		 4706 for (p = (char *)buf; *p; p++)
4707 if (!(isdigit(*p) || isspace(*p)))
4708 break;
4709
4710 if (*p)
ece95f7f 4711 rv = sscanf(buf, "%20s", modestr);
a42e534f
JV		 4712 else
4713 rv = sscanf(buf, "%d", &mode);
4714
4715 if (!rv)
4716 return -1;
1da177e4
LT		 4717
4718 for (i = 0; tbl[i].modename; i++) {
ece95f7f
JV		 4719 if (mode == tbl[i].mode)
4720 return tbl[i].mode;
4721 if (strcmp(modestr, tbl[i].modename) == 0)
1da177e4 4722 return tbl[i].mode;
1da177e4
LT		 4723 }
4724
4725 return -1;
4726}
4727
4728static int bond_check_params(struct bond_params *params)
4729{
3915c1e8 4730 int arp_validate_value, fail_over_mac_value;
f5b2b966 4731
1da177e4
LT		 4732 /*
4733 * Convert string parameters.
4734 */
4735 if (mode) {
4736 bond_mode = bond_parse_parm(mode, bond_mode_tbl);
4737 if (bond_mode == -1) {
4738 printk(KERN_ERR DRV_NAME
4739 ": Error: Invalid bonding mode \"%s\"\n",
4740 mode == NULL ? "NULL" : mode);
4741 return -EINVAL;
4742 }
4743 }
4744
169a3e66
JV		 4745 if (xmit_hash_policy) {
4746 if ((bond_mode != BOND_MODE_XOR) &&
4747 (bond_mode != BOND_MODE_8023AD)) {
4748 printk(KERN_INFO DRV_NAME
4749 ": xor_mode param is irrelevant in mode %s\n",
4750 bond_mode_name(bond_mode));
4751 } else {
4752 xmit_hashtype = bond_parse_parm(xmit_hash_policy,
4753 xmit_hashtype_tbl);
4754 if (xmit_hashtype == -1) {
4755 printk(KERN_ERR DRV_NAME
4756 ": Error: Invalid xmit_hash_policy \"%s\"\n",
4757 xmit_hash_policy == NULL ? "NULL" :
4758 xmit_hash_policy);
4759 return -EINVAL;
4760 }
4761 }
4762 }
4763
1da177e4
LT		 4764 if (lacp_rate) {
4765 if (bond_mode != BOND_MODE_8023AD) {
4766 printk(KERN_INFO DRV_NAME
4767 ": lacp_rate param is irrelevant in mode %s\n",
4768 bond_mode_name(bond_mode));
4769 } else {
4770 lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl);
4771 if (lacp_fast == -1) {
4772 printk(KERN_ERR DRV_NAME
4773 ": Error: Invalid lacp rate \"%s\"\n",
4774 lacp_rate == NULL ? "NULL" : lacp_rate);
4775 return -EINVAL;
4776 }
4777 }
4778 }
4779
fd989c83
JV		 4780 if (ad_select) {
4781 params->ad_select = bond_parse_parm(ad_select, ad_select_tbl);
4782 if (params->ad_select == -1) {
4783 printk(KERN_ERR DRV_NAME
4784 ": Error: Invalid ad_select \"%s\"\n",
4785 ad_select == NULL ? "NULL" : ad_select);
4786 return -EINVAL;
4787 }
4788
4789 if (bond_mode != BOND_MODE_8023AD) {
4790 printk(KERN_WARNING DRV_NAME
4791 ": ad_select param only affects 802.3ad mode\n");
4792 }
4793 } else {
4794 params->ad_select = BOND_AD_STABLE;
4795 }
4796
b8a9787e 4797 if (max_bonds < 0 || max_bonds > INT_MAX) {
1da177e4
LT		 4798 printk(KERN_WARNING DRV_NAME
4799 ": Warning: max_bonds (%d) not in range %d-%d, so it "
4e0952c7 4800 "was reset to BOND_DEFAULT_MAX_BONDS (%d)\n",
b8a9787e 4801 max_bonds, 0, INT_MAX, BOND_DEFAULT_MAX_BONDS);
1da177e4
LT		 4802 max_bonds = BOND_DEFAULT_MAX_BONDS;
4803 }
4804
4805 if (miimon < 0) {
4806 printk(KERN_WARNING DRV_NAME
4807 ": Warning: miimon module parameter (%d), "
4808 "not in range 0-%d, so it was reset to %d\n",
4809 miimon, INT_MAX, BOND_LINK_MON_INTERV);
4810 miimon = BOND_LINK_MON_INTERV;
4811 }
4812
4813 if (updelay < 0) {
4814 printk(KERN_WARNING DRV_NAME
4815 ": Warning: updelay module parameter (%d), "
4816 "not in range 0-%d, so it was reset to 0\n",
4817 updelay, INT_MAX);
4818 updelay = 0;
4819 }
4820
4821 if (downdelay < 0) {
4822 printk(KERN_WARNING DRV_NAME
4823 ": Warning: downdelay module parameter (%d), "
4824 "not in range 0-%d, so it was reset to 0\n",
4825 downdelay, INT_MAX);
4826 downdelay = 0;
4827 }
4828
4829 if ((use_carrier != 0) && (use_carrier != 1)) {
4830 printk(KERN_WARNING DRV_NAME
4831 ": Warning: use_carrier module parameter (%d), "
4832 "not of valid value (0/1), so it was set to 1\n",
4833 use_carrier);
4834 use_carrier = 1;
4835 }
4836
7893b249
MS		 4837 if (num_grat_arp < 0 || num_grat_arp > 255) {
4838 printk(KERN_WARNING DRV_NAME
4839 ": Warning: num_grat_arp (%d) not in range 0-255 so it "
4840 "was reset to 1 \n", num_grat_arp);
4841 num_grat_arp = 1;
4842 }
4843
305d552a
BH		 4844 if (num_unsol_na < 0 || num_unsol_na > 255) {
4845 printk(KERN_WARNING DRV_NAME
4846 ": Warning: num_unsol_na (%d) not in range 0-255 so it "
4847 "was reset to 1 \n", num_unsol_na);
4848 num_unsol_na = 1;
4849 }
4850
1da177e4
LT		 4851 /* reset values for 802.3ad */
4852 if (bond_mode == BOND_MODE_8023AD) {
4853 if (!miimon) {
4854 printk(KERN_WARNING DRV_NAME
4855 ": Warning: miimon must be specified, "
4856 "otherwise bonding will not detect link "
4857 "failure, speed and duplex which are "
4858 "essential for 802.3ad operation\n");
4859 printk(KERN_WARNING "Forcing miimon to 100msec\n");
4860 miimon = 100;
4861 }
4862 }
4863
4864 /* reset values for TLB/ALB */
4865 if ((bond_mode == BOND_MODE_TLB) ||
4866 (bond_mode == BOND_MODE_ALB)) {
4867 if (!miimon) {
4868 printk(KERN_WARNING DRV_NAME
4869 ": Warning: miimon must be specified, "
4870 "otherwise bonding will not detect link "
4871 "failure and link speed which are essential "
4872 "for TLB/ALB load balancing\n");
4873 printk(KERN_WARNING "Forcing miimon to 100msec\n");
4874 miimon = 100;
4875 }
4876 }
4877
4878 if (bond_mode == BOND_MODE_ALB) {
4879 printk(KERN_NOTICE DRV_NAME
4880 ": In ALB mode you might experience client "
4881 "disconnections upon reconnection of a link if the "
4882 "bonding module updelay parameter (%d msec) is "
4883 "incompatible with the forwarding delay time of the "
4884 "switch\n",
4885 updelay);
4886 }
4887
4888 if (!miimon) {
4889 if (updelay || downdelay) {
4890 /* just warn the user the up/down delay will have
4891 * no effect since miimon is zero...
4892 */
4893 printk(KERN_WARNING DRV_NAME
4894 ": Warning: miimon module parameter not set "
4895 "and updelay (%d) or downdelay (%d) module "
4896 "parameter is set; updelay and downdelay have "
4897 "no effect unless miimon is set\n",
4898 updelay, downdelay);
4899 }
4900 } else {
4901 /* don't allow arp monitoring */
4902 if (arp_interval) {
4903 printk(KERN_WARNING DRV_NAME
4904 ": Warning: miimon (%d) and arp_interval (%d) "
4905 "can't be used simultaneously, disabling ARP "
4906 "monitoring\n",
4907 miimon, arp_interval);
4908 arp_interval = 0;
4909 }
4910
4911 if ((updelay % miimon) != 0) {
4912 printk(KERN_WARNING DRV_NAME
4913 ": Warning: updelay (%d) is not a multiple "
4914 "of miimon (%d), updelay rounded to %d ms\n",
4915 updelay, miimon, (updelay / miimon) * miimon);
4916 }
4917
4918 updelay /= miimon;
4919
4920 if ((downdelay % miimon) != 0) {
4921 printk(KERN_WARNING DRV_NAME
4922 ": Warning: downdelay (%d) is not a multiple "
4923 "of miimon (%d), downdelay rounded to %d ms\n",
4924 downdelay, miimon,
4925 (downdelay / miimon) * miimon);
4926 }
4927
4928 downdelay /= miimon;
4929 }
4930
4931 if (arp_interval < 0) {
4932 printk(KERN_WARNING DRV_NAME
4933 ": Warning: arp_interval module parameter (%d) "
4934 ", not in range 0-%d, so it was reset to %d\n",
4935 arp_interval, INT_MAX, BOND_LINK_ARP_INTERV);
4936 arp_interval = BOND_LINK_ARP_INTERV;
4937 }
4938
4939 for (arp_ip_count = 0;
4940 (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[arp_ip_count];
4941 arp_ip_count++) {
4942 /* not complete check, but should be good enough to
4943 catch mistakes */
4944 if (!isdigit(arp_ip_target[arp_ip_count][0])) {
4945 printk(KERN_WARNING DRV_NAME
4946 ": Warning: bad arp_ip_target module parameter "
4947 "(%s), ARP monitoring will not be performed\n",
4948 arp_ip_target[arp_ip_count]);
4949 arp_interval = 0;
4950 } else {
d3bb52b0 4951 __be32 ip = in_aton(arp_ip_target[arp_ip_count]);
1da177e4
LT		 4952 arp_target[arp_ip_count] = ip;
4953 }
4954 }
4955
4956 if (arp_interval && !arp_ip_count) {
4957 /* don't allow arping if no arp_ip_target given... */
4958 printk(KERN_WARNING DRV_NAME
4959 ": Warning: arp_interval module parameter (%d) "
4960 "specified without providing an arp_ip_target "
4961 "parameter, arp_interval was reset to 0\n",
4962 arp_interval);
4963 arp_interval = 0;
4964 }
4965
f5b2b966
JV		 4966 if (arp_validate) {
4967 if (bond_mode != BOND_MODE_ACTIVEBACKUP) {
4968 printk(KERN_ERR DRV_NAME
4969 ": arp_validate only supported in active-backup mode\n");
4970 return -EINVAL;
4971 }
4972 if (!arp_interval) {
4973 printk(KERN_ERR DRV_NAME
4974 ": arp_validate requires arp_interval\n");
4975 return -EINVAL;
4976 }
4977
4978 arp_validate_value = bond_parse_parm(arp_validate,
4979 arp_validate_tbl);
4980 if (arp_validate_value == -1) {
4981 printk(KERN_ERR DRV_NAME
4982 ": Error: invalid arp_validate \"%s\"\n",
4983 arp_validate == NULL ? "NULL" : arp_validate);
4984 return -EINVAL;
4985 }
4986 } else
4987 arp_validate_value = 0;
4988
1da177e4
LT		 4989 if (miimon) {
4990 printk(KERN_INFO DRV_NAME
4991 ": MII link monitoring set to %d ms\n",
4992 miimon);
4993 } else if (arp_interval) {
4994 int i;
4995
4996 printk(KERN_INFO DRV_NAME
f5b2b966
JV		 4997 ": ARP monitoring set to %d ms, validate %s, with %d target(s):",
4998 arp_interval,
4999 arp_validate_tbl[arp_validate_value].modename,
5000 arp_ip_count);
1da177e4
LT		 5001
5002 for (i = 0; i < arp_ip_count; i++)
5003 printk (" %s", arp_ip_target[i]);
5004
5005 printk("\n");
5006
b8a9787e 5007 } else if (max_bonds) {
1da177e4
LT		 5008 /* miimon and arp_interval not set, we need one so things
5009 * work as expected, see bonding.txt for details
5010 */
5011 printk(KERN_WARNING DRV_NAME
5012 ": Warning: either miimon or arp_interval and "
5013 "arp_ip_target module parameters must be specified, "
5014 "otherwise bonding will not detect link failures! see "
5015 "bonding.txt for details.\n");
5016 }
5017
5018 if (primary && !USES_PRIMARY(bond_mode)) {
5019 /* currently, using a primary only makes sense
5020 * in active backup, TLB or ALB modes
5021 */
5022 printk(KERN_WARNING DRV_NAME
5023 ": Warning: %s primary device specified but has no "
5024 "effect in %s mode\n",
5025 primary, bond_mode_name(bond_mode));
5026 primary = NULL;
5027 }
5028
3915c1e8
JV		 5029 if (fail_over_mac) {
5030 fail_over_mac_value = bond_parse_parm(fail_over_mac,
5031 fail_over_mac_tbl);
5032 if (fail_over_mac_value == -1) {
5033 printk(KERN_ERR DRV_NAME
5034 ": Error: invalid fail_over_mac \"%s\"\n",
5035 arp_validate == NULL ? "NULL" : arp_validate);
5036 return -EINVAL;
5037 }
5038
5039 if (bond_mode != BOND_MODE_ACTIVEBACKUP)
5040 printk(KERN_WARNING DRV_NAME
5041 ": Warning: fail_over_mac only affects "
5042 "active-backup mode.\n");
5043 } else {
5044 fail_over_mac_value = BOND_FOM_NONE;
5045 }
dd957c57 5046
1da177e4
LT		 5047 /* fill params struct with the proper values */
5048 params->mode = bond_mode;
169a3e66 5049 params->xmit_policy = xmit_hashtype;
1da177e4 5050 params->miimon = miimon;
7893b249 5051 params->num_grat_arp = num_grat_arp;
305d552a 5052 params->num_unsol_na = num_unsol_na;
1da177e4 5053 params->arp_interval = arp_interval;
f5b2b966 5054 params->arp_validate = arp_validate_value;
1da177e4
LT		 5055 params->updelay = updelay;
5056 params->downdelay = downdelay;
5057 params->use_carrier = use_carrier;
5058 params->lacp_fast = lacp_fast;
5059 params->primary[0] = 0;
3915c1e8 5060 params->fail_over_mac = fail_over_mac_value;
1da177e4
LT		 5061
5062 if (primary) {
5063 strncpy(params->primary, primary, IFNAMSIZ);
5064 params->primary[IFNAMSIZ - 1] = 0;
5065 }
5066
5067 memcpy(params->arp_targets, arp_target, sizeof(arp_target));
5068
5069 return 0;
5070}
5071
0daa2303 5072static struct lock_class_key bonding_netdev_xmit_lock_key;
cf508b12 5073static struct lock_class_key bonding_netdev_addr_lock_key;
0daa2303 5074
e8a0464c
DM		 5075static void bond_set_lockdep_class_one(struct net_device *dev,
5076 struct netdev_queue *txq,
5077 void *_unused)
c773e847
DM		 5078{
5079 lockdep_set_class(&txq->_xmit_lock,
5080 &bonding_netdev_xmit_lock_key);
5081}
5082
5083static void bond_set_lockdep_class(struct net_device *dev)
5084{
cf508b12
DM		 5085 lockdep_set_class(&dev->addr_list_lock,
5086 &bonding_netdev_addr_lock_key);
e8a0464c 5087 netdev_for_each_tx_queue(dev, bond_set_lockdep_class_one, NULL);
c773e847
DM		 5088}
5089
dfe60397 5090/* Create a new bond based on the specified name and bonding parameters.
e4b91c48 5091 * If name is NULL, obtain a suitable "bond%d" name for us.
dfe60397
MW		 5092 * Caller must NOT hold rtnl_lock; we need to release it here before we
5093 * set up our sysfs entries.
5094 */
0dd646fe 5095int bond_create(char *name, struct bond_params *params)
dfe60397
MW		 5096{
5097 struct net_device *bond_dev;
0883beca 5098 struct bonding *bond;
dfe60397
MW		 5099 int res;
5100
5101 rtnl_lock();
027ea041
JV		 5102 down_write(&bonding_rwsem);
5103
5104 /* Check to see if the bond already exists. */
4fe4763c 5105 if (name) {
0883beca 5106 list_for_each_entry(bond, &bond_dev_list, bond_list)
4fe4763c
JV		 5107 if (strnicmp(bond->dev->name, name, IFNAMSIZ) == 0) {
5108 printk(KERN_ERR DRV_NAME
027ea041 5109 ": cannot add bond %s; it already exists\n",
4fe4763c
JV		 5110 name);
5111 res = -EPERM;
5112 goto out_rtnl;
5113 }
5114 }
027ea041 5115
e4b91c48
JV		 5116 bond_dev = alloc_netdev(sizeof(struct bonding), name ? name : "",
5117 ether_setup);
dfe60397
MW		 5118 if (!bond_dev) {
5119 printk(KERN_ERR DRV_NAME
5120 ": %s: eek! can't alloc netdev!\n",
5121 name);
5122 res = -ENOMEM;
5123 goto out_rtnl;
5124 }
5125
e4b91c48
JV		 5126 if (!name) {
5127 res = dev_alloc_name(bond_dev, "bond%d");
5128 if (res < 0)
5129 goto out_netdev;
5130 }
5131
dfe60397
MW		 5132 /* bond_init() must be called after dev_alloc_name() (for the
5133 * /proc files), but before register_netdevice(), because we
5134 * need to set function pointers.
5135 */
5136
5137 res = bond_init(bond_dev, params);
5138 if (res < 0) {
5139 goto out_netdev;
5140 }
5141
dfe60397
MW		 5142 res = register_netdevice(bond_dev);
5143 if (res < 0) {
5144 goto out_bond;
5145 }
0daa2303 5146
c773e847 5147 bond_set_lockdep_class(bond_dev);
0daa2303 5148
ff59c456
JV		 5149 netif_carrier_off(bond_dev);
5150
027ea041 5151 up_write(&bonding_rwsem);
dfe60397 5152 rtnl_unlock(); /* allows sysfs registration of net device */
454d7c9b 5153 res = bond_create_sysfs_entry(netdev_priv(bond_dev));
09c89279
JV		 5154 if (res < 0) {
5155 rtnl_lock();
027ea041 5156 down_write(&bonding_rwsem);
822973ba
PE		 5157 bond_deinit(bond_dev);
5158 unregister_netdevice(bond_dev);
5159 goto out_rtnl;
09c89279
JV		 5160 }
5161
5162 return 0;
5163
dfe60397
MW		 5164out_bond:
5165 bond_deinit(bond_dev);
5166out_netdev:
5167 free_netdev(bond_dev);
5168out_rtnl:
027ea041 5169 up_write(&bonding_rwsem);
dfe60397 5170 rtnl_unlock();
dfe60397
MW		 5171 return res;
5172}
5173
1da177e4
LT		 5174static int __init bonding_init(void)
5175{
1da177e4
LT		 5176 int i;
5177 int res;
0883beca 5178 struct bonding *bond;
1da177e4
LT		 5179
5180 printk(KERN_INFO "%s", version);
5181
dfe60397 5182 res = bond_check_params(&bonding_defaults);
1da177e4 5183 if (res) {
dfe60397 5184 goto out;
1da177e4
LT		 5185 }
5186
1da177e4
LT		 5187#ifdef CONFIG_PROC_FS
5188 bond_create_proc_dir();
5189#endif
027ea041
JV		 5190
5191 init_rwsem(&bonding_rwsem);
5192
1da177e4 5193 for (i = 0; i < max_bonds; i++) {
0dd646fe 5194 res = bond_create(NULL, &bonding_defaults);
dfe60397
MW		 5195 if (res)
5196 goto err;
1da177e4
LT		 5197 }
5198
b76cdba9
MW		 5199 res = bond_create_sysfs();
5200 if (res)
5201 goto err;
5202
1da177e4 5203 register_netdevice_notifier(&bond_netdev_notifier);
c3ade5ca 5204 register_inetaddr_notifier(&bond_inetaddr_notifier);
305d552a 5205 bond_register_ipv6_notifier();
1da177e4 5206
dfe60397
MW		 5207 goto out;
5208err:
0883beca 5209 list_for_each_entry(bond, &bond_dev_list, bond_list) {
1b76b316
JV		 5210 bond_work_cancel_all(bond);
5211 destroy_workqueue(bond->wq);
5212 }
5213
ae68c398
PE		 5214 bond_destroy_sysfs();
5215
40abc270 5216 rtnl_lock();
1da177e4 5217 bond_free_all();
1da177e4 5218 rtnl_unlock();
dfe60397 5219out:
1da177e4 5220 return res;
dfe60397 5221
1da177e4
LT		 5222}
5223
5224static void __exit bonding_exit(void)
5225{
5226 unregister_netdevice_notifier(&bond_netdev_notifier);
c3ade5ca 5227 unregister_inetaddr_notifier(&bond_inetaddr_notifier);
305d552a 5228 bond_unregister_ipv6_notifier();
1da177e4 5229
ae68c398
PE		 5230 bond_destroy_sysfs();
5231
1da177e4
LT		 5232 rtnl_lock();
5233 bond_free_all();
5234 rtnl_unlock();
5235}
5236
5237module_init(bonding_init);
5238module_exit(bonding_exit);
5239MODULE_LICENSE("GPL");
5240MODULE_VERSION(DRV_VERSION);
5241MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION);
5242MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others");
5243MODULE_SUPPORTED_DEVICE("most ethernet devices");
5244
5245/*
5246 * Local variables:
5247 * c-indent-level: 8
5248 * c-basic-offset: 8
5249 * tab-width: 8
5250 * End:
5251 */
5252
Clone of davem's net-next-2.6 tree