blob: a816382fc8af1b9efb016f888493ca4dcc65fe3b [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
Ying Xue1da46562015-01-09 15:27:07 +080066 spin_unlock_bh(&tn->bclink->lock);
Ying Xue3f5a12b2014-05-05 08:56:17 +080067}
68
Jon Paul Maloycb1b7282015-02-05 08:36:44 -050069void tipc_bclink_input(struct net *net)
70{
71 struct tipc_net *tn = net_generic(net, tipc_net_id);
72
73 tipc_sk_mcast_rcv(net, &tn->bclink->arrvq, &tn->bclink->inputq);
74}
75
Jon Paul Maloy078bec82014-07-16 20:41:00 -040076uint tipc_bclink_get_mtu(void)
77{
78 return MAX_PKT_DEFAULT_MCAST;
79}
80
Sam Ravnborg05790c62006-03-20 22:37:04 -080081static u32 bcbuf_acks(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +010082{
David S. Miller880b0052006-01-12 13:22:32 -080083 return (u32)(unsigned long)TIPC_SKB_CB(buf)->handle;
Per Lidenb97bf3f2006-01-02 19:04:38 +010084}
85
Sam Ravnborg05790c62006-03-20 22:37:04 -080086static void bcbuf_set_acks(struct sk_buff *buf, u32 acks)
Per Lidenb97bf3f2006-01-02 19:04:38 +010087{
David S. Miller880b0052006-01-12 13:22:32 -080088 TIPC_SKB_CB(buf)->handle = (void *)(unsigned long)acks;
Per Lidenb97bf3f2006-01-02 19:04:38 +010089}
90
Sam Ravnborg05790c62006-03-20 22:37:04 -080091static void bcbuf_decr_acks(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +010092{
93 bcbuf_set_acks(buf, bcbuf_acks(buf) - 1);
94}
95
Ying Xue1da46562015-01-09 15:27:07 +080096void tipc_bclink_add_node(struct net *net, u32 addr)
Allan Stephenscd3decd2011-10-24 11:18:12 -040097{
Ying Xue1da46562015-01-09 15:27:07 +080098 struct tipc_net *tn = net_generic(net, tipc_net_id);
99
100 tipc_bclink_lock(net);
101 tipc_nmap_add(&tn->bclink->bcast_nodes, addr);
102 tipc_bclink_unlock(net);
Allan Stephenscd3decd2011-10-24 11:18:12 -0400103}
104
Ying Xue1da46562015-01-09 15:27:07 +0800105void tipc_bclink_remove_node(struct net *net, u32 addr)
Allan Stephenscd3decd2011-10-24 11:18:12 -0400106{
Ying Xue1da46562015-01-09 15:27:07 +0800107 struct tipc_net *tn = net_generic(net, tipc_net_id);
108
109 tipc_bclink_lock(net);
110 tipc_nmap_remove(&tn->bclink->bcast_nodes, addr);
Jon Paul Maloy7d967b62015-06-28 09:44:44 -0400111
112 /* Last node? => reset backlog queue */
113 if (!tn->bclink->bcast_nodes.count)
114 tipc_link_purge_backlog(&tn->bclink->link);
115
Ying Xue1da46562015-01-09 15:27:07 +0800116 tipc_bclink_unlock(net);
Allan Stephenscd3decd2011-10-24 11:18:12 -0400117}
Per Lidenb97bf3f2006-01-02 19:04:38 +0100118
Ying Xue1da46562015-01-09 15:27:07 +0800119static void bclink_set_last_sent(struct net *net)
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000120{
Ying Xue1da46562015-01-09 15:27:07 +0800121 struct tipc_net *tn = net_generic(net, tipc_net_id);
122 struct tipc_link *bcl = tn->bcl;
123
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400124 bcl->silent_intv_cnt = mod(bcl->snd_nxt - 1);
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000125}
126
Ying Xue1da46562015-01-09 15:27:07 +0800127u32 tipc_bclink_get_last_sent(struct net *net)
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000128{
Ying Xue1da46562015-01-09 15:27:07 +0800129 struct tipc_net *tn = net_generic(net, tipc_net_id);
130
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400131 return tn->bcl->silent_intv_cnt;
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000132}
133
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400134static void bclink_update_last_sent(struct tipc_node *node, u32 seqno)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100135{
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400136 node->bclink.last_sent = less_eq(node->bclink.last_sent, seqno) ?
137 seqno : node->bclink.last_sent;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100138}
139
Ben Hutchings2c530402012-07-10 10:55:09 +0000140/**
Allan Stephens01d83ed2011-01-18 13:53:16 -0500141 * tipc_bclink_retransmit_to - get most recent node to request retransmission
142 *
Ying Xued69afc92014-05-05 08:56:15 +0800143 * Called with bclink_lock locked
Allan Stephens01d83ed2011-01-18 13:53:16 -0500144 */
Ying Xue1da46562015-01-09 15:27:07 +0800145struct tipc_node *tipc_bclink_retransmit_to(struct net *net)
Allan Stephens01d83ed2011-01-18 13:53:16 -0500146{
Ying Xue1da46562015-01-09 15:27:07 +0800147 struct tipc_net *tn = net_generic(net, tipc_net_id);
148
149 return tn->bclink->retransmit_to;
Allan Stephens01d83ed2011-01-18 13:53:16 -0500150}
151
152/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100153 * bclink_retransmit_pkt - retransmit broadcast packets
154 * @after: sequence number of last packet to *not* retransmit
155 * @to: sequence number of last packet to retransmit
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900156 *
Ying Xued69afc92014-05-05 08:56:15 +0800157 * Called with bclink_lock locked
Per Lidenb97bf3f2006-01-02 19:04:38 +0100158 */
Ying Xue1da46562015-01-09 15:27:07 +0800159static void bclink_retransmit_pkt(struct tipc_net *tn, u32 after, u32 to)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100160{
Ying Xue58dc55f2014-11-26 11:41:52 +0800161 struct sk_buff *skb;
Ying Xue1da46562015-01-09 15:27:07 +0800162 struct tipc_link *bcl = tn->bcl;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100163
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400164 skb_queue_walk(&bcl->transmq, skb) {
Jon Maloy703068e2015-01-09 15:26:58 +0800165 if (more(buf_seqno(skb), after)) {
166 tipc_link_retransmit(bcl, skb, mod(to - after));
Ying Xue58dc55f2014-11-26 11:41:52 +0800167 break;
Jon Maloy703068e2015-01-09 15:26:58 +0800168 }
Ying Xue58dc55f2014-11-26 11:41:52 +0800169 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100170}
171
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900172/**
Jon Maloy908344c2014-10-07 14:12:34 -0400173 * tipc_bclink_wakeup_users - wake up pending users
174 *
175 * Called with no locks taken
176 */
Ying Xuef2f98002015-01-09 15:27:05 +0800177void tipc_bclink_wakeup_users(struct net *net)
Jon Maloy908344c2014-10-07 14:12:34 -0400178{
Ying Xue1da46562015-01-09 15:27:07 +0800179 struct tipc_net *tn = net_generic(net, tipc_net_id);
Erik Hugne4988bb42014-12-03 16:58:40 +0100180
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500181 tipc_sk_rcv(net, &tn->bclink->link.wakeupq);
Jon Maloy908344c2014-10-07 14:12:34 -0400182}
183
184/**
Per Liden4323add2006-01-18 00:38:21 +0100185 * tipc_bclink_acknowledge - handle acknowledgement of broadcast packets
Per Lidenb97bf3f2006-01-02 19:04:38 +0100186 * @n_ptr: node that sent acknowledgement info
187 * @acked: broadcast sequence # that has been acknowledged
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900188 *
Ying Xued69afc92014-05-05 08:56:15 +0800189 * Node is locked, bclink_lock unlocked.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100190 */
David S. Miller6c000552008-09-02 23:38:32 -0700191void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100192{
Ying Xue58dc55f2014-11-26 11:41:52 +0800193 struct sk_buff *skb, *tmp;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100194 unsigned int released = 0;
Ying Xue1da46562015-01-09 15:27:07 +0800195 struct net *net = n_ptr->net;
196 struct tipc_net *tn = net_generic(net, tipc_net_id);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100197
Jon Paul Maloy2cdf3912015-03-13 16:08:09 -0400198 if (unlikely(!n_ptr->bclink.recv_permitted))
199 return;
200
Ying Xue1da46562015-01-09 15:27:07 +0800201 tipc_bclink_lock(net);
Jon Paul Maloy2cdf3912015-03-13 16:08:09 -0400202
Allan Stephens365595912011-10-24 15:26:24 -0400203 /* Bail out if tx queue is empty (no clean up is required) */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400204 skb = skb_peek(&tn->bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800205 if (!skb)
Allan Stephens365595912011-10-24 15:26:24 -0400206 goto exit;
207
208 /* Determine which messages need to be acknowledged */
209 if (acked == INVALID_LINK_SEQ) {
210 /*
211 * Contact with specified node has been lost, so need to
212 * acknowledge sent messages only (if other nodes still exist)
213 * or both sent and unsent messages (otherwise)
214 */
Ying Xue1da46562015-01-09 15:27:07 +0800215 if (tn->bclink->bcast_nodes.count)
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400216 acked = tn->bcl->silent_intv_cnt;
Allan Stephens365595912011-10-24 15:26:24 -0400217 else
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400218 acked = tn->bcl->snd_nxt;
Allan Stephens365595912011-10-24 15:26:24 -0400219 } else {
220 /*
221 * Bail out if specified sequence number does not correspond
222 * to a message that has been sent and not yet acknowledged
223 */
Ying Xue58dc55f2014-11-26 11:41:52 +0800224 if (less(acked, buf_seqno(skb)) ||
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400225 less(tn->bcl->silent_intv_cnt, acked) ||
Allan Stephens365595912011-10-24 15:26:24 -0400226 less_eq(acked, n_ptr->bclink.acked))
227 goto exit;
228 }
229
230 /* Skip over packets that node has previously acknowledged */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400231 skb_queue_walk(&tn->bcl->transmq, skb) {
Ying Xue58dc55f2014-11-26 11:41:52 +0800232 if (more(buf_seqno(skb), n_ptr->bclink.acked))
233 break;
234 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100235
236 /* Update packets that node is now acknowledging */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400237 skb_queue_walk_from_safe(&tn->bcl->transmq, skb, tmp) {
Ying Xue58dc55f2014-11-26 11:41:52 +0800238 if (more(buf_seqno(skb), acked))
239 break;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400240 bcbuf_decr_acks(skb);
241 bclink_set_last_sent(net);
Ying Xue58dc55f2014-11-26 11:41:52 +0800242 if (bcbuf_acks(skb) == 0) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400243 __skb_unlink(skb, &tn->bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800244 kfree_skb(skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100245 released = 1;
246 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100247 }
248 n_ptr->bclink.acked = acked;
249
250 /* Try resolving broadcast link congestion, if necessary */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400251 if (unlikely(skb_peek(&tn->bcl->backlogq))) {
Ying Xue1da46562015-01-09 15:27:07 +0800252 tipc_link_push_packets(tn->bcl);
253 bclink_set_last_sent(net);
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000254 }
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500255 if (unlikely(released && !skb_queue_empty(&tn->bcl->wakeupq)))
Jon Maloy908344c2014-10-07 14:12:34 -0400256 n_ptr->action_flags |= TIPC_WAKEUP_BCAST_USERS;
Allan Stephens365595912011-10-24 15:26:24 -0400257exit:
Ying Xue1da46562015-01-09 15:27:07 +0800258 tipc_bclink_unlock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100259}
260
Ben Hutchings2c530402012-07-10 10:55:09 +0000261/**
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400262 * tipc_bclink_update_link_state - update broadcast link state
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900263 *
Ying Xue7216cd92014-04-21 10:55:48 +0800264 * RCU and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100265 */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500266void tipc_bclink_update_link_state(struct tipc_node *n_ptr,
Ying Xuec93d3ba2015-01-09 15:27:04 +0800267 u32 last_sent)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100268{
269 struct sk_buff *buf;
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500270 struct net *net = n_ptr->net;
Ying Xuec93d3ba2015-01-09 15:27:04 +0800271 struct tipc_net *tn = net_generic(net, tipc_net_id);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100272
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400273 /* Ignore "stale" link state info */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400274 if (less_eq(last_sent, n_ptr->bclink.last_in))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100275 return;
276
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400277 /* Update link synchronization state; quit if in sync */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400278 bclink_update_last_sent(n_ptr, last_sent);
279
280 if (n_ptr->bclink.last_sent == n_ptr->bclink.last_in)
281 return;
282
283 /* Update out-of-sync state; quit if loss is still unconfirmed */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400284 if ((++n_ptr->bclink.oos_state) == 1) {
285 if (n_ptr->bclink.deferred_size < (TIPC_MIN_LINK_WIN / 2))
286 return;
287 n_ptr->bclink.oos_state++;
288 }
289
290 /* Don't NACK if one has been recently sent (or seen) */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400291 if (n_ptr->bclink.oos_state & 0x1)
292 return;
293
294 /* Send NACK */
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000295 buf = tipc_buf_acquire(INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100296 if (buf) {
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400297 struct tipc_msg *msg = buf_msg(buf);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400298 struct sk_buff *skb = skb_peek(&n_ptr->bclink.deferdq);
Ying Xuebc6fecd2014-11-26 11:41:53 +0800299 u32 to = skb ? buf_seqno(skb) - 1 : n_ptr->bclink.last_sent;
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400300
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500301 tipc_msg_init(tn->own_addr, msg, BCAST_PROTOCOL, STATE_MSG,
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400302 INT_H_SIZE, n_ptr->addr);
Allan Stephensbf781ec2011-01-25 16:12:39 -0500303 msg_set_non_seq(msg, 1);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800304 msg_set_mc_netid(msg, tn->net_id);
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400305 msg_set_bcast_ack(msg, n_ptr->bclink.last_in);
306 msg_set_bcgap_after(msg, n_ptr->bclink.last_in);
Ying Xuebc6fecd2014-11-26 11:41:53 +0800307 msg_set_bcgap_to(msg, to);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100308
Ying Xue1da46562015-01-09 15:27:07 +0800309 tipc_bclink_lock(net);
Ying Xue7f9f95d2015-01-09 15:27:06 +0800310 tipc_bearer_send(net, MAX_BEARERS, buf, NULL);
Ying Xue1da46562015-01-09 15:27:07 +0800311 tn->bcl->stats.sent_nacks++;
312 tipc_bclink_unlock(net);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400313 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100314
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400315 n_ptr->bclink.oos_state++;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100316 }
317}
318
Ben Hutchings2c530402012-07-10 10:55:09 +0000319/**
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400320 * bclink_peek_nack - monitor retransmission requests sent by other nodes
Per Lidenb97bf3f2006-01-02 19:04:38 +0100321 *
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400322 * Delay any upcoming NACK by this node if another node has already
323 * requested the first message this node is going to ask for.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100324 */
Ying Xuef2f98002015-01-09 15:27:05 +0800325static void bclink_peek_nack(struct net *net, struct tipc_msg *msg)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100326{
Ying Xuef2f98002015-01-09 15:27:05 +0800327 struct tipc_node *n_ptr = tipc_node_find(net, msg_destnode(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100328
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400329 if (unlikely(!n_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100330 return;
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400331
Per Liden4323add2006-01-18 00:38:21 +0100332 tipc_node_lock(n_ptr);
Ying Xue389dd9b2012-11-16 13:51:30 +0800333 if (n_ptr->bclink.recv_permitted &&
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400334 (n_ptr->bclink.last_in != n_ptr->bclink.last_sent) &&
335 (n_ptr->bclink.last_in == msg_bcgap_after(msg)))
336 n_ptr->bclink.oos_state = 2;
Per Liden4323add2006-01-18 00:38:21 +0100337 tipc_node_unlock(n_ptr);
Ying Xue8a0f6eb2015-03-26 18:10:24 +0800338 tipc_node_put(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100339}
340
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500341/* tipc_bclink_xmit - deliver buffer chain to all nodes in cluster
Jon Paul Maloy9fbfb8b2014-07-16 20:41:03 -0400342 * and to identified node local sockets
Ying Xuef2f98002015-01-09 15:27:05 +0800343 * @net: the applicable net namespace
Ying Xuea6ca1092014-11-26 11:41:55 +0800344 * @list: chain of buffers containing message
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400345 * Consumes the buffer chain, except when returning -ELINKCONG
346 * Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE
347 */
Ying Xuef2f98002015-01-09 15:27:05 +0800348int tipc_bclink_xmit(struct net *net, struct sk_buff_head *list)
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400349{
Ying Xue1da46562015-01-09 15:27:07 +0800350 struct tipc_net *tn = net_generic(net, tipc_net_id);
351 struct tipc_link *bcl = tn->bcl;
352 struct tipc_bclink *bclink = tn->bclink;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400353 int rc = 0;
354 int bc = 0;
Ying Xuea6ca1092014-11-26 11:41:55 +0800355 struct sk_buff *skb;
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500356 struct sk_buff_head arrvq;
357 struct sk_buff_head inputq;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400358
359 /* Prepare clone of message for local node */
Ying Xuea6ca1092014-11-26 11:41:55 +0800360 skb = tipc_msg_reassemble(list);
361 if (unlikely(!skb)) {
362 __skb_queue_purge(list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400363 return -EHOSTUNREACH;
364 }
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500365 /* Broadcast to all nodes */
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400366 if (likely(bclink)) {
Ying Xue1da46562015-01-09 15:27:07 +0800367 tipc_bclink_lock(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400368 if (likely(bclink->bcast_nodes.count)) {
Ying Xue7f9f95d2015-01-09 15:27:06 +0800369 rc = __tipc_link_xmit(net, bcl, list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400370 if (likely(!rc)) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400371 u32 len = skb_queue_len(&bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800372
Ying Xue1da46562015-01-09 15:27:07 +0800373 bclink_set_last_sent(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400374 bcl->stats.queue_sz_counts++;
Ying Xue58dc55f2014-11-26 11:41:52 +0800375 bcl->stats.accu_queue_sz += len;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400376 }
377 bc = 1;
378 }
Ying Xue1da46562015-01-09 15:27:07 +0800379 tipc_bclink_unlock(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400380 }
381
382 if (unlikely(!bc))
Ying Xuea6ca1092014-11-26 11:41:55 +0800383 __skb_queue_purge(list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400384
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500385 if (unlikely(rc)) {
Ying Xuea6ca1092014-11-26 11:41:55 +0800386 kfree_skb(skb);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500387 return rc;
388 }
389 /* Deliver message clone */
390 __skb_queue_head_init(&arrvq);
391 skb_queue_head_init(&inputq);
392 __skb_queue_tail(&arrvq, skb);
393 tipc_sk_mcast_rcv(net, &arrvq, &inputq);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400394 return rc;
395}
396
Ben Hutchings2c530402012-07-10 10:55:09 +0000397/**
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400398 * bclink_accept_pkt - accept an incoming, in-sequence broadcast packet
399 *
Ying Xued69afc92014-05-05 08:56:15 +0800400 * Called with both sending node's lock and bclink_lock taken.
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400401 */
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400402static void bclink_accept_pkt(struct tipc_node *node, u32 seqno)
403{
Ying Xue1da46562015-01-09 15:27:07 +0800404 struct tipc_net *tn = net_generic(node->net, tipc_net_id);
405
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400406 bclink_update_last_sent(node, seqno);
407 node->bclink.last_in = seqno;
408 node->bclink.oos_state = 0;
Ying Xue1da46562015-01-09 15:27:07 +0800409 tn->bcl->stats.recv_info++;
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400410
411 /*
412 * Unicast an ACK periodically, ensuring that
413 * all nodes in the cluster don't ACK at the same time
414 */
Ying Xue34747532015-01-09 15:27:10 +0800415 if (((seqno - tn->own_addr) % TIPC_MIN_LINK_WIN) == 0) {
Ying Xue247f0f32014-02-18 16:06:46 +0800416 tipc_link_proto_xmit(node->active_links[node->addr & 1],
Jon Paul Maloyed193ec2015-04-02 09:33:02 -0400417 STATE_MSG, 0, 0, 0, 0);
Ying Xue1da46562015-01-09 15:27:07 +0800418 tn->bcl->stats.sent_acks++;
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400419 }
420}
421
Ben Hutchings2c530402012-07-10 10:55:09 +0000422/**
Ying Xue247f0f32014-02-18 16:06:46 +0800423 * tipc_bclink_rcv - receive a broadcast packet, and deliver upwards
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900424 *
Ying Xue7216cd92014-04-21 10:55:48 +0800425 * RCU is locked, no other locks set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100426 */
Ying Xuec93d3ba2015-01-09 15:27:04 +0800427void tipc_bclink_rcv(struct net *net, struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -0700428{
Ying Xuec93d3ba2015-01-09 15:27:04 +0800429 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800430 struct tipc_link *bcl = tn->bcl;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100431 struct tipc_msg *msg = buf_msg(buf);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400432 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100433 u32 next_in;
434 u32 seqno;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400435 int deferred = 0;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500436 int pos = 0;
437 struct sk_buff *iskb;
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500438 struct sk_buff_head *arrvq, *inputq;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100439
Allan Stephens5d3c4882011-04-07 13:57:25 -0400440 /* Screen out unwanted broadcast messages */
Ying Xuec93d3ba2015-01-09 15:27:04 +0800441 if (msg_mc_netid(msg) != tn->net_id)
Allan Stephens5d3c4882011-04-07 13:57:25 -0400442 goto exit;
443
Ying Xuef2f98002015-01-09 15:27:05 +0800444 node = tipc_node_find(net, msg_prevnode(msg));
Allan Stephens5d3c4882011-04-07 13:57:25 -0400445 if (unlikely(!node))
446 goto exit;
447
448 tipc_node_lock(node);
Ying Xue389dd9b2012-11-16 13:51:30 +0800449 if (unlikely(!node->bclink.recv_permitted))
Allan Stephens5d3c4882011-04-07 13:57:25 -0400450 goto unlock;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100451
Allan Stephens8a275a62011-10-26 15:33:44 -0400452 /* Handle broadcast protocol message */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100453 if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
Allan Stephens9f6bdcd42011-04-07 14:57:53 -0400454 if (msg_type(msg) != STATE_MSG)
455 goto unlock;
Ying Xue34747532015-01-09 15:27:10 +0800456 if (msg_destnode(msg) == tn->own_addr) {
Per Liden4323add2006-01-18 00:38:21 +0100457 tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
Ying Xue1da46562015-01-09 15:27:07 +0800458 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100459 bcl->stats.recv_nacks++;
Ying Xue1da46562015-01-09 15:27:07 +0800460 tn->bclink->retransmit_to = node;
461 bclink_retransmit_pkt(tn, msg_bcgap_after(msg),
Per Lidenb97bf3f2006-01-02 19:04:38 +0100462 msg_bcgap_to(msg));
Ying Xue1da46562015-01-09 15:27:07 +0800463 tipc_bclink_unlock(net);
Ying Xueb952b2b2015-03-26 18:10:23 +0800464 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100465 } else {
Allan Stephens5d3c4882011-04-07 13:57:25 -0400466 tipc_node_unlock(node);
Ying Xuef2f98002015-01-09 15:27:05 +0800467 bclink_peek_nack(net, msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100468 }
Ying Xue8a0f6eb2015-03-26 18:10:24 +0800469 tipc_node_put(node);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400470 goto exit;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100471 }
472
Allan Stephens5d3c4882011-04-07 13:57:25 -0400473 /* Handle in-sequence broadcast message */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100474 seqno = msg_seqno(msg);
Allan Stephens8a275a62011-10-26 15:33:44 -0400475 next_in = mod(node->bclink.last_in + 1);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500476 arrvq = &tn->bclink->arrvq;
477 inputq = &tn->bclink->inputq;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100478
479 if (likely(seqno == next_in)) {
Allan Stephens8a275a62011-10-26 15:33:44 -0400480receive:
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400481 /* Deliver message to destination */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100482 if (likely(msg_isdata(msg))) {
Ying Xue1da46562015-01-09 15:27:07 +0800483 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400484 bclink_accept_pkt(node, seqno);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500485 spin_lock_bh(&inputq->lock);
486 __skb_queue_tail(arrvq, buf);
487 spin_unlock_bh(&inputq->lock);
488 node->action_flags |= TIPC_BCAST_MSG_EVT;
Ying Xue1da46562015-01-09 15:27:07 +0800489 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100490 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100491 } else if (msg_user(msg) == MSG_BUNDLER) {
Ying Xue1da46562015-01-09 15:27:07 +0800492 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400493 bclink_accept_pkt(node, seqno);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100494 bcl->stats.recv_bundles++;
495 bcl->stats.recv_bundled += msg_msgcnt(msg);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500496 pos = 0;
497 while (tipc_msg_extract(buf, &iskb, &pos)) {
498 spin_lock_bh(&inputq->lock);
499 __skb_queue_tail(arrvq, iskb);
500 spin_unlock_bh(&inputq->lock);
501 }
502 node->action_flags |= TIPC_BCAST_MSG_EVT;
Ying Xue1da46562015-01-09 15:27:07 +0800503 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100504 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100505 } else if (msg_user(msg) == MSG_FRAGMENTER) {
Ying Xue1da46562015-01-09 15:27:07 +0800506 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400507 bclink_accept_pkt(node, seqno);
Ying Xuebc14b8d2015-03-25 18:09:40 +0800508 tipc_buf_append(&node->bclink.reasm_buf, &buf);
509 if (unlikely(!buf && !node->bclink.reasm_buf)) {
510 tipc_bclink_unlock(net);
511 goto unlock;
512 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100513 bcl->stats.recv_fragments++;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400514 if (buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100515 bcl->stats.recv_fragmented++;
Erik Hugne40ba3cd2013-11-06 09:28:06 +0100516 msg = buf_msg(buf);
Ying Xue1da46562015-01-09 15:27:07 +0800517 tipc_bclink_unlock(net);
Erik Hugne528f6f42013-11-06 09:28:05 +0100518 goto receive;
519 }
Ying Xue1da46562015-01-09 15:27:07 +0800520 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100521 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100522 } else {
Ying Xue1da46562015-01-09 15:27:07 +0800523 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400524 bclink_accept_pkt(node, seqno);
Ying Xue1da46562015-01-09 15:27:07 +0800525 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100526 tipc_node_unlock(node);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400527 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100528 }
Allan Stephens5d3c4882011-04-07 13:57:25 -0400529 buf = NULL;
Allan Stephens8a275a62011-10-26 15:33:44 -0400530
531 /* Determine new synchronization state */
Allan Stephens5d3c4882011-04-07 13:57:25 -0400532 tipc_node_lock(node);
Allan Stephens8a275a62011-10-26 15:33:44 -0400533 if (unlikely(!tipc_node_is_up(node)))
534 goto unlock;
535
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400536 if (node->bclink.last_in == node->bclink.last_sent)
Allan Stephens8a275a62011-10-26 15:33:44 -0400537 goto unlock;
538
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400539 if (skb_queue_empty(&node->bclink.deferdq)) {
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400540 node->bclink.oos_state = 1;
541 goto unlock;
542 }
543
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400544 msg = buf_msg(skb_peek(&node->bclink.deferdq));
Allan Stephens8a275a62011-10-26 15:33:44 -0400545 seqno = msg_seqno(msg);
546 next_in = mod(next_in + 1);
547 if (seqno != next_in)
548 goto unlock;
549
550 /* Take in-sequence message from deferred queue & deliver it */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400551 buf = __skb_dequeue(&node->bclink.deferdq);
Allan Stephens8a275a62011-10-26 15:33:44 -0400552 goto receive;
553 }
554
555 /* Handle out-of-sequence broadcast message */
Allan Stephens8a275a62011-10-26 15:33:44 -0400556 if (less(next_in, seqno)) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400557 deferred = tipc_link_defer_pkt(&node->bclink.deferdq,
Allan Stephens8a275a62011-10-26 15:33:44 -0400558 buf);
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400559 bclink_update_last_sent(node, seqno);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400560 buf = NULL;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400561 }
Allan Stephens8a275a62011-10-26 15:33:44 -0400562
Ying Xue1da46562015-01-09 15:27:07 +0800563 tipc_bclink_lock(net);
Allan Stephensb98158e2011-10-26 16:13:35 -0400564
Allan Stephens8a275a62011-10-26 15:33:44 -0400565 if (deferred)
566 bcl->stats.deferred_recv++;
Allan Stephens0232c5a2011-10-26 15:57:26 -0400567 else
568 bcl->stats.duplicates++;
Allan Stephens8a275a62011-10-26 15:33:44 -0400569
Ying Xue1da46562015-01-09 15:27:07 +0800570 tipc_bclink_unlock(net);
Allan Stephensb98158e2011-10-26 16:13:35 -0400571
Allan Stephens5d3c4882011-04-07 13:57:25 -0400572unlock:
Per Liden4323add2006-01-18 00:38:21 +0100573 tipc_node_unlock(node);
Ying Xue8a0f6eb2015-03-26 18:10:24 +0800574 tipc_node_put(node);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400575exit:
Allan Stephens5f6d9122011-11-04 13:24:29 -0400576 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100577}
578
David S. Miller6c000552008-09-02 23:38:32 -0700579u32 tipc_bclink_acks_missing(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100580{
Ying Xue389dd9b2012-11-16 13:51:30 +0800581 return (n_ptr->bclink.recv_permitted &&
Ying Xue1da46562015-01-09 15:27:07 +0800582 (tipc_bclink_get_last_sent(n_ptr->net) != n_ptr->bclink.acked));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100583}
584
585
586/**
Per Liden4323add2006-01-18 00:38:21 +0100587 * tipc_bcbearer_send - send a packet through the broadcast pseudo-bearer
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900588 *
Allan Stephens2ff9f922011-04-07 10:44:54 -0400589 * Send packet over as many bearers as necessary to reach all nodes
590 * that have joined the broadcast link.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900591 *
Allan Stephens2ff9f922011-04-07 10:44:54 -0400592 * Returns 0 (packet sent successfully) under all circumstances,
593 * since the broadcast link's pseudo-bearer never blocks
Per Lidenb97bf3f2006-01-02 19:04:38 +0100594 */
Ying Xue1da46562015-01-09 15:27:07 +0800595static int tipc_bcbearer_send(struct net *net, struct sk_buff *buf,
596 struct tipc_bearer *unused1,
Adrian Bunk988f0882006-03-20 22:37:52 -0800597 struct tipc_media_addr *unused2)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100598{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100599 int bp_index;
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400600 struct tipc_msg *msg = buf_msg(buf);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800601 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800602 struct tipc_bcbearer *bcbearer = tn->bcbearer;
603 struct tipc_bclink *bclink = tn->bclink;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100604
Gerlando Falautoe6160712013-05-01 12:04:44 +0000605 /* Prepare broadcast link message for reliable transmission,
Allan Stephens2ff9f922011-04-07 10:44:54 -0400606 * if first time trying to send it;
607 * preparation is skipped for broadcast link protocol messages
608 * since they are sent in an unreliable manner and don't need it
609 */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100610 if (likely(!msg_non_seq(buf_msg(buf)))) {
Allan Stephenscd3decd2011-10-24 11:18:12 -0400611 bcbuf_set_acks(buf, bclink->bcast_nodes.count);
Allan Stephens40aecb12008-06-04 17:54:48 -0700612 msg_set_non_seq(msg, 1);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800613 msg_set_mc_netid(msg, tn->net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800614 tn->bcl->stats.sent_info++;
Allan Stephenscd3decd2011-10-24 11:18:12 -0400615 if (WARN_ON(!bclink->bcast_nodes.count)) {
Allan Stephens5e726902011-05-23 13:14:18 -0400616 dump_stack();
617 return 0;
618 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100619 }
620
Per Lidenb97bf3f2006-01-02 19:04:38 +0100621 /* Send buffer over bearers until all targets reached */
Allan Stephenscd3decd2011-10-24 11:18:12 -0400622 bcbearer->remains = bclink->bcast_nodes;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100623
624 for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
Allan Stephens2d627b92011-01-07 13:00:11 -0500625 struct tipc_bearer *p = bcbearer->bpairs[bp_index].primary;
626 struct tipc_bearer *s = bcbearer->bpairs[bp_index].secondary;
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400627 struct tipc_bearer *bp[2] = {p, s};
628 struct tipc_bearer *b = bp[msg_link_selector(msg)];
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000629 struct sk_buff *tbuf;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100630
631 if (!p)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000632 break; /* No more bearers to try */
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400633 if (!b)
634 b = p;
Gerlando Falauto77861d92013-05-01 12:04:45 +0000635 tipc_nmap_diff(&bcbearer->remains, &b->nodes,
Gerlando Falautoe6160712013-05-01 12:04:44 +0000636 &bcbearer->remains_new);
Allan Stephens65f51ef2006-06-25 23:53:20 -0700637 if (bcbearer->remains_new.count == bcbearer->remains.count)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000638 continue; /* Nothing added by bearer pair */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100639
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000640 if (bp_index == 0) {
641 /* Use original buffer for first bearer */
Ying Xue7f9f95d2015-01-09 15:27:06 +0800642 tipc_bearer_send(net, b->identity, buf, &b->bcast_addr);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000643 } else {
644 /* Avoid concurrent buffer access */
Octavian Purdilabad93e92014-06-12 01:36:26 +0300645 tbuf = pskb_copy_for_clone(buf, GFP_ATOMIC);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000646 if (!tbuf)
647 break;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800648 tipc_bearer_send(net, b->identity, tbuf,
649 &b->bcast_addr);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000650 kfree_skb(tbuf); /* Bearer keeps a clone */
651 }
Allan Stephens65f51ef2006-06-25 23:53:20 -0700652 if (bcbearer->remains_new.count == 0)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000653 break; /* All targets reached */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100654
Allan Stephens65f51ef2006-06-25 23:53:20 -0700655 bcbearer->remains = bcbearer->remains_new;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100656 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900657
Allan Stephens2ff9f922011-04-07 10:44:54 -0400658 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100659}
660
661/**
Per Liden4323add2006-01-18 00:38:21 +0100662 * tipc_bcbearer_sort - create sets of bearer pairs used by broadcast bearer
Per Lidenb97bf3f2006-01-02 19:04:38 +0100663 */
Ying Xue7f9f95d2015-01-09 15:27:06 +0800664void tipc_bcbearer_sort(struct net *net, struct tipc_node_map *nm_ptr,
665 u32 node, bool action)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100666{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800667 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800668 struct tipc_bcbearer *bcbearer = tn->bcbearer;
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -0500669 struct tipc_bcbearer_pair *bp_temp = bcbearer->bpairs_temp;
670 struct tipc_bcbearer_pair *bp_curr;
Ying Xuef8322df2014-04-21 10:55:45 +0800671 struct tipc_bearer *b;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100672 int b_index;
673 int pri;
674
Ying Xue1da46562015-01-09 15:27:07 +0800675 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100676
Ying Xue28dd9412014-04-21 10:55:51 +0800677 if (action)
678 tipc_nmap_add(nm_ptr, node);
679 else
680 tipc_nmap_remove(nm_ptr, node);
681
Per Lidenb97bf3f2006-01-02 19:04:38 +0100682 /* Group bearers by priority (can assume max of two per priority) */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100683 memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));
684
Ying Xuef8322df2014-04-21 10:55:45 +0800685 rcu_read_lock();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100686 for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
Ying Xue7f9f95d2015-01-09 15:27:06 +0800687 b = rcu_dereference_rtnl(tn->bearer_list[b_index]);
Ying Xuef47de122014-03-27 12:54:34 +0800688 if (!b || !b->nodes.count)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100689 continue;
690
691 if (!bp_temp[b->priority].primary)
692 bp_temp[b->priority].primary = b;
693 else
694 bp_temp[b->priority].secondary = b;
695 }
Ying Xuef8322df2014-04-21 10:55:45 +0800696 rcu_read_unlock();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100697
698 /* Create array of bearer pairs for broadcasting */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100699 bp_curr = bcbearer->bpairs;
700 memset(bcbearer->bpairs, 0, sizeof(bcbearer->bpairs));
701
Per Liden16cb4b32006-01-13 22:22:22 +0100702 for (pri = TIPC_MAX_LINK_PRI; pri >= 0; pri--) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100703
704 if (!bp_temp[pri].primary)
705 continue;
706
707 bp_curr->primary = bp_temp[pri].primary;
708
709 if (bp_temp[pri].secondary) {
Per Liden4323add2006-01-18 00:38:21 +0100710 if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
711 &bp_temp[pri].secondary->nodes)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100712 bp_curr->secondary = bp_temp[pri].secondary;
713 } else {
714 bp_curr++;
715 bp_curr->primary = bp_temp[pri].secondary;
716 }
717 }
718
719 bp_curr++;
720 }
721
Ying Xue1da46562015-01-09 15:27:07 +0800722 tipc_bclink_unlock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100723}
724
Richard Alped8182802014-11-24 11:10:29 +0100725static int __tipc_nl_add_bc_link_stat(struct sk_buff *skb,
726 struct tipc_stats *stats)
Richard Alpe7be57fc2014-11-20 10:29:12 +0100727{
728 int i;
729 struct nlattr *nest;
730
731 struct nla_map {
732 __u32 key;
733 __u32 val;
734 };
735
736 struct nla_map map[] = {
737 {TIPC_NLA_STATS_RX_INFO, stats->recv_info},
738 {TIPC_NLA_STATS_RX_FRAGMENTS, stats->recv_fragments},
739 {TIPC_NLA_STATS_RX_FRAGMENTED, stats->recv_fragmented},
740 {TIPC_NLA_STATS_RX_BUNDLES, stats->recv_bundles},
741 {TIPC_NLA_STATS_RX_BUNDLED, stats->recv_bundled},
742 {TIPC_NLA_STATS_TX_INFO, stats->sent_info},
743 {TIPC_NLA_STATS_TX_FRAGMENTS, stats->sent_fragments},
744 {TIPC_NLA_STATS_TX_FRAGMENTED, stats->sent_fragmented},
745 {TIPC_NLA_STATS_TX_BUNDLES, stats->sent_bundles},
746 {TIPC_NLA_STATS_TX_BUNDLED, stats->sent_bundled},
747 {TIPC_NLA_STATS_RX_NACKS, stats->recv_nacks},
748 {TIPC_NLA_STATS_RX_DEFERRED, stats->deferred_recv},
749 {TIPC_NLA_STATS_TX_NACKS, stats->sent_nacks},
750 {TIPC_NLA_STATS_TX_ACKS, stats->sent_acks},
751 {TIPC_NLA_STATS_RETRANSMITTED, stats->retransmitted},
752 {TIPC_NLA_STATS_DUPLICATES, stats->duplicates},
753 {TIPC_NLA_STATS_LINK_CONGS, stats->link_congs},
754 {TIPC_NLA_STATS_MAX_QUEUE, stats->max_queue_sz},
755 {TIPC_NLA_STATS_AVG_QUEUE, stats->queue_sz_counts ?
756 (stats->accu_queue_sz / stats->queue_sz_counts) : 0}
757 };
758
759 nest = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
760 if (!nest)
761 return -EMSGSIZE;
762
763 for (i = 0; i < ARRAY_SIZE(map); i++)
764 if (nla_put_u32(skb, map[i].key, map[i].val))
765 goto msg_full;
766
767 nla_nest_end(skb, nest);
768
769 return 0;
770msg_full:
771 nla_nest_cancel(skb, nest);
772
773 return -EMSGSIZE;
774}
775
Ying Xue1da46562015-01-09 15:27:07 +0800776int tipc_nl_add_bc_link(struct net *net, struct tipc_nl_msg *msg)
Richard Alpe7be57fc2014-11-20 10:29:12 +0100777{
778 int err;
779 void *hdr;
780 struct nlattr *attrs;
781 struct nlattr *prop;
Ying Xue1da46562015-01-09 15:27:07 +0800782 struct tipc_net *tn = net_generic(net, tipc_net_id);
783 struct tipc_link *bcl = tn->bcl;
Richard Alpe7be57fc2014-11-20 10:29:12 +0100784
785 if (!bcl)
786 return 0;
787
Ying Xue1da46562015-01-09 15:27:07 +0800788 tipc_bclink_lock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100789
Richard Alpebfb3e5d2015-02-09 09:50:03 +0100790 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
Richard Alpe7be57fc2014-11-20 10:29:12 +0100791 NLM_F_MULTI, TIPC_NL_LINK_GET);
792 if (!hdr)
793 return -EMSGSIZE;
794
795 attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
796 if (!attrs)
797 goto msg_full;
798
799 /* The broadcast link is always up */
800 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
801 goto attr_msg_full;
802
803 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_BROADCAST))
804 goto attr_msg_full;
805 if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, bcl->name))
806 goto attr_msg_full;
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400807 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, bcl->rcv_nxt))
Richard Alpe7be57fc2014-11-20 10:29:12 +0100808 goto attr_msg_full;
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400809 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, bcl->snd_nxt))
Richard Alpe7be57fc2014-11-20 10:29:12 +0100810 goto attr_msg_full;
811
812 prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
813 if (!prop)
814 goto attr_msg_full;
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400815 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bcl->window))
Richard Alpe7be57fc2014-11-20 10:29:12 +0100816 goto prop_msg_full;
817 nla_nest_end(msg->skb, prop);
818
819 err = __tipc_nl_add_bc_link_stat(msg->skb, &bcl->stats);
820 if (err)
821 goto attr_msg_full;
822
Ying Xue1da46562015-01-09 15:27:07 +0800823 tipc_bclink_unlock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100824 nla_nest_end(msg->skb, attrs);
825 genlmsg_end(msg->skb, hdr);
826
827 return 0;
828
829prop_msg_full:
830 nla_nest_cancel(msg->skb, prop);
831attr_msg_full:
832 nla_nest_cancel(msg->skb, attrs);
833msg_full:
Ying Xue1da46562015-01-09 15:27:07 +0800834 tipc_bclink_unlock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100835 genlmsg_cancel(msg->skb, hdr);
836
837 return -EMSGSIZE;
838}
Per Lidenb97bf3f2006-01-02 19:04:38 +0100839
Ying Xue1da46562015-01-09 15:27:07 +0800840int tipc_bclink_reset_stats(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100841{
Ying Xue1da46562015-01-09 15:27:07 +0800842 struct tipc_net *tn = net_generic(net, tipc_net_id);
843 struct tipc_link *bcl = tn->bcl;
844
Per Lidenb97bf3f2006-01-02 19:04:38 +0100845 if (!bcl)
846 return -ENOPROTOOPT;
847
Ying Xue1da46562015-01-09 15:27:07 +0800848 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100849 memset(&bcl->stats, 0, sizeof(bcl->stats));
Ying Xue1da46562015-01-09 15:27:07 +0800850 tipc_bclink_unlock(net);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700851 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100852}
853
Ying Xue1da46562015-01-09 15:27:07 +0800854int tipc_bclink_set_queue_limits(struct net *net, u32 limit)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100855{
Ying Xue1da46562015-01-09 15:27:07 +0800856 struct tipc_net *tn = net_generic(net, tipc_net_id);
857 struct tipc_link *bcl = tn->bcl;
858
Per Lidenb97bf3f2006-01-02 19:04:38 +0100859 if (!bcl)
860 return -ENOPROTOOPT;
861 if ((limit < TIPC_MIN_LINK_WIN) || (limit > TIPC_MAX_LINK_WIN))
862 return -EINVAL;
863
Ying Xue1da46562015-01-09 15:27:07 +0800864 tipc_bclink_lock(net);
Per Liden4323add2006-01-18 00:38:21 +0100865 tipc_link_set_queue_limits(bcl, limit);
Ying Xue1da46562015-01-09 15:27:07 +0800866 tipc_bclink_unlock(net);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700867 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100868}
869
Richard Alpe670f4f82015-05-06 13:58:55 +0200870int tipc_nl_bc_link_set(struct net *net, struct nlattr *attrs[])
871{
872 int err;
873 u32 win;
874 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
875
876 if (!attrs[TIPC_NLA_LINK_PROP])
877 return -EINVAL;
878
879 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP], props);
880 if (err)
881 return err;
882
883 if (!props[TIPC_NLA_PROP_WIN])
884 return -EOPNOTSUPP;
885
886 win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
887
888 return tipc_bclink_set_queue_limits(net, win);
889}
890
Ying Xue7f9f95d2015-01-09 15:27:06 +0800891int tipc_bclink_init(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100892{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800893 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800894 struct tipc_bcbearer *bcbearer;
895 struct tipc_bclink *bclink;
896 struct tipc_link *bcl;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800897
Ying Xueeb8b00f2014-05-05 08:56:16 +0800898 bcbearer = kzalloc(sizeof(*bcbearer), GFP_ATOMIC);
899 if (!bcbearer)
900 return -ENOMEM;
901
902 bclink = kzalloc(sizeof(*bclink), GFP_ATOMIC);
903 if (!bclink) {
904 kfree(bcbearer);
905 return -ENOMEM;
906 }
907
908 bcl = &bclink->link;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100909 bcbearer->bearer.media = &bcbearer->media;
Per Liden4323add2006-01-18 00:38:21 +0100910 bcbearer->media.send_msg = tipc_bcbearer_send;
Allan Stephens2e2d9be2011-04-07 10:22:31 -0400911 sprintf(bcbearer->media.name, "tipc-broadcast");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100912
Ying Xued69afc92014-05-05 08:56:15 +0800913 spin_lock_init(&bclink->lock);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400914 __skb_queue_head_init(&bcl->transmq);
915 __skb_queue_head_init(&bcl->backlogq);
916 __skb_queue_head_init(&bcl->deferdq);
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500917 skb_queue_head_init(&bcl->wakeupq);
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400918 bcl->snd_nxt = 1;
Ingo Molnar34af9462006-06-27 02:53:55 -0700919 spin_lock_init(&bclink->node.lock);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500920 __skb_queue_head_init(&bclink->arrvq);
921 skb_queue_head_init(&bclink->inputq);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100922 bcl->owner = &bclink->node;
Ying Xue1da46562015-01-09 15:27:07 +0800923 bcl->owner->net = net;
Jon Paul Maloyed193ec2015-04-02 09:33:02 -0400924 bcl->mtu = MAX_PKT_DEFAULT_MCAST;
Per Liden4323add2006-01-18 00:38:21 +0100925 tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
Ying Xue7a2f7d12014-04-21 10:55:46 +0800926 bcl->bearer_id = MAX_BEARERS;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800927 rcu_assign_pointer(tn->bearer_list[MAX_BEARERS], &bcbearer->bearer);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100928 bcl->state = WORKING_WORKING;
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500929 bcl->pmsg = (struct tipc_msg *)&bcl->proto_msg;
930 msg_set_prevnode(bcl->pmsg, tn->own_addr);
Stephen Hemminger4b704d52009-03-18 19:11:29 -0700931 strlcpy(bcl->name, tipc_bclink_name, TIPC_MAX_LINK_NAME);
Ying Xue1da46562015-01-09 15:27:07 +0800932 tn->bcbearer = bcbearer;
933 tn->bclink = bclink;
934 tn->bcl = bcl;
Ying Xueeb8b00f2014-05-05 08:56:16 +0800935 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100936}
937
Ying Xue7f9f95d2015-01-09 15:27:06 +0800938void tipc_bclink_stop(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100939{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800940 struct tipc_net *tn = net_generic(net, tipc_net_id);
941
Ying Xue1da46562015-01-09 15:27:07 +0800942 tipc_bclink_lock(net);
943 tipc_link_purge_queues(tn->bcl);
944 tipc_bclink_unlock(net);
Allan Stephensc47e9b92011-10-24 10:29:26 -0400945
Ying Xue7f9f95d2015-01-09 15:27:06 +0800946 RCU_INIT_POINTER(tn->bearer_list[BCBEARER], NULL);
Ying Xueeb8b00f2014-05-05 08:56:16 +0800947 synchronize_net();
Ying Xue1da46562015-01-09 15:27:07 +0800948 kfree(tn->bcbearer);
949 kfree(tn->bclink);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100950}
951
Allan Stephens3e22e622010-05-11 14:30:14 +0000952/**
953 * tipc_nmap_add - add a node to a node map
954 */
Ying Xue28dd9412014-04-21 10:55:51 +0800955static void tipc_nmap_add(struct tipc_node_map *nm_ptr, u32 node)
Allan Stephens3e22e622010-05-11 14:30:14 +0000956{
957 int n = tipc_node(node);
958 int w = n / WSIZE;
959 u32 mask = (1 << (n % WSIZE));
960
961 if ((nm_ptr->map[w] & mask) == 0) {
962 nm_ptr->count++;
963 nm_ptr->map[w] |= mask;
964 }
965}
966
967/**
968 * tipc_nmap_remove - remove a node from a node map
969 */
Ying Xue28dd9412014-04-21 10:55:51 +0800970static void tipc_nmap_remove(struct tipc_node_map *nm_ptr, u32 node)
Allan Stephens3e22e622010-05-11 14:30:14 +0000971{
972 int n = tipc_node(node);
973 int w = n / WSIZE;
974 u32 mask = (1 << (n % WSIZE));
975
976 if ((nm_ptr->map[w] & mask) != 0) {
977 nm_ptr->map[w] &= ~mask;
978 nm_ptr->count--;
979 }
980}
981
982/**
983 * tipc_nmap_diff - find differences between node maps
984 * @nm_a: input node map A
985 * @nm_b: input node map B
986 * @nm_diff: output node map A-B (i.e. nodes of A that are not in B)
987 */
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000988static void tipc_nmap_diff(struct tipc_node_map *nm_a,
989 struct tipc_node_map *nm_b,
990 struct tipc_node_map *nm_diff)
Allan Stephens3e22e622010-05-11 14:30:14 +0000991{
992 int stop = ARRAY_SIZE(nm_a->map);
993 int w;
994 int b;
995 u32 map;
996
997 memset(nm_diff, 0, sizeof(*nm_diff));
998 for (w = 0; w < stop; w++) {
999 map = nm_a->map[w] ^ (nm_a->map[w] & nm_b->map[w]);
1000 nm_diff->map[w] = map;
1001 if (map != 0) {
1002 for (b = 0 ; b < WSIZE; b++) {
1003 if (map & (1 << b))
1004 nm_diff->count++;
1005 }
1006 }
1007 }
1008}