2 * Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, see <http://www.gnu.org/licenses/>.
17 * The full GNU General Public License is included in this distribution in the
18 * file called LICENSE.
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 #include <linux/skbuff.h>
25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h>
27 #include <linux/pkt_sched.h>
28 #include <linux/spinlock.h>
29 #include <linux/slab.h>
30 #include <linux/timer.h>
32 #include <linux/ipv6.h>
33 #include <linux/if_arp.h>
34 #include <linux/if_ether.h>
35 #include <linux/if_bonding.h>
36 #include <linux/if_vlan.h>
41 #include <asm/byteorder.h>
47 #ifndef __long_aligned
48 #define __long_aligned __attribute__((aligned((sizeof(long)))))
50 static const u8 mac_bcast
[ETH_ALEN
] __long_aligned
= {
51 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
53 static const u8 mac_v6_allmcast
[ETH_ALEN
] __long_aligned
= {
54 0x33, 0x33, 0x00, 0x00, 0x00, 0x01
56 static const int alb_delta_in_ticks
= HZ
/ ALB_TIMER_TICKS_PER_SEC
;
63 u8 padding
[ETH_ZLEN
- ETH_HLEN
];
68 __be16 prot_addr_space
;
72 u8 mac_src
[ETH_ALEN
]; /* sender hardware address */
73 __be32 ip_src
; /* sender IP address */
74 u8 mac_dst
[ETH_ALEN
]; /* target hardware address */
75 __be32 ip_dst
; /* target IP address */
79 static inline struct arp_pkt
*arp_pkt(const struct sk_buff
*skb
)
81 return (struct arp_pkt
*)skb_network_header(skb
);
84 /* Forward declaration */
85 static void alb_send_learning_packets(struct slave
*slave
, u8 mac_addr
[],
87 static void rlb_purge_src_ip(struct bonding
*bond
, struct arp_pkt
*arp
);
88 static void rlb_src_unlink(struct bonding
*bond
, u32 index
);
89 static void rlb_src_link(struct bonding
*bond
, u32 ip_src_hash
,
92 static inline u8
_simple_hash(const u8
*hash_start
, int hash_size
)
97 for (i
= 0; i
< hash_size
; i
++)
98 hash
^= hash_start
[i
];
103 /*********************** tlb specific functions ***************************/
105 static inline void _lock_tx_hashtbl_bh(struct bonding
*bond
)
107 spin_lock_bh(&(BOND_ALB_INFO(bond
).tx_hashtbl_lock
));
110 static inline void _unlock_tx_hashtbl_bh(struct bonding
*bond
)
112 spin_unlock_bh(&(BOND_ALB_INFO(bond
).tx_hashtbl_lock
));
115 static inline void _lock_tx_hashtbl(struct bonding
*bond
)
117 spin_lock(&(BOND_ALB_INFO(bond
).tx_hashtbl_lock
));
120 static inline void _unlock_tx_hashtbl(struct bonding
*bond
)
122 spin_unlock(&(BOND_ALB_INFO(bond
).tx_hashtbl_lock
));
125 /* Caller must hold tx_hashtbl lock */
126 static inline void tlb_init_table_entry(struct tlb_client_info
*entry
, int save_load
)
129 entry
->load_history
= 1 + entry
->tx_bytes
/
130 BOND_TLB_REBALANCE_INTERVAL
;
134 entry
->tx_slave
= NULL
;
135 entry
->next
= TLB_NULL_INDEX
;
136 entry
->prev
= TLB_NULL_INDEX
;
139 static inline void tlb_init_slave(struct slave
*slave
)
141 SLAVE_TLB_INFO(slave
).load
= 0;
142 SLAVE_TLB_INFO(slave
).head
= TLB_NULL_INDEX
;
145 /* Caller must hold bond lock for read, BH disabled */
146 static void __tlb_clear_slave(struct bonding
*bond
, struct slave
*slave
,
149 struct tlb_client_info
*tx_hash_table
;
152 /* clear slave from tx_hashtbl */
153 tx_hash_table
= BOND_ALB_INFO(bond
).tx_hashtbl
;
155 /* skip this if we've already freed the tx hash table */
157 index
= SLAVE_TLB_INFO(slave
).head
;
158 while (index
!= TLB_NULL_INDEX
) {
159 u32 next_index
= tx_hash_table
[index
].next
;
160 tlb_init_table_entry(&tx_hash_table
[index
], save_load
);
165 tlb_init_slave(slave
);
168 /* Caller must hold bond lock for read */
169 static void tlb_clear_slave(struct bonding
*bond
, struct slave
*slave
,
172 _lock_tx_hashtbl_bh(bond
);
173 __tlb_clear_slave(bond
, slave
, save_load
);
174 _unlock_tx_hashtbl_bh(bond
);
177 /* Must be called before starting the monitor timer */
178 static int tlb_initialize(struct bonding
*bond
)
180 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
181 int size
= TLB_HASH_TABLE_SIZE
* sizeof(struct tlb_client_info
);
182 struct tlb_client_info
*new_hashtbl
;
185 new_hashtbl
= kzalloc(size
, GFP_KERNEL
);
189 _lock_tx_hashtbl_bh(bond
);
191 bond_info
->tx_hashtbl
= new_hashtbl
;
193 for (i
= 0; i
< TLB_HASH_TABLE_SIZE
; i
++)
194 tlb_init_table_entry(&bond_info
->tx_hashtbl
[i
], 0);
196 _unlock_tx_hashtbl_bh(bond
);
201 /* Must be called only after all slaves have been released */
202 static void tlb_deinitialize(struct bonding
*bond
)
204 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
206 _lock_tx_hashtbl_bh(bond
);
208 kfree(bond_info
->tx_hashtbl
);
209 bond_info
->tx_hashtbl
= NULL
;
211 _unlock_tx_hashtbl_bh(bond
);
214 static long long compute_gap(struct slave
*slave
)
216 return (s64
) (slave
->speed
<< 20) - /* Convert to Megabit per sec */
217 (s64
) (SLAVE_TLB_INFO(slave
).load
<< 3); /* Bytes to bits */
220 /* Caller must hold bond lock for read */
221 static struct slave
*tlb_get_least_loaded_slave(struct bonding
*bond
)
223 struct slave
*slave
, *least_loaded
;
224 struct list_head
*iter
;
230 /* Find the slave with the largest gap */
231 bond_for_each_slave_rcu(bond
, slave
, iter
) {
232 if (SLAVE_IS_OK(slave
)) {
233 long long gap
= compute_gap(slave
);
236 least_loaded
= slave
;
245 static struct slave
*__tlb_choose_channel(struct bonding
*bond
, u32 hash_index
,
248 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
249 struct tlb_client_info
*hash_table
;
250 struct slave
*assigned_slave
;
252 hash_table
= bond_info
->tx_hashtbl
;
253 assigned_slave
= hash_table
[hash_index
].tx_slave
;
254 if (!assigned_slave
) {
255 assigned_slave
= tlb_get_least_loaded_slave(bond
);
257 if (assigned_slave
) {
258 struct tlb_slave_info
*slave_info
=
259 &(SLAVE_TLB_INFO(assigned_slave
));
260 u32 next_index
= slave_info
->head
;
262 hash_table
[hash_index
].tx_slave
= assigned_slave
;
263 hash_table
[hash_index
].next
= next_index
;
264 hash_table
[hash_index
].prev
= TLB_NULL_INDEX
;
266 if (next_index
!= TLB_NULL_INDEX
)
267 hash_table
[next_index
].prev
= hash_index
;
269 slave_info
->head
= hash_index
;
271 hash_table
[hash_index
].load_history
;
276 hash_table
[hash_index
].tx_bytes
+= skb_len
;
278 return assigned_slave
;
281 /* Caller must hold bond lock for read */
282 static struct slave
*tlb_choose_channel(struct bonding
*bond
, u32 hash_index
,
285 struct slave
*tx_slave
;
287 * We don't need to disable softirq here, becase
288 * tlb_choose_channel() is only called by bond_alb_xmit()
289 * which already has softirq disabled.
291 _lock_tx_hashtbl(bond
);
292 tx_slave
= __tlb_choose_channel(bond
, hash_index
, skb_len
);
293 _unlock_tx_hashtbl(bond
);
297 /*********************** rlb specific functions ***************************/
298 static inline void _lock_rx_hashtbl_bh(struct bonding
*bond
)
300 spin_lock_bh(&(BOND_ALB_INFO(bond
).rx_hashtbl_lock
));
303 static inline void _unlock_rx_hashtbl_bh(struct bonding
*bond
)
305 spin_unlock_bh(&(BOND_ALB_INFO(bond
).rx_hashtbl_lock
));
308 static inline void _lock_rx_hashtbl(struct bonding
*bond
)
310 spin_lock(&(BOND_ALB_INFO(bond
).rx_hashtbl_lock
));
313 static inline void _unlock_rx_hashtbl(struct bonding
*bond
)
315 spin_unlock(&(BOND_ALB_INFO(bond
).rx_hashtbl_lock
));
318 /* when an ARP REPLY is received from a client update its info
321 static void rlb_update_entry_from_arp(struct bonding
*bond
, struct arp_pkt
*arp
)
323 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
324 struct rlb_client_info
*client_info
;
327 _lock_rx_hashtbl_bh(bond
);
329 hash_index
= _simple_hash((u8
*)&(arp
->ip_src
), sizeof(arp
->ip_src
));
330 client_info
= &(bond_info
->rx_hashtbl
[hash_index
]);
332 if ((client_info
->assigned
) &&
333 (client_info
->ip_src
== arp
->ip_dst
) &&
334 (client_info
->ip_dst
== arp
->ip_src
) &&
335 (!ether_addr_equal_64bits(client_info
->mac_dst
, arp
->mac_src
))) {
336 /* update the clients MAC address */
337 ether_addr_copy(client_info
->mac_dst
, arp
->mac_src
);
338 client_info
->ntt
= 1;
339 bond_info
->rx_ntt
= 1;
342 _unlock_rx_hashtbl_bh(bond
);
345 static int rlb_arp_recv(const struct sk_buff
*skb
, struct bonding
*bond
,
348 struct arp_pkt
*arp
, _arp
;
350 if (skb
->protocol
!= cpu_to_be16(ETH_P_ARP
))
353 arp
= skb_header_pointer(skb
, 0, sizeof(_arp
), &_arp
);
357 /* We received an ARP from arp->ip_src.
358 * We might have used this IP address previously (on the bonding host
359 * itself or on a system that is bridged together with the bond).
360 * However, if arp->mac_src is different than what is stored in
361 * rx_hashtbl, some other host is now using the IP and we must prevent
362 * sending out client updates with this IP address and the old MAC
364 * Clean up all hash table entries that have this address as ip_src but
365 * have a different mac_src.
367 rlb_purge_src_ip(bond
, arp
);
369 if (arp
->op_code
== htons(ARPOP_REPLY
)) {
370 /* update rx hash table for this ARP */
371 rlb_update_entry_from_arp(bond
, arp
);
372 pr_debug("Server received an ARP Reply from client\n");
375 return RX_HANDLER_ANOTHER
;
378 /* Caller must hold bond lock for read */
379 static struct slave
*rlb_next_rx_slave(struct bonding
*bond
)
381 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
382 struct slave
*before
= NULL
, *rx_slave
= NULL
, *slave
;
383 struct list_head
*iter
;
386 bond_for_each_slave(bond
, slave
, iter
) {
387 if (!SLAVE_IS_OK(slave
))
390 if (!before
|| before
->speed
< slave
->speed
)
393 if (!rx_slave
|| rx_slave
->speed
< slave
->speed
)
396 if (slave
== bond_info
->rx_slave
)
399 /* we didn't find anything after the current or we have something
400 * better before and up to the current slave
402 if (!rx_slave
|| (before
&& rx_slave
->speed
< before
->speed
))
406 bond_info
->rx_slave
= rx_slave
;
411 /* Caller must hold rcu_read_lock() for read */
412 static struct slave
*__rlb_next_rx_slave(struct bonding
*bond
)
414 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
415 struct slave
*before
= NULL
, *rx_slave
= NULL
, *slave
;
416 struct list_head
*iter
;
419 bond_for_each_slave_rcu(bond
, slave
, iter
) {
420 if (!SLAVE_IS_OK(slave
))
423 if (!before
|| before
->speed
< slave
->speed
)
426 if (!rx_slave
|| rx_slave
->speed
< slave
->speed
)
429 if (slave
== bond_info
->rx_slave
)
432 /* we didn't find anything after the current or we have something
433 * better before and up to the current slave
435 if (!rx_slave
|| (before
&& rx_slave
->speed
< before
->speed
))
439 bond_info
->rx_slave
= rx_slave
;
444 /* teach the switch the mac of a disabled slave
445 * on the primary for fault tolerance
447 * Caller must hold bond->curr_slave_lock for write or bond lock for write
449 static void rlb_teach_disabled_mac_on_primary(struct bonding
*bond
, u8 addr
[])
451 if (!bond
->curr_active_slave
)
454 if (!bond
->alb_info
.primary_is_promisc
) {
455 if (!dev_set_promiscuity(bond
->curr_active_slave
->dev
, 1))
456 bond
->alb_info
.primary_is_promisc
= 1;
458 bond
->alb_info
.primary_is_promisc
= 0;
461 bond
->alb_info
.rlb_promisc_timeout_counter
= 0;
463 alb_send_learning_packets(bond
->curr_active_slave
, addr
, true);
466 /* slave being removed should not be active at this point
468 * Caller must hold rtnl.
470 static void rlb_clear_slave(struct bonding
*bond
, struct slave
*slave
)
472 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
473 struct rlb_client_info
*rx_hash_table
;
474 u32 index
, next_index
;
476 /* clear slave from rx_hashtbl */
477 _lock_rx_hashtbl_bh(bond
);
479 rx_hash_table
= bond_info
->rx_hashtbl
;
480 index
= bond_info
->rx_hashtbl_used_head
;
481 for (; index
!= RLB_NULL_INDEX
; index
= next_index
) {
482 next_index
= rx_hash_table
[index
].used_next
;
483 if (rx_hash_table
[index
].slave
== slave
) {
484 struct slave
*assigned_slave
= rlb_next_rx_slave(bond
);
486 if (assigned_slave
) {
487 rx_hash_table
[index
].slave
= assigned_slave
;
488 if (!ether_addr_equal_64bits(rx_hash_table
[index
].mac_dst
,
490 bond_info
->rx_hashtbl
[index
].ntt
= 1;
491 bond_info
->rx_ntt
= 1;
492 /* A slave has been removed from the
493 * table because it is either disabled
494 * or being released. We must retry the
495 * update to avoid clients from not
496 * being updated & disconnecting when
499 bond_info
->rlb_update_retry_counter
=
502 } else { /* there is no active slave */
503 rx_hash_table
[index
].slave
= NULL
;
508 _unlock_rx_hashtbl_bh(bond
);
510 write_lock_bh(&bond
->curr_slave_lock
);
512 if (slave
!= bond
->curr_active_slave
)
513 rlb_teach_disabled_mac_on_primary(bond
, slave
->dev
->dev_addr
);
515 write_unlock_bh(&bond
->curr_slave_lock
);
518 static void rlb_update_client(struct rlb_client_info
*client_info
)
522 if (!client_info
->slave
)
525 for (i
= 0; i
< RLB_ARP_BURST_SIZE
; i
++) {
528 skb
= arp_create(ARPOP_REPLY
, ETH_P_ARP
,
530 client_info
->slave
->dev
,
532 client_info
->mac_dst
,
533 client_info
->slave
->dev
->dev_addr
,
534 client_info
->mac_dst
);
536 pr_err("%s: Error: failed to create an ARP packet\n",
537 client_info
->slave
->bond
->dev
->name
);
541 skb
->dev
= client_info
->slave
->dev
;
543 if (client_info
->vlan_id
) {
544 skb
= vlan_put_tag(skb
, htons(ETH_P_8021Q
), client_info
->vlan_id
);
546 pr_err("%s: Error: failed to insert VLAN tag\n",
547 client_info
->slave
->bond
->dev
->name
);
556 /* sends ARP REPLIES that update the clients that need updating */
557 static void rlb_update_rx_clients(struct bonding
*bond
)
559 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
560 struct rlb_client_info
*client_info
;
563 _lock_rx_hashtbl_bh(bond
);
565 hash_index
= bond_info
->rx_hashtbl_used_head
;
566 for (; hash_index
!= RLB_NULL_INDEX
;
567 hash_index
= client_info
->used_next
) {
568 client_info
= &(bond_info
->rx_hashtbl
[hash_index
]);
569 if (client_info
->ntt
) {
570 rlb_update_client(client_info
);
571 if (bond_info
->rlb_update_retry_counter
== 0)
572 client_info
->ntt
= 0;
576 /* do not update the entries again until this counter is zero so that
577 * not to confuse the clients.
579 bond_info
->rlb_update_delay_counter
= RLB_UPDATE_DELAY
;
581 _unlock_rx_hashtbl_bh(bond
);
584 /* The slave was assigned a new mac address - update the clients */
585 static void rlb_req_update_slave_clients(struct bonding
*bond
, struct slave
*slave
)
587 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
588 struct rlb_client_info
*client_info
;
592 _lock_rx_hashtbl_bh(bond
);
594 hash_index
= bond_info
->rx_hashtbl_used_head
;
595 for (; hash_index
!= RLB_NULL_INDEX
;
596 hash_index
= client_info
->used_next
) {
597 client_info
= &(bond_info
->rx_hashtbl
[hash_index
]);
599 if ((client_info
->slave
== slave
) &&
600 !ether_addr_equal_64bits(client_info
->mac_dst
, mac_bcast
)) {
601 client_info
->ntt
= 1;
606 /* update the team's flag only after the whole iteration */
608 bond_info
->rx_ntt
= 1;
609 /* fasten the change */
610 bond_info
->rlb_update_retry_counter
= RLB_UPDATE_RETRY
;
613 _unlock_rx_hashtbl_bh(bond
);
616 /* mark all clients using src_ip to be updated */
617 static void rlb_req_update_subnet_clients(struct bonding
*bond
, __be32 src_ip
)
619 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
620 struct rlb_client_info
*client_info
;
623 _lock_rx_hashtbl(bond
);
625 hash_index
= bond_info
->rx_hashtbl_used_head
;
626 for (; hash_index
!= RLB_NULL_INDEX
;
627 hash_index
= client_info
->used_next
) {
628 client_info
= &(bond_info
->rx_hashtbl
[hash_index
]);
630 if (!client_info
->slave
) {
631 pr_err("%s: Error: found a client with no channel in the client's hash table\n",
635 /*update all clients using this src_ip, that are not assigned
636 * to the team's address (curr_active_slave) and have a known
637 * unicast mac address.
639 if ((client_info
->ip_src
== src_ip
) &&
640 !ether_addr_equal_64bits(client_info
->slave
->dev
->dev_addr
,
641 bond
->dev
->dev_addr
) &&
642 !ether_addr_equal_64bits(client_info
->mac_dst
, mac_bcast
)) {
643 client_info
->ntt
= 1;
644 bond_info
->rx_ntt
= 1;
648 _unlock_rx_hashtbl(bond
);
651 /* Caller must hold both bond and ptr locks for read */
652 static struct slave
*rlb_choose_channel(struct sk_buff
*skb
, struct bonding
*bond
)
654 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
655 struct arp_pkt
*arp
= arp_pkt(skb
);
656 struct slave
*assigned_slave
, *curr_active_slave
;
657 struct rlb_client_info
*client_info
;
660 _lock_rx_hashtbl(bond
);
662 curr_active_slave
= rcu_dereference(bond
->curr_active_slave
);
664 hash_index
= _simple_hash((u8
*)&arp
->ip_dst
, sizeof(arp
->ip_dst
));
665 client_info
= &(bond_info
->rx_hashtbl
[hash_index
]);
667 if (client_info
->assigned
) {
668 if ((client_info
->ip_src
== arp
->ip_src
) &&
669 (client_info
->ip_dst
== arp
->ip_dst
)) {
670 /* the entry is already assigned to this client */
671 if (!ether_addr_equal_64bits(arp
->mac_dst
, mac_bcast
)) {
672 /* update mac address from arp */
673 ether_addr_copy(client_info
->mac_dst
, arp
->mac_dst
);
675 ether_addr_copy(client_info
->mac_src
, arp
->mac_src
);
677 assigned_slave
= client_info
->slave
;
678 if (assigned_slave
) {
679 _unlock_rx_hashtbl(bond
);
680 return assigned_slave
;
683 /* the entry is already assigned to some other client,
684 * move the old client to primary (curr_active_slave) so
685 * that the new client can be assigned to this entry.
687 if (bond
->curr_active_slave
&&
688 client_info
->slave
!= curr_active_slave
) {
689 client_info
->slave
= curr_active_slave
;
690 rlb_update_client(client_info
);
694 /* assign a new slave */
695 assigned_slave
= __rlb_next_rx_slave(bond
);
697 if (assigned_slave
) {
698 if (!(client_info
->assigned
&&
699 client_info
->ip_src
== arp
->ip_src
)) {
700 /* ip_src is going to be updated,
701 * fix the src hash list
703 u32 hash_src
= _simple_hash((u8
*)&arp
->ip_src
,
704 sizeof(arp
->ip_src
));
705 rlb_src_unlink(bond
, hash_index
);
706 rlb_src_link(bond
, hash_src
, hash_index
);
709 client_info
->ip_src
= arp
->ip_src
;
710 client_info
->ip_dst
= arp
->ip_dst
;
711 /* arp->mac_dst is broadcast for arp reqeusts.
712 * will be updated with clients actual unicast mac address
713 * upon receiving an arp reply.
715 ether_addr_copy(client_info
->mac_dst
, arp
->mac_dst
);
716 ether_addr_copy(client_info
->mac_src
, arp
->mac_src
);
717 client_info
->slave
= assigned_slave
;
719 if (!ether_addr_equal_64bits(client_info
->mac_dst
, mac_bcast
)) {
720 client_info
->ntt
= 1;
721 bond
->alb_info
.rx_ntt
= 1;
723 client_info
->ntt
= 0;
726 if (vlan_get_tag(skb
, &client_info
->vlan_id
))
727 client_info
->vlan_id
= 0;
729 if (!client_info
->assigned
) {
730 u32 prev_tbl_head
= bond_info
->rx_hashtbl_used_head
;
731 bond_info
->rx_hashtbl_used_head
= hash_index
;
732 client_info
->used_next
= prev_tbl_head
;
733 if (prev_tbl_head
!= RLB_NULL_INDEX
) {
734 bond_info
->rx_hashtbl
[prev_tbl_head
].used_prev
=
737 client_info
->assigned
= 1;
741 _unlock_rx_hashtbl(bond
);
743 return assigned_slave
;
746 /* chooses (and returns) transmit channel for arp reply
747 * does not choose channel for other arp types since they are
748 * sent on the curr_active_slave
750 static struct slave
*rlb_arp_xmit(struct sk_buff
*skb
, struct bonding
*bond
)
752 struct arp_pkt
*arp
= arp_pkt(skb
);
753 struct slave
*tx_slave
= NULL
;
755 /* Don't modify or load balance ARPs that do not originate locally
756 * (e.g.,arrive via a bridge).
758 if (!bond_slave_has_mac_rcu(bond
, arp
->mac_src
))
761 if (arp
->op_code
== htons(ARPOP_REPLY
)) {
762 /* the arp must be sent on the selected
765 tx_slave
= rlb_choose_channel(skb
, bond
);
767 ether_addr_copy(arp
->mac_src
, tx_slave
->dev
->dev_addr
);
768 pr_debug("Server sent ARP Reply packet\n");
769 } else if (arp
->op_code
== htons(ARPOP_REQUEST
)) {
770 /* Create an entry in the rx_hashtbl for this client as a
772 * When the arp reply is received the entry will be updated
773 * with the correct unicast address of the client.
775 rlb_choose_channel(skb
, bond
);
777 /* The ARP reply packets must be delayed so that
778 * they can cancel out the influence of the ARP request.
780 bond
->alb_info
.rlb_update_delay_counter
= RLB_UPDATE_DELAY
;
782 /* arp requests are broadcast and are sent on the primary
783 * the arp request will collapse all clients on the subnet to
784 * the primary slave. We must register these clients to be
785 * updated with their assigned mac.
787 rlb_req_update_subnet_clients(bond
, arp
->ip_src
);
788 pr_debug("Server sent ARP Request packet\n");
794 /* Caller must hold bond lock for read */
795 static void rlb_rebalance(struct bonding
*bond
)
797 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
798 struct slave
*assigned_slave
;
799 struct rlb_client_info
*client_info
;
803 _lock_rx_hashtbl_bh(bond
);
806 hash_index
= bond_info
->rx_hashtbl_used_head
;
807 for (; hash_index
!= RLB_NULL_INDEX
;
808 hash_index
= client_info
->used_next
) {
809 client_info
= &(bond_info
->rx_hashtbl
[hash_index
]);
810 assigned_slave
= __rlb_next_rx_slave(bond
);
811 if (assigned_slave
&& (client_info
->slave
!= assigned_slave
)) {
812 client_info
->slave
= assigned_slave
;
813 client_info
->ntt
= 1;
818 /* update the team's flag only after the whole iteration */
820 bond_info
->rx_ntt
= 1;
821 _unlock_rx_hashtbl_bh(bond
);
824 /* Caller must hold rx_hashtbl lock */
825 static void rlb_init_table_entry_dst(struct rlb_client_info
*entry
)
827 entry
->used_next
= RLB_NULL_INDEX
;
828 entry
->used_prev
= RLB_NULL_INDEX
;
833 static void rlb_init_table_entry_src(struct rlb_client_info
*entry
)
835 entry
->src_first
= RLB_NULL_INDEX
;
836 entry
->src_prev
= RLB_NULL_INDEX
;
837 entry
->src_next
= RLB_NULL_INDEX
;
840 static void rlb_init_table_entry(struct rlb_client_info
*entry
)
842 memset(entry
, 0, sizeof(struct rlb_client_info
));
843 rlb_init_table_entry_dst(entry
);
844 rlb_init_table_entry_src(entry
);
847 static void rlb_delete_table_entry_dst(struct bonding
*bond
, u32 index
)
849 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
850 u32 next_index
= bond_info
->rx_hashtbl
[index
].used_next
;
851 u32 prev_index
= bond_info
->rx_hashtbl
[index
].used_prev
;
853 if (index
== bond_info
->rx_hashtbl_used_head
)
854 bond_info
->rx_hashtbl_used_head
= next_index
;
855 if (prev_index
!= RLB_NULL_INDEX
)
856 bond_info
->rx_hashtbl
[prev_index
].used_next
= next_index
;
857 if (next_index
!= RLB_NULL_INDEX
)
858 bond_info
->rx_hashtbl
[next_index
].used_prev
= prev_index
;
861 /* unlink a rlb hash table entry from the src list */
862 static void rlb_src_unlink(struct bonding
*bond
, u32 index
)
864 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
865 u32 next_index
= bond_info
->rx_hashtbl
[index
].src_next
;
866 u32 prev_index
= bond_info
->rx_hashtbl
[index
].src_prev
;
868 bond_info
->rx_hashtbl
[index
].src_next
= RLB_NULL_INDEX
;
869 bond_info
->rx_hashtbl
[index
].src_prev
= RLB_NULL_INDEX
;
871 if (next_index
!= RLB_NULL_INDEX
)
872 bond_info
->rx_hashtbl
[next_index
].src_prev
= prev_index
;
874 if (prev_index
== RLB_NULL_INDEX
)
877 /* is prev_index pointing to the head of this list? */
878 if (bond_info
->rx_hashtbl
[prev_index
].src_first
== index
)
879 bond_info
->rx_hashtbl
[prev_index
].src_first
= next_index
;
881 bond_info
->rx_hashtbl
[prev_index
].src_next
= next_index
;
885 static void rlb_delete_table_entry(struct bonding
*bond
, u32 index
)
887 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
888 struct rlb_client_info
*entry
= &(bond_info
->rx_hashtbl
[index
]);
890 rlb_delete_table_entry_dst(bond
, index
);
891 rlb_init_table_entry_dst(entry
);
893 rlb_src_unlink(bond
, index
);
896 /* add the rx_hashtbl[ip_dst_hash] entry to the list
897 * of entries with identical ip_src_hash
899 static void rlb_src_link(struct bonding
*bond
, u32 ip_src_hash
, u32 ip_dst_hash
)
901 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
904 bond_info
->rx_hashtbl
[ip_dst_hash
].src_prev
= ip_src_hash
;
905 next
= bond_info
->rx_hashtbl
[ip_src_hash
].src_first
;
906 bond_info
->rx_hashtbl
[ip_dst_hash
].src_next
= next
;
907 if (next
!= RLB_NULL_INDEX
)
908 bond_info
->rx_hashtbl
[next
].src_prev
= ip_dst_hash
;
909 bond_info
->rx_hashtbl
[ip_src_hash
].src_first
= ip_dst_hash
;
912 /* deletes all rx_hashtbl entries with arp->ip_src if their mac_src does
913 * not match arp->mac_src */
914 static void rlb_purge_src_ip(struct bonding
*bond
, struct arp_pkt
*arp
)
916 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
917 u32 ip_src_hash
= _simple_hash((u8
*)&(arp
->ip_src
), sizeof(arp
->ip_src
));
920 _lock_rx_hashtbl_bh(bond
);
922 index
= bond_info
->rx_hashtbl
[ip_src_hash
].src_first
;
923 while (index
!= RLB_NULL_INDEX
) {
924 struct rlb_client_info
*entry
= &(bond_info
->rx_hashtbl
[index
]);
925 u32 next_index
= entry
->src_next
;
926 if (entry
->ip_src
== arp
->ip_src
&&
927 !ether_addr_equal_64bits(arp
->mac_src
, entry
->mac_src
))
928 rlb_delete_table_entry(bond
, index
);
931 _unlock_rx_hashtbl_bh(bond
);
934 static int rlb_initialize(struct bonding
*bond
)
936 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
937 struct rlb_client_info
*new_hashtbl
;
938 int size
= RLB_HASH_TABLE_SIZE
* sizeof(struct rlb_client_info
);
941 new_hashtbl
= kmalloc(size
, GFP_KERNEL
);
945 _lock_rx_hashtbl_bh(bond
);
947 bond_info
->rx_hashtbl
= new_hashtbl
;
949 bond_info
->rx_hashtbl_used_head
= RLB_NULL_INDEX
;
951 for (i
= 0; i
< RLB_HASH_TABLE_SIZE
; i
++)
952 rlb_init_table_entry(bond_info
->rx_hashtbl
+ i
);
954 _unlock_rx_hashtbl_bh(bond
);
956 /* register to receive ARPs */
957 bond
->recv_probe
= rlb_arp_recv
;
962 static void rlb_deinitialize(struct bonding
*bond
)
964 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
966 _lock_rx_hashtbl_bh(bond
);
968 kfree(bond_info
->rx_hashtbl
);
969 bond_info
->rx_hashtbl
= NULL
;
970 bond_info
->rx_hashtbl_used_head
= RLB_NULL_INDEX
;
972 _unlock_rx_hashtbl_bh(bond
);
975 static void rlb_clear_vlan(struct bonding
*bond
, unsigned short vlan_id
)
977 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
980 _lock_rx_hashtbl_bh(bond
);
982 curr_index
= bond_info
->rx_hashtbl_used_head
;
983 while (curr_index
!= RLB_NULL_INDEX
) {
984 struct rlb_client_info
*curr
= &(bond_info
->rx_hashtbl
[curr_index
]);
985 u32 next_index
= bond_info
->rx_hashtbl
[curr_index
].used_next
;
987 if (curr
->vlan_id
== vlan_id
)
988 rlb_delete_table_entry(bond
, curr_index
);
990 curr_index
= next_index
;
993 _unlock_rx_hashtbl_bh(bond
);
996 /*********************** tlb/rlb shared functions *********************/
998 static void alb_send_lp_vid(struct slave
*slave
, u8 mac_addr
[],
999 __be16 vlan_proto
, u16 vid
)
1001 struct learning_pkt pkt
;
1002 struct sk_buff
*skb
;
1003 int size
= sizeof(struct learning_pkt
);
1006 memset(&pkt
, 0, size
);
1007 ether_addr_copy(pkt
.mac_dst
, mac_addr
);
1008 ether_addr_copy(pkt
.mac_src
, mac_addr
);
1009 pkt
.type
= cpu_to_be16(ETH_P_LOOPBACK
);
1011 skb
= dev_alloc_skb(size
);
1015 data
= skb_put(skb
, size
);
1016 memcpy(data
, &pkt
, size
);
1018 skb_reset_mac_header(skb
);
1019 skb
->network_header
= skb
->mac_header
+ ETH_HLEN
;
1020 skb
->protocol
= pkt
.type
;
1021 skb
->priority
= TC_PRIO_CONTROL
;
1022 skb
->dev
= slave
->dev
;
1025 skb
= vlan_put_tag(skb
, vlan_proto
, vid
);
1027 pr_err("%s: Error: failed to insert VLAN tag\n",
1028 slave
->bond
->dev
->name
);
1033 dev_queue_xmit(skb
);
1036 static void alb_send_learning_packets(struct slave
*slave
, u8 mac_addr
[],
1039 struct bonding
*bond
= bond_get_bond_by_slave(slave
);
1040 struct net_device
*upper
;
1041 struct list_head
*iter
;
1044 alb_send_lp_vid(slave
, mac_addr
, 0, 0);
1046 /* loop through vlans and send one packet for each */
1048 netdev_for_each_all_upper_dev_rcu(bond
->dev
, upper
, iter
) {
1049 if (is_vlan_dev(upper
) && vlan_get_encap_level(upper
) == 0) {
1051 ether_addr_equal_64bits(mac_addr
,
1053 alb_send_lp_vid(slave
, mac_addr
,
1054 vlan_dev_vlan_proto(upper
),
1055 vlan_dev_vlan_id(upper
));
1056 } else if (!strict_match
) {
1057 alb_send_lp_vid(slave
, upper
->dev_addr
,
1058 vlan_dev_vlan_proto(upper
),
1059 vlan_dev_vlan_id(upper
));
1066 static int alb_set_slave_mac_addr(struct slave
*slave
, u8 addr
[])
1068 struct net_device
*dev
= slave
->dev
;
1069 struct sockaddr s_addr
;
1071 if (slave
->bond
->params
.mode
== BOND_MODE_TLB
) {
1072 memcpy(dev
->dev_addr
, addr
, dev
->addr_len
);
1076 /* for rlb each slave must have a unique hw mac addresses so that */
1077 /* each slave will receive packets destined to a different mac */
1078 memcpy(s_addr
.sa_data
, addr
, dev
->addr_len
);
1079 s_addr
.sa_family
= dev
->type
;
1080 if (dev_set_mac_address(dev
, &s_addr
)) {
1081 pr_err("%s: Error: dev_set_mac_address of dev %s failed!\n"
1082 "ALB mode requires that the base driver support setting the hw address also when the network device's interface is open\n",
1083 slave
->bond
->dev
->name
, dev
->name
);
1090 * Swap MAC addresses between two slaves.
1092 * Called with RTNL held, and no other locks.
1096 static void alb_swap_mac_addr(struct slave
*slave1
, struct slave
*slave2
)
1098 u8 tmp_mac_addr
[ETH_ALEN
];
1100 ether_addr_copy(tmp_mac_addr
, slave1
->dev
->dev_addr
);
1101 alb_set_slave_mac_addr(slave1
, slave2
->dev
->dev_addr
);
1102 alb_set_slave_mac_addr(slave2
, tmp_mac_addr
);
1107 * Send learning packets after MAC address swap.
1109 * Called with RTNL and no other locks
1111 static void alb_fasten_mac_swap(struct bonding
*bond
, struct slave
*slave1
,
1112 struct slave
*slave2
)
1114 int slaves_state_differ
= (SLAVE_IS_OK(slave1
) != SLAVE_IS_OK(slave2
));
1115 struct slave
*disabled_slave
= NULL
;
1119 /* fasten the change in the switch */
1120 if (SLAVE_IS_OK(slave1
)) {
1121 alb_send_learning_packets(slave1
, slave1
->dev
->dev_addr
, false);
1122 if (bond
->alb_info
.rlb_enabled
) {
1123 /* inform the clients that the mac address
1126 rlb_req_update_slave_clients(bond
, slave1
);
1129 disabled_slave
= slave1
;
1132 if (SLAVE_IS_OK(slave2
)) {
1133 alb_send_learning_packets(slave2
, slave2
->dev
->dev_addr
, false);
1134 if (bond
->alb_info
.rlb_enabled
) {
1135 /* inform the clients that the mac address
1138 rlb_req_update_slave_clients(bond
, slave2
);
1141 disabled_slave
= slave2
;
1144 if (bond
->alb_info
.rlb_enabled
&& slaves_state_differ
) {
1145 /* A disabled slave was assigned an active mac addr */
1146 rlb_teach_disabled_mac_on_primary(bond
,
1147 disabled_slave
->dev
->dev_addr
);
1152 * alb_change_hw_addr_on_detach
1153 * @bond: bonding we're working on
1154 * @slave: the slave that was just detached
1156 * We assume that @slave was already detached from the slave list.
1158 * If @slave's permanent hw address is different both from its current
1159 * address and from @bond's address, then somewhere in the bond there's
1160 * a slave that has @slave's permanet address as its current address.
1161 * We'll make sure that that slave no longer uses @slave's permanent address.
1163 * Caller must hold RTNL and no other locks
1165 static void alb_change_hw_addr_on_detach(struct bonding
*bond
, struct slave
*slave
)
1169 struct slave
*found_slave
;
1171 perm_curr_diff
= !ether_addr_equal_64bits(slave
->perm_hwaddr
,
1172 slave
->dev
->dev_addr
);
1173 perm_bond_diff
= !ether_addr_equal_64bits(slave
->perm_hwaddr
,
1174 bond
->dev
->dev_addr
);
1176 if (perm_curr_diff
&& perm_bond_diff
) {
1177 found_slave
= bond_slave_has_mac(bond
, slave
->perm_hwaddr
);
1180 /* locking: needs RTNL and nothing else */
1181 alb_swap_mac_addr(slave
, found_slave
);
1182 alb_fasten_mac_swap(bond
, slave
, found_slave
);
1188 * alb_handle_addr_collision_on_attach
1189 * @bond: bonding we're working on
1190 * @slave: the slave that was just attached
1192 * checks uniqueness of slave's mac address and handles the case the
1193 * new slave uses the bonds mac address.
1195 * If the permanent hw address of @slave is @bond's hw address, we need to
1196 * find a different hw address to give @slave, that isn't in use by any other
1197 * slave in the bond. This address must be, of course, one of the permanent
1198 * addresses of the other slaves.
1200 * We go over the slave list, and for each slave there we compare its
1201 * permanent hw address with the current address of all the other slaves.
1202 * If no match was found, then we've found a slave with a permanent address
1203 * that isn't used by any other slave in the bond, so we can assign it to
1206 * assumption: this function is called before @slave is attached to the
1209 static int alb_handle_addr_collision_on_attach(struct bonding
*bond
, struct slave
*slave
)
1211 struct slave
*has_bond_addr
= bond
->curr_active_slave
;
1212 struct slave
*tmp_slave1
, *free_mac_slave
= NULL
;
1213 struct list_head
*iter
;
1215 if (!bond_has_slaves(bond
)) {
1216 /* this is the first slave */
1220 /* if slave's mac address differs from bond's mac address
1221 * check uniqueness of slave's mac address against the other
1222 * slaves in the bond.
1224 if (!ether_addr_equal_64bits(slave
->perm_hwaddr
, bond
->dev
->dev_addr
)) {
1225 if (!bond_slave_has_mac(bond
, slave
->dev
->dev_addr
))
1228 /* Try setting slave mac to bond address and fall-through
1229 to code handling that situation below... */
1230 alb_set_slave_mac_addr(slave
, bond
->dev
->dev_addr
);
1233 /* The slave's address is equal to the address of the bond.
1234 * Search for a spare address in the bond for this slave.
1236 bond_for_each_slave(bond
, tmp_slave1
, iter
) {
1237 if (!bond_slave_has_mac(bond
, tmp_slave1
->perm_hwaddr
)) {
1238 /* no slave has tmp_slave1's perm addr
1241 free_mac_slave
= tmp_slave1
;
1245 if (!has_bond_addr
) {
1246 if (ether_addr_equal_64bits(tmp_slave1
->dev
->dev_addr
,
1247 bond
->dev
->dev_addr
)) {
1249 has_bond_addr
= tmp_slave1
;
1254 if (free_mac_slave
) {
1255 alb_set_slave_mac_addr(slave
, free_mac_slave
->perm_hwaddr
);
1257 pr_warn("%s: Warning: the hw address of slave %s is in use by the bond; giving it the hw address of %s\n",
1258 bond
->dev
->name
, slave
->dev
->name
,
1259 free_mac_slave
->dev
->name
);
1261 } else if (has_bond_addr
) {
1262 pr_err("%s: Error: the hw address of slave %s is in use by the bond; couldn't find a slave with a free hw address to give it (this should not have happened)\n",
1263 bond
->dev
->name
, slave
->dev
->name
);
1271 * alb_set_mac_address
1275 * In TLB mode all slaves are configured to the bond's hw address, but set
1276 * their dev_addr field to different addresses (based on their permanent hw
1279 * For each slave, this function sets the interface to the new address and then
1280 * changes its dev_addr field to its previous value.
1282 * Unwinding assumes bond's mac address has not yet changed.
1284 static int alb_set_mac_address(struct bonding
*bond
, void *addr
)
1286 struct slave
*slave
, *rollback_slave
;
1287 struct list_head
*iter
;
1289 char tmp_addr
[ETH_ALEN
];
1292 if (bond
->alb_info
.rlb_enabled
)
1295 bond_for_each_slave(bond
, slave
, iter
) {
1296 /* save net_device's current hw address */
1297 ether_addr_copy(tmp_addr
, slave
->dev
->dev_addr
);
1299 res
= dev_set_mac_address(slave
->dev
, addr
);
1301 /* restore net_device's hw address */
1302 ether_addr_copy(slave
->dev
->dev_addr
, tmp_addr
);
1311 memcpy(sa
.sa_data
, bond
->dev
->dev_addr
, bond
->dev
->addr_len
);
1312 sa
.sa_family
= bond
->dev
->type
;
1314 /* unwind from head to the slave that failed */
1315 bond_for_each_slave(bond
, rollback_slave
, iter
) {
1316 if (rollback_slave
== slave
)
1318 ether_addr_copy(tmp_addr
, rollback_slave
->dev
->dev_addr
);
1319 dev_set_mac_address(rollback_slave
->dev
, &sa
);
1320 ether_addr_copy(rollback_slave
->dev
->dev_addr
, tmp_addr
);
1326 /************************ exported alb funcions ************************/
1328 int bond_alb_initialize(struct bonding
*bond
, int rlb_enabled
)
1332 res
= tlb_initialize(bond
);
1337 bond
->alb_info
.rlb_enabled
= 1;
1338 /* initialize rlb */
1339 res
= rlb_initialize(bond
);
1341 tlb_deinitialize(bond
);
1345 bond
->alb_info
.rlb_enabled
= 0;
1351 void bond_alb_deinitialize(struct bonding
*bond
)
1353 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
1355 tlb_deinitialize(bond
);
1357 if (bond_info
->rlb_enabled
)
1358 rlb_deinitialize(bond
);
1361 int bond_alb_xmit(struct sk_buff
*skb
, struct net_device
*bond_dev
)
1363 struct bonding
*bond
= netdev_priv(bond_dev
);
1364 struct ethhdr
*eth_data
;
1365 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
1366 struct slave
*tx_slave
= NULL
;
1367 static const __be32 ip_bcast
= htonl(0xffffffff);
1369 int do_tx_balance
= 1;
1371 const u8
*hash_start
= NULL
;
1372 struct ipv6hdr
*ip6hdr
;
1374 skb_reset_mac_header(skb
);
1375 eth_data
= eth_hdr(skb
);
1377 switch (ntohs(skb
->protocol
)) {
1379 const struct iphdr
*iph
= ip_hdr(skb
);
1381 if (ether_addr_equal_64bits(eth_data
->h_dest
, mac_bcast
) ||
1382 (iph
->daddr
== ip_bcast
) ||
1383 (iph
->protocol
== IPPROTO_IGMP
)) {
1387 hash_start
= (char *)&(iph
->daddr
);
1388 hash_size
= sizeof(iph
->daddr
);
1392 /* IPv6 doesn't really use broadcast mac address, but leave
1393 * that here just in case.
1395 if (ether_addr_equal_64bits(eth_data
->h_dest
, mac_bcast
)) {
1400 /* IPv6 uses all-nodes multicast as an equivalent to
1401 * broadcasts in IPv4.
1403 if (ether_addr_equal_64bits(eth_data
->h_dest
, mac_v6_allmcast
)) {
1408 /* Additianally, DAD probes should not be tx-balanced as that
1409 * will lead to false positives for duplicate addresses and
1410 * prevent address configuration from working.
1412 ip6hdr
= ipv6_hdr(skb
);
1413 if (ipv6_addr_any(&ip6hdr
->saddr
)) {
1418 hash_start
= (char *)&(ipv6_hdr(skb
)->daddr
);
1419 hash_size
= sizeof(ipv6_hdr(skb
)->daddr
);
1422 if (ipx_hdr(skb
)->ipx_checksum
!= IPX_NO_CHECKSUM
) {
1423 /* something is wrong with this packet */
1428 if (ipx_hdr(skb
)->ipx_type
!= IPX_TYPE_NCP
) {
1429 /* The only protocol worth balancing in
1430 * this family since it has an "ARP" like
1437 hash_start
= (char *)eth_data
->h_dest
;
1438 hash_size
= ETH_ALEN
;
1442 if (bond_info
->rlb_enabled
)
1443 tx_slave
= rlb_arp_xmit(skb
, bond
);
1450 if (do_tx_balance
) {
1451 hash_index
= _simple_hash(hash_start
, hash_size
);
1452 tx_slave
= tlb_choose_channel(bond
, hash_index
, skb
->len
);
1456 /* unbalanced or unassigned, send through primary */
1457 tx_slave
= rcu_dereference(bond
->curr_active_slave
);
1458 bond_info
->unbalanced_load
+= skb
->len
;
1461 if (tx_slave
&& SLAVE_IS_OK(tx_slave
)) {
1462 if (tx_slave
!= rcu_dereference(bond
->curr_active_slave
)) {
1463 ether_addr_copy(eth_data
->h_source
,
1464 tx_slave
->dev
->dev_addr
);
1467 bond_dev_queue_xmit(bond
, skb
, tx_slave
->dev
);
1472 _lock_tx_hashtbl(bond
);
1473 __tlb_clear_slave(bond
, tx_slave
, 0);
1474 _unlock_tx_hashtbl(bond
);
1477 /* no suitable interface, frame not sent */
1478 dev_kfree_skb_any(skb
);
1480 return NETDEV_TX_OK
;
1483 void bond_alb_monitor(struct work_struct
*work
)
1485 struct bonding
*bond
= container_of(work
, struct bonding
,
1487 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
1488 struct list_head
*iter
;
1489 struct slave
*slave
;
1491 if (!bond_has_slaves(bond
)) {
1492 bond_info
->tx_rebalance_counter
= 0;
1493 bond_info
->lp_counter
= 0;
1499 bond_info
->tx_rebalance_counter
++;
1500 bond_info
->lp_counter
++;
1502 /* send learning packets */
1503 if (bond_info
->lp_counter
>= BOND_ALB_LP_TICKS(bond
)) {
1506 /* change of curr_active_slave involves swapping of mac addresses.
1507 * in order to avoid this swapping from happening while
1508 * sending the learning packets, the curr_slave_lock must be held for
1511 read_lock(&bond
->curr_slave_lock
);
1513 bond_for_each_slave_rcu(bond
, slave
, iter
) {
1514 /* If updating current_active, use all currently
1515 * user mac addreses (!strict_match). Otherwise, only
1516 * use mac of the slave device.
1518 strict_match
= (slave
!= bond
->curr_active_slave
);
1519 alb_send_learning_packets(slave
, slave
->dev
->dev_addr
,
1523 read_unlock(&bond
->curr_slave_lock
);
1525 bond_info
->lp_counter
= 0;
1528 /* rebalance tx traffic */
1529 if (bond_info
->tx_rebalance_counter
>= BOND_TLB_REBALANCE_TICKS
) {
1531 read_lock(&bond
->curr_slave_lock
);
1533 bond_for_each_slave_rcu(bond
, slave
, iter
) {
1534 tlb_clear_slave(bond
, slave
, 1);
1535 if (slave
== bond
->curr_active_slave
) {
1536 SLAVE_TLB_INFO(slave
).load
=
1537 bond_info
->unbalanced_load
/
1538 BOND_TLB_REBALANCE_INTERVAL
;
1539 bond_info
->unbalanced_load
= 0;
1543 read_unlock(&bond
->curr_slave_lock
);
1545 bond_info
->tx_rebalance_counter
= 0;
1548 /* handle rlb stuff */
1549 if (bond_info
->rlb_enabled
) {
1550 if (bond_info
->primary_is_promisc
&&
1551 (++bond_info
->rlb_promisc_timeout_counter
>= RLB_PROMISC_TIMEOUT
)) {
1554 * dev_set_promiscuity requires rtnl and
1555 * nothing else. Avoid race with bond_close.
1558 if (!rtnl_trylock())
1561 bond_info
->rlb_promisc_timeout_counter
= 0;
1563 /* If the primary was set to promiscuous mode
1564 * because a slave was disabled then
1565 * it can now leave promiscuous mode.
1567 dev_set_promiscuity(bond
->curr_active_slave
->dev
, -1);
1568 bond_info
->primary_is_promisc
= 0;
1574 if (bond_info
->rlb_rebalance
) {
1575 bond_info
->rlb_rebalance
= 0;
1576 rlb_rebalance(bond
);
1579 /* check if clients need updating */
1580 if (bond_info
->rx_ntt
) {
1581 if (bond_info
->rlb_update_delay_counter
) {
1582 --bond_info
->rlb_update_delay_counter
;
1584 rlb_update_rx_clients(bond
);
1585 if (bond_info
->rlb_update_retry_counter
)
1586 --bond_info
->rlb_update_retry_counter
;
1588 bond_info
->rx_ntt
= 0;
1594 queue_delayed_work(bond
->wq
, &bond
->alb_work
, alb_delta_in_ticks
);
1597 /* assumption: called before the slave is attached to the bond
1598 * and not locked by the bond lock
1600 int bond_alb_init_slave(struct bonding
*bond
, struct slave
*slave
)
1604 res
= alb_set_slave_mac_addr(slave
, slave
->perm_hwaddr
);
1608 res
= alb_handle_addr_collision_on_attach(bond
, slave
);
1612 tlb_init_slave(slave
);
1614 /* order a rebalance ASAP */
1615 bond
->alb_info
.tx_rebalance_counter
= BOND_TLB_REBALANCE_TICKS
;
1617 if (bond
->alb_info
.rlb_enabled
)
1618 bond
->alb_info
.rlb_rebalance
= 1;
1624 * Remove slave from tlb and rlb hash tables, and fix up MAC addresses
1627 * Caller must hold RTNL and no other locks
1629 void bond_alb_deinit_slave(struct bonding
*bond
, struct slave
*slave
)
1631 if (bond_has_slaves(bond
))
1632 alb_change_hw_addr_on_detach(bond
, slave
);
1634 tlb_clear_slave(bond
, slave
, 0);
1636 if (bond
->alb_info
.rlb_enabled
) {
1637 bond
->alb_info
.rx_slave
= NULL
;
1638 rlb_clear_slave(bond
, slave
);
1642 /* Caller must hold bond lock for read */
1643 void bond_alb_handle_link_change(struct bonding
*bond
, struct slave
*slave
, char link
)
1645 struct alb_bond_info
*bond_info
= &(BOND_ALB_INFO(bond
));
1647 if (link
== BOND_LINK_DOWN
) {
1648 tlb_clear_slave(bond
, slave
, 0);
1649 if (bond
->alb_info
.rlb_enabled
)
1650 rlb_clear_slave(bond
, slave
);
1651 } else if (link
== BOND_LINK_UP
) {
1652 /* order a rebalance ASAP */
1653 bond_info
->tx_rebalance_counter
= BOND_TLB_REBALANCE_TICKS
;
1654 if (bond
->alb_info
.rlb_enabled
) {
1655 bond
->alb_info
.rlb_rebalance
= 1;
1656 /* If the updelay module parameter is smaller than the
1657 * forwarding delay of the switch the rebalance will
1658 * not work because the rebalance arp replies will
1659 * not be forwarded to the clients..
1666 * bond_alb_handle_active_change - assign new curr_active_slave
1667 * @bond: our bonding struct
1668 * @new_slave: new slave to assign
1670 * Set the bond->curr_active_slave to @new_slave and handle
1671 * mac address swapping and promiscuity changes as needed.
1673 * If new_slave is NULL, caller must hold curr_slave_lock or
1674 * bond->lock for write.
1676 * If new_slave is not NULL, caller must hold RTNL, curr_slave_lock
1677 * for write. Processing here may sleep, so no other locks may be held.
1679 void bond_alb_handle_active_change(struct bonding
*bond
, struct slave
*new_slave
)
1680 __releases(&bond
->curr_slave_lock
)
1681 __acquires(&bond
->curr_slave_lock
)
1683 struct slave
*swap_slave
;
1685 if (bond
->curr_active_slave
== new_slave
)
1688 if (bond
->curr_active_slave
&& bond
->alb_info
.primary_is_promisc
) {
1689 dev_set_promiscuity(bond
->curr_active_slave
->dev
, -1);
1690 bond
->alb_info
.primary_is_promisc
= 0;
1691 bond
->alb_info
.rlb_promisc_timeout_counter
= 0;
1694 swap_slave
= bond
->curr_active_slave
;
1695 rcu_assign_pointer(bond
->curr_active_slave
, new_slave
);
1697 if (!new_slave
|| !bond_has_slaves(bond
))
1700 /* set the new curr_active_slave to the bonds mac address
1701 * i.e. swap mac addresses of old curr_active_slave and new curr_active_slave
1704 swap_slave
= bond_slave_has_mac(bond
, bond
->dev
->dev_addr
);
1707 * Arrange for swap_slave and new_slave to temporarily be
1708 * ignored so we can mess with their MAC addresses without
1709 * fear of interference from transmit activity.
1712 tlb_clear_slave(bond
, swap_slave
, 1);
1713 tlb_clear_slave(bond
, new_slave
, 1);
1715 write_unlock_bh(&bond
->curr_slave_lock
);
1719 /* in TLB mode, the slave might flip down/up with the old dev_addr,
1720 * and thus filter bond->dev_addr's packets, so force bond's mac
1722 if (bond
->params
.mode
== BOND_MODE_TLB
) {
1724 u8 tmp_addr
[ETH_ALEN
];
1726 ether_addr_copy(tmp_addr
, new_slave
->dev
->dev_addr
);
1728 memcpy(sa
.sa_data
, bond
->dev
->dev_addr
, bond
->dev
->addr_len
);
1729 sa
.sa_family
= bond
->dev
->type
;
1730 /* we don't care if it can't change its mac, best effort */
1731 dev_set_mac_address(new_slave
->dev
, &sa
);
1733 ether_addr_copy(new_slave
->dev
->dev_addr
, tmp_addr
);
1736 /* curr_active_slave must be set before calling alb_swap_mac_addr */
1738 /* swap mac address */
1739 alb_swap_mac_addr(swap_slave
, new_slave
);
1740 alb_fasten_mac_swap(bond
, swap_slave
, new_slave
);
1742 /* set the new_slave to the bond mac address */
1743 alb_set_slave_mac_addr(new_slave
, bond
->dev
->dev_addr
);
1744 alb_send_learning_packets(new_slave
, bond
->dev
->dev_addr
,
1748 write_lock_bh(&bond
->curr_slave_lock
);
1754 int bond_alb_set_mac_address(struct net_device
*bond_dev
, void *addr
)
1755 __acquires(&bond
->lock
)
1756 __releases(&bond
->lock
)
1758 struct bonding
*bond
= netdev_priv(bond_dev
);
1759 struct sockaddr
*sa
= addr
;
1760 struct slave
*swap_slave
;
1763 if (!is_valid_ether_addr(sa
->sa_data
))
1764 return -EADDRNOTAVAIL
;
1766 res
= alb_set_mac_address(bond
, addr
);
1770 memcpy(bond_dev
->dev_addr
, sa
->sa_data
, bond_dev
->addr_len
);
1772 /* If there is no curr_active_slave there is nothing else to do.
1773 * Otherwise we'll need to pass the new address to it and handle
1776 if (!bond
->curr_active_slave
)
1779 swap_slave
= bond_slave_has_mac(bond
, bond_dev
->dev_addr
);
1782 alb_swap_mac_addr(swap_slave
, bond
->curr_active_slave
);
1783 alb_fasten_mac_swap(bond
, swap_slave
, bond
->curr_active_slave
);
1785 alb_set_slave_mac_addr(bond
->curr_active_slave
, bond_dev
->dev_addr
);
1787 read_lock(&bond
->lock
);
1788 alb_send_learning_packets(bond
->curr_active_slave
,
1789 bond_dev
->dev_addr
, false);
1790 if (bond
->alb_info
.rlb_enabled
) {
1791 /* inform clients mac address has changed */
1792 rlb_req_update_slave_clients(bond
, bond
->curr_active_slave
);
1794 read_unlock(&bond
->lock
);
1800 void bond_alb_clear_vlan(struct bonding
*bond
, unsigned short vlan_id
)
1802 if (bond
->alb_info
.rlb_enabled
)
1803 rlb_clear_vlan(bond
, vlan_id
);