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