bcast.c 22.8 KB
Newer Older
P
Per Liden 已提交
1 2
/*
 * net/tipc/bcast.c: TIPC broadcast code
3
 *
P
Per Liden 已提交
4
 * Copyright (c) 2004-2006, Ericsson AB
P
Per Liden 已提交
5 6 7 8
 * Copyright (c) 2004, Intel Corporation.
 * Copyright (c) 2005, Wind River Systems
 * All rights reserved.
 *
P
Per Liden 已提交
9
 * Redistribution and use in source and binary forms, with or without
P
Per Liden 已提交
10 11
 * modification, are permitted provided that the following conditions are met:
 *
P
Per Liden 已提交
12 13 14 15 16 17 18 19
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
P
Per Liden 已提交
20
 *
P
Per Liden 已提交
21 22 23 24 25 26 27 28 29 30 31 32 33 34
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
P
Per Liden 已提交
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "core.h"
#include "msg.h"
#include "dbg.h"
#include "link.h"
#include "net.h"
#include "node.h"
#include "port.h"
#include "addr.h"
#include "node_subscr.h"
#include "name_distr.h"
#include "bearer.h"
#include "name_table.h"
#include "bcast.h"

#define MAX_PKT_DEFAULT_MCAST 1500	/* bcast link max packet size (fixed) */

#define BCLINK_WIN_DEFAULT 20		/* bcast link window size (default) */

#define BCLINK_LOG_BUF_SIZE 0

58 59 60 61
/*
 * Loss rate for incoming broadcast frames; used to test retransmission code.
 * Set to N to cause every N'th frame to be discarded; 0 => don't discard any.
 */
62

63 64
#define TIPC_BCAST_LOSS_RATE 0

P
Per Liden 已提交
65 66 67 68
/**
 * struct bcbearer_pair - a pair of bearers used by broadcast link
 * @primary: pointer to primary bearer
 * @secondary: pointer to secondary bearer
69 70
 *
 * Bearers must have same priority and same set of reachable destinations
P
Per Liden 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83
 * to be paired.
 */

struct bcbearer_pair {
	struct bearer *primary;
	struct bearer *secondary;
};

/**
 * struct bcbearer - bearer used by broadcast link
 * @bearer: (non-standard) broadcast bearer structure
 * @media: (non-standard) broadcast media structure
 * @bpairs: array of bearer pairs
84 85 86
 * @bpairs_temp: temporary array of bearer pairs used by tipc_bcbearer_sort()
 * @remains: temporary node map used by tipc_bcbearer_send()
 * @remains_new: temporary node map used tipc_bcbearer_send()
87
 *
88 89 90 91
 * Note: The fields labelled "temporary" are incorporated into the bearer
 * to avoid consuming potentially limited stack space through the use of
 * large local variables within multicast routines.  Concurrent access is
 * prevented through use of the spinlock "bc_lock".
P
Per Liden 已提交
92 93 94 95 96 97
 */

struct bcbearer {
	struct bearer bearer;
	struct media media;
	struct bcbearer_pair bpairs[MAX_BEARERS];
P
Per Liden 已提交
98
	struct bcbearer_pair bpairs_temp[TIPC_MAX_LINK_PRI + 1];
99 100
	struct tipc_node_map remains;
	struct tipc_node_map remains_new;
P
Per Liden 已提交
101 102 103 104 105 106
};

/**
 * struct bclink - link used for broadcast messages
 * @link: (non-standard) broadcast link structure
 * @node: (non-standard) node structure representing b'cast link's peer node
107
 *
P
Per Liden 已提交
108 109 110 111 112
 * Handles sequence numbering, fragmentation, bundling, etc.
 */

struct bclink {
	struct link link;
113
	struct tipc_node node;
P
Per Liden 已提交
114 115 116 117 118 119
};


static struct bcbearer *bcbearer = NULL;
static struct bclink *bclink = NULL;
static struct link *bcl = NULL;
I
Ingo Molnar 已提交
120
static DEFINE_SPINLOCK(bc_lock);
P
Per Liden 已提交
121

122
const char tipc_bclink_name[] = "broadcast-link";
P
Per Liden 已提交
123 124


S
Sam Ravnborg 已提交
125
static u32 buf_seqno(struct sk_buff *buf)
P
Per Liden 已提交
126 127
{
	return msg_seqno(buf_msg(buf));
128
}
P
Per Liden 已提交
129

S
Sam Ravnborg 已提交
130
static u32 bcbuf_acks(struct sk_buff *buf)
P
Per Liden 已提交
131
{
132
	return (u32)(unsigned long)TIPC_SKB_CB(buf)->handle;
P
Per Liden 已提交
133 134
}

S
Sam Ravnborg 已提交
135
static void bcbuf_set_acks(struct sk_buff *buf, u32 acks)
P
Per Liden 已提交
136
{
137
	TIPC_SKB_CB(buf)->handle = (void *)(unsigned long)acks;
P
Per Liden 已提交
138 139
}

S
Sam Ravnborg 已提交
140
static void bcbuf_decr_acks(struct sk_buff *buf)
P
Per Liden 已提交
141 142 143 144 145
{
	bcbuf_set_acks(buf, bcbuf_acks(buf) - 1);
}


146
/**
P
Per Liden 已提交
147
 * bclink_set_gap - set gap according to contents of current deferred pkt queue
148
 *
P
Per Liden 已提交
149 150 151
 * Called with 'node' locked, bc_lock unlocked
 */

152
static void bclink_set_gap(struct tipc_node *n_ptr)
P
Per Liden 已提交
153 154 155 156 157 158 159 160 161
{
	struct sk_buff *buf = n_ptr->bclink.deferred_head;

	n_ptr->bclink.gap_after = n_ptr->bclink.gap_to =
		mod(n_ptr->bclink.last_in);
	if (unlikely(buf != NULL))
		n_ptr->bclink.gap_to = mod(buf_seqno(buf) - 1);
}

162
/**
P
Per Liden 已提交
163
 * bclink_ack_allowed - test if ACK or NACK message can be sent at this moment
164
 *
P
Per Liden 已提交
165 166
 * This mechanism endeavours to prevent all nodes in network from trying
 * to ACK or NACK at the same time.
167
 *
P
Per Liden 已提交
168
 * Note: TIPC uses a different trigger to distribute ACKs than it does to
169
 *       distribute NACKs, but tries to use the same spacing (divide by 16).
P
Per Liden 已提交
170 171
 */

S
Sam Ravnborg 已提交
172
static int bclink_ack_allowed(u32 n)
P
Per Liden 已提交
173 174 175 176 177
{
	return((n % TIPC_MIN_LINK_WIN) == tipc_own_tag);
}


178
/**
P
Per Liden 已提交
179 180 181
 * bclink_retransmit_pkt - retransmit broadcast packets
 * @after: sequence number of last packet to *not* retransmit
 * @to: sequence number of last packet to retransmit
182
 *
183
 * Called with bc_lock locked
P
Per Liden 已提交
184 185 186 187 188 189 190 191
 */

static void bclink_retransmit_pkt(u32 after, u32 to)
{
	struct sk_buff *buf;

	buf = bcl->first_out;
	while (buf && less_eq(buf_seqno(buf), after)) {
192
		buf = buf->next;
P
Per Liden 已提交
193
	}
194
	tipc_link_retransmit(bcl, buf, mod(to - after));
P
Per Liden 已提交
195 196
}

197
/**
198
 * tipc_bclink_acknowledge - handle acknowledgement of broadcast packets
P
Per Liden 已提交
199 200
 * @n_ptr: node that sent acknowledgement info
 * @acked: broadcast sequence # that has been acknowledged
201
 *
P
Per Liden 已提交
202 203 204
 * Node is locked, bc_lock unlocked.
 */

205
void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked)
P
Per Liden 已提交
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
{
	struct sk_buff *crs;
	struct sk_buff *next;
	unsigned int released = 0;

	if (less_eq(acked, n_ptr->bclink.acked))
		return;

	spin_lock_bh(&bc_lock);

	/* Skip over packets that node has previously acknowledged */

	crs = bcl->first_out;
	while (crs && less_eq(buf_seqno(crs), n_ptr->bclink.acked)) {
		crs = crs->next;
	}

	/* Update packets that node is now acknowledging */

	while (crs && less_eq(buf_seqno(crs), acked)) {
		next = crs->next;
		bcbuf_decr_acks(crs);
		if (bcbuf_acks(crs) == 0) {
			bcl->first_out = next;
			bcl->out_queue_size--;
			buf_discard(crs);
			released = 1;
		}
		crs = next;
	}
	n_ptr->bclink.acked = acked;

	/* Try resolving broadcast link congestion, if necessary */

	if (unlikely(bcl->next_out))
241
		tipc_link_push_queue(bcl);
P
Per Liden 已提交
242
	if (unlikely(released && !list_empty(&bcl->waiting_ports)))
243
		tipc_link_wakeup_ports(bcl, 0);
P
Per Liden 已提交
244 245 246
	spin_unlock_bh(&bc_lock);
}

247
/**
P
Per Liden 已提交
248
 * bclink_send_ack - unicast an ACK msg
249
 *
250
 * tipc_net_lock and node lock set
P
Per Liden 已提交
251 252
 */

253
static void bclink_send_ack(struct tipc_node *n_ptr)
P
Per Liden 已提交
254 255 256 257
{
	struct link *l_ptr = n_ptr->active_links[n_ptr->addr & 1];

	if (l_ptr != NULL)
258
		tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
P
Per Liden 已提交
259 260
}

261
/**
P
Per Liden 已提交
262
 * bclink_send_nack- broadcast a NACK msg
263
 *
264
 * tipc_net_lock and node lock set
P
Per Liden 已提交
265 266
 */

267
static void bclink_send_nack(struct tipc_node *n_ptr)
P
Per Liden 已提交
268 269 270 271 272 273 274 275 276 277
{
	struct sk_buff *buf;
	struct tipc_msg *msg;

	if (!less(n_ptr->bclink.gap_after, n_ptr->bclink.gap_to))
		return;

	buf = buf_acquire(INT_H_SIZE);
	if (buf) {
		msg = buf_msg(buf);
278
		tipc_msg_init(msg, BCAST_PROTOCOL, STATE_MSG,
279
			 INT_H_SIZE, n_ptr->addr);
P
Per Liden 已提交
280
		msg_set_mc_netid(msg, tipc_net_id);
281
		msg_set_bcast_ack(msg, mod(n_ptr->bclink.last_in));
P
Per Liden 已提交
282 283 284 285
		msg_set_bcgap_after(msg, n_ptr->bclink.gap_after);
		msg_set_bcgap_to(msg, n_ptr->bclink.gap_to);
		msg_set_bcast_tag(msg, tipc_own_tag);

286
		if (tipc_bearer_send(&bcbearer->bearer, buf, NULL)) {
P
Per Liden 已提交
287 288 289
			bcl->stats.sent_nacks++;
			buf_discard(buf);
		} else {
290
			tipc_bearer_schedule(bcl->b_ptr, bcl);
P
Per Liden 已提交
291 292 293 294
			bcl->proto_msg_queue = buf;
			bcl->stats.bearer_congs++;
		}

295
		/*
P
Per Liden 已提交
296 297 298 299
		 * Ensure we doesn't send another NACK msg to the node
		 * until 16 more deferred messages arrive from it
		 * (i.e. helps prevent all nodes from NACK'ing at same time)
		 */
300

P
Per Liden 已提交
301 302 303 304
		n_ptr->bclink.nack_sync = tipc_own_tag;
	}
}

305
/**
306
 * tipc_bclink_check_gap - send a NACK if a sequence gap exists
P
Per Liden 已提交
307
 *
308
 * tipc_net_lock and node lock set
P
Per Liden 已提交
309 310
 */

311
void tipc_bclink_check_gap(struct tipc_node *n_ptr, u32 last_sent)
P
Per Liden 已提交
312 313 314 315 316 317 318 319 320 321 322
{
	if (!n_ptr->bclink.supported ||
	    less_eq(last_sent, mod(n_ptr->bclink.last_in)))
		return;

	bclink_set_gap(n_ptr);
	if (n_ptr->bclink.gap_after == n_ptr->bclink.gap_to)
		n_ptr->bclink.gap_to = last_sent;
	bclink_send_nack(n_ptr);
}

323
/**
324
 * tipc_bclink_peek_nack - process a NACK msg meant for another node
325
 *
326
 * Only tipc_net_lock set.
P
Per Liden 已提交
327 328
 */

A
Adrian Bunk 已提交
329
static void tipc_bclink_peek_nack(u32 dest, u32 sender_tag, u32 gap_after, u32 gap_to)
P
Per Liden 已提交
330
{
331
	struct tipc_node *n_ptr = tipc_node_find(dest);
P
Per Liden 已提交
332 333
	u32 my_after, my_to;

334
	if (unlikely(!n_ptr || !tipc_node_is_up(n_ptr)))
P
Per Liden 已提交
335
		return;
336
	tipc_node_lock(n_ptr);
P
Per Liden 已提交
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
	/*
	 * Modify gap to suppress unnecessary NACKs from this node
	 */
	my_after = n_ptr->bclink.gap_after;
	my_to = n_ptr->bclink.gap_to;

	if (less_eq(gap_after, my_after)) {
		if (less(my_after, gap_to) && less(gap_to, my_to))
			n_ptr->bclink.gap_after = gap_to;
		else if (less_eq(my_to, gap_to))
			n_ptr->bclink.gap_to = n_ptr->bclink.gap_after;
	} else if (less_eq(gap_after, my_to)) {
		if (less_eq(my_to, gap_to))
			n_ptr->bclink.gap_to = gap_after;
	} else {
352
		/*
P
Per Liden 已提交
353 354 355 356 357 358 359 360
		 * Expand gap if missing bufs not in deferred queue:
		 */
		struct sk_buff *buf = n_ptr->bclink.deferred_head;
		u32 prev = n_ptr->bclink.gap_to;

		for (; buf; buf = buf->next) {
			u32 seqno = buf_seqno(buf);

361
			if (mod(seqno - prev) != 1) {
P
Per Liden 已提交
362
				buf = NULL;
363 364
				break;
			}
P
Per Liden 已提交
365 366 367 368 369 370 371 372 373
			if (seqno == gap_after)
				break;
			prev = seqno;
		}
		if (buf == NULL)
			n_ptr->bclink.gap_to = gap_after;
	}
	/*
	 * Some nodes may send a complementary NACK now:
374
	 */
P
Per Liden 已提交
375 376 377 378 379 380
	if (bclink_ack_allowed(sender_tag + 1)) {
		if (n_ptr->bclink.gap_to != n_ptr->bclink.gap_after) {
			bclink_send_nack(n_ptr);
			bclink_set_gap(n_ptr);
		}
	}
381
	tipc_node_unlock(n_ptr);
P
Per Liden 已提交
382 383 384
}

/**
385
 * tipc_bclink_send_msg - broadcast a packet to all nodes in cluster
P
Per Liden 已提交
386 387
 */

388
int tipc_bclink_send_msg(struct sk_buff *buf)
P
Per Liden 已提交
389 390 391 392 393
{
	int res;

	spin_lock_bh(&bc_lock);

394
	res = tipc_link_send_buf(bcl, buf);
P
Per Liden 已提交
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
	if (unlikely(res == -ELINKCONG))
		buf_discard(buf);
	else
		bcl->stats.sent_info++;

	if (bcl->out_queue_size > bcl->stats.max_queue_sz)
		bcl->stats.max_queue_sz = bcl->out_queue_size;
	bcl->stats.queue_sz_counts++;
	bcl->stats.accu_queue_sz += bcl->out_queue_size;

	spin_unlock_bh(&bc_lock);
	return res;
}

/**
410
 * tipc_bclink_recv_pkt - receive a broadcast packet, and deliver upwards
411
 *
412
 * tipc_net_lock is read_locked, no other locks set
P
Per Liden 已提交
413 414
 */

415
void tipc_bclink_recv_pkt(struct sk_buff *buf)
416 417 418 419
{
#if (TIPC_BCAST_LOSS_RATE)
	static int rx_count = 0;
#endif
P
Per Liden 已提交
420
	struct tipc_msg *msg = buf_msg(buf);
421
	struct tipc_node* node = tipc_node_find(msg_prevnode(msg));
P
Per Liden 已提交
422 423 424 425 426 427
	u32 next_in;
	u32 seqno;
	struct sk_buff *deferred;

	msg_dbg(msg, "<BC<<<");

428
	if (unlikely(!node || !tipc_node_is_up(node) || !node->bclink.supported ||
P
Per Liden 已提交
429 430 431 432 433 434 435 436
		     (msg_mc_netid(msg) != tipc_net_id))) {
		buf_discard(buf);
		return;
	}

	if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
		msg_dbg(msg, "<BCNACK<<<");
		if (msg_destnode(msg) == tipc_own_addr) {
437 438 439
			tipc_node_lock(node);
			tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
			tipc_node_unlock(node);
440
			spin_lock_bh(&bc_lock);
P
Per Liden 已提交
441
			bcl->stats.recv_nacks++;
442
			bcl->owner->next = node;   /* remember requestor */
P
Per Liden 已提交
443 444
			bclink_retransmit_pkt(msg_bcgap_after(msg),
					      msg_bcgap_to(msg));
445
			bcl->owner->next = NULL;
446
			spin_unlock_bh(&bc_lock);
P
Per Liden 已提交
447
		} else {
448
			tipc_bclink_peek_nack(msg_destnode(msg),
A
Adrian Bunk 已提交
449 450 451
					      msg_bcast_tag(msg),
					      msg_bcgap_after(msg),
					      msg_bcgap_to(msg));
P
Per Liden 已提交
452 453 454 455 456
		}
		buf_discard(buf);
		return;
	}

457 458 459 460 461 462 463 464
#if (TIPC_BCAST_LOSS_RATE)
	if (++rx_count == TIPC_BCAST_LOSS_RATE) {
		rx_count = 0;
		buf_discard(buf);
		return;
	}
#endif

465
	tipc_node_lock(node);
P
Per Liden 已提交
466 467 468 469 470 471 472 473 474 475 476 477 478 479
receive:
	deferred = node->bclink.deferred_head;
	next_in = mod(node->bclink.last_in + 1);
	seqno = msg_seqno(msg);

	if (likely(seqno == next_in)) {
		bcl->stats.recv_info++;
		node->bclink.last_in++;
		bclink_set_gap(node);
		if (unlikely(bclink_ack_allowed(seqno))) {
			bclink_send_ack(node);
			bcl->stats.sent_acks++;
		}
		if (likely(msg_isdata(msg))) {
480 481
			tipc_node_unlock(node);
			tipc_port_recv_mcast(buf, NULL);
P
Per Liden 已提交
482 483 484
		} else if (msg_user(msg) == MSG_BUNDLER) {
			bcl->stats.recv_bundles++;
			bcl->stats.recv_bundled += msg_msgcnt(msg);
485 486
			tipc_node_unlock(node);
			tipc_link_recv_bundle(buf);
P
Per Liden 已提交
487 488
		} else if (msg_user(msg) == MSG_FRAGMENTER) {
			bcl->stats.recv_fragments++;
489 490
			if (tipc_link_recv_fragment(&node->bclink.defragm,
						    &buf, &msg))
P
Per Liden 已提交
491
				bcl->stats.recv_fragmented++;
492 493
			tipc_node_unlock(node);
			tipc_net_route_msg(buf);
P
Per Liden 已提交
494
		} else {
495 496
			tipc_node_unlock(node);
			tipc_net_route_msg(buf);
P
Per Liden 已提交
497 498
		}
		if (deferred && (buf_seqno(deferred) == mod(next_in + 1))) {
499
			tipc_node_lock(node);
P
Per Liden 已提交
500 501 502 503 504 505 506 507 508 509
			buf = deferred;
			msg = buf_msg(buf);
			node->bclink.deferred_head = deferred->next;
			goto receive;
		}
		return;
	} else if (less(next_in, seqno)) {
		u32 gap_after = node->bclink.gap_after;
		u32 gap_to = node->bclink.gap_to;

510 511 512
		if (tipc_link_defer_pkt(&node->bclink.deferred_head,
					&node->bclink.deferred_tail,
					buf)) {
P
Per Liden 已提交
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
			node->bclink.nack_sync++;
			bcl->stats.deferred_recv++;
			if (seqno == mod(gap_after + 1))
				node->bclink.gap_after = seqno;
			else if (less(gap_after, seqno) && less(seqno, gap_to))
				node->bclink.gap_to = seqno;
		}
		if (bclink_ack_allowed(node->bclink.nack_sync)) {
			if (gap_to != gap_after)
				bclink_send_nack(node);
			bclink_set_gap(node);
		}
	} else {
		bcl->stats.duplicates++;
		buf_discard(buf);
	}
529
	tipc_node_unlock(node);
P
Per Liden 已提交
530 531
}

532
u32 tipc_bclink_get_last_sent(void)
P
Per Liden 已提交
533 534 535 536 537 538 539 540
{
	u32 last_sent = mod(bcl->next_out_no - 1);

	if (bcl->next_out)
		last_sent = mod(buf_seqno(bcl->next_out) - 1);
	return last_sent;
}

541
u32 tipc_bclink_acks_missing(struct tipc_node *n_ptr)
P
Per Liden 已提交
542 543
{
	return (n_ptr->bclink.supported &&
544
		(tipc_bclink_get_last_sent() != n_ptr->bclink.acked));
P
Per Liden 已提交
545 546 547 548
}


/**
549
 * tipc_bcbearer_send - send a packet through the broadcast pseudo-bearer
550
 *
P
Per Liden 已提交
551 552
 * Send through as many bearers as necessary to reach all nodes
 * that support TIPC multicasting.
553
 *
P
Per Liden 已提交
554 555 556
 * Returns 0 if packet sent successfully, non-zero if not
 */

A
Adrian Bunk 已提交
557 558 559
static int tipc_bcbearer_send(struct sk_buff *buf,
			      struct tipc_bearer *unused1,
			      struct tipc_media_addr *unused2)
P
Per Liden 已提交
560 561 562 563 564 565 566 567
{
	int bp_index;

	/* Prepare buffer for broadcasting (if first time trying to send it) */

	if (likely(!msg_non_seq(buf_msg(buf)))) {
		struct tipc_msg *msg;

568 569
		assert(tipc_cltr_bcast_nodes.count != 0);
		bcbuf_set_acks(buf, tipc_cltr_bcast_nodes.count);
P
Per Liden 已提交
570
		msg = buf_msg(buf);
571
		msg_set_non_seq(msg, 1);
P
Per Liden 已提交
572 573 574 575
		msg_set_mc_netid(msg, tipc_net_id);
	}

	/* Send buffer over bearers until all targets reached */
576

577
	bcbearer->remains = tipc_cltr_bcast_nodes;
P
Per Liden 已提交
578 579 580 581 582 583 584 585

	for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
		struct bearer *p = bcbearer->bpairs[bp_index].primary;
		struct bearer *s = bcbearer->bpairs[bp_index].secondary;

		if (!p)
			break;	/* no more bearers to try */

586 587
		tipc_nmap_diff(&bcbearer->remains, &p->nodes, &bcbearer->remains_new);
		if (bcbearer->remains_new.count == bcbearer->remains.count)
P
Per Liden 已提交
588 589
			continue;	/* bearer pair doesn't add anything */

590 591 592 593 594 595 596 597 598 599 600 601 602 603
		if (p->publ.blocked ||
		    p->media->send_msg(buf, &p->publ, &p->media->bcast_addr)) {
			/* unable to send on primary bearer */
			if (!s || s->publ.blocked ||
			    s->media->send_msg(buf, &s->publ,
					       &s->media->bcast_addr)) {
				/* unable to send on either bearer */
				continue;
			}
		}

		if (s) {
			bcbearer->bpairs[bp_index].primary = s;
			bcbearer->bpairs[bp_index].secondary = p;
P
Per Liden 已提交
604 605
		}

606
		if (bcbearer->remains_new.count == 0)
607
			return 0;
P
Per Liden 已提交
608

609
		bcbearer->remains = bcbearer->remains_new;
P
Per Liden 已提交
610
	}
611

P
Per Liden 已提交
612 613 614 615
	/* Unable to reach all targets */

	bcbearer->bearer.publ.blocked = 1;
	bcl->stats.bearer_congs++;
616
	return 1;
P
Per Liden 已提交
617 618 619
}

/**
620
 * tipc_bcbearer_sort - create sets of bearer pairs used by broadcast bearer
P
Per Liden 已提交
621 622
 */

623
void tipc_bcbearer_sort(void)
P
Per Liden 已提交
624 625 626 627 628 629 630 631 632 633 634 635 636
{
	struct bcbearer_pair *bp_temp = bcbearer->bpairs_temp;
	struct bcbearer_pair *bp_curr;
	int b_index;
	int pri;

	spin_lock_bh(&bc_lock);

	/* Group bearers by priority (can assume max of two per priority) */

	memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));

	for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
637
		struct bearer *b = &tipc_bearers[b_index];
P
Per Liden 已提交
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652

		if (!b->active || !b->nodes.count)
			continue;

		if (!bp_temp[b->priority].primary)
			bp_temp[b->priority].primary = b;
		else
			bp_temp[b->priority].secondary = b;
	}

	/* Create array of bearer pairs for broadcasting */

	bp_curr = bcbearer->bpairs;
	memset(bcbearer->bpairs, 0, sizeof(bcbearer->bpairs));

P
Per Liden 已提交
653
	for (pri = TIPC_MAX_LINK_PRI; pri >= 0; pri--) {
P
Per Liden 已提交
654 655 656 657 658 659 660

		if (!bp_temp[pri].primary)
			continue;

		bp_curr->primary = bp_temp[pri].primary;

		if (bp_temp[pri].secondary) {
661 662
			if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
					    &bp_temp[pri].secondary->nodes)) {
P
Per Liden 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675 676
				bp_curr->secondary = bp_temp[pri].secondary;
			} else {
				bp_curr++;
				bp_curr->primary = bp_temp[pri].secondary;
			}
		}

		bp_curr++;
	}

	spin_unlock_bh(&bc_lock);
}

/**
677
 * tipc_bcbearer_push - resolve bearer congestion
678
 *
P
Per Liden 已提交
679 680 681 682 683
 * Forces bclink to push out any unsent packets, until all packets are gone
 * or congestion reoccurs.
 * No locks set when function called
 */

684
void tipc_bcbearer_push(void)
P
Per Liden 已提交
685 686 687 688 689 690 691
{
	struct bearer *b_ptr;

	spin_lock_bh(&bc_lock);
	b_ptr = &bcbearer->bearer;
	if (b_ptr->publ.blocked) {
		b_ptr->publ.blocked = 0;
692
		tipc_bearer_lock_push(b_ptr);
P
Per Liden 已提交
693 694 695 696 697
	}
	spin_unlock_bh(&bc_lock);
}


698
int tipc_bclink_stats(char *buf, const u32 buf_size)
P
Per Liden 已提交
699 700 701 702 703 704
{
	struct print_buf pb;

	if (!bcl)
		return 0;

705
	tipc_printbuf_init(&pb, buf, buf_size);
P
Per Liden 已提交
706 707 708 709

	spin_lock_bh(&bc_lock);

	tipc_printf(&pb, "Link <%s>\n"
710
			 "  Window:%u packets\n",
P
Per Liden 已提交
711
		    bcl->name, bcl->queue_limit[0]);
712
	tipc_printf(&pb, "  RX packets:%u fragments:%u/%u bundles:%u/%u\n",
P
Per Liden 已提交
713 714 715 716 717
		    bcl->stats.recv_info,
		    bcl->stats.recv_fragments,
		    bcl->stats.recv_fragmented,
		    bcl->stats.recv_bundles,
		    bcl->stats.recv_bundled);
718
	tipc_printf(&pb, "  TX packets:%u fragments:%u/%u bundles:%u/%u\n",
P
Per Liden 已提交
719 720
		    bcl->stats.sent_info,
		    bcl->stats.sent_fragments,
721
		    bcl->stats.sent_fragmented,
P
Per Liden 已提交
722 723
		    bcl->stats.sent_bundles,
		    bcl->stats.sent_bundled);
724
	tipc_printf(&pb, "  RX naks:%u defs:%u dups:%u\n",
P
Per Liden 已提交
725
		    bcl->stats.recv_nacks,
726
		    bcl->stats.deferred_recv,
P
Per Liden 已提交
727
		    bcl->stats.duplicates);
728 729 730
	tipc_printf(&pb, "  TX naks:%u acks:%u dups:%u\n",
		    bcl->stats.sent_nacks,
		    bcl->stats.sent_acks,
P
Per Liden 已提交
731 732 733 734 735 736 737 738 739 740
		    bcl->stats.retransmitted);
	tipc_printf(&pb, "  Congestion bearer:%u link:%u  Send queue max:%u avg:%u\n",
		    bcl->stats.bearer_congs,
		    bcl->stats.link_congs,
		    bcl->stats.max_queue_sz,
		    bcl->stats.queue_sz_counts
		    ? (bcl->stats.accu_queue_sz / bcl->stats.queue_sz_counts)
		    : 0);

	spin_unlock_bh(&bc_lock);
741
	return tipc_printbuf_validate(&pb);
P
Per Liden 已提交
742 743
}

744
int tipc_bclink_reset_stats(void)
P
Per Liden 已提交
745 746 747 748 749 750 751
{
	if (!bcl)
		return -ENOPROTOOPT;

	spin_lock_bh(&bc_lock);
	memset(&bcl->stats, 0, sizeof(bcl->stats));
	spin_unlock_bh(&bc_lock);
752
	return 0;
P
Per Liden 已提交
753 754
}

755
int tipc_bclink_set_queue_limits(u32 limit)
P
Per Liden 已提交
756 757 758 759 760 761 762
{
	if (!bcl)
		return -ENOPROTOOPT;
	if ((limit < TIPC_MIN_LINK_WIN) || (limit > TIPC_MAX_LINK_WIN))
		return -EINVAL;

	spin_lock_bh(&bc_lock);
763
	tipc_link_set_queue_limits(bcl, limit);
P
Per Liden 已提交
764
	spin_unlock_bh(&bc_lock);
765
	return 0;
P
Per Liden 已提交
766 767
}

768
int tipc_bclink_init(void)
P
Per Liden 已提交
769
{
770 771
	bcbearer = kzalloc(sizeof(*bcbearer), GFP_ATOMIC);
	bclink = kzalloc(sizeof(*bclink), GFP_ATOMIC);
P
Per Liden 已提交
772 773
	if (!bcbearer || !bclink) {
 nomem:
774
		warn("Multicast link creation failed, no memory\n");
P
Per Liden 已提交
775 776 777 778 779 780 781 782 783
		kfree(bcbearer);
		bcbearer = NULL;
		kfree(bclink);
		bclink = NULL;
		return -ENOMEM;
	}

	INIT_LIST_HEAD(&bcbearer->bearer.cong_links);
	bcbearer->bearer.media = &bcbearer->media;
784
	bcbearer->media.send_msg = tipc_bcbearer_send;
P
Per Liden 已提交
785 786 787 788 789
	sprintf(bcbearer->media.name, "tipc-multicast");

	bcl = &bclink->link;
	INIT_LIST_HEAD(&bcl->waiting_ports);
	bcl->next_out_no = 1;
I
Ingo Molnar 已提交
790
	spin_lock_init(&bclink->node.lock);
P
Per Liden 已提交
791
	bcl->owner = &bclink->node;
792
	bcl->max_pkt = MAX_PKT_DEFAULT_MCAST;
793
	tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
P
Per Liden 已提交
794 795
	bcl->b_ptr = &bcbearer->bearer;
	bcl->state = WORKING_WORKING;
796
	strlcpy(bcl->name, tipc_bclink_name, TIPC_MAX_LINK_NAME);
P
Per Liden 已提交
797 798 799 800 801 802

	if (BCLINK_LOG_BUF_SIZE) {
		char *pb = kmalloc(BCLINK_LOG_BUF_SIZE, GFP_ATOMIC);

		if (!pb)
			goto nomem;
803
		tipc_printbuf_init(&bcl->print_buf, pb, BCLINK_LOG_BUF_SIZE);
P
Per Liden 已提交
804 805
	}

806
	return 0;
P
Per Liden 已提交
807 808
}

809
void tipc_bclink_stop(void)
P
Per Liden 已提交
810 811 812
{
	spin_lock_bh(&bc_lock);
	if (bcbearer) {
813
		tipc_link_stop(bcl);
P
Per Liden 已提交
814 815 816 817 818 819 820 821 822 823 824
		if (BCLINK_LOG_BUF_SIZE)
			kfree(bcl->print_buf.buf);
		bcl = NULL;
		kfree(bclink);
		bclink = NULL;
		kfree(bcbearer);
		bcbearer = NULL;
	}
	spin_unlock_bh(&bc_lock);
}

825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 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

/**
 * tipc_nmap_add - add a node to a node map
 */

void tipc_nmap_add(struct tipc_node_map *nm_ptr, u32 node)
{
	int n = tipc_node(node);
	int w = n / WSIZE;
	u32 mask = (1 << (n % WSIZE));

	if ((nm_ptr->map[w] & mask) == 0) {
		nm_ptr->count++;
		nm_ptr->map[w] |= mask;
	}
}

/**
 * tipc_nmap_remove - remove a node from a node map
 */

void tipc_nmap_remove(struct tipc_node_map *nm_ptr, u32 node)
{
	int n = tipc_node(node);
	int w = n / WSIZE;
	u32 mask = (1 << (n % WSIZE));

	if ((nm_ptr->map[w] & mask) != 0) {
		nm_ptr->map[w] &= ~mask;
		nm_ptr->count--;
	}
}

/**
 * tipc_nmap_diff - find differences between node maps
 * @nm_a: input node map A
 * @nm_b: input node map B
 * @nm_diff: output node map A-B (i.e. nodes of A that are not in B)
 */

void tipc_nmap_diff(struct tipc_node_map *nm_a, struct tipc_node_map *nm_b,
				  struct tipc_node_map *nm_diff)
{
	int stop = ARRAY_SIZE(nm_a->map);
	int w;
	int b;
	u32 map;

	memset(nm_diff, 0, sizeof(*nm_diff));
	for (w = 0; w < stop; w++) {
		map = nm_a->map[w] ^ (nm_a->map[w] & nm_b->map[w]);
		nm_diff->map[w] = map;
		if (map != 0) {
			for (b = 0 ; b < WSIZE; b++) {
				if (map & (1 << b))
					nm_diff->count++;
			}
		}
	}
}
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 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934

/**
 * tipc_port_list_add - add a port to a port list, ensuring no duplicates
 */

void tipc_port_list_add(struct port_list *pl_ptr, u32 port)
{
	struct port_list *item = pl_ptr;
	int i;
	int item_sz = PLSIZE;
	int cnt = pl_ptr->count;

	for (; ; cnt -= item_sz, item = item->next) {
		if (cnt < PLSIZE)
			item_sz = cnt;
		for (i = 0; i < item_sz; i++)
			if (item->ports[i] == port)
				return;
		if (i < PLSIZE) {
			item->ports[i] = port;
			pl_ptr->count++;
			return;
		}
		if (!item->next) {
			item->next = kmalloc(sizeof(*item), GFP_ATOMIC);
			if (!item->next) {
				warn("Incomplete multicast delivery, no memory\n");
				return;
			}
			item->next->next = NULL;
		}
	}
}

/**
 * tipc_port_list_free - free dynamically created entries in port_list chain
 *
 */

void tipc_port_list_free(struct port_list *pl_ptr)
{
	struct port_list *item;
	struct port_list *next;

	for (item = pl_ptr->next; item; item = next) {
		next = item->next;
		kfree(item);
	}
}