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