projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tipc: fix lockdep warning during bearer initialization
[deliverable/linux.git] / net / tipc / link.c
CommitLineData
b97bf3fd
PL		 1/*
2 * net/tipc/link.c: TIPC link code
c4307285 3 *
05646c91 4 * Copyright (c) 1996-2007, Ericsson AB
23dd4cce 5 * Copyright (c) 2004-2007, 2010-2011, Wind River Systems
b97bf3fd
PL		 6 * All rights reserved.
7 *
9ea1fd3c 8 * Redistribution and use in source and binary forms, with or without
b97bf3fd
PL		 9 * modification, are permitted provided that the following conditions are met:
10 *
9ea1fd3c
PL		 11 * 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.
b97bf3fd 19 *
9ea1fd3c
PL		 20 * 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
b97bf3fd
PL		 34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37#include "core.h"
b97bf3fd 38#include "link.h"
b97bf3fd 39#include "port.h"
b97bf3fd 40#include "name_distr.h"
b97bf3fd
PL		 41#include "discover.h"
42#include "config.h"
b97bf3fd 43
2cf8aa19
EH		 44/*
45 * Error message prefixes
46 */
47static const char *link_co_err = "Link changeover error, ";
48static const char *link_rst_msg = "Resetting link ";
49static const char *link_unk_evt = "Unknown link event ";
b97bf3fd 50
a686e685
AS		 51/*
52 * Out-of-range value for link session numbers
53 */
a686e685
AS		 54#define INVALID_SESSION 0x10000
55
c4307285
YH		 56/*
57 * Link state events:
b97bf3fd 58 */
b97bf3fd
PL		 59#define STARTING_EVT 856384768 /* link processing trigger */
60#define TRAFFIC_MSG_EVT 560815u /* rx'd ??? */
61#define TIMEOUT_EVT 560817u /* link timer expired */
62
c4307285
YH		 63/*
64 * The following two 'message types' is really just implementation
65 * data conveniently stored in the message header.
b97bf3fd
PL		 66 * They must not be considered part of the protocol
67 */
68#define OPEN_MSG 0
69#define CLOSED_MSG 1
70
c4307285 71/*
b97bf3fd
PL		 72 * State value stored in 'exp_msg_count'
73 */
b97bf3fd
PL		 74#define START_CHANGEOVER 100000u
75
76/**
a18c4bc3 77 * struct tipc_link_name - deconstructed link name
b97bf3fd
PL		 78 * @addr_local: network address of node at this end
79 * @if_local: name of interface at this end
80 * @addr_peer: network address of node at far end
81 * @if_peer: name of interface at far end
82 */
a18c4bc3 83struct tipc_link_name {
b97bf3fd
PL		 84 u32 addr_local;
85 char if_local[TIPC_MAX_IF_NAME];
86 u32 addr_peer;
87 char if_peer[TIPC_MAX_IF_NAME];
88};
89
a18c4bc3 90static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
b97bf3fd 91 struct sk_buff *buf);
a18c4bc3
PG		 92static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf);
93static int link_recv_changeover_msg(struct tipc_link **l_ptr,
94 struct sk_buff **buf);
95static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance);
23dd4cce 96static int link_send_sections_long(struct tipc_port *sender,
b97bf3fd 97 struct iovec const *msg_sect,
26896904
AS		 98 u32 num_sect, unsigned int total_len,
99 u32 destnode);
a18c4bc3
PG		 100static void link_check_defragm_bufs(struct tipc_link *l_ptr);
101static void link_state_event(struct tipc_link *l_ptr, u32 event);
102static void link_reset_statistics(struct tipc_link *l_ptr);
103static void link_print(struct tipc_link *l_ptr, const char *str);
104static void link_start(struct tipc_link *l_ptr);
105static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf);
31e3c3f6 106
b97bf3fd 107/*
05790c64 108 * Simple link routines
b97bf3fd 109 */
05790c64 110static unsigned int align(unsigned int i)
b97bf3fd
PL		 111{
112 return (i + 3) & ~3u;
113}
114
a18c4bc3 115static void link_init_max_pkt(struct tipc_link *l_ptr)
b97bf3fd
PL		 116{
117 u32 max_pkt;
c4307285 118
2d627b92 119 max_pkt = (l_ptr->b_ptr->mtu & ~3);
b97bf3fd
PL		 120 if (max_pkt > MAX_MSG_SIZE)
121 max_pkt = MAX_MSG_SIZE;
122
c4307285 123 l_ptr->max_pkt_target = max_pkt;
b97bf3fd
PL		 124 if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT)
125 l_ptr->max_pkt = l_ptr->max_pkt_target;
c4307285 126 else
b97bf3fd
PL		 127 l_ptr->max_pkt = MAX_PKT_DEFAULT;
128
c4307285 129 l_ptr->max_pkt_probes = 0;
b97bf3fd
PL		 130}
131
a18c4bc3 132static u32 link_next_sent(struct tipc_link *l_ptr)
b97bf3fd
PL		 133{
134 if (l_ptr->next_out)
f905730c 135 return buf_seqno(l_ptr->next_out);
b97bf3fd
PL		 136 return mod(l_ptr->next_out_no);
137}
138
a18c4bc3 139static u32 link_last_sent(struct tipc_link *l_ptr)
b97bf3fd
PL		 140{
141 return mod(link_next_sent(l_ptr) - 1);
142}
143
144/*
05790c64 145 * Simple non-static link routines (i.e. referenced outside this file)
b97bf3fd 146 */
a18c4bc3 147int tipc_link_is_up(struct tipc_link *l_ptr)
b97bf3fd
PL		 148{
149 if (!l_ptr)
150 return 0;
a02cec21 151 return link_working_working(l_ptr) || link_working_unknown(l_ptr);
b97bf3fd
PL		 152}
153
a18c4bc3 154int tipc_link_is_active(struct tipc_link *l_ptr)
b97bf3fd 155{
a02cec21
ED		 156 return (l_ptr->owner->active_links[0] == l_ptr) ||
157 (l_ptr->owner->active_links[1] == l_ptr);
b97bf3fd
PL		 158}
159
160/**
a18c4bc3 161 * link_name_validate - validate & (optionally) deconstruct tipc_link name
2c53040f
BH		 162 * @name: ptr to link name string
163 * @name_parts: ptr to area for link name components (or NULL if not needed)
c4307285 164 *
b97bf3fd
PL		 165 * Returns 1 if link name is valid, otherwise 0.
166 */
a18c4bc3
PG		 167static int link_name_validate(const char *name,
168 struct tipc_link_name *name_parts)
b97bf3fd
PL		 169{
170 char name_copy[TIPC_MAX_LINK_NAME];
171 char *addr_local;
172 char *if_local;
173 char *addr_peer;
174 char *if_peer;
175 char dummy;
176 u32 z_local, c_local, n_local;
177 u32 z_peer, c_peer, n_peer;
178 u32 if_local_len;
179 u32 if_peer_len;
180
181 /* copy link name & ensure length is OK */
b97bf3fd
PL		 182 name_copy[TIPC_MAX_LINK_NAME - 1] = 0;
183 /* need above in case non-Posix strncpy() doesn't pad with nulls */
184 strncpy(name_copy, name, TIPC_MAX_LINK_NAME);
185 if (name_copy[TIPC_MAX_LINK_NAME - 1] != 0)
186 return 0;
187
188 /* ensure all component parts of link name are present */
b97bf3fd 189 addr_local = name_copy;
2db9983a
AS		 190 if_local = strchr(addr_local, ':');
191 if (if_local == NULL)
b97bf3fd
PL		 192 return 0;
193 *(if_local++) = 0;
2db9983a
AS		 194 addr_peer = strchr(if_local, '-');
195 if (addr_peer == NULL)
b97bf3fd
PL		 196 return 0;
197 *(addr_peer++) = 0;
198 if_local_len = addr_peer - if_local;
2db9983a
AS		 199 if_peer = strchr(addr_peer, ':');
200 if (if_peer == NULL)
b97bf3fd
PL		 201 return 0;
202 *(if_peer++) = 0;
203 if_peer_len = strlen(if_peer) + 1;
204
205 /* validate component parts of link name */
b97bf3fd
PL		 206 if ((sscanf(addr_local, "%u.%u.%u%c",
207 &z_local, &c_local, &n_local, &dummy) != 3) ||
208 (sscanf(addr_peer, "%u.%u.%u%c",
209 &z_peer, &c_peer, &n_peer, &dummy) != 3) ||
210 (z_local > 255) || (c_local > 4095) || (n_local > 4095) ||
211 (z_peer > 255) || (c_peer > 4095) || (n_peer > 4095) ||
c4307285
YH		 212 (if_local_len <= 1) || (if_local_len > TIPC_MAX_IF_NAME) ||
213 (if_peer_len <= 1) || (if_peer_len > TIPC_MAX_IF_NAME) ||
b97bf3fd
PL		 214 (strspn(if_local, tipc_alphabet) != (if_local_len - 1)) ||
215 (strspn(if_peer, tipc_alphabet) != (if_peer_len - 1)))
216 return 0;
217
218 /* return link name components, if necessary */
b97bf3fd
PL		 219 if (name_parts) {
220 name_parts->addr_local = tipc_addr(z_local, c_local, n_local);
221 strcpy(name_parts->if_local, if_local);
222 name_parts->addr_peer = tipc_addr(z_peer, c_peer, n_peer);
223 strcpy(name_parts->if_peer, if_peer);
224 }
225 return 1;
226}
227
228/**
229 * link_timeout - handle expiration of link timer
230 * @l_ptr: pointer to link
c4307285 231 *
4323add6
PL		 232 * This routine must not grab "tipc_net_lock" to avoid a potential deadlock conflict
233 * with tipc_link_delete(). (There is no risk that the node will be deleted by
234 * another thread because tipc_link_delete() always cancels the link timer before
235 * tipc_node_delete() is called.)
b97bf3fd 236 */
a18c4bc3 237static void link_timeout(struct tipc_link *l_ptr)
b97bf3fd 238{
4323add6 239 tipc_node_lock(l_ptr->owner);
b97bf3fd
PL		 240
241 /* update counters used in statistical profiling of send traffic */
b97bf3fd
PL		 242 l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size;
243 l_ptr->stats.queue_sz_counts++;
244
b97bf3fd
PL		 245 if (l_ptr->first_out) {
246 struct tipc_msg *msg = buf_msg(l_ptr->first_out);
247 u32 length = msg_size(msg);
248
f64f9e71
JP		 249 if ((msg_user(msg) == MSG_FRAGMENTER) &&
250 (msg_type(msg) == FIRST_FRAGMENT)) {
b97bf3fd
PL		 251 length = msg_size(msg_get_wrapped(msg));
252 }
253 if (length) {
254 l_ptr->stats.msg_lengths_total += length;
255 l_ptr->stats.msg_length_counts++;
256 if (length <= 64)
257 l_ptr->stats.msg_length_profile[0]++;
258 else if (length <= 256)
259 l_ptr->stats.msg_length_profile[1]++;
260 else if (length <= 1024)
261 l_ptr->stats.msg_length_profile[2]++;
262 else if (length <= 4096)
263 l_ptr->stats.msg_length_profile[3]++;
264 else if (length <= 16384)
265 l_ptr->stats.msg_length_profile[4]++;
266 else if (length <= 32768)
267 l_ptr->stats.msg_length_profile[5]++;
268 else
269 l_ptr->stats.msg_length_profile[6]++;
270 }
271 }
272
273 /* do all other link processing performed on a periodic basis */
b97bf3fd
PL		 274 link_check_defragm_bufs(l_ptr);
275
276 link_state_event(l_ptr, TIMEOUT_EVT);
277
278 if (l_ptr->next_out)
4323add6 279 tipc_link_push_queue(l_ptr);
b97bf3fd 280
4323add6 281 tipc_node_unlock(l_ptr->owner);
b97bf3fd
PL		 282}
283
a18c4bc3 284static void link_set_timer(struct tipc_link *l_ptr, u32 time)
b97bf3fd
PL		 285{
286 k_start_timer(&l_ptr->timer, time);
287}
288
289/**
4323add6 290 * tipc_link_create - create a new link
37b9c08a 291 * @n_ptr: pointer to associated node
b97bf3fd 292 * @b_ptr: pointer to associated bearer
b97bf3fd 293 * @media_addr: media address to use when sending messages over link
c4307285 294 *
b97bf3fd
PL		 295 * Returns pointer to link.
296 */
a18c4bc3 297struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
37b9c08a 298 struct tipc_bearer *b_ptr,
4323add6 299 const struct tipc_media_addr *media_addr)
b97bf3fd 300{
a18c4bc3 301 struct tipc_link *l_ptr;
b97bf3fd
PL		 302 struct tipc_msg *msg;
303 char *if_name;
37b9c08a
AS		 304 char addr_string[16];
305 u32 peer = n_ptr->addr;
306
307 if (n_ptr->link_cnt >= 2) {
308 tipc_addr_string_fill(addr_string, n_ptr->addr);
2cf8aa19 309 pr_err("Attempt to establish third link to %s\n", addr_string);
37b9c08a
AS		 310 return NULL;
311 }
312
313 if (n_ptr->links[b_ptr->identity]) {
314 tipc_addr_string_fill(addr_string, n_ptr->addr);
2cf8aa19
EH		 315 pr_err("Attempt to establish second link on <%s> to %s\n",
316 b_ptr->name, addr_string);
37b9c08a
AS		 317 return NULL;
318 }
b97bf3fd 319
0da974f4 320 l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC);
b97bf3fd 321 if (!l_ptr) {
2cf8aa19 322 pr_warn("Link creation failed, no memory\n");
b97bf3fd
PL		 323 return NULL;
324 }
b97bf3fd
PL		 325
326 l_ptr->addr = peer;
2d627b92 327 if_name = strchr(b_ptr->name, ':') + 1;
062b4c99 328 sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
b97bf3fd 329 tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
c4307285 330 tipc_node(tipc_own_addr),
b97bf3fd
PL		 331 if_name,
332 tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
062b4c99 333 /* note: peer i/f name is updated by reset/activate message */
b97bf3fd 334 memcpy(&l_ptr->media_addr, media_addr, sizeof(*media_addr));
37b9c08a 335 l_ptr->owner = n_ptr;
b97bf3fd 336 l_ptr->checkpoint = 1;
f882cb76 337 l_ptr->peer_session = INVALID_SESSION;
b97bf3fd 338 l_ptr->b_ptr = b_ptr;
5c216e1d 339 link_set_supervision_props(l_ptr, b_ptr->tolerance);
b97bf3fd
PL		 340 l_ptr->state = RESET_UNKNOWN;
341
342 l_ptr->pmsg = (struct tipc_msg *)&l_ptr->proto_msg;
343 msg = l_ptr->pmsg;
c68ca7b7 344 tipc_msg_init(msg, LINK_PROTOCOL, RESET_MSG, INT_H_SIZE, l_ptr->addr);
b97bf3fd 345 msg_set_size(msg, sizeof(l_ptr->proto_msg));
a686e685 346 msg_set_session(msg, (tipc_random & 0xffff));
b97bf3fd
PL		 347 msg_set_bearer_id(msg, b_ptr->identity);
348 strcpy((char *)msg_data(msg), if_name);
349
350 l_ptr->priority = b_ptr->priority;
5c216e1d 351 tipc_link_set_queue_limits(l_ptr, b_ptr->window);
b97bf3fd
PL		 352
353 link_init_max_pkt(l_ptr);
354
355 l_ptr->next_out_no = 1;
356 INIT_LIST_HEAD(&l_ptr->waiting_ports);
357
358 link_reset_statistics(l_ptr);
359
37b9c08a 360 tipc_node_attach_link(n_ptr, l_ptr);
b97bf3fd 361
94571065
FW		 362 k_init_timer(&l_ptr->timer, (Handler)link_timeout, (unsigned long)l_ptr);
363 list_add_tail(&l_ptr->link_list, &b_ptr->links);
31e3c3f6 364 tipc_k_signal((Handler)link_start, (unsigned long)l_ptr);
b97bf3fd 365
b97bf3fd
PL		 366 return l_ptr;
367}
368
c4307285 369/**
4323add6 370 * tipc_link_delete - delete a link
b97bf3fd 371 * @l_ptr: pointer to link
c4307285 372 *
4323add6 373 * Note: 'tipc_net_lock' is write_locked, bearer is locked.
b97bf3fd 374 * This routine must not grab the node lock until after link timer cancellation
c4307285 375 * to avoid a potential deadlock situation.
b97bf3fd 376 */
a18c4bc3 377void tipc_link_delete(struct tipc_link *l_ptr)
b97bf3fd
PL		 378{
379 if (!l_ptr) {
2cf8aa19 380 pr_err("Attempt to delete non-existent link\n");
b97bf3fd
PL		 381 return;
382 }
383
b97bf3fd 384 k_cancel_timer(&l_ptr->timer);
c4307285 385
4323add6
PL		 386 tipc_node_lock(l_ptr->owner);
387 tipc_link_reset(l_ptr);
388 tipc_node_detach_link(l_ptr->owner, l_ptr);
389 tipc_link_stop(l_ptr);
b97bf3fd 390 list_del_init(&l_ptr->link_list);
4323add6 391 tipc_node_unlock(l_ptr->owner);
b97bf3fd
PL		 392 k_term_timer(&l_ptr->timer);
393 kfree(l_ptr);
394}
395
a18c4bc3 396static void link_start(struct tipc_link *l_ptr)
b97bf3fd 397{
214dda4a 398 tipc_node_lock(l_ptr->owner);
b97bf3fd 399 link_state_event(l_ptr, STARTING_EVT);
214dda4a 400 tipc_node_unlock(l_ptr->owner);
b97bf3fd
PL		 401}
402
403/**
c4307285 404 * link_schedule_port - schedule port for deferred sending
b97bf3fd
PL		 405 * @l_ptr: pointer to link
406 * @origport: reference to sending port
407 * @sz: amount of data to be sent
c4307285
YH		 408 *
409 * Schedules port for renewed sending of messages after link congestion
b97bf3fd
PL		 410 * has abated.
411 */
a18c4bc3 412static int link_schedule_port(struct tipc_link *l_ptr, u32 origport, u32 sz)
b97bf3fd 413{
23dd4cce 414 struct tipc_port *p_ptr;
b97bf3fd 415
4323add6
PL		 416 spin_lock_bh(&tipc_port_list_lock);
417 p_ptr = tipc_port_lock(origport);
b97bf3fd
PL		 418 if (p_ptr) {
419 if (!p_ptr->wakeup)
420 goto exit;
421 if (!list_empty(&p_ptr->wait_list))
422 goto exit;
23dd4cce 423 p_ptr->congested = 1;
15e979da 424 p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt);
b97bf3fd
PL		 425 list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports);
426 l_ptr->stats.link_congs++;
427exit:
4323add6 428 tipc_port_unlock(p_ptr);
b97bf3fd 429 }
4323add6 430 spin_unlock_bh(&tipc_port_list_lock);
b97bf3fd
PL		 431 return -ELINKCONG;
432}
433
a18c4bc3 434void tipc_link_wakeup_ports(struct tipc_link *l_ptr, int all)
b97bf3fd 435{
23dd4cce
AS		 436 struct tipc_port *p_ptr;
437 struct tipc_port *temp_p_ptr;
b97bf3fd
PL		 438 int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size;
439
440 if (all)
441 win = 100000;
442 if (win <= 0)
443 return;
4323add6 444 if (!spin_trylock_bh(&tipc_port_list_lock))
b97bf3fd
PL		 445 return;
446 if (link_congested(l_ptr))
447 goto exit;
c4307285 448 list_for_each_entry_safe(p_ptr, temp_p_ptr, &l_ptr->waiting_ports,
b97bf3fd
PL		 449 wait_list) {
450 if (win <= 0)
451 break;
452 list_del_init(&p_ptr->wait_list);
23dd4cce
AS		 453 spin_lock_bh(p_ptr->lock);
454 p_ptr->congested = 0;
455 p_ptr->wakeup(p_ptr);
b97bf3fd 456 win -= p_ptr->waiting_pkts;
23dd4cce 457 spin_unlock_bh(p_ptr->lock);
b97bf3fd
PL		 458 }
459
460exit:
4323add6 461 spin_unlock_bh(&tipc_port_list_lock);
b97bf3fd
PL		 462}
463
c4307285 464/**
b97bf3fd
PL		 465 * link_release_outqueue - purge link's outbound message queue
466 * @l_ptr: pointer to link
467 */
a18c4bc3 468static void link_release_outqueue(struct tipc_link *l_ptr)
b97bf3fd
PL		 469{
470 struct sk_buff *buf = l_ptr->first_out;
471 struct sk_buff *next;
472
473 while (buf) {
474 next = buf->next;
5f6d9123 475 kfree_skb(buf);
b97bf3fd
PL		 476 buf = next;
477 }
478 l_ptr->first_out = NULL;
479 l_ptr->out_queue_size = 0;
480}
481
482/**
4323add6 483 * tipc_link_reset_fragments - purge link's inbound message fragments queue
b97bf3fd
PL		 484 * @l_ptr: pointer to link
485 */
a18c4bc3 486void tipc_link_reset_fragments(struct tipc_link *l_ptr)
b97bf3fd
PL		 487{
488 struct sk_buff *buf = l_ptr->defragm_buf;
489 struct sk_buff *next;
490
491 while (buf) {
492 next = buf->next;
5f6d9123 493 kfree_skb(buf);
b97bf3fd
PL		 494 buf = next;
495 }
496 l_ptr->defragm_buf = NULL;
497}
498
c4307285 499/**
4323add6 500 * tipc_link_stop - purge all inbound and outbound messages associated with link
b97bf3fd
PL		 501 * @l_ptr: pointer to link
502 */
a18c4bc3 503void tipc_link_stop(struct tipc_link *l_ptr)
b97bf3fd
PL		 504{
505 struct sk_buff *buf;
506 struct sk_buff *next;
507
508 buf = l_ptr->oldest_deferred_in;
509 while (buf) {
510 next = buf->next;
5f6d9123 511 kfree_skb(buf);
b97bf3fd
PL		 512 buf = next;
513 }
514
515 buf = l_ptr->first_out;
516 while (buf) {
517 next = buf->next;
5f6d9123 518 kfree_skb(buf);
b97bf3fd
PL		 519 buf = next;
520 }
521
4323add6 522 tipc_link_reset_fragments(l_ptr);
b97bf3fd 523
5f6d9123 524 kfree_skb(l_ptr->proto_msg_queue);
b97bf3fd
PL		 525 l_ptr->proto_msg_queue = NULL;
526}
527
a18c4bc3 528void tipc_link_reset(struct tipc_link *l_ptr)
b97bf3fd
PL		 529{
530 struct sk_buff *buf;
531 u32 prev_state = l_ptr->state;
532 u32 checkpoint = l_ptr->next_in_no;
5392d646 533 int was_active_link = tipc_link_is_active(l_ptr);
c4307285 534
a686e685 535 msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff));
b97bf3fd 536
a686e685
AS		 537 /* Link is down, accept any session */
538 l_ptr->peer_session = INVALID_SESSION;
b97bf3fd 539
c4307285 540 /* Prepare for max packet size negotiation */
b97bf3fd 541 link_init_max_pkt(l_ptr);
c4307285 542
b97bf3fd 543 l_ptr->state = RESET_UNKNOWN;
b97bf3fd
PL		 544
545 if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))
546 return;
547
4323add6
PL		 548 tipc_node_link_down(l_ptr->owner, l_ptr);
549 tipc_bearer_remove_dest(l_ptr->b_ptr, l_ptr->addr);
7368ddf1 550
8f19afb2 551 if (was_active_link && tipc_node_active_links(l_ptr->owner) &&
b97bf3fd
PL		 552 l_ptr->owner->permit_changeover) {
553 l_ptr->reset_checkpoint = checkpoint;
554 l_ptr->exp_msg_count = START_CHANGEOVER;
555 }
556
557 /* Clean up all queues: */
b97bf3fd 558 link_release_outqueue(l_ptr);
5f6d9123 559 kfree_skb(l_ptr->proto_msg_queue);
b97bf3fd
PL		 560 l_ptr->proto_msg_queue = NULL;
561 buf = l_ptr->oldest_deferred_in;
562 while (buf) {
563 struct sk_buff *next = buf->next;
5f6d9123 564 kfree_skb(buf);
b97bf3fd
PL		 565 buf = next;
566 }
567 if (!list_empty(&l_ptr->waiting_ports))
4323add6 568 tipc_link_wakeup_ports(l_ptr, 1);
b97bf3fd
PL		 569
570 l_ptr->retransm_queue_head = 0;
571 l_ptr->retransm_queue_size = 0;
572 l_ptr->last_out = NULL;
573 l_ptr->first_out = NULL;
574 l_ptr->next_out = NULL;
575 l_ptr->unacked_window = 0;
576 l_ptr->checkpoint = 1;
577 l_ptr->next_out_no = 1;
578 l_ptr->deferred_inqueue_sz = 0;
579 l_ptr->oldest_deferred_in = NULL;
580 l_ptr->newest_deferred_in = NULL;
581 l_ptr->fsm_msg_cnt = 0;
582 l_ptr->stale_count = 0;
583 link_reset_statistics(l_ptr);
b97bf3fd
PL		 584}
585
586
a18c4bc3 587static void link_activate(struct tipc_link *l_ptr)
b97bf3fd 588{
5392d646 589 l_ptr->next_in_no = l_ptr->stats.recv_info = 1;
4323add6
PL		 590 tipc_node_link_up(l_ptr->owner, l_ptr);
591 tipc_bearer_add_dest(l_ptr->b_ptr, l_ptr->addr);
b97bf3fd
PL		 592}
593
594/**
595 * link_state_event - link finite state machine
596 * @l_ptr: pointer to link
597 * @event: state machine event to process
598 */
95c96174 599static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
b97bf3fd 600{
a18c4bc3 601 struct tipc_link *other;
b97bf3fd
PL		 602 u32 cont_intv = l_ptr->continuity_interval;
603
604 if (!l_ptr->started && (event != STARTING_EVT))
605 return; /* Not yet. */
606
607 if (link_blocked(l_ptr)) {
a016892c 608 if (event == TIMEOUT_EVT)
b97bf3fd 609 link_set_timer(l_ptr, cont_intv);
b97bf3fd
PL		 610 return; /* Changeover going on */
611 }
b97bf3fd
PL		 612
613 switch (l_ptr->state) {
614 case WORKING_WORKING:
b97bf3fd
PL		 615 switch (event) {
616 case TRAFFIC_MSG_EVT:
b97bf3fd 617 case ACTIVATE_MSG:
b97bf3fd
PL		 618 break;
619 case TIMEOUT_EVT:
b97bf3fd
PL		 620 if (l_ptr->next_in_no != l_ptr->checkpoint) {
621 l_ptr->checkpoint = l_ptr->next_in_no;
4323add6 622 if (tipc_bclink_acks_missing(l_ptr->owner)) {
c4307285 623 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
4323add6 624 0, 0, 0, 0, 0);
b97bf3fd
PL		 625 l_ptr->fsm_msg_cnt++;
626 } else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {
c4307285 627 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
4323add6 628 1, 0, 0, 0, 0);
b97bf3fd
PL		 629 l_ptr->fsm_msg_cnt++;
630 }
631 link_set_timer(l_ptr, cont_intv);
632 break;
633 }
b97bf3fd
PL		 634 l_ptr->state = WORKING_UNKNOWN;
635 l_ptr->fsm_msg_cnt = 0;
4323add6 636 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
b97bf3fd
PL		 637 l_ptr->fsm_msg_cnt++;
638 link_set_timer(l_ptr, cont_intv / 4);
639 break;
640 case RESET_MSG:
2cf8aa19
EH		 641 pr_info("%s<%s>, requested by peer\n", link_rst_msg,
642 l_ptr->name);
4323add6 643 tipc_link_reset(l_ptr);
b97bf3fd
PL		 644 l_ptr->state = RESET_RESET;
645 l_ptr->fsm_msg_cnt = 0;
4323add6 646 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
b97bf3fd
PL		 647 l_ptr->fsm_msg_cnt++;
648 link_set_timer(l_ptr, cont_intv);
649 break;
650 default:
2cf8aa19 651 pr_err("%s%u in WW state\n", link_unk_evt, event);
b97bf3fd
PL		 652 }
653 break;
654 case WORKING_UNKNOWN:
b97bf3fd
PL		 655 switch (event) {
656 case TRAFFIC_MSG_EVT:
b97bf3fd 657 case ACTIVATE_MSG:
b97bf3fd
PL		 658 l_ptr->state = WORKING_WORKING;
659 l_ptr->fsm_msg_cnt = 0;
660 link_set_timer(l_ptr, cont_intv);
661 break;
662 case RESET_MSG:
2cf8aa19
EH		 663 pr_info("%s<%s>, requested by peer while probing\n",
664 link_rst_msg, l_ptr->name);
4323add6 665 tipc_link_reset(l_ptr);
b97bf3fd
PL		 666 l_ptr->state = RESET_RESET;
667 l_ptr->fsm_msg_cnt = 0;
4323add6 668 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
b97bf3fd
PL		 669 l_ptr->fsm_msg_cnt++;
670 link_set_timer(l_ptr, cont_intv);
671 break;
672 case TIMEOUT_EVT:
b97bf3fd 673 if (l_ptr->next_in_no != l_ptr->checkpoint) {
b97bf3fd
PL		 674 l_ptr->state = WORKING_WORKING;
675 l_ptr->fsm_msg_cnt = 0;
676 l_ptr->checkpoint = l_ptr->next_in_no;
4323add6
PL		 677 if (tipc_bclink_acks_missing(l_ptr->owner)) {
678 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
679 0, 0, 0, 0, 0);
b97bf3fd
PL		 680 l_ptr->fsm_msg_cnt++;
681 }
682 link_set_timer(l_ptr, cont_intv);
683 } else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {
c4307285 684 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
4323add6 685 1, 0, 0, 0, 0);
b97bf3fd
PL		 686 l_ptr->fsm_msg_cnt++;
687 link_set_timer(l_ptr, cont_intv / 4);
688 } else { /* Link has failed */
2cf8aa19
EH		 689 pr_warn("%s<%s>, peer not responding\n",
690 link_rst_msg, l_ptr->name);
4323add6 691 tipc_link_reset(l_ptr);
b97bf3fd
PL		 692 l_ptr->state = RESET_UNKNOWN;
693 l_ptr->fsm_msg_cnt = 0;
4323add6
PL		 694 tipc_link_send_proto_msg(l_ptr, RESET_MSG,
695 0, 0, 0, 0, 0);
b97bf3fd
PL		 696 l_ptr->fsm_msg_cnt++;
697 link_set_timer(l_ptr, cont_intv);
698 }
699 break;
700 default:
2cf8aa19 701 pr_err("%s%u in WU state\n", link_unk_evt, event);
b97bf3fd
PL		 702 }
703 break;
704 case RESET_UNKNOWN:
b97bf3fd
PL		 705 switch (event) {
706 case TRAFFIC_MSG_EVT:
b97bf3fd
PL		 707 break;
708 case ACTIVATE_MSG:
709 other = l_ptr->owner->active_links[0];
8d64a5ba 710 if (other && link_working_unknown(other))
b97bf3fd 711 break;
b97bf3fd
PL		 712 l_ptr->state = WORKING_WORKING;
713 l_ptr->fsm_msg_cnt = 0;
714 link_activate(l_ptr);
4323add6 715 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
b97bf3fd
PL		 716 l_ptr->fsm_msg_cnt++;
717 link_set_timer(l_ptr, cont_intv);
718 break;
719 case RESET_MSG:
b97bf3fd
PL		 720 l_ptr->state = RESET_RESET;
721 l_ptr->fsm_msg_cnt = 0;
4323add6 722 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 1, 0, 0, 0, 0);
b97bf3fd
PL		 723 l_ptr->fsm_msg_cnt++;
724 link_set_timer(l_ptr, cont_intv);
725 break;
726 case STARTING_EVT:
b97bf3fd
PL		 727 l_ptr->started = 1;
728 /* fall through */
729 case TIMEOUT_EVT:
4323add6 730 tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
b97bf3fd
PL		 731 l_ptr->fsm_msg_cnt++;
732 link_set_timer(l_ptr, cont_intv);
733 break;
734 default:
2cf8aa19 735 pr_err("%s%u in RU state\n", link_unk_evt, event);
b97bf3fd
PL		 736 }
737 break;
738 case RESET_RESET:
b97bf3fd
PL		 739 switch (event) {
740 case TRAFFIC_MSG_EVT:
b97bf3fd
PL		 741 case ACTIVATE_MSG:
742 other = l_ptr->owner->active_links[0];
8d64a5ba 743 if (other && link_working_unknown(other))
b97bf3fd 744 break;
b97bf3fd
PL		 745 l_ptr->state = WORKING_WORKING;
746 l_ptr->fsm_msg_cnt = 0;
747 link_activate(l_ptr);
4323add6 748 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
b97bf3fd
PL		 749 l_ptr->fsm_msg_cnt++;
750 link_set_timer(l_ptr, cont_intv);
751 break;
752 case RESET_MSG:
b97bf3fd
PL		 753 break;
754 case TIMEOUT_EVT:
4323add6 755 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
b97bf3fd
PL		 756 l_ptr->fsm_msg_cnt++;
757 link_set_timer(l_ptr, cont_intv);
b97bf3fd
PL		 758 break;
759 default:
2cf8aa19 760 pr_err("%s%u in RR state\n", link_unk_evt, event);
b97bf3fd
PL		 761 }
762 break;
763 default:
2cf8aa19 764 pr_err("Unknown link state %u/%u\n", l_ptr->state, event);
b97bf3fd
PL		 765 }
766}
767
768/*
769 * link_bundle_buf(): Append contents of a buffer to
c4307285 770 * the tail of an existing one.
b97bf3fd 771 */
a18c4bc3 772static int link_bundle_buf(struct tipc_link *l_ptr,
c4307285 773 struct sk_buff *bundler,
b97bf3fd
PL		 774 struct sk_buff *buf)
775{
776 struct tipc_msg *bundler_msg = buf_msg(bundler);
777 struct tipc_msg *msg = buf_msg(buf);
778 u32 size = msg_size(msg);
e49060c7
AS		 779 u32 bundle_size = msg_size(bundler_msg);
780 u32 to_pos = align(bundle_size);
781 u32 pad = to_pos - bundle_size;
b97bf3fd
PL		 782
783 if (msg_user(bundler_msg) != MSG_BUNDLER)
784 return 0;
785 if (msg_type(bundler_msg) != OPEN_MSG)
786 return 0;
e49060c7 787 if (skb_tailroom(bundler) < (pad + size))
b97bf3fd 788 return 0;
15e979da 789 if (l_ptr->max_pkt < (to_pos + size))
863fae66 790 return 0;
b97bf3fd 791
e49060c7 792 skb_put(bundler, pad + size);
27d7ff46 793 skb_copy_to_linear_data_offset(bundler, to_pos, buf->data, size);
b97bf3fd
PL		 794 msg_set_size(bundler_msg, to_pos + size);
795 msg_set_msgcnt(bundler_msg, msg_msgcnt(bundler_msg) + 1);
5f6d9123 796 kfree_skb(buf);
b97bf3fd
PL		 797 l_ptr->stats.sent_bundled++;
798 return 1;
799}
800
a18c4bc3 801static void link_add_to_outqueue(struct tipc_link *l_ptr,
05790c64
SR		 802 struct sk_buff *buf,
803 struct tipc_msg *msg)
b97bf3fd
PL		 804{
805 u32 ack = mod(l_ptr->next_in_no - 1);
806 u32 seqno = mod(l_ptr->next_out_no++);
807
808 msg_set_word(msg, 2, ((ack << 16) | seqno));
809 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
810 buf->next = NULL;
811 if (l_ptr->first_out) {
812 l_ptr->last_out->next = buf;
813 l_ptr->last_out = buf;
814 } else
815 l_ptr->first_out = l_ptr->last_out = buf;
9bd80b60 816
b97bf3fd 817 l_ptr->out_queue_size++;
9bd80b60
AS		 818 if (l_ptr->out_queue_size > l_ptr->stats.max_queue_sz)
819 l_ptr->stats.max_queue_sz = l_ptr->out_queue_size;
b97bf3fd
PL		 820}
821
a18c4bc3 822static void link_add_chain_to_outqueue(struct tipc_link *l_ptr,
dc63d91e
AS		 823 struct sk_buff *buf_chain,
824 u32 long_msgno)
825{
826 struct sk_buff *buf;
827 struct tipc_msg *msg;
828
829 if (!l_ptr->next_out)
830 l_ptr->next_out = buf_chain;
831 while (buf_chain) {
832 buf = buf_chain;
833 buf_chain = buf_chain->next;
834
835 msg = buf_msg(buf);
836 msg_set_long_msgno(msg, long_msgno);
837 link_add_to_outqueue(l_ptr, buf, msg);
838 }
839}
840
c4307285
YH		 841/*
842 * tipc_link_send_buf() is the 'full path' for messages, called from
b97bf3fd
PL		 843 * inside TIPC when the 'fast path' in tipc_send_buf
844 * has failed, and from link_send()
845 */
a18c4bc3 846int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
b97bf3fd
PL		 847{
848 struct tipc_msg *msg = buf_msg(buf);
849 u32 size = msg_size(msg);
850 u32 dsz = msg_data_sz(msg);
851 u32 queue_size = l_ptr->out_queue_size;
c68ca7b7 852 u32 imp = tipc_msg_tot_importance(msg);
b97bf3fd 853 u32 queue_limit = l_ptr->queue_limit[imp];
15e979da 854 u32 max_packet = l_ptr->max_pkt;
b97bf3fd 855
b97bf3fd 856 /* Match msg importance against queue limits: */
b97bf3fd
PL		 857 if (unlikely(queue_size >= queue_limit)) {
858 if (imp <= TIPC_CRITICAL_IMPORTANCE) {
bebc55ae 859 link_schedule_port(l_ptr, msg_origport(msg), size);
5f6d9123 860 kfree_skb(buf);
bebc55ae 861 return -ELINKCONG;
b97bf3fd 862 }
5f6d9123 863 kfree_skb(buf);
b97bf3fd 864 if (imp > CONN_MANAGER) {
2cf8aa19
EH		 865 pr_warn("%s<%s>, send queue full", link_rst_msg,
866 l_ptr->name);
4323add6 867 tipc_link_reset(l_ptr);
b97bf3fd
PL		 868 }
869 return dsz;
870 }
871
872 /* Fragmentation needed ? */
b97bf3fd 873 if (size > max_packet)
31e3c3f6 874 return link_send_long_buf(l_ptr, buf);
b97bf3fd 875
617d3c7a 876 /* Packet can be queued or sent. */
c4307285 877 if (likely(!tipc_bearer_congested(l_ptr->b_ptr, l_ptr) &&
b97bf3fd
PL		 878 !link_congested(l_ptr))) {
879 link_add_to_outqueue(l_ptr, buf, msg);
880
4323add6 881 if (likely(tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr))) {
b97bf3fd
PL		 882 l_ptr->unacked_window = 0;
883 } else {
4323add6 884 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
b97bf3fd
PL		 885 l_ptr->stats.bearer_congs++;
886 l_ptr->next_out = buf;
887 }
888 return dsz;
889 }
617d3c7a 890 /* Congestion: can message be bundled ? */
b97bf3fd
PL		 891 if ((msg_user(msg) != CHANGEOVER_PROTOCOL) &&
892 (msg_user(msg) != MSG_FRAGMENTER)) {
893
894 /* Try adding message to an existing bundle */
c4307285 895 if (l_ptr->next_out &&
b97bf3fd 896 link_bundle_buf(l_ptr, l_ptr->last_out, buf)) {
4323add6 897 tipc_bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
b97bf3fd
PL		 898 return dsz;
899 }
900
901 /* Try creating a new bundle */
b97bf3fd 902 if (size <= max_packet * 2 / 3) {
31e3c3f6 903 struct sk_buff *bundler = tipc_buf_acquire(max_packet);
b97bf3fd
PL		 904 struct tipc_msg bundler_hdr;
905
906 if (bundler) {
c68ca7b7 907 tipc_msg_init(&bundler_hdr, MSG_BUNDLER, OPEN_MSG,
75715217 908 INT_H_SIZE, l_ptr->addr);
27d7ff46
ACM		 909 skb_copy_to_linear_data(bundler, &bundler_hdr,
910 INT_H_SIZE);
b97bf3fd
PL		 911 skb_trim(bundler, INT_H_SIZE);
912 link_bundle_buf(l_ptr, bundler, buf);
913 buf = bundler;
914 msg = buf_msg(buf);
915 l_ptr->stats.sent_bundles++;
916 }
917 }
918 }
919 if (!l_ptr->next_out)
920 l_ptr->next_out = buf;
921 link_add_to_outqueue(l_ptr, buf, msg);
4323add6 922 tipc_bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
b97bf3fd
PL		 923 return dsz;
924}
925
c4307285
YH		 926/*
927 * tipc_link_send(): same as tipc_link_send_buf(), but the link to use has
b97bf3fd
PL		 928 * not been selected yet, and the the owner node is not locked
929 * Called by TIPC internal users, e.g. the name distributor
930 */
4323add6 931int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector)
b97bf3fd 932{
a18c4bc3 933 struct tipc_link *l_ptr;
6c00055a 934 struct tipc_node *n_ptr;
b97bf3fd
PL		 935 int res = -ELINKCONG;
936
4323add6 937 read_lock_bh(&tipc_net_lock);
51a8e4de 938 n_ptr = tipc_node_find(dest);
b97bf3fd 939 if (n_ptr) {
4323add6 940 tipc_node_lock(n_ptr);
b97bf3fd 941 l_ptr = n_ptr->active_links[selector & 1];
a016892c 942 if (l_ptr)
4323add6 943 res = tipc_link_send_buf(l_ptr, buf);
a016892c 944 else
5f6d9123 945 kfree_skb(buf);
4323add6 946 tipc_node_unlock(n_ptr);
b97bf3fd 947 } else {
5f6d9123 948 kfree_skb(buf);
b97bf3fd 949 }
4323add6 950 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 951 return res;
952}
953
2c53040f 954/**
9aa88c2a
AS		 955 * tipc_link_send_names - send name table entries to new neighbor
956 *
957 * Send routine for bulk delivery of name table messages when contact
958 * with a new neighbor occurs. No link congestion checking is performed
959 * because name table messages *must* be delivered. The messages must be
960 * small enough not to require fragmentation.
961 * Called without any locks held.
962 */
9aa88c2a
AS		 963void tipc_link_send_names(struct list_head *message_list, u32 dest)
964{
965 struct tipc_node *n_ptr;
a18c4bc3 966 struct tipc_link *l_ptr;
9aa88c2a
AS		 967 struct sk_buff *buf;
968 struct sk_buff *temp_buf;
969
970 if (list_empty(message_list))
971 return;
972
973 read_lock_bh(&tipc_net_lock);
974 n_ptr = tipc_node_find(dest);
975 if (n_ptr) {
976 tipc_node_lock(n_ptr);
977 l_ptr = n_ptr->active_links[0];
978 if (l_ptr) {
979 /* convert circular list to linear list */
980 ((struct sk_buff *)message_list->prev)->next = NULL;
981 link_add_chain_to_outqueue(l_ptr,
982 (struct sk_buff *)message_list->next, 0);
983 tipc_link_push_queue(l_ptr);
984 INIT_LIST_HEAD(message_list);
985 }
986 tipc_node_unlock(n_ptr);
987 }
988 read_unlock_bh(&tipc_net_lock);
989
990 /* discard the messages if they couldn't be sent */
9aa88c2a
AS		 991 list_for_each_safe(buf, temp_buf, ((struct sk_buff *)message_list)) {
992 list_del((struct list_head *)buf);
5f6d9123 993 kfree_skb(buf);
9aa88c2a
AS		 994 }
995}
996
c4307285
YH		 997/*
998 * link_send_buf_fast: Entry for data messages where the
b97bf3fd
PL		 999 * destination link is known and the header is complete,
1000 * inclusive total message length. Very time critical.
1001 * Link is locked. Returns user data length.
1002 */
a18c4bc3 1003static int link_send_buf_fast(struct tipc_link *l_ptr, struct sk_buff *buf,
05790c64 1004 u32 *used_max_pkt)
b97bf3fd
PL		 1005{
1006 struct tipc_msg *msg = buf_msg(buf);
1007 int res = msg_data_sz(msg);
1008
1009 if (likely(!link_congested(l_ptr))) {
15e979da 1010 if (likely(msg_size(msg) <= l_ptr->max_pkt)) {
b97bf3fd
PL		 1011 if (likely(list_empty(&l_ptr->b_ptr->cong_links))) {
1012 link_add_to_outqueue(l_ptr, buf, msg);
4323add6
PL		 1013 if (likely(tipc_bearer_send(l_ptr->b_ptr, buf,
1014 &l_ptr->media_addr))) {
b97bf3fd 1015 l_ptr->unacked_window = 0;
b97bf3fd
PL		 1016 return res;
1017 }
4323add6 1018 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
b97bf3fd
PL		 1019 l_ptr->stats.bearer_congs++;
1020 l_ptr->next_out = buf;
1021 return res;
1022 }
0e65967e 1023 } else
15e979da 1024 *used_max_pkt = l_ptr->max_pkt;
b97bf3fd 1025 }
4323add6 1026 return tipc_link_send_buf(l_ptr, buf); /* All other cases */
b97bf3fd
PL		 1027}
1028
c4307285
YH		 1029/*
1030 * tipc_send_buf_fast: Entry for data messages where the
b97bf3fd
PL		 1031 * destination node is known and the header is complete,
1032 * inclusive total message length.
1033 * Returns user data length.
1034 */
1035int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode)
1036{
a18c4bc3 1037 struct tipc_link *l_ptr;
6c00055a 1038 struct tipc_node *n_ptr;
b97bf3fd
PL		 1039 int res;
1040 u32 selector = msg_origport(buf_msg(buf)) & 1;
1041 u32 dummy;
1042
4323add6 1043 read_lock_bh(&tipc_net_lock);
51a8e4de 1044 n_ptr = tipc_node_find(destnode);
b97bf3fd 1045 if (likely(n_ptr)) {
4323add6 1046 tipc_node_lock(n_ptr);
b97bf3fd 1047 l_ptr = n_ptr->active_links[selector];
b97bf3fd
PL		 1048 if (likely(l_ptr)) {
1049 res = link_send_buf_fast(l_ptr, buf, &dummy);
4323add6
PL		 1050 tipc_node_unlock(n_ptr);
1051 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 1052 return res;
1053 }
4323add6 1054 tipc_node_unlock(n_ptr);
b97bf3fd 1055 }
4323add6 1056 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 1057 res = msg_data_sz(buf_msg(buf));
1058 tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
1059 return res;
1060}
1061
1062
c4307285
YH		 1063/*
1064 * tipc_link_send_sections_fast: Entry for messages where the
b97bf3fd 1065 * destination processor is known and the header is complete,
c4307285 1066 * except for total message length.
b97bf3fd
PL		 1067 * Returns user data length or errno.
1068 */
23dd4cce 1069int tipc_link_send_sections_fast(struct tipc_port *sender,
4323add6 1070 struct iovec const *msg_sect,
c4307285 1071 const u32 num_sect,
26896904 1072 unsigned int total_len,
4323add6 1073 u32 destaddr)
b97bf3fd 1074{
23dd4cce 1075 struct tipc_msg *hdr = &sender->phdr;
a18c4bc3 1076 struct tipc_link *l_ptr;
b97bf3fd 1077 struct sk_buff *buf;
6c00055a 1078 struct tipc_node *node;
b97bf3fd
PL		 1079 int res;
1080 u32 selector = msg_origport(hdr) & 1;
1081
b97bf3fd
PL		 1082again:
1083 /*
1084 * Try building message using port's max_pkt hint.
1085 * (Must not hold any locks while building message.)
1086 */
26896904
AS		 1087 res = tipc_msg_build(hdr, msg_sect, num_sect, total_len,
1088 sender->max_pkt, !sender->user_port, &buf);
b97bf3fd 1089
4323add6 1090 read_lock_bh(&tipc_net_lock);
51a8e4de 1091 node = tipc_node_find(destaddr);
b97bf3fd 1092 if (likely(node)) {
4323add6 1093 tipc_node_lock(node);
b97bf3fd
PL		 1094 l_ptr = node->active_links[selector];
1095 if (likely(l_ptr)) {
1096 if (likely(buf)) {
1097 res = link_send_buf_fast(l_ptr, buf,
23dd4cce 1098 &sender->max_pkt);
b97bf3fd 1099exit:
4323add6
PL		 1100 tipc_node_unlock(node);
1101 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 1102 return res;
1103 }
1104
1105 /* Exit if build request was invalid */
b97bf3fd
PL		 1106 if (unlikely(res < 0))
1107 goto exit;
1108
1109 /* Exit if link (or bearer) is congested */
c4307285 1110 if (link_congested(l_ptr) ||
b97bf3fd
PL		 1111 !list_empty(&l_ptr->b_ptr->cong_links)) {
1112 res = link_schedule_port(l_ptr,
23dd4cce 1113 sender->ref, res);
b97bf3fd
PL		 1114 goto exit;
1115 }
1116
c4307285 1117 /*
b97bf3fd
PL		 1118 * Message size exceeds max_pkt hint; update hint,
1119 * then re-try fast path or fragment the message
1120 */
23dd4cce 1121 sender->max_pkt = l_ptr->max_pkt;
4323add6
PL		 1122 tipc_node_unlock(node);
1123 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 1124
1125
23dd4cce 1126 if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)
b97bf3fd
PL		 1127 goto again;
1128
1129 return link_send_sections_long(sender, msg_sect,
26896904
AS		 1130 num_sect, total_len,
1131 destaddr);
b97bf3fd 1132 }
4323add6 1133 tipc_node_unlock(node);
b97bf3fd 1134 }
4323add6 1135 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 1136
1137 /* Couldn't find a link to the destination node */
b97bf3fd
PL		 1138 if (buf)
1139 return tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
1140 if (res >= 0)
4323add6 1141 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
26896904 1142 total_len, TIPC_ERR_NO_NODE);
b97bf3fd
PL		 1143 return res;
1144}
1145
c4307285
YH		 1146/*
1147 * link_send_sections_long(): Entry for long messages where the
b97bf3fd 1148 * destination node is known and the header is complete,
c4307285 1149 * inclusive total message length.
b97bf3fd
PL		 1150 * Link and bearer congestion status have been checked to be ok,
1151 * and are ignored if they change.
1152 *
1153 * Note that fragments do not use the full link MTU so that they won't have
1154 * to undergo refragmentation if link changeover causes them to be sent
1155 * over another link with an additional tunnel header added as prefix.
1156 * (Refragmentation will still occur if the other link has a smaller MTU.)
1157 *
1158 * Returns user data length or errno.
1159 */
23dd4cce 1160static int link_send_sections_long(struct tipc_port *sender,
b97bf3fd
PL		 1161 struct iovec const *msg_sect,
1162 u32 num_sect,
26896904 1163 unsigned int total_len,
b97bf3fd
PL		 1164 u32 destaddr)
1165{
a18c4bc3 1166 struct tipc_link *l_ptr;
6c00055a 1167 struct tipc_node *node;
23dd4cce 1168 struct tipc_msg *hdr = &sender->phdr;
26896904 1169 u32 dsz = total_len;
0e65967e 1170 u32 max_pkt, fragm_sz, rest;
b97bf3fd 1171 struct tipc_msg fragm_hdr;
0e65967e
AS		 1172 struct sk_buff *buf, *buf_chain, *prev;
1173 u32 fragm_crs, fragm_rest, hsz, sect_rest;
b97bf3fd
PL		 1174 const unchar *sect_crs;
1175 int curr_sect;
1176 u32 fragm_no;
1177
1178again:
1179 fragm_no = 1;
23dd4cce 1180 max_pkt = sender->max_pkt - INT_H_SIZE;
b97bf3fd 1181 /* leave room for tunnel header in case of link changeover */
c4307285 1182 fragm_sz = max_pkt - INT_H_SIZE;
b97bf3fd
PL		 1183 /* leave room for fragmentation header in each fragment */
1184 rest = dsz;
1185 fragm_crs = 0;
1186 fragm_rest = 0;
1187 sect_rest = 0;
1fc54d8f 1188 sect_crs = NULL;
b97bf3fd
PL		 1189 curr_sect = -1;
1190
617d3c7a 1191 /* Prepare reusable fragment header */
c68ca7b7 1192 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
75715217 1193 INT_H_SIZE, msg_destnode(hdr));
b97bf3fd
PL		 1194 msg_set_size(&fragm_hdr, max_pkt);
1195 msg_set_fragm_no(&fragm_hdr, 1);
1196
617d3c7a 1197 /* Prepare header of first fragment */
31e3c3f6 1198 buf_chain = buf = tipc_buf_acquire(max_pkt);
b97bf3fd
PL		 1199 if (!buf)
1200 return -ENOMEM;
1201 buf->next = NULL;
27d7ff46 1202 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
b97bf3fd 1203 hsz = msg_hdr_sz(hdr);
27d7ff46 1204 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, hdr, hsz);
b97bf3fd 1205
617d3c7a 1206 /* Chop up message */
b97bf3fd
PL		 1207 fragm_crs = INT_H_SIZE + hsz;
1208 fragm_rest = fragm_sz - hsz;
1209
1210 do { /* For all sections */
1211 u32 sz;
1212
1213 if (!sect_rest) {
1214 sect_rest = msg_sect[++curr_sect].iov_len;
1215 sect_crs = (const unchar *)msg_sect[curr_sect].iov_base;
1216 }
1217
1218 if (sect_rest < fragm_rest)
1219 sz = sect_rest;
1220 else
1221 sz = fragm_rest;
1222
1223 if (likely(!sender->user_port)) {
1224 if (copy_from_user(buf->data + fragm_crs, sect_crs, sz)) {
1225error:
1226 for (; buf_chain; buf_chain = buf) {
1227 buf = buf_chain->next;
5f6d9123 1228 kfree_skb(buf_chain);
b97bf3fd
PL		 1229 }
1230 return -EFAULT;
1231 }
1232 } else
27d7ff46
ACM		 1233 skb_copy_to_linear_data_offset(buf, fragm_crs,
1234 sect_crs, sz);
b97bf3fd
PL		 1235 sect_crs += sz;
1236 sect_rest -= sz;
1237 fragm_crs += sz;
1238 fragm_rest -= sz;
1239 rest -= sz;
1240
1241 if (!fragm_rest && rest) {
1242
1243 /* Initiate new fragment: */
1244 if (rest <= fragm_sz) {
1245 fragm_sz = rest;
0e65967e 1246 msg_set_type(&fragm_hdr, LAST_FRAGMENT);
b97bf3fd
PL		 1247 } else {
1248 msg_set_type(&fragm_hdr, FRAGMENT);
1249 }
1250 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
1251 msg_set_fragm_no(&fragm_hdr, ++fragm_no);
1252 prev = buf;
31e3c3f6 1253 buf = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
b97bf3fd
PL		 1254 if (!buf)
1255 goto error;
1256
c4307285 1257 buf->next = NULL;
b97bf3fd 1258 prev->next = buf;
27d7ff46 1259 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
b97bf3fd
PL		 1260 fragm_crs = INT_H_SIZE;
1261 fragm_rest = fragm_sz;
b97bf3fd 1262 }
0e65967e 1263 } while (rest > 0);
b97bf3fd 1264
c4307285 1265 /*
b97bf3fd
PL		 1266 * Now we have a buffer chain. Select a link and check
1267 * that packet size is still OK
1268 */
51a8e4de 1269 node = tipc_node_find(destaddr);
b97bf3fd 1270 if (likely(node)) {
4323add6 1271 tipc_node_lock(node);
23dd4cce 1272 l_ptr = node->active_links[sender->ref & 1];
b97bf3fd 1273 if (!l_ptr) {
4323add6 1274 tipc_node_unlock(node);
b97bf3fd
PL		 1275 goto reject;
1276 }
15e979da 1277 if (l_ptr->max_pkt < max_pkt) {
23dd4cce 1278 sender->max_pkt = l_ptr->max_pkt;
4323add6 1279 tipc_node_unlock(node);
b97bf3fd
PL		 1280 for (; buf_chain; buf_chain = buf) {
1281 buf = buf_chain->next;
5f6d9123 1282 kfree_skb(buf_chain);
b97bf3fd
PL		 1283 }
1284 goto again;
1285 }
1286 } else {
1287reject:
1288 for (; buf_chain; buf_chain = buf) {
1289 buf = buf_chain->next;
5f6d9123 1290 kfree_skb(buf_chain);
b97bf3fd 1291 }
4323add6 1292 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
26896904 1293 total_len, TIPC_ERR_NO_NODE);
b97bf3fd
PL		 1294 }
1295
dc63d91e 1296 /* Append chain of fragments to send queue & send them */
e0f08596 1297 l_ptr->long_msg_seq_no++;
dc63d91e
AS		 1298 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
1299 l_ptr->stats.sent_fragments += fragm_no;
b97bf3fd 1300 l_ptr->stats.sent_fragmented++;
4323add6
PL		 1301 tipc_link_push_queue(l_ptr);
1302 tipc_node_unlock(node);
b97bf3fd
PL		 1303 return dsz;
1304}
1305
c4307285 1306/*
4323add6 1307 * tipc_link_push_packet: Push one unsent packet to the media
b97bf3fd 1308 */
a18c4bc3 1309u32 tipc_link_push_packet(struct tipc_link *l_ptr)
b97bf3fd
PL		 1310{
1311 struct sk_buff *buf = l_ptr->first_out;
1312 u32 r_q_size = l_ptr->retransm_queue_size;
1313 u32 r_q_head = l_ptr->retransm_queue_head;
1314
1315 /* Step to position where retransmission failed, if any, */
1316 /* consider that buffers may have been released in meantime */
b97bf3fd 1317 if (r_q_size && buf) {
c4307285 1318 u32 last = lesser(mod(r_q_head + r_q_size),
b97bf3fd 1319 link_last_sent(l_ptr));
f905730c 1320 u32 first = buf_seqno(buf);
b97bf3fd
PL		 1321
1322 while (buf && less(first, r_q_head)) {
1323 first = mod(first + 1);
1324 buf = buf->next;
1325 }
1326 l_ptr->retransm_queue_head = r_q_head = first;
1327 l_ptr->retransm_queue_size = r_q_size = mod(last - first);
1328 }
1329
1330 /* Continue retransmission now, if there is anything: */
ca509101 1331 if (r_q_size && buf) {
b97bf3fd 1332 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
c4307285 1333 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
4323add6 1334 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
b97bf3fd
PL		 1335 l_ptr->retransm_queue_head = mod(++r_q_head);
1336 l_ptr->retransm_queue_size = --r_q_size;
1337 l_ptr->stats.retransmitted++;
0e35fd5e 1338 return 0;
b97bf3fd
PL		 1339 } else {
1340 l_ptr->stats.bearer_congs++;
b97bf3fd
PL		 1341 return PUSH_FAILED;
1342 }
1343 }
1344
1345 /* Send deferred protocol message, if any: */
b97bf3fd
PL		 1346 buf = l_ptr->proto_msg_queue;
1347 if (buf) {
1348 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
0e65967e 1349 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
4323add6 1350 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
b97bf3fd 1351 l_ptr->unacked_window = 0;
5f6d9123 1352 kfree_skb(buf);
1fc54d8f 1353 l_ptr->proto_msg_queue = NULL;
0e35fd5e 1354 return 0;
b97bf3fd 1355 } else {
b97bf3fd
PL		 1356 l_ptr->stats.bearer_congs++;
1357 return PUSH_FAILED;
1358 }
1359 }
1360
1361 /* Send one deferred data message, if send window not full: */
b97bf3fd
PL		 1362 buf = l_ptr->next_out;
1363 if (buf) {
1364 struct tipc_msg *msg = buf_msg(buf);
1365 u32 next = msg_seqno(msg);
f905730c 1366 u32 first = buf_seqno(l_ptr->first_out);
b97bf3fd
PL		 1367
1368 if (mod(next - first) < l_ptr->queue_limit[0]) {
1369 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
c4307285 1370 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
4323add6 1371 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
b97bf3fd
PL		 1372 if (msg_user(msg) == MSG_BUNDLER)
1373 msg_set_type(msg, CLOSED_MSG);
b97bf3fd 1374 l_ptr->next_out = buf->next;
0e35fd5e 1375 return 0;
b97bf3fd 1376 } else {
b97bf3fd
PL		 1377 l_ptr->stats.bearer_congs++;
1378 return PUSH_FAILED;
1379 }
1380 }
1381 }
1382 return PUSH_FINISHED;
1383}
1384
1385/*
1386 * push_queue(): push out the unsent messages of a link where
1387 * congestion has abated. Node is locked
1388 */
a18c4bc3 1389void tipc_link_push_queue(struct tipc_link *l_ptr)
b97bf3fd
PL		 1390{
1391 u32 res;
1392
4323add6 1393 if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr))
b97bf3fd
PL		 1394 return;
1395
1396 do {
4323add6 1397 res = tipc_link_push_packet(l_ptr);
0e35fd5e
AS		 1398 } while (!res);
1399
b97bf3fd 1400 if (res == PUSH_FAILED)
4323add6 1401 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
b97bf3fd
PL		 1402}
1403
d356eeba
AS		 1404static void link_reset_all(unsigned long addr)
1405{
6c00055a 1406 struct tipc_node *n_ptr;
d356eeba
AS		 1407 char addr_string[16];
1408 u32 i;
1409
1410 read_lock_bh(&tipc_net_lock);
1411 n_ptr = tipc_node_find((u32)addr);
1412 if (!n_ptr) {
1413 read_unlock_bh(&tipc_net_lock);
1414 return; /* node no longer exists */
1415 }
1416
1417 tipc_node_lock(n_ptr);
1418
2cf8aa19
EH		 1419 pr_warn("Resetting all links to %s\n",
1420 tipc_addr_string_fill(addr_string, n_ptr->addr));
d356eeba
AS		 1421
1422 for (i = 0; i < MAX_BEARERS; i++) {
1423 if (n_ptr->links[i]) {
8d64a5ba 1424 link_print(n_ptr->links[i], "Resetting link\n");
d356eeba
AS		 1425 tipc_link_reset(n_ptr->links[i]);
1426 }
1427 }
1428
1429 tipc_node_unlock(n_ptr);
1430 read_unlock_bh(&tipc_net_lock);
1431}
1432
a18c4bc3
PG		 1433static void link_retransmit_failure(struct tipc_link *l_ptr,
1434 struct sk_buff *buf)
d356eeba
AS		 1435{
1436 struct tipc_msg *msg = buf_msg(buf);
1437
2cf8aa19 1438 pr_warn("Retransmission failure on link <%s>\n", l_ptr->name);
d356eeba
AS		 1439
1440 if (l_ptr->addr) {
d356eeba 1441 /* Handle failure on standard link */
8d64a5ba 1442 link_print(l_ptr, "Resetting link\n");
d356eeba
AS		 1443 tipc_link_reset(l_ptr);
1444
1445 } else {
d356eeba 1446 /* Handle failure on broadcast link */
6c00055a 1447 struct tipc_node *n_ptr;
d356eeba
AS		 1448 char addr_string[16];
1449
2cf8aa19
EH		 1450 pr_info("Msg seq number: %u, ", msg_seqno(msg));
1451 pr_cont("Outstanding acks: %lu\n",
1452 (unsigned long) TIPC_SKB_CB(buf)->handle);
617dbeaa 1453
01d83edd 1454 n_ptr = tipc_bclink_retransmit_to();
d356eeba
AS		 1455 tipc_node_lock(n_ptr);
1456
c68ca7b7 1457 tipc_addr_string_fill(addr_string, n_ptr->addr);
2cf8aa19
EH		 1458 pr_info("Broadcast link info for %s\n", addr_string);
1459 pr_info("Supportable: %d, Supported: %d, Acked: %u\n",
1460 n_ptr->bclink.supportable,
1461 n_ptr->bclink.supported,
1462 n_ptr->bclink.acked);
1463 pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
1464 n_ptr->bclink.last_in,
1465 n_ptr->bclink.oos_state,
1466 n_ptr->bclink.last_sent);
d356eeba
AS		 1467
1468 tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr);
1469
1470 tipc_node_unlock(n_ptr);
1471
1472 l_ptr->stale_count = 0;
1473 }
1474}
1475
a18c4bc3 1476void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf,
4323add6 1477 u32 retransmits)
b97bf3fd
PL		 1478{
1479 struct tipc_msg *msg;
1480
d356eeba
AS		 1481 if (!buf)
1482 return;
1483
1484 msg = buf_msg(buf);
c4307285 1485
d356eeba 1486 if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
ca509101 1487 if (l_ptr->retransm_queue_size == 0) {
d356eeba
AS		 1488 l_ptr->retransm_queue_head = msg_seqno(msg);
1489 l_ptr->retransm_queue_size = retransmits;
d356eeba 1490 } else {
2cf8aa19
EH		 1491 pr_err("Unexpected retransmit on link %s (qsize=%d)\n",
1492 l_ptr->name, l_ptr->retransm_queue_size);
d356eeba 1493 }
ca509101 1494 return;
d356eeba
AS		 1495 } else {
1496 /* Detect repeated retransmit failures on uncongested bearer */
d356eeba
AS		 1497 if (l_ptr->last_retransmitted == msg_seqno(msg)) {
1498 if (++l_ptr->stale_count > 100) {
1499 link_retransmit_failure(l_ptr, buf);
1500 return;
1501 }
1502 } else {
1503 l_ptr->last_retransmitted = msg_seqno(msg);
1504 l_ptr->stale_count = 1;
1505 }
b97bf3fd 1506 }
d356eeba 1507
ca509101 1508 while (retransmits && (buf != l_ptr->next_out) && buf) {
b97bf3fd
PL		 1509 msg = buf_msg(buf);
1510 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
c4307285 1511 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
4323add6 1512 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
b97bf3fd
PL		 1513 buf = buf->next;
1514 retransmits--;
1515 l_ptr->stats.retransmitted++;
1516 } else {
4323add6 1517 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
b97bf3fd 1518 l_ptr->stats.bearer_congs++;
f905730c 1519 l_ptr->retransm_queue_head = buf_seqno(buf);
b97bf3fd
PL		 1520 l_ptr->retransm_queue_size = retransmits;
1521 return;
1522 }
1523 }
d356eeba 1524
b97bf3fd
PL		 1525 l_ptr->retransm_queue_head = l_ptr->retransm_queue_size = 0;
1526}
1527
c4307285 1528/**
b97bf3fd
PL		 1529 * link_insert_deferred_queue - insert deferred messages back into receive chain
1530 */
a18c4bc3 1531static struct sk_buff *link_insert_deferred_queue(struct tipc_link *l_ptr,
b97bf3fd
PL		 1532 struct sk_buff *buf)
1533{
1534 u32 seq_no;
1535
1536 if (l_ptr->oldest_deferred_in == NULL)
1537 return buf;
1538
f905730c 1539 seq_no = buf_seqno(l_ptr->oldest_deferred_in);
b97bf3fd
PL		 1540 if (seq_no == mod(l_ptr->next_in_no)) {
1541 l_ptr->newest_deferred_in->next = buf;
1542 buf = l_ptr->oldest_deferred_in;
1543 l_ptr->oldest_deferred_in = NULL;
1544 l_ptr->deferred_inqueue_sz = 0;
1545 }
1546 return buf;
1547}
1548
85035568
AS		 1549/**
1550 * link_recv_buf_validate - validate basic format of received message
1551 *
1552 * This routine ensures a TIPC message has an acceptable header, and at least
1553 * as much data as the header indicates it should. The routine also ensures
1554 * that the entire message header is stored in the main fragment of the message
1555 * buffer, to simplify future access to message header fields.
1556 *
1557 * Note: Having extra info present in the message header or data areas is OK.
1558 * TIPC will ignore the excess, under the assumption that it is optional info
1559 * introduced by a later release of the protocol.
1560 */
85035568
AS		 1561static int link_recv_buf_validate(struct sk_buff *buf)
1562{
1563 static u32 min_data_hdr_size[8] = {
741d9eb7 1564 SHORT_H_SIZE, MCAST_H_SIZE, NAMED_H_SIZE, BASIC_H_SIZE,
85035568
AS		 1565 MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE
1566 };
1567
1568 struct tipc_msg *msg;
1569 u32 tipc_hdr[2];
1570 u32 size;
1571 u32 hdr_size;
1572 u32 min_hdr_size;
1573
1574 if (unlikely(buf->len < MIN_H_SIZE))
1575 return 0;
1576
1577 msg = skb_header_pointer(buf, 0, sizeof(tipc_hdr), tipc_hdr);
1578 if (msg == NULL)
1579 return 0;
1580
1581 if (unlikely(msg_version(msg) != TIPC_VERSION))
1582 return 0;
1583
1584 size = msg_size(msg);
1585 hdr_size = msg_hdr_sz(msg);
1586 min_hdr_size = msg_isdata(msg) ?
1587 min_data_hdr_size[msg_type(msg)] : INT_H_SIZE;
1588
1589 if (unlikely((hdr_size < min_hdr_size) ||
1590 (size < hdr_size) ||
1591 (buf->len < size) ||
1592 (size - hdr_size > TIPC_MAX_USER_MSG_SIZE)))
1593 return 0;
1594
1595 return pskb_may_pull(buf, hdr_size);
1596}
1597
b02b69c8
AS		 1598/**
1599 * tipc_recv_msg - process TIPC messages arriving from off-node
1600 * @head: pointer to message buffer chain
1601 * @tb_ptr: pointer to bearer message arrived on
1602 *
1603 * Invoked with no locks held. Bearer pointer must point to a valid bearer
1604 * structure (i.e. cannot be NULL), but bearer can be inactive.
1605 */
2d627b92 1606void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *b_ptr)
b97bf3fd 1607{
4323add6 1608 read_lock_bh(&tipc_net_lock);
b97bf3fd 1609 while (head) {
6c00055a 1610 struct tipc_node *n_ptr;
a18c4bc3 1611 struct tipc_link *l_ptr;
b97bf3fd
PL		 1612 struct sk_buff *crs;
1613 struct sk_buff *buf = head;
85035568
AS		 1614 struct tipc_msg *msg;
1615 u32 seq_no;
1616 u32 ackd;
b97bf3fd
PL		 1617 u32 released = 0;
1618 int type;
1619
b97bf3fd 1620 head = head->next;
85035568 1621
b02b69c8 1622 /* Ensure bearer is still enabled */
b02b69c8
AS		 1623 if (unlikely(!b_ptr->active))
1624 goto cont;
1625
85035568 1626 /* Ensure message is well-formed */
85035568 1627 if (unlikely(!link_recv_buf_validate(buf)))
b97bf3fd 1628 goto cont;
b97bf3fd 1629
fe13dda2 1630 /* Ensure message data is a single contiguous unit */
5f6d9123 1631 if (unlikely(skb_linearize(buf)))
fe13dda2 1632 goto cont;
fe13dda2 1633
85035568 1634 /* Handle arrival of a non-unicast link message */
85035568
AS		 1635 msg = buf_msg(buf);
1636
b97bf3fd 1637 if (unlikely(msg_non_seq(msg))) {
1265a021
AS		 1638 if (msg_user(msg) == LINK_CONFIG)
1639 tipc_disc_recv_msg(buf, b_ptr);
1640 else
1641 tipc_bclink_recv_pkt(buf);
b97bf3fd
PL		 1642 continue;
1643 }
c4307285 1644
ed33a9c4 1645 /* Discard unicast link messages destined for another node */
26008247
AS		 1646 if (unlikely(!msg_short(msg) &&
1647 (msg_destnode(msg) != tipc_own_addr)))
1648 goto cont;
c4307285 1649
5a68d5ee 1650 /* Locate neighboring node that sent message */
4323add6 1651 n_ptr = tipc_node_find(msg_prevnode(msg));
b97bf3fd
PL		 1652 if (unlikely(!n_ptr))
1653 goto cont;
4323add6 1654 tipc_node_lock(n_ptr);
85035568 1655
b4b56102 1656 /* Locate unicast link endpoint that should handle message */
b4b56102
AS		 1657 l_ptr = n_ptr->links[b_ptr->identity];
1658 if (unlikely(!l_ptr)) {
5a68d5ee
AS		 1659 tipc_node_unlock(n_ptr);
1660 goto cont;
1661 }
1662
b4b56102 1663 /* Verify that communication with node is currently allowed */
b4b56102
AS		 1664 if ((n_ptr->block_setup & WAIT_PEER_DOWN) &&
1665 msg_user(msg) == LINK_PROTOCOL &&
1666 (msg_type(msg) == RESET_MSG ||
1667 msg_type(msg) == ACTIVATE_MSG) &&
1668 !msg_redundant_link(msg))
1669 n_ptr->block_setup &= ~WAIT_PEER_DOWN;
1670
1671 if (n_ptr->block_setup) {
4323add6 1672 tipc_node_unlock(n_ptr);
b97bf3fd
PL		 1673 goto cont;
1674 }
85035568
AS		 1675
1676 /* Validate message sequence number info */
85035568
AS		 1677 seq_no = msg_seqno(msg);
1678 ackd = msg_ack(msg);
1679
1680 /* Release acked messages */
93499313 1681 if (n_ptr->bclink.supported)
36559591 1682 tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
b97bf3fd
PL		 1683
1684 crs = l_ptr->first_out;
c4307285 1685 while ((crs != l_ptr->next_out) &&
f905730c 1686 less_eq(buf_seqno(crs), ackd)) {
b97bf3fd
PL		 1687 struct sk_buff *next = crs->next;
1688
5f6d9123 1689 kfree_skb(crs);
b97bf3fd
PL		 1690 crs = next;
1691 released++;
1692 }
1693 if (released) {
1694 l_ptr->first_out = crs;
1695 l_ptr->out_queue_size -= released;
1696 }
85035568
AS		 1697
1698 /* Try sending any messages link endpoint has pending */
b97bf3fd 1699 if (unlikely(l_ptr->next_out))
4323add6 1700 tipc_link_push_queue(l_ptr);
b97bf3fd 1701 if (unlikely(!list_empty(&l_ptr->waiting_ports)))
4323add6 1702 tipc_link_wakeup_ports(l_ptr, 0);
b97bf3fd
PL		 1703 if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
1704 l_ptr->stats.sent_acks++;
4323add6 1705 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
b97bf3fd
PL		 1706 }
1707
85035568 1708 /* Now (finally!) process the incoming message */
b97bf3fd
PL		 1709protocol_check:
1710 if (likely(link_working_working(l_ptr))) {
1711 if (likely(seq_no == mod(l_ptr->next_in_no))) {
1712 l_ptr->next_in_no++;
1713 if (unlikely(l_ptr->oldest_deferred_in))
1714 head = link_insert_deferred_queue(l_ptr,
1715 head);
b97bf3fd 1716deliver:
c74a4611
AS		 1717 if (likely(msg_isdata(msg))) {
1718 tipc_node_unlock(n_ptr);
1719 tipc_port_recv_msg(buf);
1720 continue;
1721 }
1722 switch (msg_user(msg)) {
1723 int ret;
1724 case MSG_BUNDLER:
1725 l_ptr->stats.recv_bundles++;
1726 l_ptr->stats.recv_bundled +=
1727 msg_msgcnt(msg);
1728 tipc_node_unlock(n_ptr);
1729 tipc_link_recv_bundle(buf);
1730 continue;
1731 case NAME_DISTRIBUTOR:
1732 tipc_node_unlock(n_ptr);
1733 tipc_named_recv(buf);
1734 continue;
1735 case CONN_MANAGER:
1736 tipc_node_unlock(n_ptr);
1737 tipc_port_recv_proto_msg(buf);
1738 continue;
1739 case MSG_FRAGMENTER:
1740 l_ptr->stats.recv_fragments++;
1741 ret = tipc_link_recv_fragment(
1742 &l_ptr->defragm_buf,
1743 &buf, &msg);
1744 if (ret == 1) {
1745 l_ptr->stats.recv_fragmented++;
1746 goto deliver;
b97bf3fd 1747 }
c74a4611
AS		 1748 if (ret == -1)
1749 l_ptr->next_in_no--;
1750 break;
1751 case CHANGEOVER_PROTOCOL:
1752 type = msg_type(msg);
1753 if (link_recv_changeover_msg(&l_ptr,
1754 &buf)) {
1755 msg = buf_msg(buf);
1756 seq_no = msg_seqno(msg);
1757 if (type == ORIGINAL_MSG)
b97bf3fd 1758 goto deliver;
c74a4611 1759 goto protocol_check;
b97bf3fd 1760 }
c74a4611
AS		 1761 break;
1762 default:
5f6d9123 1763 kfree_skb(buf);
c74a4611
AS		 1764 buf = NULL;
1765 break;
b97bf3fd 1766 }
4323add6
PL		 1767 tipc_node_unlock(n_ptr);
1768 tipc_net_route_msg(buf);
b97bf3fd
PL		 1769 continue;
1770 }
1771 link_handle_out_of_seq_msg(l_ptr, buf);
1772 head = link_insert_deferred_queue(l_ptr, head);
4323add6 1773 tipc_node_unlock(n_ptr);
b97bf3fd
PL		 1774 continue;
1775 }
1776
1777 if (msg_user(msg) == LINK_PROTOCOL) {
1778 link_recv_proto_msg(l_ptr, buf);
1779 head = link_insert_deferred_queue(l_ptr, head);
4323add6 1780 tipc_node_unlock(n_ptr);
b97bf3fd
PL		 1781 continue;
1782 }
b97bf3fd
PL		 1783 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
1784
1785 if (link_working_working(l_ptr)) {
1786 /* Re-insert in front of queue */
b97bf3fd
PL		 1787 buf->next = head;
1788 head = buf;
4323add6 1789 tipc_node_unlock(n_ptr);
b97bf3fd
PL		 1790 continue;
1791 }
4323add6 1792 tipc_node_unlock(n_ptr);
b97bf3fd 1793cont:
5f6d9123 1794 kfree_skb(buf);
b97bf3fd 1795 }
4323add6 1796 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 1797}
1798
2c53040f 1799/**
8809b255
AS		 1800 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
1801 *
1802 * Returns increase in queue length (i.e. 0 or 1)
b97bf3fd 1803 */
8809b255 1804u32 tipc_link_defer_pkt(struct sk_buff **head, struct sk_buff **tail,
4323add6 1805 struct sk_buff *buf)
b97bf3fd 1806{
8809b255
AS		 1807 struct sk_buff *queue_buf;
1808 struct sk_buff **prev;
f905730c 1809 u32 seq_no = buf_seqno(buf);
b97bf3fd
PL		 1810
1811 buf->next = NULL;
1812
1813 /* Empty queue ? */
1814 if (*head == NULL) {
1815 *head = *tail = buf;
1816 return 1;
1817 }
1818
1819 /* Last ? */
f905730c 1820 if (less(buf_seqno(*tail), seq_no)) {
b97bf3fd
PL		 1821 (*tail)->next = buf;
1822 *tail = buf;
1823 return 1;
1824 }
1825
8809b255
AS		 1826 /* Locate insertion point in queue, then insert; discard if duplicate */
1827 prev = head;
1828 queue_buf = *head;
1829 for (;;) {
1830 u32 curr_seqno = buf_seqno(queue_buf);
b97bf3fd 1831
8809b255 1832 if (seq_no == curr_seqno) {
5f6d9123 1833 kfree_skb(buf);
8809b255 1834 return 0;
b97bf3fd 1835 }
8809b255
AS		 1836
1837 if (less(seq_no, curr_seqno))
b97bf3fd 1838 break;
b97bf3fd 1839
8809b255
AS		 1840 prev = &queue_buf->next;
1841 queue_buf = queue_buf->next;
1842 }
b97bf3fd 1843
8809b255
AS		 1844 buf->next = queue_buf;
1845 *prev = buf;
1846 return 1;
b97bf3fd
PL		 1847}
1848
8809b255 1849/*
b97bf3fd
PL		 1850 * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
1851 */
a18c4bc3 1852static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
b97bf3fd
PL		 1853 struct sk_buff *buf)
1854{
f905730c 1855 u32 seq_no = buf_seqno(buf);
b97bf3fd
PL		 1856
1857 if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) {
1858 link_recv_proto_msg(l_ptr, buf);
1859 return;
1860 }
1861
b97bf3fd 1862 /* Record OOS packet arrival (force mismatch on next timeout) */
b97bf3fd
PL		 1863 l_ptr->checkpoint--;
1864
c4307285 1865 /*
b97bf3fd
PL		 1866 * Discard packet if a duplicate; otherwise add it to deferred queue
1867 * and notify peer of gap as per protocol specification
1868 */
b97bf3fd
PL		 1869 if (less(seq_no, mod(l_ptr->next_in_no))) {
1870 l_ptr->stats.duplicates++;
5f6d9123 1871 kfree_skb(buf);
b97bf3fd
PL		 1872 return;
1873 }
1874
4323add6
PL		 1875 if (tipc_link_defer_pkt(&l_ptr->oldest_deferred_in,
1876 &l_ptr->newest_deferred_in, buf)) {
b97bf3fd
PL		 1877 l_ptr->deferred_inqueue_sz++;
1878 l_ptr->stats.deferred_recv++;
1879 if ((l_ptr->deferred_inqueue_sz % 16) == 1)
4323add6 1880 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
b97bf3fd
PL		 1881 } else
1882 l_ptr->stats.duplicates++;
1883}
1884
1885/*
1886 * Send protocol message to the other endpoint.
1887 */
a18c4bc3
PG		 1888void tipc_link_send_proto_msg(struct tipc_link *l_ptr, u32 msg_typ,
1889 int probe_msg, u32 gap, u32 tolerance,
1890 u32 priority, u32 ack_mtu)
b97bf3fd 1891{
1fc54d8f 1892 struct sk_buff *buf = NULL;
b97bf3fd 1893 struct tipc_msg *msg = l_ptr->pmsg;
c4307285 1894 u32 msg_size = sizeof(l_ptr->proto_msg);
75f0aa49 1895 int r_flag;
b97bf3fd 1896
92d2c905 1897 /* Discard any previous message that was deferred due to congestion */
92d2c905 1898 if (l_ptr->proto_msg_queue) {
5f6d9123 1899 kfree_skb(l_ptr->proto_msg_queue);
92d2c905
AS		 1900 l_ptr->proto_msg_queue = NULL;
1901 }
1902
b97bf3fd
PL		 1903 if (link_blocked(l_ptr))
1904 return;
b4b56102
AS		 1905
1906 /* Abort non-RESET send if communication with node is prohibited */
b4b56102
AS		 1907 if ((l_ptr->owner->block_setup) && (msg_typ != RESET_MSG))
1908 return;
1909
92d2c905 1910 /* Create protocol message with "out-of-sequence" sequence number */
b97bf3fd
PL		 1911 msg_set_type(msg, msg_typ);
1912 msg_set_net_plane(msg, l_ptr->b_ptr->net_plane);
7a54d4a9 1913 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
4323add6 1914 msg_set_last_bcast(msg, tipc_bclink_get_last_sent());
b97bf3fd
PL		 1915
1916 if (msg_typ == STATE_MSG) {
1917 u32 next_sent = mod(l_ptr->next_out_no);
1918
4323add6 1919 if (!tipc_link_is_up(l_ptr))
b97bf3fd
PL		 1920 return;
1921 if (l_ptr->next_out)
f905730c 1922 next_sent = buf_seqno(l_ptr->next_out);
b97bf3fd
PL		 1923 msg_set_next_sent(msg, next_sent);
1924 if (l_ptr->oldest_deferred_in) {
f905730c 1925 u32 rec = buf_seqno(l_ptr->oldest_deferred_in);
b97bf3fd
PL		 1926 gap = mod(rec - mod(l_ptr->next_in_no));
1927 }
1928 msg_set_seq_gap(msg, gap);
1929 if (gap)
1930 l_ptr->stats.sent_nacks++;
1931 msg_set_link_tolerance(msg, tolerance);
1932 msg_set_linkprio(msg, priority);
1933 msg_set_max_pkt(msg, ack_mtu);
1934 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
1935 msg_set_probe(msg, probe_msg != 0);
c4307285 1936 if (probe_msg) {
b97bf3fd
PL		 1937 u32 mtu = l_ptr->max_pkt;
1938
c4307285 1939 if ((mtu < l_ptr->max_pkt_target) &&
b97bf3fd
PL		 1940 link_working_working(l_ptr) &&
1941 l_ptr->fsm_msg_cnt) {
1942 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
c4307285
YH		 1943 if (l_ptr->max_pkt_probes == 10) {
1944 l_ptr->max_pkt_target = (msg_size - 4);
1945 l_ptr->max_pkt_probes = 0;
b97bf3fd 1946 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
c4307285 1947 }
b97bf3fd 1948 l_ptr->max_pkt_probes++;
c4307285 1949 }
b97bf3fd
PL		 1950
1951 l_ptr->stats.sent_probes++;
c4307285 1952 }
b97bf3fd
PL		 1953 l_ptr->stats.sent_states++;
1954 } else { /* RESET_MSG or ACTIVATE_MSG */
1955 msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
1956 msg_set_seq_gap(msg, 0);
1957 msg_set_next_sent(msg, 1);
f23d9bf2 1958 msg_set_probe(msg, 0);
b97bf3fd
PL		 1959 msg_set_link_tolerance(msg, l_ptr->tolerance);
1960 msg_set_linkprio(msg, l_ptr->priority);
1961 msg_set_max_pkt(msg, l_ptr->max_pkt_target);
1962 }
1963
75f0aa49
AS		 1964 r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr));
1965 msg_set_redundant_link(msg, r_flag);
b97bf3fd 1966 msg_set_linkprio(msg, l_ptr->priority);
92d2c905 1967 msg_set_size(msg, msg_size);
b97bf3fd
PL		 1968
1969 msg_set_seqno(msg, mod(l_ptr->next_out_no + (0xffff/2)));
1970
31e3c3f6 1971 buf = tipc_buf_acquire(msg_size);
b97bf3fd
PL		 1972 if (!buf)
1973 return;
1974
27d7ff46 1975 skb_copy_to_linear_data(buf, msg, sizeof(l_ptr->proto_msg));
b97bf3fd 1976
92d2c905 1977 /* Defer message if bearer is already congested */
92d2c905
AS		 1978 if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
1979 l_ptr->proto_msg_queue = buf;
1980 return;
1981 }
1982
1983 /* Defer message if attempting to send results in bearer congestion */
92d2c905
AS		 1984 if (!tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
1985 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
1986 l_ptr->proto_msg_queue = buf;
1987 l_ptr->stats.bearer_congs++;
b97bf3fd
PL		 1988 return;
1989 }
1990
92d2c905 1991 /* Discard message if it was sent successfully */
92d2c905 1992 l_ptr->unacked_window = 0;
5f6d9123 1993 kfree_skb(buf);
b97bf3fd
PL		 1994}
1995
1996/*
1997 * Receive protocol message :
c4307285
YH		 1998 * Note that network plane id propagates through the network, and may
1999 * change at any time. The node with lowest address rules
b97bf3fd 2000 */
a18c4bc3 2001static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf)
b97bf3fd
PL		 2002{
2003 u32 rec_gap = 0;
2004 u32 max_pkt_info;
c4307285 2005 u32 max_pkt_ack;
b97bf3fd
PL		 2006 u32 msg_tol;
2007 struct tipc_msg *msg = buf_msg(buf);
2008
b97bf3fd
PL		 2009 if (link_blocked(l_ptr))
2010 goto exit;
2011
2012 /* record unnumbered packet arrival (force mismatch on next timeout) */
b97bf3fd
PL		 2013 l_ptr->checkpoint--;
2014
2015 if (l_ptr->b_ptr->net_plane != msg_net_plane(msg))
2016 if (tipc_own_addr > msg_prevnode(msg))
2017 l_ptr->b_ptr->net_plane = msg_net_plane(msg);
2018
2019 l_ptr->owner->permit_changeover = msg_redundant_link(msg);
2020
2021 switch (msg_type(msg)) {
c4307285 2022
b97bf3fd 2023 case RESET_MSG:
a686e685
AS		 2024 if (!link_working_unknown(l_ptr) &&
2025 (l_ptr->peer_session != INVALID_SESSION)) {
641c218d
AS		 2026 if (less_eq(msg_session(msg), l_ptr->peer_session))
2027 break; /* duplicate or old reset: ignore */
b97bf3fd 2028 }
b4b56102
AS		 2029
2030 if (!msg_redundant_link(msg) && (link_working_working(l_ptr) ||
2031 link_working_unknown(l_ptr))) {
2032 /*
2033 * peer has lost contact -- don't allow peer's links
2034 * to reactivate before we recognize loss & clean up
2035 */
2036 l_ptr->owner->block_setup = WAIT_NODE_DOWN;
2037 }
2038
47361c87
AS		 2039 link_state_event(l_ptr, RESET_MSG);
2040
b97bf3fd
PL		 2041 /* fall thru' */
2042 case ACTIVATE_MSG:
2043 /* Update link settings according other endpoint's values */
b97bf3fd
PL		 2044 strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg));
2045
2db9983a
AS		 2046 msg_tol = msg_link_tolerance(msg);
2047 if (msg_tol > l_ptr->tolerance)
b97bf3fd
PL		 2048 link_set_supervision_props(l_ptr, msg_tol);
2049
2050 if (msg_linkprio(msg) > l_ptr->priority)
2051 l_ptr->priority = msg_linkprio(msg);
2052
2053 max_pkt_info = msg_max_pkt(msg);
c4307285 2054 if (max_pkt_info) {
b97bf3fd
PL		 2055 if (max_pkt_info < l_ptr->max_pkt_target)
2056 l_ptr->max_pkt_target = max_pkt_info;
2057 if (l_ptr->max_pkt > l_ptr->max_pkt_target)
2058 l_ptr->max_pkt = l_ptr->max_pkt_target;
2059 } else {
c4307285 2060 l_ptr->max_pkt = l_ptr->max_pkt_target;
b97bf3fd 2061 }
93499313 2062 l_ptr->owner->bclink.supportable = (max_pkt_info != 0);
b97bf3fd 2063
4d75313c 2064 /* Synchronize broadcast link info, if not done previously */
7a54d4a9
AS		 2065 if (!tipc_node_is_up(l_ptr->owner)) {
2066 l_ptr->owner->bclink.last_sent =
2067 l_ptr->owner->bclink.last_in =
2068 msg_last_bcast(msg);
2069 l_ptr->owner->bclink.oos_state = 0;
2070 }
4d75313c 2071
b97bf3fd
PL		 2072 l_ptr->peer_session = msg_session(msg);
2073 l_ptr->peer_bearer_id = msg_bearer_id(msg);
47361c87
AS		 2074
2075 if (msg_type(msg) == ACTIVATE_MSG)
2076 link_state_event(l_ptr, ACTIVATE_MSG);
b97bf3fd
PL		 2077 break;
2078 case STATE_MSG:
2079
2db9983a
AS		 2080 msg_tol = msg_link_tolerance(msg);
2081 if (msg_tol)
b97bf3fd 2082 link_set_supervision_props(l_ptr, msg_tol);
c4307285
YH		 2083
2084 if (msg_linkprio(msg) &&
b97bf3fd 2085 (msg_linkprio(msg) != l_ptr->priority)) {
2cf8aa19
EH		 2086 pr_warn("%s<%s>, priority change %u->%u\n",
2087 link_rst_msg, l_ptr->name, l_ptr->priority,
2088 msg_linkprio(msg));
b97bf3fd 2089 l_ptr->priority = msg_linkprio(msg);
4323add6 2090 tipc_link_reset(l_ptr); /* Enforce change to take effect */
b97bf3fd
PL		 2091 break;
2092 }
2093 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
2094 l_ptr->stats.recv_states++;
2095 if (link_reset_unknown(l_ptr))
2096 break;
2097
2098 if (less_eq(mod(l_ptr->next_in_no), msg_next_sent(msg))) {
c4307285 2099 rec_gap = mod(msg_next_sent(msg) -
b97bf3fd
PL		 2100 mod(l_ptr->next_in_no));
2101 }
2102
2103 max_pkt_ack = msg_max_pkt(msg);
c4307285 2104 if (max_pkt_ack > l_ptr->max_pkt) {
c4307285
YH		 2105 l_ptr->max_pkt = max_pkt_ack;
2106 l_ptr->max_pkt_probes = 0;
2107 }
b97bf3fd
PL		 2108
2109 max_pkt_ack = 0;
c4307285 2110 if (msg_probe(msg)) {
b97bf3fd 2111 l_ptr->stats.recv_probes++;
a016892c 2112 if (msg_size(msg) > sizeof(l_ptr->proto_msg))
c4307285 2113 max_pkt_ack = msg_size(msg);
c4307285 2114 }
b97bf3fd
PL		 2115
2116 /* Protocol message before retransmits, reduce loss risk */
7a54d4a9
AS		 2117 if (l_ptr->owner->bclink.supported)
2118 tipc_bclink_update_link_state(l_ptr->owner,
2119 msg_last_bcast(msg));
b97bf3fd
PL		 2120
2121 if (rec_gap || (msg_probe(msg))) {
4323add6
PL		 2122 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
2123 0, rec_gap, 0, 0, max_pkt_ack);
b97bf3fd
PL		 2124 }
2125 if (msg_seq_gap(msg)) {
b97bf3fd 2126 l_ptr->stats.recv_nacks++;
4323add6
PL		 2127 tipc_link_retransmit(l_ptr, l_ptr->first_out,
2128 msg_seq_gap(msg));
b97bf3fd
PL		 2129 }
2130 break;
b97bf3fd
PL		 2131 }
2132exit:
5f6d9123 2133 kfree_skb(buf);
b97bf3fd
PL		 2134}
2135
2136
2137/*
c4307285 2138 * tipc_link_tunnel(): Send one message via a link belonging to
b97bf3fd
PL		 2139 * another bearer. Owner node is locked.
2140 */
a18c4bc3 2141static void tipc_link_tunnel(struct tipc_link *l_ptr,
31e3c3f6 2142 struct tipc_msg *tunnel_hdr,
2143 struct tipc_msg *msg,
2144 u32 selector)
b97bf3fd 2145{
a18c4bc3 2146 struct tipc_link *tunnel;
b97bf3fd
PL		 2147 struct sk_buff *buf;
2148 u32 length = msg_size(msg);
2149
2150 tunnel = l_ptr->owner->active_links[selector & 1];
5392d646 2151 if (!tipc_link_is_up(tunnel)) {
2cf8aa19 2152 pr_warn("%stunnel link no longer available\n", link_co_err);
b97bf3fd 2153 return;
5392d646 2154 }
b97bf3fd 2155 msg_set_size(tunnel_hdr, length + INT_H_SIZE);
31e3c3f6 2156 buf = tipc_buf_acquire(length + INT_H_SIZE);
5392d646 2157 if (!buf) {
2cf8aa19 2158 pr_warn("%sunable to send tunnel msg\n", link_co_err);
b97bf3fd 2159 return;
5392d646 2160 }
27d7ff46
ACM		 2161 skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE);
2162 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, msg, length);
4323add6 2163 tipc_link_send_buf(tunnel, buf);
b97bf3fd
PL		 2164}
2165
2166
2167
2168/*
2169 * changeover(): Send whole message queue via the remaining link
2170 * Owner node is locked.
2171 */
a18c4bc3 2172void tipc_link_changeover(struct tipc_link *l_ptr)
b97bf3fd
PL		 2173{
2174 u32 msgcount = l_ptr->out_queue_size;
2175 struct sk_buff *crs = l_ptr->first_out;
a18c4bc3 2176 struct tipc_link *tunnel = l_ptr->owner->active_links[0];
b97bf3fd 2177 struct tipc_msg tunnel_hdr;
5392d646 2178 int split_bundles;
b97bf3fd
PL		 2179
2180 if (!tunnel)
2181 return;
2182
5392d646 2183 if (!l_ptr->owner->permit_changeover) {
2cf8aa19 2184 pr_warn("%speer did not permit changeover\n", link_co_err);
b97bf3fd 2185 return;
5392d646 2186 }
b97bf3fd 2187
c68ca7b7 2188 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
75715217 2189 ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
b97bf3fd
PL		 2190 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2191 msg_set_msgcnt(&tunnel_hdr, msgcount);
f131072c 2192
b97bf3fd
PL		 2193 if (!l_ptr->first_out) {
2194 struct sk_buff *buf;
2195
31e3c3f6 2196 buf = tipc_buf_acquire(INT_H_SIZE);
b97bf3fd 2197 if (buf) {
27d7ff46 2198 skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);
b97bf3fd 2199 msg_set_size(&tunnel_hdr, INT_H_SIZE);
4323add6 2200 tipc_link_send_buf(tunnel, buf);
b97bf3fd 2201 } else {
2cf8aa19
EH		 2202 pr_warn("%sunable to send changeover msg\n",
2203 link_co_err);
b97bf3fd
PL		 2204 }
2205 return;
2206 }
f131072c 2207
c4307285 2208 split_bundles = (l_ptr->owner->active_links[0] !=
5392d646
AS		 2209 l_ptr->owner->active_links[1]);
2210
b97bf3fd
PL		 2211 while (crs) {
2212 struct tipc_msg *msg = buf_msg(crs);
2213
2214 if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
b97bf3fd 2215 struct tipc_msg *m = msg_get_wrapped(msg);
0e65967e 2216 unchar *pos = (unchar *)m;
b97bf3fd 2217
d788d805 2218 msgcount = msg_msgcnt(msg);
b97bf3fd 2219 while (msgcount--) {
0e65967e 2220 msg_set_seqno(m, msg_seqno(msg));
4323add6
PL		 2221 tipc_link_tunnel(l_ptr, &tunnel_hdr, m,
2222 msg_link_selector(m));
b97bf3fd
PL		 2223 pos += align(msg_size(m));
2224 m = (struct tipc_msg *)pos;
2225 }
2226 } else {
4323add6
PL		 2227 tipc_link_tunnel(l_ptr, &tunnel_hdr, msg,
2228 msg_link_selector(msg));
b97bf3fd
PL		 2229 }
2230 crs = crs->next;
2231 }
2232}
2233
a18c4bc3 2234void tipc_link_send_duplicate(struct tipc_link *l_ptr, struct tipc_link *tunnel)
b97bf3fd
PL		 2235{
2236 struct sk_buff *iter;
2237 struct tipc_msg tunnel_hdr;
2238
c68ca7b7 2239 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
75715217 2240 DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr);
b97bf3fd
PL		 2241 msg_set_msgcnt(&tunnel_hdr, l_ptr->out_queue_size);
2242 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2243 iter = l_ptr->first_out;
2244 while (iter) {
2245 struct sk_buff *outbuf;
2246 struct tipc_msg *msg = buf_msg(iter);
2247 u32 length = msg_size(msg);
2248
2249 if (msg_user(msg) == MSG_BUNDLER)
2250 msg_set_type(msg, CLOSED_MSG);
2251 msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */
c4307285 2252 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
b97bf3fd 2253 msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
31e3c3f6 2254 outbuf = tipc_buf_acquire(length + INT_H_SIZE);
b97bf3fd 2255 if (outbuf == NULL) {
2cf8aa19
EH		 2256 pr_warn("%sunable to send duplicate msg\n",
2257 link_co_err);
b97bf3fd
PL		 2258 return;
2259 }
27d7ff46
ACM		 2260 skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);
2261 skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data,
2262 length);
4323add6
PL		 2263 tipc_link_send_buf(tunnel, outbuf);
2264 if (!tipc_link_is_up(l_ptr))
b97bf3fd
PL		 2265 return;
2266 iter = iter->next;
2267 }
2268}
2269
b97bf3fd
PL		 2270/**
2271 * buf_extract - extracts embedded TIPC message from another message
2272 * @skb: encapsulating message buffer
2273 * @from_pos: offset to extract from
2274 *
c4307285 2275 * Returns a new message buffer containing an embedded message. The
b97bf3fd
PL		 2276 * encapsulating message itself is left unchanged.
2277 */
b97bf3fd
PL		 2278static struct sk_buff *buf_extract(struct sk_buff *skb, u32 from_pos)
2279{
2280 struct tipc_msg *msg = (struct tipc_msg *)(skb->data + from_pos);
2281 u32 size = msg_size(msg);
2282 struct sk_buff *eb;
2283
31e3c3f6 2284 eb = tipc_buf_acquire(size);
b97bf3fd 2285 if (eb)
27d7ff46 2286 skb_copy_to_linear_data(eb, msg, size);
b97bf3fd
PL		 2287 return eb;
2288}
2289
c4307285 2290/*
b97bf3fd
PL		 2291 * link_recv_changeover_msg(): Receive tunneled packet sent
2292 * via other link. Node is locked. Return extracted buffer.
2293 */
a18c4bc3 2294static int link_recv_changeover_msg(struct tipc_link **l_ptr,
b97bf3fd
PL		 2295 struct sk_buff **buf)
2296{
2297 struct sk_buff *tunnel_buf = *buf;
a18c4bc3 2298 struct tipc_link *dest_link;
b97bf3fd
PL		 2299 struct tipc_msg *msg;
2300 struct tipc_msg *tunnel_msg = buf_msg(tunnel_buf);
2301 u32 msg_typ = msg_type(tunnel_msg);
2302 u32 msg_count = msg_msgcnt(tunnel_msg);
2303
2304 dest_link = (*l_ptr)->owner->links[msg_bearer_id(tunnel_msg)];
b29f1428 2305 if (!dest_link)
b97bf3fd 2306 goto exit;
f131072c 2307 if (dest_link == *l_ptr) {
2cf8aa19
EH		 2308 pr_err("Unexpected changeover message on link <%s>\n",
2309 (*l_ptr)->name);
f131072c
AS		 2310 goto exit;
2311 }
b97bf3fd
PL		 2312 *l_ptr = dest_link;
2313 msg = msg_get_wrapped(tunnel_msg);
2314
2315 if (msg_typ == DUPLICATE_MSG) {
b29f1428 2316 if (less(msg_seqno(msg), mod(dest_link->next_in_no)))
b97bf3fd 2317 goto exit;
0e65967e 2318 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
b97bf3fd 2319 if (*buf == NULL) {
2cf8aa19 2320 pr_warn("%sduplicate msg dropped\n", link_co_err);
b97bf3fd
PL		 2321 goto exit;
2322 }
5f6d9123 2323 kfree_skb(tunnel_buf);
b97bf3fd
PL		 2324 return 1;
2325 }
2326
2327 /* First original message ?: */
4323add6 2328 if (tipc_link_is_up(dest_link)) {
2cf8aa19
EH		 2329 pr_info("%s<%s>, changeover initiated by peer\n", link_rst_msg,
2330 dest_link->name);
4323add6 2331 tipc_link_reset(dest_link);
b97bf3fd
PL		 2332 dest_link->exp_msg_count = msg_count;
2333 if (!msg_count)
2334 goto exit;
2335 } else if (dest_link->exp_msg_count == START_CHANGEOVER) {
b97bf3fd
PL		 2336 dest_link->exp_msg_count = msg_count;
2337 if (!msg_count)
2338 goto exit;
2339 }
2340
2341 /* Receive original message */
b97bf3fd 2342 if (dest_link->exp_msg_count == 0) {
2cf8aa19 2343 pr_warn("%sgot too many tunnelled messages\n", link_co_err);
b97bf3fd
PL		 2344 goto exit;
2345 }
2346 dest_link->exp_msg_count--;
2347 if (less(msg_seqno(msg), dest_link->reset_checkpoint)) {
b97bf3fd
PL		 2348 goto exit;
2349 } else {
2350 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
2351 if (*buf != NULL) {
5f6d9123 2352 kfree_skb(tunnel_buf);
b97bf3fd
PL		 2353 return 1;
2354 } else {
2cf8aa19 2355 pr_warn("%soriginal msg dropped\n", link_co_err);
b97bf3fd
PL		 2356 }
2357 }
2358exit:
1fc54d8f 2359 *buf = NULL;
5f6d9123 2360 kfree_skb(tunnel_buf);
b97bf3fd
PL		 2361 return 0;
2362}
2363
2364/*
2365 * Bundler functionality:
2366 */
4323add6 2367void tipc_link_recv_bundle(struct sk_buff *buf)
b97bf3fd
PL		 2368{
2369 u32 msgcount = msg_msgcnt(buf_msg(buf));
2370 u32 pos = INT_H_SIZE;
2371 struct sk_buff *obuf;
2372
b97bf3fd
PL		 2373 while (msgcount--) {
2374 obuf = buf_extract(buf, pos);
2375 if (obuf == NULL) {
2cf8aa19 2376 pr_warn("Link unable to unbundle message(s)\n");
a10bd924 2377 break;
3ff50b79 2378 }
b97bf3fd 2379 pos += align(msg_size(buf_msg(obuf)));
4323add6 2380 tipc_net_route_msg(obuf);
b97bf3fd 2381 }
5f6d9123 2382 kfree_skb(buf);
b97bf3fd
PL		 2383}
2384
2385/*
2386 * Fragmentation/defragmentation:
2387 */
2388
c4307285 2389/*
31e3c3f6 2390 * link_send_long_buf: Entry for buffers needing fragmentation.
c4307285 2391 * The buffer is complete, inclusive total message length.
b97bf3fd
PL		 2392 * Returns user data length.
2393 */
a18c4bc3 2394static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
b97bf3fd 2395{
77561557
AS		 2396 struct sk_buff *buf_chain = NULL;
2397 struct sk_buff *buf_chain_tail = (struct sk_buff *)&buf_chain;
b97bf3fd
PL		 2398 struct tipc_msg *inmsg = buf_msg(buf);
2399 struct tipc_msg fragm_hdr;
2400 u32 insize = msg_size(inmsg);
2401 u32 dsz = msg_data_sz(inmsg);
2402 unchar *crs = buf->data;
2403 u32 rest = insize;
15e979da 2404 u32 pack_sz = l_ptr->max_pkt;
b97bf3fd 2405 u32 fragm_sz = pack_sz - INT_H_SIZE;
77561557 2406 u32 fragm_no = 0;
9c396a7b 2407 u32 destaddr;
b97bf3fd
PL		 2408
2409 if (msg_short(inmsg))
2410 destaddr = l_ptr->addr;
9c396a7b
AS		 2411 else
2412 destaddr = msg_destnode(inmsg);
b97bf3fd 2413
b97bf3fd 2414 /* Prepare reusable fragment header: */
c68ca7b7 2415 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
75715217 2416 INT_H_SIZE, destaddr);
b97bf3fd
PL		 2417
2418 /* Chop up message: */
b97bf3fd
PL		 2419 while (rest > 0) {
2420 struct sk_buff *fragm;
2421
2422 if (rest <= fragm_sz) {
2423 fragm_sz = rest;
2424 msg_set_type(&fragm_hdr, LAST_FRAGMENT);
2425 }
31e3c3f6 2426 fragm = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
b97bf3fd 2427 if (fragm == NULL) {
5f6d9123 2428 kfree_skb(buf);
77561557
AS		 2429 while (buf_chain) {
2430 buf = buf_chain;
2431 buf_chain = buf_chain->next;
5f6d9123 2432 kfree_skb(buf);
77561557
AS		 2433 }
2434 return -ENOMEM;
b97bf3fd
PL		 2435 }
2436 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
77561557
AS		 2437 fragm_no++;
2438 msg_set_fragm_no(&fragm_hdr, fragm_no);
27d7ff46
ACM		 2439 skb_copy_to_linear_data(fragm, &fragm_hdr, INT_H_SIZE);
2440 skb_copy_to_linear_data_offset(fragm, INT_H_SIZE, crs,
2441 fragm_sz);
77561557
AS		 2442 buf_chain_tail->next = fragm;
2443 buf_chain_tail = fragm;
b97bf3fd 2444
b97bf3fd
PL		 2445 rest -= fragm_sz;
2446 crs += fragm_sz;
2447 msg_set_type(&fragm_hdr, FRAGMENT);
2448 }
5f6d9123 2449 kfree_skb(buf);
77561557
AS		 2450
2451 /* Append chain of fragments to send queue & send them */
77561557
AS		 2452 l_ptr->long_msg_seq_no++;
2453 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
2454 l_ptr->stats.sent_fragments += fragm_no;
2455 l_ptr->stats.sent_fragmented++;
2456 tipc_link_push_queue(l_ptr);
2457
b97bf3fd
PL		 2458 return dsz;
2459}
2460
c4307285
YH		 2461/*
2462 * A pending message being re-assembled must store certain values
2463 * to handle subsequent fragments correctly. The following functions
b97bf3fd 2464 * help storing these values in unused, available fields in the
25985edc 2465 * pending message. This makes dynamic memory allocation unnecessary.
b97bf3fd 2466 */
05790c64 2467static void set_long_msg_seqno(struct sk_buff *buf, u32 seqno)
b97bf3fd
PL		 2468{
2469 msg_set_seqno(buf_msg(buf), seqno);
2470}
2471
05790c64 2472static u32 get_fragm_size(struct sk_buff *buf)
b97bf3fd
PL		 2473{
2474 return msg_ack(buf_msg(buf));
2475}
2476
05790c64 2477static void set_fragm_size(struct sk_buff *buf, u32 sz)
b97bf3fd
PL		 2478{
2479 msg_set_ack(buf_msg(buf), sz);
2480}
2481
05790c64 2482static u32 get_expected_frags(struct sk_buff *buf)
b97bf3fd
PL		 2483{
2484 return msg_bcast_ack(buf_msg(buf));
2485}
2486
05790c64 2487static void set_expected_frags(struct sk_buff *buf, u32 exp)
b97bf3fd
PL		 2488{
2489 msg_set_bcast_ack(buf_msg(buf), exp);
2490}
2491
05790c64 2492static u32 get_timer_cnt(struct sk_buff *buf)
b97bf3fd
PL		 2493{
2494 return msg_reroute_cnt(buf_msg(buf));
2495}
2496
05790c64 2497static void incr_timer_cnt(struct sk_buff *buf)
b97bf3fd
PL		 2498{
2499 msg_incr_reroute_cnt(buf_msg(buf));
2500}
2501
c4307285
YH		 2502/*
2503 * tipc_link_recv_fragment(): Called with node lock on. Returns
b97bf3fd
PL		 2504 * the reassembled buffer if message is complete.
2505 */
c4307285 2506int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
4323add6 2507 struct tipc_msg **m)
b97bf3fd 2508{
1fc54d8f 2509 struct sk_buff *prev = NULL;
b97bf3fd
PL		 2510 struct sk_buff *fbuf = *fb;
2511 struct tipc_msg *fragm = buf_msg(fbuf);
2512 struct sk_buff *pbuf = *pending;
2513 u32 long_msg_seq_no = msg_long_msgno(fragm);
2514
1fc54d8f 2515 *fb = NULL;
b97bf3fd
PL		 2516
2517 /* Is there an incomplete message waiting for this fragment? */
f905730c 2518 while (pbuf && ((buf_seqno(pbuf) != long_msg_seq_no) ||
f64f9e71 2519 (msg_orignode(fragm) != msg_orignode(buf_msg(pbuf))))) {
b97bf3fd
PL		 2520 prev = pbuf;
2521 pbuf = pbuf->next;
2522 }
2523
2524 if (!pbuf && (msg_type(fragm) == FIRST_FRAGMENT)) {
2525 struct tipc_msg *imsg = (struct tipc_msg *)msg_data(fragm);
2526 u32 msg_sz = msg_size(imsg);
2527 u32 fragm_sz = msg_data_sz(fragm);
2528 u32 exp_fragm_cnt = msg_sz/fragm_sz + !!(msg_sz % fragm_sz);
741d9eb7 2529 u32 max = TIPC_MAX_USER_MSG_SIZE + NAMED_H_SIZE;
b97bf3fd
PL		 2530 if (msg_type(imsg) == TIPC_MCAST_MSG)
2531 max = TIPC_MAX_USER_MSG_SIZE + MCAST_H_SIZE;
2532 if (msg_size(imsg) > max) {
5f6d9123 2533 kfree_skb(fbuf);
b97bf3fd
PL		 2534 return 0;
2535 }
31e3c3f6 2536 pbuf = tipc_buf_acquire(msg_size(imsg));
b97bf3fd
PL		 2537 if (pbuf != NULL) {
2538 pbuf->next = *pending;
2539 *pending = pbuf;
27d7ff46
ACM		 2540 skb_copy_to_linear_data(pbuf, imsg,
2541 msg_data_sz(fragm));
b97bf3fd 2542 /* Prepare buffer for subsequent fragments. */
c4307285 2543 set_long_msg_seqno(pbuf, long_msg_seq_no);
0e65967e
AS		 2544 set_fragm_size(pbuf, fragm_sz);
2545 set_expected_frags(pbuf, exp_fragm_cnt - 1);
b97bf3fd 2546 } else {
2cf8aa19 2547 pr_debug("Link unable to reassemble fragmented message\n");
5f6d9123 2548 kfree_skb(fbuf);
b76b27ca 2549 return -1;
b97bf3fd 2550 }
5f6d9123 2551 kfree_skb(fbuf);
b97bf3fd
PL		 2552 return 0;
2553 } else if (pbuf && (msg_type(fragm) != FIRST_FRAGMENT)) {
2554 u32 dsz = msg_data_sz(fragm);
2555 u32 fsz = get_fragm_size(pbuf);
2556 u32 crs = ((msg_fragm_no(fragm) - 1) * fsz);
2557 u32 exp_frags = get_expected_frags(pbuf) - 1;
27d7ff46
ACM		 2558 skb_copy_to_linear_data_offset(pbuf, crs,
2559 msg_data(fragm), dsz);
5f6d9123 2560 kfree_skb(fbuf);
b97bf3fd
PL		 2561
2562 /* Is message complete? */
b97bf3fd
PL		 2563 if (exp_frags == 0) {
2564 if (prev)
2565 prev->next = pbuf->next;
2566 else
2567 *pending = pbuf->next;
2568 msg_reset_reroute_cnt(buf_msg(pbuf));
2569 *fb = pbuf;
2570 *m = buf_msg(pbuf);
2571 return 1;
2572 }
0e65967e 2573 set_expected_frags(pbuf, exp_frags);
b97bf3fd
PL		 2574 return 0;
2575 }
5f6d9123 2576 kfree_skb(fbuf);
b97bf3fd
PL		 2577 return 0;
2578}
2579
2580/**
2581 * link_check_defragm_bufs - flush stale incoming message fragments
2582 * @l_ptr: pointer to link
2583 */
a18c4bc3 2584static void link_check_defragm_bufs(struct tipc_link *l_ptr)
b97bf3fd 2585{
1fc54d8f
SR		 2586 struct sk_buff *prev = NULL;
2587 struct sk_buff *next = NULL;
b97bf3fd
PL		 2588 struct sk_buff *buf = l_ptr->defragm_buf;
2589
2590 if (!buf)
2591 return;
2592 if (!link_working_working(l_ptr))
2593 return;
2594 while (buf) {
2595 u32 cnt = get_timer_cnt(buf);
2596
2597 next = buf->next;
2598 if (cnt < 4) {
2599 incr_timer_cnt(buf);
2600 prev = buf;
2601 } else {
b97bf3fd
PL		 2602 if (prev)
2603 prev->next = buf->next;
2604 else
2605 l_ptr->defragm_buf = buf->next;
5f6d9123 2606 kfree_skb(buf);
b97bf3fd
PL		 2607 }
2608 buf = next;
2609 }
2610}
2611
a18c4bc3 2612static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance)
b97bf3fd 2613{
5413b4c6
AS		 2614 if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL))
2615 return;
2616
b97bf3fd
PL		 2617 l_ptr->tolerance = tolerance;
2618 l_ptr->continuity_interval =
2619 ((tolerance / 4) > 500) ? 500 : tolerance / 4;
2620 l_ptr->abort_limit = tolerance / (l_ptr->continuity_interval / 4);
2621}
2622
a18c4bc3 2623void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window)
b97bf3fd
PL		 2624{
2625 /* Data messages from this node, inclusive FIRST_FRAGM */
06d82c91
AS		 2626 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE] = window;
2627 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE] = (window / 3) * 4;
2628 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE] = (window / 3) * 5;
2629 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE] = (window / 3) * 6;
b97bf3fd 2630 /* Transiting data messages,inclusive FIRST_FRAGM */
06d82c91
AS		 2631 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE + 4] = 300;
2632 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE + 4] = 600;
2633 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;
2634 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;
b97bf3fd 2635 l_ptr->queue_limit[CONN_MANAGER] = 1200;
b97bf3fd
PL		 2636 l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;
2637 l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;
2638 /* FRAGMENT and LAST_FRAGMENT packets */
2639 l_ptr->queue_limit[MSG_FRAGMENTER] = 4000;
2640}
2641
2642/**
2643 * link_find_link - locate link by name
2c53040f
BH		 2644 * @name: ptr to link name string
2645 * @node: ptr to area to be filled with ptr to associated node
c4307285 2646 *
4323add6 2647 * Caller must hold 'tipc_net_lock' to ensure node and bearer are not deleted;
b97bf3fd 2648 * this also prevents link deletion.
c4307285 2649 *
b97bf3fd
PL		 2650 * Returns pointer to link (or 0 if invalid link name).
2651 */
a18c4bc3
PG		 2652static struct tipc_link *link_find_link(const char *name,
2653 struct tipc_node **node)
b97bf3fd 2654{
a18c4bc3 2655 struct tipc_link_name link_name_parts;
2d627b92 2656 struct tipc_bearer *b_ptr;
a18c4bc3 2657 struct tipc_link *l_ptr;
b97bf3fd
PL		 2658
2659 if (!link_name_validate(name, &link_name_parts))
1fc54d8f 2660 return NULL;
b97bf3fd 2661
4323add6 2662 b_ptr = tipc_bearer_find_interface(link_name_parts.if_local);
b97bf3fd 2663 if (!b_ptr)
1fc54d8f 2664 return NULL;
b97bf3fd 2665
c4307285 2666 *node = tipc_node_find(link_name_parts.addr_peer);
b97bf3fd 2667 if (!*node)
1fc54d8f 2668 return NULL;
b97bf3fd
PL		 2669
2670 l_ptr = (*node)->links[b_ptr->identity];
2671 if (!l_ptr || strcmp(l_ptr->name, name))
1fc54d8f 2672 return NULL;
b97bf3fd
PL		 2673
2674 return l_ptr;
2675}
2676
5c216e1d
AS		 2677/**
2678 * link_value_is_valid -- validate proposed link tolerance/priority/window
2679 *
2c53040f
BH		 2680 * @cmd: value type (TIPC_CMD_SET_LINK_*)
2681 * @new_value: the new value
5c216e1d
AS		 2682 *
2683 * Returns 1 if value is within range, 0 if not.
2684 */
5c216e1d
AS		 2685static int link_value_is_valid(u16 cmd, u32 new_value)
2686{
2687 switch (cmd) {
2688 case TIPC_CMD_SET_LINK_TOL:
2689 return (new_value >= TIPC_MIN_LINK_TOL) &&
2690 (new_value <= TIPC_MAX_LINK_TOL);
2691 case TIPC_CMD_SET_LINK_PRI:
2692 return (new_value <= TIPC_MAX_LINK_PRI);
2693 case TIPC_CMD_SET_LINK_WINDOW:
2694 return (new_value >= TIPC_MIN_LINK_WIN) &&
2695 (new_value <= TIPC_MAX_LINK_WIN);
2696 }
2697 return 0;
2698}
2699
5c216e1d
AS		 2700/**
2701 * link_cmd_set_value - change priority/tolerance/window for link/bearer/media
2c53040f
BH		 2702 * @name: ptr to link, bearer, or media name
2703 * @new_value: new value of link, bearer, or media setting
2704 * @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*)
5c216e1d
AS		 2705 *
2706 * Caller must hold 'tipc_net_lock' to ensure link/bearer/media is not deleted.
2707 *
2708 * Returns 0 if value updated and negative value on error.
2709 */
5c216e1d
AS		 2710static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd)
2711{
2712 struct tipc_node *node;
a18c4bc3 2713 struct tipc_link *l_ptr;
5c216e1d 2714 struct tipc_bearer *b_ptr;
358a0d1c 2715 struct tipc_media *m_ptr;
5c216e1d
AS		 2716
2717 l_ptr = link_find_link(name, &node);
2718 if (l_ptr) {
2719 /*
2720 * acquire node lock for tipc_link_send_proto_msg().
2721 * see "TIPC locking policy" in net.c.
2722 */
2723 tipc_node_lock(node);
2724 switch (cmd) {
2725 case TIPC_CMD_SET_LINK_TOL:
2726 link_set_supervision_props(l_ptr, new_value);
2727 tipc_link_send_proto_msg(l_ptr,
2728 STATE_MSG, 0, 0, new_value, 0, 0);
2729 break;
2730 case TIPC_CMD_SET_LINK_PRI:
2731 l_ptr->priority = new_value;
2732 tipc_link_send_proto_msg(l_ptr,
2733 STATE_MSG, 0, 0, 0, new_value, 0);
2734 break;
2735 case TIPC_CMD_SET_LINK_WINDOW:
2736 tipc_link_set_queue_limits(l_ptr, new_value);
2737 break;
2738 }
2739 tipc_node_unlock(node);
2740 return 0;
2741 }
2742
2743 b_ptr = tipc_bearer_find(name);
2744 if (b_ptr) {
2745 switch (cmd) {
2746 case TIPC_CMD_SET_LINK_TOL:
2747 b_ptr->tolerance = new_value;
2748 return 0;
2749 case TIPC_CMD_SET_LINK_PRI:
2750 b_ptr->priority = new_value;
2751 return 0;
2752 case TIPC_CMD_SET_LINK_WINDOW:
2753 b_ptr->window = new_value;
2754 return 0;
2755 }
2756 return -EINVAL;
2757 }
2758
2759 m_ptr = tipc_media_find(name);
2760 if (!m_ptr)
2761 return -ENODEV;
2762 switch (cmd) {
2763 case TIPC_CMD_SET_LINK_TOL:
2764 m_ptr->tolerance = new_value;
2765 return 0;
2766 case TIPC_CMD_SET_LINK_PRI:
2767 m_ptr->priority = new_value;
2768 return 0;
2769 case TIPC_CMD_SET_LINK_WINDOW:
2770 m_ptr->window = new_value;
2771 return 0;
2772 }
2773 return -EINVAL;
2774}
2775
c4307285 2776struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space,
4323add6 2777 u16 cmd)
b97bf3fd
PL		 2778{
2779 struct tipc_link_config *args;
c4307285 2780 u32 new_value;
c4307285 2781 int res;
b97bf3fd
PL		 2782
2783 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_CONFIG))
4323add6 2784 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
b97bf3fd
PL		 2785
2786 args = (struct tipc_link_config *)TLV_DATA(req_tlv_area);
2787 new_value = ntohl(args->value);
2788
5c216e1d
AS		 2789 if (!link_value_is_valid(cmd, new_value))
2790 return tipc_cfg_reply_error_string(
2791 "cannot change, value invalid");
2792
4323add6 2793 if (!strcmp(args->name, tipc_bclink_name)) {
b97bf3fd 2794 if ((cmd == TIPC_CMD_SET_LINK_WINDOW) &&
4323add6
PL		 2795 (tipc_bclink_set_queue_limits(new_value) == 0))
2796 return tipc_cfg_reply_none();
c4307285 2797 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
4323add6 2798 " (cannot change setting on broadcast link)");
b97bf3fd
PL		 2799 }
2800
4323add6 2801 read_lock_bh(&tipc_net_lock);
5c216e1d 2802 res = link_cmd_set_value(args->name, new_value, cmd);
4323add6 2803 read_unlock_bh(&tipc_net_lock);
b97bf3fd 2804 if (res)
c4307285 2805 return tipc_cfg_reply_error_string("cannot change link setting");
b97bf3fd 2806
4323add6 2807 return tipc_cfg_reply_none();
b97bf3fd
PL		 2808}
2809
2810/**
2811 * link_reset_statistics - reset link statistics
2812 * @l_ptr: pointer to link
2813 */
a18c4bc3 2814static void link_reset_statistics(struct tipc_link *l_ptr)
b97bf3fd
PL		 2815{
2816 memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));
2817 l_ptr->stats.sent_info = l_ptr->next_out_no;
2818 l_ptr->stats.recv_info = l_ptr->next_in_no;
2819}
2820
4323add6 2821struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space)
b97bf3fd
PL		 2822{
2823 char *link_name;
a18c4bc3 2824 struct tipc_link *l_ptr;
6c00055a 2825 struct tipc_node *node;
b97bf3fd
PL		 2826
2827 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
4323add6 2828 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
b97bf3fd
PL		 2829
2830 link_name = (char *)TLV_DATA(req_tlv_area);
4323add6
PL		 2831 if (!strcmp(link_name, tipc_bclink_name)) {
2832 if (tipc_bclink_reset_stats())
2833 return tipc_cfg_reply_error_string("link not found");
2834 return tipc_cfg_reply_none();
b97bf3fd
PL		 2835 }
2836
4323add6 2837 read_lock_bh(&tipc_net_lock);
c4307285 2838 l_ptr = link_find_link(link_name, &node);
b97bf3fd 2839 if (!l_ptr) {
4323add6
PL		 2840 read_unlock_bh(&tipc_net_lock);
2841 return tipc_cfg_reply_error_string("link not found");
b97bf3fd
PL		 2842 }
2843
4323add6 2844 tipc_node_lock(node);
b97bf3fd 2845 link_reset_statistics(l_ptr);
4323add6
PL		 2846 tipc_node_unlock(node);
2847 read_unlock_bh(&tipc_net_lock);
2848 return tipc_cfg_reply_none();
b97bf3fd
PL		 2849}
2850
2851/**
2852 * percent - convert count to a percentage of total (rounding up or down)
2853 */
b97bf3fd
PL		 2854static u32 percent(u32 count, u32 total)
2855{
2856 return (count * 100 + (total / 2)) / total;
2857}
2858
2859/**
4323add6 2860 * tipc_link_stats - print link statistics
b97bf3fd
PL		 2861 * @name: link name
2862 * @buf: print buffer area
2863 * @buf_size: size of print buffer area
c4307285 2864 *
b97bf3fd
PL		 2865 * Returns length of print buffer data string (or 0 if error)
2866 */
4323add6 2867static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
b97bf3fd 2868{
dc1aed37
EH		 2869 struct tipc_link *l;
2870 struct tipc_stats *s;
6c00055a 2871 struct tipc_node *node;
b97bf3fd
PL		 2872 char *status;
2873 u32 profile_total = 0;
dc1aed37 2874 int ret;
b97bf3fd 2875
4323add6
PL		 2876 if (!strcmp(name, tipc_bclink_name))
2877 return tipc_bclink_stats(buf, buf_size);
b97bf3fd 2878
4323add6 2879 read_lock_bh(&tipc_net_lock);
dc1aed37
EH		 2880 l = link_find_link(name, &node);
2881 if (!l) {
4323add6 2882 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 2883 return 0;
2884 }
4323add6 2885 tipc_node_lock(node);
dc1aed37 2886 s = &l->stats;
b97bf3fd 2887
dc1aed37 2888 if (tipc_link_is_active(l))
b97bf3fd 2889 status = "ACTIVE";
dc1aed37 2890 else if (tipc_link_is_up(l))
b97bf3fd
PL		 2891 status = "STANDBY";
2892 else
2893 status = "DEFUNCT";
dc1aed37
EH		 2894
2895 ret = tipc_snprintf(buf, buf_size, "Link <%s>\n"
2896 " %s MTU:%u Priority:%u Tolerance:%u ms"
2897 " Window:%u packets\n",
2898 l->name, status, l->max_pkt, l->priority,
2899 l->tolerance, l->queue_limit[0]);
2900
2901 ret += tipc_snprintf(buf + ret, buf_size - ret,
2902 " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
2903 l->next_in_no - s->recv_info, s->recv_fragments,
2904 s->recv_fragmented, s->recv_bundles,
2905 s->recv_bundled);
2906
2907 ret += tipc_snprintf(buf + ret, buf_size - ret,
2908 " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
2909 l->next_out_no - s->sent_info, s->sent_fragments,
2910 s->sent_fragmented, s->sent_bundles,
2911 s->sent_bundled);
2912
2913 profile_total = s->msg_length_counts;
b97bf3fd
PL		 2914 if (!profile_total)
2915 profile_total = 1;
dc1aed37
EH		 2916
2917 ret += tipc_snprintf(buf + ret, buf_size - ret,
2918 " TX profile sample:%u packets average:%u octets\n"
2919 " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
2920 "-16384:%u%% -32768:%u%% -66000:%u%%\n",
2921 s->msg_length_counts,
2922 s->msg_lengths_total / profile_total,
2923 percent(s->msg_length_profile[0], profile_total),
2924 percent(s->msg_length_profile[1], profile_total),
2925 percent(s->msg_length_profile[2], profile_total),
2926 percent(s->msg_length_profile[3], profile_total),
2927 percent(s->msg_length_profile[4], profile_total),
2928 percent(s->msg_length_profile[5], profile_total),
2929 percent(s->msg_length_profile[6], profile_total));
2930
2931 ret += tipc_snprintf(buf + ret, buf_size - ret,
2932 " RX states:%u probes:%u naks:%u defs:%u"
2933 " dups:%u\n", s->recv_states, s->recv_probes,
2934 s->recv_nacks, s->deferred_recv, s->duplicates);
2935
2936 ret += tipc_snprintf(buf + ret, buf_size - ret,
2937 " TX states:%u probes:%u naks:%u acks:%u"
2938 " dups:%u\n", s->sent_states, s->sent_probes,
2939 s->sent_nacks, s->sent_acks, s->retransmitted);
2940
2941 ret += tipc_snprintf(buf + ret, buf_size - ret,
2942 " Congestion bearer:%u link:%u Send queue"
2943 " max:%u avg:%u\n", s->bearer_congs, s->link_congs,
2944 s->max_queue_sz, s->queue_sz_counts ?
2945 (s->accu_queue_sz / s->queue_sz_counts) : 0);
b97bf3fd 2946
4323add6
PL		 2947 tipc_node_unlock(node);
2948 read_unlock_bh(&tipc_net_lock);
dc1aed37 2949 return ret;
b97bf3fd
PL		 2950}
2951
4323add6 2952struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
b97bf3fd
PL		 2953{
2954 struct sk_buff *buf;
2955 struct tlv_desc *rep_tlv;
2956 int str_len;
dc1aed37
EH		 2957 int pb_len;
2958 char *pb;
b97bf3fd
PL		 2959
2960 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
4323add6 2961 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
b97bf3fd 2962
dc1aed37 2963 buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
b97bf3fd
PL		 2964 if (!buf)
2965 return NULL;
2966
2967 rep_tlv = (struct tlv_desc *)buf->data;
dc1aed37
EH		 2968 pb = TLV_DATA(rep_tlv);
2969 pb_len = ULTRA_STRING_MAX_LEN;
4323add6 2970 str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area),
dc1aed37 2971 pb, pb_len);
b97bf3fd 2972 if (!str_len) {
5f6d9123 2973 kfree_skb(buf);
c4307285 2974 return tipc_cfg_reply_error_string("link not found");
b97bf3fd 2975 }
dc1aed37 2976 str_len += 1; /* for "\0" */
b97bf3fd
PL		 2977 skb_put(buf, TLV_SPACE(str_len));
2978 TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
2979
2980 return buf;
2981}
2982
b97bf3fd 2983/**
4323add6 2984 * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination
b97bf3fd
PL		 2985 * @dest: network address of destination node
2986 * @selector: used to select from set of active links
c4307285 2987 *
b97bf3fd
PL		 2988 * If no active link can be found, uses default maximum packet size.
2989 */
4323add6 2990u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
b97bf3fd 2991{
6c00055a 2992 struct tipc_node *n_ptr;
a18c4bc3 2993 struct tipc_link *l_ptr;
b97bf3fd 2994 u32 res = MAX_PKT_DEFAULT;
c4307285 2995
b97bf3fd
PL		 2996 if (dest == tipc_own_addr)
2997 return MAX_MSG_SIZE;
2998
c4307285 2999 read_lock_bh(&tipc_net_lock);
51a8e4de 3000 n_ptr = tipc_node_find(dest);
b97bf3fd 3001 if (n_ptr) {
4323add6 3002 tipc_node_lock(n_ptr);
b97bf3fd
PL		 3003 l_ptr = n_ptr->active_links[selector & 1];
3004 if (l_ptr)
15e979da 3005 res = l_ptr->max_pkt;
4323add6 3006 tipc_node_unlock(n_ptr);
b97bf3fd 3007 }
c4307285 3008 read_unlock_bh(&tipc_net_lock);
b97bf3fd
PL		 3009 return res;
3010}
3011
a18c4bc3 3012static void link_print(struct tipc_link *l_ptr, const char *str)
b97bf3fd 3013{
5deedde9 3014 pr_info("%s Link %x<%s>:", str, l_ptr->addr, l_ptr->b_ptr->name);
8d64a5ba 3015
b97bf3fd 3016 if (link_working_unknown(l_ptr))
5deedde9 3017 pr_cont(":WU\n");
8d64a5ba 3018 else if (link_reset_reset(l_ptr))
5deedde9 3019 pr_cont(":RR\n");
8d64a5ba 3020 else if (link_reset_unknown(l_ptr))
5deedde9 3021 pr_cont(":RU\n");
8d64a5ba 3022 else if (link_working_working(l_ptr))
5deedde9
PG		 3023 pr_cont(":WW\n");
3024 else
3025 pr_cont("\n");
b97bf3fd 3026}
Linux kernel - Deliverables
This page took 0.820467 seconds and 5 git commands to generate.