blob: d34429d03c16e9d873c9b54aca429cf7cc480492 [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 Maloyc64f7a62012-11-16 13:51:31 +08004 * Copyright (c) 1996-2007, 2012, 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"
Per Lidenb97bf3f2006-01-02 19:04:38 +010038#include "link.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010039#include "port.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010040#include "name_distr.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010041#include "discover.h"
42#include "config.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010043
Erik Hugne2cf8aa12012-06-29 00:16:37 -040044/*
45 * Error message prefixes
46 */
47static const char *link_co_err = "Link changeover error, ";
48static const char *link_rst_msg = "Resetting link ";
49static const char *link_unk_evt = "Unknown link event ";
Per Lidenb97bf3f2006-01-02 19:04:38 +010050
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090051/*
Allan Stephensa686e682008-06-04 17:29:39 -070052 * Out-of-range value for link session numbers
53 */
Allan Stephensa686e682008-06-04 17:29:39 -070054#define INVALID_SESSION 0x10000
55
56/*
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090057 * Link state events:
Per Lidenb97bf3f2006-01-02 19:04:38 +010058 */
Per Lidenb97bf3f2006-01-02 19:04:38 +010059#define STARTING_EVT 856384768 /* link processing trigger */
60#define TRAFFIC_MSG_EVT 560815u /* rx'd ??? */
61#define TIMEOUT_EVT 560817u /* link timer expired */
62
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090063/*
64 * The following two 'message types' is really just implementation
65 * data conveniently stored in the message header.
Per Lidenb97bf3f2006-01-02 19:04:38 +010066 * They must not be considered part of the protocol
67 */
68#define OPEN_MSG 0
69#define CLOSED_MSG 1
70
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090071/*
Per Lidenb97bf3f2006-01-02 19:04:38 +010072 * State value stored in 'exp_msg_count'
73 */
Per Lidenb97bf3f2006-01-02 19:04:38 +010074#define START_CHANGEOVER 100000u
75
76/**
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050077 * struct tipc_link_name - deconstructed link name
Per Lidenb97bf3f2006-01-02 19:04:38 +010078 * @addr_local: network address of node at this end
79 * @if_local: name of interface at this end
80 * @addr_peer: network address of node at far end
81 * @if_peer: name of interface at far end
82 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050083struct tipc_link_name {
Per Lidenb97bf3f2006-01-02 19:04:38 +010084 u32 addr_local;
85 char if_local[TIPC_MAX_IF_NAME];
86 u32 addr_peer;
87 char if_peer[TIPC_MAX_IF_NAME];
88};
89
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050090static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +010091 struct sk_buff *buf);
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050092static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf);
93static int link_recv_changeover_msg(struct tipc_link **l_ptr,
94 struct sk_buff **buf);
95static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance);
Allan Stephens23dd4cc2011-01-07 11:43:40 -050096static int link_send_sections_long(struct tipc_port *sender,
Per Lidenb97bf3f2006-01-02 19:04:38 +010097 struct iovec const *msg_sect,
Allan Stephens26896902011-04-21 10:42:07 -050098 u32 num_sect, unsigned int total_len,
99 u32 destnode);
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500100static void link_state_event(struct tipc_link *l_ptr, u32 event);
101static void link_reset_statistics(struct tipc_link *l_ptr);
102static void link_print(struct tipc_link *l_ptr, const char *str);
103static void link_start(struct tipc_link *l_ptr);
104static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf);
Jon Maloyc64f7a62012-11-16 13:51:31 +0800105static void tipc_link_send_sync(struct tipc_link *l);
106static void tipc_link_recv_sync(struct tipc_node *n, struct sk_buff *buf);
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000107
Per Lidenb97bf3f2006-01-02 19:04:38 +0100108/*
Sam Ravnborg05790c62006-03-20 22:37:04 -0800109 * Simple link routines
Per Lidenb97bf3f2006-01-02 19:04:38 +0100110 */
Sam Ravnborg05790c62006-03-20 22:37:04 -0800111static unsigned int align(unsigned int i)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100112{
113 return (i + 3) & ~3u;
114}
115
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500116static void link_init_max_pkt(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100117{
118 u32 max_pkt;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900119
Allan Stephens2d627b92011-01-07 13:00:11 -0500120 max_pkt = (l_ptr->b_ptr->mtu & ~3);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100121 if (max_pkt > MAX_MSG_SIZE)
122 max_pkt = MAX_MSG_SIZE;
123
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900124 l_ptr->max_pkt_target = max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100125 if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT)
126 l_ptr->max_pkt = l_ptr->max_pkt_target;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900127 else
Per Lidenb97bf3f2006-01-02 19:04:38 +0100128 l_ptr->max_pkt = MAX_PKT_DEFAULT;
129
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900130 l_ptr->max_pkt_probes = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100131}
132
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500133static u32 link_next_sent(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100134{
135 if (l_ptr->next_out)
Allan Stephensf9057302011-10-24 16:03:12 -0400136 return buf_seqno(l_ptr->next_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100137 return mod(l_ptr->next_out_no);
138}
139
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500140static u32 link_last_sent(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100141{
142 return mod(link_next_sent(l_ptr) - 1);
143}
144
145/*
Sam Ravnborg05790c62006-03-20 22:37:04 -0800146 * Simple non-static link routines (i.e. referenced outside this file)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100147 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500148int tipc_link_is_up(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100149{
150 if (!l_ptr)
151 return 0;
Eric Dumazeta02cec22010-09-22 20:43:57 +0000152 return link_working_working(l_ptr) || link_working_unknown(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100153}
154
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500155int tipc_link_is_active(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100156{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000157 return (l_ptr->owner->active_links[0] == l_ptr) ||
158 (l_ptr->owner->active_links[1] == l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100159}
160
161/**
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500162 * link_name_validate - validate & (optionally) deconstruct tipc_link name
Ben Hutchings2c530402012-07-10 10:55:09 +0000163 * @name: ptr to link name string
164 * @name_parts: ptr to area for link name components (or NULL if not needed)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900165 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100166 * Returns 1 if link name is valid, otherwise 0.
167 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500168static int link_name_validate(const char *name,
169 struct tipc_link_name *name_parts)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100170{
171 char name_copy[TIPC_MAX_LINK_NAME];
172 char *addr_local;
173 char *if_local;
174 char *addr_peer;
175 char *if_peer;
176 char dummy;
177 u32 z_local, c_local, n_local;
178 u32 z_peer, c_peer, n_peer;
179 u32 if_local_len;
180 u32 if_peer_len;
181
182 /* copy link name & ensure length is OK */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100183 name_copy[TIPC_MAX_LINK_NAME - 1] = 0;
184 /* need above in case non-Posix strncpy() doesn't pad with nulls */
185 strncpy(name_copy, name, TIPC_MAX_LINK_NAME);
186 if (name_copy[TIPC_MAX_LINK_NAME - 1] != 0)
187 return 0;
188
189 /* ensure all component parts of link name are present */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100190 addr_local = name_copy;
Allan Stephens2db99832010-12-31 18:59:33 +0000191 if_local = strchr(addr_local, ':');
192 if (if_local == NULL)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100193 return 0;
194 *(if_local++) = 0;
Allan Stephens2db99832010-12-31 18:59:33 +0000195 addr_peer = strchr(if_local, '-');
196 if (addr_peer == NULL)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100197 return 0;
198 *(addr_peer++) = 0;
199 if_local_len = addr_peer - if_local;
Allan Stephens2db99832010-12-31 18:59:33 +0000200 if_peer = strchr(addr_peer, ':');
201 if (if_peer == NULL)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100202 return 0;
203 *(if_peer++) = 0;
204 if_peer_len = strlen(if_peer) + 1;
205
206 /* validate component parts of link name */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100207 if ((sscanf(addr_local, "%u.%u.%u%c",
208 &z_local, &c_local, &n_local, &dummy) != 3) ||
209 (sscanf(addr_peer, "%u.%u.%u%c",
210 &z_peer, &c_peer, &n_peer, &dummy) != 3) ||
211 (z_local > 255) || (c_local > 4095) || (n_local > 4095) ||
212 (z_peer > 255) || (c_peer > 4095) || (n_peer > 4095) ||
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900213 (if_local_len <= 1) || (if_local_len > TIPC_MAX_IF_NAME) ||
Ying Xuefc073932012-08-16 12:09:08 +0000214 (if_peer_len <= 1) || (if_peer_len > TIPC_MAX_IF_NAME))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100215 return 0;
216
217 /* return link name components, if necessary */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100218 if (name_parts) {
219 name_parts->addr_local = tipc_addr(z_local, c_local, n_local);
220 strcpy(name_parts->if_local, if_local);
221 name_parts->addr_peer = tipc_addr(z_peer, c_peer, n_peer);
222 strcpy(name_parts->if_peer, if_peer);
223 }
224 return 1;
225}
226
227/**
228 * link_timeout - handle expiration of link timer
229 * @l_ptr: pointer to link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900230 *
Per Liden4323add2006-01-18 00:38:21 +0100231 * This routine must not grab "tipc_net_lock" to avoid a potential deadlock conflict
232 * with tipc_link_delete(). (There is no risk that the node will be deleted by
233 * another thread because tipc_link_delete() always cancels the link timer before
234 * tipc_node_delete() is called.)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100235 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500236static void link_timeout(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100237{
Per Liden4323add2006-01-18 00:38:21 +0100238 tipc_node_lock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100239
240 /* update counters used in statistical profiling of send traffic */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100241 l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size;
242 l_ptr->stats.queue_sz_counts++;
243
Per Lidenb97bf3f2006-01-02 19:04:38 +0100244 if (l_ptr->first_out) {
245 struct tipc_msg *msg = buf_msg(l_ptr->first_out);
246 u32 length = msg_size(msg);
247
Joe Perchesf64f9e72009-11-29 16:55:45 -0800248 if ((msg_user(msg) == MSG_FRAGMENTER) &&
249 (msg_type(msg) == FIRST_FRAGMENT)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100250 length = msg_size(msg_get_wrapped(msg));
251 }
252 if (length) {
253 l_ptr->stats.msg_lengths_total += length;
254 l_ptr->stats.msg_length_counts++;
255 if (length <= 64)
256 l_ptr->stats.msg_length_profile[0]++;
257 else if (length <= 256)
258 l_ptr->stats.msg_length_profile[1]++;
259 else if (length <= 1024)
260 l_ptr->stats.msg_length_profile[2]++;
261 else if (length <= 4096)
262 l_ptr->stats.msg_length_profile[3]++;
263 else if (length <= 16384)
264 l_ptr->stats.msg_length_profile[4]++;
265 else if (length <= 32768)
266 l_ptr->stats.msg_length_profile[5]++;
267 else
268 l_ptr->stats.msg_length_profile[6]++;
269 }
270 }
271
272 /* do all other link processing performed on a periodic basis */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100273
274 link_state_event(l_ptr, TIMEOUT_EVT);
275
276 if (l_ptr->next_out)
Per Liden4323add2006-01-18 00:38:21 +0100277 tipc_link_push_queue(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100278
Per Liden4323add2006-01-18 00:38:21 +0100279 tipc_node_unlock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100280}
281
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500282static void link_set_timer(struct tipc_link *l_ptr, u32 time)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100283{
284 k_start_timer(&l_ptr->timer, time);
285}
286
287/**
Per Liden4323add2006-01-18 00:38:21 +0100288 * tipc_link_create - create a new link
Allan Stephens37b9c082011-02-28 11:32:27 -0500289 * @n_ptr: pointer to associated node
Per Lidenb97bf3f2006-01-02 19:04:38 +0100290 * @b_ptr: pointer to associated bearer
Per Lidenb97bf3f2006-01-02 19:04:38 +0100291 * @media_addr: media address to use when sending messages over link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900292 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100293 * Returns pointer to link.
294 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500295struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
Allan Stephens37b9c082011-02-28 11:32:27 -0500296 struct tipc_bearer *b_ptr,
Per Liden4323add2006-01-18 00:38:21 +0100297 const struct tipc_media_addr *media_addr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100298{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500299 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100300 struct tipc_msg *msg;
301 char *if_name;
Allan Stephens37b9c082011-02-28 11:32:27 -0500302 char addr_string[16];
303 u32 peer = n_ptr->addr;
304
305 if (n_ptr->link_cnt >= 2) {
306 tipc_addr_string_fill(addr_string, n_ptr->addr);
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400307 pr_err("Attempt to establish third link to %s\n", addr_string);
Allan Stephens37b9c082011-02-28 11:32:27 -0500308 return NULL;
309 }
310
311 if (n_ptr->links[b_ptr->identity]) {
312 tipc_addr_string_fill(addr_string, n_ptr->addr);
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400313 pr_err("Attempt to establish second link on <%s> to %s\n",
314 b_ptr->name, addr_string);
Allan Stephens37b9c082011-02-28 11:32:27 -0500315 return NULL;
316 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100317
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700318 l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100319 if (!l_ptr) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400320 pr_warn("Link creation failed, no memory\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100321 return NULL;
322 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100323
324 l_ptr->addr = peer;
Allan Stephens2d627b92011-01-07 13:00:11 -0500325 if_name = strchr(b_ptr->name, ':') + 1;
Allan Stephens062b4c92011-04-07 09:28:47 -0400326 sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100327 tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900328 tipc_node(tipc_own_addr),
Per Lidenb97bf3f2006-01-02 19:04:38 +0100329 if_name,
330 tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
Allan Stephens062b4c92011-04-07 09:28:47 -0400331 /* note: peer i/f name is updated by reset/activate message */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100332 memcpy(&l_ptr->media_addr, media_addr, sizeof(*media_addr));
Allan Stephens37b9c082011-02-28 11:32:27 -0500333 l_ptr->owner = n_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100334 l_ptr->checkpoint = 1;
Allan Stephensf882cb762011-04-07 09:43:27 -0400335 l_ptr->peer_session = INVALID_SESSION;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100336 l_ptr->b_ptr = b_ptr;
Allan Stephens5c216e12011-10-18 11:34:29 -0400337 link_set_supervision_props(l_ptr, b_ptr->tolerance);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100338 l_ptr->state = RESET_UNKNOWN;
339
340 l_ptr->pmsg = (struct tipc_msg *)&l_ptr->proto_msg;
341 msg = l_ptr->pmsg;
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000342 tipc_msg_init(msg, LINK_PROTOCOL, RESET_MSG, INT_H_SIZE, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100343 msg_set_size(msg, sizeof(l_ptr->proto_msg));
Allan Stephensa686e682008-06-04 17:29:39 -0700344 msg_set_session(msg, (tipc_random & 0xffff));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100345 msg_set_bearer_id(msg, b_ptr->identity);
346 strcpy((char *)msg_data(msg), if_name);
347
348 l_ptr->priority = b_ptr->priority;
Allan Stephens5c216e12011-10-18 11:34:29 -0400349 tipc_link_set_queue_limits(l_ptr, b_ptr->window);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100350
351 link_init_max_pkt(l_ptr);
352
353 l_ptr->next_out_no = 1;
354 INIT_LIST_HEAD(&l_ptr->waiting_ports);
355
356 link_reset_statistics(l_ptr);
357
Allan Stephens37b9c082011-02-28 11:32:27 -0500358 tipc_node_attach_link(n_ptr, l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100359
Florian Westphal945710652007-07-26 00:05:07 -0700360 k_init_timer(&l_ptr->timer, (Handler)link_timeout, (unsigned long)l_ptr);
361 list_add_tail(&l_ptr->link_list, &b_ptr->links);
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000362 tipc_k_signal((Handler)link_start, (unsigned long)l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100363
Per Lidenb97bf3f2006-01-02 19:04:38 +0100364 return l_ptr;
365}
366
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900367/**
Per Liden4323add2006-01-18 00:38:21 +0100368 * tipc_link_delete - delete a link
Per Lidenb97bf3f2006-01-02 19:04:38 +0100369 * @l_ptr: pointer to link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900370 *
Per Liden4323add2006-01-18 00:38:21 +0100371 * Note: 'tipc_net_lock' is write_locked, bearer is locked.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100372 * This routine must not grab the node lock until after link timer cancellation
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900373 * to avoid a potential deadlock situation.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100374 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500375void tipc_link_delete(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100376{
377 if (!l_ptr) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400378 pr_err("Attempt to delete non-existent link\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100379 return;
380 }
381
Per Lidenb97bf3f2006-01-02 19:04:38 +0100382 k_cancel_timer(&l_ptr->timer);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900383
Per Liden4323add2006-01-18 00:38:21 +0100384 tipc_node_lock(l_ptr->owner);
385 tipc_link_reset(l_ptr);
386 tipc_node_detach_link(l_ptr->owner, l_ptr);
387 tipc_link_stop(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100388 list_del_init(&l_ptr->link_list);
Per Liden4323add2006-01-18 00:38:21 +0100389 tipc_node_unlock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100390 k_term_timer(&l_ptr->timer);
391 kfree(l_ptr);
392}
393
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500394static void link_start(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100395{
Allan Stephens214dda42011-01-24 16:22:43 -0500396 tipc_node_lock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100397 link_state_event(l_ptr, STARTING_EVT);
Allan Stephens214dda42011-01-24 16:22:43 -0500398 tipc_node_unlock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100399}
400
401/**
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900402 * link_schedule_port - schedule port for deferred sending
Per Lidenb97bf3f2006-01-02 19:04:38 +0100403 * @l_ptr: pointer to link
404 * @origport: reference to sending port
405 * @sz: amount of data to be sent
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900406 *
407 * Schedules port for renewed sending of messages after link congestion
Per Lidenb97bf3f2006-01-02 19:04:38 +0100408 * has abated.
409 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500410static int link_schedule_port(struct tipc_link *l_ptr, u32 origport, u32 sz)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100411{
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500412 struct tipc_port *p_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100413
Per Liden4323add2006-01-18 00:38:21 +0100414 spin_lock_bh(&tipc_port_list_lock);
415 p_ptr = tipc_port_lock(origport);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100416 if (p_ptr) {
417 if (!p_ptr->wakeup)
418 goto exit;
419 if (!list_empty(&p_ptr->wait_list))
420 goto exit;
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500421 p_ptr->congested = 1;
Allan Stephens15e979d2010-05-11 14:30:10 +0000422 p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100423 list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports);
424 l_ptr->stats.link_congs++;
425exit:
Per Liden4323add2006-01-18 00:38:21 +0100426 tipc_port_unlock(p_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100427 }
Per Liden4323add2006-01-18 00:38:21 +0100428 spin_unlock_bh(&tipc_port_list_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100429 return -ELINKCONG;
430}
431
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500432void tipc_link_wakeup_ports(struct tipc_link *l_ptr, int all)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100433{
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500434 struct tipc_port *p_ptr;
435 struct tipc_port *temp_p_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100436 int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size;
437
438 if (all)
439 win = 100000;
440 if (win <= 0)
441 return;
Per Liden4323add2006-01-18 00:38:21 +0100442 if (!spin_trylock_bh(&tipc_port_list_lock))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100443 return;
444 if (link_congested(l_ptr))
445 goto exit;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900446 list_for_each_entry_safe(p_ptr, temp_p_ptr, &l_ptr->waiting_ports,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100447 wait_list) {
448 if (win <= 0)
449 break;
450 list_del_init(&p_ptr->wait_list);
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500451 spin_lock_bh(p_ptr->lock);
452 p_ptr->congested = 0;
453 p_ptr->wakeup(p_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100454 win -= p_ptr->waiting_pkts;
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500455 spin_unlock_bh(p_ptr->lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100456 }
457
458exit:
Per Liden4323add2006-01-18 00:38:21 +0100459 spin_unlock_bh(&tipc_port_list_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100460}
461
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900462/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100463 * link_release_outqueue - purge link's outbound message queue
464 * @l_ptr: pointer to link
465 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500466static void link_release_outqueue(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100467{
468 struct sk_buff *buf = l_ptr->first_out;
469 struct sk_buff *next;
470
471 while (buf) {
472 next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400473 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100474 buf = next;
475 }
476 l_ptr->first_out = NULL;
477 l_ptr->out_queue_size = 0;
478}
479
480/**
Per Liden4323add2006-01-18 00:38:21 +0100481 * tipc_link_reset_fragments - purge link's inbound message fragments queue
Per Lidenb97bf3f2006-01-02 19:04:38 +0100482 * @l_ptr: pointer to link
483 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500484void tipc_link_reset_fragments(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100485{
486 struct sk_buff *buf = l_ptr->defragm_buf;
487 struct sk_buff *next;
488
489 while (buf) {
490 next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400491 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100492 buf = next;
493 }
494 l_ptr->defragm_buf = NULL;
495}
496
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900497/**
Per Liden4323add2006-01-18 00:38:21 +0100498 * tipc_link_stop - purge all inbound and outbound messages associated with link
Per Lidenb97bf3f2006-01-02 19:04:38 +0100499 * @l_ptr: pointer to link
500 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500501void tipc_link_stop(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100502{
503 struct sk_buff *buf;
504 struct sk_buff *next;
505
506 buf = l_ptr->oldest_deferred_in;
507 while (buf) {
508 next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400509 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100510 buf = next;
511 }
512
513 buf = l_ptr->first_out;
514 while (buf) {
515 next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400516 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100517 buf = next;
518 }
519
Per Liden4323add2006-01-18 00:38:21 +0100520 tipc_link_reset_fragments(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100521
Allan Stephens5f6d9122011-11-04 13:24:29 -0400522 kfree_skb(l_ptr->proto_msg_queue);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100523 l_ptr->proto_msg_queue = NULL;
524}
525
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500526void tipc_link_reset(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100527{
528 struct sk_buff *buf;
529 u32 prev_state = l_ptr->state;
530 u32 checkpoint = l_ptr->next_in_no;
Allan Stephens5392d642006-06-25 23:52:50 -0700531 int was_active_link = tipc_link_is_active(l_ptr);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900532
Allan Stephensa686e682008-06-04 17:29:39 -0700533 msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100534
Allan Stephensa686e682008-06-04 17:29:39 -0700535 /* Link is down, accept any session */
536 l_ptr->peer_session = INVALID_SESSION;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100537
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900538 /* Prepare for max packet size negotiation */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100539 link_init_max_pkt(l_ptr);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900540
Per Lidenb97bf3f2006-01-02 19:04:38 +0100541 l_ptr->state = RESET_UNKNOWN;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100542
543 if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))
544 return;
545
Per Liden4323add2006-01-18 00:38:21 +0100546 tipc_node_link_down(l_ptr->owner, l_ptr);
547 tipc_bearer_remove_dest(l_ptr->b_ptr, l_ptr->addr);
Paul Gortmaker7368ddf2010-10-12 14:25:58 +0000548
Paul Gortmaker8f19afb2011-02-28 11:36:21 -0400549 if (was_active_link && tipc_node_active_links(l_ptr->owner) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +0100550 l_ptr->owner->permit_changeover) {
551 l_ptr->reset_checkpoint = checkpoint;
552 l_ptr->exp_msg_count = START_CHANGEOVER;
553 }
554
555 /* Clean up all queues: */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100556 link_release_outqueue(l_ptr);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400557 kfree_skb(l_ptr->proto_msg_queue);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100558 l_ptr->proto_msg_queue = NULL;
559 buf = l_ptr->oldest_deferred_in;
560 while (buf) {
561 struct sk_buff *next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400562 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100563 buf = next;
564 }
565 if (!list_empty(&l_ptr->waiting_ports))
Per Liden4323add2006-01-18 00:38:21 +0100566 tipc_link_wakeup_ports(l_ptr, 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100567
568 l_ptr->retransm_queue_head = 0;
569 l_ptr->retransm_queue_size = 0;
570 l_ptr->last_out = NULL;
571 l_ptr->first_out = NULL;
572 l_ptr->next_out = NULL;
573 l_ptr->unacked_window = 0;
574 l_ptr->checkpoint = 1;
575 l_ptr->next_out_no = 1;
576 l_ptr->deferred_inqueue_sz = 0;
577 l_ptr->oldest_deferred_in = NULL;
578 l_ptr->newest_deferred_in = NULL;
579 l_ptr->fsm_msg_cnt = 0;
580 l_ptr->stale_count = 0;
581 link_reset_statistics(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100582}
583
584
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500585static void link_activate(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100586{
Allan Stephens5392d642006-06-25 23:52:50 -0700587 l_ptr->next_in_no = l_ptr->stats.recv_info = 1;
Per Liden4323add2006-01-18 00:38:21 +0100588 tipc_node_link_up(l_ptr->owner, l_ptr);
589 tipc_bearer_add_dest(l_ptr->b_ptr, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100590}
591
592/**
593 * link_state_event - link finite state machine
594 * @l_ptr: pointer to link
595 * @event: state machine event to process
596 */
Eric Dumazet95c96172012-04-15 05:58:06 +0000597static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100598{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500599 struct tipc_link *other;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100600 u32 cont_intv = l_ptr->continuity_interval;
601
602 if (!l_ptr->started && (event != STARTING_EVT))
603 return; /* Not yet. */
604
605 if (link_blocked(l_ptr)) {
Allan Stephensa0168922010-12-31 18:59:35 +0000606 if (event == TIMEOUT_EVT)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100607 link_set_timer(l_ptr, cont_intv);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100608 return; /* Changeover going on */
609 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100610
611 switch (l_ptr->state) {
612 case WORKING_WORKING:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100613 switch (event) {
614 case TRAFFIC_MSG_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100615 case ACTIVATE_MSG:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100616 break;
617 case TIMEOUT_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100618 if (l_ptr->next_in_no != l_ptr->checkpoint) {
619 l_ptr->checkpoint = l_ptr->next_in_no;
Per Liden4323add2006-01-18 00:38:21 +0100620 if (tipc_bclink_acks_missing(l_ptr->owner)) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900621 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
Per Liden4323add2006-01-18 00:38:21 +0100622 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100623 l_ptr->fsm_msg_cnt++;
624 } else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900625 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
Per Liden4323add2006-01-18 00:38:21 +0100626 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100627 l_ptr->fsm_msg_cnt++;
628 }
629 link_set_timer(l_ptr, cont_intv);
630 break;
631 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100632 l_ptr->state = WORKING_UNKNOWN;
633 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100634 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100635 l_ptr->fsm_msg_cnt++;
636 link_set_timer(l_ptr, cont_intv / 4);
637 break;
638 case RESET_MSG:
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400639 pr_info("%s<%s>, requested by peer\n", link_rst_msg,
640 l_ptr->name);
Per Liden4323add2006-01-18 00:38:21 +0100641 tipc_link_reset(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100642 l_ptr->state = RESET_RESET;
643 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100644 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100645 l_ptr->fsm_msg_cnt++;
646 link_set_timer(l_ptr, cont_intv);
647 break;
648 default:
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400649 pr_err("%s%u in WW state\n", link_unk_evt, event);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100650 }
651 break;
652 case WORKING_UNKNOWN:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100653 switch (event) {
654 case TRAFFIC_MSG_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100655 case ACTIVATE_MSG:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100656 l_ptr->state = WORKING_WORKING;
657 l_ptr->fsm_msg_cnt = 0;
658 link_set_timer(l_ptr, cont_intv);
659 break;
660 case RESET_MSG:
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400661 pr_info("%s<%s>, requested by peer while probing\n",
662 link_rst_msg, l_ptr->name);
Per Liden4323add2006-01-18 00:38:21 +0100663 tipc_link_reset(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100664 l_ptr->state = RESET_RESET;
665 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100666 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100667 l_ptr->fsm_msg_cnt++;
668 link_set_timer(l_ptr, cont_intv);
669 break;
670 case TIMEOUT_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100671 if (l_ptr->next_in_no != l_ptr->checkpoint) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100672 l_ptr->state = WORKING_WORKING;
673 l_ptr->fsm_msg_cnt = 0;
674 l_ptr->checkpoint = l_ptr->next_in_no;
Per Liden4323add2006-01-18 00:38:21 +0100675 if (tipc_bclink_acks_missing(l_ptr->owner)) {
676 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
677 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100678 l_ptr->fsm_msg_cnt++;
679 }
680 link_set_timer(l_ptr, cont_intv);
681 } else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900682 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
Per Liden4323add2006-01-18 00:38:21 +0100683 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100684 l_ptr->fsm_msg_cnt++;
685 link_set_timer(l_ptr, cont_intv / 4);
686 } else { /* Link has failed */
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400687 pr_warn("%s<%s>, peer not responding\n",
688 link_rst_msg, l_ptr->name);
Per Liden4323add2006-01-18 00:38:21 +0100689 tipc_link_reset(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100690 l_ptr->state = RESET_UNKNOWN;
691 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100692 tipc_link_send_proto_msg(l_ptr, RESET_MSG,
693 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100694 l_ptr->fsm_msg_cnt++;
695 link_set_timer(l_ptr, cont_intv);
696 }
697 break;
698 default:
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400699 pr_err("%s%u in WU state\n", link_unk_evt, event);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100700 }
701 break;
702 case RESET_UNKNOWN:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100703 switch (event) {
704 case TRAFFIC_MSG_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100705 break;
706 case ACTIVATE_MSG:
707 other = l_ptr->owner->active_links[0];
Allan Stephens8d64a5b2010-12-31 18:59:27 +0000708 if (other && link_working_unknown(other))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100709 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100710 l_ptr->state = WORKING_WORKING;
711 l_ptr->fsm_msg_cnt = 0;
712 link_activate(l_ptr);
Per Liden4323add2006-01-18 00:38:21 +0100713 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100714 l_ptr->fsm_msg_cnt++;
Jon Maloyc64f7a62012-11-16 13:51:31 +0800715 if (l_ptr->owner->working_links == 1)
716 tipc_link_send_sync(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100717 link_set_timer(l_ptr, cont_intv);
718 break;
719 case RESET_MSG:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100720 l_ptr->state = RESET_RESET;
721 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100722 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100723 l_ptr->fsm_msg_cnt++;
724 link_set_timer(l_ptr, cont_intv);
725 break;
726 case STARTING_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100727 l_ptr->started = 1;
728 /* fall through */
729 case TIMEOUT_EVT:
Per Liden4323add2006-01-18 00:38:21 +0100730 tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100731 l_ptr->fsm_msg_cnt++;
732 link_set_timer(l_ptr, cont_intv);
733 break;
734 default:
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400735 pr_err("%s%u in RU state\n", link_unk_evt, event);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100736 }
737 break;
738 case RESET_RESET:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100739 switch (event) {
740 case TRAFFIC_MSG_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100741 case ACTIVATE_MSG:
742 other = l_ptr->owner->active_links[0];
Allan Stephens8d64a5b2010-12-31 18:59:27 +0000743 if (other && link_working_unknown(other))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100744 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100745 l_ptr->state = WORKING_WORKING;
746 l_ptr->fsm_msg_cnt = 0;
747 link_activate(l_ptr);
Per Liden4323add2006-01-18 00:38:21 +0100748 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100749 l_ptr->fsm_msg_cnt++;
Jon Maloyc64f7a62012-11-16 13:51:31 +0800750 if (l_ptr->owner->working_links == 1)
751 tipc_link_send_sync(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100752 link_set_timer(l_ptr, cont_intv);
753 break;
754 case RESET_MSG:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100755 break;
756 case TIMEOUT_EVT:
Per Liden4323add2006-01-18 00:38:21 +0100757 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100758 l_ptr->fsm_msg_cnt++;
759 link_set_timer(l_ptr, cont_intv);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100760 break;
761 default:
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400762 pr_err("%s%u in RR state\n", link_unk_evt, event);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100763 }
764 break;
765 default:
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400766 pr_err("Unknown link state %u/%u\n", l_ptr->state, event);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100767 }
768}
769
770/*
771 * link_bundle_buf(): Append contents of a buffer to
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900772 * the tail of an existing one.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100773 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500774static int link_bundle_buf(struct tipc_link *l_ptr,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900775 struct sk_buff *bundler,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100776 struct sk_buff *buf)
777{
778 struct tipc_msg *bundler_msg = buf_msg(bundler);
779 struct tipc_msg *msg = buf_msg(buf);
780 u32 size = msg_size(msg);
Allan Stephense49060c2006-06-29 12:32:46 -0700781 u32 bundle_size = msg_size(bundler_msg);
782 u32 to_pos = align(bundle_size);
783 u32 pad = to_pos - bundle_size;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100784
785 if (msg_user(bundler_msg) != MSG_BUNDLER)
786 return 0;
787 if (msg_type(bundler_msg) != OPEN_MSG)
788 return 0;
Allan Stephense49060c2006-06-29 12:32:46 -0700789 if (skb_tailroom(bundler) < (pad + size))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100790 return 0;
Allan Stephens15e979d2010-05-11 14:30:10 +0000791 if (l_ptr->max_pkt < (to_pos + size))
Allan Stephens863fae62006-07-03 19:39:36 -0700792 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100793
Allan Stephense49060c2006-06-29 12:32:46 -0700794 skb_put(bundler, pad + size);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -0300795 skb_copy_to_linear_data_offset(bundler, to_pos, buf->data, size);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100796 msg_set_size(bundler_msg, to_pos + size);
797 msg_set_msgcnt(bundler_msg, msg_msgcnt(bundler_msg) + 1);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400798 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100799 l_ptr->stats.sent_bundled++;
800 return 1;
801}
802
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500803static void link_add_to_outqueue(struct tipc_link *l_ptr,
Sam Ravnborg05790c62006-03-20 22:37:04 -0800804 struct sk_buff *buf,
805 struct tipc_msg *msg)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100806{
807 u32 ack = mod(l_ptr->next_in_no - 1);
808 u32 seqno = mod(l_ptr->next_out_no++);
809
810 msg_set_word(msg, 2, ((ack << 16) | seqno));
811 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
812 buf->next = NULL;
813 if (l_ptr->first_out) {
814 l_ptr->last_out->next = buf;
815 l_ptr->last_out = buf;
816 } else
817 l_ptr->first_out = l_ptr->last_out = buf;
Allan Stephens9bd80b62011-01-18 15:02:50 -0500818
Per Lidenb97bf3f2006-01-02 19:04:38 +0100819 l_ptr->out_queue_size++;
Allan Stephens9bd80b62011-01-18 15:02:50 -0500820 if (l_ptr->out_queue_size > l_ptr->stats.max_queue_sz)
821 l_ptr->stats.max_queue_sz = l_ptr->out_queue_size;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100822}
823
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500824static void link_add_chain_to_outqueue(struct tipc_link *l_ptr,
Allan Stephensdc63d912011-04-21 11:50:42 -0400825 struct sk_buff *buf_chain,
826 u32 long_msgno)
827{
828 struct sk_buff *buf;
829 struct tipc_msg *msg;
830
831 if (!l_ptr->next_out)
832 l_ptr->next_out = buf_chain;
833 while (buf_chain) {
834 buf = buf_chain;
835 buf_chain = buf_chain->next;
836
837 msg = buf_msg(buf);
838 msg_set_long_msgno(msg, long_msgno);
839 link_add_to_outqueue(l_ptr, buf, msg);
840 }
841}
842
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900843/*
844 * tipc_link_send_buf() is the 'full path' for messages, called from
Per Lidenb97bf3f2006-01-02 19:04:38 +0100845 * inside TIPC when the 'fast path' in tipc_send_buf
846 * has failed, and from link_send()
847 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500848int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100849{
850 struct tipc_msg *msg = buf_msg(buf);
851 u32 size = msg_size(msg);
852 u32 dsz = msg_data_sz(msg);
853 u32 queue_size = l_ptr->out_queue_size;
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000854 u32 imp = tipc_msg_tot_importance(msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100855 u32 queue_limit = l_ptr->queue_limit[imp];
Allan Stephens15e979d2010-05-11 14:30:10 +0000856 u32 max_packet = l_ptr->max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100857
Per Lidenb97bf3f2006-01-02 19:04:38 +0100858 /* Match msg importance against queue limits: */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100859 if (unlikely(queue_size >= queue_limit)) {
860 if (imp <= TIPC_CRITICAL_IMPORTANCE) {
Allan Stephensbebc55a2011-04-19 10:17:58 -0400861 link_schedule_port(l_ptr, msg_origport(msg), size);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400862 kfree_skb(buf);
Allan Stephensbebc55a2011-04-19 10:17:58 -0400863 return -ELINKCONG;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100864 }
Allan Stephens5f6d9122011-11-04 13:24:29 -0400865 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100866 if (imp > CONN_MANAGER) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400867 pr_warn("%s<%s>, send queue full", link_rst_msg,
868 l_ptr->name);
Per Liden4323add2006-01-18 00:38:21 +0100869 tipc_link_reset(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100870 }
871 return dsz;
872 }
873
874 /* Fragmentation needed ? */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100875 if (size > max_packet)
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000876 return link_send_long_buf(l_ptr, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100877
Paul Gortmaker617d3c72012-04-30 15:29:02 -0400878 /* Packet can be queued or sent. */
Ying Xue3c294cb2012-11-15 11:34:45 +0800879 if (likely(!tipc_bearer_blocked(l_ptr->b_ptr) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +0100880 !link_congested(l_ptr))) {
881 link_add_to_outqueue(l_ptr, buf, msg);
882
Ying Xue3c294cb2012-11-15 11:34:45 +0800883 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
884 l_ptr->unacked_window = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100885 return dsz;
886 }
Paul Gortmaker617d3c72012-04-30 15:29:02 -0400887 /* Congestion: can message be bundled ? */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100888 if ((msg_user(msg) != CHANGEOVER_PROTOCOL) &&
889 (msg_user(msg) != MSG_FRAGMENTER)) {
890
891 /* Try adding message to an existing bundle */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900892 if (l_ptr->next_out &&
Ying Xue3c294cb2012-11-15 11:34:45 +0800893 link_bundle_buf(l_ptr, l_ptr->last_out, buf))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100894 return dsz;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100895
896 /* Try creating a new bundle */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100897 if (size <= max_packet * 2 / 3) {
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000898 struct sk_buff *bundler = tipc_buf_acquire(max_packet);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100899 struct tipc_msg bundler_hdr;
900
901 if (bundler) {
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000902 tipc_msg_init(&bundler_hdr, MSG_BUNDLER, OPEN_MSG,
Allan Stephens75715212008-06-04 17:37:34 -0700903 INT_H_SIZE, l_ptr->addr);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -0300904 skb_copy_to_linear_data(bundler, &bundler_hdr,
905 INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100906 skb_trim(bundler, INT_H_SIZE);
907 link_bundle_buf(l_ptr, bundler, buf);
908 buf = bundler;
909 msg = buf_msg(buf);
910 l_ptr->stats.sent_bundles++;
911 }
912 }
913 }
914 if (!l_ptr->next_out)
915 l_ptr->next_out = buf;
916 link_add_to_outqueue(l_ptr, buf, msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100917 return dsz;
918}
919
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900920/*
921 * tipc_link_send(): same as tipc_link_send_buf(), but the link to use has
Per Lidenb97bf3f2006-01-02 19:04:38 +0100922 * not been selected yet, and the the owner node is not locked
923 * Called by TIPC internal users, e.g. the name distributor
924 */
Per Liden4323add2006-01-18 00:38:21 +0100925int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100926{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500927 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -0700928 struct tipc_node *n_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100929 int res = -ELINKCONG;
930
Per Liden4323add2006-01-18 00:38:21 +0100931 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +0000932 n_ptr = tipc_node_find(dest);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100933 if (n_ptr) {
Per Liden4323add2006-01-18 00:38:21 +0100934 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100935 l_ptr = n_ptr->active_links[selector & 1];
Allan Stephensa0168922010-12-31 18:59:35 +0000936 if (l_ptr)
Per Liden4323add2006-01-18 00:38:21 +0100937 res = tipc_link_send_buf(l_ptr, buf);
Allan Stephensa0168922010-12-31 18:59:35 +0000938 else
Allan Stephens5f6d9122011-11-04 13:24:29 -0400939 kfree_skb(buf);
Per Liden4323add2006-01-18 00:38:21 +0100940 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100941 } else {
Allan Stephens5f6d9122011-11-04 13:24:29 -0400942 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100943 }
Per Liden4323add2006-01-18 00:38:21 +0100944 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100945 return res;
946}
947
Jon Maloyc64f7a62012-11-16 13:51:31 +0800948/*
949 * tipc_link_send_sync - synchronize broadcast link endpoints.
950 *
951 * Give a newly added peer node the sequence number where it should
952 * start receiving and acking broadcast packets.
953 *
954 * Called with node locked
955 */
956static void tipc_link_send_sync(struct tipc_link *l)
957{
958 struct sk_buff *buf;
959 struct tipc_msg *msg;
960
961 buf = tipc_buf_acquire(INT_H_SIZE);
962 if (!buf)
963 return;
964
965 msg = buf_msg(buf);
966 tipc_msg_init(msg, BCAST_PROTOCOL, STATE_MSG, INT_H_SIZE, l->addr);
967 msg_set_last_bcast(msg, l->owner->bclink.acked);
968 link_add_chain_to_outqueue(l, buf, 0);
969 tipc_link_push_queue(l);
970}
971
972/*
973 * tipc_link_recv_sync - synchronize broadcast link endpoints.
974 * Receive the sequence number where we should start receiving and
975 * acking broadcast packets from a newly added peer node, and open
976 * up for reception of such packets.
977 *
978 * Called with node locked
979 */
980static void tipc_link_recv_sync(struct tipc_node *n, struct sk_buff *buf)
981{
982 struct tipc_msg *msg = buf_msg(buf);
983
984 n->bclink.last_sent = n->bclink.last_in = msg_last_bcast(msg);
985 n->bclink.recv_permitted = true;
986 kfree_skb(buf);
987}
988
989/*
Allan Stephens9aa88c22011-05-31 13:38:02 -0400990 * tipc_link_send_names - send name table entries to new neighbor
991 *
992 * Send routine for bulk delivery of name table messages when contact
993 * with a new neighbor occurs. No link congestion checking is performed
994 * because name table messages *must* be delivered. The messages must be
995 * small enough not to require fragmentation.
996 * Called without any locks held.
997 */
Allan Stephens9aa88c22011-05-31 13:38:02 -0400998void tipc_link_send_names(struct list_head *message_list, u32 dest)
999{
1000 struct tipc_node *n_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001001 struct tipc_link *l_ptr;
Allan Stephens9aa88c22011-05-31 13:38:02 -04001002 struct sk_buff *buf;
1003 struct sk_buff *temp_buf;
1004
1005 if (list_empty(message_list))
1006 return;
1007
1008 read_lock_bh(&tipc_net_lock);
1009 n_ptr = tipc_node_find(dest);
1010 if (n_ptr) {
1011 tipc_node_lock(n_ptr);
1012 l_ptr = n_ptr->active_links[0];
1013 if (l_ptr) {
1014 /* convert circular list to linear list */
1015 ((struct sk_buff *)message_list->prev)->next = NULL;
1016 link_add_chain_to_outqueue(l_ptr,
1017 (struct sk_buff *)message_list->next, 0);
1018 tipc_link_push_queue(l_ptr);
1019 INIT_LIST_HEAD(message_list);
1020 }
1021 tipc_node_unlock(n_ptr);
1022 }
1023 read_unlock_bh(&tipc_net_lock);
1024
1025 /* discard the messages if they couldn't be sent */
Allan Stephens9aa88c22011-05-31 13:38:02 -04001026 list_for_each_safe(buf, temp_buf, ((struct sk_buff *)message_list)) {
1027 list_del((struct list_head *)buf);
Allan Stephens5f6d9122011-11-04 13:24:29 -04001028 kfree_skb(buf);
Allan Stephens9aa88c22011-05-31 13:38:02 -04001029 }
1030}
1031
1032/*
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001033 * link_send_buf_fast: Entry for data messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001034 * destination link is known and the header is complete,
1035 * inclusive total message length. Very time critical.
1036 * Link is locked. Returns user data length.
1037 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001038static int link_send_buf_fast(struct tipc_link *l_ptr, struct sk_buff *buf,
Sam Ravnborg05790c62006-03-20 22:37:04 -08001039 u32 *used_max_pkt)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001040{
1041 struct tipc_msg *msg = buf_msg(buf);
1042 int res = msg_data_sz(msg);
1043
1044 if (likely(!link_congested(l_ptr))) {
Allan Stephens15e979d2010-05-11 14:30:10 +00001045 if (likely(msg_size(msg) <= l_ptr->max_pkt)) {
Ying Xue3c294cb2012-11-15 11:34:45 +08001046 if (likely(!tipc_bearer_blocked(l_ptr->b_ptr))) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001047 link_add_to_outqueue(l_ptr, buf, msg);
Ying Xue3c294cb2012-11-15 11:34:45 +08001048 tipc_bearer_send(l_ptr->b_ptr, buf,
1049 &l_ptr->media_addr);
1050 l_ptr->unacked_window = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001051 return res;
1052 }
Allan Stephens0e659672010-12-31 18:59:32 +00001053 } else
Allan Stephens15e979d2010-05-11 14:30:10 +00001054 *used_max_pkt = l_ptr->max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001055 }
Per Liden4323add2006-01-18 00:38:21 +01001056 return tipc_link_send_buf(l_ptr, buf); /* All other cases */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001057}
1058
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001059/*
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001060 * tipc_link_send_sections_fast: Entry for messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001061 * destination processor is known and the header is complete,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001062 * except for total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001063 * Returns user data length or errno.
1064 */
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001065int tipc_link_send_sections_fast(struct tipc_port *sender,
Per Liden4323add2006-01-18 00:38:21 +01001066 struct iovec const *msg_sect,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001067 const u32 num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001068 unsigned int total_len,
Per Liden4323add2006-01-18 00:38:21 +01001069 u32 destaddr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001070{
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001071 struct tipc_msg *hdr = &sender->phdr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001072 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001073 struct sk_buff *buf;
David S. Miller6c000552008-09-02 23:38:32 -07001074 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001075 int res;
1076 u32 selector = msg_origport(hdr) & 1;
1077
Per Lidenb97bf3f2006-01-02 19:04:38 +01001078again:
1079 /*
1080 * Try building message using port's max_pkt hint.
1081 * (Must not hold any locks while building message.)
1082 */
Allan Stephens26896902011-04-21 10:42:07 -05001083 res = tipc_msg_build(hdr, msg_sect, num_sect, total_len,
Ying Xuef1733d72013-06-17 10:54:43 -04001084 sender->max_pkt, &buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001085
Per Liden4323add2006-01-18 00:38:21 +01001086 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +00001087 node = tipc_node_find(destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001088 if (likely(node)) {
Per Liden4323add2006-01-18 00:38:21 +01001089 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001090 l_ptr = node->active_links[selector];
1091 if (likely(l_ptr)) {
1092 if (likely(buf)) {
1093 res = link_send_buf_fast(l_ptr, buf,
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001094 &sender->max_pkt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001095exit:
Per Liden4323add2006-01-18 00:38:21 +01001096 tipc_node_unlock(node);
1097 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001098 return res;
1099 }
1100
1101 /* Exit if build request was invalid */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001102 if (unlikely(res < 0))
1103 goto exit;
1104
1105 /* Exit if link (or bearer) is congested */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001106 if (link_congested(l_ptr) ||
Ying Xue3c294cb2012-11-15 11:34:45 +08001107 tipc_bearer_blocked(l_ptr->b_ptr)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001108 res = link_schedule_port(l_ptr,
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001109 sender->ref, res);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001110 goto exit;
1111 }
1112
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001113 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001114 * Message size exceeds max_pkt hint; update hint,
1115 * then re-try fast path or fragment the message
1116 */
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001117 sender->max_pkt = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01001118 tipc_node_unlock(node);
1119 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001120
1121
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001122 if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001123 goto again;
1124
1125 return link_send_sections_long(sender, msg_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001126 num_sect, total_len,
1127 destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001128 }
Per Liden4323add2006-01-18 00:38:21 +01001129 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001130 }
Per Liden4323add2006-01-18 00:38:21 +01001131 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001132
1133 /* Couldn't find a link to the destination node */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001134 if (buf)
1135 return tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
1136 if (res >= 0)
Per Liden4323add2006-01-18 00:38:21 +01001137 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001138 total_len, TIPC_ERR_NO_NODE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001139 return res;
1140}
1141
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001142/*
1143 * link_send_sections_long(): Entry for long messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001144 * destination node is known and the header is complete,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001145 * inclusive total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001146 * Link and bearer congestion status have been checked to be ok,
1147 * and are ignored if they change.
1148 *
1149 * Note that fragments do not use the full link MTU so that they won't have
1150 * to undergo refragmentation if link changeover causes them to be sent
1151 * over another link with an additional tunnel header added as prefix.
1152 * (Refragmentation will still occur if the other link has a smaller MTU.)
1153 *
1154 * Returns user data length or errno.
1155 */
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001156static int link_send_sections_long(struct tipc_port *sender,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001157 struct iovec const *msg_sect,
1158 u32 num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001159 unsigned int total_len,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001160 u32 destaddr)
1161{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001162 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07001163 struct tipc_node *node;
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001164 struct tipc_msg *hdr = &sender->phdr;
Allan Stephens26896902011-04-21 10:42:07 -05001165 u32 dsz = total_len;
Allan Stephens0e659672010-12-31 18:59:32 +00001166 u32 max_pkt, fragm_sz, rest;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001167 struct tipc_msg fragm_hdr;
Allan Stephens0e659672010-12-31 18:59:32 +00001168 struct sk_buff *buf, *buf_chain, *prev;
1169 u32 fragm_crs, fragm_rest, hsz, sect_rest;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001170 const unchar *sect_crs;
1171 int curr_sect;
1172 u32 fragm_no;
1173
1174again:
1175 fragm_no = 1;
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001176 max_pkt = sender->max_pkt - INT_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001177 /* leave room for tunnel header in case of link changeover */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001178 fragm_sz = max_pkt - INT_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001179 /* leave room for fragmentation header in each fragment */
1180 rest = dsz;
1181 fragm_crs = 0;
1182 fragm_rest = 0;
1183 sect_rest = 0;
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08001184 sect_crs = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001185 curr_sect = -1;
1186
Paul Gortmaker617d3c72012-04-30 15:29:02 -04001187 /* Prepare reusable fragment header */
Allan Stephensc68ca7b2010-05-11 14:30:12 +00001188 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
Allan Stephens75715212008-06-04 17:37:34 -07001189 INT_H_SIZE, msg_destnode(hdr));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001190 msg_set_size(&fragm_hdr, max_pkt);
1191 msg_set_fragm_no(&fragm_hdr, 1);
1192
Paul Gortmaker617d3c72012-04-30 15:29:02 -04001193 /* Prepare header of first fragment */
stephen hemminger31e3c3f2010-10-13 13:20:35 +00001194 buf_chain = buf = tipc_buf_acquire(max_pkt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001195 if (!buf)
1196 return -ENOMEM;
1197 buf->next = NULL;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001198 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001199 hsz = msg_hdr_sz(hdr);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001200 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, hdr, hsz);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001201
Paul Gortmaker617d3c72012-04-30 15:29:02 -04001202 /* Chop up message */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001203 fragm_crs = INT_H_SIZE + hsz;
1204 fragm_rest = fragm_sz - hsz;
1205
1206 do { /* For all sections */
1207 u32 sz;
1208
1209 if (!sect_rest) {
1210 sect_rest = msg_sect[++curr_sect].iov_len;
1211 sect_crs = (const unchar *)msg_sect[curr_sect].iov_base;
1212 }
1213
1214 if (sect_rest < fragm_rest)
1215 sz = sect_rest;
1216 else
1217 sz = fragm_rest;
1218
Ying Xuef1733d72013-06-17 10:54:43 -04001219 if (copy_from_user(buf->data + fragm_crs, sect_crs, sz)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001220error:
Ying Xuef1733d72013-06-17 10:54:43 -04001221 for (; buf_chain; buf_chain = buf) {
1222 buf = buf_chain->next;
1223 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001224 }
Ying Xuef1733d72013-06-17 10:54:43 -04001225 return -EFAULT;
1226 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001227 sect_crs += sz;
1228 sect_rest -= sz;
1229 fragm_crs += sz;
1230 fragm_rest -= sz;
1231 rest -= sz;
1232
1233 if (!fragm_rest && rest) {
1234
1235 /* Initiate new fragment: */
1236 if (rest <= fragm_sz) {
1237 fragm_sz = rest;
Allan Stephens0e659672010-12-31 18:59:32 +00001238 msg_set_type(&fragm_hdr, LAST_FRAGMENT);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001239 } else {
1240 msg_set_type(&fragm_hdr, FRAGMENT);
1241 }
1242 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
1243 msg_set_fragm_no(&fragm_hdr, ++fragm_no);
1244 prev = buf;
stephen hemminger31e3c3f2010-10-13 13:20:35 +00001245 buf = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001246 if (!buf)
1247 goto error;
1248
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001249 buf->next = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001250 prev->next = buf;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001251 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001252 fragm_crs = INT_H_SIZE;
1253 fragm_rest = fragm_sz;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001254 }
Allan Stephens0e659672010-12-31 18:59:32 +00001255 } while (rest > 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001256
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001257 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001258 * Now we have a buffer chain. Select a link and check
1259 * that packet size is still OK
1260 */
Allan Stephens51a8e4d2010-12-31 18:59:18 +00001261 node = tipc_node_find(destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001262 if (likely(node)) {
Per Liden4323add2006-01-18 00:38:21 +01001263 tipc_node_lock(node);
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001264 l_ptr = node->active_links[sender->ref & 1];
Per Lidenb97bf3f2006-01-02 19:04:38 +01001265 if (!l_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01001266 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001267 goto reject;
1268 }
Allan Stephens15e979d2010-05-11 14:30:10 +00001269 if (l_ptr->max_pkt < max_pkt) {
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001270 sender->max_pkt = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01001271 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001272 for (; buf_chain; buf_chain = buf) {
1273 buf = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001274 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001275 }
1276 goto again;
1277 }
1278 } else {
1279reject:
1280 for (; buf_chain; buf_chain = buf) {
1281 buf = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001282 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001283 }
Per Liden4323add2006-01-18 00:38:21 +01001284 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001285 total_len, TIPC_ERR_NO_NODE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001286 }
1287
Allan Stephensdc63d912011-04-21 11:50:42 -04001288 /* Append chain of fragments to send queue & send them */
Allan Stephense0f08592011-04-17 11:44:24 -04001289 l_ptr->long_msg_seq_no++;
Allan Stephensdc63d912011-04-21 11:50:42 -04001290 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
1291 l_ptr->stats.sent_fragments += fragm_no;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001292 l_ptr->stats.sent_fragmented++;
Per Liden4323add2006-01-18 00:38:21 +01001293 tipc_link_push_queue(l_ptr);
1294 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001295 return dsz;
1296}
1297
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001298/*
Per Liden4323add2006-01-18 00:38:21 +01001299 * tipc_link_push_packet: Push one unsent packet to the media
Per Lidenb97bf3f2006-01-02 19:04:38 +01001300 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001301u32 tipc_link_push_packet(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001302{
1303 struct sk_buff *buf = l_ptr->first_out;
1304 u32 r_q_size = l_ptr->retransm_queue_size;
1305 u32 r_q_head = l_ptr->retransm_queue_head;
1306
1307 /* Step to position where retransmission failed, if any, */
1308 /* consider that buffers may have been released in meantime */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001309 if (r_q_size && buf) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001310 u32 last = lesser(mod(r_q_head + r_q_size),
Per Lidenb97bf3f2006-01-02 19:04:38 +01001311 link_last_sent(l_ptr));
Allan Stephensf9057302011-10-24 16:03:12 -04001312 u32 first = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001313
1314 while (buf && less(first, r_q_head)) {
1315 first = mod(first + 1);
1316 buf = buf->next;
1317 }
1318 l_ptr->retransm_queue_head = r_q_head = first;
1319 l_ptr->retransm_queue_size = r_q_size = mod(last - first);
1320 }
1321
1322 /* Continue retransmission now, if there is anything: */
Neil Hormanca509102010-03-15 07:58:45 +00001323 if (r_q_size && buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001324 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001325 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
Ying Xue3c294cb2012-11-15 11:34:45 +08001326 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
1327 l_ptr->retransm_queue_head = mod(++r_q_head);
1328 l_ptr->retransm_queue_size = --r_q_size;
1329 l_ptr->stats.retransmitted++;
1330 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001331 }
1332
1333 /* Send deferred protocol message, if any: */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001334 buf = l_ptr->proto_msg_queue;
1335 if (buf) {
1336 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
Allan Stephens0e659672010-12-31 18:59:32 +00001337 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
Ying Xue3c294cb2012-11-15 11:34:45 +08001338 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
1339 l_ptr->unacked_window = 0;
1340 kfree_skb(buf);
1341 l_ptr->proto_msg_queue = NULL;
1342 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001343 }
1344
1345 /* Send one deferred data message, if send window not full: */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001346 buf = l_ptr->next_out;
1347 if (buf) {
1348 struct tipc_msg *msg = buf_msg(buf);
1349 u32 next = msg_seqno(msg);
Allan Stephensf9057302011-10-24 16:03:12 -04001350 u32 first = buf_seqno(l_ptr->first_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001351
1352 if (mod(next - first) < l_ptr->queue_limit[0]) {
1353 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001354 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Ying Xue3c294cb2012-11-15 11:34:45 +08001355 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
1356 if (msg_user(msg) == MSG_BUNDLER)
1357 msg_set_type(msg, CLOSED_MSG);
1358 l_ptr->next_out = buf->next;
1359 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001360 }
1361 }
Ying Xue3c294cb2012-11-15 11:34:45 +08001362 return 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001363}
1364
1365/*
1366 * push_queue(): push out the unsent messages of a link where
1367 * congestion has abated. Node is locked
1368 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001369void tipc_link_push_queue(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001370{
1371 u32 res;
1372
Ying Xue3c294cb2012-11-15 11:34:45 +08001373 if (tipc_bearer_blocked(l_ptr->b_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001374 return;
1375
1376 do {
Per Liden4323add2006-01-18 00:38:21 +01001377 res = tipc_link_push_packet(l_ptr);
Allan Stephens0e35fd52008-07-14 22:44:01 -07001378 } while (!res);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001379}
1380
Allan Stephensd356eeb2006-06-25 23:40:01 -07001381static void link_reset_all(unsigned long addr)
1382{
David S. Miller6c000552008-09-02 23:38:32 -07001383 struct tipc_node *n_ptr;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001384 char addr_string[16];
1385 u32 i;
1386
1387 read_lock_bh(&tipc_net_lock);
1388 n_ptr = tipc_node_find((u32)addr);
1389 if (!n_ptr) {
1390 read_unlock_bh(&tipc_net_lock);
1391 return; /* node no longer exists */
1392 }
1393
1394 tipc_node_lock(n_ptr);
1395
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001396 pr_warn("Resetting all links to %s\n",
1397 tipc_addr_string_fill(addr_string, n_ptr->addr));
Allan Stephensd356eeb2006-06-25 23:40:01 -07001398
1399 for (i = 0; i < MAX_BEARERS; i++) {
1400 if (n_ptr->links[i]) {
Allan Stephens8d64a5b2010-12-31 18:59:27 +00001401 link_print(n_ptr->links[i], "Resetting link\n");
Allan Stephensd356eeb2006-06-25 23:40:01 -07001402 tipc_link_reset(n_ptr->links[i]);
1403 }
1404 }
1405
1406 tipc_node_unlock(n_ptr);
1407 read_unlock_bh(&tipc_net_lock);
1408}
1409
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001410static void link_retransmit_failure(struct tipc_link *l_ptr,
1411 struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -07001412{
1413 struct tipc_msg *msg = buf_msg(buf);
1414
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001415 pr_warn("Retransmission failure on link <%s>\n", l_ptr->name);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001416
1417 if (l_ptr->addr) {
Allan Stephensd356eeb2006-06-25 23:40:01 -07001418 /* Handle failure on standard link */
Allan Stephens8d64a5b2010-12-31 18:59:27 +00001419 link_print(l_ptr, "Resetting link\n");
Allan Stephensd356eeb2006-06-25 23:40:01 -07001420 tipc_link_reset(l_ptr);
1421
1422 } else {
Allan Stephensd356eeb2006-06-25 23:40:01 -07001423 /* Handle failure on broadcast link */
David S. Miller6c000552008-09-02 23:38:32 -07001424 struct tipc_node *n_ptr;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001425 char addr_string[16];
1426
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001427 pr_info("Msg seq number: %u, ", msg_seqno(msg));
1428 pr_cont("Outstanding acks: %lu\n",
1429 (unsigned long) TIPC_SKB_CB(buf)->handle);
Jeff Garzik617dbea2006-10-03 16:25:34 -07001430
Allan Stephens01d83ed2011-01-18 13:53:16 -05001431 n_ptr = tipc_bclink_retransmit_to();
Allan Stephensd356eeb2006-06-25 23:40:01 -07001432 tipc_node_lock(n_ptr);
1433
Allan Stephensc68ca7b2010-05-11 14:30:12 +00001434 tipc_addr_string_fill(addr_string, n_ptr->addr);
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001435 pr_info("Broadcast link info for %s\n", addr_string);
Ying Xue389dd9b2012-11-16 13:51:30 +08001436 pr_info("Reception permitted: %d, Acked: %u\n",
1437 n_ptr->bclink.recv_permitted,
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001438 n_ptr->bclink.acked);
1439 pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
1440 n_ptr->bclink.last_in,
1441 n_ptr->bclink.oos_state,
1442 n_ptr->bclink.last_sent);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001443
1444 tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr);
1445
1446 tipc_node_unlock(n_ptr);
1447
1448 l_ptr->stale_count = 0;
1449 }
1450}
1451
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001452void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf,
Per Liden4323add2006-01-18 00:38:21 +01001453 u32 retransmits)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001454{
1455 struct tipc_msg *msg;
1456
Allan Stephensd356eeb2006-06-25 23:40:01 -07001457 if (!buf)
1458 return;
1459
1460 msg = buf_msg(buf);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001461
Ying Xue3c294cb2012-11-15 11:34:45 +08001462 if (tipc_bearer_blocked(l_ptr->b_ptr)) {
Neil Hormanca509102010-03-15 07:58:45 +00001463 if (l_ptr->retransm_queue_size == 0) {
Allan Stephensd356eeb2006-06-25 23:40:01 -07001464 l_ptr->retransm_queue_head = msg_seqno(msg);
1465 l_ptr->retransm_queue_size = retransmits;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001466 } else {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001467 pr_err("Unexpected retransmit on link %s (qsize=%d)\n",
1468 l_ptr->name, l_ptr->retransm_queue_size);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001469 }
Neil Hormanca509102010-03-15 07:58:45 +00001470 return;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001471 } else {
Ying Xue3c294cb2012-11-15 11:34:45 +08001472 /* Detect repeated retransmit failures on unblocked bearer */
Allan Stephensd356eeb2006-06-25 23:40:01 -07001473 if (l_ptr->last_retransmitted == msg_seqno(msg)) {
1474 if (++l_ptr->stale_count > 100) {
1475 link_retransmit_failure(l_ptr, buf);
1476 return;
1477 }
1478 } else {
1479 l_ptr->last_retransmitted = msg_seqno(msg);
1480 l_ptr->stale_count = 1;
1481 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001482 }
Allan Stephensd356eeb2006-06-25 23:40:01 -07001483
Neil Hormanca509102010-03-15 07:58:45 +00001484 while (retransmits && (buf != l_ptr->next_out) && buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001485 msg = buf_msg(buf);
1486 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001487 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Ying Xue3c294cb2012-11-15 11:34:45 +08001488 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
1489 buf = buf->next;
1490 retransmits--;
1491 l_ptr->stats.retransmitted++;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001492 }
Allan Stephensd356eeb2006-06-25 23:40:01 -07001493
Per Lidenb97bf3f2006-01-02 19:04:38 +01001494 l_ptr->retransm_queue_head = l_ptr->retransm_queue_size = 0;
1495}
1496
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001497/**
Per Lidenb97bf3f2006-01-02 19:04:38 +01001498 * link_insert_deferred_queue - insert deferred messages back into receive chain
1499 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001500static struct sk_buff *link_insert_deferred_queue(struct tipc_link *l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001501 struct sk_buff *buf)
1502{
1503 u32 seq_no;
1504
1505 if (l_ptr->oldest_deferred_in == NULL)
1506 return buf;
1507
Allan Stephensf9057302011-10-24 16:03:12 -04001508 seq_no = buf_seqno(l_ptr->oldest_deferred_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001509 if (seq_no == mod(l_ptr->next_in_no)) {
1510 l_ptr->newest_deferred_in->next = buf;
1511 buf = l_ptr->oldest_deferred_in;
1512 l_ptr->oldest_deferred_in = NULL;
1513 l_ptr->deferred_inqueue_sz = 0;
1514 }
1515 return buf;
1516}
1517
Allan Stephens85035562008-04-15 19:04:54 -07001518/**
1519 * link_recv_buf_validate - validate basic format of received message
1520 *
1521 * This routine ensures a TIPC message has an acceptable header, and at least
1522 * as much data as the header indicates it should. The routine also ensures
1523 * that the entire message header is stored in the main fragment of the message
1524 * buffer, to simplify future access to message header fields.
1525 *
1526 * Note: Having extra info present in the message header or data areas is OK.
1527 * TIPC will ignore the excess, under the assumption that it is optional info
1528 * introduced by a later release of the protocol.
1529 */
Allan Stephens85035562008-04-15 19:04:54 -07001530static int link_recv_buf_validate(struct sk_buff *buf)
1531{
1532 static u32 min_data_hdr_size[8] = {
Allan Stephens741d9eb2011-05-31 15:03:18 -04001533 SHORT_H_SIZE, MCAST_H_SIZE, NAMED_H_SIZE, BASIC_H_SIZE,
Allan Stephens85035562008-04-15 19:04:54 -07001534 MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE
1535 };
1536
1537 struct tipc_msg *msg;
1538 u32 tipc_hdr[2];
1539 u32 size;
1540 u32 hdr_size;
1541 u32 min_hdr_size;
1542
1543 if (unlikely(buf->len < MIN_H_SIZE))
1544 return 0;
1545
1546 msg = skb_header_pointer(buf, 0, sizeof(tipc_hdr), tipc_hdr);
1547 if (msg == NULL)
1548 return 0;
1549
1550 if (unlikely(msg_version(msg) != TIPC_VERSION))
1551 return 0;
1552
1553 size = msg_size(msg);
1554 hdr_size = msg_hdr_sz(msg);
1555 min_hdr_size = msg_isdata(msg) ?
1556 min_data_hdr_size[msg_type(msg)] : INT_H_SIZE;
1557
1558 if (unlikely((hdr_size < min_hdr_size) ||
1559 (size < hdr_size) ||
1560 (buf->len < size) ||
1561 (size - hdr_size > TIPC_MAX_USER_MSG_SIZE)))
1562 return 0;
1563
1564 return pskb_may_pull(buf, hdr_size);
1565}
1566
Allan Stephensb02b69c2010-08-17 11:00:07 +00001567/**
1568 * tipc_recv_msg - process TIPC messages arriving from off-node
1569 * @head: pointer to message buffer chain
1570 * @tb_ptr: pointer to bearer message arrived on
1571 *
1572 * Invoked with no locks held. Bearer pointer must point to a valid bearer
1573 * structure (i.e. cannot be NULL), but bearer can be inactive.
1574 */
Allan Stephens2d627b92011-01-07 13:00:11 -05001575void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *b_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001576{
Per Liden4323add2006-01-18 00:38:21 +01001577 read_lock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001578 while (head) {
David S. Miller6c000552008-09-02 23:38:32 -07001579 struct tipc_node *n_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001580 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001581 struct sk_buff *crs;
1582 struct sk_buff *buf = head;
Allan Stephens85035562008-04-15 19:04:54 -07001583 struct tipc_msg *msg;
1584 u32 seq_no;
1585 u32 ackd;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001586 u32 released = 0;
1587 int type;
1588
Per Lidenb97bf3f2006-01-02 19:04:38 +01001589 head = head->next;
Allan Stephens85035562008-04-15 19:04:54 -07001590
Allan Stephensb02b69c2010-08-17 11:00:07 +00001591 /* Ensure bearer is still enabled */
Allan Stephensb02b69c2010-08-17 11:00:07 +00001592 if (unlikely(!b_ptr->active))
1593 goto cont;
1594
Allan Stephens85035562008-04-15 19:04:54 -07001595 /* Ensure message is well-formed */
Allan Stephens85035562008-04-15 19:04:54 -07001596 if (unlikely(!link_recv_buf_validate(buf)))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001597 goto cont;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001598
Allan Stephensfe13dda2008-04-15 19:03:23 -07001599 /* Ensure message data is a single contiguous unit */
Allan Stephens5f6d9122011-11-04 13:24:29 -04001600 if (unlikely(skb_linearize(buf)))
Allan Stephensfe13dda2008-04-15 19:03:23 -07001601 goto cont;
Allan Stephensfe13dda2008-04-15 19:03:23 -07001602
Allan Stephens85035562008-04-15 19:04:54 -07001603 /* Handle arrival of a non-unicast link message */
Allan Stephens85035562008-04-15 19:04:54 -07001604 msg = buf_msg(buf);
1605
Per Lidenb97bf3f2006-01-02 19:04:38 +01001606 if (unlikely(msg_non_seq(msg))) {
Allan Stephens1265a022008-06-04 17:32:35 -07001607 if (msg_user(msg) == LINK_CONFIG)
1608 tipc_disc_recv_msg(buf, b_ptr);
1609 else
1610 tipc_bclink_recv_pkt(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001611 continue;
1612 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001613
Allan Stephensed33a9c2011-04-05 15:15:04 -04001614 /* Discard unicast link messages destined for another node */
Allan Stephens26008242006-06-25 23:39:31 -07001615 if (unlikely(!msg_short(msg) &&
1616 (msg_destnode(msg) != tipc_own_addr)))
1617 goto cont;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001618
Allan Stephens5a68d5e2010-08-17 11:00:16 +00001619 /* Locate neighboring node that sent message */
Per Liden4323add2006-01-18 00:38:21 +01001620 n_ptr = tipc_node_find(msg_prevnode(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001621 if (unlikely(!n_ptr))
1622 goto cont;
Per Liden4323add2006-01-18 00:38:21 +01001623 tipc_node_lock(n_ptr);
Allan Stephens85035562008-04-15 19:04:54 -07001624
Allan Stephens5a68d5e2010-08-17 11:00:16 +00001625 /* Locate unicast link endpoint that should handle message */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001626 l_ptr = n_ptr->links[b_ptr->identity];
1627 if (unlikely(!l_ptr)) {
Per Liden4323add2006-01-18 00:38:21 +01001628 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001629 goto cont;
1630 }
Allan Stephens85035562008-04-15 19:04:54 -07001631
Allan Stephensb4b56102011-05-27 11:00:51 -04001632 /* Verify that communication with node is currently allowed */
Allan Stephensb4b56102011-05-27 11:00:51 -04001633 if ((n_ptr->block_setup & WAIT_PEER_DOWN) &&
1634 msg_user(msg) == LINK_PROTOCOL &&
1635 (msg_type(msg) == RESET_MSG ||
1636 msg_type(msg) == ACTIVATE_MSG) &&
1637 !msg_redundant_link(msg))
1638 n_ptr->block_setup &= ~WAIT_PEER_DOWN;
1639
1640 if (n_ptr->block_setup) {
1641 tipc_node_unlock(n_ptr);
1642 goto cont;
1643 }
1644
Allan Stephens85035562008-04-15 19:04:54 -07001645 /* Validate message sequence number info */
Allan Stephens85035562008-04-15 19:04:54 -07001646 seq_no = msg_seqno(msg);
1647 ackd = msg_ack(msg);
1648
1649 /* Release acked messages */
Ying Xue389dd9b2012-11-16 13:51:30 +08001650 if (n_ptr->bclink.recv_permitted)
Allan Stephens365595912011-10-24 15:26:24 -04001651 tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001652
1653 crs = l_ptr->first_out;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001654 while ((crs != l_ptr->next_out) &&
Allan Stephensf9057302011-10-24 16:03:12 -04001655 less_eq(buf_seqno(crs), ackd)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001656 struct sk_buff *next = crs->next;
1657
Allan Stephens5f6d9122011-11-04 13:24:29 -04001658 kfree_skb(crs);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001659 crs = next;
1660 released++;
1661 }
1662 if (released) {
1663 l_ptr->first_out = crs;
1664 l_ptr->out_queue_size -= released;
1665 }
Allan Stephens85035562008-04-15 19:04:54 -07001666
1667 /* Try sending any messages link endpoint has pending */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001668 if (unlikely(l_ptr->next_out))
Per Liden4323add2006-01-18 00:38:21 +01001669 tipc_link_push_queue(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001670 if (unlikely(!list_empty(&l_ptr->waiting_ports)))
Per Liden4323add2006-01-18 00:38:21 +01001671 tipc_link_wakeup_ports(l_ptr, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001672 if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
1673 l_ptr->stats.sent_acks++;
Per Liden4323add2006-01-18 00:38:21 +01001674 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001675 }
1676
Allan Stephens85035562008-04-15 19:04:54 -07001677 /* Now (finally!) process the incoming message */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001678protocol_check:
1679 if (likely(link_working_working(l_ptr))) {
1680 if (likely(seq_no == mod(l_ptr->next_in_no))) {
1681 l_ptr->next_in_no++;
1682 if (unlikely(l_ptr->oldest_deferred_in))
1683 head = link_insert_deferred_queue(l_ptr,
1684 head);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001685deliver:
Allan Stephensc74a4612011-11-02 15:08:44 -04001686 if (likely(msg_isdata(msg))) {
1687 tipc_node_unlock(n_ptr);
1688 tipc_port_recv_msg(buf);
1689 continue;
1690 }
1691 switch (msg_user(msg)) {
1692 int ret;
1693 case MSG_BUNDLER:
1694 l_ptr->stats.recv_bundles++;
1695 l_ptr->stats.recv_bundled +=
1696 msg_msgcnt(msg);
1697 tipc_node_unlock(n_ptr);
1698 tipc_link_recv_bundle(buf);
1699 continue;
1700 case NAME_DISTRIBUTOR:
Jon Maloyc64f7a62012-11-16 13:51:31 +08001701 n_ptr->bclink.recv_permitted = true;
Allan Stephensc74a4612011-11-02 15:08:44 -04001702 tipc_node_unlock(n_ptr);
1703 tipc_named_recv(buf);
1704 continue;
Jon Maloyc64f7a62012-11-16 13:51:31 +08001705 case BCAST_PROTOCOL:
1706 tipc_link_recv_sync(n_ptr, buf);
1707 tipc_node_unlock(n_ptr);
1708 continue;
Allan Stephensc74a4612011-11-02 15:08:44 -04001709 case CONN_MANAGER:
1710 tipc_node_unlock(n_ptr);
1711 tipc_port_recv_proto_msg(buf);
1712 continue;
1713 case MSG_FRAGMENTER:
1714 l_ptr->stats.recv_fragments++;
1715 ret = tipc_link_recv_fragment(
1716 &l_ptr->defragm_buf,
1717 &buf, &msg);
1718 if (ret == 1) {
1719 l_ptr->stats.recv_fragmented++;
1720 goto deliver;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001721 }
Allan Stephensc74a4612011-11-02 15:08:44 -04001722 if (ret == -1)
1723 l_ptr->next_in_no--;
1724 break;
1725 case CHANGEOVER_PROTOCOL:
1726 type = msg_type(msg);
1727 if (link_recv_changeover_msg(&l_ptr,
1728 &buf)) {
1729 msg = buf_msg(buf);
1730 seq_no = msg_seqno(msg);
1731 if (type == ORIGINAL_MSG)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001732 goto deliver;
Allan Stephensc74a4612011-11-02 15:08:44 -04001733 goto protocol_check;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001734 }
Allan Stephensc74a4612011-11-02 15:08:44 -04001735 break;
1736 default:
Allan Stephens5f6d9122011-11-04 13:24:29 -04001737 kfree_skb(buf);
Allan Stephensc74a4612011-11-02 15:08:44 -04001738 buf = NULL;
1739 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001740 }
Per Liden4323add2006-01-18 00:38:21 +01001741 tipc_node_unlock(n_ptr);
1742 tipc_net_route_msg(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001743 continue;
1744 }
1745 link_handle_out_of_seq_msg(l_ptr, buf);
1746 head = link_insert_deferred_queue(l_ptr, head);
Per Liden4323add2006-01-18 00:38:21 +01001747 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001748 continue;
1749 }
1750
Jon Maloyc64f7a62012-11-16 13:51:31 +08001751 /* Link is not in state WORKING_WORKING */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001752 if (msg_user(msg) == LINK_PROTOCOL) {
1753 link_recv_proto_msg(l_ptr, buf);
1754 head = link_insert_deferred_queue(l_ptr, head);
Per Liden4323add2006-01-18 00:38:21 +01001755 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001756 continue;
1757 }
Jon Maloyc64f7a62012-11-16 13:51:31 +08001758
1759 /* Traffic message. Conditionally activate link */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001760 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
1761
1762 if (link_working_working(l_ptr)) {
Jon Maloyc64f7a62012-11-16 13:51:31 +08001763 /* Re-insert buffer in front of queue */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001764 buf->next = head;
1765 head = buf;
Per Liden4323add2006-01-18 00:38:21 +01001766 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001767 continue;
1768 }
Per Liden4323add2006-01-18 00:38:21 +01001769 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001770cont:
Allan Stephens5f6d9122011-11-04 13:24:29 -04001771 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001772 }
Per Liden4323add2006-01-18 00:38:21 +01001773 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001774}
1775
Ben Hutchings2c530402012-07-10 10:55:09 +00001776/**
Allan Stephens8809b252011-10-25 10:44:35 -04001777 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
1778 *
1779 * Returns increase in queue length (i.e. 0 or 1)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001780 */
Allan Stephens8809b252011-10-25 10:44:35 -04001781u32 tipc_link_defer_pkt(struct sk_buff **head, struct sk_buff **tail,
Per Liden4323add2006-01-18 00:38:21 +01001782 struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001783{
Allan Stephens8809b252011-10-25 10:44:35 -04001784 struct sk_buff *queue_buf;
1785 struct sk_buff **prev;
Allan Stephensf9057302011-10-24 16:03:12 -04001786 u32 seq_no = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001787
1788 buf->next = NULL;
1789
1790 /* Empty queue ? */
1791 if (*head == NULL) {
1792 *head = *tail = buf;
1793 return 1;
1794 }
1795
1796 /* Last ? */
Allan Stephensf9057302011-10-24 16:03:12 -04001797 if (less(buf_seqno(*tail), seq_no)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001798 (*tail)->next = buf;
1799 *tail = buf;
1800 return 1;
1801 }
1802
Allan Stephens8809b252011-10-25 10:44:35 -04001803 /* Locate insertion point in queue, then insert; discard if duplicate */
1804 prev = head;
1805 queue_buf = *head;
1806 for (;;) {
1807 u32 curr_seqno = buf_seqno(queue_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001808
Allan Stephens8809b252011-10-25 10:44:35 -04001809 if (seq_no == curr_seqno) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04001810 kfree_skb(buf);
Allan Stephens8809b252011-10-25 10:44:35 -04001811 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001812 }
Allan Stephens8809b252011-10-25 10:44:35 -04001813
1814 if (less(seq_no, curr_seqno))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001815 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001816
Allan Stephens8809b252011-10-25 10:44:35 -04001817 prev = &queue_buf->next;
1818 queue_buf = queue_buf->next;
1819 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001820
Allan Stephens8809b252011-10-25 10:44:35 -04001821 buf->next = queue_buf;
1822 *prev = buf;
1823 return 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001824}
1825
Allan Stephens8809b252011-10-25 10:44:35 -04001826/*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001827 * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
1828 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001829static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001830 struct sk_buff *buf)
1831{
Allan Stephensf9057302011-10-24 16:03:12 -04001832 u32 seq_no = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001833
1834 if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) {
1835 link_recv_proto_msg(l_ptr, buf);
1836 return;
1837 }
1838
Per Lidenb97bf3f2006-01-02 19:04:38 +01001839 /* Record OOS packet arrival (force mismatch on next timeout) */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001840 l_ptr->checkpoint--;
1841
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001842 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001843 * Discard packet if a duplicate; otherwise add it to deferred queue
1844 * and notify peer of gap as per protocol specification
1845 */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001846 if (less(seq_no, mod(l_ptr->next_in_no))) {
1847 l_ptr->stats.duplicates++;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001848 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001849 return;
1850 }
1851
Per Liden4323add2006-01-18 00:38:21 +01001852 if (tipc_link_defer_pkt(&l_ptr->oldest_deferred_in,
1853 &l_ptr->newest_deferred_in, buf)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001854 l_ptr->deferred_inqueue_sz++;
1855 l_ptr->stats.deferred_recv++;
1856 if ((l_ptr->deferred_inqueue_sz % 16) == 1)
Per Liden4323add2006-01-18 00:38:21 +01001857 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001858 } else
1859 l_ptr->stats.duplicates++;
1860}
1861
1862/*
1863 * Send protocol message to the other endpoint.
1864 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001865void tipc_link_send_proto_msg(struct tipc_link *l_ptr, u32 msg_typ,
1866 int probe_msg, u32 gap, u32 tolerance,
1867 u32 priority, u32 ack_mtu)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001868{
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08001869 struct sk_buff *buf = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001870 struct tipc_msg *msg = l_ptr->pmsg;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001871 u32 msg_size = sizeof(l_ptr->proto_msg);
Allan Stephens75f0aa42011-02-28 15:30:20 -05001872 int r_flag;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001873
Allan Stephens92d2c902011-10-25 11:20:26 -04001874 /* Discard any previous message that was deferred due to congestion */
Allan Stephens92d2c902011-10-25 11:20:26 -04001875 if (l_ptr->proto_msg_queue) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04001876 kfree_skb(l_ptr->proto_msg_queue);
Allan Stephens92d2c902011-10-25 11:20:26 -04001877 l_ptr->proto_msg_queue = NULL;
1878 }
1879
Per Lidenb97bf3f2006-01-02 19:04:38 +01001880 if (link_blocked(l_ptr))
1881 return;
Allan Stephensb4b56102011-05-27 11:00:51 -04001882
1883 /* Abort non-RESET send if communication with node is prohibited */
Allan Stephensb4b56102011-05-27 11:00:51 -04001884 if ((l_ptr->owner->block_setup) && (msg_typ != RESET_MSG))
1885 return;
1886
Allan Stephens92d2c902011-10-25 11:20:26 -04001887 /* Create protocol message with "out-of-sequence" sequence number */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001888 msg_set_type(msg, msg_typ);
1889 msg_set_net_plane(msg, l_ptr->b_ptr->net_plane);
Allan Stephens7a54d4a2011-10-27 14:17:53 -04001890 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Per Liden4323add2006-01-18 00:38:21 +01001891 msg_set_last_bcast(msg, tipc_bclink_get_last_sent());
Per Lidenb97bf3f2006-01-02 19:04:38 +01001892
1893 if (msg_typ == STATE_MSG) {
1894 u32 next_sent = mod(l_ptr->next_out_no);
1895
Per Liden4323add2006-01-18 00:38:21 +01001896 if (!tipc_link_is_up(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001897 return;
1898 if (l_ptr->next_out)
Allan Stephensf9057302011-10-24 16:03:12 -04001899 next_sent = buf_seqno(l_ptr->next_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001900 msg_set_next_sent(msg, next_sent);
1901 if (l_ptr->oldest_deferred_in) {
Allan Stephensf9057302011-10-24 16:03:12 -04001902 u32 rec = buf_seqno(l_ptr->oldest_deferred_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001903 gap = mod(rec - mod(l_ptr->next_in_no));
1904 }
1905 msg_set_seq_gap(msg, gap);
1906 if (gap)
1907 l_ptr->stats.sent_nacks++;
1908 msg_set_link_tolerance(msg, tolerance);
1909 msg_set_linkprio(msg, priority);
1910 msg_set_max_pkt(msg, ack_mtu);
1911 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
1912 msg_set_probe(msg, probe_msg != 0);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001913 if (probe_msg) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001914 u32 mtu = l_ptr->max_pkt;
1915
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001916 if ((mtu < l_ptr->max_pkt_target) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +01001917 link_working_working(l_ptr) &&
1918 l_ptr->fsm_msg_cnt) {
1919 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001920 if (l_ptr->max_pkt_probes == 10) {
1921 l_ptr->max_pkt_target = (msg_size - 4);
1922 l_ptr->max_pkt_probes = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001923 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001924 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001925 l_ptr->max_pkt_probes++;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001926 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001927
1928 l_ptr->stats.sent_probes++;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001929 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001930 l_ptr->stats.sent_states++;
1931 } else { /* RESET_MSG or ACTIVATE_MSG */
1932 msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
1933 msg_set_seq_gap(msg, 0);
1934 msg_set_next_sent(msg, 1);
Allan Stephensf23d9bf2011-01-18 15:15:34 -05001935 msg_set_probe(msg, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001936 msg_set_link_tolerance(msg, l_ptr->tolerance);
1937 msg_set_linkprio(msg, l_ptr->priority);
1938 msg_set_max_pkt(msg, l_ptr->max_pkt_target);
1939 }
1940
Allan Stephens75f0aa42011-02-28 15:30:20 -05001941 r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr));
1942 msg_set_redundant_link(msg, r_flag);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001943 msg_set_linkprio(msg, l_ptr->priority);
Allan Stephens92d2c902011-10-25 11:20:26 -04001944 msg_set_size(msg, msg_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001945
1946 msg_set_seqno(msg, mod(l_ptr->next_out_no + (0xffff/2)));
1947
stephen hemminger31e3c3f2010-10-13 13:20:35 +00001948 buf = tipc_buf_acquire(msg_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001949 if (!buf)
1950 return;
1951
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001952 skb_copy_to_linear_data(buf, msg, sizeof(l_ptr->proto_msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001953
Ying Xue3c294cb2012-11-15 11:34:45 +08001954 /* Defer message if bearer is already blocked */
1955 if (tipc_bearer_blocked(l_ptr->b_ptr)) {
Allan Stephens92d2c902011-10-25 11:20:26 -04001956 l_ptr->proto_msg_queue = buf;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001957 return;
1958 }
1959
Ying Xue3c294cb2012-11-15 11:34:45 +08001960 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
Allan Stephens92d2c902011-10-25 11:20:26 -04001961 l_ptr->unacked_window = 0;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001962 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001963}
1964
1965/*
1966 * Receive protocol message :
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001967 * Note that network plane id propagates through the network, and may
1968 * change at any time. The node with lowest address rules
Per Lidenb97bf3f2006-01-02 19:04:38 +01001969 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001970static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001971{
1972 u32 rec_gap = 0;
1973 u32 max_pkt_info;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001974 u32 max_pkt_ack;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001975 u32 msg_tol;
1976 struct tipc_msg *msg = buf_msg(buf);
1977
Per Lidenb97bf3f2006-01-02 19:04:38 +01001978 if (link_blocked(l_ptr))
1979 goto exit;
1980
1981 /* record unnumbered packet arrival (force mismatch on next timeout) */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001982 l_ptr->checkpoint--;
1983
1984 if (l_ptr->b_ptr->net_plane != msg_net_plane(msg))
1985 if (tipc_own_addr > msg_prevnode(msg))
1986 l_ptr->b_ptr->net_plane = msg_net_plane(msg);
1987
1988 l_ptr->owner->permit_changeover = msg_redundant_link(msg);
1989
1990 switch (msg_type(msg)) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001991
Per Lidenb97bf3f2006-01-02 19:04:38 +01001992 case RESET_MSG:
Allan Stephensa686e682008-06-04 17:29:39 -07001993 if (!link_working_unknown(l_ptr) &&
1994 (l_ptr->peer_session != INVALID_SESSION)) {
Allan Stephens641c2182011-04-07 09:54:43 -04001995 if (less_eq(msg_session(msg), l_ptr->peer_session))
1996 break; /* duplicate or old reset: ignore */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001997 }
Allan Stephensb4b56102011-05-27 11:00:51 -04001998
1999 if (!msg_redundant_link(msg) && (link_working_working(l_ptr) ||
2000 link_working_unknown(l_ptr))) {
2001 /*
2002 * peer has lost contact -- don't allow peer's links
2003 * to reactivate before we recognize loss & clean up
2004 */
2005 l_ptr->owner->block_setup = WAIT_NODE_DOWN;
2006 }
2007
Allan Stephens47361c82011-10-26 10:55:16 -04002008 link_state_event(l_ptr, RESET_MSG);
2009
Per Lidenb97bf3f2006-01-02 19:04:38 +01002010 /* fall thru' */
2011 case ACTIVATE_MSG:
2012 /* Update link settings according other endpoint's values */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002013 strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg));
2014
Allan Stephens2db99832010-12-31 18:59:33 +00002015 msg_tol = msg_link_tolerance(msg);
2016 if (msg_tol > l_ptr->tolerance)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002017 link_set_supervision_props(l_ptr, msg_tol);
2018
2019 if (msg_linkprio(msg) > l_ptr->priority)
2020 l_ptr->priority = msg_linkprio(msg);
2021
2022 max_pkt_info = msg_max_pkt(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002023 if (max_pkt_info) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002024 if (max_pkt_info < l_ptr->max_pkt_target)
2025 l_ptr->max_pkt_target = max_pkt_info;
2026 if (l_ptr->max_pkt > l_ptr->max_pkt_target)
2027 l_ptr->max_pkt = l_ptr->max_pkt_target;
2028 } else {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002029 l_ptr->max_pkt = l_ptr->max_pkt_target;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002030 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002031
Allan Stephens4d753132011-10-25 12:19:05 -04002032 /* Synchronize broadcast link info, if not done previously */
Allan Stephens7a54d4a2011-10-27 14:17:53 -04002033 if (!tipc_node_is_up(l_ptr->owner)) {
2034 l_ptr->owner->bclink.last_sent =
2035 l_ptr->owner->bclink.last_in =
2036 msg_last_bcast(msg);
2037 l_ptr->owner->bclink.oos_state = 0;
2038 }
Allan Stephens4d753132011-10-25 12:19:05 -04002039
Per Lidenb97bf3f2006-01-02 19:04:38 +01002040 l_ptr->peer_session = msg_session(msg);
2041 l_ptr->peer_bearer_id = msg_bearer_id(msg);
Allan Stephens47361c82011-10-26 10:55:16 -04002042
2043 if (msg_type(msg) == ACTIVATE_MSG)
2044 link_state_event(l_ptr, ACTIVATE_MSG);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002045 break;
2046 case STATE_MSG:
2047
Allan Stephens2db99832010-12-31 18:59:33 +00002048 msg_tol = msg_link_tolerance(msg);
2049 if (msg_tol)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002050 link_set_supervision_props(l_ptr, msg_tol);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002051
2052 if (msg_linkprio(msg) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +01002053 (msg_linkprio(msg) != l_ptr->priority)) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002054 pr_warn("%s<%s>, priority change %u->%u\n",
2055 link_rst_msg, l_ptr->name, l_ptr->priority,
2056 msg_linkprio(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002057 l_ptr->priority = msg_linkprio(msg);
Per Liden4323add2006-01-18 00:38:21 +01002058 tipc_link_reset(l_ptr); /* Enforce change to take effect */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002059 break;
2060 }
2061 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
2062 l_ptr->stats.recv_states++;
2063 if (link_reset_unknown(l_ptr))
2064 break;
2065
2066 if (less_eq(mod(l_ptr->next_in_no), msg_next_sent(msg))) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002067 rec_gap = mod(msg_next_sent(msg) -
Per Lidenb97bf3f2006-01-02 19:04:38 +01002068 mod(l_ptr->next_in_no));
2069 }
2070
2071 max_pkt_ack = msg_max_pkt(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002072 if (max_pkt_ack > l_ptr->max_pkt) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002073 l_ptr->max_pkt = max_pkt_ack;
2074 l_ptr->max_pkt_probes = 0;
2075 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002076
2077 max_pkt_ack = 0;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002078 if (msg_probe(msg)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002079 l_ptr->stats.recv_probes++;
Allan Stephensa0168922010-12-31 18:59:35 +00002080 if (msg_size(msg) > sizeof(l_ptr->proto_msg))
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002081 max_pkt_ack = msg_size(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002082 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002083
2084 /* Protocol message before retransmits, reduce loss risk */
Ying Xue389dd9b2012-11-16 13:51:30 +08002085 if (l_ptr->owner->bclink.recv_permitted)
Allan Stephens7a54d4a2011-10-27 14:17:53 -04002086 tipc_bclink_update_link_state(l_ptr->owner,
2087 msg_last_bcast(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002088
2089 if (rec_gap || (msg_probe(msg))) {
Per Liden4323add2006-01-18 00:38:21 +01002090 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
2091 0, rec_gap, 0, 0, max_pkt_ack);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002092 }
2093 if (msg_seq_gap(msg)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002094 l_ptr->stats.recv_nacks++;
Per Liden4323add2006-01-18 00:38:21 +01002095 tipc_link_retransmit(l_ptr, l_ptr->first_out,
2096 msg_seq_gap(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002097 }
2098 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002099 }
2100exit:
Allan Stephens5f6d9122011-11-04 13:24:29 -04002101 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002102}
2103
2104
2105/*
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002106 * tipc_link_tunnel(): Send one message via a link belonging to
Per Lidenb97bf3f2006-01-02 19:04:38 +01002107 * another bearer. Owner node is locked.
2108 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002109static void tipc_link_tunnel(struct tipc_link *l_ptr,
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002110 struct tipc_msg *tunnel_hdr,
2111 struct tipc_msg *msg,
2112 u32 selector)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002113{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002114 struct tipc_link *tunnel;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002115 struct sk_buff *buf;
2116 u32 length = msg_size(msg);
2117
2118 tunnel = l_ptr->owner->active_links[selector & 1];
Allan Stephens5392d642006-06-25 23:52:50 -07002119 if (!tipc_link_is_up(tunnel)) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002120 pr_warn("%stunnel link no longer available\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002121 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002122 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002123 msg_set_size(tunnel_hdr, length + INT_H_SIZE);
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002124 buf = tipc_buf_acquire(length + INT_H_SIZE);
Allan Stephens5392d642006-06-25 23:52:50 -07002125 if (!buf) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002126 pr_warn("%sunable to send tunnel msg\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002127 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002128 }
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002129 skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE);
2130 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, msg, length);
Per Liden4323add2006-01-18 00:38:21 +01002131 tipc_link_send_buf(tunnel, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002132}
2133
2134
2135
2136/*
2137 * changeover(): Send whole message queue via the remaining link
2138 * Owner node is locked.
2139 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002140void tipc_link_changeover(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002141{
2142 u32 msgcount = l_ptr->out_queue_size;
2143 struct sk_buff *crs = l_ptr->first_out;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002144 struct tipc_link *tunnel = l_ptr->owner->active_links[0];
Per Lidenb97bf3f2006-01-02 19:04:38 +01002145 struct tipc_msg tunnel_hdr;
Allan Stephens5392d642006-06-25 23:52:50 -07002146 int split_bundles;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002147
2148 if (!tunnel)
2149 return;
2150
Allan Stephens5392d642006-06-25 23:52:50 -07002151 if (!l_ptr->owner->permit_changeover) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002152 pr_warn("%speer did not permit changeover\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002153 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002154 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002155
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002156 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
Allan Stephens75715212008-06-04 17:37:34 -07002157 ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002158 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2159 msg_set_msgcnt(&tunnel_hdr, msgcount);
Allan Stephensf1310722006-06-25 23:51:37 -07002160
Per Lidenb97bf3f2006-01-02 19:04:38 +01002161 if (!l_ptr->first_out) {
2162 struct sk_buff *buf;
2163
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002164 buf = tipc_buf_acquire(INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002165 if (buf) {
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002166 skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002167 msg_set_size(&tunnel_hdr, INT_H_SIZE);
Per Liden4323add2006-01-18 00:38:21 +01002168 tipc_link_send_buf(tunnel, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002169 } else {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002170 pr_warn("%sunable to send changeover msg\n",
2171 link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002172 }
2173 return;
2174 }
Allan Stephensf1310722006-06-25 23:51:37 -07002175
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002176 split_bundles = (l_ptr->owner->active_links[0] !=
Allan Stephens5392d642006-06-25 23:52:50 -07002177 l_ptr->owner->active_links[1]);
2178
Per Lidenb97bf3f2006-01-02 19:04:38 +01002179 while (crs) {
2180 struct tipc_msg *msg = buf_msg(crs);
2181
2182 if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002183 struct tipc_msg *m = msg_get_wrapped(msg);
Allan Stephens0e659672010-12-31 18:59:32 +00002184 unchar *pos = (unchar *)m;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002185
Florian Westphald788d802007-08-02 19:28:06 -07002186 msgcount = msg_msgcnt(msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002187 while (msgcount--) {
Allan Stephens0e659672010-12-31 18:59:32 +00002188 msg_set_seqno(m, msg_seqno(msg));
Per Liden4323add2006-01-18 00:38:21 +01002189 tipc_link_tunnel(l_ptr, &tunnel_hdr, m,
2190 msg_link_selector(m));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002191 pos += align(msg_size(m));
2192 m = (struct tipc_msg *)pos;
2193 }
2194 } else {
Per Liden4323add2006-01-18 00:38:21 +01002195 tipc_link_tunnel(l_ptr, &tunnel_hdr, msg,
2196 msg_link_selector(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002197 }
2198 crs = crs->next;
2199 }
2200}
2201
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002202void tipc_link_send_duplicate(struct tipc_link *l_ptr, struct tipc_link *tunnel)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002203{
2204 struct sk_buff *iter;
2205 struct tipc_msg tunnel_hdr;
2206
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002207 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
Allan Stephens75715212008-06-04 17:37:34 -07002208 DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002209 msg_set_msgcnt(&tunnel_hdr, l_ptr->out_queue_size);
2210 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2211 iter = l_ptr->first_out;
2212 while (iter) {
2213 struct sk_buff *outbuf;
2214 struct tipc_msg *msg = buf_msg(iter);
2215 u32 length = msg_size(msg);
2216
2217 if (msg_user(msg) == MSG_BUNDLER)
2218 msg_set_type(msg, CLOSED_MSG);
2219 msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002220 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002221 msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002222 outbuf = tipc_buf_acquire(length + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002223 if (outbuf == NULL) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002224 pr_warn("%sunable to send duplicate msg\n",
2225 link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002226 return;
2227 }
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002228 skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);
2229 skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data,
2230 length);
Per Liden4323add2006-01-18 00:38:21 +01002231 tipc_link_send_buf(tunnel, outbuf);
2232 if (!tipc_link_is_up(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002233 return;
2234 iter = iter->next;
2235 }
2236}
2237
Per Lidenb97bf3f2006-01-02 19:04:38 +01002238/**
2239 * buf_extract - extracts embedded TIPC message from another message
2240 * @skb: encapsulating message buffer
2241 * @from_pos: offset to extract from
2242 *
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002243 * Returns a new message buffer containing an embedded message. The
Per Lidenb97bf3f2006-01-02 19:04:38 +01002244 * encapsulating message itself is left unchanged.
2245 */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002246static struct sk_buff *buf_extract(struct sk_buff *skb, u32 from_pos)
2247{
2248 struct tipc_msg *msg = (struct tipc_msg *)(skb->data + from_pos);
2249 u32 size = msg_size(msg);
2250 struct sk_buff *eb;
2251
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002252 eb = tipc_buf_acquire(size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002253 if (eb)
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002254 skb_copy_to_linear_data(eb, msg, size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002255 return eb;
2256}
2257
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002258/*
Per Lidenb97bf3f2006-01-02 19:04:38 +01002259 * link_recv_changeover_msg(): Receive tunneled packet sent
2260 * via other link. Node is locked. Return extracted buffer.
2261 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002262static int link_recv_changeover_msg(struct tipc_link **l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01002263 struct sk_buff **buf)
2264{
2265 struct sk_buff *tunnel_buf = *buf;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002266 struct tipc_link *dest_link;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002267 struct tipc_msg *msg;
2268 struct tipc_msg *tunnel_msg = buf_msg(tunnel_buf);
2269 u32 msg_typ = msg_type(tunnel_msg);
2270 u32 msg_count = msg_msgcnt(tunnel_msg);
Dan Carpentercb4b102f2013-05-06 08:28:41 +00002271 u32 bearer_id = msg_bearer_id(tunnel_msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002272
Dan Carpentercb4b102f2013-05-06 08:28:41 +00002273 if (bearer_id >= MAX_BEARERS)
2274 goto exit;
2275 dest_link = (*l_ptr)->owner->links[bearer_id];
Allan Stephensb29f1422010-12-31 18:59:25 +00002276 if (!dest_link)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002277 goto exit;
Allan Stephensf1310722006-06-25 23:51:37 -07002278 if (dest_link == *l_ptr) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002279 pr_err("Unexpected changeover message on link <%s>\n",
2280 (*l_ptr)->name);
Allan Stephensf1310722006-06-25 23:51:37 -07002281 goto exit;
2282 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002283 *l_ptr = dest_link;
2284 msg = msg_get_wrapped(tunnel_msg);
2285
2286 if (msg_typ == DUPLICATE_MSG) {
Allan Stephensb29f1422010-12-31 18:59:25 +00002287 if (less(msg_seqno(msg), mod(dest_link->next_in_no)))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002288 goto exit;
Allan Stephens0e659672010-12-31 18:59:32 +00002289 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002290 if (*buf == NULL) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002291 pr_warn("%sduplicate msg dropped\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002292 goto exit;
2293 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002294 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002295 return 1;
2296 }
2297
2298 /* First original message ?: */
Per Liden4323add2006-01-18 00:38:21 +01002299 if (tipc_link_is_up(dest_link)) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002300 pr_info("%s<%s>, changeover initiated by peer\n", link_rst_msg,
2301 dest_link->name);
Per Liden4323add2006-01-18 00:38:21 +01002302 tipc_link_reset(dest_link);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002303 dest_link->exp_msg_count = msg_count;
2304 if (!msg_count)
2305 goto exit;
2306 } else if (dest_link->exp_msg_count == START_CHANGEOVER) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002307 dest_link->exp_msg_count = msg_count;
2308 if (!msg_count)
2309 goto exit;
2310 }
2311
2312 /* Receive original message */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002313 if (dest_link->exp_msg_count == 0) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002314 pr_warn("%sgot too many tunnelled messages\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002315 goto exit;
2316 }
2317 dest_link->exp_msg_count--;
2318 if (less(msg_seqno(msg), dest_link->reset_checkpoint)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002319 goto exit;
2320 } else {
2321 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
2322 if (*buf != NULL) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002323 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002324 return 1;
2325 } else {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002326 pr_warn("%soriginal msg dropped\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002327 }
2328 }
2329exit:
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002330 *buf = NULL;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002331 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002332 return 0;
2333}
2334
2335/*
2336 * Bundler functionality:
2337 */
Per Liden4323add2006-01-18 00:38:21 +01002338void tipc_link_recv_bundle(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002339{
2340 u32 msgcount = msg_msgcnt(buf_msg(buf));
2341 u32 pos = INT_H_SIZE;
2342 struct sk_buff *obuf;
2343
Per Lidenb97bf3f2006-01-02 19:04:38 +01002344 while (msgcount--) {
2345 obuf = buf_extract(buf, pos);
2346 if (obuf == NULL) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002347 pr_warn("Link unable to unbundle message(s)\n");
Allan Stephensa10bd922006-06-25 23:52:17 -07002348 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002349 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002350 pos += align(msg_size(buf_msg(obuf)));
Per Liden4323add2006-01-18 00:38:21 +01002351 tipc_net_route_msg(obuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002352 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002353 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002354}
2355
2356/*
2357 * Fragmentation/defragmentation:
2358 */
2359
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002360/*
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002361 * link_send_long_buf: Entry for buffers needing fragmentation.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002362 * The buffer is complete, inclusive total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01002363 * Returns user data length.
2364 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002365static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002366{
Allan Stephens77561552011-04-17 13:06:23 -04002367 struct sk_buff *buf_chain = NULL;
2368 struct sk_buff *buf_chain_tail = (struct sk_buff *)&buf_chain;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002369 struct tipc_msg *inmsg = buf_msg(buf);
2370 struct tipc_msg fragm_hdr;
2371 u32 insize = msg_size(inmsg);
2372 u32 dsz = msg_data_sz(inmsg);
2373 unchar *crs = buf->data;
2374 u32 rest = insize;
Allan Stephens15e979d2010-05-11 14:30:10 +00002375 u32 pack_sz = l_ptr->max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002376 u32 fragm_sz = pack_sz - INT_H_SIZE;
Allan Stephens77561552011-04-17 13:06:23 -04002377 u32 fragm_no = 0;
Allan Stephens9c396a72008-06-04 17:36:58 -07002378 u32 destaddr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002379
2380 if (msg_short(inmsg))
2381 destaddr = l_ptr->addr;
Allan Stephens9c396a72008-06-04 17:36:58 -07002382 else
2383 destaddr = msg_destnode(inmsg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002384
Per Lidenb97bf3f2006-01-02 19:04:38 +01002385 /* Prepare reusable fragment header: */
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002386 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
Allan Stephens75715212008-06-04 17:37:34 -07002387 INT_H_SIZE, destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002388
2389 /* Chop up message: */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002390 while (rest > 0) {
2391 struct sk_buff *fragm;
2392
2393 if (rest <= fragm_sz) {
2394 fragm_sz = rest;
2395 msg_set_type(&fragm_hdr, LAST_FRAGMENT);
2396 }
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002397 fragm = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002398 if (fragm == NULL) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002399 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002400 while (buf_chain) {
2401 buf = buf_chain;
2402 buf_chain = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002403 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002404 }
2405 return -ENOMEM;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002406 }
2407 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
Allan Stephens77561552011-04-17 13:06:23 -04002408 fragm_no++;
2409 msg_set_fragm_no(&fragm_hdr, fragm_no);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002410 skb_copy_to_linear_data(fragm, &fragm_hdr, INT_H_SIZE);
2411 skb_copy_to_linear_data_offset(fragm, INT_H_SIZE, crs,
2412 fragm_sz);
Allan Stephens77561552011-04-17 13:06:23 -04002413 buf_chain_tail->next = fragm;
2414 buf_chain_tail = fragm;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002415
Per Lidenb97bf3f2006-01-02 19:04:38 +01002416 rest -= fragm_sz;
2417 crs += fragm_sz;
2418 msg_set_type(&fragm_hdr, FRAGMENT);
2419 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002420 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002421
2422 /* Append chain of fragments to send queue & send them */
Allan Stephens77561552011-04-17 13:06:23 -04002423 l_ptr->long_msg_seq_no++;
2424 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
2425 l_ptr->stats.sent_fragments += fragm_no;
2426 l_ptr->stats.sent_fragmented++;
2427 tipc_link_push_queue(l_ptr);
2428
Per Lidenb97bf3f2006-01-02 19:04:38 +01002429 return dsz;
2430}
2431
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002432/*
2433 * A pending message being re-assembled must store certain values
2434 * to handle subsequent fragments correctly. The following functions
Per Lidenb97bf3f2006-01-02 19:04:38 +01002435 * help storing these values in unused, available fields in the
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002436 * pending message. This makes dynamic memory allocation unnecessary.
Per Lidenb97bf3f2006-01-02 19:04:38 +01002437 */
Sam Ravnborg05790c62006-03-20 22:37:04 -08002438static void set_long_msg_seqno(struct sk_buff *buf, u32 seqno)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002439{
2440 msg_set_seqno(buf_msg(buf), seqno);
2441}
2442
Sam Ravnborg05790c62006-03-20 22:37:04 -08002443static u32 get_fragm_size(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002444{
2445 return msg_ack(buf_msg(buf));
2446}
2447
Sam Ravnborg05790c62006-03-20 22:37:04 -08002448static void set_fragm_size(struct sk_buff *buf, u32 sz)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002449{
2450 msg_set_ack(buf_msg(buf), sz);
2451}
2452
Sam Ravnborg05790c62006-03-20 22:37:04 -08002453static u32 get_expected_frags(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002454{
2455 return msg_bcast_ack(buf_msg(buf));
2456}
2457
Sam Ravnborg05790c62006-03-20 22:37:04 -08002458static void set_expected_frags(struct sk_buff *buf, u32 exp)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002459{
2460 msg_set_bcast_ack(buf_msg(buf), exp);
2461}
2462
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002463/*
2464 * tipc_link_recv_fragment(): Called with node lock on. Returns
Per Lidenb97bf3f2006-01-02 19:04:38 +01002465 * the reassembled buffer if message is complete.
2466 */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002467int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
Per Liden4323add2006-01-18 00:38:21 +01002468 struct tipc_msg **m)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002469{
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002470 struct sk_buff *prev = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002471 struct sk_buff *fbuf = *fb;
2472 struct tipc_msg *fragm = buf_msg(fbuf);
2473 struct sk_buff *pbuf = *pending;
2474 u32 long_msg_seq_no = msg_long_msgno(fragm);
2475
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002476 *fb = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002477
2478 /* Is there an incomplete message waiting for this fragment? */
Allan Stephensf9057302011-10-24 16:03:12 -04002479 while (pbuf && ((buf_seqno(pbuf) != long_msg_seq_no) ||
Joe Perchesf64f9e72009-11-29 16:55:45 -08002480 (msg_orignode(fragm) != msg_orignode(buf_msg(pbuf))))) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002481 prev = pbuf;
2482 pbuf = pbuf->next;
2483 }
2484
2485 if (!pbuf && (msg_type(fragm) == FIRST_FRAGMENT)) {
2486 struct tipc_msg *imsg = (struct tipc_msg *)msg_data(fragm);
2487 u32 msg_sz = msg_size(imsg);
2488 u32 fragm_sz = msg_data_sz(fragm);
Dan Carpenter6bf15192013-05-06 09:31:17 +00002489 u32 exp_fragm_cnt;
Allan Stephens741d9eb2011-05-31 15:03:18 -04002490 u32 max = TIPC_MAX_USER_MSG_SIZE + NAMED_H_SIZE;
Dan Carpenter6bf15192013-05-06 09:31:17 +00002491
Per Lidenb97bf3f2006-01-02 19:04:38 +01002492 if (msg_type(imsg) == TIPC_MCAST_MSG)
2493 max = TIPC_MAX_USER_MSG_SIZE + MCAST_H_SIZE;
Dan Carpenter6bf15192013-05-06 09:31:17 +00002494 if (fragm_sz == 0 || msg_size(imsg) > max) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002495 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002496 return 0;
2497 }
Dan Carpenter6bf15192013-05-06 09:31:17 +00002498 exp_fragm_cnt = msg_sz / fragm_sz + !!(msg_sz % fragm_sz);
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002499 pbuf = tipc_buf_acquire(msg_size(imsg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002500 if (pbuf != NULL) {
2501 pbuf->next = *pending;
2502 *pending = pbuf;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002503 skb_copy_to_linear_data(pbuf, imsg,
2504 msg_data_sz(fragm));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002505 /* Prepare buffer for subsequent fragments. */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002506 set_long_msg_seqno(pbuf, long_msg_seq_no);
Allan Stephens0e659672010-12-31 18:59:32 +00002507 set_fragm_size(pbuf, fragm_sz);
2508 set_expected_frags(pbuf, exp_fragm_cnt - 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002509 } else {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002510 pr_debug("Link unable to reassemble fragmented message\n");
Allan Stephens5f6d9122011-11-04 13:24:29 -04002511 kfree_skb(fbuf);
Allan Stephensb76b27c2011-10-27 16:31:26 -04002512 return -1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002513 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002514 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002515 return 0;
2516 } else if (pbuf && (msg_type(fragm) != FIRST_FRAGMENT)) {
2517 u32 dsz = msg_data_sz(fragm);
2518 u32 fsz = get_fragm_size(pbuf);
2519 u32 crs = ((msg_fragm_no(fragm) - 1) * fsz);
2520 u32 exp_frags = get_expected_frags(pbuf) - 1;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002521 skb_copy_to_linear_data_offset(pbuf, crs,
2522 msg_data(fragm), dsz);
Allan Stephens5f6d9122011-11-04 13:24:29 -04002523 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002524
2525 /* Is message complete? */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002526 if (exp_frags == 0) {
2527 if (prev)
2528 prev->next = pbuf->next;
2529 else
2530 *pending = pbuf->next;
2531 msg_reset_reroute_cnt(buf_msg(pbuf));
2532 *fb = pbuf;
2533 *m = buf_msg(pbuf);
2534 return 1;
2535 }
Allan Stephens0e659672010-12-31 18:59:32 +00002536 set_expected_frags(pbuf, exp_frags);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002537 return 0;
2538 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002539 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002540 return 0;
2541}
2542
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002543static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002544{
Allan Stephens5413b4c2011-01-18 13:24:55 -05002545 if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL))
2546 return;
2547
Per Lidenb97bf3f2006-01-02 19:04:38 +01002548 l_ptr->tolerance = tolerance;
2549 l_ptr->continuity_interval =
2550 ((tolerance / 4) > 500) ? 500 : tolerance / 4;
2551 l_ptr->abort_limit = tolerance / (l_ptr->continuity_interval / 4);
2552}
2553
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002554void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002555{
2556 /* Data messages from this node, inclusive FIRST_FRAGM */
Allan Stephens06d82c92008-03-06 15:06:55 -08002557 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE] = window;
2558 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE] = (window / 3) * 4;
2559 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE] = (window / 3) * 5;
2560 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE] = (window / 3) * 6;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002561 /* Transiting data messages,inclusive FIRST_FRAGM */
Allan Stephens06d82c92008-03-06 15:06:55 -08002562 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE + 4] = 300;
2563 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE + 4] = 600;
2564 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;
2565 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002566 l_ptr->queue_limit[CONN_MANAGER] = 1200;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002567 l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;
2568 l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;
2569 /* FRAGMENT and LAST_FRAGMENT packets */
2570 l_ptr->queue_limit[MSG_FRAGMENTER] = 4000;
2571}
2572
2573/**
2574 * link_find_link - locate link by name
Ben Hutchings2c530402012-07-10 10:55:09 +00002575 * @name: ptr to link name string
2576 * @node: ptr to area to be filled with ptr to associated node
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002577 *
Per Liden4323add2006-01-18 00:38:21 +01002578 * Caller must hold 'tipc_net_lock' to ensure node and bearer are not deleted;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002579 * this also prevents link deletion.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002580 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002581 * Returns pointer to link (or 0 if invalid link name).
2582 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002583static struct tipc_link *link_find_link(const char *name,
2584 struct tipc_node **node)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002585{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002586 struct tipc_link_name link_name_parts;
Allan Stephens2d627b92011-01-07 13:00:11 -05002587 struct tipc_bearer *b_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002588 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002589
2590 if (!link_name_validate(name, &link_name_parts))
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002591 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002592
Per Liden4323add2006-01-18 00:38:21 +01002593 b_ptr = tipc_bearer_find_interface(link_name_parts.if_local);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002594 if (!b_ptr)
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002595 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002596
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002597 *node = tipc_node_find(link_name_parts.addr_peer);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002598 if (!*node)
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002599 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002600
2601 l_ptr = (*node)->links[b_ptr->identity];
2602 if (!l_ptr || strcmp(l_ptr->name, name))
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002603 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002604
2605 return l_ptr;
2606}
2607
Allan Stephens5c216e12011-10-18 11:34:29 -04002608/**
2609 * link_value_is_valid -- validate proposed link tolerance/priority/window
2610 *
Ben Hutchings2c530402012-07-10 10:55:09 +00002611 * @cmd: value type (TIPC_CMD_SET_LINK_*)
2612 * @new_value: the new value
Allan Stephens5c216e12011-10-18 11:34:29 -04002613 *
2614 * Returns 1 if value is within range, 0 if not.
2615 */
Allan Stephens5c216e12011-10-18 11:34:29 -04002616static int link_value_is_valid(u16 cmd, u32 new_value)
2617{
2618 switch (cmd) {
2619 case TIPC_CMD_SET_LINK_TOL:
2620 return (new_value >= TIPC_MIN_LINK_TOL) &&
2621 (new_value <= TIPC_MAX_LINK_TOL);
2622 case TIPC_CMD_SET_LINK_PRI:
2623 return (new_value <= TIPC_MAX_LINK_PRI);
2624 case TIPC_CMD_SET_LINK_WINDOW:
2625 return (new_value >= TIPC_MIN_LINK_WIN) &&
2626 (new_value <= TIPC_MAX_LINK_WIN);
2627 }
2628 return 0;
2629}
2630
Allan Stephens5c216e12011-10-18 11:34:29 -04002631/**
2632 * link_cmd_set_value - change priority/tolerance/window for link/bearer/media
Ben Hutchings2c530402012-07-10 10:55:09 +00002633 * @name: ptr to link, bearer, or media name
2634 * @new_value: new value of link, bearer, or media setting
2635 * @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*)
Allan Stephens5c216e12011-10-18 11:34:29 -04002636 *
2637 * Caller must hold 'tipc_net_lock' to ensure link/bearer/media is not deleted.
2638 *
2639 * Returns 0 if value updated and negative value on error.
2640 */
Allan Stephens5c216e12011-10-18 11:34:29 -04002641static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd)
2642{
2643 struct tipc_node *node;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002644 struct tipc_link *l_ptr;
Allan Stephens5c216e12011-10-18 11:34:29 -04002645 struct tipc_bearer *b_ptr;
Paul Gortmaker358a0d12011-12-29 20:19:42 -05002646 struct tipc_media *m_ptr;
Allan Stephens5c216e12011-10-18 11:34:29 -04002647
2648 l_ptr = link_find_link(name, &node);
2649 if (l_ptr) {
2650 /*
2651 * acquire node lock for tipc_link_send_proto_msg().
2652 * see "TIPC locking policy" in net.c.
2653 */
2654 tipc_node_lock(node);
2655 switch (cmd) {
2656 case TIPC_CMD_SET_LINK_TOL:
2657 link_set_supervision_props(l_ptr, new_value);
2658 tipc_link_send_proto_msg(l_ptr,
2659 STATE_MSG, 0, 0, new_value, 0, 0);
2660 break;
2661 case TIPC_CMD_SET_LINK_PRI:
2662 l_ptr->priority = new_value;
2663 tipc_link_send_proto_msg(l_ptr,
2664 STATE_MSG, 0, 0, 0, new_value, 0);
2665 break;
2666 case TIPC_CMD_SET_LINK_WINDOW:
2667 tipc_link_set_queue_limits(l_ptr, new_value);
2668 break;
2669 }
2670 tipc_node_unlock(node);
2671 return 0;
2672 }
2673
2674 b_ptr = tipc_bearer_find(name);
2675 if (b_ptr) {
2676 switch (cmd) {
2677 case TIPC_CMD_SET_LINK_TOL:
2678 b_ptr->tolerance = new_value;
2679 return 0;
2680 case TIPC_CMD_SET_LINK_PRI:
2681 b_ptr->priority = new_value;
2682 return 0;
2683 case TIPC_CMD_SET_LINK_WINDOW:
2684 b_ptr->window = new_value;
2685 return 0;
2686 }
2687 return -EINVAL;
2688 }
2689
2690 m_ptr = tipc_media_find(name);
2691 if (!m_ptr)
2692 return -ENODEV;
2693 switch (cmd) {
2694 case TIPC_CMD_SET_LINK_TOL:
2695 m_ptr->tolerance = new_value;
2696 return 0;
2697 case TIPC_CMD_SET_LINK_PRI:
2698 m_ptr->priority = new_value;
2699 return 0;
2700 case TIPC_CMD_SET_LINK_WINDOW:
2701 m_ptr->window = new_value;
2702 return 0;
2703 }
2704 return -EINVAL;
2705}
2706
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002707struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space,
Per Liden4323add2006-01-18 00:38:21 +01002708 u16 cmd)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002709{
2710 struct tipc_link_config *args;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002711 u32 new_value;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002712 int res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002713
2714 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_CONFIG))
Per Liden4323add2006-01-18 00:38:21 +01002715 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002716
2717 args = (struct tipc_link_config *)TLV_DATA(req_tlv_area);
2718 new_value = ntohl(args->value);
2719
Allan Stephens5c216e12011-10-18 11:34:29 -04002720 if (!link_value_is_valid(cmd, new_value))
2721 return tipc_cfg_reply_error_string(
2722 "cannot change, value invalid");
2723
Per Liden4323add2006-01-18 00:38:21 +01002724 if (!strcmp(args->name, tipc_bclink_name)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002725 if ((cmd == TIPC_CMD_SET_LINK_WINDOW) &&
Per Liden4323add2006-01-18 00:38:21 +01002726 (tipc_bclink_set_queue_limits(new_value) == 0))
2727 return tipc_cfg_reply_none();
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002728 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
Per Liden4323add2006-01-18 00:38:21 +01002729 " (cannot change setting on broadcast link)");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002730 }
2731
Per Liden4323add2006-01-18 00:38:21 +01002732 read_lock_bh(&tipc_net_lock);
Allan Stephens5c216e12011-10-18 11:34:29 -04002733 res = link_cmd_set_value(args->name, new_value, cmd);
Per Liden4323add2006-01-18 00:38:21 +01002734 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002735 if (res)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002736 return tipc_cfg_reply_error_string("cannot change link setting");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002737
Per Liden4323add2006-01-18 00:38:21 +01002738 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002739}
2740
2741/**
2742 * link_reset_statistics - reset link statistics
2743 * @l_ptr: pointer to link
2744 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002745static void link_reset_statistics(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002746{
2747 memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));
2748 l_ptr->stats.sent_info = l_ptr->next_out_no;
2749 l_ptr->stats.recv_info = l_ptr->next_in_no;
2750}
2751
Per Liden4323add2006-01-18 00:38:21 +01002752struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002753{
2754 char *link_name;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002755 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07002756 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002757
2758 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
Per Liden4323add2006-01-18 00:38:21 +01002759 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002760
2761 link_name = (char *)TLV_DATA(req_tlv_area);
Per Liden4323add2006-01-18 00:38:21 +01002762 if (!strcmp(link_name, tipc_bclink_name)) {
2763 if (tipc_bclink_reset_stats())
2764 return tipc_cfg_reply_error_string("link not found");
2765 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002766 }
2767
Per Liden4323add2006-01-18 00:38:21 +01002768 read_lock_bh(&tipc_net_lock);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002769 l_ptr = link_find_link(link_name, &node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002770 if (!l_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01002771 read_unlock_bh(&tipc_net_lock);
2772 return tipc_cfg_reply_error_string("link not found");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002773 }
2774
Per Liden4323add2006-01-18 00:38:21 +01002775 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002776 link_reset_statistics(l_ptr);
Per Liden4323add2006-01-18 00:38:21 +01002777 tipc_node_unlock(node);
2778 read_unlock_bh(&tipc_net_lock);
2779 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002780}
2781
2782/**
2783 * percent - convert count to a percentage of total (rounding up or down)
2784 */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002785static u32 percent(u32 count, u32 total)
2786{
2787 return (count * 100 + (total / 2)) / total;
2788}
2789
2790/**
Per Liden4323add2006-01-18 00:38:21 +01002791 * tipc_link_stats - print link statistics
Per Lidenb97bf3f2006-01-02 19:04:38 +01002792 * @name: link name
2793 * @buf: print buffer area
2794 * @buf_size: size of print buffer area
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002795 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002796 * Returns length of print buffer data string (or 0 if error)
2797 */
Per Liden4323add2006-01-18 00:38:21 +01002798static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002799{
Erik Hugnedc1aed32012-06-29 00:50:23 -04002800 struct tipc_link *l;
2801 struct tipc_stats *s;
David S. Miller6c000552008-09-02 23:38:32 -07002802 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002803 char *status;
2804 u32 profile_total = 0;
Erik Hugnedc1aed32012-06-29 00:50:23 -04002805 int ret;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002806
Per Liden4323add2006-01-18 00:38:21 +01002807 if (!strcmp(name, tipc_bclink_name))
2808 return tipc_bclink_stats(buf, buf_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002809
Per Liden4323add2006-01-18 00:38:21 +01002810 read_lock_bh(&tipc_net_lock);
Erik Hugnedc1aed32012-06-29 00:50:23 -04002811 l = link_find_link(name, &node);
2812 if (!l) {
Per Liden4323add2006-01-18 00:38:21 +01002813 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002814 return 0;
2815 }
Per Liden4323add2006-01-18 00:38:21 +01002816 tipc_node_lock(node);
Erik Hugnedc1aed32012-06-29 00:50:23 -04002817 s = &l->stats;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002818
Erik Hugnedc1aed32012-06-29 00:50:23 -04002819 if (tipc_link_is_active(l))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002820 status = "ACTIVE";
Erik Hugnedc1aed32012-06-29 00:50:23 -04002821 else if (tipc_link_is_up(l))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002822 status = "STANDBY";
2823 else
2824 status = "DEFUNCT";
Erik Hugnedc1aed32012-06-29 00:50:23 -04002825
2826 ret = tipc_snprintf(buf, buf_size, "Link <%s>\n"
2827 " %s MTU:%u Priority:%u Tolerance:%u ms"
2828 " Window:%u packets\n",
2829 l->name, status, l->max_pkt, l->priority,
2830 l->tolerance, l->queue_limit[0]);
2831
2832 ret += tipc_snprintf(buf + ret, buf_size - ret,
2833 " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
2834 l->next_in_no - s->recv_info, s->recv_fragments,
2835 s->recv_fragmented, s->recv_bundles,
2836 s->recv_bundled);
2837
2838 ret += tipc_snprintf(buf + ret, buf_size - ret,
2839 " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
2840 l->next_out_no - s->sent_info, s->sent_fragments,
2841 s->sent_fragmented, s->sent_bundles,
2842 s->sent_bundled);
2843
2844 profile_total = s->msg_length_counts;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002845 if (!profile_total)
2846 profile_total = 1;
Erik Hugnedc1aed32012-06-29 00:50:23 -04002847
2848 ret += tipc_snprintf(buf + ret, buf_size - ret,
2849 " TX profile sample:%u packets average:%u octets\n"
2850 " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
2851 "-16384:%u%% -32768:%u%% -66000:%u%%\n",
2852 s->msg_length_counts,
2853 s->msg_lengths_total / profile_total,
2854 percent(s->msg_length_profile[0], profile_total),
2855 percent(s->msg_length_profile[1], profile_total),
2856 percent(s->msg_length_profile[2], profile_total),
2857 percent(s->msg_length_profile[3], profile_total),
2858 percent(s->msg_length_profile[4], profile_total),
2859 percent(s->msg_length_profile[5], profile_total),
2860 percent(s->msg_length_profile[6], profile_total));
2861
2862 ret += tipc_snprintf(buf + ret, buf_size - ret,
2863 " RX states:%u probes:%u naks:%u defs:%u"
2864 " dups:%u\n", s->recv_states, s->recv_probes,
2865 s->recv_nacks, s->deferred_recv, s->duplicates);
2866
2867 ret += tipc_snprintf(buf + ret, buf_size - ret,
2868 " TX states:%u probes:%u naks:%u acks:%u"
2869 " dups:%u\n", s->sent_states, s->sent_probes,
2870 s->sent_nacks, s->sent_acks, s->retransmitted);
2871
2872 ret += tipc_snprintf(buf + ret, buf_size - ret,
Ying Xue3c294cb2012-11-15 11:34:45 +08002873 " Congestion link:%u Send queue"
2874 " max:%u avg:%u\n", s->link_congs,
Erik Hugnedc1aed32012-06-29 00:50:23 -04002875 s->max_queue_sz, s->queue_sz_counts ?
2876 (s->accu_queue_sz / s->queue_sz_counts) : 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002877
Per Liden4323add2006-01-18 00:38:21 +01002878 tipc_node_unlock(node);
2879 read_unlock_bh(&tipc_net_lock);
Erik Hugnedc1aed32012-06-29 00:50:23 -04002880 return ret;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002881}
2882
Per Liden4323add2006-01-18 00:38:21 +01002883struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002884{
2885 struct sk_buff *buf;
2886 struct tlv_desc *rep_tlv;
2887 int str_len;
Erik Hugnedc1aed32012-06-29 00:50:23 -04002888 int pb_len;
2889 char *pb;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002890
2891 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
Per Liden4323add2006-01-18 00:38:21 +01002892 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002893
Erik Hugnedc1aed32012-06-29 00:50:23 -04002894 buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002895 if (!buf)
2896 return NULL;
2897
2898 rep_tlv = (struct tlv_desc *)buf->data;
Erik Hugnedc1aed32012-06-29 00:50:23 -04002899 pb = TLV_DATA(rep_tlv);
2900 pb_len = ULTRA_STRING_MAX_LEN;
Per Liden4323add2006-01-18 00:38:21 +01002901 str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area),
Erik Hugnedc1aed32012-06-29 00:50:23 -04002902 pb, pb_len);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002903 if (!str_len) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002904 kfree_skb(buf);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002905 return tipc_cfg_reply_error_string("link not found");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002906 }
Erik Hugnedc1aed32012-06-29 00:50:23 -04002907 str_len += 1; /* for "\0" */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002908 skb_put(buf, TLV_SPACE(str_len));
2909 TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
2910
2911 return buf;
2912}
2913
Per Lidenb97bf3f2006-01-02 19:04:38 +01002914/**
Per Liden4323add2006-01-18 00:38:21 +01002915 * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination
Per Lidenb97bf3f2006-01-02 19:04:38 +01002916 * @dest: network address of destination node
2917 * @selector: used to select from set of active links
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002918 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002919 * If no active link can be found, uses default maximum packet size.
2920 */
Per Liden4323add2006-01-18 00:38:21 +01002921u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002922{
David S. Miller6c000552008-09-02 23:38:32 -07002923 struct tipc_node *n_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002924 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002925 u32 res = MAX_PKT_DEFAULT;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002926
Per Lidenb97bf3f2006-01-02 19:04:38 +01002927 if (dest == tipc_own_addr)
2928 return MAX_MSG_SIZE;
2929
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002930 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +00002931 n_ptr = tipc_node_find(dest);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002932 if (n_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01002933 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002934 l_ptr = n_ptr->active_links[selector & 1];
2935 if (l_ptr)
Allan Stephens15e979d2010-05-11 14:30:10 +00002936 res = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01002937 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002938 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002939 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002940 return res;
2941}
2942
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002943static void link_print(struct tipc_link *l_ptr, const char *str)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002944{
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002945 pr_info("%s Link %x<%s>:", str, l_ptr->addr, l_ptr->b_ptr->name);
Allan Stephens8d64a5b2010-12-31 18:59:27 +00002946
Per Lidenb97bf3f2006-01-02 19:04:38 +01002947 if (link_working_unknown(l_ptr))
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002948 pr_cont(":WU\n");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00002949 else if (link_reset_reset(l_ptr))
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002950 pr_cont(":RR\n");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00002951 else if (link_reset_unknown(l_ptr))
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002952 pr_cont(":RU\n");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00002953 else if (link_working_working(l_ptr))
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002954 pr_cont(":WW\n");
2955 else
2956 pr_cont("\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002957}