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