1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/skbuff.h>
24#include <linux/if_ether.h>
25#include <linux/netdevice.h>
26#include <linux/spinlock.h>
27#include <linux/ethtool.h>
28#include <linux/etherdevice.h>
29#include <linux/if_bonding.h>
30#include <linux/pkt_sched.h>
31#include <net/net_namespace.h>
32#include <net/bonding.h>
33#include <net/bond_3ad.h>
34
35
36#define AD_SHORT_TIMEOUT 1
37#define AD_LONG_TIMEOUT 0
38#define AD_STANDBY 0x2
39#define AD_MAX_TX_IN_SECOND 3
40#define AD_COLLECTOR_MAX_DELAY 0
41
42
43#define AD_FAST_PERIODIC_TIME 1
44#define AD_SLOW_PERIODIC_TIME 30
45#define AD_SHORT_TIMEOUT_TIME (3*AD_FAST_PERIODIC_TIME)
46#define AD_LONG_TIMEOUT_TIME (3*AD_SLOW_PERIODIC_TIME)
47#define AD_CHURN_DETECTION_TIME 60
48#define AD_AGGREGATE_WAIT_TIME 2
49
50
51#define AD_STATE_LACP_ACTIVITY 0x1
52#define AD_STATE_LACP_TIMEOUT 0x2
53#define AD_STATE_AGGREGATION 0x4
54#define AD_STATE_SYNCHRONIZATION 0x8
55#define AD_STATE_COLLECTING 0x10
56#define AD_STATE_DISTRIBUTING 0x20
57#define AD_STATE_DEFAULTED 0x40
58#define AD_STATE_EXPIRED 0x80
59
60
61
62
63#define AD_PORT_BEGIN 0x1
64#define AD_PORT_LACP_ENABLED 0x2
65#define AD_PORT_ACTOR_CHURN 0x4
66#define AD_PORT_PARTNER_CHURN 0x8
67#define AD_PORT_READY 0x10
68#define AD_PORT_READY_N 0x20
69#define AD_PORT_MATCHED 0x40
70#define AD_PORT_STANDBY 0x80
71#define AD_PORT_SELECTED 0x100
72#define AD_PORT_MOVED 0x200
73#define AD_PORT_CHURNED (AD_PORT_ACTOR_CHURN | AD_PORT_PARTNER_CHURN)
74
75
76
77
78
79
80
81
82
83#define AD_DUPLEX_KEY_MASKS 0x1
84#define AD_SPEED_KEY_MASKS 0x3E
85#define AD_USER_KEY_MASKS 0xFFC0
86
87enum ad_link_speed_type {
88 AD_LINK_SPEED_1MBPS = 1,
89 AD_LINK_SPEED_10MBPS,
90 AD_LINK_SPEED_100MBPS,
91 AD_LINK_SPEED_1000MBPS,
92 AD_LINK_SPEED_2500MBPS,
93 AD_LINK_SPEED_10000MBPS,
94 AD_LINK_SPEED_20000MBPS,
95 AD_LINK_SPEED_40000MBPS,
96 AD_LINK_SPEED_56000MBPS,
97 AD_LINK_SPEED_100000MBPS,
98};
99
100
101#define MAC_ADDRESS_EQUAL(A, B) \
102 ether_addr_equal_64bits((const u8 *)A, (const u8 *)B)
103
104static struct mac_addr null_mac_addr = { { 0, 0, 0, 0, 0, 0 } };
105static u16 ad_ticks_per_sec;
106static const int ad_delta_in_ticks = (AD_TIMER_INTERVAL * HZ) / 1000;
107
108static const u8 lacpdu_mcast_addr[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
109
110
111static int ad_lacpdu_send(struct port *port);
112static int ad_marker_send(struct port *port, struct bond_marker *marker);
113static void ad_mux_machine(struct port *port, bool *update_slave_arr);
114static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port);
115static void ad_tx_machine(struct port *port);
116static void ad_periodic_machine(struct port *port);
117static void ad_port_selection_logic(struct port *port, bool *update_slave_arr);
118static void ad_agg_selection_logic(struct aggregator *aggregator,
119 bool *update_slave_arr);
120static void ad_clear_agg(struct aggregator *aggregator);
121static void ad_initialize_agg(struct aggregator *aggregator);
122static void ad_initialize_port(struct port *port, int lacp_fast);
123static void ad_enable_collecting_distributing(struct port *port,
124 bool *update_slave_arr);
125static void ad_disable_collecting_distributing(struct port *port,
126 bool *update_slave_arr);
127static void ad_marker_info_received(struct bond_marker *marker_info,
128 struct port *port);
129static void ad_marker_response_received(struct bond_marker *marker,
130 struct port *port);
131static void ad_update_actor_keys(struct port *port, bool reset);
132
133
134
135
136
137
138
139
140
141
142static inline struct bonding *__get_bond_by_port(struct port *port)
143{
144 if (port->slave == NULL)
145 return NULL;
146
147 return bond_get_bond_by_slave(port->slave);
148}
149
150
151
152
153
154
155
156
157
158static inline struct aggregator *__get_first_agg(struct port *port)
159{
160 struct bonding *bond = __get_bond_by_port(port);
161 struct slave *first_slave;
162 struct aggregator *agg;
163
164
165 if (bond == NULL)
166 return NULL;
167
168 rcu_read_lock();
169 first_slave = bond_first_slave_rcu(bond);
170 agg = first_slave ? &(SLAVE_AD_INFO(first_slave)->aggregator) : NULL;
171 rcu_read_unlock();
172
173 return agg;
174}
175
176
177
178
179
180
181
182
183static inline int __agg_has_partner(struct aggregator *agg)
184{
185 return !is_zero_ether_addr(agg->partner_system.mac_addr_value);
186}
187
188
189
190
191
192static inline void __disable_port(struct port *port)
193{
194 bond_set_slave_inactive_flags(port->slave, BOND_SLAVE_NOTIFY_LATER);
195}
196
197
198
199
200
201static inline void __enable_port(struct port *port)
202{
203 struct slave *slave = port->slave;
204
205 if ((slave->link == BOND_LINK_UP) && bond_slave_is_up(slave))
206 bond_set_slave_active_flags(slave, BOND_SLAVE_NOTIFY_LATER);
207}
208
209
210
211
212
213static inline int __port_is_enabled(struct port *port)
214{
215 return bond_is_active_slave(port->slave);
216}
217
218
219
220
221
222
223
224static inline u32 __get_agg_selection_mode(struct port *port)
225{
226 struct bonding *bond = __get_bond_by_port(port);
227
228 if (bond == NULL)
229 return BOND_AD_STABLE;
230
231 return bond->params.ad_select;
232}
233
234
235
236
237
238static inline int __check_agg_selection_timer(struct port *port)
239{
240 struct bonding *bond = __get_bond_by_port(port);
241
242 if (bond == NULL)
243 return 0;
244
245 return BOND_AD_INFO(bond).agg_select_timer ? 1 : 0;
246}
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264static u16 __get_link_speed(struct port *port)
265{
266 struct slave *slave = port->slave;
267 u16 speed;
268
269
270
271
272
273
274 if (slave->link != BOND_LINK_UP)
275 speed = 0;
276 else {
277 switch (slave->speed) {
278 case SPEED_10:
279 speed = AD_LINK_SPEED_10MBPS;
280 break;
281
282 case SPEED_100:
283 speed = AD_LINK_SPEED_100MBPS;
284 break;
285
286 case SPEED_1000:
287 speed = AD_LINK_SPEED_1000MBPS;
288 break;
289
290 case SPEED_2500:
291 speed = AD_LINK_SPEED_2500MBPS;
292 break;
293
294 case SPEED_10000:
295 speed = AD_LINK_SPEED_10000MBPS;
296 break;
297
298 case SPEED_20000:
299 speed = AD_LINK_SPEED_20000MBPS;
300 break;
301
302 case SPEED_40000:
303 speed = AD_LINK_SPEED_40000MBPS;
304 break;
305
306 case SPEED_56000:
307 speed = AD_LINK_SPEED_56000MBPS;
308 break;
309
310 case SPEED_100000:
311 speed = AD_LINK_SPEED_100000MBPS;
312 break;
313
314 default:
315
316 speed = 0;
317 break;
318 }
319 }
320
321 netdev_dbg(slave->bond->dev, "Port %d Received link speed %d update from adapter\n",
322 port->actor_port_number, speed);
323 return speed;
324}
325
326
327
328
329
330
331
332
333
334static u8 __get_duplex(struct port *port)
335{
336 struct slave *slave = port->slave;
337 u8 retval = 0x0;
338
339
340
341
342 if (slave->link == BOND_LINK_UP) {
343 switch (slave->duplex) {
344 case DUPLEX_FULL:
345 retval = 0x1;
346 netdev_dbg(slave->bond->dev, "Port %d Received status full duplex update from adapter\n",
347 port->actor_port_number);
348 break;
349 case DUPLEX_HALF:
350 default:
351 retval = 0x0;
352 netdev_dbg(slave->bond->dev, "Port %d Received status NOT full duplex update from adapter\n",
353 port->actor_port_number);
354 break;
355 }
356 }
357 return retval;
358}
359
360static void __ad_actor_update_port(struct port *port)
361{
362 const struct bonding *bond = bond_get_bond_by_slave(port->slave);
363
364 port->actor_system = BOND_AD_INFO(bond).system.sys_mac_addr;
365 port->actor_system_priority = BOND_AD_INFO(bond).system.sys_priority;
366}
367
368
369
370
371
372
373
374
375
376
377
378
379static u16 __ad_timer_to_ticks(u16 timer_type, u16 par)
380{
381 u16 retval = 0;
382
383 switch (timer_type) {
384 case AD_CURRENT_WHILE_TIMER:
385 if (par)
386 retval = (AD_SHORT_TIMEOUT_TIME*ad_ticks_per_sec);
387 else
388 retval = (AD_LONG_TIMEOUT_TIME*ad_ticks_per_sec);
389 break;
390 case AD_ACTOR_CHURN_TIMER:
391 retval = (AD_CHURN_DETECTION_TIME*ad_ticks_per_sec);
392 break;
393 case AD_PERIODIC_TIMER:
394 retval = (par*ad_ticks_per_sec);
395 break;
396 case AD_PARTNER_CHURN_TIMER:
397 retval = (AD_CHURN_DETECTION_TIME*ad_ticks_per_sec);
398 break;
399 case AD_WAIT_WHILE_TIMER:
400 retval = (AD_AGGREGATE_WAIT_TIME*ad_ticks_per_sec);
401 break;
402 }
403
404 return retval;
405}
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433static void __choose_matched(struct lacpdu *lacpdu, struct port *port)
434{
435
436
437
438
439 if (((ntohs(lacpdu->partner_port) == port->actor_port_number) &&
440 (ntohs(lacpdu->partner_port_priority) == port->actor_port_priority) &&
441 MAC_ADDRESS_EQUAL(&(lacpdu->partner_system), &(port->actor_system)) &&
442 (ntohs(lacpdu->partner_system_priority) == port->actor_system_priority) &&
443 (ntohs(lacpdu->partner_key) == port->actor_oper_port_key) &&
444 ((lacpdu->partner_state & AD_STATE_AGGREGATION) == (port->actor_oper_port_state & AD_STATE_AGGREGATION))) ||
445 ((lacpdu->actor_state & AD_STATE_AGGREGATION) == 0)
446 ) {
447 port->sm_vars |= AD_PORT_MATCHED;
448 } else {
449 port->sm_vars &= ~AD_PORT_MATCHED;
450 }
451}
452
453
454
455
456
457
458
459
460
461
462static void __record_pdu(struct lacpdu *lacpdu, struct port *port)
463{
464 if (lacpdu && port) {
465 struct port_params *partner = &port->partner_oper;
466
467 __choose_matched(lacpdu, port);
468
469
470
471 partner->port_number = ntohs(lacpdu->actor_port);
472 partner->port_priority = ntohs(lacpdu->actor_port_priority);
473 partner->system = lacpdu->actor_system;
474 partner->system_priority = ntohs(lacpdu->actor_system_priority);
475 partner->key = ntohs(lacpdu->actor_key);
476 partner->port_state = lacpdu->actor_state;
477
478
479 port->actor_oper_port_state &= ~AD_STATE_DEFAULTED;
480
481
482
483
484 if ((port->sm_vars & AD_PORT_MATCHED) &&
485 (lacpdu->actor_state & AD_STATE_SYNCHRONIZATION)) {
486 partner->port_state |= AD_STATE_SYNCHRONIZATION;
487 pr_debug("%s partner sync=1\n", port->slave->dev->name);
488 } else {
489 partner->port_state &= ~AD_STATE_SYNCHRONIZATION;
490 pr_debug("%s partner sync=0\n", port->slave->dev->name);
491 }
492 }
493}
494
495
496
497
498
499
500
501
502
503static void __record_default(struct port *port)
504{
505 if (port) {
506
507 memcpy(&port->partner_oper, &port->partner_admin,
508 sizeof(struct port_params));
509
510
511 port->actor_oper_port_state |= AD_STATE_DEFAULTED;
512 }
513}
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528static void __update_selected(struct lacpdu *lacpdu, struct port *port)
529{
530 if (lacpdu && port) {
531 const struct port_params *partner = &port->partner_oper;
532
533
534
535
536 if (ntohs(lacpdu->actor_port) != partner->port_number ||
537 ntohs(lacpdu->actor_port_priority) != partner->port_priority ||
538 !MAC_ADDRESS_EQUAL(&lacpdu->actor_system, &partner->system) ||
539 ntohs(lacpdu->actor_system_priority) != partner->system_priority ||
540 ntohs(lacpdu->actor_key) != partner->key ||
541 (lacpdu->actor_state & AD_STATE_AGGREGATION) != (partner->port_state & AD_STATE_AGGREGATION)) {
542 port->sm_vars &= ~AD_PORT_SELECTED;
543 }
544 }
545}
546
547
548
549
550
551
552
553
554
555
556
557
558
559static void __update_default_selected(struct port *port)
560{
561 if (port) {
562 const struct port_params *admin = &port->partner_admin;
563 const struct port_params *oper = &port->partner_oper;
564
565
566
567
568 if (admin->port_number != oper->port_number ||
569 admin->port_priority != oper->port_priority ||
570 !MAC_ADDRESS_EQUAL(&admin->system, &oper->system) ||
571 admin->system_priority != oper->system_priority ||
572 admin->key != oper->key ||
573 (admin->port_state & AD_STATE_AGGREGATION)
574 != (oper->port_state & AD_STATE_AGGREGATION)) {
575 port->sm_vars &= ~AD_PORT_SELECTED;
576 }
577 }
578}
579
580
581
582
583
584
585
586
587
588
589
590
591
592static void __update_ntt(struct lacpdu *lacpdu, struct port *port)
593{
594
595 if (lacpdu && port) {
596
597
598
599 if ((ntohs(lacpdu->partner_port) != port->actor_port_number) ||
600 (ntohs(lacpdu->partner_port_priority) != port->actor_port_priority) ||
601 !MAC_ADDRESS_EQUAL(&(lacpdu->partner_system), &(port->actor_system)) ||
602 (ntohs(lacpdu->partner_system_priority) != port->actor_system_priority) ||
603 (ntohs(lacpdu->partner_key) != port->actor_oper_port_key) ||
604 ((lacpdu->partner_state & AD_STATE_LACP_ACTIVITY) != (port->actor_oper_port_state & AD_STATE_LACP_ACTIVITY)) ||
605 ((lacpdu->partner_state & AD_STATE_LACP_TIMEOUT) != (port->actor_oper_port_state & AD_STATE_LACP_TIMEOUT)) ||
606 ((lacpdu->partner_state & AD_STATE_SYNCHRONIZATION) != (port->actor_oper_port_state & AD_STATE_SYNCHRONIZATION)) ||
607 ((lacpdu->partner_state & AD_STATE_AGGREGATION) != (port->actor_oper_port_state & AD_STATE_AGGREGATION))
608 ) {
609 port->ntt = true;
610 }
611 }
612}
613
614
615
616
617
618
619static int __agg_ports_are_ready(struct aggregator *aggregator)
620{
621 struct port *port;
622 int retval = 1;
623
624 if (aggregator) {
625
626
627
628 for (port = aggregator->lag_ports;
629 port;
630 port = port->next_port_in_aggregator) {
631 if (!(port->sm_vars & AD_PORT_READY_N)) {
632 retval = 0;
633 break;
634 }
635 }
636 }
637
638 return retval;
639}
640
641
642
643
644
645
646
647static void __set_agg_ports_ready(struct aggregator *aggregator, int val)
648{
649 struct port *port;
650
651 for (port = aggregator->lag_ports; port;
652 port = port->next_port_in_aggregator) {
653 if (val)
654 port->sm_vars |= AD_PORT_READY;
655 else
656 port->sm_vars &= ~AD_PORT_READY;
657 }
658}
659
660
661
662
663
664
665static u32 __get_agg_bandwidth(struct aggregator *aggregator)
666{
667 u32 bandwidth = 0;
668
669 if (aggregator->num_of_ports) {
670 switch (__get_link_speed(aggregator->lag_ports)) {
671 case AD_LINK_SPEED_1MBPS:
672 bandwidth = aggregator->num_of_ports;
673 break;
674 case AD_LINK_SPEED_10MBPS:
675 bandwidth = aggregator->num_of_ports * 10;
676 break;
677 case AD_LINK_SPEED_100MBPS:
678 bandwidth = aggregator->num_of_ports * 100;
679 break;
680 case AD_LINK_SPEED_1000MBPS:
681 bandwidth = aggregator->num_of_ports * 1000;
682 break;
683 case AD_LINK_SPEED_2500MBPS:
684 bandwidth = aggregator->num_of_ports * 2500;
685 break;
686 case AD_LINK_SPEED_10000MBPS:
687 bandwidth = aggregator->num_of_ports * 10000;
688 break;
689 case AD_LINK_SPEED_20000MBPS:
690 bandwidth = aggregator->num_of_ports * 20000;
691 break;
692 case AD_LINK_SPEED_40000MBPS:
693 bandwidth = aggregator->num_of_ports * 40000;
694 break;
695 case AD_LINK_SPEED_56000MBPS:
696 bandwidth = aggregator->num_of_ports * 56000;
697 break;
698 case AD_LINK_SPEED_100000MBPS:
699 bandwidth = aggregator->num_of_ports * 100000;
700 break;
701 default:
702 bandwidth = 0;
703 }
704 }
705 return bandwidth;
706}
707
708
709
710
711
712
713
714static struct aggregator *__get_active_agg(struct aggregator *aggregator)
715{
716 struct bonding *bond = aggregator->slave->bond;
717 struct list_head *iter;
718 struct slave *slave;
719
720 bond_for_each_slave_rcu(bond, slave, iter)
721 if (SLAVE_AD_INFO(slave)->aggregator.is_active)
722 return &(SLAVE_AD_INFO(slave)->aggregator);
723
724 return NULL;
725}
726
727
728
729
730
731static inline void __update_lacpdu_from_port(struct port *port)
732{
733 struct lacpdu *lacpdu = &port->lacpdu;
734 const struct port_params *partner = &port->partner_oper;
735
736
737
738
739
740
741
742
743 lacpdu->actor_system_priority = htons(port->actor_system_priority);
744 lacpdu->actor_system = port->actor_system;
745 lacpdu->actor_key = htons(port->actor_oper_port_key);
746 lacpdu->actor_port_priority = htons(port->actor_port_priority);
747 lacpdu->actor_port = htons(port->actor_port_number);
748 lacpdu->actor_state = port->actor_oper_port_state;
749 pr_debug("update lacpdu: %s, actor port state %x\n",
750 port->slave->dev->name, port->actor_oper_port_state);
751
752
753
754
755
756
757 lacpdu->partner_system_priority = htons(partner->system_priority);
758 lacpdu->partner_system = partner->system;
759 lacpdu->partner_key = htons(partner->key);
760 lacpdu->partner_port_priority = htons(partner->port_priority);
761 lacpdu->partner_port = htons(partner->port_number);
762 lacpdu->partner_state = partner->port_state;
763
764
765
766
767
768
769
770
771
772
773}
774
775
776
777
778
779
780
781
782
783
784static int ad_lacpdu_send(struct port *port)
785{
786 struct slave *slave = port->slave;
787 struct sk_buff *skb;
788 struct lacpdu_header *lacpdu_header;
789 int length = sizeof(struct lacpdu_header);
790
791 skb = dev_alloc_skb(length);
792 if (!skb)
793 return -ENOMEM;
794
795 skb->dev = slave->dev;
796 skb_reset_mac_header(skb);
797 skb->network_header = skb->mac_header + ETH_HLEN;
798 skb->protocol = PKT_TYPE_LACPDU;
799 skb->priority = TC_PRIO_CONTROL;
800
801 lacpdu_header = (struct lacpdu_header *)skb_put(skb, length);
802
803 ether_addr_copy(lacpdu_header->hdr.h_dest, lacpdu_mcast_addr);
804
805
806
807 ether_addr_copy(lacpdu_header->hdr.h_source, slave->perm_hwaddr);
808 lacpdu_header->hdr.h_proto = PKT_TYPE_LACPDU;
809
810 lacpdu_header->lacpdu = port->lacpdu;
811
812 dev_queue_xmit(skb);
813
814 return 0;
815}
816
817
818
819
820
821
822
823
824
825static int ad_marker_send(struct port *port, struct bond_marker *marker)
826{
827 struct slave *slave = port->slave;
828 struct sk_buff *skb;
829 struct bond_marker_header *marker_header;
830 int length = sizeof(struct bond_marker_header);
831
832 skb = dev_alloc_skb(length + 16);
833 if (!skb)
834 return -ENOMEM;
835
836 skb_reserve(skb, 16);
837
838 skb->dev = slave->dev;
839 skb_reset_mac_header(skb);
840 skb->network_header = skb->mac_header + ETH_HLEN;
841 skb->protocol = PKT_TYPE_LACPDU;
842
843 marker_header = (struct bond_marker_header *)skb_put(skb, length);
844
845 ether_addr_copy(marker_header->hdr.h_dest, lacpdu_mcast_addr);
846
847
848
849 ether_addr_copy(marker_header->hdr.h_source, slave->perm_hwaddr);
850 marker_header->hdr.h_proto = PKT_TYPE_LACPDU;
851
852 marker_header->marker = *marker;
853
854 dev_queue_xmit(skb);
855
856 return 0;
857}
858
859
860
861
862
863
864static void ad_mux_machine(struct port *port, bool *update_slave_arr)
865{
866 mux_states_t last_state;
867
868
869
870
871 last_state = port->sm_mux_state;
872
873 if (port->sm_vars & AD_PORT_BEGIN) {
874 port->sm_mux_state = AD_MUX_DETACHED;
875 } else {
876 switch (port->sm_mux_state) {
877 case AD_MUX_DETACHED:
878 if ((port->sm_vars & AD_PORT_SELECTED)
879 || (port->sm_vars & AD_PORT_STANDBY))
880
881 port->sm_mux_state = AD_MUX_WAITING;
882 break;
883 case AD_MUX_WAITING:
884
885 if (!(port->sm_vars & AD_PORT_SELECTED)) {
886 port->sm_vars &= ~AD_PORT_READY_N;
887
888
889
890
891
892 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
893 port->sm_mux_state = AD_MUX_DETACHED;
894 break;
895 }
896
897
898 if (port->sm_mux_timer_counter
899 && !(--port->sm_mux_timer_counter))
900 port->sm_vars |= AD_PORT_READY_N;
901
902
903
904
905
906
907 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
908
909
910
911
912 if ((port->sm_vars & AD_PORT_READY)
913 && !port->sm_mux_timer_counter)
914 port->sm_mux_state = AD_MUX_ATTACHED;
915 break;
916 case AD_MUX_ATTACHED:
917
918
919
920 if ((port->sm_vars & AD_PORT_SELECTED) &&
921 (port->partner_oper.port_state & AD_STATE_SYNCHRONIZATION) &&
922 !__check_agg_selection_timer(port)) {
923 if (port->aggregator->is_active)
924 port->sm_mux_state =
925 AD_MUX_COLLECTING_DISTRIBUTING;
926 } else if (!(port->sm_vars & AD_PORT_SELECTED) ||
927 (port->sm_vars & AD_PORT_STANDBY)) {
928
929 port->sm_vars &= ~AD_PORT_READY_N;
930
931
932
933
934
935 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
936 port->sm_mux_state = AD_MUX_DETACHED;
937 } else if (port->aggregator->is_active) {
938 port->actor_oper_port_state |=
939 AD_STATE_SYNCHRONIZATION;
940 }
941 break;
942 case AD_MUX_COLLECTING_DISTRIBUTING:
943 if (!(port->sm_vars & AD_PORT_SELECTED) ||
944 (port->sm_vars & AD_PORT_STANDBY) ||
945 !(port->partner_oper.port_state & AD_STATE_SYNCHRONIZATION) ||
946 !(port->actor_oper_port_state & AD_STATE_SYNCHRONIZATION)) {
947 port->sm_mux_state = AD_MUX_ATTACHED;
948 } else {
949
950
951
952
953 if (port->aggregator &&
954 port->aggregator->is_active &&
955 !__port_is_enabled(port)) {
956
957 __enable_port(port);
958 }
959 }
960 break;
961 default:
962 break;
963 }
964 }
965
966
967 if (port->sm_mux_state != last_state) {
968 pr_debug("Mux Machine: Port=%d (%s), Last State=%d, Curr State=%d\n",
969 port->actor_port_number,
970 port->slave->dev->name,
971 last_state,
972 port->sm_mux_state);
973 switch (port->sm_mux_state) {
974 case AD_MUX_DETACHED:
975 port->actor_oper_port_state &= ~AD_STATE_SYNCHRONIZATION;
976 ad_disable_collecting_distributing(port,
977 update_slave_arr);
978 port->actor_oper_port_state &= ~AD_STATE_COLLECTING;
979 port->actor_oper_port_state &= ~AD_STATE_DISTRIBUTING;
980 port->ntt = true;
981 break;
982 case AD_MUX_WAITING:
983 port->sm_mux_timer_counter = __ad_timer_to_ticks(AD_WAIT_WHILE_TIMER, 0);
984 break;
985 case AD_MUX_ATTACHED:
986 if (port->aggregator->is_active)
987 port->actor_oper_port_state |=
988 AD_STATE_SYNCHRONIZATION;
989 else
990 port->actor_oper_port_state &=
991 ~AD_STATE_SYNCHRONIZATION;
992 port->actor_oper_port_state &= ~AD_STATE_COLLECTING;
993 port->actor_oper_port_state &= ~AD_STATE_DISTRIBUTING;
994 ad_disable_collecting_distributing(port,
995 update_slave_arr);
996 port->ntt = true;
997 break;
998 case AD_MUX_COLLECTING_DISTRIBUTING:
999 port->actor_oper_port_state |= AD_STATE_COLLECTING;
1000 port->actor_oper_port_state |= AD_STATE_DISTRIBUTING;
1001 port->actor_oper_port_state |= AD_STATE_SYNCHRONIZATION;
1002 ad_enable_collecting_distributing(port,
1003 update_slave_arr);
1004 port->ntt = true;
1005 break;
1006 default:
1007 break;
1008 }
1009 }
1010}
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port)
1022{
1023 rx_states_t last_state;
1024
1025
1026
1027
1028 last_state = port->sm_rx_state;
1029
1030
1031
1032
1033 if (port->sm_vars & AD_PORT_BEGIN) {
1034 port->sm_rx_state = AD_RX_INITIALIZE;
1035 port->sm_vars |= AD_PORT_CHURNED;
1036
1037 } else if (!(port->sm_vars & AD_PORT_BEGIN)
1038 && !port->is_enabled && !(port->sm_vars & AD_PORT_MOVED))
1039 port->sm_rx_state = AD_RX_PORT_DISABLED;
1040
1041 else if (lacpdu && ((port->sm_rx_state == AD_RX_EXPIRED) ||
1042 (port->sm_rx_state == AD_RX_DEFAULTED) ||
1043 (port->sm_rx_state == AD_RX_CURRENT))) {
1044 if (port->sm_rx_state != AD_RX_CURRENT)
1045 port->sm_vars |= AD_PORT_CHURNED;
1046 port->sm_rx_timer_counter = 0;
1047 port->sm_rx_state = AD_RX_CURRENT;
1048 } else {
1049
1050 if (port->sm_rx_timer_counter &&
1051 !(--port->sm_rx_timer_counter)) {
1052 switch (port->sm_rx_state) {
1053 case AD_RX_EXPIRED:
1054 port->sm_rx_state = AD_RX_DEFAULTED;
1055 break;
1056 case AD_RX_CURRENT:
1057 port->sm_rx_state = AD_RX_EXPIRED;
1058 break;
1059 default:
1060 break;
1061 }
1062 } else {
1063
1064 switch (port->sm_rx_state) {
1065 case AD_RX_PORT_DISABLED:
1066 if (port->sm_vars & AD_PORT_MOVED)
1067 port->sm_rx_state = AD_RX_INITIALIZE;
1068 else if (port->is_enabled
1069 && (port->sm_vars
1070 & AD_PORT_LACP_ENABLED))
1071 port->sm_rx_state = AD_RX_EXPIRED;
1072 else if (port->is_enabled
1073 && ((port->sm_vars
1074 & AD_PORT_LACP_ENABLED) == 0))
1075 port->sm_rx_state = AD_RX_LACP_DISABLED;
1076 break;
1077 default:
1078 break;
1079
1080 }
1081 }
1082 }
1083
1084
1085 if ((port->sm_rx_state != last_state) || (lacpdu)) {
1086 pr_debug("Rx Machine: Port=%d (%s), Last State=%d, Curr State=%d\n",
1087 port->actor_port_number,
1088 port->slave->dev->name,
1089 last_state,
1090 port->sm_rx_state);
1091 switch (port->sm_rx_state) {
1092 case AD_RX_INITIALIZE:
1093 if (!(port->actor_oper_port_key & AD_DUPLEX_KEY_MASKS))
1094 port->sm_vars &= ~AD_PORT_LACP_ENABLED;
1095 else
1096 port->sm_vars |= AD_PORT_LACP_ENABLED;
1097 port->sm_vars &= ~AD_PORT_SELECTED;
1098 __record_default(port);
1099 port->actor_oper_port_state &= ~AD_STATE_EXPIRED;
1100 port->sm_vars &= ~AD_PORT_MOVED;
1101 port->sm_rx_state = AD_RX_PORT_DISABLED;
1102
1103
1104 case AD_RX_PORT_DISABLED:
1105 port->sm_vars &= ~AD_PORT_MATCHED;
1106 break;
1107 case AD_RX_LACP_DISABLED:
1108 port->sm_vars &= ~AD_PORT_SELECTED;
1109 __record_default(port);
1110 port->partner_oper.port_state &= ~AD_STATE_AGGREGATION;
1111 port->sm_vars |= AD_PORT_MATCHED;
1112 port->actor_oper_port_state &= ~AD_STATE_EXPIRED;
1113 break;
1114 case AD_RX_EXPIRED:
1115
1116
1117
1118
1119
1120
1121 port->partner_oper.port_state &= ~AD_STATE_SYNCHRONIZATION;
1122 port->sm_vars &= ~AD_PORT_MATCHED;
1123 port->partner_oper.port_state |= AD_STATE_LACP_TIMEOUT;
1124 port->partner_oper.port_state |= AD_STATE_LACP_ACTIVITY;
1125 port->sm_rx_timer_counter = __ad_timer_to_ticks(AD_CURRENT_WHILE_TIMER, (u16)(AD_SHORT_TIMEOUT));
1126 port->actor_oper_port_state |= AD_STATE_EXPIRED;
1127 port->sm_vars |= AD_PORT_CHURNED;
1128 break;
1129 case AD_RX_DEFAULTED:
1130 __update_default_selected(port);
1131 __record_default(port);
1132 port->sm_vars |= AD_PORT_MATCHED;
1133 port->actor_oper_port_state &= ~AD_STATE_EXPIRED;
1134 break;
1135 case AD_RX_CURRENT:
1136
1137 if (MAC_ADDRESS_EQUAL(&(lacpdu->actor_system),
1138 &(port->actor_system))) {
1139 netdev_err(port->slave->bond->dev, "An illegal loopback occurred on adapter (%s)\n"
1140 "Check the configuration to verify that all adapters are connected to 802.3ad compliant switch ports\n",
1141 port->slave->dev->name);
1142 return;
1143 }
1144 __update_selected(lacpdu, port);
1145 __update_ntt(lacpdu, port);
1146 __record_pdu(lacpdu, port);
1147 port->sm_rx_timer_counter = __ad_timer_to_ticks(AD_CURRENT_WHILE_TIMER, (u16)(port->actor_oper_port_state & AD_STATE_LACP_TIMEOUT));
1148 port->actor_oper_port_state &= ~AD_STATE_EXPIRED;
1149 break;
1150 default:
1151 break;
1152 }
1153 }
1154}
1155
1156
1157
1158
1159
1160
1161static void ad_churn_machine(struct port *port)
1162{
1163 if (port->sm_vars & AD_PORT_CHURNED) {
1164 port->sm_vars &= ~AD_PORT_CHURNED;
1165 port->sm_churn_actor_state = AD_CHURN_MONITOR;
1166 port->sm_churn_partner_state = AD_CHURN_MONITOR;
1167 port->sm_churn_actor_timer_counter =
1168 __ad_timer_to_ticks(AD_ACTOR_CHURN_TIMER, 0);
1169 port->sm_churn_partner_timer_counter =
1170 __ad_timer_to_ticks(AD_PARTNER_CHURN_TIMER, 0);
1171 return;
1172 }
1173 if (port->sm_churn_actor_timer_counter &&
1174 !(--port->sm_churn_actor_timer_counter) &&
1175 port->sm_churn_actor_state == AD_CHURN_MONITOR) {
1176 if (port->actor_oper_port_state & AD_STATE_SYNCHRONIZATION) {
1177 port->sm_churn_actor_state = AD_NO_CHURN;
1178 } else {
1179 port->churn_actor_count++;
1180 port->sm_churn_actor_state = AD_CHURN;
1181 }
1182 }
1183 if (port->sm_churn_partner_timer_counter &&
1184 !(--port->sm_churn_partner_timer_counter) &&
1185 port->sm_churn_partner_state == AD_CHURN_MONITOR) {
1186 if (port->partner_oper.port_state & AD_STATE_SYNCHRONIZATION) {
1187 port->sm_churn_partner_state = AD_NO_CHURN;
1188 } else {
1189 port->churn_partner_count++;
1190 port->sm_churn_partner_state = AD_CHURN;
1191 }
1192 }
1193}
1194
1195
1196
1197
1198
1199static void ad_tx_machine(struct port *port)
1200{
1201
1202
1203
1204 if (port->sm_tx_timer_counter && !(--port->sm_tx_timer_counter)) {
1205
1206 if (port->ntt && (port->sm_vars & AD_PORT_LACP_ENABLED)) {
1207 __update_lacpdu_from_port(port);
1208
1209 if (ad_lacpdu_send(port) >= 0) {
1210 pr_debug("Sent LACPDU on port %d\n",
1211 port->actor_port_number);
1212
1213
1214
1215
1216 port->ntt = false;
1217 }
1218 }
1219
1220
1221
1222 port->sm_tx_timer_counter = ad_ticks_per_sec/AD_MAX_TX_IN_SECOND;
1223 }
1224}
1225
1226
1227
1228
1229
1230
1231
1232static void ad_periodic_machine(struct port *port)
1233{
1234 periodic_states_t last_state;
1235
1236
1237 last_state = port->sm_periodic_state;
1238
1239
1240 if (((port->sm_vars & AD_PORT_BEGIN) || !(port->sm_vars & AD_PORT_LACP_ENABLED) || !port->is_enabled) ||
1241 (!(port->actor_oper_port_state & AD_STATE_LACP_ACTIVITY) && !(port->partner_oper.port_state & AD_STATE_LACP_ACTIVITY))
1242 ) {
1243 port->sm_periodic_state = AD_NO_PERIODIC;
1244 }
1245
1246 else if (port->sm_periodic_timer_counter) {
1247
1248 if (!(--port->sm_periodic_timer_counter)) {
1249
1250 port->sm_periodic_state = AD_PERIODIC_TX;
1251 } else {
1252
1253
1254
1255 switch (port->sm_periodic_state) {
1256 case AD_FAST_PERIODIC:
1257 if (!(port->partner_oper.port_state
1258 & AD_STATE_LACP_TIMEOUT))
1259 port->sm_periodic_state = AD_SLOW_PERIODIC;
1260 break;
1261 case AD_SLOW_PERIODIC:
1262 if ((port->partner_oper.port_state & AD_STATE_LACP_TIMEOUT)) {
1263 port->sm_periodic_timer_counter = 0;
1264 port->sm_periodic_state = AD_PERIODIC_TX;
1265 }
1266 break;
1267 default:
1268 break;
1269 }
1270 }
1271 } else {
1272 switch (port->sm_periodic_state) {
1273 case AD_NO_PERIODIC:
1274 port->sm_periodic_state = AD_FAST_PERIODIC;
1275 break;
1276 case AD_PERIODIC_TX:
1277 if (!(port->partner_oper.port_state &
1278 AD_STATE_LACP_TIMEOUT))
1279 port->sm_periodic_state = AD_SLOW_PERIODIC;
1280 else
1281 port->sm_periodic_state = AD_FAST_PERIODIC;
1282 break;
1283 default:
1284 break;
1285 }
1286 }
1287
1288
1289 if (port->sm_periodic_state != last_state) {
1290 pr_debug("Periodic Machine: Port=%d, Last State=%d, Curr State=%d\n",
1291 port->actor_port_number, last_state,
1292 port->sm_periodic_state);
1293 switch (port->sm_periodic_state) {
1294 case AD_NO_PERIODIC:
1295 port->sm_periodic_timer_counter = 0;
1296 break;
1297 case AD_FAST_PERIODIC:
1298
1299 port->sm_periodic_timer_counter = __ad_timer_to_ticks(AD_PERIODIC_TIMER, (u16)(AD_FAST_PERIODIC_TIME))-1;
1300 break;
1301 case AD_SLOW_PERIODIC:
1302
1303 port->sm_periodic_timer_counter = __ad_timer_to_ticks(AD_PERIODIC_TIMER, (u16)(AD_SLOW_PERIODIC_TIME))-1;
1304 break;
1305 case AD_PERIODIC_TX:
1306 port->ntt = true;
1307 break;
1308 default:
1309 break;
1310 }
1311 }
1312}
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323static void ad_port_selection_logic(struct port *port, bool *update_slave_arr)
1324{
1325 struct aggregator *aggregator, *free_aggregator = NULL, *temp_aggregator;
1326 struct port *last_port = NULL, *curr_port;
1327 struct list_head *iter;
1328 struct bonding *bond;
1329 struct slave *slave;
1330 int found = 0;
1331
1332
1333 if (port->sm_vars & AD_PORT_SELECTED)
1334 return;
1335
1336 bond = __get_bond_by_port(port);
1337
1338
1339 if (port->aggregator) {
1340
1341 temp_aggregator = port->aggregator;
1342 for (curr_port = temp_aggregator->lag_ports; curr_port;
1343 last_port = curr_port,
1344 curr_port = curr_port->next_port_in_aggregator) {
1345 if (curr_port == port) {
1346 temp_aggregator->num_of_ports--;
1347
1348
1349
1350 if (!last_port) {
1351 temp_aggregator->lag_ports =
1352 port->next_port_in_aggregator;
1353 } else {
1354
1355
1356
1357 last_port->next_port_in_aggregator =
1358 port->next_port_in_aggregator;
1359 }
1360
1361
1362
1363
1364 port->aggregator = NULL;
1365 port->next_port_in_aggregator = NULL;
1366 port->actor_port_aggregator_identifier = 0;
1367
1368 netdev_dbg(bond->dev, "Port %d left LAG %d\n",
1369 port->actor_port_number,
1370 temp_aggregator->aggregator_identifier);
1371
1372
1373
1374 if (!temp_aggregator->lag_ports)
1375 ad_clear_agg(temp_aggregator);
1376 break;
1377 }
1378 }
1379 if (!curr_port) {
1380
1381
1382
1383 net_warn_ratelimited("%s: Warning: Port %d (on %s) was related to aggregator %d but was not on its port list\n",
1384 port->slave->bond->dev->name,
1385 port->actor_port_number,
1386 port->slave->dev->name,
1387 port->aggregator->aggregator_identifier);
1388 }
1389 }
1390
1391 bond_for_each_slave(bond, slave, iter) {
1392 aggregator = &(SLAVE_AD_INFO(slave)->aggregator);
1393
1394
1395 if (!aggregator->lag_ports) {
1396 if (!free_aggregator)
1397 free_aggregator = aggregator;
1398 continue;
1399 }
1400
1401 if (((aggregator->actor_oper_aggregator_key == port->actor_oper_port_key) &&
1402 MAC_ADDRESS_EQUAL(&(aggregator->partner_system), &(port->partner_oper.system)) &&
1403 (aggregator->partner_system_priority == port->partner_oper.system_priority) &&
1404 (aggregator->partner_oper_aggregator_key == port->partner_oper.key)
1405 ) &&
1406 ((!MAC_ADDRESS_EQUAL(&(port->partner_oper.system), &(null_mac_addr)) &&
1407 !aggregator->is_individual)
1408 )
1409 ) {
1410
1411 port->aggregator = aggregator;
1412 port->actor_port_aggregator_identifier =
1413 port->aggregator->aggregator_identifier;
1414 port->next_port_in_aggregator = aggregator->lag_ports;
1415 port->aggregator->num_of_ports++;
1416 aggregator->lag_ports = port;
1417 netdev_dbg(bond->dev, "Port %d joined LAG %d(existing LAG)\n",
1418 port->actor_port_number,
1419 port->aggregator->aggregator_identifier);
1420
1421
1422 port->sm_vars |= AD_PORT_SELECTED;
1423 found = 1;
1424 break;
1425 }
1426 }
1427
1428
1429
1430
1431 if (!found) {
1432 if (free_aggregator) {
1433
1434 port->aggregator = free_aggregator;
1435 port->actor_port_aggregator_identifier =
1436 port->aggregator->aggregator_identifier;
1437
1438
1439
1440
1441 if (port->actor_oper_port_key & AD_DUPLEX_KEY_MASKS)
1442
1443 port->aggregator->is_individual = false;
1444 else
1445 port->aggregator->is_individual = true;
1446
1447 port->aggregator->actor_admin_aggregator_key =
1448 port->actor_admin_port_key;
1449 port->aggregator->actor_oper_aggregator_key =
1450 port->actor_oper_port_key;
1451 port->aggregator->partner_system =
1452 port->partner_oper.system;
1453 port->aggregator->partner_system_priority =
1454 port->partner_oper.system_priority;
1455 port->aggregator->partner_oper_aggregator_key = port->partner_oper.key;
1456 port->aggregator->receive_state = 1;
1457 port->aggregator->transmit_state = 1;
1458 port->aggregator->lag_ports = port;
1459 port->aggregator->num_of_ports++;
1460
1461
1462 port->sm_vars |= AD_PORT_SELECTED;
1463
1464 netdev_dbg(bond->dev, "Port %d joined LAG %d(new LAG)\n",
1465 port->actor_port_number,
1466 port->aggregator->aggregator_identifier);
1467 } else {
1468 netdev_err(bond->dev, "Port %d (on %s) did not find a suitable aggregator\n",
1469 port->actor_port_number, port->slave->dev->name);
1470 }
1471 }
1472
1473
1474
1475
1476 __set_agg_ports_ready(port->aggregator,
1477 __agg_ports_are_ready(port->aggregator));
1478
1479 aggregator = __get_first_agg(port);
1480 ad_agg_selection_logic(aggregator, update_slave_arr);
1481
1482 if (!port->aggregator->is_active)
1483 port->actor_oper_port_state &= ~AD_STATE_SYNCHRONIZATION;
1484}
1485
1486
1487
1488
1489static struct aggregator *ad_agg_selection_test(struct aggregator *best,
1490 struct aggregator *curr)
1491{
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516 if (!best)
1517 return curr;
1518
1519 if (!curr->is_individual && best->is_individual)
1520 return curr;
1521
1522 if (curr->is_individual && !best->is_individual)
1523 return best;
1524
1525 if (__agg_has_partner(curr) && !__agg_has_partner(best))
1526 return curr;
1527
1528 if (!__agg_has_partner(curr) && __agg_has_partner(best))
1529 return best;
1530
1531 switch (__get_agg_selection_mode(curr->lag_ports)) {
1532 case BOND_AD_COUNT:
1533 if (curr->num_of_ports > best->num_of_ports)
1534 return curr;
1535
1536 if (curr->num_of_ports < best->num_of_ports)
1537 return best;
1538
1539
1540 case BOND_AD_STABLE:
1541 case BOND_AD_BANDWIDTH:
1542 if (__get_agg_bandwidth(curr) > __get_agg_bandwidth(best))
1543 return curr;
1544
1545 break;
1546
1547 default:
1548 net_warn_ratelimited("%s: Impossible agg select mode %d\n",
1549 curr->slave->bond->dev->name,
1550 __get_agg_selection_mode(curr->lag_ports));
1551 break;
1552 }
1553
1554 return best;
1555}
1556
1557static int agg_device_up(const struct aggregator *agg)
1558{
1559 struct port *port = agg->lag_ports;
1560
1561 if (!port)
1562 return 0;
1563
1564 return netif_running(port->slave->dev) &&
1565 netif_carrier_ok(port->slave->dev);
1566}
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594static void ad_agg_selection_logic(struct aggregator *agg,
1595 bool *update_slave_arr)
1596{
1597 struct aggregator *best, *active, *origin;
1598 struct bonding *bond = agg->slave->bond;
1599 struct list_head *iter;
1600 struct slave *slave;
1601 struct port *port;
1602
1603 rcu_read_lock();
1604 origin = agg;
1605 active = __get_active_agg(agg);
1606 best = (active && agg_device_up(active)) ? active : NULL;
1607
1608 bond_for_each_slave_rcu(bond, slave, iter) {
1609 agg = &(SLAVE_AD_INFO(slave)->aggregator);
1610
1611 agg->is_active = 0;
1612
1613 if (agg->num_of_ports && agg_device_up(agg))
1614 best = ad_agg_selection_test(best, agg);
1615 }
1616
1617 if (best &&
1618 __get_agg_selection_mode(best->lag_ports) == BOND_AD_STABLE) {
1619
1620
1621
1622
1623
1624 if (active && active->lag_ports &&
1625 active->lag_ports->is_enabled &&
1626 (__agg_has_partner(active) ||
1627 (!__agg_has_partner(active) &&
1628 !__agg_has_partner(best)))) {
1629 if (!(!active->actor_oper_aggregator_key &&
1630 best->actor_oper_aggregator_key)) {
1631 best = NULL;
1632 active->is_active = 1;
1633 }
1634 }
1635 }
1636
1637 if (best && (best == active)) {
1638 best = NULL;
1639 active->is_active = 1;
1640 }
1641
1642
1643 if (best) {
1644 netdev_dbg(bond->dev, "best Agg=%d; P=%d; a k=%d; p k=%d; Ind=%d; Act=%d\n",
1645 best->aggregator_identifier, best->num_of_ports,
1646 best->actor_oper_aggregator_key,
1647 best->partner_oper_aggregator_key,
1648 best->is_individual, best->is_active);
1649 netdev_dbg(bond->dev, "best ports %p slave %p %s\n",
1650 best->lag_ports, best->slave,
1651 best->slave ? best->slave->dev->name : "NULL");
1652
1653 bond_for_each_slave_rcu(bond, slave, iter) {
1654 agg = &(SLAVE_AD_INFO(slave)->aggregator);
1655
1656 netdev_dbg(bond->dev, "Agg=%d; P=%d; a k=%d; p k=%d; Ind=%d; Act=%d\n",
1657 agg->aggregator_identifier, agg->num_of_ports,
1658 agg->actor_oper_aggregator_key,
1659 agg->partner_oper_aggregator_key,
1660 agg->is_individual, agg->is_active);
1661 }
1662
1663
1664 if (best->is_individual) {
1665 net_warn_ratelimited("%s: Warning: No 802.3ad response from the link partner for any adapters in the bond\n",
1666 best->slave ?
1667 best->slave->bond->dev->name : "NULL");
1668 }
1669
1670 best->is_active = 1;
1671 netdev_dbg(bond->dev, "LAG %d chosen as the active LAG\n",
1672 best->aggregator_identifier);
1673 netdev_dbg(bond->dev, "Agg=%d; P=%d; a k=%d; p k=%d; Ind=%d; Act=%d\n",
1674 best->aggregator_identifier, best->num_of_ports,
1675 best->actor_oper_aggregator_key,
1676 best->partner_oper_aggregator_key,
1677 best->is_individual, best->is_active);
1678
1679
1680
1681
1682 if (active) {
1683 for (port = active->lag_ports; port;
1684 port = port->next_port_in_aggregator) {
1685 __disable_port(port);
1686 }
1687 }
1688
1689 *update_slave_arr = true;
1690 }
1691
1692
1693
1694
1695 active = __get_active_agg(origin);
1696
1697 if (active) {
1698 if (!__agg_has_partner(active)) {
1699 for (port = active->lag_ports; port;
1700 port = port->next_port_in_aggregator) {
1701 __enable_port(port);
1702 }
1703 }
1704 }
1705
1706 rcu_read_unlock();
1707
1708 bond_3ad_set_carrier(bond);
1709}
1710
1711
1712
1713
1714
1715static void ad_clear_agg(struct aggregator *aggregator)
1716{
1717 if (aggregator) {
1718 aggregator->is_individual = false;
1719 aggregator->actor_admin_aggregator_key = 0;
1720 aggregator->actor_oper_aggregator_key = 0;
1721 aggregator->partner_system = null_mac_addr;
1722 aggregator->partner_system_priority = 0;
1723 aggregator->partner_oper_aggregator_key = 0;
1724 aggregator->receive_state = 0;
1725 aggregator->transmit_state = 0;
1726 aggregator->lag_ports = NULL;
1727 aggregator->is_active = 0;
1728 aggregator->num_of_ports = 0;
1729 pr_debug("LAG %d was cleared\n",
1730 aggregator->aggregator_identifier);
1731 }
1732}
1733
1734
1735
1736
1737
1738static void ad_initialize_agg(struct aggregator *aggregator)
1739{
1740 if (aggregator) {
1741 ad_clear_agg(aggregator);
1742
1743 aggregator->aggregator_mac_address = null_mac_addr;
1744 aggregator->aggregator_identifier = 0;
1745 aggregator->slave = NULL;
1746 }
1747}
1748
1749
1750
1751
1752
1753
1754static void ad_initialize_port(struct port *port, int lacp_fast)
1755{
1756 static const struct port_params tmpl = {
1757 .system_priority = 0xffff,
1758 .key = 1,
1759 .port_number = 1,
1760 .port_priority = 0xff,
1761 .port_state = 1,
1762 };
1763 static const struct lacpdu lacpdu = {
1764 .subtype = 0x01,
1765 .version_number = 0x01,
1766 .tlv_type_actor_info = 0x01,
1767 .actor_information_length = 0x14,
1768 .tlv_type_partner_info = 0x02,
1769 .partner_information_length = 0x14,
1770 .tlv_type_collector_info = 0x03,
1771 .collector_information_length = 0x10,
1772 .collector_max_delay = htons(AD_COLLECTOR_MAX_DELAY),
1773 };
1774
1775 if (port) {
1776 port->actor_port_priority = 0xff;
1777 port->actor_port_aggregator_identifier = 0;
1778 port->ntt = false;
1779 port->actor_admin_port_state = AD_STATE_AGGREGATION |
1780 AD_STATE_LACP_ACTIVITY;
1781 port->actor_oper_port_state = AD_STATE_AGGREGATION |
1782 AD_STATE_LACP_ACTIVITY;
1783
1784 if (lacp_fast)
1785 port->actor_oper_port_state |= AD_STATE_LACP_TIMEOUT;
1786
1787 memcpy(&port->partner_admin, &tmpl, sizeof(tmpl));
1788 memcpy(&port->partner_oper, &tmpl, sizeof(tmpl));
1789
1790 port->is_enabled = true;
1791
1792 port->sm_vars = AD_PORT_BEGIN | AD_PORT_LACP_ENABLED;
1793 port->sm_rx_state = 0;
1794 port->sm_rx_timer_counter = 0;
1795 port->sm_periodic_state = 0;
1796 port->sm_periodic_timer_counter = 0;
1797 port->sm_mux_state = 0;
1798 port->sm_mux_timer_counter = 0;
1799 port->sm_tx_state = 0;
1800 port->aggregator = NULL;
1801 port->next_port_in_aggregator = NULL;
1802 port->transaction_id = 0;
1803
1804 port->sm_churn_actor_timer_counter = 0;
1805 port->sm_churn_actor_state = 0;
1806 port->churn_actor_count = 0;
1807 port->sm_churn_partner_timer_counter = 0;
1808 port->sm_churn_partner_state = 0;
1809 port->churn_partner_count = 0;
1810
1811 memcpy(&port->lacpdu, &lacpdu, sizeof(lacpdu));
1812 }
1813}
1814
1815
1816
1817
1818
1819
1820
1821
1822static void ad_enable_collecting_distributing(struct port *port,
1823 bool *update_slave_arr)
1824{
1825 if (port->aggregator->is_active) {
1826 pr_debug("Enabling port %d(LAG %d)\n",
1827 port->actor_port_number,
1828 port->aggregator->aggregator_identifier);
1829 __enable_port(port);
1830
1831 *update_slave_arr = true;
1832 }
1833}
1834
1835
1836
1837
1838
1839
1840static void ad_disable_collecting_distributing(struct port *port,
1841 bool *update_slave_arr)
1842{
1843 if (port->aggregator &&
1844 !MAC_ADDRESS_EQUAL(&(port->aggregator->partner_system),
1845 &(null_mac_addr))) {
1846 pr_debug("Disabling port %d(LAG %d)\n",
1847 port->actor_port_number,
1848 port->aggregator->aggregator_identifier);
1849 __disable_port(port);
1850
1851 *update_slave_arr = true;
1852 }
1853}
1854
1855
1856
1857
1858
1859
1860static void ad_marker_info_received(struct bond_marker *marker_info,
1861 struct port *port)
1862{
1863 struct bond_marker marker;
1864
1865
1866 memcpy(&marker, marker_info, sizeof(struct bond_marker));
1867
1868 marker.tlv_type = AD_MARKER_RESPONSE_SUBTYPE;
1869
1870
1871 if (ad_marker_send(port, &marker) >= 0) {
1872 pr_debug("Sent Marker Response on port %d\n",
1873 port->actor_port_number);
1874 }
1875}
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886static void ad_marker_response_received(struct bond_marker *marker,
1887 struct port *port)
1888{
1889
1890}
1891
1892
1893
1894
1895#define AD_AGGREGATOR_SELECTION_TIMER 8
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905void bond_3ad_initiate_agg_selection(struct bonding *bond, int timeout)
1906{
1907 BOND_AD_INFO(bond).agg_select_timer = timeout;
1908}
1909
1910
1911
1912
1913
1914
1915
1916
1917void bond_3ad_initialize(struct bonding *bond, u16 tick_resolution)
1918{
1919
1920 if (!MAC_ADDRESS_EQUAL(&(BOND_AD_INFO(bond).system.sys_mac_addr),
1921 bond->dev->dev_addr)) {
1922
1923 BOND_AD_INFO(bond).aggregator_identifier = 0;
1924
1925 BOND_AD_INFO(bond).system.sys_priority =
1926 bond->params.ad_actor_sys_prio;
1927 if (is_zero_ether_addr(bond->params.ad_actor_system))
1928 BOND_AD_INFO(bond).system.sys_mac_addr =
1929 *((struct mac_addr *)bond->dev->dev_addr);
1930 else
1931 BOND_AD_INFO(bond).system.sys_mac_addr =
1932 *((struct mac_addr *)bond->params.ad_actor_system);
1933
1934
1935
1936
1937 ad_ticks_per_sec = tick_resolution;
1938
1939 bond_3ad_initiate_agg_selection(bond,
1940 AD_AGGREGATOR_SELECTION_TIMER *
1941 ad_ticks_per_sec);
1942 }
1943}
1944
1945
1946
1947
1948
1949
1950
1951
1952void bond_3ad_bind_slave(struct slave *slave)
1953{
1954 struct bonding *bond = bond_get_bond_by_slave(slave);
1955 struct port *port;
1956 struct aggregator *aggregator;
1957
1958
1959 if (SLAVE_AD_INFO(slave)->port.slave != slave) {
1960
1961
1962 port = &(SLAVE_AD_INFO(slave)->port);
1963
1964 ad_initialize_port(port, bond->params.lacp_fast);
1965
1966 port->slave = slave;
1967 port->actor_port_number = SLAVE_AD_INFO(slave)->id;
1968
1969
1970
1971 port->actor_admin_port_key = bond->params.ad_user_port_key << 6;
1972 ad_update_actor_keys(port, false);
1973
1974 __ad_actor_update_port(port);
1975
1976
1977
1978 port->sm_tx_timer_counter = ad_ticks_per_sec/AD_MAX_TX_IN_SECOND;
1979
1980 __disable_port(port);
1981
1982
1983 aggregator = &(SLAVE_AD_INFO(slave)->aggregator);
1984
1985 ad_initialize_agg(aggregator);
1986
1987 aggregator->aggregator_mac_address = *((struct mac_addr *)bond->dev->dev_addr);
1988 aggregator->aggregator_identifier = ++BOND_AD_INFO(bond).aggregator_identifier;
1989 aggregator->slave = slave;
1990 aggregator->is_active = 0;
1991 aggregator->num_of_ports = 0;
1992 }
1993}
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003void bond_3ad_unbind_slave(struct slave *slave)
2004{
2005 struct port *port, *prev_port, *temp_port;
2006 struct aggregator *aggregator, *new_aggregator, *temp_aggregator;
2007 int select_new_active_agg = 0;
2008 struct bonding *bond = slave->bond;
2009 struct slave *slave_iter;
2010 struct list_head *iter;
2011 bool dummy_slave_update;
2012
2013
2014 spin_lock_bh(&bond->mode_lock);
2015 aggregator = &(SLAVE_AD_INFO(slave)->aggregator);
2016 port = &(SLAVE_AD_INFO(slave)->port);
2017
2018
2019 if (!port->slave) {
2020 netdev_warn(bond->dev, "Trying to unbind an uninitialized port on %s\n",
2021 slave->dev->name);
2022 goto out;
2023 }
2024
2025 netdev_dbg(bond->dev, "Unbinding Link Aggregation Group %d\n",
2026 aggregator->aggregator_identifier);
2027
2028
2029 port->actor_oper_port_state &= ~AD_STATE_AGGREGATION;
2030 __update_lacpdu_from_port(port);
2031 ad_lacpdu_send(port);
2032
2033
2034 if (aggregator->lag_ports) {
2035
2036
2037
2038
2039
2040 if ((aggregator->lag_ports != port) ||
2041 (aggregator->lag_ports->next_port_in_aggregator)) {
2042
2043 bond_for_each_slave(bond, slave_iter, iter) {
2044 new_aggregator = &(SLAVE_AD_INFO(slave_iter)->aggregator);
2045
2046
2047
2048 if (!new_aggregator->lag_ports ||
2049 ((new_aggregator->lag_ports == port) &&
2050 !new_aggregator->lag_ports->next_port_in_aggregator))
2051 break;
2052 }
2053 if (!slave_iter)
2054 new_aggregator = NULL;
2055
2056
2057
2058
2059
2060 if ((new_aggregator) && ((!new_aggregator->lag_ports) || ((new_aggregator->lag_ports == port) && !new_aggregator->lag_ports->next_port_in_aggregator))) {
2061 netdev_dbg(bond->dev, "Some port(s) related to LAG %d - replacing with LAG %d\n",
2062 aggregator->aggregator_identifier,
2063 new_aggregator->aggregator_identifier);
2064
2065 if ((new_aggregator->lag_ports == port) &&
2066 new_aggregator->is_active) {
2067 netdev_info(bond->dev, "Removing an active aggregator\n");
2068 select_new_active_agg = 1;
2069 }
2070
2071 new_aggregator->is_individual = aggregator->is_individual;
2072 new_aggregator->actor_admin_aggregator_key = aggregator->actor_admin_aggregator_key;
2073 new_aggregator->actor_oper_aggregator_key = aggregator->actor_oper_aggregator_key;
2074 new_aggregator->partner_system = aggregator->partner_system;
2075 new_aggregator->partner_system_priority = aggregator->partner_system_priority;
2076 new_aggregator->partner_oper_aggregator_key = aggregator->partner_oper_aggregator_key;
2077 new_aggregator->receive_state = aggregator->receive_state;
2078 new_aggregator->transmit_state = aggregator->transmit_state;
2079 new_aggregator->lag_ports = aggregator->lag_ports;
2080 new_aggregator->is_active = aggregator->is_active;
2081 new_aggregator->num_of_ports = aggregator->num_of_ports;
2082
2083
2084
2085
2086 for (temp_port = aggregator->lag_ports; temp_port;
2087 temp_port = temp_port->next_port_in_aggregator) {
2088 temp_port->aggregator = new_aggregator;
2089 temp_port->actor_port_aggregator_identifier = new_aggregator->aggregator_identifier;
2090 }
2091
2092 ad_clear_agg(aggregator);
2093
2094 if (select_new_active_agg)
2095 ad_agg_selection_logic(__get_first_agg(port),
2096 &dummy_slave_update);
2097 } else {
2098 netdev_warn(bond->dev, "unbinding aggregator, and could not find a new aggregator for its ports\n");
2099 }
2100 } else {
2101
2102
2103
2104 select_new_active_agg = aggregator->is_active;
2105 ad_clear_agg(aggregator);
2106 if (select_new_active_agg) {
2107 netdev_info(bond->dev, "Removing an active aggregator\n");
2108
2109 temp_aggregator = __get_first_agg(port);
2110 if (temp_aggregator)
2111 ad_agg_selection_logic(temp_aggregator,
2112 &dummy_slave_update);
2113 }
2114 }
2115 }
2116
2117 netdev_dbg(bond->dev, "Unbinding port %d\n", port->actor_port_number);
2118
2119
2120 bond_for_each_slave(bond, slave_iter, iter) {
2121 temp_aggregator = &(SLAVE_AD_INFO(slave_iter)->aggregator);
2122 prev_port = NULL;
2123
2124 for (temp_port = temp_aggregator->lag_ports; temp_port;
2125 prev_port = temp_port,
2126 temp_port = temp_port->next_port_in_aggregator) {
2127 if (temp_port == port) {
2128
2129
2130
2131 if (prev_port)
2132 prev_port->next_port_in_aggregator = temp_port->next_port_in_aggregator;
2133 else
2134 temp_aggregator->lag_ports = temp_port->next_port_in_aggregator;
2135 temp_aggregator->num_of_ports--;
2136 if (temp_aggregator->num_of_ports == 0) {
2137 select_new_active_agg = temp_aggregator->is_active;
2138 ad_clear_agg(temp_aggregator);
2139 if (select_new_active_agg) {
2140 netdev_info(bond->dev, "Removing an active aggregator\n");
2141
2142 ad_agg_selection_logic(__get_first_agg(port),
2143 &dummy_slave_update);
2144 }
2145 }
2146 break;
2147 }
2148 }
2149 }
2150 port->slave = NULL;
2151
2152out:
2153 spin_unlock_bh(&bond->mode_lock);
2154}
2155
2156
2157
2158
2159
2160
2161
2162
2163void bond_3ad_update_ad_actor_settings(struct bonding *bond)
2164{
2165 struct list_head *iter;
2166 struct slave *slave;
2167
2168 ASSERT_RTNL();
2169
2170 BOND_AD_INFO(bond).system.sys_priority = bond->params.ad_actor_sys_prio;
2171 if (is_zero_ether_addr(bond->params.ad_actor_system))
2172 BOND_AD_INFO(bond).system.sys_mac_addr =
2173 *((struct mac_addr *)bond->dev->dev_addr);
2174 else
2175 BOND_AD_INFO(bond).system.sys_mac_addr =
2176 *((struct mac_addr *)bond->params.ad_actor_system);
2177
2178 spin_lock_bh(&bond->mode_lock);
2179 bond_for_each_slave(bond, slave, iter) {
2180 struct port *port = &(SLAVE_AD_INFO(slave))->port;
2181
2182 __ad_actor_update_port(port);
2183 port->ntt = true;
2184 }
2185 spin_unlock_bh(&bond->mode_lock);
2186}
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201void bond_3ad_state_machine_handler(struct work_struct *work)
2202{
2203 struct bonding *bond = container_of(work, struct bonding,
2204 ad_work.work);
2205 struct aggregator *aggregator;
2206 struct list_head *iter;
2207 struct slave *slave;
2208 struct port *port;
2209 bool should_notify_rtnl = BOND_SLAVE_NOTIFY_LATER;
2210 bool update_slave_arr = false;
2211
2212
2213
2214
2215
2216 spin_lock_bh(&bond->mode_lock);
2217 rcu_read_lock();
2218
2219
2220 if (!bond_has_slaves(bond))
2221 goto re_arm;
2222
2223
2224 if (BOND_AD_INFO(bond).agg_select_timer &&
2225 !(--BOND_AD_INFO(bond).agg_select_timer)) {
2226 slave = bond_first_slave_rcu(bond);
2227 port = slave ? &(SLAVE_AD_INFO(slave)->port) : NULL;
2228
2229
2230 if (port) {
2231 if (!port->slave) {
2232 net_warn_ratelimited("%s: Warning: bond's first port is uninitialized\n",
2233 bond->dev->name);
2234 goto re_arm;
2235 }
2236
2237 aggregator = __get_first_agg(port);
2238 ad_agg_selection_logic(aggregator, &update_slave_arr);
2239 }
2240 bond_3ad_set_carrier(bond);
2241 }
2242
2243
2244 bond_for_each_slave_rcu(bond, slave, iter) {
2245 port = &(SLAVE_AD_INFO(slave)->port);
2246 if (!port->slave) {
2247 net_warn_ratelimited("%s: Warning: Found an uninitialized port\n",
2248 bond->dev->name);
2249 goto re_arm;
2250 }
2251
2252 ad_rx_machine(NULL, port);
2253 ad_periodic_machine(port);
2254 ad_port_selection_logic(port, &update_slave_arr);
2255 ad_mux_machine(port, &update_slave_arr);
2256 ad_tx_machine(port);
2257 ad_churn_machine(port);
2258
2259
2260 if (port->sm_vars & AD_PORT_BEGIN)
2261 port->sm_vars &= ~AD_PORT_BEGIN;
2262 }
2263
2264re_arm:
2265 bond_for_each_slave_rcu(bond, slave, iter) {
2266 if (slave->should_notify) {
2267 should_notify_rtnl = BOND_SLAVE_NOTIFY_NOW;
2268 break;
2269 }
2270 }
2271 rcu_read_unlock();
2272 spin_unlock_bh(&bond->mode_lock);
2273
2274 if (update_slave_arr)
2275 bond_slave_arr_work_rearm(bond, 0);
2276
2277 if (should_notify_rtnl && rtnl_trylock()) {
2278 bond_slave_state_notify(bond);
2279 rtnl_unlock();
2280 }
2281 queue_delayed_work(bond->wq, &bond->ad_work, ad_delta_in_ticks);
2282}
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294static int bond_3ad_rx_indication(struct lacpdu *lacpdu, struct slave *slave,
2295 u16 length)
2296{
2297 struct port *port;
2298 int ret = RX_HANDLER_ANOTHER;
2299
2300 if (length >= sizeof(struct lacpdu)) {
2301
2302 port = &(SLAVE_AD_INFO(slave)->port);
2303
2304 if (!port->slave) {
2305 net_warn_ratelimited("%s: Warning: port of slave %s is uninitialized\n",
2306 slave->dev->name, slave->bond->dev->name);
2307 return ret;
2308 }
2309
2310 switch (lacpdu->subtype) {
2311 case AD_TYPE_LACPDU:
2312 ret = RX_HANDLER_CONSUMED;
2313 netdev_dbg(slave->bond->dev,
2314 "Received LACPDU on port %d slave %s\n",
2315 port->actor_port_number,
2316 slave->dev->name);
2317
2318 spin_lock(&slave->bond->mode_lock);
2319 ad_rx_machine(lacpdu, port);
2320 spin_unlock(&slave->bond->mode_lock);
2321 break;
2322
2323 case AD_TYPE_MARKER:
2324 ret = RX_HANDLER_CONSUMED;
2325
2326
2327
2328
2329 switch (((struct bond_marker *)lacpdu)->tlv_type) {
2330 case AD_MARKER_INFORMATION_SUBTYPE:
2331 netdev_dbg(slave->bond->dev, "Received Marker Information on port %d\n",
2332 port->actor_port_number);
2333 ad_marker_info_received((struct bond_marker *)lacpdu, port);
2334 break;
2335
2336 case AD_MARKER_RESPONSE_SUBTYPE:
2337 netdev_dbg(slave->bond->dev, "Received Marker Response on port %d\n",
2338 port->actor_port_number);
2339 ad_marker_response_received((struct bond_marker *)lacpdu, port);
2340 break;
2341
2342 default:
2343 netdev_dbg(slave->bond->dev, "Received an unknown Marker subtype on slot %d\n",
2344 port->actor_port_number);
2345 }
2346 }
2347 }
2348 return ret;
2349}
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362static void ad_update_actor_keys(struct port *port, bool reset)
2363{
2364 u8 duplex = 0;
2365 u16 ospeed = 0, speed = 0;
2366 u16 old_oper_key = port->actor_oper_port_key;
2367
2368 port->actor_admin_port_key &= ~(AD_SPEED_KEY_MASKS|AD_DUPLEX_KEY_MASKS);
2369 if (!reset) {
2370 speed = __get_link_speed(port);
2371 ospeed = (old_oper_key & AD_SPEED_KEY_MASKS) >> 1;
2372 duplex = __get_duplex(port);
2373 port->actor_admin_port_key |= (speed << 1) | duplex;
2374 }
2375 port->actor_oper_port_key = port->actor_admin_port_key;
2376
2377 if (old_oper_key != port->actor_oper_port_key) {
2378
2379 if (duplex)
2380 port->sm_vars |= AD_PORT_LACP_ENABLED;
2381 else
2382 port->sm_vars &= ~AD_PORT_LACP_ENABLED;
2383
2384 if (!reset) {
2385 if (!speed) {
2386 netdev_err(port->slave->dev,
2387 "speed changed to 0 for port %s",
2388 port->slave->dev->name);
2389 } else if (duplex && ospeed != speed) {
2390
2391 port->sm_vars |= AD_PORT_BEGIN;
2392 }
2393 }
2394 }
2395}
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405void bond_3ad_adapter_speed_duplex_changed(struct slave *slave)
2406{
2407 struct port *port;
2408
2409 port = &(SLAVE_AD_INFO(slave)->port);
2410
2411
2412 if (!port->slave) {
2413 netdev_warn(slave->bond->dev,
2414 "speed/duplex changed for uninitialized port %s\n",
2415 slave->dev->name);
2416 return;
2417 }
2418
2419 spin_lock_bh(&slave->bond->mode_lock);
2420 ad_update_actor_keys(port, false);
2421 netdev_dbg(slave->bond->dev, "Port %d slave %s changed speed/duplex\n",
2422 port->actor_port_number, slave->dev->name);
2423 spin_unlock_bh(&slave->bond->mode_lock);
2424}
2425
2426
2427
2428
2429
2430
2431
2432
2433void bond_3ad_handle_link_change(struct slave *slave, char link)
2434{
2435 struct port *port;
2436
2437 port = &(SLAVE_AD_INFO(slave)->port);
2438
2439
2440 if (!port->slave) {
2441 netdev_warn(slave->bond->dev, "link status changed for uninitialized port on %s\n",
2442 slave->dev->name);
2443 return;
2444 }
2445
2446 spin_lock_bh(&slave->bond->mode_lock);
2447
2448
2449
2450
2451
2452
2453
2454 if (link == BOND_LINK_UP) {
2455 port->is_enabled = true;
2456 ad_update_actor_keys(port, false);
2457 } else {
2458
2459 port->is_enabled = false;
2460 ad_update_actor_keys(port, true);
2461 }
2462 netdev_dbg(slave->bond->dev, "Port %d changed link status to %s\n",
2463 port->actor_port_number,
2464 link == BOND_LINK_UP ? "UP" : "DOWN");
2465
2466 spin_unlock_bh(&slave->bond->mode_lock);
2467
2468
2469
2470
2471 bond_update_slave_arr(slave->bond, NULL);
2472}
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487int bond_3ad_set_carrier(struct bonding *bond)
2488{
2489 struct aggregator *active;
2490 struct slave *first_slave;
2491 int ret = 1;
2492
2493 rcu_read_lock();
2494 first_slave = bond_first_slave_rcu(bond);
2495 if (!first_slave) {
2496 ret = 0;
2497 goto out;
2498 }
2499 active = __get_active_agg(&(SLAVE_AD_INFO(first_slave)->aggregator));
2500 if (active) {
2501
2502 if (active->num_of_ports < bond->params.min_links) {
2503 if (netif_carrier_ok(bond->dev)) {
2504 netif_carrier_off(bond->dev);
2505 goto out;
2506 }
2507 } else if (!netif_carrier_ok(bond->dev)) {
2508 netif_carrier_on(bond->dev);
2509 goto out;
2510 }
2511 } else if (netif_carrier_ok(bond->dev)) {
2512 netif_carrier_off(bond->dev);
2513 }
2514out:
2515 rcu_read_unlock();
2516 return ret;
2517}
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527int __bond_3ad_get_active_agg_info(struct bonding *bond,
2528 struct ad_info *ad_info)
2529{
2530 struct aggregator *aggregator = NULL;
2531 struct list_head *iter;
2532 struct slave *slave;
2533 struct port *port;
2534
2535 bond_for_each_slave_rcu(bond, slave, iter) {
2536 port = &(SLAVE_AD_INFO(slave)->port);
2537 if (port->aggregator && port->aggregator->is_active) {
2538 aggregator = port->aggregator;
2539 break;
2540 }
2541 }
2542
2543 if (!aggregator)
2544 return -1;
2545
2546 ad_info->aggregator_id = aggregator->aggregator_identifier;
2547 ad_info->ports = aggregator->num_of_ports;
2548 ad_info->actor_key = aggregator->actor_oper_aggregator_key;
2549 ad_info->partner_key = aggregator->partner_oper_aggregator_key;
2550 ether_addr_copy(ad_info->partner_system,
2551 aggregator->partner_system.mac_addr_value);
2552 return 0;
2553}
2554
2555int bond_3ad_get_active_agg_info(struct bonding *bond, struct ad_info *ad_info)
2556{
2557 int ret;
2558
2559 rcu_read_lock();
2560 ret = __bond_3ad_get_active_agg_info(bond, ad_info);
2561 rcu_read_unlock();
2562
2563 return ret;
2564}
2565
2566int bond_3ad_lacpdu_recv(const struct sk_buff *skb, struct bonding *bond,
2567 struct slave *slave)
2568{
2569 struct lacpdu *lacpdu, _lacpdu;
2570
2571 if (skb->protocol != PKT_TYPE_LACPDU)
2572 return RX_HANDLER_ANOTHER;
2573
2574 if (!MAC_ADDRESS_EQUAL(eth_hdr(skb)->h_dest, lacpdu_mcast_addr))
2575 return RX_HANDLER_ANOTHER;
2576
2577 lacpdu = skb_header_pointer(skb, 0, sizeof(_lacpdu), &_lacpdu);
2578 if (!lacpdu)
2579 return RX_HANDLER_ANOTHER;
2580
2581 return bond_3ad_rx_indication(lacpdu, slave, skb->len);
2582}
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595void bond_3ad_update_lacp_rate(struct bonding *bond)
2596{
2597 struct port *port = NULL;
2598 struct list_head *iter;
2599 struct slave *slave;
2600 int lacp_fast;
2601
2602 lacp_fast = bond->params.lacp_fast;
2603 spin_lock_bh(&bond->mode_lock);
2604 bond_for_each_slave(bond, slave, iter) {
2605 port = &(SLAVE_AD_INFO(slave)->port);
2606 if (lacp_fast)
2607 port->actor_oper_port_state |= AD_STATE_LACP_TIMEOUT;
2608 else
2609 port->actor_oper_port_state &= ~AD_STATE_LACP_TIMEOUT;
2610 }
2611 spin_unlock_bh(&bond->mode_lock);
2612}
2613