blob: daa6080a2a0c459a663f6453247a838f43fb0eca [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
Allan Stephens23dd4cc2011-01-07 11:43:40 -05005 * Copyright (c) 2004-2007, 2010-2011, 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 Stephensf882cb72011-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/*
1060 * tipc_send_buf_fast: Entry for data messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001061 * destination node is known and the header is complete,
1062 * inclusive total message length.
1063 * Returns user data length.
1064 */
1065int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode)
1066{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001067 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07001068 struct tipc_node *n_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001069 int res;
1070 u32 selector = msg_origport(buf_msg(buf)) & 1;
1071 u32 dummy;
1072
Per Liden4323add2006-01-18 00:38:21 +01001073 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +00001074 n_ptr = tipc_node_find(destnode);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001075 if (likely(n_ptr)) {
Per Liden4323add2006-01-18 00:38:21 +01001076 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001077 l_ptr = n_ptr->active_links[selector];
Per Lidenb97bf3f2006-01-02 19:04:38 +01001078 if (likely(l_ptr)) {
1079 res = link_send_buf_fast(l_ptr, buf, &dummy);
Per Liden4323add2006-01-18 00:38:21 +01001080 tipc_node_unlock(n_ptr);
1081 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001082 return res;
1083 }
Per Liden4323add2006-01-18 00:38:21 +01001084 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001085 }
Per Liden4323add2006-01-18 00:38:21 +01001086 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001087 res = msg_data_sz(buf_msg(buf));
1088 tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
1089 return res;
1090}
1091
1092
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001093/*
1094 * tipc_link_send_sections_fast: Entry for messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001095 * destination processor is known and the header is complete,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001096 * except for total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001097 * Returns user data length or errno.
1098 */
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001099int tipc_link_send_sections_fast(struct tipc_port *sender,
Per Liden4323add2006-01-18 00:38:21 +01001100 struct iovec const *msg_sect,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001101 const u32 num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001102 unsigned int total_len,
Per Liden4323add2006-01-18 00:38:21 +01001103 u32 destaddr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001104{
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001105 struct tipc_msg *hdr = &sender->phdr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001106 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001107 struct sk_buff *buf;
David S. Miller6c000552008-09-02 23:38:32 -07001108 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001109 int res;
1110 u32 selector = msg_origport(hdr) & 1;
1111
Per Lidenb97bf3f2006-01-02 19:04:38 +01001112again:
1113 /*
1114 * Try building message using port's max_pkt hint.
1115 * (Must not hold any locks while building message.)
1116 */
Allan Stephens26896902011-04-21 10:42:07 -05001117 res = tipc_msg_build(hdr, msg_sect, num_sect, total_len,
1118 sender->max_pkt, !sender->user_port, &buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001119
Per Liden4323add2006-01-18 00:38:21 +01001120 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +00001121 node = tipc_node_find(destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001122 if (likely(node)) {
Per Liden4323add2006-01-18 00:38:21 +01001123 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001124 l_ptr = node->active_links[selector];
1125 if (likely(l_ptr)) {
1126 if (likely(buf)) {
1127 res = link_send_buf_fast(l_ptr, buf,
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001128 &sender->max_pkt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001129exit:
Per Liden4323add2006-01-18 00:38:21 +01001130 tipc_node_unlock(node);
1131 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001132 return res;
1133 }
1134
1135 /* Exit if build request was invalid */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001136 if (unlikely(res < 0))
1137 goto exit;
1138
1139 /* Exit if link (or bearer) is congested */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001140 if (link_congested(l_ptr) ||
Ying Xue3c294cb2012-11-15 11:34:45 +08001141 tipc_bearer_blocked(l_ptr->b_ptr)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001142 res = link_schedule_port(l_ptr,
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001143 sender->ref, res);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001144 goto exit;
1145 }
1146
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001147 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001148 * Message size exceeds max_pkt hint; update hint,
1149 * then re-try fast path or fragment the message
1150 */
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001151 sender->max_pkt = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01001152 tipc_node_unlock(node);
1153 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001154
1155
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001156 if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001157 goto again;
1158
1159 return link_send_sections_long(sender, msg_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001160 num_sect, total_len,
1161 destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001162 }
Per Liden4323add2006-01-18 00:38:21 +01001163 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001164 }
Per Liden4323add2006-01-18 00:38:21 +01001165 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001166
1167 /* Couldn't find a link to the destination node */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001168 if (buf)
1169 return tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
1170 if (res >= 0)
Per Liden4323add2006-01-18 00:38:21 +01001171 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001172 total_len, TIPC_ERR_NO_NODE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001173 return res;
1174}
1175
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001176/*
1177 * link_send_sections_long(): Entry for long messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001178 * destination node is known and the header is complete,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001179 * inclusive total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001180 * Link and bearer congestion status have been checked to be ok,
1181 * and are ignored if they change.
1182 *
1183 * Note that fragments do not use the full link MTU so that they won't have
1184 * to undergo refragmentation if link changeover causes them to be sent
1185 * over another link with an additional tunnel header added as prefix.
1186 * (Refragmentation will still occur if the other link has a smaller MTU.)
1187 *
1188 * Returns user data length or errno.
1189 */
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001190static int link_send_sections_long(struct tipc_port *sender,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001191 struct iovec const *msg_sect,
1192 u32 num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001193 unsigned int total_len,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001194 u32 destaddr)
1195{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001196 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07001197 struct tipc_node *node;
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001198 struct tipc_msg *hdr = &sender->phdr;
Allan Stephens26896902011-04-21 10:42:07 -05001199 u32 dsz = total_len;
Allan Stephens0e659672010-12-31 18:59:32 +00001200 u32 max_pkt, fragm_sz, rest;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001201 struct tipc_msg fragm_hdr;
Allan Stephens0e659672010-12-31 18:59:32 +00001202 struct sk_buff *buf, *buf_chain, *prev;
1203 u32 fragm_crs, fragm_rest, hsz, sect_rest;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001204 const unchar *sect_crs;
1205 int curr_sect;
1206 u32 fragm_no;
1207
1208again:
1209 fragm_no = 1;
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001210 max_pkt = sender->max_pkt - INT_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001211 /* leave room for tunnel header in case of link changeover */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001212 fragm_sz = max_pkt - INT_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001213 /* leave room for fragmentation header in each fragment */
1214 rest = dsz;
1215 fragm_crs = 0;
1216 fragm_rest = 0;
1217 sect_rest = 0;
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08001218 sect_crs = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001219 curr_sect = -1;
1220
Paul Gortmaker617d3c72012-04-30 15:29:02 -04001221 /* Prepare reusable fragment header */
Allan Stephensc68ca7b2010-05-11 14:30:12 +00001222 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
Allan Stephens75715212008-06-04 17:37:34 -07001223 INT_H_SIZE, msg_destnode(hdr));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001224 msg_set_size(&fragm_hdr, max_pkt);
1225 msg_set_fragm_no(&fragm_hdr, 1);
1226
Paul Gortmaker617d3c72012-04-30 15:29:02 -04001227 /* Prepare header of first fragment */
stephen hemminger31e3c3f2010-10-13 13:20:35 +00001228 buf_chain = buf = tipc_buf_acquire(max_pkt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001229 if (!buf)
1230 return -ENOMEM;
1231 buf->next = NULL;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001232 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001233 hsz = msg_hdr_sz(hdr);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001234 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, hdr, hsz);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001235
Paul Gortmaker617d3c72012-04-30 15:29:02 -04001236 /* Chop up message */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001237 fragm_crs = INT_H_SIZE + hsz;
1238 fragm_rest = fragm_sz - hsz;
1239
1240 do { /* For all sections */
1241 u32 sz;
1242
1243 if (!sect_rest) {
1244 sect_rest = msg_sect[++curr_sect].iov_len;
1245 sect_crs = (const unchar *)msg_sect[curr_sect].iov_base;
1246 }
1247
1248 if (sect_rest < fragm_rest)
1249 sz = sect_rest;
1250 else
1251 sz = fragm_rest;
1252
1253 if (likely(!sender->user_port)) {
1254 if (copy_from_user(buf->data + fragm_crs, sect_crs, sz)) {
1255error:
1256 for (; buf_chain; buf_chain = buf) {
1257 buf = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001258 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001259 }
1260 return -EFAULT;
1261 }
1262 } else
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001263 skb_copy_to_linear_data_offset(buf, fragm_crs,
1264 sect_crs, sz);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001265 sect_crs += sz;
1266 sect_rest -= sz;
1267 fragm_crs += sz;
1268 fragm_rest -= sz;
1269 rest -= sz;
1270
1271 if (!fragm_rest && rest) {
1272
1273 /* Initiate new fragment: */
1274 if (rest <= fragm_sz) {
1275 fragm_sz = rest;
Allan Stephens0e659672010-12-31 18:59:32 +00001276 msg_set_type(&fragm_hdr, LAST_FRAGMENT);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001277 } else {
1278 msg_set_type(&fragm_hdr, FRAGMENT);
1279 }
1280 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
1281 msg_set_fragm_no(&fragm_hdr, ++fragm_no);
1282 prev = buf;
stephen hemminger31e3c3f2010-10-13 13:20:35 +00001283 buf = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001284 if (!buf)
1285 goto error;
1286
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001287 buf->next = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001288 prev->next = buf;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001289 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001290 fragm_crs = INT_H_SIZE;
1291 fragm_rest = fragm_sz;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001292 }
Allan Stephens0e659672010-12-31 18:59:32 +00001293 } while (rest > 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001294
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001295 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001296 * Now we have a buffer chain. Select a link and check
1297 * that packet size is still OK
1298 */
Allan Stephens51a8e4d2010-12-31 18:59:18 +00001299 node = tipc_node_find(destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001300 if (likely(node)) {
Per Liden4323add2006-01-18 00:38:21 +01001301 tipc_node_lock(node);
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001302 l_ptr = node->active_links[sender->ref & 1];
Per Lidenb97bf3f2006-01-02 19:04:38 +01001303 if (!l_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01001304 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001305 goto reject;
1306 }
Allan Stephens15e979d2010-05-11 14:30:10 +00001307 if (l_ptr->max_pkt < max_pkt) {
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001308 sender->max_pkt = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01001309 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001310 for (; buf_chain; buf_chain = buf) {
1311 buf = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001312 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001313 }
1314 goto again;
1315 }
1316 } else {
1317reject:
1318 for (; buf_chain; buf_chain = buf) {
1319 buf = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001320 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001321 }
Per Liden4323add2006-01-18 00:38:21 +01001322 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001323 total_len, TIPC_ERR_NO_NODE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001324 }
1325
Allan Stephensdc63d912011-04-21 11:50:42 -04001326 /* Append chain of fragments to send queue & send them */
Allan Stephense0f08592011-04-17 11:44:24 -04001327 l_ptr->long_msg_seq_no++;
Allan Stephensdc63d912011-04-21 11:50:42 -04001328 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
1329 l_ptr->stats.sent_fragments += fragm_no;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001330 l_ptr->stats.sent_fragmented++;
Per Liden4323add2006-01-18 00:38:21 +01001331 tipc_link_push_queue(l_ptr);
1332 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001333 return dsz;
1334}
1335
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001336/*
Per Liden4323add2006-01-18 00:38:21 +01001337 * tipc_link_push_packet: Push one unsent packet to the media
Per Lidenb97bf3f2006-01-02 19:04:38 +01001338 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001339u32 tipc_link_push_packet(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001340{
1341 struct sk_buff *buf = l_ptr->first_out;
1342 u32 r_q_size = l_ptr->retransm_queue_size;
1343 u32 r_q_head = l_ptr->retransm_queue_head;
1344
1345 /* Step to position where retransmission failed, if any, */
1346 /* consider that buffers may have been released in meantime */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001347 if (r_q_size && buf) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001348 u32 last = lesser(mod(r_q_head + r_q_size),
Per Lidenb97bf3f2006-01-02 19:04:38 +01001349 link_last_sent(l_ptr));
Allan Stephensf9057302011-10-24 16:03:12 -04001350 u32 first = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001351
1352 while (buf && less(first, r_q_head)) {
1353 first = mod(first + 1);
1354 buf = buf->next;
1355 }
1356 l_ptr->retransm_queue_head = r_q_head = first;
1357 l_ptr->retransm_queue_size = r_q_size = mod(last - first);
1358 }
1359
1360 /* Continue retransmission now, if there is anything: */
Neil Hormanca509102010-03-15 07:58:45 +00001361 if (r_q_size && buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001362 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001363 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
Ying Xue3c294cb2012-11-15 11:34:45 +08001364 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
1365 l_ptr->retransm_queue_head = mod(++r_q_head);
1366 l_ptr->retransm_queue_size = --r_q_size;
1367 l_ptr->stats.retransmitted++;
1368 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001369 }
1370
1371 /* Send deferred protocol message, if any: */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001372 buf = l_ptr->proto_msg_queue;
1373 if (buf) {
1374 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
Allan Stephens0e659672010-12-31 18:59:32 +00001375 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
Ying Xue3c294cb2012-11-15 11:34:45 +08001376 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
1377 l_ptr->unacked_window = 0;
1378 kfree_skb(buf);
1379 l_ptr->proto_msg_queue = NULL;
1380 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001381 }
1382
1383 /* Send one deferred data message, if send window not full: */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001384 buf = l_ptr->next_out;
1385 if (buf) {
1386 struct tipc_msg *msg = buf_msg(buf);
1387 u32 next = msg_seqno(msg);
Allan Stephensf9057302011-10-24 16:03:12 -04001388 u32 first = buf_seqno(l_ptr->first_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001389
1390 if (mod(next - first) < l_ptr->queue_limit[0]) {
1391 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001392 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Ying Xue3c294cb2012-11-15 11:34:45 +08001393 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
1394 if (msg_user(msg) == MSG_BUNDLER)
1395 msg_set_type(msg, CLOSED_MSG);
1396 l_ptr->next_out = buf->next;
1397 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001398 }
1399 }
Ying Xue3c294cb2012-11-15 11:34:45 +08001400 return 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001401}
1402
1403/*
1404 * push_queue(): push out the unsent messages of a link where
1405 * congestion has abated. Node is locked
1406 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001407void tipc_link_push_queue(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001408{
1409 u32 res;
1410
Ying Xue3c294cb2012-11-15 11:34:45 +08001411 if (tipc_bearer_blocked(l_ptr->b_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001412 return;
1413
1414 do {
Per Liden4323add2006-01-18 00:38:21 +01001415 res = tipc_link_push_packet(l_ptr);
Allan Stephens0e35fd52008-07-14 22:44:01 -07001416 } while (!res);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001417}
1418
Allan Stephensd356eeb2006-06-25 23:40:01 -07001419static void link_reset_all(unsigned long addr)
1420{
David S. Miller6c000552008-09-02 23:38:32 -07001421 struct tipc_node *n_ptr;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001422 char addr_string[16];
1423 u32 i;
1424
1425 read_lock_bh(&tipc_net_lock);
1426 n_ptr = tipc_node_find((u32)addr);
1427 if (!n_ptr) {
1428 read_unlock_bh(&tipc_net_lock);
1429 return; /* node no longer exists */
1430 }
1431
1432 tipc_node_lock(n_ptr);
1433
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001434 pr_warn("Resetting all links to %s\n",
1435 tipc_addr_string_fill(addr_string, n_ptr->addr));
Allan Stephensd356eeb2006-06-25 23:40:01 -07001436
1437 for (i = 0; i < MAX_BEARERS; i++) {
1438 if (n_ptr->links[i]) {
Allan Stephens8d64a5b2010-12-31 18:59:27 +00001439 link_print(n_ptr->links[i], "Resetting link\n");
Allan Stephensd356eeb2006-06-25 23:40:01 -07001440 tipc_link_reset(n_ptr->links[i]);
1441 }
1442 }
1443
1444 tipc_node_unlock(n_ptr);
1445 read_unlock_bh(&tipc_net_lock);
1446}
1447
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001448static void link_retransmit_failure(struct tipc_link *l_ptr,
1449 struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -07001450{
1451 struct tipc_msg *msg = buf_msg(buf);
1452
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001453 pr_warn("Retransmission failure on link <%s>\n", l_ptr->name);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001454
1455 if (l_ptr->addr) {
Allan Stephensd356eeb2006-06-25 23:40:01 -07001456 /* Handle failure on standard link */
Allan Stephens8d64a5b2010-12-31 18:59:27 +00001457 link_print(l_ptr, "Resetting link\n");
Allan Stephensd356eeb2006-06-25 23:40:01 -07001458 tipc_link_reset(l_ptr);
1459
1460 } else {
Allan Stephensd356eeb2006-06-25 23:40:01 -07001461 /* Handle failure on broadcast link */
David S. Miller6c000552008-09-02 23:38:32 -07001462 struct tipc_node *n_ptr;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001463 char addr_string[16];
1464
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001465 pr_info("Msg seq number: %u, ", msg_seqno(msg));
1466 pr_cont("Outstanding acks: %lu\n",
1467 (unsigned long) TIPC_SKB_CB(buf)->handle);
Jeff Garzik617dbea2006-10-03 16:25:34 -07001468
Allan Stephens01d83ed2011-01-18 13:53:16 -05001469 n_ptr = tipc_bclink_retransmit_to();
Allan Stephensd356eeb2006-06-25 23:40:01 -07001470 tipc_node_lock(n_ptr);
1471
Allan Stephensc68ca7b2010-05-11 14:30:12 +00001472 tipc_addr_string_fill(addr_string, n_ptr->addr);
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001473 pr_info("Broadcast link info for %s\n", addr_string);
Ying Xue389dd9b2012-11-16 13:51:30 +08001474 pr_info("Reception permitted: %d, Acked: %u\n",
1475 n_ptr->bclink.recv_permitted,
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001476 n_ptr->bclink.acked);
1477 pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
1478 n_ptr->bclink.last_in,
1479 n_ptr->bclink.oos_state,
1480 n_ptr->bclink.last_sent);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001481
1482 tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr);
1483
1484 tipc_node_unlock(n_ptr);
1485
1486 l_ptr->stale_count = 0;
1487 }
1488}
1489
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001490void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf,
Per Liden4323add2006-01-18 00:38:21 +01001491 u32 retransmits)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001492{
1493 struct tipc_msg *msg;
1494
Allan Stephensd356eeb2006-06-25 23:40:01 -07001495 if (!buf)
1496 return;
1497
1498 msg = buf_msg(buf);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001499
Ying Xue3c294cb2012-11-15 11:34:45 +08001500 if (tipc_bearer_blocked(l_ptr->b_ptr)) {
Neil Hormanca509102010-03-15 07:58:45 +00001501 if (l_ptr->retransm_queue_size == 0) {
Allan Stephensd356eeb2006-06-25 23:40:01 -07001502 l_ptr->retransm_queue_head = msg_seqno(msg);
1503 l_ptr->retransm_queue_size = retransmits;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001504 } else {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04001505 pr_err("Unexpected retransmit on link %s (qsize=%d)\n",
1506 l_ptr->name, l_ptr->retransm_queue_size);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001507 }
Neil Hormanca509102010-03-15 07:58:45 +00001508 return;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001509 } else {
Ying Xue3c294cb2012-11-15 11:34:45 +08001510 /* Detect repeated retransmit failures on unblocked bearer */
Allan Stephensd356eeb2006-06-25 23:40:01 -07001511 if (l_ptr->last_retransmitted == msg_seqno(msg)) {
1512 if (++l_ptr->stale_count > 100) {
1513 link_retransmit_failure(l_ptr, buf);
1514 return;
1515 }
1516 } else {
1517 l_ptr->last_retransmitted = msg_seqno(msg);
1518 l_ptr->stale_count = 1;
1519 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001520 }
Allan Stephensd356eeb2006-06-25 23:40:01 -07001521
Neil Hormanca509102010-03-15 07:58:45 +00001522 while (retransmits && (buf != l_ptr->next_out) && buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001523 msg = buf_msg(buf);
1524 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001525 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Ying Xue3c294cb2012-11-15 11:34:45 +08001526 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
1527 buf = buf->next;
1528 retransmits--;
1529 l_ptr->stats.retransmitted++;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001530 }
Allan Stephensd356eeb2006-06-25 23:40:01 -07001531
Per Lidenb97bf3f2006-01-02 19:04:38 +01001532 l_ptr->retransm_queue_head = l_ptr->retransm_queue_size = 0;
1533}
1534
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001535/**
Per Lidenb97bf3f2006-01-02 19:04:38 +01001536 * link_insert_deferred_queue - insert deferred messages back into receive chain
1537 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001538static struct sk_buff *link_insert_deferred_queue(struct tipc_link *l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001539 struct sk_buff *buf)
1540{
1541 u32 seq_no;
1542
1543 if (l_ptr->oldest_deferred_in == NULL)
1544 return buf;
1545
Allan Stephensf9057302011-10-24 16:03:12 -04001546 seq_no = buf_seqno(l_ptr->oldest_deferred_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001547 if (seq_no == mod(l_ptr->next_in_no)) {
1548 l_ptr->newest_deferred_in->next = buf;
1549 buf = l_ptr->oldest_deferred_in;
1550 l_ptr->oldest_deferred_in = NULL;
1551 l_ptr->deferred_inqueue_sz = 0;
1552 }
1553 return buf;
1554}
1555
Allan Stephens85035562008-04-15 19:04:54 -07001556/**
1557 * link_recv_buf_validate - validate basic format of received message
1558 *
1559 * This routine ensures a TIPC message has an acceptable header, and at least
1560 * as much data as the header indicates it should. The routine also ensures
1561 * that the entire message header is stored in the main fragment of the message
1562 * buffer, to simplify future access to message header fields.
1563 *
1564 * Note: Having extra info present in the message header or data areas is OK.
1565 * TIPC will ignore the excess, under the assumption that it is optional info
1566 * introduced by a later release of the protocol.
1567 */
Allan Stephens85035562008-04-15 19:04:54 -07001568static int link_recv_buf_validate(struct sk_buff *buf)
1569{
1570 static u32 min_data_hdr_size[8] = {
Allan Stephens741d9eb2011-05-31 15:03:18 -04001571 SHORT_H_SIZE, MCAST_H_SIZE, NAMED_H_SIZE, BASIC_H_SIZE,
Allan Stephens85035562008-04-15 19:04:54 -07001572 MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE
1573 };
1574
1575 struct tipc_msg *msg;
1576 u32 tipc_hdr[2];
1577 u32 size;
1578 u32 hdr_size;
1579 u32 min_hdr_size;
1580
1581 if (unlikely(buf->len < MIN_H_SIZE))
1582 return 0;
1583
1584 msg = skb_header_pointer(buf, 0, sizeof(tipc_hdr), tipc_hdr);
1585 if (msg == NULL)
1586 return 0;
1587
1588 if (unlikely(msg_version(msg) != TIPC_VERSION))
1589 return 0;
1590
1591 size = msg_size(msg);
1592 hdr_size = msg_hdr_sz(msg);
1593 min_hdr_size = msg_isdata(msg) ?
1594 min_data_hdr_size[msg_type(msg)] : INT_H_SIZE;
1595
1596 if (unlikely((hdr_size < min_hdr_size) ||
1597 (size < hdr_size) ||
1598 (buf->len < size) ||
1599 (size - hdr_size > TIPC_MAX_USER_MSG_SIZE)))
1600 return 0;
1601
1602 return pskb_may_pull(buf, hdr_size);
1603}
1604
Allan Stephensb02b69c2010-08-17 11:00:07 +00001605/**
1606 * tipc_recv_msg - process TIPC messages arriving from off-node
1607 * @head: pointer to message buffer chain
1608 * @tb_ptr: pointer to bearer message arrived on
1609 *
1610 * Invoked with no locks held. Bearer pointer must point to a valid bearer
1611 * structure (i.e. cannot be NULL), but bearer can be inactive.
1612 */
Allan Stephens2d627b92011-01-07 13:00:11 -05001613void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *b_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001614{
Per Liden4323add2006-01-18 00:38:21 +01001615 read_lock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001616 while (head) {
David S. Miller6c000552008-09-02 23:38:32 -07001617 struct tipc_node *n_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001618 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001619 struct sk_buff *crs;
1620 struct sk_buff *buf = head;
Allan Stephens85035562008-04-15 19:04:54 -07001621 struct tipc_msg *msg;
1622 u32 seq_no;
1623 u32 ackd;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001624 u32 released = 0;
1625 int type;
1626
Per Lidenb97bf3f2006-01-02 19:04:38 +01001627 head = head->next;
Allan Stephens85035562008-04-15 19:04:54 -07001628
Allan Stephensb02b69c2010-08-17 11:00:07 +00001629 /* Ensure bearer is still enabled */
Allan Stephensb02b69c2010-08-17 11:00:07 +00001630 if (unlikely(!b_ptr->active))
1631 goto cont;
1632
Allan Stephens85035562008-04-15 19:04:54 -07001633 /* Ensure message is well-formed */
Allan Stephens85035562008-04-15 19:04:54 -07001634 if (unlikely(!link_recv_buf_validate(buf)))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001635 goto cont;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001636
Allan Stephensfe13dda2008-04-15 19:03:23 -07001637 /* Ensure message data is a single contiguous unit */
Allan Stephens5f6d9122011-11-04 13:24:29 -04001638 if (unlikely(skb_linearize(buf)))
Allan Stephensfe13dda2008-04-15 19:03:23 -07001639 goto cont;
Allan Stephensfe13dda2008-04-15 19:03:23 -07001640
Allan Stephens85035562008-04-15 19:04:54 -07001641 /* Handle arrival of a non-unicast link message */
Allan Stephens85035562008-04-15 19:04:54 -07001642 msg = buf_msg(buf);
1643
Per Lidenb97bf3f2006-01-02 19:04:38 +01001644 if (unlikely(msg_non_seq(msg))) {
Allan Stephens1265a022008-06-04 17:32:35 -07001645 if (msg_user(msg) == LINK_CONFIG)
1646 tipc_disc_recv_msg(buf, b_ptr);
1647 else
1648 tipc_bclink_recv_pkt(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001649 continue;
1650 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001651
Allan Stephensed33a9c2011-04-05 15:15:04 -04001652 /* Discard unicast link messages destined for another node */
Allan Stephens26008242006-06-25 23:39:31 -07001653 if (unlikely(!msg_short(msg) &&
1654 (msg_destnode(msg) != tipc_own_addr)))
1655 goto cont;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001656
Allan Stephens5a68d5e2010-08-17 11:00:16 +00001657 /* Locate neighboring node that sent message */
Per Liden4323add2006-01-18 00:38:21 +01001658 n_ptr = tipc_node_find(msg_prevnode(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001659 if (unlikely(!n_ptr))
1660 goto cont;
Per Liden4323add2006-01-18 00:38:21 +01001661 tipc_node_lock(n_ptr);
Allan Stephens85035562008-04-15 19:04:54 -07001662
Allan Stephens5a68d5e2010-08-17 11:00:16 +00001663 /* Locate unicast link endpoint that should handle message */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001664 l_ptr = n_ptr->links[b_ptr->identity];
1665 if (unlikely(!l_ptr)) {
Per Liden4323add2006-01-18 00:38:21 +01001666 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001667 goto cont;
1668 }
Allan Stephens85035562008-04-15 19:04:54 -07001669
Allan Stephensb4b56102011-05-27 11:00:51 -04001670 /* Verify that communication with node is currently allowed */
Allan Stephensb4b56102011-05-27 11:00:51 -04001671 if ((n_ptr->block_setup & WAIT_PEER_DOWN) &&
1672 msg_user(msg) == LINK_PROTOCOL &&
1673 (msg_type(msg) == RESET_MSG ||
1674 msg_type(msg) == ACTIVATE_MSG) &&
1675 !msg_redundant_link(msg))
1676 n_ptr->block_setup &= ~WAIT_PEER_DOWN;
1677
1678 if (n_ptr->block_setup) {
1679 tipc_node_unlock(n_ptr);
1680 goto cont;
1681 }
1682
Allan Stephens85035562008-04-15 19:04:54 -07001683 /* Validate message sequence number info */
Allan Stephens85035562008-04-15 19:04:54 -07001684 seq_no = msg_seqno(msg);
1685 ackd = msg_ack(msg);
1686
1687 /* Release acked messages */
Ying Xue389dd9b2012-11-16 13:51:30 +08001688 if (n_ptr->bclink.recv_permitted)
Allan Stephens365595912011-10-24 15:26:24 -04001689 tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001690
1691 crs = l_ptr->first_out;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001692 while ((crs != l_ptr->next_out) &&
Allan Stephensf9057302011-10-24 16:03:12 -04001693 less_eq(buf_seqno(crs), ackd)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001694 struct sk_buff *next = crs->next;
1695
Allan Stephens5f6d9122011-11-04 13:24:29 -04001696 kfree_skb(crs);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001697 crs = next;
1698 released++;
1699 }
1700 if (released) {
1701 l_ptr->first_out = crs;
1702 l_ptr->out_queue_size -= released;
1703 }
Allan Stephens85035562008-04-15 19:04:54 -07001704
1705 /* Try sending any messages link endpoint has pending */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001706 if (unlikely(l_ptr->next_out))
Per Liden4323add2006-01-18 00:38:21 +01001707 tipc_link_push_queue(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001708 if (unlikely(!list_empty(&l_ptr->waiting_ports)))
Per Liden4323add2006-01-18 00:38:21 +01001709 tipc_link_wakeup_ports(l_ptr, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001710 if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
1711 l_ptr->stats.sent_acks++;
Per Liden4323add2006-01-18 00:38:21 +01001712 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001713 }
1714
Allan Stephens85035562008-04-15 19:04:54 -07001715 /* Now (finally!) process the incoming message */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001716protocol_check:
1717 if (likely(link_working_working(l_ptr))) {
1718 if (likely(seq_no == mod(l_ptr->next_in_no))) {
1719 l_ptr->next_in_no++;
1720 if (unlikely(l_ptr->oldest_deferred_in))
1721 head = link_insert_deferred_queue(l_ptr,
1722 head);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001723deliver:
Allan Stephensc74a4612011-11-02 15:08:44 -04001724 if (likely(msg_isdata(msg))) {
1725 tipc_node_unlock(n_ptr);
1726 tipc_port_recv_msg(buf);
1727 continue;
1728 }
1729 switch (msg_user(msg)) {
1730 int ret;
1731 case MSG_BUNDLER:
1732 l_ptr->stats.recv_bundles++;
1733 l_ptr->stats.recv_bundled +=
1734 msg_msgcnt(msg);
1735 tipc_node_unlock(n_ptr);
1736 tipc_link_recv_bundle(buf);
1737 continue;
1738 case NAME_DISTRIBUTOR:
Jon Maloyc64f7a62012-11-16 13:51:31 +08001739 n_ptr->bclink.recv_permitted = true;
Allan Stephensc74a4612011-11-02 15:08:44 -04001740 tipc_node_unlock(n_ptr);
1741 tipc_named_recv(buf);
1742 continue;
Jon Maloyc64f7a62012-11-16 13:51:31 +08001743 case BCAST_PROTOCOL:
1744 tipc_link_recv_sync(n_ptr, buf);
1745 tipc_node_unlock(n_ptr);
1746 continue;
Allan Stephensc74a4612011-11-02 15:08:44 -04001747 case CONN_MANAGER:
1748 tipc_node_unlock(n_ptr);
1749 tipc_port_recv_proto_msg(buf);
1750 continue;
1751 case MSG_FRAGMENTER:
1752 l_ptr->stats.recv_fragments++;
1753 ret = tipc_link_recv_fragment(
1754 &l_ptr->defragm_buf,
1755 &buf, &msg);
1756 if (ret == 1) {
1757 l_ptr->stats.recv_fragmented++;
1758 goto deliver;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001759 }
Allan Stephensc74a4612011-11-02 15:08:44 -04001760 if (ret == -1)
1761 l_ptr->next_in_no--;
1762 break;
1763 case CHANGEOVER_PROTOCOL:
1764 type = msg_type(msg);
1765 if (link_recv_changeover_msg(&l_ptr,
1766 &buf)) {
1767 msg = buf_msg(buf);
1768 seq_no = msg_seqno(msg);
1769 if (type == ORIGINAL_MSG)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001770 goto deliver;
Allan Stephensc74a4612011-11-02 15:08:44 -04001771 goto protocol_check;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001772 }
Allan Stephensc74a4612011-11-02 15:08:44 -04001773 break;
1774 default:
Allan Stephens5f6d9122011-11-04 13:24:29 -04001775 kfree_skb(buf);
Allan Stephensc74a4612011-11-02 15:08:44 -04001776 buf = NULL;
1777 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001778 }
Per Liden4323add2006-01-18 00:38:21 +01001779 tipc_node_unlock(n_ptr);
1780 tipc_net_route_msg(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001781 continue;
1782 }
1783 link_handle_out_of_seq_msg(l_ptr, buf);
1784 head = link_insert_deferred_queue(l_ptr, head);
Per Liden4323add2006-01-18 00:38:21 +01001785 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001786 continue;
1787 }
1788
Jon Maloyc64f7a62012-11-16 13:51:31 +08001789 /* Link is not in state WORKING_WORKING */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001790 if (msg_user(msg) == LINK_PROTOCOL) {
1791 link_recv_proto_msg(l_ptr, buf);
1792 head = link_insert_deferred_queue(l_ptr, head);
Per Liden4323add2006-01-18 00:38:21 +01001793 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001794 continue;
1795 }
Jon Maloyc64f7a62012-11-16 13:51:31 +08001796
1797 /* Traffic message. Conditionally activate link */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001798 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
1799
1800 if (link_working_working(l_ptr)) {
Jon Maloyc64f7a62012-11-16 13:51:31 +08001801 /* Re-insert buffer in front of queue */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001802 buf->next = head;
1803 head = buf;
Per Liden4323add2006-01-18 00:38:21 +01001804 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001805 continue;
1806 }
Per Liden4323add2006-01-18 00:38:21 +01001807 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001808cont:
Allan Stephens5f6d9122011-11-04 13:24:29 -04001809 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001810 }
Per Liden4323add2006-01-18 00:38:21 +01001811 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001812}
1813
Ben Hutchings2c530402012-07-10 10:55:09 +00001814/**
Allan Stephens8809b252011-10-25 10:44:35 -04001815 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
1816 *
1817 * Returns increase in queue length (i.e. 0 or 1)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001818 */
Allan Stephens8809b252011-10-25 10:44:35 -04001819u32 tipc_link_defer_pkt(struct sk_buff **head, struct sk_buff **tail,
Per Liden4323add2006-01-18 00:38:21 +01001820 struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001821{
Allan Stephens8809b252011-10-25 10:44:35 -04001822 struct sk_buff *queue_buf;
1823 struct sk_buff **prev;
Allan Stephensf9057302011-10-24 16:03:12 -04001824 u32 seq_no = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001825
1826 buf->next = NULL;
1827
1828 /* Empty queue ? */
1829 if (*head == NULL) {
1830 *head = *tail = buf;
1831 return 1;
1832 }
1833
1834 /* Last ? */
Allan Stephensf9057302011-10-24 16:03:12 -04001835 if (less(buf_seqno(*tail), seq_no)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001836 (*tail)->next = buf;
1837 *tail = buf;
1838 return 1;
1839 }
1840
Allan Stephens8809b252011-10-25 10:44:35 -04001841 /* Locate insertion point in queue, then insert; discard if duplicate */
1842 prev = head;
1843 queue_buf = *head;
1844 for (;;) {
1845 u32 curr_seqno = buf_seqno(queue_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001846
Allan Stephens8809b252011-10-25 10:44:35 -04001847 if (seq_no == curr_seqno) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04001848 kfree_skb(buf);
Allan Stephens8809b252011-10-25 10:44:35 -04001849 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001850 }
Allan Stephens8809b252011-10-25 10:44:35 -04001851
1852 if (less(seq_no, curr_seqno))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001853 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001854
Allan Stephens8809b252011-10-25 10:44:35 -04001855 prev = &queue_buf->next;
1856 queue_buf = queue_buf->next;
1857 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001858
Allan Stephens8809b252011-10-25 10:44:35 -04001859 buf->next = queue_buf;
1860 *prev = buf;
1861 return 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001862}
1863
Allan Stephens8809b252011-10-25 10:44:35 -04001864/*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001865 * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
1866 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001867static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001868 struct sk_buff *buf)
1869{
Allan Stephensf9057302011-10-24 16:03:12 -04001870 u32 seq_no = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001871
1872 if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) {
1873 link_recv_proto_msg(l_ptr, buf);
1874 return;
1875 }
1876
Per Lidenb97bf3f2006-01-02 19:04:38 +01001877 /* Record OOS packet arrival (force mismatch on next timeout) */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001878 l_ptr->checkpoint--;
1879
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001880 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001881 * Discard packet if a duplicate; otherwise add it to deferred queue
1882 * and notify peer of gap as per protocol specification
1883 */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001884 if (less(seq_no, mod(l_ptr->next_in_no))) {
1885 l_ptr->stats.duplicates++;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001886 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001887 return;
1888 }
1889
Per Liden4323add2006-01-18 00:38:21 +01001890 if (tipc_link_defer_pkt(&l_ptr->oldest_deferred_in,
1891 &l_ptr->newest_deferred_in, buf)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001892 l_ptr->deferred_inqueue_sz++;
1893 l_ptr->stats.deferred_recv++;
1894 if ((l_ptr->deferred_inqueue_sz % 16) == 1)
Per Liden4323add2006-01-18 00:38:21 +01001895 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001896 } else
1897 l_ptr->stats.duplicates++;
1898}
1899
1900/*
1901 * Send protocol message to the other endpoint.
1902 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001903void tipc_link_send_proto_msg(struct tipc_link *l_ptr, u32 msg_typ,
1904 int probe_msg, u32 gap, u32 tolerance,
1905 u32 priority, u32 ack_mtu)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001906{
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08001907 struct sk_buff *buf = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001908 struct tipc_msg *msg = l_ptr->pmsg;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001909 u32 msg_size = sizeof(l_ptr->proto_msg);
Allan Stephens75f0aa42011-02-28 15:30:20 -05001910 int r_flag;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001911
Allan Stephens92d2c902011-10-25 11:20:26 -04001912 /* Discard any previous message that was deferred due to congestion */
Allan Stephens92d2c902011-10-25 11:20:26 -04001913 if (l_ptr->proto_msg_queue) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04001914 kfree_skb(l_ptr->proto_msg_queue);
Allan Stephens92d2c902011-10-25 11:20:26 -04001915 l_ptr->proto_msg_queue = NULL;
1916 }
1917
Per Lidenb97bf3f2006-01-02 19:04:38 +01001918 if (link_blocked(l_ptr))
1919 return;
Allan Stephensb4b56102011-05-27 11:00:51 -04001920
1921 /* Abort non-RESET send if communication with node is prohibited */
Allan Stephensb4b56102011-05-27 11:00:51 -04001922 if ((l_ptr->owner->block_setup) && (msg_typ != RESET_MSG))
1923 return;
1924
Allan Stephens92d2c902011-10-25 11:20:26 -04001925 /* Create protocol message with "out-of-sequence" sequence number */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001926 msg_set_type(msg, msg_typ);
1927 msg_set_net_plane(msg, l_ptr->b_ptr->net_plane);
Allan Stephens7a54d4a2011-10-27 14:17:53 -04001928 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Per Liden4323add2006-01-18 00:38:21 +01001929 msg_set_last_bcast(msg, tipc_bclink_get_last_sent());
Per Lidenb97bf3f2006-01-02 19:04:38 +01001930
1931 if (msg_typ == STATE_MSG) {
1932 u32 next_sent = mod(l_ptr->next_out_no);
1933
Per Liden4323add2006-01-18 00:38:21 +01001934 if (!tipc_link_is_up(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001935 return;
1936 if (l_ptr->next_out)
Allan Stephensf9057302011-10-24 16:03:12 -04001937 next_sent = buf_seqno(l_ptr->next_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001938 msg_set_next_sent(msg, next_sent);
1939 if (l_ptr->oldest_deferred_in) {
Allan Stephensf9057302011-10-24 16:03:12 -04001940 u32 rec = buf_seqno(l_ptr->oldest_deferred_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001941 gap = mod(rec - mod(l_ptr->next_in_no));
1942 }
1943 msg_set_seq_gap(msg, gap);
1944 if (gap)
1945 l_ptr->stats.sent_nacks++;
1946 msg_set_link_tolerance(msg, tolerance);
1947 msg_set_linkprio(msg, priority);
1948 msg_set_max_pkt(msg, ack_mtu);
1949 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
1950 msg_set_probe(msg, probe_msg != 0);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001951 if (probe_msg) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001952 u32 mtu = l_ptr->max_pkt;
1953
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001954 if ((mtu < l_ptr->max_pkt_target) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +01001955 link_working_working(l_ptr) &&
1956 l_ptr->fsm_msg_cnt) {
1957 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001958 if (l_ptr->max_pkt_probes == 10) {
1959 l_ptr->max_pkt_target = (msg_size - 4);
1960 l_ptr->max_pkt_probes = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001961 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001962 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001963 l_ptr->max_pkt_probes++;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001964 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001965
1966 l_ptr->stats.sent_probes++;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001967 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001968 l_ptr->stats.sent_states++;
1969 } else { /* RESET_MSG or ACTIVATE_MSG */
1970 msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
1971 msg_set_seq_gap(msg, 0);
1972 msg_set_next_sent(msg, 1);
Allan Stephensf23d9bf2011-01-18 15:15:34 -05001973 msg_set_probe(msg, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001974 msg_set_link_tolerance(msg, l_ptr->tolerance);
1975 msg_set_linkprio(msg, l_ptr->priority);
1976 msg_set_max_pkt(msg, l_ptr->max_pkt_target);
1977 }
1978
Allan Stephens75f0aa42011-02-28 15:30:20 -05001979 r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr));
1980 msg_set_redundant_link(msg, r_flag);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001981 msg_set_linkprio(msg, l_ptr->priority);
Allan Stephens92d2c902011-10-25 11:20:26 -04001982 msg_set_size(msg, msg_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001983
1984 msg_set_seqno(msg, mod(l_ptr->next_out_no + (0xffff/2)));
1985
stephen hemminger31e3c3f2010-10-13 13:20:35 +00001986 buf = tipc_buf_acquire(msg_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001987 if (!buf)
1988 return;
1989
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001990 skb_copy_to_linear_data(buf, msg, sizeof(l_ptr->proto_msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001991
Ying Xue3c294cb2012-11-15 11:34:45 +08001992 /* Defer message if bearer is already blocked */
1993 if (tipc_bearer_blocked(l_ptr->b_ptr)) {
Allan Stephens92d2c902011-10-25 11:20:26 -04001994 l_ptr->proto_msg_queue = buf;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001995 return;
1996 }
1997
Ying Xue3c294cb2012-11-15 11:34:45 +08001998 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr);
Allan Stephens92d2c902011-10-25 11:20:26 -04001999 l_ptr->unacked_window = 0;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002000 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002001}
2002
2003/*
2004 * Receive protocol message :
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002005 * Note that network plane id propagates through the network, and may
2006 * change at any time. The node with lowest address rules
Per Lidenb97bf3f2006-01-02 19:04:38 +01002007 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002008static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002009{
2010 u32 rec_gap = 0;
2011 u32 max_pkt_info;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002012 u32 max_pkt_ack;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002013 u32 msg_tol;
2014 struct tipc_msg *msg = buf_msg(buf);
2015
Per Lidenb97bf3f2006-01-02 19:04:38 +01002016 if (link_blocked(l_ptr))
2017 goto exit;
2018
2019 /* record unnumbered packet arrival (force mismatch on next timeout) */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002020 l_ptr->checkpoint--;
2021
2022 if (l_ptr->b_ptr->net_plane != msg_net_plane(msg))
2023 if (tipc_own_addr > msg_prevnode(msg))
2024 l_ptr->b_ptr->net_plane = msg_net_plane(msg);
2025
2026 l_ptr->owner->permit_changeover = msg_redundant_link(msg);
2027
2028 switch (msg_type(msg)) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002029
Per Lidenb97bf3f2006-01-02 19:04:38 +01002030 case RESET_MSG:
Allan Stephensa686e682008-06-04 17:29:39 -07002031 if (!link_working_unknown(l_ptr) &&
2032 (l_ptr->peer_session != INVALID_SESSION)) {
Allan Stephens641c2182011-04-07 09:54:43 -04002033 if (less_eq(msg_session(msg), l_ptr->peer_session))
2034 break; /* duplicate or old reset: ignore */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002035 }
Allan Stephensb4b56102011-05-27 11:00:51 -04002036
2037 if (!msg_redundant_link(msg) && (link_working_working(l_ptr) ||
2038 link_working_unknown(l_ptr))) {
2039 /*
2040 * peer has lost contact -- don't allow peer's links
2041 * to reactivate before we recognize loss & clean up
2042 */
2043 l_ptr->owner->block_setup = WAIT_NODE_DOWN;
2044 }
2045
Allan Stephens47361c82011-10-26 10:55:16 -04002046 link_state_event(l_ptr, RESET_MSG);
2047
Per Lidenb97bf3f2006-01-02 19:04:38 +01002048 /* fall thru' */
2049 case ACTIVATE_MSG:
2050 /* Update link settings according other endpoint's values */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002051 strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg));
2052
Allan Stephens2db99832010-12-31 18:59:33 +00002053 msg_tol = msg_link_tolerance(msg);
2054 if (msg_tol > l_ptr->tolerance)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002055 link_set_supervision_props(l_ptr, msg_tol);
2056
2057 if (msg_linkprio(msg) > l_ptr->priority)
2058 l_ptr->priority = msg_linkprio(msg);
2059
2060 max_pkt_info = msg_max_pkt(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002061 if (max_pkt_info) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002062 if (max_pkt_info < l_ptr->max_pkt_target)
2063 l_ptr->max_pkt_target = max_pkt_info;
2064 if (l_ptr->max_pkt > l_ptr->max_pkt_target)
2065 l_ptr->max_pkt = l_ptr->max_pkt_target;
2066 } else {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002067 l_ptr->max_pkt = l_ptr->max_pkt_target;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002068 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002069
Allan Stephens4d753132011-10-25 12:19:05 -04002070 /* Synchronize broadcast link info, if not done previously */
Allan Stephens7a54d4a2011-10-27 14:17:53 -04002071 if (!tipc_node_is_up(l_ptr->owner)) {
2072 l_ptr->owner->bclink.last_sent =
2073 l_ptr->owner->bclink.last_in =
2074 msg_last_bcast(msg);
2075 l_ptr->owner->bclink.oos_state = 0;
2076 }
Allan Stephens4d753132011-10-25 12:19:05 -04002077
Per Lidenb97bf3f2006-01-02 19:04:38 +01002078 l_ptr->peer_session = msg_session(msg);
2079 l_ptr->peer_bearer_id = msg_bearer_id(msg);
Allan Stephens47361c82011-10-26 10:55:16 -04002080
2081 if (msg_type(msg) == ACTIVATE_MSG)
2082 link_state_event(l_ptr, ACTIVATE_MSG);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002083 break;
2084 case STATE_MSG:
2085
Allan Stephens2db99832010-12-31 18:59:33 +00002086 msg_tol = msg_link_tolerance(msg);
2087 if (msg_tol)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002088 link_set_supervision_props(l_ptr, msg_tol);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002089
2090 if (msg_linkprio(msg) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +01002091 (msg_linkprio(msg) != l_ptr->priority)) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002092 pr_warn("%s<%s>, priority change %u->%u\n",
2093 link_rst_msg, l_ptr->name, l_ptr->priority,
2094 msg_linkprio(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002095 l_ptr->priority = msg_linkprio(msg);
Per Liden4323add2006-01-18 00:38:21 +01002096 tipc_link_reset(l_ptr); /* Enforce change to take effect */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002097 break;
2098 }
2099 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
2100 l_ptr->stats.recv_states++;
2101 if (link_reset_unknown(l_ptr))
2102 break;
2103
2104 if (less_eq(mod(l_ptr->next_in_no), msg_next_sent(msg))) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002105 rec_gap = mod(msg_next_sent(msg) -
Per Lidenb97bf3f2006-01-02 19:04:38 +01002106 mod(l_ptr->next_in_no));
2107 }
2108
2109 max_pkt_ack = msg_max_pkt(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002110 if (max_pkt_ack > l_ptr->max_pkt) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002111 l_ptr->max_pkt = max_pkt_ack;
2112 l_ptr->max_pkt_probes = 0;
2113 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002114
2115 max_pkt_ack = 0;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002116 if (msg_probe(msg)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002117 l_ptr->stats.recv_probes++;
Allan Stephensa0168922010-12-31 18:59:35 +00002118 if (msg_size(msg) > sizeof(l_ptr->proto_msg))
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002119 max_pkt_ack = msg_size(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002120 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002121
2122 /* Protocol message before retransmits, reduce loss risk */
Ying Xue389dd9b2012-11-16 13:51:30 +08002123 if (l_ptr->owner->bclink.recv_permitted)
Allan Stephens7a54d4a2011-10-27 14:17:53 -04002124 tipc_bclink_update_link_state(l_ptr->owner,
2125 msg_last_bcast(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002126
2127 if (rec_gap || (msg_probe(msg))) {
Per Liden4323add2006-01-18 00:38:21 +01002128 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
2129 0, rec_gap, 0, 0, max_pkt_ack);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002130 }
2131 if (msg_seq_gap(msg)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002132 l_ptr->stats.recv_nacks++;
Per Liden4323add2006-01-18 00:38:21 +01002133 tipc_link_retransmit(l_ptr, l_ptr->first_out,
2134 msg_seq_gap(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002135 }
2136 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002137 }
2138exit:
Allan Stephens5f6d9122011-11-04 13:24:29 -04002139 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002140}
2141
2142
2143/*
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002144 * tipc_link_tunnel(): Send one message via a link belonging to
Per Lidenb97bf3f2006-01-02 19:04:38 +01002145 * another bearer. Owner node is locked.
2146 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002147static void tipc_link_tunnel(struct tipc_link *l_ptr,
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002148 struct tipc_msg *tunnel_hdr,
2149 struct tipc_msg *msg,
2150 u32 selector)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002151{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002152 struct tipc_link *tunnel;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002153 struct sk_buff *buf;
2154 u32 length = msg_size(msg);
2155
2156 tunnel = l_ptr->owner->active_links[selector & 1];
Allan Stephens5392d642006-06-25 23:52:50 -07002157 if (!tipc_link_is_up(tunnel)) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002158 pr_warn("%stunnel link no longer available\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002159 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002160 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002161 msg_set_size(tunnel_hdr, length + INT_H_SIZE);
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002162 buf = tipc_buf_acquire(length + INT_H_SIZE);
Allan Stephens5392d642006-06-25 23:52:50 -07002163 if (!buf) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002164 pr_warn("%sunable to send tunnel msg\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002165 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002166 }
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002167 skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE);
2168 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, msg, length);
Per Liden4323add2006-01-18 00:38:21 +01002169 tipc_link_send_buf(tunnel, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002170}
2171
2172
2173
2174/*
2175 * changeover(): Send whole message queue via the remaining link
2176 * Owner node is locked.
2177 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002178void tipc_link_changeover(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002179{
2180 u32 msgcount = l_ptr->out_queue_size;
2181 struct sk_buff *crs = l_ptr->first_out;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002182 struct tipc_link *tunnel = l_ptr->owner->active_links[0];
Per Lidenb97bf3f2006-01-02 19:04:38 +01002183 struct tipc_msg tunnel_hdr;
Allan Stephens5392d642006-06-25 23:52:50 -07002184 int split_bundles;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002185
2186 if (!tunnel)
2187 return;
2188
Allan Stephens5392d642006-06-25 23:52:50 -07002189 if (!l_ptr->owner->permit_changeover) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002190 pr_warn("%speer did not permit changeover\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002191 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002192 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002193
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002194 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
Allan Stephens75715212008-06-04 17:37:34 -07002195 ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002196 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2197 msg_set_msgcnt(&tunnel_hdr, msgcount);
Allan Stephensf1310722006-06-25 23:51:37 -07002198
Per Lidenb97bf3f2006-01-02 19:04:38 +01002199 if (!l_ptr->first_out) {
2200 struct sk_buff *buf;
2201
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002202 buf = tipc_buf_acquire(INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002203 if (buf) {
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002204 skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002205 msg_set_size(&tunnel_hdr, INT_H_SIZE);
Per Liden4323add2006-01-18 00:38:21 +01002206 tipc_link_send_buf(tunnel, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002207 } else {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002208 pr_warn("%sunable to send changeover msg\n",
2209 link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002210 }
2211 return;
2212 }
Allan Stephensf1310722006-06-25 23:51:37 -07002213
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002214 split_bundles = (l_ptr->owner->active_links[0] !=
Allan Stephens5392d642006-06-25 23:52:50 -07002215 l_ptr->owner->active_links[1]);
2216
Per Lidenb97bf3f2006-01-02 19:04:38 +01002217 while (crs) {
2218 struct tipc_msg *msg = buf_msg(crs);
2219
2220 if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002221 struct tipc_msg *m = msg_get_wrapped(msg);
Allan Stephens0e659672010-12-31 18:59:32 +00002222 unchar *pos = (unchar *)m;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002223
Florian Westphald788d802007-08-02 19:28:06 -07002224 msgcount = msg_msgcnt(msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002225 while (msgcount--) {
Allan Stephens0e659672010-12-31 18:59:32 +00002226 msg_set_seqno(m, msg_seqno(msg));
Per Liden4323add2006-01-18 00:38:21 +01002227 tipc_link_tunnel(l_ptr, &tunnel_hdr, m,
2228 msg_link_selector(m));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002229 pos += align(msg_size(m));
2230 m = (struct tipc_msg *)pos;
2231 }
2232 } else {
Per Liden4323add2006-01-18 00:38:21 +01002233 tipc_link_tunnel(l_ptr, &tunnel_hdr, msg,
2234 msg_link_selector(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002235 }
2236 crs = crs->next;
2237 }
2238}
2239
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002240void tipc_link_send_duplicate(struct tipc_link *l_ptr, struct tipc_link *tunnel)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002241{
2242 struct sk_buff *iter;
2243 struct tipc_msg tunnel_hdr;
2244
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002245 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
Allan Stephens75715212008-06-04 17:37:34 -07002246 DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002247 msg_set_msgcnt(&tunnel_hdr, l_ptr->out_queue_size);
2248 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2249 iter = l_ptr->first_out;
2250 while (iter) {
2251 struct sk_buff *outbuf;
2252 struct tipc_msg *msg = buf_msg(iter);
2253 u32 length = msg_size(msg);
2254
2255 if (msg_user(msg) == MSG_BUNDLER)
2256 msg_set_type(msg, CLOSED_MSG);
2257 msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002258 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002259 msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002260 outbuf = tipc_buf_acquire(length + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002261 if (outbuf == NULL) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002262 pr_warn("%sunable to send duplicate msg\n",
2263 link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002264 return;
2265 }
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002266 skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);
2267 skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data,
2268 length);
Per Liden4323add2006-01-18 00:38:21 +01002269 tipc_link_send_buf(tunnel, outbuf);
2270 if (!tipc_link_is_up(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002271 return;
2272 iter = iter->next;
2273 }
2274}
2275
Per Lidenb97bf3f2006-01-02 19:04:38 +01002276/**
2277 * buf_extract - extracts embedded TIPC message from another message
2278 * @skb: encapsulating message buffer
2279 * @from_pos: offset to extract from
2280 *
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002281 * Returns a new message buffer containing an embedded message. The
Per Lidenb97bf3f2006-01-02 19:04:38 +01002282 * encapsulating message itself is left unchanged.
2283 */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002284static struct sk_buff *buf_extract(struct sk_buff *skb, u32 from_pos)
2285{
2286 struct tipc_msg *msg = (struct tipc_msg *)(skb->data + from_pos);
2287 u32 size = msg_size(msg);
2288 struct sk_buff *eb;
2289
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002290 eb = tipc_buf_acquire(size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002291 if (eb)
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002292 skb_copy_to_linear_data(eb, msg, size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002293 return eb;
2294}
2295
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002296/*
Per Lidenb97bf3f2006-01-02 19:04:38 +01002297 * link_recv_changeover_msg(): Receive tunneled packet sent
2298 * via other link. Node is locked. Return extracted buffer.
2299 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002300static int link_recv_changeover_msg(struct tipc_link **l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01002301 struct sk_buff **buf)
2302{
2303 struct sk_buff *tunnel_buf = *buf;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002304 struct tipc_link *dest_link;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002305 struct tipc_msg *msg;
2306 struct tipc_msg *tunnel_msg = buf_msg(tunnel_buf);
2307 u32 msg_typ = msg_type(tunnel_msg);
2308 u32 msg_count = msg_msgcnt(tunnel_msg);
2309
2310 dest_link = (*l_ptr)->owner->links[msg_bearer_id(tunnel_msg)];
Allan Stephensb29f1422010-12-31 18:59:25 +00002311 if (!dest_link)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002312 goto exit;
Allan Stephensf1310722006-06-25 23:51:37 -07002313 if (dest_link == *l_ptr) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002314 pr_err("Unexpected changeover message on link <%s>\n",
2315 (*l_ptr)->name);
Allan Stephensf1310722006-06-25 23:51:37 -07002316 goto exit;
2317 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002318 *l_ptr = dest_link;
2319 msg = msg_get_wrapped(tunnel_msg);
2320
2321 if (msg_typ == DUPLICATE_MSG) {
Allan Stephensb29f1422010-12-31 18:59:25 +00002322 if (less(msg_seqno(msg), mod(dest_link->next_in_no)))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002323 goto exit;
Allan Stephens0e659672010-12-31 18:59:32 +00002324 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002325 if (*buf == NULL) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002326 pr_warn("%sduplicate msg dropped\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002327 goto exit;
2328 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002329 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002330 return 1;
2331 }
2332
2333 /* First original message ?: */
Per Liden4323add2006-01-18 00:38:21 +01002334 if (tipc_link_is_up(dest_link)) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002335 pr_info("%s<%s>, changeover initiated by peer\n", link_rst_msg,
2336 dest_link->name);
Per Liden4323add2006-01-18 00:38:21 +01002337 tipc_link_reset(dest_link);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002338 dest_link->exp_msg_count = msg_count;
2339 if (!msg_count)
2340 goto exit;
2341 } else if (dest_link->exp_msg_count == START_CHANGEOVER) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002342 dest_link->exp_msg_count = msg_count;
2343 if (!msg_count)
2344 goto exit;
2345 }
2346
2347 /* Receive original message */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002348 if (dest_link->exp_msg_count == 0) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002349 pr_warn("%sgot too many tunnelled messages\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002350 goto exit;
2351 }
2352 dest_link->exp_msg_count--;
2353 if (less(msg_seqno(msg), dest_link->reset_checkpoint)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002354 goto exit;
2355 } else {
2356 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
2357 if (*buf != NULL) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002358 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002359 return 1;
2360 } else {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002361 pr_warn("%soriginal msg dropped\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002362 }
2363 }
2364exit:
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002365 *buf = NULL;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002366 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002367 return 0;
2368}
2369
2370/*
2371 * Bundler functionality:
2372 */
Per Liden4323add2006-01-18 00:38:21 +01002373void tipc_link_recv_bundle(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002374{
2375 u32 msgcount = msg_msgcnt(buf_msg(buf));
2376 u32 pos = INT_H_SIZE;
2377 struct sk_buff *obuf;
2378
Per Lidenb97bf3f2006-01-02 19:04:38 +01002379 while (msgcount--) {
2380 obuf = buf_extract(buf, pos);
2381 if (obuf == NULL) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002382 pr_warn("Link unable to unbundle message(s)\n");
Allan Stephensa10bd922006-06-25 23:52:17 -07002383 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002384 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002385 pos += align(msg_size(buf_msg(obuf)));
Per Liden4323add2006-01-18 00:38:21 +01002386 tipc_net_route_msg(obuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002387 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002388 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002389}
2390
2391/*
2392 * Fragmentation/defragmentation:
2393 */
2394
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002395/*
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002396 * link_send_long_buf: Entry for buffers needing fragmentation.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002397 * The buffer is complete, inclusive total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01002398 * Returns user data length.
2399 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002400static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002401{
Allan Stephens77561552011-04-17 13:06:23 -04002402 struct sk_buff *buf_chain = NULL;
2403 struct sk_buff *buf_chain_tail = (struct sk_buff *)&buf_chain;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002404 struct tipc_msg *inmsg = buf_msg(buf);
2405 struct tipc_msg fragm_hdr;
2406 u32 insize = msg_size(inmsg);
2407 u32 dsz = msg_data_sz(inmsg);
2408 unchar *crs = buf->data;
2409 u32 rest = insize;
Allan Stephens15e979d2010-05-11 14:30:10 +00002410 u32 pack_sz = l_ptr->max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002411 u32 fragm_sz = pack_sz - INT_H_SIZE;
Allan Stephens77561552011-04-17 13:06:23 -04002412 u32 fragm_no = 0;
Allan Stephens9c396a72008-06-04 17:36:58 -07002413 u32 destaddr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002414
2415 if (msg_short(inmsg))
2416 destaddr = l_ptr->addr;
Allan Stephens9c396a72008-06-04 17:36:58 -07002417 else
2418 destaddr = msg_destnode(inmsg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002419
Per Lidenb97bf3f2006-01-02 19:04:38 +01002420 /* Prepare reusable fragment header: */
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002421 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
Allan Stephens75715212008-06-04 17:37:34 -07002422 INT_H_SIZE, destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002423
2424 /* Chop up message: */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002425 while (rest > 0) {
2426 struct sk_buff *fragm;
2427
2428 if (rest <= fragm_sz) {
2429 fragm_sz = rest;
2430 msg_set_type(&fragm_hdr, LAST_FRAGMENT);
2431 }
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002432 fragm = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002433 if (fragm == NULL) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002434 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002435 while (buf_chain) {
2436 buf = buf_chain;
2437 buf_chain = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002438 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002439 }
2440 return -ENOMEM;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002441 }
2442 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
Allan Stephens77561552011-04-17 13:06:23 -04002443 fragm_no++;
2444 msg_set_fragm_no(&fragm_hdr, fragm_no);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002445 skb_copy_to_linear_data(fragm, &fragm_hdr, INT_H_SIZE);
2446 skb_copy_to_linear_data_offset(fragm, INT_H_SIZE, crs,
2447 fragm_sz);
Allan Stephens77561552011-04-17 13:06:23 -04002448 buf_chain_tail->next = fragm;
2449 buf_chain_tail = fragm;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002450
Per Lidenb97bf3f2006-01-02 19:04:38 +01002451 rest -= fragm_sz;
2452 crs += fragm_sz;
2453 msg_set_type(&fragm_hdr, FRAGMENT);
2454 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002455 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002456
2457 /* Append chain of fragments to send queue & send them */
Allan Stephens77561552011-04-17 13:06:23 -04002458 l_ptr->long_msg_seq_no++;
2459 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
2460 l_ptr->stats.sent_fragments += fragm_no;
2461 l_ptr->stats.sent_fragmented++;
2462 tipc_link_push_queue(l_ptr);
2463
Per Lidenb97bf3f2006-01-02 19:04:38 +01002464 return dsz;
2465}
2466
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002467/*
2468 * A pending message being re-assembled must store certain values
2469 * to handle subsequent fragments correctly. The following functions
Per Lidenb97bf3f2006-01-02 19:04:38 +01002470 * help storing these values in unused, available fields in the
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002471 * pending message. This makes dynamic memory allocation unnecessary.
Per Lidenb97bf3f2006-01-02 19:04:38 +01002472 */
Sam Ravnborg05790c62006-03-20 22:37:04 -08002473static void set_long_msg_seqno(struct sk_buff *buf, u32 seqno)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002474{
2475 msg_set_seqno(buf_msg(buf), seqno);
2476}
2477
Sam Ravnborg05790c62006-03-20 22:37:04 -08002478static u32 get_fragm_size(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002479{
2480 return msg_ack(buf_msg(buf));
2481}
2482
Sam Ravnborg05790c62006-03-20 22:37:04 -08002483static void set_fragm_size(struct sk_buff *buf, u32 sz)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002484{
2485 msg_set_ack(buf_msg(buf), sz);
2486}
2487
Sam Ravnborg05790c62006-03-20 22:37:04 -08002488static u32 get_expected_frags(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002489{
2490 return msg_bcast_ack(buf_msg(buf));
2491}
2492
Sam Ravnborg05790c62006-03-20 22:37:04 -08002493static void set_expected_frags(struct sk_buff *buf, u32 exp)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002494{
2495 msg_set_bcast_ack(buf_msg(buf), exp);
2496}
2497
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002498/*
2499 * tipc_link_recv_fragment(): Called with node lock on. Returns
Per Lidenb97bf3f2006-01-02 19:04:38 +01002500 * the reassembled buffer if message is complete.
2501 */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002502int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
Per Liden4323add2006-01-18 00:38:21 +01002503 struct tipc_msg **m)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002504{
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002505 struct sk_buff *prev = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002506 struct sk_buff *fbuf = *fb;
2507 struct tipc_msg *fragm = buf_msg(fbuf);
2508 struct sk_buff *pbuf = *pending;
2509 u32 long_msg_seq_no = msg_long_msgno(fragm);
2510
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002511 *fb = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002512
2513 /* Is there an incomplete message waiting for this fragment? */
Allan Stephensf9057302011-10-24 16:03:12 -04002514 while (pbuf && ((buf_seqno(pbuf) != long_msg_seq_no) ||
Joe Perchesf64f9e72009-11-29 16:55:45 -08002515 (msg_orignode(fragm) != msg_orignode(buf_msg(pbuf))))) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002516 prev = pbuf;
2517 pbuf = pbuf->next;
2518 }
2519
2520 if (!pbuf && (msg_type(fragm) == FIRST_FRAGMENT)) {
2521 struct tipc_msg *imsg = (struct tipc_msg *)msg_data(fragm);
2522 u32 msg_sz = msg_size(imsg);
2523 u32 fragm_sz = msg_data_sz(fragm);
2524 u32 exp_fragm_cnt = msg_sz/fragm_sz + !!(msg_sz % fragm_sz);
Allan Stephens741d9eb2011-05-31 15:03:18 -04002525 u32 max = TIPC_MAX_USER_MSG_SIZE + NAMED_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002526 if (msg_type(imsg) == TIPC_MCAST_MSG)
2527 max = TIPC_MAX_USER_MSG_SIZE + MCAST_H_SIZE;
2528 if (msg_size(imsg) > max) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002529 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002530 return 0;
2531 }
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002532 pbuf = tipc_buf_acquire(msg_size(imsg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002533 if (pbuf != NULL) {
2534 pbuf->next = *pending;
2535 *pending = pbuf;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002536 skb_copy_to_linear_data(pbuf, imsg,
2537 msg_data_sz(fragm));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002538 /* Prepare buffer for subsequent fragments. */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002539 set_long_msg_seqno(pbuf, long_msg_seq_no);
Allan Stephens0e659672010-12-31 18:59:32 +00002540 set_fragm_size(pbuf, fragm_sz);
2541 set_expected_frags(pbuf, exp_fragm_cnt - 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002542 } else {
Erik Hugne2cf8aa12012-06-29 00:16:37 -04002543 pr_debug("Link unable to reassemble fragmented message\n");
Allan Stephens5f6d9122011-11-04 13:24:29 -04002544 kfree_skb(fbuf);
Allan Stephensb76b27c2011-10-27 16:31:26 -04002545 return -1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002546 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002547 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002548 return 0;
2549 } else if (pbuf && (msg_type(fragm) != FIRST_FRAGMENT)) {
2550 u32 dsz = msg_data_sz(fragm);
2551 u32 fsz = get_fragm_size(pbuf);
2552 u32 crs = ((msg_fragm_no(fragm) - 1) * fsz);
2553 u32 exp_frags = get_expected_frags(pbuf) - 1;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002554 skb_copy_to_linear_data_offset(pbuf, crs,
2555 msg_data(fragm), dsz);
Allan Stephens5f6d9122011-11-04 13:24:29 -04002556 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002557
2558 /* Is message complete? */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002559 if (exp_frags == 0) {
2560 if (prev)
2561 prev->next = pbuf->next;
2562 else
2563 *pending = pbuf->next;
2564 msg_reset_reroute_cnt(buf_msg(pbuf));
2565 *fb = pbuf;
2566 *m = buf_msg(pbuf);
2567 return 1;
2568 }
Allan Stephens0e659672010-12-31 18:59:32 +00002569 set_expected_frags(pbuf, exp_frags);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002570 return 0;
2571 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002572 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002573 return 0;
2574}
2575
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002576static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002577{
Allan Stephens5413b4c2011-01-18 13:24:55 -05002578 if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL))
2579 return;
2580
Per Lidenb97bf3f2006-01-02 19:04:38 +01002581 l_ptr->tolerance = tolerance;
2582 l_ptr->continuity_interval =
2583 ((tolerance / 4) > 500) ? 500 : tolerance / 4;
2584 l_ptr->abort_limit = tolerance / (l_ptr->continuity_interval / 4);
2585}
2586
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002587void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002588{
2589 /* Data messages from this node, inclusive FIRST_FRAGM */
Allan Stephens06d82c92008-03-06 15:06:55 -08002590 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE] = window;
2591 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE] = (window / 3) * 4;
2592 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE] = (window / 3) * 5;
2593 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE] = (window / 3) * 6;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002594 /* Transiting data messages,inclusive FIRST_FRAGM */
Allan Stephens06d82c92008-03-06 15:06:55 -08002595 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE + 4] = 300;
2596 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE + 4] = 600;
2597 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;
2598 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002599 l_ptr->queue_limit[CONN_MANAGER] = 1200;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002600 l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;
2601 l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;
2602 /* FRAGMENT and LAST_FRAGMENT packets */
2603 l_ptr->queue_limit[MSG_FRAGMENTER] = 4000;
2604}
2605
2606/**
2607 * link_find_link - locate link by name
Ben Hutchings2c530402012-07-10 10:55:09 +00002608 * @name: ptr to link name string
2609 * @node: ptr to area to be filled with ptr to associated node
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002610 *
Per Liden4323add2006-01-18 00:38:21 +01002611 * Caller must hold 'tipc_net_lock' to ensure node and bearer are not deleted;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002612 * this also prevents link deletion.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002613 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002614 * Returns pointer to link (or 0 if invalid link name).
2615 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002616static struct tipc_link *link_find_link(const char *name,
2617 struct tipc_node **node)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002618{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002619 struct tipc_link_name link_name_parts;
Allan Stephens2d627b92011-01-07 13:00:11 -05002620 struct tipc_bearer *b_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002621 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002622
2623 if (!link_name_validate(name, &link_name_parts))
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002624 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002625
Per Liden4323add2006-01-18 00:38:21 +01002626 b_ptr = tipc_bearer_find_interface(link_name_parts.if_local);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002627 if (!b_ptr)
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002628 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002629
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002630 *node = tipc_node_find(link_name_parts.addr_peer);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002631 if (!*node)
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002632 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002633
2634 l_ptr = (*node)->links[b_ptr->identity];
2635 if (!l_ptr || strcmp(l_ptr->name, name))
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002636 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002637
2638 return l_ptr;
2639}
2640
Allan Stephens5c216e12011-10-18 11:34:29 -04002641/**
2642 * link_value_is_valid -- validate proposed link tolerance/priority/window
2643 *
Ben Hutchings2c530402012-07-10 10:55:09 +00002644 * @cmd: value type (TIPC_CMD_SET_LINK_*)
2645 * @new_value: the new value
Allan Stephens5c216e12011-10-18 11:34:29 -04002646 *
2647 * Returns 1 if value is within range, 0 if not.
2648 */
Allan Stephens5c216e12011-10-18 11:34:29 -04002649static int link_value_is_valid(u16 cmd, u32 new_value)
2650{
2651 switch (cmd) {
2652 case TIPC_CMD_SET_LINK_TOL:
2653 return (new_value >= TIPC_MIN_LINK_TOL) &&
2654 (new_value <= TIPC_MAX_LINK_TOL);
2655 case TIPC_CMD_SET_LINK_PRI:
2656 return (new_value <= TIPC_MAX_LINK_PRI);
2657 case TIPC_CMD_SET_LINK_WINDOW:
2658 return (new_value >= TIPC_MIN_LINK_WIN) &&
2659 (new_value <= TIPC_MAX_LINK_WIN);
2660 }
2661 return 0;
2662}
2663
Allan Stephens5c216e12011-10-18 11:34:29 -04002664/**
2665 * link_cmd_set_value - change priority/tolerance/window for link/bearer/media
Ben Hutchings2c530402012-07-10 10:55:09 +00002666 * @name: ptr to link, bearer, or media name
2667 * @new_value: new value of link, bearer, or media setting
2668 * @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*)
Allan Stephens5c216e12011-10-18 11:34:29 -04002669 *
2670 * Caller must hold 'tipc_net_lock' to ensure link/bearer/media is not deleted.
2671 *
2672 * Returns 0 if value updated and negative value on error.
2673 */
Allan Stephens5c216e12011-10-18 11:34:29 -04002674static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd)
2675{
2676 struct tipc_node *node;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002677 struct tipc_link *l_ptr;
Allan Stephens5c216e12011-10-18 11:34:29 -04002678 struct tipc_bearer *b_ptr;
Paul Gortmaker358a0d12011-12-29 20:19:42 -05002679 struct tipc_media *m_ptr;
Allan Stephens5c216e12011-10-18 11:34:29 -04002680
2681 l_ptr = link_find_link(name, &node);
2682 if (l_ptr) {
2683 /*
2684 * acquire node lock for tipc_link_send_proto_msg().
2685 * see "TIPC locking policy" in net.c.
2686 */
2687 tipc_node_lock(node);
2688 switch (cmd) {
2689 case TIPC_CMD_SET_LINK_TOL:
2690 link_set_supervision_props(l_ptr, new_value);
2691 tipc_link_send_proto_msg(l_ptr,
2692 STATE_MSG, 0, 0, new_value, 0, 0);
2693 break;
2694 case TIPC_CMD_SET_LINK_PRI:
2695 l_ptr->priority = new_value;
2696 tipc_link_send_proto_msg(l_ptr,
2697 STATE_MSG, 0, 0, 0, new_value, 0);
2698 break;
2699 case TIPC_CMD_SET_LINK_WINDOW:
2700 tipc_link_set_queue_limits(l_ptr, new_value);
2701 break;
2702 }
2703 tipc_node_unlock(node);
2704 return 0;
2705 }
2706
2707 b_ptr = tipc_bearer_find(name);
2708 if (b_ptr) {
2709 switch (cmd) {
2710 case TIPC_CMD_SET_LINK_TOL:
2711 b_ptr->tolerance = new_value;
2712 return 0;
2713 case TIPC_CMD_SET_LINK_PRI:
2714 b_ptr->priority = new_value;
2715 return 0;
2716 case TIPC_CMD_SET_LINK_WINDOW:
2717 b_ptr->window = new_value;
2718 return 0;
2719 }
2720 return -EINVAL;
2721 }
2722
2723 m_ptr = tipc_media_find(name);
2724 if (!m_ptr)
2725 return -ENODEV;
2726 switch (cmd) {
2727 case TIPC_CMD_SET_LINK_TOL:
2728 m_ptr->tolerance = new_value;
2729 return 0;
2730 case TIPC_CMD_SET_LINK_PRI:
2731 m_ptr->priority = new_value;
2732 return 0;
2733 case TIPC_CMD_SET_LINK_WINDOW:
2734 m_ptr->window = new_value;
2735 return 0;
2736 }
2737 return -EINVAL;
2738}
2739
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002740struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space,
Per Liden4323add2006-01-18 00:38:21 +01002741 u16 cmd)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002742{
2743 struct tipc_link_config *args;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002744 u32 new_value;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002745 int res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002746
2747 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_CONFIG))
Per Liden4323add2006-01-18 00:38:21 +01002748 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002749
2750 args = (struct tipc_link_config *)TLV_DATA(req_tlv_area);
2751 new_value = ntohl(args->value);
2752
Allan Stephens5c216e12011-10-18 11:34:29 -04002753 if (!link_value_is_valid(cmd, new_value))
2754 return tipc_cfg_reply_error_string(
2755 "cannot change, value invalid");
2756
Per Liden4323add2006-01-18 00:38:21 +01002757 if (!strcmp(args->name, tipc_bclink_name)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002758 if ((cmd == TIPC_CMD_SET_LINK_WINDOW) &&
Per Liden4323add2006-01-18 00:38:21 +01002759 (tipc_bclink_set_queue_limits(new_value) == 0))
2760 return tipc_cfg_reply_none();
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002761 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
Per Liden4323add2006-01-18 00:38:21 +01002762 " (cannot change setting on broadcast link)");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002763 }
2764
Per Liden4323add2006-01-18 00:38:21 +01002765 read_lock_bh(&tipc_net_lock);
Allan Stephens5c216e12011-10-18 11:34:29 -04002766 res = link_cmd_set_value(args->name, new_value, cmd);
Per Liden4323add2006-01-18 00:38:21 +01002767 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002768 if (res)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002769 return tipc_cfg_reply_error_string("cannot change link setting");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002770
Per Liden4323add2006-01-18 00:38:21 +01002771 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002772}
2773
2774/**
2775 * link_reset_statistics - reset link statistics
2776 * @l_ptr: pointer to link
2777 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002778static void link_reset_statistics(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002779{
2780 memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));
2781 l_ptr->stats.sent_info = l_ptr->next_out_no;
2782 l_ptr->stats.recv_info = l_ptr->next_in_no;
2783}
2784
Per Liden4323add2006-01-18 00:38:21 +01002785struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002786{
2787 char *link_name;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002788 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07002789 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002790
2791 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
Per Liden4323add2006-01-18 00:38:21 +01002792 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002793
2794 link_name = (char *)TLV_DATA(req_tlv_area);
Per Liden4323add2006-01-18 00:38:21 +01002795 if (!strcmp(link_name, tipc_bclink_name)) {
2796 if (tipc_bclink_reset_stats())
2797 return tipc_cfg_reply_error_string("link not found");
2798 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002799 }
2800
Per Liden4323add2006-01-18 00:38:21 +01002801 read_lock_bh(&tipc_net_lock);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002802 l_ptr = link_find_link(link_name, &node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002803 if (!l_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01002804 read_unlock_bh(&tipc_net_lock);
2805 return tipc_cfg_reply_error_string("link not found");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002806 }
2807
Per Liden4323add2006-01-18 00:38:21 +01002808 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002809 link_reset_statistics(l_ptr);
Per Liden4323add2006-01-18 00:38:21 +01002810 tipc_node_unlock(node);
2811 read_unlock_bh(&tipc_net_lock);
2812 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002813}
2814
2815/**
2816 * percent - convert count to a percentage of total (rounding up or down)
2817 */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002818static u32 percent(u32 count, u32 total)
2819{
2820 return (count * 100 + (total / 2)) / total;
2821}
2822
2823/**
Per Liden4323add2006-01-18 00:38:21 +01002824 * tipc_link_stats - print link statistics
Per Lidenb97bf3f2006-01-02 19:04:38 +01002825 * @name: link name
2826 * @buf: print buffer area
2827 * @buf_size: size of print buffer area
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002828 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002829 * Returns length of print buffer data string (or 0 if error)
2830 */
Per Liden4323add2006-01-18 00:38:21 +01002831static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002832{
Erik Hugnedc1aed32012-06-29 00:50:23 -04002833 struct tipc_link *l;
2834 struct tipc_stats *s;
David S. Miller6c000552008-09-02 23:38:32 -07002835 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002836 char *status;
2837 u32 profile_total = 0;
Erik Hugnedc1aed32012-06-29 00:50:23 -04002838 int ret;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002839
Per Liden4323add2006-01-18 00:38:21 +01002840 if (!strcmp(name, tipc_bclink_name))
2841 return tipc_bclink_stats(buf, buf_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002842
Per Liden4323add2006-01-18 00:38:21 +01002843 read_lock_bh(&tipc_net_lock);
Erik Hugnedc1aed32012-06-29 00:50:23 -04002844 l = link_find_link(name, &node);
2845 if (!l) {
Per Liden4323add2006-01-18 00:38:21 +01002846 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002847 return 0;
2848 }
Per Liden4323add2006-01-18 00:38:21 +01002849 tipc_node_lock(node);
Erik Hugnedc1aed32012-06-29 00:50:23 -04002850 s = &l->stats;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002851
Erik Hugnedc1aed32012-06-29 00:50:23 -04002852 if (tipc_link_is_active(l))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002853 status = "ACTIVE";
Erik Hugnedc1aed32012-06-29 00:50:23 -04002854 else if (tipc_link_is_up(l))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002855 status = "STANDBY";
2856 else
2857 status = "DEFUNCT";
Erik Hugnedc1aed32012-06-29 00:50:23 -04002858
2859 ret = tipc_snprintf(buf, buf_size, "Link <%s>\n"
2860 " %s MTU:%u Priority:%u Tolerance:%u ms"
2861 " Window:%u packets\n",
2862 l->name, status, l->max_pkt, l->priority,
2863 l->tolerance, l->queue_limit[0]);
2864
2865 ret += tipc_snprintf(buf + ret, buf_size - ret,
2866 " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
2867 l->next_in_no - s->recv_info, s->recv_fragments,
2868 s->recv_fragmented, s->recv_bundles,
2869 s->recv_bundled);
2870
2871 ret += tipc_snprintf(buf + ret, buf_size - ret,
2872 " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
2873 l->next_out_no - s->sent_info, s->sent_fragments,
2874 s->sent_fragmented, s->sent_bundles,
2875 s->sent_bundled);
2876
2877 profile_total = s->msg_length_counts;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002878 if (!profile_total)
2879 profile_total = 1;
Erik Hugnedc1aed32012-06-29 00:50:23 -04002880
2881 ret += tipc_snprintf(buf + ret, buf_size - ret,
2882 " TX profile sample:%u packets average:%u octets\n"
2883 " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
2884 "-16384:%u%% -32768:%u%% -66000:%u%%\n",
2885 s->msg_length_counts,
2886 s->msg_lengths_total / profile_total,
2887 percent(s->msg_length_profile[0], profile_total),
2888 percent(s->msg_length_profile[1], profile_total),
2889 percent(s->msg_length_profile[2], profile_total),
2890 percent(s->msg_length_profile[3], profile_total),
2891 percent(s->msg_length_profile[4], profile_total),
2892 percent(s->msg_length_profile[5], profile_total),
2893 percent(s->msg_length_profile[6], profile_total));
2894
2895 ret += tipc_snprintf(buf + ret, buf_size - ret,
2896 " RX states:%u probes:%u naks:%u defs:%u"
2897 " dups:%u\n", s->recv_states, s->recv_probes,
2898 s->recv_nacks, s->deferred_recv, s->duplicates);
2899
2900 ret += tipc_snprintf(buf + ret, buf_size - ret,
2901 " TX states:%u probes:%u naks:%u acks:%u"
2902 " dups:%u\n", s->sent_states, s->sent_probes,
2903 s->sent_nacks, s->sent_acks, s->retransmitted);
2904
2905 ret += tipc_snprintf(buf + ret, buf_size - ret,
Ying Xue3c294cb2012-11-15 11:34:45 +08002906 " Congestion link:%u Send queue"
2907 " max:%u avg:%u\n", s->link_congs,
Erik Hugnedc1aed32012-06-29 00:50:23 -04002908 s->max_queue_sz, s->queue_sz_counts ?
2909 (s->accu_queue_sz / s->queue_sz_counts) : 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002910
Per Liden4323add2006-01-18 00:38:21 +01002911 tipc_node_unlock(node);
2912 read_unlock_bh(&tipc_net_lock);
Erik Hugnedc1aed32012-06-29 00:50:23 -04002913 return ret;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002914}
2915
Per Liden4323add2006-01-18 00:38:21 +01002916struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002917{
2918 struct sk_buff *buf;
2919 struct tlv_desc *rep_tlv;
2920 int str_len;
Erik Hugnedc1aed32012-06-29 00:50:23 -04002921 int pb_len;
2922 char *pb;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002923
2924 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
Per Liden4323add2006-01-18 00:38:21 +01002925 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002926
Erik Hugnedc1aed32012-06-29 00:50:23 -04002927 buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002928 if (!buf)
2929 return NULL;
2930
2931 rep_tlv = (struct tlv_desc *)buf->data;
Erik Hugnedc1aed32012-06-29 00:50:23 -04002932 pb = TLV_DATA(rep_tlv);
2933 pb_len = ULTRA_STRING_MAX_LEN;
Per Liden4323add2006-01-18 00:38:21 +01002934 str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area),
Erik Hugnedc1aed32012-06-29 00:50:23 -04002935 pb, pb_len);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002936 if (!str_len) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002937 kfree_skb(buf);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002938 return tipc_cfg_reply_error_string("link not found");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002939 }
Erik Hugnedc1aed32012-06-29 00:50:23 -04002940 str_len += 1; /* for "\0" */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002941 skb_put(buf, TLV_SPACE(str_len));
2942 TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
2943
2944 return buf;
2945}
2946
Per Lidenb97bf3f2006-01-02 19:04:38 +01002947/**
Per Liden4323add2006-01-18 00:38:21 +01002948 * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination
Per Lidenb97bf3f2006-01-02 19:04:38 +01002949 * @dest: network address of destination node
2950 * @selector: used to select from set of active links
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002951 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002952 * If no active link can be found, uses default maximum packet size.
2953 */
Per Liden4323add2006-01-18 00:38:21 +01002954u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002955{
David S. Miller6c000552008-09-02 23:38:32 -07002956 struct tipc_node *n_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002957 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002958 u32 res = MAX_PKT_DEFAULT;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002959
Per Lidenb97bf3f2006-01-02 19:04:38 +01002960 if (dest == tipc_own_addr)
2961 return MAX_MSG_SIZE;
2962
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002963 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +00002964 n_ptr = tipc_node_find(dest);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002965 if (n_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01002966 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002967 l_ptr = n_ptr->active_links[selector & 1];
2968 if (l_ptr)
Allan Stephens15e979d2010-05-11 14:30:10 +00002969 res = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01002970 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002971 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002972 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002973 return res;
2974}
2975
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002976static void link_print(struct tipc_link *l_ptr, const char *str)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002977{
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002978 pr_info("%s Link %x<%s>:", str, l_ptr->addr, l_ptr->b_ptr->name);
Allan Stephens8d64a5b2010-12-31 18:59:27 +00002979
Per Lidenb97bf3f2006-01-02 19:04:38 +01002980 if (link_working_unknown(l_ptr))
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002981 pr_cont(":WU\n");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00002982 else if (link_reset_reset(l_ptr))
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002983 pr_cont(":RR\n");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00002984 else if (link_reset_unknown(l_ptr))
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002985 pr_cont(":RU\n");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00002986 else if (link_working_working(l_ptr))
Paul Gortmaker5deedde2012-07-11 19:27:56 -04002987 pr_cont(":WW\n");
2988 else
2989 pr_cont("\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002990}