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