blob: 8eb87b11d10050f7497498e4776064b39c216be9 [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"
Allan Stephens9f6bdcd42011-04-07 14:57:53 -040042#include "name_distr.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010043
Per Lidenb97bf3f2006-01-02 19:04:38 +010044#define MAX_PKT_DEFAULT_MCAST 1500 /* bcast link max packet size (fixed) */
45
46#define BCLINK_WIN_DEFAULT 20 /* bcast link window size (default) */
47
Per Lidenb97bf3f2006-01-02 19:04:38 +010048/**
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -050049 * struct tipc_bcbearer_pair - a pair of bearers used by broadcast link
Per Lidenb97bf3f2006-01-02 19:04:38 +010050 * @primary: pointer to primary bearer
51 * @secondary: pointer to secondary bearer
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090052 *
53 * Bearers must have same priority and same set of reachable destinations
Per Lidenb97bf3f2006-01-02 19:04:38 +010054 * to be paired.
55 */
56
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -050057struct tipc_bcbearer_pair {
Allan Stephens2d627b92011-01-07 13:00:11 -050058 struct tipc_bearer *primary;
59 struct tipc_bearer *secondary;
Per Lidenb97bf3f2006-01-02 19:04:38 +010060};
61
62/**
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -050063 * struct tipc_bcbearer - bearer used by broadcast link
Per Lidenb97bf3f2006-01-02 19:04:38 +010064 * @bearer: (non-standard) broadcast bearer structure
65 * @media: (non-standard) broadcast media structure
66 * @bpairs: array of bearer pairs
Allan Stephens65f51ef2006-06-25 23:53:20 -070067 * @bpairs_temp: temporary array of bearer pairs used by tipc_bcbearer_sort()
68 * @remains: temporary node map used by tipc_bcbearer_send()
69 * @remains_new: temporary node map used tipc_bcbearer_send()
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090070 *
Allan Stephens65f51ef2006-06-25 23:53:20 -070071 * Note: The fields labelled "temporary" are incorporated into the bearer
72 * to avoid consuming potentially limited stack space through the use of
73 * large local variables within multicast routines. Concurrent access is
74 * prevented through use of the spinlock "bc_lock".
Per Lidenb97bf3f2006-01-02 19:04:38 +010075 */
76
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -050077struct tipc_bcbearer {
Allan Stephens2d627b92011-01-07 13:00:11 -050078 struct tipc_bearer bearer;
Paul Gortmaker358a0d12011-12-29 20:19:42 -050079 struct tipc_media media;
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -050080 struct tipc_bcbearer_pair bpairs[MAX_BEARERS];
81 struct tipc_bcbearer_pair bpairs_temp[TIPC_MAX_LINK_PRI + 1];
David S. Miller6c000552008-09-02 23:38:32 -070082 struct tipc_node_map remains;
83 struct tipc_node_map remains_new;
Per Lidenb97bf3f2006-01-02 19:04:38 +010084};
85
86/**
Paul Gortmaker6765fd62011-12-29 20:52:18 -050087 * struct tipc_bclink - link used for broadcast messages
Per Lidenb97bf3f2006-01-02 19:04:38 +010088 * @link: (non-standard) broadcast link structure
89 * @node: (non-standard) node structure representing b'cast link's peer node
Allan Stephenscd3decd2011-10-24 11:18:12 -040090 * @bcast_nodes: map of broadcast-capable nodes
Allan Stephens01d83ed2011-01-18 13:53:16 -050091 * @retransmit_to: node that most recently requested a retransmit
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090092 *
Per Lidenb97bf3f2006-01-02 19:04:38 +010093 * Handles sequence numbering, fragmentation, bundling, etc.
94 */
95
Paul Gortmaker6765fd62011-12-29 20:52:18 -050096struct tipc_bclink {
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050097 struct tipc_link link;
David S. Miller6c000552008-09-02 23:38:32 -070098 struct tipc_node node;
Allan Stephenscd3decd2011-10-24 11:18:12 -040099 struct tipc_node_map bcast_nodes;
Allan Stephens01d83ed2011-01-18 13:53:16 -0500100 struct tipc_node *retransmit_to;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100101};
102
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -0500103static struct tipc_bcbearer bcast_bearer;
Paul Gortmaker6765fd62011-12-29 20:52:18 -0500104static struct tipc_bclink bcast_link;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100105
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -0500106static struct tipc_bcbearer *bcbearer = &bcast_bearer;
Paul Gortmaker6765fd62011-12-29 20:52:18 -0500107static struct tipc_bclink *bclink = &bcast_link;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500108static struct tipc_link *bcl = &bcast_link.link;
Allan Stephensc47e9b92011-10-24 10:29:26 -0400109
Ingo Molnar34af9462006-06-27 02:53:55 -0700110static DEFINE_SPINLOCK(bc_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100111
Allan Stephens3aec9cc2010-05-11 14:30:07 +0000112const char tipc_bclink_name[] = "broadcast-link";
Per Lidenb97bf3f2006-01-02 19:04:38 +0100113
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000114static void tipc_nmap_diff(struct tipc_node_map *nm_a,
115 struct tipc_node_map *nm_b,
116 struct tipc_node_map *nm_diff);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100117
Sam Ravnborg05790c62006-03-20 22:37:04 -0800118static u32 bcbuf_acks(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100119{
David S. Miller880b0052006-01-12 13:22:32 -0800120 return (u32)(unsigned long)TIPC_SKB_CB(buf)->handle;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100121}
122
Sam Ravnborg05790c62006-03-20 22:37:04 -0800123static void bcbuf_set_acks(struct sk_buff *buf, u32 acks)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100124{
David S. Miller880b0052006-01-12 13:22:32 -0800125 TIPC_SKB_CB(buf)->handle = (void *)(unsigned long)acks;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100126}
127
Sam Ravnborg05790c62006-03-20 22:37:04 -0800128static void bcbuf_decr_acks(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100129{
130 bcbuf_set_acks(buf, bcbuf_acks(buf) - 1);
131}
132
Allan Stephenscd3decd2011-10-24 11:18:12 -0400133void tipc_bclink_add_node(u32 addr)
134{
135 spin_lock_bh(&bc_lock);
136 tipc_nmap_add(&bclink->bcast_nodes, addr);
137 spin_unlock_bh(&bc_lock);
138}
139
140void tipc_bclink_remove_node(u32 addr)
141{
142 spin_lock_bh(&bc_lock);
143 tipc_nmap_remove(&bclink->bcast_nodes, addr);
144 spin_unlock_bh(&bc_lock);
145}
Per Lidenb97bf3f2006-01-02 19:04:38 +0100146
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000147static void bclink_set_last_sent(void)
148{
149 if (bcl->next_out)
150 bcl->fsm_msg_cnt = mod(buf_seqno(bcl->next_out) - 1);
151 else
152 bcl->fsm_msg_cnt = mod(bcl->next_out_no - 1);
153}
154
155u32 tipc_bclink_get_last_sent(void)
156{
157 return bcl->fsm_msg_cnt;
158}
159
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900160/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100161 * bclink_set_gap - set gap according to contents of current deferred pkt queue
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900162 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100163 * Called with 'node' locked, bc_lock unlocked
164 */
165
David S. Miller6c000552008-09-02 23:38:32 -0700166static void bclink_set_gap(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100167{
168 struct sk_buff *buf = n_ptr->bclink.deferred_head;
169
170 n_ptr->bclink.gap_after = n_ptr->bclink.gap_to =
171 mod(n_ptr->bclink.last_in);
172 if (unlikely(buf != NULL))
173 n_ptr->bclink.gap_to = mod(buf_seqno(buf) - 1);
174}
175
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900176/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100177 * bclink_ack_allowed - test if ACK or NACK message can be sent at this moment
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900178 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100179 * This mechanism endeavours to prevent all nodes in network from trying
180 * to ACK or NACK at the same time.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900181 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100182 * Note: TIPC uses a different trigger to distribute ACKs than it does to
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900183 * distribute NACKs, but tries to use the same spacing (divide by 16).
Per Lidenb97bf3f2006-01-02 19:04:38 +0100184 */
185
Sam Ravnborg05790c62006-03-20 22:37:04 -0800186static int bclink_ack_allowed(u32 n)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100187{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000188 return (n % TIPC_MIN_LINK_WIN) == tipc_own_tag;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100189}
190
191
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900192/**
Allan Stephens01d83ed2011-01-18 13:53:16 -0500193 * tipc_bclink_retransmit_to - get most recent node to request retransmission
194 *
195 * Called with bc_lock locked
196 */
197
198struct tipc_node *tipc_bclink_retransmit_to(void)
199{
200 return bclink->retransmit_to;
201}
202
203/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100204 * bclink_retransmit_pkt - retransmit broadcast packets
205 * @after: sequence number of last packet to *not* retransmit
206 * @to: sequence number of last packet to retransmit
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900207 *
Allan Stephensd356eeb2006-06-25 23:40:01 -0700208 * Called with bc_lock locked
Per Lidenb97bf3f2006-01-02 19:04:38 +0100209 */
210
211static void bclink_retransmit_pkt(u32 after, u32 to)
212{
213 struct sk_buff *buf;
214
Per Lidenb97bf3f2006-01-02 19:04:38 +0100215 buf = bcl->first_out;
Allan Stephensa0168922010-12-31 18:59:35 +0000216 while (buf && less_eq(buf_seqno(buf), after))
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900217 buf = buf->next;
Allan Stephensd356eeb2006-06-25 23:40:01 -0700218 tipc_link_retransmit(bcl, buf, mod(to - after));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100219}
220
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900221/**
Per Liden4323add2006-01-18 00:38:21 +0100222 * tipc_bclink_acknowledge - handle acknowledgement of broadcast packets
Per Lidenb97bf3f2006-01-02 19:04:38 +0100223 * @n_ptr: node that sent acknowledgement info
224 * @acked: broadcast sequence # that has been acknowledged
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900225 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100226 * Node is locked, bc_lock unlocked.
227 */
228
David S. Miller6c000552008-09-02 23:38:32 -0700229void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100230{
231 struct sk_buff *crs;
232 struct sk_buff *next;
233 unsigned int released = 0;
234
Per Lidenb97bf3f2006-01-02 19:04:38 +0100235 spin_lock_bh(&bc_lock);
236
Allan Stephens365595912011-10-24 15:26:24 -0400237 /* Bail out if tx queue is empty (no clean up is required) */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100238 crs = bcl->first_out;
Allan Stephens365595912011-10-24 15:26:24 -0400239 if (!crs)
240 goto exit;
241
242 /* Determine which messages need to be acknowledged */
243 if (acked == INVALID_LINK_SEQ) {
244 /*
245 * Contact with specified node has been lost, so need to
246 * acknowledge sent messages only (if other nodes still exist)
247 * or both sent and unsent messages (otherwise)
248 */
249 if (bclink->bcast_nodes.count)
250 acked = bcl->fsm_msg_cnt;
251 else
252 acked = bcl->next_out_no;
253 } else {
254 /*
255 * Bail out if specified sequence number does not correspond
256 * to a message that has been sent and not yet acknowledged
257 */
258 if (less(acked, buf_seqno(crs)) ||
259 less(bcl->fsm_msg_cnt, acked) ||
260 less_eq(acked, n_ptr->bclink.acked))
261 goto exit;
262 }
263
264 /* Skip over packets that node has previously acknowledged */
Allan Stephensa0168922010-12-31 18:59:35 +0000265 while (crs && less_eq(buf_seqno(crs), n_ptr->bclink.acked))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100266 crs = crs->next;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100267
268 /* Update packets that node is now acknowledging */
269
270 while (crs && less_eq(buf_seqno(crs), acked)) {
271 next = crs->next;
Allan Stephens10745cd2011-10-24 14:59:20 -0400272
273 if (crs != bcl->next_out)
274 bcbuf_decr_acks(crs);
Allan Stephens10745cd2011-10-24 14:59:20 -0400275 else {
276 bcbuf_set_acks(crs, 0);
277 bcl->next_out = next;
278 bclink_set_last_sent();
279 }
280
Per Lidenb97bf3f2006-01-02 19:04:38 +0100281 if (bcbuf_acks(crs) == 0) {
282 bcl->first_out = next;
283 bcl->out_queue_size--;
284 buf_discard(crs);
285 released = 1;
286 }
287 crs = next;
288 }
289 n_ptr->bclink.acked = acked;
290
291 /* Try resolving broadcast link congestion, if necessary */
292
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000293 if (unlikely(bcl->next_out)) {
Per Liden4323add2006-01-18 00:38:21 +0100294 tipc_link_push_queue(bcl);
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000295 bclink_set_last_sent();
296 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100297 if (unlikely(released && !list_empty(&bcl->waiting_ports)))
Per Liden4323add2006-01-18 00:38:21 +0100298 tipc_link_wakeup_ports(bcl, 0);
Allan Stephens365595912011-10-24 15:26:24 -0400299exit:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100300 spin_unlock_bh(&bc_lock);
301}
302
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900303/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100304 * bclink_send_ack - unicast an ACK msg
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900305 *
Per Liden4323add2006-01-18 00:38:21 +0100306 * tipc_net_lock and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100307 */
308
David S. Miller6c000552008-09-02 23:38:32 -0700309static void bclink_send_ack(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100310{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500311 struct tipc_link *l_ptr = n_ptr->active_links[n_ptr->addr & 1];
Per Lidenb97bf3f2006-01-02 19:04:38 +0100312
313 if (l_ptr != NULL)
Per Liden4323add2006-01-18 00:38:21 +0100314 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100315}
316
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900317/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100318 * bclink_send_nack- broadcast a NACK msg
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900319 *
Per Liden4323add2006-01-18 00:38:21 +0100320 * tipc_net_lock and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100321 */
322
David S. Miller6c000552008-09-02 23:38:32 -0700323static void bclink_send_nack(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100324{
325 struct sk_buff *buf;
326 struct tipc_msg *msg;
327
328 if (!less(n_ptr->bclink.gap_after, n_ptr->bclink.gap_to))
329 return;
330
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000331 buf = tipc_buf_acquire(INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100332 if (buf) {
333 msg = buf_msg(buf);
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000334 tipc_msg_init(msg, BCAST_PROTOCOL, STATE_MSG,
Allan Stephens75715212008-06-04 17:37:34 -0700335 INT_H_SIZE, n_ptr->addr);
Allan Stephensbf781ec2011-01-25 16:12:39 -0500336 msg_set_non_seq(msg, 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100337 msg_set_mc_netid(msg, tipc_net_id);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900338 msg_set_bcast_ack(msg, mod(n_ptr->bclink.last_in));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100339 msg_set_bcgap_after(msg, n_ptr->bclink.gap_after);
340 msg_set_bcgap_to(msg, n_ptr->bclink.gap_to);
341 msg_set_bcast_tag(msg, tipc_own_tag);
342
Allan Stephens0f385132011-04-07 15:47:48 -0400343 tipc_bearer_send(&bcbearer->bearer, buf, NULL);
344 bcl->stats.sent_nacks++;
345 buf_discard(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100346
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900347 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +0100348 * Ensure we doesn't send another NACK msg to the node
349 * until 16 more deferred messages arrive from it
350 * (i.e. helps prevent all nodes from NACK'ing at same time)
351 */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900352
Per Lidenb97bf3f2006-01-02 19:04:38 +0100353 n_ptr->bclink.nack_sync = tipc_own_tag;
354 }
355}
356
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900357/**
Per Liden4323add2006-01-18 00:38:21 +0100358 * tipc_bclink_check_gap - send a NACK if a sequence gap exists
Per Lidenb97bf3f2006-01-02 19:04:38 +0100359 *
Per Liden4323add2006-01-18 00:38:21 +0100360 * tipc_net_lock and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100361 */
362
David S. Miller6c000552008-09-02 23:38:32 -0700363void tipc_bclink_check_gap(struct tipc_node *n_ptr, u32 last_sent)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100364{
365 if (!n_ptr->bclink.supported ||
366 less_eq(last_sent, mod(n_ptr->bclink.last_in)))
367 return;
368
369 bclink_set_gap(n_ptr);
370 if (n_ptr->bclink.gap_after == n_ptr->bclink.gap_to)
371 n_ptr->bclink.gap_to = last_sent;
372 bclink_send_nack(n_ptr);
373}
374
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900375/**
Per Liden4323add2006-01-18 00:38:21 +0100376 * tipc_bclink_peek_nack - process a NACK msg meant for another node
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900377 *
Per Liden4323add2006-01-18 00:38:21 +0100378 * Only tipc_net_lock set.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100379 */
380
Adrian Bunk988f0882006-03-20 22:37:52 -0800381static void tipc_bclink_peek_nack(u32 dest, u32 sender_tag, u32 gap_after, u32 gap_to)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100382{
David S. Miller6c000552008-09-02 23:38:32 -0700383 struct tipc_node *n_ptr = tipc_node_find(dest);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100384 u32 my_after, my_to;
385
Per Liden4323add2006-01-18 00:38:21 +0100386 if (unlikely(!n_ptr || !tipc_node_is_up(n_ptr)))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100387 return;
Per Liden4323add2006-01-18 00:38:21 +0100388 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100389 /*
390 * Modify gap to suppress unnecessary NACKs from this node
391 */
392 my_after = n_ptr->bclink.gap_after;
393 my_to = n_ptr->bclink.gap_to;
394
395 if (less_eq(gap_after, my_after)) {
396 if (less(my_after, gap_to) && less(gap_to, my_to))
397 n_ptr->bclink.gap_after = gap_to;
398 else if (less_eq(my_to, gap_to))
399 n_ptr->bclink.gap_to = n_ptr->bclink.gap_after;
400 } else if (less_eq(gap_after, my_to)) {
401 if (less_eq(my_to, gap_to))
402 n_ptr->bclink.gap_to = gap_after;
403 } else {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900404 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +0100405 * Expand gap if missing bufs not in deferred queue:
406 */
407 struct sk_buff *buf = n_ptr->bclink.deferred_head;
408 u32 prev = n_ptr->bclink.gap_to;
409
410 for (; buf; buf = buf->next) {
411 u32 seqno = buf_seqno(buf);
412
Eric Sesterhenn3ac90212006-06-25 23:41:15 -0700413 if (mod(seqno - prev) != 1) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100414 buf = NULL;
Eric Sesterhenn3ac90212006-06-25 23:41:15 -0700415 break;
416 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100417 if (seqno == gap_after)
418 break;
419 prev = seqno;
420 }
421 if (buf == NULL)
422 n_ptr->bclink.gap_to = gap_after;
423 }
424 /*
425 * Some nodes may send a complementary NACK now:
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900426 */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100427 if (bclink_ack_allowed(sender_tag + 1)) {
428 if (n_ptr->bclink.gap_to != n_ptr->bclink.gap_after) {
429 bclink_send_nack(n_ptr);
430 bclink_set_gap(n_ptr);
431 }
432 }
Per Liden4323add2006-01-18 00:38:21 +0100433 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100434}
435
436/**
Per Liden4323add2006-01-18 00:38:21 +0100437 * tipc_bclink_send_msg - broadcast a packet to all nodes in cluster
Per Lidenb97bf3f2006-01-02 19:04:38 +0100438 */
439
Per Liden4323add2006-01-18 00:38:21 +0100440int tipc_bclink_send_msg(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100441{
442 int res;
443
444 spin_lock_bh(&bc_lock);
445
Allan Stephens2b78f9a2011-10-24 13:05:55 -0400446 if (!bclink->bcast_nodes.count) {
447 res = msg_data_sz(buf_msg(buf));
448 buf_discard(buf);
449 goto exit;
450 }
451
Per Liden4323add2006-01-18 00:38:21 +0100452 res = tipc_link_send_buf(bcl, buf);
Allan Stephens9157baf2011-10-24 13:27:31 -0400453 if (likely(res >= 0)) {
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000454 bclink_set_last_sent();
Allan Stephens9157baf2011-10-24 13:27:31 -0400455 bcl->stats.queue_sz_counts++;
456 bcl->stats.accu_queue_sz += bcl->out_queue_size;
457 }
Allan Stephens2b78f9a2011-10-24 13:05:55 -0400458exit:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100459 spin_unlock_bh(&bc_lock);
460 return res;
461}
462
463/**
Per Liden4323add2006-01-18 00:38:21 +0100464 * tipc_bclink_recv_pkt - receive a broadcast packet, and deliver upwards
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900465 *
Per Liden4323add2006-01-18 00:38:21 +0100466 * tipc_net_lock is read_locked, no other locks set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100467 */
468
Per Liden4323add2006-01-18 00:38:21 +0100469void tipc_bclink_recv_pkt(struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -0700470{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100471 struct tipc_msg *msg = buf_msg(buf);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400472 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100473 u32 next_in;
474 u32 seqno;
475 struct sk_buff *deferred;
476
Allan Stephens5d3c4882011-04-07 13:57:25 -0400477 /* Screen out unwanted broadcast messages */
478
479 if (msg_mc_netid(msg) != tipc_net_id)
480 goto exit;
481
482 node = tipc_node_find(msg_prevnode(msg));
483 if (unlikely(!node))
484 goto exit;
485
486 tipc_node_lock(node);
487 if (unlikely(!node->bclink.supported))
488 goto unlock;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100489
490 if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
Allan Stephens9f6bdcd42011-04-07 14:57:53 -0400491 if (msg_type(msg) != STATE_MSG)
492 goto unlock;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100493 if (msg_destnode(msg) == tipc_own_addr) {
Per Liden4323add2006-01-18 00:38:21 +0100494 tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
495 tipc_node_unlock(node);
Allan Stephensd356eeb2006-06-25 23:40:01 -0700496 spin_lock_bh(&bc_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100497 bcl->stats.recv_nacks++;
Allan Stephens01d83ed2011-01-18 13:53:16 -0500498 bclink->retransmit_to = node;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100499 bclink_retransmit_pkt(msg_bcgap_after(msg),
500 msg_bcgap_to(msg));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900501 spin_unlock_bh(&bc_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100502 } else {
Allan Stephens5d3c4882011-04-07 13:57:25 -0400503 tipc_node_unlock(node);
Per Liden4323add2006-01-18 00:38:21 +0100504 tipc_bclink_peek_nack(msg_destnode(msg),
Adrian Bunk988f0882006-03-20 22:37:52 -0800505 msg_bcast_tag(msg),
506 msg_bcgap_after(msg),
507 msg_bcgap_to(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100508 }
Allan Stephens5d3c4882011-04-07 13:57:25 -0400509 goto exit;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100510 }
511
Allan Stephens5d3c4882011-04-07 13:57:25 -0400512 /* Handle in-sequence broadcast message */
513
Per Lidenb97bf3f2006-01-02 19:04:38 +0100514receive:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100515 next_in = mod(node->bclink.last_in + 1);
516 seqno = msg_seqno(msg);
517
518 if (likely(seqno == next_in)) {
519 bcl->stats.recv_info++;
520 node->bclink.last_in++;
521 bclink_set_gap(node);
522 if (unlikely(bclink_ack_allowed(seqno))) {
523 bclink_send_ack(node);
524 bcl->stats.sent_acks++;
525 }
526 if (likely(msg_isdata(msg))) {
Per Liden4323add2006-01-18 00:38:21 +0100527 tipc_node_unlock(node);
Allan Stephens9f6bdcd42011-04-07 14:57:53 -0400528 if (likely(msg_mcast(msg)))
529 tipc_port_recv_mcast(buf, NULL);
530 else
531 buf_discard(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100532 } else if (msg_user(msg) == MSG_BUNDLER) {
533 bcl->stats.recv_bundles++;
534 bcl->stats.recv_bundled += msg_msgcnt(msg);
Per Liden4323add2006-01-18 00:38:21 +0100535 tipc_node_unlock(node);
536 tipc_link_recv_bundle(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100537 } else if (msg_user(msg) == MSG_FRAGMENTER) {
538 bcl->stats.recv_fragments++;
Per Liden4323add2006-01-18 00:38:21 +0100539 if (tipc_link_recv_fragment(&node->bclink.defragm,
540 &buf, &msg))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100541 bcl->stats.recv_fragmented++;
Per Liden4323add2006-01-18 00:38:21 +0100542 tipc_node_unlock(node);
543 tipc_net_route_msg(buf);
Allan Stephens9f6bdcd42011-04-07 14:57:53 -0400544 } else if (msg_user(msg) == NAME_DISTRIBUTOR) {
545 tipc_node_unlock(node);
546 tipc_named_recv(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100547 } else {
Per Liden4323add2006-01-18 00:38:21 +0100548 tipc_node_unlock(node);
Allan Stephens9f6bdcd42011-04-07 14:57:53 -0400549 buf_discard(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100550 }
Allan Stephens5d3c4882011-04-07 13:57:25 -0400551 buf = NULL;
552 tipc_node_lock(node);
Allan Stephens693d03a2011-04-07 14:20:45 -0400553 deferred = node->bclink.deferred_head;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100554 if (deferred && (buf_seqno(deferred) == mod(next_in + 1))) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100555 buf = deferred;
556 msg = buf_msg(buf);
557 node->bclink.deferred_head = deferred->next;
558 goto receive;
559 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100560 } else if (less(next_in, seqno)) {
561 u32 gap_after = node->bclink.gap_after;
562 u32 gap_to = node->bclink.gap_to;
563
Per Liden4323add2006-01-18 00:38:21 +0100564 if (tipc_link_defer_pkt(&node->bclink.deferred_head,
565 &node->bclink.deferred_tail,
566 buf)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100567 node->bclink.nack_sync++;
568 bcl->stats.deferred_recv++;
569 if (seqno == mod(gap_after + 1))
570 node->bclink.gap_after = seqno;
571 else if (less(gap_after, seqno) && less(seqno, gap_to))
572 node->bclink.gap_to = seqno;
573 }
Allan Stephens5d3c4882011-04-07 13:57:25 -0400574 buf = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100575 if (bclink_ack_allowed(node->bclink.nack_sync)) {
576 if (gap_to != gap_after)
577 bclink_send_nack(node);
578 bclink_set_gap(node);
579 }
580 } else {
581 bcl->stats.duplicates++;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100582 }
Allan Stephens5d3c4882011-04-07 13:57:25 -0400583unlock:
Per Liden4323add2006-01-18 00:38:21 +0100584 tipc_node_unlock(node);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400585exit:
586 buf_discard(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100587}
588
David S. Miller6c000552008-09-02 23:38:32 -0700589u32 tipc_bclink_acks_missing(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100590{
591 return (n_ptr->bclink.supported &&
Per Liden4323add2006-01-18 00:38:21 +0100592 (tipc_bclink_get_last_sent() != n_ptr->bclink.acked));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100593}
594
595
596/**
Per Liden4323add2006-01-18 00:38:21 +0100597 * tipc_bcbearer_send - send a packet through the broadcast pseudo-bearer
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900598 *
Allan Stephens2ff9f922011-04-07 10:44:54 -0400599 * Send packet over as many bearers as necessary to reach all nodes
600 * that have joined the broadcast link.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900601 *
Allan Stephens2ff9f922011-04-07 10:44:54 -0400602 * Returns 0 (packet sent successfully) under all circumstances,
603 * since the broadcast link's pseudo-bearer never blocks
Per Lidenb97bf3f2006-01-02 19:04:38 +0100604 */
605
Adrian Bunk988f0882006-03-20 22:37:52 -0800606static int tipc_bcbearer_send(struct sk_buff *buf,
607 struct tipc_bearer *unused1,
608 struct tipc_media_addr *unused2)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100609{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100610 int bp_index;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100611
Allan Stephens2ff9f922011-04-07 10:44:54 -0400612 /*
613 * Prepare broadcast link message for reliable transmission,
614 * if first time trying to send it;
615 * preparation is skipped for broadcast link protocol messages
616 * since they are sent in an unreliable manner and don't need it
617 */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100618
619 if (likely(!msg_non_seq(buf_msg(buf)))) {
620 struct tipc_msg *msg;
621
Allan Stephenscd3decd2011-10-24 11:18:12 -0400622 bcbuf_set_acks(buf, bclink->bcast_nodes.count);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100623 msg = buf_msg(buf);
Allan Stephens40aecb12008-06-04 17:54:48 -0700624 msg_set_non_seq(msg, 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100625 msg_set_mc_netid(msg, tipc_net_id);
Allan Stephens0048b822010-08-17 11:00:10 +0000626 bcl->stats.sent_info++;
Allan Stephens5e726902011-05-23 13:14:18 -0400627
Allan Stephenscd3decd2011-10-24 11:18:12 -0400628 if (WARN_ON(!bclink->bcast_nodes.count)) {
Allan Stephens5e726902011-05-23 13:14:18 -0400629 dump_stack();
630 return 0;
631 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100632 }
633
Per Lidenb97bf3f2006-01-02 19:04:38 +0100634 /* Send buffer over bearers until all targets reached */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900635
Allan Stephenscd3decd2011-10-24 11:18:12 -0400636 bcbearer->remains = bclink->bcast_nodes;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100637
638 for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
Allan Stephens2d627b92011-01-07 13:00:11 -0500639 struct tipc_bearer *p = bcbearer->bpairs[bp_index].primary;
640 struct tipc_bearer *s = bcbearer->bpairs[bp_index].secondary;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100641
642 if (!p)
643 break; /* no more bearers to try */
644
Allan Stephens65f51ef2006-06-25 23:53:20 -0700645 tipc_nmap_diff(&bcbearer->remains, &p->nodes, &bcbearer->remains_new);
646 if (bcbearer->remains_new.count == bcbearer->remains.count)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100647 continue; /* bearer pair doesn't add anything */
648
Allan Stephens2d627b92011-01-07 13:00:11 -0500649 if (p->blocked ||
650 p->media->send_msg(buf, p, &p->media->bcast_addr)) {
Neil Horman1a624832010-03-15 08:02:24 +0000651 /* unable to send on primary bearer */
Allan Stephens2d627b92011-01-07 13:00:11 -0500652 if (!s || s->blocked ||
653 s->media->send_msg(buf, s,
Neil Horman1a624832010-03-15 08:02:24 +0000654 &s->media->bcast_addr)) {
655 /* unable to send on either bearer */
656 continue;
657 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100658 }
659
Neil Horman1a624832010-03-15 08:02:24 +0000660 if (s) {
661 bcbearer->bpairs[bp_index].primary = s;
662 bcbearer->bpairs[bp_index].secondary = p;
663 }
664
Allan Stephens65f51ef2006-06-25 23:53:20 -0700665 if (bcbearer->remains_new.count == 0)
Allan Stephens2ff9f922011-04-07 10:44:54 -0400666 break; /* all targets reached */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100667
Allan Stephens65f51ef2006-06-25 23:53:20 -0700668 bcbearer->remains = bcbearer->remains_new;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100669 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900670
Allan Stephens2ff9f922011-04-07 10:44:54 -0400671 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100672}
673
674/**
Per Liden4323add2006-01-18 00:38:21 +0100675 * tipc_bcbearer_sort - create sets of bearer pairs used by broadcast bearer
Per Lidenb97bf3f2006-01-02 19:04:38 +0100676 */
677
Per Liden4323add2006-01-18 00:38:21 +0100678void tipc_bcbearer_sort(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100679{
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -0500680 struct tipc_bcbearer_pair *bp_temp = bcbearer->bpairs_temp;
681 struct tipc_bcbearer_pair *bp_curr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100682 int b_index;
683 int pri;
684
685 spin_lock_bh(&bc_lock);
686
687 /* Group bearers by priority (can assume max of two per priority) */
688
689 memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));
690
691 for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
Allan Stephens2d627b92011-01-07 13:00:11 -0500692 struct tipc_bearer *b = &tipc_bearers[b_index];
Per Lidenb97bf3f2006-01-02 19:04:38 +0100693
694 if (!b->active || !b->nodes.count)
695 continue;
696
697 if (!bp_temp[b->priority].primary)
698 bp_temp[b->priority].primary = b;
699 else
700 bp_temp[b->priority].secondary = b;
701 }
702
703 /* Create array of bearer pairs for broadcasting */
704
705 bp_curr = bcbearer->bpairs;
706 memset(bcbearer->bpairs, 0, sizeof(bcbearer->bpairs));
707
Per Liden16cb4b32006-01-13 22:22:22 +0100708 for (pri = TIPC_MAX_LINK_PRI; pri >= 0; pri--) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100709
710 if (!bp_temp[pri].primary)
711 continue;
712
713 bp_curr->primary = bp_temp[pri].primary;
714
715 if (bp_temp[pri].secondary) {
Per Liden4323add2006-01-18 00:38:21 +0100716 if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
717 &bp_temp[pri].secondary->nodes)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100718 bp_curr->secondary = bp_temp[pri].secondary;
719 } else {
720 bp_curr++;
721 bp_curr->primary = bp_temp[pri].secondary;
722 }
723 }
724
725 bp_curr++;
726 }
727
728 spin_unlock_bh(&bc_lock);
729}
730
Per Lidenb97bf3f2006-01-02 19:04:38 +0100731
Per Liden4323add2006-01-18 00:38:21 +0100732int tipc_bclink_stats(char *buf, const u32 buf_size)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100733{
734 struct print_buf pb;
735
736 if (!bcl)
737 return 0;
738
Per Liden4323add2006-01-18 00:38:21 +0100739 tipc_printbuf_init(&pb, buf, buf_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100740
741 spin_lock_bh(&bc_lock);
742
743 tipc_printf(&pb, "Link <%s>\n"
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900744 " Window:%u packets\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100745 bcl->name, bcl->queue_limit[0]);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900746 tipc_printf(&pb, " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100747 bcl->stats.recv_info,
748 bcl->stats.recv_fragments,
749 bcl->stats.recv_fragmented,
750 bcl->stats.recv_bundles,
751 bcl->stats.recv_bundled);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900752 tipc_printf(&pb, " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100753 bcl->stats.sent_info,
754 bcl->stats.sent_fragments,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900755 bcl->stats.sent_fragmented,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100756 bcl->stats.sent_bundles,
757 bcl->stats.sent_bundled);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900758 tipc_printf(&pb, " RX naks:%u defs:%u dups:%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100759 bcl->stats.recv_nacks,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900760 bcl->stats.deferred_recv,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100761 bcl->stats.duplicates);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900762 tipc_printf(&pb, " TX naks:%u acks:%u dups:%u\n",
763 bcl->stats.sent_nacks,
764 bcl->stats.sent_acks,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100765 bcl->stats.retransmitted);
766 tipc_printf(&pb, " Congestion bearer:%u link:%u Send queue max:%u avg:%u\n",
767 bcl->stats.bearer_congs,
768 bcl->stats.link_congs,
769 bcl->stats.max_queue_sz,
770 bcl->stats.queue_sz_counts
771 ? (bcl->stats.accu_queue_sz / bcl->stats.queue_sz_counts)
772 : 0);
773
774 spin_unlock_bh(&bc_lock);
Per Liden4323add2006-01-18 00:38:21 +0100775 return tipc_printbuf_validate(&pb);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100776}
777
Per Liden4323add2006-01-18 00:38:21 +0100778int tipc_bclink_reset_stats(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100779{
780 if (!bcl)
781 return -ENOPROTOOPT;
782
783 spin_lock_bh(&bc_lock);
784 memset(&bcl->stats, 0, sizeof(bcl->stats));
785 spin_unlock_bh(&bc_lock);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700786 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100787}
788
Per Liden4323add2006-01-18 00:38:21 +0100789int tipc_bclink_set_queue_limits(u32 limit)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100790{
791 if (!bcl)
792 return -ENOPROTOOPT;
793 if ((limit < TIPC_MIN_LINK_WIN) || (limit > TIPC_MAX_LINK_WIN))
794 return -EINVAL;
795
796 spin_lock_bh(&bc_lock);
Per Liden4323add2006-01-18 00:38:21 +0100797 tipc_link_set_queue_limits(bcl, limit);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100798 spin_unlock_bh(&bc_lock);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700799 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100800}
801
Allan Stephensc47e9b92011-10-24 10:29:26 -0400802void tipc_bclink_init(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100803{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100804 INIT_LIST_HEAD(&bcbearer->bearer.cong_links);
805 bcbearer->bearer.media = &bcbearer->media;
Per Liden4323add2006-01-18 00:38:21 +0100806 bcbearer->media.send_msg = tipc_bcbearer_send;
Allan Stephens2e2d9be2011-04-07 10:22:31 -0400807 sprintf(bcbearer->media.name, "tipc-broadcast");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100808
Per Lidenb97bf3f2006-01-02 19:04:38 +0100809 INIT_LIST_HEAD(&bcl->waiting_ports);
810 bcl->next_out_no = 1;
Ingo Molnar34af9462006-06-27 02:53:55 -0700811 spin_lock_init(&bclink->node.lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100812 bcl->owner = &bclink->node;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900813 bcl->max_pkt = MAX_PKT_DEFAULT_MCAST;
Per Liden4323add2006-01-18 00:38:21 +0100814 tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100815 bcl->b_ptr = &bcbearer->bearer;
816 bcl->state = WORKING_WORKING;
Stephen Hemminger4b704d52009-03-18 19:11:29 -0700817 strlcpy(bcl->name, tipc_bclink_name, TIPC_MAX_LINK_NAME);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100818}
819
Per Liden4323add2006-01-18 00:38:21 +0100820void tipc_bclink_stop(void)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100821{
822 spin_lock_bh(&bc_lock);
Allan Stephensc47e9b92011-10-24 10:29:26 -0400823 tipc_link_stop(bcl);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100824 spin_unlock_bh(&bc_lock);
Allan Stephensc47e9b92011-10-24 10:29:26 -0400825
826 memset(bclink, 0, sizeof(*bclink));
827 memset(bcbearer, 0, sizeof(*bcbearer));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100828}
829
Allan Stephens3e22e622010-05-11 14:30:14 +0000830
831/**
832 * tipc_nmap_add - add a node to a node map
833 */
834
835void tipc_nmap_add(struct tipc_node_map *nm_ptr, u32 node)
836{
837 int n = tipc_node(node);
838 int w = n / WSIZE;
839 u32 mask = (1 << (n % WSIZE));
840
841 if ((nm_ptr->map[w] & mask) == 0) {
842 nm_ptr->count++;
843 nm_ptr->map[w] |= mask;
844 }
845}
846
847/**
848 * tipc_nmap_remove - remove a node from a node map
849 */
850
851void tipc_nmap_remove(struct tipc_node_map *nm_ptr, u32 node)
852{
853 int n = tipc_node(node);
854 int w = n / WSIZE;
855 u32 mask = (1 << (n % WSIZE));
856
857 if ((nm_ptr->map[w] & mask) != 0) {
858 nm_ptr->map[w] &= ~mask;
859 nm_ptr->count--;
860 }
861}
862
863/**
864 * tipc_nmap_diff - find differences between node maps
865 * @nm_a: input node map A
866 * @nm_b: input node map B
867 * @nm_diff: output node map A-B (i.e. nodes of A that are not in B)
868 */
869
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000870static void tipc_nmap_diff(struct tipc_node_map *nm_a,
871 struct tipc_node_map *nm_b,
872 struct tipc_node_map *nm_diff)
Allan Stephens3e22e622010-05-11 14:30:14 +0000873{
874 int stop = ARRAY_SIZE(nm_a->map);
875 int w;
876 int b;
877 u32 map;
878
879 memset(nm_diff, 0, sizeof(*nm_diff));
880 for (w = 0; w < stop; w++) {
881 map = nm_a->map[w] ^ (nm_a->map[w] & nm_b->map[w]);
882 nm_diff->map[w] = map;
883 if (map != 0) {
884 for (b = 0 ; b < WSIZE; b++) {
885 if (map & (1 << b))
886 nm_diff->count++;
887 }
888 }
889 }
890}
Allan Stephens43608ed2010-05-11 14:30:15 +0000891
892/**
893 * tipc_port_list_add - add a port to a port list, ensuring no duplicates
894 */
895
Paul Gortmaker45843102011-12-29 20:33:30 -0500896void tipc_port_list_add(struct tipc_port_list *pl_ptr, u32 port)
Allan Stephens43608ed2010-05-11 14:30:15 +0000897{
Paul Gortmaker45843102011-12-29 20:33:30 -0500898 struct tipc_port_list *item = pl_ptr;
Allan Stephens43608ed2010-05-11 14:30:15 +0000899 int i;
900 int item_sz = PLSIZE;
901 int cnt = pl_ptr->count;
902
903 for (; ; cnt -= item_sz, item = item->next) {
904 if (cnt < PLSIZE)
905 item_sz = cnt;
906 for (i = 0; i < item_sz; i++)
907 if (item->ports[i] == port)
908 return;
909 if (i < PLSIZE) {
910 item->ports[i] = port;
911 pl_ptr->count++;
912 return;
913 }
914 if (!item->next) {
915 item->next = kmalloc(sizeof(*item), GFP_ATOMIC);
916 if (!item->next) {
917 warn("Incomplete multicast delivery, no memory\n");
918 return;
919 }
920 item->next->next = NULL;
921 }
922 }
923}
924
925/**
926 * tipc_port_list_free - free dynamically created entries in port_list chain
927 *
928 */
929
Paul Gortmaker45843102011-12-29 20:33:30 -0500930void tipc_port_list_free(struct tipc_port_list *pl_ptr)
Allan Stephens43608ed2010-05-11 14:30:15 +0000931{
Paul Gortmaker45843102011-12-29 20:33:30 -0500932 struct tipc_port_list *item;
933 struct tipc_port_list *next;
Allan Stephens43608ed2010-05-11 14:30:15 +0000934
935 for (item = pl_ptr->next; item; item = next) {
936 next = item->next;
937 kfree(item);
938 }
939}
940