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 "bonding.h" 41#include "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 skb = vlan_put_tag(skb, htons(ETH_P_8021Q), client_info->vlan_id); 479 if (!skb) { 480 netdev_err(client_info->slave->bond->dev, 481 "failed to insert VLAN tag\n"); 482 continue; 483 } 484 } 485 486 arp_xmit(skb); 487 } 488} 489 490/* sends ARP REPLIES that update the clients that need updating */ 491static void rlb_update_rx_clients(struct bonding *bond) 492{ 493 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 494 struct rlb_client_info *client_info; 495 u32 hash_index; 496 497 spin_lock_bh(&bond->mode_lock); 498 499 hash_index = bond_info->rx_hashtbl_used_head; 500 for (; hash_index != RLB_NULL_INDEX; 501 hash_index = client_info->used_next) { 502 client_info = &(bond_info->rx_hashtbl[hash_index]); 503 if (client_info->ntt) { 504 rlb_update_client(client_info); 505 if (bond_info->rlb_update_retry_counter == 0) 506 client_info->ntt = 0; 507 } 508 } 509 510 /* do not update the entries again until this counter is zero so that 511 * not to confuse the clients. 512 */ 513 bond_info->rlb_update_delay_counter = RLB_UPDATE_DELAY; 514 515 spin_unlock_bh(&bond->mode_lock); 516} 517 518/* The slave was assigned a new mac address - update the clients */ 519static void rlb_req_update_slave_clients(struct bonding *bond, struct slave *slave) 520{ 521 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 522 struct rlb_client_info *client_info; 523 int ntt = 0; 524 u32 hash_index; 525 526 spin_lock_bh(&bond->mode_lock); 527 528 hash_index = bond_info->rx_hashtbl_used_head; 529 for (; hash_index != RLB_NULL_INDEX; 530 hash_index = client_info->used_next) { 531 client_info = &(bond_info->rx_hashtbl[hash_index]); 532 533 if ((client_info->slave == slave) && 534 !ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) { 535 client_info->ntt = 1; 536 ntt = 1; 537 } 538 } 539 540 /* update the team's flag only after the whole iteration */ 541 if (ntt) { 542 bond_info->rx_ntt = 1; 543 /* fasten the change */ 544 bond_info->rlb_update_retry_counter = RLB_UPDATE_RETRY; 545 } 546 547 spin_unlock_bh(&bond->mode_lock); 548} 549 550/* mark all clients using src_ip to be updated */ 551static void rlb_req_update_subnet_clients(struct bonding *bond, __be32 src_ip) 552{ 553 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 554 struct rlb_client_info *client_info; 555 u32 hash_index; 556 557 spin_lock(&bond->mode_lock); 558 559 hash_index = bond_info->rx_hashtbl_used_head; 560 for (; hash_index != RLB_NULL_INDEX; 561 hash_index = client_info->used_next) { 562 client_info = &(bond_info->rx_hashtbl[hash_index]); 563 564 if (!client_info->slave) { 565 netdev_err(bond->dev, "found a client with no channel in the client's hash table\n"); 566 continue; 567 } 568 /* update all clients using this src_ip, that are not assigned 569 * to the team's address (curr_active_slave) and have a known 570 * unicast mac address. 571 */ 572 if ((client_info->ip_src == src_ip) && 573 !ether_addr_equal_64bits(client_info->slave->dev->dev_addr, 574 bond->dev->dev_addr) && 575 !ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) { 576 client_info->ntt = 1; 577 bond_info->rx_ntt = 1; 578 } 579 } 580 581 spin_unlock(&bond->mode_lock); 582} 583 584static struct slave *rlb_choose_channel(struct sk_buff *skb, struct bonding *bond) 585{ 586 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 587 struct arp_pkt *arp = arp_pkt(skb); 588 struct slave *assigned_slave, *curr_active_slave; 589 struct rlb_client_info *client_info; 590 u32 hash_index = 0; 591 592 spin_lock(&bond->mode_lock); 593 594 curr_active_slave = rcu_dereference(bond->curr_active_slave); 595 596 hash_index = _simple_hash((u8 *)&arp->ip_dst, sizeof(arp->ip_dst)); 597 client_info = &(bond_info->rx_hashtbl[hash_index]); 598 599 if (client_info->assigned) { 600 if ((client_info->ip_src == arp->ip_src) && 601 (client_info->ip_dst == arp->ip_dst)) { 602 /* the entry is already assigned to this client */ 603 if (!ether_addr_equal_64bits(arp->mac_dst, mac_bcast)) { 604 /* update mac address from arp */ 605 ether_addr_copy(client_info->mac_dst, arp->mac_dst); 606 } 607 ether_addr_copy(client_info->mac_src, arp->mac_src); 608 609 assigned_slave = client_info->slave; 610 if (assigned_slave) { 611 spin_unlock(&bond->mode_lock); 612 return assigned_slave; 613 } 614 } else { 615 /* the entry is already assigned to some other client, 616 * move the old client to primary (curr_active_slave) so 617 * that the new client can be assigned to this entry. 618 */ 619 if (curr_active_slave && 620 client_info->slave != curr_active_slave) { 621 client_info->slave = curr_active_slave; 622 rlb_update_client(client_info); 623 } 624 } 625 } 626 /* assign a new slave */ 627 assigned_slave = __rlb_next_rx_slave(bond); 628 629 if (assigned_slave) { 630 if (!(client_info->assigned && 631 client_info->ip_src == arp->ip_src)) { 632 /* ip_src is going to be updated, 633 * fix the src hash list 634 */ 635 u32 hash_src = _simple_hash((u8 *)&arp->ip_src, 636 sizeof(arp->ip_src)); 637 rlb_src_unlink(bond, hash_index); 638 rlb_src_link(bond, hash_src, hash_index); 639 } 640 641 client_info->ip_src = arp->ip_src; 642 client_info->ip_dst = arp->ip_dst; 643 /* arp->mac_dst is broadcast for arp reqeusts. 644 * will be updated with clients actual unicast mac address 645 * upon receiving an arp reply. 646 */ 647 ether_addr_copy(client_info->mac_dst, arp->mac_dst); 648 ether_addr_copy(client_info->mac_src, arp->mac_src); 649 client_info->slave = assigned_slave; 650 651 if (!ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) { 652 client_info->ntt = 1; 653 bond->alb_info.rx_ntt = 1; 654 } else { 655 client_info->ntt = 0; 656 } 657 658 if (vlan_get_tag(skb, &client_info->vlan_id)) 659 client_info->vlan_id = 0; 660 661 if (!client_info->assigned) { 662 u32 prev_tbl_head = bond_info->rx_hashtbl_used_head; 663 bond_info->rx_hashtbl_used_head = hash_index; 664 client_info->used_next = prev_tbl_head; 665 if (prev_tbl_head != RLB_NULL_INDEX) { 666 bond_info->rx_hashtbl[prev_tbl_head].used_prev = 667 hash_index; 668 } 669 client_info->assigned = 1; 670 } 671 } 672 673 spin_unlock(&bond->mode_lock); 674 675 return assigned_slave; 676} 677 678/* chooses (and returns) transmit channel for arp reply 679 * does not choose channel for other arp types since they are 680 * sent on the curr_active_slave 681 */ 682static struct slave *rlb_arp_xmit(struct sk_buff *skb, struct bonding *bond) 683{ 684 struct arp_pkt *arp = arp_pkt(skb); 685 struct slave *tx_slave = NULL; 686 687 /* Don't modify or load balance ARPs that do not originate locally 688 * (e.g.,arrive via a bridge). 689 */ 690 if (!bond_slave_has_mac_rx(bond, arp->mac_src)) 691 return NULL; 692 693 if (arp->op_code == htons(ARPOP_REPLY)) { 694 /* the arp must be sent on the selected rx channel */ 695 tx_slave = rlb_choose_channel(skb, bond); 696 if (tx_slave) 697 ether_addr_copy(arp->mac_src, tx_slave->dev->dev_addr); 698 netdev_dbg(bond->dev, "Server sent ARP Reply packet\n"); 699 } else if (arp->op_code == htons(ARPOP_REQUEST)) { 700 /* Create an entry in the rx_hashtbl for this client as a 701 * place holder. 702 * When the arp reply is received the entry will be updated 703 * with the correct unicast address of the client. 704 */ 705 rlb_choose_channel(skb, bond); 706 707 /* The ARP reply packets must be delayed so that 708 * they can cancel out the influence of the ARP request. 709 */ 710 bond->alb_info.rlb_update_delay_counter = RLB_UPDATE_DELAY; 711 712 /* arp requests are broadcast and are sent on the primary 713 * the arp request will collapse all clients on the subnet to 714 * the primary slave. We must register these clients to be 715 * updated with their assigned mac. 716 */ 717 rlb_req_update_subnet_clients(bond, arp->ip_src); 718 netdev_dbg(bond->dev, "Server sent ARP Request packet\n"); 719 } 720 721 return tx_slave; 722} 723 724static void rlb_rebalance(struct bonding *bond) 725{ 726 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 727 struct slave *assigned_slave; 728 struct rlb_client_info *client_info; 729 int ntt; 730 u32 hash_index; 731 732 spin_lock_bh(&bond->mode_lock); 733 734 ntt = 0; 735 hash_index = bond_info->rx_hashtbl_used_head; 736 for (; hash_index != RLB_NULL_INDEX; 737 hash_index = client_info->used_next) { 738 client_info = &(bond_info->rx_hashtbl[hash_index]); 739 assigned_slave = __rlb_next_rx_slave(bond); 740 if (assigned_slave && (client_info->slave != assigned_slave)) { 741 client_info->slave = assigned_slave; 742 client_info->ntt = 1; 743 ntt = 1; 744 } 745 } 746 747 /* update the team's flag only after the whole iteration */ 748 if (ntt) 749 bond_info->rx_ntt = 1; 750 spin_unlock_bh(&bond->mode_lock); 751} 752 753/* Caller must hold mode_lock */ 754static void rlb_init_table_entry_dst(struct rlb_client_info *entry) 755{ 756 entry->used_next = RLB_NULL_INDEX; 757 entry->used_prev = RLB_NULL_INDEX; 758 entry->assigned = 0; 759 entry->slave = NULL; 760 entry->vlan_id = 0; 761} 762static void rlb_init_table_entry_src(struct rlb_client_info *entry) 763{ 764 entry->src_first = RLB_NULL_INDEX; 765 entry->src_prev = RLB_NULL_INDEX; 766 entry->src_next = RLB_NULL_INDEX; 767} 768 769static void rlb_init_table_entry(struct rlb_client_info *entry) 770{ 771 memset(entry, 0, sizeof(struct rlb_client_info)); 772 rlb_init_table_entry_dst(entry); 773 rlb_init_table_entry_src(entry); 774} 775 776static void rlb_delete_table_entry_dst(struct bonding *bond, u32 index) 777{ 778 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 779 u32 next_index = bond_info->rx_hashtbl[index].used_next; 780 u32 prev_index = bond_info->rx_hashtbl[index].used_prev; 781 782 if (index == bond_info->rx_hashtbl_used_head) 783 bond_info->rx_hashtbl_used_head = next_index; 784 if (prev_index != RLB_NULL_INDEX) 785 bond_info->rx_hashtbl[prev_index].used_next = next_index; 786 if (next_index != RLB_NULL_INDEX) 787 bond_info->rx_hashtbl[next_index].used_prev = prev_index; 788} 789 790/* unlink a rlb hash table entry from the src list */ 791static void rlb_src_unlink(struct bonding *bond, u32 index) 792{ 793 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 794 u32 next_index = bond_info->rx_hashtbl[index].src_next; 795 u32 prev_index = bond_info->rx_hashtbl[index].src_prev; 796 797 bond_info->rx_hashtbl[index].src_next = RLB_NULL_INDEX; 798 bond_info->rx_hashtbl[index].src_prev = RLB_NULL_INDEX; 799 800 if (next_index != RLB_NULL_INDEX) 801 bond_info->rx_hashtbl[next_index].src_prev = prev_index; 802 803 if (prev_index == RLB_NULL_INDEX) 804 return; 805 806 /* is prev_index pointing to the head of this list? */ 807 if (bond_info->rx_hashtbl[prev_index].src_first == index) 808 bond_info->rx_hashtbl[prev_index].src_first = next_index; 809 else 810 bond_info->rx_hashtbl[prev_index].src_next = next_index; 811 812} 813 814static void rlb_delete_table_entry(struct bonding *bond, u32 index) 815{ 816 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 817 struct rlb_client_info *entry = &(bond_info->rx_hashtbl[index]); 818 819 rlb_delete_table_entry_dst(bond, index); 820 rlb_init_table_entry_dst(entry); 821 822 rlb_src_unlink(bond, index); 823} 824 825/* add the rx_hashtbl[ip_dst_hash] entry to the list 826 * of entries with identical ip_src_hash 827 */ 828static void rlb_src_link(struct bonding *bond, u32 ip_src_hash, u32 ip_dst_hash) 829{ 830 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 831 u32 next; 832 833 bond_info->rx_hashtbl[ip_dst_hash].src_prev = ip_src_hash; 834 next = bond_info->rx_hashtbl[ip_src_hash].src_first; 835 bond_info->rx_hashtbl[ip_dst_hash].src_next = next; 836 if (next != RLB_NULL_INDEX) 837 bond_info->rx_hashtbl[next].src_prev = ip_dst_hash; 838 bond_info->rx_hashtbl[ip_src_hash].src_first = ip_dst_hash; 839} 840 841/* deletes all rx_hashtbl entries with arp->ip_src if their mac_src does 842 * not match arp->mac_src 843 */ 844static void rlb_purge_src_ip(struct bonding *bond, struct arp_pkt *arp) 845{ 846 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 847 u32 ip_src_hash = _simple_hash((u8 *)&(arp->ip_src), sizeof(arp->ip_src)); 848 u32 index; 849 850 spin_lock_bh(&bond->mode_lock); 851 852 index = bond_info->rx_hashtbl[ip_src_hash].src_first; 853 while (index != RLB_NULL_INDEX) { 854 struct rlb_client_info *entry = &(bond_info->rx_hashtbl[index]); 855 u32 next_index = entry->src_next; 856 if (entry->ip_src == arp->ip_src && 857 !ether_addr_equal_64bits(arp->mac_src, entry->mac_src)) 858 rlb_delete_table_entry(bond, index); 859 index = next_index; 860 } 861 spin_unlock_bh(&bond->mode_lock); 862} 863 864static int rlb_initialize(struct bonding *bond) 865{ 866 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 867 struct rlb_client_info *new_hashtbl; 868 int size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info); 869 int i; 870 871 new_hashtbl = kmalloc(size, GFP_KERNEL); 872 if (!new_hashtbl) 873 return -1; 874 875 spin_lock_bh(&bond->mode_lock); 876 877 bond_info->rx_hashtbl = new_hashtbl; 878 879 bond_info->rx_hashtbl_used_head = RLB_NULL_INDEX; 880 881 for (i = 0; i < RLB_HASH_TABLE_SIZE; i++) 882 rlb_init_table_entry(bond_info->rx_hashtbl + i); 883 884 spin_unlock_bh(&bond->mode_lock); 885 886 /* register to receive ARPs */ 887 bond->recv_probe = rlb_arp_recv; 888 889 return 0; 890} 891 892static void rlb_deinitialize(struct bonding *bond) 893{ 894 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 895 896 spin_lock_bh(&bond->mode_lock); 897 898 kfree(bond_info->rx_hashtbl); 899 bond_info->rx_hashtbl = NULL; 900 bond_info->rx_hashtbl_used_head = RLB_NULL_INDEX; 901 902 spin_unlock_bh(&bond->mode_lock); 903} 904 905static void rlb_clear_vlan(struct bonding *bond, unsigned short vlan_id) 906{ 907 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 908 u32 curr_index; 909 910 spin_lock_bh(&bond->mode_lock); 911 912 curr_index = bond_info->rx_hashtbl_used_head; 913 while (curr_index != RLB_NULL_INDEX) { 914 struct rlb_client_info *curr = &(bond_info->rx_hashtbl[curr_index]); 915 u32 next_index = bond_info->rx_hashtbl[curr_index].used_next; 916 917 if (curr->vlan_id == vlan_id) 918 rlb_delete_table_entry(bond, curr_index); 919 920 curr_index = next_index; 921 } 922 923 spin_unlock_bh(&bond->mode_lock); 924} 925 926/*********************** tlb/rlb shared functions *********************/ 927 928static void alb_send_lp_vid(struct slave *slave, u8 mac_addr[], 929 __be16 vlan_proto, u16 vid) 930{ 931 struct learning_pkt pkt; 932 struct sk_buff *skb; 933 int size = sizeof(struct learning_pkt); 934 char *data; 935 936 memset(&pkt, 0, size); 937 ether_addr_copy(pkt.mac_dst, mac_addr); 938 ether_addr_copy(pkt.mac_src, mac_addr); 939 pkt.type = cpu_to_be16(ETH_P_LOOPBACK); 940 941 skb = dev_alloc_skb(size); 942 if (!skb) 943 return; 944 945 data = skb_put(skb, size); 946 memcpy(data, &pkt, size); 947 948 skb_reset_mac_header(skb); 949 skb->network_header = skb->mac_header + ETH_HLEN; 950 skb->protocol = pkt.type; 951 skb->priority = TC_PRIO_CONTROL; 952 skb->dev = slave->dev; 953 954 if (vid) { 955 skb = vlan_put_tag(skb, vlan_proto, vid); 956 if (!skb) { 957 netdev_err(slave->bond->dev, "failed to insert VLAN tag\n"); 958 return; 959 } 960 } 961 962 dev_queue_xmit(skb); 963} 964 965static void alb_send_learning_packets(struct slave *slave, u8 mac_addr[], 966 bool strict_match) 967{ 968 struct bonding *bond = bond_get_bond_by_slave(slave); 969 struct net_device *upper; 970 struct list_head *iter; 971 struct bond_vlan_tag *tags; 972 973 /* send untagged */ 974 alb_send_lp_vid(slave, mac_addr, 0, 0); 975 976 /* loop through all devices and see if we need to send a packet 977 * for that device. 978 */ 979 rcu_read_lock(); 980 netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) { 981 if (is_vlan_dev(upper) && vlan_get_encap_level(upper) == 0) { 982 if (strict_match && 983 ether_addr_equal_64bits(mac_addr, 984 upper->dev_addr)) { 985 alb_send_lp_vid(slave, mac_addr, 986 vlan_dev_vlan_proto(upper), 987 vlan_dev_vlan_id(upper)); 988 } else if (!strict_match) { 989 alb_send_lp_vid(slave, upper->dev_addr, 990 vlan_dev_vlan_proto(upper), 991 vlan_dev_vlan_id(upper)); 992 } 993 } 994 995 /* If this is a macvlan device, then only send updates 996 * when strict_match is turned off. 997 */ 998 if (netif_is_macvlan(upper) && !strict_match) { 999 tags = bond_verify_device_path(bond->dev, upper, 0); 1000 if (IS_ERR_OR_NULL(tags)) 1001 BUG(); 1002 alb_send_lp_vid(slave, upper->dev_addr, 1003 tags[0].vlan_proto, tags[0].vlan_id); 1004 kfree(tags); 1005 } 1006 } 1007 rcu_read_unlock(); 1008} 1009 1010static int alb_set_slave_mac_addr(struct slave *slave, u8 addr[]) 1011{ 1012 struct net_device *dev = slave->dev; 1013 struct sockaddr s_addr; 1014 1015 if (BOND_MODE(slave->bond) == BOND_MODE_TLB) { 1016 memcpy(dev->dev_addr, addr, dev->addr_len); 1017 return 0; 1018 } 1019 1020 /* for rlb each slave must have a unique hw mac addresses so that 1021 * each slave will receive packets destined to a different mac 1022 */ 1023 memcpy(s_addr.sa_data, addr, dev->addr_len); 1024 s_addr.sa_family = dev->type; 1025 if (dev_set_mac_address(dev, &s_addr)) { 1026 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", 1027 dev->name); 1028 return -EOPNOTSUPP; 1029 } 1030 return 0; 1031} 1032 1033/* Swap MAC addresses between two slaves. 1034 * 1035 * Called with RTNL held, and no other locks. 1036 */ 1037static void alb_swap_mac_addr(struct slave *slave1, struct slave *slave2) 1038{ 1039 u8 tmp_mac_addr[ETH_ALEN]; 1040 1041 ether_addr_copy(tmp_mac_addr, slave1->dev->dev_addr); 1042 alb_set_slave_mac_addr(slave1, slave2->dev->dev_addr); 1043 alb_set_slave_mac_addr(slave2, tmp_mac_addr); 1044 1045} 1046 1047/* Send learning packets after MAC address swap. 1048 * 1049 * Called with RTNL and no other locks 1050 */ 1051static void alb_fasten_mac_swap(struct bonding *bond, struct slave *slave1, 1052 struct slave *slave2) 1053{ 1054 int slaves_state_differ = (bond_slave_can_tx(slave1) != bond_slave_can_tx(slave2)); 1055 struct slave *disabled_slave = NULL; 1056 1057 ASSERT_RTNL(); 1058 1059 /* fasten the change in the switch */ 1060 if (bond_slave_can_tx(slave1)) { 1061 alb_send_learning_packets(slave1, slave1->dev->dev_addr, false); 1062 if (bond->alb_info.rlb_enabled) { 1063 /* inform the clients that the mac address 1064 * has changed 1065 */ 1066 rlb_req_update_slave_clients(bond, slave1); 1067 } 1068 } else { 1069 disabled_slave = slave1; 1070 } 1071 1072 if (bond_slave_can_tx(slave2)) { 1073 alb_send_learning_packets(slave2, slave2->dev->dev_addr, false); 1074 if (bond->alb_info.rlb_enabled) { 1075 /* inform the clients that the mac address 1076 * has changed 1077 */ 1078 rlb_req_update_slave_clients(bond, slave2); 1079 } 1080 } else { 1081 disabled_slave = slave2; 1082 } 1083 1084 if (bond->alb_info.rlb_enabled && slaves_state_differ) { 1085 /* A disabled slave was assigned an active mac addr */ 1086 rlb_teach_disabled_mac_on_primary(bond, 1087 disabled_slave->dev->dev_addr); 1088 } 1089} 1090 1091/** 1092 * alb_change_hw_addr_on_detach 1093 * @bond: bonding we're working on 1094 * @slave: the slave that was just detached 1095 * 1096 * We assume that @slave was already detached from the slave list. 1097 * 1098 * If @slave's permanent hw address is different both from its current 1099 * address and from @bond's address, then somewhere in the bond there's 1100 * a slave that has @slave's permanet address as its current address. 1101 * We'll make sure that that slave no longer uses @slave's permanent address. 1102 * 1103 * Caller must hold RTNL and no other locks 1104 */ 1105static void alb_change_hw_addr_on_detach(struct bonding *bond, struct slave *slave) 1106{ 1107 int perm_curr_diff; 1108 int perm_bond_diff; 1109 struct slave *found_slave; 1110 1111 perm_curr_diff = !ether_addr_equal_64bits(slave->perm_hwaddr, 1112 slave->dev->dev_addr); 1113 perm_bond_diff = !ether_addr_equal_64bits(slave->perm_hwaddr, 1114 bond->dev->dev_addr); 1115 1116 if (perm_curr_diff && perm_bond_diff) { 1117 found_slave = bond_slave_has_mac(bond, slave->perm_hwaddr); 1118 1119 if (found_slave) { 1120 alb_swap_mac_addr(slave, found_slave); 1121 alb_fasten_mac_swap(bond, slave, found_slave); 1122 } 1123 } 1124} 1125 1126/** 1127 * alb_handle_addr_collision_on_attach 1128 * @bond: bonding we're working on 1129 * @slave: the slave that was just attached 1130 * 1131 * checks uniqueness of slave's mac address and handles the case the 1132 * new slave uses the bonds mac address. 1133 * 1134 * If the permanent hw address of @slave is @bond's hw address, we need to 1135 * find a different hw address to give @slave, that isn't in use by any other 1136 * slave in the bond. This address must be, of course, one of the permanent 1137 * addresses of the other slaves. 1138 * 1139 * We go over the slave list, and for each slave there we compare its 1140 * permanent hw address with the current address of all the other slaves. 1141 * If no match was found, then we've found a slave with a permanent address 1142 * that isn't used by any other slave in the bond, so we can assign it to 1143 * @slave. 1144 * 1145 * assumption: this function is called before @slave is attached to the 1146 * bond slave list. 1147 */ 1148static int alb_handle_addr_collision_on_attach(struct bonding *bond, struct slave *slave) 1149{ 1150 struct slave *has_bond_addr = rcu_access_pointer(bond->curr_active_slave); 1151 struct slave *tmp_slave1, *free_mac_slave = NULL; 1152 struct list_head *iter; 1153 1154 if (!bond_has_slaves(bond)) { 1155 /* this is the first slave */ 1156 return 0; 1157 } 1158 1159 /* if slave's mac address differs from bond's mac address 1160 * check uniqueness of slave's mac address against the other 1161 * slaves in the bond. 1162 */ 1163 if (!ether_addr_equal_64bits(slave->perm_hwaddr, bond->dev->dev_addr)) { 1164 if (!bond_slave_has_mac(bond, slave->dev->dev_addr)) 1165 return 0; 1166 1167 /* Try setting slave mac to bond address and fall-through 1168 * to code handling that situation below... 1169 */ 1170 alb_set_slave_mac_addr(slave, bond->dev->dev_addr); 1171 } 1172 1173 /* The slave's address is equal to the address of the bond. 1174 * Search for a spare address in the bond for this slave. 1175 */ 1176 bond_for_each_slave(bond, tmp_slave1, iter) { 1177 if (!bond_slave_has_mac(bond, tmp_slave1->perm_hwaddr)) { 1178 /* no slave has tmp_slave1's perm addr 1179 * as its curr addr 1180 */ 1181 free_mac_slave = tmp_slave1; 1182 break; 1183 } 1184 1185 if (!has_bond_addr) { 1186 if (ether_addr_equal_64bits(tmp_slave1->dev->dev_addr, 1187 bond->dev->dev_addr)) { 1188 1189 has_bond_addr = tmp_slave1; 1190 } 1191 } 1192 } 1193 1194 if (free_mac_slave) { 1195 alb_set_slave_mac_addr(slave, free_mac_slave->perm_hwaddr); 1196 1197 netdev_warn(bond->dev, "the hw address of slave %s is in use by the bond; giving it the hw address of %s\n", 1198 slave->dev->name, free_mac_slave->dev->name); 1199 1200 } else if (has_bond_addr) { 1201 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", 1202 slave->dev->name); 1203 return -EFAULT; 1204 } 1205 1206 return 0; 1207} 1208 1209/** 1210 * alb_set_mac_address 1211 * @bond: 1212 * @addr: 1213 * 1214 * In TLB mode all slaves are configured to the bond's hw address, but set 1215 * their dev_addr field to different addresses (based on their permanent hw 1216 * addresses). 1217 * 1218 * For each slave, this function sets the interface to the new address and then 1219 * changes its dev_addr field to its previous value. 1220 * 1221 * Unwinding assumes bond's mac address has not yet changed. 1222 */ 1223static int alb_set_mac_address(struct bonding *bond, void *addr) 1224{ 1225 struct slave *slave, *rollback_slave; 1226 struct list_head *iter; 1227 struct sockaddr sa; 1228 char tmp_addr[ETH_ALEN]; 1229 int res; 1230 1231 if (bond->alb_info.rlb_enabled) 1232 return 0; 1233 1234 bond_for_each_slave(bond, slave, iter) { 1235 /* save net_device's current hw address */ 1236 ether_addr_copy(tmp_addr, slave->dev->dev_addr); 1237 1238 res = dev_set_mac_address(slave->dev, addr); 1239 1240 /* restore net_device's hw address */ 1241 ether_addr_copy(slave->dev->dev_addr, tmp_addr); 1242 1243 if (res) 1244 goto unwind; 1245 } 1246 1247 return 0; 1248 1249unwind: 1250 memcpy(sa.sa_data, bond->dev->dev_addr, bond->dev->addr_len); 1251 sa.sa_family = bond->dev->type; 1252 1253 /* unwind from head to the slave that failed */ 1254 bond_for_each_slave(bond, rollback_slave, iter) { 1255 if (rollback_slave == slave) 1256 break; 1257 ether_addr_copy(tmp_addr, rollback_slave->dev->dev_addr); 1258 dev_set_mac_address(rollback_slave->dev, &sa); 1259 ether_addr_copy(rollback_slave->dev->dev_addr, tmp_addr); 1260 } 1261 1262 return res; 1263} 1264 1265/************************ exported alb funcions ************************/ 1266 1267int bond_alb_initialize(struct bonding *bond, int rlb_enabled) 1268{ 1269 int res; 1270 1271 res = tlb_initialize(bond); 1272 if (res) 1273 return res; 1274 1275 if (rlb_enabled) { 1276 bond->alb_info.rlb_enabled = 1; 1277 res = rlb_initialize(bond); 1278 if (res) { 1279 tlb_deinitialize(bond); 1280 return res; 1281 } 1282 } else { 1283 bond->alb_info.rlb_enabled = 0; 1284 } 1285 1286 return 0; 1287} 1288 1289void bond_alb_deinitialize(struct bonding *bond) 1290{ 1291 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 1292 1293 tlb_deinitialize(bond); 1294 1295 if (bond_info->rlb_enabled) 1296 rlb_deinitialize(bond); 1297} 1298 1299static int bond_do_alb_xmit(struct sk_buff *skb, struct bonding *bond, 1300 struct slave *tx_slave) 1301{ 1302 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 1303 struct ethhdr *eth_data = eth_hdr(skb); 1304 1305 if (!tx_slave) { 1306 /* unbalanced or unassigned, send through primary */ 1307 tx_slave = rcu_dereference(bond->curr_active_slave); 1308 if (bond->params.tlb_dynamic_lb) 1309 bond_info->unbalanced_load += skb->len; 1310 } 1311 1312 if (tx_slave && bond_slave_can_tx(tx_slave)) { 1313 if (tx_slave != rcu_access_pointer(bond->curr_active_slave)) { 1314 ether_addr_copy(eth_data->h_source, 1315 tx_slave->dev->dev_addr); 1316 } 1317 1318 bond_dev_queue_xmit(bond, skb, tx_slave->dev); 1319 goto out; 1320 } 1321 1322 if (tx_slave && bond->params.tlb_dynamic_lb) { 1323 spin_lock(&bond->mode_lock); 1324 __tlb_clear_slave(bond, tx_slave, 0); 1325 spin_unlock(&bond->mode_lock); 1326 } 1327 1328 /* no suitable interface, frame not sent */ 1329 dev_kfree_skb_any(skb); 1330out: 1331 return NETDEV_TX_OK; 1332} 1333 1334int bond_tlb_xmit(struct sk_buff *skb, struct net_device *bond_dev) 1335{ 1336 struct bonding *bond = netdev_priv(bond_dev); 1337 struct ethhdr *eth_data; 1338 struct slave *tx_slave = NULL; 1339 u32 hash_index; 1340 1341 skb_reset_mac_header(skb); 1342 eth_data = eth_hdr(skb); 1343 1344 /* Do not TX balance any multicast or broadcast */ 1345 if (!is_multicast_ether_addr(eth_data->h_dest)) { 1346 switch (skb->protocol) { 1347 case htons(ETH_P_IP): 1348 case htons(ETH_P_IPX): 1349 /* In case of IPX, it will falback to L2 hash */ 1350 case htons(ETH_P_IPV6): 1351 hash_index = bond_xmit_hash(bond, skb); 1352 if (bond->params.tlb_dynamic_lb) { 1353 tx_slave = tlb_choose_channel(bond, 1354 hash_index & 0xFF, 1355 skb->len); 1356 } else { 1357 struct bond_up_slave *slaves; 1358 unsigned int count; 1359 1360 slaves = rcu_dereference(bond->slave_arr); 1361 count = slaves ? ACCESS_ONCE(slaves->count) : 0; 1362 if (likely(count)) 1363 tx_slave = slaves->arr[hash_index % 1364 count]; 1365 } 1366 break; 1367 } 1368 } 1369 return bond_do_alb_xmit(skb, bond, tx_slave); 1370} 1371 1372int bond_alb_xmit(struct sk_buff *skb, struct net_device *bond_dev) 1373{ 1374 struct bonding *bond = netdev_priv(bond_dev); 1375 struct ethhdr *eth_data; 1376 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 1377 struct slave *tx_slave = NULL; 1378 static const __be32 ip_bcast = htonl(0xffffffff); 1379 int hash_size = 0; 1380 bool do_tx_balance = true; 1381 u32 hash_index = 0; 1382 const u8 *hash_start = NULL; 1383 struct ipv6hdr *ip6hdr; 1384 1385 skb_reset_mac_header(skb); 1386 eth_data = eth_hdr(skb); 1387 1388 switch (ntohs(skb->protocol)) { 1389 case ETH_P_IP: { 1390 const struct iphdr *iph = ip_hdr(skb); 1391 1392 if (ether_addr_equal_64bits(eth_data->h_dest, mac_bcast) || 1393 (iph->daddr == ip_bcast) || 1394 (iph->protocol == IPPROTO_IGMP)) { 1395 do_tx_balance = false; 1396 break; 1397 } 1398 hash_start = (char *)&(iph->daddr); 1399 hash_size = sizeof(iph->daddr); 1400 } 1401 break; 1402 case ETH_P_IPV6: 1403 /* IPv6 doesn't really use broadcast mac address, but leave 1404 * that here just in case. 1405 */ 1406 if (ether_addr_equal_64bits(eth_data->h_dest, mac_bcast)) { 1407 do_tx_balance = false; 1408 break; 1409 } 1410 1411 /* IPv6 uses all-nodes multicast as an equivalent to 1412 * broadcasts in IPv4. 1413 */ 1414 if (ether_addr_equal_64bits(eth_data->h_dest, mac_v6_allmcast)) { 1415 do_tx_balance = false; 1416 break; 1417 } 1418 1419 /* Additianally, DAD probes should not be tx-balanced as that 1420 * will lead to false positives for duplicate addresses and 1421 * prevent address configuration from working. 1422 */ 1423 ip6hdr = ipv6_hdr(skb); 1424 if (ipv6_addr_any(&ip6hdr->saddr)) { 1425 do_tx_balance = false; 1426 break; 1427 } 1428 1429 hash_start = (char *)&(ipv6_hdr(skb)->daddr); 1430 hash_size = sizeof(ipv6_hdr(skb)->daddr); 1431 break; 1432 case ETH_P_IPX: 1433 if (ipx_hdr(skb)->ipx_checksum != IPX_NO_CHECKSUM) { 1434 /* something is wrong with this packet */ 1435 do_tx_balance = false; 1436 break; 1437 } 1438 1439 if (ipx_hdr(skb)->ipx_type != IPX_TYPE_NCP) { 1440 /* The only protocol worth balancing in 1441 * this family since it has an "ARP" like 1442 * mechanism 1443 */ 1444 do_tx_balance = false; 1445 break; 1446 } 1447 1448 hash_start = (char *)eth_data->h_dest; 1449 hash_size = ETH_ALEN; 1450 break; 1451 case ETH_P_ARP: 1452 do_tx_balance = false; 1453 if (bond_info->rlb_enabled) 1454 tx_slave = rlb_arp_xmit(skb, bond); 1455 break; 1456 default: 1457 do_tx_balance = false; 1458 break; 1459 } 1460 1461 if (do_tx_balance) { 1462 hash_index = _simple_hash(hash_start, hash_size); 1463 tx_slave = tlb_choose_channel(bond, hash_index, skb->len); 1464 } 1465 1466 return bond_do_alb_xmit(skb, bond, tx_slave); 1467} 1468 1469void bond_alb_monitor(struct work_struct *work) 1470{ 1471 struct bonding *bond = container_of(work, struct bonding, 1472 alb_work.work); 1473 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 1474 struct list_head *iter; 1475 struct slave *slave; 1476 1477 if (!bond_has_slaves(bond)) { 1478 bond_info->tx_rebalance_counter = 0; 1479 bond_info->lp_counter = 0; 1480 goto re_arm; 1481 } 1482 1483 rcu_read_lock(); 1484 1485 bond_info->tx_rebalance_counter++; 1486 bond_info->lp_counter++; 1487 1488 /* send learning packets */ 1489 if (bond_info->lp_counter >= BOND_ALB_LP_TICKS(bond)) { 1490 bool strict_match; 1491 1492 bond_for_each_slave_rcu(bond, slave, iter) { 1493 /* If updating current_active, use all currently 1494 * user mac addreses (!strict_match). Otherwise, only 1495 * use mac of the slave device. 1496 * In RLB mode, we always use strict matches. 1497 */ 1498 strict_match = (slave != rcu_access_pointer(bond->curr_active_slave) || 1499 bond_info->rlb_enabled); 1500 alb_send_learning_packets(slave, slave->dev->dev_addr, 1501 strict_match); 1502 } 1503 bond_info->lp_counter = 0; 1504 } 1505 1506 /* rebalance tx traffic */ 1507 if (bond_info->tx_rebalance_counter >= BOND_TLB_REBALANCE_TICKS) { 1508 bond_for_each_slave_rcu(bond, slave, iter) { 1509 tlb_clear_slave(bond, slave, 1); 1510 if (slave == rcu_access_pointer(bond->curr_active_slave)) { 1511 SLAVE_TLB_INFO(slave).load = 1512 bond_info->unbalanced_load / 1513 BOND_TLB_REBALANCE_INTERVAL; 1514 bond_info->unbalanced_load = 0; 1515 } 1516 } 1517 bond_info->tx_rebalance_counter = 0; 1518 } 1519 1520 if (bond_info->rlb_enabled) { 1521 if (bond_info->primary_is_promisc && 1522 (++bond_info->rlb_promisc_timeout_counter >= RLB_PROMISC_TIMEOUT)) { 1523 1524 /* dev_set_promiscuity requires rtnl and 1525 * nothing else. Avoid race with bond_close. 1526 */ 1527 rcu_read_unlock(); 1528 if (!rtnl_trylock()) 1529 goto re_arm; 1530 1531 bond_info->rlb_promisc_timeout_counter = 0; 1532 1533 /* If the primary was set to promiscuous mode 1534 * because a slave was disabled then 1535 * it can now leave promiscuous mode. 1536 */ 1537 dev_set_promiscuity(rtnl_dereference(bond->curr_active_slave)->dev, 1538 -1); 1539 bond_info->primary_is_promisc = 0; 1540 1541 rtnl_unlock(); 1542 rcu_read_lock(); 1543 } 1544 1545 if (bond_info->rlb_rebalance) { 1546 bond_info->rlb_rebalance = 0; 1547 rlb_rebalance(bond); 1548 } 1549 1550 /* check if clients need updating */ 1551 if (bond_info->rx_ntt) { 1552 if (bond_info->rlb_update_delay_counter) { 1553 --bond_info->rlb_update_delay_counter; 1554 } else { 1555 rlb_update_rx_clients(bond); 1556 if (bond_info->rlb_update_retry_counter) 1557 --bond_info->rlb_update_retry_counter; 1558 else 1559 bond_info->rx_ntt = 0; 1560 } 1561 } 1562 } 1563 rcu_read_unlock(); 1564re_arm: 1565 queue_delayed_work(bond->wq, &bond->alb_work, alb_delta_in_ticks); 1566} 1567 1568/* assumption: called before the slave is attached to the bond 1569 * and not locked by the bond lock 1570 */ 1571int bond_alb_init_slave(struct bonding *bond, struct slave *slave) 1572{ 1573 int res; 1574 1575 res = alb_set_slave_mac_addr(slave, slave->perm_hwaddr); 1576 if (res) 1577 return res; 1578 1579 res = alb_handle_addr_collision_on_attach(bond, slave); 1580 if (res) 1581 return res; 1582 1583 tlb_init_slave(slave); 1584 1585 /* order a rebalance ASAP */ 1586 bond->alb_info.tx_rebalance_counter = BOND_TLB_REBALANCE_TICKS; 1587 1588 if (bond->alb_info.rlb_enabled) 1589 bond->alb_info.rlb_rebalance = 1; 1590 1591 return 0; 1592} 1593 1594/* Remove slave from tlb and rlb hash tables, and fix up MAC addresses 1595 * if necessary. 1596 * 1597 * Caller must hold RTNL and no other locks 1598 */ 1599void bond_alb_deinit_slave(struct bonding *bond, struct slave *slave) 1600{ 1601 if (bond_has_slaves(bond)) 1602 alb_change_hw_addr_on_detach(bond, slave); 1603 1604 tlb_clear_slave(bond, slave, 0); 1605 1606 if (bond->alb_info.rlb_enabled) { 1607 bond->alb_info.rx_slave = NULL; 1608 rlb_clear_slave(bond, slave); 1609 } 1610 1611} 1612 1613void bond_alb_handle_link_change(struct bonding *bond, struct slave *slave, char link) 1614{ 1615 struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); 1616 1617 if (link == BOND_LINK_DOWN) { 1618 tlb_clear_slave(bond, slave, 0); 1619 if (bond->alb_info.rlb_enabled) 1620 rlb_clear_slave(bond, slave); 1621 } else if (link == BOND_LINK_UP) { 1622 /* order a rebalance ASAP */ 1623 bond_info->tx_rebalance_counter = BOND_TLB_REBALANCE_TICKS; 1624 if (bond->alb_info.rlb_enabled) { 1625 bond->alb_info.rlb_rebalance = 1; 1626 /* If the updelay module parameter is smaller than the 1627 * forwarding delay of the switch the rebalance will 1628 * not work because the rebalance arp replies will 1629 * not be forwarded to the clients.. 1630 */ 1631 } 1632 } 1633 1634 if (bond_is_nondyn_tlb(bond)) { 1635 if (bond_update_slave_arr(bond, NULL)) 1636 pr_err("Failed to build slave-array for TLB mode.\n"); 1637 } 1638} 1639 1640/** 1641 * bond_alb_handle_active_change - assign new curr_active_slave 1642 * @bond: our bonding struct 1643 * @new_slave: new slave to assign 1644 * 1645 * Set the bond->curr_active_slave to @new_slave and handle 1646 * mac address swapping and promiscuity changes as needed. 1647 * 1648 * Caller must hold RTNL 1649 */ 1650void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave) 1651{ 1652 struct slave *swap_slave; 1653 struct slave *curr_active; 1654 1655 curr_active = rtnl_dereference(bond->curr_active_slave); 1656 if (curr_active == new_slave) 1657 return; 1658 1659 if (curr_active && bond->alb_info.primary_is_promisc) { 1660 dev_set_promiscuity(curr_active->dev, -1); 1661 bond->alb_info.primary_is_promisc = 0; 1662 bond->alb_info.rlb_promisc_timeout_counter = 0; 1663 } 1664 1665 swap_slave = curr_active; 1666 rcu_assign_pointer(bond->curr_active_slave, new_slave); 1667 1668 if (!new_slave || !bond_has_slaves(bond)) 1669 return; 1670 1671 /* set the new curr_active_slave to the bonds mac address 1672 * i.e. swap mac addresses of old curr_active_slave and new curr_active_slave 1673 */ 1674 if (!swap_slave) 1675 swap_slave = bond_slave_has_mac(bond, bond->dev->dev_addr); 1676 1677 /* Arrange for swap_slave and new_slave to temporarily be 1678 * ignored so we can mess with their MAC addresses without 1679 * fear of interference from transmit activity. 1680 */ 1681 if (swap_slave) 1682 tlb_clear_slave(bond, swap_slave, 1); 1683 tlb_clear_slave(bond, new_slave, 1); 1684 1685 /* in TLB mode, the slave might flip down/up with the old dev_addr, 1686 * and thus filter bond->dev_addr's packets, so force bond's mac 1687 */ 1688 if (BOND_MODE(bond) == BOND_MODE_TLB) { 1689 struct sockaddr sa; 1690 u8 tmp_addr[ETH_ALEN]; 1691 1692 ether_addr_copy(tmp_addr, new_slave->dev->dev_addr); 1693 1694 memcpy(sa.sa_data, bond->dev->dev_addr, bond->dev->addr_len); 1695 sa.sa_family = bond->dev->type; 1696 /* we don't care if it can't change its mac, best effort */ 1697 dev_set_mac_address(new_slave->dev, &sa); 1698 1699 ether_addr_copy(new_slave->dev->dev_addr, tmp_addr); 1700 } 1701 1702 /* curr_active_slave must be set before calling alb_swap_mac_addr */ 1703 if (swap_slave) { 1704 /* swap mac address */ 1705 alb_swap_mac_addr(swap_slave, new_slave); 1706 alb_fasten_mac_swap(bond, swap_slave, new_slave); 1707 } else { 1708 /* set the new_slave to the bond mac address */ 1709 alb_set_slave_mac_addr(new_slave, bond->dev->dev_addr); 1710 alb_send_learning_packets(new_slave, bond->dev->dev_addr, 1711 false); 1712 } 1713} 1714 1715/* Called with RTNL */ 1716int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr) 1717{ 1718 struct bonding *bond = netdev_priv(bond_dev); 1719 struct sockaddr *sa = addr; 1720 struct slave *curr_active; 1721 struct slave *swap_slave; 1722 int res; 1723 1724 if (!is_valid_ether_addr(sa->sa_data)) 1725 return -EADDRNOTAVAIL; 1726 1727 res = alb_set_mac_address(bond, addr); 1728 if (res) 1729 return res; 1730 1731 memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len); 1732 1733 /* If there is no curr_active_slave there is nothing else to do. 1734 * Otherwise we'll need to pass the new address to it and handle 1735 * duplications. 1736 */ 1737 curr_active = rtnl_dereference(bond->curr_active_slave); 1738 if (!curr_active) 1739 return 0; 1740 1741 swap_slave = bond_slave_has_mac(bond, bond_dev->dev_addr); 1742 1743 if (swap_slave) { 1744 alb_swap_mac_addr(swap_slave, curr_active); 1745 alb_fasten_mac_swap(bond, swap_slave, curr_active); 1746 } else { 1747 alb_set_slave_mac_addr(curr_active, bond_dev->dev_addr); 1748 1749 alb_send_learning_packets(curr_active, 1750 bond_dev->dev_addr, false); 1751 if (bond->alb_info.rlb_enabled) { 1752 /* inform clients mac address has changed */ 1753 rlb_req_update_slave_clients(bond, curr_active); 1754 } 1755 } 1756 1757 return 0; 1758} 1759 1760void bond_alb_clear_vlan(struct bonding *bond, unsigned short vlan_id) 1761{ 1762 if (bond->alb_info.rlb_enabled) 1763 rlb_clear_vlan(bond, vlan_id); 1764} 1765 1766