blob: 52307397e0b1ebcc2be3ebb883c3d9f760f55daf [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 *
Jon Paul Maloy3c724ac2015-02-05 08:36:43 -05004 * Copyright (c) 2004-2006, 2014-2015, 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
Jon Paul Maloy078bec82014-07-16 20:41:00 -040038#include "socket.h"
39#include "msg.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010040#include "bcast.h"
Allan Stephens9f6bdcd42011-04-07 14:57:53 -040041#include "name_distr.h"
Ying Xue1da46562015-01-09 15:27:07 +080042#include "core.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010043
Ying Xue987b58b2014-03-27 12:54:35 +080044#define MAX_PKT_DEFAULT_MCAST 1500 /* bcast link max packet size (fixed) */
45#define BCLINK_WIN_DEFAULT 20 /* bcast link window size (default) */
Allan Stephensc47e9b92011-10-24 10:29:26 -040046
Allan Stephens3aec9cc2010-05-11 14:30:07 +000047const char tipc_bclink_name[] = "broadcast-link";
Per Lidenb97bf3f2006-01-02 19:04:38 +010048
stephen hemminger31e3c3f2010-10-13 13:20:35 +000049static void tipc_nmap_diff(struct tipc_node_map *nm_a,
50 struct tipc_node_map *nm_b,
51 struct tipc_node_map *nm_diff);
Ying Xue28dd9412014-04-21 10:55:51 +080052static void tipc_nmap_add(struct tipc_node_map *nm_ptr, u32 node);
53static void tipc_nmap_remove(struct tipc_node_map *nm_ptr, u32 node);
Per Lidenb97bf3f2006-01-02 19:04:38 +010054
Ying Xue1da46562015-01-09 15:27:07 +080055static void tipc_bclink_lock(struct net *net)
Ying Xued69afc92014-05-05 08:56:15 +080056{
Ying Xue1da46562015-01-09 15:27:07 +080057 struct tipc_net *tn = net_generic(net, tipc_net_id);
58
59 spin_lock_bh(&tn->bclink->lock);
Ying Xued69afc92014-05-05 08:56:15 +080060}
61
Ying Xue1da46562015-01-09 15:27:07 +080062static void tipc_bclink_unlock(struct net *net)
Ying Xued69afc92014-05-05 08:56:15 +080063{
Ying Xue1da46562015-01-09 15:27:07 +080064 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue3f5a12b2014-05-05 08:56:17 +080065 struct tipc_node *node = NULL;
66
Ying Xue1da46562015-01-09 15:27:07 +080067 if (likely(!tn->bclink->flags)) {
68 spin_unlock_bh(&tn->bclink->lock);
Ying Xue3f5a12b2014-05-05 08:56:17 +080069 return;
70 }
71
Ying Xue1da46562015-01-09 15:27:07 +080072 if (tn->bclink->flags & TIPC_BCLINK_RESET) {
73 tn->bclink->flags &= ~TIPC_BCLINK_RESET;
74 node = tipc_bclink_retransmit_to(net);
Ying Xue3f5a12b2014-05-05 08:56:17 +080075 }
Ying Xue1da46562015-01-09 15:27:07 +080076 spin_unlock_bh(&tn->bclink->lock);
Ying Xue3f5a12b2014-05-05 08:56:17 +080077
78 if (node)
79 tipc_link_reset_all(node);
80}
81
Jon Paul Maloycb1b7282015-02-05 08:36:44 -050082void tipc_bclink_input(struct net *net)
83{
84 struct tipc_net *tn = net_generic(net, tipc_net_id);
85
86 tipc_sk_mcast_rcv(net, &tn->bclink->arrvq, &tn->bclink->inputq);
87}
88
Jon Paul Maloy078bec82014-07-16 20:41:00 -040089uint tipc_bclink_get_mtu(void)
90{
91 return MAX_PKT_DEFAULT_MCAST;
92}
93
Ying Xue1da46562015-01-09 15:27:07 +080094void tipc_bclink_set_flags(struct net *net, unsigned int flags)
Ying Xue3f5a12b2014-05-05 08:56:17 +080095{
Ying Xue1da46562015-01-09 15:27:07 +080096 struct tipc_net *tn = net_generic(net, tipc_net_id);
97
98 tn->bclink->flags |= flags;
Ying Xued69afc92014-05-05 08:56:15 +080099}
100
Sam Ravnborg05790c62006-03-20 22:37:04 -0800101static u32 bcbuf_acks(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100102{
David S. Miller880b0052006-01-12 13:22:32 -0800103 return (u32)(unsigned long)TIPC_SKB_CB(buf)->handle;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100104}
105
Sam Ravnborg05790c62006-03-20 22:37:04 -0800106static void bcbuf_set_acks(struct sk_buff *buf, u32 acks)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100107{
David S. Miller880b0052006-01-12 13:22:32 -0800108 TIPC_SKB_CB(buf)->handle = (void *)(unsigned long)acks;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100109}
110
Sam Ravnborg05790c62006-03-20 22:37:04 -0800111static void bcbuf_decr_acks(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100112{
113 bcbuf_set_acks(buf, bcbuf_acks(buf) - 1);
114}
115
Ying Xue1da46562015-01-09 15:27:07 +0800116void tipc_bclink_add_node(struct net *net, u32 addr)
Allan Stephenscd3decd2011-10-24 11:18:12 -0400117{
Ying Xue1da46562015-01-09 15:27:07 +0800118 struct tipc_net *tn = net_generic(net, tipc_net_id);
119
120 tipc_bclink_lock(net);
121 tipc_nmap_add(&tn->bclink->bcast_nodes, addr);
122 tipc_bclink_unlock(net);
Allan Stephenscd3decd2011-10-24 11:18:12 -0400123}
124
Ying Xue1da46562015-01-09 15:27:07 +0800125void tipc_bclink_remove_node(struct net *net, u32 addr)
Allan Stephenscd3decd2011-10-24 11:18:12 -0400126{
Ying Xue1da46562015-01-09 15:27:07 +0800127 struct tipc_net *tn = net_generic(net, tipc_net_id);
128
129 tipc_bclink_lock(net);
130 tipc_nmap_remove(&tn->bclink->bcast_nodes, addr);
131 tipc_bclink_unlock(net);
Allan Stephenscd3decd2011-10-24 11:18:12 -0400132}
Per Lidenb97bf3f2006-01-02 19:04:38 +0100133
Ying Xue1da46562015-01-09 15:27:07 +0800134static void bclink_set_last_sent(struct net *net)
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000135{
Ying Xue1da46562015-01-09 15:27:07 +0800136 struct tipc_net *tn = net_generic(net, tipc_net_id);
137 struct tipc_link *bcl = tn->bcl;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400138 struct sk_buff *skb = skb_peek(&bcl->backlogq);
Ying Xue1da46562015-01-09 15:27:07 +0800139
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400140 if (skb)
141 bcl->fsm_msg_cnt = mod(buf_seqno(skb) - 1);
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000142 else
143 bcl->fsm_msg_cnt = mod(bcl->next_out_no - 1);
144}
145
Ying Xue1da46562015-01-09 15:27:07 +0800146u32 tipc_bclink_get_last_sent(struct net *net)
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000147{
Ying Xue1da46562015-01-09 15:27:07 +0800148 struct tipc_net *tn = net_generic(net, tipc_net_id);
149
150 return tn->bcl->fsm_msg_cnt;
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000151}
152
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400153static void bclink_update_last_sent(struct tipc_node *node, u32 seqno)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100154{
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400155 node->bclink.last_sent = less_eq(node->bclink.last_sent, seqno) ?
156 seqno : node->bclink.last_sent;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100157}
158
159
Ben Hutchings2c530402012-07-10 10:55:09 +0000160/**
Allan Stephens01d83ed2011-01-18 13:53:16 -0500161 * tipc_bclink_retransmit_to - get most recent node to request retransmission
162 *
Ying Xued69afc92014-05-05 08:56:15 +0800163 * Called with bclink_lock locked
Allan Stephens01d83ed2011-01-18 13:53:16 -0500164 */
Ying Xue1da46562015-01-09 15:27:07 +0800165struct tipc_node *tipc_bclink_retransmit_to(struct net *net)
Allan Stephens01d83ed2011-01-18 13:53:16 -0500166{
Ying Xue1da46562015-01-09 15:27:07 +0800167 struct tipc_net *tn = net_generic(net, tipc_net_id);
168
169 return tn->bclink->retransmit_to;
Allan Stephens01d83ed2011-01-18 13:53:16 -0500170}
171
172/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100173 * bclink_retransmit_pkt - retransmit broadcast packets
174 * @after: sequence number of last packet to *not* retransmit
175 * @to: sequence number of last packet to retransmit
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900176 *
Ying Xued69afc92014-05-05 08:56:15 +0800177 * Called with bclink_lock locked
Per Lidenb97bf3f2006-01-02 19:04:38 +0100178 */
Ying Xue1da46562015-01-09 15:27:07 +0800179static void bclink_retransmit_pkt(struct tipc_net *tn, u32 after, u32 to)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100180{
Ying Xue58dc55f2014-11-26 11:41:52 +0800181 struct sk_buff *skb;
Ying Xue1da46562015-01-09 15:27:07 +0800182 struct tipc_link *bcl = tn->bcl;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100183
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400184 skb_queue_walk(&bcl->transmq, skb) {
Jon Maloy703068e2015-01-09 15:26:58 +0800185 if (more(buf_seqno(skb), after)) {
186 tipc_link_retransmit(bcl, skb, mod(to - after));
Ying Xue58dc55f2014-11-26 11:41:52 +0800187 break;
Jon Maloy703068e2015-01-09 15:26:58 +0800188 }
Ying Xue58dc55f2014-11-26 11:41:52 +0800189 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100190}
191
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900192/**
Jon Maloy908344c2014-10-07 14:12:34 -0400193 * tipc_bclink_wakeup_users - wake up pending users
194 *
195 * Called with no locks taken
196 */
Ying Xuef2f98002015-01-09 15:27:05 +0800197void tipc_bclink_wakeup_users(struct net *net)
Jon Maloy908344c2014-10-07 14:12:34 -0400198{
Ying Xue1da46562015-01-09 15:27:07 +0800199 struct tipc_net *tn = net_generic(net, tipc_net_id);
Erik Hugne4988bb42014-12-03 16:58:40 +0100200
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500201 tipc_sk_rcv(net, &tn->bclink->link.wakeupq);
Jon Maloy908344c2014-10-07 14:12:34 -0400202}
203
204/**
Per Liden4323add2006-01-18 00:38:21 +0100205 * tipc_bclink_acknowledge - handle acknowledgement of broadcast packets
Per Lidenb97bf3f2006-01-02 19:04:38 +0100206 * @n_ptr: node that sent acknowledgement info
207 * @acked: broadcast sequence # that has been acknowledged
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900208 *
Ying Xued69afc92014-05-05 08:56:15 +0800209 * Node is locked, bclink_lock unlocked.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100210 */
David S. Miller6c000552008-09-02 23:38:32 -0700211void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100212{
Ying Xue58dc55f2014-11-26 11:41:52 +0800213 struct sk_buff *skb, *tmp;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100214 unsigned int released = 0;
Ying Xue1da46562015-01-09 15:27:07 +0800215 struct net *net = n_ptr->net;
216 struct tipc_net *tn = net_generic(net, tipc_net_id);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100217
Jon Paul Maloy2cdf3912015-03-13 16:08:09 -0400218 if (unlikely(!n_ptr->bclink.recv_permitted))
219 return;
220
Ying Xue1da46562015-01-09 15:27:07 +0800221 tipc_bclink_lock(net);
Jon Paul Maloy2cdf3912015-03-13 16:08:09 -0400222
Allan Stephens365595912011-10-24 15:26:24 -0400223 /* Bail out if tx queue is empty (no clean up is required) */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400224 skb = skb_peek(&tn->bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800225 if (!skb)
Allan Stephens365595912011-10-24 15:26:24 -0400226 goto exit;
227
228 /* Determine which messages need to be acknowledged */
229 if (acked == INVALID_LINK_SEQ) {
230 /*
231 * Contact with specified node has been lost, so need to
232 * acknowledge sent messages only (if other nodes still exist)
233 * or both sent and unsent messages (otherwise)
234 */
Ying Xue1da46562015-01-09 15:27:07 +0800235 if (tn->bclink->bcast_nodes.count)
236 acked = tn->bcl->fsm_msg_cnt;
Allan Stephens365595912011-10-24 15:26:24 -0400237 else
Ying Xue1da46562015-01-09 15:27:07 +0800238 acked = tn->bcl->next_out_no;
Allan Stephens365595912011-10-24 15:26:24 -0400239 } else {
240 /*
241 * Bail out if specified sequence number does not correspond
242 * to a message that has been sent and not yet acknowledged
243 */
Ying Xue58dc55f2014-11-26 11:41:52 +0800244 if (less(acked, buf_seqno(skb)) ||
Ying Xue1da46562015-01-09 15:27:07 +0800245 less(tn->bcl->fsm_msg_cnt, acked) ||
Allan Stephens365595912011-10-24 15:26:24 -0400246 less_eq(acked, n_ptr->bclink.acked))
247 goto exit;
248 }
249
250 /* Skip over packets that node has previously acknowledged */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400251 skb_queue_walk(&tn->bcl->transmq, skb) {
Ying Xue58dc55f2014-11-26 11:41:52 +0800252 if (more(buf_seqno(skb), n_ptr->bclink.acked))
253 break;
254 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100255
256 /* Update packets that node is now acknowledging */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400257 skb_queue_walk_from_safe(&tn->bcl->transmq, skb, tmp) {
Ying Xue58dc55f2014-11-26 11:41:52 +0800258 if (more(buf_seqno(skb), acked))
259 break;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400260 bcbuf_decr_acks(skb);
261 bclink_set_last_sent(net);
Ying Xue58dc55f2014-11-26 11:41:52 +0800262 if (bcbuf_acks(skb) == 0) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400263 __skb_unlink(skb, &tn->bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800264 kfree_skb(skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100265 released = 1;
266 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100267 }
268 n_ptr->bclink.acked = acked;
269
270 /* Try resolving broadcast link congestion, if necessary */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400271 if (unlikely(skb_peek(&tn->bcl->backlogq))) {
Ying Xue1da46562015-01-09 15:27:07 +0800272 tipc_link_push_packets(tn->bcl);
273 bclink_set_last_sent(net);
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000274 }
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500275 if (unlikely(released && !skb_queue_empty(&tn->bcl->wakeupq)))
Jon Maloy908344c2014-10-07 14:12:34 -0400276 n_ptr->action_flags |= TIPC_WAKEUP_BCAST_USERS;
Allan Stephens365595912011-10-24 15:26:24 -0400277exit:
Ying Xue1da46562015-01-09 15:27:07 +0800278 tipc_bclink_unlock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100279}
280
Ben Hutchings2c530402012-07-10 10:55:09 +0000281/**
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400282 * tipc_bclink_update_link_state - update broadcast link state
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900283 *
Ying Xue7216cd92014-04-21 10:55:48 +0800284 * RCU and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100285 */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500286void tipc_bclink_update_link_state(struct tipc_node *n_ptr,
Ying Xuec93d3ba2015-01-09 15:27:04 +0800287 u32 last_sent)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100288{
289 struct sk_buff *buf;
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500290 struct net *net = n_ptr->net;
Ying Xuec93d3ba2015-01-09 15:27:04 +0800291 struct tipc_net *tn = net_generic(net, tipc_net_id);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100292
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400293 /* Ignore "stale" link state info */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400294 if (less_eq(last_sent, n_ptr->bclink.last_in))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100295 return;
296
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400297 /* Update link synchronization state; quit if in sync */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400298 bclink_update_last_sent(n_ptr, last_sent);
299
300 if (n_ptr->bclink.last_sent == n_ptr->bclink.last_in)
301 return;
302
303 /* Update out-of-sync state; quit if loss is still unconfirmed */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400304 if ((++n_ptr->bclink.oos_state) == 1) {
305 if (n_ptr->bclink.deferred_size < (TIPC_MIN_LINK_WIN / 2))
306 return;
307 n_ptr->bclink.oos_state++;
308 }
309
310 /* Don't NACK if one has been recently sent (or seen) */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400311 if (n_ptr->bclink.oos_state & 0x1)
312 return;
313
314 /* Send NACK */
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000315 buf = tipc_buf_acquire(INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100316 if (buf) {
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400317 struct tipc_msg *msg = buf_msg(buf);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400318 struct sk_buff *skb = skb_peek(&n_ptr->bclink.deferdq);
Ying Xuebc6fecd2014-11-26 11:41:53 +0800319 u32 to = skb ? buf_seqno(skb) - 1 : n_ptr->bclink.last_sent;
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400320
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500321 tipc_msg_init(tn->own_addr, msg, BCAST_PROTOCOL, STATE_MSG,
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400322 INT_H_SIZE, n_ptr->addr);
Allan Stephensbf781ec2011-01-25 16:12:39 -0500323 msg_set_non_seq(msg, 1);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800324 msg_set_mc_netid(msg, tn->net_id);
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400325 msg_set_bcast_ack(msg, n_ptr->bclink.last_in);
326 msg_set_bcgap_after(msg, n_ptr->bclink.last_in);
Ying Xuebc6fecd2014-11-26 11:41:53 +0800327 msg_set_bcgap_to(msg, to);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100328
Ying Xue1da46562015-01-09 15:27:07 +0800329 tipc_bclink_lock(net);
Ying Xue7f9f95d2015-01-09 15:27:06 +0800330 tipc_bearer_send(net, MAX_BEARERS, buf, NULL);
Ying Xue1da46562015-01-09 15:27:07 +0800331 tn->bcl->stats.sent_nacks++;
332 tipc_bclink_unlock(net);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400333 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100334
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400335 n_ptr->bclink.oos_state++;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100336 }
337}
338
Ben Hutchings2c530402012-07-10 10:55:09 +0000339/**
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400340 * bclink_peek_nack - monitor retransmission requests sent by other nodes
Per Lidenb97bf3f2006-01-02 19:04:38 +0100341 *
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400342 * Delay any upcoming NACK by this node if another node has already
343 * requested the first message this node is going to ask for.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100344 */
Ying Xuef2f98002015-01-09 15:27:05 +0800345static void bclink_peek_nack(struct net *net, struct tipc_msg *msg)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100346{
Ying Xuef2f98002015-01-09 15:27:05 +0800347 struct tipc_node *n_ptr = tipc_node_find(net, msg_destnode(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100348
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400349 if (unlikely(!n_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100350 return;
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400351
Per Liden4323add2006-01-18 00:38:21 +0100352 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100353
Ying Xue389dd9b2012-11-16 13:51:30 +0800354 if (n_ptr->bclink.recv_permitted &&
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400355 (n_ptr->bclink.last_in != n_ptr->bclink.last_sent) &&
356 (n_ptr->bclink.last_in == msg_bcgap_after(msg)))
357 n_ptr->bclink.oos_state = 2;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100358
Per Liden4323add2006-01-18 00:38:21 +0100359 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100360}
361
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500362/* tipc_bclink_xmit - deliver buffer chain to all nodes in cluster
Jon Paul Maloy9fbfb8b2014-07-16 20:41:03 -0400363 * and to identified node local sockets
Ying Xuef2f98002015-01-09 15:27:05 +0800364 * @net: the applicable net namespace
Ying Xuea6ca1092014-11-26 11:41:55 +0800365 * @list: chain of buffers containing message
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400366 * Consumes the buffer chain, except when returning -ELINKCONG
367 * Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE
368 */
Ying Xuef2f98002015-01-09 15:27:05 +0800369int tipc_bclink_xmit(struct net *net, struct sk_buff_head *list)
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400370{
Ying Xue1da46562015-01-09 15:27:07 +0800371 struct tipc_net *tn = net_generic(net, tipc_net_id);
372 struct tipc_link *bcl = tn->bcl;
373 struct tipc_bclink *bclink = tn->bclink;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400374 int rc = 0;
375 int bc = 0;
Ying Xuea6ca1092014-11-26 11:41:55 +0800376 struct sk_buff *skb;
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500377 struct sk_buff_head arrvq;
378 struct sk_buff_head inputq;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400379
380 /* Prepare clone of message for local node */
Ying Xuea6ca1092014-11-26 11:41:55 +0800381 skb = tipc_msg_reassemble(list);
382 if (unlikely(!skb)) {
383 __skb_queue_purge(list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400384 return -EHOSTUNREACH;
385 }
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500386 /* Broadcast to all nodes */
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400387 if (likely(bclink)) {
Ying Xue1da46562015-01-09 15:27:07 +0800388 tipc_bclink_lock(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400389 if (likely(bclink->bcast_nodes.count)) {
Ying Xue7f9f95d2015-01-09 15:27:06 +0800390 rc = __tipc_link_xmit(net, bcl, list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400391 if (likely(!rc)) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400392 u32 len = skb_queue_len(&bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800393
Ying Xue1da46562015-01-09 15:27:07 +0800394 bclink_set_last_sent(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400395 bcl->stats.queue_sz_counts++;
Ying Xue58dc55f2014-11-26 11:41:52 +0800396 bcl->stats.accu_queue_sz += len;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400397 }
398 bc = 1;
399 }
Ying Xue1da46562015-01-09 15:27:07 +0800400 tipc_bclink_unlock(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400401 }
402
403 if (unlikely(!bc))
Ying Xuea6ca1092014-11-26 11:41:55 +0800404 __skb_queue_purge(list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400405
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500406 if (unlikely(rc)) {
Ying Xuea6ca1092014-11-26 11:41:55 +0800407 kfree_skb(skb);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500408 return rc;
409 }
410 /* Deliver message clone */
411 __skb_queue_head_init(&arrvq);
412 skb_queue_head_init(&inputq);
413 __skb_queue_tail(&arrvq, skb);
414 tipc_sk_mcast_rcv(net, &arrvq, &inputq);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400415 return rc;
416}
417
Ben Hutchings2c530402012-07-10 10:55:09 +0000418/**
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400419 * bclink_accept_pkt - accept an incoming, in-sequence broadcast packet
420 *
Ying Xued69afc92014-05-05 08:56:15 +0800421 * Called with both sending node's lock and bclink_lock taken.
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400422 */
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400423static void bclink_accept_pkt(struct tipc_node *node, u32 seqno)
424{
Ying Xue1da46562015-01-09 15:27:07 +0800425 struct tipc_net *tn = net_generic(node->net, tipc_net_id);
426
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400427 bclink_update_last_sent(node, seqno);
428 node->bclink.last_in = seqno;
429 node->bclink.oos_state = 0;
Ying Xue1da46562015-01-09 15:27:07 +0800430 tn->bcl->stats.recv_info++;
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400431
432 /*
433 * Unicast an ACK periodically, ensuring that
434 * all nodes in the cluster don't ACK at the same time
435 */
Ying Xue34747532015-01-09 15:27:10 +0800436 if (((seqno - tn->own_addr) % TIPC_MIN_LINK_WIN) == 0) {
Ying Xue247f0f32014-02-18 16:06:46 +0800437 tipc_link_proto_xmit(node->active_links[node->addr & 1],
438 STATE_MSG, 0, 0, 0, 0, 0);
Ying Xue1da46562015-01-09 15:27:07 +0800439 tn->bcl->stats.sent_acks++;
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400440 }
441}
442
Ben Hutchings2c530402012-07-10 10:55:09 +0000443/**
Ying Xue247f0f32014-02-18 16:06:46 +0800444 * tipc_bclink_rcv - receive a broadcast packet, and deliver upwards
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900445 *
Ying Xue7216cd92014-04-21 10:55:48 +0800446 * RCU is locked, no other locks set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100447 */
Ying Xuec93d3ba2015-01-09 15:27:04 +0800448void tipc_bclink_rcv(struct net *net, struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -0700449{
Ying Xuec93d3ba2015-01-09 15:27:04 +0800450 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800451 struct tipc_link *bcl = tn->bcl;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100452 struct tipc_msg *msg = buf_msg(buf);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400453 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100454 u32 next_in;
455 u32 seqno;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400456 int deferred = 0;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500457 int pos = 0;
458 struct sk_buff *iskb;
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500459 struct sk_buff_head *arrvq, *inputq;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100460
Allan Stephens5d3c4882011-04-07 13:57:25 -0400461 /* Screen out unwanted broadcast messages */
Ying Xuec93d3ba2015-01-09 15:27:04 +0800462 if (msg_mc_netid(msg) != tn->net_id)
Allan Stephens5d3c4882011-04-07 13:57:25 -0400463 goto exit;
464
Ying Xuef2f98002015-01-09 15:27:05 +0800465 node = tipc_node_find(net, msg_prevnode(msg));
Allan Stephens5d3c4882011-04-07 13:57:25 -0400466 if (unlikely(!node))
467 goto exit;
468
469 tipc_node_lock(node);
Ying Xue389dd9b2012-11-16 13:51:30 +0800470 if (unlikely(!node->bclink.recv_permitted))
Allan Stephens5d3c4882011-04-07 13:57:25 -0400471 goto unlock;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100472
Allan Stephens8a275a62011-10-26 15:33:44 -0400473 /* Handle broadcast protocol message */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100474 if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
Allan Stephens9f6bdcd42011-04-07 14:57:53 -0400475 if (msg_type(msg) != STATE_MSG)
476 goto unlock;
Ying Xue34747532015-01-09 15:27:10 +0800477 if (msg_destnode(msg) == tn->own_addr) {
Per Liden4323add2006-01-18 00:38:21 +0100478 tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
479 tipc_node_unlock(node);
Ying Xue1da46562015-01-09 15:27:07 +0800480 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100481 bcl->stats.recv_nacks++;
Ying Xue1da46562015-01-09 15:27:07 +0800482 tn->bclink->retransmit_to = node;
483 bclink_retransmit_pkt(tn, msg_bcgap_after(msg),
Per Lidenb97bf3f2006-01-02 19:04:38 +0100484 msg_bcgap_to(msg));
Ying Xue1da46562015-01-09 15:27:07 +0800485 tipc_bclink_unlock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100486 } else {
Allan Stephens5d3c4882011-04-07 13:57:25 -0400487 tipc_node_unlock(node);
Ying Xuef2f98002015-01-09 15:27:05 +0800488 bclink_peek_nack(net, msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100489 }
Allan Stephens5d3c4882011-04-07 13:57:25 -0400490 goto exit;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100491 }
492
Allan Stephens5d3c4882011-04-07 13:57:25 -0400493 /* Handle in-sequence broadcast message */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100494 seqno = msg_seqno(msg);
Allan Stephens8a275a62011-10-26 15:33:44 -0400495 next_in = mod(node->bclink.last_in + 1);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500496 arrvq = &tn->bclink->arrvq;
497 inputq = &tn->bclink->inputq;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100498
499 if (likely(seqno == next_in)) {
Allan Stephens8a275a62011-10-26 15:33:44 -0400500receive:
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400501 /* Deliver message to destination */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100502 if (likely(msg_isdata(msg))) {
Ying Xue1da46562015-01-09 15:27:07 +0800503 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400504 bclink_accept_pkt(node, seqno);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500505 spin_lock_bh(&inputq->lock);
506 __skb_queue_tail(arrvq, buf);
507 spin_unlock_bh(&inputq->lock);
508 node->action_flags |= TIPC_BCAST_MSG_EVT;
Ying Xue1da46562015-01-09 15:27:07 +0800509 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100510 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100511 } else if (msg_user(msg) == MSG_BUNDLER) {
Ying Xue1da46562015-01-09 15:27:07 +0800512 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400513 bclink_accept_pkt(node, seqno);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100514 bcl->stats.recv_bundles++;
515 bcl->stats.recv_bundled += msg_msgcnt(msg);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500516 pos = 0;
517 while (tipc_msg_extract(buf, &iskb, &pos)) {
518 spin_lock_bh(&inputq->lock);
519 __skb_queue_tail(arrvq, iskb);
520 spin_unlock_bh(&inputq->lock);
521 }
522 node->action_flags |= TIPC_BCAST_MSG_EVT;
Ying Xue1da46562015-01-09 15:27:07 +0800523 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100524 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100525 } else if (msg_user(msg) == MSG_FRAGMENTER) {
Ying Xue1da46562015-01-09 15:27:07 +0800526 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400527 bclink_accept_pkt(node, seqno);
Ying Xuebc14b8d2015-03-25 18:09:40 +0800528 tipc_buf_append(&node->bclink.reasm_buf, &buf);
529 if (unlikely(!buf && !node->bclink.reasm_buf)) {
530 tipc_bclink_unlock(net);
531 goto unlock;
532 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100533 bcl->stats.recv_fragments++;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400534 if (buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100535 bcl->stats.recv_fragmented++;
Erik Hugne40ba3cd2013-11-06 09:28:06 +0100536 msg = buf_msg(buf);
Ying Xue1da46562015-01-09 15:27:07 +0800537 tipc_bclink_unlock(net);
Erik Hugne528f6f42013-11-06 09:28:05 +0100538 goto receive;
539 }
Ying Xue1da46562015-01-09 15:27:07 +0800540 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100541 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100542 } else {
Ying Xue1da46562015-01-09 15:27:07 +0800543 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400544 bclink_accept_pkt(node, seqno);
Ying Xue1da46562015-01-09 15:27:07 +0800545 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100546 tipc_node_unlock(node);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400547 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100548 }
Allan Stephens5d3c4882011-04-07 13:57:25 -0400549 buf = NULL;
Allan Stephens8a275a62011-10-26 15:33:44 -0400550
551 /* Determine new synchronization state */
Allan Stephens5d3c4882011-04-07 13:57:25 -0400552 tipc_node_lock(node);
Allan Stephens8a275a62011-10-26 15:33:44 -0400553 if (unlikely(!tipc_node_is_up(node)))
554 goto unlock;
555
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400556 if (node->bclink.last_in == node->bclink.last_sent)
Allan Stephens8a275a62011-10-26 15:33:44 -0400557 goto unlock;
558
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400559 if (skb_queue_empty(&node->bclink.deferdq)) {
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400560 node->bclink.oos_state = 1;
561 goto unlock;
562 }
563
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400564 msg = buf_msg(skb_peek(&node->bclink.deferdq));
Allan Stephens8a275a62011-10-26 15:33:44 -0400565 seqno = msg_seqno(msg);
566 next_in = mod(next_in + 1);
567 if (seqno != next_in)
568 goto unlock;
569
570 /* Take in-sequence message from deferred queue & deliver it */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400571 buf = __skb_dequeue(&node->bclink.deferdq);
Allan Stephens8a275a62011-10-26 15:33:44 -0400572 goto receive;
573 }
574
575 /* Handle out-of-sequence broadcast message */
Allan Stephens8a275a62011-10-26 15:33:44 -0400576 if (less(next_in, seqno)) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400577 deferred = tipc_link_defer_pkt(&node->bclink.deferdq,
Allan Stephens8a275a62011-10-26 15:33:44 -0400578 buf);
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400579 bclink_update_last_sent(node, seqno);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400580 buf = NULL;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400581 }
Allan Stephens8a275a62011-10-26 15:33:44 -0400582
Ying Xue1da46562015-01-09 15:27:07 +0800583 tipc_bclink_lock(net);
Allan Stephensb98158e2011-10-26 16:13:35 -0400584
Allan Stephens8a275a62011-10-26 15:33:44 -0400585 if (deferred)
586 bcl->stats.deferred_recv++;
Allan Stephens0232c5a2011-10-26 15:57:26 -0400587 else
588 bcl->stats.duplicates++;
Allan Stephens8a275a62011-10-26 15:33:44 -0400589
Ying Xue1da46562015-01-09 15:27:07 +0800590 tipc_bclink_unlock(net);
Allan Stephensb98158e2011-10-26 16:13:35 -0400591
Allan Stephens5d3c4882011-04-07 13:57:25 -0400592unlock:
Per Liden4323add2006-01-18 00:38:21 +0100593 tipc_node_unlock(node);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400594exit:
Allan Stephens5f6d9122011-11-04 13:24:29 -0400595 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100596}
597
David S. Miller6c000552008-09-02 23:38:32 -0700598u32 tipc_bclink_acks_missing(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100599{
Ying Xue389dd9b2012-11-16 13:51:30 +0800600 return (n_ptr->bclink.recv_permitted &&
Ying Xue1da46562015-01-09 15:27:07 +0800601 (tipc_bclink_get_last_sent(n_ptr->net) != n_ptr->bclink.acked));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100602}
603
604
605/**
Per Liden4323add2006-01-18 00:38:21 +0100606 * tipc_bcbearer_send - send a packet through the broadcast pseudo-bearer
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900607 *
Allan Stephens2ff9f922011-04-07 10:44:54 -0400608 * Send packet over as many bearers as necessary to reach all nodes
609 * that have joined the broadcast link.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900610 *
Allan Stephens2ff9f922011-04-07 10:44:54 -0400611 * Returns 0 (packet sent successfully) under all circumstances,
612 * since the broadcast link's pseudo-bearer never blocks
Per Lidenb97bf3f2006-01-02 19:04:38 +0100613 */
Ying Xue1da46562015-01-09 15:27:07 +0800614static int tipc_bcbearer_send(struct net *net, struct sk_buff *buf,
615 struct tipc_bearer *unused1,
Adrian Bunk988f0882006-03-20 22:37:52 -0800616 struct tipc_media_addr *unused2)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100617{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100618 int bp_index;
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400619 struct tipc_msg *msg = buf_msg(buf);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800620 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800621 struct tipc_bcbearer *bcbearer = tn->bcbearer;
622 struct tipc_bclink *bclink = tn->bclink;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100623
Gerlando Falautoe6160712013-05-01 12:04:44 +0000624 /* Prepare broadcast link message for reliable transmission,
Allan Stephens2ff9f922011-04-07 10:44:54 -0400625 * if first time trying to send it;
626 * preparation is skipped for broadcast link protocol messages
627 * since they are sent in an unreliable manner and don't need it
628 */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100629 if (likely(!msg_non_seq(buf_msg(buf)))) {
Allan Stephenscd3decd2011-10-24 11:18:12 -0400630 bcbuf_set_acks(buf, bclink->bcast_nodes.count);
Allan Stephens40aecb12008-06-04 17:54:48 -0700631 msg_set_non_seq(msg, 1);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800632 msg_set_mc_netid(msg, tn->net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800633 tn->bcl->stats.sent_info++;
Allan Stephenscd3decd2011-10-24 11:18:12 -0400634 if (WARN_ON(!bclink->bcast_nodes.count)) {
Allan Stephens5e726902011-05-23 13:14:18 -0400635 dump_stack();
636 return 0;
637 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100638 }
639
Per Lidenb97bf3f2006-01-02 19:04:38 +0100640 /* Send buffer over bearers until all targets reached */
Allan Stephenscd3decd2011-10-24 11:18:12 -0400641 bcbearer->remains = bclink->bcast_nodes;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100642
643 for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
Allan Stephens2d627b92011-01-07 13:00:11 -0500644 struct tipc_bearer *p = bcbearer->bpairs[bp_index].primary;
645 struct tipc_bearer *s = bcbearer->bpairs[bp_index].secondary;
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400646 struct tipc_bearer *bp[2] = {p, s};
647 struct tipc_bearer *b = bp[msg_link_selector(msg)];
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000648 struct sk_buff *tbuf;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100649
650 if (!p)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000651 break; /* No more bearers to try */
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400652 if (!b)
653 b = p;
Gerlando Falauto77861d92013-05-01 12:04:45 +0000654 tipc_nmap_diff(&bcbearer->remains, &b->nodes,
Gerlando Falautoe6160712013-05-01 12:04:44 +0000655 &bcbearer->remains_new);
Allan Stephens65f51ef2006-06-25 23:53:20 -0700656 if (bcbearer->remains_new.count == bcbearer->remains.count)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000657 continue; /* Nothing added by bearer pair */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100658
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000659 if (bp_index == 0) {
660 /* Use original buffer for first bearer */
Ying Xue7f9f95d2015-01-09 15:27:06 +0800661 tipc_bearer_send(net, b->identity, buf, &b->bcast_addr);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000662 } else {
663 /* Avoid concurrent buffer access */
Octavian Purdilabad93e92014-06-12 01:36:26 +0300664 tbuf = pskb_copy_for_clone(buf, GFP_ATOMIC);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000665 if (!tbuf)
666 break;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800667 tipc_bearer_send(net, b->identity, tbuf,
668 &b->bcast_addr);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000669 kfree_skb(tbuf); /* Bearer keeps a clone */
670 }
Allan Stephens65f51ef2006-06-25 23:53:20 -0700671 if (bcbearer->remains_new.count == 0)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000672 break; /* All targets reached */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100673
Allan Stephens65f51ef2006-06-25 23:53:20 -0700674 bcbearer->remains = bcbearer->remains_new;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100675 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900676
Allan Stephens2ff9f922011-04-07 10:44:54 -0400677 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100678}
679
680/**
Per Liden4323add2006-01-18 00:38:21 +0100681 * tipc_bcbearer_sort - create sets of bearer pairs used by broadcast bearer
Per Lidenb97bf3f2006-01-02 19:04:38 +0100682 */
Ying Xue7f9f95d2015-01-09 15:27:06 +0800683void tipc_bcbearer_sort(struct net *net, struct tipc_node_map *nm_ptr,
684 u32 node, bool action)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100685{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800686 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800687 struct tipc_bcbearer *bcbearer = tn->bcbearer;
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -0500688 struct tipc_bcbearer_pair *bp_temp = bcbearer->bpairs_temp;
689 struct tipc_bcbearer_pair *bp_curr;
Ying Xuef8322df2014-04-21 10:55:45 +0800690 struct tipc_bearer *b;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100691 int b_index;
692 int pri;
693
Ying Xue1da46562015-01-09 15:27:07 +0800694 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100695
Ying Xue28dd9412014-04-21 10:55:51 +0800696 if (action)
697 tipc_nmap_add(nm_ptr, node);
698 else
699 tipc_nmap_remove(nm_ptr, node);
700
Per Lidenb97bf3f2006-01-02 19:04:38 +0100701 /* Group bearers by priority (can assume max of two per priority) */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100702 memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));
703
Ying Xuef8322df2014-04-21 10:55:45 +0800704 rcu_read_lock();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100705 for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
Ying Xue7f9f95d2015-01-09 15:27:06 +0800706 b = rcu_dereference_rtnl(tn->bearer_list[b_index]);
Ying Xuef47de122014-03-27 12:54:34 +0800707 if (!b || !b->nodes.count)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100708 continue;
709
710 if (!bp_temp[b->priority].primary)
711 bp_temp[b->priority].primary = b;
712 else
713 bp_temp[b->priority].secondary = b;
714 }
Ying Xuef8322df2014-04-21 10:55:45 +0800715 rcu_read_unlock();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100716
717 /* Create array of bearer pairs for broadcasting */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100718 bp_curr = bcbearer->bpairs;
719 memset(bcbearer->bpairs, 0, sizeof(bcbearer->bpairs));
720
Per Liden16cb4b32006-01-13 22:22:22 +0100721 for (pri = TIPC_MAX_LINK_PRI; pri >= 0; pri--) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100722
723 if (!bp_temp[pri].primary)
724 continue;
725
726 bp_curr->primary = bp_temp[pri].primary;
727
728 if (bp_temp[pri].secondary) {
Per Liden4323add2006-01-18 00:38:21 +0100729 if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
730 &bp_temp[pri].secondary->nodes)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100731 bp_curr->secondary = bp_temp[pri].secondary;
732 } else {
733 bp_curr++;
734 bp_curr->primary = bp_temp[pri].secondary;
735 }
736 }
737
738 bp_curr++;
739 }
740
Ying Xue1da46562015-01-09 15:27:07 +0800741 tipc_bclink_unlock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100742}
743
Richard Alped8182802014-11-24 11:10:29 +0100744static int __tipc_nl_add_bc_link_stat(struct sk_buff *skb,
745 struct tipc_stats *stats)
Richard Alpe7be57fc2014-11-20 10:29:12 +0100746{
747 int i;
748 struct nlattr *nest;
749
750 struct nla_map {
751 __u32 key;
752 __u32 val;
753 };
754
755 struct nla_map map[] = {
756 {TIPC_NLA_STATS_RX_INFO, stats->recv_info},
757 {TIPC_NLA_STATS_RX_FRAGMENTS, stats->recv_fragments},
758 {TIPC_NLA_STATS_RX_FRAGMENTED, stats->recv_fragmented},
759 {TIPC_NLA_STATS_RX_BUNDLES, stats->recv_bundles},
760 {TIPC_NLA_STATS_RX_BUNDLED, stats->recv_bundled},
761 {TIPC_NLA_STATS_TX_INFO, stats->sent_info},
762 {TIPC_NLA_STATS_TX_FRAGMENTS, stats->sent_fragments},
763 {TIPC_NLA_STATS_TX_FRAGMENTED, stats->sent_fragmented},
764 {TIPC_NLA_STATS_TX_BUNDLES, stats->sent_bundles},
765 {TIPC_NLA_STATS_TX_BUNDLED, stats->sent_bundled},
766 {TIPC_NLA_STATS_RX_NACKS, stats->recv_nacks},
767 {TIPC_NLA_STATS_RX_DEFERRED, stats->deferred_recv},
768 {TIPC_NLA_STATS_TX_NACKS, stats->sent_nacks},
769 {TIPC_NLA_STATS_TX_ACKS, stats->sent_acks},
770 {TIPC_NLA_STATS_RETRANSMITTED, stats->retransmitted},
771 {TIPC_NLA_STATS_DUPLICATES, stats->duplicates},
772 {TIPC_NLA_STATS_LINK_CONGS, stats->link_congs},
773 {TIPC_NLA_STATS_MAX_QUEUE, stats->max_queue_sz},
774 {TIPC_NLA_STATS_AVG_QUEUE, stats->queue_sz_counts ?
775 (stats->accu_queue_sz / stats->queue_sz_counts) : 0}
776 };
777
778 nest = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
779 if (!nest)
780 return -EMSGSIZE;
781
782 for (i = 0; i < ARRAY_SIZE(map); i++)
783 if (nla_put_u32(skb, map[i].key, map[i].val))
784 goto msg_full;
785
786 nla_nest_end(skb, nest);
787
788 return 0;
789msg_full:
790 nla_nest_cancel(skb, nest);
791
792 return -EMSGSIZE;
793}
794
Ying Xue1da46562015-01-09 15:27:07 +0800795int tipc_nl_add_bc_link(struct net *net, struct tipc_nl_msg *msg)
Richard Alpe7be57fc2014-11-20 10:29:12 +0100796{
797 int err;
798 void *hdr;
799 struct nlattr *attrs;
800 struct nlattr *prop;
Ying Xue1da46562015-01-09 15:27:07 +0800801 struct tipc_net *tn = net_generic(net, tipc_net_id);
802 struct tipc_link *bcl = tn->bcl;
Richard Alpe7be57fc2014-11-20 10:29:12 +0100803
804 if (!bcl)
805 return 0;
806
Ying Xue1da46562015-01-09 15:27:07 +0800807 tipc_bclink_lock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100808
Richard Alpebfb3e5d2015-02-09 09:50:03 +0100809 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
Richard Alpe7be57fc2014-11-20 10:29:12 +0100810 NLM_F_MULTI, TIPC_NL_LINK_GET);
811 if (!hdr)
812 return -EMSGSIZE;
813
814 attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
815 if (!attrs)
816 goto msg_full;
817
818 /* The broadcast link is always up */
819 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
820 goto attr_msg_full;
821
822 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_BROADCAST))
823 goto attr_msg_full;
824 if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, bcl->name))
825 goto attr_msg_full;
826 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, bcl->next_in_no))
827 goto attr_msg_full;
828 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, bcl->next_out_no))
829 goto attr_msg_full;
830
831 prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
832 if (!prop)
833 goto attr_msg_full;
834 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bcl->queue_limit[0]))
835 goto prop_msg_full;
836 nla_nest_end(msg->skb, prop);
837
838 err = __tipc_nl_add_bc_link_stat(msg->skb, &bcl->stats);
839 if (err)
840 goto attr_msg_full;
841
Ying Xue1da46562015-01-09 15:27:07 +0800842 tipc_bclink_unlock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100843 nla_nest_end(msg->skb, attrs);
844 genlmsg_end(msg->skb, hdr);
845
846 return 0;
847
848prop_msg_full:
849 nla_nest_cancel(msg->skb, prop);
850attr_msg_full:
851 nla_nest_cancel(msg->skb, attrs);
852msg_full:
Ying Xue1da46562015-01-09 15:27:07 +0800853 tipc_bclink_unlock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100854 genlmsg_cancel(msg->skb, hdr);
855
856 return -EMSGSIZE;
857}
Per Lidenb97bf3f2006-01-02 19:04:38 +0100858
Ying Xue1da46562015-01-09 15:27:07 +0800859int tipc_bclink_reset_stats(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100860{
Ying Xue1da46562015-01-09 15:27:07 +0800861 struct tipc_net *tn = net_generic(net, tipc_net_id);
862 struct tipc_link *bcl = tn->bcl;
863
Per Lidenb97bf3f2006-01-02 19:04:38 +0100864 if (!bcl)
865 return -ENOPROTOOPT;
866
Ying Xue1da46562015-01-09 15:27:07 +0800867 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100868 memset(&bcl->stats, 0, sizeof(bcl->stats));
Ying Xue1da46562015-01-09 15:27:07 +0800869 tipc_bclink_unlock(net);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700870 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100871}
872
Ying Xue1da46562015-01-09 15:27:07 +0800873int tipc_bclink_set_queue_limits(struct net *net, u32 limit)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100874{
Ying Xue1da46562015-01-09 15:27:07 +0800875 struct tipc_net *tn = net_generic(net, tipc_net_id);
876 struct tipc_link *bcl = tn->bcl;
877
Per Lidenb97bf3f2006-01-02 19:04:38 +0100878 if (!bcl)
879 return -ENOPROTOOPT;
880 if ((limit < TIPC_MIN_LINK_WIN) || (limit > TIPC_MAX_LINK_WIN))
881 return -EINVAL;
882
Ying Xue1da46562015-01-09 15:27:07 +0800883 tipc_bclink_lock(net);
Per Liden4323add2006-01-18 00:38:21 +0100884 tipc_link_set_queue_limits(bcl, limit);
Ying Xue1da46562015-01-09 15:27:07 +0800885 tipc_bclink_unlock(net);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700886 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100887}
888
Ying Xue7f9f95d2015-01-09 15:27:06 +0800889int tipc_bclink_init(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100890{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800891 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800892 struct tipc_bcbearer *bcbearer;
893 struct tipc_bclink *bclink;
894 struct tipc_link *bcl;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800895
Ying Xueeb8b00f2014-05-05 08:56:16 +0800896 bcbearer = kzalloc(sizeof(*bcbearer), GFP_ATOMIC);
897 if (!bcbearer)
898 return -ENOMEM;
899
900 bclink = kzalloc(sizeof(*bclink), GFP_ATOMIC);
901 if (!bclink) {
902 kfree(bcbearer);
903 return -ENOMEM;
904 }
905
906 bcl = &bclink->link;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100907 bcbearer->bearer.media = &bcbearer->media;
Per Liden4323add2006-01-18 00:38:21 +0100908 bcbearer->media.send_msg = tipc_bcbearer_send;
Allan Stephens2e2d9be2011-04-07 10:22:31 -0400909 sprintf(bcbearer->media.name, "tipc-broadcast");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100910
Ying Xued69afc92014-05-05 08:56:15 +0800911 spin_lock_init(&bclink->lock);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400912 __skb_queue_head_init(&bcl->transmq);
913 __skb_queue_head_init(&bcl->backlogq);
914 __skb_queue_head_init(&bcl->deferdq);
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500915 skb_queue_head_init(&bcl->wakeupq);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100916 bcl->next_out_no = 1;
Ingo Molnar34af9462006-06-27 02:53:55 -0700917 spin_lock_init(&bclink->node.lock);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500918 __skb_queue_head_init(&bclink->arrvq);
919 skb_queue_head_init(&bclink->inputq);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100920 bcl->owner = &bclink->node;
Ying Xue1da46562015-01-09 15:27:07 +0800921 bcl->owner->net = net;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900922 bcl->max_pkt = MAX_PKT_DEFAULT_MCAST;
Per Liden4323add2006-01-18 00:38:21 +0100923 tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
Ying Xue7a2f7d12014-04-21 10:55:46 +0800924 bcl->bearer_id = MAX_BEARERS;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800925 rcu_assign_pointer(tn->bearer_list[MAX_BEARERS], &bcbearer->bearer);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100926 bcl->state = WORKING_WORKING;
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500927 bcl->pmsg = (struct tipc_msg *)&bcl->proto_msg;
928 msg_set_prevnode(bcl->pmsg, tn->own_addr);
Stephen Hemminger4b704d52009-03-18 19:11:29 -0700929 strlcpy(bcl->name, tipc_bclink_name, TIPC_MAX_LINK_NAME);
Ying Xue1da46562015-01-09 15:27:07 +0800930 tn->bcbearer = bcbearer;
931 tn->bclink = bclink;
932 tn->bcl = bcl;
Ying Xueeb8b00f2014-05-05 08:56:16 +0800933 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100934}
935
Ying Xue7f9f95d2015-01-09 15:27:06 +0800936void tipc_bclink_stop(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100937{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800938 struct tipc_net *tn = net_generic(net, tipc_net_id);
939
Ying Xue1da46562015-01-09 15:27:07 +0800940 tipc_bclink_lock(net);
941 tipc_link_purge_queues(tn->bcl);
942 tipc_bclink_unlock(net);
Allan Stephensc47e9b92011-10-24 10:29:26 -0400943
Ying Xue7f9f95d2015-01-09 15:27:06 +0800944 RCU_INIT_POINTER(tn->bearer_list[BCBEARER], NULL);
Ying Xueeb8b00f2014-05-05 08:56:16 +0800945 synchronize_net();
Ying Xue1da46562015-01-09 15:27:07 +0800946 kfree(tn->bcbearer);
947 kfree(tn->bclink);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100948}
949
Allan Stephens3e22e622010-05-11 14:30:14 +0000950/**
951 * tipc_nmap_add - add a node to a node map
952 */
Ying Xue28dd9412014-04-21 10:55:51 +0800953static void tipc_nmap_add(struct tipc_node_map *nm_ptr, u32 node)
Allan Stephens3e22e622010-05-11 14:30:14 +0000954{
955 int n = tipc_node(node);
956 int w = n / WSIZE;
957 u32 mask = (1 << (n % WSIZE));
958
959 if ((nm_ptr->map[w] & mask) == 0) {
960 nm_ptr->count++;
961 nm_ptr->map[w] |= mask;
962 }
963}
964
965/**
966 * tipc_nmap_remove - remove a node from a node map
967 */
Ying Xue28dd9412014-04-21 10:55:51 +0800968static void tipc_nmap_remove(struct tipc_node_map *nm_ptr, u32 node)
Allan Stephens3e22e622010-05-11 14:30:14 +0000969{
970 int n = tipc_node(node);
971 int w = n / WSIZE;
972 u32 mask = (1 << (n % WSIZE));
973
974 if ((nm_ptr->map[w] & mask) != 0) {
975 nm_ptr->map[w] &= ~mask;
976 nm_ptr->count--;
977 }
978}
979
980/**
981 * tipc_nmap_diff - find differences between node maps
982 * @nm_a: input node map A
983 * @nm_b: input node map B
984 * @nm_diff: output node map A-B (i.e. nodes of A that are not in B)
985 */
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000986static void tipc_nmap_diff(struct tipc_node_map *nm_a,
987 struct tipc_node_map *nm_b,
988 struct tipc_node_map *nm_diff)
Allan Stephens3e22e622010-05-11 14:30:14 +0000989{
990 int stop = ARRAY_SIZE(nm_a->map);
991 int w;
992 int b;
993 u32 map;
994
995 memset(nm_diff, 0, sizeof(*nm_diff));
996 for (w = 0; w < stop; w++) {
997 map = nm_a->map[w] ^ (nm_a->map[w] & nm_b->map[w]);
998 nm_diff->map[w] = map;
999 if (map != 0) {
1000 for (b = 0 ; b < WSIZE; b++) {
1001 if (map & (1 << b))
1002 nm_diff->count++;
1003 }
1004 }
1005 }
1006}