Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
bond_alb.c
Go to the documentation of this file.
1 /*
2  * Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License as published by the
6  * Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12  * for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17  *
18  * The full GNU General Public License is included in this distribution in the
19  * file called LICENSE.
20  *
21  */
22 
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 
25 #include <linux/skbuff.h>
26 #include <linux/netdevice.h>
27 #include <linux/etherdevice.h>
28 #include <linux/pkt_sched.h>
29 #include <linux/spinlock.h>
30 #include <linux/slab.h>
31 #include <linux/timer.h>
32 #include <linux/ip.h>
33 #include <linux/ipv6.h>
34 #include <linux/if_arp.h>
35 #include <linux/if_ether.h>
36 #include <linux/if_bonding.h>
37 #include <linux/if_vlan.h>
38 #include <linux/in.h>
39 #include <net/ipx.h>
40 #include <net/arp.h>
41 #include <net/ipv6.h>
42 #include <asm/byteorder.h>
43 #include "bonding.h"
44 #include "bond_alb.h"
45 
46 
47 
48 #ifndef __long_aligned
49 #define __long_aligned __attribute__((aligned((sizeof(long)))))
50 #endif
51 static const u8 mac_bcast[ETH_ALEN] __long_aligned = {
52  0xff, 0xff, 0xff, 0xff, 0xff, 0xff
53 };
54 static const u8 mac_v6_allmcast[ETH_ALEN] __long_aligned = {
55  0x33, 0x33, 0x00, 0x00, 0x00, 0x01
56 };
57 static const int alb_delta_in_ticks = HZ / ALB_TIMER_TICKS_PER_SEC;
58 
59 #pragma pack(1)
60 struct learning_pkt {
65 };
66 
67 struct arp_pkt {
73  u8 mac_src[ETH_ALEN]; /* sender hardware address */
74  __be32 ip_src; /* sender IP address */
75  u8 mac_dst[ETH_ALEN]; /* target hardware address */
76  __be32 ip_dst; /* target IP address */
77 };
78 #pragma pack()
79 
80 static inline struct arp_pkt *arp_pkt(const struct sk_buff *skb)
81 {
82  return (struct arp_pkt *)skb_network_header(skb);
83 }
84 
85 /* Forward declaration */
86 static void alb_send_learning_packets(struct slave *slave, u8 mac_addr[]);
87 
88 static inline u8 _simple_hash(const u8 *hash_start, int hash_size)
89 {
90  int i;
91  u8 hash = 0;
92 
93  for (i = 0; i < hash_size; i++) {
94  hash ^= hash_start[i];
95  }
96 
97  return hash;
98 }
99 
100 /*********************** tlb specific functions ***************************/
101 
102 static inline void _lock_tx_hashtbl_bh(struct bonding *bond)
103 {
104  spin_lock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
105 }
106 
107 static inline void _unlock_tx_hashtbl_bh(struct bonding *bond)
108 {
109  spin_unlock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
110 }
111 
112 static inline void _lock_tx_hashtbl(struct bonding *bond)
113 {
114  spin_lock(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
115 }
116 
117 static inline void _unlock_tx_hashtbl(struct bonding *bond)
118 {
119  spin_unlock(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
120 }
121 
122 /* Caller must hold tx_hashtbl lock */
123 static inline void tlb_init_table_entry(struct tlb_client_info *entry, int save_load)
124 {
125  if (save_load) {
126  entry->load_history = 1 + entry->tx_bytes /
128  entry->tx_bytes = 0;
129  }
130 
131  entry->tx_slave = NULL;
132  entry->next = TLB_NULL_INDEX;
133  entry->prev = TLB_NULL_INDEX;
134 }
135 
136 static inline void tlb_init_slave(struct slave *slave)
137 {
138  SLAVE_TLB_INFO(slave).load = 0;
139  SLAVE_TLB_INFO(slave).head = TLB_NULL_INDEX;
140 }
141 
142 /* Caller must hold bond lock for read, BH disabled */
143 static void __tlb_clear_slave(struct bonding *bond, struct slave *slave,
144  int save_load)
145 {
146  struct tlb_client_info *tx_hash_table;
147  u32 index;
148 
149  /* clear slave from tx_hashtbl */
150  tx_hash_table = BOND_ALB_INFO(bond).tx_hashtbl;
151 
152  /* skip this if we've already freed the tx hash table */
153  if (tx_hash_table) {
154  index = SLAVE_TLB_INFO(slave).head;
155  while (index != TLB_NULL_INDEX) {
156  u32 next_index = tx_hash_table[index].next;
157  tlb_init_table_entry(&tx_hash_table[index], save_load);
158  index = next_index;
159  }
160  }
161 
162  tlb_init_slave(slave);
163 }
164 
165 /* Caller must hold bond lock for read */
166 static void tlb_clear_slave(struct bonding *bond, struct slave *slave,
167  int save_load)
168 {
169  _lock_tx_hashtbl_bh(bond);
170  __tlb_clear_slave(bond, slave, save_load);
171  _unlock_tx_hashtbl_bh(bond);
172 }
173 
174 /* Must be called before starting the monitor timer */
175 static int tlb_initialize(struct bonding *bond)
176 {
177  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
178  int size = TLB_HASH_TABLE_SIZE * sizeof(struct tlb_client_info);
179  struct tlb_client_info *new_hashtbl;
180  int i;
181 
182  new_hashtbl = kzalloc(size, GFP_KERNEL);
183  if (!new_hashtbl)
184  return -1;
185 
186  _lock_tx_hashtbl_bh(bond);
187 
188  bond_info->tx_hashtbl = new_hashtbl;
189 
190  for (i = 0; i < TLB_HASH_TABLE_SIZE; i++) {
191  tlb_init_table_entry(&bond_info->tx_hashtbl[i], 0);
192  }
193 
194  _unlock_tx_hashtbl_bh(bond);
195 
196  return 0;
197 }
198 
199 /* Must be called only after all slaves have been released */
200 static void tlb_deinitialize(struct bonding *bond)
201 {
202  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
203 
204  _lock_tx_hashtbl_bh(bond);
205 
206  kfree(bond_info->tx_hashtbl);
207  bond_info->tx_hashtbl = NULL;
208 
209  _unlock_tx_hashtbl_bh(bond);
210 }
211 
212 static long long compute_gap(struct slave *slave)
213 {
214  return (s64) (slave->speed << 20) - /* Convert to Megabit per sec */
215  (s64) (SLAVE_TLB_INFO(slave).load << 3); /* Bytes to bits */
216 }
217 
218 /* Caller must hold bond lock for read */
219 static struct slave *tlb_get_least_loaded_slave(struct bonding *bond)
220 {
221  struct slave *slave, *least_loaded;
222  long long max_gap;
223  int i;
224 
225  least_loaded = NULL;
226  max_gap = LLONG_MIN;
227 
228  /* Find the slave with the largest gap */
229  bond_for_each_slave(bond, slave, i) {
230  if (SLAVE_IS_OK(slave)) {
231  long long gap = compute_gap(slave);
232 
233  if (max_gap < gap) {
234  least_loaded = slave;
235  max_gap = gap;
236  }
237  }
238  }
239 
240  return least_loaded;
241 }
242 
243 static struct slave *__tlb_choose_channel(struct bonding *bond, u32 hash_index,
244  u32 skb_len)
245 {
246  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
247  struct tlb_client_info *hash_table;
248  struct slave *assigned_slave;
249 
250  hash_table = bond_info->tx_hashtbl;
251  assigned_slave = hash_table[hash_index].tx_slave;
252  if (!assigned_slave) {
253  assigned_slave = tlb_get_least_loaded_slave(bond);
254 
255  if (assigned_slave) {
256  struct tlb_slave_info *slave_info =
257  &(SLAVE_TLB_INFO(assigned_slave));
258  u32 next_index = slave_info->head;
259 
260  hash_table[hash_index].tx_slave = assigned_slave;
261  hash_table[hash_index].next = next_index;
262  hash_table[hash_index].prev = TLB_NULL_INDEX;
263 
264  if (next_index != TLB_NULL_INDEX) {
265  hash_table[next_index].prev = hash_index;
266  }
267 
268  slave_info->head = hash_index;
269  slave_info->load +=
270  hash_table[hash_index].load_history;
271  }
272  }
273 
274  if (assigned_slave) {
275  hash_table[hash_index].tx_bytes += skb_len;
276  }
277 
278  return assigned_slave;
279 }
280 
281 /* Caller must hold bond lock for read */
282 static struct slave *tlb_choose_channel(struct bonding *bond, u32 hash_index,
283  u32 skb_len)
284 {
285  struct slave *tx_slave;
286  /*
287  * We don't need to disable softirq here, becase
288  * tlb_choose_channel() is only called by bond_alb_xmit()
289  * which already has softirq disabled.
290  */
291  _lock_tx_hashtbl(bond);
292  tx_slave = __tlb_choose_channel(bond, hash_index, skb_len);
293  _unlock_tx_hashtbl(bond);
294  return tx_slave;
295 }
296 
297 /*********************** rlb specific functions ***************************/
298 static inline void _lock_rx_hashtbl_bh(struct bonding *bond)
299 {
300  spin_lock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
301 }
302 
303 static inline void _unlock_rx_hashtbl_bh(struct bonding *bond)
304 {
305  spin_unlock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
306 }
307 
308 static inline void _lock_rx_hashtbl(struct bonding *bond)
309 {
310  spin_lock(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
311 }
312 
313 static inline void _unlock_rx_hashtbl(struct bonding *bond)
314 {
315  spin_unlock(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
316 }
317 
318 /* when an ARP REPLY is received from a client update its info
319  * in the rx_hashtbl
320  */
321 static void rlb_update_entry_from_arp(struct bonding *bond, struct arp_pkt *arp)
322 {
323  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
324  struct rlb_client_info *client_info;
325  u32 hash_index;
326 
327  _lock_rx_hashtbl_bh(bond);
328 
329  hash_index = _simple_hash((u8*)&(arp->ip_src), sizeof(arp->ip_src));
330  client_info = &(bond_info->rx_hashtbl[hash_index]);
331 
332  if ((client_info->assigned) &&
333  (client_info->ip_src == arp->ip_dst) &&
334  (client_info->ip_dst == arp->ip_src) &&
335  (!ether_addr_equal_64bits(client_info->mac_dst, arp->mac_src))) {
336  /* update the clients MAC address */
337  memcpy(client_info->mac_dst, arp->mac_src, ETH_ALEN);
338  client_info->ntt = 1;
339  bond_info->rx_ntt = 1;
340  }
341 
342  _unlock_rx_hashtbl_bh(bond);
343 }
344 
345 static int rlb_arp_recv(const struct sk_buff *skb, struct bonding *bond,
346  struct slave *slave)
347 {
348  struct arp_pkt *arp, _arp;
349 
350  if (skb->protocol != cpu_to_be16(ETH_P_ARP))
351  goto out;
352 
353  arp = skb_header_pointer(skb, 0, sizeof(_arp), &_arp);
354  if (!arp)
355  goto out;
356 
357  if (arp->op_code == htons(ARPOP_REPLY)) {
358  /* update rx hash table for this ARP */
359  rlb_update_entry_from_arp(bond, arp);
360  pr_debug("Server received an ARP Reply from client\n");
361  }
362 out:
363  return RX_HANDLER_ANOTHER;
364 }
365 
366 /* Caller must hold bond lock for read */
367 static struct slave *rlb_next_rx_slave(struct bonding *bond)
368 {
369  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
370  struct slave *rx_slave, *slave, *start_at;
371  int i = 0;
372 
373  if (bond_info->next_rx_slave) {
374  start_at = bond_info->next_rx_slave;
375  } else {
376  start_at = bond->first_slave;
377  }
378 
379  rx_slave = NULL;
380 
381  bond_for_each_slave_from(bond, slave, i, start_at) {
382  if (SLAVE_IS_OK(slave)) {
383  if (!rx_slave) {
384  rx_slave = slave;
385  } else if (slave->speed > rx_slave->speed) {
386  rx_slave = slave;
387  }
388  }
389  }
390 
391  if (rx_slave) {
392  bond_info->next_rx_slave = rx_slave->next;
393  }
394 
395  return rx_slave;
396 }
397 
398 /* teach the switch the mac of a disabled slave
399  * on the primary for fault tolerance
400  *
401  * Caller must hold bond->curr_slave_lock for write or bond lock for write
402  */
403 static void rlb_teach_disabled_mac_on_primary(struct bonding *bond, u8 addr[])
404 {
405  if (!bond->curr_active_slave) {
406  return;
407  }
408 
409  if (!bond->alb_info.primary_is_promisc) {
410  if (!dev_set_promiscuity(bond->curr_active_slave->dev, 1))
411  bond->alb_info.primary_is_promisc = 1;
412  else
413  bond->alb_info.primary_is_promisc = 0;
414  }
415 
416  bond->alb_info.rlb_promisc_timeout_counter = 0;
417 
418  alb_send_learning_packets(bond->curr_active_slave, addr);
419 }
420 
421 /* slave being removed should not be active at this point
422  *
423  * Caller must hold bond lock for read
424  */
425 static void rlb_clear_slave(struct bonding *bond, struct slave *slave)
426 {
427  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
428  struct rlb_client_info *rx_hash_table;
429  u32 index, next_index;
430 
431  /* clear slave from rx_hashtbl */
432  _lock_rx_hashtbl_bh(bond);
433 
434  rx_hash_table = bond_info->rx_hashtbl;
435  index = bond_info->rx_hashtbl_head;
436  for (; index != RLB_NULL_INDEX; index = next_index) {
437  next_index = rx_hash_table[index].next;
438  if (rx_hash_table[index].slave == slave) {
439  struct slave *assigned_slave = rlb_next_rx_slave(bond);
440 
441  if (assigned_slave) {
442  rx_hash_table[index].slave = assigned_slave;
443  if (!ether_addr_equal_64bits(rx_hash_table[index].mac_dst,
444  mac_bcast)) {
445  bond_info->rx_hashtbl[index].ntt = 1;
446  bond_info->rx_ntt = 1;
447  /* A slave has been removed from the
448  * table because it is either disabled
449  * or being released. We must retry the
450  * update to avoid clients from not
451  * being updated & disconnecting when
452  * there is stress
453  */
454  bond_info->rlb_update_retry_counter =
456  }
457  } else { /* there is no active slave */
458  rx_hash_table[index].slave = NULL;
459  }
460  }
461  }
462 
463  _unlock_rx_hashtbl_bh(bond);
464 
466 
467  if (slave != bond->curr_active_slave) {
468  rlb_teach_disabled_mac_on_primary(bond, slave->dev->dev_addr);
469  }
470 
472 }
473 
474 static void rlb_update_client(struct rlb_client_info *client_info)
475 {
476  int i;
477 
478  if (!client_info->slave) {
479  return;
480  }
481 
482  for (i = 0; i < RLB_ARP_BURST_SIZE; i++) {
483  struct sk_buff *skb;
484 
486  client_info->ip_dst,
487  client_info->slave->dev,
488  client_info->ip_src,
489  client_info->mac_dst,
490  client_info->slave->dev->dev_addr,
491  client_info->mac_dst);
492  if (!skb) {
493  pr_err("%s: Error: failed to create an ARP packet\n",
494  client_info->slave->dev->master->name);
495  continue;
496  }
497 
498  skb->dev = client_info->slave->dev;
499 
500  if (client_info->tag) {
501  skb = vlan_put_tag(skb, client_info->vlan_id);
502  if (!skb) {
503  pr_err("%s: Error: failed to insert VLAN tag\n",
504  client_info->slave->dev->master->name);
505  continue;
506  }
507  }
508 
509  arp_xmit(skb);
510  }
511 }
512 
513 /* sends ARP REPLIES that update the clients that need updating */
514 static void rlb_update_rx_clients(struct bonding *bond)
515 {
516  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
517  struct rlb_client_info *client_info;
518  u32 hash_index;
519 
520  _lock_rx_hashtbl_bh(bond);
521 
522  hash_index = bond_info->rx_hashtbl_head;
523  for (; hash_index != RLB_NULL_INDEX; hash_index = client_info->next) {
524  client_info = &(bond_info->rx_hashtbl[hash_index]);
525  if (client_info->ntt) {
526  rlb_update_client(client_info);
527  if (bond_info->rlb_update_retry_counter == 0) {
528  client_info->ntt = 0;
529  }
530  }
531  }
532 
533  /* do not update the entries again until this counter is zero so that
534  * not to confuse the clients.
535  */
537 
538  _unlock_rx_hashtbl_bh(bond);
539 }
540 
541 /* The slave was assigned a new mac address - update the clients */
542 static void rlb_req_update_slave_clients(struct bonding *bond, struct slave *slave)
543 {
544  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
545  struct rlb_client_info *client_info;
546  int ntt = 0;
547  u32 hash_index;
548 
549  _lock_rx_hashtbl_bh(bond);
550 
551  hash_index = bond_info->rx_hashtbl_head;
552  for (; hash_index != RLB_NULL_INDEX; hash_index = client_info->next) {
553  client_info = &(bond_info->rx_hashtbl[hash_index]);
554 
555  if ((client_info->slave == slave) &&
556  !ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) {
557  client_info->ntt = 1;
558  ntt = 1;
559  }
560  }
561 
562  // update the team's flag only after the whole iteration
563  if (ntt) {
564  bond_info->rx_ntt = 1;
565  //fasten the change
567  }
568 
569  _unlock_rx_hashtbl_bh(bond);
570 }
571 
572 /* mark all clients using src_ip to be updated */
573 static void rlb_req_update_subnet_clients(struct bonding *bond, __be32 src_ip)
574 {
575  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
576  struct rlb_client_info *client_info;
577  u32 hash_index;
578 
579  _lock_rx_hashtbl(bond);
580 
581  hash_index = bond_info->rx_hashtbl_head;
582  for (; hash_index != RLB_NULL_INDEX; hash_index = client_info->next) {
583  client_info = &(bond_info->rx_hashtbl[hash_index]);
584 
585  if (!client_info->slave) {
586  pr_err("%s: Error: found a client with no channel in the client's hash table\n",
587  bond->dev->name);
588  continue;
589  }
590  /*update all clients using this src_ip, that are not assigned
591  * to the team's address (curr_active_slave) and have a known
592  * unicast mac address.
593  */
594  if ((client_info->ip_src == src_ip) &&
595  !ether_addr_equal_64bits(client_info->slave->dev->dev_addr,
596  bond->dev->dev_addr) &&
597  !ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) {
598  client_info->ntt = 1;
599  bond_info->rx_ntt = 1;
600  }
601  }
602 
603  _unlock_rx_hashtbl(bond);
604 }
605 
606 /* Caller must hold both bond and ptr locks for read */
607 static struct slave *rlb_choose_channel(struct sk_buff *skb, struct bonding *bond)
608 {
609  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
610  struct arp_pkt *arp = arp_pkt(skb);
611  struct slave *assigned_slave;
612  struct rlb_client_info *client_info;
613  u32 hash_index = 0;
614 
615  _lock_rx_hashtbl(bond);
616 
617  hash_index = _simple_hash((u8 *)&arp->ip_dst, sizeof(arp->ip_dst));
618  client_info = &(bond_info->rx_hashtbl[hash_index]);
619 
620  if (client_info->assigned) {
621  if ((client_info->ip_src == arp->ip_src) &&
622  (client_info->ip_dst == arp->ip_dst)) {
623  /* the entry is already assigned to this client */
624  if (!ether_addr_equal_64bits(arp->mac_dst, mac_bcast)) {
625  /* update mac address from arp */
626  memcpy(client_info->mac_dst, arp->mac_dst, ETH_ALEN);
627  }
628 
629  assigned_slave = client_info->slave;
630  if (assigned_slave) {
631  _unlock_rx_hashtbl(bond);
632  return assigned_slave;
633  }
634  } else {
635  /* the entry is already assigned to some other client,
636  * move the old client to primary (curr_active_slave) so
637  * that the new client can be assigned to this entry.
638  */
639  if (bond->curr_active_slave &&
640  client_info->slave != bond->curr_active_slave) {
641  client_info->slave = bond->curr_active_slave;
642  rlb_update_client(client_info);
643  }
644  }
645  }
646  /* assign a new slave */
647  assigned_slave = rlb_next_rx_slave(bond);
648 
649  if (assigned_slave) {
650  client_info->ip_src = arp->ip_src;
651  client_info->ip_dst = arp->ip_dst;
652  /* arp->mac_dst is broadcast for arp reqeusts.
653  * will be updated with clients actual unicast mac address
654  * upon receiving an arp reply.
655  */
656  memcpy(client_info->mac_dst, arp->mac_dst, ETH_ALEN);
657  client_info->slave = assigned_slave;
658 
659  if (!ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) {
660  client_info->ntt = 1;
661  bond->alb_info.rx_ntt = 1;
662  } else {
663  client_info->ntt = 0;
664  }
665 
666  if (bond_vlan_used(bond)) {
667  if (!vlan_get_tag(skb, &client_info->vlan_id))
668  client_info->tag = 1;
669  }
670 
671  if (!client_info->assigned) {
672  u32 prev_tbl_head = bond_info->rx_hashtbl_head;
673  bond_info->rx_hashtbl_head = hash_index;
674  client_info->next = prev_tbl_head;
675  if (prev_tbl_head != RLB_NULL_INDEX) {
676  bond_info->rx_hashtbl[prev_tbl_head].prev =
677  hash_index;
678  }
679  client_info->assigned = 1;
680  }
681  }
682 
683  _unlock_rx_hashtbl(bond);
684 
685  return assigned_slave;
686 }
687 
688 /* chooses (and returns) transmit channel for arp reply
689  * does not choose channel for other arp types since they are
690  * sent on the curr_active_slave
691  */
692 static struct slave *rlb_arp_xmit(struct sk_buff *skb, struct bonding *bond)
693 {
694  struct arp_pkt *arp = arp_pkt(skb);
695  struct slave *tx_slave = NULL;
696 
697  if (arp->op_code == htons(ARPOP_REPLY)) {
698  /* the arp must be sent on the selected
699  * rx channel
700  */
701  tx_slave = rlb_choose_channel(skb, bond);
702  if (tx_slave) {
703  memcpy(arp->mac_src,tx_slave->dev->dev_addr, ETH_ALEN);
704  }
705  pr_debug("Server sent ARP Reply packet\n");
706  } else if (arp->op_code == htons(ARPOP_REQUEST)) {
707  /* Create an entry in the rx_hashtbl for this client as a
708  * place holder.
709  * When the arp reply is received the entry will be updated
710  * with the correct unicast address of the client.
711  */
712  rlb_choose_channel(skb, bond);
713 
714  /* The ARP reply packets must be delayed so that
715  * they can cancel out the influence of the ARP request.
716  */
717  bond->alb_info.rlb_update_delay_counter = RLB_UPDATE_DELAY;
718 
719  /* arp requests are broadcast and are sent on the primary
720  * the arp request will collapse all clients on the subnet to
721  * the primary slave. We must register these clients to be
722  * updated with their assigned mac.
723  */
724  rlb_req_update_subnet_clients(bond, arp->ip_src);
725  pr_debug("Server sent ARP Request packet\n");
726  }
727 
728  return tx_slave;
729 }
730 
731 /* Caller must hold bond lock for read */
732 static void rlb_rebalance(struct bonding *bond)
733 {
734  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
735  struct slave *assigned_slave;
736  struct rlb_client_info *client_info;
737  int ntt;
738  u32 hash_index;
739 
740  _lock_rx_hashtbl_bh(bond);
741 
742  ntt = 0;
743  hash_index = bond_info->rx_hashtbl_head;
744  for (; hash_index != RLB_NULL_INDEX; hash_index = client_info->next) {
745  client_info = &(bond_info->rx_hashtbl[hash_index]);
746  assigned_slave = rlb_next_rx_slave(bond);
747  if (assigned_slave && (client_info->slave != assigned_slave)) {
748  client_info->slave = assigned_slave;
749  client_info->ntt = 1;
750  ntt = 1;
751  }
752  }
753 
754  /* update the team's flag only after the whole iteration */
755  if (ntt) {
756  bond_info->rx_ntt = 1;
757  }
758  _unlock_rx_hashtbl_bh(bond);
759 }
760 
761 /* Caller must hold rx_hashtbl lock */
762 static void rlb_init_table_entry(struct rlb_client_info *entry)
763 {
764  memset(entry, 0, sizeof(struct rlb_client_info));
765  entry->next = RLB_NULL_INDEX;
766  entry->prev = RLB_NULL_INDEX;
767 }
768 
769 static int rlb_initialize(struct bonding *bond)
770 {
771  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
772  struct rlb_client_info *new_hashtbl;
773  int size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info);
774  int i;
775 
776  new_hashtbl = kmalloc(size, GFP_KERNEL);
777  if (!new_hashtbl)
778  return -1;
779 
780  _lock_rx_hashtbl_bh(bond);
781 
782  bond_info->rx_hashtbl = new_hashtbl;
783 
784  bond_info->rx_hashtbl_head = RLB_NULL_INDEX;
785 
786  for (i = 0; i < RLB_HASH_TABLE_SIZE; i++) {
787  rlb_init_table_entry(bond_info->rx_hashtbl + i);
788  }
789 
790  _unlock_rx_hashtbl_bh(bond);
791 
792  /* register to receive ARPs */
793  bond->recv_probe = rlb_arp_recv;
794 
795  return 0;
796 }
797 
798 static void rlb_deinitialize(struct bonding *bond)
799 {
800  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
801 
802  _lock_rx_hashtbl_bh(bond);
803 
804  kfree(bond_info->rx_hashtbl);
805  bond_info->rx_hashtbl = NULL;
806  bond_info->rx_hashtbl_head = RLB_NULL_INDEX;
807 
808  _unlock_rx_hashtbl_bh(bond);
809 }
810 
811 static void rlb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
812 {
813  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
814  u32 curr_index;
815 
816  _lock_rx_hashtbl_bh(bond);
817 
818  curr_index = bond_info->rx_hashtbl_head;
819  while (curr_index != RLB_NULL_INDEX) {
820  struct rlb_client_info *curr = &(bond_info->rx_hashtbl[curr_index]);
821  u32 next_index = bond_info->rx_hashtbl[curr_index].next;
822  u32 prev_index = bond_info->rx_hashtbl[curr_index].prev;
823 
824  if (curr->tag && (curr->vlan_id == vlan_id)) {
825  if (curr_index == bond_info->rx_hashtbl_head) {
826  bond_info->rx_hashtbl_head = next_index;
827  }
828  if (prev_index != RLB_NULL_INDEX) {
829  bond_info->rx_hashtbl[prev_index].next = next_index;
830  }
831  if (next_index != RLB_NULL_INDEX) {
832  bond_info->rx_hashtbl[next_index].prev = prev_index;
833  }
834 
835  rlb_init_table_entry(curr);
836  }
837 
838  curr_index = next_index;
839  }
840 
841  _unlock_rx_hashtbl_bh(bond);
842 }
843 
844 /*********************** tlb/rlb shared functions *********************/
845 
846 static void alb_send_learning_packets(struct slave *slave, u8 mac_addr[])
847 {
848  struct bonding *bond = bond_get_bond_by_slave(slave);
849  struct learning_pkt pkt;
850  int size = sizeof(struct learning_pkt);
851  int i;
852 
853  memset(&pkt, 0, size);
854  memcpy(pkt.mac_dst, mac_addr, ETH_ALEN);
855  memcpy(pkt.mac_src, mac_addr, ETH_ALEN);
856  pkt.type = cpu_to_be16(ETH_P_LOOP);
857 
858  for (i = 0; i < MAX_LP_BURST; i++) {
859  struct sk_buff *skb;
860  char *data;
861 
862  skb = dev_alloc_skb(size);
863  if (!skb) {
864  return;
865  }
866 
867  data = skb_put(skb, size);
868  memcpy(data, &pkt, size);
869 
870  skb_reset_mac_header(skb);
871  skb->network_header = skb->mac_header + ETH_HLEN;
872  skb->protocol = pkt.type;
873  skb->priority = TC_PRIO_CONTROL;
874  skb->dev = slave->dev;
875 
876  if (bond_vlan_used(bond)) {
877  struct vlan_entry *vlan;
878 
879  vlan = bond_next_vlan(bond,
880  bond->alb_info.current_alb_vlan);
881 
882  bond->alb_info.current_alb_vlan = vlan;
883  if (!vlan) {
884  kfree_skb(skb);
885  continue;
886  }
887 
888  skb = vlan_put_tag(skb, vlan->vlan_id);
889  if (!skb) {
890  pr_err("%s: Error: failed to insert VLAN tag\n",
891  bond->dev->name);
892  continue;
893  }
894  }
895 
896  dev_queue_xmit(skb);
897  }
898 }
899 
900 static int alb_set_slave_mac_addr(struct slave *slave, u8 addr[])
901 {
902  struct net_device *dev = slave->dev;
903  struct sockaddr s_addr;
904 
905  if (slave->bond->params.mode == BOND_MODE_TLB) {
906  memcpy(dev->dev_addr, addr, dev->addr_len);
907  return 0;
908  }
909 
910  /* for rlb each slave must have a unique hw mac addresses so that */
911  /* each slave will receive packets destined to a different mac */
912  memcpy(s_addr.sa_data, addr, dev->addr_len);
913  s_addr.sa_family = dev->type;
914  if (dev_set_mac_address(dev, &s_addr)) {
915  pr_err("%s: Error: dev_set_mac_address of dev %s failed!\n"
916  "ALB mode requires that the base driver support setting the hw address also when the network device's interface is open\n",
917  dev->master->name, dev->name);
918  return -EOPNOTSUPP;
919  }
920  return 0;
921 }
922 
923 /*
924  * Swap MAC addresses between two slaves.
925  *
926  * Called with RTNL held, and no other locks.
927  *
928  */
929 
930 static void alb_swap_mac_addr(struct bonding *bond, struct slave *slave1, struct slave *slave2)
931 {
932  u8 tmp_mac_addr[ETH_ALEN];
933 
934  memcpy(tmp_mac_addr, slave1->dev->dev_addr, ETH_ALEN);
935  alb_set_slave_mac_addr(slave1, slave2->dev->dev_addr);
936  alb_set_slave_mac_addr(slave2, tmp_mac_addr);
937 
938 }
939 
940 /*
941  * Send learning packets after MAC address swap.
942  *
943  * Called with RTNL and no other locks
944  */
945 static void alb_fasten_mac_swap(struct bonding *bond, struct slave *slave1,
946  struct slave *slave2)
947 {
948  int slaves_state_differ = (SLAVE_IS_OK(slave1) != SLAVE_IS_OK(slave2));
949  struct slave *disabled_slave = NULL;
950 
951  ASSERT_RTNL();
952 
953  /* fasten the change in the switch */
954  if (SLAVE_IS_OK(slave1)) {
955  alb_send_learning_packets(slave1, slave1->dev->dev_addr);
956  if (bond->alb_info.rlb_enabled) {
957  /* inform the clients that the mac address
958  * has changed
959  */
960  rlb_req_update_slave_clients(bond, slave1);
961  }
962  } else {
963  disabled_slave = slave1;
964  }
965 
966  if (SLAVE_IS_OK(slave2)) {
967  alb_send_learning_packets(slave2, slave2->dev->dev_addr);
968  if (bond->alb_info.rlb_enabled) {
969  /* inform the clients that the mac address
970  * has changed
971  */
972  rlb_req_update_slave_clients(bond, slave2);
973  }
974  } else {
975  disabled_slave = slave2;
976  }
977 
978  if (bond->alb_info.rlb_enabled && slaves_state_differ) {
979  /* A disabled slave was assigned an active mac addr */
980  rlb_teach_disabled_mac_on_primary(bond,
981  disabled_slave->dev->dev_addr);
982  }
983 }
984 
999 static void alb_change_hw_addr_on_detach(struct bonding *bond, struct slave *slave)
1000 {
1001  int perm_curr_diff;
1002  int perm_bond_diff;
1003 
1004  perm_curr_diff = !ether_addr_equal_64bits(slave->perm_hwaddr,
1005  slave->dev->dev_addr);
1006  perm_bond_diff = !ether_addr_equal_64bits(slave->perm_hwaddr,
1007  bond->dev->dev_addr);
1008 
1009  if (perm_curr_diff && perm_bond_diff) {
1010  struct slave *tmp_slave;
1011  int i, found = 0;
1012 
1013  bond_for_each_slave(bond, tmp_slave, i) {
1014  if (ether_addr_equal_64bits(slave->perm_hwaddr,
1015  tmp_slave->dev->dev_addr)) {
1016  found = 1;
1017  break;
1018  }
1019  }
1020 
1021  if (found) {
1022  /* locking: needs RTNL and nothing else */
1023  alb_swap_mac_addr(bond, slave, tmp_slave);
1024  alb_fasten_mac_swap(bond, slave, tmp_slave);
1025  }
1026  }
1027 }
1028 
1054 static int alb_handle_addr_collision_on_attach(struct bonding *bond, struct slave *slave)
1055 {
1056  struct slave *tmp_slave1, *tmp_slave2, *free_mac_slave;
1057  struct slave *has_bond_addr = bond->curr_active_slave;
1058  int i, j, found = 0;
1059 
1060  if (bond->slave_cnt == 0) {
1061  /* this is the first slave */
1062  return 0;
1063  }
1064 
1065  /* if slave's mac address differs from bond's mac address
1066  * check uniqueness of slave's mac address against the other
1067  * slaves in the bond.
1068  */
1069  if (!ether_addr_equal_64bits(slave->perm_hwaddr, bond->dev->dev_addr)) {
1070  bond_for_each_slave(bond, tmp_slave1, i) {
1071  if (ether_addr_equal_64bits(tmp_slave1->dev->dev_addr,
1072  slave->dev->dev_addr)) {
1073  found = 1;
1074  break;
1075  }
1076  }
1077 
1078  if (!found)
1079  return 0;
1080 
1081  /* Try setting slave mac to bond address and fall-through
1082  to code handling that situation below... */
1083  alb_set_slave_mac_addr(slave, bond->dev->dev_addr);
1084  }
1085 
1086  /* The slave's address is equal to the address of the bond.
1087  * Search for a spare address in the bond for this slave.
1088  */
1089  free_mac_slave = NULL;
1090 
1091  bond_for_each_slave(bond, tmp_slave1, i) {
1092  found = 0;
1093  bond_for_each_slave(bond, tmp_slave2, j) {
1094  if (ether_addr_equal_64bits(tmp_slave1->perm_hwaddr,
1095  tmp_slave2->dev->dev_addr)) {
1096  found = 1;
1097  break;
1098  }
1099  }
1100 
1101  if (!found) {
1102  /* no slave has tmp_slave1's perm addr
1103  * as its curr addr
1104  */
1105  free_mac_slave = tmp_slave1;
1106  break;
1107  }
1108 
1109  if (!has_bond_addr) {
1110  if (ether_addr_equal_64bits(tmp_slave1->dev->dev_addr,
1111  bond->dev->dev_addr)) {
1112 
1113  has_bond_addr = tmp_slave1;
1114  }
1115  }
1116  }
1117 
1118  if (free_mac_slave) {
1119  alb_set_slave_mac_addr(slave, free_mac_slave->perm_hwaddr);
1120 
1121  pr_warning("%s: Warning: the hw address of slave %s is in use by the bond; giving it the hw address of %s\n",
1122  bond->dev->name, slave->dev->name,
1123  free_mac_slave->dev->name);
1124 
1125  } else if (has_bond_addr) {
1126  pr_err("%s: Error: the hw address of slave %s is in use by the bond; couldn't find a slave with a free hw address to give it (this should not have happened)\n",
1127  bond->dev->name, slave->dev->name);
1128  return -EFAULT;
1129  }
1130 
1131  return 0;
1132 }
1133 
1148 static int alb_set_mac_address(struct bonding *bond, void *addr)
1149 {
1150  struct sockaddr sa;
1151  struct slave *slave, *stop_at;
1152  char tmp_addr[ETH_ALEN];
1153  int res;
1154  int i;
1155 
1156  if (bond->alb_info.rlb_enabled) {
1157  return 0;
1158  }
1159 
1160  bond_for_each_slave(bond, slave, i) {
1161  /* save net_device's current hw address */
1162  memcpy(tmp_addr, slave->dev->dev_addr, ETH_ALEN);
1163 
1164  res = dev_set_mac_address(slave->dev, addr);
1165 
1166  /* restore net_device's hw address */
1167  memcpy(slave->dev->dev_addr, tmp_addr, ETH_ALEN);
1168 
1169  if (res)
1170  goto unwind;
1171  }
1172 
1173  return 0;
1174 
1175 unwind:
1176  memcpy(sa.sa_data, bond->dev->dev_addr, bond->dev->addr_len);
1177  sa.sa_family = bond->dev->type;
1178 
1179  /* unwind from head to the slave that failed */
1180  stop_at = slave;
1181  bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
1182  memcpy(tmp_addr, slave->dev->dev_addr, ETH_ALEN);
1183  dev_set_mac_address(slave->dev, &sa);
1184  memcpy(slave->dev->dev_addr, tmp_addr, ETH_ALEN);
1185  }
1186 
1187  return res;
1188 }
1189 
1190 /************************ exported alb funcions ************************/
1191 
1192 int bond_alb_initialize(struct bonding *bond, int rlb_enabled)
1193 {
1194  int res;
1195 
1196  res = tlb_initialize(bond);
1197  if (res) {
1198  return res;
1199  }
1200 
1201  if (rlb_enabled) {
1202  bond->alb_info.rlb_enabled = 1;
1203  /* initialize rlb */
1204  res = rlb_initialize(bond);
1205  if (res) {
1206  tlb_deinitialize(bond);
1207  return res;
1208  }
1209  } else {
1210  bond->alb_info.rlb_enabled = 0;
1211  }
1212 
1213  return 0;
1214 }
1215 
1216 void bond_alb_deinitialize(struct bonding *bond)
1217 {
1218  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1219 
1220  tlb_deinitialize(bond);
1221 
1222  if (bond_info->rlb_enabled) {
1223  rlb_deinitialize(bond);
1224  }
1225 }
1226 
1227 int bond_alb_xmit(struct sk_buff *skb, struct net_device *bond_dev)
1228 {
1229  struct bonding *bond = netdev_priv(bond_dev);
1230  struct ethhdr *eth_data;
1231  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1232  struct slave *tx_slave = NULL;
1233  static const __be32 ip_bcast = htonl(0xffffffff);
1234  int hash_size = 0;
1235  int do_tx_balance = 1;
1236  u32 hash_index = 0;
1237  const u8 *hash_start = NULL;
1238  int res = 1;
1239  struct ipv6hdr *ip6hdr;
1240 
1241  skb_reset_mac_header(skb);
1242  eth_data = eth_hdr(skb);
1243 
1244  /* make sure that the curr_active_slave do not change during tx
1245  */
1246  read_lock(&bond->curr_slave_lock);
1247 
1248  switch (ntohs(skb->protocol)) {
1249  case ETH_P_IP: {
1250  const struct iphdr *iph = ip_hdr(skb);
1251 
1252  if (ether_addr_equal_64bits(eth_data->h_dest, mac_bcast) ||
1253  (iph->daddr == ip_bcast) ||
1254  (iph->protocol == IPPROTO_IGMP)) {
1255  do_tx_balance = 0;
1256  break;
1257  }
1258  hash_start = (char *)&(iph->daddr);
1259  hash_size = sizeof(iph->daddr);
1260  }
1261  break;
1262  case ETH_P_IPV6:
1263  /* IPv6 doesn't really use broadcast mac address, but leave
1264  * that here just in case.
1265  */
1266  if (ether_addr_equal_64bits(eth_data->h_dest, mac_bcast)) {
1267  do_tx_balance = 0;
1268  break;
1269  }
1270 
1271  /* IPv6 uses all-nodes multicast as an equivalent to
1272  * broadcasts in IPv4.
1273  */
1274  if (ether_addr_equal_64bits(eth_data->h_dest, mac_v6_allmcast)) {
1275  do_tx_balance = 0;
1276  break;
1277  }
1278 
1279  /* Additianally, DAD probes should not be tx-balanced as that
1280  * will lead to false positives for duplicate addresses and
1281  * prevent address configuration from working.
1282  */
1283  ip6hdr = ipv6_hdr(skb);
1284  if (ipv6_addr_any(&ip6hdr->saddr)) {
1285  do_tx_balance = 0;
1286  break;
1287  }
1288 
1289  hash_start = (char *)&(ipv6_hdr(skb)->daddr);
1290  hash_size = sizeof(ipv6_hdr(skb)->daddr);
1291  break;
1292  case ETH_P_IPX:
1293  if (ipx_hdr(skb)->ipx_checksum != IPX_NO_CHECKSUM) {
1294  /* something is wrong with this packet */
1295  do_tx_balance = 0;
1296  break;
1297  }
1298 
1299  if (ipx_hdr(skb)->ipx_type != IPX_TYPE_NCP) {
1300  /* The only protocol worth balancing in
1301  * this family since it has an "ARP" like
1302  * mechanism
1303  */
1304  do_tx_balance = 0;
1305  break;
1306  }
1307 
1308  hash_start = (char*)eth_data->h_dest;
1309  hash_size = ETH_ALEN;
1310  break;
1311  case ETH_P_ARP:
1312  do_tx_balance = 0;
1313  if (bond_info->rlb_enabled) {
1314  tx_slave = rlb_arp_xmit(skb, bond);
1315  }
1316  break;
1317  default:
1318  do_tx_balance = 0;
1319  break;
1320  }
1321 
1322  if (do_tx_balance) {
1323  hash_index = _simple_hash(hash_start, hash_size);
1324  tx_slave = tlb_choose_channel(bond, hash_index, skb->len);
1325  }
1326 
1327  if (!tx_slave) {
1328  /* unbalanced or unassigned, send through primary */
1329  tx_slave = bond->curr_active_slave;
1330  bond_info->unbalanced_load += skb->len;
1331  }
1332 
1333  if (tx_slave && SLAVE_IS_OK(tx_slave)) {
1334  if (tx_slave != bond->curr_active_slave) {
1335  memcpy(eth_data->h_source,
1336  tx_slave->dev->dev_addr,
1337  ETH_ALEN);
1338  }
1339 
1340  res = bond_dev_queue_xmit(bond, skb, tx_slave->dev);
1341  } else {
1342  if (tx_slave) {
1343  _lock_tx_hashtbl(bond);
1344  __tlb_clear_slave(bond, tx_slave, 0);
1345  _unlock_tx_hashtbl(bond);
1346  }
1347  }
1348 
1349  read_unlock(&bond->curr_slave_lock);
1350 
1351  if (res) {
1352  /* no suitable interface, frame not sent */
1353  kfree_skb(skb);
1354  }
1355  return NETDEV_TX_OK;
1356 }
1357 
1359 {
1360  struct bonding *bond = container_of(work, struct bonding,
1361  alb_work.work);
1362  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1363  struct slave *slave;
1364  int i;
1365 
1366  read_lock(&bond->lock);
1367 
1368  if (bond->slave_cnt == 0) {
1369  bond_info->tx_rebalance_counter = 0;
1370  bond_info->lp_counter = 0;
1371  goto re_arm;
1372  }
1373 
1374  bond_info->tx_rebalance_counter++;
1375  bond_info->lp_counter++;
1376 
1377  /* send learning packets */
1378  if (bond_info->lp_counter >= BOND_ALB_LP_TICKS) {
1379  /* change of curr_active_slave involves swapping of mac addresses.
1380  * in order to avoid this swapping from happening while
1381  * sending the learning packets, the curr_slave_lock must be held for
1382  * read.
1383  */
1384  read_lock(&bond->curr_slave_lock);
1385 
1386  bond_for_each_slave(bond, slave, i) {
1387  alb_send_learning_packets(slave, slave->dev->dev_addr);
1388  }
1389 
1390  read_unlock(&bond->curr_slave_lock);
1391 
1392  bond_info->lp_counter = 0;
1393  }
1394 
1395  /* rebalance tx traffic */
1396  if (bond_info->tx_rebalance_counter >= BOND_TLB_REBALANCE_TICKS) {
1397 
1398  read_lock(&bond->curr_slave_lock);
1399 
1400  bond_for_each_slave(bond, slave, i) {
1401  tlb_clear_slave(bond, slave, 1);
1402  if (slave == bond->curr_active_slave) {
1403  SLAVE_TLB_INFO(slave).load =
1404  bond_info->unbalanced_load /
1406  bond_info->unbalanced_load = 0;
1407  }
1408  }
1409 
1410  read_unlock(&bond->curr_slave_lock);
1411 
1412  bond_info->tx_rebalance_counter = 0;
1413  }
1414 
1415  /* handle rlb stuff */
1416  if (bond_info->rlb_enabled) {
1417  if (bond_info->primary_is_promisc &&
1419 
1420  /*
1421  * dev_set_promiscuity requires rtnl and
1422  * nothing else. Avoid race with bond_close.
1423  */
1424  read_unlock(&bond->lock);
1425  if (!rtnl_trylock()) {
1426  read_lock(&bond->lock);
1427  goto re_arm;
1428  }
1429 
1430  bond_info->rlb_promisc_timeout_counter = 0;
1431 
1432  /* If the primary was set to promiscuous mode
1433  * because a slave was disabled then
1434  * it can now leave promiscuous mode.
1435  */
1436  dev_set_promiscuity(bond->curr_active_slave->dev, -1);
1437  bond_info->primary_is_promisc = 0;
1438 
1439  rtnl_unlock();
1440  read_lock(&bond->lock);
1441  }
1442 
1443  if (bond_info->rlb_rebalance) {
1444  bond_info->rlb_rebalance = 0;
1445  rlb_rebalance(bond);
1446  }
1447 
1448  /* check if clients need updating */
1449  if (bond_info->rx_ntt) {
1450  if (bond_info->rlb_update_delay_counter) {
1451  --bond_info->rlb_update_delay_counter;
1452  } else {
1453  rlb_update_rx_clients(bond);
1454  if (bond_info->rlb_update_retry_counter) {
1455  --bond_info->rlb_update_retry_counter;
1456  } else {
1457  bond_info->rx_ntt = 0;
1458  }
1459  }
1460  }
1461  }
1462 
1463 re_arm:
1464  queue_delayed_work(bond->wq, &bond->alb_work, alb_delta_in_ticks);
1465 
1466  read_unlock(&bond->lock);
1467 }
1468 
1469 /* assumption: called before the slave is attached to the bond
1470  * and not locked by the bond lock
1471  */
1472 int bond_alb_init_slave(struct bonding *bond, struct slave *slave)
1473 {
1474  int res;
1475 
1476  res = alb_set_slave_mac_addr(slave, slave->perm_hwaddr);
1477  if (res) {
1478  return res;
1479  }
1480 
1481  /* caller must hold the bond lock for write since the mac addresses
1482  * are compared and may be swapped.
1483  */
1484  read_lock(&bond->lock);
1485 
1486  res = alb_handle_addr_collision_on_attach(bond, slave);
1487 
1488  read_unlock(&bond->lock);
1489 
1490  if (res) {
1491  return res;
1492  }
1493 
1494  tlb_init_slave(slave);
1495 
1496  /* order a rebalance ASAP */
1497  bond->alb_info.tx_rebalance_counter = BOND_TLB_REBALANCE_TICKS;
1498 
1499  if (bond->alb_info.rlb_enabled) {
1500  bond->alb_info.rlb_rebalance = 1;
1501  }
1502 
1503  return 0;
1504 }
1505 
1506 /*
1507  * Remove slave from tlb and rlb hash tables, and fix up MAC addresses
1508  * if necessary.
1509  *
1510  * Caller must hold RTNL and no other locks
1511  */
1512 void bond_alb_deinit_slave(struct bonding *bond, struct slave *slave)
1513 {
1514  if (bond->slave_cnt > 1) {
1515  alb_change_hw_addr_on_detach(bond, slave);
1516  }
1517 
1518  tlb_clear_slave(bond, slave, 0);
1519 
1520  if (bond->alb_info.rlb_enabled) {
1521  bond->alb_info.next_rx_slave = NULL;
1522  rlb_clear_slave(bond, slave);
1523  }
1524 }
1525 
1526 /* Caller must hold bond lock for read */
1527 void bond_alb_handle_link_change(struct bonding *bond, struct slave *slave, char link)
1528 {
1529  struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1530 
1531  if (link == BOND_LINK_DOWN) {
1532  tlb_clear_slave(bond, slave, 0);
1533  if (bond->alb_info.rlb_enabled) {
1534  rlb_clear_slave(bond, slave);
1535  }
1536  } else if (link == BOND_LINK_UP) {
1537  /* order a rebalance ASAP */
1539  if (bond->alb_info.rlb_enabled) {
1540  bond->alb_info.rlb_rebalance = 1;
1541  /* If the updelay module parameter is smaller than the
1542  * forwarding delay of the switch the rebalance will
1543  * not work because the rebalance arp replies will
1544  * not be forwarded to the clients..
1545  */
1546  }
1547  }
1548 }
1549 
1565 void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave)
1566  __releases(&bond->curr_slave_lock)
1567  __releases(&bond->lock)
1568  __acquires(&bond->lock)
1569  __acquires(&bond->curr_slave_lock)
1570 {
1571  struct slave *swap_slave;
1572  int i;
1573 
1574  if (bond->curr_active_slave == new_slave) {
1575  return;
1576  }
1577 
1578  if (bond->curr_active_slave && bond->alb_info.primary_is_promisc) {
1579  dev_set_promiscuity(bond->curr_active_slave->dev, -1);
1580  bond->alb_info.primary_is_promisc = 0;
1581  bond->alb_info.rlb_promisc_timeout_counter = 0;
1582  }
1583 
1584  swap_slave = bond->curr_active_slave;
1585  bond->curr_active_slave = new_slave;
1586 
1587  if (!new_slave || (bond->slave_cnt == 0)) {
1588  return;
1589  }
1590 
1591  /* set the new curr_active_slave to the bonds mac address
1592  * i.e. swap mac addresses of old curr_active_slave and new curr_active_slave
1593  */
1594  if (!swap_slave) {
1595  struct slave *tmp_slave;
1596  /* find slave that is holding the bond's mac address */
1597  bond_for_each_slave(bond, tmp_slave, i) {
1598  if (ether_addr_equal_64bits(tmp_slave->dev->dev_addr,
1599  bond->dev->dev_addr)) {
1600  swap_slave = tmp_slave;
1601  break;
1602  }
1603  }
1604  }
1605 
1606  /*
1607  * Arrange for swap_slave and new_slave to temporarily be
1608  * ignored so we can mess with their MAC addresses without
1609  * fear of interference from transmit activity.
1610  */
1611  if (swap_slave) {
1612  tlb_clear_slave(bond, swap_slave, 1);
1613  }
1614  tlb_clear_slave(bond, new_slave, 1);
1615 
1617  read_unlock(&bond->lock);
1618 
1619  ASSERT_RTNL();
1620 
1621  /* curr_active_slave must be set before calling alb_swap_mac_addr */
1622  if (swap_slave) {
1623  /* swap mac address */
1624  alb_swap_mac_addr(bond, swap_slave, new_slave);
1625  } else {
1626  /* set the new_slave to the bond mac address */
1627  alb_set_slave_mac_addr(new_slave, bond->dev->dev_addr);
1628  }
1629 
1630  if (swap_slave) {
1631  alb_fasten_mac_swap(bond, swap_slave, new_slave);
1632  read_lock(&bond->lock);
1633  } else {
1634  read_lock(&bond->lock);
1635  alb_send_learning_packets(new_slave, bond->dev->dev_addr);
1636  }
1637 
1639 }
1640 
1641 /*
1642  * Called with RTNL
1643  */
1644 int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
1645  __acquires(&bond->lock)
1646  __releases(&bond->lock)
1647 {
1648  struct bonding *bond = netdev_priv(bond_dev);
1649  struct sockaddr *sa = addr;
1650  struct slave *slave, *swap_slave;
1651  int res;
1652  int i;
1653 
1654  if (!is_valid_ether_addr(sa->sa_data)) {
1655  return -EADDRNOTAVAIL;
1656  }
1657 
1658  res = alb_set_mac_address(bond, addr);
1659  if (res) {
1660  return res;
1661  }
1662 
1663  memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);
1664 
1665  /* If there is no curr_active_slave there is nothing else to do.
1666  * Otherwise we'll need to pass the new address to it and handle
1667  * duplications.
1668  */
1669  if (!bond->curr_active_slave) {
1670  return 0;
1671  }
1672 
1673  swap_slave = NULL;
1674 
1675  bond_for_each_slave(bond, slave, i) {
1676  if (ether_addr_equal_64bits(slave->dev->dev_addr,
1677  bond_dev->dev_addr)) {
1678  swap_slave = slave;
1679  break;
1680  }
1681  }
1682 
1683  if (swap_slave) {
1684  alb_swap_mac_addr(bond, swap_slave, bond->curr_active_slave);
1685  alb_fasten_mac_swap(bond, swap_slave, bond->curr_active_slave);
1686  } else {
1687  alb_set_slave_mac_addr(bond->curr_active_slave, bond_dev->dev_addr);
1688 
1689  read_lock(&bond->lock);
1690  alb_send_learning_packets(bond->curr_active_slave, bond_dev->dev_addr);
1691  if (bond->alb_info.rlb_enabled) {
1692  /* inform clients mac address has changed */
1693  rlb_req_update_slave_clients(bond, bond->curr_active_slave);
1694  }
1695  read_unlock(&bond->lock);
1696  }
1697 
1698  return 0;
1699 }
1700 
1701 void bond_alb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
1702 {
1703  if (bond->alb_info.current_alb_vlan &&
1704  (bond->alb_info.current_alb_vlan->vlan_id == vlan_id)) {
1705  bond->alb_info.current_alb_vlan = NULL;
1706  }
1707 
1708  if (bond->alb_info.rlb_enabled) {
1709  rlb_clear_vlan(bond, vlan_id);
1710  }
1711 }
1712