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