blob: b4b9b30167a3b38d53cafc797cb1d863e6391738 [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 *
Allan Stephens05646c92007-06-10 17:25:24 -07004 * Copyright (c) 1996-2007, 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
44
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090045/*
Allan Stephensa686e682008-06-04 17:29:39 -070046 * Out-of-range value for link session numbers
47 */
48
49#define INVALID_SESSION 0x10000
50
51/*
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090052 * Link state events:
Per Lidenb97bf3f2006-01-02 19:04:38 +010053 */
54
55#define STARTING_EVT 856384768 /* link processing trigger */
56#define TRAFFIC_MSG_EVT 560815u /* rx'd ??? */
57#define TIMEOUT_EVT 560817u /* link timer expired */
58
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090059/*
60 * The following two 'message types' is really just implementation
61 * data conveniently stored in the message header.
Per Lidenb97bf3f2006-01-02 19:04:38 +010062 * They must not be considered part of the protocol
63 */
64#define OPEN_MSG 0
65#define CLOSED_MSG 1
66
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +090067/*
Per Lidenb97bf3f2006-01-02 19:04:38 +010068 * State value stored in 'exp_msg_count'
69 */
70
71#define START_CHANGEOVER 100000u
72
73/**
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050074 * struct tipc_link_name - deconstructed link name
Per Lidenb97bf3f2006-01-02 19:04:38 +010075 * @addr_local: network address of node at this end
76 * @if_local: name of interface at this end
77 * @addr_peer: network address of node at far end
78 * @if_peer: name of interface at far end
79 */
80
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050081struct tipc_link_name {
Per Lidenb97bf3f2006-01-02 19:04:38 +010082 u32 addr_local;
83 char if_local[TIPC_MAX_IF_NAME];
84 u32 addr_peer;
85 char if_peer[TIPC_MAX_IF_NAME];
86};
87
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050088static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +010089 struct sk_buff *buf);
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050090static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf);
91static int link_recv_changeover_msg(struct tipc_link **l_ptr,
92 struct sk_buff **buf);
93static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance);
Allan Stephens23dd4cc2011-01-07 11:43:40 -050094static int link_send_sections_long(struct tipc_port *sender,
Per Lidenb97bf3f2006-01-02 19:04:38 +010095 struct iovec const *msg_sect,
Allan Stephens26896902011-04-21 10:42:07 -050096 u32 num_sect, unsigned int total_len,
97 u32 destnode);
Paul Gortmakera18c4bc2011-12-29 20:58:42 -050098static void link_check_defragm_bufs(struct tipc_link *l_ptr);
99static void link_state_event(struct tipc_link *l_ptr, u32 event);
100static void link_reset_statistics(struct tipc_link *l_ptr);
101static void link_print(struct tipc_link *l_ptr, const char *str);
102static void link_start(struct tipc_link *l_ptr);
103static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf);
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000104
Per Lidenb97bf3f2006-01-02 19:04:38 +0100105/*
Sam Ravnborg05790c62006-03-20 22:37:04 -0800106 * Simple link routines
Per Lidenb97bf3f2006-01-02 19:04:38 +0100107 */
108
Sam Ravnborg05790c62006-03-20 22:37:04 -0800109static unsigned int align(unsigned int i)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100110{
111 return (i + 3) & ~3u;
112}
113
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500114static void link_init_max_pkt(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100115{
116 u32 max_pkt;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900117
Allan Stephens2d627b92011-01-07 13:00:11 -0500118 max_pkt = (l_ptr->b_ptr->mtu & ~3);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100119 if (max_pkt > MAX_MSG_SIZE)
120 max_pkt = MAX_MSG_SIZE;
121
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900122 l_ptr->max_pkt_target = max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100123 if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT)
124 l_ptr->max_pkt = l_ptr->max_pkt_target;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900125 else
Per Lidenb97bf3f2006-01-02 19:04:38 +0100126 l_ptr->max_pkt = MAX_PKT_DEFAULT;
127
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900128 l_ptr->max_pkt_probes = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100129}
130
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500131static u32 link_next_sent(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100132{
133 if (l_ptr->next_out)
Allan Stephensf9057302011-10-24 16:03:12 -0400134 return buf_seqno(l_ptr->next_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100135 return mod(l_ptr->next_out_no);
136}
137
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500138static u32 link_last_sent(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100139{
140 return mod(link_next_sent(l_ptr) - 1);
141}
142
143/*
Sam Ravnborg05790c62006-03-20 22:37:04 -0800144 * Simple non-static link routines (i.e. referenced outside this file)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100145 */
146
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500147int tipc_link_is_up(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100148{
149 if (!l_ptr)
150 return 0;
Eric Dumazeta02cec22010-09-22 20:43:57 +0000151 return link_working_working(l_ptr) || link_working_unknown(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100152}
153
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500154int tipc_link_is_active(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100155{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000156 return (l_ptr->owner->active_links[0] == l_ptr) ||
157 (l_ptr->owner->active_links[1] == l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100158}
159
160/**
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500161 * link_name_validate - validate & (optionally) deconstruct tipc_link name
Per Lidenb97bf3f2006-01-02 19:04:38 +0100162 * @name - ptr to link name string
163 * @name_parts - ptr to area for link name components (or NULL if not needed)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900164 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100165 * Returns 1 if link name is valid, otherwise 0.
166 */
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 */
183
184 name_copy[TIPC_MAX_LINK_NAME - 1] = 0;
185 /* need above in case non-Posix strncpy() doesn't pad with nulls */
186 strncpy(name_copy, name, TIPC_MAX_LINK_NAME);
187 if (name_copy[TIPC_MAX_LINK_NAME - 1] != 0)
188 return 0;
189
190 /* ensure all component parts of link name are present */
191
192 addr_local = name_copy;
Allan Stephens2db99832010-12-31 18:59:33 +0000193 if_local = strchr(addr_local, ':');
194 if (if_local == NULL)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100195 return 0;
196 *(if_local++) = 0;
Allan Stephens2db99832010-12-31 18:59:33 +0000197 addr_peer = strchr(if_local, '-');
198 if (addr_peer == NULL)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100199 return 0;
200 *(addr_peer++) = 0;
201 if_local_len = addr_peer - if_local;
Allan Stephens2db99832010-12-31 18:59:33 +0000202 if_peer = strchr(addr_peer, ':');
203 if (if_peer == NULL)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100204 return 0;
205 *(if_peer++) = 0;
206 if_peer_len = strlen(if_peer) + 1;
207
208 /* validate component parts of link name */
209
210 if ((sscanf(addr_local, "%u.%u.%u%c",
211 &z_local, &c_local, &n_local, &dummy) != 3) ||
212 (sscanf(addr_peer, "%u.%u.%u%c",
213 &z_peer, &c_peer, &n_peer, &dummy) != 3) ||
214 (z_local > 255) || (c_local > 4095) || (n_local > 4095) ||
215 (z_peer > 255) || (c_peer > 4095) || (n_peer > 4095) ||
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900216 (if_local_len <= 1) || (if_local_len > TIPC_MAX_IF_NAME) ||
217 (if_peer_len <= 1) || (if_peer_len > TIPC_MAX_IF_NAME) ||
Per Lidenb97bf3f2006-01-02 19:04:38 +0100218 (strspn(if_local, tipc_alphabet) != (if_local_len - 1)) ||
219 (strspn(if_peer, tipc_alphabet) != (if_peer_len - 1)))
220 return 0;
221
222 /* return link name components, if necessary */
223
224 if (name_parts) {
225 name_parts->addr_local = tipc_addr(z_local, c_local, n_local);
226 strcpy(name_parts->if_local, if_local);
227 name_parts->addr_peer = tipc_addr(z_peer, c_peer, n_peer);
228 strcpy(name_parts->if_peer, if_peer);
229 }
230 return 1;
231}
232
233/**
234 * link_timeout - handle expiration of link timer
235 * @l_ptr: pointer to link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900236 *
Per Liden4323add2006-01-18 00:38:21 +0100237 * This routine must not grab "tipc_net_lock" to avoid a potential deadlock conflict
238 * with tipc_link_delete(). (There is no risk that the node will be deleted by
239 * another thread because tipc_link_delete() always cancels the link timer before
240 * tipc_node_delete() is called.)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100241 */
242
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500243static void link_timeout(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100244{
Per Liden4323add2006-01-18 00:38:21 +0100245 tipc_node_lock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100246
247 /* update counters used in statistical profiling of send traffic */
248
249 l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size;
250 l_ptr->stats.queue_sz_counts++;
251
Per Lidenb97bf3f2006-01-02 19:04:38 +0100252 if (l_ptr->first_out) {
253 struct tipc_msg *msg = buf_msg(l_ptr->first_out);
254 u32 length = msg_size(msg);
255
Joe Perchesf64f9e72009-11-29 16:55:45 -0800256 if ((msg_user(msg) == MSG_FRAGMENTER) &&
257 (msg_type(msg) == FIRST_FRAGMENT)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100258 length = msg_size(msg_get_wrapped(msg));
259 }
260 if (length) {
261 l_ptr->stats.msg_lengths_total += length;
262 l_ptr->stats.msg_length_counts++;
263 if (length <= 64)
264 l_ptr->stats.msg_length_profile[0]++;
265 else if (length <= 256)
266 l_ptr->stats.msg_length_profile[1]++;
267 else if (length <= 1024)
268 l_ptr->stats.msg_length_profile[2]++;
269 else if (length <= 4096)
270 l_ptr->stats.msg_length_profile[3]++;
271 else if (length <= 16384)
272 l_ptr->stats.msg_length_profile[4]++;
273 else if (length <= 32768)
274 l_ptr->stats.msg_length_profile[5]++;
275 else
276 l_ptr->stats.msg_length_profile[6]++;
277 }
278 }
279
280 /* do all other link processing performed on a periodic basis */
281
282 link_check_defragm_bufs(l_ptr);
283
284 link_state_event(l_ptr, TIMEOUT_EVT);
285
286 if (l_ptr->next_out)
Per Liden4323add2006-01-18 00:38:21 +0100287 tipc_link_push_queue(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100288
Per Liden4323add2006-01-18 00:38:21 +0100289 tipc_node_unlock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100290}
291
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500292static void link_set_timer(struct tipc_link *l_ptr, u32 time)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100293{
294 k_start_timer(&l_ptr->timer, time);
295}
296
297/**
Per Liden4323add2006-01-18 00:38:21 +0100298 * tipc_link_create - create a new link
Allan Stephens37b9c082011-02-28 11:32:27 -0500299 * @n_ptr: pointer to associated node
Per Lidenb97bf3f2006-01-02 19:04:38 +0100300 * @b_ptr: pointer to associated bearer
Per Lidenb97bf3f2006-01-02 19:04:38 +0100301 * @media_addr: media address to use when sending messages over link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900302 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100303 * Returns pointer to link.
304 */
305
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500306struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
Allan Stephens37b9c082011-02-28 11:32:27 -0500307 struct tipc_bearer *b_ptr,
Per Liden4323add2006-01-18 00:38:21 +0100308 const struct tipc_media_addr *media_addr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100309{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500310 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100311 struct tipc_msg *msg;
312 char *if_name;
Allan Stephens37b9c082011-02-28 11:32:27 -0500313 char addr_string[16];
314 u32 peer = n_ptr->addr;
315
316 if (n_ptr->link_cnt >= 2) {
317 tipc_addr_string_fill(addr_string, n_ptr->addr);
318 err("Attempt to establish third link to %s\n", addr_string);
319 return NULL;
320 }
321
322 if (n_ptr->links[b_ptr->identity]) {
323 tipc_addr_string_fill(addr_string, n_ptr->addr);
324 err("Attempt to establish second link on <%s> to %s\n",
325 b_ptr->name, addr_string);
326 return NULL;
327 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100328
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700329 l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100330 if (!l_ptr) {
Allan Stephensa10bd922006-06-25 23:52:17 -0700331 warn("Link creation failed, no memory\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100332 return NULL;
333 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100334
335 l_ptr->addr = peer;
Allan Stephens2d627b92011-01-07 13:00:11 -0500336 if_name = strchr(b_ptr->name, ':') + 1;
Allan Stephens062b4c92011-04-07 09:28:47 -0400337 sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
Per Lidenb97bf3f2006-01-02 19:04:38 +0100338 tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900339 tipc_node(tipc_own_addr),
Per Lidenb97bf3f2006-01-02 19:04:38 +0100340 if_name,
341 tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
Allan Stephens062b4c92011-04-07 09:28:47 -0400342 /* note: peer i/f name is updated by reset/activate message */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100343 memcpy(&l_ptr->media_addr, media_addr, sizeof(*media_addr));
Allan Stephens37b9c082011-02-28 11:32:27 -0500344 l_ptr->owner = n_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100345 l_ptr->checkpoint = 1;
Allan Stephensf882cb72011-04-07 09:43:27 -0400346 l_ptr->peer_session = INVALID_SESSION;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100347 l_ptr->b_ptr = b_ptr;
Allan Stephens5c216e12011-10-18 11:34:29 -0400348 link_set_supervision_props(l_ptr, b_ptr->tolerance);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100349 l_ptr->state = RESET_UNKNOWN;
350
351 l_ptr->pmsg = (struct tipc_msg *)&l_ptr->proto_msg;
352 msg = l_ptr->pmsg;
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000353 tipc_msg_init(msg, LINK_PROTOCOL, RESET_MSG, INT_H_SIZE, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100354 msg_set_size(msg, sizeof(l_ptr->proto_msg));
Allan Stephensa686e682008-06-04 17:29:39 -0700355 msg_set_session(msg, (tipc_random & 0xffff));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100356 msg_set_bearer_id(msg, b_ptr->identity);
357 strcpy((char *)msg_data(msg), if_name);
358
359 l_ptr->priority = b_ptr->priority;
Allan Stephens5c216e12011-10-18 11:34:29 -0400360 tipc_link_set_queue_limits(l_ptr, b_ptr->window);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100361
362 link_init_max_pkt(l_ptr);
363
364 l_ptr->next_out_no = 1;
365 INIT_LIST_HEAD(&l_ptr->waiting_ports);
366
367 link_reset_statistics(l_ptr);
368
Allan Stephens37b9c082011-02-28 11:32:27 -0500369 tipc_node_attach_link(n_ptr, l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100370
Florian Westphal945710652007-07-26 00:05:07 -0700371 k_init_timer(&l_ptr->timer, (Handler)link_timeout, (unsigned long)l_ptr);
372 list_add_tail(&l_ptr->link_list, &b_ptr->links);
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000373 tipc_k_signal((Handler)link_start, (unsigned long)l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100374
Per Lidenb97bf3f2006-01-02 19:04:38 +0100375 return l_ptr;
376}
377
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900378/**
Per Liden4323add2006-01-18 00:38:21 +0100379 * tipc_link_delete - delete a link
Per Lidenb97bf3f2006-01-02 19:04:38 +0100380 * @l_ptr: pointer to link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900381 *
Per Liden4323add2006-01-18 00:38:21 +0100382 * Note: 'tipc_net_lock' is write_locked, bearer is locked.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100383 * This routine must not grab the node lock until after link timer cancellation
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900384 * to avoid a potential deadlock situation.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100385 */
386
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500387void tipc_link_delete(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100388{
389 if (!l_ptr) {
390 err("Attempt to delete non-existent link\n");
391 return;
392 }
393
Per Lidenb97bf3f2006-01-02 19:04:38 +0100394 k_cancel_timer(&l_ptr->timer);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900395
Per Liden4323add2006-01-18 00:38:21 +0100396 tipc_node_lock(l_ptr->owner);
397 tipc_link_reset(l_ptr);
398 tipc_node_detach_link(l_ptr->owner, l_ptr);
399 tipc_link_stop(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100400 list_del_init(&l_ptr->link_list);
Per Liden4323add2006-01-18 00:38:21 +0100401 tipc_node_unlock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100402 k_term_timer(&l_ptr->timer);
403 kfree(l_ptr);
404}
405
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500406static void link_start(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100407{
Allan Stephens214dda42011-01-24 16:22:43 -0500408 tipc_node_lock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100409 link_state_event(l_ptr, STARTING_EVT);
Allan Stephens214dda42011-01-24 16:22:43 -0500410 tipc_node_unlock(l_ptr->owner);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100411}
412
413/**
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900414 * link_schedule_port - schedule port for deferred sending
Per Lidenb97bf3f2006-01-02 19:04:38 +0100415 * @l_ptr: pointer to link
416 * @origport: reference to sending port
417 * @sz: amount of data to be sent
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900418 *
419 * Schedules port for renewed sending of messages after link congestion
Per Lidenb97bf3f2006-01-02 19:04:38 +0100420 * has abated.
421 */
422
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500423static int link_schedule_port(struct tipc_link *l_ptr, u32 origport, u32 sz)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100424{
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500425 struct tipc_port *p_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100426
Per Liden4323add2006-01-18 00:38:21 +0100427 spin_lock_bh(&tipc_port_list_lock);
428 p_ptr = tipc_port_lock(origport);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100429 if (p_ptr) {
430 if (!p_ptr->wakeup)
431 goto exit;
432 if (!list_empty(&p_ptr->wait_list))
433 goto exit;
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500434 p_ptr->congested = 1;
Allan Stephens15e979d2010-05-11 14:30:10 +0000435 p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100436 list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports);
437 l_ptr->stats.link_congs++;
438exit:
Per Liden4323add2006-01-18 00:38:21 +0100439 tipc_port_unlock(p_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100440 }
Per Liden4323add2006-01-18 00:38:21 +0100441 spin_unlock_bh(&tipc_port_list_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100442 return -ELINKCONG;
443}
444
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500445void tipc_link_wakeup_ports(struct tipc_link *l_ptr, int all)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100446{
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500447 struct tipc_port *p_ptr;
448 struct tipc_port *temp_p_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100449 int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size;
450
451 if (all)
452 win = 100000;
453 if (win <= 0)
454 return;
Per Liden4323add2006-01-18 00:38:21 +0100455 if (!spin_trylock_bh(&tipc_port_list_lock))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100456 return;
457 if (link_congested(l_ptr))
458 goto exit;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900459 list_for_each_entry_safe(p_ptr, temp_p_ptr, &l_ptr->waiting_ports,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100460 wait_list) {
461 if (win <= 0)
462 break;
463 list_del_init(&p_ptr->wait_list);
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500464 spin_lock_bh(p_ptr->lock);
465 p_ptr->congested = 0;
466 p_ptr->wakeup(p_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100467 win -= p_ptr->waiting_pkts;
Allan Stephens23dd4cc2011-01-07 11:43:40 -0500468 spin_unlock_bh(p_ptr->lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100469 }
470
471exit:
Per Liden4323add2006-01-18 00:38:21 +0100472 spin_unlock_bh(&tipc_port_list_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100473}
474
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900475/**
Per Lidenb97bf3f2006-01-02 19:04:38 +0100476 * link_release_outqueue - purge link's outbound message queue
477 * @l_ptr: pointer to link
478 */
479
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500480static void link_release_outqueue(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100481{
482 struct sk_buff *buf = l_ptr->first_out;
483 struct sk_buff *next;
484
485 while (buf) {
486 next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400487 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100488 buf = next;
489 }
490 l_ptr->first_out = NULL;
491 l_ptr->out_queue_size = 0;
492}
493
494/**
Per Liden4323add2006-01-18 00:38:21 +0100495 * tipc_link_reset_fragments - purge link's inbound message fragments queue
Per Lidenb97bf3f2006-01-02 19:04:38 +0100496 * @l_ptr: pointer to link
497 */
498
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500499void tipc_link_reset_fragments(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100500{
501 struct sk_buff *buf = l_ptr->defragm_buf;
502 struct sk_buff *next;
503
504 while (buf) {
505 next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400506 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100507 buf = next;
508 }
509 l_ptr->defragm_buf = NULL;
510}
511
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900512/**
Per Liden4323add2006-01-18 00:38:21 +0100513 * tipc_link_stop - purge all inbound and outbound messages associated with link
Per Lidenb97bf3f2006-01-02 19:04:38 +0100514 * @l_ptr: pointer to link
515 */
516
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500517void tipc_link_stop(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100518{
519 struct sk_buff *buf;
520 struct sk_buff *next;
521
522 buf = l_ptr->oldest_deferred_in;
523 while (buf) {
524 next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400525 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100526 buf = next;
527 }
528
529 buf = l_ptr->first_out;
530 while (buf) {
531 next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400532 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100533 buf = next;
534 }
535
Per Liden4323add2006-01-18 00:38:21 +0100536 tipc_link_reset_fragments(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100537
Allan Stephens5f6d9122011-11-04 13:24:29 -0400538 kfree_skb(l_ptr->proto_msg_queue);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100539 l_ptr->proto_msg_queue = NULL;
540}
541
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500542void tipc_link_reset(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100543{
544 struct sk_buff *buf;
545 u32 prev_state = l_ptr->state;
546 u32 checkpoint = l_ptr->next_in_no;
Allan Stephens5392d642006-06-25 23:52:50 -0700547 int was_active_link = tipc_link_is_active(l_ptr);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900548
Allan Stephensa686e682008-06-04 17:29:39 -0700549 msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100550
Allan Stephensa686e682008-06-04 17:29:39 -0700551 /* Link is down, accept any session */
552 l_ptr->peer_session = INVALID_SESSION;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100553
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900554 /* Prepare for max packet size negotiation */
Per Lidenb97bf3f2006-01-02 19:04:38 +0100555 link_init_max_pkt(l_ptr);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900556
Per Lidenb97bf3f2006-01-02 19:04:38 +0100557 l_ptr->state = RESET_UNKNOWN;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100558
559 if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))
560 return;
561
Per Liden4323add2006-01-18 00:38:21 +0100562 tipc_node_link_down(l_ptr->owner, l_ptr);
563 tipc_bearer_remove_dest(l_ptr->b_ptr, l_ptr->addr);
Paul Gortmaker7368ddf2010-10-12 14:25:58 +0000564
Paul Gortmaker8f19afb2011-02-28 11:36:21 -0400565 if (was_active_link && tipc_node_active_links(l_ptr->owner) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +0100566 l_ptr->owner->permit_changeover) {
567 l_ptr->reset_checkpoint = checkpoint;
568 l_ptr->exp_msg_count = START_CHANGEOVER;
569 }
570
571 /* Clean up all queues: */
572
573 link_release_outqueue(l_ptr);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400574 kfree_skb(l_ptr->proto_msg_queue);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100575 l_ptr->proto_msg_queue = NULL;
576 buf = l_ptr->oldest_deferred_in;
577 while (buf) {
578 struct sk_buff *next = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -0400579 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100580 buf = next;
581 }
582 if (!list_empty(&l_ptr->waiting_ports))
Per Liden4323add2006-01-18 00:38:21 +0100583 tipc_link_wakeup_ports(l_ptr, 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100584
585 l_ptr->retransm_queue_head = 0;
586 l_ptr->retransm_queue_size = 0;
587 l_ptr->last_out = NULL;
588 l_ptr->first_out = NULL;
589 l_ptr->next_out = NULL;
590 l_ptr->unacked_window = 0;
591 l_ptr->checkpoint = 1;
592 l_ptr->next_out_no = 1;
593 l_ptr->deferred_inqueue_sz = 0;
594 l_ptr->oldest_deferred_in = NULL;
595 l_ptr->newest_deferred_in = NULL;
596 l_ptr->fsm_msg_cnt = 0;
597 l_ptr->stale_count = 0;
598 link_reset_statistics(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100599}
600
601
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500602static void link_activate(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100603{
Allan Stephens5392d642006-06-25 23:52:50 -0700604 l_ptr->next_in_no = l_ptr->stats.recv_info = 1;
Per Liden4323add2006-01-18 00:38:21 +0100605 tipc_node_link_up(l_ptr->owner, l_ptr);
606 tipc_bearer_add_dest(l_ptr->b_ptr, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100607}
608
609/**
610 * link_state_event - link finite state machine
611 * @l_ptr: pointer to link
612 * @event: state machine event to process
613 */
614
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500615static void link_state_event(struct tipc_link *l_ptr, unsigned event)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100616{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500617 struct tipc_link *other;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100618 u32 cont_intv = l_ptr->continuity_interval;
619
620 if (!l_ptr->started && (event != STARTING_EVT))
621 return; /* Not yet. */
622
623 if (link_blocked(l_ptr)) {
Allan Stephensa0168922010-12-31 18:59:35 +0000624 if (event == TIMEOUT_EVT)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100625 link_set_timer(l_ptr, cont_intv);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100626 return; /* Changeover going on */
627 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100628
629 switch (l_ptr->state) {
630 case WORKING_WORKING:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100631 switch (event) {
632 case TRAFFIC_MSG_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100633 case ACTIVATE_MSG:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100634 break;
635 case TIMEOUT_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100636 if (l_ptr->next_in_no != l_ptr->checkpoint) {
637 l_ptr->checkpoint = l_ptr->next_in_no;
Per Liden4323add2006-01-18 00:38:21 +0100638 if (tipc_bclink_acks_missing(l_ptr->owner)) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900639 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
Per Liden4323add2006-01-18 00:38:21 +0100640 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100641 l_ptr->fsm_msg_cnt++;
642 } else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900643 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
Per Liden4323add2006-01-18 00:38:21 +0100644 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100645 l_ptr->fsm_msg_cnt++;
646 }
647 link_set_timer(l_ptr, cont_intv);
648 break;
649 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100650 l_ptr->state = WORKING_UNKNOWN;
651 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100652 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100653 l_ptr->fsm_msg_cnt++;
654 link_set_timer(l_ptr, cont_intv / 4);
655 break;
656 case RESET_MSG:
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900657 info("Resetting link <%s>, requested by peer\n",
Allan Stephensa10bd922006-06-25 23:52:17 -0700658 l_ptr->name);
Per Liden4323add2006-01-18 00:38:21 +0100659 tipc_link_reset(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100660 l_ptr->state = RESET_RESET;
661 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100662 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100663 l_ptr->fsm_msg_cnt++;
664 link_set_timer(l_ptr, cont_intv);
665 break;
666 default:
667 err("Unknown link event %u in WW state\n", event);
668 }
669 break;
670 case WORKING_UNKNOWN:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100671 switch (event) {
672 case TRAFFIC_MSG_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100673 case ACTIVATE_MSG:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100674 l_ptr->state = WORKING_WORKING;
675 l_ptr->fsm_msg_cnt = 0;
676 link_set_timer(l_ptr, cont_intv);
677 break;
678 case RESET_MSG:
Allan Stephensa10bd922006-06-25 23:52:17 -0700679 info("Resetting link <%s>, requested by peer "
680 "while probing\n", l_ptr->name);
Per Liden4323add2006-01-18 00:38:21 +0100681 tipc_link_reset(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100682 l_ptr->state = RESET_RESET;
683 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100684 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100685 l_ptr->fsm_msg_cnt++;
686 link_set_timer(l_ptr, cont_intv);
687 break;
688 case TIMEOUT_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100689 if (l_ptr->next_in_no != l_ptr->checkpoint) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100690 l_ptr->state = WORKING_WORKING;
691 l_ptr->fsm_msg_cnt = 0;
692 l_ptr->checkpoint = l_ptr->next_in_no;
Per Liden4323add2006-01-18 00:38:21 +0100693 if (tipc_bclink_acks_missing(l_ptr->owner)) {
694 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
695 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100696 l_ptr->fsm_msg_cnt++;
697 }
698 link_set_timer(l_ptr, cont_intv);
699 } else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900700 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
Per Liden4323add2006-01-18 00:38:21 +0100701 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100702 l_ptr->fsm_msg_cnt++;
703 link_set_timer(l_ptr, cont_intv / 4);
704 } else { /* Link has failed */
Allan Stephensa10bd922006-06-25 23:52:17 -0700705 warn("Resetting link <%s>, peer not responding\n",
706 l_ptr->name);
Per Liden4323add2006-01-18 00:38:21 +0100707 tipc_link_reset(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100708 l_ptr->state = RESET_UNKNOWN;
709 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100710 tipc_link_send_proto_msg(l_ptr, RESET_MSG,
711 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100712 l_ptr->fsm_msg_cnt++;
713 link_set_timer(l_ptr, cont_intv);
714 }
715 break;
716 default:
717 err("Unknown link event %u in WU state\n", event);
718 }
719 break;
720 case RESET_UNKNOWN:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100721 switch (event) {
722 case TRAFFIC_MSG_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100723 break;
724 case ACTIVATE_MSG:
725 other = l_ptr->owner->active_links[0];
Allan Stephens8d64a5b2010-12-31 18:59:27 +0000726 if (other && link_working_unknown(other))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100727 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100728 l_ptr->state = WORKING_WORKING;
729 l_ptr->fsm_msg_cnt = 0;
730 link_activate(l_ptr);
Per Liden4323add2006-01-18 00:38:21 +0100731 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100732 l_ptr->fsm_msg_cnt++;
733 link_set_timer(l_ptr, cont_intv);
734 break;
735 case RESET_MSG:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100736 l_ptr->state = RESET_RESET;
737 l_ptr->fsm_msg_cnt = 0;
Per Liden4323add2006-01-18 00:38:21 +0100738 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100739 l_ptr->fsm_msg_cnt++;
740 link_set_timer(l_ptr, cont_intv);
741 break;
742 case STARTING_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100743 l_ptr->started = 1;
744 /* fall through */
745 case TIMEOUT_EVT:
Per Liden4323add2006-01-18 00:38:21 +0100746 tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100747 l_ptr->fsm_msg_cnt++;
748 link_set_timer(l_ptr, cont_intv);
749 break;
750 default:
751 err("Unknown link event %u in RU state\n", event);
752 }
753 break;
754 case RESET_RESET:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100755 switch (event) {
756 case TRAFFIC_MSG_EVT:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100757 case ACTIVATE_MSG:
758 other = l_ptr->owner->active_links[0];
Allan Stephens8d64a5b2010-12-31 18:59:27 +0000759 if (other && link_working_unknown(other))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100760 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100761 l_ptr->state = WORKING_WORKING;
762 l_ptr->fsm_msg_cnt = 0;
763 link_activate(l_ptr);
Per Liden4323add2006-01-18 00:38:21 +0100764 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100765 l_ptr->fsm_msg_cnt++;
766 link_set_timer(l_ptr, cont_intv);
767 break;
768 case RESET_MSG:
Per Lidenb97bf3f2006-01-02 19:04:38 +0100769 break;
770 case TIMEOUT_EVT:
Per Liden4323add2006-01-18 00:38:21 +0100771 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100772 l_ptr->fsm_msg_cnt++;
773 link_set_timer(l_ptr, cont_intv);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100774 break;
775 default:
776 err("Unknown link event %u in RR state\n", event);
777 }
778 break;
779 default:
780 err("Unknown link state %u/%u\n", l_ptr->state, event);
781 }
782}
783
784/*
785 * link_bundle_buf(): Append contents of a buffer to
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900786 * the tail of an existing one.
Per Lidenb97bf3f2006-01-02 19:04:38 +0100787 */
788
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500789static int link_bundle_buf(struct tipc_link *l_ptr,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900790 struct sk_buff *bundler,
Per Lidenb97bf3f2006-01-02 19:04:38 +0100791 struct sk_buff *buf)
792{
793 struct tipc_msg *bundler_msg = buf_msg(bundler);
794 struct tipc_msg *msg = buf_msg(buf);
795 u32 size = msg_size(msg);
Allan Stephense49060c2006-06-29 12:32:46 -0700796 u32 bundle_size = msg_size(bundler_msg);
797 u32 to_pos = align(bundle_size);
798 u32 pad = to_pos - bundle_size;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100799
800 if (msg_user(bundler_msg) != MSG_BUNDLER)
801 return 0;
802 if (msg_type(bundler_msg) != OPEN_MSG)
803 return 0;
Allan Stephense49060c2006-06-29 12:32:46 -0700804 if (skb_tailroom(bundler) < (pad + size))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100805 return 0;
Allan Stephens15e979d2010-05-11 14:30:10 +0000806 if (l_ptr->max_pkt < (to_pos + size))
Allan Stephens863fae62006-07-03 19:39:36 -0700807 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100808
Allan Stephense49060c2006-06-29 12:32:46 -0700809 skb_put(bundler, pad + size);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -0300810 skb_copy_to_linear_data_offset(bundler, to_pos, buf->data, size);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100811 msg_set_size(bundler_msg, to_pos + size);
812 msg_set_msgcnt(bundler_msg, msg_msgcnt(bundler_msg) + 1);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400813 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100814 l_ptr->stats.sent_bundled++;
815 return 1;
816}
817
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500818static void link_add_to_outqueue(struct tipc_link *l_ptr,
Sam Ravnborg05790c62006-03-20 22:37:04 -0800819 struct sk_buff *buf,
820 struct tipc_msg *msg)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100821{
822 u32 ack = mod(l_ptr->next_in_no - 1);
823 u32 seqno = mod(l_ptr->next_out_no++);
824
825 msg_set_word(msg, 2, ((ack << 16) | seqno));
826 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
827 buf->next = NULL;
828 if (l_ptr->first_out) {
829 l_ptr->last_out->next = buf;
830 l_ptr->last_out = buf;
831 } else
832 l_ptr->first_out = l_ptr->last_out = buf;
Allan Stephens9bd80b62011-01-18 15:02:50 -0500833
Per Lidenb97bf3f2006-01-02 19:04:38 +0100834 l_ptr->out_queue_size++;
Allan Stephens9bd80b62011-01-18 15:02:50 -0500835 if (l_ptr->out_queue_size > l_ptr->stats.max_queue_sz)
836 l_ptr->stats.max_queue_sz = l_ptr->out_queue_size;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100837}
838
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500839static void link_add_chain_to_outqueue(struct tipc_link *l_ptr,
Allan Stephensdc63d912011-04-21 11:50:42 -0400840 struct sk_buff *buf_chain,
841 u32 long_msgno)
842{
843 struct sk_buff *buf;
844 struct tipc_msg *msg;
845
846 if (!l_ptr->next_out)
847 l_ptr->next_out = buf_chain;
848 while (buf_chain) {
849 buf = buf_chain;
850 buf_chain = buf_chain->next;
851
852 msg = buf_msg(buf);
853 msg_set_long_msgno(msg, long_msgno);
854 link_add_to_outqueue(l_ptr, buf, msg);
855 }
856}
857
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900858/*
859 * tipc_link_send_buf() is the 'full path' for messages, called from
Per Lidenb97bf3f2006-01-02 19:04:38 +0100860 * inside TIPC when the 'fast path' in tipc_send_buf
861 * has failed, and from link_send()
862 */
863
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500864int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100865{
866 struct tipc_msg *msg = buf_msg(buf);
867 u32 size = msg_size(msg);
868 u32 dsz = msg_data_sz(msg);
869 u32 queue_size = l_ptr->out_queue_size;
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000870 u32 imp = tipc_msg_tot_importance(msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100871 u32 queue_limit = l_ptr->queue_limit[imp];
Allan Stephens15e979d2010-05-11 14:30:10 +0000872 u32 max_packet = l_ptr->max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100873
Per Lidenb97bf3f2006-01-02 19:04:38 +0100874 /* Match msg importance against queue limits: */
875
876 if (unlikely(queue_size >= queue_limit)) {
877 if (imp <= TIPC_CRITICAL_IMPORTANCE) {
Allan Stephensbebc55a2011-04-19 10:17:58 -0400878 link_schedule_port(l_ptr, msg_origport(msg), size);
Allan Stephens5f6d9122011-11-04 13:24:29 -0400879 kfree_skb(buf);
Allan Stephensbebc55a2011-04-19 10:17:58 -0400880 return -ELINKCONG;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100881 }
Allan Stephens5f6d9122011-11-04 13:24:29 -0400882 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100883 if (imp > CONN_MANAGER) {
Allan Stephensa10bd922006-06-25 23:52:17 -0700884 warn("Resetting link <%s>, send queue full", l_ptr->name);
Per Liden4323add2006-01-18 00:38:21 +0100885 tipc_link_reset(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100886 }
887 return dsz;
888 }
889
890 /* Fragmentation needed ? */
891
892 if (size > max_packet)
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000893 return link_send_long_buf(l_ptr, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100894
895 /* Packet can be queued or sent: */
896
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900897 if (likely(!tipc_bearer_congested(l_ptr->b_ptr, l_ptr) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +0100898 !link_congested(l_ptr))) {
899 link_add_to_outqueue(l_ptr, buf, msg);
900
Per Liden4323add2006-01-18 00:38:21 +0100901 if (likely(tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr))) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100902 l_ptr->unacked_window = 0;
903 } else {
Per Liden4323add2006-01-18 00:38:21 +0100904 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100905 l_ptr->stats.bearer_congs++;
906 l_ptr->next_out = buf;
907 }
908 return dsz;
909 }
910 /* Congestion: can message be bundled ?: */
911
912 if ((msg_user(msg) != CHANGEOVER_PROTOCOL) &&
913 (msg_user(msg) != MSG_FRAGMENTER)) {
914
915 /* Try adding message to an existing bundle */
916
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900917 if (l_ptr->next_out &&
Per Lidenb97bf3f2006-01-02 19:04:38 +0100918 link_bundle_buf(l_ptr, l_ptr->last_out, buf)) {
Per Liden4323add2006-01-18 00:38:21 +0100919 tipc_bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100920 return dsz;
921 }
922
923 /* Try creating a new bundle */
924
925 if (size <= max_packet * 2 / 3) {
stephen hemminger31e3c3f2010-10-13 13:20:35 +0000926 struct sk_buff *bundler = tipc_buf_acquire(max_packet);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100927 struct tipc_msg bundler_hdr;
928
929 if (bundler) {
Allan Stephensc68ca7b2010-05-11 14:30:12 +0000930 tipc_msg_init(&bundler_hdr, MSG_BUNDLER, OPEN_MSG,
Allan Stephens75715212008-06-04 17:37:34 -0700931 INT_H_SIZE, l_ptr->addr);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -0300932 skb_copy_to_linear_data(bundler, &bundler_hdr,
933 INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100934 skb_trim(bundler, INT_H_SIZE);
935 link_bundle_buf(l_ptr, bundler, buf);
936 buf = bundler;
937 msg = buf_msg(buf);
938 l_ptr->stats.sent_bundles++;
939 }
940 }
941 }
942 if (!l_ptr->next_out)
943 l_ptr->next_out = buf;
944 link_add_to_outqueue(l_ptr, buf, msg);
Per Liden4323add2006-01-18 00:38:21 +0100945 tipc_bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100946 return dsz;
947}
948
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900949/*
950 * tipc_link_send(): same as tipc_link_send_buf(), but the link to use has
Per Lidenb97bf3f2006-01-02 19:04:38 +0100951 * not been selected yet, and the the owner node is not locked
952 * Called by TIPC internal users, e.g. the name distributor
953 */
954
Per Liden4323add2006-01-18 00:38:21 +0100955int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100956{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500957 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -0700958 struct tipc_node *n_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100959 int res = -ELINKCONG;
960
Per Liden4323add2006-01-18 00:38:21 +0100961 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +0000962 n_ptr = tipc_node_find(dest);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100963 if (n_ptr) {
Per Liden4323add2006-01-18 00:38:21 +0100964 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100965 l_ptr = n_ptr->active_links[selector & 1];
Allan Stephensa0168922010-12-31 18:59:35 +0000966 if (l_ptr)
Per Liden4323add2006-01-18 00:38:21 +0100967 res = tipc_link_send_buf(l_ptr, buf);
Allan Stephensa0168922010-12-31 18:59:35 +0000968 else
Allan Stephens5f6d9122011-11-04 13:24:29 -0400969 kfree_skb(buf);
Per Liden4323add2006-01-18 00:38:21 +0100970 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100971 } else {
Allan Stephens5f6d9122011-11-04 13:24:29 -0400972 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100973 }
Per Liden4323add2006-01-18 00:38:21 +0100974 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100975 return res;
976}
977
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900978/*
Allan Stephens9aa88c22011-05-31 13:38:02 -0400979 * tipc_link_send_names - send name table entries to new neighbor
980 *
981 * Send routine for bulk delivery of name table messages when contact
982 * with a new neighbor occurs. No link congestion checking is performed
983 * because name table messages *must* be delivered. The messages must be
984 * small enough not to require fragmentation.
985 * Called without any locks held.
986 */
987
988void tipc_link_send_names(struct list_head *message_list, u32 dest)
989{
990 struct tipc_node *n_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500991 struct tipc_link *l_ptr;
Allan Stephens9aa88c22011-05-31 13:38:02 -0400992 struct sk_buff *buf;
993 struct sk_buff *temp_buf;
994
995 if (list_empty(message_list))
996 return;
997
998 read_lock_bh(&tipc_net_lock);
999 n_ptr = tipc_node_find(dest);
1000 if (n_ptr) {
1001 tipc_node_lock(n_ptr);
1002 l_ptr = n_ptr->active_links[0];
1003 if (l_ptr) {
1004 /* convert circular list to linear list */
1005 ((struct sk_buff *)message_list->prev)->next = NULL;
1006 link_add_chain_to_outqueue(l_ptr,
1007 (struct sk_buff *)message_list->next, 0);
1008 tipc_link_push_queue(l_ptr);
1009 INIT_LIST_HEAD(message_list);
1010 }
1011 tipc_node_unlock(n_ptr);
1012 }
1013 read_unlock_bh(&tipc_net_lock);
1014
1015 /* discard the messages if they couldn't be sent */
1016
1017 list_for_each_safe(buf, temp_buf, ((struct sk_buff *)message_list)) {
1018 list_del((struct list_head *)buf);
Allan Stephens5f6d9122011-11-04 13:24:29 -04001019 kfree_skb(buf);
Allan Stephens9aa88c22011-05-31 13:38:02 -04001020 }
1021}
1022
1023/*
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001024 * link_send_buf_fast: Entry for data messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001025 * destination link is known and the header is complete,
1026 * inclusive total message length. Very time critical.
1027 * Link is locked. Returns user data length.
1028 */
1029
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001030static int link_send_buf_fast(struct tipc_link *l_ptr, struct sk_buff *buf,
Sam Ravnborg05790c62006-03-20 22:37:04 -08001031 u32 *used_max_pkt)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001032{
1033 struct tipc_msg *msg = buf_msg(buf);
1034 int res = msg_data_sz(msg);
1035
1036 if (likely(!link_congested(l_ptr))) {
Allan Stephens15e979d2010-05-11 14:30:10 +00001037 if (likely(msg_size(msg) <= l_ptr->max_pkt)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001038 if (likely(list_empty(&l_ptr->b_ptr->cong_links))) {
1039 link_add_to_outqueue(l_ptr, buf, msg);
Per Liden4323add2006-01-18 00:38:21 +01001040 if (likely(tipc_bearer_send(l_ptr->b_ptr, buf,
1041 &l_ptr->media_addr))) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001042 l_ptr->unacked_window = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001043 return res;
1044 }
Per Liden4323add2006-01-18 00:38:21 +01001045 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001046 l_ptr->stats.bearer_congs++;
1047 l_ptr->next_out = buf;
1048 return res;
1049 }
Allan Stephens0e659672010-12-31 18:59:32 +00001050 } else
Allan Stephens15e979d2010-05-11 14:30:10 +00001051 *used_max_pkt = l_ptr->max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001052 }
Per Liden4323add2006-01-18 00:38:21 +01001053 return tipc_link_send_buf(l_ptr, buf); /* All other cases */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001054}
1055
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001056/*
1057 * tipc_send_buf_fast: Entry for data messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001058 * destination node is known and the header is complete,
1059 * inclusive total message length.
1060 * Returns user data length.
1061 */
1062int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode)
1063{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001064 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07001065 struct tipc_node *n_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001066 int res;
1067 u32 selector = msg_origport(buf_msg(buf)) & 1;
1068 u32 dummy;
1069
Per Liden4323add2006-01-18 00:38:21 +01001070 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +00001071 n_ptr = tipc_node_find(destnode);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001072 if (likely(n_ptr)) {
Per Liden4323add2006-01-18 00:38:21 +01001073 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001074 l_ptr = n_ptr->active_links[selector];
Per Lidenb97bf3f2006-01-02 19:04:38 +01001075 if (likely(l_ptr)) {
1076 res = link_send_buf_fast(l_ptr, buf, &dummy);
Per Liden4323add2006-01-18 00:38:21 +01001077 tipc_node_unlock(n_ptr);
1078 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001079 return res;
1080 }
Per Liden4323add2006-01-18 00:38:21 +01001081 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001082 }
Per Liden4323add2006-01-18 00:38:21 +01001083 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001084 res = msg_data_sz(buf_msg(buf));
1085 tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
1086 return res;
1087}
1088
1089
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001090/*
1091 * tipc_link_send_sections_fast: Entry for messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001092 * destination processor is known and the header is complete,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001093 * except for total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001094 * Returns user data length or errno.
1095 */
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001096int tipc_link_send_sections_fast(struct tipc_port *sender,
Per Liden4323add2006-01-18 00:38:21 +01001097 struct iovec const *msg_sect,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001098 const u32 num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001099 unsigned int total_len,
Per Liden4323add2006-01-18 00:38:21 +01001100 u32 destaddr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001101{
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001102 struct tipc_msg *hdr = &sender->phdr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001103 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001104 struct sk_buff *buf;
David S. Miller6c000552008-09-02 23:38:32 -07001105 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001106 int res;
1107 u32 selector = msg_origport(hdr) & 1;
1108
Per Lidenb97bf3f2006-01-02 19:04:38 +01001109again:
1110 /*
1111 * Try building message using port's max_pkt hint.
1112 * (Must not hold any locks while building message.)
1113 */
1114
Allan Stephens26896902011-04-21 10:42:07 -05001115 res = tipc_msg_build(hdr, msg_sect, num_sect, total_len,
1116 sender->max_pkt, !sender->user_port, &buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001117
Per Liden4323add2006-01-18 00:38:21 +01001118 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +00001119 node = tipc_node_find(destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001120 if (likely(node)) {
Per Liden4323add2006-01-18 00:38:21 +01001121 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001122 l_ptr = node->active_links[selector];
1123 if (likely(l_ptr)) {
1124 if (likely(buf)) {
1125 res = link_send_buf_fast(l_ptr, buf,
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001126 &sender->max_pkt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001127exit:
Per Liden4323add2006-01-18 00:38:21 +01001128 tipc_node_unlock(node);
1129 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001130 return res;
1131 }
1132
1133 /* Exit if build request was invalid */
1134
1135 if (unlikely(res < 0))
1136 goto exit;
1137
1138 /* Exit if link (or bearer) is congested */
1139
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001140 if (link_congested(l_ptr) ||
Per Lidenb97bf3f2006-01-02 19:04:38 +01001141 !list_empty(&l_ptr->b_ptr->cong_links)) {
1142 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 */
1151
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001152 sender->max_pkt = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01001153 tipc_node_unlock(node);
1154 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001155
1156
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001157 if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001158 goto again;
1159
1160 return link_send_sections_long(sender, msg_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001161 num_sect, total_len,
1162 destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001163 }
Per Liden4323add2006-01-18 00:38:21 +01001164 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001165 }
Per Liden4323add2006-01-18 00:38:21 +01001166 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001167
1168 /* Couldn't find a link to the destination node */
1169
1170 if (buf)
1171 return tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
1172 if (res >= 0)
Per Liden4323add2006-01-18 00:38:21 +01001173 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001174 total_len, TIPC_ERR_NO_NODE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001175 return res;
1176}
1177
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001178/*
1179 * link_send_sections_long(): Entry for long messages where the
Per Lidenb97bf3f2006-01-02 19:04:38 +01001180 * destination node is known and the header is complete,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001181 * inclusive total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001182 * Link and bearer congestion status have been checked to be ok,
1183 * and are ignored if they change.
1184 *
1185 * Note that fragments do not use the full link MTU so that they won't have
1186 * to undergo refragmentation if link changeover causes them to be sent
1187 * over another link with an additional tunnel header added as prefix.
1188 * (Refragmentation will still occur if the other link has a smaller MTU.)
1189 *
1190 * Returns user data length or errno.
1191 */
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001192static int link_send_sections_long(struct tipc_port *sender,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001193 struct iovec const *msg_sect,
1194 u32 num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001195 unsigned int total_len,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001196 u32 destaddr)
1197{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001198 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07001199 struct tipc_node *node;
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001200 struct tipc_msg *hdr = &sender->phdr;
Allan Stephens26896902011-04-21 10:42:07 -05001201 u32 dsz = total_len;
Allan Stephens0e659672010-12-31 18:59:32 +00001202 u32 max_pkt, fragm_sz, rest;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001203 struct tipc_msg fragm_hdr;
Allan Stephens0e659672010-12-31 18:59:32 +00001204 struct sk_buff *buf, *buf_chain, *prev;
1205 u32 fragm_crs, fragm_rest, hsz, sect_rest;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001206 const unchar *sect_crs;
1207 int curr_sect;
1208 u32 fragm_no;
1209
1210again:
1211 fragm_no = 1;
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001212 max_pkt = sender->max_pkt - INT_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001213 /* leave room for tunnel header in case of link changeover */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001214 fragm_sz = max_pkt - INT_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001215 /* leave room for fragmentation header in each fragment */
1216 rest = dsz;
1217 fragm_crs = 0;
1218 fragm_rest = 0;
1219 sect_rest = 0;
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08001220 sect_crs = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001221 curr_sect = -1;
1222
1223 /* Prepare reusable fragment header: */
1224
Allan Stephensc68ca7b2010-05-11 14:30:12 +00001225 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
Allan Stephens75715212008-06-04 17:37:34 -07001226 INT_H_SIZE, msg_destnode(hdr));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001227 msg_set_size(&fragm_hdr, max_pkt);
1228 msg_set_fragm_no(&fragm_hdr, 1);
1229
1230 /* Prepare header of first fragment: */
1231
stephen hemminger31e3c3f2010-10-13 13:20:35 +00001232 buf_chain = buf = tipc_buf_acquire(max_pkt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001233 if (!buf)
1234 return -ENOMEM;
1235 buf->next = NULL;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001236 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001237 hsz = msg_hdr_sz(hdr);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001238 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, hdr, hsz);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001239
1240 /* Chop up message: */
1241
1242 fragm_crs = INT_H_SIZE + hsz;
1243 fragm_rest = fragm_sz - hsz;
1244
1245 do { /* For all sections */
1246 u32 sz;
1247
1248 if (!sect_rest) {
1249 sect_rest = msg_sect[++curr_sect].iov_len;
1250 sect_crs = (const unchar *)msg_sect[curr_sect].iov_base;
1251 }
1252
1253 if (sect_rest < fragm_rest)
1254 sz = sect_rest;
1255 else
1256 sz = fragm_rest;
1257
1258 if (likely(!sender->user_port)) {
1259 if (copy_from_user(buf->data + fragm_crs, sect_crs, sz)) {
1260error:
1261 for (; buf_chain; buf_chain = buf) {
1262 buf = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001263 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001264 }
1265 return -EFAULT;
1266 }
1267 } else
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001268 skb_copy_to_linear_data_offset(buf, fragm_crs,
1269 sect_crs, sz);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001270 sect_crs += sz;
1271 sect_rest -= sz;
1272 fragm_crs += sz;
1273 fragm_rest -= sz;
1274 rest -= sz;
1275
1276 if (!fragm_rest && rest) {
1277
1278 /* Initiate new fragment: */
1279 if (rest <= fragm_sz) {
1280 fragm_sz = rest;
Allan Stephens0e659672010-12-31 18:59:32 +00001281 msg_set_type(&fragm_hdr, LAST_FRAGMENT);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001282 } else {
1283 msg_set_type(&fragm_hdr, FRAGMENT);
1284 }
1285 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
1286 msg_set_fragm_no(&fragm_hdr, ++fragm_no);
1287 prev = buf;
stephen hemminger31e3c3f2010-10-13 13:20:35 +00001288 buf = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001289 if (!buf)
1290 goto error;
1291
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001292 buf->next = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001293 prev->next = buf;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001294 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001295 fragm_crs = INT_H_SIZE;
1296 fragm_rest = fragm_sz;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001297 }
Allan Stephens0e659672010-12-31 18:59:32 +00001298 } while (rest > 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001299
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001300 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001301 * Now we have a buffer chain. Select a link and check
1302 * that packet size is still OK
1303 */
Allan Stephens51a8e4d2010-12-31 18:59:18 +00001304 node = tipc_node_find(destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001305 if (likely(node)) {
Per Liden4323add2006-01-18 00:38:21 +01001306 tipc_node_lock(node);
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001307 l_ptr = node->active_links[sender->ref & 1];
Per Lidenb97bf3f2006-01-02 19:04:38 +01001308 if (!l_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01001309 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001310 goto reject;
1311 }
Allan Stephens15e979d2010-05-11 14:30:10 +00001312 if (l_ptr->max_pkt < max_pkt) {
Allan Stephens23dd4cc2011-01-07 11:43:40 -05001313 sender->max_pkt = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01001314 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001315 for (; buf_chain; buf_chain = buf) {
1316 buf = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001317 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001318 }
1319 goto again;
1320 }
1321 } else {
1322reject:
1323 for (; buf_chain; buf_chain = buf) {
1324 buf = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001325 kfree_skb(buf_chain);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001326 }
Per Liden4323add2006-01-18 00:38:21 +01001327 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
Allan Stephens26896902011-04-21 10:42:07 -05001328 total_len, TIPC_ERR_NO_NODE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001329 }
1330
Allan Stephensdc63d912011-04-21 11:50:42 -04001331 /* Append chain of fragments to send queue & send them */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001332
Allan Stephense0f08592011-04-17 11:44:24 -04001333 l_ptr->long_msg_seq_no++;
Allan Stephensdc63d912011-04-21 11:50:42 -04001334 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
1335 l_ptr->stats.sent_fragments += fragm_no;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001336 l_ptr->stats.sent_fragmented++;
Per Liden4323add2006-01-18 00:38:21 +01001337 tipc_link_push_queue(l_ptr);
1338 tipc_node_unlock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001339 return dsz;
1340}
1341
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001342/*
Per Liden4323add2006-01-18 00:38:21 +01001343 * tipc_link_push_packet: Push one unsent packet to the media
Per Lidenb97bf3f2006-01-02 19:04:38 +01001344 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001345u32 tipc_link_push_packet(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001346{
1347 struct sk_buff *buf = l_ptr->first_out;
1348 u32 r_q_size = l_ptr->retransm_queue_size;
1349 u32 r_q_head = l_ptr->retransm_queue_head;
1350
1351 /* Step to position where retransmission failed, if any, */
1352 /* consider that buffers may have been released in meantime */
1353
1354 if (r_q_size && buf) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001355 u32 last = lesser(mod(r_q_head + r_q_size),
Per Lidenb97bf3f2006-01-02 19:04:38 +01001356 link_last_sent(l_ptr));
Allan Stephensf9057302011-10-24 16:03:12 -04001357 u32 first = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001358
1359 while (buf && less(first, r_q_head)) {
1360 first = mod(first + 1);
1361 buf = buf->next;
1362 }
1363 l_ptr->retransm_queue_head = r_q_head = first;
1364 l_ptr->retransm_queue_size = r_q_size = mod(last - first);
1365 }
1366
1367 /* Continue retransmission now, if there is anything: */
1368
Neil Hormanca509102010-03-15 07:58:45 +00001369 if (r_q_size && buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001370 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001371 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
Per Liden4323add2006-01-18 00:38:21 +01001372 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001373 l_ptr->retransm_queue_head = mod(++r_q_head);
1374 l_ptr->retransm_queue_size = --r_q_size;
1375 l_ptr->stats.retransmitted++;
Allan Stephens0e35fd52008-07-14 22:44:01 -07001376 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001377 } else {
1378 l_ptr->stats.bearer_congs++;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001379 return PUSH_FAILED;
1380 }
1381 }
1382
1383 /* Send deferred protocol message, if any: */
1384
1385 buf = l_ptr->proto_msg_queue;
1386 if (buf) {
1387 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
Allan Stephens0e659672010-12-31 18:59:32 +00001388 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
Per Liden4323add2006-01-18 00:38:21 +01001389 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001390 l_ptr->unacked_window = 0;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001391 kfree_skb(buf);
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08001392 l_ptr->proto_msg_queue = NULL;
Allan Stephens0e35fd52008-07-14 22:44:01 -07001393 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001394 } else {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001395 l_ptr->stats.bearer_congs++;
1396 return PUSH_FAILED;
1397 }
1398 }
1399
1400 /* Send one deferred data message, if send window not full: */
1401
1402 buf = l_ptr->next_out;
1403 if (buf) {
1404 struct tipc_msg *msg = buf_msg(buf);
1405 u32 next = msg_seqno(msg);
Allan Stephensf9057302011-10-24 16:03:12 -04001406 u32 first = buf_seqno(l_ptr->first_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001407
1408 if (mod(next - first) < l_ptr->queue_limit[0]) {
1409 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001410 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Per Liden4323add2006-01-18 00:38:21 +01001411 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001412 if (msg_user(msg) == MSG_BUNDLER)
1413 msg_set_type(msg, CLOSED_MSG);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001414 l_ptr->next_out = buf->next;
Allan Stephens0e35fd52008-07-14 22:44:01 -07001415 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001416 } else {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001417 l_ptr->stats.bearer_congs++;
1418 return PUSH_FAILED;
1419 }
1420 }
1421 }
1422 return PUSH_FINISHED;
1423}
1424
1425/*
1426 * push_queue(): push out the unsent messages of a link where
1427 * congestion has abated. Node is locked
1428 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001429void tipc_link_push_queue(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001430{
1431 u32 res;
1432
Per Liden4323add2006-01-18 00:38:21 +01001433 if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001434 return;
1435
1436 do {
Per Liden4323add2006-01-18 00:38:21 +01001437 res = tipc_link_push_packet(l_ptr);
Allan Stephens0e35fd52008-07-14 22:44:01 -07001438 } while (!res);
1439
Per Lidenb97bf3f2006-01-02 19:04:38 +01001440 if (res == PUSH_FAILED)
Per Liden4323add2006-01-18 00:38:21 +01001441 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001442}
1443
Allan Stephensd356eeb2006-06-25 23:40:01 -07001444static void link_reset_all(unsigned long addr)
1445{
David S. Miller6c000552008-09-02 23:38:32 -07001446 struct tipc_node *n_ptr;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001447 char addr_string[16];
1448 u32 i;
1449
1450 read_lock_bh(&tipc_net_lock);
1451 n_ptr = tipc_node_find((u32)addr);
1452 if (!n_ptr) {
1453 read_unlock_bh(&tipc_net_lock);
1454 return; /* node no longer exists */
1455 }
1456
1457 tipc_node_lock(n_ptr);
1458
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001459 warn("Resetting all links to %s\n",
Allan Stephensc68ca7b2010-05-11 14:30:12 +00001460 tipc_addr_string_fill(addr_string, n_ptr->addr));
Allan Stephensd356eeb2006-06-25 23:40:01 -07001461
1462 for (i = 0; i < MAX_BEARERS; i++) {
1463 if (n_ptr->links[i]) {
Allan Stephens8d64a5b2010-12-31 18:59:27 +00001464 link_print(n_ptr->links[i], "Resetting link\n");
Allan Stephensd356eeb2006-06-25 23:40:01 -07001465 tipc_link_reset(n_ptr->links[i]);
1466 }
1467 }
1468
1469 tipc_node_unlock(n_ptr);
1470 read_unlock_bh(&tipc_net_lock);
1471}
1472
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001473static void link_retransmit_failure(struct tipc_link *l_ptr,
1474 struct sk_buff *buf)
Allan Stephensd356eeb2006-06-25 23:40:01 -07001475{
1476 struct tipc_msg *msg = buf_msg(buf);
1477
1478 warn("Retransmission failure on link <%s>\n", l_ptr->name);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001479
1480 if (l_ptr->addr) {
1481
1482 /* Handle failure on standard link */
1483
Allan Stephens8d64a5b2010-12-31 18:59:27 +00001484 link_print(l_ptr, "Resetting link\n");
Allan Stephensd356eeb2006-06-25 23:40:01 -07001485 tipc_link_reset(l_ptr);
1486
1487 } else {
1488
1489 /* Handle failure on broadcast link */
1490
David S. Miller6c000552008-09-02 23:38:32 -07001491 struct tipc_node *n_ptr;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001492 char addr_string[16];
1493
Allan Stephens8d64a5b2010-12-31 18:59:27 +00001494 info("Msg seq number: %u, ", msg_seqno(msg));
1495 info("Outstanding acks: %lu\n",
1496 (unsigned long) TIPC_SKB_CB(buf)->handle);
Jeff Garzik617dbea2006-10-03 16:25:34 -07001497
Allan Stephens01d83ed2011-01-18 13:53:16 -05001498 n_ptr = tipc_bclink_retransmit_to();
Allan Stephensd356eeb2006-06-25 23:40:01 -07001499 tipc_node_lock(n_ptr);
1500
Allan Stephensc68ca7b2010-05-11 14:30:12 +00001501 tipc_addr_string_fill(addr_string, n_ptr->addr);
Allan Stephens7a54d4a2011-10-27 14:17:53 -04001502 info("Broadcast link info for %s\n", addr_string);
Allan Stephens93499312011-10-25 15:14:46 -04001503 info("Supportable: %d, ", n_ptr->bclink.supportable);
Allan Stephens8d64a5b2010-12-31 18:59:27 +00001504 info("Supported: %d, ", n_ptr->bclink.supported);
1505 info("Acked: %u\n", n_ptr->bclink.acked);
1506 info("Last in: %u, ", n_ptr->bclink.last_in);
Allan Stephens7a54d4a2011-10-27 14:17:53 -04001507 info("Oos state: %u, ", n_ptr->bclink.oos_state);
1508 info("Last sent: %u\n", n_ptr->bclink.last_sent);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001509
1510 tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr);
1511
1512 tipc_node_unlock(n_ptr);
1513
1514 l_ptr->stale_count = 0;
1515 }
1516}
1517
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001518void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf,
Per Liden4323add2006-01-18 00:38:21 +01001519 u32 retransmits)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001520{
1521 struct tipc_msg *msg;
1522
Allan Stephensd356eeb2006-06-25 23:40:01 -07001523 if (!buf)
1524 return;
1525
1526 msg = buf_msg(buf);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001527
Allan Stephensd356eeb2006-06-25 23:40:01 -07001528 if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
Neil Hormanca509102010-03-15 07:58:45 +00001529 if (l_ptr->retransm_queue_size == 0) {
Allan Stephensd356eeb2006-06-25 23:40:01 -07001530 l_ptr->retransm_queue_head = msg_seqno(msg);
1531 l_ptr->retransm_queue_size = retransmits;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001532 } else {
Neil Hormanca509102010-03-15 07:58:45 +00001533 err("Unexpected retransmit on link %s (qsize=%d)\n",
1534 l_ptr->name, l_ptr->retransm_queue_size);
Allan Stephensd356eeb2006-06-25 23:40:01 -07001535 }
Neil Hormanca509102010-03-15 07:58:45 +00001536 return;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001537 } else {
1538 /* Detect repeated retransmit failures on uncongested bearer */
1539
1540 if (l_ptr->last_retransmitted == msg_seqno(msg)) {
1541 if (++l_ptr->stale_count > 100) {
1542 link_retransmit_failure(l_ptr, buf);
1543 return;
1544 }
1545 } else {
1546 l_ptr->last_retransmitted = msg_seqno(msg);
1547 l_ptr->stale_count = 1;
1548 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001549 }
Allan Stephensd356eeb2006-06-25 23:40:01 -07001550
Neil Hormanca509102010-03-15 07:58:45 +00001551 while (retransmits && (buf != l_ptr->next_out) && buf) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001552 msg = buf_msg(buf);
1553 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001554 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Per Liden4323add2006-01-18 00:38:21 +01001555 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001556 buf = buf->next;
1557 retransmits--;
1558 l_ptr->stats.retransmitted++;
1559 } else {
Per Liden4323add2006-01-18 00:38:21 +01001560 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001561 l_ptr->stats.bearer_congs++;
Allan Stephensf9057302011-10-24 16:03:12 -04001562 l_ptr->retransm_queue_head = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001563 l_ptr->retransm_queue_size = retransmits;
1564 return;
1565 }
1566 }
Allan Stephensd356eeb2006-06-25 23:40:01 -07001567
Per Lidenb97bf3f2006-01-02 19:04:38 +01001568 l_ptr->retransm_queue_head = l_ptr->retransm_queue_size = 0;
1569}
1570
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001571/**
Per Lidenb97bf3f2006-01-02 19:04:38 +01001572 * link_insert_deferred_queue - insert deferred messages back into receive chain
1573 */
1574
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001575static struct sk_buff *link_insert_deferred_queue(struct tipc_link *l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001576 struct sk_buff *buf)
1577{
1578 u32 seq_no;
1579
1580 if (l_ptr->oldest_deferred_in == NULL)
1581 return buf;
1582
Allan Stephensf9057302011-10-24 16:03:12 -04001583 seq_no = buf_seqno(l_ptr->oldest_deferred_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001584 if (seq_no == mod(l_ptr->next_in_no)) {
1585 l_ptr->newest_deferred_in->next = buf;
1586 buf = l_ptr->oldest_deferred_in;
1587 l_ptr->oldest_deferred_in = NULL;
1588 l_ptr->deferred_inqueue_sz = 0;
1589 }
1590 return buf;
1591}
1592
Allan Stephens85035562008-04-15 19:04:54 -07001593/**
1594 * link_recv_buf_validate - validate basic format of received message
1595 *
1596 * This routine ensures a TIPC message has an acceptable header, and at least
1597 * as much data as the header indicates it should. The routine also ensures
1598 * that the entire message header is stored in the main fragment of the message
1599 * buffer, to simplify future access to message header fields.
1600 *
1601 * Note: Having extra info present in the message header or data areas is OK.
1602 * TIPC will ignore the excess, under the assumption that it is optional info
1603 * introduced by a later release of the protocol.
1604 */
1605
1606static int link_recv_buf_validate(struct sk_buff *buf)
1607{
1608 static u32 min_data_hdr_size[8] = {
Allan Stephens741d9eb2011-05-31 15:03:18 -04001609 SHORT_H_SIZE, MCAST_H_SIZE, NAMED_H_SIZE, BASIC_H_SIZE,
Allan Stephens85035562008-04-15 19:04:54 -07001610 MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE
1611 };
1612
1613 struct tipc_msg *msg;
1614 u32 tipc_hdr[2];
1615 u32 size;
1616 u32 hdr_size;
1617 u32 min_hdr_size;
1618
1619 if (unlikely(buf->len < MIN_H_SIZE))
1620 return 0;
1621
1622 msg = skb_header_pointer(buf, 0, sizeof(tipc_hdr), tipc_hdr);
1623 if (msg == NULL)
1624 return 0;
1625
1626 if (unlikely(msg_version(msg) != TIPC_VERSION))
1627 return 0;
1628
1629 size = msg_size(msg);
1630 hdr_size = msg_hdr_sz(msg);
1631 min_hdr_size = msg_isdata(msg) ?
1632 min_data_hdr_size[msg_type(msg)] : INT_H_SIZE;
1633
1634 if (unlikely((hdr_size < min_hdr_size) ||
1635 (size < hdr_size) ||
1636 (buf->len < size) ||
1637 (size - hdr_size > TIPC_MAX_USER_MSG_SIZE)))
1638 return 0;
1639
1640 return pskb_may_pull(buf, hdr_size);
1641}
1642
Allan Stephensb02b69c2010-08-17 11:00:07 +00001643/**
1644 * tipc_recv_msg - process TIPC messages arriving from off-node
1645 * @head: pointer to message buffer chain
1646 * @tb_ptr: pointer to bearer message arrived on
1647 *
1648 * Invoked with no locks held. Bearer pointer must point to a valid bearer
1649 * structure (i.e. cannot be NULL), but bearer can be inactive.
1650 */
1651
Allan Stephens2d627b92011-01-07 13:00:11 -05001652void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *b_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001653{
Per Liden4323add2006-01-18 00:38:21 +01001654 read_lock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001655 while (head) {
David S. Miller6c000552008-09-02 23:38:32 -07001656 struct tipc_node *n_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001657 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001658 struct sk_buff *crs;
1659 struct sk_buff *buf = head;
Allan Stephens85035562008-04-15 19:04:54 -07001660 struct tipc_msg *msg;
1661 u32 seq_no;
1662 u32 ackd;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001663 u32 released = 0;
1664 int type;
1665
Per Lidenb97bf3f2006-01-02 19:04:38 +01001666 head = head->next;
Allan Stephens85035562008-04-15 19:04:54 -07001667
Allan Stephensb02b69c2010-08-17 11:00:07 +00001668 /* Ensure bearer is still enabled */
1669
1670 if (unlikely(!b_ptr->active))
1671 goto cont;
1672
Allan Stephens85035562008-04-15 19:04:54 -07001673 /* Ensure message is well-formed */
1674
1675 if (unlikely(!link_recv_buf_validate(buf)))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001676 goto cont;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001677
Allan Stephensfe13dda2008-04-15 19:03:23 -07001678 /* Ensure message data is a single contiguous unit */
1679
Allan Stephens5f6d9122011-11-04 13:24:29 -04001680 if (unlikely(skb_linearize(buf)))
Allan Stephensfe13dda2008-04-15 19:03:23 -07001681 goto cont;
Allan Stephensfe13dda2008-04-15 19:03:23 -07001682
Allan Stephens85035562008-04-15 19:04:54 -07001683 /* Handle arrival of a non-unicast link message */
1684
1685 msg = buf_msg(buf);
1686
Per Lidenb97bf3f2006-01-02 19:04:38 +01001687 if (unlikely(msg_non_seq(msg))) {
Allan Stephens1265a022008-06-04 17:32:35 -07001688 if (msg_user(msg) == LINK_CONFIG)
1689 tipc_disc_recv_msg(buf, b_ptr);
1690 else
1691 tipc_bclink_recv_pkt(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001692 continue;
1693 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001694
Allan Stephensed33a9c2011-04-05 15:15:04 -04001695 /* Discard unicast link messages destined for another node */
1696
Allan Stephens26008242006-06-25 23:39:31 -07001697 if (unlikely(!msg_short(msg) &&
1698 (msg_destnode(msg) != tipc_own_addr)))
1699 goto cont;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001700
Allan Stephens5a68d5e2010-08-17 11:00:16 +00001701 /* Locate neighboring node that sent message */
Allan Stephens85035562008-04-15 19:04:54 -07001702
Per Liden4323add2006-01-18 00:38:21 +01001703 n_ptr = tipc_node_find(msg_prevnode(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001704 if (unlikely(!n_ptr))
1705 goto cont;
Per Liden4323add2006-01-18 00:38:21 +01001706 tipc_node_lock(n_ptr);
Allan Stephens85035562008-04-15 19:04:54 -07001707
Allan Stephens5a68d5e2010-08-17 11:00:16 +00001708 /* Locate unicast link endpoint that should handle message */
1709
Per Lidenb97bf3f2006-01-02 19:04:38 +01001710 l_ptr = n_ptr->links[b_ptr->identity];
1711 if (unlikely(!l_ptr)) {
Per Liden4323add2006-01-18 00:38:21 +01001712 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001713 goto cont;
1714 }
Allan Stephens85035562008-04-15 19:04:54 -07001715
Allan Stephensb4b56102011-05-27 11:00:51 -04001716 /* Verify that communication with node is currently allowed */
1717
1718 if ((n_ptr->block_setup & WAIT_PEER_DOWN) &&
1719 msg_user(msg) == LINK_PROTOCOL &&
1720 (msg_type(msg) == RESET_MSG ||
1721 msg_type(msg) == ACTIVATE_MSG) &&
1722 !msg_redundant_link(msg))
1723 n_ptr->block_setup &= ~WAIT_PEER_DOWN;
1724
1725 if (n_ptr->block_setup) {
1726 tipc_node_unlock(n_ptr);
1727 goto cont;
1728 }
1729
Allan Stephens85035562008-04-15 19:04:54 -07001730 /* Validate message sequence number info */
1731
1732 seq_no = msg_seqno(msg);
1733 ackd = msg_ack(msg);
1734
1735 /* Release acked messages */
1736
Allan Stephens93499312011-10-25 15:14:46 -04001737 if (n_ptr->bclink.supported)
Allan Stephens365595912011-10-24 15:26:24 -04001738 tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001739
1740 crs = l_ptr->first_out;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001741 while ((crs != l_ptr->next_out) &&
Allan Stephensf9057302011-10-24 16:03:12 -04001742 less_eq(buf_seqno(crs), ackd)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001743 struct sk_buff *next = crs->next;
1744
Allan Stephens5f6d9122011-11-04 13:24:29 -04001745 kfree_skb(crs);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001746 crs = next;
1747 released++;
1748 }
1749 if (released) {
1750 l_ptr->first_out = crs;
1751 l_ptr->out_queue_size -= released;
1752 }
Allan Stephens85035562008-04-15 19:04:54 -07001753
1754 /* Try sending any messages link endpoint has pending */
1755
Per Lidenb97bf3f2006-01-02 19:04:38 +01001756 if (unlikely(l_ptr->next_out))
Per Liden4323add2006-01-18 00:38:21 +01001757 tipc_link_push_queue(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001758 if (unlikely(!list_empty(&l_ptr->waiting_ports)))
Per Liden4323add2006-01-18 00:38:21 +01001759 tipc_link_wakeup_ports(l_ptr, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001760 if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
1761 l_ptr->stats.sent_acks++;
Per Liden4323add2006-01-18 00:38:21 +01001762 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001763 }
1764
Allan Stephens85035562008-04-15 19:04:54 -07001765 /* Now (finally!) process the incoming message */
1766
Per Lidenb97bf3f2006-01-02 19:04:38 +01001767protocol_check:
1768 if (likely(link_working_working(l_ptr))) {
1769 if (likely(seq_no == mod(l_ptr->next_in_no))) {
1770 l_ptr->next_in_no++;
1771 if (unlikely(l_ptr->oldest_deferred_in))
1772 head = link_insert_deferred_queue(l_ptr,
1773 head);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001774deliver:
Allan Stephensc74a4612011-11-02 15:08:44 -04001775 if (likely(msg_isdata(msg))) {
1776 tipc_node_unlock(n_ptr);
1777 tipc_port_recv_msg(buf);
1778 continue;
1779 }
1780 switch (msg_user(msg)) {
1781 int ret;
1782 case MSG_BUNDLER:
1783 l_ptr->stats.recv_bundles++;
1784 l_ptr->stats.recv_bundled +=
1785 msg_msgcnt(msg);
1786 tipc_node_unlock(n_ptr);
1787 tipc_link_recv_bundle(buf);
1788 continue;
1789 case NAME_DISTRIBUTOR:
1790 tipc_node_unlock(n_ptr);
1791 tipc_named_recv(buf);
1792 continue;
1793 case CONN_MANAGER:
1794 tipc_node_unlock(n_ptr);
1795 tipc_port_recv_proto_msg(buf);
1796 continue;
1797 case MSG_FRAGMENTER:
1798 l_ptr->stats.recv_fragments++;
1799 ret = tipc_link_recv_fragment(
1800 &l_ptr->defragm_buf,
1801 &buf, &msg);
1802 if (ret == 1) {
1803 l_ptr->stats.recv_fragmented++;
1804 goto deliver;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001805 }
Allan Stephensc74a4612011-11-02 15:08:44 -04001806 if (ret == -1)
1807 l_ptr->next_in_no--;
1808 break;
1809 case CHANGEOVER_PROTOCOL:
1810 type = msg_type(msg);
1811 if (link_recv_changeover_msg(&l_ptr,
1812 &buf)) {
1813 msg = buf_msg(buf);
1814 seq_no = msg_seqno(msg);
1815 if (type == ORIGINAL_MSG)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001816 goto deliver;
Allan Stephensc74a4612011-11-02 15:08:44 -04001817 goto protocol_check;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001818 }
Allan Stephensc74a4612011-11-02 15:08:44 -04001819 break;
1820 default:
Allan Stephens5f6d9122011-11-04 13:24:29 -04001821 kfree_skb(buf);
Allan Stephensc74a4612011-11-02 15:08:44 -04001822 buf = NULL;
1823 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001824 }
Per Liden4323add2006-01-18 00:38:21 +01001825 tipc_node_unlock(n_ptr);
1826 tipc_net_route_msg(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001827 continue;
1828 }
1829 link_handle_out_of_seq_msg(l_ptr, buf);
1830 head = link_insert_deferred_queue(l_ptr, head);
Per Liden4323add2006-01-18 00:38:21 +01001831 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001832 continue;
1833 }
1834
1835 if (msg_user(msg) == LINK_PROTOCOL) {
1836 link_recv_proto_msg(l_ptr, buf);
1837 head = link_insert_deferred_queue(l_ptr, head);
Per Liden4323add2006-01-18 00:38:21 +01001838 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001839 continue;
1840 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001841 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
1842
1843 if (link_working_working(l_ptr)) {
1844 /* Re-insert in front of queue */
Per Lidenb97bf3f2006-01-02 19:04:38 +01001845 buf->next = head;
1846 head = buf;
Per Liden4323add2006-01-18 00:38:21 +01001847 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001848 continue;
1849 }
Per Liden4323add2006-01-18 00:38:21 +01001850 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001851cont:
Allan Stephens5f6d9122011-11-04 13:24:29 -04001852 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001853 }
Per Liden4323add2006-01-18 00:38:21 +01001854 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001855}
1856
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001857/*
Allan Stephens8809b252011-10-25 10:44:35 -04001858 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
1859 *
1860 * Returns increase in queue length (i.e. 0 or 1)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001861 */
1862
Allan Stephens8809b252011-10-25 10:44:35 -04001863u32 tipc_link_defer_pkt(struct sk_buff **head, struct sk_buff **tail,
Per Liden4323add2006-01-18 00:38:21 +01001864 struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001865{
Allan Stephens8809b252011-10-25 10:44:35 -04001866 struct sk_buff *queue_buf;
1867 struct sk_buff **prev;
Allan Stephensf9057302011-10-24 16:03:12 -04001868 u32 seq_no = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001869
1870 buf->next = NULL;
1871
1872 /* Empty queue ? */
1873 if (*head == NULL) {
1874 *head = *tail = buf;
1875 return 1;
1876 }
1877
1878 /* Last ? */
Allan Stephensf9057302011-10-24 16:03:12 -04001879 if (less(buf_seqno(*tail), seq_no)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001880 (*tail)->next = buf;
1881 *tail = buf;
1882 return 1;
1883 }
1884
Allan Stephens8809b252011-10-25 10:44:35 -04001885 /* Locate insertion point in queue, then insert; discard if duplicate */
1886 prev = head;
1887 queue_buf = *head;
1888 for (;;) {
1889 u32 curr_seqno = buf_seqno(queue_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001890
Allan Stephens8809b252011-10-25 10:44:35 -04001891 if (seq_no == curr_seqno) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04001892 kfree_skb(buf);
Allan Stephens8809b252011-10-25 10:44:35 -04001893 return 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001894 }
Allan Stephens8809b252011-10-25 10:44:35 -04001895
1896 if (less(seq_no, curr_seqno))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001897 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001898
Allan Stephens8809b252011-10-25 10:44:35 -04001899 prev = &queue_buf->next;
1900 queue_buf = queue_buf->next;
1901 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001902
Allan Stephens8809b252011-10-25 10:44:35 -04001903 buf->next = queue_buf;
1904 *prev = buf;
1905 return 1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001906}
1907
Allan Stephens8809b252011-10-25 10:44:35 -04001908/*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001909 * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
1910 */
1911
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001912static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01001913 struct sk_buff *buf)
1914{
Allan Stephensf9057302011-10-24 16:03:12 -04001915 u32 seq_no = buf_seqno(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001916
1917 if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) {
1918 link_recv_proto_msg(l_ptr, buf);
1919 return;
1920 }
1921
Per Lidenb97bf3f2006-01-02 19:04:38 +01001922 /* Record OOS packet arrival (force mismatch on next timeout) */
1923
1924 l_ptr->checkpoint--;
1925
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001926 /*
Per Lidenb97bf3f2006-01-02 19:04:38 +01001927 * Discard packet if a duplicate; otherwise add it to deferred queue
1928 * and notify peer of gap as per protocol specification
1929 */
1930
1931 if (less(seq_no, mod(l_ptr->next_in_no))) {
1932 l_ptr->stats.duplicates++;
Allan Stephens5f6d9122011-11-04 13:24:29 -04001933 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001934 return;
1935 }
1936
Per Liden4323add2006-01-18 00:38:21 +01001937 if (tipc_link_defer_pkt(&l_ptr->oldest_deferred_in,
1938 &l_ptr->newest_deferred_in, buf)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01001939 l_ptr->deferred_inqueue_sz++;
1940 l_ptr->stats.deferred_recv++;
1941 if ((l_ptr->deferred_inqueue_sz % 16) == 1)
Per Liden4323add2006-01-18 00:38:21 +01001942 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001943 } else
1944 l_ptr->stats.duplicates++;
1945}
1946
1947/*
1948 * Send protocol message to the other endpoint.
1949 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05001950void tipc_link_send_proto_msg(struct tipc_link *l_ptr, u32 msg_typ,
1951 int probe_msg, u32 gap, u32 tolerance,
1952 u32 priority, u32 ack_mtu)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001953{
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08001954 struct sk_buff *buf = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001955 struct tipc_msg *msg = l_ptr->pmsg;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09001956 u32 msg_size = sizeof(l_ptr->proto_msg);
Allan Stephens75f0aa42011-02-28 15:30:20 -05001957 int r_flag;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001958
Allan Stephens92d2c902011-10-25 11:20:26 -04001959 /* Discard any previous message that was deferred due to congestion */
1960
1961 if (l_ptr->proto_msg_queue) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04001962 kfree_skb(l_ptr->proto_msg_queue);
Allan Stephens92d2c902011-10-25 11:20:26 -04001963 l_ptr->proto_msg_queue = NULL;
1964 }
1965
Per Lidenb97bf3f2006-01-02 19:04:38 +01001966 if (link_blocked(l_ptr))
1967 return;
Allan Stephensb4b56102011-05-27 11:00:51 -04001968
1969 /* Abort non-RESET send if communication with node is prohibited */
1970
1971 if ((l_ptr->owner->block_setup) && (msg_typ != RESET_MSG))
1972 return;
1973
Allan Stephens92d2c902011-10-25 11:20:26 -04001974 /* Create protocol message with "out-of-sequence" sequence number */
1975
Per Lidenb97bf3f2006-01-02 19:04:38 +01001976 msg_set_type(msg, msg_typ);
1977 msg_set_net_plane(msg, l_ptr->b_ptr->net_plane);
Allan Stephens7a54d4a2011-10-27 14:17:53 -04001978 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Per Liden4323add2006-01-18 00:38:21 +01001979 msg_set_last_bcast(msg, tipc_bclink_get_last_sent());
Per Lidenb97bf3f2006-01-02 19:04:38 +01001980
1981 if (msg_typ == STATE_MSG) {
1982 u32 next_sent = mod(l_ptr->next_out_no);
1983
Per Liden4323add2006-01-18 00:38:21 +01001984 if (!tipc_link_is_up(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01001985 return;
1986 if (l_ptr->next_out)
Allan Stephensf9057302011-10-24 16:03:12 -04001987 next_sent = buf_seqno(l_ptr->next_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001988 msg_set_next_sent(msg, next_sent);
1989 if (l_ptr->oldest_deferred_in) {
Allan Stephensf9057302011-10-24 16:03:12 -04001990 u32 rec = buf_seqno(l_ptr->oldest_deferred_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001991 gap = mod(rec - mod(l_ptr->next_in_no));
1992 }
1993 msg_set_seq_gap(msg, gap);
1994 if (gap)
1995 l_ptr->stats.sent_nacks++;
1996 msg_set_link_tolerance(msg, tolerance);
1997 msg_set_linkprio(msg, priority);
1998 msg_set_max_pkt(msg, ack_mtu);
1999 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
2000 msg_set_probe(msg, probe_msg != 0);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002001 if (probe_msg) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002002 u32 mtu = l_ptr->max_pkt;
2003
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002004 if ((mtu < l_ptr->max_pkt_target) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +01002005 link_working_working(l_ptr) &&
2006 l_ptr->fsm_msg_cnt) {
2007 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002008 if (l_ptr->max_pkt_probes == 10) {
2009 l_ptr->max_pkt_target = (msg_size - 4);
2010 l_ptr->max_pkt_probes = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002011 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002012 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002013 l_ptr->max_pkt_probes++;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002014 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002015
2016 l_ptr->stats.sent_probes++;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002017 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002018 l_ptr->stats.sent_states++;
2019 } else { /* RESET_MSG or ACTIVATE_MSG */
2020 msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
2021 msg_set_seq_gap(msg, 0);
2022 msg_set_next_sent(msg, 1);
Allan Stephensf23d9bf2011-01-18 15:15:34 -05002023 msg_set_probe(msg, 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002024 msg_set_link_tolerance(msg, l_ptr->tolerance);
2025 msg_set_linkprio(msg, l_ptr->priority);
2026 msg_set_max_pkt(msg, l_ptr->max_pkt_target);
2027 }
2028
Allan Stephens75f0aa42011-02-28 15:30:20 -05002029 r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr));
2030 msg_set_redundant_link(msg, r_flag);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002031 msg_set_linkprio(msg, l_ptr->priority);
Allan Stephens92d2c902011-10-25 11:20:26 -04002032 msg_set_size(msg, msg_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002033
2034 msg_set_seqno(msg, mod(l_ptr->next_out_no + (0xffff/2)));
2035
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002036 buf = tipc_buf_acquire(msg_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002037 if (!buf)
2038 return;
2039
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002040 skb_copy_to_linear_data(buf, msg, sizeof(l_ptr->proto_msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002041
Allan Stephens92d2c902011-10-25 11:20:26 -04002042 /* Defer message if bearer is already congested */
2043
2044 if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
2045 l_ptr->proto_msg_queue = buf;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002046 return;
2047 }
2048
Allan Stephens92d2c902011-10-25 11:20:26 -04002049 /* Defer message if attempting to send results in bearer congestion */
2050
2051 if (!tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
2052 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
2053 l_ptr->proto_msg_queue = buf;
2054 l_ptr->stats.bearer_congs++;
2055 return;
2056 }
2057
2058 /* Discard message if it was sent successfully */
2059
2060 l_ptr->unacked_window = 0;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002061 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002062}
2063
2064/*
2065 * Receive protocol message :
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002066 * Note that network plane id propagates through the network, and may
2067 * change at any time. The node with lowest address rules
Per Lidenb97bf3f2006-01-02 19:04:38 +01002068 */
2069
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002070static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002071{
2072 u32 rec_gap = 0;
2073 u32 max_pkt_info;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002074 u32 max_pkt_ack;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002075 u32 msg_tol;
2076 struct tipc_msg *msg = buf_msg(buf);
2077
Per Lidenb97bf3f2006-01-02 19:04:38 +01002078 if (link_blocked(l_ptr))
2079 goto exit;
2080
2081 /* record unnumbered packet arrival (force mismatch on next timeout) */
2082
2083 l_ptr->checkpoint--;
2084
2085 if (l_ptr->b_ptr->net_plane != msg_net_plane(msg))
2086 if (tipc_own_addr > msg_prevnode(msg))
2087 l_ptr->b_ptr->net_plane = msg_net_plane(msg);
2088
2089 l_ptr->owner->permit_changeover = msg_redundant_link(msg);
2090
2091 switch (msg_type(msg)) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002092
Per Lidenb97bf3f2006-01-02 19:04:38 +01002093 case RESET_MSG:
Allan Stephensa686e682008-06-04 17:29:39 -07002094 if (!link_working_unknown(l_ptr) &&
2095 (l_ptr->peer_session != INVALID_SESSION)) {
Allan Stephens641c2182011-04-07 09:54:43 -04002096 if (less_eq(msg_session(msg), l_ptr->peer_session))
2097 break; /* duplicate or old reset: ignore */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002098 }
Allan Stephensb4b56102011-05-27 11:00:51 -04002099
2100 if (!msg_redundant_link(msg) && (link_working_working(l_ptr) ||
2101 link_working_unknown(l_ptr))) {
2102 /*
2103 * peer has lost contact -- don't allow peer's links
2104 * to reactivate before we recognize loss & clean up
2105 */
2106 l_ptr->owner->block_setup = WAIT_NODE_DOWN;
2107 }
2108
Allan Stephens47361c82011-10-26 10:55:16 -04002109 link_state_event(l_ptr, RESET_MSG);
2110
Per Lidenb97bf3f2006-01-02 19:04:38 +01002111 /* fall thru' */
2112 case ACTIVATE_MSG:
2113 /* Update link settings according other endpoint's values */
2114
2115 strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg));
2116
Allan Stephens2db99832010-12-31 18:59:33 +00002117 msg_tol = msg_link_tolerance(msg);
2118 if (msg_tol > l_ptr->tolerance)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002119 link_set_supervision_props(l_ptr, msg_tol);
2120
2121 if (msg_linkprio(msg) > l_ptr->priority)
2122 l_ptr->priority = msg_linkprio(msg);
2123
2124 max_pkt_info = msg_max_pkt(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002125 if (max_pkt_info) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002126 if (max_pkt_info < l_ptr->max_pkt_target)
2127 l_ptr->max_pkt_target = max_pkt_info;
2128 if (l_ptr->max_pkt > l_ptr->max_pkt_target)
2129 l_ptr->max_pkt = l_ptr->max_pkt_target;
2130 } else {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002131 l_ptr->max_pkt = l_ptr->max_pkt_target;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002132 }
Allan Stephens93499312011-10-25 15:14:46 -04002133 l_ptr->owner->bclink.supportable = (max_pkt_info != 0);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002134
Allan Stephens4d753132011-10-25 12:19:05 -04002135 /* Synchronize broadcast link info, if not done previously */
2136
Allan Stephens7a54d4a2011-10-27 14:17:53 -04002137 if (!tipc_node_is_up(l_ptr->owner)) {
2138 l_ptr->owner->bclink.last_sent =
2139 l_ptr->owner->bclink.last_in =
2140 msg_last_bcast(msg);
2141 l_ptr->owner->bclink.oos_state = 0;
2142 }
Allan Stephens4d753132011-10-25 12:19:05 -04002143
Per Lidenb97bf3f2006-01-02 19:04:38 +01002144 l_ptr->peer_session = msg_session(msg);
2145 l_ptr->peer_bearer_id = msg_bearer_id(msg);
Allan Stephens47361c82011-10-26 10:55:16 -04002146
2147 if (msg_type(msg) == ACTIVATE_MSG)
2148 link_state_event(l_ptr, ACTIVATE_MSG);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002149 break;
2150 case STATE_MSG:
2151
Allan Stephens2db99832010-12-31 18:59:33 +00002152 msg_tol = msg_link_tolerance(msg);
2153 if (msg_tol)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002154 link_set_supervision_props(l_ptr, msg_tol);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002155
2156 if (msg_linkprio(msg) &&
Per Lidenb97bf3f2006-01-02 19:04:38 +01002157 (msg_linkprio(msg) != l_ptr->priority)) {
Allan Stephensa10bd922006-06-25 23:52:17 -07002158 warn("Resetting link <%s>, priority change %u->%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +01002159 l_ptr->name, l_ptr->priority, msg_linkprio(msg));
2160 l_ptr->priority = msg_linkprio(msg);
Per Liden4323add2006-01-18 00:38:21 +01002161 tipc_link_reset(l_ptr); /* Enforce change to take effect */
Per Lidenb97bf3f2006-01-02 19:04:38 +01002162 break;
2163 }
2164 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
2165 l_ptr->stats.recv_states++;
2166 if (link_reset_unknown(l_ptr))
2167 break;
2168
2169 if (less_eq(mod(l_ptr->next_in_no), msg_next_sent(msg))) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002170 rec_gap = mod(msg_next_sent(msg) -
Per Lidenb97bf3f2006-01-02 19:04:38 +01002171 mod(l_ptr->next_in_no));
2172 }
2173
2174 max_pkt_ack = msg_max_pkt(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002175 if (max_pkt_ack > l_ptr->max_pkt) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002176 l_ptr->max_pkt = max_pkt_ack;
2177 l_ptr->max_pkt_probes = 0;
2178 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002179
2180 max_pkt_ack = 0;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002181 if (msg_probe(msg)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002182 l_ptr->stats.recv_probes++;
Allan Stephensa0168922010-12-31 18:59:35 +00002183 if (msg_size(msg) > sizeof(l_ptr->proto_msg))
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002184 max_pkt_ack = msg_size(msg);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002185 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002186
2187 /* Protocol message before retransmits, reduce loss risk */
2188
Allan Stephens7a54d4a2011-10-27 14:17:53 -04002189 if (l_ptr->owner->bclink.supported)
2190 tipc_bclink_update_link_state(l_ptr->owner,
2191 msg_last_bcast(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002192
2193 if (rec_gap || (msg_probe(msg))) {
Per Liden4323add2006-01-18 00:38:21 +01002194 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
2195 0, rec_gap, 0, 0, max_pkt_ack);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002196 }
2197 if (msg_seq_gap(msg)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002198 l_ptr->stats.recv_nacks++;
Per Liden4323add2006-01-18 00:38:21 +01002199 tipc_link_retransmit(l_ptr, l_ptr->first_out,
2200 msg_seq_gap(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002201 }
2202 break;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002203 }
2204exit:
Allan Stephens5f6d9122011-11-04 13:24:29 -04002205 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002206}
2207
2208
2209/*
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002210 * tipc_link_tunnel(): Send one message via a link belonging to
Per Lidenb97bf3f2006-01-02 19:04:38 +01002211 * another bearer. Owner node is locked.
2212 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002213static void tipc_link_tunnel(struct tipc_link *l_ptr,
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002214 struct tipc_msg *tunnel_hdr,
2215 struct tipc_msg *msg,
2216 u32 selector)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002217{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002218 struct tipc_link *tunnel;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002219 struct sk_buff *buf;
2220 u32 length = msg_size(msg);
2221
2222 tunnel = l_ptr->owner->active_links[selector & 1];
Allan Stephens5392d642006-06-25 23:52:50 -07002223 if (!tipc_link_is_up(tunnel)) {
2224 warn("Link changeover error, "
2225 "tunnel link no longer available\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002226 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002227 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002228 msg_set_size(tunnel_hdr, length + INT_H_SIZE);
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002229 buf = tipc_buf_acquire(length + INT_H_SIZE);
Allan Stephens5392d642006-06-25 23:52:50 -07002230 if (!buf) {
2231 warn("Link changeover error, "
2232 "unable to send tunnel msg\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002233 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002234 }
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002235 skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE);
2236 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, msg, length);
Per Liden4323add2006-01-18 00:38:21 +01002237 tipc_link_send_buf(tunnel, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002238}
2239
2240
2241
2242/*
2243 * changeover(): Send whole message queue via the remaining link
2244 * Owner node is locked.
2245 */
2246
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002247void tipc_link_changeover(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002248{
2249 u32 msgcount = l_ptr->out_queue_size;
2250 struct sk_buff *crs = l_ptr->first_out;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002251 struct tipc_link *tunnel = l_ptr->owner->active_links[0];
Per Lidenb97bf3f2006-01-02 19:04:38 +01002252 struct tipc_msg tunnel_hdr;
Allan Stephens5392d642006-06-25 23:52:50 -07002253 int split_bundles;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002254
2255 if (!tunnel)
2256 return;
2257
Allan Stephens5392d642006-06-25 23:52:50 -07002258 if (!l_ptr->owner->permit_changeover) {
2259 warn("Link changeover error, "
2260 "peer did not permit changeover\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002261 return;
Allan Stephens5392d642006-06-25 23:52:50 -07002262 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002263
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002264 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
Allan Stephens75715212008-06-04 17:37:34 -07002265 ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002266 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2267 msg_set_msgcnt(&tunnel_hdr, msgcount);
Allan Stephensf1310722006-06-25 23:51:37 -07002268
Per Lidenb97bf3f2006-01-02 19:04:38 +01002269 if (!l_ptr->first_out) {
2270 struct sk_buff *buf;
2271
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002272 buf = tipc_buf_acquire(INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002273 if (buf) {
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002274 skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002275 msg_set_size(&tunnel_hdr, INT_H_SIZE);
Per Liden4323add2006-01-18 00:38:21 +01002276 tipc_link_send_buf(tunnel, buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002277 } else {
Allan Stephensa10bd922006-06-25 23:52:17 -07002278 warn("Link changeover error, "
2279 "unable to send changeover msg\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002280 }
2281 return;
2282 }
Allan Stephensf1310722006-06-25 23:51:37 -07002283
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002284 split_bundles = (l_ptr->owner->active_links[0] !=
Allan Stephens5392d642006-06-25 23:52:50 -07002285 l_ptr->owner->active_links[1]);
2286
Per Lidenb97bf3f2006-01-02 19:04:38 +01002287 while (crs) {
2288 struct tipc_msg *msg = buf_msg(crs);
2289
2290 if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002291 struct tipc_msg *m = msg_get_wrapped(msg);
Allan Stephens0e659672010-12-31 18:59:32 +00002292 unchar *pos = (unchar *)m;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002293
Florian Westphald788d802007-08-02 19:28:06 -07002294 msgcount = msg_msgcnt(msg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002295 while (msgcount--) {
Allan Stephens0e659672010-12-31 18:59:32 +00002296 msg_set_seqno(m, msg_seqno(msg));
Per Liden4323add2006-01-18 00:38:21 +01002297 tipc_link_tunnel(l_ptr, &tunnel_hdr, m,
2298 msg_link_selector(m));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002299 pos += align(msg_size(m));
2300 m = (struct tipc_msg *)pos;
2301 }
2302 } else {
Per Liden4323add2006-01-18 00:38:21 +01002303 tipc_link_tunnel(l_ptr, &tunnel_hdr, msg,
2304 msg_link_selector(msg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002305 }
2306 crs = crs->next;
2307 }
2308}
2309
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002310void tipc_link_send_duplicate(struct tipc_link *l_ptr, struct tipc_link *tunnel)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002311{
2312 struct sk_buff *iter;
2313 struct tipc_msg tunnel_hdr;
2314
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002315 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
Allan Stephens75715212008-06-04 17:37:34 -07002316 DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002317 msg_set_msgcnt(&tunnel_hdr, l_ptr->out_queue_size);
2318 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2319 iter = l_ptr->first_out;
2320 while (iter) {
2321 struct sk_buff *outbuf;
2322 struct tipc_msg *msg = buf_msg(iter);
2323 u32 length = msg_size(msg);
2324
2325 if (msg_user(msg) == MSG_BUNDLER)
2326 msg_set_type(msg, CLOSED_MSG);
2327 msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002328 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002329 msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002330 outbuf = tipc_buf_acquire(length + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002331 if (outbuf == NULL) {
Allan Stephensa10bd922006-06-25 23:52:17 -07002332 warn("Link changeover error, "
2333 "unable to send duplicate msg\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002334 return;
2335 }
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002336 skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);
2337 skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data,
2338 length);
Per Liden4323add2006-01-18 00:38:21 +01002339 tipc_link_send_buf(tunnel, outbuf);
2340 if (!tipc_link_is_up(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002341 return;
2342 iter = iter->next;
2343 }
2344}
2345
2346
2347
2348/**
2349 * buf_extract - extracts embedded TIPC message from another message
2350 * @skb: encapsulating message buffer
2351 * @from_pos: offset to extract from
2352 *
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002353 * Returns a new message buffer containing an embedded message. The
Per Lidenb97bf3f2006-01-02 19:04:38 +01002354 * encapsulating message itself is left unchanged.
2355 */
2356
2357static struct sk_buff *buf_extract(struct sk_buff *skb, u32 from_pos)
2358{
2359 struct tipc_msg *msg = (struct tipc_msg *)(skb->data + from_pos);
2360 u32 size = msg_size(msg);
2361 struct sk_buff *eb;
2362
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002363 eb = tipc_buf_acquire(size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002364 if (eb)
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002365 skb_copy_to_linear_data(eb, msg, size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002366 return eb;
2367}
2368
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002369/*
Per Lidenb97bf3f2006-01-02 19:04:38 +01002370 * link_recv_changeover_msg(): Receive tunneled packet sent
2371 * via other link. Node is locked. Return extracted buffer.
2372 */
2373
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002374static int link_recv_changeover_msg(struct tipc_link **l_ptr,
Per Lidenb97bf3f2006-01-02 19:04:38 +01002375 struct sk_buff **buf)
2376{
2377 struct sk_buff *tunnel_buf = *buf;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002378 struct tipc_link *dest_link;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002379 struct tipc_msg *msg;
2380 struct tipc_msg *tunnel_msg = buf_msg(tunnel_buf);
2381 u32 msg_typ = msg_type(tunnel_msg);
2382 u32 msg_count = msg_msgcnt(tunnel_msg);
2383
2384 dest_link = (*l_ptr)->owner->links[msg_bearer_id(tunnel_msg)];
Allan Stephensb29f1422010-12-31 18:59:25 +00002385 if (!dest_link)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002386 goto exit;
Allan Stephensf1310722006-06-25 23:51:37 -07002387 if (dest_link == *l_ptr) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002388 err("Unexpected changeover message on link <%s>\n",
Allan Stephensf1310722006-06-25 23:51:37 -07002389 (*l_ptr)->name);
2390 goto exit;
2391 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002392 *l_ptr = dest_link;
2393 msg = msg_get_wrapped(tunnel_msg);
2394
2395 if (msg_typ == DUPLICATE_MSG) {
Allan Stephensb29f1422010-12-31 18:59:25 +00002396 if (less(msg_seqno(msg), mod(dest_link->next_in_no)))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002397 goto exit;
Allan Stephens0e659672010-12-31 18:59:32 +00002398 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002399 if (*buf == NULL) {
Allan Stephensa10bd922006-06-25 23:52:17 -07002400 warn("Link changeover error, duplicate msg dropped\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002401 goto exit;
2402 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002403 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002404 return 1;
2405 }
2406
2407 /* First original message ?: */
2408
Per Liden4323add2006-01-18 00:38:21 +01002409 if (tipc_link_is_up(dest_link)) {
Allan Stephensa10bd922006-06-25 23:52:17 -07002410 info("Resetting link <%s>, changeover initiated by peer\n",
2411 dest_link->name);
Per Liden4323add2006-01-18 00:38:21 +01002412 tipc_link_reset(dest_link);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002413 dest_link->exp_msg_count = msg_count;
2414 if (!msg_count)
2415 goto exit;
2416 } else if (dest_link->exp_msg_count == START_CHANGEOVER) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002417 dest_link->exp_msg_count = msg_count;
2418 if (!msg_count)
2419 goto exit;
2420 }
2421
2422 /* Receive original message */
2423
2424 if (dest_link->exp_msg_count == 0) {
Allan Stephens5392d642006-06-25 23:52:50 -07002425 warn("Link switchover error, "
2426 "got too many tunnelled messages\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002427 goto exit;
2428 }
2429 dest_link->exp_msg_count--;
2430 if (less(msg_seqno(msg), dest_link->reset_checkpoint)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002431 goto exit;
2432 } else {
2433 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
2434 if (*buf != NULL) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002435 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002436 return 1;
2437 } else {
Allan Stephensa10bd922006-06-25 23:52:17 -07002438 warn("Link changeover error, original msg dropped\n");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002439 }
2440 }
2441exit:
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002442 *buf = NULL;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002443 kfree_skb(tunnel_buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002444 return 0;
2445}
2446
2447/*
2448 * Bundler functionality:
2449 */
Per Liden4323add2006-01-18 00:38:21 +01002450void tipc_link_recv_bundle(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002451{
2452 u32 msgcount = msg_msgcnt(buf_msg(buf));
2453 u32 pos = INT_H_SIZE;
2454 struct sk_buff *obuf;
2455
Per Lidenb97bf3f2006-01-02 19:04:38 +01002456 while (msgcount--) {
2457 obuf = buf_extract(buf, pos);
2458 if (obuf == NULL) {
Allan Stephensa10bd922006-06-25 23:52:17 -07002459 warn("Link unable to unbundle message(s)\n");
2460 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002461 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002462 pos += align(msg_size(buf_msg(obuf)));
Per Liden4323add2006-01-18 00:38:21 +01002463 tipc_net_route_msg(obuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002464 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002465 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002466}
2467
2468/*
2469 * Fragmentation/defragmentation:
2470 */
2471
2472
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002473/*
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002474 * link_send_long_buf: Entry for buffers needing fragmentation.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002475 * The buffer is complete, inclusive total message length.
Per Lidenb97bf3f2006-01-02 19:04:38 +01002476 * Returns user data length.
2477 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002478static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002479{
Allan Stephens77561552011-04-17 13:06:23 -04002480 struct sk_buff *buf_chain = NULL;
2481 struct sk_buff *buf_chain_tail = (struct sk_buff *)&buf_chain;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002482 struct tipc_msg *inmsg = buf_msg(buf);
2483 struct tipc_msg fragm_hdr;
2484 u32 insize = msg_size(inmsg);
2485 u32 dsz = msg_data_sz(inmsg);
2486 unchar *crs = buf->data;
2487 u32 rest = insize;
Allan Stephens15e979d2010-05-11 14:30:10 +00002488 u32 pack_sz = l_ptr->max_pkt;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002489 u32 fragm_sz = pack_sz - INT_H_SIZE;
Allan Stephens77561552011-04-17 13:06:23 -04002490 u32 fragm_no = 0;
Allan Stephens9c396a72008-06-04 17:36:58 -07002491 u32 destaddr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002492
2493 if (msg_short(inmsg))
2494 destaddr = l_ptr->addr;
Allan Stephens9c396a72008-06-04 17:36:58 -07002495 else
2496 destaddr = msg_destnode(inmsg);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002497
Per Lidenb97bf3f2006-01-02 19:04:38 +01002498 /* Prepare reusable fragment header: */
2499
Allan Stephensc68ca7b2010-05-11 14:30:12 +00002500 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
Allan Stephens75715212008-06-04 17:37:34 -07002501 INT_H_SIZE, destaddr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002502
2503 /* Chop up message: */
2504
2505 while (rest > 0) {
2506 struct sk_buff *fragm;
2507
2508 if (rest <= fragm_sz) {
2509 fragm_sz = rest;
2510 msg_set_type(&fragm_hdr, LAST_FRAGMENT);
2511 }
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002512 fragm = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002513 if (fragm == NULL) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002514 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002515 while (buf_chain) {
2516 buf = buf_chain;
2517 buf_chain = buf_chain->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002518 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002519 }
2520 return -ENOMEM;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002521 }
2522 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
Allan Stephens77561552011-04-17 13:06:23 -04002523 fragm_no++;
2524 msg_set_fragm_no(&fragm_hdr, fragm_no);
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002525 skb_copy_to_linear_data(fragm, &fragm_hdr, INT_H_SIZE);
2526 skb_copy_to_linear_data_offset(fragm, INT_H_SIZE, crs,
2527 fragm_sz);
Allan Stephens77561552011-04-17 13:06:23 -04002528 buf_chain_tail->next = fragm;
2529 buf_chain_tail = fragm;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002530
Per Lidenb97bf3f2006-01-02 19:04:38 +01002531 rest -= fragm_sz;
2532 crs += fragm_sz;
2533 msg_set_type(&fragm_hdr, FRAGMENT);
2534 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002535 kfree_skb(buf);
Allan Stephens77561552011-04-17 13:06:23 -04002536
2537 /* Append chain of fragments to send queue & send them */
2538
2539 l_ptr->long_msg_seq_no++;
2540 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
2541 l_ptr->stats.sent_fragments += fragm_no;
2542 l_ptr->stats.sent_fragmented++;
2543 tipc_link_push_queue(l_ptr);
2544
Per Lidenb97bf3f2006-01-02 19:04:38 +01002545 return dsz;
2546}
2547
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002548/*
2549 * A pending message being re-assembled must store certain values
2550 * to handle subsequent fragments correctly. The following functions
Per Lidenb97bf3f2006-01-02 19:04:38 +01002551 * help storing these values in unused, available fields in the
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002552 * pending message. This makes dynamic memory allocation unnecessary.
Per Lidenb97bf3f2006-01-02 19:04:38 +01002553 */
2554
Sam Ravnborg05790c62006-03-20 22:37:04 -08002555static void set_long_msg_seqno(struct sk_buff *buf, u32 seqno)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002556{
2557 msg_set_seqno(buf_msg(buf), seqno);
2558}
2559
Sam Ravnborg05790c62006-03-20 22:37:04 -08002560static u32 get_fragm_size(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002561{
2562 return msg_ack(buf_msg(buf));
2563}
2564
Sam Ravnborg05790c62006-03-20 22:37:04 -08002565static void set_fragm_size(struct sk_buff *buf, u32 sz)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002566{
2567 msg_set_ack(buf_msg(buf), sz);
2568}
2569
Sam Ravnborg05790c62006-03-20 22:37:04 -08002570static u32 get_expected_frags(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002571{
2572 return msg_bcast_ack(buf_msg(buf));
2573}
2574
Sam Ravnborg05790c62006-03-20 22:37:04 -08002575static void set_expected_frags(struct sk_buff *buf, u32 exp)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002576{
2577 msg_set_bcast_ack(buf_msg(buf), exp);
2578}
2579
Sam Ravnborg05790c62006-03-20 22:37:04 -08002580static u32 get_timer_cnt(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002581{
2582 return msg_reroute_cnt(buf_msg(buf));
2583}
2584
Sam Ravnborg05790c62006-03-20 22:37:04 -08002585static void incr_timer_cnt(struct sk_buff *buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002586{
2587 msg_incr_reroute_cnt(buf_msg(buf));
2588}
2589
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002590/*
2591 * tipc_link_recv_fragment(): Called with node lock on. Returns
Per Lidenb97bf3f2006-01-02 19:04:38 +01002592 * the reassembled buffer if message is complete.
2593 */
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002594int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
Per Liden4323add2006-01-18 00:38:21 +01002595 struct tipc_msg **m)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002596{
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002597 struct sk_buff *prev = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002598 struct sk_buff *fbuf = *fb;
2599 struct tipc_msg *fragm = buf_msg(fbuf);
2600 struct sk_buff *pbuf = *pending;
2601 u32 long_msg_seq_no = msg_long_msgno(fragm);
2602
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002603 *fb = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002604
2605 /* Is there an incomplete message waiting for this fragment? */
2606
Allan Stephensf9057302011-10-24 16:03:12 -04002607 while (pbuf && ((buf_seqno(pbuf) != long_msg_seq_no) ||
Joe Perchesf64f9e72009-11-29 16:55:45 -08002608 (msg_orignode(fragm) != msg_orignode(buf_msg(pbuf))))) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002609 prev = pbuf;
2610 pbuf = pbuf->next;
2611 }
2612
2613 if (!pbuf && (msg_type(fragm) == FIRST_FRAGMENT)) {
2614 struct tipc_msg *imsg = (struct tipc_msg *)msg_data(fragm);
2615 u32 msg_sz = msg_size(imsg);
2616 u32 fragm_sz = msg_data_sz(fragm);
2617 u32 exp_fragm_cnt = msg_sz/fragm_sz + !!(msg_sz % fragm_sz);
Allan Stephens741d9eb2011-05-31 15:03:18 -04002618 u32 max = TIPC_MAX_USER_MSG_SIZE + NAMED_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002619 if (msg_type(imsg) == TIPC_MCAST_MSG)
2620 max = TIPC_MAX_USER_MSG_SIZE + MCAST_H_SIZE;
2621 if (msg_size(imsg) > max) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04002622 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002623 return 0;
2624 }
stephen hemminger31e3c3f2010-10-13 13:20:35 +00002625 pbuf = tipc_buf_acquire(msg_size(imsg));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002626 if (pbuf != NULL) {
2627 pbuf->next = *pending;
2628 *pending = pbuf;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002629 skb_copy_to_linear_data(pbuf, imsg,
2630 msg_data_sz(fragm));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002631 /* Prepare buffer for subsequent fragments. */
2632
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002633 set_long_msg_seqno(pbuf, long_msg_seq_no);
Allan Stephens0e659672010-12-31 18:59:32 +00002634 set_fragm_size(pbuf, fragm_sz);
2635 set_expected_frags(pbuf, exp_fragm_cnt - 1);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002636 } else {
Allan Stephensb76b27c2011-10-27 16:31:26 -04002637 dbg("Link unable to reassemble fragmented message\n");
Allan Stephens5f6d9122011-11-04 13:24:29 -04002638 kfree_skb(fbuf);
Allan Stephensb76b27c2011-10-27 16:31:26 -04002639 return -1;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002640 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002641 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002642 return 0;
2643 } else if (pbuf && (msg_type(fragm) != FIRST_FRAGMENT)) {
2644 u32 dsz = msg_data_sz(fragm);
2645 u32 fsz = get_fragm_size(pbuf);
2646 u32 crs = ((msg_fragm_no(fragm) - 1) * fsz);
2647 u32 exp_frags = get_expected_frags(pbuf) - 1;
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002648 skb_copy_to_linear_data_offset(pbuf, crs,
2649 msg_data(fragm), dsz);
Allan Stephens5f6d9122011-11-04 13:24:29 -04002650 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002651
2652 /* Is message complete? */
2653
2654 if (exp_frags == 0) {
2655 if (prev)
2656 prev->next = pbuf->next;
2657 else
2658 *pending = pbuf->next;
2659 msg_reset_reroute_cnt(buf_msg(pbuf));
2660 *fb = pbuf;
2661 *m = buf_msg(pbuf);
2662 return 1;
2663 }
Allan Stephens0e659672010-12-31 18:59:32 +00002664 set_expected_frags(pbuf, exp_frags);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002665 return 0;
2666 }
Allan Stephens5f6d9122011-11-04 13:24:29 -04002667 kfree_skb(fbuf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002668 return 0;
2669}
2670
2671/**
2672 * link_check_defragm_bufs - flush stale incoming message fragments
2673 * @l_ptr: pointer to link
2674 */
2675
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002676static void link_check_defragm_bufs(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002677{
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002678 struct sk_buff *prev = NULL;
2679 struct sk_buff *next = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002680 struct sk_buff *buf = l_ptr->defragm_buf;
2681
2682 if (!buf)
2683 return;
2684 if (!link_working_working(l_ptr))
2685 return;
2686 while (buf) {
2687 u32 cnt = get_timer_cnt(buf);
2688
2689 next = buf->next;
2690 if (cnt < 4) {
2691 incr_timer_cnt(buf);
2692 prev = buf;
2693 } else {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002694 if (prev)
2695 prev->next = buf->next;
2696 else
2697 l_ptr->defragm_buf = buf->next;
Allan Stephens5f6d9122011-11-04 13:24:29 -04002698 kfree_skb(buf);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002699 }
2700 buf = next;
2701 }
2702}
2703
2704
2705
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002706static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002707{
Allan Stephens5413b4c2011-01-18 13:24:55 -05002708 if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL))
2709 return;
2710
Per Lidenb97bf3f2006-01-02 19:04:38 +01002711 l_ptr->tolerance = tolerance;
2712 l_ptr->continuity_interval =
2713 ((tolerance / 4) > 500) ? 500 : tolerance / 4;
2714 l_ptr->abort_limit = tolerance / (l_ptr->continuity_interval / 4);
2715}
2716
2717
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002718void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002719{
2720 /* Data messages from this node, inclusive FIRST_FRAGM */
Allan Stephens06d82c92008-03-06 15:06:55 -08002721 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE] = window;
2722 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE] = (window / 3) * 4;
2723 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE] = (window / 3) * 5;
2724 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE] = (window / 3) * 6;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002725 /* Transiting data messages,inclusive FIRST_FRAGM */
Allan Stephens06d82c92008-03-06 15:06:55 -08002726 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE + 4] = 300;
2727 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE + 4] = 600;
2728 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;
2729 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002730 l_ptr->queue_limit[CONN_MANAGER] = 1200;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002731 l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;
2732 l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;
2733 /* FRAGMENT and LAST_FRAGMENT packets */
2734 l_ptr->queue_limit[MSG_FRAGMENTER] = 4000;
2735}
2736
2737/**
2738 * link_find_link - locate link by name
2739 * @name - ptr to link name string
2740 * @node - ptr to area to be filled with ptr to associated node
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002741 *
Per Liden4323add2006-01-18 00:38:21 +01002742 * Caller must hold 'tipc_net_lock' to ensure node and bearer are not deleted;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002743 * this also prevents link deletion.
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002744 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002745 * Returns pointer to link (or 0 if invalid link name).
2746 */
2747
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002748static struct tipc_link *link_find_link(const char *name,
2749 struct tipc_node **node)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002750{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002751 struct tipc_link_name link_name_parts;
Allan Stephens2d627b92011-01-07 13:00:11 -05002752 struct tipc_bearer *b_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002753 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002754
2755 if (!link_name_validate(name, &link_name_parts))
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002756 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002757
Per Liden4323add2006-01-18 00:38:21 +01002758 b_ptr = tipc_bearer_find_interface(link_name_parts.if_local);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002759 if (!b_ptr)
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002760 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002761
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002762 *node = tipc_node_find(link_name_parts.addr_peer);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002763 if (!*node)
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002764 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002765
2766 l_ptr = (*node)->links[b_ptr->identity];
2767 if (!l_ptr || strcmp(l_ptr->name, name))
Sam Ravnborg1fc54d82006-03-20 22:36:47 -08002768 return NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002769
2770 return l_ptr;
2771}
2772
Allan Stephens5c216e12011-10-18 11:34:29 -04002773/**
2774 * link_value_is_valid -- validate proposed link tolerance/priority/window
2775 *
2776 * @cmd - value type (TIPC_CMD_SET_LINK_*)
2777 * @new_value - the new value
2778 *
2779 * Returns 1 if value is within range, 0 if not.
2780 */
2781
2782static int link_value_is_valid(u16 cmd, u32 new_value)
2783{
2784 switch (cmd) {
2785 case TIPC_CMD_SET_LINK_TOL:
2786 return (new_value >= TIPC_MIN_LINK_TOL) &&
2787 (new_value <= TIPC_MAX_LINK_TOL);
2788 case TIPC_CMD_SET_LINK_PRI:
2789 return (new_value <= TIPC_MAX_LINK_PRI);
2790 case TIPC_CMD_SET_LINK_WINDOW:
2791 return (new_value >= TIPC_MIN_LINK_WIN) &&
2792 (new_value <= TIPC_MAX_LINK_WIN);
2793 }
2794 return 0;
2795}
2796
2797
2798/**
2799 * link_cmd_set_value - change priority/tolerance/window for link/bearer/media
2800 * @name - ptr to link, bearer, or media name
2801 * @new_value - new value of link, bearer, or media setting
2802 * @cmd - which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*)
2803 *
2804 * Caller must hold 'tipc_net_lock' to ensure link/bearer/media is not deleted.
2805 *
2806 * Returns 0 if value updated and negative value on error.
2807 */
2808
2809static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd)
2810{
2811 struct tipc_node *node;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002812 struct tipc_link *l_ptr;
Allan Stephens5c216e12011-10-18 11:34:29 -04002813 struct tipc_bearer *b_ptr;
Paul Gortmaker358a0d12011-12-29 20:19:42 -05002814 struct tipc_media *m_ptr;
Allan Stephens5c216e12011-10-18 11:34:29 -04002815
2816 l_ptr = link_find_link(name, &node);
2817 if (l_ptr) {
2818 /*
2819 * acquire node lock for tipc_link_send_proto_msg().
2820 * see "TIPC locking policy" in net.c.
2821 */
2822 tipc_node_lock(node);
2823 switch (cmd) {
2824 case TIPC_CMD_SET_LINK_TOL:
2825 link_set_supervision_props(l_ptr, new_value);
2826 tipc_link_send_proto_msg(l_ptr,
2827 STATE_MSG, 0, 0, new_value, 0, 0);
2828 break;
2829 case TIPC_CMD_SET_LINK_PRI:
2830 l_ptr->priority = new_value;
2831 tipc_link_send_proto_msg(l_ptr,
2832 STATE_MSG, 0, 0, 0, new_value, 0);
2833 break;
2834 case TIPC_CMD_SET_LINK_WINDOW:
2835 tipc_link_set_queue_limits(l_ptr, new_value);
2836 break;
2837 }
2838 tipc_node_unlock(node);
2839 return 0;
2840 }
2841
2842 b_ptr = tipc_bearer_find(name);
2843 if (b_ptr) {
2844 switch (cmd) {
2845 case TIPC_CMD_SET_LINK_TOL:
2846 b_ptr->tolerance = new_value;
2847 return 0;
2848 case TIPC_CMD_SET_LINK_PRI:
2849 b_ptr->priority = new_value;
2850 return 0;
2851 case TIPC_CMD_SET_LINK_WINDOW:
2852 b_ptr->window = new_value;
2853 return 0;
2854 }
2855 return -EINVAL;
2856 }
2857
2858 m_ptr = tipc_media_find(name);
2859 if (!m_ptr)
2860 return -ENODEV;
2861 switch (cmd) {
2862 case TIPC_CMD_SET_LINK_TOL:
2863 m_ptr->tolerance = new_value;
2864 return 0;
2865 case TIPC_CMD_SET_LINK_PRI:
2866 m_ptr->priority = new_value;
2867 return 0;
2868 case TIPC_CMD_SET_LINK_WINDOW:
2869 m_ptr->window = new_value;
2870 return 0;
2871 }
2872 return -EINVAL;
2873}
2874
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002875struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space,
Per Liden4323add2006-01-18 00:38:21 +01002876 u16 cmd)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002877{
2878 struct tipc_link_config *args;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002879 u32 new_value;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002880 int res;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002881
2882 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_CONFIG))
Per Liden4323add2006-01-18 00:38:21 +01002883 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002884
2885 args = (struct tipc_link_config *)TLV_DATA(req_tlv_area);
2886 new_value = ntohl(args->value);
2887
Allan Stephens5c216e12011-10-18 11:34:29 -04002888 if (!link_value_is_valid(cmd, new_value))
2889 return tipc_cfg_reply_error_string(
2890 "cannot change, value invalid");
2891
Per Liden4323add2006-01-18 00:38:21 +01002892 if (!strcmp(args->name, tipc_bclink_name)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01002893 if ((cmd == TIPC_CMD_SET_LINK_WINDOW) &&
Per Liden4323add2006-01-18 00:38:21 +01002894 (tipc_bclink_set_queue_limits(new_value) == 0))
2895 return tipc_cfg_reply_none();
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002896 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
Per Liden4323add2006-01-18 00:38:21 +01002897 " (cannot change setting on broadcast link)");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002898 }
2899
Per Liden4323add2006-01-18 00:38:21 +01002900 read_lock_bh(&tipc_net_lock);
Allan Stephens5c216e12011-10-18 11:34:29 -04002901 res = link_cmd_set_value(args->name, new_value, cmd);
Per Liden4323add2006-01-18 00:38:21 +01002902 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002903 if (res)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002904 return tipc_cfg_reply_error_string("cannot change link setting");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002905
Per Liden4323add2006-01-18 00:38:21 +01002906 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002907}
2908
2909/**
2910 * link_reset_statistics - reset link statistics
2911 * @l_ptr: pointer to link
2912 */
2913
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002914static void link_reset_statistics(struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002915{
2916 memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));
2917 l_ptr->stats.sent_info = l_ptr->next_out_no;
2918 l_ptr->stats.recv_info = l_ptr->next_in_no;
2919}
2920
Per Liden4323add2006-01-18 00:38:21 +01002921struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002922{
2923 char *link_name;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002924 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07002925 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002926
2927 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
Per Liden4323add2006-01-18 00:38:21 +01002928 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002929
2930 link_name = (char *)TLV_DATA(req_tlv_area);
Per Liden4323add2006-01-18 00:38:21 +01002931 if (!strcmp(link_name, tipc_bclink_name)) {
2932 if (tipc_bclink_reset_stats())
2933 return tipc_cfg_reply_error_string("link not found");
2934 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002935 }
2936
Per Liden4323add2006-01-18 00:38:21 +01002937 read_lock_bh(&tipc_net_lock);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002938 l_ptr = link_find_link(link_name, &node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002939 if (!l_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01002940 read_unlock_bh(&tipc_net_lock);
2941 return tipc_cfg_reply_error_string("link not found");
Per Lidenb97bf3f2006-01-02 19:04:38 +01002942 }
2943
Per Liden4323add2006-01-18 00:38:21 +01002944 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002945 link_reset_statistics(l_ptr);
Per Liden4323add2006-01-18 00:38:21 +01002946 tipc_node_unlock(node);
2947 read_unlock_bh(&tipc_net_lock);
2948 return tipc_cfg_reply_none();
Per Lidenb97bf3f2006-01-02 19:04:38 +01002949}
2950
2951/**
2952 * percent - convert count to a percentage of total (rounding up or down)
2953 */
2954
2955static u32 percent(u32 count, u32 total)
2956{
2957 return (count * 100 + (total / 2)) / total;
2958}
2959
2960/**
Per Liden4323add2006-01-18 00:38:21 +01002961 * tipc_link_stats - print link statistics
Per Lidenb97bf3f2006-01-02 19:04:38 +01002962 * @name: link name
2963 * @buf: print buffer area
2964 * @buf_size: size of print buffer area
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002965 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01002966 * Returns length of print buffer data string (or 0 if error)
2967 */
2968
Per Liden4323add2006-01-18 00:38:21 +01002969static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002970{
2971 struct print_buf pb;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05002972 struct tipc_link *l_ptr;
David S. Miller6c000552008-09-02 23:38:32 -07002973 struct tipc_node *node;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002974 char *status;
2975 u32 profile_total = 0;
2976
Per Liden4323add2006-01-18 00:38:21 +01002977 if (!strcmp(name, tipc_bclink_name))
2978 return tipc_bclink_stats(buf, buf_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002979
Per Liden4323add2006-01-18 00:38:21 +01002980 tipc_printbuf_init(&pb, buf, buf_size);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002981
Per Liden4323add2006-01-18 00:38:21 +01002982 read_lock_bh(&tipc_net_lock);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002983 l_ptr = link_find_link(name, &node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002984 if (!l_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01002985 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002986 return 0;
2987 }
Per Liden4323add2006-01-18 00:38:21 +01002988 tipc_node_lock(node);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002989
Per Liden4323add2006-01-18 00:38:21 +01002990 if (tipc_link_is_active(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002991 status = "ACTIVE";
Per Liden4323add2006-01-18 00:38:21 +01002992 else if (tipc_link_is_up(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01002993 status = "STANDBY";
2994 else
2995 status = "DEFUNCT";
2996 tipc_printf(&pb, "Link <%s>\n"
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09002997 " %s MTU:%u Priority:%u Tolerance:%u ms"
2998 " Window:%u packets\n",
Allan Stephens15e979d2010-05-11 14:30:10 +00002999 l_ptr->name, status, l_ptr->max_pkt,
Per Lidenb97bf3f2006-01-02 19:04:38 +01003000 l_ptr->priority, l_ptr->tolerance, l_ptr->queue_limit[0]);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003001 tipc_printf(&pb, " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +01003002 l_ptr->next_in_no - l_ptr->stats.recv_info,
3003 l_ptr->stats.recv_fragments,
3004 l_ptr->stats.recv_fragmented,
3005 l_ptr->stats.recv_bundles,
3006 l_ptr->stats.recv_bundled);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003007 tipc_printf(&pb, " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +01003008 l_ptr->next_out_no - l_ptr->stats.sent_info,
3009 l_ptr->stats.sent_fragments,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003010 l_ptr->stats.sent_fragmented,
Per Lidenb97bf3f2006-01-02 19:04:38 +01003011 l_ptr->stats.sent_bundles,
3012 l_ptr->stats.sent_bundled);
3013 profile_total = l_ptr->stats.msg_length_counts;
3014 if (!profile_total)
3015 profile_total = 1;
3016 tipc_printf(&pb, " TX profile sample:%u packets average:%u octets\n"
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003017 " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
Allan Stephens0f305bf2011-05-30 15:36:56 -04003018 "-16384:%u%% -32768:%u%% -66000:%u%%\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +01003019 l_ptr->stats.msg_length_counts,
3020 l_ptr->stats.msg_lengths_total / profile_total,
3021 percent(l_ptr->stats.msg_length_profile[0], profile_total),
3022 percent(l_ptr->stats.msg_length_profile[1], profile_total),
3023 percent(l_ptr->stats.msg_length_profile[2], profile_total),
3024 percent(l_ptr->stats.msg_length_profile[3], profile_total),
3025 percent(l_ptr->stats.msg_length_profile[4], profile_total),
3026 percent(l_ptr->stats.msg_length_profile[5], profile_total),
3027 percent(l_ptr->stats.msg_length_profile[6], profile_total));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003028 tipc_printf(&pb, " RX states:%u probes:%u naks:%u defs:%u dups:%u\n",
Per Lidenb97bf3f2006-01-02 19:04:38 +01003029 l_ptr->stats.recv_states,
3030 l_ptr->stats.recv_probes,
3031 l_ptr->stats.recv_nacks,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003032 l_ptr->stats.deferred_recv,
Per Lidenb97bf3f2006-01-02 19:04:38 +01003033 l_ptr->stats.duplicates);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003034 tipc_printf(&pb, " TX states:%u probes:%u naks:%u acks:%u dups:%u\n",
3035 l_ptr->stats.sent_states,
3036 l_ptr->stats.sent_probes,
3037 l_ptr->stats.sent_nacks,
3038 l_ptr->stats.sent_acks,
Per Lidenb97bf3f2006-01-02 19:04:38 +01003039 l_ptr->stats.retransmitted);
3040 tipc_printf(&pb, " Congestion bearer:%u link:%u Send queue max:%u avg:%u\n",
3041 l_ptr->stats.bearer_congs,
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003042 l_ptr->stats.link_congs,
Per Lidenb97bf3f2006-01-02 19:04:38 +01003043 l_ptr->stats.max_queue_sz,
3044 l_ptr->stats.queue_sz_counts
3045 ? (l_ptr->stats.accu_queue_sz / l_ptr->stats.queue_sz_counts)
3046 : 0);
3047
Per Liden4323add2006-01-18 00:38:21 +01003048 tipc_node_unlock(node);
3049 read_unlock_bh(&tipc_net_lock);
3050 return tipc_printbuf_validate(&pb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003051}
3052
3053#define MAX_LINK_STATS_INFO 2000
3054
Per Liden4323add2006-01-18 00:38:21 +01003055struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
Per Lidenb97bf3f2006-01-02 19:04:38 +01003056{
3057 struct sk_buff *buf;
3058 struct tlv_desc *rep_tlv;
3059 int str_len;
3060
3061 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
Per Liden4323add2006-01-18 00:38:21 +01003062 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003063
Per Liden4323add2006-01-18 00:38:21 +01003064 buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_LINK_STATS_INFO));
Per Lidenb97bf3f2006-01-02 19:04:38 +01003065 if (!buf)
3066 return NULL;
3067
3068 rep_tlv = (struct tlv_desc *)buf->data;
3069
Per Liden4323add2006-01-18 00:38:21 +01003070 str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area),
3071 (char *)TLV_DATA(rep_tlv), MAX_LINK_STATS_INFO);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003072 if (!str_len) {
Allan Stephens5f6d9122011-11-04 13:24:29 -04003073 kfree_skb(buf);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003074 return tipc_cfg_reply_error_string("link not found");
Per Lidenb97bf3f2006-01-02 19:04:38 +01003075 }
3076
3077 skb_put(buf, TLV_SPACE(str_len));
3078 TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
3079
3080 return buf;
3081}
3082
Per Lidenb97bf3f2006-01-02 19:04:38 +01003083/**
Per Liden4323add2006-01-18 00:38:21 +01003084 * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination
Per Lidenb97bf3f2006-01-02 19:04:38 +01003085 * @dest: network address of destination node
3086 * @selector: used to select from set of active links
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003087 *
Per Lidenb97bf3f2006-01-02 19:04:38 +01003088 * If no active link can be found, uses default maximum packet size.
3089 */
3090
Per Liden4323add2006-01-18 00:38:21 +01003091u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
Per Lidenb97bf3f2006-01-02 19:04:38 +01003092{
David S. Miller6c000552008-09-02 23:38:32 -07003093 struct tipc_node *n_ptr;
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05003094 struct tipc_link *l_ptr;
Per Lidenb97bf3f2006-01-02 19:04:38 +01003095 u32 res = MAX_PKT_DEFAULT;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003096
Per Lidenb97bf3f2006-01-02 19:04:38 +01003097 if (dest == tipc_own_addr)
3098 return MAX_MSG_SIZE;
3099
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003100 read_lock_bh(&tipc_net_lock);
Allan Stephens51a8e4d2010-12-31 18:59:18 +00003101 n_ptr = tipc_node_find(dest);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003102 if (n_ptr) {
Per Liden4323add2006-01-18 00:38:21 +01003103 tipc_node_lock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003104 l_ptr = n_ptr->active_links[selector & 1];
3105 if (l_ptr)
Allan Stephens15e979d2010-05-11 14:30:10 +00003106 res = l_ptr->max_pkt;
Per Liden4323add2006-01-18 00:38:21 +01003107 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003108 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003109 read_unlock_bh(&tipc_net_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003110 return res;
3111}
3112
Paul Gortmakera18c4bc2011-12-29 20:58:42 -05003113static void link_print(struct tipc_link *l_ptr, const char *str)
Per Lidenb97bf3f2006-01-02 19:04:38 +01003114{
Allan Stephens8d64a5b2010-12-31 18:59:27 +00003115 char print_area[256];
3116 struct print_buf pb;
3117 struct print_buf *buf = &pb;
3118
3119 tipc_printbuf_init(buf, print_area, sizeof(print_area));
3120
Per Lidenb97bf3f2006-01-02 19:04:38 +01003121 tipc_printf(buf, str);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003122 tipc_printf(buf, "Link %x<%s>:",
Allan Stephens2d627b92011-01-07 13:00:11 -05003123 l_ptr->addr, l_ptr->b_ptr->name);
Allan Stephens8d64a5b2010-12-31 18:59:27 +00003124
3125#ifdef CONFIG_TIPC_DEBUG
3126 if (link_reset_reset(l_ptr) || link_reset_unknown(l_ptr))
3127 goto print_state;
3128
Per Lidenb97bf3f2006-01-02 19:04:38 +01003129 tipc_printf(buf, ": NXO(%u):", mod(l_ptr->next_out_no));
3130 tipc_printf(buf, "NXI(%u):", mod(l_ptr->next_in_no));
3131 tipc_printf(buf, "SQUE");
3132 if (l_ptr->first_out) {
Allan Stephensf9057302011-10-24 16:03:12 -04003133 tipc_printf(buf, "[%u..", buf_seqno(l_ptr->first_out));
Per Lidenb97bf3f2006-01-02 19:04:38 +01003134 if (l_ptr->next_out)
Allan Stephensf9057302011-10-24 16:03:12 -04003135 tipc_printf(buf, "%u..", buf_seqno(l_ptr->next_out));
3136 tipc_printf(buf, "%u]", buf_seqno(l_ptr->last_out));
3137 if ((mod(buf_seqno(l_ptr->last_out) -
3138 buf_seqno(l_ptr->first_out))
Joe Perchesf64f9e72009-11-29 16:55:45 -08003139 != (l_ptr->out_queue_size - 1)) ||
3140 (l_ptr->last_out->next != NULL)) {
Per Lidenb97bf3f2006-01-02 19:04:38 +01003141 tipc_printf(buf, "\nSend queue inconsistency\n");
Allan Stephensc8a61b52011-01-18 13:31:32 -05003142 tipc_printf(buf, "first_out= %p ", l_ptr->first_out);
3143 tipc_printf(buf, "next_out= %p ", l_ptr->next_out);
3144 tipc_printf(buf, "last_out= %p ", l_ptr->last_out);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003145 }
3146 } else
3147 tipc_printf(buf, "[]");
3148 tipc_printf(buf, "SQSIZ(%u)", l_ptr->out_queue_size);
3149 if (l_ptr->oldest_deferred_in) {
Allan Stephensf9057302011-10-24 16:03:12 -04003150 u32 o = buf_seqno(l_ptr->oldest_deferred_in);
3151 u32 n = buf_seqno(l_ptr->newest_deferred_in);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003152 tipc_printf(buf, ":RQUE[%u..%u]", o, n);
3153 if (l_ptr->deferred_inqueue_sz != mod((n + 1) - o)) {
3154 tipc_printf(buf, ":RQSIZ(%u)",
3155 l_ptr->deferred_inqueue_sz);
3156 }
3157 }
Allan Stephens8d64a5b2010-12-31 18:59:27 +00003158print_state:
3159#endif
3160
Per Lidenb97bf3f2006-01-02 19:04:38 +01003161 if (link_working_unknown(l_ptr))
3162 tipc_printf(buf, ":WU");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00003163 else if (link_reset_reset(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01003164 tipc_printf(buf, ":RR");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00003165 else if (link_reset_unknown(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01003166 tipc_printf(buf, ":RU");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00003167 else if (link_working_working(l_ptr))
Per Lidenb97bf3f2006-01-02 19:04:38 +01003168 tipc_printf(buf, ":WW");
3169 tipc_printf(buf, "\n");
Allan Stephens8d64a5b2010-12-31 18:59:27 +00003170
3171 tipc_printbuf_validate(buf);
3172 info("%s", print_area);
Per Lidenb97bf3f2006-01-02 19:04:38 +01003173}
3174