xref: /linux/drivers/net/bonding/bond_alb.c (revision f9bff0e31881d03badf191d3b0005839391f5f2b)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
4  */
5 
6 #include <linux/skbuff.h>
7 #include <linux/netdevice.h>
8 #include <linux/etherdevice.h>
9 #include <linux/pkt_sched.h>
10 #include <linux/spinlock.h>
11 #include <linux/slab.h>
12 #include <linux/timer.h>
13 #include <linux/ip.h>
14 #include <linux/ipv6.h>
15 #include <linux/if_arp.h>
16 #include <linux/if_ether.h>
17 #include <linux/if_bonding.h>
18 #include <linux/if_vlan.h>
19 #include <linux/in.h>
20 #include <net/arp.h>
21 #include <net/ipv6.h>
22 #include <net/ndisc.h>
23 #include <asm/byteorder.h>
24 #include <net/bonding.h>
25 #include <net/bond_alb.h>
26 
27 static const u8 mac_v6_allmcast[ETH_ALEN + 2] __long_aligned = {
28 	0x33, 0x33, 0x00, 0x00, 0x00, 0x01
29 };
30 static const int alb_delta_in_ticks = HZ / ALB_TIMER_TICKS_PER_SEC;
31 
32 #pragma pack(1)
33 struct learning_pkt {
34 	u8 mac_dst[ETH_ALEN];
35 	u8 mac_src[ETH_ALEN];
36 	__be16 type;
37 	u8 padding[ETH_ZLEN - ETH_HLEN];
38 };
39 
40 struct arp_pkt {
41 	__be16  hw_addr_space;
42 	__be16  prot_addr_space;
43 	u8      hw_addr_len;
44 	u8      prot_addr_len;
45 	__be16  op_code;
46 	u8      mac_src[ETH_ALEN];	/* sender hardware address */
47 	__be32  ip_src;			/* sender IP address */
48 	u8      mac_dst[ETH_ALEN];	/* target hardware address */
49 	__be32  ip_dst;			/* target IP address */
50 };
51 #pragma pack()
52 
53 /* Forward declaration */
54 static void alb_send_learning_packets(struct slave *slave, const u8 mac_addr[],
55 				      bool strict_match);
56 static void rlb_purge_src_ip(struct bonding *bond, struct arp_pkt *arp);
57 static void rlb_src_unlink(struct bonding *bond, u32 index);
58 static void rlb_src_link(struct bonding *bond, u32 ip_src_hash,
59 			 u32 ip_dst_hash);
60 
61 static inline u8 _simple_hash(const u8 *hash_start, int hash_size)
62 {
63 	int i;
64 	u8 hash = 0;
65 
66 	for (i = 0; i < hash_size; i++)
67 		hash ^= hash_start[i];
68 
69 	return hash;
70 }
71 
72 /*********************** tlb specific functions ***************************/
73 
74 static inline void tlb_init_table_entry(struct tlb_client_info *entry, int save_load)
75 {
76 	if (save_load) {
77 		entry->load_history = 1 + entry->tx_bytes /
78 				      BOND_TLB_REBALANCE_INTERVAL;
79 		entry->tx_bytes = 0;
80 	}
81 
82 	entry->tx_slave = NULL;
83 	entry->next = TLB_NULL_INDEX;
84 	entry->prev = TLB_NULL_INDEX;
85 }
86 
87 static inline void tlb_init_slave(struct slave *slave)
88 {
89 	SLAVE_TLB_INFO(slave).load = 0;
90 	SLAVE_TLB_INFO(slave).head = TLB_NULL_INDEX;
91 }
92 
93 static void __tlb_clear_slave(struct bonding *bond, struct slave *slave,
94 			 int save_load)
95 {
96 	struct tlb_client_info *tx_hash_table;
97 	u32 index;
98 
99 	/* clear slave from tx_hashtbl */
100 	tx_hash_table = BOND_ALB_INFO(bond).tx_hashtbl;
101 
102 	/* skip this if we've already freed the tx hash table */
103 	if (tx_hash_table) {
104 		index = SLAVE_TLB_INFO(slave).head;
105 		while (index != TLB_NULL_INDEX) {
106 			u32 next_index = tx_hash_table[index].next;
107 
108 			tlb_init_table_entry(&tx_hash_table[index], save_load);
109 			index = next_index;
110 		}
111 	}
112 
113 	tlb_init_slave(slave);
114 }
115 
116 static void tlb_clear_slave(struct bonding *bond, struct slave *slave,
117 			 int save_load)
118 {
119 	spin_lock_bh(&bond->mode_lock);
120 	__tlb_clear_slave(bond, slave, save_load);
121 	spin_unlock_bh(&bond->mode_lock);
122 }
123 
124 /* Must be called before starting the monitor timer */
125 static int tlb_initialize(struct bonding *bond)
126 {
127 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
128 	int size = TLB_HASH_TABLE_SIZE * sizeof(struct tlb_client_info);
129 	struct tlb_client_info *new_hashtbl;
130 	int i;
131 
132 	new_hashtbl = kzalloc(size, GFP_KERNEL);
133 	if (!new_hashtbl)
134 		return -ENOMEM;
135 
136 	spin_lock_bh(&bond->mode_lock);
137 
138 	bond_info->tx_hashtbl = new_hashtbl;
139 
140 	for (i = 0; i < TLB_HASH_TABLE_SIZE; i++)
141 		tlb_init_table_entry(&bond_info->tx_hashtbl[i], 0);
142 
143 	spin_unlock_bh(&bond->mode_lock);
144 
145 	return 0;
146 }
147 
148 /* Must be called only after all slaves have been released */
149 static void tlb_deinitialize(struct bonding *bond)
150 {
151 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
152 
153 	spin_lock_bh(&bond->mode_lock);
154 
155 	kfree(bond_info->tx_hashtbl);
156 	bond_info->tx_hashtbl = NULL;
157 
158 	spin_unlock_bh(&bond->mode_lock);
159 }
160 
161 static long long compute_gap(struct slave *slave)
162 {
163 	return (s64) (slave->speed << 20) - /* Convert to Megabit per sec */
164 	       (s64) (SLAVE_TLB_INFO(slave).load << 3); /* Bytes to bits */
165 }
166 
167 static struct slave *tlb_get_least_loaded_slave(struct bonding *bond)
168 {
169 	struct slave *slave, *least_loaded;
170 	struct list_head *iter;
171 	long long max_gap;
172 
173 	least_loaded = NULL;
174 	max_gap = LLONG_MIN;
175 
176 	/* Find the slave with the largest gap */
177 	bond_for_each_slave_rcu(bond, slave, iter) {
178 		if (bond_slave_can_tx(slave)) {
179 			long long gap = compute_gap(slave);
180 
181 			if (max_gap < gap) {
182 				least_loaded = slave;
183 				max_gap = gap;
184 			}
185 		}
186 	}
187 
188 	return least_loaded;
189 }
190 
191 static struct slave *__tlb_choose_channel(struct bonding *bond, u32 hash_index,
192 						u32 skb_len)
193 {
194 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
195 	struct tlb_client_info *hash_table;
196 	struct slave *assigned_slave;
197 
198 	hash_table = bond_info->tx_hashtbl;
199 	assigned_slave = hash_table[hash_index].tx_slave;
200 	if (!assigned_slave) {
201 		assigned_slave = tlb_get_least_loaded_slave(bond);
202 
203 		if (assigned_slave) {
204 			struct tlb_slave_info *slave_info =
205 				&(SLAVE_TLB_INFO(assigned_slave));
206 			u32 next_index = slave_info->head;
207 
208 			hash_table[hash_index].tx_slave = assigned_slave;
209 			hash_table[hash_index].next = next_index;
210 			hash_table[hash_index].prev = TLB_NULL_INDEX;
211 
212 			if (next_index != TLB_NULL_INDEX)
213 				hash_table[next_index].prev = hash_index;
214 
215 			slave_info->head = hash_index;
216 			slave_info->load +=
217 				hash_table[hash_index].load_history;
218 		}
219 	}
220 
221 	if (assigned_slave)
222 		hash_table[hash_index].tx_bytes += skb_len;
223 
224 	return assigned_slave;
225 }
226 
227 static struct slave *tlb_choose_channel(struct bonding *bond, u32 hash_index,
228 					u32 skb_len)
229 {
230 	struct slave *tx_slave;
231 
232 	/* We don't need to disable softirq here, because
233 	 * tlb_choose_channel() is only called by bond_alb_xmit()
234 	 * which already has softirq disabled.
235 	 */
236 	spin_lock(&bond->mode_lock);
237 	tx_slave = __tlb_choose_channel(bond, hash_index, skb_len);
238 	spin_unlock(&bond->mode_lock);
239 
240 	return tx_slave;
241 }
242 
243 /*********************** rlb specific functions ***************************/
244 
245 /* when an ARP REPLY is received from a client update its info
246  * in the rx_hashtbl
247  */
248 static void rlb_update_entry_from_arp(struct bonding *bond, struct arp_pkt *arp)
249 {
250 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
251 	struct rlb_client_info *client_info;
252 	u32 hash_index;
253 
254 	spin_lock_bh(&bond->mode_lock);
255 
256 	hash_index = _simple_hash((u8 *)&(arp->ip_src), sizeof(arp->ip_src));
257 	client_info = &(bond_info->rx_hashtbl[hash_index]);
258 
259 	if ((client_info->assigned) &&
260 	    (client_info->ip_src == arp->ip_dst) &&
261 	    (client_info->ip_dst == arp->ip_src) &&
262 	    (!ether_addr_equal_64bits(client_info->mac_dst, arp->mac_src))) {
263 		/* update the clients MAC address */
264 		ether_addr_copy(client_info->mac_dst, arp->mac_src);
265 		client_info->ntt = 1;
266 		bond_info->rx_ntt = 1;
267 	}
268 
269 	spin_unlock_bh(&bond->mode_lock);
270 }
271 
272 static int rlb_arp_recv(const struct sk_buff *skb, struct bonding *bond,
273 			struct slave *slave)
274 {
275 	struct arp_pkt *arp, _arp;
276 
277 	if (skb->protocol != cpu_to_be16(ETH_P_ARP))
278 		goto out;
279 
280 	arp = skb_header_pointer(skb, 0, sizeof(_arp), &_arp);
281 	if (!arp)
282 		goto out;
283 
284 	/* We received an ARP from arp->ip_src.
285 	 * We might have used this IP address previously (on the bonding host
286 	 * itself or on a system that is bridged together with the bond).
287 	 * However, if arp->mac_src is different than what is stored in
288 	 * rx_hashtbl, some other host is now using the IP and we must prevent
289 	 * sending out client updates with this IP address and the old MAC
290 	 * address.
291 	 * Clean up all hash table entries that have this address as ip_src but
292 	 * have a different mac_src.
293 	 */
294 	rlb_purge_src_ip(bond, arp);
295 
296 	if (arp->op_code == htons(ARPOP_REPLY)) {
297 		/* update rx hash table for this ARP */
298 		rlb_update_entry_from_arp(bond, arp);
299 		slave_dbg(bond->dev, slave->dev, "Server received an ARP Reply from client\n");
300 	}
301 out:
302 	return RX_HANDLER_ANOTHER;
303 }
304 
305 /* Caller must hold rcu_read_lock() */
306 static struct slave *__rlb_next_rx_slave(struct bonding *bond)
307 {
308 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
309 	struct slave *before = NULL, *rx_slave = NULL, *slave;
310 	struct list_head *iter;
311 	bool found = false;
312 
313 	bond_for_each_slave_rcu(bond, slave, iter) {
314 		if (!bond_slave_can_tx(slave))
315 			continue;
316 		if (!found) {
317 			if (!before || before->speed < slave->speed)
318 				before = slave;
319 		} else {
320 			if (!rx_slave || rx_slave->speed < slave->speed)
321 				rx_slave = slave;
322 		}
323 		if (slave == bond_info->rx_slave)
324 			found = true;
325 	}
326 	/* we didn't find anything after the current or we have something
327 	 * better before and up to the current slave
328 	 */
329 	if (!rx_slave || (before && rx_slave->speed < before->speed))
330 		rx_slave = before;
331 
332 	if (rx_slave)
333 		bond_info->rx_slave = rx_slave;
334 
335 	return rx_slave;
336 }
337 
338 /* Caller must hold RTNL, rcu_read_lock is obtained only to silence checkers */
339 static struct slave *rlb_next_rx_slave(struct bonding *bond)
340 {
341 	struct slave *rx_slave;
342 
343 	ASSERT_RTNL();
344 
345 	rcu_read_lock();
346 	rx_slave = __rlb_next_rx_slave(bond);
347 	rcu_read_unlock();
348 
349 	return rx_slave;
350 }
351 
352 /* teach the switch the mac of a disabled slave
353  * on the primary for fault tolerance
354  *
355  * Caller must hold RTNL
356  */
357 static void rlb_teach_disabled_mac_on_primary(struct bonding *bond,
358 					      const u8 addr[])
359 {
360 	struct slave *curr_active = rtnl_dereference(bond->curr_active_slave);
361 
362 	if (!curr_active)
363 		return;
364 
365 	if (!bond->alb_info.primary_is_promisc) {
366 		if (!dev_set_promiscuity(curr_active->dev, 1))
367 			bond->alb_info.primary_is_promisc = 1;
368 		else
369 			bond->alb_info.primary_is_promisc = 0;
370 	}
371 
372 	bond->alb_info.rlb_promisc_timeout_counter = 0;
373 
374 	alb_send_learning_packets(curr_active, addr, true);
375 }
376 
377 /* slave being removed should not be active at this point
378  *
379  * Caller must hold rtnl.
380  */
381 static void rlb_clear_slave(struct bonding *bond, struct slave *slave)
382 {
383 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
384 	struct rlb_client_info *rx_hash_table;
385 	u32 index, next_index;
386 
387 	/* clear slave from rx_hashtbl */
388 	spin_lock_bh(&bond->mode_lock);
389 
390 	rx_hash_table = bond_info->rx_hashtbl;
391 	index = bond_info->rx_hashtbl_used_head;
392 	for (; index != RLB_NULL_INDEX; index = next_index) {
393 		next_index = rx_hash_table[index].used_next;
394 		if (rx_hash_table[index].slave == slave) {
395 			struct slave *assigned_slave = rlb_next_rx_slave(bond);
396 
397 			if (assigned_slave) {
398 				rx_hash_table[index].slave = assigned_slave;
399 				if (is_valid_ether_addr(rx_hash_table[index].mac_dst)) {
400 					bond_info->rx_hashtbl[index].ntt = 1;
401 					bond_info->rx_ntt = 1;
402 					/* A slave has been removed from the
403 					 * table because it is either disabled
404 					 * or being released. We must retry the
405 					 * update to avoid clients from not
406 					 * being updated & disconnecting when
407 					 * there is stress
408 					 */
409 					bond_info->rlb_update_retry_counter =
410 						RLB_UPDATE_RETRY;
411 				}
412 			} else {  /* there is no active slave */
413 				rx_hash_table[index].slave = NULL;
414 			}
415 		}
416 	}
417 
418 	spin_unlock_bh(&bond->mode_lock);
419 
420 	if (slave != rtnl_dereference(bond->curr_active_slave))
421 		rlb_teach_disabled_mac_on_primary(bond, slave->dev->dev_addr);
422 }
423 
424 static void rlb_update_client(struct rlb_client_info *client_info)
425 {
426 	int i;
427 
428 	if (!client_info->slave || !is_valid_ether_addr(client_info->mac_dst))
429 		return;
430 
431 	for (i = 0; i < RLB_ARP_BURST_SIZE; i++) {
432 		struct sk_buff *skb;
433 
434 		skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
435 				 client_info->ip_dst,
436 				 client_info->slave->dev,
437 				 client_info->ip_src,
438 				 client_info->mac_dst,
439 				 client_info->slave->dev->dev_addr,
440 				 client_info->mac_dst);
441 		if (!skb) {
442 			slave_err(client_info->slave->bond->dev,
443 				  client_info->slave->dev,
444 				  "failed to create an ARP packet\n");
445 			continue;
446 		}
447 
448 		skb->dev = client_info->slave->dev;
449 
450 		if (client_info->vlan_id) {
451 			__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
452 					       client_info->vlan_id);
453 		}
454 
455 		arp_xmit(skb);
456 	}
457 }
458 
459 /* sends ARP REPLIES that update the clients that need updating */
460 static void rlb_update_rx_clients(struct bonding *bond)
461 {
462 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
463 	struct rlb_client_info *client_info;
464 	u32 hash_index;
465 
466 	spin_lock_bh(&bond->mode_lock);
467 
468 	hash_index = bond_info->rx_hashtbl_used_head;
469 	for (; hash_index != RLB_NULL_INDEX;
470 	     hash_index = client_info->used_next) {
471 		client_info = &(bond_info->rx_hashtbl[hash_index]);
472 		if (client_info->ntt) {
473 			rlb_update_client(client_info);
474 			if (bond_info->rlb_update_retry_counter == 0)
475 				client_info->ntt = 0;
476 		}
477 	}
478 
479 	/* do not update the entries again until this counter is zero so that
480 	 * not to confuse the clients.
481 	 */
482 	bond_info->rlb_update_delay_counter = RLB_UPDATE_DELAY;
483 
484 	spin_unlock_bh(&bond->mode_lock);
485 }
486 
487 /* The slave was assigned a new mac address - update the clients */
488 static void rlb_req_update_slave_clients(struct bonding *bond, struct slave *slave)
489 {
490 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
491 	struct rlb_client_info *client_info;
492 	int ntt = 0;
493 	u32 hash_index;
494 
495 	spin_lock_bh(&bond->mode_lock);
496 
497 	hash_index = bond_info->rx_hashtbl_used_head;
498 	for (; hash_index != RLB_NULL_INDEX;
499 	     hash_index = client_info->used_next) {
500 		client_info = &(bond_info->rx_hashtbl[hash_index]);
501 
502 		if ((client_info->slave == slave) &&
503 		    is_valid_ether_addr(client_info->mac_dst)) {
504 			client_info->ntt = 1;
505 			ntt = 1;
506 		}
507 	}
508 
509 	/* update the team's flag only after the whole iteration */
510 	if (ntt) {
511 		bond_info->rx_ntt = 1;
512 		/* fasten the change */
513 		bond_info->rlb_update_retry_counter = RLB_UPDATE_RETRY;
514 	}
515 
516 	spin_unlock_bh(&bond->mode_lock);
517 }
518 
519 /* mark all clients using src_ip to be updated */
520 static void rlb_req_update_subnet_clients(struct bonding *bond, __be32 src_ip)
521 {
522 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
523 	struct rlb_client_info *client_info;
524 	u32 hash_index;
525 
526 	spin_lock(&bond->mode_lock);
527 
528 	hash_index = bond_info->rx_hashtbl_used_head;
529 	for (; hash_index != RLB_NULL_INDEX;
530 	     hash_index = client_info->used_next) {
531 		client_info = &(bond_info->rx_hashtbl[hash_index]);
532 
533 		if (!client_info->slave) {
534 			netdev_err(bond->dev, "found a client with no channel in the client's hash table\n");
535 			continue;
536 		}
537 		/* update all clients using this src_ip, that are not assigned
538 		 * to the team's address (curr_active_slave) and have a known
539 		 * unicast mac address.
540 		 */
541 		if ((client_info->ip_src == src_ip) &&
542 		    !ether_addr_equal_64bits(client_info->slave->dev->dev_addr,
543 					     bond->dev->dev_addr) &&
544 		    is_valid_ether_addr(client_info->mac_dst)) {
545 			client_info->ntt = 1;
546 			bond_info->rx_ntt = 1;
547 		}
548 	}
549 
550 	spin_unlock(&bond->mode_lock);
551 }
552 
553 static struct slave *rlb_choose_channel(struct sk_buff *skb,
554 					struct bonding *bond,
555 					const struct arp_pkt *arp)
556 {
557 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
558 	struct slave *assigned_slave, *curr_active_slave;
559 	struct rlb_client_info *client_info;
560 	u32 hash_index = 0;
561 
562 	spin_lock(&bond->mode_lock);
563 
564 	curr_active_slave = rcu_dereference(bond->curr_active_slave);
565 
566 	hash_index = _simple_hash((u8 *)&arp->ip_dst, sizeof(arp->ip_dst));
567 	client_info = &(bond_info->rx_hashtbl[hash_index]);
568 
569 	if (client_info->assigned) {
570 		if ((client_info->ip_src == arp->ip_src) &&
571 		    (client_info->ip_dst == arp->ip_dst)) {
572 			/* the entry is already assigned to this client */
573 			if (!is_broadcast_ether_addr(arp->mac_dst)) {
574 				/* update mac address from arp */
575 				ether_addr_copy(client_info->mac_dst, arp->mac_dst);
576 			}
577 			ether_addr_copy(client_info->mac_src, arp->mac_src);
578 
579 			assigned_slave = client_info->slave;
580 			if (assigned_slave) {
581 				spin_unlock(&bond->mode_lock);
582 				return assigned_slave;
583 			}
584 		} else {
585 			/* the entry is already assigned to some other client,
586 			 * move the old client to primary (curr_active_slave) so
587 			 * that the new client can be assigned to this entry.
588 			 */
589 			if (curr_active_slave &&
590 			    client_info->slave != curr_active_slave) {
591 				client_info->slave = curr_active_slave;
592 				rlb_update_client(client_info);
593 			}
594 		}
595 	}
596 	/* assign a new slave */
597 	assigned_slave = __rlb_next_rx_slave(bond);
598 
599 	if (assigned_slave) {
600 		if (!(client_info->assigned &&
601 		      client_info->ip_src == arp->ip_src)) {
602 			/* ip_src is going to be updated,
603 			 * fix the src hash list
604 			 */
605 			u32 hash_src = _simple_hash((u8 *)&arp->ip_src,
606 						    sizeof(arp->ip_src));
607 			rlb_src_unlink(bond, hash_index);
608 			rlb_src_link(bond, hash_src, hash_index);
609 		}
610 
611 		client_info->ip_src = arp->ip_src;
612 		client_info->ip_dst = arp->ip_dst;
613 		/* arp->mac_dst is broadcast for arp requests.
614 		 * will be updated with clients actual unicast mac address
615 		 * upon receiving an arp reply.
616 		 */
617 		ether_addr_copy(client_info->mac_dst, arp->mac_dst);
618 		ether_addr_copy(client_info->mac_src, arp->mac_src);
619 		client_info->slave = assigned_slave;
620 
621 		if (is_valid_ether_addr(client_info->mac_dst)) {
622 			client_info->ntt = 1;
623 			bond->alb_info.rx_ntt = 1;
624 		} else {
625 			client_info->ntt = 0;
626 		}
627 
628 		if (vlan_get_tag(skb, &client_info->vlan_id))
629 			client_info->vlan_id = 0;
630 
631 		if (!client_info->assigned) {
632 			u32 prev_tbl_head = bond_info->rx_hashtbl_used_head;
633 
634 			bond_info->rx_hashtbl_used_head = hash_index;
635 			client_info->used_next = prev_tbl_head;
636 			if (prev_tbl_head != RLB_NULL_INDEX) {
637 				bond_info->rx_hashtbl[prev_tbl_head].used_prev =
638 					hash_index;
639 			}
640 			client_info->assigned = 1;
641 		}
642 	}
643 
644 	spin_unlock(&bond->mode_lock);
645 
646 	return assigned_slave;
647 }
648 
649 /* chooses (and returns) transmit channel for arp reply
650  * does not choose channel for other arp types since they are
651  * sent on the curr_active_slave
652  */
653 static struct slave *rlb_arp_xmit(struct sk_buff *skb, struct bonding *bond)
654 {
655 	struct slave *tx_slave = NULL;
656 	struct net_device *dev;
657 	struct arp_pkt *arp;
658 
659 	if (!pskb_network_may_pull(skb, sizeof(*arp)))
660 		return NULL;
661 	arp = (struct arp_pkt *)skb_network_header(skb);
662 
663 	/* Don't modify or load balance ARPs that do not originate locally
664 	 * (e.g.,arrive via a bridge).
665 	 */
666 	if (!bond_slave_has_mac_rx(bond, arp->mac_src))
667 		return NULL;
668 
669 	dev = ip_dev_find(dev_net(bond->dev), arp->ip_src);
670 	if (dev) {
671 		if (netif_is_bridge_master(dev)) {
672 			dev_put(dev);
673 			return NULL;
674 		}
675 		dev_put(dev);
676 	}
677 
678 	if (arp->op_code == htons(ARPOP_REPLY)) {
679 		/* the arp must be sent on the selected rx channel */
680 		tx_slave = rlb_choose_channel(skb, bond, arp);
681 		if (tx_slave)
682 			bond_hw_addr_copy(arp->mac_src, tx_slave->dev->dev_addr,
683 					  tx_slave->dev->addr_len);
684 		netdev_dbg(bond->dev, "(slave %s): Server sent ARP Reply packet\n",
685 			   tx_slave ? tx_slave->dev->name : "NULL");
686 	} else if (arp->op_code == htons(ARPOP_REQUEST)) {
687 		/* Create an entry in the rx_hashtbl for this client as a
688 		 * place holder.
689 		 * When the arp reply is received the entry will be updated
690 		 * with the correct unicast address of the client.
691 		 */
692 		tx_slave = rlb_choose_channel(skb, bond, arp);
693 
694 		/* The ARP reply packets must be delayed so that
695 		 * they can cancel out the influence of the ARP request.
696 		 */
697 		bond->alb_info.rlb_update_delay_counter = RLB_UPDATE_DELAY;
698 
699 		/* arp requests are broadcast and are sent on the primary
700 		 * the arp request will collapse all clients on the subnet to
701 		 * the primary slave. We must register these clients to be
702 		 * updated with their assigned mac.
703 		 */
704 		rlb_req_update_subnet_clients(bond, arp->ip_src);
705 		netdev_dbg(bond->dev, "(slave %s): Server sent ARP Request packet\n",
706 			   tx_slave ? tx_slave->dev->name : "NULL");
707 	}
708 
709 	return tx_slave;
710 }
711 
712 static void rlb_rebalance(struct bonding *bond)
713 {
714 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
715 	struct slave *assigned_slave;
716 	struct rlb_client_info *client_info;
717 	int ntt;
718 	u32 hash_index;
719 
720 	spin_lock_bh(&bond->mode_lock);
721 
722 	ntt = 0;
723 	hash_index = bond_info->rx_hashtbl_used_head;
724 	for (; hash_index != RLB_NULL_INDEX;
725 	     hash_index = client_info->used_next) {
726 		client_info = &(bond_info->rx_hashtbl[hash_index]);
727 		assigned_slave = __rlb_next_rx_slave(bond);
728 		if (assigned_slave && (client_info->slave != assigned_slave)) {
729 			client_info->slave = assigned_slave;
730 			if (!is_zero_ether_addr(client_info->mac_dst)) {
731 				client_info->ntt = 1;
732 				ntt = 1;
733 			}
734 		}
735 	}
736 
737 	/* update the team's flag only after the whole iteration */
738 	if (ntt)
739 		bond_info->rx_ntt = 1;
740 	spin_unlock_bh(&bond->mode_lock);
741 }
742 
743 /* Caller must hold mode_lock */
744 static void rlb_init_table_entry_dst(struct rlb_client_info *entry)
745 {
746 	entry->used_next = RLB_NULL_INDEX;
747 	entry->used_prev = RLB_NULL_INDEX;
748 	entry->assigned = 0;
749 	entry->slave = NULL;
750 	entry->vlan_id = 0;
751 }
752 static void rlb_init_table_entry_src(struct rlb_client_info *entry)
753 {
754 	entry->src_first = RLB_NULL_INDEX;
755 	entry->src_prev = RLB_NULL_INDEX;
756 	entry->src_next = RLB_NULL_INDEX;
757 }
758 
759 static void rlb_init_table_entry(struct rlb_client_info *entry)
760 {
761 	memset(entry, 0, sizeof(struct rlb_client_info));
762 	rlb_init_table_entry_dst(entry);
763 	rlb_init_table_entry_src(entry);
764 }
765 
766 static void rlb_delete_table_entry_dst(struct bonding *bond, u32 index)
767 {
768 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
769 	u32 next_index = bond_info->rx_hashtbl[index].used_next;
770 	u32 prev_index = bond_info->rx_hashtbl[index].used_prev;
771 
772 	if (index == bond_info->rx_hashtbl_used_head)
773 		bond_info->rx_hashtbl_used_head = next_index;
774 	if (prev_index != RLB_NULL_INDEX)
775 		bond_info->rx_hashtbl[prev_index].used_next = next_index;
776 	if (next_index != RLB_NULL_INDEX)
777 		bond_info->rx_hashtbl[next_index].used_prev = prev_index;
778 }
779 
780 /* unlink a rlb hash table entry from the src list */
781 static void rlb_src_unlink(struct bonding *bond, u32 index)
782 {
783 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
784 	u32 next_index = bond_info->rx_hashtbl[index].src_next;
785 	u32 prev_index = bond_info->rx_hashtbl[index].src_prev;
786 
787 	bond_info->rx_hashtbl[index].src_next = RLB_NULL_INDEX;
788 	bond_info->rx_hashtbl[index].src_prev = RLB_NULL_INDEX;
789 
790 	if (next_index != RLB_NULL_INDEX)
791 		bond_info->rx_hashtbl[next_index].src_prev = prev_index;
792 
793 	if (prev_index == RLB_NULL_INDEX)
794 		return;
795 
796 	/* is prev_index pointing to the head of this list? */
797 	if (bond_info->rx_hashtbl[prev_index].src_first == index)
798 		bond_info->rx_hashtbl[prev_index].src_first = next_index;
799 	else
800 		bond_info->rx_hashtbl[prev_index].src_next = next_index;
801 
802 }
803 
804 static void rlb_delete_table_entry(struct bonding *bond, u32 index)
805 {
806 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
807 	struct rlb_client_info *entry = &(bond_info->rx_hashtbl[index]);
808 
809 	rlb_delete_table_entry_dst(bond, index);
810 	rlb_init_table_entry_dst(entry);
811 
812 	rlb_src_unlink(bond, index);
813 }
814 
815 /* add the rx_hashtbl[ip_dst_hash] entry to the list
816  * of entries with identical ip_src_hash
817  */
818 static void rlb_src_link(struct bonding *bond, u32 ip_src_hash, u32 ip_dst_hash)
819 {
820 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
821 	u32 next;
822 
823 	bond_info->rx_hashtbl[ip_dst_hash].src_prev = ip_src_hash;
824 	next = bond_info->rx_hashtbl[ip_src_hash].src_first;
825 	bond_info->rx_hashtbl[ip_dst_hash].src_next = next;
826 	if (next != RLB_NULL_INDEX)
827 		bond_info->rx_hashtbl[next].src_prev = ip_dst_hash;
828 	bond_info->rx_hashtbl[ip_src_hash].src_first = ip_dst_hash;
829 }
830 
831 /* deletes all rx_hashtbl entries with arp->ip_src if their mac_src does
832  * not match arp->mac_src
833  */
834 static void rlb_purge_src_ip(struct bonding *bond, struct arp_pkt *arp)
835 {
836 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
837 	u32 ip_src_hash = _simple_hash((u8 *)&(arp->ip_src), sizeof(arp->ip_src));
838 	u32 index;
839 
840 	spin_lock_bh(&bond->mode_lock);
841 
842 	index = bond_info->rx_hashtbl[ip_src_hash].src_first;
843 	while (index != RLB_NULL_INDEX) {
844 		struct rlb_client_info *entry = &(bond_info->rx_hashtbl[index]);
845 		u32 next_index = entry->src_next;
846 
847 		if (entry->ip_src == arp->ip_src &&
848 		    !ether_addr_equal_64bits(arp->mac_src, entry->mac_src))
849 			rlb_delete_table_entry(bond, index);
850 		index = next_index;
851 	}
852 	spin_unlock_bh(&bond->mode_lock);
853 }
854 
855 static int rlb_initialize(struct bonding *bond)
856 {
857 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
858 	struct rlb_client_info	*new_hashtbl;
859 	int size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info);
860 	int i;
861 
862 	new_hashtbl = kmalloc(size, GFP_KERNEL);
863 	if (!new_hashtbl)
864 		return -1;
865 
866 	spin_lock_bh(&bond->mode_lock);
867 
868 	bond_info->rx_hashtbl = new_hashtbl;
869 
870 	bond_info->rx_hashtbl_used_head = RLB_NULL_INDEX;
871 
872 	for (i = 0; i < RLB_HASH_TABLE_SIZE; i++)
873 		rlb_init_table_entry(bond_info->rx_hashtbl + i);
874 
875 	spin_unlock_bh(&bond->mode_lock);
876 
877 	/* register to receive ARPs */
878 	bond->recv_probe = rlb_arp_recv;
879 
880 	return 0;
881 }
882 
883 static void rlb_deinitialize(struct bonding *bond)
884 {
885 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
886 
887 	spin_lock_bh(&bond->mode_lock);
888 
889 	kfree(bond_info->rx_hashtbl);
890 	bond_info->rx_hashtbl = NULL;
891 	bond_info->rx_hashtbl_used_head = RLB_NULL_INDEX;
892 
893 	spin_unlock_bh(&bond->mode_lock);
894 }
895 
896 static void rlb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
897 {
898 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
899 	u32 curr_index;
900 
901 	spin_lock_bh(&bond->mode_lock);
902 
903 	curr_index = bond_info->rx_hashtbl_used_head;
904 	while (curr_index != RLB_NULL_INDEX) {
905 		struct rlb_client_info *curr = &(bond_info->rx_hashtbl[curr_index]);
906 		u32 next_index = bond_info->rx_hashtbl[curr_index].used_next;
907 
908 		if (curr->vlan_id == vlan_id)
909 			rlb_delete_table_entry(bond, curr_index);
910 
911 		curr_index = next_index;
912 	}
913 
914 	spin_unlock_bh(&bond->mode_lock);
915 }
916 
917 /*********************** tlb/rlb shared functions *********************/
918 
919 static void alb_send_lp_vid(struct slave *slave, const u8 mac_addr[],
920 			    __be16 vlan_proto, u16 vid)
921 {
922 	struct learning_pkt pkt;
923 	struct sk_buff *skb;
924 	int size = sizeof(struct learning_pkt);
925 
926 	memset(&pkt, 0, size);
927 	ether_addr_copy(pkt.mac_dst, mac_addr);
928 	ether_addr_copy(pkt.mac_src, mac_addr);
929 	pkt.type = cpu_to_be16(ETH_P_LOOPBACK);
930 
931 	skb = dev_alloc_skb(size);
932 	if (!skb)
933 		return;
934 
935 	skb_put_data(skb, &pkt, size);
936 
937 	skb_reset_mac_header(skb);
938 	skb->network_header = skb->mac_header + ETH_HLEN;
939 	skb->protocol = pkt.type;
940 	skb->priority = TC_PRIO_CONTROL;
941 	skb->dev = slave->dev;
942 
943 	slave_dbg(slave->bond->dev, slave->dev,
944 		  "Send learning packet: mac %pM vlan %d\n", mac_addr, vid);
945 
946 	if (vid)
947 		__vlan_hwaccel_put_tag(skb, vlan_proto, vid);
948 
949 	dev_queue_xmit(skb);
950 }
951 
952 struct alb_walk_data {
953 	struct bonding *bond;
954 	struct slave *slave;
955 	const u8 *mac_addr;
956 	bool strict_match;
957 };
958 
959 static int alb_upper_dev_walk(struct net_device *upper,
960 			      struct netdev_nested_priv *priv)
961 {
962 	struct alb_walk_data *data = (struct alb_walk_data *)priv->data;
963 	bool strict_match = data->strict_match;
964 	const u8 *mac_addr = data->mac_addr;
965 	struct bonding *bond = data->bond;
966 	struct slave *slave = data->slave;
967 	struct bond_vlan_tag *tags;
968 
969 	if (is_vlan_dev(upper) &&
970 	    bond->dev->lower_level == upper->lower_level - 1) {
971 		if (upper->addr_assign_type == NET_ADDR_STOLEN) {
972 			alb_send_lp_vid(slave, mac_addr,
973 					vlan_dev_vlan_proto(upper),
974 					vlan_dev_vlan_id(upper));
975 		} else {
976 			alb_send_lp_vid(slave, upper->dev_addr,
977 					vlan_dev_vlan_proto(upper),
978 					vlan_dev_vlan_id(upper));
979 		}
980 	}
981 
982 	/* If this is a macvlan device, then only send updates
983 	 * when strict_match is turned off.
984 	 */
985 	if (netif_is_macvlan(upper) && !strict_match) {
986 		tags = bond_verify_device_path(bond->dev, upper, 0);
987 		if (IS_ERR_OR_NULL(tags))
988 			BUG();
989 		alb_send_lp_vid(slave, upper->dev_addr,
990 				tags[0].vlan_proto, tags[0].vlan_id);
991 		kfree(tags);
992 	}
993 
994 	return 0;
995 }
996 
997 static void alb_send_learning_packets(struct slave *slave, const u8 mac_addr[],
998 				      bool strict_match)
999 {
1000 	struct bonding *bond = bond_get_bond_by_slave(slave);
1001 	struct netdev_nested_priv priv;
1002 	struct alb_walk_data data = {
1003 		.strict_match = strict_match,
1004 		.mac_addr = mac_addr,
1005 		.slave = slave,
1006 		.bond = bond,
1007 	};
1008 
1009 	priv.data = (void *)&data;
1010 	/* send untagged */
1011 	alb_send_lp_vid(slave, mac_addr, 0, 0);
1012 
1013 	/* loop through all devices and see if we need to send a packet
1014 	 * for that device.
1015 	 */
1016 	rcu_read_lock();
1017 	netdev_walk_all_upper_dev_rcu(bond->dev, alb_upper_dev_walk, &priv);
1018 	rcu_read_unlock();
1019 }
1020 
1021 static int alb_set_slave_mac_addr(struct slave *slave, const u8 addr[],
1022 				  unsigned int len)
1023 {
1024 	struct net_device *dev = slave->dev;
1025 	struct sockaddr_storage ss;
1026 
1027 	if (BOND_MODE(slave->bond) == BOND_MODE_TLB) {
1028 		__dev_addr_set(dev, addr, len);
1029 		return 0;
1030 	}
1031 
1032 	/* for rlb each slave must have a unique hw mac addresses so that
1033 	 * each slave will receive packets destined to a different mac
1034 	 */
1035 	memcpy(ss.__data, addr, len);
1036 	ss.ss_family = dev->type;
1037 	if (dev_set_mac_address(dev, (struct sockaddr *)&ss, NULL)) {
1038 		slave_err(slave->bond->dev, dev, "dev_set_mac_address on slave failed! ALB mode requires that the base driver support setting the hw address also when the network device's interface is open\n");
1039 		return -EOPNOTSUPP;
1040 	}
1041 	return 0;
1042 }
1043 
1044 /* Swap MAC addresses between two slaves.
1045  *
1046  * Called with RTNL held, and no other locks.
1047  */
1048 static void alb_swap_mac_addr(struct slave *slave1, struct slave *slave2)
1049 {
1050 	u8 tmp_mac_addr[MAX_ADDR_LEN];
1051 
1052 	bond_hw_addr_copy(tmp_mac_addr, slave1->dev->dev_addr,
1053 			  slave1->dev->addr_len);
1054 	alb_set_slave_mac_addr(slave1, slave2->dev->dev_addr,
1055 			       slave2->dev->addr_len);
1056 	alb_set_slave_mac_addr(slave2, tmp_mac_addr,
1057 			       slave1->dev->addr_len);
1058 
1059 }
1060 
1061 /* Send learning packets after MAC address swap.
1062  *
1063  * Called with RTNL and no other locks
1064  */
1065 static void alb_fasten_mac_swap(struct bonding *bond, struct slave *slave1,
1066 				struct slave *slave2)
1067 {
1068 	int slaves_state_differ = (bond_slave_can_tx(slave1) != bond_slave_can_tx(slave2));
1069 	struct slave *disabled_slave = NULL;
1070 
1071 	ASSERT_RTNL();
1072 
1073 	/* fasten the change in the switch */
1074 	if (bond_slave_can_tx(slave1)) {
1075 		alb_send_learning_packets(slave1, slave1->dev->dev_addr, false);
1076 		if (bond->alb_info.rlb_enabled) {
1077 			/* inform the clients that the mac address
1078 			 * has changed
1079 			 */
1080 			rlb_req_update_slave_clients(bond, slave1);
1081 		}
1082 	} else {
1083 		disabled_slave = slave1;
1084 	}
1085 
1086 	if (bond_slave_can_tx(slave2)) {
1087 		alb_send_learning_packets(slave2, slave2->dev->dev_addr, false);
1088 		if (bond->alb_info.rlb_enabled) {
1089 			/* inform the clients that the mac address
1090 			 * has changed
1091 			 */
1092 			rlb_req_update_slave_clients(bond, slave2);
1093 		}
1094 	} else {
1095 		disabled_slave = slave2;
1096 	}
1097 
1098 	if (bond->alb_info.rlb_enabled && slaves_state_differ) {
1099 		/* A disabled slave was assigned an active mac addr */
1100 		rlb_teach_disabled_mac_on_primary(bond,
1101 						  disabled_slave->dev->dev_addr);
1102 	}
1103 }
1104 
1105 /**
1106  * alb_change_hw_addr_on_detach
1107  * @bond: bonding we're working on
1108  * @slave: the slave that was just detached
1109  *
1110  * We assume that @slave was already detached from the slave list.
1111  *
1112  * If @slave's permanent hw address is different both from its current
1113  * address and from @bond's address, then somewhere in the bond there's
1114  * a slave that has @slave's permanet address as its current address.
1115  * We'll make sure that slave no longer uses @slave's permanent address.
1116  *
1117  * Caller must hold RTNL and no other locks
1118  */
1119 static void alb_change_hw_addr_on_detach(struct bonding *bond, struct slave *slave)
1120 {
1121 	int perm_curr_diff;
1122 	int perm_bond_diff;
1123 	struct slave *found_slave;
1124 
1125 	perm_curr_diff = !ether_addr_equal_64bits(slave->perm_hwaddr,
1126 						  slave->dev->dev_addr);
1127 	perm_bond_diff = !ether_addr_equal_64bits(slave->perm_hwaddr,
1128 						  bond->dev->dev_addr);
1129 
1130 	if (perm_curr_diff && perm_bond_diff) {
1131 		found_slave = bond_slave_has_mac(bond, slave->perm_hwaddr);
1132 
1133 		if (found_slave) {
1134 			alb_swap_mac_addr(slave, found_slave);
1135 			alb_fasten_mac_swap(bond, slave, found_slave);
1136 		}
1137 	}
1138 }
1139 
1140 /**
1141  * alb_handle_addr_collision_on_attach
1142  * @bond: bonding we're working on
1143  * @slave: the slave that was just attached
1144  *
1145  * checks uniqueness of slave's mac address and handles the case the
1146  * new slave uses the bonds mac address.
1147  *
1148  * If the permanent hw address of @slave is @bond's hw address, we need to
1149  * find a different hw address to give @slave, that isn't in use by any other
1150  * slave in the bond. This address must be, of course, one of the permanent
1151  * addresses of the other slaves.
1152  *
1153  * We go over the slave list, and for each slave there we compare its
1154  * permanent hw address with the current address of all the other slaves.
1155  * If no match was found, then we've found a slave with a permanent address
1156  * that isn't used by any other slave in the bond, so we can assign it to
1157  * @slave.
1158  *
1159  * assumption: this function is called before @slave is attached to the
1160  *	       bond slave list.
1161  */
1162 static int alb_handle_addr_collision_on_attach(struct bonding *bond, struct slave *slave)
1163 {
1164 	struct slave *has_bond_addr = rcu_access_pointer(bond->curr_active_slave);
1165 	struct slave *tmp_slave1, *free_mac_slave = NULL;
1166 	struct list_head *iter;
1167 
1168 	if (!bond_has_slaves(bond)) {
1169 		/* this is the first slave */
1170 		return 0;
1171 	}
1172 
1173 	/* if slave's mac address differs from bond's mac address
1174 	 * check uniqueness of slave's mac address against the other
1175 	 * slaves in the bond.
1176 	 */
1177 	if (!ether_addr_equal_64bits(slave->perm_hwaddr, bond->dev->dev_addr)) {
1178 		if (!bond_slave_has_mac(bond, slave->dev->dev_addr))
1179 			return 0;
1180 
1181 		/* Try setting slave mac to bond address and fall-through
1182 		 * to code handling that situation below...
1183 		 */
1184 		alb_set_slave_mac_addr(slave, bond->dev->dev_addr,
1185 				       bond->dev->addr_len);
1186 	}
1187 
1188 	/* The slave's address is equal to the address of the bond.
1189 	 * Search for a spare address in the bond for this slave.
1190 	 */
1191 	bond_for_each_slave(bond, tmp_slave1, iter) {
1192 		if (!bond_slave_has_mac(bond, tmp_slave1->perm_hwaddr)) {
1193 			/* no slave has tmp_slave1's perm addr
1194 			 * as its curr addr
1195 			 */
1196 			free_mac_slave = tmp_slave1;
1197 			break;
1198 		}
1199 
1200 		if (!has_bond_addr) {
1201 			if (ether_addr_equal_64bits(tmp_slave1->dev->dev_addr,
1202 						    bond->dev->dev_addr)) {
1203 
1204 				has_bond_addr = tmp_slave1;
1205 			}
1206 		}
1207 	}
1208 
1209 	if (free_mac_slave) {
1210 		alb_set_slave_mac_addr(slave, free_mac_slave->perm_hwaddr,
1211 				       free_mac_slave->dev->addr_len);
1212 
1213 		slave_warn(bond->dev, slave->dev, "the slave hw address is in use by the bond; giving it the hw address of %s\n",
1214 			   free_mac_slave->dev->name);
1215 
1216 	} else if (has_bond_addr) {
1217 		slave_err(bond->dev, slave->dev, "the slave hw address 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");
1218 		return -EFAULT;
1219 	}
1220 
1221 	return 0;
1222 }
1223 
1224 /**
1225  * alb_set_mac_address
1226  * @bond: bonding we're working on
1227  * @addr: MAC address to set
1228  *
1229  * In TLB mode all slaves are configured to the bond's hw address, but set
1230  * their dev_addr field to different addresses (based on their permanent hw
1231  * addresses).
1232  *
1233  * For each slave, this function sets the interface to the new address and then
1234  * changes its dev_addr field to its previous value.
1235  *
1236  * Unwinding assumes bond's mac address has not yet changed.
1237  */
1238 static int alb_set_mac_address(struct bonding *bond, void *addr)
1239 {
1240 	struct slave *slave, *rollback_slave;
1241 	struct list_head *iter;
1242 	struct sockaddr_storage ss;
1243 	char tmp_addr[MAX_ADDR_LEN];
1244 	int res;
1245 
1246 	if (bond->alb_info.rlb_enabled)
1247 		return 0;
1248 
1249 	bond_for_each_slave(bond, slave, iter) {
1250 		/* save net_device's current hw address */
1251 		bond_hw_addr_copy(tmp_addr, slave->dev->dev_addr,
1252 				  slave->dev->addr_len);
1253 
1254 		res = dev_set_mac_address(slave->dev, addr, NULL);
1255 
1256 		/* restore net_device's hw address */
1257 		dev_addr_set(slave->dev, tmp_addr);
1258 
1259 		if (res)
1260 			goto unwind;
1261 	}
1262 
1263 	return 0;
1264 
1265 unwind:
1266 	memcpy(ss.__data, bond->dev->dev_addr, bond->dev->addr_len);
1267 	ss.ss_family = bond->dev->type;
1268 
1269 	/* unwind from head to the slave that failed */
1270 	bond_for_each_slave(bond, rollback_slave, iter) {
1271 		if (rollback_slave == slave)
1272 			break;
1273 		bond_hw_addr_copy(tmp_addr, rollback_slave->dev->dev_addr,
1274 				  rollback_slave->dev->addr_len);
1275 		dev_set_mac_address(rollback_slave->dev,
1276 				    (struct sockaddr *)&ss, NULL);
1277 		dev_addr_set(rollback_slave->dev, tmp_addr);
1278 	}
1279 
1280 	return res;
1281 }
1282 
1283 /* determine if the packet is NA or NS */
1284 static bool alb_determine_nd(struct sk_buff *skb, struct bonding *bond)
1285 {
1286 	struct ipv6hdr *ip6hdr;
1287 	struct icmp6hdr *hdr;
1288 
1289 	if (!pskb_network_may_pull(skb, sizeof(*ip6hdr)))
1290 		return true;
1291 
1292 	ip6hdr = ipv6_hdr(skb);
1293 	if (ip6hdr->nexthdr != IPPROTO_ICMPV6)
1294 		return false;
1295 
1296 	if (!pskb_network_may_pull(skb, sizeof(*ip6hdr) + sizeof(*hdr)))
1297 		return true;
1298 
1299 	hdr = icmp6_hdr(skb);
1300 	return hdr->icmp6_type == NDISC_NEIGHBOUR_ADVERTISEMENT ||
1301 		hdr->icmp6_type == NDISC_NEIGHBOUR_SOLICITATION;
1302 }
1303 
1304 /************************ exported alb functions ************************/
1305 
1306 int bond_alb_initialize(struct bonding *bond, int rlb_enabled)
1307 {
1308 	int res;
1309 
1310 	res = tlb_initialize(bond);
1311 	if (res)
1312 		return res;
1313 
1314 	if (rlb_enabled) {
1315 		res = rlb_initialize(bond);
1316 		if (res) {
1317 			tlb_deinitialize(bond);
1318 			return res;
1319 		}
1320 		bond->alb_info.rlb_enabled = 1;
1321 	} else {
1322 		bond->alb_info.rlb_enabled = 0;
1323 	}
1324 
1325 	return 0;
1326 }
1327 
1328 void bond_alb_deinitialize(struct bonding *bond)
1329 {
1330 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1331 
1332 	tlb_deinitialize(bond);
1333 
1334 	if (bond_info->rlb_enabled)
1335 		rlb_deinitialize(bond);
1336 }
1337 
1338 static netdev_tx_t bond_do_alb_xmit(struct sk_buff *skb, struct bonding *bond,
1339 				    struct slave *tx_slave)
1340 {
1341 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1342 	struct ethhdr *eth_data = eth_hdr(skb);
1343 
1344 	if (!tx_slave) {
1345 		/* unbalanced or unassigned, send through primary */
1346 		tx_slave = rcu_dereference(bond->curr_active_slave);
1347 		if (bond->params.tlb_dynamic_lb)
1348 			bond_info->unbalanced_load += skb->len;
1349 	}
1350 
1351 	if (tx_slave && bond_slave_can_tx(tx_slave)) {
1352 		if (tx_slave != rcu_access_pointer(bond->curr_active_slave)) {
1353 			ether_addr_copy(eth_data->h_source,
1354 					tx_slave->dev->dev_addr);
1355 		}
1356 
1357 		return bond_dev_queue_xmit(bond, skb, tx_slave->dev);
1358 	}
1359 
1360 	if (tx_slave && bond->params.tlb_dynamic_lb) {
1361 		spin_lock(&bond->mode_lock);
1362 		__tlb_clear_slave(bond, tx_slave, 0);
1363 		spin_unlock(&bond->mode_lock);
1364 	}
1365 
1366 	/* no suitable interface, frame not sent */
1367 	return bond_tx_drop(bond->dev, skb);
1368 }
1369 
1370 struct slave *bond_xmit_tlb_slave_get(struct bonding *bond,
1371 				      struct sk_buff *skb)
1372 {
1373 	struct slave *tx_slave = NULL;
1374 	struct ethhdr *eth_data;
1375 	u32 hash_index;
1376 
1377 	skb_reset_mac_header(skb);
1378 	eth_data = eth_hdr(skb);
1379 
1380 	/* Do not TX balance any multicast or broadcast */
1381 	if (!is_multicast_ether_addr(eth_data->h_dest)) {
1382 		switch (skb->protocol) {
1383 		case htons(ETH_P_IPV6):
1384 			if (alb_determine_nd(skb, bond))
1385 				break;
1386 			fallthrough;
1387 		case htons(ETH_P_IP):
1388 			hash_index = bond_xmit_hash(bond, skb);
1389 			if (bond->params.tlb_dynamic_lb) {
1390 				tx_slave = tlb_choose_channel(bond,
1391 							      hash_index & 0xFF,
1392 							      skb->len);
1393 			} else {
1394 				struct bond_up_slave *slaves;
1395 				unsigned int count;
1396 
1397 				slaves = rcu_dereference(bond->usable_slaves);
1398 				count = slaves ? READ_ONCE(slaves->count) : 0;
1399 				if (likely(count))
1400 					tx_slave = slaves->arr[hash_index %
1401 							       count];
1402 			}
1403 			break;
1404 		}
1405 	}
1406 	return tx_slave;
1407 }
1408 
1409 netdev_tx_t bond_tlb_xmit(struct sk_buff *skb, struct net_device *bond_dev)
1410 {
1411 	struct bonding *bond = netdev_priv(bond_dev);
1412 	struct slave *tx_slave;
1413 
1414 	tx_slave = bond_xmit_tlb_slave_get(bond, skb);
1415 	return bond_do_alb_xmit(skb, bond, tx_slave);
1416 }
1417 
1418 struct slave *bond_xmit_alb_slave_get(struct bonding *bond,
1419 				      struct sk_buff *skb)
1420 {
1421 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1422 	static const __be32 ip_bcast = htonl(0xffffffff);
1423 	struct slave *tx_slave = NULL;
1424 	const u8 *hash_start = NULL;
1425 	bool do_tx_balance = true;
1426 	struct ethhdr *eth_data;
1427 	u32 hash_index = 0;
1428 	int hash_size = 0;
1429 
1430 	skb_reset_mac_header(skb);
1431 	eth_data = eth_hdr(skb);
1432 
1433 	switch (ntohs(skb->protocol)) {
1434 	case ETH_P_IP: {
1435 		const struct iphdr *iph;
1436 
1437 		if (is_broadcast_ether_addr(eth_data->h_dest) ||
1438 		    !pskb_network_may_pull(skb, sizeof(*iph))) {
1439 			do_tx_balance = false;
1440 			break;
1441 		}
1442 		iph = ip_hdr(skb);
1443 		if (iph->daddr == ip_bcast || iph->protocol == IPPROTO_IGMP) {
1444 			do_tx_balance = false;
1445 			break;
1446 		}
1447 		hash_start = (char *)&(iph->daddr);
1448 		hash_size = sizeof(iph->daddr);
1449 		break;
1450 	}
1451 	case ETH_P_IPV6: {
1452 		const struct ipv6hdr *ip6hdr;
1453 
1454 		/* IPv6 doesn't really use broadcast mac address, but leave
1455 		 * that here just in case.
1456 		 */
1457 		if (is_broadcast_ether_addr(eth_data->h_dest)) {
1458 			do_tx_balance = false;
1459 			break;
1460 		}
1461 
1462 		/* IPv6 uses all-nodes multicast as an equivalent to
1463 		 * broadcasts in IPv4.
1464 		 */
1465 		if (ether_addr_equal_64bits(eth_data->h_dest, mac_v6_allmcast)) {
1466 			do_tx_balance = false;
1467 			break;
1468 		}
1469 
1470 		if (alb_determine_nd(skb, bond)) {
1471 			do_tx_balance = false;
1472 			break;
1473 		}
1474 
1475 		/* The IPv6 header is pulled by alb_determine_nd */
1476 		/* Additionally, DAD probes should not be tx-balanced as that
1477 		 * will lead to false positives for duplicate addresses and
1478 		 * prevent address configuration from working.
1479 		 */
1480 		ip6hdr = ipv6_hdr(skb);
1481 		if (ipv6_addr_any(&ip6hdr->saddr)) {
1482 			do_tx_balance = false;
1483 			break;
1484 		}
1485 
1486 		hash_start = (char *)&ip6hdr->daddr;
1487 		hash_size = sizeof(ip6hdr->daddr);
1488 		break;
1489 	}
1490 	case ETH_P_ARP:
1491 		do_tx_balance = false;
1492 		if (bond_info->rlb_enabled)
1493 			tx_slave = rlb_arp_xmit(skb, bond);
1494 		break;
1495 	default:
1496 		do_tx_balance = false;
1497 		break;
1498 	}
1499 
1500 	if (do_tx_balance) {
1501 		if (bond->params.tlb_dynamic_lb) {
1502 			hash_index = _simple_hash(hash_start, hash_size);
1503 			tx_slave = tlb_choose_channel(bond, hash_index, skb->len);
1504 		} else {
1505 			/*
1506 			 * do_tx_balance means we are free to select the tx_slave
1507 			 * So we do exactly what tlb would do for hash selection
1508 			 */
1509 
1510 			struct bond_up_slave *slaves;
1511 			unsigned int count;
1512 
1513 			slaves = rcu_dereference(bond->usable_slaves);
1514 			count = slaves ? READ_ONCE(slaves->count) : 0;
1515 			if (likely(count))
1516 				tx_slave = slaves->arr[bond_xmit_hash(bond, skb) %
1517 						       count];
1518 		}
1519 	}
1520 	return tx_slave;
1521 }
1522 
1523 netdev_tx_t bond_alb_xmit(struct sk_buff *skb, struct net_device *bond_dev)
1524 {
1525 	struct bonding *bond = netdev_priv(bond_dev);
1526 	struct slave *tx_slave = NULL;
1527 
1528 	tx_slave = bond_xmit_alb_slave_get(bond, skb);
1529 	return bond_do_alb_xmit(skb, bond, tx_slave);
1530 }
1531 
1532 void bond_alb_monitor(struct work_struct *work)
1533 {
1534 	struct bonding *bond = container_of(work, struct bonding,
1535 					    alb_work.work);
1536 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1537 	struct list_head *iter;
1538 	struct slave *slave;
1539 
1540 	if (!bond_has_slaves(bond)) {
1541 		atomic_set(&bond_info->tx_rebalance_counter, 0);
1542 		bond_info->lp_counter = 0;
1543 		goto re_arm;
1544 	}
1545 
1546 	rcu_read_lock();
1547 
1548 	atomic_inc(&bond_info->tx_rebalance_counter);
1549 	bond_info->lp_counter++;
1550 
1551 	/* send learning packets */
1552 	if (bond_info->lp_counter >= BOND_ALB_LP_TICKS(bond)) {
1553 		bool strict_match;
1554 
1555 		bond_for_each_slave_rcu(bond, slave, iter) {
1556 			/* If updating current_active, use all currently
1557 			 * user mac addresses (!strict_match).  Otherwise, only
1558 			 * use mac of the slave device.
1559 			 * In RLB mode, we always use strict matches.
1560 			 */
1561 			strict_match = (slave != rcu_access_pointer(bond->curr_active_slave) ||
1562 					bond_info->rlb_enabled);
1563 			alb_send_learning_packets(slave, slave->dev->dev_addr,
1564 						  strict_match);
1565 		}
1566 		bond_info->lp_counter = 0;
1567 	}
1568 
1569 	/* rebalance tx traffic */
1570 	if (atomic_read(&bond_info->tx_rebalance_counter) >= BOND_TLB_REBALANCE_TICKS) {
1571 		bond_for_each_slave_rcu(bond, slave, iter) {
1572 			tlb_clear_slave(bond, slave, 1);
1573 			if (slave == rcu_access_pointer(bond->curr_active_slave)) {
1574 				SLAVE_TLB_INFO(slave).load =
1575 					bond_info->unbalanced_load /
1576 						BOND_TLB_REBALANCE_INTERVAL;
1577 				bond_info->unbalanced_load = 0;
1578 			}
1579 		}
1580 		atomic_set(&bond_info->tx_rebalance_counter, 0);
1581 	}
1582 
1583 	if (bond_info->rlb_enabled) {
1584 		if (bond_info->primary_is_promisc &&
1585 		    (++bond_info->rlb_promisc_timeout_counter >= RLB_PROMISC_TIMEOUT)) {
1586 
1587 			/* dev_set_promiscuity requires rtnl and
1588 			 * nothing else.  Avoid race with bond_close.
1589 			 */
1590 			rcu_read_unlock();
1591 			if (!rtnl_trylock())
1592 				goto re_arm;
1593 
1594 			bond_info->rlb_promisc_timeout_counter = 0;
1595 
1596 			/* If the primary was set to promiscuous mode
1597 			 * because a slave was disabled then
1598 			 * it can now leave promiscuous mode.
1599 			 */
1600 			dev_set_promiscuity(rtnl_dereference(bond->curr_active_slave)->dev,
1601 					    -1);
1602 			bond_info->primary_is_promisc = 0;
1603 
1604 			rtnl_unlock();
1605 			rcu_read_lock();
1606 		}
1607 
1608 		if (bond_info->rlb_rebalance) {
1609 			bond_info->rlb_rebalance = 0;
1610 			rlb_rebalance(bond);
1611 		}
1612 
1613 		/* check if clients need updating */
1614 		if (bond_info->rx_ntt) {
1615 			if (bond_info->rlb_update_delay_counter) {
1616 				--bond_info->rlb_update_delay_counter;
1617 			} else {
1618 				rlb_update_rx_clients(bond);
1619 				if (bond_info->rlb_update_retry_counter)
1620 					--bond_info->rlb_update_retry_counter;
1621 				else
1622 					bond_info->rx_ntt = 0;
1623 			}
1624 		}
1625 	}
1626 	rcu_read_unlock();
1627 re_arm:
1628 	queue_delayed_work(bond->wq, &bond->alb_work, alb_delta_in_ticks);
1629 }
1630 
1631 /* assumption: called before the slave is attached to the bond
1632  * and not locked by the bond lock
1633  */
1634 int bond_alb_init_slave(struct bonding *bond, struct slave *slave)
1635 {
1636 	int res;
1637 
1638 	res = alb_set_slave_mac_addr(slave, slave->perm_hwaddr,
1639 				     slave->dev->addr_len);
1640 	if (res)
1641 		return res;
1642 
1643 	res = alb_handle_addr_collision_on_attach(bond, slave);
1644 	if (res)
1645 		return res;
1646 
1647 	tlb_init_slave(slave);
1648 
1649 	/* order a rebalance ASAP */
1650 	atomic_set(&bond->alb_info.tx_rebalance_counter,
1651 		   BOND_TLB_REBALANCE_TICKS);
1652 
1653 	if (bond->alb_info.rlb_enabled)
1654 		bond->alb_info.rlb_rebalance = 1;
1655 
1656 	return 0;
1657 }
1658 
1659 /* Remove slave from tlb and rlb hash tables, and fix up MAC addresses
1660  * if necessary.
1661  *
1662  * Caller must hold RTNL and no other locks
1663  */
1664 void bond_alb_deinit_slave(struct bonding *bond, struct slave *slave)
1665 {
1666 	if (bond_has_slaves(bond))
1667 		alb_change_hw_addr_on_detach(bond, slave);
1668 
1669 	tlb_clear_slave(bond, slave, 0);
1670 
1671 	if (bond->alb_info.rlb_enabled) {
1672 		bond->alb_info.rx_slave = NULL;
1673 		rlb_clear_slave(bond, slave);
1674 	}
1675 
1676 }
1677 
1678 void bond_alb_handle_link_change(struct bonding *bond, struct slave *slave, char link)
1679 {
1680 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1681 
1682 	if (link == BOND_LINK_DOWN) {
1683 		tlb_clear_slave(bond, slave, 0);
1684 		if (bond->alb_info.rlb_enabled)
1685 			rlb_clear_slave(bond, slave);
1686 	} else if (link == BOND_LINK_UP) {
1687 		/* order a rebalance ASAP */
1688 		atomic_set(&bond_info->tx_rebalance_counter,
1689 			   BOND_TLB_REBALANCE_TICKS);
1690 		if (bond->alb_info.rlb_enabled) {
1691 			bond->alb_info.rlb_rebalance = 1;
1692 			/* If the updelay module parameter is smaller than the
1693 			 * forwarding delay of the switch the rebalance will
1694 			 * not work because the rebalance arp replies will
1695 			 * not be forwarded to the clients..
1696 			 */
1697 		}
1698 	}
1699 
1700 	if (bond_is_nondyn_tlb(bond)) {
1701 		if (bond_update_slave_arr(bond, NULL))
1702 			pr_err("Failed to build slave-array for TLB mode.\n");
1703 	}
1704 }
1705 
1706 /**
1707  * bond_alb_handle_active_change - assign new curr_active_slave
1708  * @bond: our bonding struct
1709  * @new_slave: new slave to assign
1710  *
1711  * Set the bond->curr_active_slave to @new_slave and handle
1712  * mac address swapping and promiscuity changes as needed.
1713  *
1714  * Caller must hold RTNL
1715  */
1716 void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave)
1717 {
1718 	struct slave *swap_slave;
1719 	struct slave *curr_active;
1720 
1721 	curr_active = rtnl_dereference(bond->curr_active_slave);
1722 	if (curr_active == new_slave)
1723 		return;
1724 
1725 	if (curr_active && bond->alb_info.primary_is_promisc) {
1726 		dev_set_promiscuity(curr_active->dev, -1);
1727 		bond->alb_info.primary_is_promisc = 0;
1728 		bond->alb_info.rlb_promisc_timeout_counter = 0;
1729 	}
1730 
1731 	swap_slave = curr_active;
1732 	rcu_assign_pointer(bond->curr_active_slave, new_slave);
1733 
1734 	if (!new_slave || !bond_has_slaves(bond))
1735 		return;
1736 
1737 	/* set the new curr_active_slave to the bonds mac address
1738 	 * i.e. swap mac addresses of old curr_active_slave and new curr_active_slave
1739 	 */
1740 	if (!swap_slave)
1741 		swap_slave = bond_slave_has_mac(bond, bond->dev->dev_addr);
1742 
1743 	/* Arrange for swap_slave and new_slave to temporarily be
1744 	 * ignored so we can mess with their MAC addresses without
1745 	 * fear of interference from transmit activity.
1746 	 */
1747 	if (swap_slave)
1748 		tlb_clear_slave(bond, swap_slave, 1);
1749 	tlb_clear_slave(bond, new_slave, 1);
1750 
1751 	/* in TLB mode, the slave might flip down/up with the old dev_addr,
1752 	 * and thus filter bond->dev_addr's packets, so force bond's mac
1753 	 */
1754 	if (BOND_MODE(bond) == BOND_MODE_TLB) {
1755 		struct sockaddr_storage ss;
1756 		u8 tmp_addr[MAX_ADDR_LEN];
1757 
1758 		bond_hw_addr_copy(tmp_addr, new_slave->dev->dev_addr,
1759 				  new_slave->dev->addr_len);
1760 
1761 		bond_hw_addr_copy(ss.__data, bond->dev->dev_addr,
1762 				  bond->dev->addr_len);
1763 		ss.ss_family = bond->dev->type;
1764 		/* we don't care if it can't change its mac, best effort */
1765 		dev_set_mac_address(new_slave->dev, (struct sockaddr *)&ss,
1766 				    NULL);
1767 
1768 		dev_addr_set(new_slave->dev, tmp_addr);
1769 	}
1770 
1771 	/* curr_active_slave must be set before calling alb_swap_mac_addr */
1772 	if (swap_slave) {
1773 		/* swap mac address */
1774 		alb_swap_mac_addr(swap_slave, new_slave);
1775 		alb_fasten_mac_swap(bond, swap_slave, new_slave);
1776 	} else {
1777 		/* set the new_slave to the bond mac address */
1778 		alb_set_slave_mac_addr(new_slave, bond->dev->dev_addr,
1779 				       bond->dev->addr_len);
1780 		alb_send_learning_packets(new_slave, bond->dev->dev_addr,
1781 					  false);
1782 	}
1783 }
1784 
1785 /* Called with RTNL */
1786 int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
1787 {
1788 	struct bonding *bond = netdev_priv(bond_dev);
1789 	struct sockaddr_storage *ss = addr;
1790 	struct slave *curr_active;
1791 	struct slave *swap_slave;
1792 	int res;
1793 
1794 	if (!is_valid_ether_addr(ss->__data))
1795 		return -EADDRNOTAVAIL;
1796 
1797 	res = alb_set_mac_address(bond, addr);
1798 	if (res)
1799 		return res;
1800 
1801 	dev_addr_set(bond_dev, ss->__data);
1802 
1803 	/* If there is no curr_active_slave there is nothing else to do.
1804 	 * Otherwise we'll need to pass the new address to it and handle
1805 	 * duplications.
1806 	 */
1807 	curr_active = rtnl_dereference(bond->curr_active_slave);
1808 	if (!curr_active)
1809 		return 0;
1810 
1811 	swap_slave = bond_slave_has_mac(bond, bond_dev->dev_addr);
1812 
1813 	if (swap_slave) {
1814 		alb_swap_mac_addr(swap_slave, curr_active);
1815 		alb_fasten_mac_swap(bond, swap_slave, curr_active);
1816 	} else {
1817 		alb_set_slave_mac_addr(curr_active, bond_dev->dev_addr,
1818 				       bond_dev->addr_len);
1819 
1820 		alb_send_learning_packets(curr_active,
1821 					  bond_dev->dev_addr, false);
1822 		if (bond->alb_info.rlb_enabled) {
1823 			/* inform clients mac address has changed */
1824 			rlb_req_update_slave_clients(bond, curr_active);
1825 		}
1826 	}
1827 
1828 	return 0;
1829 }
1830 
1831 void bond_alb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
1832 {
1833 	if (bond->alb_info.rlb_enabled)
1834 		rlb_clear_vlan(bond, vlan_id);
1835 }
1836 
1837