blob: c5cbdcb1f0b561a22d2f5537f5cca0a80ee36486 [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);
111 tipc_bclink_unlock(net);
Allan Stephenscd3decd2011-10-24 11:18:12 -0400112}
Per Lidenb97bf3f2006-01-02 19:04:38 +0100113
Ying Xue1da46562015-01-09 15:27:07 +0800114static void bclink_set_last_sent(struct net *net)
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000115{
Ying Xue1da46562015-01-09 15:27:07 +0800116 struct tipc_net *tn = net_generic(net, tipc_net_id);
117 struct tipc_link *bcl = tn->bcl;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400118 struct sk_buff *skb = skb_peek(&bcl->backlogq);
Ying Xue1da46562015-01-09 15:27:07 +0800119
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400120 if (skb)
121 bcl->fsm_msg_cnt = mod(buf_seqno(skb) - 1);
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000122 else
123 bcl->fsm_msg_cnt = mod(bcl->next_out_no - 1);
124}
125
Ying Xue1da46562015-01-09 15:27:07 +0800126u32 tipc_bclink_get_last_sent(struct net *net)
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000127{
Ying Xue1da46562015-01-09 15:27:07 +0800128 struct tipc_net *tn = net_generic(net, tipc_net_id);
129
130 return tn->bcl->fsm_msg_cnt;
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000131}
132
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400133static void bclink_update_last_sent(struct tipc_node *node, u32 seqno)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100134{
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400135 node->bclink.last_sent = less_eq(node->bclink.last_sent, seqno) ?
136 seqno : node->bclink.last_sent;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100137}
138
Ben Hutchings2c530402012-07-10 10:55:09 +0000139/**
Allan Stephens01d83ed2011-01-18 13:53:16 -0500140 * tipc_bclink_retransmit_to - get most recent node to request retransmission
141 *
Ying Xued69afc92014-05-05 08:56:15 +0800142 * Called with bclink_lock locked
Allan Stephens01d83ed2011-01-18 13:53:16 -0500143 */
Ying Xue1da46562015-01-09 15:27:07 +0800144struct tipc_node *tipc_bclink_retransmit_to(struct net *net)
Allan Stephens01d83ed2011-01-18 13:53:16 -0500145{
Ying Xue1da46562015-01-09 15:27:07 +0800146 struct tipc_net *tn = net_generic(net, tipc_net_id);
147
148 return tn->bclink->retransmit_to;
Allan Stephens01d83ed2011-01-18 13:53:16 -0500149}
150
151/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100152 * bclink_retransmit_pkt - retransmit broadcast packets
153 * @after: sequence number of last packet to *not* retransmit
154 * @to: sequence number of last packet to retransmit
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900155 *
Ying Xued69afc92014-05-05 08:56:15 +0800156 * Called with bclink_lock locked
Per Lidenb97bf3f2006-01-02 19:04:38 +0100157 */
Ying Xue1da46562015-01-09 15:27:07 +0800158static void bclink_retransmit_pkt(struct tipc_net *tn, u32 after, u32 to)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100159{
Ying Xue58dc55f2014-11-26 11:41:52 +0800160 struct sk_buff *skb;
Ying Xue1da46562015-01-09 15:27:07 +0800161 struct tipc_link *bcl = tn->bcl;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100162
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400163 skb_queue_walk(&bcl->transmq, skb) {
Jon Maloy703068e2015-01-09 15:26:58 +0800164 if (more(buf_seqno(skb), after)) {
165 tipc_link_retransmit(bcl, skb, mod(to - after));
Ying Xue58dc55f2014-11-26 11:41:52 +0800166 break;
Jon Maloy703068e2015-01-09 15:26:58 +0800167 }
Ying Xue58dc55f2014-11-26 11:41:52 +0800168 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100169}
170
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900171/**
Jon Maloy908344c2014-10-07 14:12:34 -0400172 * tipc_bclink_wakeup_users - wake up pending users
173 *
174 * Called with no locks taken
175 */
Ying Xuef2f98002015-01-09 15:27:05 +0800176void tipc_bclink_wakeup_users(struct net *net)
Jon Maloy908344c2014-10-07 14:12:34 -0400177{
Ying Xue1da46562015-01-09 15:27:07 +0800178 struct tipc_net *tn = net_generic(net, tipc_net_id);
Erik Hugne4988bb42014-12-03 16:58:40 +0100179
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500180 tipc_sk_rcv(net, &tn->bclink->link.wakeupq);
Jon Maloy908344c2014-10-07 14:12:34 -0400181}
182
183/**
Per Liden4323add2006-01-18 00:38:21 +0100184 * tipc_bclink_acknowledge - handle acknowledgement of broadcast packets
Per Lidenb97bf3f2006-01-02 19:04:38 +0100185 * @n_ptr: node that sent acknowledgement info
186 * @acked: broadcast sequence # that has been acknowledged
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900187 *
Ying Xued69afc92014-05-05 08:56:15 +0800188 * Node is locked, bclink_lock unlocked.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100189 */
David S. Miller6c000552008-09-02 23:38:32 -0700190void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100191{
Ying Xue58dc55f2014-11-26 11:41:52 +0800192 struct sk_buff *skb, *tmp;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100193 unsigned int released = 0;
Ying Xue1da46562015-01-09 15:27:07 +0800194 struct net *net = n_ptr->net;
195 struct tipc_net *tn = net_generic(net, tipc_net_id);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100196
Jon Paul Maloy2cdf3912015-03-13 16:08:09 -0400197 if (unlikely(!n_ptr->bclink.recv_permitted))
198 return;
199
Ying Xue1da46562015-01-09 15:27:07 +0800200 tipc_bclink_lock(net);
Jon Paul Maloy2cdf3912015-03-13 16:08:09 -0400201
Allan Stephens365595912011-10-24 15:26:24 -0400202 /* Bail out if tx queue is empty (no clean up is required) */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400203 skb = skb_peek(&tn->bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800204 if (!skb)
Allan Stephens365595912011-10-24 15:26:24 -0400205 goto exit;
206
207 /* Determine which messages need to be acknowledged */
208 if (acked == INVALID_LINK_SEQ) {
209 /*
210 * Contact with specified node has been lost, so need to
211 * acknowledge sent messages only (if other nodes still exist)
212 * or both sent and unsent messages (otherwise)
213 */
Ying Xue1da46562015-01-09 15:27:07 +0800214 if (tn->bclink->bcast_nodes.count)
215 acked = tn->bcl->fsm_msg_cnt;
Allan Stephens365595912011-10-24 15:26:24 -0400216 else
Ying Xue1da46562015-01-09 15:27:07 +0800217 acked = tn->bcl->next_out_no;
Allan Stephens365595912011-10-24 15:26:24 -0400218 } else {
219 /*
220 * Bail out if specified sequence number does not correspond
221 * to a message that has been sent and not yet acknowledged
222 */
Ying Xue58dc55f2014-11-26 11:41:52 +0800223 if (less(acked, buf_seqno(skb)) ||
Ying Xue1da46562015-01-09 15:27:07 +0800224 less(tn->bcl->fsm_msg_cnt, acked) ||
Allan Stephens365595912011-10-24 15:26:24 -0400225 less_eq(acked, n_ptr->bclink.acked))
226 goto exit;
227 }
228
229 /* Skip over packets that node has previously acknowledged */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400230 skb_queue_walk(&tn->bcl->transmq, skb) {
Ying Xue58dc55f2014-11-26 11:41:52 +0800231 if (more(buf_seqno(skb), n_ptr->bclink.acked))
232 break;
233 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100234
235 /* Update packets that node is now acknowledging */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400236 skb_queue_walk_from_safe(&tn->bcl->transmq, skb, tmp) {
Ying Xue58dc55f2014-11-26 11:41:52 +0800237 if (more(buf_seqno(skb), acked))
238 break;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400239 bcbuf_decr_acks(skb);
240 bclink_set_last_sent(net);
Ying Xue58dc55f2014-11-26 11:41:52 +0800241 if (bcbuf_acks(skb) == 0) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400242 __skb_unlink(skb, &tn->bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800243 kfree_skb(skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100244 released = 1;
245 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100246 }
247 n_ptr->bclink.acked = acked;
248
249 /* Try resolving broadcast link congestion, if necessary */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400250 if (unlikely(skb_peek(&tn->bcl->backlogq))) {
Ying Xue1da46562015-01-09 15:27:07 +0800251 tipc_link_push_packets(tn->bcl);
252 bclink_set_last_sent(net);
Allan Stephens5b1f7bd2010-08-17 11:00:09 +0000253 }
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500254 if (unlikely(released && !skb_queue_empty(&tn->bcl->wakeupq)))
Jon Maloy908344c2014-10-07 14:12:34 -0400255 n_ptr->action_flags |= TIPC_WAKEUP_BCAST_USERS;
Allan Stephens365595912011-10-24 15:26:24 -0400256exit:
Ying Xue1da46562015-01-09 15:27:07 +0800257 tipc_bclink_unlock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100258}
259
Ben Hutchings2c530402012-07-10 10:55:09 +0000260/**
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400261 * tipc_bclink_update_link_state - update broadcast link state
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900262 *
Ying Xue7216cd92014-04-21 10:55:48 +0800263 * RCU and node lock set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100264 */
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500265void tipc_bclink_update_link_state(struct tipc_node *n_ptr,
Ying Xuec93d3ba2015-01-09 15:27:04 +0800266 u32 last_sent)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100267{
268 struct sk_buff *buf;
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500269 struct net *net = n_ptr->net;
Ying Xuec93d3ba2015-01-09 15:27:04 +0800270 struct tipc_net *tn = net_generic(net, tipc_net_id);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100271
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400272 /* Ignore "stale" link state info */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400273 if (less_eq(last_sent, n_ptr->bclink.last_in))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100274 return;
275
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400276 /* Update link synchronization state; quit if in sync */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400277 bclink_update_last_sent(n_ptr, last_sent);
278
279 if (n_ptr->bclink.last_sent == n_ptr->bclink.last_in)
280 return;
281
282 /* Update out-of-sync state; quit if loss is still unconfirmed */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400283 if ((++n_ptr->bclink.oos_state) == 1) {
284 if (n_ptr->bclink.deferred_size < (TIPC_MIN_LINK_WIN / 2))
285 return;
286 n_ptr->bclink.oos_state++;
287 }
288
289 /* Don't NACK if one has been recently sent (or seen) */
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400290 if (n_ptr->bclink.oos_state & 0x1)
291 return;
292
293 /* Send NACK */
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000294 buf = tipc_buf_acquire(INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100295 if (buf) {
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400296 struct tipc_msg *msg = buf_msg(buf);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400297 struct sk_buff *skb = skb_peek(&n_ptr->bclink.deferdq);
Ying Xuebc6fecd2014-11-26 11:41:53 +0800298 u32 to = skb ? buf_seqno(skb) - 1 : n_ptr->bclink.last_sent;
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400299
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500300 tipc_msg_init(tn->own_addr, msg, BCAST_PROTOCOL, STATE_MSG,
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400301 INT_H_SIZE, n_ptr->addr);
Allan Stephensbf781ec2011-01-25 16:12:39 -0500302 msg_set_non_seq(msg, 1);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800303 msg_set_mc_netid(msg, tn->net_id);
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400304 msg_set_bcast_ack(msg, n_ptr->bclink.last_in);
305 msg_set_bcgap_after(msg, n_ptr->bclink.last_in);
Ying Xuebc6fecd2014-11-26 11:41:53 +0800306 msg_set_bcgap_to(msg, to);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100307
Ying Xue1da46562015-01-09 15:27:07 +0800308 tipc_bclink_lock(net);
Ying Xue7f9f95d2015-01-09 15:27:06 +0800309 tipc_bearer_send(net, MAX_BEARERS, buf, NULL);
Ying Xue1da46562015-01-09 15:27:07 +0800310 tn->bcl->stats.sent_nacks++;
311 tipc_bclink_unlock(net);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400312 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100313
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400314 n_ptr->bclink.oos_state++;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100315 }
316}
317
Ben Hutchings2c530402012-07-10 10:55:09 +0000318/**
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400319 * bclink_peek_nack - monitor retransmission requests sent by other nodes
Per Lidenb97bf3f2006-01-02 19:04:38 +0100320 *
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400321 * Delay any upcoming NACK by this node if another node has already
322 * requested the first message this node is going to ask for.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100323 */
Ying Xuef2f98002015-01-09 15:27:05 +0800324static void bclink_peek_nack(struct net *net, struct tipc_msg *msg)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100325{
Ying Xuef2f98002015-01-09 15:27:05 +0800326 struct tipc_node *n_ptr = tipc_node_find(net, msg_destnode(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100327
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400328 if (unlikely(!n_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100329 return;
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400330
Per Liden4323add2006-01-18 00:38:21 +0100331 tipc_node_lock(n_ptr);
Ying Xue389dd9b2012-11-16 13:51:30 +0800332 if (n_ptr->bclink.recv_permitted &&
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400333 (n_ptr->bclink.last_in != n_ptr->bclink.last_sent) &&
334 (n_ptr->bclink.last_in == msg_bcgap_after(msg)))
335 n_ptr->bclink.oos_state = 2;
Per Liden4323add2006-01-18 00:38:21 +0100336 tipc_node_unlock(n_ptr);
Ying Xue8a0f6eb2015-03-26 18:10:24 +0800337 tipc_node_put(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100338}
339
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500340/* tipc_bclink_xmit - deliver buffer chain to all nodes in cluster
Jon Paul Maloy9fbfb8b2014-07-16 20:41:03 -0400341 * and to identified node local sockets
Ying Xuef2f98002015-01-09 15:27:05 +0800342 * @net: the applicable net namespace
Ying Xuea6ca1092014-11-26 11:41:55 +0800343 * @list: chain of buffers containing message
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400344 * Consumes the buffer chain, except when returning -ELINKCONG
345 * Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE
346 */
Ying Xuef2f98002015-01-09 15:27:05 +0800347int tipc_bclink_xmit(struct net *net, struct sk_buff_head *list)
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400348{
Ying Xue1da46562015-01-09 15:27:07 +0800349 struct tipc_net *tn = net_generic(net, tipc_net_id);
350 struct tipc_link *bcl = tn->bcl;
351 struct tipc_bclink *bclink = tn->bclink;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400352 int rc = 0;
353 int bc = 0;
Ying Xuea6ca1092014-11-26 11:41:55 +0800354 struct sk_buff *skb;
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500355 struct sk_buff_head arrvq;
356 struct sk_buff_head inputq;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400357
358 /* Prepare clone of message for local node */
Ying Xuea6ca1092014-11-26 11:41:55 +0800359 skb = tipc_msg_reassemble(list);
360 if (unlikely(!skb)) {
361 __skb_queue_purge(list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400362 return -EHOSTUNREACH;
363 }
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500364 /* Broadcast to all nodes */
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400365 if (likely(bclink)) {
Ying Xue1da46562015-01-09 15:27:07 +0800366 tipc_bclink_lock(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400367 if (likely(bclink->bcast_nodes.count)) {
Ying Xue7f9f95d2015-01-09 15:27:06 +0800368 rc = __tipc_link_xmit(net, bcl, list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400369 if (likely(!rc)) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400370 u32 len = skb_queue_len(&bcl->transmq);
Ying Xue58dc55f2014-11-26 11:41:52 +0800371
Ying Xue1da46562015-01-09 15:27:07 +0800372 bclink_set_last_sent(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400373 bcl->stats.queue_sz_counts++;
Ying Xue58dc55f2014-11-26 11:41:52 +0800374 bcl->stats.accu_queue_sz += len;
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400375 }
376 bc = 1;
377 }
Ying Xue1da46562015-01-09 15:27:07 +0800378 tipc_bclink_unlock(net);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400379 }
380
381 if (unlikely(!bc))
Ying Xuea6ca1092014-11-26 11:41:55 +0800382 __skb_queue_purge(list);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400383
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500384 if (unlikely(rc)) {
Ying Xuea6ca1092014-11-26 11:41:55 +0800385 kfree_skb(skb);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500386 return rc;
387 }
388 /* Deliver message clone */
389 __skb_queue_head_init(&arrvq);
390 skb_queue_head_init(&inputq);
391 __skb_queue_tail(&arrvq, skb);
392 tipc_sk_mcast_rcv(net, &arrvq, &inputq);
Jon Paul Maloy078bec82014-07-16 20:41:00 -0400393 return rc;
394}
395
Ben Hutchings2c530402012-07-10 10:55:09 +0000396/**
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400397 * bclink_accept_pkt - accept an incoming, in-sequence broadcast packet
398 *
Ying Xued69afc92014-05-05 08:56:15 +0800399 * Called with both sending node's lock and bclink_lock taken.
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400400 */
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400401static void bclink_accept_pkt(struct tipc_node *node, u32 seqno)
402{
Ying Xue1da46562015-01-09 15:27:07 +0800403 struct tipc_net *tn = net_generic(node->net, tipc_net_id);
404
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400405 bclink_update_last_sent(node, seqno);
406 node->bclink.last_in = seqno;
407 node->bclink.oos_state = 0;
Ying Xue1da46562015-01-09 15:27:07 +0800408 tn->bcl->stats.recv_info++;
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400409
410 /*
411 * Unicast an ACK periodically, ensuring that
412 * all nodes in the cluster don't ACK at the same time
413 */
Ying Xue34747532015-01-09 15:27:10 +0800414 if (((seqno - tn->own_addr) % TIPC_MIN_LINK_WIN) == 0) {
Ying Xue247f0f32014-02-18 16:06:46 +0800415 tipc_link_proto_xmit(node->active_links[node->addr & 1],
Jon Paul Maloyed193ec2015-04-02 09:33:02 -0400416 STATE_MSG, 0, 0, 0, 0);
Ying Xue1da46562015-01-09 15:27:07 +0800417 tn->bcl->stats.sent_acks++;
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400418 }
419}
420
Ben Hutchings2c530402012-07-10 10:55:09 +0000421/**
Ying Xue247f0f32014-02-18 16:06:46 +0800422 * tipc_bclink_rcv - receive a broadcast packet, and deliver upwards
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900423 *
Ying Xue7216cd92014-04-21 10:55:48 +0800424 * RCU is locked, no other locks set
Per Lidenb97bf3f2006-01-02 19:04:38 +0100425 */
Ying Xuec93d3ba2015-01-09 15:27:04 +0800426void tipc_bclink_rcv(struct net *net, struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -0700427{
Ying Xuec93d3ba2015-01-09 15:27:04 +0800428 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800429 struct tipc_link *bcl = tn->bcl;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100430 struct tipc_msg *msg = buf_msg(buf);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400431 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100432 u32 next_in;
433 u32 seqno;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400434 int deferred = 0;
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500435 int pos = 0;
436 struct sk_buff *iskb;
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500437 struct sk_buff_head *arrvq, *inputq;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100438
Allan Stephens5d3c4882011-04-07 13:57:25 -0400439 /* Screen out unwanted broadcast messages */
Ying Xuec93d3ba2015-01-09 15:27:04 +0800440 if (msg_mc_netid(msg) != tn->net_id)
Allan Stephens5d3c4882011-04-07 13:57:25 -0400441 goto exit;
442
Ying Xuef2f98002015-01-09 15:27:05 +0800443 node = tipc_node_find(net, msg_prevnode(msg));
Allan Stephens5d3c4882011-04-07 13:57:25 -0400444 if (unlikely(!node))
445 goto exit;
446
447 tipc_node_lock(node);
Ying Xue389dd9b2012-11-16 13:51:30 +0800448 if (unlikely(!node->bclink.recv_permitted))
Allan Stephens5d3c4882011-04-07 13:57:25 -0400449 goto unlock;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100450
Allan Stephens8a275a62011-10-26 15:33:44 -0400451 /* Handle broadcast protocol message */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100452 if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
Allan Stephens9f6bdcd42011-04-07 14:57:53 -0400453 if (msg_type(msg) != STATE_MSG)
454 goto unlock;
Ying Xue34747532015-01-09 15:27:10 +0800455 if (msg_destnode(msg) == tn->own_addr) {
Per Liden4323add2006-01-18 00:38:21 +0100456 tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
Ying Xue1da46562015-01-09 15:27:07 +0800457 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100458 bcl->stats.recv_nacks++;
Ying Xue1da46562015-01-09 15:27:07 +0800459 tn->bclink->retransmit_to = node;
460 bclink_retransmit_pkt(tn, msg_bcgap_after(msg),
Per Lidenb97bf3f2006-01-02 19:04:38 +0100461 msg_bcgap_to(msg));
Ying Xue1da46562015-01-09 15:27:07 +0800462 tipc_bclink_unlock(net);
Ying Xueb952b2b2015-03-26 18:10:23 +0800463 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100464 } else {
Allan Stephens5d3c4882011-04-07 13:57:25 -0400465 tipc_node_unlock(node);
Ying Xuef2f98002015-01-09 15:27:05 +0800466 bclink_peek_nack(net, msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100467 }
Ying Xue8a0f6eb2015-03-26 18:10:24 +0800468 tipc_node_put(node);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400469 goto exit;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100470 }
471
Allan Stephens5d3c4882011-04-07 13:57:25 -0400472 /* Handle in-sequence broadcast message */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100473 seqno = msg_seqno(msg);
Allan Stephens8a275a62011-10-26 15:33:44 -0400474 next_in = mod(node->bclink.last_in + 1);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500475 arrvq = &tn->bclink->arrvq;
476 inputq = &tn->bclink->inputq;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100477
478 if (likely(seqno == next_in)) {
Allan Stephens8a275a62011-10-26 15:33:44 -0400479receive:
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400480 /* Deliver message to destination */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100481 if (likely(msg_isdata(msg))) {
Ying Xue1da46562015-01-09 15:27:07 +0800482 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400483 bclink_accept_pkt(node, seqno);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500484 spin_lock_bh(&inputq->lock);
485 __skb_queue_tail(arrvq, buf);
486 spin_unlock_bh(&inputq->lock);
487 node->action_flags |= TIPC_BCAST_MSG_EVT;
Ying Xue1da46562015-01-09 15:27:07 +0800488 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100489 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100490 } else if (msg_user(msg) == MSG_BUNDLER) {
Ying Xue1da46562015-01-09 15:27:07 +0800491 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400492 bclink_accept_pkt(node, seqno);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100493 bcl->stats.recv_bundles++;
494 bcl->stats.recv_bundled += msg_msgcnt(msg);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500495 pos = 0;
496 while (tipc_msg_extract(buf, &iskb, &pos)) {
497 spin_lock_bh(&inputq->lock);
498 __skb_queue_tail(arrvq, iskb);
499 spin_unlock_bh(&inputq->lock);
500 }
501 node->action_flags |= TIPC_BCAST_MSG_EVT;
Ying Xue1da46562015-01-09 15:27:07 +0800502 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100503 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100504 } else if (msg_user(msg) == MSG_FRAGMENTER) {
Ying Xue1da46562015-01-09 15:27:07 +0800505 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400506 bclink_accept_pkt(node, seqno);
Ying Xuebc14b8d2015-03-25 18:09:40 +0800507 tipc_buf_append(&node->bclink.reasm_buf, &buf);
508 if (unlikely(!buf && !node->bclink.reasm_buf)) {
509 tipc_bclink_unlock(net);
510 goto unlock;
511 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100512 bcl->stats.recv_fragments++;
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400513 if (buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100514 bcl->stats.recv_fragmented++;
Erik Hugne40ba3cd2013-11-06 09:28:06 +0100515 msg = buf_msg(buf);
Ying Xue1da46562015-01-09 15:27:07 +0800516 tipc_bclink_unlock(net);
Erik Hugne528f6f42013-11-06 09:28:05 +0100517 goto receive;
518 }
Ying Xue1da46562015-01-09 15:27:07 +0800519 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100520 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100521 } else {
Ying Xue1da46562015-01-09 15:27:07 +0800522 tipc_bclink_lock(net);
Allan Stephens63e7f1a2011-10-27 16:43:09 -0400523 bclink_accept_pkt(node, seqno);
Ying Xue1da46562015-01-09 15:27:07 +0800524 tipc_bclink_unlock(net);
Per Liden4323add2006-01-18 00:38:21 +0100525 tipc_node_unlock(node);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400526 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100527 }
Allan Stephens5d3c4882011-04-07 13:57:25 -0400528 buf = NULL;
Allan Stephens8a275a62011-10-26 15:33:44 -0400529
530 /* Determine new synchronization state */
Allan Stephens5d3c4882011-04-07 13:57:25 -0400531 tipc_node_lock(node);
Allan Stephens8a275a62011-10-26 15:33:44 -0400532 if (unlikely(!tipc_node_is_up(node)))
533 goto unlock;
534
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400535 if (node->bclink.last_in == node->bclink.last_sent)
Allan Stephens8a275a62011-10-26 15:33:44 -0400536 goto unlock;
537
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400538 if (skb_queue_empty(&node->bclink.deferdq)) {
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400539 node->bclink.oos_state = 1;
540 goto unlock;
541 }
542
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400543 msg = buf_msg(skb_peek(&node->bclink.deferdq));
Allan Stephens8a275a62011-10-26 15:33:44 -0400544 seqno = msg_seqno(msg);
545 next_in = mod(next_in + 1);
546 if (seqno != next_in)
547 goto unlock;
548
549 /* Take in-sequence message from deferred queue & deliver it */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400550 buf = __skb_dequeue(&node->bclink.deferdq);
Allan Stephens8a275a62011-10-26 15:33:44 -0400551 goto receive;
552 }
553
554 /* Handle out-of-sequence broadcast message */
Allan Stephens8a275a62011-10-26 15:33:44 -0400555 if (less(next_in, seqno)) {
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400556 deferred = tipc_link_defer_pkt(&node->bclink.deferdq,
Allan Stephens8a275a62011-10-26 15:33:44 -0400557 buf);
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400558 bclink_update_last_sent(node, seqno);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400559 buf = NULL;
Jon Paul Maloy0abd8ff2014-07-16 20:41:01 -0400560 }
Allan Stephens8a275a62011-10-26 15:33:44 -0400561
Ying Xue1da46562015-01-09 15:27:07 +0800562 tipc_bclink_lock(net);
Allan Stephensb98158e2011-10-26 16:13:35 -0400563
Allan Stephens8a275a62011-10-26 15:33:44 -0400564 if (deferred)
565 bcl->stats.deferred_recv++;
Allan Stephens0232c5a2011-10-26 15:57:26 -0400566 else
567 bcl->stats.duplicates++;
Allan Stephens8a275a62011-10-26 15:33:44 -0400568
Ying Xue1da46562015-01-09 15:27:07 +0800569 tipc_bclink_unlock(net);
Allan Stephensb98158e2011-10-26 16:13:35 -0400570
Allan Stephens5d3c4882011-04-07 13:57:25 -0400571unlock:
Per Liden4323add2006-01-18 00:38:21 +0100572 tipc_node_unlock(node);
Ying Xue8a0f6eb2015-03-26 18:10:24 +0800573 tipc_node_put(node);
Allan Stephens5d3c4882011-04-07 13:57:25 -0400574exit:
Allan Stephens5f6d9122011-11-04 13:24:29 -0400575 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100576}
577
David S. Miller6c000552008-09-02 23:38:32 -0700578u32 tipc_bclink_acks_missing(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100579{
Ying Xue389dd9b2012-11-16 13:51:30 +0800580 return (n_ptr->bclink.recv_permitted &&
Ying Xue1da46562015-01-09 15:27:07 +0800581 (tipc_bclink_get_last_sent(n_ptr->net) != n_ptr->bclink.acked));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100582}
583
584
585/**
Per Liden4323add2006-01-18 00:38:21 +0100586 * tipc_bcbearer_send - send a packet through the broadcast pseudo-bearer
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900587 *
Allan Stephens2ff9f922011-04-07 10:44:54 -0400588 * Send packet over as many bearers as necessary to reach all nodes
589 * that have joined the broadcast link.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900590 *
Allan Stephens2ff9f922011-04-07 10:44:54 -0400591 * Returns 0 (packet sent successfully) under all circumstances,
592 * since the broadcast link's pseudo-bearer never blocks
Per Lidenb97bf3f2006-01-02 19:04:38 +0100593 */
Ying Xue1da46562015-01-09 15:27:07 +0800594static int tipc_bcbearer_send(struct net *net, struct sk_buff *buf,
595 struct tipc_bearer *unused1,
Adrian Bunk988f0882006-03-20 22:37:52 -0800596 struct tipc_media_addr *unused2)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100597{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100598 int bp_index;
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400599 struct tipc_msg *msg = buf_msg(buf);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800600 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800601 struct tipc_bcbearer *bcbearer = tn->bcbearer;
602 struct tipc_bclink *bclink = tn->bclink;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100603
Gerlando Falautoe6160712013-05-01 12:04:44 +0000604 /* Prepare broadcast link message for reliable transmission,
Allan Stephens2ff9f922011-04-07 10:44:54 -0400605 * if first time trying to send it;
606 * preparation is skipped for broadcast link protocol messages
607 * since they are sent in an unreliable manner and don't need it
608 */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100609 if (likely(!msg_non_seq(buf_msg(buf)))) {
Allan Stephenscd3decd2011-10-24 11:18:12 -0400610 bcbuf_set_acks(buf, bclink->bcast_nodes.count);
Allan Stephens40aecb12008-06-04 17:54:48 -0700611 msg_set_non_seq(msg, 1);
Ying Xuec93d3ba2015-01-09 15:27:04 +0800612 msg_set_mc_netid(msg, tn->net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800613 tn->bcl->stats.sent_info++;
Allan Stephenscd3decd2011-10-24 11:18:12 -0400614 if (WARN_ON(!bclink->bcast_nodes.count)) {
Allan Stephens5e726902011-05-23 13:14:18 -0400615 dump_stack();
616 return 0;
617 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100618 }
619
Per Lidenb97bf3f2006-01-02 19:04:38 +0100620 /* Send buffer over bearers until all targets reached */
Allan Stephenscd3decd2011-10-24 11:18:12 -0400621 bcbearer->remains = bclink->bcast_nodes;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100622
623 for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
Allan Stephens2d627b92011-01-07 13:00:11 -0500624 struct tipc_bearer *p = bcbearer->bpairs[bp_index].primary;
625 struct tipc_bearer *s = bcbearer->bpairs[bp_index].secondary;
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400626 struct tipc_bearer *bp[2] = {p, s};
627 struct tipc_bearer *b = bp[msg_link_selector(msg)];
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000628 struct sk_buff *tbuf;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100629
630 if (!p)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000631 break; /* No more bearers to try */
Jon Paul Maloy6f92ee52014-07-16 20:41:04 -0400632 if (!b)
633 b = p;
Gerlando Falauto77861d92013-05-01 12:04:45 +0000634 tipc_nmap_diff(&bcbearer->remains, &b->nodes,
Gerlando Falautoe6160712013-05-01 12:04:44 +0000635 &bcbearer->remains_new);
Allan Stephens65f51ef2006-06-25 23:53:20 -0700636 if (bcbearer->remains_new.count == bcbearer->remains.count)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000637 continue; /* Nothing added by bearer pair */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100638
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000639 if (bp_index == 0) {
640 /* Use original buffer for first bearer */
Ying Xue7f9f95d2015-01-09 15:27:06 +0800641 tipc_bearer_send(net, b->identity, buf, &b->bcast_addr);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000642 } else {
643 /* Avoid concurrent buffer access */
Octavian Purdilabad93e92014-06-12 01:36:26 +0300644 tbuf = pskb_copy_for_clone(buf, GFP_ATOMIC);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000645 if (!tbuf)
646 break;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800647 tipc_bearer_send(net, b->identity, tbuf,
648 &b->bcast_addr);
Gerlando Falauto488fc9a2013-05-01 12:04:46 +0000649 kfree_skb(tbuf); /* Bearer keeps a clone */
650 }
Allan Stephens65f51ef2006-06-25 23:53:20 -0700651 if (bcbearer->remains_new.count == 0)
Gerlando Falautoe6160712013-05-01 12:04:44 +0000652 break; /* All targets reached */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100653
Allan Stephens65f51ef2006-06-25 23:53:20 -0700654 bcbearer->remains = bcbearer->remains_new;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100655 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900656
Allan Stephens2ff9f922011-04-07 10:44:54 -0400657 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100658}
659
660/**
Per Liden4323add2006-01-18 00:38:21 +0100661 * tipc_bcbearer_sort - create sets of bearer pairs used by broadcast bearer
Per Lidenb97bf3f2006-01-02 19:04:38 +0100662 */
Ying Xue7f9f95d2015-01-09 15:27:06 +0800663void tipc_bcbearer_sort(struct net *net, struct tipc_node_map *nm_ptr,
664 u32 node, bool action)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100665{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800666 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800667 struct tipc_bcbearer *bcbearer = tn->bcbearer;
Paul Gortmaker7f9ab6a2011-12-29 20:55:27 -0500668 struct tipc_bcbearer_pair *bp_temp = bcbearer->bpairs_temp;
669 struct tipc_bcbearer_pair *bp_curr;
Ying Xuef8322df2014-04-21 10:55:45 +0800670 struct tipc_bearer *b;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100671 int b_index;
672 int pri;
673
Ying Xue1da46562015-01-09 15:27:07 +0800674 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100675
Ying Xue28dd9412014-04-21 10:55:51 +0800676 if (action)
677 tipc_nmap_add(nm_ptr, node);
678 else
679 tipc_nmap_remove(nm_ptr, node);
680
Per Lidenb97bf3f2006-01-02 19:04:38 +0100681 /* Group bearers by priority (can assume max of two per priority) */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100682 memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));
683
Ying Xuef8322df2014-04-21 10:55:45 +0800684 rcu_read_lock();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100685 for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
Ying Xue7f9f95d2015-01-09 15:27:06 +0800686 b = rcu_dereference_rtnl(tn->bearer_list[b_index]);
Ying Xuef47de122014-03-27 12:54:34 +0800687 if (!b || !b->nodes.count)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100688 continue;
689
690 if (!bp_temp[b->priority].primary)
691 bp_temp[b->priority].primary = b;
692 else
693 bp_temp[b->priority].secondary = b;
694 }
Ying Xuef8322df2014-04-21 10:55:45 +0800695 rcu_read_unlock();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100696
697 /* Create array of bearer pairs for broadcasting */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100698 bp_curr = bcbearer->bpairs;
699 memset(bcbearer->bpairs, 0, sizeof(bcbearer->bpairs));
700
Per Liden16cb4b32006-01-13 22:22:22 +0100701 for (pri = TIPC_MAX_LINK_PRI; pri >= 0; pri--) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100702
703 if (!bp_temp[pri].primary)
704 continue;
705
706 bp_curr->primary = bp_temp[pri].primary;
707
708 if (bp_temp[pri].secondary) {
Per Liden4323add2006-01-18 00:38:21 +0100709 if (tipc_nmap_equal(&bp_temp[pri].primary->nodes,
710 &bp_temp[pri].secondary->nodes)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100711 bp_curr->secondary = bp_temp[pri].secondary;
712 } else {
713 bp_curr++;
714 bp_curr->primary = bp_temp[pri].secondary;
715 }
716 }
717
718 bp_curr++;
719 }
720
Ying Xue1da46562015-01-09 15:27:07 +0800721 tipc_bclink_unlock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100722}
723
Richard Alped8182802014-11-24 11:10:29 +0100724static int __tipc_nl_add_bc_link_stat(struct sk_buff *skb,
725 struct tipc_stats *stats)
Richard Alpe7be57fc2014-11-20 10:29:12 +0100726{
727 int i;
728 struct nlattr *nest;
729
730 struct nla_map {
731 __u32 key;
732 __u32 val;
733 };
734
735 struct nla_map map[] = {
736 {TIPC_NLA_STATS_RX_INFO, stats->recv_info},
737 {TIPC_NLA_STATS_RX_FRAGMENTS, stats->recv_fragments},
738 {TIPC_NLA_STATS_RX_FRAGMENTED, stats->recv_fragmented},
739 {TIPC_NLA_STATS_RX_BUNDLES, stats->recv_bundles},
740 {TIPC_NLA_STATS_RX_BUNDLED, stats->recv_bundled},
741 {TIPC_NLA_STATS_TX_INFO, stats->sent_info},
742 {TIPC_NLA_STATS_TX_FRAGMENTS, stats->sent_fragments},
743 {TIPC_NLA_STATS_TX_FRAGMENTED, stats->sent_fragmented},
744 {TIPC_NLA_STATS_TX_BUNDLES, stats->sent_bundles},
745 {TIPC_NLA_STATS_TX_BUNDLED, stats->sent_bundled},
746 {TIPC_NLA_STATS_RX_NACKS, stats->recv_nacks},
747 {TIPC_NLA_STATS_RX_DEFERRED, stats->deferred_recv},
748 {TIPC_NLA_STATS_TX_NACKS, stats->sent_nacks},
749 {TIPC_NLA_STATS_TX_ACKS, stats->sent_acks},
750 {TIPC_NLA_STATS_RETRANSMITTED, stats->retransmitted},
751 {TIPC_NLA_STATS_DUPLICATES, stats->duplicates},
752 {TIPC_NLA_STATS_LINK_CONGS, stats->link_congs},
753 {TIPC_NLA_STATS_MAX_QUEUE, stats->max_queue_sz},
754 {TIPC_NLA_STATS_AVG_QUEUE, stats->queue_sz_counts ?
755 (stats->accu_queue_sz / stats->queue_sz_counts) : 0}
756 };
757
758 nest = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
759 if (!nest)
760 return -EMSGSIZE;
761
762 for (i = 0; i < ARRAY_SIZE(map); i++)
763 if (nla_put_u32(skb, map[i].key, map[i].val))
764 goto msg_full;
765
766 nla_nest_end(skb, nest);
767
768 return 0;
769msg_full:
770 nla_nest_cancel(skb, nest);
771
772 return -EMSGSIZE;
773}
774
Ying Xue1da46562015-01-09 15:27:07 +0800775int tipc_nl_add_bc_link(struct net *net, struct tipc_nl_msg *msg)
Richard Alpe7be57fc2014-11-20 10:29:12 +0100776{
777 int err;
778 void *hdr;
779 struct nlattr *attrs;
780 struct nlattr *prop;
Ying Xue1da46562015-01-09 15:27:07 +0800781 struct tipc_net *tn = net_generic(net, tipc_net_id);
782 struct tipc_link *bcl = tn->bcl;
Richard Alpe7be57fc2014-11-20 10:29:12 +0100783
784 if (!bcl)
785 return 0;
786
Ying Xue1da46562015-01-09 15:27:07 +0800787 tipc_bclink_lock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100788
Richard Alpebfb3e5d2015-02-09 09:50:03 +0100789 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
Richard Alpe7be57fc2014-11-20 10:29:12 +0100790 NLM_F_MULTI, TIPC_NL_LINK_GET);
791 if (!hdr)
792 return -EMSGSIZE;
793
794 attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
795 if (!attrs)
796 goto msg_full;
797
798 /* The broadcast link is always up */
799 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
800 goto attr_msg_full;
801
802 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_BROADCAST))
803 goto attr_msg_full;
804 if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, bcl->name))
805 goto attr_msg_full;
806 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, bcl->next_in_no))
807 goto attr_msg_full;
808 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, bcl->next_out_no))
809 goto attr_msg_full;
810
811 prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
812 if (!prop)
813 goto attr_msg_full;
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400814 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bcl->window))
Richard Alpe7be57fc2014-11-20 10:29:12 +0100815 goto prop_msg_full;
816 nla_nest_end(msg->skb, prop);
817
818 err = __tipc_nl_add_bc_link_stat(msg->skb, &bcl->stats);
819 if (err)
820 goto attr_msg_full;
821
Ying Xue1da46562015-01-09 15:27:07 +0800822 tipc_bclink_unlock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100823 nla_nest_end(msg->skb, attrs);
824 genlmsg_end(msg->skb, hdr);
825
826 return 0;
827
828prop_msg_full:
829 nla_nest_cancel(msg->skb, prop);
830attr_msg_full:
831 nla_nest_cancel(msg->skb, attrs);
832msg_full:
Ying Xue1da46562015-01-09 15:27:07 +0800833 tipc_bclink_unlock(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +0100834 genlmsg_cancel(msg->skb, hdr);
835
836 return -EMSGSIZE;
837}
Per Lidenb97bf3f2006-01-02 19:04:38 +0100838
Ying Xue1da46562015-01-09 15:27:07 +0800839int tipc_bclink_reset_stats(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100840{
Ying Xue1da46562015-01-09 15:27:07 +0800841 struct tipc_net *tn = net_generic(net, tipc_net_id);
842 struct tipc_link *bcl = tn->bcl;
843
Per Lidenb97bf3f2006-01-02 19:04:38 +0100844 if (!bcl)
845 return -ENOPROTOOPT;
846
Ying Xue1da46562015-01-09 15:27:07 +0800847 tipc_bclink_lock(net);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100848 memset(&bcl->stats, 0, sizeof(bcl->stats));
Ying Xue1da46562015-01-09 15:27:07 +0800849 tipc_bclink_unlock(net);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700850 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100851}
852
Ying Xue1da46562015-01-09 15:27:07 +0800853int tipc_bclink_set_queue_limits(struct net *net, u32 limit)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100854{
Ying Xue1da46562015-01-09 15:27:07 +0800855 struct tipc_net *tn = net_generic(net, tipc_net_id);
856 struct tipc_link *bcl = tn->bcl;
857
Per Lidenb97bf3f2006-01-02 19:04:38 +0100858 if (!bcl)
859 return -ENOPROTOOPT;
860 if ((limit < TIPC_MIN_LINK_WIN) || (limit > TIPC_MAX_LINK_WIN))
861 return -EINVAL;
862
Ying Xue1da46562015-01-09 15:27:07 +0800863 tipc_bclink_lock(net);
Per Liden4323add2006-01-18 00:38:21 +0100864 tipc_link_set_queue_limits(bcl, limit);
Ying Xue1da46562015-01-09 15:27:07 +0800865 tipc_bclink_unlock(net);
Allan Stephens0e35fd52008-07-14 22:44:01 -0700866 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100867}
868
Ying Xue7f9f95d2015-01-09 15:27:06 +0800869int tipc_bclink_init(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100870{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800871 struct tipc_net *tn = net_generic(net, tipc_net_id);
Ying Xue1da46562015-01-09 15:27:07 +0800872 struct tipc_bcbearer *bcbearer;
873 struct tipc_bclink *bclink;
874 struct tipc_link *bcl;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800875
Ying Xueeb8b00f2014-05-05 08:56:16 +0800876 bcbearer = kzalloc(sizeof(*bcbearer), GFP_ATOMIC);
877 if (!bcbearer)
878 return -ENOMEM;
879
880 bclink = kzalloc(sizeof(*bclink), GFP_ATOMIC);
881 if (!bclink) {
882 kfree(bcbearer);
883 return -ENOMEM;
884 }
885
886 bcl = &bclink->link;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100887 bcbearer->bearer.media = &bcbearer->media;
Per Liden4323add2006-01-18 00:38:21 +0100888 bcbearer->media.send_msg = tipc_bcbearer_send;
Allan Stephens2e2d9be2011-04-07 10:22:31 -0400889 sprintf(bcbearer->media.name, "tipc-broadcast");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100890
Ying Xued69afc92014-05-05 08:56:15 +0800891 spin_lock_init(&bclink->lock);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400892 __skb_queue_head_init(&bcl->transmq);
893 __skb_queue_head_init(&bcl->backlogq);
894 __skb_queue_head_init(&bcl->deferdq);
Jon Paul Maloyc637c102015-02-05 08:36:41 -0500895 skb_queue_head_init(&bcl->wakeupq);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100896 bcl->next_out_no = 1;
Ingo Molnar34af9462006-06-27 02:53:55 -0700897 spin_lock_init(&bclink->node.lock);
Jon Paul Maloycb1b7282015-02-05 08:36:44 -0500898 __skb_queue_head_init(&bclink->arrvq);
899 skb_queue_head_init(&bclink->inputq);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100900 bcl->owner = &bclink->node;
Ying Xue1da46562015-01-09 15:27:07 +0800901 bcl->owner->net = net;
Jon Paul Maloyed193ec2015-04-02 09:33:02 -0400902 bcl->mtu = MAX_PKT_DEFAULT_MCAST;
Per Liden4323add2006-01-18 00:38:21 +0100903 tipc_link_set_queue_limits(bcl, BCLINK_WIN_DEFAULT);
Ying Xue7a2f7d12014-04-21 10:55:46 +0800904 bcl->bearer_id = MAX_BEARERS;
Ying Xue7f9f95d2015-01-09 15:27:06 +0800905 rcu_assign_pointer(tn->bearer_list[MAX_BEARERS], &bcbearer->bearer);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100906 bcl->state = WORKING_WORKING;
Jon Paul Maloyc5898632015-02-05 08:36:36 -0500907 bcl->pmsg = (struct tipc_msg *)&bcl->proto_msg;
908 msg_set_prevnode(bcl->pmsg, tn->own_addr);
Stephen Hemminger4b704d52009-03-18 19:11:29 -0700909 strlcpy(bcl->name, tipc_bclink_name, TIPC_MAX_LINK_NAME);
Ying Xue1da46562015-01-09 15:27:07 +0800910 tn->bcbearer = bcbearer;
911 tn->bclink = bclink;
912 tn->bcl = bcl;
Ying Xueeb8b00f2014-05-05 08:56:16 +0800913 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100914}
915
Ying Xue7f9f95d2015-01-09 15:27:06 +0800916void tipc_bclink_stop(struct net *net)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100917{
Ying Xue7f9f95d2015-01-09 15:27:06 +0800918 struct tipc_net *tn = net_generic(net, tipc_net_id);
919
Ying Xue1da46562015-01-09 15:27:07 +0800920 tipc_bclink_lock(net);
921 tipc_link_purge_queues(tn->bcl);
922 tipc_bclink_unlock(net);
Allan Stephensc47e9b92011-10-24 10:29:26 -0400923
Ying Xue7f9f95d2015-01-09 15:27:06 +0800924 RCU_INIT_POINTER(tn->bearer_list[BCBEARER], NULL);
Ying Xueeb8b00f2014-05-05 08:56:16 +0800925 synchronize_net();
Ying Xue1da46562015-01-09 15:27:07 +0800926 kfree(tn->bcbearer);
927 kfree(tn->bclink);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100928}
929
Allan Stephens3e22e622010-05-11 14:30:14 +0000930/**
931 * tipc_nmap_add - add a node to a node map
932 */
Ying Xue28dd9412014-04-21 10:55:51 +0800933static void tipc_nmap_add(struct tipc_node_map *nm_ptr, u32 node)
Allan Stephens3e22e622010-05-11 14:30:14 +0000934{
935 int n = tipc_node(node);
936 int w = n / WSIZE;
937 u32 mask = (1 << (n % WSIZE));
938
939 if ((nm_ptr->map[w] & mask) == 0) {
940 nm_ptr->count++;
941 nm_ptr->map[w] |= mask;
942 }
943}
944
945/**
946 * tipc_nmap_remove - remove a node from a node map
947 */
Ying Xue28dd9412014-04-21 10:55:51 +0800948static void tipc_nmap_remove(struct tipc_node_map *nm_ptr, u32 node)
Allan Stephens3e22e622010-05-11 14:30:14 +0000949{
950 int n = tipc_node(node);
951 int w = n / WSIZE;
952 u32 mask = (1 << (n % WSIZE));
953
954 if ((nm_ptr->map[w] & mask) != 0) {
955 nm_ptr->map[w] &= ~mask;
956 nm_ptr->count--;
957 }
958}
959
960/**
961 * tipc_nmap_diff - find differences between node maps
962 * @nm_a: input node map A
963 * @nm_b: input node map B
964 * @nm_diff: output node map A-B (i.e. nodes of A that are not in B)
965 */
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000966static void tipc_nmap_diff(struct tipc_node_map *nm_a,
967 struct tipc_node_map *nm_b,
968 struct tipc_node_map *nm_diff)
Allan Stephens3e22e622010-05-11 14:30:14 +0000969{
970 int stop = ARRAY_SIZE(nm_a->map);
971 int w;
972 int b;
973 u32 map;
974
975 memset(nm_diff, 0, sizeof(*nm_diff));
976 for (w = 0; w < stop; w++) {
977 map = nm_a->map[w] ^ (nm_a->map[w] & nm_b->map[w]);
978 nm_diff->map[w] = map;
979 if (map != 0) {
980 for (b = 0 ; b < WSIZE; b++) {
981 if (map & (1 << b))
982 nm_diff->count++;
983 }
984 }
985 }
986}