bond_alb.c 49.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 * Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
15
 * with this program; if not, see <http://www.gnu.org/licenses/>.
L
Linus Torvalds 已提交
16 17 18 19 20 21
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 */

J
Joe Perches 已提交
22 23
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

L
Linus Torvalds 已提交
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/pkt_sched.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/if_arp.h>
#include <linux/if_ether.h>
#include <linux/if_bonding.h>
#include <linux/if_vlan.h>
#include <linux/in.h>
#include <net/ipx.h>
#include <net/arp.h>
40
#include <net/ipv6.h>
L
Linus Torvalds 已提交
41 42 43 44 45 46
#include <asm/byteorder.h>
#include "bonding.h"
#include "bond_alb.h"



47 48 49 50 51 52 53 54 55
#ifndef __long_aligned
#define __long_aligned __attribute__((aligned((sizeof(long)))))
#endif
static const u8 mac_bcast[ETH_ALEN] __long_aligned = {
	0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
static const u8 mac_v6_allmcast[ETH_ALEN] __long_aligned = {
	0x33, 0x33, 0x00, 0x00, 0x00, 0x01
};
L
Linus Torvalds 已提交
56 57 58 59 60 61
static const int alb_delta_in_ticks = HZ / ALB_TIMER_TICKS_PER_SEC;

#pragma pack(1)
struct learning_pkt {
	u8 mac_dst[ETH_ALEN];
	u8 mac_src[ETH_ALEN];
62
	__be16 type;
L
Linus Torvalds 已提交
63 64 65 66
	u8 padding[ETH_ZLEN - ETH_HLEN];
};

struct arp_pkt {
67 68
	__be16  hw_addr_space;
	__be16  prot_addr_space;
L
Linus Torvalds 已提交
69 70
	u8      hw_addr_len;
	u8      prot_addr_len;
71
	__be16  op_code;
L
Linus Torvalds 已提交
72
	u8      mac_src[ETH_ALEN];	/* sender hardware address */
73
	__be32  ip_src;			/* sender IP address */
L
Linus Torvalds 已提交
74
	u8      mac_dst[ETH_ALEN];	/* target hardware address */
75
	__be32  ip_dst;			/* target IP address */
L
Linus Torvalds 已提交
76 77 78
};
#pragma pack()

79 80
static inline struct arp_pkt *arp_pkt(const struct sk_buff *skb)
{
81
	return (struct arp_pkt *)skb_network_header(skb);
82 83
}

L
Linus Torvalds 已提交
84
/* Forward declaration */
85 86
static void alb_send_learning_packets(struct slave *slave, u8 mac_addr[],
				      bool strict_match);
87 88 89 90
static void rlb_purge_src_ip(struct bonding *bond, struct arp_pkt *arp);
static void rlb_src_unlink(struct bonding *bond, u32 index);
static void rlb_src_link(struct bonding *bond, u32 ip_src_hash,
			 u32 ip_dst_hash);
L
Linus Torvalds 已提交
91

92
static inline u8 _simple_hash(const u8 *hash_start, int hash_size)
L
Linus Torvalds 已提交
93 94 95 96
{
	int i;
	u8 hash = 0;

97
	for (i = 0; i < hash_size; i++)
L
Linus Torvalds 已提交
98 99 100 101 102 103 104
		hash ^= hash_start[i];

	return hash;
}

/*********************** tlb specific functions ***************************/

105
static inline void _lock_tx_hashtbl_bh(struct bonding *bond)
L
Linus Torvalds 已提交
106
{
107
	spin_lock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
L
Linus Torvalds 已提交
108 109
}

110
static inline void _unlock_tx_hashtbl_bh(struct bonding *bond)
L
Linus Torvalds 已提交
111
{
112
	spin_unlock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
L
Linus Torvalds 已提交
113 114
}

115 116 117 118 119 120 121 122 123 124
static inline void _lock_tx_hashtbl(struct bonding *bond)
{
	spin_lock(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
}

static inline void _unlock_tx_hashtbl(struct bonding *bond)
{
	spin_unlock(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
}

L
Linus Torvalds 已提交
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
/* Caller must hold tx_hashtbl lock */
static inline void tlb_init_table_entry(struct tlb_client_info *entry, int save_load)
{
	if (save_load) {
		entry->load_history = 1 + entry->tx_bytes /
				      BOND_TLB_REBALANCE_INTERVAL;
		entry->tx_bytes = 0;
	}

	entry->tx_slave = NULL;
	entry->next = TLB_NULL_INDEX;
	entry->prev = TLB_NULL_INDEX;
}

static inline void tlb_init_slave(struct slave *slave)
{
	SLAVE_TLB_INFO(slave).load = 0;
	SLAVE_TLB_INFO(slave).head = TLB_NULL_INDEX;
}

145 146 147
/* Caller must hold bond lock for read, BH disabled */
static void __tlb_clear_slave(struct bonding *bond, struct slave *slave,
			 int save_load)
L
Linus Torvalds 已提交
148 149 150 151 152 153 154
{
	struct tlb_client_info *tx_hash_table;
	u32 index;

	/* clear slave from tx_hashtbl */
	tx_hash_table = BOND_ALB_INFO(bond).tx_hashtbl;

155 156 157 158 159 160 161 162
	/* skip this if we've already freed the tx hash table */
	if (tx_hash_table) {
		index = SLAVE_TLB_INFO(slave).head;
		while (index != TLB_NULL_INDEX) {
			u32 next_index = tx_hash_table[index].next;
			tlb_init_table_entry(&tx_hash_table[index], save_load);
			index = next_index;
		}
L
Linus Torvalds 已提交
163 164 165
	}

	tlb_init_slave(slave);
166
}
167

168 169 170 171 172 173 174
/* Caller must hold bond lock for read */
static void tlb_clear_slave(struct bonding *bond, struct slave *slave,
			 int save_load)
{
	_lock_tx_hashtbl_bh(bond);
	__tlb_clear_slave(bond, slave, save_load);
	_unlock_tx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
175 176 177 178 179 180 181
}

/* Must be called before starting the monitor timer */
static int tlb_initialize(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	int size = TLB_HASH_TABLE_SIZE * sizeof(struct tlb_client_info);
182
	struct tlb_client_info *new_hashtbl;
L
Linus Torvalds 已提交
183 184
	int i;

185
	new_hashtbl = kzalloc(size, GFP_KERNEL);
186
	if (!new_hashtbl)
L
Linus Torvalds 已提交
187
		return -1;
188

189
	_lock_tx_hashtbl_bh(bond);
190 191

	bond_info->tx_hashtbl = new_hashtbl;
L
Linus Torvalds 已提交
192

193
	for (i = 0; i < TLB_HASH_TABLE_SIZE; i++)
194
		tlb_init_table_entry(&bond_info->tx_hashtbl[i], 0);
L
Linus Torvalds 已提交
195

196
	_unlock_tx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
197 198 199 200 201 202 203 204 205

	return 0;
}

/* Must be called only after all slaves have been released */
static void tlb_deinitialize(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));

206
	_lock_tx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
207 208 209 210

	kfree(bond_info->tx_hashtbl);
	bond_info->tx_hashtbl = NULL;

211
	_unlock_tx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
212 213
}

214 215 216 217 218 219
static long long compute_gap(struct slave *slave)
{
	return (s64) (slave->speed << 20) - /* Convert to Megabit per sec */
	       (s64) (SLAVE_TLB_INFO(slave).load << 3); /* Bytes to bits */
}

L
Linus Torvalds 已提交
220 221 222 223
/* Caller must hold bond lock for read */
static struct slave *tlb_get_least_loaded_slave(struct bonding *bond)
{
	struct slave *slave, *least_loaded;
224
	struct list_head *iter;
225
	long long max_gap;
L
Linus Torvalds 已提交
226

227 228
	least_loaded = NULL;
	max_gap = LLONG_MIN;
L
Linus Torvalds 已提交
229 230

	/* Find the slave with the largest gap */
231
	bond_for_each_slave_rcu(bond, slave, iter) {
232
		if (bond_slave_can_tx(slave)) {
233 234
			long long gap = compute_gap(slave);

L
Linus Torvalds 已提交
235 236 237 238 239 240 241 242 243 244
			if (max_gap < gap) {
				least_loaded = slave;
				max_gap = gap;
			}
		}
	}

	return least_loaded;
}

245 246
static struct slave *__tlb_choose_channel(struct bonding *bond, u32 hash_index,
						u32 skb_len)
L
Linus Torvalds 已提交
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct tlb_client_info *hash_table;
	struct slave *assigned_slave;

	hash_table = bond_info->tx_hashtbl;
	assigned_slave = hash_table[hash_index].tx_slave;
	if (!assigned_slave) {
		assigned_slave = tlb_get_least_loaded_slave(bond);

		if (assigned_slave) {
			struct tlb_slave_info *slave_info =
				&(SLAVE_TLB_INFO(assigned_slave));
			u32 next_index = slave_info->head;

			hash_table[hash_index].tx_slave = assigned_slave;
			hash_table[hash_index].next = next_index;
			hash_table[hash_index].prev = TLB_NULL_INDEX;

266
			if (next_index != TLB_NULL_INDEX)
L
Linus Torvalds 已提交
267 268 269 270 271 272 273 274
				hash_table[next_index].prev = hash_index;

			slave_info->head = hash_index;
			slave_info->load +=
				hash_table[hash_index].load_history;
		}
	}

275
	if (assigned_slave)
L
Linus Torvalds 已提交
276 277 278 279 280
		hash_table[hash_index].tx_bytes += skb_len;

	return assigned_slave;
}

281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
/* Caller must hold bond lock for read */
static struct slave *tlb_choose_channel(struct bonding *bond, u32 hash_index,
					u32 skb_len)
{
	struct slave *tx_slave;
	/*
	 * We don't need to disable softirq here, becase
	 * tlb_choose_channel() is only called by bond_alb_xmit()
	 * which already has softirq disabled.
	 */
	_lock_tx_hashtbl(bond);
	tx_slave = __tlb_choose_channel(bond, hash_index, skb_len);
	_unlock_tx_hashtbl(bond);
	return tx_slave;
}

L
Linus Torvalds 已提交
297
/*********************** rlb specific functions ***************************/
298
static inline void _lock_rx_hashtbl_bh(struct bonding *bond)
L
Linus Torvalds 已提交
299
{
300
	spin_lock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
L
Linus Torvalds 已提交
301 302
}

303
static inline void _unlock_rx_hashtbl_bh(struct bonding *bond)
L
Linus Torvalds 已提交
304
{
305
	spin_unlock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
L
Linus Torvalds 已提交
306 307
}

308 309 310 311 312 313 314 315 316 317
static inline void _lock_rx_hashtbl(struct bonding *bond)
{
	spin_lock(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
}

static inline void _unlock_rx_hashtbl(struct bonding *bond)
{
	spin_unlock(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
}

L
Linus Torvalds 已提交
318 319 320 321 322 323 324 325 326
/* when an ARP REPLY is received from a client update its info
 * in the rx_hashtbl
 */
static void rlb_update_entry_from_arp(struct bonding *bond, struct arp_pkt *arp)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct rlb_client_info *client_info;
	u32 hash_index;

327
	_lock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
328

329
	hash_index = _simple_hash((u8 *)&(arp->ip_src), sizeof(arp->ip_src));
L
Linus Torvalds 已提交
330 331 332 333
	client_info = &(bond_info->rx_hashtbl[hash_index]);

	if ((client_info->assigned) &&
	    (client_info->ip_src == arp->ip_dst) &&
334
	    (client_info->ip_dst == arp->ip_src) &&
335
	    (!ether_addr_equal_64bits(client_info->mac_dst, arp->mac_src))) {
L
Linus Torvalds 已提交
336
		/* update the clients MAC address */
337
		ether_addr_copy(client_info->mac_dst, arp->mac_src);
L
Linus Torvalds 已提交
338 339 340 341
		client_info->ntt = 1;
		bond_info->rx_ntt = 1;
	}

342
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
343 344
}

345 346
static int rlb_arp_recv(const struct sk_buff *skb, struct bonding *bond,
			struct slave *slave)
L
Linus Torvalds 已提交
347
{
348
	struct arp_pkt *arp, _arp;
L
Linus Torvalds 已提交
349

350
	if (skb->protocol != cpu_to_be16(ETH_P_ARP))
351
		goto out;
L
Linus Torvalds 已提交
352

353 354
	arp = skb_header_pointer(skb, 0, sizeof(_arp), &_arp);
	if (!arp)
355
		goto out;
L
Linus Torvalds 已提交
356

357 358 359 360 361 362 363 364 365 366 367 368
	/* We received an ARP from arp->ip_src.
	 * We might have used this IP address previously (on the bonding host
	 * itself or on a system that is bridged together with the bond).
	 * However, if arp->mac_src is different than what is stored in
	 * rx_hashtbl, some other host is now using the IP and we must prevent
	 * sending out client updates with this IP address and the old MAC
	 * address.
	 * Clean up all hash table entries that have this address as ip_src but
	 * have a different mac_src.
	 */
	rlb_purge_src_ip(bond, arp);

L
Linus Torvalds 已提交
369 370 371
	if (arp->op_code == htons(ARPOP_REPLY)) {
		/* update rx hash table for this ARP */
		rlb_update_entry_from_arp(bond, arp);
372
		pr_debug("Server received an ARP Reply from client\n");
L
Linus Torvalds 已提交
373
	}
374 375
out:
	return RX_HANDLER_ANOTHER;
L
Linus Torvalds 已提交
376 377 378 379 380 381
}

/* Caller must hold bond lock for read */
static struct slave *rlb_next_rx_slave(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
382 383 384
	struct slave *before = NULL, *rx_slave = NULL, *slave;
	struct list_head *iter;
	bool found = false;
L
Linus Torvalds 已提交
385

386
	bond_for_each_slave(bond, slave, iter) {
387
		if (!bond_slave_can_tx(slave))
388 389 390 391 392 393
			continue;
		if (!found) {
			if (!before || before->speed < slave->speed)
				before = slave;
		} else {
			if (!rx_slave || rx_slave->speed < slave->speed)
L
Linus Torvalds 已提交
394 395
				rx_slave = slave;
		}
396 397
		if (slave == bond_info->rx_slave)
			found = true;
L
Linus Torvalds 已提交
398
	}
399 400 401 402 403
	/* we didn't find anything after the current or we have something
	 * better before and up to the current slave
	 */
	if (!rx_slave || (before && rx_slave->speed < before->speed))
		rx_slave = before;
L
Linus Torvalds 已提交
404

405 406
	if (rx_slave)
		bond_info->rx_slave = rx_slave;
L
Linus Torvalds 已提交
407 408 409 410

	return rx_slave;
}

411 412 413 414 415 416 417 418 419
/* Caller must hold rcu_read_lock() for read */
static struct slave *__rlb_next_rx_slave(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct slave *before = NULL, *rx_slave = NULL, *slave;
	struct list_head *iter;
	bool found = false;

	bond_for_each_slave_rcu(bond, slave, iter) {
420
		if (!bond_slave_can_tx(slave))
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
			continue;
		if (!found) {
			if (!before || before->speed < slave->speed)
				before = slave;
		} else {
			if (!rx_slave || rx_slave->speed < slave->speed)
				rx_slave = slave;
		}
		if (slave == bond_info->rx_slave)
			found = true;
	}
	/* we didn't find anything after the current or we have something
	 * better before and up to the current slave
	 */
	if (!rx_slave || (before && rx_slave->speed < before->speed))
		rx_slave = before;

	if (rx_slave)
		bond_info->rx_slave = rx_slave;

	return rx_slave;
}

L
Linus Torvalds 已提交
444 445 446 447 448 449 450
/* teach the switch the mac of a disabled slave
 * on the primary for fault tolerance
 *
 * Caller must hold bond->curr_slave_lock for write or bond lock for write
 */
static void rlb_teach_disabled_mac_on_primary(struct bonding *bond, u8 addr[])
{
451
	if (!bond->curr_active_slave)
L
Linus Torvalds 已提交
452 453 454
		return;

	if (!bond->alb_info.primary_is_promisc) {
455 456 457 458
		if (!dev_set_promiscuity(bond->curr_active_slave->dev, 1))
			bond->alb_info.primary_is_promisc = 1;
		else
			bond->alb_info.primary_is_promisc = 0;
L
Linus Torvalds 已提交
459 460 461 462
	}

	bond->alb_info.rlb_promisc_timeout_counter = 0;

463
	alb_send_learning_packets(bond->curr_active_slave, addr, true);
L
Linus Torvalds 已提交
464 465 466 467
}

/* slave being removed should not be active at this point
 *
468
 * Caller must hold rtnl.
L
Linus Torvalds 已提交
469 470 471 472 473 474 475 476
 */
static void rlb_clear_slave(struct bonding *bond, struct slave *slave)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct rlb_client_info *rx_hash_table;
	u32 index, next_index;

	/* clear slave from rx_hashtbl */
477
	_lock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
478 479

	rx_hash_table = bond_info->rx_hashtbl;
480
	index = bond_info->rx_hashtbl_used_head;
L
Linus Torvalds 已提交
481
	for (; index != RLB_NULL_INDEX; index = next_index) {
482
		next_index = rx_hash_table[index].used_next;
L
Linus Torvalds 已提交
483 484 485 486 487
		if (rx_hash_table[index].slave == slave) {
			struct slave *assigned_slave = rlb_next_rx_slave(bond);

			if (assigned_slave) {
				rx_hash_table[index].slave = assigned_slave;
488 489
				if (!ether_addr_equal_64bits(rx_hash_table[index].mac_dst,
							     mac_bcast)) {
L
Linus Torvalds 已提交
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
					bond_info->rx_hashtbl[index].ntt = 1;
					bond_info->rx_ntt = 1;
					/* A slave has been removed from the
					 * table because it is either disabled
					 * or being released. We must retry the
					 * update to avoid clients from not
					 * being updated & disconnecting when
					 * there is stress
					 */
					bond_info->rlb_update_retry_counter =
						RLB_UPDATE_RETRY;
				}
			} else {  /* there is no active slave */
				rx_hash_table[index].slave = NULL;
			}
		}
	}

508
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
509

510
	write_lock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
511

512
	if (slave != bond->curr_active_slave)
L
Linus Torvalds 已提交
513 514
		rlb_teach_disabled_mac_on_primary(bond, slave->dev->dev_addr);

515
	write_unlock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
516 517 518 519 520 521
}

static void rlb_update_client(struct rlb_client_info *client_info)
{
	int i;

522
	if (!client_info->slave)
L
Linus Torvalds 已提交
523 524 525 526 527 528 529 530 531 532 533 534 535
		return;

	for (i = 0; i < RLB_ARP_BURST_SIZE; i++) {
		struct sk_buff *skb;

		skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
				 client_info->ip_dst,
				 client_info->slave->dev,
				 client_info->ip_src,
				 client_info->mac_dst,
				 client_info->slave->dev->dev_addr,
				 client_info->mac_dst);
		if (!skb) {
J
Joe Perches 已提交
536
			pr_err("%s: Error: failed to create an ARP packet\n",
537
			       client_info->slave->bond->dev->name);
L
Linus Torvalds 已提交
538 539 540 541 542
			continue;
		}

		skb->dev = client_info->slave->dev;

543
		if (client_info->vlan_id) {
544
			skb = vlan_put_tag(skb, htons(ETH_P_8021Q), client_info->vlan_id);
L
Linus Torvalds 已提交
545
			if (!skb) {
J
Joe Perches 已提交
546
				pr_err("%s: Error: failed to insert VLAN tag\n",
547
				       client_info->slave->bond->dev->name);
L
Linus Torvalds 已提交
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
				continue;
			}
		}

		arp_xmit(skb);
	}
}

/* sends ARP REPLIES that update the clients that need updating */
static void rlb_update_rx_clients(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct rlb_client_info *client_info;
	u32 hash_index;

563
	_lock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
564

565 566 567
	hash_index = bond_info->rx_hashtbl_used_head;
	for (; hash_index != RLB_NULL_INDEX;
	     hash_index = client_info->used_next) {
L
Linus Torvalds 已提交
568 569 570
		client_info = &(bond_info->rx_hashtbl[hash_index]);
		if (client_info->ntt) {
			rlb_update_client(client_info);
571
			if (bond_info->rlb_update_retry_counter == 0)
L
Linus Torvalds 已提交
572 573 574 575
				client_info->ntt = 0;
		}
	}

576
	/* do not update the entries again until this counter is zero so that
L
Linus Torvalds 已提交
577 578 579 580
	 * not to confuse the clients.
	 */
	bond_info->rlb_update_delay_counter = RLB_UPDATE_DELAY;

581
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
582 583 584 585 586 587 588 589 590 591
}

/* The slave was assigned a new mac address - update the clients */
static void rlb_req_update_slave_clients(struct bonding *bond, struct slave *slave)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct rlb_client_info *client_info;
	int ntt = 0;
	u32 hash_index;

592
	_lock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
593

594 595 596
	hash_index = bond_info->rx_hashtbl_used_head;
	for (; hash_index != RLB_NULL_INDEX;
	     hash_index = client_info->used_next) {
L
Linus Torvalds 已提交
597 598 599
		client_info = &(bond_info->rx_hashtbl[hash_index]);

		if ((client_info->slave == slave) &&
600
		    !ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) {
L
Linus Torvalds 已提交
601 602 603 604 605
			client_info->ntt = 1;
			ntt = 1;
		}
	}

606
	/* update the team's flag only after the whole iteration */
L
Linus Torvalds 已提交
607 608
	if (ntt) {
		bond_info->rx_ntt = 1;
609
		/* fasten the change */
L
Linus Torvalds 已提交
610 611 612
		bond_info->rlb_update_retry_counter = RLB_UPDATE_RETRY;
	}

613
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
614 615 616
}

/* mark all clients using src_ip to be updated */
617
static void rlb_req_update_subnet_clients(struct bonding *bond, __be32 src_ip)
L
Linus Torvalds 已提交
618 619 620 621 622 623 624
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct rlb_client_info *client_info;
	u32 hash_index;

	_lock_rx_hashtbl(bond);

625 626 627
	hash_index = bond_info->rx_hashtbl_used_head;
	for (; hash_index != RLB_NULL_INDEX;
	     hash_index = client_info->used_next) {
L
Linus Torvalds 已提交
628 629 630
		client_info = &(bond_info->rx_hashtbl[hash_index]);

		if (!client_info->slave) {
J
Joe Perches 已提交
631
			pr_err("%s: Error: found a client with no channel in the client's hash table\n",
632
			       bond->dev->name);
L
Linus Torvalds 已提交
633 634 635 636 637 638 639
			continue;
		}
		/*update all clients using this src_ip, that are not assigned
		 * to the team's address (curr_active_slave) and have a known
		 * unicast mac address.
		 */
		if ((client_info->ip_src == src_ip) &&
640 641 642
		    !ether_addr_equal_64bits(client_info->slave->dev->dev_addr,
					     bond->dev->dev_addr) &&
		    !ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) {
L
Linus Torvalds 已提交
643 644 645 646 647 648 649 650 651 652 653 654
			client_info->ntt = 1;
			bond_info->rx_ntt = 1;
		}
	}

	_unlock_rx_hashtbl(bond);
}

/* Caller must hold both bond and ptr locks for read */
static struct slave *rlb_choose_channel(struct sk_buff *skb, struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
655
	struct arp_pkt *arp = arp_pkt(skb);
656
	struct slave *assigned_slave, *curr_active_slave;
L
Linus Torvalds 已提交
657 658 659 660 661
	struct rlb_client_info *client_info;
	u32 hash_index = 0;

	_lock_rx_hashtbl(bond);

662 663
	curr_active_slave = rcu_dereference(bond->curr_active_slave);

664
	hash_index = _simple_hash((u8 *)&arp->ip_dst, sizeof(arp->ip_dst));
L
Linus Torvalds 已提交
665 666 667 668 669 670
	client_info = &(bond_info->rx_hashtbl[hash_index]);

	if (client_info->assigned) {
		if ((client_info->ip_src == arp->ip_src) &&
		    (client_info->ip_dst == arp->ip_dst)) {
			/* the entry is already assigned to this client */
671
			if (!ether_addr_equal_64bits(arp->mac_dst, mac_bcast)) {
L
Linus Torvalds 已提交
672
				/* update mac address from arp */
673
				ether_addr_copy(client_info->mac_dst, arp->mac_dst);
L
Linus Torvalds 已提交
674
			}
675
			ether_addr_copy(client_info->mac_src, arp->mac_src);
L
Linus Torvalds 已提交
676 677 678 679 680 681 682 683 684 685 686 687

			assigned_slave = client_info->slave;
			if (assigned_slave) {
				_unlock_rx_hashtbl(bond);
				return assigned_slave;
			}
		} else {
			/* the entry is already assigned to some other client,
			 * move the old client to primary (curr_active_slave) so
			 * that the new client can be assigned to this entry.
			 */
			if (bond->curr_active_slave &&
688 689
			    client_info->slave != curr_active_slave) {
				client_info->slave = curr_active_slave;
L
Linus Torvalds 已提交
690 691 692 693 694
				rlb_update_client(client_info);
			}
		}
	}
	/* assign a new slave */
695
	assigned_slave = __rlb_next_rx_slave(bond);
L
Linus Torvalds 已提交
696 697

	if (assigned_slave) {
698 699 700 701 702 703 704 705 706 707 708
		if (!(client_info->assigned &&
		      client_info->ip_src == arp->ip_src)) {
			/* ip_src is going to be updated,
			 * fix the src hash list
			 */
			u32 hash_src = _simple_hash((u8 *)&arp->ip_src,
						    sizeof(arp->ip_src));
			rlb_src_unlink(bond, hash_index);
			rlb_src_link(bond, hash_src, hash_index);
		}

L
Linus Torvalds 已提交
709 710 711 712 713 714
		client_info->ip_src = arp->ip_src;
		client_info->ip_dst = arp->ip_dst;
		/* arp->mac_dst is broadcast for arp reqeusts.
		 * will be updated with clients actual unicast mac address
		 * upon receiving an arp reply.
		 */
715 716
		ether_addr_copy(client_info->mac_dst, arp->mac_dst);
		ether_addr_copy(client_info->mac_src, arp->mac_src);
L
Linus Torvalds 已提交
717 718
		client_info->slave = assigned_slave;

719
		if (!ether_addr_equal_64bits(client_info->mac_dst, mac_bcast)) {
L
Linus Torvalds 已提交
720 721 722 723 724 725
			client_info->ntt = 1;
			bond->alb_info.rx_ntt = 1;
		} else {
			client_info->ntt = 0;
		}

726
		if (vlan_get_tag(skb, &client_info->vlan_id))
727
			client_info->vlan_id = 0;
L
Linus Torvalds 已提交
728 729

		if (!client_info->assigned) {
730 731 732
			u32 prev_tbl_head = bond_info->rx_hashtbl_used_head;
			bond_info->rx_hashtbl_used_head = hash_index;
			client_info->used_next = prev_tbl_head;
L
Linus Torvalds 已提交
733
			if (prev_tbl_head != RLB_NULL_INDEX) {
734
				bond_info->rx_hashtbl[prev_tbl_head].used_prev =
L
Linus Torvalds 已提交
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
					hash_index;
			}
			client_info->assigned = 1;
		}
	}

	_unlock_rx_hashtbl(bond);

	return assigned_slave;
}

/* chooses (and returns) transmit channel for arp reply
 * does not choose channel for other arp types since they are
 * sent on the curr_active_slave
 */
static struct slave *rlb_arp_xmit(struct sk_buff *skb, struct bonding *bond)
{
752
	struct arp_pkt *arp = arp_pkt(skb);
L
Linus Torvalds 已提交
753 754
	struct slave *tx_slave = NULL;

755 756 757
	/* Don't modify or load balance ARPs that do not originate locally
	 * (e.g.,arrive via a bridge).
	 */
758
	if (!bond_slave_has_mac_rcu(bond, arp->mac_src))
759 760
		return NULL;

761
	if (arp->op_code == htons(ARPOP_REPLY)) {
L
Linus Torvalds 已提交
762 763 764 765
		/* the arp must be sent on the selected
		* rx channel
		*/
		tx_slave = rlb_choose_channel(skb, bond);
766
		if (tx_slave)
767
			ether_addr_copy(arp->mac_src, tx_slave->dev->dev_addr);
768
		pr_debug("Server sent ARP Reply packet\n");
769
	} else if (arp->op_code == htons(ARPOP_REQUEST)) {
L
Linus Torvalds 已提交
770 771 772 773 774 775 776
		/* Create an entry in the rx_hashtbl for this client as a
		 * place holder.
		 * When the arp reply is received the entry will be updated
		 * with the correct unicast address of the client.
		 */
		rlb_choose_channel(skb, bond);

P
Peter Pan(潘卫平) 已提交
777
		/* The ARP reply packets must be delayed so that
L
Linus Torvalds 已提交
778 779 780 781 782 783 784 785 786 787
		 * they can cancel out the influence of the ARP request.
		 */
		bond->alb_info.rlb_update_delay_counter = RLB_UPDATE_DELAY;

		/* arp requests are broadcast and are sent on the primary
		 * the arp request will collapse all clients on the subnet to
		 * the primary slave. We must register these clients to be
		 * updated with their assigned mac.
		 */
		rlb_req_update_subnet_clients(bond, arp->ip_src);
788
		pr_debug("Server sent ARP Request packet\n");
L
Linus Torvalds 已提交
789 790 791 792 793 794 795 796 797 798 799 800 801 802
	}

	return tx_slave;
}

/* Caller must hold bond lock for read */
static void rlb_rebalance(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct slave *assigned_slave;
	struct rlb_client_info *client_info;
	int ntt;
	u32 hash_index;

803
	_lock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
804 805

	ntt = 0;
806 807 808
	hash_index = bond_info->rx_hashtbl_used_head;
	for (; hash_index != RLB_NULL_INDEX;
	     hash_index = client_info->used_next) {
L
Linus Torvalds 已提交
809
		client_info = &(bond_info->rx_hashtbl[hash_index]);
810
		assigned_slave = __rlb_next_rx_slave(bond);
L
Linus Torvalds 已提交
811 812 813 814 815 816 817 818
		if (assigned_slave && (client_info->slave != assigned_slave)) {
			client_info->slave = assigned_slave;
			client_info->ntt = 1;
			ntt = 1;
		}
	}

	/* update the team's flag only after the whole iteration */
819
	if (ntt)
L
Linus Torvalds 已提交
820
		bond_info->rx_ntt = 1;
821
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
822 823 824
}

/* Caller must hold rx_hashtbl lock */
825 826 827 828 829 830
static void rlb_init_table_entry_dst(struct rlb_client_info *entry)
{
	entry->used_next = RLB_NULL_INDEX;
	entry->used_prev = RLB_NULL_INDEX;
	entry->assigned = 0;
	entry->slave = NULL;
831
	entry->vlan_id = 0;
832 833 834 835 836 837 838 839
}
static void rlb_init_table_entry_src(struct rlb_client_info *entry)
{
	entry->src_first = RLB_NULL_INDEX;
	entry->src_prev = RLB_NULL_INDEX;
	entry->src_next = RLB_NULL_INDEX;
}

L
Linus Torvalds 已提交
840 841 842
static void rlb_init_table_entry(struct rlb_client_info *entry)
{
	memset(entry, 0, sizeof(struct rlb_client_info));
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916
	rlb_init_table_entry_dst(entry);
	rlb_init_table_entry_src(entry);
}

static void rlb_delete_table_entry_dst(struct bonding *bond, u32 index)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	u32 next_index = bond_info->rx_hashtbl[index].used_next;
	u32 prev_index = bond_info->rx_hashtbl[index].used_prev;

	if (index == bond_info->rx_hashtbl_used_head)
		bond_info->rx_hashtbl_used_head = next_index;
	if (prev_index != RLB_NULL_INDEX)
		bond_info->rx_hashtbl[prev_index].used_next = next_index;
	if (next_index != RLB_NULL_INDEX)
		bond_info->rx_hashtbl[next_index].used_prev = prev_index;
}

/* unlink a rlb hash table entry from the src list */
static void rlb_src_unlink(struct bonding *bond, u32 index)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	u32 next_index = bond_info->rx_hashtbl[index].src_next;
	u32 prev_index = bond_info->rx_hashtbl[index].src_prev;

	bond_info->rx_hashtbl[index].src_next = RLB_NULL_INDEX;
	bond_info->rx_hashtbl[index].src_prev = RLB_NULL_INDEX;

	if (next_index != RLB_NULL_INDEX)
		bond_info->rx_hashtbl[next_index].src_prev = prev_index;

	if (prev_index == RLB_NULL_INDEX)
		return;

	/* is prev_index pointing to the head of this list? */
	if (bond_info->rx_hashtbl[prev_index].src_first == index)
		bond_info->rx_hashtbl[prev_index].src_first = next_index;
	else
		bond_info->rx_hashtbl[prev_index].src_next = next_index;

}

static void rlb_delete_table_entry(struct bonding *bond, u32 index)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct rlb_client_info *entry = &(bond_info->rx_hashtbl[index]);

	rlb_delete_table_entry_dst(bond, index);
	rlb_init_table_entry_dst(entry);

	rlb_src_unlink(bond, index);
}

/* add the rx_hashtbl[ip_dst_hash] entry to the list
 * of entries with identical ip_src_hash
 */
static void rlb_src_link(struct bonding *bond, u32 ip_src_hash, u32 ip_dst_hash)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	u32 next;

	bond_info->rx_hashtbl[ip_dst_hash].src_prev = ip_src_hash;
	next = bond_info->rx_hashtbl[ip_src_hash].src_first;
	bond_info->rx_hashtbl[ip_dst_hash].src_next = next;
	if (next != RLB_NULL_INDEX)
		bond_info->rx_hashtbl[next].src_prev = ip_dst_hash;
	bond_info->rx_hashtbl[ip_src_hash].src_first = ip_dst_hash;
}

/* deletes all rx_hashtbl entries with  arp->ip_src if their mac_src does
 * not match arp->mac_src */
static void rlb_purge_src_ip(struct bonding *bond, struct arp_pkt *arp)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
917
	u32 ip_src_hash = _simple_hash((u8 *)&(arp->ip_src), sizeof(arp->ip_src));
918 919 920 921 922 923 924 925 926 927 928 929 930 931
	u32 index;

	_lock_rx_hashtbl_bh(bond);

	index = bond_info->rx_hashtbl[ip_src_hash].src_first;
	while (index != RLB_NULL_INDEX) {
		struct rlb_client_info *entry = &(bond_info->rx_hashtbl[index]);
		u32 next_index = entry->src_next;
		if (entry->ip_src == arp->ip_src &&
		    !ether_addr_equal_64bits(arp->mac_src, entry->mac_src))
				rlb_delete_table_entry(bond, index);
		index = next_index;
	}
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
932 933 934 935 936
}

static int rlb_initialize(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
937
	struct rlb_client_info	*new_hashtbl;
L
Linus Torvalds 已提交
938 939 940
	int size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info);
	int i;

941
	new_hashtbl = kmalloc(size, GFP_KERNEL);
942
	if (!new_hashtbl)
L
Linus Torvalds 已提交
943
		return -1;
944

945
	_lock_rx_hashtbl_bh(bond);
946 947

	bond_info->rx_hashtbl = new_hashtbl;
L
Linus Torvalds 已提交
948

949
	bond_info->rx_hashtbl_used_head = RLB_NULL_INDEX;
L
Linus Torvalds 已提交
950

951
	for (i = 0; i < RLB_HASH_TABLE_SIZE; i++)
L
Linus Torvalds 已提交
952 953
		rlb_init_table_entry(bond_info->rx_hashtbl + i);

954
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
955 956

	/* register to receive ARPs */
957
	bond->recv_probe = rlb_arp_recv;
L
Linus Torvalds 已提交
958 959 960 961 962 963 964 965

	return 0;
}

static void rlb_deinitialize(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));

966
	_lock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
967 968 969

	kfree(bond_info->rx_hashtbl);
	bond_info->rx_hashtbl = NULL;
970
	bond_info->rx_hashtbl_used_head = RLB_NULL_INDEX;
L
Linus Torvalds 已提交
971

972
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
973 974 975 976 977 978 979
}

static void rlb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	u32 curr_index;

980
	_lock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
981

982
	curr_index = bond_info->rx_hashtbl_used_head;
L
Linus Torvalds 已提交
983 984
	while (curr_index != RLB_NULL_INDEX) {
		struct rlb_client_info *curr = &(bond_info->rx_hashtbl[curr_index]);
985
		u32 next_index = bond_info->rx_hashtbl[curr_index].used_next;
L
Linus Torvalds 已提交
986

987
		if (curr->vlan_id == vlan_id)
988
			rlb_delete_table_entry(bond, curr_index);
L
Linus Torvalds 已提交
989 990 991 992

		curr_index = next_index;
	}

993
	_unlock_rx_hashtbl_bh(bond);
L
Linus Torvalds 已提交
994 995 996 997
}

/*********************** tlb/rlb shared functions *********************/

998
static void alb_send_lp_vid(struct slave *slave, u8 mac_addr[],
999
			    __be16 vlan_proto, u16 vid)
L
Linus Torvalds 已提交
1000 1001
{
	struct learning_pkt pkt;
1002
	struct sk_buff *skb;
L
Linus Torvalds 已提交
1003
	int size = sizeof(struct learning_pkt);
1004
	char *data;
L
Linus Torvalds 已提交
1005 1006

	memset(&pkt, 0, size);
1007 1008
	ether_addr_copy(pkt.mac_dst, mac_addr);
	ether_addr_copy(pkt.mac_src, mac_addr);
1009
	pkt.type = cpu_to_be16(ETH_P_LOOPBACK);
L
Linus Torvalds 已提交
1010

1011 1012 1013
	skb = dev_alloc_skb(size);
	if (!skb)
		return;
L
Linus Torvalds 已提交
1014

1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
	data = skb_put(skb, size);
	memcpy(data, &pkt, size);

	skb_reset_mac_header(skb);
	skb->network_header = skb->mac_header + ETH_HLEN;
	skb->protocol = pkt.type;
	skb->priority = TC_PRIO_CONTROL;
	skb->dev = slave->dev;

	if (vid) {
1025
		skb = vlan_put_tag(skb, vlan_proto, vid);
L
Linus Torvalds 已提交
1026
		if (!skb) {
1027 1028
			pr_err("%s: Error: failed to insert VLAN tag\n",
			       slave->bond->dev->name);
L
Linus Torvalds 已提交
1029 1030
			return;
		}
1031 1032 1033 1034
	}

	dev_queue_xmit(skb);
}
L
Linus Torvalds 已提交
1035

1036 1037
static void alb_send_learning_packets(struct slave *slave, u8 mac_addr[],
				      bool strict_match)
1038 1039
{
	struct bonding *bond = bond_get_bond_by_slave(slave);
1040 1041 1042 1043
	struct net_device *upper;
	struct list_head *iter;

	/* send untagged */
1044
	alb_send_lp_vid(slave, mac_addr, 0, 0);
1045 1046 1047

	/* loop through vlans and send one packet for each */
	rcu_read_lock();
1048
	netdev_for_each_all_upper_dev_rcu(bond->dev, upper, iter) {
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
		if (is_vlan_dev(upper) && vlan_get_encap_level(upper) == 0) {
			if (strict_match &&
			    ether_addr_equal_64bits(mac_addr,
						    upper->dev_addr)) {
				alb_send_lp_vid(slave, mac_addr,
						vlan_dev_vlan_proto(upper),
						vlan_dev_vlan_id(upper));
			} else if (!strict_match) {
				alb_send_lp_vid(slave, upper->dev_addr,
						vlan_dev_vlan_proto(upper),
						vlan_dev_vlan_id(upper));
			}
		}
L
Linus Torvalds 已提交
1062
	}
1063
	rcu_read_unlock();
L
Linus Torvalds 已提交
1064 1065
}

1066
static int alb_set_slave_mac_addr(struct slave *slave, u8 addr[])
L
Linus Torvalds 已提交
1067 1068 1069 1070
{
	struct net_device *dev = slave->dev;
	struct sockaddr s_addr;

1071
	if (BOND_MODE(slave->bond) == BOND_MODE_TLB) {
L
Linus Torvalds 已提交
1072 1073 1074 1075 1076 1077 1078 1079 1080
		memcpy(dev->dev_addr, addr, dev->addr_len);
		return 0;
	}

	/* for rlb each slave must have a unique hw mac addresses so that */
	/* each slave will receive packets destined to a different mac */
	memcpy(s_addr.sa_data, addr, dev->addr_len);
	s_addr.sa_family = dev->type;
	if (dev_set_mac_address(dev, &s_addr)) {
J
Joe Perches 已提交
1081 1082
		pr_err("%s: Error: dev_set_mac_address of dev %s failed!\n"
		       "ALB mode requires that the base driver support setting the hw address also when the network device's interface is open\n",
1083
		       slave->bond->dev->name, dev->name);
L
Linus Torvalds 已提交
1084 1085 1086 1087 1088
		return -EOPNOTSUPP;
	}
	return 0;
}

1089 1090 1091 1092 1093 1094 1095
/*
 * Swap MAC addresses between two slaves.
 *
 * Called with RTNL held, and no other locks.
 *
 */

1096
static void alb_swap_mac_addr(struct slave *slave1, struct slave *slave2)
L
Linus Torvalds 已提交
1097 1098 1099
{
	u8 tmp_mac_addr[ETH_ALEN];

1100
	ether_addr_copy(tmp_mac_addr, slave1->dev->dev_addr);
1101 1102
	alb_set_slave_mac_addr(slave1, slave2->dev->dev_addr);
	alb_set_slave_mac_addr(slave2, tmp_mac_addr);
L
Linus Torvalds 已提交
1103

1104 1105 1106 1107 1108
}

/*
 * Send learning packets after MAC address swap.
 *
1109
 * Called with RTNL and no other locks
1110 1111 1112 1113
 */
static void alb_fasten_mac_swap(struct bonding *bond, struct slave *slave1,
				struct slave *slave2)
{
1114
	int slaves_state_differ = (bond_slave_can_tx(slave1) != bond_slave_can_tx(slave2));
1115 1116
	struct slave *disabled_slave = NULL;

1117 1118
	ASSERT_RTNL();

L
Linus Torvalds 已提交
1119
	/* fasten the change in the switch */
1120
	if (bond_slave_can_tx(slave1)) {
1121
		alb_send_learning_packets(slave1, slave1->dev->dev_addr, false);
L
Linus Torvalds 已提交
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
		if (bond->alb_info.rlb_enabled) {
			/* inform the clients that the mac address
			 * has changed
			 */
			rlb_req_update_slave_clients(bond, slave1);
		}
	} else {
		disabled_slave = slave1;
	}

1132
	if (bond_slave_can_tx(slave2)) {
1133
		alb_send_learning_packets(slave2, slave2->dev->dev_addr, false);
L
Linus Torvalds 已提交
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
		if (bond->alb_info.rlb_enabled) {
			/* inform the clients that the mac address
			 * has changed
			 */
			rlb_req_update_slave_clients(bond, slave2);
		}
	} else {
		disabled_slave = slave2;
	}

	if (bond->alb_info.rlb_enabled && slaves_state_differ) {
		/* A disabled slave was assigned an active mac addr */
		rlb_teach_disabled_mac_on_primary(bond,
						  disabled_slave->dev->dev_addr);
	}
}

/**
 * alb_change_hw_addr_on_detach
 * @bond: bonding we're working on
 * @slave: the slave that was just detached
 *
 * We assume that @slave was already detached from the slave list.
 *
 * If @slave's permanent hw address is different both from its current
 * address and from @bond's address, then somewhere in the bond there's
 * a slave that has @slave's permanet address as its current address.
 * We'll make sure that that slave no longer uses @slave's permanent address.
 *
1163
 * Caller must hold RTNL and no other locks
L
Linus Torvalds 已提交
1164 1165 1166 1167 1168
 */
static void alb_change_hw_addr_on_detach(struct bonding *bond, struct slave *slave)
{
	int perm_curr_diff;
	int perm_bond_diff;
1169
	struct slave *found_slave;
L
Linus Torvalds 已提交
1170

1171 1172 1173 1174
	perm_curr_diff = !ether_addr_equal_64bits(slave->perm_hwaddr,
						  slave->dev->dev_addr);
	perm_bond_diff = !ether_addr_equal_64bits(slave->perm_hwaddr,
						  bond->dev->dev_addr);
L
Linus Torvalds 已提交
1175 1176

	if (perm_curr_diff && perm_bond_diff) {
1177
		found_slave = bond_slave_has_mac(bond, slave->perm_hwaddr);
L
Linus Torvalds 已提交
1178

1179
		if (found_slave) {
1180
			/* locking: needs RTNL and nothing else */
1181 1182
			alb_swap_mac_addr(slave, found_slave);
			alb_fasten_mac_swap(bond, slave, found_slave);
L
Linus Torvalds 已提交
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
		}
	}
}

/**
 * alb_handle_addr_collision_on_attach
 * @bond: bonding we're working on
 * @slave: the slave that was just attached
 *
 * checks uniqueness of slave's mac address and handles the case the
 * new slave uses the bonds mac address.
 *
 * If the permanent hw address of @slave is @bond's hw address, we need to
 * find a different hw address to give @slave, that isn't in use by any other
P
Peter Pan(潘卫平) 已提交
1197
 * slave in the bond. This address must be, of course, one of the permanent
L
Linus Torvalds 已提交
1198 1199 1200 1201 1202 1203 1204 1205 1206
 * addresses of the other slaves.
 *
 * We go over the slave list, and for each slave there we compare its
 * permanent hw address with the current address of all the other slaves.
 * If no match was found, then we've found a slave with a permanent address
 * that isn't used by any other slave in the bond, so we can assign it to
 * @slave.
 *
 * assumption: this function is called before @slave is attached to the
1207
 *	       bond slave list.
L
Linus Torvalds 已提交
1208 1209 1210 1211
 */
static int alb_handle_addr_collision_on_attach(struct bonding *bond, struct slave *slave)
{
	struct slave *has_bond_addr = bond->curr_active_slave;
1212 1213
	struct slave *tmp_slave1, *free_mac_slave = NULL;
	struct list_head *iter;
L
Linus Torvalds 已提交
1214

1215
	if (!bond_has_slaves(bond)) {
L
Linus Torvalds 已提交
1216 1217 1218 1219 1220 1221 1222 1223
		/* this is the first slave */
		return 0;
	}

	/* if slave's mac address differs from bond's mac address
	 * check uniqueness of slave's mac address against the other
	 * slaves in the bond.
	 */
1224
	if (!ether_addr_equal_64bits(slave->perm_hwaddr, bond->dev->dev_addr)) {
1225
		if (!bond_slave_has_mac(bond, slave->dev->dev_addr))
1226
			return 0;
L
Linus Torvalds 已提交
1227

1228 1229
		/* Try setting slave mac to bond address and fall-through
		   to code handling that situation below... */
1230
		alb_set_slave_mac_addr(slave, bond->dev->dev_addr);
L
Linus Torvalds 已提交
1231 1232 1233 1234 1235
	}

	/* The slave's address is equal to the address of the bond.
	 * Search for a spare address in the bond for this slave.
	 */
1236
	bond_for_each_slave(bond, tmp_slave1, iter) {
1237
		if (!bond_slave_has_mac(bond, tmp_slave1->perm_hwaddr)) {
L
Linus Torvalds 已提交
1238 1239 1240 1241 1242 1243 1244 1245
			/* no slave has tmp_slave1's perm addr
			 * as its curr addr
			 */
			free_mac_slave = tmp_slave1;
			break;
		}

		if (!has_bond_addr) {
1246 1247
			if (ether_addr_equal_64bits(tmp_slave1->dev->dev_addr,
						    bond->dev->dev_addr)) {
L
Linus Torvalds 已提交
1248 1249 1250 1251 1252 1253 1254

				has_bond_addr = tmp_slave1;
			}
		}
	}

	if (free_mac_slave) {
1255
		alb_set_slave_mac_addr(slave, free_mac_slave->perm_hwaddr);
L
Linus Torvalds 已提交
1256

1257 1258 1259
		pr_warn("%s: Warning: the hw address of slave %s is in use by the bond; giving it the hw address of %s\n",
			bond->dev->name, slave->dev->name,
			free_mac_slave->dev->name);
L
Linus Torvalds 已提交
1260 1261

	} else if (has_bond_addr) {
J
Joe Perches 已提交
1262
		pr_err("%s: Error: the hw address of slave %s is in use by the bond; couldn't find a slave with a free hw address to give it (this should not have happened)\n",
1263
		       bond->dev->name, slave->dev->name);
L
Linus Torvalds 已提交
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
		return -EFAULT;
	}

	return 0;
}

/**
 * alb_set_mac_address
 * @bond:
 * @addr:
 *
 * In TLB mode all slaves are configured to the bond's hw address, but set
 * their dev_addr field to different addresses (based on their permanent hw
 * addresses).
 *
 * For each slave, this function sets the interface to the new address and then
 * changes its dev_addr field to its previous value.
 *
 * Unwinding assumes bond's mac address has not yet changed.
 */
static int alb_set_mac_address(struct bonding *bond, void *addr)
{
1286
	struct slave *slave, *rollback_slave;
1287
	struct list_head *iter;
1288
	struct sockaddr sa;
1289
	char tmp_addr[ETH_ALEN];
L
Linus Torvalds 已提交
1290 1291
	int res;

1292
	if (bond->alb_info.rlb_enabled)
L
Linus Torvalds 已提交
1293 1294
		return 0;

1295
	bond_for_each_slave(bond, slave, iter) {
L
Linus Torvalds 已提交
1296
		/* save net_device's current hw address */
1297
		ether_addr_copy(tmp_addr, slave->dev->dev_addr);
L
Linus Torvalds 已提交
1298 1299 1300 1301

		res = dev_set_mac_address(slave->dev, addr);

		/* restore net_device's hw address */
1302
		ether_addr_copy(slave->dev->dev_addr, tmp_addr);
L
Linus Torvalds 已提交
1303

1304
		if (res)
L
Linus Torvalds 已提交
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
			goto unwind;
	}

	return 0;

unwind:
	memcpy(sa.sa_data, bond->dev->dev_addr, bond->dev->addr_len);
	sa.sa_family = bond->dev->type;

	/* unwind from head to the slave that failed */
1315
	bond_for_each_slave(bond, rollback_slave, iter) {
1316 1317
		if (rollback_slave == slave)
			break;
1318
		ether_addr_copy(tmp_addr, rollback_slave->dev->dev_addr);
1319
		dev_set_mac_address(rollback_slave->dev, &sa);
1320
		ether_addr_copy(rollback_slave->dev->dev_addr, tmp_addr);
L
Linus Torvalds 已提交
1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332
	}

	return res;
}

/************************ exported alb funcions ************************/

int bond_alb_initialize(struct bonding *bond, int rlb_enabled)
{
	int res;

	res = tlb_initialize(bond);
1333
	if (res)
L
Linus Torvalds 已提交
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
		return res;

	if (rlb_enabled) {
		bond->alb_info.rlb_enabled = 1;
		/* initialize rlb */
		res = rlb_initialize(bond);
		if (res) {
			tlb_deinitialize(bond);
			return res;
		}
1344 1345
	} else {
		bond->alb_info.rlb_enabled = 0;
L
Linus Torvalds 已提交
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
	}

	return 0;
}

void bond_alb_deinitialize(struct bonding *bond)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));

	tlb_deinitialize(bond);

1357
	if (bond_info->rlb_enabled)
L
Linus Torvalds 已提交
1358 1359 1360
		rlb_deinitialize(bond);
}

1361 1362 1363 1364 1365 1366 1367 1368 1369
static int bond_do_alb_xmit(struct sk_buff *skb, struct bonding *bond,
		struct slave *tx_slave)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct ethhdr *eth_data = eth_hdr(skb);

	if (!tx_slave) {
		/* unbalanced or unassigned, send through primary */
		tx_slave = rcu_dereference(bond->curr_active_slave);
1370 1371
		if (bond->params.tlb_dynamic_lb)
			bond_info->unbalanced_load += skb->len;
1372 1373
	}

1374
	if (tx_slave && bond_slave_can_tx(tx_slave)) {
1375 1376 1377 1378 1379 1380 1381 1382 1383
		if (tx_slave != rcu_dereference(bond->curr_active_slave)) {
			ether_addr_copy(eth_data->h_source,
					tx_slave->dev->dev_addr);
		}

		bond_dev_queue_xmit(bond, skb, tx_slave->dev);
		goto out;
	}

1384
	if (tx_slave && bond->params.tlb_dynamic_lb) {
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
		_lock_tx_hashtbl(bond);
		__tlb_clear_slave(bond, tx_slave, 0);
		_unlock_tx_hashtbl(bond);
	}

	/* no suitable interface, frame not sent */
	dev_kfree_skb_any(skb);
out:
	return NETDEV_TX_OK;
}

1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
int bond_tlb_xmit(struct sk_buff *skb, struct net_device *bond_dev)
{
	struct bonding *bond = netdev_priv(bond_dev);
	struct ethhdr *eth_data;
	struct slave *tx_slave = NULL;
	u32 hash_index;

	skb_reset_mac_header(skb);
	eth_data = eth_hdr(skb);

	/* Do not TX balance any multicast or broadcast */
	if (!is_multicast_ether_addr(eth_data->h_dest)) {
		switch (skb->protocol) {
		case htons(ETH_P_IP):
		case htons(ETH_P_IPX):
		    /* In case of IPX, it will falback to L2 hash */
		case htons(ETH_P_IPV6):
			hash_index = bond_xmit_hash(bond, skb);
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
			if (bond->params.tlb_dynamic_lb) {
				tx_slave = tlb_choose_channel(bond,
							      hash_index & 0xFF,
							      skb->len);
			} else {
				struct list_head *iter;
				int idx = hash_index % bond->slave_cnt;

				bond_for_each_slave_rcu(bond, tx_slave, iter)
					if (--idx < 0)
						break;
			}
1426 1427 1428 1429 1430 1431
			break;
		}
	}
	return bond_do_alb_xmit(skb, bond, tx_slave);
}

L
Linus Torvalds 已提交
1432 1433
int bond_alb_xmit(struct sk_buff *skb, struct net_device *bond_dev)
{
1434
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
1435 1436 1437
	struct ethhdr *eth_data;
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct slave *tx_slave = NULL;
1438
	static const __be32 ip_bcast = htonl(0xffffffff);
L
Linus Torvalds 已提交
1439
	int hash_size = 0;
1440
	bool do_tx_balance = true;
L
Linus Torvalds 已提交
1441
	u32 hash_index = 0;
1442
	const u8 *hash_start = NULL;
1443
	struct ipv6hdr *ip6hdr;
L
Linus Torvalds 已提交
1444

1445
	skb_reset_mac_header(skb);
L
Linus Torvalds 已提交
1446 1447 1448
	eth_data = eth_hdr(skb);

	switch (ntohs(skb->protocol)) {
1449 1450 1451
	case ETH_P_IP: {
		const struct iphdr *iph = ip_hdr(skb);

1452
		if (ether_addr_equal_64bits(eth_data->h_dest, mac_bcast) ||
1453 1454
		    (iph->daddr == ip_bcast) ||
		    (iph->protocol == IPPROTO_IGMP)) {
1455
			do_tx_balance = false;
L
Linus Torvalds 已提交
1456 1457
			break;
		}
1458 1459 1460
		hash_start = (char *)&(iph->daddr);
		hash_size = sizeof(iph->daddr);
	}
L
Linus Torvalds 已提交
1461 1462
		break;
	case ETH_P_IPV6:
1463 1464 1465
		/* IPv6 doesn't really use broadcast mac address, but leave
		 * that here just in case.
		 */
1466
		if (ether_addr_equal_64bits(eth_data->h_dest, mac_bcast)) {
1467
			do_tx_balance = false;
L
Linus Torvalds 已提交
1468
			break;
1469 1470 1471 1472 1473
		}

		/* IPv6 uses all-nodes multicast as an equivalent to
		 * broadcasts in IPv4.
		 */
1474
		if (ether_addr_equal_64bits(eth_data->h_dest, mac_v6_allmcast)) {
1475
			do_tx_balance = false;
1476 1477 1478 1479 1480 1481 1482 1483 1484
			break;
		}

		/* Additianally, DAD probes should not be tx-balanced as that
		 * will lead to false positives for duplicate addresses and
		 * prevent address configuration from working.
		 */
		ip6hdr = ipv6_hdr(skb);
		if (ipv6_addr_any(&ip6hdr->saddr)) {
1485
			do_tx_balance = false;
1486
			break;
L
Linus Torvalds 已提交
1487 1488
		}

1489 1490
		hash_start = (char *)&(ipv6_hdr(skb)->daddr);
		hash_size = sizeof(ipv6_hdr(skb)->daddr);
L
Linus Torvalds 已提交
1491 1492
		break;
	case ETH_P_IPX:
1493
		if (ipx_hdr(skb)->ipx_checksum != IPX_NO_CHECKSUM) {
L
Linus Torvalds 已提交
1494
			/* something is wrong with this packet */
1495
			do_tx_balance = false;
L
Linus Torvalds 已提交
1496 1497 1498 1499 1500 1501 1502 1503
			break;
		}

		if (ipx_hdr(skb)->ipx_type != IPX_TYPE_NCP) {
			/* The only protocol worth balancing in
			 * this family since it has an "ARP" like
			 * mechanism
			 */
1504
			do_tx_balance = false;
L
Linus Torvalds 已提交
1505 1506 1507
			break;
		}

1508
		hash_start = (char *)eth_data->h_dest;
L
Linus Torvalds 已提交
1509 1510 1511
		hash_size = ETH_ALEN;
		break;
	case ETH_P_ARP:
1512
		do_tx_balance = false;
1513
		if (bond_info->rlb_enabled)
L
Linus Torvalds 已提交
1514 1515 1516
			tx_slave = rlb_arp_xmit(skb, bond);
		break;
	default:
1517
		do_tx_balance = false;
L
Linus Torvalds 已提交
1518 1519 1520 1521 1522 1523 1524 1525
		break;
	}

	if (do_tx_balance) {
		hash_index = _simple_hash(hash_start, hash_size);
		tx_slave = tlb_choose_channel(bond, hash_index, skb->len);
	}

1526
	return bond_do_alb_xmit(skb, bond, tx_slave);
L
Linus Torvalds 已提交
1527 1528
}

1529
void bond_alb_monitor(struct work_struct *work)
L
Linus Torvalds 已提交
1530
{
1531 1532
	struct bonding *bond = container_of(work, struct bonding,
					    alb_work.work);
L
Linus Torvalds 已提交
1533
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
1534
	struct list_head *iter;
L
Linus Torvalds 已提交
1535 1536
	struct slave *slave;

1537
	if (!bond_has_slaves(bond)) {
L
Linus Torvalds 已提交
1538 1539 1540 1541 1542
		bond_info->tx_rebalance_counter = 0;
		bond_info->lp_counter = 0;
		goto re_arm;
	}

1543 1544
	rcu_read_lock();

L
Linus Torvalds 已提交
1545 1546 1547 1548
	bond_info->tx_rebalance_counter++;
	bond_info->lp_counter++;

	/* send learning packets */
1549
	if (bond_info->lp_counter >= BOND_ALB_LP_TICKS(bond)) {
1550 1551
		bool strict_match;

L
Linus Torvalds 已提交
1552 1553 1554 1555 1556 1557 1558
		/* change of curr_active_slave involves swapping of mac addresses.
		 * in order to avoid this swapping from happening while
		 * sending the learning packets, the curr_slave_lock must be held for
		 * read.
		 */
		read_lock(&bond->curr_slave_lock);

1559 1560 1561 1562 1563 1564 1565 1566 1567
		bond_for_each_slave_rcu(bond, slave, iter) {
			/* If updating current_active, use all currently
			 * user mac addreses (!strict_match).  Otherwise, only
			 * use mac of the slave device.
			 */
			strict_match = (slave != bond->curr_active_slave);
			alb_send_learning_packets(slave, slave->dev->dev_addr,
						  strict_match);
		}
L
Linus Torvalds 已提交
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578

		read_unlock(&bond->curr_slave_lock);

		bond_info->lp_counter = 0;
	}

	/* rebalance tx traffic */
	if (bond_info->tx_rebalance_counter >= BOND_TLB_REBALANCE_TICKS) {

		read_lock(&bond->curr_slave_lock);

1579
		bond_for_each_slave_rcu(bond, slave, iter) {
L
Linus Torvalds 已提交
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
			tlb_clear_slave(bond, slave, 1);
			if (slave == bond->curr_active_slave) {
				SLAVE_TLB_INFO(slave).load =
					bond_info->unbalanced_load /
						BOND_TLB_REBALANCE_INTERVAL;
				bond_info->unbalanced_load = 0;
			}
		}

		read_unlock(&bond->curr_slave_lock);

		bond_info->tx_rebalance_counter = 0;
	}

	/* handle rlb stuff */
	if (bond_info->rlb_enabled) {
		if (bond_info->primary_is_promisc &&
		    (++bond_info->rlb_promisc_timeout_counter >= RLB_PROMISC_TIMEOUT)) {

1599 1600 1601 1602
			/*
			 * dev_set_promiscuity requires rtnl and
			 * nothing else.  Avoid race with bond_close.
			 */
1603 1604
			rcu_read_unlock();
			if (!rtnl_trylock())
1605 1606
				goto re_arm;

L
Linus Torvalds 已提交
1607 1608 1609 1610 1611 1612 1613 1614
			bond_info->rlb_promisc_timeout_counter = 0;

			/* If the primary was set to promiscuous mode
			 * because a slave was disabled then
			 * it can now leave promiscuous mode.
			 */
			dev_set_promiscuity(bond->curr_active_slave->dev, -1);
			bond_info->primary_is_promisc = 0;
1615 1616

			rtnl_unlock();
1617
			rcu_read_lock();
1618
		}
L
Linus Torvalds 已提交
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630

		if (bond_info->rlb_rebalance) {
			bond_info->rlb_rebalance = 0;
			rlb_rebalance(bond);
		}

		/* check if clients need updating */
		if (bond_info->rx_ntt) {
			if (bond_info->rlb_update_delay_counter) {
				--bond_info->rlb_update_delay_counter;
			} else {
				rlb_update_rx_clients(bond);
1631
				if (bond_info->rlb_update_retry_counter)
L
Linus Torvalds 已提交
1632
					--bond_info->rlb_update_retry_counter;
1633
				else
L
Linus Torvalds 已提交
1634 1635 1636 1637
					bond_info->rx_ntt = 0;
			}
		}
	}
1638
	rcu_read_unlock();
L
Linus Torvalds 已提交
1639
re_arm:
1640
	queue_delayed_work(bond->wq, &bond->alb_work, alb_delta_in_ticks);
L
Linus Torvalds 已提交
1641 1642 1643 1644 1645 1646 1647 1648 1649
}

/* assumption: called before the slave is attached to the bond
 * and not locked by the bond lock
 */
int bond_alb_init_slave(struct bonding *bond, struct slave *slave)
{
	int res;

1650
	res = alb_set_slave_mac_addr(slave, slave->perm_hwaddr);
1651
	if (res)
L
Linus Torvalds 已提交
1652 1653 1654
		return res;

	res = alb_handle_addr_collision_on_attach(bond, slave);
1655
	if (res)
L
Linus Torvalds 已提交
1656 1657 1658 1659 1660 1661 1662
		return res;

	tlb_init_slave(slave);

	/* order a rebalance ASAP */
	bond->alb_info.tx_rebalance_counter = BOND_TLB_REBALANCE_TICKS;

1663
	if (bond->alb_info.rlb_enabled)
L
Linus Torvalds 已提交
1664 1665 1666 1667 1668
		bond->alb_info.rlb_rebalance = 1;

	return 0;
}

1669 1670 1671 1672 1673 1674
/*
 * Remove slave from tlb and rlb hash tables, and fix up MAC addresses
 * if necessary.
 *
 * Caller must hold RTNL and no other locks
 */
L
Linus Torvalds 已提交
1675 1676
void bond_alb_deinit_slave(struct bonding *bond, struct slave *slave)
{
1677
	if (bond_has_slaves(bond))
L
Linus Torvalds 已提交
1678 1679 1680 1681 1682
		alb_change_hw_addr_on_detach(bond, slave);

	tlb_clear_slave(bond, slave, 0);

	if (bond->alb_info.rlb_enabled) {
1683
		bond->alb_info.rx_slave = NULL;
L
Linus Torvalds 已提交
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
		rlb_clear_slave(bond, slave);
	}
}

/* Caller must hold bond lock for read */
void bond_alb_handle_link_change(struct bonding *bond, struct slave *slave, char link)
{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));

	if (link == BOND_LINK_DOWN) {
		tlb_clear_slave(bond, slave, 0);
1695
		if (bond->alb_info.rlb_enabled)
L
Linus Torvalds 已提交
1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718
			rlb_clear_slave(bond, slave);
	} else if (link == BOND_LINK_UP) {
		/* order a rebalance ASAP */
		bond_info->tx_rebalance_counter = BOND_TLB_REBALANCE_TICKS;
		if (bond->alb_info.rlb_enabled) {
			bond->alb_info.rlb_rebalance = 1;
			/* If the updelay module parameter is smaller than the
			 * forwarding delay of the switch the rebalance will
			 * not work because the rebalance arp replies will
			 * not be forwarded to the clients..
			 */
		}
	}
}

/**
 * bond_alb_handle_active_change - assign new curr_active_slave
 * @bond: our bonding struct
 * @new_slave: new slave to assign
 *
 * Set the bond->curr_active_slave to @new_slave and handle
 * mac address swapping and promiscuity changes as needed.
 *
1719 1720 1721
 * If new_slave is NULL, caller must hold curr_slave_lock or
 * bond->lock for write.
 *
1722 1723
 * If new_slave is not NULL, caller must hold RTNL, curr_slave_lock
 * for write.  Processing here may sleep, so no other locks may be held.
L
Linus Torvalds 已提交
1724 1725
 */
void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave)
1726 1727
	__releases(&bond->curr_slave_lock)
	__acquires(&bond->curr_slave_lock)
L
Linus Torvalds 已提交
1728 1729 1730
{
	struct slave *swap_slave;

1731
	if (bond->curr_active_slave == new_slave)
L
Linus Torvalds 已提交
1732 1733 1734 1735 1736 1737 1738 1739 1740
		return;

	if (bond->curr_active_slave && bond->alb_info.primary_is_promisc) {
		dev_set_promiscuity(bond->curr_active_slave->dev, -1);
		bond->alb_info.primary_is_promisc = 0;
		bond->alb_info.rlb_promisc_timeout_counter = 0;
	}

	swap_slave = bond->curr_active_slave;
1741
	rcu_assign_pointer(bond->curr_active_slave, new_slave);
L
Linus Torvalds 已提交
1742

1743
	if (!new_slave || !bond_has_slaves(bond))
L
Linus Torvalds 已提交
1744 1745 1746 1747 1748
		return;

	/* set the new curr_active_slave to the bonds mac address
	 * i.e. swap mac addresses of old curr_active_slave and new curr_active_slave
	 */
1749 1750
	if (!swap_slave)
		swap_slave = bond_slave_has_mac(bond, bond->dev->dev_addr);
L
Linus Torvalds 已提交
1751

1752 1753 1754 1755 1756
	/*
	 * Arrange for swap_slave and new_slave to temporarily be
	 * ignored so we can mess with their MAC addresses without
	 * fear of interference from transmit activity.
	 */
1757
	if (swap_slave)
1758 1759 1760 1761 1762
		tlb_clear_slave(bond, swap_slave, 1);
	tlb_clear_slave(bond, new_slave, 1);

	write_unlock_bh(&bond->curr_slave_lock);

1763 1764
	ASSERT_RTNL();

1765 1766 1767
	/* in TLB mode, the slave might flip down/up with the old dev_addr,
	 * and thus filter bond->dev_addr's packets, so force bond's mac
	 */
1768
	if (BOND_MODE(bond) == BOND_MODE_TLB) {
1769 1770 1771
		struct sockaddr sa;
		u8 tmp_addr[ETH_ALEN];

1772
		ether_addr_copy(tmp_addr, new_slave->dev->dev_addr);
1773 1774 1775 1776 1777 1778

		memcpy(sa.sa_data, bond->dev->dev_addr, bond->dev->addr_len);
		sa.sa_family = bond->dev->type;
		/* we don't care if it can't change its mac, best effort */
		dev_set_mac_address(new_slave->dev, &sa);

1779
		ether_addr_copy(new_slave->dev->dev_addr, tmp_addr);
1780 1781
	}

L
Linus Torvalds 已提交
1782 1783 1784
	/* curr_active_slave must be set before calling alb_swap_mac_addr */
	if (swap_slave) {
		/* swap mac address */
1785
		alb_swap_mac_addr(swap_slave, new_slave);
1786 1787
		alb_fasten_mac_swap(bond, swap_slave, new_slave);
	} else {
1788 1789
		/* set the new_slave to the bond mac address */
		alb_set_slave_mac_addr(new_slave, bond->dev->dev_addr);
1790 1791
		alb_send_learning_packets(new_slave, bond->dev->dev_addr,
					  false);
L
Linus Torvalds 已提交
1792
	}
1793 1794

	write_lock_bh(&bond->curr_slave_lock);
L
Linus Torvalds 已提交
1795 1796
}

1797 1798 1799
/*
 * Called with RTNL
 */
L
Linus Torvalds 已提交
1800
int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
1801
	__acquires(&bond->lock)
1802
	__releases(&bond->lock)
L
Linus Torvalds 已提交
1803
{
1804
	struct bonding *bond = netdev_priv(bond_dev);
L
Linus Torvalds 已提交
1805
	struct sockaddr *sa = addr;
1806
	struct slave *swap_slave;
L
Linus Torvalds 已提交
1807 1808
	int res;

1809
	if (!is_valid_ether_addr(sa->sa_data))
L
Linus Torvalds 已提交
1810 1811 1812
		return -EADDRNOTAVAIL;

	res = alb_set_mac_address(bond, addr);
1813
	if (res)
L
Linus Torvalds 已提交
1814 1815 1816 1817 1818 1819 1820 1821
		return res;

	memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);

	/* If there is no curr_active_slave there is nothing else to do.
	 * Otherwise we'll need to pass the new address to it and handle
	 * duplications.
	 */
1822
	if (!bond->curr_active_slave)
L
Linus Torvalds 已提交
1823 1824
		return 0;

1825
	swap_slave = bond_slave_has_mac(bond, bond_dev->dev_addr);
L
Linus Torvalds 已提交
1826 1827

	if (swap_slave) {
1828
		alb_swap_mac_addr(swap_slave, bond->curr_active_slave);
1829
		alb_fasten_mac_swap(bond, swap_slave, bond->curr_active_slave);
L
Linus Torvalds 已提交
1830
	} else {
1831
		alb_set_slave_mac_addr(bond->curr_active_slave, bond_dev->dev_addr);
L
Linus Torvalds 已提交
1832

1833
		read_lock(&bond->lock);
1834 1835
		alb_send_learning_packets(bond->curr_active_slave,
					  bond_dev->dev_addr, false);
L
Linus Torvalds 已提交
1836 1837 1838 1839
		if (bond->alb_info.rlb_enabled) {
			/* inform clients mac address has changed */
			rlb_req_update_slave_clients(bond, bond->curr_active_slave);
		}
1840
		read_unlock(&bond->lock);
L
Linus Torvalds 已提交
1841 1842 1843 1844 1845 1846 1847
	}

	return 0;
}

void bond_alb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
{
1848
	if (bond->alb_info.rlb_enabled)
L
Linus Torvalds 已提交
1849 1850 1851
		rlb_clear_vlan(bond, vlan_id);
}