blob: 7dc1dc7151ea876a4baef3afa547ad1f098523c6 [file] [log] [blame]
Per Lidenb97bf3f2006-01-02 19:04:38 +01001/*
2 * net/tipc/bcast.c: TIPC broadcast code
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003 *
Per Liden593a5f22006-01-11 19:14:19 +01004 * Copyright (c) 2004-2006, Ericsson AB
Per Lidenb97bf3f2006-01-02 19:04:38 +01005 * Copyright (c) 2004, Intel Corporation.
Allan Stephens2d627b92011-01-07 13:00:11 -05006 * Copyright (c) 2005, 2010-2011, Wind River Systems
Per Lidenb97bf3f2006-01-02 19:04:38 +01007 * All rights reserved.
8 *
Per Liden9ea1fd32006-01-11 13:30:43 +01009 * Redistribution and use in source and binary forms, with or without
Per Lidenb97bf3f2006-01-02 19:04:38 +010010 * modification, are permitted provided that the following conditions are met:
11 *
Per Liden9ea1fd32006-01-11 13:30:43 +010012 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the names of the copyright holders nor the names of its
18 * contributors may be used to endorse or promote products derived from
19 * this software without specific prior written permission.
Per Lidenb97bf3f2006-01-02 19:04:38 +010020 *
Per Liden9ea1fd32006-01-11 13:30:43 +010021 * Alternatively, this software may be distributed under the terms of the
22 * GNU General Public License ("GPL") version 2 as published by the Free
23 * Software Foundation.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
26 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
29 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
Per Lidenb97bf3f2006-01-02 19:04:38 +010035 * POSSIBILITY OF SUCH DAMAGE.
36 */
37
38#include "core.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010039#include "link.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010040#include "port.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010041#include "bcast.h"
42
Per Lidenb97bf3f2006-01-02 19:04:38 +010043#define MAX_PKT_DEFAULT_MCAST 1500 /* bcast link max packet size (fixed) */
44
45#define BCLINK_WIN_DEFAULT 20 /* bcast link window size (default) */
46
Allan Stephensd356eeb2006-06-25 23:40:01 -070047/*
48 * Loss rate for incoming broadcast frames; used to test retransmission code.
49 * Set to N to cause every N'th frame to be discarded; 0 => don't discard any.
50 */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090051
Allan Stephensd356eeb2006-06-25 23:40:01 -070052#define TIPC_BCAST_LOSS_RATE 0
53
Per Lidenb97bf3f2006-01-02 19:04:38 +010054/**
55 * struct bcbearer_pair - a pair of bearers used by broadcast link
56 * @primary: pointer to primary bearer
57 * @secondary: pointer to secondary bearer
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090058 *
59 * Bearers must have same priority and same set of reachable destinations
Per Lidenb97bf3f2006-01-02 19:04:38 +010060 * to be paired.
61 */
62
63struct bcbearer_pair {
Allan Stephens2d627b92011-01-07 13:00:11 -050064 struct tipc_bearer *primary;
65 struct tipc_bearer *secondary;
Per Lidenb97bf3f2006-01-02 19:04:38 +010066};
67
68/**
69 * struct bcbearer - bearer used by broadcast link
70 * @bearer: (non-standard) broadcast bearer structure
71 * @media: (non-standard) broadcast media structure
72 * @bpairs: array of bearer pairs
Allan Stephens65f51ef2006-06-25 23:53:20 -070073 * @bpairs_temp: temporary array of bearer pairs used by tipc_bcbearer_sort()
74 * @remains: temporary node map used by tipc_bcbearer_send()
75 * @remains_new: temporary node map used tipc_bcbearer_send()
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090076 *
Allan Stephens65f51ef2006-06-25 23:53:20 -070077 * Note: The fields labelled "temporary" are incorporated into the bearer
78 * to avoid consuming potentially limited stack space through the use of
79 * large local variables within multicast routines. Concurrent access is
80 * prevented through use of the spinlock "bc_lock".
Per Lidenb97bf3f2006-01-02 19:04:38 +010081 */
82
83struct bcbearer {
Allan Stephens2d627b92011-01-07 13:00:11 -050084 struct tipc_bearer bearer;
Per Lidenb97bf3f2006-01-02 19:04:38 +010085 struct media media;
86 struct bcbearer_pair bpairs[MAX_BEARERS];
Per Liden16cb4b32006-01-13 22:22:22 +010087 struct bcbearer_pair bpairs_temp[TIPC_MAX_LINK_PRI + 1];
David S. Miller6c000552008-09-02 23:38:32 -070088 struct tipc_node_map remains;
89 struct tipc_node_map remains_new;
Per Lidenb97bf3f2006-01-02 19:04:38 +010090};
91
92/**
93 * struct bclink - link used for broadcast messages
94 * @link: (non-standard) broadcast link structure
95 * @node: (non-standard) node structure representing b'cast link's peer node
Allan Stephens01d83ed2011-01-18 13:53:16 -050096 * @retransmit_to: node that most recently requested a retransmit
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090097 *
Per Lidenb97bf3f2006-01-02 19:04:38 +010098 * Handles sequence numbering, fragmentation, bundling, etc.
99 */
100
101struct bclink {
102 struct link link;
David S. Miller6c000552008-09-02 23:38:32 -0700103 struct tipc_node node;
Allan Stephens01d83ed2011-01-18 13:53:16 -0500104 struct tipc_node *retransmit_to;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100105};
106
107
Allan Stephense3ec9c72010-12-31 18:59:34 +0000108static struct bcbearer *bcbearer;
109static struct bclink *bclink;
110static struct link *bcl;
Ingo Molnar34af9462006-06-27 02:53:55 -0700111static DEFINE_SPINLOCK(bc_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100112
Allan Stephens8f92df62010-12-31 18:59:19 +0000113/* broadcast-capable node map */
114struct tipc_node_map tipc_bcast_nmap;
115
Allan Stephens3aec9cc2010-05-11 14:30:07 +0000116const char tipc_bclink_name[] = "broadcast-link";
Per Lidenb97bf3f2006-01-02 19:04:38 +0100117
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000118static void tipc_nmap_diff(struct tipc_node_map *nm_a,
119 struct tipc_node_map *nm_b,
120 struct tipc_node_map *nm_diff);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100121
Sam Ravnborg05790c62006-03-20 22:37:04 -0800122static u32 buf_seqno(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100123{
124 return msg_seqno(buf_msg(buf));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900125}
Per Lidenb97bf3f2006-01-02 19:04:38 +0100126
Sam Ravnborg05790c62006-03-20 22:37:04 -0800127static u32 bcbuf_acks(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100128{
David S. Miller880b0052006-01-12 13:22:32 -0800129 return (u32)(unsigned long)TIPC_SKB_CB(buf)->handle;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100130}
131
Sam Ravnborg05790c62006-03-20 22:37:04 -0800132static void bcbuf_set_acks(struct sk_buff *buf, u32 acks)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100133{
David S. Miller880b0052006-01-12 13:22:32 -0800134 TIPC_SKB_CB(buf)->handle = (void *)(unsigned long)acks;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100135}
136
Sam Ravnborg05790c62006-03-20 22:37:04 -0800137static void bcbuf_decr_acks(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100138{
139 bcbuf_set_acks(buf, bcbuf_acks(buf) - 1);
140}
141
142
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000143static void bclink_set_last_sent(void)
144{
145 if (bcl->next_out)
146 bcl->fsm_msg_cnt = mod(buf_seqno(bcl->next_out) - 1);
147 else
148 bcl->fsm_msg_cnt = mod(bcl->next_out_no - 1);
149}
150
151u32 tipc_bclink_get_last_sent(void)
152{
153 return bcl->fsm_msg_cnt;
154}
155
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900156/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100157 * bclink_set_gap - set gap according to contents of current deferred pkt queue
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900158 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100159 * Called with 'node' locked, bc_lock unlocked
160 */
161
David S. Miller6c000552008-09-02 23:38:32 -0700162static void bclink_set_gap(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100163{
164 struct sk_buff *buf = n_ptr->bclink.deferred_head;
165
166 n_ptr->bclink.gap_after = n_ptr->bclink.gap_to =
167 mod(n_ptr->bclink.last_in);
168 if (unlikely(buf != NULL))
169 n_ptr->bclink.gap_to = mod(buf_seqno(buf) - 1);
170}
171
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900172/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100173 * bclink_ack_allowed - test if ACK or NACK message can be sent at this moment
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900174 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100175 * This mechanism endeavours to prevent all nodes in network from trying
176 * to ACK or NACK at the same time.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900177 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100178 * Note: TIPC uses a different trigger to distribute ACKs than it does to
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900179 * distribute NACKs, but tries to use the same spacing (divide by 16).
Per Lidenb97bf3f2006-01-02 19:04:38 +0100180 */
181
Sam Ravnborg05790c62006-03-20 22:37:04 -0800182static int bclink_ack_allowed(u32 n)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100183{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000184 return (n % TIPC_MIN_LINK_WIN) == tipc_own_tag;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100185}
186
187
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900188/**
Allan Stephens01d83ed2011-01-18 13:53:16 -0500189 * tipc_bclink_retransmit_to - get most recent node to request retransmission
190 *
191 * Called with bc_lock locked
192 */
193
194struct tipc_node *tipc_bclink_retransmit_to(void)
195{
196 return bclink->retransmit_to;
197}
198
199/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100200 * bclink_retransmit_pkt - retransmit broadcast packets
201 * @after: sequence number of last packet to *not* retransmit
202 * @to: sequence number of last packet to retransmit
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900203 *
Allan Stephensd356eeb2006-06-25 23:40:01 -0700204 * Called with bc_lock locked
Per Lidenb97bf3f2006-01-02 19:04:38 +0100205 */
206
207static void bclink_retransmit_pkt(u32 after, u32 to)
208{
209 struct sk_buff *buf;
210
Per Lidenb97bf3f2006-01-02 19:04:38 +0100211 buf = bcl->first_out;
Allan Stephensa0168922010-12-31 18:59:35 +0000212 while (buf && less_eq(buf_seqno(buf), after))
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900213 buf = buf->next;
Allan Stephensd356eeb2006-06-25 23:40:01 -0700214 tipc_link_retransmit(bcl, buf, mod(to - after));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100215}
216
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900217/**
Per Liden4323add2006-01-18 00:38:21 +0100218 * tipc_bclink_acknowledge - handle acknowledgement of broadcast packets
Per Lidenb97bf3f2006-01-02 19:04:38 +0100219 * @n_ptr: node that sent acknowledgement info
220 * @acked: broadcast sequence # that has been acknowledged
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900221 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100222 * Node is locked, bc_lock unlocked.
223 */
224
David S. Miller6c000552008-09-02 23:38:32 -0700225void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100226{
227 struct sk_buff *crs;
228 struct sk_buff *next;
229 unsigned int released = 0;
230
231 if (less_eq(acked, n_ptr->bclink.acked))
232 return;
233
234 spin_lock_bh(&bc_lock);
235
236 /* Skip over packets that node has previously acknowledged */
237
238 crs = bcl->first_out;
Allan Stephensa0168922010-12-31 18:59:35 +0000239 while (crs && less_eq(buf_seqno(crs), n_ptr->bclink.acked))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100240 crs = crs->next;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100241
242 /* Update packets that node is now acknowledging */
243
244 while (crs && less_eq(buf_seqno(crs), acked)) {
245 next = crs->next;
246 bcbuf_decr_acks(crs);
247 if (bcbuf_acks(crs) == 0) {
248 bcl->first_out = next;
249 bcl->out_queue_size--;
250 buf_discard(crs);
251 released = 1;
252 }
253 crs = next;
254 }
255 n_ptr->bclink.acked = acked;
256
257 /* Try resolving broadcast link congestion, if necessary */
258
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000259 if (unlikely(bcl->next_out)) {
Per Liden4323add2006-01-18 00:38:21 +0100260 tipc_link_push_queue(bcl);
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000261 bclink_set_last_sent();
262 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100263 if (unlikely(released && !list_empty(&bcl->waiting_ports)))
Per Liden4323add2006-01-18 00:38:21 +0100264 tipc_link_wakeup_ports(bcl, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100265 spin_unlock_bh(&bc_lock);
266}
267
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900268/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100269 * bclink_send_ack - unicast an ACK msg
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900270 *
Per Liden4323add2006-01-18 00:38:21 +0100271 * tipc_net_lock and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100272 */
273
David S. Miller6c000552008-09-02 23:38:32 -0700274static void bclink_send_ack(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100275{
276 struct link *l_ptr = n_ptr->active_links[n_ptr->addr & 1];
277
278 if (l_ptr != NULL)
Per Liden4323add2006-01-18 00:38:21 +0100279 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100280}
281
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900282/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100283 * bclink_send_nack- broadcast a NACK msg
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900284 *
Per Liden4323add2006-01-18 00:38:21 +0100285 * tipc_net_lock and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100286 */
287
David S. Miller6c000552008-09-02 23:38:32 -0700288static void bclink_send_nack(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100289{
290 struct sk_buff *buf;
291 struct tipc_msg *msg;
292
293 if (!less(n_ptr->bclink.gap_after, n_ptr->bclink.gap_to))
294 return;
295
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000296 buf = tipc_buf_acquire(INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100297 if (buf) {
298 msg = buf_msg(buf);
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000299 tipc_msg_init(msg, BCAST_PROTOCOL, STATE_MSG,
Allan Stephens75715212008-06-04 17:37:34 -0700300 INT_H_SIZE, n_ptr->addr);
Allan Stephensbf781ec2011-01-25 16:12:39 -0500301 msg_set_non_seq(msg, 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100302 msg_set_mc_netid(msg, tipc_net_id);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900303 msg_set_bcast_ack(msg, mod(n_ptr->bclink.last_in));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100304 msg_set_bcgap_after(msg, n_ptr->bclink.gap_after);
305 msg_set_bcgap_to(msg, n_ptr->bclink.gap_to);
306 msg_set_bcast_tag(msg, tipc_own_tag);
307
Sam Ravnborg1fc54d82006-03-20 22:36:47 -0800308 if (tipc_bearer_send(&bcbearer->bearer, buf, NULL)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100309 bcl->stats.sent_nacks++;
310 buf_discard(buf);
311 } else {
Per Liden4323add2006-01-18 00:38:21 +0100312 tipc_bearer_schedule(bcl->b_ptr, bcl);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100313 bcl->proto_msg_queue = buf;
314 bcl->stats.bearer_congs++;
315 }
316
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900317 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +0100318 * Ensure we doesn't send another NACK msg to the node
319 * until 16 more deferred messages arrive from it
320 * (i.e. helps prevent all nodes from NACK'ing at same time)
321 */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900322
Per Lidenb97bf3f2006-01-02 19:04:38 +0100323 n_ptr->bclink.nack_sync = tipc_own_tag;
324 }
325}
326
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900327/**
Per Liden4323add2006-01-18 00:38:21 +0100328 * tipc_bclink_check_gap - send a NACK if a sequence gap exists
Per Lidenb97bf3f2006-01-02 19:04:38 +0100329 *
Per Liden4323add2006-01-18 00:38:21 +0100330 * tipc_net_lock and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100331 */
332
David S. Miller6c000552008-09-02 23:38:32 -0700333void tipc_bclink_check_gap(struct tipc_node *n_ptr, u32 last_sent)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100334{
335 if (!n_ptr->bclink.supported ||
336 less_eq(last_sent, mod(n_ptr->bclink.last_in)))
337 return;
338
339 bclink_set_gap(n_ptr);
340 if (n_ptr->bclink.gap_after == n_ptr->bclink.gap_to)
341 n_ptr->bclink.gap_to = last_sent;
342 bclink_send_nack(n_ptr);
343}
344
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900345/**
Per Liden4323add2006-01-18 00:38:21 +0100346 * tipc_bclink_peek_nack - process a NACK msg meant for another node
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900347 *
Per Liden4323add2006-01-18 00:38:21 +0100348 * Only tipc_net_lock set.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100349 */
350
Adrian Bunk988f0882006-03-20 22:37:52 -0800351static void tipc_bclink_peek_nack(u32 dest, u32 sender_tag, u32 gap_after, u32 gap_to)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100352{
David S. Miller6c000552008-09-02 23:38:32 -0700353 struct tipc_node *n_ptr = tipc_node_find(dest);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100354 u32 my_after, my_to;
355
Per Liden4323add2006-01-18 00:38:21 +0100356 if (unlikely(!n_ptr || !tipc_node_is_up(n_ptr)))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100357 return;
Per Liden4323add2006-01-18 00:38:21 +0100358 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100359 /*
360 * Modify gap to suppress unnecessary NACKs from this node
361 */
362 my_after = n_ptr->bclink.gap_after;
363 my_to = n_ptr->bclink.gap_to;
364
365 if (less_eq(gap_after, my_after)) {
366 if (less(my_after, gap_to) && less(gap_to, my_to))
367 n_ptr->bclink.gap_after = gap_to;
368 else if (less_eq(my_to, gap_to))
369 n_ptr->bclink.gap_to = n_ptr->bclink.gap_after;
370 } else if (less_eq(gap_after, my_to)) {
371 if (less_eq(my_to, gap_to))
372 n_ptr->bclink.gap_to = gap_after;
373 } else {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900374 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +0100375 * Expand gap if missing bufs not in deferred queue:
376 */
377 struct sk_buff *buf = n_ptr->bclink.deferred_head;
378 u32 prev = n_ptr->bclink.gap_to;
379
380 for (; buf; buf = buf->next) {
381 u32 seqno = buf_seqno(buf);
382
Eric Sesterhenn3ac90212006-06-25 23:41:15 -0700383 if (mod(seqno - prev) != 1) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100384 buf = NULL;
Eric Sesterhenn3ac90212006-06-25 23:41:15 -0700385 break;
386 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100387 if (seqno == gap_after)
388 break;
389 prev = seqno;
390 }
391 if (buf == NULL)
392 n_ptr->bclink.gap_to = gap_after;
393 }
394 /*
395 * Some nodes may send a complementary NACK now:
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900396 */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100397 if (bclink_ack_allowed(sender_tag + 1)) {
398 if (n_ptr->bclink.gap_to != n_ptr->bclink.gap_after) {
399 bclink_send_nack(n_ptr);
400 bclink_set_gap(n_ptr);
401 }
402 }
Per Liden4323add2006-01-18 00:38:21 +0100403 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100404}
405
406/**
Per Liden4323add2006-01-18 00:38:21 +0100407 * tipc_bclink_send_msg - broadcast a packet to all nodes in cluster
Per Lidenb97bf3f2006-01-02 19:04:38 +0100408 */
409
Per Liden4323add2006-01-18 00:38:21 +0100410int tipc_bclink_send_msg(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100411{
412 int res;
413
414 spin_lock_bh(&bc_lock);
415
Per Liden4323add2006-01-18 00:38:21 +0100416 res = tipc_link_send_buf(bcl, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100417 if (unlikely(res == -ELINKCONG))
418 buf_discard(buf);
Allan Stephens0048b822010-08-17 11:00:10 +0000419 else
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000420 bclink_set_last_sent();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100421
Per Lidenb97bf3f2006-01-02 19:04:38 +0100422 bcl->stats.queue_sz_counts++;
423 bcl->stats.accu_queue_sz += bcl->out_queue_size;
424
425 spin_unlock_bh(&bc_lock);
426 return res;
427}
428
429/**
Per Liden4323add2006-01-18 00:38:21 +0100430 * tipc_bclink_recv_pkt - receive a broadcast packet, and deliver upwards
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900431 *
Per Liden4323add2006-01-18 00:38:21 +0100432 * tipc_net_lock is read_locked, no other locks set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100433 */
434
Per Liden4323add2006-01-18 00:38:21 +0100435void tipc_bclink_recv_pkt(struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -0700436{
437#if (TIPC_BCAST_LOSS_RATE)
Allan Stephense3ec9c72010-12-31 18:59:34 +0000438 static int rx_count;
Allan Stephensd356eeb2006-06-25 23:40:01 -0700439#endif
Per Lidenb97bf3f2006-01-02 19:04:38 +0100440 struct tipc_msg *msg = buf_msg(buf);
Allan Stephens0e659672010-12-31 18:59:32 +0000441 struct tipc_node *node = tipc_node_find(msg_prevnode(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100442 u32 next_in;
443 u32 seqno;
444 struct sk_buff *deferred;
445
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900446 if (unlikely(!node || !tipc_node_is_up(node) || !node->bclink.supported ||
Per Lidenb97bf3f2006-01-02 19:04:38 +0100447 (msg_mc_netid(msg) != tipc_net_id))) {
448 buf_discard(buf);
449 return;
450 }
451
452 if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100453 if (msg_destnode(msg) == tipc_own_addr) {
Per Liden4323add2006-01-18 00:38:21 +0100454 tipc_node_lock(node);
455 tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
456 tipc_node_unlock(node);
Allan Stephensd356eeb2006-06-25 23:40:01 -0700457 spin_lock_bh(&bc_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100458 bcl->stats.recv_nacks++;
Allan Stephens01d83ed2011-01-18 13:53:16 -0500459 bclink->retransmit_to = node;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100460 bclink_retransmit_pkt(msg_bcgap_after(msg),
461 msg_bcgap_to(msg));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900462 spin_unlock_bh(&bc_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100463 } else {
Per Liden4323add2006-01-18 00:38:21 +0100464 tipc_bclink_peek_nack(msg_destnode(msg),
Adrian Bunk988f0882006-03-20 22:37:52 -0800465 msg_bcast_tag(msg),
466 msg_bcgap_after(msg),
467 msg_bcgap_to(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100468 }
469 buf_discard(buf);
470 return;
471 }
472
Allan Stephensd356eeb2006-06-25 23:40:01 -0700473#if (TIPC_BCAST_LOSS_RATE)
474 if (++rx_count == TIPC_BCAST_LOSS_RATE) {
475 rx_count = 0;
476 buf_discard(buf);
477 return;
478 }
479#endif
480
Per Liden4323add2006-01-18 00:38:21 +0100481 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100482receive:
483 deferred = node->bclink.deferred_head;
484 next_in = mod(node->bclink.last_in + 1);
485 seqno = msg_seqno(msg);
486
487 if (likely(seqno == next_in)) {
488 bcl->stats.recv_info++;
489 node->bclink.last_in++;
490 bclink_set_gap(node);
491 if (unlikely(bclink_ack_allowed(seqno))) {
492 bclink_send_ack(node);
493 bcl->stats.sent_acks++;
494 }
495 if (likely(msg_isdata(msg))) {
Per Liden4323add2006-01-18 00:38:21 +0100496 tipc_node_unlock(node);
497 tipc_port_recv_mcast(buf, NULL);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100498 } else if (msg_user(msg) == MSG_BUNDLER) {
499 bcl->stats.recv_bundles++;
500 bcl->stats.recv_bundled += msg_msgcnt(msg);
Per Liden4323add2006-01-18 00:38:21 +0100501 tipc_node_unlock(node);
502 tipc_link_recv_bundle(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100503 } else if (msg_user(msg) == MSG_FRAGMENTER) {
504 bcl->stats.recv_fragments++;
Per Liden4323add2006-01-18 00:38:21 +0100505 if (tipc_link_recv_fragment(&node->bclink.defragm,
506 &buf, &msg))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100507 bcl->stats.recv_fragmented++;
Per Liden4323add2006-01-18 00:38:21 +0100508 tipc_node_unlock(node);
509 tipc_net_route_msg(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100510 } else {
Per Liden4323add2006-01-18 00:38:21 +0100511 tipc_node_unlock(node);
512 tipc_net_route_msg(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100513 }
514 if (deferred && (buf_seqno(deferred) == mod(next_in + 1))) {
Per Liden4323add2006-01-18 00:38:21 +0100515 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100516 buf = deferred;
517 msg = buf_msg(buf);
518 node->bclink.deferred_head = deferred->next;
519 goto receive;
520 }
521 return;
522 } else if (less(next_in, seqno)) {
523 u32 gap_after = node->bclink.gap_after;
524 u32 gap_to = node->bclink.gap_to;
525
Per Liden4323add2006-01-18 00:38:21 +0100526 if (tipc_link_defer_pkt(&node->bclink.deferred_head,
527 &node->bclink.deferred_tail,
528 buf)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100529 node->bclink.nack_sync++;
530 bcl->stats.deferred_recv++;
531 if (seqno == mod(gap_after + 1))
532 node->bclink.gap_after = seqno;
533 else if (less(gap_after, seqno) && less(seqno, gap_to))
534 node->bclink.gap_to = seqno;
535 }
536 if (bclink_ack_allowed(node->bclink.nack_sync)) {
537 if (gap_to != gap_after)
538 bclink_send_nack(node);
539 bclink_set_gap(node);
540 }
541 } else {
542 bcl->stats.duplicates++;
543 buf_discard(buf);
544 }
Per Liden4323add2006-01-18 00:38:21 +0100545 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100546}
547
David S. Miller6c000552008-09-02 23:38:32 -0700548u32 tipc_bclink_acks_missing(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100549{
550 return (n_ptr->bclink.supported &&
Per Liden4323add2006-01-18 00:38:21 +0100551 (tipc_bclink_get_last_sent() != n_ptr->bclink.acked));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100552}
553
554
555/**
Per Liden4323add2006-01-18 00:38:21 +0100556 * tipc_bcbearer_send - send a packet through the broadcast pseudo-bearer
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900557 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100558 * Send through as many bearers as necessary to reach all nodes
559 * that support TIPC multicasting.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900560 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100561 * Returns 0 if packet sent successfully, non-zero if not
562 */
563
Adrian Bunk988f0882006-03-20 22:37:52 -0800564static int tipc_bcbearer_send(struct sk_buff *buf,
565 struct tipc_bearer *unused1,
566 struct tipc_media_addr *unused2)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100567{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100568 int bp_index;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100569
570 /* Prepare buffer for broadcasting (if first time trying to send it) */
571
572 if (likely(!msg_non_seq(buf_msg(buf)))) {
573 struct tipc_msg *msg;
574
Allan Stephens8f92df62010-12-31 18:59:19 +0000575 assert(tipc_bcast_nmap.count != 0);
576 bcbuf_set_acks(buf, tipc_bcast_nmap.count);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100577 msg = buf_msg(buf);
Allan Stephens40aecb12008-06-04 17:54:48 -0700578 msg_set_non_seq(msg, 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100579 msg_set_mc_netid(msg, tipc_net_id);
Allan Stephens0048b822010-08-17 11:00:10 +0000580 bcl->stats.sent_info++;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100581 }
582
Per Lidenb97bf3f2006-01-02 19:04:38 +0100583 /* Send buffer over bearers until all targets reached */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900584
Allan Stephens8f92df62010-12-31 18:59:19 +0000585 bcbearer->remains = tipc_bcast_nmap;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100586
587 for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
Allan Stephens2d627b92011-01-07 13:00:11 -0500588 struct tipc_bearer *p = bcbearer->bpairs[bp_index].primary;
589 struct tipc_bearer *s = bcbearer->bpairs[bp_index].secondary;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100590
591 if (!p)
592 break; /* no more bearers to try */
593
Allan Stephens65f51ef2006-06-25 23:53:20 -0700594 tipc_nmap_diff(&bcbearer->remains, &p->nodes, &bcbearer->remains_new);
595 if (bcbearer->remains_new.count == bcbearer->remains.count)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100596 continue; /* bearer pair doesn't add anything */
597
Allan Stephens2d627b92011-01-07 13:00:11 -0500598 if (p->blocked ||
599 p->media->send_msg(buf, p, &p->media->bcast_addr)) {
Neil Horman1a624832010-03-15 08:02:24 +0000600 /* unable to send on primary bearer */
Allan Stephens2d627b92011-01-07 13:00:11 -0500601 if (!s || s->blocked ||
602 s->media->send_msg(buf, s,
Neil Horman1a624832010-03-15 08:02:24 +0000603 &s->media->bcast_addr)) {
604 /* unable to send on either bearer */
605 continue;
606 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100607 }
608
Neil Horman1a624832010-03-15 08:02:24 +0000609 if (s) {
610 bcbearer->bpairs[bp_index].primary = s;
611 bcbearer->bpairs[bp_index].secondary = p;
612 }
613
Allan Stephens65f51ef2006-06-25 23:53:20 -0700614 if (bcbearer->remains_new.count == 0)
Allan Stephens0e35fd52008-07-14 22:44:01 -0700615 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100616
Allan Stephens65f51ef2006-06-25 23:53:20 -0700617 bcbearer->remains = bcbearer->remains_new;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100618 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900619
Allan Stephens7e3e5d02010-08-17 11:00:08 +0000620 /*
621 * Unable to reach all targets (indicate success, since currently
622 * there isn't code in place to properly block & unblock the
623 * pseudo-bearer used by the broadcast link)
624 */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100625
Allan Stephens7e3e5d02010-08-17 11:00:08 +0000626 return TIPC_OK;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100627}
628
629/**
Per Liden4323add2006-01-18 00:38:21 +0100630 * tipc_bcbearer_sort - create sets of bearer pairs used by broadcast bearer
Per Lidenb97bf3f2006-01-02 19:04:38 +0100631 */
632
Per Liden4323add2006-01-18 00:38:21 +0100633void tipc_bcbearer_sort(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100634{
635 struct bcbearer_pair *bp_temp = bcbearer->bpairs_temp;
636 struct bcbearer_pair *bp_curr;
637 int b_index;
638 int pri;
639
640 spin_lock_bh(&bc_lock);
641
642 /* Group bearers by priority (can assume max of two per priority) */
643
644 memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));
645
646 for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
Allan Stephens2d627b92011-01-07 13:00:11 -0500647 struct tipc_bearer *b = &tipc_bearers[b_index];
Per Lidenb97bf3f2006-01-02 19:04:38 +0100648
649 if (!b->active || !b->nodes.count)
650 continue;
651
652 if (!bp_temp[b->priority].primary)
653 bp_temp[b->priority].primary = b;
654 else
655 bp_temp[b->priority].secondary = b;
656 }
657
658 /* Create array of bearer pairs for broadcasting */
659
660 bp_curr = bcbearer->bpairs;
661 memset(bcbearer->bpairs, 0, sizeof(bcbearer->bpairs));
662
Per Liden16cb4b32006-01-13 22:22:22 +0100663 for (pri = TIPC_MAX_LINK_PRI; pri >= 0; pri--) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100664
665 if (!bp_temp[pri].primary)
666 continue;
667
668 bp_curr->primary = bp_temp[pri].primary;
669
670 if (bp_temp[pri].secondary) {
Per Liden4323add2006-01-18 00:38:21 +0100671 if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
672 &bp_temp[pri].secondary->nodes)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100673 bp_curr->secondary = bp_temp[pri].secondary;
674 } else {
675 bp_curr++;
676 bp_curr->primary = bp_temp[pri].secondary;
677 }
678 }
679
680 bp_curr++;
681 }
682
683 spin_unlock_bh(&bc_lock);
684}
685
686/**
Per Liden4323add2006-01-18 00:38:21 +0100687 * tipc_bcbearer_push - resolve bearer congestion
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900688 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100689 * Forces bclink to push out any unsent packets, until all packets are gone
690 * or congestion reoccurs.
691 * No locks set when function called
692 */
693
Per Liden4323add2006-01-18 00:38:21 +0100694void tipc_bcbearer_push(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100695{
Allan Stephens2d627b92011-01-07 13:00:11 -0500696 struct tipc_bearer *b_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100697
698 spin_lock_bh(&bc_lock);
699 b_ptr = &bcbearer->bearer;
Allan Stephens2d627b92011-01-07 13:00:11 -0500700 if (b_ptr->blocked) {
701 b_ptr->blocked = 0;
Per Liden4323add2006-01-18 00:38:21 +0100702 tipc_bearer_lock_push(b_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100703 }
704 spin_unlock_bh(&bc_lock);
705}
706
707
Per Liden4323add2006-01-18 00:38:21 +0100708int tipc_bclink_stats(char *buf, const u32 buf_size)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100709{
710 struct print_buf pb;
711
712 if (!bcl)
713 return 0;
714
Per Liden4323add2006-01-18 00:38:21 +0100715 tipc_printbuf_init(&pb, buf, buf_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100716
717 spin_lock_bh(&bc_lock);
718
719 tipc_printf(&pb, "Link <%s>\n"
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900720 " Window:%u packets\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100721 bcl->name, bcl->queue_limit[0]);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900722 tipc_printf(&pb, " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100723 bcl->stats.recv_info,
724 bcl->stats.recv_fragments,
725 bcl->stats.recv_fragmented,
726 bcl->stats.recv_bundles,
727 bcl->stats.recv_bundled);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900728 tipc_printf(&pb, " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100729 bcl->stats.sent_info,
730 bcl->stats.sent_fragments,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900731 bcl->stats.sent_fragmented,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100732 bcl->stats.sent_bundles,
733 bcl->stats.sent_bundled);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900734 tipc_printf(&pb, " RX naks:%u defs:%u dups:%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100735 bcl->stats.recv_nacks,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900736 bcl->stats.deferred_recv,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100737 bcl->stats.duplicates);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900738 tipc_printf(&pb, " TX naks:%u acks:%u dups:%u\n",
739 bcl->stats.sent_nacks,
740 bcl->stats.sent_acks,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100741 bcl->stats.retransmitted);
742 tipc_printf(&pb, " Congestion bearer:%u link:%u Send queue max:%u avg:%u\n",
743 bcl->stats.bearer_congs,
744 bcl->stats.link_congs,
745 bcl->stats.max_queue_sz,
746 bcl->stats.queue_sz_counts
747 ? (bcl->stats.accu_queue_sz / bcl->stats.queue_sz_counts)
748 : 0);
749
750 spin_unlock_bh(&bc_lock);
Per Liden4323add2006-01-18 00:38:21 +0100751 return tipc_printbuf_validate(&pb);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100752}
753
Per Liden4323add2006-01-18 00:38:21 +0100754int tipc_bclink_reset_stats(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100755{
756 if (!bcl)
757 return -ENOPROTOOPT;
758
759 spin_lock_bh(&bc_lock);
760 memset(&bcl->stats, 0, sizeof(bcl->stats));
761 spin_unlock_bh(&bc_lock);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700762 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100763}
764
Per Liden4323add2006-01-18 00:38:21 +0100765int tipc_bclink_set_queue_limits(u32 limit)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100766{
767 if (!bcl)
768 return -ENOPROTOOPT;
769 if ((limit < TIPC_MIN_LINK_WIN) || (limit > TIPC_MAX_LINK_WIN))
770 return -EINVAL;
771
772 spin_lock_bh(&bc_lock);
Per Liden4323add2006-01-18 00:38:21 +0100773 tipc_link_set_queue_limits(bcl, limit);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100774 spin_unlock_bh(&bc_lock);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700775 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100776}
777
Per Liden4323add2006-01-18 00:38:21 +0100778int tipc_bclink_init(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100779{
Arnaldo Carvalho de Melo2710b572006-11-21 01:22:12 -0200780 bcbearer = kzalloc(sizeof(*bcbearer), GFP_ATOMIC);
781 bclink = kzalloc(sizeof(*bclink), GFP_ATOMIC);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100782 if (!bcbearer || !bclink) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900783 warn("Multicast link creation failed, no memory\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100784 kfree(bcbearer);
785 bcbearer = NULL;
786 kfree(bclink);
787 bclink = NULL;
788 return -ENOMEM;
789 }
790
Per Lidenb97bf3f2006-01-02 19:04:38 +0100791 INIT_LIST_HEAD(&bcbearer->bearer.cong_links);
792 bcbearer->bearer.media = &bcbearer->media;
Per Liden4323add2006-01-18 00:38:21 +0100793 bcbearer->media.send_msg = tipc_bcbearer_send;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100794 sprintf(bcbearer->media.name, "tipc-multicast");
795
796 bcl = &bclink->link;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100797 INIT_LIST_HEAD(&bcl->waiting_ports);
798 bcl->next_out_no = 1;
Ingo Molnar34af9462006-06-27 02:53:55 -0700799 spin_lock_init(&bclink->node.lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100800 bcl->owner = &bclink->node;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900801 bcl->max_pkt = MAX_PKT_DEFAULT_MCAST;
Per Liden4323add2006-01-18 00:38:21 +0100802 tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100803 bcl->b_ptr = &bcbearer->bearer;
804 bcl->state = WORKING_WORKING;
Stephen Hemminger4b704d52009-03-18 19:11:29 -0700805 strlcpy(bcl->name, tipc_bclink_name, TIPC_MAX_LINK_NAME);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100806
Allan Stephens0e35fd52008-07-14 22:44:01 -0700807 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100808}
809
Per Liden4323add2006-01-18 00:38:21 +0100810void tipc_bclink_stop(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100811{
812 spin_lock_bh(&bc_lock);
813 if (bcbearer) {
Per Liden4323add2006-01-18 00:38:21 +0100814 tipc_link_stop(bcl);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100815 bcl = NULL;
816 kfree(bclink);
817 bclink = NULL;
818 kfree(bcbearer);
819 bcbearer = NULL;
820 }
821 spin_unlock_bh(&bc_lock);
822}
823
Allan Stephens3e22e622010-05-11 14:30:14 +0000824
825/**
826 * tipc_nmap_add - add a node to a node map
827 */
828
829void tipc_nmap_add(struct tipc_node_map *nm_ptr, u32 node)
830{
831 int n = tipc_node(node);
832 int w = n / WSIZE;
833 u32 mask = (1 << (n % WSIZE));
834
835 if ((nm_ptr->map[w] & mask) == 0) {
836 nm_ptr->count++;
837 nm_ptr->map[w] |= mask;
838 }
839}
840
841/**
842 * tipc_nmap_remove - remove a node from a node map
843 */
844
845void tipc_nmap_remove(struct tipc_node_map *nm_ptr, u32 node)
846{
847 int n = tipc_node(node);
848 int w = n / WSIZE;
849 u32 mask = (1 << (n % WSIZE));
850
851 if ((nm_ptr->map[w] & mask) != 0) {
852 nm_ptr->map[w] &= ~mask;
853 nm_ptr->count--;
854 }
855}
856
857/**
858 * tipc_nmap_diff - find differences between node maps
859 * @nm_a: input node map A
860 * @nm_b: input node map B
861 * @nm_diff: output node map A-B (i.e. nodes of A that are not in B)
862 */
863
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000864static void tipc_nmap_diff(struct tipc_node_map *nm_a,
865 struct tipc_node_map *nm_b,
866 struct tipc_node_map *nm_diff)
Allan Stephens3e22e622010-05-11 14:30:14 +0000867{
868 int stop = ARRAY_SIZE(nm_a->map);
869 int w;
870 int b;
871 u32 map;
872
873 memset(nm_diff, 0, sizeof(*nm_diff));
874 for (w = 0; w < stop; w++) {
875 map = nm_a->map[w] ^ (nm_a->map[w] & nm_b->map[w]);
876 nm_diff->map[w] = map;
877 if (map != 0) {
878 for (b = 0 ; b < WSIZE; b++) {
879 if (map & (1 << b))
880 nm_diff->count++;
881 }
882 }
883 }
884}
Allan Stephens43608ed2010-05-11 14:30:15 +0000885
886/**
887 * tipc_port_list_add - add a port to a port list, ensuring no duplicates
888 */
889
890void tipc_port_list_add(struct port_list *pl_ptr, u32 port)
891{
892 struct port_list *item = pl_ptr;
893 int i;
894 int item_sz = PLSIZE;
895 int cnt = pl_ptr->count;
896
897 for (; ; cnt -= item_sz, item = item->next) {
898 if (cnt < PLSIZE)
899 item_sz = cnt;
900 for (i = 0; i < item_sz; i++)
901 if (item->ports[i] == port)
902 return;
903 if (i < PLSIZE) {
904 item->ports[i] = port;
905 pl_ptr->count++;
906 return;
907 }
908 if (!item->next) {
909 item->next = kmalloc(sizeof(*item), GFP_ATOMIC);
910 if (!item->next) {
911 warn("Incomplete multicast delivery, no memory\n");
912 return;
913 }
914 item->next->next = NULL;
915 }
916 }
917}
918
919/**
920 * tipc_port_list_free - free dynamically created entries in port_list chain
921 *
922 */
923
924void tipc_port_list_free(struct port_list *pl_ptr)
925{
926 struct port_list *item;
927 struct port_list *next;
928
929 for (item = pl_ptr->next; item; item = next) {
930 next = item->next;
931 kfree(item);
932 }
933}
934