blob: 6a1a9d9239ae2abf79a25315e8351f0dcc45af78 [file] [log] [blame]
Per Lidenb97bf3f2006-01-02 19:04:38 +01001/*
2 * net/tipc/link.c: TIPC link code
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003 *
Jon Paul Maloyc1336ee2015-03-13 16:08:08 -04004 * Copyright (c) 1996-2007, 2012-2015, Ericsson AB
Ying Xue198d73b2013-06-17 10:54:42 -04005 * Copyright (c) 2004-2007, 2010-2013, Wind River Systems
Per Lidenb97bf3f2006-01-02 19:04:38 +01006 * All rights reserved.
7 *
Per Liden9ea1fd32006-01-11 13:30:43 +01008 * Redistribution and use in source and binary forms, with or without
Per Lidenb97bf3f2006-01-02 19:04:38 +01009 * modification, are permitted provided that the following conditions are met:
10 *
Per Liden9ea1fd32006-01-11 13:30:43 +010011 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
Per Lidenb97bf3f2006-01-02 19:04:38 +010019 *
Per Liden9ea1fd32006-01-11 13:30:43 +010020 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
Per Lidenb97bf3f2006-01-02 19:04:38 +010034 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37#include "core.h"
Jon Paul Maloye3eea1e2015-03-13 16:08:11 -040038#include "subscr.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010039#include "link.h"
Richard Alpe7be57fc2014-11-20 10:29:12 +010040#include "bcast.h"
Jon Paul Maloy9816f062014-05-14 05:39:15 -040041#include "socket.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010042#include "name_distr.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010043#include "discover.h"
Richard Alpe0655f6a2014-11-20 10:29:07 +010044#include "netlink.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010045
Ying Xue796c75d2013-06-17 10:54:48 -040046#include <linux/pkt_sched.h>
47
Erik Hugne2cf8aa12012-06-29 00:16:37 -040048/*
49 * Error message prefixes
50 */
Jon Paul Maloy6e498152015-07-30 18:24:19 -040051static const char *link_co_err = "Link tunneling error, ";
Erik Hugne2cf8aa12012-06-29 00:16:37 -040052static const char *link_rst_msg = "Resetting link ";
Jon Paul Maloy32301902015-10-22 08:51:37 -040053static const char tipc_bclink_name[] = "broadcast-link";
Per Lidenb97bf3f2006-01-02 19:04:38 +010054
Richard Alpe7be57fc2014-11-20 10:29:12 +010055static const struct nla_policy tipc_nl_link_policy[TIPC_NLA_LINK_MAX + 1] = {
56 [TIPC_NLA_LINK_UNSPEC] = { .type = NLA_UNSPEC },
57 [TIPC_NLA_LINK_NAME] = {
58 .type = NLA_STRING,
59 .len = TIPC_MAX_LINK_NAME
60 },
61 [TIPC_NLA_LINK_MTU] = { .type = NLA_U32 },
62 [TIPC_NLA_LINK_BROADCAST] = { .type = NLA_FLAG },
63 [TIPC_NLA_LINK_UP] = { .type = NLA_FLAG },
64 [TIPC_NLA_LINK_ACTIVE] = { .type = NLA_FLAG },
65 [TIPC_NLA_LINK_PROP] = { .type = NLA_NESTED },
66 [TIPC_NLA_LINK_STATS] = { .type = NLA_NESTED },
67 [TIPC_NLA_LINK_RX] = { .type = NLA_U32 },
68 [TIPC_NLA_LINK_TX] = { .type = NLA_U32 }
69};
70
Richard Alpe0655f6a2014-11-20 10:29:07 +010071/* Properties valid for media, bearar and link */
72static const struct nla_policy tipc_nl_prop_policy[TIPC_NLA_PROP_MAX + 1] = {
73 [TIPC_NLA_PROP_UNSPEC] = { .type = NLA_UNSPEC },
74 [TIPC_NLA_PROP_PRIO] = { .type = NLA_U32 },
75 [TIPC_NLA_PROP_TOL] = { .type = NLA_U32 },
76 [TIPC_NLA_PROP_WIN] = { .type = NLA_U32 }
77};
78
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090079/*
Jon Paul Maloyd9992972015-07-16 16:54:31 -040080 * Interval between NACKs when packets arrive out of order
81 */
82#define TIPC_NACK_INTV (TIPC_MIN_LINK_WIN * 2)
83/*
Allan Stephensa686e682008-06-04 17:29:39 -070084 * Out-of-range value for link session numbers
85 */
Jon Paul Maloyd3504c32015-07-16 16:54:25 -040086#define WILDCARD_SESSION 0x10000
Allan Stephensa686e682008-06-04 17:29:39 -070087
Jon Paul Maloy662921c2015-07-30 18:24:21 -040088/* Link FSM states:
Jon Paul Maloyd3504c32015-07-16 16:54:25 -040089 */
90enum {
Jon Paul Maloy662921c2015-07-30 18:24:21 -040091 LINK_ESTABLISHED = 0xe,
92 LINK_ESTABLISHING = 0xe << 4,
93 LINK_RESET = 0x1 << 8,
94 LINK_RESETTING = 0x2 << 12,
95 LINK_PEER_RESET = 0xd << 16,
96 LINK_FAILINGOVER = 0xf << 20,
97 LINK_SYNCHING = 0xc << 24
Jon Paul Maloyd3504c32015-07-16 16:54:25 -040098};
99
100/* Link FSM state checking routines
101 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400102static int link_is_up(struct tipc_link *l)
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400103{
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400104 return l->state & (LINK_ESTABLISHED | LINK_SYNCHING);
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400105}
106
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400107static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
108 struct sk_buff_head *xmitq);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -0400109static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
110 u16 rcvgap, int tolerance, int priority,
111 struct sk_buff_head *xmitq);
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500112static void link_reset_statistics(struct tipc_link *l_ptr);
113static void link_print(struct tipc_link *l_ptr, const char *str);
Ying Xue247f0f32014-02-18 16:06:46 +0800114static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf);
Jon Paul Maloy8b4ed862015-03-25 12:07:26 -0400115
Per Lidenb97bf3f2006-01-02 19:04:38 +0100116/*
Sam Ravnborg05790c62006-03-20 22:37:04 -0800117 * Simple non-static link routines (i.e. referenced outside this file)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100118 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400119bool tipc_link_is_up(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100120{
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400121 return link_is_up(l);
122}
123
Jon Paul Maloyc8199302015-10-15 14:52:46 -0400124bool tipc_link_peer_is_down(struct tipc_link *l)
125{
126 return l->state == LINK_PEER_RESET;
127}
128
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400129bool tipc_link_is_reset(struct tipc_link *l)
130{
131 return l->state & (LINK_RESET | LINK_FAILINGOVER | LINK_ESTABLISHING);
132}
133
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400134bool tipc_link_is_establishing(struct tipc_link *l)
135{
136 return l->state == LINK_ESTABLISHING;
137}
138
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400139bool tipc_link_is_synching(struct tipc_link *l)
140{
141 return l->state == LINK_SYNCHING;
142}
143
144bool tipc_link_is_failingover(struct tipc_link *l)
145{
146 return l->state == LINK_FAILINGOVER;
147}
148
149bool tipc_link_is_blocked(struct tipc_link *l)
150{
151 return l->state & (LINK_RESETTING | LINK_PEER_RESET | LINK_FAILINGOVER);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100152}
153
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -0400154int tipc_link_is_active(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100155{
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -0400156 struct tipc_node *n = l->owner;
157
158 return (node_active_link(n, 0) == l) || (node_active_link(n, 1) == l);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100159}
160
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400161void tipc_link_add_bc_peer(struct tipc_link *l)
162{
163 l->ackers++;
164}
165
166void tipc_link_remove_bc_peer(struct tipc_link *l)
167{
168 l->ackers--;
169}
170
171int tipc_link_bc_peers(struct tipc_link *l)
172{
173 return l->ackers;
174}
175
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400176static u32 link_own_addr(struct tipc_link *l)
177{
178 return msg_prevnode(l->pmsg);
179}
180
Per Lidenb97bf3f2006-01-02 19:04:38 +0100181/**
Per Liden4323add2006-01-18 00:38:21 +0100182 * tipc_link_create - create a new link
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400183 * @n: pointer to associated node
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400184 * @if_name: associated interface name
185 * @bearer_id: id (index) of associated bearer
186 * @tolerance: link tolerance to be used by link
187 * @net_plane: network plane (A,B,c..) this link belongs to
188 * @mtu: mtu to be advertised by link
189 * @priority: priority to be used by link
190 * @window: send window to be used by link
191 * @session: session to be used by link
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400192 * @ownnode: identity of own node
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400193 * @peer: node id of peer node
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400194 * @peer_caps: bitmap describing peer node capabilities
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400195 * @maddr: media address to be used
196 * @inputq: queue to put messages ready for delivery
197 * @namedq: queue to put binding table update messages ready for delivery
198 * @link: return value, pointer to put the created link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900199 *
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400200 * Returns true if link was created, otherwise false
Per Lidenb97bf3f2006-01-02 19:04:38 +0100201 */
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400202bool tipc_link_create(struct tipc_node *n, char *if_name, int bearer_id,
203 int tolerance, char net_plane, u32 mtu, int priority,
204 int window, u32 session, u32 ownnode, u32 peer,
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400205 u16 peer_caps, struct tipc_media_addr *maddr,
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400206 struct sk_buff_head *inputq, struct sk_buff_head *namedq,
207 struct tipc_link **link)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100208{
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400209 struct tipc_link *l;
210 struct tipc_msg *hdr;
Allan Stephens37b9c082011-02-28 11:32:27 -0500211
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400212 l = kzalloc(sizeof(*l), GFP_ATOMIC);
213 if (!l)
214 return false;
215 *link = l;
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400216 l->pmsg = (struct tipc_msg *)&l->proto_msg;
217 hdr = l->pmsg;
218 tipc_msg_init(ownnode, hdr, LINK_PROTOCOL, RESET_MSG, INT_H_SIZE, peer);
219 msg_set_size(hdr, sizeof(l->proto_msg));
220 msg_set_session(hdr, session);
221 msg_set_bearer_id(hdr, l->bearer_id);
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400222
223 /* Note: peer i/f name is completed by reset/activate message */
224 sprintf(l->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
225 tipc_zone(ownnode), tipc_cluster(ownnode), tipc_node(ownnode),
226 if_name, tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400227 strcpy((char *)msg_data(hdr), if_name);
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400228
229 l->addr = peer;
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400230 l->peer_caps = peer_caps;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400231 l->media_addr = maddr;
232 l->owner = n;
233 l->peer_session = WILDCARD_SESSION;
234 l->bearer_id = bearer_id;
235 l->tolerance = tolerance;
236 l->net_plane = net_plane;
237 l->advertised_mtu = mtu;
238 l->mtu = mtu;
239 l->priority = priority;
240 tipc_link_set_queue_limits(l, window);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400241 l->ackers = 1;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400242 l->inputq = inputq;
243 l->namedq = namedq;
244 l->state = LINK_RESETTING;
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400245 __skb_queue_head_init(&l->transmq);
246 __skb_queue_head_init(&l->backlogq);
247 __skb_queue_head_init(&l->deferdq);
248 skb_queue_head_init(&l->wakeupq);
249 skb_queue_head_init(l->inputq);
250 return true;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100251}
252
Jon Paul Maloy32301902015-10-22 08:51:37 -0400253/**
254 * tipc_link_bc_create - create new link to be used for broadcast
255 * @n: pointer to associated node
256 * @mtu: mtu to be used
257 * @window: send window to be used
258 * @inputq: queue to put messages ready for delivery
259 * @namedq: queue to put binding table update messages ready for delivery
260 * @link: return value, pointer to put the created link
261 *
262 * Returns true if link was created, otherwise false
263 */
264bool tipc_link_bc_create(struct tipc_node *n, int mtu, int window,
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400265 u16 peer_caps,
Jon Paul Maloy32301902015-10-22 08:51:37 -0400266 struct sk_buff_head *inputq,
267 struct sk_buff_head *namedq,
268 struct tipc_link **link)
269{
270 struct tipc_link *l;
271
272 if (!tipc_link_create(n, "", MAX_BEARERS, 0, 'Z', mtu, 0, window,
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400273 0, 0, 0, peer_caps, NULL, inputq, namedq, link))
Jon Paul Maloy32301902015-10-22 08:51:37 -0400274 return false;
275
276 l = *link;
277 strcpy(l->name, tipc_bclink_name);
278 tipc_link_reset(l);
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400279 l->ackers = 0;
Jon Paul Maloy32301902015-10-22 08:51:37 -0400280 return true;
281}
282
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400283/* tipc_link_build_bcast_sync_msg() - synchronize broadcast link endpoints.
284 *
285 * Give a newly added peer node the sequence number where it should
286 * start receiving and acking broadcast packets.
287 */
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400288void tipc_link_build_bcast_sync_msg(struct tipc_link *l,
289 struct sk_buff_head *xmitq)
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400290{
291 struct sk_buff *skb;
292 struct sk_buff_head list;
Jon Maloy5a4c3552015-07-29 18:28:01 -0400293 u16 last_sent;
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400294
295 skb = tipc_msg_create(BCAST_PROTOCOL, STATE_MSG, INT_H_SIZE,
296 0, l->addr, link_own_addr(l), 0, 0, 0);
297 if (!skb)
298 return;
Jon Maloy5a4c3552015-07-29 18:28:01 -0400299 last_sent = tipc_bclink_get_last_sent(l->owner->net);
300 msg_set_last_bcast(buf_msg(skb), last_sent);
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400301 __skb_queue_head_init(&list);
302 __skb_queue_tail(&list, skb);
303 tipc_link_xmit(l, &list, xmitq);
304}
305
Per Lidenb97bf3f2006-01-02 19:04:38 +0100306/**
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400307 * tipc_link_fsm_evt - link finite state machine
308 * @l: pointer to link
309 * @evt: state machine event to be processed
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400310 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400311int tipc_link_fsm_evt(struct tipc_link *l, int evt)
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400312{
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400313 int rc = 0;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400314
315 switch (l->state) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400316 case LINK_RESETTING:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400317 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400318 case LINK_PEER_RESET_EVT:
319 l->state = LINK_PEER_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400320 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400321 case LINK_RESET_EVT:
322 l->state = LINK_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400323 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400324 case LINK_FAILURE_EVT:
325 case LINK_FAILOVER_BEGIN_EVT:
326 case LINK_ESTABLISH_EVT:
327 case LINK_FAILOVER_END_EVT:
328 case LINK_SYNCH_BEGIN_EVT:
329 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400330 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400331 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400332 }
333 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400334 case LINK_RESET:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400335 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400336 case LINK_PEER_RESET_EVT:
337 l->state = LINK_ESTABLISHING;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400338 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400339 case LINK_FAILOVER_BEGIN_EVT:
340 l->state = LINK_FAILINGOVER;
341 case LINK_FAILURE_EVT:
342 case LINK_RESET_EVT:
343 case LINK_ESTABLISH_EVT:
344 case LINK_FAILOVER_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400345 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400346 case LINK_SYNCH_BEGIN_EVT:
347 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400348 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400349 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400350 }
351 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400352 case LINK_PEER_RESET:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400353 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400354 case LINK_RESET_EVT:
355 l->state = LINK_ESTABLISHING;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400356 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400357 case LINK_PEER_RESET_EVT:
358 case LINK_ESTABLISH_EVT:
359 case LINK_FAILURE_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400360 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400361 case LINK_SYNCH_BEGIN_EVT:
362 case LINK_SYNCH_END_EVT:
363 case LINK_FAILOVER_BEGIN_EVT:
364 case LINK_FAILOVER_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400365 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400366 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400367 }
368 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400369 case LINK_FAILINGOVER:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400370 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400371 case LINK_FAILOVER_END_EVT:
372 l->state = LINK_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400373 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400374 case LINK_PEER_RESET_EVT:
375 case LINK_RESET_EVT:
376 case LINK_ESTABLISH_EVT:
377 case LINK_FAILURE_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400378 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400379 case LINK_FAILOVER_BEGIN_EVT:
380 case LINK_SYNCH_BEGIN_EVT:
381 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400382 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400383 goto illegal_evt;
384 }
385 break;
386 case LINK_ESTABLISHING:
387 switch (evt) {
388 case LINK_ESTABLISH_EVT:
389 l->state = LINK_ESTABLISHED;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400390 break;
391 case LINK_FAILOVER_BEGIN_EVT:
392 l->state = LINK_FAILINGOVER;
393 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400394 case LINK_RESET_EVT:
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400395 l->state = LINK_RESET;
396 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400397 case LINK_FAILURE_EVT:
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400398 case LINK_PEER_RESET_EVT:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400399 case LINK_SYNCH_BEGIN_EVT:
400 case LINK_FAILOVER_END_EVT:
401 break;
402 case LINK_SYNCH_END_EVT:
403 default:
404 goto illegal_evt;
405 }
406 break;
407 case LINK_ESTABLISHED:
408 switch (evt) {
409 case LINK_PEER_RESET_EVT:
410 l->state = LINK_PEER_RESET;
411 rc |= TIPC_LINK_DOWN_EVT;
412 break;
413 case LINK_FAILURE_EVT:
414 l->state = LINK_RESETTING;
415 rc |= TIPC_LINK_DOWN_EVT;
416 break;
417 case LINK_RESET_EVT:
418 l->state = LINK_RESET;
419 break;
420 case LINK_ESTABLISH_EVT:
Jon Paul Maloy5ae2f8e2015-08-20 02:12:55 -0400421 case LINK_SYNCH_END_EVT:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400422 break;
423 case LINK_SYNCH_BEGIN_EVT:
424 l->state = LINK_SYNCHING;
425 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400426 case LINK_FAILOVER_BEGIN_EVT:
427 case LINK_FAILOVER_END_EVT:
428 default:
429 goto illegal_evt;
430 }
431 break;
432 case LINK_SYNCHING:
433 switch (evt) {
434 case LINK_PEER_RESET_EVT:
435 l->state = LINK_PEER_RESET;
436 rc |= TIPC_LINK_DOWN_EVT;
437 break;
438 case LINK_FAILURE_EVT:
439 l->state = LINK_RESETTING;
440 rc |= TIPC_LINK_DOWN_EVT;
441 break;
442 case LINK_RESET_EVT:
443 l->state = LINK_RESET;
444 break;
445 case LINK_ESTABLISH_EVT:
446 case LINK_SYNCH_BEGIN_EVT:
447 break;
448 case LINK_SYNCH_END_EVT:
449 l->state = LINK_ESTABLISHED;
450 break;
451 case LINK_FAILOVER_BEGIN_EVT:
452 case LINK_FAILOVER_END_EVT:
453 default:
454 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400455 }
456 break;
457 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400458 pr_err("Unknown FSM state %x in %s\n", l->state, l->name);
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400459 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400460 return rc;
461illegal_evt:
462 pr_err("Illegal FSM event %x in state %x on link %s\n",
463 evt, l->state, l->name);
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400464 return rc;
465}
466
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400467/* link_profile_stats - update statistical profiling of traffic
468 */
469static void link_profile_stats(struct tipc_link *l)
470{
471 struct sk_buff *skb;
472 struct tipc_msg *msg;
473 int length;
474
475 /* Update counters used in statistical profiling of send traffic */
476 l->stats.accu_queue_sz += skb_queue_len(&l->transmq);
477 l->stats.queue_sz_counts++;
478
479 skb = skb_peek(&l->transmq);
480 if (!skb)
481 return;
482 msg = buf_msg(skb);
483 length = msg_size(msg);
484
485 if (msg_user(msg) == MSG_FRAGMENTER) {
486 if (msg_type(msg) != FIRST_FRAGMENT)
487 return;
488 length = msg_size(msg_get_wrapped(msg));
489 }
490 l->stats.msg_lengths_total += length;
491 l->stats.msg_length_counts++;
492 if (length <= 64)
493 l->stats.msg_length_profile[0]++;
494 else if (length <= 256)
495 l->stats.msg_length_profile[1]++;
496 else if (length <= 1024)
497 l->stats.msg_length_profile[2]++;
498 else if (length <= 4096)
499 l->stats.msg_length_profile[3]++;
500 else if (length <= 16384)
501 l->stats.msg_length_profile[4]++;
502 else if (length <= 32768)
503 l->stats.msg_length_profile[5]++;
504 else
505 l->stats.msg_length_profile[6]++;
506}
507
508/* tipc_link_timeout - perform periodic task as instructed from node timeout
509 */
510int tipc_link_timeout(struct tipc_link *l, struct sk_buff_head *xmitq)
511{
512 int rc = 0;
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400513 int mtyp = STATE_MSG;
514 bool xmit = false;
515 bool prb = false;
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400516
517 link_profile_stats(l);
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400518
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400519 switch (l->state) {
520 case LINK_ESTABLISHED:
521 case LINK_SYNCHING:
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400522 if (!l->silent_intv_cnt) {
523 if (tipc_bclink_acks_missing(l->owner))
524 xmit = true;
525 } else if (l->silent_intv_cnt <= l->abort_limit) {
526 xmit = true;
527 prb = true;
528 } else {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400529 rc |= tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400530 }
531 l->silent_intv_cnt++;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400532 break;
533 case LINK_RESET:
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400534 xmit = true;
535 mtyp = RESET_MSG;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400536 break;
537 case LINK_ESTABLISHING:
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400538 xmit = true;
539 mtyp = ACTIVATE_MSG;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400540 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400541 case LINK_PEER_RESET:
Jon Paul Maloy598411d2015-07-30 18:24:23 -0400542 case LINK_RESETTING:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400543 case LINK_FAILINGOVER:
544 break;
545 default:
546 break;
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400547 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400548
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400549 if (xmit)
550 tipc_link_build_proto_msg(l, mtyp, prb, 0, 0, 0, xmitq);
551
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400552 return rc;
553}
554
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400555/**
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400556 * link_schedule_user - schedule a message sender for wakeup after congestion
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400557 * @link: congested link
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400558 * @list: message that was attempted sent
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400559 * Create pseudo msg to send back to user when congestion abates
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400560 * Does not consume buffer list
Per Lidenb97bf3f2006-01-02 19:04:38 +0100561 */
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400562static int link_schedule_user(struct tipc_link *link, struct sk_buff_head *list)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100563{
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400564 struct tipc_msg *msg = buf_msg(skb_peek(list));
565 int imp = msg_importance(msg);
566 u32 oport = msg_origport(msg);
567 u32 addr = link_own_addr(link);
568 struct sk_buff *skb;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100569
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400570 /* This really cannot happen... */
571 if (unlikely(imp > TIPC_CRITICAL_IMPORTANCE)) {
572 pr_warn("%s<%s>, send queue full", link_rst_msg, link->name);
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400573 return -ENOBUFS;
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400574 }
575 /* Non-blocking sender: */
576 if (TIPC_SKB_CB(skb_peek(list))->wakeup_pending)
577 return -ELINKCONG;
578
579 /* Create and schedule wakeup pseudo message */
580 skb = tipc_msg_create(SOCK_WAKEUP, 0, INT_H_SIZE, 0,
581 addr, addr, oport, 0, 0);
582 if (!skb)
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400583 return -ENOBUFS;
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400584 TIPC_SKB_CB(skb)->chain_sz = skb_queue_len(list);
585 TIPC_SKB_CB(skb)->chain_imp = imp;
586 skb_queue_tail(&link->wakeupq, skb);
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400587 link->stats.link_congs++;
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400588 return -ELINKCONG;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100589}
590
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400591/**
592 * link_prepare_wakeup - prepare users for wakeup after congestion
593 * @link: congested link
594 * Move a number of waiting users, as permitted by available space in
595 * the send queue, from link wait queue to node wait queue for wakeup
596 */
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400597void link_prepare_wakeup(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100598{
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400599 int pnd[TIPC_SYSTEM_IMPORTANCE + 1] = {0,};
600 int imp, lim;
Ying Xue58d78b32014-11-26 11:41:51 +0800601 struct sk_buff *skb, *tmp;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100602
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400603 skb_queue_walk_safe(&l->wakeupq, skb, tmp) {
604 imp = TIPC_SKB_CB(skb)->chain_imp;
605 lim = l->window + l->backlog[imp].limit;
606 pnd[imp] += TIPC_SKB_CB(skb)->chain_sz;
607 if ((pnd[imp] + l->backlog[imp].len) >= lim)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100608 break;
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400609 skb_unlink(skb, &l->wakeupq);
Jon Paul Maloyd39bbd42015-07-16 16:54:21 -0400610 skb_queue_tail(l->inputq, skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100611 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100612}
613
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900614/**
Per Liden4323add2006-01-18 00:38:21 +0100615 * tipc_link_reset_fragments - purge link's inbound message fragments queue
Per Lidenb97bf3f2006-01-02 19:04:38 +0100616 * @l_ptr: pointer to link
617 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500618void tipc_link_reset_fragments(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100619{
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400620 kfree_skb(l_ptr->reasm_buf);
621 l_ptr->reasm_buf = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100622}
623
Jon Paul Maloy7d967b62015-06-28 09:44:44 -0400624void tipc_link_purge_backlog(struct tipc_link *l)
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400625{
626 __skb_queue_purge(&l->backlogq);
627 l->backlog[TIPC_LOW_IMPORTANCE].len = 0;
628 l->backlog[TIPC_MEDIUM_IMPORTANCE].len = 0;
629 l->backlog[TIPC_HIGH_IMPORTANCE].len = 0;
630 l->backlog[TIPC_CRITICAL_IMPORTANCE].len = 0;
631 l->backlog[TIPC_SYSTEM_IMPORTANCE].len = 0;
632}
633
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900634/**
Jon Paul Maloy581465f2014-01-07 17:02:44 -0500635 * tipc_link_purge_queues - purge all pkt queues associated with link
Per Lidenb97bf3f2006-01-02 19:04:38 +0100636 * @l_ptr: pointer to link
637 */
Jon Paul Maloy581465f2014-01-07 17:02:44 -0500638void tipc_link_purge_queues(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100639{
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400640 __skb_queue_purge(&l_ptr->deferdq);
641 __skb_queue_purge(&l_ptr->transmq);
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400642 tipc_link_purge_backlog(l_ptr);
Per Liden4323add2006-01-18 00:38:21 +0100643 tipc_link_reset_fragments(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100644}
645
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400646void tipc_link_reset(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100647{
Allan Stephensa686e682008-06-04 17:29:39 -0700648 /* Link is down, accept any session */
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400649 l->peer_session = WILDCARD_SESSION;
650
651 /* If peer is up, it only accepts an incremented session number */
652 msg_set_session(l->pmsg, msg_session(l->pmsg) + 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100653
Jon Paul Maloyed193ec2015-04-02 09:33:02 -0400654 /* Prepare for renewed mtu size negotiation */
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400655 l->mtu = l->advertised_mtu;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900656
Jon Paul Maloy23d83352015-07-30 18:24:24 -0400657 /* Clean up all queues: */
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400658 __skb_queue_purge(&l->transmq);
659 __skb_queue_purge(&l->deferdq);
Jon Paul Maloy23d83352015-07-30 18:24:24 -0400660 skb_queue_splice_init(&l->wakeupq, l->inputq);
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400661
662 tipc_link_purge_backlog(l);
663 kfree_skb(l->reasm_buf);
664 kfree_skb(l->failover_reasm_skb);
665 l->reasm_buf = NULL;
666 l->failover_reasm_skb = NULL;
667 l->rcv_unacked = 0;
668 l->snd_nxt = 1;
669 l->rcv_nxt = 1;
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400670 l->acked = 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400671 l->silent_intv_cnt = 0;
672 l->stats.recv_info = 0;
673 l->stale_count = 0;
674 link_reset_statistics(l);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100675}
676
Per Lidenb97bf3f2006-01-02 19:04:38 +0100677/**
Jon Paul Maloy9fbfb8b2014-07-16 20:41:03 -0400678 * __tipc_link_xmit(): same as tipc_link_xmit, but destlink is known & locked
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500679 * @link: link to use
Ying Xuea6ca1092014-11-26 11:41:55 +0800680 * @list: chain of buffers containing message
681 *
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400682 * Consumes the buffer chain, except when returning an error code,
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400683 * Returns 0 if success, or errno: -ELINKCONG, -EMSGSIZE or -ENOBUFS
684 * Messages at TIPC_SYSTEM_IMPORTANCE are always accepted
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500685 */
Ying Xue7f9f95d2015-01-09 15:27:06 +0800686int __tipc_link_xmit(struct net *net, struct tipc_link *link,
687 struct sk_buff_head *list)
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500688{
Ying Xuea6ca1092014-11-26 11:41:55 +0800689 struct tipc_msg *msg = buf_msg(skb_peek(list));
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400690 unsigned int maxwin = link->window;
Jon Paul Maloyf21e8972015-05-14 10:46:17 -0400691 unsigned int i, imp = msg_importance(msg);
Jon Paul Maloyed193ec2015-04-02 09:33:02 -0400692 uint mtu = link->mtu;
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400693 u16 ack = mod(link->rcv_nxt - 1);
694 u16 seqno = link->snd_nxt;
Jon Paul Maloye4bf4f72015-05-14 10:46:14 -0400695 u16 bc_last_in = link->owner->bclink.last_in;
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400696 struct tipc_media_addr *addr = link->media_addr;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400697 struct sk_buff_head *transmq = &link->transmq;
698 struct sk_buff_head *backlogq = &link->backlogq;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400699 struct sk_buff *skb, *bskb;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500700
Jon Paul Maloyf21e8972015-05-14 10:46:17 -0400701 /* Match msg importance against this and all higher backlog limits: */
702 for (i = imp; i <= TIPC_SYSTEM_IMPORTANCE; i++) {
703 if (unlikely(link->backlog[i].len >= link->backlog[i].limit))
704 return link_schedule_user(link, list);
705 }
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400706 if (unlikely(msg_size(msg) > mtu))
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500707 return -EMSGSIZE;
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400708
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400709 /* Prepare each packet for sending, and add to relevant queue: */
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400710 while (skb_queue_len(list)) {
711 skb = skb_peek(list);
Ying Xue58dc55f2014-11-26 11:41:52 +0800712 msg = buf_msg(skb);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400713 msg_set_seqno(msg, seqno);
714 msg_set_ack(msg, ack);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500715 msg_set_bcast_ack(msg, bc_last_in);
716
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400717 if (likely(skb_queue_len(transmq) < maxwin)) {
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400718 __skb_dequeue(list);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400719 __skb_queue_tail(transmq, skb);
720 tipc_bearer_send(net, link->bearer_id, skb, addr);
721 link->rcv_unacked = 0;
722 seqno++;
723 continue;
724 }
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400725 if (tipc_msg_bundle(skb_peek_tail(backlogq), msg, mtu)) {
726 kfree_skb(__skb_dequeue(list));
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500727 link->stats.sent_bundled++;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500728 continue;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400729 }
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400730 if (tipc_msg_make_bundle(&bskb, msg, mtu, link->addr)) {
731 kfree_skb(__skb_dequeue(list));
732 __skb_queue_tail(backlogq, bskb);
733 link->backlog[msg_importance(buf_msg(bskb))].len++;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500734 link->stats.sent_bundled++;
735 link->stats.sent_bundles++;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400736 continue;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500737 }
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400738 link->backlog[imp].len += skb_queue_len(list);
739 skb_queue_splice_tail_init(list, backlogq);
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500740 }
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400741 link->snd_nxt = seqno;
Jon Paul Maloy4f1688b2014-06-25 20:41:32 -0500742 return 0;
743}
744
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400745/**
746 * tipc_link_xmit(): enqueue buffer list according to queue situation
747 * @link: link to use
748 * @list: chain of buffers containing message
749 * @xmitq: returned list of packets to be sent by caller
750 *
751 * Consumes the buffer chain, except when returning -ELINKCONG,
752 * since the caller then may want to make more send attempts.
753 * Returns 0 if success, or errno: -ELINKCONG, -EMSGSIZE or -ENOBUFS
754 * Messages at TIPC_SYSTEM_IMPORTANCE are always accepted
755 */
756int tipc_link_xmit(struct tipc_link *l, struct sk_buff_head *list,
757 struct sk_buff_head *xmitq)
758{
759 struct tipc_msg *hdr = buf_msg(skb_peek(list));
760 unsigned int maxwin = l->window;
761 unsigned int i, imp = msg_importance(hdr);
762 unsigned int mtu = l->mtu;
763 u16 ack = l->rcv_nxt - 1;
764 u16 seqno = l->snd_nxt;
765 u16 bc_last_in = l->owner->bclink.last_in;
766 struct sk_buff_head *transmq = &l->transmq;
767 struct sk_buff_head *backlogq = &l->backlogq;
768 struct sk_buff *skb, *_skb, *bskb;
769
770 /* Match msg importance against this and all higher backlog limits: */
771 for (i = imp; i <= TIPC_SYSTEM_IMPORTANCE; i++) {
772 if (unlikely(l->backlog[i].len >= l->backlog[i].limit))
773 return link_schedule_user(l, list);
774 }
775 if (unlikely(msg_size(hdr) > mtu))
776 return -EMSGSIZE;
777
778 /* Prepare each packet for sending, and add to relevant queue: */
779 while (skb_queue_len(list)) {
780 skb = skb_peek(list);
781 hdr = buf_msg(skb);
782 msg_set_seqno(hdr, seqno);
783 msg_set_ack(hdr, ack);
784 msg_set_bcast_ack(hdr, bc_last_in);
785
786 if (likely(skb_queue_len(transmq) < maxwin)) {
787 _skb = skb_clone(skb, GFP_ATOMIC);
788 if (!_skb)
789 return -ENOBUFS;
790 __skb_dequeue(list);
791 __skb_queue_tail(transmq, skb);
792 __skb_queue_tail(xmitq, _skb);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400793 TIPC_SKB_CB(skb)->ackers = l->ackers;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400794 l->rcv_unacked = 0;
795 seqno++;
796 continue;
797 }
798 if (tipc_msg_bundle(skb_peek_tail(backlogq), hdr, mtu)) {
799 kfree_skb(__skb_dequeue(list));
800 l->stats.sent_bundled++;
801 continue;
802 }
803 if (tipc_msg_make_bundle(&bskb, hdr, mtu, l->addr)) {
804 kfree_skb(__skb_dequeue(list));
805 __skb_queue_tail(backlogq, bskb);
806 l->backlog[msg_importance(buf_msg(bskb))].len++;
807 l->stats.sent_bundled++;
808 l->stats.sent_bundles++;
809 continue;
810 }
811 l->backlog[imp].len += skb_queue_len(list);
812 skb_queue_splice_tail_init(list, backlogq);
813 }
814 l->snd_nxt = seqno;
815 return 0;
816}
817
Jon Maloyc64f7a62012-11-16 13:51:31 +0800818/*
Ying Xue247f0f32014-02-18 16:06:46 +0800819 * tipc_link_sync_rcv - synchronize broadcast link endpoints.
Jon Maloyc64f7a62012-11-16 13:51:31 +0800820 * Receive the sequence number where we should start receiving and
821 * acking broadcast packets from a newly added peer node, and open
822 * up for reception of such packets.
823 *
824 * Called with node locked
825 */
Ying Xue247f0f32014-02-18 16:06:46 +0800826static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf)
Jon Maloyc64f7a62012-11-16 13:51:31 +0800827{
828 struct tipc_msg *msg = buf_msg(buf);
829
830 n->bclink.last_sent = n->bclink.last_in = msg_last_bcast(msg);
831 n->bclink.recv_permitted = true;
832 kfree_skb(buf);
833}
834
835/*
Ying Xue47b4c9a2014-11-26 11:41:48 +0800836 * tipc_link_push_packets - push unsent packets to bearer
837 *
838 * Push out the unsent messages of a link where congestion
839 * has abated. Node is locked.
840 *
841 * Called with node locked
Per Lidenb97bf3f2006-01-02 19:04:38 +0100842 */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400843void tipc_link_push_packets(struct tipc_link *link)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100844{
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400845 struct sk_buff *skb;
Ying Xue47b4c9a2014-11-26 11:41:48 +0800846 struct tipc_msg *msg;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400847 u16 seqno = link->snd_nxt;
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400848 u16 ack = mod(link->rcv_nxt - 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100849
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400850 while (skb_queue_len(&link->transmq) < link->window) {
851 skb = __skb_dequeue(&link->backlogq);
852 if (!skb)
Ying Xue47b4c9a2014-11-26 11:41:48 +0800853 break;
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400854 TIPC_SKB_CB(skb)->ackers = link->ackers;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400855 msg = buf_msg(skb);
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400856 link->backlog[msg_importance(msg)].len--;
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400857 msg_set_ack(msg, ack);
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400858 msg_set_seqno(msg, seqno);
859 seqno = mod(seqno + 1);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400860 msg_set_bcast_ack(msg, link->owner->bclink.last_in);
861 link->rcv_unacked = 0;
862 __skb_queue_tail(&link->transmq, skb);
863 tipc_bearer_send(link->owner->net, link->bearer_id,
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400864 skb, link->media_addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100865 }
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -0400866 link->snd_nxt = seqno;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100867}
868
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400869void tipc_link_advance_backlog(struct tipc_link *l, struct sk_buff_head *xmitq)
870{
871 struct sk_buff *skb, *_skb;
872 struct tipc_msg *hdr;
873 u16 seqno = l->snd_nxt;
874 u16 ack = l->rcv_nxt - 1;
875
876 while (skb_queue_len(&l->transmq) < l->window) {
877 skb = skb_peek(&l->backlogq);
878 if (!skb)
879 break;
880 _skb = skb_clone(skb, GFP_ATOMIC);
881 if (!_skb)
882 break;
883 __skb_dequeue(&l->backlogq);
884 hdr = buf_msg(skb);
885 l->backlog[msg_importance(hdr)].len--;
886 __skb_queue_tail(&l->transmq, skb);
887 __skb_queue_tail(xmitq, _skb);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400888 TIPC_SKB_CB(skb)->ackers = l->ackers;
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400889 msg_set_ack(hdr, ack);
890 msg_set_seqno(hdr, seqno);
891 msg_set_bcast_ack(hdr, l->owner->bclink.last_in);
892 l->rcv_unacked = 0;
893 seqno++;
894 }
895 l->snd_nxt = seqno;
896}
897
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500898static void link_retransmit_failure(struct tipc_link *l_ptr,
Paul Gortmakerae8509c2013-06-17 10:54:47 -0400899 struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -0700900{
901 struct tipc_msg *msg = buf_msg(buf);
Ying Xue1da46562015-01-09 15:27:07 +0800902 struct net *net = l_ptr->owner->net;
Allan Stephensd356eeb2006-06-25 23:40:01 -0700903
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400904 pr_warn("Retransmission failure on link <%s>\n", l_ptr->name);
Allan Stephensd356eeb2006-06-25 23:40:01 -0700905
906 if (l_ptr->addr) {
Allan Stephensd356eeb2006-06-25 23:40:01 -0700907 /* Handle failure on standard link */
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -0400908 link_print(l_ptr, "Resetting link ");
909 pr_info("Failed msg: usr %u, typ %u, len %u, err %u\n",
910 msg_user(msg), msg_type(msg), msg_size(msg),
911 msg_errcode(msg));
912 pr_info("sqno %u, prev: %x, src: %x\n",
913 msg_seqno(msg), msg_prevnode(msg), msg_orignode(msg));
Allan Stephensd356eeb2006-06-25 23:40:01 -0700914 } else {
Allan Stephensd356eeb2006-06-25 23:40:01 -0700915 /* Handle failure on broadcast link */
David S. Miller6c000552008-09-02 23:38:32 -0700916 struct tipc_node *n_ptr;
Allan Stephensd356eeb2006-06-25 23:40:01 -0700917 char addr_string[16];
918
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400919 pr_info("Msg seq number: %u, ", msg_seqno(msg));
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400920 pr_cont("Outstanding acks: %u\n", TIPC_SKB_CB(buf)->ackers);
Jeff Garzik617dbea2006-10-03 16:25:34 -0700921
Ying Xue1da46562015-01-09 15:27:07 +0800922 n_ptr = tipc_bclink_retransmit_to(net);
Allan Stephensd356eeb2006-06-25 23:40:01 -0700923
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000924 tipc_addr_string_fill(addr_string, n_ptr->addr);
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400925 pr_info("Broadcast link info for %s\n", addr_string);
Ying Xue389dd9b2012-11-16 13:51:30 +0800926 pr_info("Reception permitted: %d, Acked: %u\n",
927 n_ptr->bclink.recv_permitted,
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400928 n_ptr->bclink.acked);
929 pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
930 n_ptr->bclink.last_in,
931 n_ptr->bclink.oos_state,
932 n_ptr->bclink.last_sent);
Allan Stephensd356eeb2006-06-25 23:40:01 -0700933
Ying Xueb952b2b2015-03-26 18:10:23 +0800934 n_ptr->action_flags |= TIPC_BCAST_RESET;
Allan Stephensd356eeb2006-06-25 23:40:01 -0700935 l_ptr->stale_count = 0;
936 }
937}
938
Ying Xue58dc55f2014-11-26 11:41:52 +0800939void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *skb,
Per Liden4323add2006-01-18 00:38:21 +0100940 u32 retransmits)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100941{
942 struct tipc_msg *msg;
943
Ying Xue58dc55f2014-11-26 11:41:52 +0800944 if (!skb)
Allan Stephensd356eeb2006-06-25 23:40:01 -0700945 return;
946
Ying Xue58dc55f2014-11-26 11:41:52 +0800947 msg = buf_msg(skb);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900948
Erik Hugne512137e2013-12-06 10:08:00 -0500949 /* Detect repeated retransmit failures */
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400950 if (l_ptr->last_retransm == msg_seqno(msg)) {
Erik Hugne512137e2013-12-06 10:08:00 -0500951 if (++l_ptr->stale_count > 100) {
Ying Xue58dc55f2014-11-26 11:41:52 +0800952 link_retransmit_failure(l_ptr, skb);
Erik Hugne512137e2013-12-06 10:08:00 -0500953 return;
Allan Stephensd356eeb2006-06-25 23:40:01 -0700954 }
955 } else {
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400956 l_ptr->last_retransm = msg_seqno(msg);
Erik Hugne512137e2013-12-06 10:08:00 -0500957 l_ptr->stale_count = 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100958 }
Allan Stephensd356eeb2006-06-25 23:40:01 -0700959
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -0400960 skb_queue_walk_from(&l_ptr->transmq, skb) {
961 if (!retransmits)
Ying Xue58dc55f2014-11-26 11:41:52 +0800962 break;
963 msg = buf_msg(skb);
Jon Paul Maloya97b9d32015-05-14 10:46:15 -0400964 msg_set_ack(msg, mod(l_ptr->rcv_nxt - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900965 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Ying Xue7f9f95d2015-01-09 15:27:06 +0800966 tipc_bearer_send(l_ptr->owner->net, l_ptr->bearer_id, skb,
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400967 l_ptr->media_addr);
Ying Xue3c294cb2012-11-15 11:34:45 +0800968 retransmits--;
969 l_ptr->stats.retransmitted++;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100970 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100971}
972
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400973int tipc_link_retrans(struct tipc_link *l, u16 from, u16 to,
974 struct sk_buff_head *xmitq)
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400975{
976 struct sk_buff *_skb, *skb = skb_peek(&l->transmq);
977 struct tipc_msg *hdr;
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400978 u16 ack = l->rcv_nxt - 1;
979 u16 bc_ack = l->owner->bclink.last_in;
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400980
981 if (!skb)
982 return 0;
983
984 /* Detect repeated retransmit failures on same packet */
985 if (likely(l->last_retransm != buf_seqno(skb))) {
986 l->last_retransm = buf_seqno(skb);
987 l->stale_count = 1;
988 } else if (++l->stale_count > 100) {
989 link_retransmit_failure(l, skb);
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400990 return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400991 }
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400992
993 /* Move forward to where retransmission should start */
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400994 skb_queue_walk(&l->transmq, skb) {
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400995 if (!less(buf_seqno(skb), from))
996 break;
997 }
998
999 skb_queue_walk_from(&l->transmq, skb) {
1000 if (more(buf_seqno(skb), to))
1001 break;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001002 hdr = buf_msg(skb);
1003 _skb = __pskb_copy(skb, MIN_H_SIZE, GFP_ATOMIC);
1004 if (!_skb)
1005 return 0;
1006 hdr = buf_msg(_skb);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001007 msg_set_ack(hdr, ack);
1008 msg_set_bcast_ack(hdr, bc_ack);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001009 _skb->priority = TC_PRIO_CONTROL;
1010 __skb_queue_tail(xmitq, _skb);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001011 l->stats.retransmitted++;
1012 }
1013 return 0;
1014}
1015
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001016/* tipc_data_input - deliver data and name distr msgs to upper layer
Erik Hugne7ae934b2014-07-01 10:22:40 +02001017 *
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001018 * Consumes buffer if message is of right type
Erik Hugne7ae934b2014-07-01 10:22:40 +02001019 * Node lock must be held
1020 */
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001021static bool tipc_data_input(struct tipc_link *link, struct sk_buff *skb,
1022 struct sk_buff_head *inputq)
Erik Hugne7ae934b2014-07-01 10:22:40 +02001023{
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001024 struct tipc_node *node = link->owner;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001025
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001026 switch (msg_user(buf_msg(skb))) {
Erik Hugne7ae934b2014-07-01 10:22:40 +02001027 case TIPC_LOW_IMPORTANCE:
1028 case TIPC_MEDIUM_IMPORTANCE:
1029 case TIPC_HIGH_IMPORTANCE:
1030 case TIPC_CRITICAL_IMPORTANCE:
1031 case CONN_MANAGER:
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001032 skb_queue_tail(inputq, skb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001033 return true;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001034 case NAME_DISTRIBUTOR:
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001035 node->bclink.recv_permitted = true;
Jon Paul Maloyd39bbd42015-07-16 16:54:21 -04001036 skb_queue_tail(link->namedq, skb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001037 return true;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001038 case MSG_BUNDLER:
Jon Paul Maloydff29b12015-04-02 09:33:01 -04001039 case TUNNEL_PROTOCOL:
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001040 case MSG_FRAGMENTER:
1041 case BCAST_PROTOCOL:
1042 return false;
1043 default:
1044 pr_warn("Dropping received illegal msg type\n");
1045 kfree_skb(skb);
1046 return false;
1047 };
1048}
1049
1050/* tipc_link_input - process packet that has passed link protocol check
1051 *
1052 * Consumes buffer
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001053 */
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001054static int tipc_link_input(struct tipc_link *l, struct sk_buff *skb,
1055 struct sk_buff_head *inputq)
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001056{
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001057 struct tipc_node *node = l->owner;
1058 struct tipc_msg *hdr = buf_msg(skb);
1059 struct sk_buff **reasm_skb = &l->reasm_buf;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001060 struct sk_buff *iskb;
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001061 struct sk_buff_head tmpq;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001062 int usr = msg_user(hdr);
Jon Paul Maloy6144a992015-07-30 18:24:16 -04001063 int rc = 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001064 int pos = 0;
1065 int ipos = 0;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001066
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001067 if (unlikely(usr == TUNNEL_PROTOCOL)) {
1068 if (msg_type(hdr) == SYNCH_MSG) {
1069 __skb_queue_purge(&l->deferdq);
1070 goto drop;
Jon Paul Maloy8b4ed862015-03-25 12:07:26 -04001071 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001072 if (!tipc_msg_extract(skb, &iskb, &ipos))
1073 return rc;
1074 kfree_skb(skb);
1075 skb = iskb;
1076 hdr = buf_msg(skb);
1077 if (less(msg_seqno(hdr), l->drop_point))
1078 goto drop;
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001079 if (tipc_data_input(l, skb, inputq))
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001080 return rc;
1081 usr = msg_user(hdr);
1082 reasm_skb = &l->failover_reasm_skb;
1083 }
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001084
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001085 if (usr == MSG_BUNDLER) {
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001086 skb_queue_head_init(&tmpq);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001087 l->stats.recv_bundles++;
1088 l->stats.recv_bundled += msg_msgcnt(hdr);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001089 while (tipc_msg_extract(skb, &iskb, &pos))
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001090 tipc_data_input(l, iskb, &tmpq);
1091 tipc_skb_queue_splice_tail(&tmpq, inputq);
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001092 return 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001093 } else if (usr == MSG_FRAGMENTER) {
1094 l->stats.recv_fragments++;
1095 if (tipc_buf_append(reasm_skb, &skb)) {
1096 l->stats.recv_fragmented++;
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001097 tipc_data_input(l, skb, inputq);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001098 } else if (!*reasm_skb) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001099 return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001100 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001101 return 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001102 } else if (usr == BCAST_PROTOCOL) {
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001103 tipc_link_sync_rcv(node, skb);
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001104 return 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001105 }
1106drop:
1107 kfree_skb(skb);
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001108 return 0;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001109}
1110
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001111static bool tipc_link_release_pkts(struct tipc_link *l, u16 acked)
1112{
1113 bool released = false;
1114 struct sk_buff *skb, *tmp;
1115
1116 skb_queue_walk_safe(&l->transmq, skb, tmp) {
1117 if (more(buf_seqno(skb), acked))
1118 break;
1119 __skb_unlink(skb, &l->transmq);
1120 kfree_skb(skb);
1121 released = true;
1122 }
1123 return released;
1124}
1125
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001126/* tipc_link_build_ack_msg: prepare link acknowledge message for transmission
1127 */
1128void tipc_link_build_ack_msg(struct tipc_link *l, struct sk_buff_head *xmitq)
1129{
1130 l->rcv_unacked = 0;
1131 l->stats.sent_acks++;
1132 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, 0, xmitq);
1133}
1134
Jon Paul Maloy282b3a02015-10-15 14:52:45 -04001135/* tipc_link_build_reset_msg: prepare link RESET or ACTIVATE message
1136 */
1137void tipc_link_build_reset_msg(struct tipc_link *l, struct sk_buff_head *xmitq)
1138{
1139 int mtyp = RESET_MSG;
1140
1141 if (l->state == LINK_ESTABLISHING)
1142 mtyp = ACTIVATE_MSG;
1143
1144 tipc_link_build_proto_msg(l, mtyp, 0, 0, 0, 0, xmitq);
1145}
1146
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001147/* tipc_link_build_nack_msg: prepare link nack message for transmission
1148 */
1149static void tipc_link_build_nack_msg(struct tipc_link *l,
1150 struct sk_buff_head *xmitq)
1151{
1152 u32 def_cnt = ++l->stats.deferred_recv;
1153
1154 if ((skb_queue_len(&l->deferdq) == 1) || !(def_cnt % TIPC_NACK_INTV))
1155 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, 0, xmitq);
1156}
1157
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001158/* tipc_link_rcv - process TIPC packets/messages arriving from off-node
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001159 * @l: the link that should handle the message
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001160 * @skb: TIPC packet
1161 * @xmitq: queue to place packets to be sent after this call
1162 */
1163int tipc_link_rcv(struct tipc_link *l, struct sk_buff *skb,
1164 struct sk_buff_head *xmitq)
1165{
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001166 struct sk_buff_head *defq = &l->deferdq;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001167 struct tipc_msg *hdr;
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001168 u16 seqno, rcv_nxt, win_lim;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001169 int rc = 0;
1170
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001171 do {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001172 hdr = buf_msg(skb);
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001173 seqno = msg_seqno(hdr);
1174 rcv_nxt = l->rcv_nxt;
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001175 win_lim = rcv_nxt + TIPC_MAX_LINK_WIN;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001176
1177 /* Verify and update link state */
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001178 if (unlikely(msg_user(hdr) == LINK_PROTOCOL))
1179 return tipc_link_proto_rcv(l, skb, xmitq);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001180
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001181 if (unlikely(!link_is_up(l))) {
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001182 if (l->state == LINK_ESTABLISHING)
1183 rc = TIPC_LINK_UP_EVT;
1184 goto drop;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001185 }
1186
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001187 /* Don't send probe at next timeout expiration */
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001188 l->silent_intv_cnt = 0;
1189
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001190 /* Drop if outside receive window */
1191 if (unlikely(less(seqno, rcv_nxt) || more(seqno, win_lim))) {
1192 l->stats.duplicates++;
1193 goto drop;
1194 }
1195
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001196 /* Forward queues and wake up waiting users */
1197 if (likely(tipc_link_release_pkts(l, msg_ack(hdr)))) {
1198 tipc_link_advance_backlog(l, xmitq);
1199 if (unlikely(!skb_queue_empty(&l->wakeupq)))
1200 link_prepare_wakeup(l);
1201 }
1202
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001203 /* Defer delivery if sequence gap */
1204 if (unlikely(seqno != rcv_nxt)) {
Jon Paul Maloy8306f992015-10-15 14:52:43 -04001205 __tipc_skb_queue_sorted(defq, seqno, skb);
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001206 tipc_link_build_nack_msg(l, xmitq);
1207 break;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001208 }
1209
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001210 /* Deliver packet */
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001211 l->rcv_nxt++;
1212 l->stats.recv_info++;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001213 if (!tipc_data_input(l, skb, l->inputq))
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001214 rc = tipc_link_input(l, skb, l->inputq);
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001215 if (unlikely(rc))
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001216 break;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001217 if (unlikely(++l->rcv_unacked >= TIPC_MIN_LINK_WIN))
1218 tipc_link_build_ack_msg(l, xmitq);
1219
1220 } while ((skb = __skb_dequeue(defq)));
1221
1222 return rc;
1223drop:
1224 kfree_skb(skb);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001225 return rc;
1226}
1227
Erik Hugne7ae934b2014-07-01 10:22:40 +02001228/**
Allan Stephens8809b252011-10-25 10:44:35 -04001229 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
1230 *
1231 * Returns increase in queue length (i.e. 0 or 1)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001232 */
Ying Xuebc6fecd2014-11-26 11:41:53 +08001233u32 tipc_link_defer_pkt(struct sk_buff_head *list, struct sk_buff *skb)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001234{
Ying Xuebc6fecd2014-11-26 11:41:53 +08001235 struct sk_buff *skb1;
Jon Paul Maloye4bf4f72015-05-14 10:46:14 -04001236 u16 seq_no = buf_seqno(skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001237
1238 /* Empty queue ? */
Ying Xuebc6fecd2014-11-26 11:41:53 +08001239 if (skb_queue_empty(list)) {
1240 __skb_queue_tail(list, skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001241 return 1;
1242 }
1243
1244 /* Last ? */
Ying Xuebc6fecd2014-11-26 11:41:53 +08001245 if (less(buf_seqno(skb_peek_tail(list)), seq_no)) {
1246 __skb_queue_tail(list, skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001247 return 1;
1248 }
1249
Allan Stephens8809b252011-10-25 10:44:35 -04001250 /* Locate insertion point in queue, then insert; discard if duplicate */
Ying Xuebc6fecd2014-11-26 11:41:53 +08001251 skb_queue_walk(list, skb1) {
Jon Paul Maloye4bf4f72015-05-14 10:46:14 -04001252 u16 curr_seqno = buf_seqno(skb1);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001253
Allan Stephens8809b252011-10-25 10:44:35 -04001254 if (seq_no == curr_seqno) {
Ying Xuebc6fecd2014-11-26 11:41:53 +08001255 kfree_skb(skb);
Allan Stephens8809b252011-10-25 10:44:35 -04001256 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001257 }
Allan Stephens8809b252011-10-25 10:44:35 -04001258
1259 if (less(seq_no, curr_seqno))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001260 break;
Allan Stephens8809b252011-10-25 10:44:35 -04001261 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001262
Ying Xuebc6fecd2014-11-26 11:41:53 +08001263 __skb_queue_before(list, skb1, skb);
Allan Stephens8809b252011-10-25 10:44:35 -04001264 return 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001265}
1266
Allan Stephens8809b252011-10-25 10:44:35 -04001267/*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001268 * Send protocol message to the other endpoint.
1269 */
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001270void tipc_link_proto_xmit(struct tipc_link *l, u32 msg_typ, int probe_msg,
Jon Paul Maloyed193ec2015-04-02 09:33:02 -04001271 u32 gap, u32 tolerance, u32 priority)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001272{
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001273 struct sk_buff *skb = NULL;
1274 struct sk_buff_head xmitq;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001275
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001276 __skb_queue_head_init(&xmitq);
1277 tipc_link_build_proto_msg(l, msg_typ, probe_msg, gap,
1278 tolerance, priority, &xmitq);
1279 skb = __skb_dequeue(&xmitq);
1280 if (!skb)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001281 return;
Jon Paul Maloy440d8962015-07-30 18:24:26 -04001282 tipc_bearer_send(l->owner->net, l->bearer_id, skb, l->media_addr);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001283 l->rcv_unacked = 0;
1284 kfree_skb(skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001285}
1286
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001287/* tipc_link_build_proto_msg: prepare link protocol message for transmission
1288 */
1289static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
1290 u16 rcvgap, int tolerance, int priority,
1291 struct sk_buff_head *xmitq)
1292{
1293 struct sk_buff *skb = NULL;
1294 struct tipc_msg *hdr = l->pmsg;
1295 u16 snd_nxt = l->snd_nxt;
1296 u16 rcv_nxt = l->rcv_nxt;
1297 u16 rcv_last = rcv_nxt - 1;
1298 int node_up = l->owner->bclink.recv_permitted;
1299
1300 /* Don't send protocol message during reset or link failover */
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001301 if (tipc_link_is_blocked(l))
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001302 return;
1303
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001304 msg_set_type(hdr, mtyp);
1305 msg_set_net_plane(hdr, l->net_plane);
1306 msg_set_bcast_ack(hdr, l->owner->bclink.last_in);
1307 msg_set_last_bcast(hdr, tipc_bclink_get_last_sent(l->owner->net));
1308 msg_set_link_tolerance(hdr, tolerance);
1309 msg_set_linkprio(hdr, priority);
1310 msg_set_redundant_link(hdr, node_up);
1311 msg_set_seq_gap(hdr, 0);
1312
1313 /* Compatibility: created msg must not be in sequence with pkt flow */
1314 msg_set_seqno(hdr, snd_nxt + U16_MAX / 2);
1315
1316 if (mtyp == STATE_MSG) {
1317 if (!tipc_link_is_up(l))
1318 return;
1319 msg_set_next_sent(hdr, snd_nxt);
1320
1321 /* Override rcvgap if there are packets in deferred queue */
1322 if (!skb_queue_empty(&l->deferdq))
1323 rcvgap = buf_seqno(skb_peek(&l->deferdq)) - rcv_nxt;
1324 if (rcvgap) {
1325 msg_set_seq_gap(hdr, rcvgap);
1326 l->stats.sent_nacks++;
1327 }
1328 msg_set_ack(hdr, rcv_last);
1329 msg_set_probe(hdr, probe);
1330 if (probe)
1331 l->stats.sent_probes++;
1332 l->stats.sent_states++;
1333 } else {
1334 /* RESET_MSG or ACTIVATE_MSG */
1335 msg_set_max_pkt(hdr, l->advertised_mtu);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001336 msg_set_ack(hdr, l->rcv_nxt - 1);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001337 msg_set_next_sent(hdr, 1);
1338 }
1339 skb = tipc_buf_acquire(msg_size(hdr));
1340 if (!skb)
1341 return;
1342 skb_copy_to_linear_data(skb, hdr, msg_size(hdr));
1343 skb->priority = TC_PRIO_CONTROL;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001344 __skb_queue_tail(xmitq, skb);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001345}
Per Lidenb97bf3f2006-01-02 19:04:38 +01001346
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001347/* tipc_link_tnl_prepare(): prepare and return a list of tunnel packets
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001348 * with contents of the link's transmit and backlog queues.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001349 */
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001350void tipc_link_tnl_prepare(struct tipc_link *l, struct tipc_link *tnl,
1351 int mtyp, struct sk_buff_head *xmitq)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001352{
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001353 struct sk_buff *skb, *tnlskb;
1354 struct tipc_msg *hdr, tnlhdr;
1355 struct sk_buff_head *queue = &l->transmq;
1356 struct sk_buff_head tmpxq, tnlq;
1357 u16 pktlen, pktcnt, seqno = l->snd_nxt;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001358
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001359 if (!tnl)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001360 return;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001361
1362 skb_queue_head_init(&tnlq);
1363 skb_queue_head_init(&tmpxq);
1364
1365 /* At least one packet required for safe algorithm => add dummy */
1366 skb = tipc_msg_create(TIPC_LOW_IMPORTANCE, TIPC_DIRECT_MSG,
1367 BASIC_H_SIZE, 0, l->addr, link_own_addr(l),
1368 0, 0, TIPC_ERR_NO_PORT);
Ying Xuea6ca1092014-11-26 11:41:55 +08001369 if (!skb) {
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001370 pr_warn("%sunable to create tunnel packet\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001371 return;
Allan Stephens5392d642006-06-25 23:52:50 -07001372 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001373 skb_queue_tail(&tnlq, skb);
1374 tipc_link_xmit(l, &tnlq, &tmpxq);
1375 __skb_queue_purge(&tmpxq);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001376
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001377 /* Initialize reusable tunnel packet header */
1378 tipc_msg_init(link_own_addr(l), &tnlhdr, TUNNEL_PROTOCOL,
1379 mtyp, INT_H_SIZE, l->addr);
1380 pktcnt = skb_queue_len(&l->transmq) + skb_queue_len(&l->backlogq);
1381 msg_set_msgcnt(&tnlhdr, pktcnt);
1382 msg_set_bearer_id(&tnlhdr, l->peer_bearer_id);
1383tnl:
1384 /* Wrap each packet into a tunnel packet */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -04001385 skb_queue_walk(queue, skb) {
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001386 hdr = buf_msg(skb);
1387 if (queue == &l->backlogq)
1388 msg_set_seqno(hdr, seqno++);
1389 pktlen = msg_size(hdr);
1390 msg_set_size(&tnlhdr, pktlen + INT_H_SIZE);
1391 tnlskb = tipc_buf_acquire(pktlen + INT_H_SIZE);
1392 if (!tnlskb) {
1393 pr_warn("%sunable to send packet\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001394 return;
1395 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001396 skb_copy_to_linear_data(tnlskb, &tnlhdr, INT_H_SIZE);
1397 skb_copy_to_linear_data_offset(tnlskb, INT_H_SIZE, hdr, pktlen);
1398 __skb_queue_tail(&tnlq, tnlskb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001399 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001400 if (queue != &l->backlogq) {
1401 queue = &l->backlogq;
1402 goto tnl;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -04001403 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001404
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001405 tipc_link_xmit(tnl, &tnlq, xmitq);
Jon Paul Maloyf006c9c2014-02-13 17:29:11 -05001406
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001407 if (mtyp == FAILOVER_MSG) {
1408 tnl->drop_point = l->rcv_nxt;
1409 tnl->failover_reasm_skb = l->reasm_buf;
1410 l->reasm_buf = NULL;
Jon Paul Maloyf006c9c2014-02-13 17:29:11 -05001411 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001412}
1413
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001414/* tipc_link_proto_rcv(): receive link level protocol message :
1415 * Note that network plane id propagates through the network, and may
1416 * change at any time. The node with lowest numerical id determines
1417 * network plane
1418 */
1419static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
1420 struct sk_buff_head *xmitq)
1421{
1422 struct tipc_msg *hdr = buf_msg(skb);
1423 u16 rcvgap = 0;
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001424 u16 ack = msg_ack(hdr);
1425 u16 gap = msg_seq_gap(hdr);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001426 u16 peers_snd_nxt = msg_next_sent(hdr);
1427 u16 peers_tol = msg_link_tolerance(hdr);
1428 u16 peers_prio = msg_linkprio(hdr);
Jon Paul Maloy2be80c22015-08-20 02:12:56 -04001429 u16 rcv_nxt = l->rcv_nxt;
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001430 int mtyp = msg_type(hdr);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001431 char *if_name;
1432 int rc = 0;
1433
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001434 if (tipc_link_is_blocked(l))
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001435 goto exit;
1436
1437 if (link_own_addr(l) > msg_prevnode(hdr))
1438 l->net_plane = msg_net_plane(hdr);
1439
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001440 switch (mtyp) {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001441 case RESET_MSG:
1442
1443 /* Ignore duplicate RESET with old session number */
1444 if ((less_eq(msg_session(hdr), l->peer_session)) &&
1445 (l->peer_session != WILDCARD_SESSION))
1446 break;
1447 /* fall thru' */
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001448
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001449 case ACTIVATE_MSG:
1450
1451 /* Complete own link name with peer's interface name */
1452 if_name = strrchr(l->name, ':') + 1;
1453 if (sizeof(l->name) - (if_name - l->name) <= TIPC_MAX_IF_NAME)
1454 break;
1455 if (msg_data_sz(hdr) < TIPC_MAX_IF_NAME)
1456 break;
1457 strncpy(if_name, msg_data(hdr), TIPC_MAX_IF_NAME);
1458
1459 /* Update own tolerance if peer indicates a non-zero value */
1460 if (in_range(peers_tol, TIPC_MIN_LINK_TOL, TIPC_MAX_LINK_TOL))
1461 l->tolerance = peers_tol;
1462
1463 /* Update own priority if peer's priority is higher */
1464 if (in_range(peers_prio, l->priority + 1, TIPC_MAX_LINK_PRI))
1465 l->priority = peers_prio;
1466
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001467 /* ACTIVATE_MSG serves as PEER_RESET if link is already down */
1468 if ((mtyp == RESET_MSG) || !link_is_up(l))
1469 rc = tipc_link_fsm_evt(l, LINK_PEER_RESET_EVT);
1470
1471 /* ACTIVATE_MSG takes up link if it was already locally reset */
1472 if ((mtyp == ACTIVATE_MSG) && (l->state == LINK_ESTABLISHING))
1473 rc = TIPC_LINK_UP_EVT;
1474
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001475 l->peer_session = msg_session(hdr);
1476 l->peer_bearer_id = msg_bearer_id(hdr);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001477 if (l->mtu > msg_max_pkt(hdr))
1478 l->mtu = msg_max_pkt(hdr);
1479 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001480
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001481 case STATE_MSG:
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001482
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001483 /* Update own tolerance if peer indicates a non-zero value */
1484 if (in_range(peers_tol, TIPC_MIN_LINK_TOL, TIPC_MAX_LINK_TOL))
1485 l->tolerance = peers_tol;
1486
1487 l->silent_intv_cnt = 0;
1488 l->stats.recv_states++;
1489 if (msg_probe(hdr))
1490 l->stats.recv_probes++;
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001491
1492 if (!link_is_up(l)) {
1493 if (l->state == LINK_ESTABLISHING)
1494 rc = TIPC_LINK_UP_EVT;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001495 break;
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001496 }
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001497
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001498 /* Send NACK if peer has sent pkts we haven't received yet */
Jon Paul Maloy2be80c22015-08-20 02:12:56 -04001499 if (more(peers_snd_nxt, rcv_nxt) && !tipc_link_is_synching(l))
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001500 rcvgap = peers_snd_nxt - l->rcv_nxt;
1501 if (rcvgap || (msg_probe(hdr)))
1502 tipc_link_build_proto_msg(l, STATE_MSG, 0, rcvgap,
Jon Paul Maloy16040892015-07-21 06:42:28 -04001503 0, 0, xmitq);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001504 tipc_link_release_pkts(l, ack);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001505
1506 /* If NACK, retransmit will now start at right position */
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001507 if (gap) {
1508 rc = tipc_link_retrans(l, ack + 1, ack + gap, xmitq);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001509 l->stats.recv_nacks++;
1510 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001511
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001512 tipc_link_advance_backlog(l, xmitq);
1513 if (unlikely(!skb_queue_empty(&l->wakeupq)))
1514 link_prepare_wakeup(l);
1515 }
1516exit:
1517 kfree_skb(skb);
1518 return rc;
1519}
1520
Jon Paul Maloye3eea1e2015-03-13 16:08:11 -04001521void tipc_link_set_queue_limits(struct tipc_link *l, u32 win)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001522{
Jon Paul Maloyed193ec2015-04-02 09:33:02 -04001523 int max_bulk = TIPC_MAX_PUBLICATIONS / (l->mtu / ITEM_SIZE);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -04001524
Jon Paul Maloye3eea1e2015-03-13 16:08:11 -04001525 l->window = win;
Jon Paul Maloy1f66d162015-03-25 12:07:24 -04001526 l->backlog[TIPC_LOW_IMPORTANCE].limit = win / 2;
1527 l->backlog[TIPC_MEDIUM_IMPORTANCE].limit = win;
1528 l->backlog[TIPC_HIGH_IMPORTANCE].limit = win / 2 * 3;
1529 l->backlog[TIPC_CRITICAL_IMPORTANCE].limit = win * 2;
1530 l->backlog[TIPC_SYSTEM_IMPORTANCE].limit = max_bulk;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001531}
1532
Jon Paul Maloye099e862014-02-13 17:29:18 -05001533/* tipc_link_find_owner - locate owner node of link by link's name
Ying Xuef2f98002015-01-09 15:27:05 +08001534 * @net: the applicable net namespace
Jon Paul Maloye099e862014-02-13 17:29:18 -05001535 * @name: pointer to link name string
1536 * @bearer_id: pointer to index in 'node->links' array where the link was found.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001537 *
Jon Paul Maloye099e862014-02-13 17:29:18 -05001538 * Returns pointer to node owning the link, or 0 if no matching link is found.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001539 */
Ying Xuef2f98002015-01-09 15:27:05 +08001540static struct tipc_node *tipc_link_find_owner(struct net *net,
1541 const char *link_name,
Jon Paul Maloye099e862014-02-13 17:29:18 -05001542 unsigned int *bearer_id)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001543{
Ying Xuef2f98002015-01-09 15:27:05 +08001544 struct tipc_net *tn = net_generic(net, tipc_net_id);
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001545 struct tipc_link *l_ptr;
Erik Hugnebbfbe472013-10-18 07:23:21 +02001546 struct tipc_node *n_ptr;
Fabian Frederick886eaa12014-12-25 12:05:50 +01001547 struct tipc_node *found_node = NULL;
Erik Hugnebbfbe472013-10-18 07:23:21 +02001548 int i;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001549
Jon Paul Maloye099e862014-02-13 17:29:18 -05001550 *bearer_id = 0;
Ying Xue6c7a7622014-03-27 12:54:37 +08001551 rcu_read_lock();
Ying Xuef2f98002015-01-09 15:27:05 +08001552 list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
Jon Paul Maloya11607f2014-02-14 16:40:44 -05001553 tipc_node_lock(n_ptr);
Erik Hugnebbfbe472013-10-18 07:23:21 +02001554 for (i = 0; i < MAX_BEARERS; i++) {
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -04001555 l_ptr = n_ptr->links[i].link;
Jon Paul Maloye099e862014-02-13 17:29:18 -05001556 if (l_ptr && !strcmp(l_ptr->name, link_name)) {
1557 *bearer_id = i;
1558 found_node = n_ptr;
1559 break;
1560 }
Erik Hugnebbfbe472013-10-18 07:23:21 +02001561 }
Jon Paul Maloya11607f2014-02-14 16:40:44 -05001562 tipc_node_unlock(n_ptr);
Jon Paul Maloye099e862014-02-13 17:29:18 -05001563 if (found_node)
1564 break;
Erik Hugnebbfbe472013-10-18 07:23:21 +02001565 }
Ying Xue6c7a7622014-03-27 12:54:37 +08001566 rcu_read_unlock();
1567
Jon Paul Maloye099e862014-02-13 17:29:18 -05001568 return found_node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001569}
1570
Allan Stephens5c216e12011-10-18 11:34:29 -04001571/**
Per Lidenb97bf3f2006-01-02 19:04:38 +01001572 * link_reset_statistics - reset link statistics
1573 * @l_ptr: pointer to link
1574 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001575static void link_reset_statistics(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001576{
1577 memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));
Jon Paul Maloya97b9d32015-05-14 10:46:15 -04001578 l_ptr->stats.sent_info = l_ptr->snd_nxt;
1579 l_ptr->stats.recv_info = l_ptr->rcv_nxt;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001580}
1581
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04001582static void link_print(struct tipc_link *l, const char *str)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001583{
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04001584 struct sk_buff *hskb = skb_peek(&l->transmq);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001585 u16 head = hskb ? msg_seqno(buf_msg(hskb)) : l->snd_nxt - 1;
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04001586 u16 tail = l->snd_nxt - 1;
Ying Xue7a2f7d12014-04-21 10:55:46 +08001587
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001588 pr_info("%s Link <%s> state %x\n", str, l->name, l->state);
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04001589 pr_info("XMTQ: %u [%u-%u], BKLGQ: %u, SNDNX: %u, RCVNX: %u\n",
1590 skb_queue_len(&l->transmq), head, tail,
1591 skb_queue_len(&l->backlogq), l->snd_nxt, l->rcv_nxt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001592}
Richard Alpe0655f6a2014-11-20 10:29:07 +01001593
1594/* Parse and validate nested (link) properties valid for media, bearer and link
1595 */
1596int tipc_nl_parse_link_prop(struct nlattr *prop, struct nlattr *props[])
1597{
1598 int err;
1599
1600 err = nla_parse_nested(props, TIPC_NLA_PROP_MAX, prop,
1601 tipc_nl_prop_policy);
1602 if (err)
1603 return err;
1604
1605 if (props[TIPC_NLA_PROP_PRIO]) {
1606 u32 prio;
1607
1608 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1609 if (prio > TIPC_MAX_LINK_PRI)
1610 return -EINVAL;
1611 }
1612
1613 if (props[TIPC_NLA_PROP_TOL]) {
1614 u32 tol;
1615
1616 tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1617 if ((tol < TIPC_MIN_LINK_TOL) || (tol > TIPC_MAX_LINK_TOL))
1618 return -EINVAL;
1619 }
1620
1621 if (props[TIPC_NLA_PROP_WIN]) {
1622 u32 win;
1623
1624 win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1625 if ((win < TIPC_MIN_LINK_WIN) || (win > TIPC_MAX_LINK_WIN))
1626 return -EINVAL;
1627 }
1628
1629 return 0;
1630}
Richard Alpe7be57fc2014-11-20 10:29:12 +01001631
Richard Alpef96ce7a2014-11-20 10:29:13 +01001632int tipc_nl_link_set(struct sk_buff *skb, struct genl_info *info)
1633{
1634 int err;
1635 int res = 0;
1636 int bearer_id;
1637 char *name;
1638 struct tipc_link *link;
1639 struct tipc_node *node;
1640 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
Richard Alpe37e2d482015-02-09 09:50:08 +01001641 struct net *net = sock_net(skb->sk);
Richard Alpef96ce7a2014-11-20 10:29:13 +01001642
1643 if (!info->attrs[TIPC_NLA_LINK])
1644 return -EINVAL;
1645
1646 err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
1647 info->attrs[TIPC_NLA_LINK],
1648 tipc_nl_link_policy);
1649 if (err)
1650 return err;
1651
1652 if (!attrs[TIPC_NLA_LINK_NAME])
1653 return -EINVAL;
1654
1655 name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
1656
Richard Alpe670f4f82015-05-06 13:58:55 +02001657 if (strcmp(name, tipc_bclink_name) == 0)
1658 return tipc_nl_bc_link_set(net, attrs);
1659
Ying Xuef2f98002015-01-09 15:27:05 +08001660 node = tipc_link_find_owner(net, name, &bearer_id);
Richard Alpef96ce7a2014-11-20 10:29:13 +01001661 if (!node)
1662 return -EINVAL;
1663
1664 tipc_node_lock(node);
1665
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -04001666 link = node->links[bearer_id].link;
Richard Alpef96ce7a2014-11-20 10:29:13 +01001667 if (!link) {
1668 res = -EINVAL;
1669 goto out;
1670 }
1671
1672 if (attrs[TIPC_NLA_LINK_PROP]) {
1673 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1674
1675 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP],
1676 props);
1677 if (err) {
1678 res = err;
1679 goto out;
1680 }
1681
1682 if (props[TIPC_NLA_PROP_TOL]) {
1683 u32 tol;
1684
1685 tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
Jon Paul Maloy8a1577c2015-07-16 16:54:29 -04001686 link->tolerance = tol;
Jon Paul Maloyed193ec2015-04-02 09:33:02 -04001687 tipc_link_proto_xmit(link, STATE_MSG, 0, 0, tol, 0);
Richard Alpef96ce7a2014-11-20 10:29:13 +01001688 }
1689 if (props[TIPC_NLA_PROP_PRIO]) {
1690 u32 prio;
1691
1692 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1693 link->priority = prio;
Jon Paul Maloyed193ec2015-04-02 09:33:02 -04001694 tipc_link_proto_xmit(link, STATE_MSG, 0, 0, 0, prio);
Richard Alpef96ce7a2014-11-20 10:29:13 +01001695 }
1696 if (props[TIPC_NLA_PROP_WIN]) {
1697 u32 win;
1698
1699 win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1700 tipc_link_set_queue_limits(link, win);
1701 }
1702 }
1703
1704out:
1705 tipc_node_unlock(node);
1706
1707 return res;
1708}
Richard Alped8182802014-11-24 11:10:29 +01001709
1710static int __tipc_nl_add_stats(struct sk_buff *skb, struct tipc_stats *s)
Richard Alpe7be57fc2014-11-20 10:29:12 +01001711{
1712 int i;
1713 struct nlattr *stats;
1714
1715 struct nla_map {
1716 u32 key;
1717 u32 val;
1718 };
1719
1720 struct nla_map map[] = {
1721 {TIPC_NLA_STATS_RX_INFO, s->recv_info},
1722 {TIPC_NLA_STATS_RX_FRAGMENTS, s->recv_fragments},
1723 {TIPC_NLA_STATS_RX_FRAGMENTED, s->recv_fragmented},
1724 {TIPC_NLA_STATS_RX_BUNDLES, s->recv_bundles},
1725 {TIPC_NLA_STATS_RX_BUNDLED, s->recv_bundled},
1726 {TIPC_NLA_STATS_TX_INFO, s->sent_info},
1727 {TIPC_NLA_STATS_TX_FRAGMENTS, s->sent_fragments},
1728 {TIPC_NLA_STATS_TX_FRAGMENTED, s->sent_fragmented},
1729 {TIPC_NLA_STATS_TX_BUNDLES, s->sent_bundles},
1730 {TIPC_NLA_STATS_TX_BUNDLED, s->sent_bundled},
1731 {TIPC_NLA_STATS_MSG_PROF_TOT, (s->msg_length_counts) ?
1732 s->msg_length_counts : 1},
1733 {TIPC_NLA_STATS_MSG_LEN_CNT, s->msg_length_counts},
1734 {TIPC_NLA_STATS_MSG_LEN_TOT, s->msg_lengths_total},
1735 {TIPC_NLA_STATS_MSG_LEN_P0, s->msg_length_profile[0]},
1736 {TIPC_NLA_STATS_MSG_LEN_P1, s->msg_length_profile[1]},
1737 {TIPC_NLA_STATS_MSG_LEN_P2, s->msg_length_profile[2]},
1738 {TIPC_NLA_STATS_MSG_LEN_P3, s->msg_length_profile[3]},
1739 {TIPC_NLA_STATS_MSG_LEN_P4, s->msg_length_profile[4]},
1740 {TIPC_NLA_STATS_MSG_LEN_P5, s->msg_length_profile[5]},
1741 {TIPC_NLA_STATS_MSG_LEN_P6, s->msg_length_profile[6]},
1742 {TIPC_NLA_STATS_RX_STATES, s->recv_states},
1743 {TIPC_NLA_STATS_RX_PROBES, s->recv_probes},
1744 {TIPC_NLA_STATS_RX_NACKS, s->recv_nacks},
1745 {TIPC_NLA_STATS_RX_DEFERRED, s->deferred_recv},
1746 {TIPC_NLA_STATS_TX_STATES, s->sent_states},
1747 {TIPC_NLA_STATS_TX_PROBES, s->sent_probes},
1748 {TIPC_NLA_STATS_TX_NACKS, s->sent_nacks},
1749 {TIPC_NLA_STATS_TX_ACKS, s->sent_acks},
1750 {TIPC_NLA_STATS_RETRANSMITTED, s->retransmitted},
1751 {TIPC_NLA_STATS_DUPLICATES, s->duplicates},
1752 {TIPC_NLA_STATS_LINK_CONGS, s->link_congs},
1753 {TIPC_NLA_STATS_MAX_QUEUE, s->max_queue_sz},
1754 {TIPC_NLA_STATS_AVG_QUEUE, s->queue_sz_counts ?
1755 (s->accu_queue_sz / s->queue_sz_counts) : 0}
1756 };
1757
1758 stats = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
1759 if (!stats)
1760 return -EMSGSIZE;
1761
1762 for (i = 0; i < ARRAY_SIZE(map); i++)
1763 if (nla_put_u32(skb, map[i].key, map[i].val))
1764 goto msg_full;
1765
1766 nla_nest_end(skb, stats);
1767
1768 return 0;
1769msg_full:
1770 nla_nest_cancel(skb, stats);
1771
1772 return -EMSGSIZE;
1773}
1774
1775/* Caller should hold appropriate locks to protect the link */
Ying Xue34747532015-01-09 15:27:10 +08001776static int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,
Nicolas Dichtelf2f67392015-04-28 18:33:50 +02001777 struct tipc_link *link, int nlflags)
Richard Alpe7be57fc2014-11-20 10:29:12 +01001778{
1779 int err;
1780 void *hdr;
1781 struct nlattr *attrs;
1782 struct nlattr *prop;
Ying Xue34747532015-01-09 15:27:10 +08001783 struct tipc_net *tn = net_generic(net, tipc_net_id);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001784
Richard Alpebfb3e5d2015-02-09 09:50:03 +01001785 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
Nicolas Dichtelf2f67392015-04-28 18:33:50 +02001786 nlflags, TIPC_NL_LINK_GET);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001787 if (!hdr)
1788 return -EMSGSIZE;
1789
1790 attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
1791 if (!attrs)
1792 goto msg_full;
1793
1794 if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, link->name))
1795 goto attr_msg_full;
1796 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_DEST,
Ying Xue34747532015-01-09 15:27:10 +08001797 tipc_cluster_mask(tn->own_addr)))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001798 goto attr_msg_full;
Jon Paul Maloyed193ec2015-04-02 09:33:02 -04001799 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_MTU, link->mtu))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001800 goto attr_msg_full;
Jon Paul Maloya97b9d32015-05-14 10:46:15 -04001801 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, link->rcv_nxt))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001802 goto attr_msg_full;
Jon Paul Maloya97b9d32015-05-14 10:46:15 -04001803 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, link->snd_nxt))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001804 goto attr_msg_full;
1805
1806 if (tipc_link_is_up(link))
1807 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
1808 goto attr_msg_full;
1809 if (tipc_link_is_active(link))
1810 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_ACTIVE))
1811 goto attr_msg_full;
1812
1813 prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
1814 if (!prop)
1815 goto attr_msg_full;
1816 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
1817 goto prop_msg_full;
1818 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, link->tolerance))
1819 goto prop_msg_full;
1820 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN,
Jon Paul Maloy1f66d162015-03-25 12:07:24 -04001821 link->window))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001822 goto prop_msg_full;
1823 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
1824 goto prop_msg_full;
1825 nla_nest_end(msg->skb, prop);
1826
1827 err = __tipc_nl_add_stats(msg->skb, &link->stats);
1828 if (err)
1829 goto attr_msg_full;
1830
1831 nla_nest_end(msg->skb, attrs);
1832 genlmsg_end(msg->skb, hdr);
1833
1834 return 0;
1835
1836prop_msg_full:
1837 nla_nest_cancel(msg->skb, prop);
1838attr_msg_full:
1839 nla_nest_cancel(msg->skb, attrs);
1840msg_full:
1841 genlmsg_cancel(msg->skb, hdr);
1842
1843 return -EMSGSIZE;
1844}
1845
1846/* Caller should hold node lock */
Ying Xue34747532015-01-09 15:27:10 +08001847static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg,
1848 struct tipc_node *node, u32 *prev_link)
Richard Alpe7be57fc2014-11-20 10:29:12 +01001849{
1850 u32 i;
1851 int err;
1852
1853 for (i = *prev_link; i < MAX_BEARERS; i++) {
1854 *prev_link = i;
1855
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -04001856 if (!node->links[i].link)
Richard Alpe7be57fc2014-11-20 10:29:12 +01001857 continue;
1858
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -04001859 err = __tipc_nl_add_link(net, msg,
1860 node->links[i].link, NLM_F_MULTI);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001861 if (err)
1862 return err;
1863 }
1864 *prev_link = 0;
1865
1866 return 0;
1867}
1868
1869int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb)
1870{
Ying Xuef2f98002015-01-09 15:27:05 +08001871 struct net *net = sock_net(skb->sk);
1872 struct tipc_net *tn = net_generic(net, tipc_net_id);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001873 struct tipc_node *node;
1874 struct tipc_nl_msg msg;
1875 u32 prev_node = cb->args[0];
1876 u32 prev_link = cb->args[1];
1877 int done = cb->args[2];
1878 int err;
1879
1880 if (done)
1881 return 0;
1882
1883 msg.skb = skb;
1884 msg.portid = NETLINK_CB(cb->skb).portid;
1885 msg.seq = cb->nlh->nlmsg_seq;
1886
1887 rcu_read_lock();
Richard Alpe7be57fc2014-11-20 10:29:12 +01001888 if (prev_node) {
Ying Xuef2f98002015-01-09 15:27:05 +08001889 node = tipc_node_find(net, prev_node);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001890 if (!node) {
1891 /* We never set seq or call nl_dump_check_consistent()
1892 * this means that setting prev_seq here will cause the
1893 * consistence check to fail in the netlink callback
1894 * handler. Resulting in the last NLMSG_DONE message
1895 * having the NLM_F_DUMP_INTR flag set.
1896 */
1897 cb->prev_seq = 1;
1898 goto out;
1899 }
Ying Xue8a0f6eb2015-03-26 18:10:24 +08001900 tipc_node_put(node);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001901
Ying Xuef2f98002015-01-09 15:27:05 +08001902 list_for_each_entry_continue_rcu(node, &tn->node_list,
1903 list) {
Richard Alpe7be57fc2014-11-20 10:29:12 +01001904 tipc_node_lock(node);
Ying Xue34747532015-01-09 15:27:10 +08001905 err = __tipc_nl_add_node_links(net, &msg, node,
1906 &prev_link);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001907 tipc_node_unlock(node);
1908 if (err)
1909 goto out;
1910
1911 prev_node = node->addr;
1912 }
1913 } else {
Ying Xue1da46562015-01-09 15:27:07 +08001914 err = tipc_nl_add_bc_link(net, &msg);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001915 if (err)
1916 goto out;
1917
Ying Xuef2f98002015-01-09 15:27:05 +08001918 list_for_each_entry_rcu(node, &tn->node_list, list) {
Richard Alpe7be57fc2014-11-20 10:29:12 +01001919 tipc_node_lock(node);
Ying Xue34747532015-01-09 15:27:10 +08001920 err = __tipc_nl_add_node_links(net, &msg, node,
1921 &prev_link);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001922 tipc_node_unlock(node);
1923 if (err)
1924 goto out;
1925
1926 prev_node = node->addr;
1927 }
1928 }
1929 done = 1;
1930out:
1931 rcu_read_unlock();
1932
1933 cb->args[0] = prev_node;
1934 cb->args[1] = prev_link;
1935 cb->args[2] = done;
1936
1937 return skb->len;
1938}
1939
1940int tipc_nl_link_get(struct sk_buff *skb, struct genl_info *info)
1941{
Ying Xuef2f98002015-01-09 15:27:05 +08001942 struct net *net = genl_info_net(info);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001943 struct tipc_nl_msg msg;
Richard Alpe7be57fc2014-11-20 10:29:12 +01001944 char *name;
Richard Alpe7be57fc2014-11-20 10:29:12 +01001945 int err;
1946
Richard Alpe7be57fc2014-11-20 10:29:12 +01001947 msg.portid = info->snd_portid;
1948 msg.seq = info->snd_seq;
1949
Richard Alpe670f4f82015-05-06 13:58:55 +02001950 if (!info->attrs[TIPC_NLA_LINK_NAME])
1951 return -EINVAL;
1952 name = nla_data(info->attrs[TIPC_NLA_LINK_NAME]);
1953
1954 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1955 if (!msg.skb)
1956 return -ENOMEM;
1957
1958 if (strcmp(name, tipc_bclink_name) == 0) {
1959 err = tipc_nl_add_bc_link(net, &msg);
1960 if (err) {
1961 nlmsg_free(msg.skb);
1962 return err;
1963 }
1964 } else {
1965 int bearer_id;
1966 struct tipc_node *node;
1967 struct tipc_link *link;
1968
1969 node = tipc_link_find_owner(net, name, &bearer_id);
1970 if (!node)
1971 return -EINVAL;
1972
1973 tipc_node_lock(node);
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -04001974 link = node->links[bearer_id].link;
Richard Alpe670f4f82015-05-06 13:58:55 +02001975 if (!link) {
1976 tipc_node_unlock(node);
1977 nlmsg_free(msg.skb);
1978 return -EINVAL;
1979 }
1980
1981 err = __tipc_nl_add_link(net, &msg, link, 0);
1982 tipc_node_unlock(node);
1983 if (err) {
1984 nlmsg_free(msg.skb);
1985 return err;
1986 }
Richard Alpe7be57fc2014-11-20 10:29:12 +01001987 }
1988
Richard Alpe670f4f82015-05-06 13:58:55 +02001989 return genlmsg_reply(msg.skb, info);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001990}
Richard Alpeae363422014-11-20 10:29:14 +01001991
1992int tipc_nl_link_reset_stats(struct sk_buff *skb, struct genl_info *info)
1993{
1994 int err;
1995 char *link_name;
1996 unsigned int bearer_id;
1997 struct tipc_link *link;
1998 struct tipc_node *node;
1999 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
Richard Alpe18178772015-02-09 09:50:09 +01002000 struct net *net = sock_net(skb->sk);
Richard Alpeae363422014-11-20 10:29:14 +01002001
2002 if (!info->attrs[TIPC_NLA_LINK])
2003 return -EINVAL;
2004
2005 err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
2006 info->attrs[TIPC_NLA_LINK],
2007 tipc_nl_link_policy);
2008 if (err)
2009 return err;
2010
2011 if (!attrs[TIPC_NLA_LINK_NAME])
2012 return -EINVAL;
2013
2014 link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
2015
2016 if (strcmp(link_name, tipc_bclink_name) == 0) {
Ying Xue1da46562015-01-09 15:27:07 +08002017 err = tipc_bclink_reset_stats(net);
Richard Alpeae363422014-11-20 10:29:14 +01002018 if (err)
2019 return err;
2020 return 0;
2021 }
2022
Ying Xuef2f98002015-01-09 15:27:05 +08002023 node = tipc_link_find_owner(net, link_name, &bearer_id);
Richard Alpeae363422014-11-20 10:29:14 +01002024 if (!node)
2025 return -EINVAL;
2026
2027 tipc_node_lock(node);
2028
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -04002029 link = node->links[bearer_id].link;
Richard Alpeae363422014-11-20 10:29:14 +01002030 if (!link) {
2031 tipc_node_unlock(node);
2032 return -EINVAL;
2033 }
2034
2035 link_reset_statistics(link);
2036
2037 tipc_node_unlock(node);
2038
2039 return 0;
2040}