link.c 73.6 KB
Newer Older
P
Per Liden 已提交
1 2
/*
 * net/tipc/link.c: TIPC link code
3
 *
4
 * Copyright (c) 1996-2007, 2012-2014, Ericsson AB
5
 * Copyright (c) 2004-2007, 2010-2013, Wind River Systems
P
Per Liden 已提交
6 7
 * All rights reserved.
 *
P
Per Liden 已提交
8
 * Redistribution and use in source and binary forms, with or without
P
Per Liden 已提交
9 10
 * modification, are permitted provided that the following conditions are met:
 *
P
Per Liden 已提交
11 12 13 14 15 16 17 18
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
P
Per Liden 已提交
19
 *
P
Per Liden 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
P
Per Liden 已提交
34 35 36 37 38 39 40 41 42 43
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "core.h"
#include "link.h"
#include "port.h"
#include "name_distr.h"
#include "discover.h"
#include "config.h"

44 45
#include <linux/pkt_sched.h>

46 47 48 49 50 51
/*
 * Error message prefixes
 */
static const char *link_co_err = "Link changeover error, ";
static const char *link_rst_msg = "Resetting link ";
static const char *link_unk_evt = "Unknown link event ";
P
Per Liden 已提交
52

53 54 55 56 57
/*
 * Out-of-range value for link session numbers
 */
#define INVALID_SESSION 0x10000

58 59
/*
 * Link state events:
P
Per Liden 已提交
60 61 62 63 64
 */
#define  STARTING_EVT    856384768	/* link processing trigger */
#define  TRAFFIC_MSG_EVT 560815u	/* rx'd ??? */
#define  TIMEOUT_EVT     560817u	/* link timer expired */

65 66 67
/*
 * The following two 'message types' is really just implementation
 * data conveniently stored in the message header.
P
Per Liden 已提交
68 69 70 71 72
 * They must not be considered part of the protocol
 */
#define OPEN_MSG   0
#define CLOSED_MSG 1

73
/*
P
Per Liden 已提交
74 75 76 77
 * State value stored in 'exp_msg_count'
 */
#define START_CHANGEOVER 100000u

78
static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
P
Per Liden 已提交
79
				       struct sk_buff *buf);
80
static void tipc_link_proto_rcv(struct tipc_link *l_ptr, struct sk_buff *buf);
81
static int  tipc_link_tunnel_rcv(struct tipc_node *n_ptr,
82
				 struct sk_buff **buf);
83
static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance);
84 85 86
static int  tipc_link_iovec_long_xmit(struct tipc_port *sender,
				      struct iovec const *msg_sect,
				      unsigned int len, u32 destnode);
87 88 89
static void link_state_event(struct tipc_link *l_ptr, u32 event);
static void link_reset_statistics(struct tipc_link *l_ptr);
static void link_print(struct tipc_link *l_ptr, const char *str);
90 91 92
static int tipc_link_frag_xmit(struct tipc_link *l_ptr, struct sk_buff *buf);
static void tipc_link_sync_xmit(struct tipc_link *l);
static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf);
93

P
Per Liden 已提交
94
/*
S
Sam Ravnborg 已提交
95
 *  Simple link routines
P
Per Liden 已提交
96
 */
S
Sam Ravnborg 已提交
97
static unsigned int align(unsigned int i)
P
Per Liden 已提交
98 99 100 101
{
	return (i + 3) & ~3u;
}

102
static void link_init_max_pkt(struct tipc_link *l_ptr)
P
Per Liden 已提交
103
{
104
	struct tipc_bearer *b_ptr;
P
Per Liden 已提交
105
	u32 max_pkt;
106

107 108 109 110 111 112 113 114 115
	rcu_read_lock();
	b_ptr = rcu_dereference_rtnl(bearer_list[l_ptr->bearer_id]);
	if (!b_ptr) {
		rcu_read_unlock();
		return;
	}
	max_pkt = (b_ptr->mtu & ~3);
	rcu_read_unlock();

P
Per Liden 已提交
116 117 118
	if (max_pkt > MAX_MSG_SIZE)
		max_pkt = MAX_MSG_SIZE;

119
	l_ptr->max_pkt_target = max_pkt;
P
Per Liden 已提交
120 121
	if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT)
		l_ptr->max_pkt = l_ptr->max_pkt_target;
122
	else
P
Per Liden 已提交
123 124
		l_ptr->max_pkt = MAX_PKT_DEFAULT;

125
	l_ptr->max_pkt_probes = 0;
P
Per Liden 已提交
126 127
}

128
static u32 link_next_sent(struct tipc_link *l_ptr)
P
Per Liden 已提交
129 130
{
	if (l_ptr->next_out)
131
		return buf_seqno(l_ptr->next_out);
P
Per Liden 已提交
132 133 134
	return mod(l_ptr->next_out_no);
}

135
static u32 link_last_sent(struct tipc_link *l_ptr)
P
Per Liden 已提交
136 137 138 139 140
{
	return mod(link_next_sent(l_ptr) - 1);
}

/*
S
Sam Ravnborg 已提交
141
 *  Simple non-static link routines (i.e. referenced outside this file)
P
Per Liden 已提交
142
 */
143
int tipc_link_is_up(struct tipc_link *l_ptr)
P
Per Liden 已提交
144 145 146
{
	if (!l_ptr)
		return 0;
E
Eric Dumazet 已提交
147
	return link_working_working(l_ptr) || link_working_unknown(l_ptr);
P
Per Liden 已提交
148 149
}

150
int tipc_link_is_active(struct tipc_link *l_ptr)
P
Per Liden 已提交
151
{
E
Eric Dumazet 已提交
152 153
	return	(l_ptr->owner->active_links[0] == l_ptr) ||
		(l_ptr->owner->active_links[1] == l_ptr);
P
Per Liden 已提交
154 155 156 157 158 159
}

/**
 * link_timeout - handle expiration of link timer
 * @l_ptr: pointer to link
 */
160
static void link_timeout(struct tipc_link *l_ptr)
P
Per Liden 已提交
161
{
162
	tipc_node_lock(l_ptr->owner);
P
Per Liden 已提交
163 164 165 166 167 168 169 170 171

	/* update counters used in statistical profiling of send traffic */
	l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size;
	l_ptr->stats.queue_sz_counts++;

	if (l_ptr->first_out) {
		struct tipc_msg *msg = buf_msg(l_ptr->first_out);
		u32 length = msg_size(msg);

172 173
		if ((msg_user(msg) == MSG_FRAGMENTER) &&
		    (msg_type(msg) == FIRST_FRAGMENT)) {
P
Per Liden 已提交
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
			length = msg_size(msg_get_wrapped(msg));
		}
		if (length) {
			l_ptr->stats.msg_lengths_total += length;
			l_ptr->stats.msg_length_counts++;
			if (length <= 64)
				l_ptr->stats.msg_length_profile[0]++;
			else if (length <= 256)
				l_ptr->stats.msg_length_profile[1]++;
			else if (length <= 1024)
				l_ptr->stats.msg_length_profile[2]++;
			else if (length <= 4096)
				l_ptr->stats.msg_length_profile[3]++;
			else if (length <= 16384)
				l_ptr->stats.msg_length_profile[4]++;
			else if (length <= 32768)
				l_ptr->stats.msg_length_profile[5]++;
			else
				l_ptr->stats.msg_length_profile[6]++;
		}
	}

	/* do all other link processing performed on a periodic basis */

	link_state_event(l_ptr, TIMEOUT_EVT);

	if (l_ptr->next_out)
201
		tipc_link_push_queue(l_ptr);
P
Per Liden 已提交
202

203
	tipc_node_unlock(l_ptr->owner);
P
Per Liden 已提交
204 205
}

206
static void link_set_timer(struct tipc_link *l_ptr, u32 time)
P
Per Liden 已提交
207 208 209 210 211
{
	k_start_timer(&l_ptr->timer, time);
}

/**
212
 * tipc_link_create - create a new link
213
 * @n_ptr: pointer to associated node
P
Per Liden 已提交
214 215
 * @b_ptr: pointer to associated bearer
 * @media_addr: media address to use when sending messages over link
216
 *
P
Per Liden 已提交
217 218
 * Returns pointer to link.
 */
219
struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
220 221
				   struct tipc_bearer *b_ptr,
				   const struct tipc_media_addr *media_addr)
P
Per Liden 已提交
222
{
223
	struct tipc_link *l_ptr;
P
Per Liden 已提交
224 225
	struct tipc_msg *msg;
	char *if_name;
226 227 228 229 230
	char addr_string[16];
	u32 peer = n_ptr->addr;

	if (n_ptr->link_cnt >= 2) {
		tipc_addr_string_fill(addr_string, n_ptr->addr);
231
		pr_err("Attempt to establish third link to %s\n", addr_string);
232 233 234 235 236
		return NULL;
	}

	if (n_ptr->links[b_ptr->identity]) {
		tipc_addr_string_fill(addr_string, n_ptr->addr);
237 238
		pr_err("Attempt to establish second link on <%s> to %s\n",
		       b_ptr->name, addr_string);
239 240
		return NULL;
	}
P
Per Liden 已提交
241

242
	l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC);
P
Per Liden 已提交
243
	if (!l_ptr) {
244
		pr_warn("Link creation failed, no memory\n");
P
Per Liden 已提交
245 246 247 248
		return NULL;
	}

	l_ptr->addr = peer;
249
	if_name = strchr(b_ptr->name, ':') + 1;
250
	sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
P
Per Liden 已提交
251
		tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
252
		tipc_node(tipc_own_addr),
P
Per Liden 已提交
253 254
		if_name,
		tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
255
		/* note: peer i/f name is updated by reset/activate message */
P
Per Liden 已提交
256
	memcpy(&l_ptr->media_addr, media_addr, sizeof(*media_addr));
257
	l_ptr->owner = n_ptr;
P
Per Liden 已提交
258
	l_ptr->checkpoint = 1;
259
	l_ptr->peer_session = INVALID_SESSION;
260
	l_ptr->bearer_id = b_ptr->identity;
261
	link_set_supervision_props(l_ptr, b_ptr->tolerance);
P
Per Liden 已提交
262 263 264 265
	l_ptr->state = RESET_UNKNOWN;

	l_ptr->pmsg = (struct tipc_msg *)&l_ptr->proto_msg;
	msg = l_ptr->pmsg;
266
	tipc_msg_init(msg, LINK_PROTOCOL, RESET_MSG, INT_H_SIZE, l_ptr->addr);
P
Per Liden 已提交
267
	msg_set_size(msg, sizeof(l_ptr->proto_msg));
268
	msg_set_session(msg, (tipc_random & 0xffff));
P
Per Liden 已提交
269 270 271 272
	msg_set_bearer_id(msg, b_ptr->identity);
	strcpy((char *)msg_data(msg), if_name);

	l_ptr->priority = b_ptr->priority;
273
	tipc_link_set_queue_limits(l_ptr, b_ptr->window);
P
Per Liden 已提交
274

275
	l_ptr->net_plane = b_ptr->net_plane;
P
Per Liden 已提交
276 277 278 279 280 281 282
	link_init_max_pkt(l_ptr);

	l_ptr->next_out_no = 1;
	INIT_LIST_HEAD(&l_ptr->waiting_ports);

	link_reset_statistics(l_ptr);

283
	tipc_node_attach_link(n_ptr, l_ptr);
P
Per Liden 已提交
284

285 286
	k_init_timer(&l_ptr->timer, (Handler)link_timeout,
		     (unsigned long)l_ptr);
287 288

	link_state_event(l_ptr, STARTING_EVT);
P
Per Liden 已提交
289 290 291 292

	return l_ptr;
}

293
void tipc_link_delete_list(unsigned int bearer_id, bool shutting_down)
294 295
{
	struct tipc_link *l_ptr;
296
	struct tipc_node *n_ptr;
297

298 299
	rcu_read_lock();
	list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) {
300
		tipc_node_lock(n_ptr);
301 302 303
		l_ptr = n_ptr->links[bearer_id];
		if (l_ptr) {
			tipc_link_reset(l_ptr);
304 305 306
			if (shutting_down || !tipc_node_is_up(n_ptr)) {
				tipc_node_detach_link(l_ptr->owner, l_ptr);
				tipc_link_reset_fragments(l_ptr);
307
				tipc_node_unlock(n_ptr);
308 309 310 311 312 313 314

				/* Nobody else can access this link now: */
				del_timer_sync(&l_ptr->timer);
				kfree(l_ptr);
			} else {
				/* Detach/delete when failover is finished: */
				l_ptr->flags |= LINK_STOPPED;
315
				tipc_node_unlock(n_ptr);
316 317
				del_timer_sync(&l_ptr->timer);
			}
318 319
			continue;
		}
320
		tipc_node_unlock(n_ptr);
321
	}
322
	rcu_read_unlock();
323
}
P
Per Liden 已提交
324 325

/**
326
 * link_schedule_port - schedule port for deferred sending
P
Per Liden 已提交
327 328 329
 * @l_ptr: pointer to link
 * @origport: reference to sending port
 * @sz: amount of data to be sent
330 331
 *
 * Schedules port for renewed sending of messages after link congestion
P
Per Liden 已提交
332 333
 * has abated.
 */
334
static int link_schedule_port(struct tipc_link *l_ptr, u32 origport, u32 sz)
P
Per Liden 已提交
335
{
336
	struct tipc_port *p_ptr;
P
Per Liden 已提交
337

338 339
	spin_lock_bh(&tipc_port_list_lock);
	p_ptr = tipc_port_lock(origport);
P
Per Liden 已提交
340 341 342
	if (p_ptr) {
		if (!list_empty(&p_ptr->wait_list))
			goto exit;
343
		p_ptr->congested = 1;
344
		p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt);
P
Per Liden 已提交
345 346 347
		list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports);
		l_ptr->stats.link_congs++;
exit:
348
		tipc_port_unlock(p_ptr);
P
Per Liden 已提交
349
	}
350
	spin_unlock_bh(&tipc_port_list_lock);
P
Per Liden 已提交
351 352 353
	return -ELINKCONG;
}

354
void tipc_link_wakeup_ports(struct tipc_link *l_ptr, int all)
P
Per Liden 已提交
355
{
356 357
	struct tipc_port *p_ptr;
	struct tipc_port *temp_p_ptr;
P
Per Liden 已提交
358 359 360 361 362 363
	int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size;

	if (all)
		win = 100000;
	if (win <= 0)
		return;
364
	if (!spin_trylock_bh(&tipc_port_list_lock))
P
Per Liden 已提交
365 366 367
		return;
	if (link_congested(l_ptr))
		goto exit;
368
	list_for_each_entry_safe(p_ptr, temp_p_ptr, &l_ptr->waiting_ports,
P
Per Liden 已提交
369 370 371 372
				 wait_list) {
		if (win <= 0)
			break;
		list_del_init(&p_ptr->wait_list);
373 374
		spin_lock_bh(p_ptr->lock);
		p_ptr->congested = 0;
375
		tipc_port_wakeup(p_ptr);
P
Per Liden 已提交
376
		win -= p_ptr->waiting_pkts;
377
		spin_unlock_bh(p_ptr->lock);
P
Per Liden 已提交
378 379 380
	}

exit:
381
	spin_unlock_bh(&tipc_port_list_lock);
P
Per Liden 已提交
382 383
}

384
/**
P
Per Liden 已提交
385 386 387
 * link_release_outqueue - purge link's outbound message queue
 * @l_ptr: pointer to link
 */
388
static void link_release_outqueue(struct tipc_link *l_ptr)
P
Per Liden 已提交
389
{
390
	kfree_skb_list(l_ptr->first_out);
P
Per Liden 已提交
391 392 393 394 395
	l_ptr->first_out = NULL;
	l_ptr->out_queue_size = 0;
}

/**
396
 * tipc_link_reset_fragments - purge link's inbound message fragments queue
P
Per Liden 已提交
397 398
 * @l_ptr: pointer to link
 */
399
void tipc_link_reset_fragments(struct tipc_link *l_ptr)
P
Per Liden 已提交
400
{
401 402 403
	kfree_skb(l_ptr->reasm_head);
	l_ptr->reasm_head = NULL;
	l_ptr->reasm_tail = NULL;
P
Per Liden 已提交
404 405
}

406
/**
407
 * tipc_link_purge_queues - purge all pkt queues associated with link
P
Per Liden 已提交
408 409
 * @l_ptr: pointer to link
 */
410
void tipc_link_purge_queues(struct tipc_link *l_ptr)
P
Per Liden 已提交
411
{
412 413
	kfree_skb_list(l_ptr->oldest_deferred_in);
	kfree_skb_list(l_ptr->first_out);
414
	tipc_link_reset_fragments(l_ptr);
415
	kfree_skb(l_ptr->proto_msg_queue);
P
Per Liden 已提交
416 417 418
	l_ptr->proto_msg_queue = NULL;
}

419
void tipc_link_reset(struct tipc_link *l_ptr)
P
Per Liden 已提交
420 421 422
{
	u32 prev_state = l_ptr->state;
	u32 checkpoint = l_ptr->next_in_no;
423
	int was_active_link = tipc_link_is_active(l_ptr);
424

425
	msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff));
P
Per Liden 已提交
426

427 428
	/* Link is down, accept any session */
	l_ptr->peer_session = INVALID_SESSION;
P
Per Liden 已提交
429

430
	/* Prepare for max packet size negotiation */
P
Per Liden 已提交
431
	link_init_max_pkt(l_ptr);
432

P
Per Liden 已提交
433 434 435 436 437
	l_ptr->state = RESET_UNKNOWN;

	if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))
		return;

438
	tipc_node_link_down(l_ptr->owner, l_ptr);
439
	tipc_bearer_remove_dest(l_ptr->bearer_id, l_ptr->addr);
440

441
	if (was_active_link && tipc_node_active_links(l_ptr->owner)) {
P
Per Liden 已提交
442 443 444 445 446 447
		l_ptr->reset_checkpoint = checkpoint;
		l_ptr->exp_msg_count = START_CHANGEOVER;
	}

	/* Clean up all queues: */
	link_release_outqueue(l_ptr);
448
	kfree_skb(l_ptr->proto_msg_queue);
P
Per Liden 已提交
449
	l_ptr->proto_msg_queue = NULL;
450
	kfree_skb_list(l_ptr->oldest_deferred_in);
P
Per Liden 已提交
451
	if (!list_empty(&l_ptr->waiting_ports))
452
		tipc_link_wakeup_ports(l_ptr, 1);
P
Per Liden 已提交
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469

	l_ptr->retransm_queue_head = 0;
	l_ptr->retransm_queue_size = 0;
	l_ptr->last_out = NULL;
	l_ptr->first_out = NULL;
	l_ptr->next_out = NULL;
	l_ptr->unacked_window = 0;
	l_ptr->checkpoint = 1;
	l_ptr->next_out_no = 1;
	l_ptr->deferred_inqueue_sz = 0;
	l_ptr->oldest_deferred_in = NULL;
	l_ptr->newest_deferred_in = NULL;
	l_ptr->fsm_msg_cnt = 0;
	l_ptr->stale_count = 0;
	link_reset_statistics(l_ptr);
}

470
void tipc_link_reset_list(unsigned int bearer_id)
471 472
{
	struct tipc_link *l_ptr;
473
	struct tipc_node *n_ptr;
474

475 476
	rcu_read_lock();
	list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) {
477
		tipc_node_lock(n_ptr);
478 479 480
		l_ptr = n_ptr->links[bearer_id];
		if (l_ptr)
			tipc_link_reset(l_ptr);
481
		tipc_node_unlock(n_ptr);
482
	}
483
	rcu_read_unlock();
484
}
P
Per Liden 已提交
485

486
static void link_activate(struct tipc_link *l_ptr)
P
Per Liden 已提交
487
{
488
	l_ptr->next_in_no = l_ptr->stats.recv_info = 1;
489
	tipc_node_link_up(l_ptr->owner, l_ptr);
490
	tipc_bearer_add_dest(l_ptr->bearer_id, l_ptr->addr);
P
Per Liden 已提交
491 492 493 494 495 496 497
}

/**
 * link_state_event - link finite state machine
 * @l_ptr: pointer to link
 * @event: state machine event to process
 */
498
static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
P
Per Liden 已提交
499
{
500
	struct tipc_link *other;
P
Per Liden 已提交
501 502
	u32 cont_intv = l_ptr->continuity_interval;

503 504 505
	if (l_ptr->flags & LINK_STOPPED)
		return;

506
	if (!(l_ptr->flags & LINK_STARTED) && (event != STARTING_EVT))
P
Per Liden 已提交
507 508
		return;		/* Not yet. */

509 510
	/* Check whether changeover is going on */
	if (l_ptr->exp_msg_count) {
511
		if (event == TIMEOUT_EVT)
P
Per Liden 已提交
512
			link_set_timer(l_ptr, cont_intv);
513
		return;
P
Per Liden 已提交
514 515 516 517 518 519 520 521 522 523 524
	}

	switch (l_ptr->state) {
	case WORKING_WORKING:
		switch (event) {
		case TRAFFIC_MSG_EVT:
		case ACTIVATE_MSG:
			break;
		case TIMEOUT_EVT:
			if (l_ptr->next_in_no != l_ptr->checkpoint) {
				l_ptr->checkpoint = l_ptr->next_in_no;
525
				if (tipc_bclink_acks_missing(l_ptr->owner)) {
526 527
					tipc_link_proto_xmit(l_ptr, STATE_MSG,
							     0, 0, 0, 0, 0);
P
Per Liden 已提交
528 529
					l_ptr->fsm_msg_cnt++;
				} else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {
530 531
					tipc_link_proto_xmit(l_ptr, STATE_MSG,
							     1, 0, 0, 0, 0);
P
Per Liden 已提交
532 533 534 535 536 537 538
					l_ptr->fsm_msg_cnt++;
				}
				link_set_timer(l_ptr, cont_intv);
				break;
			}
			l_ptr->state = WORKING_UNKNOWN;
			l_ptr->fsm_msg_cnt = 0;
539
			tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
P
Per Liden 已提交
540 541 542 543
			l_ptr->fsm_msg_cnt++;
			link_set_timer(l_ptr, cont_intv / 4);
			break;
		case RESET_MSG:
544 545
			pr_info("%s<%s>, requested by peer\n", link_rst_msg,
				l_ptr->name);
546
			tipc_link_reset(l_ptr);
P
Per Liden 已提交
547 548
			l_ptr->state = RESET_RESET;
			l_ptr->fsm_msg_cnt = 0;
549 550
			tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
					     0, 0, 0, 0, 0);
P
Per Liden 已提交
551 552 553 554
			l_ptr->fsm_msg_cnt++;
			link_set_timer(l_ptr, cont_intv);
			break;
		default:
555
			pr_err("%s%u in WW state\n", link_unk_evt, event);
P
Per Liden 已提交
556 557 558 559 560 561 562 563 564 565 566
		}
		break;
	case WORKING_UNKNOWN:
		switch (event) {
		case TRAFFIC_MSG_EVT:
		case ACTIVATE_MSG:
			l_ptr->state = WORKING_WORKING;
			l_ptr->fsm_msg_cnt = 0;
			link_set_timer(l_ptr, cont_intv);
			break;
		case RESET_MSG:
567 568
			pr_info("%s<%s>, requested by peer while probing\n",
				link_rst_msg, l_ptr->name);
569
			tipc_link_reset(l_ptr);
P
Per Liden 已提交
570 571
			l_ptr->state = RESET_RESET;
			l_ptr->fsm_msg_cnt = 0;
572 573
			tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
					     0, 0, 0, 0, 0);
P
Per Liden 已提交
574 575 576 577 578 579 580 581
			l_ptr->fsm_msg_cnt++;
			link_set_timer(l_ptr, cont_intv);
			break;
		case TIMEOUT_EVT:
			if (l_ptr->next_in_no != l_ptr->checkpoint) {
				l_ptr->state = WORKING_WORKING;
				l_ptr->fsm_msg_cnt = 0;
				l_ptr->checkpoint = l_ptr->next_in_no;
582
				if (tipc_bclink_acks_missing(l_ptr->owner)) {
583 584
					tipc_link_proto_xmit(l_ptr, STATE_MSG,
							     0, 0, 0, 0, 0);
P
Per Liden 已提交
585 586 587 588
					l_ptr->fsm_msg_cnt++;
				}
				link_set_timer(l_ptr, cont_intv);
			} else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {
589 590
				tipc_link_proto_xmit(l_ptr, STATE_MSG,
						     1, 0, 0, 0, 0);
P
Per Liden 已提交
591 592 593
				l_ptr->fsm_msg_cnt++;
				link_set_timer(l_ptr, cont_intv / 4);
			} else {	/* Link has failed */
594 595
				pr_warn("%s<%s>, peer not responding\n",
					link_rst_msg, l_ptr->name);
596
				tipc_link_reset(l_ptr);
P
Per Liden 已提交
597 598
				l_ptr->state = RESET_UNKNOWN;
				l_ptr->fsm_msg_cnt = 0;
599 600
				tipc_link_proto_xmit(l_ptr, RESET_MSG,
						     0, 0, 0, 0, 0);
P
Per Liden 已提交
601 602 603 604 605
				l_ptr->fsm_msg_cnt++;
				link_set_timer(l_ptr, cont_intv);
			}
			break;
		default:
606
			pr_err("%s%u in WU state\n", link_unk_evt, event);
P
Per Liden 已提交
607 608 609 610 611 612 613 614
		}
		break;
	case RESET_UNKNOWN:
		switch (event) {
		case TRAFFIC_MSG_EVT:
			break;
		case ACTIVATE_MSG:
			other = l_ptr->owner->active_links[0];
615
			if (other && link_working_unknown(other))
P
Per Liden 已提交
616 617 618 619
				break;
			l_ptr->state = WORKING_WORKING;
			l_ptr->fsm_msg_cnt = 0;
			link_activate(l_ptr);
620
			tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
P
Per Liden 已提交
621
			l_ptr->fsm_msg_cnt++;
622
			if (l_ptr->owner->working_links == 1)
623
				tipc_link_sync_xmit(l_ptr);
P
Per Liden 已提交
624 625 626 627 628
			link_set_timer(l_ptr, cont_intv);
			break;
		case RESET_MSG:
			l_ptr->state = RESET_RESET;
			l_ptr->fsm_msg_cnt = 0;
629 630
			tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
					     1, 0, 0, 0, 0);
P
Per Liden 已提交
631 632 633 634
			l_ptr->fsm_msg_cnt++;
			link_set_timer(l_ptr, cont_intv);
			break;
		case STARTING_EVT:
635
			l_ptr->flags |= LINK_STARTED;
P
Per Liden 已提交
636 637
			/* fall through */
		case TIMEOUT_EVT:
638
			tipc_link_proto_xmit(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
P
Per Liden 已提交
639 640 641 642
			l_ptr->fsm_msg_cnt++;
			link_set_timer(l_ptr, cont_intv);
			break;
		default:
643
			pr_err("%s%u in RU state\n", link_unk_evt, event);
P
Per Liden 已提交
644 645 646 647 648 649 650
		}
		break;
	case RESET_RESET:
		switch (event) {
		case TRAFFIC_MSG_EVT:
		case ACTIVATE_MSG:
			other = l_ptr->owner->active_links[0];
651
			if (other && link_working_unknown(other))
P
Per Liden 已提交
652 653 654 655
				break;
			l_ptr->state = WORKING_WORKING;
			l_ptr->fsm_msg_cnt = 0;
			link_activate(l_ptr);
656
			tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
P
Per Liden 已提交
657
			l_ptr->fsm_msg_cnt++;
658
			if (l_ptr->owner->working_links == 1)
659
				tipc_link_sync_xmit(l_ptr);
P
Per Liden 已提交
660 661 662 663 664
			link_set_timer(l_ptr, cont_intv);
			break;
		case RESET_MSG:
			break;
		case TIMEOUT_EVT:
665 666
			tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
					     0, 0, 0, 0, 0);
P
Per Liden 已提交
667 668 669 670
			l_ptr->fsm_msg_cnt++;
			link_set_timer(l_ptr, cont_intv);
			break;
		default:
671
			pr_err("%s%u in RR state\n", link_unk_evt, event);
P
Per Liden 已提交
672 673 674
		}
		break;
	default:
675
		pr_err("Unknown link state %u/%u\n", l_ptr->state, event);
P
Per Liden 已提交
676 677 678 679 680
	}
}

/*
 * link_bundle_buf(): Append contents of a buffer to
681
 * the tail of an existing one.
P
Per Liden 已提交
682
 */
683
static int link_bundle_buf(struct tipc_link *l_ptr, struct sk_buff *bundler,
P
Per Liden 已提交
684 685 686 687 688
			   struct sk_buff *buf)
{
	struct tipc_msg *bundler_msg = buf_msg(bundler);
	struct tipc_msg *msg = buf_msg(buf);
	u32 size = msg_size(msg);
689 690 691
	u32 bundle_size = msg_size(bundler_msg);
	u32 to_pos = align(bundle_size);
	u32 pad = to_pos - bundle_size;
P
Per Liden 已提交
692 693 694 695 696

	if (msg_user(bundler_msg) != MSG_BUNDLER)
		return 0;
	if (msg_type(bundler_msg) != OPEN_MSG)
		return 0;
697
	if (skb_tailroom(bundler) < (pad + size))
P
Per Liden 已提交
698
		return 0;
699
	if (l_ptr->max_pkt < (to_pos + size))
700
		return 0;
P
Per Liden 已提交
701

702
	skb_put(bundler, pad + size);
703
	skb_copy_to_linear_data_offset(bundler, to_pos, buf->data, size);
P
Per Liden 已提交
704 705
	msg_set_size(bundler_msg, to_pos + size);
	msg_set_msgcnt(bundler_msg, msg_msgcnt(bundler_msg) + 1);
706
	kfree_skb(buf);
P
Per Liden 已提交
707 708 709 710
	l_ptr->stats.sent_bundled++;
	return 1;
}

711
static void link_add_to_outqueue(struct tipc_link *l_ptr,
S
Sam Ravnborg 已提交
712 713
				 struct sk_buff *buf,
				 struct tipc_msg *msg)
P
Per Liden 已提交
714 715 716 717 718 719 720 721 722 723 724 725
{
	u32 ack = mod(l_ptr->next_in_no - 1);
	u32 seqno = mod(l_ptr->next_out_no++);

	msg_set_word(msg, 2, ((ack << 16) | seqno));
	msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
	buf->next = NULL;
	if (l_ptr->first_out) {
		l_ptr->last_out->next = buf;
		l_ptr->last_out = buf;
	} else
		l_ptr->first_out = l_ptr->last_out = buf;
726

P
Per Liden 已提交
727
	l_ptr->out_queue_size++;
728 729
	if (l_ptr->out_queue_size > l_ptr->stats.max_queue_sz)
		l_ptr->stats.max_queue_sz = l_ptr->out_queue_size;
P
Per Liden 已提交
730 731
}

732
static void link_add_chain_to_outqueue(struct tipc_link *l_ptr,
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
				       struct sk_buff *buf_chain,
				       u32 long_msgno)
{
	struct sk_buff *buf;
	struct tipc_msg *msg;

	if (!l_ptr->next_out)
		l_ptr->next_out = buf_chain;
	while (buf_chain) {
		buf = buf_chain;
		buf_chain = buf_chain->next;

		msg = buf_msg(buf);
		msg_set_long_msgno(msg, long_msgno);
		link_add_to_outqueue(l_ptr, buf, msg);
	}
}

751
/*
752 753
 * tipc_link_xmit() is the 'full path' for messages, called from
 * inside TIPC when the 'fast path' in tipc_send_xmit
P
Per Liden 已提交
754 755
 * has failed, and from link_send()
 */
756
int __tipc_link_xmit(struct tipc_link *l_ptr, struct sk_buff *buf)
P
Per Liden 已提交
757 758 759 760 761
{
	struct tipc_msg *msg = buf_msg(buf);
	u32 size = msg_size(msg);
	u32 dsz = msg_data_sz(msg);
	u32 queue_size = l_ptr->out_queue_size;
762
	u32 imp = tipc_msg_tot_importance(msg);
P
Per Liden 已提交
763
	u32 queue_limit = l_ptr->queue_limit[imp];
764
	u32 max_packet = l_ptr->max_pkt;
P
Per Liden 已提交
765 766 767 768

	/* Match msg importance against queue limits: */
	if (unlikely(queue_size >= queue_limit)) {
		if (imp <= TIPC_CRITICAL_IMPORTANCE) {
769
			link_schedule_port(l_ptr, msg_origport(msg), size);
770
			kfree_skb(buf);
771
			return -ELINKCONG;
P
Per Liden 已提交
772
		}
773
		kfree_skb(buf);
P
Per Liden 已提交
774
		if (imp > CONN_MANAGER) {
775 776
			pr_warn("%s<%s>, send queue full", link_rst_msg,
				l_ptr->name);
777
			tipc_link_reset(l_ptr);
P
Per Liden 已提交
778 779 780 781 782 783
		}
		return dsz;
	}

	/* Fragmentation needed ? */
	if (size > max_packet)
784
		return tipc_link_frag_xmit(l_ptr, buf);
P
Per Liden 已提交
785

786
	/* Packet can be queued or sent. */
787
	if (likely(!link_congested(l_ptr))) {
P
Per Liden 已提交
788 789
		link_add_to_outqueue(l_ptr, buf, msg);

790
		tipc_bearer_send(l_ptr->bearer_id, buf, &l_ptr->media_addr);
791
		l_ptr->unacked_window = 0;
P
Per Liden 已提交
792 793
		return dsz;
	}
794
	/* Congestion: can message be bundled ? */
P
Per Liden 已提交
795 796 797 798
	if ((msg_user(msg) != CHANGEOVER_PROTOCOL) &&
	    (msg_user(msg) != MSG_FRAGMENTER)) {

		/* Try adding message to an existing bundle */
799
		if (l_ptr->next_out &&
800
		    link_bundle_buf(l_ptr, l_ptr->last_out, buf))
P
Per Liden 已提交
801 802 803 804
			return dsz;

		/* Try creating a new bundle */
		if (size <= max_packet * 2 / 3) {
805
			struct sk_buff *bundler = tipc_buf_acquire(max_packet);
P
Per Liden 已提交
806 807 808
			struct tipc_msg bundler_hdr;

			if (bundler) {
809
				tipc_msg_init(&bundler_hdr, MSG_BUNDLER, OPEN_MSG,
810
					 INT_H_SIZE, l_ptr->addr);
811 812
				skb_copy_to_linear_data(bundler, &bundler_hdr,
							INT_H_SIZE);
P
Per Liden 已提交
813 814 815 816 817 818 819 820 821 822 823 824 825 826
				skb_trim(bundler, INT_H_SIZE);
				link_bundle_buf(l_ptr, bundler, buf);
				buf = bundler;
				msg = buf_msg(buf);
				l_ptr->stats.sent_bundles++;
			}
		}
	}
	if (!l_ptr->next_out)
		l_ptr->next_out = buf;
	link_add_to_outqueue(l_ptr, buf, msg);
	return dsz;
}

827
/*
828 829
 * tipc_link_xmit(): same as __tipc_link_xmit(), but the link to use
 * has not been selected yet, and the the owner node is not locked
P
Per Liden 已提交
830 831
 * Called by TIPC internal users, e.g. the name distributor
 */
832
int tipc_link_xmit(struct sk_buff *buf, u32 dest, u32 selector)
P
Per Liden 已提交
833
{
834
	struct tipc_link *l_ptr;
835
	struct tipc_node *n_ptr;
P
Per Liden 已提交
836 837
	int res = -ELINKCONG;

838
	n_ptr = tipc_node_find(dest);
P
Per Liden 已提交
839
	if (n_ptr) {
840
		tipc_node_lock(n_ptr);
P
Per Liden 已提交
841
		l_ptr = n_ptr->active_links[selector & 1];
842
		if (l_ptr)
843
			res = __tipc_link_xmit(l_ptr, buf);
844
		else
845
			kfree_skb(buf);
846
		tipc_node_unlock(n_ptr);
P
Per Liden 已提交
847
	} else {
848
		kfree_skb(buf);
P
Per Liden 已提交
849 850 851 852
	}
	return res;
}

853
/*
854
 * tipc_link_sync_xmit - synchronize broadcast link endpoints.
855 856 857 858 859 860
 *
 * Give a newly added peer node the sequence number where it should
 * start receiving and acking broadcast packets.
 *
 * Called with node locked
 */
861
static void tipc_link_sync_xmit(struct tipc_link *l)
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877
{
	struct sk_buff *buf;
	struct tipc_msg *msg;

	buf = tipc_buf_acquire(INT_H_SIZE);
	if (!buf)
		return;

	msg = buf_msg(buf);
	tipc_msg_init(msg, BCAST_PROTOCOL, STATE_MSG, INT_H_SIZE, l->addr);
	msg_set_last_bcast(msg, l->owner->bclink.acked);
	link_add_chain_to_outqueue(l, buf, 0);
	tipc_link_push_queue(l);
}

/*
878
 * tipc_link_sync_rcv - synchronize broadcast link endpoints.
879 880 881 882 883 884
 * Receive the sequence number where we should start receiving and
 * acking broadcast packets from a newly added peer node, and open
 * up for reception of such packets.
 *
 * Called with node locked
 */
885
static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf)
886 887 888 889 890 891 892 893 894
{
	struct tipc_msg *msg = buf_msg(buf);

	n->bclink.last_sent = n->bclink.last_in = msg_last_bcast(msg);
	n->bclink.recv_permitted = true;
	kfree_skb(buf);
}

/*
895
 * tipc_link_names_xmit - send name table entries to new neighbor
896 897 898 899 900 901 902
 *
 * Send routine for bulk delivery of name table messages when contact
 * with a new neighbor occurs. No link congestion checking is performed
 * because name table messages *must* be delivered. The messages must be
 * small enough not to require fragmentation.
 * Called without any locks held.
 */
903
void tipc_link_names_xmit(struct list_head *message_list, u32 dest)
904 905
{
	struct tipc_node *n_ptr;
906
	struct tipc_link *l_ptr;
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
	struct sk_buff *buf;
	struct sk_buff *temp_buf;

	if (list_empty(message_list))
		return;

	n_ptr = tipc_node_find(dest);
	if (n_ptr) {
		tipc_node_lock(n_ptr);
		l_ptr = n_ptr->active_links[0];
		if (l_ptr) {
			/* convert circular list to linear list */
			((struct sk_buff *)message_list->prev)->next = NULL;
			link_add_chain_to_outqueue(l_ptr,
				(struct sk_buff *)message_list->next, 0);
			tipc_link_push_queue(l_ptr);
			INIT_LIST_HEAD(message_list);
		}
		tipc_node_unlock(n_ptr);
	}

	/* discard the messages if they couldn't be sent */
	list_for_each_safe(buf, temp_buf, ((struct sk_buff *)message_list)) {
		list_del((struct list_head *)buf);
931
		kfree_skb(buf);
932 933 934
	}
}

935
/*
936
 * tipc_link_xmit_fast: Entry for data messages where the
P
Per Liden 已提交
937 938 939 940
 * destination link is known and the header is complete,
 * inclusive total message length. Very time critical.
 * Link is locked. Returns user data length.
 */
941 942
static int tipc_link_xmit_fast(struct tipc_link *l_ptr, struct sk_buff *buf,
			       u32 *used_max_pkt)
P
Per Liden 已提交
943 944 945 946 947
{
	struct tipc_msg *msg = buf_msg(buf);
	int res = msg_data_sz(msg);

	if (likely(!link_congested(l_ptr))) {
948
		if (likely(msg_size(msg) <= l_ptr->max_pkt)) {
949
			link_add_to_outqueue(l_ptr, buf, msg);
950
			tipc_bearer_send(l_ptr->bearer_id, buf,
951 952 953 954 955
					 &l_ptr->media_addr);
			l_ptr->unacked_window = 0;
			return res;
		}
		else
956
			*used_max_pkt = l_ptr->max_pkt;
P
Per Liden 已提交
957
	}
958
	return __tipc_link_xmit(l_ptr, buf);  /* All other cases */
P
Per Liden 已提交
959 960
}

961
/*
962
 * tipc_link_iovec_xmit_fast: Entry for messages where the
P
Per Liden 已提交
963
 * destination processor is known and the header is complete,
964
 * except for total message length.
P
Per Liden 已提交
965 966
 * Returns user data length or errno.
 */
967 968 969
int tipc_link_iovec_xmit_fast(struct tipc_port *sender,
			      struct iovec const *msg_sect,
			      unsigned int len, u32 destaddr)
P
Per Liden 已提交
970
{
971
	struct tipc_msg *hdr = &sender->phdr;
972
	struct tipc_link *l_ptr;
P
Per Liden 已提交
973
	struct sk_buff *buf;
974
	struct tipc_node *node;
P
Per Liden 已提交
975 976 977 978 979 980 981 982
	int res;
	u32 selector = msg_origport(hdr) & 1;

again:
	/*
	 * Try building message using port's max_pkt hint.
	 * (Must not hold any locks while building message.)
	 */
983
	res = tipc_msg_build(hdr, msg_sect, len, sender->max_pkt, &buf);
984 985 986
	/* Exit if build request was invalid */
	if (unlikely(res < 0))
		return res;
P
Per Liden 已提交
987

988
	node = tipc_node_find(destaddr);
P
Per Liden 已提交
989
	if (likely(node)) {
990
		tipc_node_lock(node);
P
Per Liden 已提交
991 992 993
		l_ptr = node->active_links[selector];
		if (likely(l_ptr)) {
			if (likely(buf)) {
994 995
				res = tipc_link_xmit_fast(l_ptr, buf,
							  &sender->max_pkt);
P
Per Liden 已提交
996
exit:
997
				tipc_node_unlock(node);
P
Per Liden 已提交
998 999 1000 1001
				return res;
			}

			/* Exit if link (or bearer) is congested */
1002
			if (link_congested(l_ptr)) {
P
Per Liden 已提交
1003
				res = link_schedule_port(l_ptr,
1004
							 sender->ref, res);
P
Per Liden 已提交
1005 1006 1007
				goto exit;
			}

1008
			/*
P
Per Liden 已提交
1009 1010 1011
			 * Message size exceeds max_pkt hint; update hint,
			 * then re-try fast path or fragment the message
			 */
1012
			sender->max_pkt = l_ptr->max_pkt;
1013
			tipc_node_unlock(node);
P
Per Liden 已提交
1014 1015


1016
			if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)
P
Per Liden 已提交
1017 1018
				goto again;

1019 1020
			return tipc_link_iovec_long_xmit(sender, msg_sect,
							 len, destaddr);
P
Per Liden 已提交
1021
		}
1022
		tipc_node_unlock(node);
P
Per Liden 已提交
1023 1024 1025
	}

	/* Couldn't find a link to the destination node */
1026 1027 1028
	kfree_skb(buf);
	tipc_port_iovec_reject(sender, hdr, msg_sect, len, TIPC_ERR_NO_NODE);
	return -ENETUNREACH;
P
Per Liden 已提交
1029 1030
}

1031
/*
1032
 * tipc_link_iovec_long_xmit(): Entry for long messages where the
P
Per Liden 已提交
1033
 * destination node is known and the header is complete,
1034
 * inclusive total message length.
P
Per Liden 已提交
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
 * Link and bearer congestion status have been checked to be ok,
 * and are ignored if they change.
 *
 * Note that fragments do not use the full link MTU so that they won't have
 * to undergo refragmentation if link changeover causes them to be sent
 * over another link with an additional tunnel header added as prefix.
 * (Refragmentation will still occur if the other link has a smaller MTU.)
 *
 * Returns user data length or errno.
 */
1045 1046 1047
static int tipc_link_iovec_long_xmit(struct tipc_port *sender,
				     struct iovec const *msg_sect,
				     unsigned int len, u32 destaddr)
P
Per Liden 已提交
1048
{
1049
	struct tipc_link *l_ptr;
1050
	struct tipc_node *node;
1051
	struct tipc_msg *hdr = &sender->phdr;
1052
	u32 dsz = len;
1053
	u32 max_pkt, fragm_sz, rest;
P
Per Liden 已提交
1054
	struct tipc_msg fragm_hdr;
1055 1056
	struct sk_buff *buf, *buf_chain, *prev;
	u32 fragm_crs, fragm_rest, hsz, sect_rest;
Y
Ying Xue 已提交
1057
	const unchar __user *sect_crs;
P
Per Liden 已提交
1058 1059
	int curr_sect;
	u32 fragm_no;
1060
	int res = 0;
P
Per Liden 已提交
1061 1062 1063

again:
	fragm_no = 1;
1064
	max_pkt = sender->max_pkt - INT_H_SIZE;
P
Per Liden 已提交
1065
		/* leave room for tunnel header in case of link changeover */
1066
	fragm_sz = max_pkt - INT_H_SIZE;
P
Per Liden 已提交
1067 1068 1069 1070 1071
		/* leave room for fragmentation header in each fragment */
	rest = dsz;
	fragm_crs = 0;
	fragm_rest = 0;
	sect_rest = 0;
1072
	sect_crs = NULL;
P
Per Liden 已提交
1073 1074
	curr_sect = -1;

1075
	/* Prepare reusable fragment header */
1076
	tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
1077
		 INT_H_SIZE, msg_destnode(hdr));
P
Per Liden 已提交
1078 1079 1080
	msg_set_size(&fragm_hdr, max_pkt);
	msg_set_fragm_no(&fragm_hdr, 1);

1081
	/* Prepare header of first fragment */
1082
	buf_chain = buf = tipc_buf_acquire(max_pkt);
P
Per Liden 已提交
1083 1084 1085
	if (!buf)
		return -ENOMEM;
	buf->next = NULL;
1086
	skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
P
Per Liden 已提交
1087
	hsz = msg_hdr_sz(hdr);
1088
	skb_copy_to_linear_data_offset(buf, INT_H_SIZE, hdr, hsz);
P
Per Liden 已提交
1089

1090
	/* Chop up message */
P
Per Liden 已提交
1091 1092 1093 1094 1095 1096 1097 1098
	fragm_crs = INT_H_SIZE + hsz;
	fragm_rest = fragm_sz - hsz;

	do {		/* For all sections */
		u32 sz;

		if (!sect_rest) {
			sect_rest = msg_sect[++curr_sect].iov_len;
Y
Ying Xue 已提交
1099
			sect_crs = msg_sect[curr_sect].iov_base;
P
Per Liden 已提交
1100 1101 1102 1103 1104 1105 1106
		}

		if (sect_rest < fragm_rest)
			sz = sect_rest;
		else
			sz = fragm_rest;

1107
		if (copy_from_user(buf->data + fragm_crs, sect_crs, sz)) {
1108
			res = -EFAULT;
P
Per Liden 已提交
1109
error:
1110
			kfree_skb_list(buf_chain);
1111
			return res;
1112
		}
P
Per Liden 已提交
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
		sect_crs += sz;
		sect_rest -= sz;
		fragm_crs += sz;
		fragm_rest -= sz;
		rest -= sz;

		if (!fragm_rest && rest) {

			/* Initiate new fragment: */
			if (rest <= fragm_sz) {
				fragm_sz = rest;
1124
				msg_set_type(&fragm_hdr, LAST_FRAGMENT);
P
Per Liden 已提交
1125 1126 1127 1128 1129 1130
			} else {
				msg_set_type(&fragm_hdr, FRAGMENT);
			}
			msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
			msg_set_fragm_no(&fragm_hdr, ++fragm_no);
			prev = buf;
1131
			buf = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
1132 1133
			if (!buf) {
				res = -ENOMEM;
P
Per Liden 已提交
1134
				goto error;
1135
			}
P
Per Liden 已提交
1136

1137
			buf->next = NULL;
P
Per Liden 已提交
1138
			prev->next = buf;
1139
			skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
P
Per Liden 已提交
1140 1141 1142
			fragm_crs = INT_H_SIZE;
			fragm_rest = fragm_sz;
		}
1143
	} while (rest > 0);
P
Per Liden 已提交
1144

1145
	/*
P
Per Liden 已提交
1146 1147 1148
	 * Now we have a buffer chain. Select a link and check
	 * that packet size is still OK
	 */
1149
	node = tipc_node_find(destaddr);
P
Per Liden 已提交
1150
	if (likely(node)) {
1151
		tipc_node_lock(node);
1152
		l_ptr = node->active_links[sender->ref & 1];
P
Per Liden 已提交
1153
		if (!l_ptr) {
1154
			tipc_node_unlock(node);
P
Per Liden 已提交
1155 1156
			goto reject;
		}
1157
		if (l_ptr->max_pkt < max_pkt) {
1158
			sender->max_pkt = l_ptr->max_pkt;
1159
			tipc_node_unlock(node);
1160
			kfree_skb_list(buf_chain);
P
Per Liden 已提交
1161 1162 1163 1164
			goto again;
		}
	} else {
reject:
1165
		kfree_skb_list(buf_chain);
1166 1167 1168
		tipc_port_iovec_reject(sender, hdr, msg_sect, len,
				       TIPC_ERR_NO_NODE);
		return -ENETUNREACH;
P
Per Liden 已提交
1169 1170
	}

1171
	/* Append chain of fragments to send queue & send them */
1172
	l_ptr->long_msg_seq_no++;
1173 1174
	link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
	l_ptr->stats.sent_fragments += fragm_no;
P
Per Liden 已提交
1175
	l_ptr->stats.sent_fragmented++;
1176 1177
	tipc_link_push_queue(l_ptr);
	tipc_node_unlock(node);
P
Per Liden 已提交
1178 1179 1180
	return dsz;
}

1181
/*
1182
 * tipc_link_push_packet: Push one unsent packet to the media
P
Per Liden 已提交
1183
 */
1184
static u32 tipc_link_push_packet(struct tipc_link *l_ptr)
P
Per Liden 已提交
1185 1186 1187 1188 1189 1190 1191 1192
{
	struct sk_buff *buf = l_ptr->first_out;
	u32 r_q_size = l_ptr->retransm_queue_size;
	u32 r_q_head = l_ptr->retransm_queue_head;

	/* Step to position where retransmission failed, if any,    */
	/* consider that buffers may have been released in meantime */
	if (r_q_size && buf) {
1193
		u32 last = lesser(mod(r_q_head + r_q_size),
P
Per Liden 已提交
1194
				  link_last_sent(l_ptr));
1195
		u32 first = buf_seqno(buf);
P
Per Liden 已提交
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205

		while (buf && less(first, r_q_head)) {
			first = mod(first + 1);
			buf = buf->next;
		}
		l_ptr->retransm_queue_head = r_q_head = first;
		l_ptr->retransm_queue_size = r_q_size = mod(last - first);
	}

	/* Continue retransmission now, if there is anything: */
1206
	if (r_q_size && buf) {
P
Per Liden 已提交
1207
		msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
1208
		msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
1209
		tipc_bearer_send(l_ptr->bearer_id, buf, &l_ptr->media_addr);
1210 1211 1212 1213
		l_ptr->retransm_queue_head = mod(++r_q_head);
		l_ptr->retransm_queue_size = --r_q_size;
		l_ptr->stats.retransmitted++;
		return 0;
P
Per Liden 已提交
1214 1215 1216 1217 1218 1219
	}

	/* Send deferred protocol message, if any: */
	buf = l_ptr->proto_msg_queue;
	if (buf) {
		msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
1220
		msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
1221
		tipc_bearer_send(l_ptr->bearer_id, buf, &l_ptr->media_addr);
1222 1223 1224 1225
		l_ptr->unacked_window = 0;
		kfree_skb(buf);
		l_ptr->proto_msg_queue = NULL;
		return 0;
P
Per Liden 已提交
1226 1227 1228 1229 1230 1231 1232
	}

	/* Send one deferred data message, if send window not full: */
	buf = l_ptr->next_out;
	if (buf) {
		struct tipc_msg *msg = buf_msg(buf);
		u32 next = msg_seqno(msg);
1233
		u32 first = buf_seqno(l_ptr->first_out);
P
Per Liden 已提交
1234 1235 1236

		if (mod(next - first) < l_ptr->queue_limit[0]) {
			msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
1237
			msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
1238 1239
			tipc_bearer_send(l_ptr->bearer_id, buf,
					 &l_ptr->media_addr);
1240 1241 1242 1243
			if (msg_user(msg) == MSG_BUNDLER)
				msg_set_type(msg, CLOSED_MSG);
			l_ptr->next_out = buf->next;
			return 0;
P
Per Liden 已提交
1244 1245
		}
	}
1246
	return 1;
P
Per Liden 已提交
1247 1248 1249 1250 1251 1252
}

/*
 * push_queue(): push out the unsent messages of a link where
 *               congestion has abated. Node is locked
 */
1253
void tipc_link_push_queue(struct tipc_link *l_ptr)
P
Per Liden 已提交
1254 1255 1256 1257
{
	u32 res;

	do {
1258
		res = tipc_link_push_packet(l_ptr);
1259
	} while (!res);
P
Per Liden 已提交
1260 1261
}

1262
void tipc_link_reset_all(struct tipc_node *node)
1263 1264 1265 1266
{
	char addr_string[16];
	u32 i;

1267
	tipc_node_lock(node);
1268

1269
	pr_warn("Resetting all links to %s\n",
1270
		tipc_addr_string_fill(addr_string, node->addr));
1271 1272

	for (i = 0; i < MAX_BEARERS; i++) {
1273 1274 1275
		if (node->links[i]) {
			link_print(node->links[i], "Resetting link\n");
			tipc_link_reset(node->links[i]);
1276 1277 1278
		}
	}

1279
	tipc_node_unlock(node);
1280 1281
}

1282
static void link_retransmit_failure(struct tipc_link *l_ptr,
1283
				    struct sk_buff *buf)
1284 1285 1286
{
	struct tipc_msg *msg = buf_msg(buf);

1287
	pr_warn("Retransmission failure on link <%s>\n", l_ptr->name);
1288 1289 1290

	if (l_ptr->addr) {
		/* Handle failure on standard link */
1291
		link_print(l_ptr, "Resetting link\n");
1292 1293 1294 1295
		tipc_link_reset(l_ptr);

	} else {
		/* Handle failure on broadcast link */
1296
		struct tipc_node *n_ptr;
1297 1298
		char addr_string[16];

1299 1300 1301
		pr_info("Msg seq number: %u,  ", msg_seqno(msg));
		pr_cont("Outstanding acks: %lu\n",
			(unsigned long) TIPC_SKB_CB(buf)->handle);
J
Jeff Garzik 已提交
1302

1303
		n_ptr = tipc_bclink_retransmit_to();
1304 1305
		tipc_node_lock(n_ptr);

1306
		tipc_addr_string_fill(addr_string, n_ptr->addr);
1307
		pr_info("Broadcast link info for %s\n", addr_string);
1308 1309
		pr_info("Reception permitted: %d,  Acked: %u\n",
			n_ptr->bclink.recv_permitted,
1310 1311 1312 1313 1314
			n_ptr->bclink.acked);
		pr_info("Last in: %u,  Oos state: %u,  Last sent: %u\n",
			n_ptr->bclink.last_in,
			n_ptr->bclink.oos_state,
			n_ptr->bclink.last_sent);
1315 1316 1317

		tipc_node_unlock(n_ptr);

1318
		tipc_bclink_set_flags(TIPC_BCLINK_RESET);
1319 1320 1321 1322
		l_ptr->stale_count = 0;
	}
}

1323
void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf,
1324
			  u32 retransmits)
P
Per Liden 已提交
1325 1326 1327
{
	struct tipc_msg *msg;

1328 1329 1330 1331
	if (!buf)
		return;

	msg = buf_msg(buf);
1332

1333 1334 1335 1336 1337
	/* Detect repeated retransmit failures */
	if (l_ptr->last_retransmitted == msg_seqno(msg)) {
		if (++l_ptr->stale_count > 100) {
			link_retransmit_failure(l_ptr, buf);
			return;
1338 1339
		}
	} else {
1340 1341
		l_ptr->last_retransmitted = msg_seqno(msg);
		l_ptr->stale_count = 1;
P
Per Liden 已提交
1342
	}
1343

1344
	while (retransmits && (buf != l_ptr->next_out) && buf) {
P
Per Liden 已提交
1345 1346
		msg = buf_msg(buf);
		msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
1347
		msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
1348
		tipc_bearer_send(l_ptr->bearer_id, buf, &l_ptr->media_addr);
1349 1350 1351
		buf = buf->next;
		retransmits--;
		l_ptr->stats.retransmitted++;
P
Per Liden 已提交
1352
	}
1353

P
Per Liden 已提交
1354 1355 1356
	l_ptr->retransm_queue_head = l_ptr->retransm_queue_size = 0;
}

1357
/**
P
Per Liden 已提交
1358 1359
 * link_insert_deferred_queue - insert deferred messages back into receive chain
 */
1360
static struct sk_buff *link_insert_deferred_queue(struct tipc_link *l_ptr,
P
Per Liden 已提交
1361 1362 1363 1364 1365 1366 1367
						  struct sk_buff *buf)
{
	u32 seq_no;

	if (l_ptr->oldest_deferred_in == NULL)
		return buf;

1368
	seq_no = buf_seqno(l_ptr->oldest_deferred_in);
P
Per Liden 已提交
1369 1370 1371 1372 1373 1374 1375 1376 1377
	if (seq_no == mod(l_ptr->next_in_no)) {
		l_ptr->newest_deferred_in->next = buf;
		buf = l_ptr->oldest_deferred_in;
		l_ptr->oldest_deferred_in = NULL;
		l_ptr->deferred_inqueue_sz = 0;
	}
	return buf;
}

1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
/**
 * link_recv_buf_validate - validate basic format of received message
 *
 * This routine ensures a TIPC message has an acceptable header, and at least
 * as much data as the header indicates it should.  The routine also ensures
 * that the entire message header is stored in the main fragment of the message
 * buffer, to simplify future access to message header fields.
 *
 * Note: Having extra info present in the message header or data areas is OK.
 * TIPC will ignore the excess, under the assumption that it is optional info
 * introduced by a later release of the protocol.
 */
static int link_recv_buf_validate(struct sk_buff *buf)
{
	static u32 min_data_hdr_size[8] = {
1393
		SHORT_H_SIZE, MCAST_H_SIZE, NAMED_H_SIZE, BASIC_H_SIZE,
1394 1395 1396 1397 1398 1399 1400 1401 1402
		MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE
		};

	struct tipc_msg *msg;
	u32 tipc_hdr[2];
	u32 size;
	u32 hdr_size;
	u32 min_hdr_size;

1403 1404 1405 1406 1407 1408
	/* If this packet comes from the defer queue, the skb has already
	 * been validated
	 */
	if (unlikely(TIPC_SKB_CB(buf)->deferred))
		return 1;

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
	if (unlikely(buf->len < MIN_H_SIZE))
		return 0;

	msg = skb_header_pointer(buf, 0, sizeof(tipc_hdr), tipc_hdr);
	if (msg == NULL)
		return 0;

	if (unlikely(msg_version(msg) != TIPC_VERSION))
		return 0;

	size = msg_size(msg);
	hdr_size = msg_hdr_sz(msg);
	min_hdr_size = msg_isdata(msg) ?
		min_data_hdr_size[msg_type(msg)] : INT_H_SIZE;

	if (unlikely((hdr_size < min_hdr_size) ||
		     (size < hdr_size) ||
		     (buf->len < size) ||
		     (size - hdr_size > TIPC_MAX_USER_MSG_SIZE)))
		return 0;

	return pskb_may_pull(buf, hdr_size);
}

1433
/**
1434
 * tipc_rcv - process TIPC packets/messages arriving from off-node
1435
 * @head: pointer to message buffer chain
1436
 * @b_ptr: pointer to bearer message arrived on
1437 1438 1439 1440
 *
 * Invoked with no locks held.  Bearer pointer must point to a valid bearer
 * structure (i.e. cannot be NULL), but bearer can be inactive.
 */
1441
void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr)
P
Per Liden 已提交
1442 1443
{
	while (head) {
1444
		struct tipc_node *n_ptr;
1445
		struct tipc_link *l_ptr;
P
Per Liden 已提交
1446 1447
		struct sk_buff *crs;
		struct sk_buff *buf = head;
1448 1449 1450
		struct tipc_msg *msg;
		u32 seq_no;
		u32 ackd;
P
Per Liden 已提交
1451 1452 1453
		u32 released = 0;

		head = head->next;
1454
		buf->next = NULL;
1455 1456 1457

		/* Ensure message is well-formed */
		if (unlikely(!link_recv_buf_validate(buf)))
1458
			goto discard;
P
Per Liden 已提交
1459

1460
		/* Ensure message data is a single contiguous unit */
1461
		if (unlikely(skb_linearize(buf)))
1462
			goto discard;
1463

1464 1465 1466
		/* Handle arrival of a non-unicast link message */
		msg = buf_msg(buf);

P
Per Liden 已提交
1467
		if (unlikely(msg_non_seq(msg))) {
1468
			if (msg_user(msg) ==  LINK_CONFIG)
1469
				tipc_disc_rcv(buf, b_ptr);
1470
			else
1471
				tipc_bclink_rcv(buf);
P
Per Liden 已提交
1472 1473
			continue;
		}
1474

1475
		/* Discard unicast link messages destined for another node */
1476 1477
		if (unlikely(!msg_short(msg) &&
			     (msg_destnode(msg) != tipc_own_addr)))
1478
			goto discard;
1479

1480
		/* Locate neighboring node that sent message */
1481
		n_ptr = tipc_node_find(msg_prevnode(msg));
P
Per Liden 已提交
1482
		if (unlikely(!n_ptr))
1483
			goto discard;
1484
		tipc_node_lock(n_ptr);
1485

1486 1487
		/* Locate unicast link endpoint that should handle message */
		l_ptr = n_ptr->links[b_ptr->identity];
1488 1489
		if (unlikely(!l_ptr))
			goto unlock_discard;
1490

1491
		/* Verify that communication with node is currently allowed */
1492 1493 1494 1495 1496 1497 1498 1499
		if ((n_ptr->flags & TIPC_NODE_DOWN) &&
		    msg_user(msg) == LINK_PROTOCOL &&
		    (msg_type(msg) == RESET_MSG ||
		    msg_type(msg) == ACTIVATE_MSG) &&
		    !msg_redundant_link(msg))
			n_ptr->flags &= ~TIPC_NODE_DOWN;

		if (tipc_node_blocked(n_ptr))
1500
			goto unlock_discard;
1501 1502 1503 1504 1505 1506

		/* Validate message sequence number info */
		seq_no = msg_seqno(msg);
		ackd = msg_ack(msg);

		/* Release acked messages */
1507
		if (n_ptr->bclink.recv_permitted)
1508
			tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
P
Per Liden 已提交
1509 1510

		crs = l_ptr->first_out;
1511
		while ((crs != l_ptr->next_out) &&
1512
		       less_eq(buf_seqno(crs), ackd)) {
P
Per Liden 已提交
1513
			struct sk_buff *next = crs->next;
1514
			kfree_skb(crs);
P
Per Liden 已提交
1515 1516 1517 1518 1519 1520 1521
			crs = next;
			released++;
		}
		if (released) {
			l_ptr->first_out = crs;
			l_ptr->out_queue_size -= released;
		}
1522 1523

		/* Try sending any messages link endpoint has pending */
P
Per Liden 已提交
1524
		if (unlikely(l_ptr->next_out))
1525
			tipc_link_push_queue(l_ptr);
1526

P
Per Liden 已提交
1527
		if (unlikely(!list_empty(&l_ptr->waiting_ports)))
1528
			tipc_link_wakeup_ports(l_ptr, 0);
1529

P
Per Liden 已提交
1530 1531
		if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
			l_ptr->stats.sent_acks++;
1532
			tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
P
Per Liden 已提交
1533 1534
		}

1535
		/* Process the incoming packet */
1536 1537
		if (unlikely(!link_working_working(l_ptr))) {
			if (msg_user(msg) == LINK_PROTOCOL) {
1538
				tipc_link_proto_rcv(l_ptr, buf);
1539
				head = link_insert_deferred_queue(l_ptr, head);
1540
				tipc_node_unlock(n_ptr);
P
Per Liden 已提交
1541 1542
				continue;
			}
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558

			/* Traffic message. Conditionally activate link */
			link_state_event(l_ptr, TRAFFIC_MSG_EVT);

			if (link_working_working(l_ptr)) {
				/* Re-insert buffer in front of queue */
				buf->next = head;
				head = buf;
				tipc_node_unlock(n_ptr);
				continue;
			}
			goto unlock_discard;
		}

		/* Link is now in state WORKING_WORKING */
		if (unlikely(seq_no != mod(l_ptr->next_in_no))) {
P
Per Liden 已提交
1559 1560
			link_handle_out_of_seq_msg(l_ptr, buf);
			head = link_insert_deferred_queue(l_ptr, head);
1561
			tipc_node_unlock(n_ptr);
P
Per Liden 已提交
1562 1563
			continue;
		}
1564 1565
		l_ptr->next_in_no++;
		if (unlikely(l_ptr->oldest_deferred_in))
P
Per Liden 已提交
1566
			head = link_insert_deferred_queue(l_ptr, head);
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597

		/* Deliver packet/message to correct user: */
		if (unlikely(msg_user(msg) ==  CHANGEOVER_PROTOCOL)) {
			if (!tipc_link_tunnel_rcv(n_ptr, &buf)) {
				tipc_node_unlock(n_ptr);
				continue;
			}
			msg = buf_msg(buf);
		} else if (msg_user(msg) == MSG_FRAGMENTER) {
			int rc;

			l_ptr->stats.recv_fragments++;
			rc = tipc_link_frag_rcv(&l_ptr->reasm_head,
						&l_ptr->reasm_tail,
						&buf);
			if (rc == LINK_REASM_COMPLETE) {
				l_ptr->stats.recv_fragmented++;
				msg = buf_msg(buf);
			} else {
				if (rc == LINK_REASM_ERROR)
					tipc_link_reset(l_ptr);
				tipc_node_unlock(n_ptr);
				continue;
			}
		}

		switch (msg_user(msg)) {
		case TIPC_LOW_IMPORTANCE:
		case TIPC_MEDIUM_IMPORTANCE:
		case TIPC_HIGH_IMPORTANCE:
		case TIPC_CRITICAL_IMPORTANCE:
1598
			tipc_node_unlock(n_ptr);
1599
			tipc_port_rcv(buf);
P
Per Liden 已提交
1600
			continue;
1601 1602 1603 1604
		case MSG_BUNDLER:
			l_ptr->stats.recv_bundles++;
			l_ptr->stats.recv_bundled += msg_msgcnt(msg);
			tipc_node_unlock(n_ptr);
1605
			tipc_link_bundle_rcv(buf);
1606 1607 1608 1609
			continue;
		case NAME_DISTRIBUTOR:
			n_ptr->bclink.recv_permitted = true;
			tipc_node_unlock(n_ptr);
1610
			tipc_named_rcv(buf);
1611 1612 1613
			continue;
		case CONN_MANAGER:
			tipc_node_unlock(n_ptr);
1614
			tipc_port_proto_rcv(buf);
1615
			continue;
1616
		case BCAST_PROTOCOL:
1617
			tipc_link_sync_rcv(n_ptr, buf);
1618
			break;
1619 1620 1621
		default:
			kfree_skb(buf);
			break;
P
Per Liden 已提交
1622
		}
1623
		tipc_node_unlock(n_ptr);
1624 1625 1626 1627
		continue;
unlock_discard:
		tipc_node_unlock(n_ptr);
discard:
1628
		kfree_skb(buf);
P
Per Liden 已提交
1629 1630 1631
	}
}

1632
/**
1633 1634 1635
 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
 *
 * Returns increase in queue length (i.e. 0 or 1)
P
Per Liden 已提交
1636
 */
1637
u32 tipc_link_defer_pkt(struct sk_buff **head, struct sk_buff **tail,
1638
			struct sk_buff *buf)
P
Per Liden 已提交
1639
{
1640 1641
	struct sk_buff *queue_buf;
	struct sk_buff **prev;
1642
	u32 seq_no = buf_seqno(buf);
P
Per Liden 已提交
1643 1644 1645 1646 1647 1648 1649 1650 1651 1652

	buf->next = NULL;

	/* Empty queue ? */
	if (*head == NULL) {
		*head = *tail = buf;
		return 1;
	}

	/* Last ? */
1653
	if (less(buf_seqno(*tail), seq_no)) {
P
Per Liden 已提交
1654 1655 1656 1657 1658
		(*tail)->next = buf;
		*tail = buf;
		return 1;
	}

1659 1660 1661 1662 1663
	/* Locate insertion point in queue, then insert; discard if duplicate */
	prev = head;
	queue_buf = *head;
	for (;;) {
		u32 curr_seqno = buf_seqno(queue_buf);
P
Per Liden 已提交
1664

1665
		if (seq_no == curr_seqno) {
1666
			kfree_skb(buf);
1667
			return 0;
P
Per Liden 已提交
1668
		}
1669 1670

		if (less(seq_no, curr_seqno))
P
Per Liden 已提交
1671 1672
			break;

1673 1674 1675
		prev = &queue_buf->next;
		queue_buf = queue_buf->next;
	}
P
Per Liden 已提交
1676

1677 1678 1679
	buf->next = queue_buf;
	*prev = buf;
	return 1;
P
Per Liden 已提交
1680 1681
}

1682
/*
P
Per Liden 已提交
1683 1684
 * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
 */
1685
static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
P
Per Liden 已提交
1686 1687
				       struct sk_buff *buf)
{
1688
	u32 seq_no = buf_seqno(buf);
P
Per Liden 已提交
1689 1690

	if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) {
1691
		tipc_link_proto_rcv(l_ptr, buf);
P
Per Liden 已提交
1692 1693 1694 1695 1696 1697
		return;
	}

	/* Record OOS packet arrival (force mismatch on next timeout) */
	l_ptr->checkpoint--;

1698
	/*
P
Per Liden 已提交
1699 1700 1701 1702 1703
	 * Discard packet if a duplicate; otherwise add it to deferred queue
	 * and notify peer of gap as per protocol specification
	 */
	if (less(seq_no, mod(l_ptr->next_in_no))) {
		l_ptr->stats.duplicates++;
1704
		kfree_skb(buf);
P
Per Liden 已提交
1705 1706 1707
		return;
	}

1708 1709
	if (tipc_link_defer_pkt(&l_ptr->oldest_deferred_in,
				&l_ptr->newest_deferred_in, buf)) {
P
Per Liden 已提交
1710 1711
		l_ptr->deferred_inqueue_sz++;
		l_ptr->stats.deferred_recv++;
1712
		TIPC_SKB_CB(buf)->deferred = true;
P
Per Liden 已提交
1713
		if ((l_ptr->deferred_inqueue_sz % 16) == 1)
1714
			tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
P
Per Liden 已提交
1715 1716 1717 1718 1719 1720 1721
	} else
		l_ptr->stats.duplicates++;
}

/*
 * Send protocol message to the other endpoint.
 */
1722 1723
void tipc_link_proto_xmit(struct tipc_link *l_ptr, u32 msg_typ, int probe_msg,
			  u32 gap, u32 tolerance, u32 priority, u32 ack_mtu)
P
Per Liden 已提交
1724
{
1725
	struct sk_buff *buf = NULL;
P
Per Liden 已提交
1726
	struct tipc_msg *msg = l_ptr->pmsg;
1727
	u32 msg_size = sizeof(l_ptr->proto_msg);
1728
	int r_flag;
P
Per Liden 已提交
1729

1730 1731
	/* Discard any previous message that was deferred due to congestion */
	if (l_ptr->proto_msg_queue) {
1732
		kfree_skb(l_ptr->proto_msg_queue);
1733 1734 1735
		l_ptr->proto_msg_queue = NULL;
	}

1736 1737
	/* Don't send protocol message during link changeover */
	if (l_ptr->exp_msg_count)
P
Per Liden 已提交
1738
		return;
1739 1740

	/* Abort non-RESET send if communication with node is prohibited */
1741
	if ((tipc_node_blocked(l_ptr->owner)) && (msg_typ != RESET_MSG))
1742 1743
		return;

1744
	/* Create protocol message with "out-of-sequence" sequence number */
P
Per Liden 已提交
1745
	msg_set_type(msg, msg_typ);
1746
	msg_set_net_plane(msg, l_ptr->net_plane);
1747
	msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
1748
	msg_set_last_bcast(msg, tipc_bclink_get_last_sent());
P
Per Liden 已提交
1749 1750 1751 1752

	if (msg_typ == STATE_MSG) {
		u32 next_sent = mod(l_ptr->next_out_no);

1753
		if (!tipc_link_is_up(l_ptr))
P
Per Liden 已提交
1754 1755
			return;
		if (l_ptr->next_out)
1756
			next_sent = buf_seqno(l_ptr->next_out);
P
Per Liden 已提交
1757 1758
		msg_set_next_sent(msg, next_sent);
		if (l_ptr->oldest_deferred_in) {
1759
			u32 rec = buf_seqno(l_ptr->oldest_deferred_in);
P
Per Liden 已提交
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
			gap = mod(rec - mod(l_ptr->next_in_no));
		}
		msg_set_seq_gap(msg, gap);
		if (gap)
			l_ptr->stats.sent_nacks++;
		msg_set_link_tolerance(msg, tolerance);
		msg_set_linkprio(msg, priority);
		msg_set_max_pkt(msg, ack_mtu);
		msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
		msg_set_probe(msg, probe_msg != 0);
1770
		if (probe_msg) {
P
Per Liden 已提交
1771 1772
			u32 mtu = l_ptr->max_pkt;

1773
			if ((mtu < l_ptr->max_pkt_target) &&
P
Per Liden 已提交
1774 1775 1776
			    link_working_working(l_ptr) &&
			    l_ptr->fsm_msg_cnt) {
				msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
1777 1778 1779
				if (l_ptr->max_pkt_probes == 10) {
					l_ptr->max_pkt_target = (msg_size - 4);
					l_ptr->max_pkt_probes = 0;
P
Per Liden 已提交
1780
					msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
1781
				}
P
Per Liden 已提交
1782
				l_ptr->max_pkt_probes++;
1783
			}
P
Per Liden 已提交
1784 1785

			l_ptr->stats.sent_probes++;
1786
		}
P
Per Liden 已提交
1787 1788 1789 1790 1791
		l_ptr->stats.sent_states++;
	} else {		/* RESET_MSG or ACTIVATE_MSG */
		msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
		msg_set_seq_gap(msg, 0);
		msg_set_next_sent(msg, 1);
1792
		msg_set_probe(msg, 0);
P
Per Liden 已提交
1793 1794 1795 1796 1797
		msg_set_link_tolerance(msg, l_ptr->tolerance);
		msg_set_linkprio(msg, l_ptr->priority);
		msg_set_max_pkt(msg, l_ptr->max_pkt_target);
	}

1798 1799
	r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr));
	msg_set_redundant_link(msg, r_flag);
P
Per Liden 已提交
1800
	msg_set_linkprio(msg, l_ptr->priority);
1801
	msg_set_size(msg, msg_size);
P
Per Liden 已提交
1802 1803 1804

	msg_set_seqno(msg, mod(l_ptr->next_out_no + (0xffff/2)));

1805
	buf = tipc_buf_acquire(msg_size);
P
Per Liden 已提交
1806 1807 1808
	if (!buf)
		return;

1809
	skb_copy_to_linear_data(buf, msg, sizeof(l_ptr->proto_msg));
1810
	buf->priority = TC_PRIO_CONTROL;
P
Per Liden 已提交
1811

1812
	tipc_bearer_send(l_ptr->bearer_id, buf, &l_ptr->media_addr);
1813
	l_ptr->unacked_window = 0;
1814
	kfree_skb(buf);
P
Per Liden 已提交
1815 1816 1817 1818
}

/*
 * Receive protocol message :
1819 1820
 * Note that network plane id propagates through the network, and may
 * change at any time. The node with lowest address rules
P
Per Liden 已提交
1821
 */
1822
static void tipc_link_proto_rcv(struct tipc_link *l_ptr, struct sk_buff *buf)
P
Per Liden 已提交
1823 1824 1825
{
	u32 rec_gap = 0;
	u32 max_pkt_info;
1826
	u32 max_pkt_ack;
P
Per Liden 已提交
1827 1828 1829
	u32 msg_tol;
	struct tipc_msg *msg = buf_msg(buf);

1830 1831
	/* Discard protocol message during link changeover */
	if (l_ptr->exp_msg_count)
P
Per Liden 已提交
1832 1833 1834 1835 1836
		goto exit;

	/* record unnumbered packet arrival (force mismatch on next timeout) */
	l_ptr->checkpoint--;

1837
	if (l_ptr->net_plane != msg_net_plane(msg))
P
Per Liden 已提交
1838
		if (tipc_own_addr > msg_prevnode(msg))
1839
			l_ptr->net_plane = msg_net_plane(msg);
P
Per Liden 已提交
1840 1841

	switch (msg_type(msg)) {
1842

P
Per Liden 已提交
1843
	case RESET_MSG:
1844 1845
		if (!link_working_unknown(l_ptr) &&
		    (l_ptr->peer_session != INVALID_SESSION)) {
1846 1847
			if (less_eq(msg_session(msg), l_ptr->peer_session))
				break; /* duplicate or old reset: ignore */
P
Per Liden 已提交
1848
		}
1849 1850 1851 1852 1853 1854 1855

		if (!msg_redundant_link(msg) && (link_working_working(l_ptr) ||
				link_working_unknown(l_ptr))) {
			/*
			 * peer has lost contact -- don't allow peer's links
			 * to reactivate before we recognize loss & clean up
			 */
1856
			l_ptr->owner->flags = TIPC_NODE_RESET;
1857 1858
		}

1859 1860
		link_state_event(l_ptr, RESET_MSG);

P
Per Liden 已提交
1861 1862 1863 1864 1865
		/* fall thru' */
	case ACTIVATE_MSG:
		/* Update link settings according other endpoint's values */
		strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg));

1866 1867
		msg_tol = msg_link_tolerance(msg);
		if (msg_tol > l_ptr->tolerance)
P
Per Liden 已提交
1868 1869 1870 1871 1872 1873
			link_set_supervision_props(l_ptr, msg_tol);

		if (msg_linkprio(msg) > l_ptr->priority)
			l_ptr->priority = msg_linkprio(msg);

		max_pkt_info = msg_max_pkt(msg);
1874
		if (max_pkt_info) {
P
Per Liden 已提交
1875 1876 1877 1878 1879
			if (max_pkt_info < l_ptr->max_pkt_target)
				l_ptr->max_pkt_target = max_pkt_info;
			if (l_ptr->max_pkt > l_ptr->max_pkt_target)
				l_ptr->max_pkt = l_ptr->max_pkt_target;
		} else {
1880
			l_ptr->max_pkt = l_ptr->max_pkt_target;
P
Per Liden 已提交
1881 1882
		}

1883
		/* Synchronize broadcast link info, if not done previously */
1884 1885 1886 1887 1888 1889
		if (!tipc_node_is_up(l_ptr->owner)) {
			l_ptr->owner->bclink.last_sent =
				l_ptr->owner->bclink.last_in =
				msg_last_bcast(msg);
			l_ptr->owner->bclink.oos_state = 0;
		}
1890

P
Per Liden 已提交
1891 1892
		l_ptr->peer_session = msg_session(msg);
		l_ptr->peer_bearer_id = msg_bearer_id(msg);
1893 1894 1895

		if (msg_type(msg) == ACTIVATE_MSG)
			link_state_event(l_ptr, ACTIVATE_MSG);
P
Per Liden 已提交
1896 1897 1898
		break;
	case STATE_MSG:

1899 1900
		msg_tol = msg_link_tolerance(msg);
		if (msg_tol)
P
Per Liden 已提交
1901
			link_set_supervision_props(l_ptr, msg_tol);
1902 1903

		if (msg_linkprio(msg) &&
P
Per Liden 已提交
1904
		    (msg_linkprio(msg) != l_ptr->priority)) {
1905 1906 1907
			pr_warn("%s<%s>, priority change %u->%u\n",
				link_rst_msg, l_ptr->name, l_ptr->priority,
				msg_linkprio(msg));
P
Per Liden 已提交
1908
			l_ptr->priority = msg_linkprio(msg);
1909
			tipc_link_reset(l_ptr); /* Enforce change to take effect */
P
Per Liden 已提交
1910 1911 1912 1913 1914 1915 1916 1917
			break;
		}
		link_state_event(l_ptr, TRAFFIC_MSG_EVT);
		l_ptr->stats.recv_states++;
		if (link_reset_unknown(l_ptr))
			break;

		if (less_eq(mod(l_ptr->next_in_no), msg_next_sent(msg))) {
1918
			rec_gap = mod(msg_next_sent(msg) -
P
Per Liden 已提交
1919 1920 1921 1922
				      mod(l_ptr->next_in_no));
		}

		max_pkt_ack = msg_max_pkt(msg);
1923 1924 1925 1926
		if (max_pkt_ack > l_ptr->max_pkt) {
			l_ptr->max_pkt = max_pkt_ack;
			l_ptr->max_pkt_probes = 0;
		}
P
Per Liden 已提交
1927 1928

		max_pkt_ack = 0;
1929
		if (msg_probe(msg)) {
P
Per Liden 已提交
1930
			l_ptr->stats.recv_probes++;
1931
			if (msg_size(msg) > sizeof(l_ptr->proto_msg))
1932 1933
				max_pkt_ack = msg_size(msg);
		}
P
Per Liden 已提交
1934 1935

		/* Protocol message before retransmits, reduce loss risk */
1936
		if (l_ptr->owner->bclink.recv_permitted)
1937 1938
			tipc_bclink_update_link_state(l_ptr->owner,
						      msg_last_bcast(msg));
P
Per Liden 已提交
1939 1940

		if (rec_gap || (msg_probe(msg))) {
1941 1942
			tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, rec_gap, 0,
					     0, max_pkt_ack);
P
Per Liden 已提交
1943 1944 1945
		}
		if (msg_seq_gap(msg)) {
			l_ptr->stats.recv_nacks++;
1946 1947
			tipc_link_retransmit(l_ptr, l_ptr->first_out,
					     msg_seq_gap(msg));
P
Per Liden 已提交
1948 1949 1950 1951
		}
		break;
	}
exit:
1952
	kfree_skb(buf);
P
Per Liden 已提交
1953 1954 1955
}


1956 1957
/* tipc_link_tunnel_xmit(): Tunnel one packet via a link belonging to
 * a different bearer. Owner node is locked.
P
Per Liden 已提交
1958
 */
1959 1960 1961 1962
static void tipc_link_tunnel_xmit(struct tipc_link *l_ptr,
				  struct tipc_msg *tunnel_hdr,
				  struct tipc_msg *msg,
				  u32 selector)
P
Per Liden 已提交
1963
{
1964
	struct tipc_link *tunnel;
P
Per Liden 已提交
1965 1966 1967 1968
	struct sk_buff *buf;
	u32 length = msg_size(msg);

	tunnel = l_ptr->owner->active_links[selector & 1];
1969
	if (!tipc_link_is_up(tunnel)) {
1970
		pr_warn("%stunnel link no longer available\n", link_co_err);
P
Per Liden 已提交
1971
		return;
1972
	}
P
Per Liden 已提交
1973
	msg_set_size(tunnel_hdr, length + INT_H_SIZE);
1974
	buf = tipc_buf_acquire(length + INT_H_SIZE);
1975
	if (!buf) {
1976
		pr_warn("%sunable to send tunnel msg\n", link_co_err);
P
Per Liden 已提交
1977
		return;
1978
	}
1979 1980
	skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE);
	skb_copy_to_linear_data_offset(buf, INT_H_SIZE, msg, length);
1981
	__tipc_link_xmit(tunnel, buf);
P
Per Liden 已提交
1982 1983 1984
}


1985 1986 1987 1988 1989
/* tipc_link_failover_send_queue(): A link has gone down, but a second
 * link is still active. We can do failover. Tunnel the failing link's
 * whole send queue via the remaining link. This way, we don't lose
 * any packets, and sequence order is preserved for subsequent traffic
 * sent over the remaining link. Owner node is locked.
P
Per Liden 已提交
1990
 */
1991
void tipc_link_failover_send_queue(struct tipc_link *l_ptr)
P
Per Liden 已提交
1992 1993 1994
{
	u32 msgcount = l_ptr->out_queue_size;
	struct sk_buff *crs = l_ptr->first_out;
1995
	struct tipc_link *tunnel = l_ptr->owner->active_links[0];
P
Per Liden 已提交
1996
	struct tipc_msg tunnel_hdr;
1997
	int split_bundles;
P
Per Liden 已提交
1998 1999 2000 2001

	if (!tunnel)
		return;

2002
	tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
2003
		 ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
P
Per Liden 已提交
2004 2005
	msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
	msg_set_msgcnt(&tunnel_hdr, msgcount);
2006

P
Per Liden 已提交
2007 2008 2009
	if (!l_ptr->first_out) {
		struct sk_buff *buf;

2010
		buf = tipc_buf_acquire(INT_H_SIZE);
P
Per Liden 已提交
2011
		if (buf) {
2012
			skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);
P
Per Liden 已提交
2013
			msg_set_size(&tunnel_hdr, INT_H_SIZE);
2014
			__tipc_link_xmit(tunnel, buf);
P
Per Liden 已提交
2015
		} else {
2016 2017
			pr_warn("%sunable to send changeover msg\n",
				link_co_err);
P
Per Liden 已提交
2018 2019 2020
		}
		return;
	}
2021

2022
	split_bundles = (l_ptr->owner->active_links[0] !=
2023 2024
			 l_ptr->owner->active_links[1]);

P
Per Liden 已提交
2025 2026 2027 2028 2029
	while (crs) {
		struct tipc_msg *msg = buf_msg(crs);

		if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
			struct tipc_msg *m = msg_get_wrapped(msg);
2030
			unchar *pos = (unchar *)m;
P
Per Liden 已提交
2031

2032
			msgcount = msg_msgcnt(msg);
P
Per Liden 已提交
2033
			while (msgcount--) {
2034
				msg_set_seqno(m, msg_seqno(msg));
2035 2036
				tipc_link_tunnel_xmit(l_ptr, &tunnel_hdr, m,
						      msg_link_selector(m));
P
Per Liden 已提交
2037 2038 2039 2040
				pos += align(msg_size(m));
				m = (struct tipc_msg *)pos;
			}
		} else {
2041 2042
			tipc_link_tunnel_xmit(l_ptr, &tunnel_hdr, msg,
					      msg_link_selector(msg));
P
Per Liden 已提交
2043 2044 2045 2046 2047
		}
		crs = crs->next;
	}
}

2048
/* tipc_link_dup_queue_xmit(): A second link has become active. Tunnel a
2049 2050 2051 2052 2053 2054 2055 2056
 * duplicate of the first link's send queue via the new link. This way, we
 * are guaranteed that currently queued packets from a socket are delivered
 * before future traffic from the same socket, even if this is using the
 * new link. The last arriving copy of each duplicate packet is dropped at
 * the receiving end by the regular protocol check, so packet cardinality
 * and sequence order is preserved per sender/receiver socket pair.
 * Owner node is locked.
 */
2057
void tipc_link_dup_queue_xmit(struct tipc_link *l_ptr,
2058
			      struct tipc_link *tunnel)
P
Per Liden 已提交
2059 2060 2061 2062
{
	struct sk_buff *iter;
	struct tipc_msg tunnel_hdr;

2063
	tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
2064
		 DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr);
P
Per Liden 已提交
2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
	msg_set_msgcnt(&tunnel_hdr, l_ptr->out_queue_size);
	msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
	iter = l_ptr->first_out;
	while (iter) {
		struct sk_buff *outbuf;
		struct tipc_msg *msg = buf_msg(iter);
		u32 length = msg_size(msg);

		if (msg_user(msg) == MSG_BUNDLER)
			msg_set_type(msg, CLOSED_MSG);
		msg_set_ack(msg, mod(l_ptr->next_in_no - 1));	/* Update */
2076
		msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
P
Per Liden 已提交
2077
		msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
2078
		outbuf = tipc_buf_acquire(length + INT_H_SIZE);
P
Per Liden 已提交
2079
		if (outbuf == NULL) {
2080 2081
			pr_warn("%sunable to send duplicate msg\n",
				link_co_err);
P
Per Liden 已提交
2082 2083
			return;
		}
2084 2085 2086
		skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);
		skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data,
					       length);
2087
		__tipc_link_xmit(tunnel, outbuf);
2088
		if (!tipc_link_is_up(l_ptr))
P
Per Liden 已提交
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
			return;
		iter = iter->next;
	}
}

/**
 * buf_extract - extracts embedded TIPC message from another message
 * @skb: encapsulating message buffer
 * @from_pos: offset to extract from
 *
2099
 * Returns a new message buffer containing an embedded message.  The
P
Per Liden 已提交
2100 2101 2102 2103 2104 2105 2106 2107
 * encapsulating message itself is left unchanged.
 */
static struct sk_buff *buf_extract(struct sk_buff *skb, u32 from_pos)
{
	struct tipc_msg *msg = (struct tipc_msg *)(skb->data + from_pos);
	u32 size = msg_size(msg);
	struct sk_buff *eb;

2108
	eb = tipc_buf_acquire(size);
P
Per Liden 已提交
2109
	if (eb)
2110
		skb_copy_to_linear_data(eb, msg, size);
P
Per Liden 已提交
2111 2112 2113
	return eb;
}

2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136


/* tipc_link_dup_rcv(): Receive a tunnelled DUPLICATE_MSG packet.
 * Owner node is locked.
 */
static void tipc_link_dup_rcv(struct tipc_link *l_ptr,
			      struct sk_buff *t_buf)
{
	struct sk_buff *buf;

	if (!tipc_link_is_up(l_ptr))
		return;

	buf = buf_extract(t_buf, INT_H_SIZE);
	if (buf == NULL) {
		pr_warn("%sfailed to extract inner dup pkt\n", link_co_err);
		return;
	}

	/* Add buffer to deferred queue, if applicable: */
	link_handle_out_of_seq_msg(l_ptr, buf);
}

2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
/*  tipc_link_failover_rcv(): Receive a tunnelled ORIGINAL_MSG packet
 *  Owner node is locked.
 */
static struct sk_buff *tipc_link_failover_rcv(struct tipc_link *l_ptr,
					      struct sk_buff *t_buf)
{
	struct tipc_msg *t_msg = buf_msg(t_buf);
	struct sk_buff *buf = NULL;
	struct tipc_msg *msg;

	if (tipc_link_is_up(l_ptr))
		tipc_link_reset(l_ptr);

	/* First failover packet? */
	if (l_ptr->exp_msg_count == START_CHANGEOVER)
		l_ptr->exp_msg_count = msg_msgcnt(t_msg);

	/* Should there be an inner packet? */
	if (l_ptr->exp_msg_count) {
		l_ptr->exp_msg_count--;
		buf = buf_extract(t_buf, INT_H_SIZE);
		if (buf == NULL) {
			pr_warn("%sno inner failover pkt\n", link_co_err);
			goto exit;
		}
		msg = buf_msg(buf);

		if (less(msg_seqno(msg), l_ptr->reset_checkpoint)) {
			kfree_skb(buf);
			buf = NULL;
			goto exit;
		}
		if (msg_user(msg) == MSG_FRAGMENTER) {
			l_ptr->stats.recv_fragments++;
			tipc_link_frag_rcv(&l_ptr->reasm_head,
					   &l_ptr->reasm_tail,
					   &buf);
		}
	}
exit:
2177 2178 2179 2180
	if ((l_ptr->exp_msg_count == 0) && (l_ptr->flags & LINK_STOPPED)) {
		tipc_node_detach_link(l_ptr->owner, l_ptr);
		kfree(l_ptr);
	}
2181 2182 2183
	return buf;
}

2184
/*  tipc_link_tunnel_rcv(): Receive a tunnelled packet, sent
2185 2186 2187 2188
 *  via other link as result of a failover (ORIGINAL_MSG) or
 *  a new active link (DUPLICATE_MSG). Failover packets are
 *  returned to the active link for delivery upwards.
 *  Owner node is locked.
P
Per Liden 已提交
2189
 */
2190
static int tipc_link_tunnel_rcv(struct tipc_node *n_ptr,
2191
				struct sk_buff **buf)
P
Per Liden 已提交
2192
{
2193 2194 2195 2196
	struct sk_buff *t_buf = *buf;
	struct tipc_link *l_ptr;
	struct tipc_msg *t_msg = buf_msg(t_buf);
	u32 bearer_id = msg_bearer_id(t_msg);
P
Per Liden 已提交
2197

2198 2199
	*buf = NULL;

2200 2201
	if (bearer_id >= MAX_BEARERS)
		goto exit;
2202

2203 2204
	l_ptr = n_ptr->links[bearer_id];
	if (!l_ptr)
P
Per Liden 已提交
2205 2206
		goto exit;

2207 2208 2209 2210
	if (msg_type(t_msg) == DUPLICATE_MSG)
		tipc_link_dup_rcv(l_ptr, t_buf);
	else if (msg_type(t_msg) == ORIGINAL_MSG)
		*buf = tipc_link_failover_rcv(l_ptr, t_buf);
2211 2212
	else
		pr_warn("%sunknown tunnel pkt received\n", link_co_err);
P
Per Liden 已提交
2213
exit:
2214
	kfree_skb(t_buf);
2215
	return *buf != NULL;
P
Per Liden 已提交
2216 2217 2218 2219 2220
}

/*
 *  Bundler functionality:
 */
2221
void tipc_link_bundle_rcv(struct sk_buff *buf)
P
Per Liden 已提交
2222 2223 2224 2225 2226 2227 2228 2229
{
	u32 msgcount = msg_msgcnt(buf_msg(buf));
	u32 pos = INT_H_SIZE;
	struct sk_buff *obuf;

	while (msgcount--) {
		obuf = buf_extract(buf, pos);
		if (obuf == NULL) {
2230
			pr_warn("Link unable to unbundle message(s)\n");
2231
			break;
2232
		}
P
Per Liden 已提交
2233
		pos += align(msg_size(buf_msg(obuf)));
2234
		tipc_net_route_msg(obuf);
P
Per Liden 已提交
2235
	}
2236
	kfree_skb(buf);
P
Per Liden 已提交
2237 2238 2239 2240 2241 2242
}

/*
 *  Fragmentation/defragmentation:
 */

2243
/*
2244
 * tipc_link_frag_xmit: Entry for buffers needing fragmentation.
2245
 * The buffer is complete, inclusive total message length.
P
Per Liden 已提交
2246 2247
 * Returns user data length.
 */
2248
static int tipc_link_frag_xmit(struct tipc_link *l_ptr, struct sk_buff *buf)
P
Per Liden 已提交
2249
{
2250 2251
	struct sk_buff *buf_chain = NULL;
	struct sk_buff *buf_chain_tail = (struct sk_buff *)&buf_chain;
P
Per Liden 已提交
2252 2253 2254 2255 2256 2257
	struct tipc_msg *inmsg = buf_msg(buf);
	struct tipc_msg fragm_hdr;
	u32 insize = msg_size(inmsg);
	u32 dsz = msg_data_sz(inmsg);
	unchar *crs = buf->data;
	u32 rest = insize;
2258
	u32 pack_sz = l_ptr->max_pkt;
P
Per Liden 已提交
2259
	u32 fragm_sz = pack_sz - INT_H_SIZE;
2260
	u32 fragm_no = 0;
2261
	u32 destaddr;
P
Per Liden 已提交
2262 2263 2264

	if (msg_short(inmsg))
		destaddr = l_ptr->addr;
2265 2266
	else
		destaddr = msg_destnode(inmsg);
P
Per Liden 已提交
2267 2268

	/* Prepare reusable fragment header: */
2269
	tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
2270
		 INT_H_SIZE, destaddr);
P
Per Liden 已提交
2271 2272 2273 2274 2275 2276 2277 2278 2279

	/* Chop up message: */
	while (rest > 0) {
		struct sk_buff *fragm;

		if (rest <= fragm_sz) {
			fragm_sz = rest;
			msg_set_type(&fragm_hdr, LAST_FRAGMENT);
		}
2280
		fragm = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
P
Per Liden 已提交
2281
		if (fragm == NULL) {
2282
			kfree_skb(buf);
2283
			kfree_skb_list(buf_chain);
2284
			return -ENOMEM;
P
Per Liden 已提交
2285 2286
		}
		msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
2287 2288
		fragm_no++;
		msg_set_fragm_no(&fragm_hdr, fragm_no);
2289 2290 2291
		skb_copy_to_linear_data(fragm, &fragm_hdr, INT_H_SIZE);
		skb_copy_to_linear_data_offset(fragm, INT_H_SIZE, crs,
					       fragm_sz);
2292 2293
		buf_chain_tail->next = fragm;
		buf_chain_tail = fragm;
P
Per Liden 已提交
2294 2295 2296 2297 2298

		rest -= fragm_sz;
		crs += fragm_sz;
		msg_set_type(&fragm_hdr, FRAGMENT);
	}
2299
	kfree_skb(buf);
2300 2301 2302 2303 2304 2305 2306 2307

	/* Append chain of fragments to send queue & send them */
	l_ptr->long_msg_seq_no++;
	link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
	l_ptr->stats.sent_fragments += fragm_no;
	l_ptr->stats.sent_fragmented++;
	tipc_link_push_queue(l_ptr);

P
Per Liden 已提交
2308 2309 2310
	return dsz;
}

2311
/* tipc_link_frag_rcv(): Called with node lock on. Returns
P
Per Liden 已提交
2312 2313
 * the reassembled buffer if message is complete.
 */
2314 2315
int tipc_link_frag_rcv(struct sk_buff **head, struct sk_buff **tail,
		       struct sk_buff **fbuf)
P
Per Liden 已提交
2316
{
2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328
	struct sk_buff *frag = *fbuf;
	struct tipc_msg *msg = buf_msg(frag);
	u32 fragid = msg_type(msg);
	bool headstolen;
	int delta;

	skb_pull(frag, msg_hdr_sz(msg));
	if (fragid == FIRST_FRAGMENT) {
		if (*head || skb_unclone(frag, GFP_ATOMIC))
			goto out_free;
		*head = frag;
		skb_frag_list_init(*head);
2329
		*fbuf = NULL;
P
Per Liden 已提交
2330
		return 0;
2331 2332
	} else if (*head &&
		   skb_try_coalesce(*head, frag, &headstolen, &delta)) {
2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347
		kfree_skb_partial(frag, headstolen);
	} else {
		if (!*head)
			goto out_free;
		if (!skb_has_frag_list(*head))
			skb_shinfo(*head)->frag_list = frag;
		else
			(*tail)->next = frag;
		*tail = frag;
		(*head)->truesize += frag->truesize;
	}
	if (fragid == LAST_FRAGMENT) {
		*fbuf = *head;
		*tail = *head = NULL;
		return LINK_REASM_COMPLETE;
P
Per Liden 已提交
2348
	}
2349
	*fbuf = NULL;
P
Per Liden 已提交
2350
	return 0;
2351 2352 2353
out_free:
	pr_warn_ratelimited("Link unable to reassemble fragmented message\n");
	kfree_skb(*fbuf);
2354
	*fbuf = NULL;
2355
	return LINK_REASM_ERROR;
P
Per Liden 已提交
2356 2357
}

2358
static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance)
P
Per Liden 已提交
2359
{
2360 2361 2362
	if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL))
		return;

P
Per Liden 已提交
2363 2364 2365 2366 2367 2368
	l_ptr->tolerance = tolerance;
	l_ptr->continuity_interval =
		((tolerance / 4) > 500) ? 500 : tolerance / 4;
	l_ptr->abort_limit = tolerance / (l_ptr->continuity_interval / 4);
}

2369
void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window)
P
Per Liden 已提交
2370 2371
{
	/* Data messages from this node, inclusive FIRST_FRAGM */
2372 2373 2374 2375
	l_ptr->queue_limit[TIPC_LOW_IMPORTANCE] = window;
	l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE] = (window / 3) * 4;
	l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE] = (window / 3) * 5;
	l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE] = (window / 3) * 6;
P
Per Liden 已提交
2376
	/* Transiting data messages,inclusive FIRST_FRAGM */
2377 2378 2379 2380
	l_ptr->queue_limit[TIPC_LOW_IMPORTANCE + 4] = 300;
	l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE + 4] = 600;
	l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;
	l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;
P
Per Liden 已提交
2381 2382 2383 2384 2385 2386 2387
	l_ptr->queue_limit[CONN_MANAGER] = 1200;
	l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;
	l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;
	/* FRAGMENT and LAST_FRAGMENT packets */
	l_ptr->queue_limit[MSG_FRAGMENTER] = 4000;
}

2388 2389 2390
/* tipc_link_find_owner - locate owner node of link by link's name
 * @name: pointer to link name string
 * @bearer_id: pointer to index in 'node->links' array where the link was found.
2391
 *
2392
 * Returns pointer to node owning the link, or 0 if no matching link is found.
P
Per Liden 已提交
2393
 */
2394 2395
static struct tipc_node *tipc_link_find_owner(const char *link_name,
					      unsigned int *bearer_id)
P
Per Liden 已提交
2396
{
2397
	struct tipc_link *l_ptr;
2398
	struct tipc_node *n_ptr;
2399
	struct tipc_node *found_node = 0;
2400
	int i;
P
Per Liden 已提交
2401

2402
	*bearer_id = 0;
2403 2404
	rcu_read_lock();
	list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) {
2405
		tipc_node_lock(n_ptr);
2406 2407
		for (i = 0; i < MAX_BEARERS; i++) {
			l_ptr = n_ptr->links[i];
2408 2409 2410 2411 2412
			if (l_ptr && !strcmp(l_ptr->name, link_name)) {
				*bearer_id = i;
				found_node = n_ptr;
				break;
			}
2413
		}
2414
		tipc_node_unlock(n_ptr);
2415 2416
		if (found_node)
			break;
2417
	}
2418 2419
	rcu_read_unlock();

2420
	return found_node;
P
Per Liden 已提交
2421 2422
}

2423 2424 2425
/**
 * link_value_is_valid -- validate proposed link tolerance/priority/window
 *
2426 2427
 * @cmd: value type (TIPC_CMD_SET_LINK_*)
 * @new_value: the new value
2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
 *
 * Returns 1 if value is within range, 0 if not.
 */
static int link_value_is_valid(u16 cmd, u32 new_value)
{
	switch (cmd) {
	case TIPC_CMD_SET_LINK_TOL:
		return (new_value >= TIPC_MIN_LINK_TOL) &&
			(new_value <= TIPC_MAX_LINK_TOL);
	case TIPC_CMD_SET_LINK_PRI:
		return (new_value <= TIPC_MAX_LINK_PRI);
	case TIPC_CMD_SET_LINK_WINDOW:
		return (new_value >= TIPC_MIN_LINK_WIN) &&
			(new_value <= TIPC_MAX_LINK_WIN);
	}
	return 0;
}

/**
 * link_cmd_set_value - change priority/tolerance/window for link/bearer/media
2448 2449 2450
 * @name: ptr to link, bearer, or media name
 * @new_value: new value of link, bearer, or media setting
 * @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*)
2451
 *
Y
Ying Xue 已提交
2452
 * Caller must hold RTNL lock to ensure link/bearer/media is not deleted.
2453 2454 2455 2456 2457 2458
 *
 * Returns 0 if value updated and negative value on error.
 */
static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd)
{
	struct tipc_node *node;
2459
	struct tipc_link *l_ptr;
2460
	struct tipc_bearer *b_ptr;
2461
	struct tipc_media *m_ptr;
2462
	int bearer_id;
2463
	int res = 0;
2464

2465 2466
	node = tipc_link_find_owner(name, &bearer_id);
	if (node) {
2467
		tipc_node_lock(node);
2468 2469 2470 2471 2472 2473
		l_ptr = node->links[bearer_id];

		if (l_ptr) {
			switch (cmd) {
			case TIPC_CMD_SET_LINK_TOL:
				link_set_supervision_props(l_ptr, new_value);
2474 2475
				tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0,
						     new_value, 0, 0);
2476 2477 2478
				break;
			case TIPC_CMD_SET_LINK_PRI:
				l_ptr->priority = new_value;
2479 2480
				tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0,
						     0, new_value, 0);
2481 2482 2483 2484 2485 2486 2487 2488
				break;
			case TIPC_CMD_SET_LINK_WINDOW:
				tipc_link_set_queue_limits(l_ptr, new_value);
				break;
			default:
				res = -EINVAL;
				break;
			}
2489 2490
		}
		tipc_node_unlock(node);
2491
		return res;
2492 2493 2494 2495 2496 2497 2498
	}

	b_ptr = tipc_bearer_find(name);
	if (b_ptr) {
		switch (cmd) {
		case TIPC_CMD_SET_LINK_TOL:
			b_ptr->tolerance = new_value;
2499
			break;
2500 2501
		case TIPC_CMD_SET_LINK_PRI:
			b_ptr->priority = new_value;
2502
			break;
2503 2504
		case TIPC_CMD_SET_LINK_WINDOW:
			b_ptr->window = new_value;
2505 2506 2507 2508
			break;
		default:
			res = -EINVAL;
			break;
2509
		}
2510
		return res;
2511 2512 2513 2514 2515 2516 2517 2518
	}

	m_ptr = tipc_media_find(name);
	if (!m_ptr)
		return -ENODEV;
	switch (cmd) {
	case TIPC_CMD_SET_LINK_TOL:
		m_ptr->tolerance = new_value;
2519
		break;
2520 2521
	case TIPC_CMD_SET_LINK_PRI:
		m_ptr->priority = new_value;
2522
		break;
2523 2524
	case TIPC_CMD_SET_LINK_WINDOW:
		m_ptr->window = new_value;
2525 2526 2527 2528
		break;
	default:
		res = -EINVAL;
		break;
2529
	}
2530
	return res;
2531 2532
}

2533
struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space,
2534
				     u16 cmd)
P
Per Liden 已提交
2535 2536
{
	struct tipc_link_config *args;
2537 2538
	u32 new_value;
	int res;
P
Per Liden 已提交
2539 2540

	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_CONFIG))
2541
		return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
P
Per Liden 已提交
2542 2543 2544 2545

	args = (struct tipc_link_config *)TLV_DATA(req_tlv_area);
	new_value = ntohl(args->value);

2546 2547 2548 2549
	if (!link_value_is_valid(cmd, new_value))
		return tipc_cfg_reply_error_string(
			"cannot change, value invalid");

2550
	if (!strcmp(args->name, tipc_bclink_name)) {
P
Per Liden 已提交
2551
		if ((cmd == TIPC_CMD_SET_LINK_WINDOW) &&
2552 2553
		    (tipc_bclink_set_queue_limits(new_value) == 0))
			return tipc_cfg_reply_none();
2554
		return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
2555
						   " (cannot change setting on broadcast link)");
P
Per Liden 已提交
2556 2557
	}

2558
	res = link_cmd_set_value(args->name, new_value, cmd);
P
Per Liden 已提交
2559
	if (res)
2560
		return tipc_cfg_reply_error_string("cannot change link setting");
P
Per Liden 已提交
2561

2562
	return tipc_cfg_reply_none();
P
Per Liden 已提交
2563 2564 2565 2566 2567 2568
}

/**
 * link_reset_statistics - reset link statistics
 * @l_ptr: pointer to link
 */
2569
static void link_reset_statistics(struct tipc_link *l_ptr)
P
Per Liden 已提交
2570 2571 2572 2573 2574 2575
{
	memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));
	l_ptr->stats.sent_info = l_ptr->next_out_no;
	l_ptr->stats.recv_info = l_ptr->next_in_no;
}

2576
struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space)
P
Per Liden 已提交
2577 2578
{
	char *link_name;
2579
	struct tipc_link *l_ptr;
2580
	struct tipc_node *node;
2581
	unsigned int bearer_id;
P
Per Liden 已提交
2582 2583

	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
2584
		return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
P
Per Liden 已提交
2585 2586

	link_name = (char *)TLV_DATA(req_tlv_area);
2587 2588 2589 2590
	if (!strcmp(link_name, tipc_bclink_name)) {
		if (tipc_bclink_reset_stats())
			return tipc_cfg_reply_error_string("link not found");
		return tipc_cfg_reply_none();
P
Per Liden 已提交
2591
	}
2592
	node = tipc_link_find_owner(link_name, &bearer_id);
Y
Ying Xue 已提交
2593
	if (!node)
2594
		return tipc_cfg_reply_error_string("link not found");
Y
Ying Xue 已提交
2595

2596
	tipc_node_lock(node);
2597
	l_ptr = node->links[bearer_id];
P
Per Liden 已提交
2598
	if (!l_ptr) {
2599
		tipc_node_unlock(node);
2600
		return tipc_cfg_reply_error_string("link not found");
P
Per Liden 已提交
2601 2602
	}
	link_reset_statistics(l_ptr);
2603 2604
	tipc_node_unlock(node);
	return tipc_cfg_reply_none();
P
Per Liden 已提交
2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615
}

/**
 * percent - convert count to a percentage of total (rounding up or down)
 */
static u32 percent(u32 count, u32 total)
{
	return (count * 100 + (total / 2)) / total;
}

/**
2616
 * tipc_link_stats - print link statistics
P
Per Liden 已提交
2617 2618 2619
 * @name: link name
 * @buf: print buffer area
 * @buf_size: size of print buffer area
2620
 *
P
Per Liden 已提交
2621 2622
 * Returns length of print buffer data string (or 0 if error)
 */
2623
static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
P
Per Liden 已提交
2624
{
2625 2626
	struct tipc_link *l;
	struct tipc_stats *s;
2627
	struct tipc_node *node;
P
Per Liden 已提交
2628 2629
	char *status;
	u32 profile_total = 0;
2630
	unsigned int bearer_id;
2631
	int ret;
P
Per Liden 已提交
2632

2633 2634
	if (!strcmp(name, tipc_bclink_name))
		return tipc_bclink_stats(buf, buf_size);
P
Per Liden 已提交
2635

2636
	node = tipc_link_find_owner(name, &bearer_id);
Y
Ying Xue 已提交
2637
	if (!node)
P
Per Liden 已提交
2638
		return 0;
Y
Ying Xue 已提交
2639

2640
	tipc_node_lock(node);
2641 2642 2643 2644 2645 2646 2647

	l = node->links[bearer_id];
	if (!l) {
		tipc_node_unlock(node);
		return 0;
	}

2648
	s = &l->stats;
P
Per Liden 已提交
2649

2650
	if (tipc_link_is_active(l))
P
Per Liden 已提交
2651
		status = "ACTIVE";
2652
	else if (tipc_link_is_up(l))
P
Per Liden 已提交
2653 2654 2655
		status = "STANDBY";
	else
		status = "DEFUNCT";
2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675

	ret = tipc_snprintf(buf, buf_size, "Link <%s>\n"
			    "  %s  MTU:%u  Priority:%u  Tolerance:%u ms"
			    "  Window:%u packets\n",
			    l->name, status, l->max_pkt, l->priority,
			    l->tolerance, l->queue_limit[0]);

	ret += tipc_snprintf(buf + ret, buf_size - ret,
			     "  RX packets:%u fragments:%u/%u bundles:%u/%u\n",
			     l->next_in_no - s->recv_info, s->recv_fragments,
			     s->recv_fragmented, s->recv_bundles,
			     s->recv_bundled);

	ret += tipc_snprintf(buf + ret, buf_size - ret,
			     "  TX packets:%u fragments:%u/%u bundles:%u/%u\n",
			     l->next_out_no - s->sent_info, s->sent_fragments,
			     s->sent_fragmented, s->sent_bundles,
			     s->sent_bundled);

	profile_total = s->msg_length_counts;
P
Per Liden 已提交
2676 2677
	if (!profile_total)
		profile_total = 1;
2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703

	ret += tipc_snprintf(buf + ret, buf_size - ret,
			     "  TX profile sample:%u packets  average:%u octets\n"
			     "  0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
			     "-16384:%u%% -32768:%u%% -66000:%u%%\n",
			     s->msg_length_counts,
			     s->msg_lengths_total / profile_total,
			     percent(s->msg_length_profile[0], profile_total),
			     percent(s->msg_length_profile[1], profile_total),
			     percent(s->msg_length_profile[2], profile_total),
			     percent(s->msg_length_profile[3], profile_total),
			     percent(s->msg_length_profile[4], profile_total),
			     percent(s->msg_length_profile[5], profile_total),
			     percent(s->msg_length_profile[6], profile_total));

	ret += tipc_snprintf(buf + ret, buf_size - ret,
			     "  RX states:%u probes:%u naks:%u defs:%u"
			     " dups:%u\n", s->recv_states, s->recv_probes,
			     s->recv_nacks, s->deferred_recv, s->duplicates);

	ret += tipc_snprintf(buf + ret, buf_size - ret,
			     "  TX states:%u probes:%u naks:%u acks:%u"
			     " dups:%u\n", s->sent_states, s->sent_probes,
			     s->sent_nacks, s->sent_acks, s->retransmitted);

	ret += tipc_snprintf(buf + ret, buf_size - ret,
2704 2705
			     "  Congestion link:%u  Send queue"
			     " max:%u avg:%u\n", s->link_congs,
2706 2707
			     s->max_queue_sz, s->queue_sz_counts ?
			     (s->accu_queue_sz / s->queue_sz_counts) : 0);
P
Per Liden 已提交
2708

2709
	tipc_node_unlock(node);
2710
	return ret;
P
Per Liden 已提交
2711 2712
}

2713
struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
P
Per Liden 已提交
2714 2715 2716 2717
{
	struct sk_buff *buf;
	struct tlv_desc *rep_tlv;
	int str_len;
2718 2719
	int pb_len;
	char *pb;
P
Per Liden 已提交
2720 2721

	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
2722
		return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
P
Per Liden 已提交
2723

2724
	buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
P
Per Liden 已提交
2725 2726 2727 2728
	if (!buf)
		return NULL;

	rep_tlv = (struct tlv_desc *)buf->data;
2729 2730
	pb = TLV_DATA(rep_tlv);
	pb_len = ULTRA_STRING_MAX_LEN;
2731
	str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area),
2732
				  pb, pb_len);
P
Per Liden 已提交
2733
	if (!str_len) {
2734
		kfree_skb(buf);
2735
		return tipc_cfg_reply_error_string("link not found");
P
Per Liden 已提交
2736
	}
2737
	str_len += 1;	/* for "\0" */
P
Per Liden 已提交
2738 2739 2740 2741 2742 2743 2744
	skb_put(buf, TLV_SPACE(str_len));
	TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);

	return buf;
}

/**
2745
 * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination
P
Per Liden 已提交
2746 2747
 * @dest: network address of destination node
 * @selector: used to select from set of active links
2748
 *
P
Per Liden 已提交
2749 2750
 * If no active link can be found, uses default maximum packet size.
 */
2751
u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
P
Per Liden 已提交
2752
{
2753
	struct tipc_node *n_ptr;
2754
	struct tipc_link *l_ptr;
P
Per Liden 已提交
2755
	u32 res = MAX_PKT_DEFAULT;
2756

P
Per Liden 已提交
2757 2758 2759
	if (dest == tipc_own_addr)
		return MAX_MSG_SIZE;

2760
	n_ptr = tipc_node_find(dest);
P
Per Liden 已提交
2761
	if (n_ptr) {
2762
		tipc_node_lock(n_ptr);
P
Per Liden 已提交
2763 2764
		l_ptr = n_ptr->active_links[selector & 1];
		if (l_ptr)
2765
			res = l_ptr->max_pkt;
2766
		tipc_node_unlock(n_ptr);
P
Per Liden 已提交
2767 2768 2769 2770
	}
	return res;
}

2771
static void link_print(struct tipc_link *l_ptr, const char *str)
P
Per Liden 已提交
2772
{
2773 2774 2775 2776 2777 2778 2779
	struct tipc_bearer *b_ptr;

	rcu_read_lock();
	b_ptr = rcu_dereference_rtnl(bearer_list[l_ptr->bearer_id]);
	if (b_ptr)
		pr_info("%s Link %x<%s>:", str, l_ptr->addr, b_ptr->name);
	rcu_read_unlock();
2780

P
Per Liden 已提交
2781
	if (link_working_unknown(l_ptr))
2782
		pr_cont(":WU\n");
2783
	else if (link_reset_reset(l_ptr))
2784
		pr_cont(":RR\n");
2785
	else if (link_reset_unknown(l_ptr))
2786
		pr_cont(":RU\n");
2787
	else if (link_working_working(l_ptr))
2788 2789 2790
		pr_cont(":WW\n");
	else
		pr_cont("\n");
P
Per Liden 已提交
2791
}