bcast.c 21.0 KB
Newer Older
P
Per Liden 已提交
1 2 3
/*
 * net/tipc/bcast.c: TIPC broadcast code
 *     
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 62 63 64
/*
 * 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.
 */
 
#define TIPC_BCAST_LOSS_RATE 0

P
Per Liden 已提交
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
/**
 * struct bcbearer_pair - a pair of bearers used by broadcast link
 * @primary: pointer to primary bearer
 * @secondary: pointer to secondary bearer
 * 
 * Bearers must have same priority and same set of reachable destinations 
 * 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 87 88 89 90 91
 * @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()
 * 
 * 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 node_map remains;
	struct node_map remains_new;
P
Per Liden 已提交
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
};

/**
 * 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
 * 
 * Handles sequence numbering, fragmentation, bundling, etc.
 */

struct bclink {
	struct link link;
	struct node node;
};


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
char tipc_bclink_name[] = "multicast-link";
P
Per Liden 已提交
123 124


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

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 146 147 148 149 150 151
{
	bcbuf_set_acks(buf, bcbuf_acks(buf) - 1);
}


/** 
 * bclink_set_gap - set gap according to contents of current deferred pkt queue
 * 
 * Called with 'node' locked, bc_lock unlocked
 */

S
Sam Ravnborg 已提交
152
static void bclink_set_gap(struct node *n_ptr)
P
Per Liden 已提交
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
{
	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);
}

/** 
 * bclink_ack_allowed - test if ACK or NACK message can be sent at this moment
 * 
 * This mechanism endeavours to prevent all nodes in network from trying
 * to ACK or NACK at the same time.
 * 
 * Note: TIPC uses a different trigger to distribute ACKs than it does to
 *       distribute NACKs, but tries to use the same spacing (divide by 16). 
 */

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


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

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)) {
		buf = buf->next;                
	}
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 201 202 203 204
 * @n_ptr: node that sent acknowledgement info
 * @acked: broadcast sequence # that has been acknowledged
 * 
 * Node is locked, bc_lock unlocked.
 */

205
void tipc_bclink_acknowledge(struct 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 247 248 249
	spin_unlock_bh(&bc_lock);
}

/** 
 * bclink_send_ack - unicast an ACK msg
 * 
250
 * tipc_net_lock and node lock set
P
Per Liden 已提交
251 252 253 254 255 256 257
 */

static void bclink_send_ack(struct node *n_ptr)
{
	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 262 263
}

/** 
 * bclink_send_nack- broadcast a NACK msg
 * 
264
 * tipc_net_lock and node lock set
P
Per Liden 已提交
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
 */

static void bclink_send_nack(struct node *n_ptr)
{
	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);
		msg_init(msg, BCAST_PROTOCOL, STATE_MSG,
			 TIPC_OK, INT_H_SIZE, n_ptr->addr);
		msg_set_mc_netid(msg, tipc_net_id);
		msg_set_bcast_ack(msg, mod(n_ptr->bclink.last_in)); 
		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 295 296 297 298 299 300 301 302 303 304 305
			bcl->proto_msg_queue = buf;
			bcl->stats.bearer_congs++;
		}

		/* 
		 * 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)
		 */
		
		n_ptr->bclink.nack_sync = tipc_own_tag;
	}
}

/** 
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 node *n_ptr, u32 last_sent)
P
Per Liden 已提交
312 313 314 315 316 317 318 319 320 321 322 323
{
	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);
}

/** 
324
 * tipc_bclink_peek_nack - process a NACK msg meant for another node
P
Per Liden 已提交
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 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 352 353 354 355 356 357 358 359 360
	/*
	 * 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 {
		/* 
		 * 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 374 375 376 377 378 379 380
			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:
	 */ 
	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
P
Per Liden 已提交
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 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 446
			bcl->owner->next = NULL;
			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 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
P
Per Liden 已提交
550 551 552 553 554 555 556
 * 
 * Send through as many bearers as necessary to reach all nodes
 * that support TIPC multicasting.
 * 
 * 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 568 569 570
{
	static int send_count = 0;

	int bp_index;
	int swap_time;

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

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

571 572
		assert(tipc_cltr_bcast_nodes.count != 0);
		bcbuf_set_acks(buf, tipc_cltr_bcast_nodes.count);
P
Per Liden 已提交
573 574 575 576 577 578 579 580 581 582 583 584
		msg = buf_msg(buf);
		msg_set_non_seq(msg);
		msg_set_mc_netid(msg, tipc_net_id);
	}

	/* Determine if bearer pairs should be swapped following this attempt */

	if ((swap_time = (++send_count >= 10)))
		send_count = 0;

	/* Send buffer over bearers until all targets reached */
	
585
	bcbearer->remains = tipc_cltr_bcast_nodes;
P
Per Liden 已提交
586 587 588 589 590 591 592 593

	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 */

594 595
		tipc_nmap_diff(&bcbearer->remains, &p->nodes, &bcbearer->remains_new);
		if (bcbearer->remains_new.count == bcbearer->remains.count)
P
Per Liden 已提交
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
			continue;	/* bearer pair doesn't add anything */

		if (!p->publ.blocked &&
		    !p->media->send_msg(buf, &p->publ, &p->media->bcast_addr)) {
			if (swap_time && s && !s->publ.blocked)
				goto swap;
			else
				goto update;
		}

		if (!s || s->publ.blocked ||
		    s->media->send_msg(buf, &s->publ, &s->media->bcast_addr))
			continue;	/* unable to send using bearer pair */
swap:
		bcbearer->bpairs[bp_index].primary = s;
		bcbearer->bpairs[bp_index].secondary = p;
update:
613 614
		if (bcbearer->remains_new.count == 0)
			return TIPC_OK;
P
Per Liden 已提交
615

616
		bcbearer->remains = bcbearer->remains_new;
P
Per Liden 已提交
617 618 619 620 621 622
	}
	
	/* Unable to reach all targets */

	bcbearer->bearer.publ.blocked = 1;
	bcl->stats.bearer_congs++;
623
	return ~TIPC_OK;
P
Per Liden 已提交
624 625 626
}

/**
627
 * tipc_bcbearer_sort - create sets of bearer pairs used by broadcast bearer
P
Per Liden 已提交
628 629
 */

630
void tipc_bcbearer_sort(void)
P
Per Liden 已提交
631 632 633 634 635 636 637 638 639 640 641 642 643
{
	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++) {
644
		struct bearer *b = &tipc_bearers[b_index];
P
Per Liden 已提交
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659

		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 已提交
660
	for (pri = TIPC_MAX_LINK_PRI; pri >= 0; pri--) {
P
Per Liden 已提交
661 662 663 664 665 666 667

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

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

		if (bp_temp[pri].secondary) {
668 669
			if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
					    &bp_temp[pri].secondary->nodes)) {
P
Per Liden 已提交
670 671 672 673 674 675 676 677 678 679 680 681 682 683
				bp_curr->secondary = bp_temp[pri].secondary;
			} else {
				bp_curr++;
				bp_curr->primary = bp_temp[pri].secondary;
			}
		}

		bp_curr++;
	}

	spin_unlock_bh(&bc_lock);
}

/**
684
 * tipc_bcbearer_push - resolve bearer congestion
P
Per Liden 已提交
685 686 687 688 689 690
 * 
 * Forces bclink to push out any unsent packets, until all packets are gone
 * or congestion reoccurs.
 * No locks set when function called
 */

691
void tipc_bcbearer_push(void)
P
Per Liden 已提交
692 693 694 695 696 697 698
{
	struct bearer *b_ptr;

	spin_lock_bh(&bc_lock);
	b_ptr = &bcbearer->bearer;
	if (b_ptr->publ.blocked) {
		b_ptr->publ.blocked = 0;
699
		tipc_bearer_lock_push(b_ptr);
P
Per Liden 已提交
700 701 702 703 704
	}
	spin_unlock_bh(&bc_lock);
}


705
int tipc_bclink_stats(char *buf, const u32 buf_size)
P
Per Liden 已提交
706 707 708 709 710 711
{
	struct print_buf pb;

	if (!bcl)
		return 0;

712
	tipc_printbuf_init(&pb, buf, buf_size);
P
Per Liden 已提交
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747

	spin_lock_bh(&bc_lock);

	tipc_printf(&pb, "Link <%s>\n"
		         "  Window:%u packets\n", 
		    bcl->name, bcl->queue_limit[0]);
	tipc_printf(&pb, "  RX packets:%u fragments:%u/%u bundles:%u/%u\n", 
		    bcl->stats.recv_info,
		    bcl->stats.recv_fragments,
		    bcl->stats.recv_fragmented,
		    bcl->stats.recv_bundles,
		    bcl->stats.recv_bundled);
	tipc_printf(&pb, "  TX packets:%u fragments:%u/%u bundles:%u/%u\n", 
		    bcl->stats.sent_info,
		    bcl->stats.sent_fragments,
		    bcl->stats.sent_fragmented, 
		    bcl->stats.sent_bundles,
		    bcl->stats.sent_bundled);
	tipc_printf(&pb, "  RX naks:%u defs:%u dups:%u\n", 
		    bcl->stats.recv_nacks,
		    bcl->stats.deferred_recv, 
		    bcl->stats.duplicates);
	tipc_printf(&pb, "  TX naks:%u acks:%u dups:%u\n", 
		    bcl->stats.sent_nacks, 
		    bcl->stats.sent_acks, 
		    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);
748
	return tipc_printbuf_validate(&pb);
P
Per Liden 已提交
749 750
}

751
int tipc_bclink_reset_stats(void)
P
Per Liden 已提交
752 753 754 755 756 757 758 759 760 761
{
	if (!bcl)
		return -ENOPROTOOPT;

	spin_lock_bh(&bc_lock);
	memset(&bcl->stats, 0, sizeof(bcl->stats));
	spin_unlock_bh(&bc_lock);
	return TIPC_OK;
}

762
int tipc_bclink_set_queue_limits(u32 limit)
P
Per Liden 已提交
763 764 765 766 767 768 769
{
	if (!bcl)
		return -ENOPROTOOPT;
	if ((limit < TIPC_MIN_LINK_WIN) || (limit > TIPC_MAX_LINK_WIN))
		return -EINVAL;

	spin_lock_bh(&bc_lock);
770
	tipc_link_set_queue_limits(bcl, limit);
P
Per Liden 已提交
771 772 773 774
	spin_unlock_bh(&bc_lock);
	return TIPC_OK;
}

775
int tipc_bclink_init(void)
P
Per Liden 已提交
776 777 778 779 780
{
	bcbearer = kmalloc(sizeof(*bcbearer), GFP_ATOMIC);
	bclink = kmalloc(sizeof(*bclink), GFP_ATOMIC);
	if (!bcbearer || !bclink) {
 nomem:
781
	 	warn("Multicast link creation failed, no memory\n");
P
Per Liden 已提交
782 783 784 785 786 787 788 789 790 791
		kfree(bcbearer);
		bcbearer = NULL;
		kfree(bclink);
		bclink = NULL;
		return -ENOMEM;
	}

	memset(bcbearer, 0, sizeof(struct bcbearer));
	INIT_LIST_HEAD(&bcbearer->bearer.cong_links);
	bcbearer->bearer.media = &bcbearer->media;
792
	bcbearer->media.send_msg = tipc_bcbearer_send;
P
Per Liden 已提交
793 794 795 796 797 798
	sprintf(bcbearer->media.name, "tipc-multicast");

	bcl = &bclink->link;
	memset(bclink, 0, sizeof(struct bclink));
	INIT_LIST_HEAD(&bcl->waiting_ports);
	bcl->next_out_no = 1;
I
Ingo Molnar 已提交
799
	spin_lock_init(&bclink->node.lock);
P
Per Liden 已提交
800 801
	bcl->owner = &bclink->node;
        bcl->max_pkt = MAX_PKT_DEFAULT_MCAST;
802
	tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
P
Per Liden 已提交
803 804
	bcl->b_ptr = &bcbearer->bearer;
	bcl->state = WORKING_WORKING;
805
	sprintf(bcl->name, tipc_bclink_name);
P
Per Liden 已提交
806 807 808 809 810 811

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

		if (!pb)
			goto nomem;
812
		tipc_printbuf_init(&bcl->print_buf, pb, BCLINK_LOG_BUF_SIZE);
P
Per Liden 已提交
813 814 815 816 817
	}

	return TIPC_OK;
}

818
void tipc_bclink_stop(void)
P
Per Liden 已提交
819 820 821
{
	spin_lock_bh(&bc_lock);
	if (bcbearer) {
822
		tipc_link_stop(bcl);
P
Per Liden 已提交
823 824 825 826 827 828 829 830 831 832 833
		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);
}