1838 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*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, 0x0129};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, because233 * 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 info246 * in the rx_hashtbl247 */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 host286 * itself or on a system that is bridged together with the bond).287 * However, if arp->mac_src is different than what is stored in288 * rx_hashtbl, some other host is now using the IP and we must prevent289 * sending out client updates with this IP address and the old MAC290 * address.291 * Clean up all hash table entries that have this address as ip_src but292 * 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 something327 * better before and up to the current slave328 */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 slave353 * on the primary for fault tolerance354 *355 * Caller must hold RTNL356 */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 else369 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 point378 *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 the403 * table because it is either disabled404 * or being released. We must retry the405 * update to avoid clients from not406 * being updated & disconnecting when407 * there is stress408 */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 that480 * 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 assigned538 * to the team's address (curr_active_slave) and have a known539 * 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) so587 * 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 list604 */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 address615 * 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 reply650 * does not choose channel for other arp types since they are651 * sent on the curr_active_slave652 */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 originate664 * 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 a688 * place holder.689 * When the arp reply is received the entry will be updated690 * 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 that695 * 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 primary700 * the arp request will collapse all clients on the subnet to701 * the primary slave. We must register these clients to be702 * 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 else800 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 list816 * of entries with identical ip_src_hash817 */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 does832 * not match arp->mac_src833 */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 updates983 * 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 packet1015 * 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 that1034 * each slave will receive packets destined to a different mac1035 */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 locks1065 */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 address1079 * has changed1080 */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 address1091 * has changed1092 */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_detach1108 * @bond: bonding we're working on1109 * @slave: the slave that was just detached1110 *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 current1114 * address and from @bond's address, then somewhere in the bond there's1115 * 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 locks1119 */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_attach1143 * @bond: bonding we're working on1144 * @slave: the slave that was just attached1145 *1146 * checks uniqueness of slave's mac address and handles the case the1147 * new slave uses the bonds mac address.1148 *1149 * If the permanent hw address of @slave is @bond's hw address, we need to1150 * find a different hw address to give @slave, that isn't in use by any other1151 * slave in the bond. This address must be, of course, one of the permanent1152 * addresses of the other slaves.1153 *1154 * We go over the slave list, and for each slave there we compare its1155 * 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 address1157 * that isn't used by any other slave in the bond, so we can assign it to1158 * @slave.1159 *1160 * assumption: this function is called before @slave is attached to the1161 * 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 address1175 * check uniqueness of slave's mac address against the other1176 * 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-through1183 * 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 addr1195 * as its curr addr1196 */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_address1227 * @bond: bonding we're working on1228 * @addr: MAC address to set1229 *1230 * In TLB mode all slaves are configured to the bond's hw address, but set1231 * their dev_addr field to different addresses (based on their permanent hw1232 * addresses).1233 *1234 * For each slave, this function sets the interface to the new address and then1235 * 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 leave1456 * 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 to1464 * 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 that1478 * will lead to false positives for duplicate addresses and1479 * 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_slave1508 * So we do exactly what tlb would do for hash selection1509 */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 currently1558 * user mac addresses (!strict_match). Otherwise, only1559 * 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 and1589 * 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 mode1598 * because a slave was disabled then1599 * 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 else1623 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 bond1633 * and not locked by the bond lock1634 */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 addresses1661 * if necessary.1662 *1663 * Caller must hold RTNL and no other locks1664 */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 the1694 * forwarding delay of the switch the rebalance will1695 * not work because the rebalance arp replies will1696 * 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_slave1709 * @bond: our bonding struct1710 * @new_slave: new slave to assign1711 *1712 * Set the bond->curr_active_slave to @new_slave and handle1713 * mac address swapping and promiscuity changes as needed.1714 *1715 * Caller must hold RTNL1716 */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 address1739 * i.e. swap mac addresses of old curr_active_slave and new curr_active_slave1740 */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 be1745 * ignored so we can mess with their MAC addresses without1746 * 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 mac1754 */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 handle1806 * 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