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