xref: /linux/drivers/net/bonding/bond_alb.c (revision 06d07429858317ded2db7986113a9e0129cd599b)
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 
_simple_hash(const u8 * hash_start,int hash_size)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 
tlb_init_table_entry(struct tlb_client_info * entry,int save_load)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 
tlb_init_slave(struct slave * slave)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 
__tlb_clear_slave(struct bonding * bond,struct slave * slave,int save_load)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 
tlb_clear_slave(struct bonding * bond,struct slave * slave,int save_load)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 */
tlb_initialize(struct bonding * bond)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 */
tlb_deinitialize(struct bonding * bond)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 
compute_gap(struct slave * slave)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 
tlb_get_least_loaded_slave(struct bonding * bond)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 
__tlb_choose_channel(struct bonding * bond,u32 hash_index,u32 skb_len)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 
tlb_choose_channel(struct bonding * bond,u32 hash_index,u32 skb_len)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  */
rlb_update_entry_from_arp(struct bonding * bond,struct arp_pkt * arp)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 
rlb_arp_recv(const struct sk_buff * skb,struct bonding * bond,struct slave * slave)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() */
__rlb_next_rx_slave(struct bonding * bond)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 */
rlb_next_rx_slave(struct bonding * bond)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  */
rlb_teach_disabled_mac_on_primary(struct bonding * bond,const u8 addr[])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  */
rlb_clear_slave(struct bonding * bond,struct slave * slave)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 
rlb_update_client(struct rlb_client_info * client_info)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 */
rlb_update_rx_clients(struct bonding * bond)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 */
rlb_req_update_slave_clients(struct bonding * bond,struct slave * slave)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 */
rlb_req_update_subnet_clients(struct bonding * bond,__be32 src_ip)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 
rlb_choose_channel(struct sk_buff * skb,struct bonding * bond,const struct arp_pkt * arp)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  */
rlb_arp_xmit(struct sk_buff * skb,struct bonding * bond)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
664 	 * from the bond itself or a VLAN directly above the bond.
665 	 */
666 	if (!bond_slave_has_mac_rcu(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_any_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 
rlb_rebalance(struct bonding * bond)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 */
rlb_init_table_entry_dst(struct rlb_client_info * entry)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 }
rlb_init_table_entry_src(struct rlb_client_info * entry)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 
rlb_init_table_entry(struct rlb_client_info * entry)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 
rlb_delete_table_entry_dst(struct bonding * bond,u32 index)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 */
rlb_src_unlink(struct bonding * bond,u32 index)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 
rlb_delete_table_entry(struct bonding * bond,u32 index)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  */
rlb_src_link(struct bonding * bond,u32 ip_src_hash,u32 ip_dst_hash)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  */
rlb_purge_src_ip(struct bonding * bond,struct arp_pkt * arp)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 
rlb_initialize(struct bonding * bond)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 
rlb_deinitialize(struct bonding * bond)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 
rlb_clear_vlan(struct bonding * bond,unsigned short vlan_id)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 
alb_send_lp_vid(struct slave * slave,const u8 mac_addr[],__be16 vlan_proto,u16 vid)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 
alb_upper_dev_walk(struct net_device * upper,struct netdev_nested_priv * priv)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 			return -ENOMEM;
989 
990 		alb_send_lp_vid(slave, upper->dev_addr,
991 				tags[0].vlan_proto, tags[0].vlan_id);
992 		kfree(tags);
993 	}
994 
995 	return 0;
996 }
997 
alb_send_learning_packets(struct slave * slave,const u8 mac_addr[],bool strict_match)998 static void alb_send_learning_packets(struct slave *slave, const u8 mac_addr[],
999 				      bool strict_match)
1000 {
1001 	struct bonding *bond = bond_get_bond_by_slave(slave);
1002 	struct netdev_nested_priv priv;
1003 	struct alb_walk_data data = {
1004 		.strict_match = strict_match,
1005 		.mac_addr = mac_addr,
1006 		.slave = slave,
1007 		.bond = bond,
1008 	};
1009 
1010 	priv.data = (void *)&data;
1011 	/* send untagged */
1012 	alb_send_lp_vid(slave, mac_addr, 0, 0);
1013 
1014 	/* loop through all devices and see if we need to send a packet
1015 	 * for that device.
1016 	 */
1017 	rcu_read_lock();
1018 	netdev_walk_all_upper_dev_rcu(bond->dev, alb_upper_dev_walk, &priv);
1019 	rcu_read_unlock();
1020 }
1021 
alb_set_slave_mac_addr(struct slave * slave,const u8 addr[],unsigned int len)1022 static int alb_set_slave_mac_addr(struct slave *slave, const u8 addr[],
1023 				  unsigned int len)
1024 {
1025 	struct net_device *dev = slave->dev;
1026 	struct sockaddr_storage ss;
1027 
1028 	if (BOND_MODE(slave->bond) == BOND_MODE_TLB) {
1029 		__dev_addr_set(dev, addr, len);
1030 		return 0;
1031 	}
1032 
1033 	/* for rlb each slave must have a unique hw mac addresses so that
1034 	 * each slave will receive packets destined to a different mac
1035 	 */
1036 	memcpy(ss.__data, addr, len);
1037 	ss.ss_family = dev->type;
1038 	if (dev_set_mac_address(dev, (struct sockaddr *)&ss, NULL)) {
1039 		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");
1040 		return -EOPNOTSUPP;
1041 	}
1042 	return 0;
1043 }
1044 
1045 /* Swap MAC addresses between two slaves.
1046  *
1047  * Called with RTNL held, and no other locks.
1048  */
alb_swap_mac_addr(struct slave * slave1,struct slave * slave2)1049 static void alb_swap_mac_addr(struct slave *slave1, struct slave *slave2)
1050 {
1051 	u8 tmp_mac_addr[MAX_ADDR_LEN];
1052 
1053 	bond_hw_addr_copy(tmp_mac_addr, slave1->dev->dev_addr,
1054 			  slave1->dev->addr_len);
1055 	alb_set_slave_mac_addr(slave1, slave2->dev->dev_addr,
1056 			       slave2->dev->addr_len);
1057 	alb_set_slave_mac_addr(slave2, tmp_mac_addr,
1058 			       slave1->dev->addr_len);
1059 
1060 }
1061 
1062 /* Send learning packets after MAC address swap.
1063  *
1064  * Called with RTNL and no other locks
1065  */
alb_fasten_mac_swap(struct bonding * bond,struct slave * slave1,struct slave * slave2)1066 static void alb_fasten_mac_swap(struct bonding *bond, struct slave *slave1,
1067 				struct slave *slave2)
1068 {
1069 	int slaves_state_differ = (bond_slave_can_tx(slave1) != bond_slave_can_tx(slave2));
1070 	struct slave *disabled_slave = NULL;
1071 
1072 	ASSERT_RTNL();
1073 
1074 	/* fasten the change in the switch */
1075 	if (bond_slave_can_tx(slave1)) {
1076 		alb_send_learning_packets(slave1, slave1->dev->dev_addr, false);
1077 		if (bond->alb_info.rlb_enabled) {
1078 			/* inform the clients that the mac address
1079 			 * has changed
1080 			 */
1081 			rlb_req_update_slave_clients(bond, slave1);
1082 		}
1083 	} else {
1084 		disabled_slave = slave1;
1085 	}
1086 
1087 	if (bond_slave_can_tx(slave2)) {
1088 		alb_send_learning_packets(slave2, slave2->dev->dev_addr, false);
1089 		if (bond->alb_info.rlb_enabled) {
1090 			/* inform the clients that the mac address
1091 			 * has changed
1092 			 */
1093 			rlb_req_update_slave_clients(bond, slave2);
1094 		}
1095 	} else {
1096 		disabled_slave = slave2;
1097 	}
1098 
1099 	if (bond->alb_info.rlb_enabled && slaves_state_differ) {
1100 		/* A disabled slave was assigned an active mac addr */
1101 		rlb_teach_disabled_mac_on_primary(bond,
1102 						  disabled_slave->dev->dev_addr);
1103 	}
1104 }
1105 
1106 /**
1107  * alb_change_hw_addr_on_detach
1108  * @bond: bonding we're working on
1109  * @slave: the slave that was just detached
1110  *
1111  * We assume that @slave was already detached from the slave list.
1112  *
1113  * If @slave's permanent hw address is different both from its current
1114  * address and from @bond's address, then somewhere in the bond there's
1115  * a slave that has @slave's permanet address as its current address.
1116  * We'll make sure that slave no longer uses @slave's permanent address.
1117  *
1118  * Caller must hold RTNL and no other locks
1119  */
alb_change_hw_addr_on_detach(struct bonding * bond,struct slave * slave)1120 static void alb_change_hw_addr_on_detach(struct bonding *bond, struct slave *slave)
1121 {
1122 	int perm_curr_diff;
1123 	int perm_bond_diff;
1124 	struct slave *found_slave;
1125 
1126 	perm_curr_diff = !ether_addr_equal_64bits(slave->perm_hwaddr,
1127 						  slave->dev->dev_addr);
1128 	perm_bond_diff = !ether_addr_equal_64bits(slave->perm_hwaddr,
1129 						  bond->dev->dev_addr);
1130 
1131 	if (perm_curr_diff && perm_bond_diff) {
1132 		found_slave = bond_slave_has_mac(bond, slave->perm_hwaddr);
1133 
1134 		if (found_slave) {
1135 			alb_swap_mac_addr(slave, found_slave);
1136 			alb_fasten_mac_swap(bond, slave, found_slave);
1137 		}
1138 	}
1139 }
1140 
1141 /**
1142  * alb_handle_addr_collision_on_attach
1143  * @bond: bonding we're working on
1144  * @slave: the slave that was just attached
1145  *
1146  * checks uniqueness of slave's mac address and handles the case the
1147  * new slave uses the bonds mac address.
1148  *
1149  * If the permanent hw address of @slave is @bond's hw address, we need to
1150  * find a different hw address to give @slave, that isn't in use by any other
1151  * slave in the bond. This address must be, of course, one of the permanent
1152  * addresses of the other slaves.
1153  *
1154  * We go over the slave list, and for each slave there we compare its
1155  * permanent hw address with the current address of all the other slaves.
1156  * If no match was found, then we've found a slave with a permanent address
1157  * that isn't used by any other slave in the bond, so we can assign it to
1158  * @slave.
1159  *
1160  * assumption: this function is called before @slave is attached to the
1161  *	       bond slave list.
1162  */
alb_handle_addr_collision_on_attach(struct bonding * bond,struct slave * slave)1163 static int alb_handle_addr_collision_on_attach(struct bonding *bond, struct slave *slave)
1164 {
1165 	struct slave *has_bond_addr = rcu_access_pointer(bond->curr_active_slave);
1166 	struct slave *tmp_slave1, *free_mac_slave = NULL;
1167 	struct list_head *iter;
1168 
1169 	if (!bond_has_slaves(bond)) {
1170 		/* this is the first slave */
1171 		return 0;
1172 	}
1173 
1174 	/* if slave's mac address differs from bond's mac address
1175 	 * check uniqueness of slave's mac address against the other
1176 	 * slaves in the bond.
1177 	 */
1178 	if (!ether_addr_equal_64bits(slave->perm_hwaddr, bond->dev->dev_addr)) {
1179 		if (!bond_slave_has_mac(bond, slave->dev->dev_addr))
1180 			return 0;
1181 
1182 		/* Try setting slave mac to bond address and fall-through
1183 		 * to code handling that situation below...
1184 		 */
1185 		alb_set_slave_mac_addr(slave, bond->dev->dev_addr,
1186 				       bond->dev->addr_len);
1187 	}
1188 
1189 	/* The slave's address is equal to the address of the bond.
1190 	 * Search for a spare address in the bond for this slave.
1191 	 */
1192 	bond_for_each_slave(bond, tmp_slave1, iter) {
1193 		if (!bond_slave_has_mac(bond, tmp_slave1->perm_hwaddr)) {
1194 			/* no slave has tmp_slave1's perm addr
1195 			 * as its curr addr
1196 			 */
1197 			free_mac_slave = tmp_slave1;
1198 			break;
1199 		}
1200 
1201 		if (!has_bond_addr) {
1202 			if (ether_addr_equal_64bits(tmp_slave1->dev->dev_addr,
1203 						    bond->dev->dev_addr)) {
1204 
1205 				has_bond_addr = tmp_slave1;
1206 			}
1207 		}
1208 	}
1209 
1210 	if (free_mac_slave) {
1211 		alb_set_slave_mac_addr(slave, free_mac_slave->perm_hwaddr,
1212 				       free_mac_slave->dev->addr_len);
1213 
1214 		slave_warn(bond->dev, slave->dev, "the slave hw address is in use by the bond; giving it the hw address of %s\n",
1215 			   free_mac_slave->dev->name);
1216 
1217 	} else if (has_bond_addr) {
1218 		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");
1219 		return -EFAULT;
1220 	}
1221 
1222 	return 0;
1223 }
1224 
1225 /**
1226  * alb_set_mac_address
1227  * @bond: bonding we're working on
1228  * @addr: MAC address to set
1229  *
1230  * In TLB mode all slaves are configured to the bond's hw address, but set
1231  * their dev_addr field to different addresses (based on their permanent hw
1232  * addresses).
1233  *
1234  * For each slave, this function sets the interface to the new address and then
1235  * changes its dev_addr field to its previous value.
1236  *
1237  * Unwinding assumes bond's mac address has not yet changed.
1238  */
alb_set_mac_address(struct bonding * bond,void * addr)1239 static int alb_set_mac_address(struct bonding *bond, void *addr)
1240 {
1241 	struct slave *slave, *rollback_slave;
1242 	struct list_head *iter;
1243 	struct sockaddr_storage ss;
1244 	char tmp_addr[MAX_ADDR_LEN];
1245 	int res;
1246 
1247 	if (bond->alb_info.rlb_enabled)
1248 		return 0;
1249 
1250 	bond_for_each_slave(bond, slave, iter) {
1251 		/* save net_device's current hw address */
1252 		bond_hw_addr_copy(tmp_addr, slave->dev->dev_addr,
1253 				  slave->dev->addr_len);
1254 
1255 		res = dev_set_mac_address(slave->dev, addr, NULL);
1256 
1257 		/* restore net_device's hw address */
1258 		dev_addr_set(slave->dev, tmp_addr);
1259 
1260 		if (res)
1261 			goto unwind;
1262 	}
1263 
1264 	return 0;
1265 
1266 unwind:
1267 	memcpy(ss.__data, bond->dev->dev_addr, bond->dev->addr_len);
1268 	ss.ss_family = bond->dev->type;
1269 
1270 	/* unwind from head to the slave that failed */
1271 	bond_for_each_slave(bond, rollback_slave, iter) {
1272 		if (rollback_slave == slave)
1273 			break;
1274 		bond_hw_addr_copy(tmp_addr, rollback_slave->dev->dev_addr,
1275 				  rollback_slave->dev->addr_len);
1276 		dev_set_mac_address(rollback_slave->dev,
1277 				    (struct sockaddr *)&ss, NULL);
1278 		dev_addr_set(rollback_slave->dev, tmp_addr);
1279 	}
1280 
1281 	return res;
1282 }
1283 
1284 /* determine if the packet is NA or NS */
alb_determine_nd(struct sk_buff * skb,struct bonding * bond)1285 static bool alb_determine_nd(struct sk_buff *skb, struct bonding *bond)
1286 {
1287 	struct ipv6hdr *ip6hdr;
1288 	struct icmp6hdr *hdr;
1289 
1290 	if (!pskb_network_may_pull(skb, sizeof(*ip6hdr)))
1291 		return true;
1292 
1293 	ip6hdr = ipv6_hdr(skb);
1294 	if (ip6hdr->nexthdr != IPPROTO_ICMPV6)
1295 		return false;
1296 
1297 	if (!pskb_network_may_pull(skb, sizeof(*ip6hdr) + sizeof(*hdr)))
1298 		return true;
1299 
1300 	hdr = icmp6_hdr(skb);
1301 	return hdr->icmp6_type == NDISC_NEIGHBOUR_ADVERTISEMENT ||
1302 		hdr->icmp6_type == NDISC_NEIGHBOUR_SOLICITATION;
1303 }
1304 
1305 /************************ exported alb functions ************************/
1306 
bond_alb_initialize(struct bonding * bond,int rlb_enabled)1307 int bond_alb_initialize(struct bonding *bond, int rlb_enabled)
1308 {
1309 	int res;
1310 
1311 	res = tlb_initialize(bond);
1312 	if (res)
1313 		return res;
1314 
1315 	if (rlb_enabled) {
1316 		res = rlb_initialize(bond);
1317 		if (res) {
1318 			tlb_deinitialize(bond);
1319 			return res;
1320 		}
1321 		bond->alb_info.rlb_enabled = 1;
1322 	} else {
1323 		bond->alb_info.rlb_enabled = 0;
1324 	}
1325 
1326 	return 0;
1327 }
1328 
bond_alb_deinitialize(struct bonding * bond)1329 void bond_alb_deinitialize(struct bonding *bond)
1330 {
1331 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1332 
1333 	tlb_deinitialize(bond);
1334 
1335 	if (bond_info->rlb_enabled)
1336 		rlb_deinitialize(bond);
1337 }
1338 
bond_do_alb_xmit(struct sk_buff * skb,struct bonding * bond,struct slave * tx_slave)1339 static netdev_tx_t bond_do_alb_xmit(struct sk_buff *skb, struct bonding *bond,
1340 				    struct slave *tx_slave)
1341 {
1342 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1343 	struct ethhdr *eth_data = eth_hdr(skb);
1344 
1345 	if (!tx_slave) {
1346 		/* unbalanced or unassigned, send through primary */
1347 		tx_slave = rcu_dereference(bond->curr_active_slave);
1348 		if (bond->params.tlb_dynamic_lb)
1349 			bond_info->unbalanced_load += skb->len;
1350 	}
1351 
1352 	if (tx_slave && bond_slave_can_tx(tx_slave)) {
1353 		if (tx_slave != rcu_access_pointer(bond->curr_active_slave)) {
1354 			ether_addr_copy(eth_data->h_source,
1355 					tx_slave->dev->dev_addr);
1356 		}
1357 
1358 		return bond_dev_queue_xmit(bond, skb, tx_slave->dev);
1359 	}
1360 
1361 	if (tx_slave && bond->params.tlb_dynamic_lb) {
1362 		spin_lock(&bond->mode_lock);
1363 		__tlb_clear_slave(bond, tx_slave, 0);
1364 		spin_unlock(&bond->mode_lock);
1365 	}
1366 
1367 	/* no suitable interface, frame not sent */
1368 	return bond_tx_drop(bond->dev, skb);
1369 }
1370 
bond_xmit_tlb_slave_get(struct bonding * bond,struct sk_buff * skb)1371 struct slave *bond_xmit_tlb_slave_get(struct bonding *bond,
1372 				      struct sk_buff *skb)
1373 {
1374 	struct slave *tx_slave = NULL;
1375 	struct ethhdr *eth_data;
1376 	u32 hash_index;
1377 
1378 	skb_reset_mac_header(skb);
1379 	eth_data = eth_hdr(skb);
1380 
1381 	/* Do not TX balance any multicast or broadcast */
1382 	if (!is_multicast_ether_addr(eth_data->h_dest)) {
1383 		switch (skb->protocol) {
1384 		case htons(ETH_P_IPV6):
1385 			if (alb_determine_nd(skb, bond))
1386 				break;
1387 			fallthrough;
1388 		case htons(ETH_P_IP):
1389 			hash_index = bond_xmit_hash(bond, skb);
1390 			if (bond->params.tlb_dynamic_lb) {
1391 				tx_slave = tlb_choose_channel(bond,
1392 							      hash_index & 0xFF,
1393 							      skb->len);
1394 			} else {
1395 				struct bond_up_slave *slaves;
1396 				unsigned int count;
1397 
1398 				slaves = rcu_dereference(bond->usable_slaves);
1399 				count = slaves ? READ_ONCE(slaves->count) : 0;
1400 				if (likely(count))
1401 					tx_slave = slaves->arr[hash_index %
1402 							       count];
1403 			}
1404 			break;
1405 		}
1406 	}
1407 	return tx_slave;
1408 }
1409 
bond_tlb_xmit(struct sk_buff * skb,struct net_device * bond_dev)1410 netdev_tx_t bond_tlb_xmit(struct sk_buff *skb, struct net_device *bond_dev)
1411 {
1412 	struct bonding *bond = netdev_priv(bond_dev);
1413 	struct slave *tx_slave;
1414 
1415 	tx_slave = bond_xmit_tlb_slave_get(bond, skb);
1416 	return bond_do_alb_xmit(skb, bond, tx_slave);
1417 }
1418 
bond_xmit_alb_slave_get(struct bonding * bond,struct sk_buff * skb)1419 struct slave *bond_xmit_alb_slave_get(struct bonding *bond,
1420 				      struct sk_buff *skb)
1421 {
1422 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1423 	static const __be32 ip_bcast = htonl(0xffffffff);
1424 	struct slave *tx_slave = NULL;
1425 	const u8 *hash_start = NULL;
1426 	bool do_tx_balance = true;
1427 	struct ethhdr *eth_data;
1428 	u32 hash_index = 0;
1429 	int hash_size = 0;
1430 
1431 	skb_reset_mac_header(skb);
1432 	eth_data = eth_hdr(skb);
1433 
1434 	switch (ntohs(skb->protocol)) {
1435 	case ETH_P_IP: {
1436 		const struct iphdr *iph;
1437 
1438 		if (is_broadcast_ether_addr(eth_data->h_dest) ||
1439 		    !pskb_network_may_pull(skb, sizeof(*iph))) {
1440 			do_tx_balance = false;
1441 			break;
1442 		}
1443 		iph = ip_hdr(skb);
1444 		if (iph->daddr == ip_bcast || iph->protocol == IPPROTO_IGMP) {
1445 			do_tx_balance = false;
1446 			break;
1447 		}
1448 		hash_start = (char *)&(iph->daddr);
1449 		hash_size = sizeof(iph->daddr);
1450 		break;
1451 	}
1452 	case ETH_P_IPV6: {
1453 		const struct ipv6hdr *ip6hdr;
1454 
1455 		/* IPv6 doesn't really use broadcast mac address, but leave
1456 		 * that here just in case.
1457 		 */
1458 		if (is_broadcast_ether_addr(eth_data->h_dest)) {
1459 			do_tx_balance = false;
1460 			break;
1461 		}
1462 
1463 		/* IPv6 uses all-nodes multicast as an equivalent to
1464 		 * broadcasts in IPv4.
1465 		 */
1466 		if (ether_addr_equal_64bits(eth_data->h_dest, mac_v6_allmcast)) {
1467 			do_tx_balance = false;
1468 			break;
1469 		}
1470 
1471 		if (alb_determine_nd(skb, bond)) {
1472 			do_tx_balance = false;
1473 			break;
1474 		}
1475 
1476 		/* The IPv6 header is pulled by alb_determine_nd */
1477 		/* Additionally, DAD probes should not be tx-balanced as that
1478 		 * will lead to false positives for duplicate addresses and
1479 		 * prevent address configuration from working.
1480 		 */
1481 		ip6hdr = ipv6_hdr(skb);
1482 		if (ipv6_addr_any(&ip6hdr->saddr)) {
1483 			do_tx_balance = false;
1484 			break;
1485 		}
1486 
1487 		hash_start = (char *)&ip6hdr->daddr;
1488 		hash_size = sizeof(ip6hdr->daddr);
1489 		break;
1490 	}
1491 	case ETH_P_ARP:
1492 		do_tx_balance = false;
1493 		if (bond_info->rlb_enabled)
1494 			tx_slave = rlb_arp_xmit(skb, bond);
1495 		break;
1496 	default:
1497 		do_tx_balance = false;
1498 		break;
1499 	}
1500 
1501 	if (do_tx_balance) {
1502 		if (bond->params.tlb_dynamic_lb) {
1503 			hash_index = _simple_hash(hash_start, hash_size);
1504 			tx_slave = tlb_choose_channel(bond, hash_index, skb->len);
1505 		} else {
1506 			/*
1507 			 * do_tx_balance means we are free to select the tx_slave
1508 			 * So we do exactly what tlb would do for hash selection
1509 			 */
1510 
1511 			struct bond_up_slave *slaves;
1512 			unsigned int count;
1513 
1514 			slaves = rcu_dereference(bond->usable_slaves);
1515 			count = slaves ? READ_ONCE(slaves->count) : 0;
1516 			if (likely(count))
1517 				tx_slave = slaves->arr[bond_xmit_hash(bond, skb) %
1518 						       count];
1519 		}
1520 	}
1521 	return tx_slave;
1522 }
1523 
bond_alb_xmit(struct sk_buff * skb,struct net_device * bond_dev)1524 netdev_tx_t bond_alb_xmit(struct sk_buff *skb, struct net_device *bond_dev)
1525 {
1526 	struct bonding *bond = netdev_priv(bond_dev);
1527 	struct slave *tx_slave = NULL;
1528 
1529 	tx_slave = bond_xmit_alb_slave_get(bond, skb);
1530 	return bond_do_alb_xmit(skb, bond, tx_slave);
1531 }
1532 
bond_alb_monitor(struct work_struct * work)1533 void bond_alb_monitor(struct work_struct *work)
1534 {
1535 	struct bonding *bond = container_of(work, struct bonding,
1536 					    alb_work.work);
1537 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1538 	struct list_head *iter;
1539 	struct slave *slave;
1540 
1541 	if (!bond_has_slaves(bond)) {
1542 		atomic_set(&bond_info->tx_rebalance_counter, 0);
1543 		bond_info->lp_counter = 0;
1544 		goto re_arm;
1545 	}
1546 
1547 	rcu_read_lock();
1548 
1549 	atomic_inc(&bond_info->tx_rebalance_counter);
1550 	bond_info->lp_counter++;
1551 
1552 	/* send learning packets */
1553 	if (bond_info->lp_counter >= BOND_ALB_LP_TICKS(bond)) {
1554 		bool strict_match;
1555 
1556 		bond_for_each_slave_rcu(bond, slave, iter) {
1557 			/* If updating current_active, use all currently
1558 			 * user mac addresses (!strict_match).  Otherwise, only
1559 			 * use mac of the slave device.
1560 			 * In RLB mode, we always use strict matches.
1561 			 */
1562 			strict_match = (slave != rcu_access_pointer(bond->curr_active_slave) ||
1563 					bond_info->rlb_enabled);
1564 			alb_send_learning_packets(slave, slave->dev->dev_addr,
1565 						  strict_match);
1566 		}
1567 		bond_info->lp_counter = 0;
1568 	}
1569 
1570 	/* rebalance tx traffic */
1571 	if (atomic_read(&bond_info->tx_rebalance_counter) >= BOND_TLB_REBALANCE_TICKS) {
1572 		bond_for_each_slave_rcu(bond, slave, iter) {
1573 			tlb_clear_slave(bond, slave, 1);
1574 			if (slave == rcu_access_pointer(bond->curr_active_slave)) {
1575 				SLAVE_TLB_INFO(slave).load =
1576 					bond_info->unbalanced_load /
1577 						BOND_TLB_REBALANCE_INTERVAL;
1578 				bond_info->unbalanced_load = 0;
1579 			}
1580 		}
1581 		atomic_set(&bond_info->tx_rebalance_counter, 0);
1582 	}
1583 
1584 	if (bond_info->rlb_enabled) {
1585 		if (bond_info->primary_is_promisc &&
1586 		    (++bond_info->rlb_promisc_timeout_counter >= RLB_PROMISC_TIMEOUT)) {
1587 
1588 			/* dev_set_promiscuity requires rtnl and
1589 			 * nothing else.  Avoid race with bond_close.
1590 			 */
1591 			rcu_read_unlock();
1592 			if (!rtnl_trylock())
1593 				goto re_arm;
1594 
1595 			bond_info->rlb_promisc_timeout_counter = 0;
1596 
1597 			/* If the primary was set to promiscuous mode
1598 			 * because a slave was disabled then
1599 			 * it can now leave promiscuous mode.
1600 			 */
1601 			dev_set_promiscuity(rtnl_dereference(bond->curr_active_slave)->dev,
1602 					    -1);
1603 			bond_info->primary_is_promisc = 0;
1604 
1605 			rtnl_unlock();
1606 			rcu_read_lock();
1607 		}
1608 
1609 		if (bond_info->rlb_rebalance) {
1610 			bond_info->rlb_rebalance = 0;
1611 			rlb_rebalance(bond);
1612 		}
1613 
1614 		/* check if clients need updating */
1615 		if (bond_info->rx_ntt) {
1616 			if (bond_info->rlb_update_delay_counter) {
1617 				--bond_info->rlb_update_delay_counter;
1618 			} else {
1619 				rlb_update_rx_clients(bond);
1620 				if (bond_info->rlb_update_retry_counter)
1621 					--bond_info->rlb_update_retry_counter;
1622 				else
1623 					bond_info->rx_ntt = 0;
1624 			}
1625 		}
1626 	}
1627 	rcu_read_unlock();
1628 re_arm:
1629 	queue_delayed_work(bond->wq, &bond->alb_work, alb_delta_in_ticks);
1630 }
1631 
1632 /* assumption: called before the slave is attached to the bond
1633  * and not locked by the bond lock
1634  */
bond_alb_init_slave(struct bonding * bond,struct slave * slave)1635 int bond_alb_init_slave(struct bonding *bond, struct slave *slave)
1636 {
1637 	int res;
1638 
1639 	res = alb_set_slave_mac_addr(slave, slave->perm_hwaddr,
1640 				     slave->dev->addr_len);
1641 	if (res)
1642 		return res;
1643 
1644 	res = alb_handle_addr_collision_on_attach(bond, slave);
1645 	if (res)
1646 		return res;
1647 
1648 	tlb_init_slave(slave);
1649 
1650 	/* order a rebalance ASAP */
1651 	atomic_set(&bond->alb_info.tx_rebalance_counter,
1652 		   BOND_TLB_REBALANCE_TICKS);
1653 
1654 	if (bond->alb_info.rlb_enabled)
1655 		bond->alb_info.rlb_rebalance = 1;
1656 
1657 	return 0;
1658 }
1659 
1660 /* Remove slave from tlb and rlb hash tables, and fix up MAC addresses
1661  * if necessary.
1662  *
1663  * Caller must hold RTNL and no other locks
1664  */
bond_alb_deinit_slave(struct bonding * bond,struct slave * slave)1665 void bond_alb_deinit_slave(struct bonding *bond, struct slave *slave)
1666 {
1667 	if (bond_has_slaves(bond))
1668 		alb_change_hw_addr_on_detach(bond, slave);
1669 
1670 	tlb_clear_slave(bond, slave, 0);
1671 
1672 	if (bond->alb_info.rlb_enabled) {
1673 		bond->alb_info.rx_slave = NULL;
1674 		rlb_clear_slave(bond, slave);
1675 	}
1676 
1677 }
1678 
bond_alb_handle_link_change(struct bonding * bond,struct slave * slave,char link)1679 void bond_alb_handle_link_change(struct bonding *bond, struct slave *slave, char link)
1680 {
1681 	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1682 
1683 	if (link == BOND_LINK_DOWN) {
1684 		tlb_clear_slave(bond, slave, 0);
1685 		if (bond->alb_info.rlb_enabled)
1686 			rlb_clear_slave(bond, slave);
1687 	} else if (link == BOND_LINK_UP) {
1688 		/* order a rebalance ASAP */
1689 		atomic_set(&bond_info->tx_rebalance_counter,
1690 			   BOND_TLB_REBALANCE_TICKS);
1691 		if (bond->alb_info.rlb_enabled) {
1692 			bond->alb_info.rlb_rebalance = 1;
1693 			/* If the updelay module parameter is smaller than the
1694 			 * forwarding delay of the switch the rebalance will
1695 			 * not work because the rebalance arp replies will
1696 			 * not be forwarded to the clients..
1697 			 */
1698 		}
1699 	}
1700 
1701 	if (bond_is_nondyn_tlb(bond)) {
1702 		if (bond_update_slave_arr(bond, NULL))
1703 			pr_err("Failed to build slave-array for TLB mode.\n");
1704 	}
1705 }
1706 
1707 /**
1708  * bond_alb_handle_active_change - assign new curr_active_slave
1709  * @bond: our bonding struct
1710  * @new_slave: new slave to assign
1711  *
1712  * Set the bond->curr_active_slave to @new_slave and handle
1713  * mac address swapping and promiscuity changes as needed.
1714  *
1715  * Caller must hold RTNL
1716  */
bond_alb_handle_active_change(struct bonding * bond,struct slave * new_slave)1717 void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave)
1718 {
1719 	struct slave *swap_slave;
1720 	struct slave *curr_active;
1721 
1722 	curr_active = rtnl_dereference(bond->curr_active_slave);
1723 	if (curr_active == new_slave)
1724 		return;
1725 
1726 	if (curr_active && bond->alb_info.primary_is_promisc) {
1727 		dev_set_promiscuity(curr_active->dev, -1);
1728 		bond->alb_info.primary_is_promisc = 0;
1729 		bond->alb_info.rlb_promisc_timeout_counter = 0;
1730 	}
1731 
1732 	swap_slave = curr_active;
1733 	rcu_assign_pointer(bond->curr_active_slave, new_slave);
1734 
1735 	if (!new_slave || !bond_has_slaves(bond))
1736 		return;
1737 
1738 	/* set the new curr_active_slave to the bonds mac address
1739 	 * i.e. swap mac addresses of old curr_active_slave and new curr_active_slave
1740 	 */
1741 	if (!swap_slave)
1742 		swap_slave = bond_slave_has_mac(bond, bond->dev->dev_addr);
1743 
1744 	/* Arrange for swap_slave and new_slave to temporarily be
1745 	 * ignored so we can mess with their MAC addresses without
1746 	 * fear of interference from transmit activity.
1747 	 */
1748 	if (swap_slave)
1749 		tlb_clear_slave(bond, swap_slave, 1);
1750 	tlb_clear_slave(bond, new_slave, 1);
1751 
1752 	/* in TLB mode, the slave might flip down/up with the old dev_addr,
1753 	 * and thus filter bond->dev_addr's packets, so force bond's mac
1754 	 */
1755 	if (BOND_MODE(bond) == BOND_MODE_TLB) {
1756 		struct sockaddr_storage ss;
1757 		u8 tmp_addr[MAX_ADDR_LEN];
1758 
1759 		bond_hw_addr_copy(tmp_addr, new_slave->dev->dev_addr,
1760 				  new_slave->dev->addr_len);
1761 
1762 		bond_hw_addr_copy(ss.__data, bond->dev->dev_addr,
1763 				  bond->dev->addr_len);
1764 		ss.ss_family = bond->dev->type;
1765 		/* we don't care if it can't change its mac, best effort */
1766 		dev_set_mac_address(new_slave->dev, (struct sockaddr *)&ss,
1767 				    NULL);
1768 
1769 		dev_addr_set(new_slave->dev, tmp_addr);
1770 	}
1771 
1772 	/* curr_active_slave must be set before calling alb_swap_mac_addr */
1773 	if (swap_slave) {
1774 		/* swap mac address */
1775 		alb_swap_mac_addr(swap_slave, new_slave);
1776 		alb_fasten_mac_swap(bond, swap_slave, new_slave);
1777 	} else {
1778 		/* set the new_slave to the bond mac address */
1779 		alb_set_slave_mac_addr(new_slave, bond->dev->dev_addr,
1780 				       bond->dev->addr_len);
1781 		alb_send_learning_packets(new_slave, bond->dev->dev_addr,
1782 					  false);
1783 	}
1784 }
1785 
1786 /* Called with RTNL */
bond_alb_set_mac_address(struct net_device * bond_dev,void * addr)1787 int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
1788 {
1789 	struct bonding *bond = netdev_priv(bond_dev);
1790 	struct sockaddr_storage *ss = addr;
1791 	struct slave *curr_active;
1792 	struct slave *swap_slave;
1793 	int res;
1794 
1795 	if (!is_valid_ether_addr(ss->__data))
1796 		return -EADDRNOTAVAIL;
1797 
1798 	res = alb_set_mac_address(bond, addr);
1799 	if (res)
1800 		return res;
1801 
1802 	dev_addr_set(bond_dev, ss->__data);
1803 
1804 	/* If there is no curr_active_slave there is nothing else to do.
1805 	 * Otherwise we'll need to pass the new address to it and handle
1806 	 * duplications.
1807 	 */
1808 	curr_active = rtnl_dereference(bond->curr_active_slave);
1809 	if (!curr_active)
1810 		return 0;
1811 
1812 	swap_slave = bond_slave_has_mac(bond, bond_dev->dev_addr);
1813 
1814 	if (swap_slave) {
1815 		alb_swap_mac_addr(swap_slave, curr_active);
1816 		alb_fasten_mac_swap(bond, swap_slave, curr_active);
1817 	} else {
1818 		alb_set_slave_mac_addr(curr_active, bond_dev->dev_addr,
1819 				       bond_dev->addr_len);
1820 
1821 		alb_send_learning_packets(curr_active,
1822 					  bond_dev->dev_addr, false);
1823 		if (bond->alb_info.rlb_enabled) {
1824 			/* inform clients mac address has changed */
1825 			rlb_req_update_slave_clients(bond, curr_active);
1826 		}
1827 	}
1828 
1829 	return 0;
1830 }
1831 
bond_alb_clear_vlan(struct bonding * bond,unsigned short vlan_id)1832 void bond_alb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
1833 {
1834 	if (bond->alb_info.rlb_enabled)
1835 		rlb_clear_vlan(bond, vlan_id);
1836 }
1837 
1838