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