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