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