node.c 34.6 KB
Newer Older
P
Per Liden 已提交
1 2
/*
 * net/tipc/node.c: TIPC node management routines
3
 *
4
 * Copyright (c) 2000-2006, 2012-2015, Ericsson AB
5
 * Copyright (c) 2005-2006, 2010-2014, 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
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "core.h"
38
#include "link.h"
P
Per Liden 已提交
39 40
#include "node.h"
#include "name_distr.h"
41
#include "socket.h"
42
#include "bcast.h"
43
#include "discover.h"
P
Per Liden 已提交
44

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
/* Node FSM states and events:
 */
enum {
	SELF_DOWN_PEER_DOWN    = 0xdd,
	SELF_UP_PEER_UP        = 0xaa,
	SELF_DOWN_PEER_LEAVING = 0xd1,
	SELF_UP_PEER_COMING    = 0xac,
	SELF_COMING_PEER_UP    = 0xca,
	SELF_LEAVING_PEER_DOWN = 0x1d,
	NODE_FAILINGOVER       = 0xf0,
	NODE_SYNCHING          = 0xcc
};

enum {
	SELF_ESTABL_CONTACT_EVT = 0xece,
	SELF_LOST_CONTACT_EVT   = 0x1ce,
	PEER_ESTABL_CONTACT_EVT = 0x9ece,
	PEER_LOST_CONTACT_EVT   = 0x91ce,
	NODE_FAILOVER_BEGIN_EVT = 0xfbe,
	NODE_FAILOVER_END_EVT   = 0xfee,
	NODE_SYNCH_BEGIN_EVT    = 0xcbe,
	NODE_SYNCH_END_EVT      = 0xcee
};

69 70 71 72 73 74
static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,
				  struct sk_buff_head *xmitq,
				  struct tipc_media_addr **maddr);
static void tipc_node_link_down(struct tipc_node *n, int bearer_id,
				bool delete);
static void node_lost_contact(struct tipc_node *n, struct sk_buff_head *inputq);
75
static void node_established_contact(struct tipc_node *n_ptr);
76
static void tipc_node_delete(struct tipc_node *node);
77
static void tipc_node_timeout(unsigned long data);
78
static void tipc_node_fsm_evt(struct tipc_node *n, int evt);
P
Per Liden 已提交
79

80 81 82 83 84 85 86
struct tipc_sock_conn {
	u32 port;
	u32 peer_port;
	u32 peer_node;
	struct list_head list;
};

87 88 89 90 91 92
static const struct nla_policy tipc_nl_node_policy[TIPC_NLA_NODE_MAX + 1] = {
	[TIPC_NLA_NODE_UNSPEC]		= { .type = NLA_UNSPEC },
	[TIPC_NLA_NODE_ADDR]		= { .type = NLA_U32 },
	[TIPC_NLA_NODE_UP]		= { .type = NLA_FLAG }
};

93 94 95 96 97 98
/*
 * A trivial power-of-two bitmask technique is used for speed, since this
 * operation is done for every incoming TIPC packet. The number of hash table
 * entries has been chosen so that no hash chain exceeds 8 nodes and will
 * usually be much smaller (typically only a single node).
 */
99
static unsigned int tipc_hashfn(u32 addr)
100 101 102 103
{
	return addr & (NODE_HTABLE_SIZE - 1);
}

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
static void tipc_node_kref_release(struct kref *kref)
{
	struct tipc_node *node = container_of(kref, struct tipc_node, kref);

	tipc_node_delete(node);
}

void tipc_node_put(struct tipc_node *node)
{
	kref_put(&node->kref, tipc_node_kref_release);
}

static void tipc_node_get(struct tipc_node *node)
{
	kref_get(&node->kref);
}

121
/*
122 123
 * tipc_node_find - locate specified node object, if it exists
 */
124
struct tipc_node *tipc_node_find(struct net *net, u32 addr)
125
{
126
	struct tipc_net *tn = net_generic(net, tipc_net_id);
127 128
	struct tipc_node *node;

129
	if (unlikely(!in_own_cluster_exact(net, addr)))
130 131
		return NULL;

132
	rcu_read_lock();
133 134
	hlist_for_each_entry_rcu(node, &tn->node_htable[tipc_hashfn(addr)],
				 hash) {
135
		if (node->addr == addr) {
136
			tipc_node_get(node);
137
			rcu_read_unlock();
138
			return node;
139
		}
140
	}
141
	rcu_read_unlock();
142 143 144
	return NULL;
}

145
struct tipc_node *tipc_node_create(struct net *net, u32 addr, u16 capabilities)
P
Per Liden 已提交
146
{
147
	struct tipc_net *tn = net_generic(net, tipc_net_id);
148
	struct tipc_node *n_ptr, *temp_node;
P
Per Liden 已提交
149

150
	spin_lock_bh(&tn->node_list_lock);
151 152 153
	n_ptr = tipc_node_find(net, addr);
	if (n_ptr)
		goto exit;
154
	n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
155
	if (!n_ptr) {
156
		pr_warn("Node creation failed, no memory\n");
157
		goto exit;
158 159
	}
	n_ptr->addr = addr;
160
	n_ptr->net = net;
161
	n_ptr->capabilities = capabilities;
162
	kref_init(&n_ptr->kref);
163
	spin_lock_init(&n_ptr->lock);
164 165
	INIT_HLIST_NODE(&n_ptr->hash);
	INIT_LIST_HEAD(&n_ptr->list);
166
	INIT_LIST_HEAD(&n_ptr->publ_list);
167
	INIT_LIST_HEAD(&n_ptr->conn_sks);
168
	skb_queue_head_init(&n_ptr->bclink.namedq);
J
Jon Paul Maloy 已提交
169
	__skb_queue_head_init(&n_ptr->bclink.deferdq);
170 171
	hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]);
	list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
172 173 174
		if (n_ptr->addr < temp_node->addr)
			break;
	}
175
	list_add_tail_rcu(&n_ptr->list, &temp_node->list);
176
	n_ptr->state = SELF_DOWN_PEER_LEAVING;
177
	n_ptr->signature = INVALID_NODE_SIG;
178 179
	n_ptr->active_links[0] = INVALID_BEARER_ID;
	n_ptr->active_links[1] = INVALID_BEARER_ID;
180
	tipc_node_get(n_ptr);
181 182
	setup_timer(&n_ptr->timer, tipc_node_timeout, (unsigned long)n_ptr);
	n_ptr->keepalive_intv = U32_MAX;
183
exit:
184
	spin_unlock_bh(&tn->node_list_lock);
P
Per Liden 已提交
185 186 187
	return n_ptr;
}

188 189 190 191 192 193 194 195 196 197 198 199 200 201
static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l)
{
	unsigned long tol = l->tolerance;
	unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;
	unsigned long keepalive_intv = msecs_to_jiffies(intv);

	/* Link with lowest tolerance determines timer interval */
	if (keepalive_intv < n->keepalive_intv)
		n->keepalive_intv = keepalive_intv;

	/* Ensure link's abort limit corresponds to current interval */
	l->abort_limit = l->tolerance / jiffies_to_msecs(n->keepalive_intv);
}

202
static void tipc_node_delete(struct tipc_node *node)
P
Per Liden 已提交
203
{
204 205 206
	list_del_rcu(&node->list);
	hlist_del_rcu(&node->hash);
	kfree_rcu(node, rcu);
P
Per Liden 已提交
207 208
}

209
void tipc_node_stop(struct net *net)
210
{
211
	struct tipc_net *tn = net_generic(net, tipc_net_id);
212 213
	struct tipc_node *node, *t_node;

214
	spin_lock_bh(&tn->node_list_lock);
215 216 217
	list_for_each_entry_safe(node, t_node, &tn->node_list, list) {
		if (del_timer(&node->timer))
			tipc_node_put(node);
218
		tipc_node_put(node);
219
	}
220
	spin_unlock_bh(&tn->node_list_lock);
221 222
}

223
int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
224 225 226
{
	struct tipc_node *node;
	struct tipc_sock_conn *conn;
227
	int err = 0;
228

229
	if (in_own_node(net, dnode))
230 231
		return 0;

232
	node = tipc_node_find(net, dnode);
233 234 235 236 237
	if (!node) {
		pr_warn("Connecting sock to node 0x%x failed\n", dnode);
		return -EHOSTUNREACH;
	}
	conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
238 239 240 241
	if (!conn) {
		err = -EHOSTUNREACH;
		goto exit;
	}
242 243 244 245 246 247 248
	conn->peer_node = dnode;
	conn->port = port;
	conn->peer_port = peer_port;

	tipc_node_lock(node);
	list_add_tail(&conn->list, &node->conn_sks);
	tipc_node_unlock(node);
249 250 251
exit:
	tipc_node_put(node);
	return err;
252 253
}

254
void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
255 256 257 258
{
	struct tipc_node *node;
	struct tipc_sock_conn *conn, *safe;

259
	if (in_own_node(net, dnode))
260 261
		return;

262
	node = tipc_node_find(net, dnode);
263 264 265 266 267 268 269 270 271 272 273
	if (!node)
		return;

	tipc_node_lock(node);
	list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
		if (port != conn->port)
			continue;
		list_del(&conn->list);
		kfree(conn);
	}
	tipc_node_unlock(node);
274
	tipc_node_put(node);
275 276
}

277 278 279 280 281
/* tipc_node_timeout - handle expiration of node timer
 */
static void tipc_node_timeout(unsigned long data)
{
	struct tipc_node *n = (struct tipc_node *)data;
282
	struct tipc_link_entry *le;
283 284 285 286 287 288 289 290
	struct sk_buff_head xmitq;
	int bearer_id;
	int rc = 0;

	__skb_queue_head_init(&xmitq);

	for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {
		tipc_node_lock(n);
291 292
		le = &n->links[bearer_id];
		if (le->link) {
293
			/* Link tolerance may change asynchronously: */
294 295
			tipc_node_calculate_timer(n, le->link);
			rc = tipc_link_timeout(le->link, &xmitq);
296 297
		}
		tipc_node_unlock(n);
298 299 300
		tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr);
		if (rc & TIPC_LINK_DOWN_EVT)
			tipc_node_link_down(n, bearer_id, false);
301 302 303 304 305 306
	}
	if (!mod_timer(&n->timer, jiffies + n->keepalive_intv))
		tipc_node_get(n);
	tipc_node_put(n);
}

P
Per Liden 已提交
307
/**
308 309
 * __tipc_node_link_up - handle addition of link
 * Node lock must be held by caller
P
Per Liden 已提交
310 311
 * Link becomes active (alone or shared) or standby, depending on its priority.
 */
312 313
static void __tipc_node_link_up(struct tipc_node *n, int bearer_id,
				struct sk_buff_head *xmitq)
P
Per Liden 已提交
314
{
315 316
	int *slot0 = &n->active_links[0];
	int *slot1 = &n->active_links[1];
317 318
	struct tipc_link *ol = node_active_link(n, 0);
	struct tipc_link *nl = n->links[bearer_id].link;
319

320 321 322
	if (!nl || !tipc_link_is_up(nl))
		return;

323 324 325 326
	if (n->working_links > 1) {
		pr_warn("Attempt to establish 3rd link to %x\n", n->addr);
		return;
	}
327 328
	n->working_links++;
	n->action_flags |= TIPC_NOTIFY_LINK_UP;
329 330 331 332
	n->link_id = nl->peer_bearer_id << 16 | bearer_id;

	/* Leave room for tunnel header when returning 'mtu' to users: */
	n->links[bearer_id].mtu = nl->mtu - INT_H_SIZE;
Y
Ying Xue 已提交
333

334 335
	tipc_bearer_add_dest(n->net, bearer_id, n->addr);

336
	pr_debug("Established link <%s> on network plane %c\n",
337
		 nl->name, nl->net_plane);
338

339 340
	/* First link? => give it both slots */
	if (!ol) {
341 342
		*slot0 = bearer_id;
		*slot1 = bearer_id;
343
		tipc_link_build_bcast_sync_msg(nl, xmitq);
344 345
		node_established_contact(n);
		return;
P
Per Liden 已提交
346
	}
347

348 349 350
	/* Second link => redistribute slots */
	if (nl->priority > ol->priority) {
		pr_debug("Old link <%s> becomes standby\n", ol->name);
351
		*slot0 = bearer_id;
352 353 354 355 356
		*slot1 = bearer_id;
	} else if (nl->priority == ol->priority) {
		*slot0 = bearer_id;
	} else {
		pr_debug("New link <%s> is standby\n", nl->name);
P
Per Liden 已提交
357 358
	}

359 360
	/* Prepare synchronization with first link */
	tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq);
P
Per Liden 已提交
361 362 363
}

/**
364 365 366
 * tipc_node_link_up - handle addition of link
 *
 * Link becomes active (alone or shared) or standby, depending on its priority.
P
Per Liden 已提交
367
 */
368 369
static void tipc_node_link_up(struct tipc_node *n, int bearer_id,
			      struct sk_buff_head *xmitq)
P
Per Liden 已提交
370
{
371 372 373 374 375 376 377 378 379 380 381 382 383
	tipc_node_lock(n);
	__tipc_node_link_up(n, bearer_id, xmitq);
	tipc_node_unlock(n);
}

/**
 * __tipc_node_link_down - handle loss of link
 */
static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,
				  struct sk_buff_head *xmitq,
				  struct tipc_media_addr **maddr)
{
	struct tipc_link_entry *le = &n->links[*bearer_id];
384 385 386
	int *slot0 = &n->active_links[0];
	int *slot1 = &n->active_links[1];
	int i, highest = 0;
387
	struct tipc_link *l, *_l, *tnl;
P
Per Liden 已提交
388

389
	l = n->links[*bearer_id].link;
390
	if (!l || tipc_link_is_reset(l))
391 392
		return;

393 394
	n->working_links--;
	n->action_flags |= TIPC_NOTIFY_LINK_DOWN;
395
	n->link_id = l->peer_bearer_id << 16 | *bearer_id;
396

397
	tipc_bearer_remove_dest(n->net, *bearer_id, n->addr);
398

399
	pr_debug("Lost link <%s> on network plane %c\n",
400
		 l->name, l->net_plane);
401

402 403 404 405 406 407 408
	/* Select new active link if any available */
	*slot0 = INVALID_BEARER_ID;
	*slot1 = INVALID_BEARER_ID;
	for (i = 0; i < MAX_BEARERS; i++) {
		_l = n->links[i].link;
		if (!_l || !tipc_link_is_up(_l))
			continue;
409 410
		if (_l == l)
			continue;
411 412 413 414 415 416 417 418 419 420
		if (_l->priority < highest)
			continue;
		if (_l->priority > highest) {
			highest = _l->priority;
			*slot0 = i;
			*slot1 = i;
			continue;
		}
		*slot1 = i;
	}
421

422 423
	if (!tipc_node_is_up(n)) {
		tipc_link_reset(l);
424
		node_lost_contact(n, &le->inputq);
425 426
		return;
	}
427

428 429 430
	/* There is still a working link => initiate failover */
	tnl = node_active_link(n, 0);
	n->sync_point = tnl->rcv_nxt + (U16_MAX / 2 - 1);
431
	tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq);
432
	tipc_link_reset(l);
433
	tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
	tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT);
	*maddr = &n->links[tnl->bearer_id].maddr;
	*bearer_id = tnl->bearer_id;
}

static void tipc_node_link_down(struct tipc_node *n, int bearer_id, bool delete)
{
	struct tipc_link_entry *le = &n->links[bearer_id];
	struct tipc_media_addr *maddr;
	struct sk_buff_head xmitq;

	__skb_queue_head_init(&xmitq);

	tipc_node_lock(n);
	__tipc_node_link_down(n, &bearer_id, &xmitq, &maddr);
	if (delete && le->link) {
		kfree(le->link);
		le->link = NULL;
		n->link_cnt--;
	}
	tipc_node_unlock(n);

	tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr);
	tipc_sk_rcv(n->net, &le->inputq);
P
Per Liden 已提交
458 459
}

460
bool tipc_node_is_up(struct tipc_node *n)
P
Per Liden 已提交
461
{
462
	return n->active_links[0] != INVALID_BEARER_ID;
P
Per Liden 已提交
463 464
}

465 466 467 468 469
void tipc_node_check_dest(struct net *net, u32 onode,
			  struct tipc_bearer *b,
			  u16 capabilities, u32 signature,
			  struct tipc_media_addr *maddr,
			  bool *respond, bool *dupl_addr)
470
{
471 472 473 474 475 476 477 478
	struct tipc_node *n;
	struct tipc_link *l;
	struct tipc_media_addr *curr_maddr;
	struct sk_buff_head *inputq;
	bool addr_match = false;
	bool sign_match = false;
	bool link_up = false;
	bool accept_addr = false;
479
	bool reset = true;
480 481 482 483 484 485
	*dupl_addr = false;
	*respond = false;

	n = tipc_node_create(net, onode, capabilities);
	if (!n)
		return;
486

487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
	tipc_node_lock(n);

	curr_maddr = &n->links[b->identity].maddr;
	inputq = &n->links[b->identity].inputq;

	/* Prepare to validate requesting node's signature and media address */
	l = n->links[b->identity].link;
	link_up = l && tipc_link_is_up(l);
	addr_match = l && !memcmp(curr_maddr, maddr, sizeof(*maddr));
	sign_match = (signature == n->signature);

	/* These three flags give us eight permutations: */

	if (sign_match && addr_match && link_up) {
		/* All is fine. Do nothing. */
502
		reset = false;
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
	} else if (sign_match && addr_match && !link_up) {
		/* Respond. The link will come up in due time */
		*respond = true;
	} else if (sign_match && !addr_match && link_up) {
		/* Peer has changed i/f address without rebooting.
		 * If so, the link will reset soon, and the next
		 * discovery will be accepted. So we can ignore it.
		 * It may also be an cloned or malicious peer having
		 * chosen the same node address and signature as an
		 * existing one.
		 * Ignore requests until the link goes down, if ever.
		 */
		*dupl_addr = true;
	} else if (sign_match && !addr_match && !link_up) {
		/* Peer link has changed i/f address without rebooting.
		 * It may also be a cloned or malicious peer; we can't
		 * distinguish between the two.
		 * The signature is correct, so we must accept.
		 */
		accept_addr = true;
		*respond = true;
	} else if (!sign_match && addr_match && link_up) {
		/* Peer node rebooted. Two possibilities:
		 *  - Delayed re-discovery; this link endpoint has already
		 *    reset and re-established contact with the peer, before
		 *    receiving a discovery message from that node.
		 *    (The peer happened to receive one from this node first).
		 *  - The peer came back so fast that our side has not
		 *    discovered it yet. Probing from this side will soon
		 *    reset the link, since there can be no working link
		 *    endpoint at the peer end, and the link will re-establish.
		 *  Accept the signature, since it comes from a known peer.
		 */
		n->signature = signature;
	} else if (!sign_match && addr_match && !link_up) {
		/*  The peer node has rebooted.
		 *  Accept signature, since it is a known peer.
		 */
		n->signature = signature;
		*respond = true;
	} else if (!sign_match && !addr_match && link_up) {
		/* Peer rebooted with new address, or a new/duplicate peer.
		 * Ignore until the link goes down, if ever.
		 */
		*dupl_addr = true;
	} else if (!sign_match && !addr_match && !link_up) {
		/* Peer rebooted with new address, or it is a new peer.
		 * Accept signature and address.
		 */
		n->signature = signature;
		accept_addr = true;
		*respond = true;
	}
556

557 558
	if (!accept_addr)
		goto exit;
559

560
	/* Now create new link if not already existing */
561
	if (!l) {
562
		l = tipc_link_create(n, b, maddr, inputq, &n->bclink.namedq);
563 564 565 566
		if (!l) {
			*respond = false;
			goto exit;
		}
567
		tipc_node_calculate_timer(n, l);
568
		if (n->link_cnt == 1)
569 570 571
			if (!mod_timer(&n->timer, jiffies + n->keepalive_intv))
				tipc_node_get(n);
	}
572
	memcpy(&l->media_addr, maddr, sizeof(*maddr));
573 574 575
	memcpy(curr_maddr, maddr, sizeof(*maddr));
exit:
	tipc_node_unlock(n);
576 577
	if (reset)
		tipc_node_link_down(n, b->identity, false);
578
	tipc_node_put(n);
579 580
}

581 582 583 584 585 586 587
void tipc_node_delete_links(struct net *net, int bearer_id)
{
	struct tipc_net *tn = net_generic(net, tipc_net_id);
	struct tipc_node *n;

	rcu_read_lock();
	list_for_each_entry_rcu(n, &tn->node_list, list) {
588
		tipc_node_link_down(n, bearer_id, true);
589 590 591 592 593 594 595
	}
	rcu_read_unlock();
}

static void tipc_node_reset_links(struct tipc_node *n)
{
	char addr_string[16];
596
	int i;
597 598 599 600 601

	pr_warn("Resetting all links to %s\n",
		tipc_addr_string_fill(addr_string, n->addr));

	for (i = 0; i < MAX_BEARERS; i++) {
602
		tipc_node_link_down(n, i, false);
603 604 605
	}
}

606
void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
P
Per Liden 已提交
607
{
608
	n_ptr->links[l_ptr->bearer_id].link = l_ptr;
609
	n_ptr->link_cnt++;
P
Per Liden 已提交
610 611
}

612
void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
P
Per Liden 已提交
613
{
614 615 616
	int i;

	for (i = 0; i < MAX_BEARERS; i++) {
617
		if (l_ptr != n_ptr->links[i].link)
J
Jon Paul Maloy 已提交
618
			continue;
619
		n_ptr->links[i].link = NULL;
J
Jon Paul Maloy 已提交
620
		n_ptr->link_cnt--;
621
	}
P
Per Liden 已提交
622 623
}

624 625 626
/* tipc_node_fsm_evt - node finite state machine
 * Determines when contact is allowed with peer node
 */
627
static void tipc_node_fsm_evt(struct tipc_node *n, int evt)
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
{
	int state = n->state;

	switch (state) {
	case SELF_DOWN_PEER_DOWN:
		switch (evt) {
		case SELF_ESTABL_CONTACT_EVT:
			state = SELF_UP_PEER_COMING;
			break;
		case PEER_ESTABL_CONTACT_EVT:
			state = SELF_COMING_PEER_UP;
			break;
		case SELF_LOST_CONTACT_EVT:
		case PEER_LOST_CONTACT_EVT:
			break;
J
Jon Paul Maloy 已提交
643 644 645 646
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
647
		default:
J
Jon Paul Maloy 已提交
648
			goto illegal_evt;
649 650 651 652 653 654 655 656 657 658
		}
		break;
	case SELF_UP_PEER_UP:
		switch (evt) {
		case SELF_LOST_CONTACT_EVT:
			state = SELF_DOWN_PEER_LEAVING;
			break;
		case PEER_LOST_CONTACT_EVT:
			state = SELF_LEAVING_PEER_DOWN;
			break;
J
Jon Paul Maloy 已提交
659 660 661 662 663 664
		case NODE_SYNCH_BEGIN_EVT:
			state = NODE_SYNCHING;
			break;
		case NODE_FAILOVER_BEGIN_EVT:
			state = NODE_FAILINGOVER;
			break;
665 666
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
J
Jon Paul Maloy 已提交
667 668
		case NODE_SYNCH_END_EVT:
		case NODE_FAILOVER_END_EVT:
669 670
			break;
		default:
J
Jon Paul Maloy 已提交
671
			goto illegal_evt;
672 673 674 675 676 677 678 679 680 681 682
		}
		break;
	case SELF_DOWN_PEER_LEAVING:
		switch (evt) {
		case PEER_LOST_CONTACT_EVT:
			state = SELF_DOWN_PEER_DOWN;
			break;
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
		case SELF_LOST_CONTACT_EVT:
			break;
J
Jon Paul Maloy 已提交
683 684 685 686
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
687
		default:
J
Jon Paul Maloy 已提交
688
			goto illegal_evt;
689 690 691 692 693 694 695 696 697 698 699 700 701
		}
		break;
	case SELF_UP_PEER_COMING:
		switch (evt) {
		case PEER_ESTABL_CONTACT_EVT:
			state = SELF_UP_PEER_UP;
			break;
		case SELF_LOST_CONTACT_EVT:
			state = SELF_DOWN_PEER_LEAVING;
			break;
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_LOST_CONTACT_EVT:
			break;
J
Jon Paul Maloy 已提交
702 703 704 705
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
706
		default:
J
Jon Paul Maloy 已提交
707
			goto illegal_evt;
708 709 710 711 712 713 714 715 716 717 718 719 720
		}
		break;
	case SELF_COMING_PEER_UP:
		switch (evt) {
		case SELF_ESTABL_CONTACT_EVT:
			state = SELF_UP_PEER_UP;
			break;
		case PEER_LOST_CONTACT_EVT:
			state = SELF_LEAVING_PEER_DOWN;
			break;
		case SELF_LOST_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
			break;
J
Jon Paul Maloy 已提交
721 722 723 724
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
725
		default:
J
Jon Paul Maloy 已提交
726
			goto illegal_evt;
727 728 729 730 731 732 733 734 735 736 737
		}
		break;
	case SELF_LEAVING_PEER_DOWN:
		switch (evt) {
		case SELF_LOST_CONTACT_EVT:
			state = SELF_DOWN_PEER_DOWN;
			break;
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
		case PEER_LOST_CONTACT_EVT:
			break;
J
Jon Paul Maloy 已提交
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
		default:
			goto illegal_evt;
		}
		break;
	case NODE_FAILINGOVER:
		switch (evt) {
		case SELF_LOST_CONTACT_EVT:
			state = SELF_DOWN_PEER_LEAVING;
			break;
		case PEER_LOST_CONTACT_EVT:
			state = SELF_LEAVING_PEER_DOWN;
			break;
		case NODE_FAILOVER_END_EVT:
			state = SELF_UP_PEER_UP;
			break;
		case NODE_FAILOVER_BEGIN_EVT:
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
			break;
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_SYNCH_END_EVT:
763
		default:
J
Jon Paul Maloy 已提交
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
			goto illegal_evt;
		}
		break;
	case NODE_SYNCHING:
		switch (evt) {
		case SELF_LOST_CONTACT_EVT:
			state = SELF_DOWN_PEER_LEAVING;
			break;
		case PEER_LOST_CONTACT_EVT:
			state = SELF_LEAVING_PEER_DOWN;
			break;
		case NODE_SYNCH_END_EVT:
			state = SELF_UP_PEER_UP;
			break;
		case NODE_FAILOVER_BEGIN_EVT:
			state = NODE_FAILINGOVER;
			break;
		case NODE_SYNCH_BEGIN_EVT:
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
			break;
		case NODE_FAILOVER_END_EVT:
		default:
			goto illegal_evt;
788 789 790 791 792 793 794
		}
		break;
	default:
		pr_err("Unknown node fsm state %x\n", state);
		break;
	}
	n->state = state;
J
Jon Paul Maloy 已提交
795 796 797 798
	return;

illegal_evt:
	pr_err("Illegal node fsm evt %x in state %x\n", evt, state);
799 800
}

801
bool tipc_node_filter_pkt(struct tipc_node *n, struct tipc_msg *hdr)
802 803 804 805 806
{
	int state = n->state;

	if (likely(state == SELF_UP_PEER_UP))
		return true;
807

808 809
	if (state == SELF_LEAVING_PEER_DOWN)
		return false;
810 811

	if (state == SELF_DOWN_PEER_LEAVING) {
812
		if (msg_peer_node_is_up(hdr))
813 814
			return false;
	}
815 816

	return true;
817 818
}

819
static void node_established_contact(struct tipc_node *n_ptr)
P
Per Liden 已提交
820
{
821
	tipc_node_fsm_evt(n_ptr, SELF_ESTABL_CONTACT_EVT);
Y
Ying Xue 已提交
822
	n_ptr->action_flags |= TIPC_NOTIFY_NODE_UP;
823
	n_ptr->bclink.oos_state = 0;
824 825
	n_ptr->bclink.acked = tipc_bclink_get_last_sent(n_ptr->net);
	tipc_bclink_add_node(n_ptr->net, n_ptr->addr);
P
Per Liden 已提交
826 827
}

828 829
static void node_lost_contact(struct tipc_node *n_ptr,
			      struct sk_buff_head *inputq)
P
Per Liden 已提交
830 831
{
	char addr_string[16];
832
	struct tipc_sock_conn *conn, *safe;
833
	struct tipc_link *l;
834 835 836 837
	struct list_head *conns = &n_ptr->conn_sks;
	struct sk_buff *skb;
	struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
	uint i;
P
Per Liden 已提交
838

839 840
	pr_debug("Lost contact with %s\n",
		 tipc_addr_string_fill(addr_string, n_ptr->addr));
841 842

	/* Flush broadcast link info associated with lost node */
843
	if (n_ptr->bclink.recv_permitted) {
J
Jon Paul Maloy 已提交
844
		__skb_queue_purge(&n_ptr->bclink.deferdq);
845

846 847 848
		if (n_ptr->bclink.reasm_buf) {
			kfree_skb(n_ptr->bclink.reasm_buf);
			n_ptr->bclink.reasm_buf = NULL;
849 850
		}

851
		tipc_bclink_remove_node(n_ptr->net, n_ptr->addr);
852
		tipc_bclink_acknowledge(n_ptr, INVALID_LINK_SEQ);
P
Per Liden 已提交
853

854
		n_ptr->bclink.recv_permitted = false;
855
	}
P
Per Liden 已提交
856

857
	/* Abort any ongoing link failover */
P
Per Liden 已提交
858
	for (i = 0; i < MAX_BEARERS; i++) {
859 860 861
		l = n_ptr->links[i].link;
		if (l)
			tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT);
P
Per Liden 已提交
862
	}
863

864
	/* Prevent re-contact with node until cleanup is done */
865
	tipc_node_fsm_evt(n_ptr, SELF_LOST_CONTACT_EVT);
866 867 868 869 870 871 872 873 874 875 876

	/* Notify publications from this node */
	n_ptr->action_flags |= TIPC_NOTIFY_NODE_DOWN;

	/* Notify sockets connected to node */
	list_for_each_entry_safe(conn, safe, conns, list) {
		skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
				      SHORT_H_SIZE, 0, tn->own_addr,
				      conn->peer_node, conn->port,
				      conn->peer_port, TIPC_ERR_NO_NODE);
		if (likely(skb)) {
877
			skb_queue_tail(inputq, skb);
878 879 880 881 882
			n_ptr->action_flags |= TIPC_MSG_EVT;
		}
		list_del(&conn->list);
		kfree(conn);
	}
P
Per Liden 已提交
883 884
}

E
Erik Hugne 已提交
885 886 887 888 889 890 891 892 893
/**
 * tipc_node_get_linkname - get the name of a link
 *
 * @bearer_id: id of the bearer
 * @node: peer node address
 * @linkname: link name output buffer
 *
 * Returns 0 on success
 */
894 895
int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
			   char *linkname, size_t len)
E
Erik Hugne 已提交
896 897
{
	struct tipc_link *link;
898
	int err = -EINVAL;
899
	struct tipc_node *node = tipc_node_find(net, addr);
E
Erik Hugne 已提交
900

901 902 903 904 905 906
	if (!node)
		return err;

	if (bearer_id >= MAX_BEARERS)
		goto exit;

E
Erik Hugne 已提交
907
	tipc_node_lock(node);
908
	link = node->links[bearer_id].link;
E
Erik Hugne 已提交
909 910
	if (link) {
		strncpy(linkname, link->name, len);
911
		err = 0;
E
Erik Hugne 已提交
912
	}
913
exit:
E
Erik Hugne 已提交
914
	tipc_node_unlock(node);
915 916
	tipc_node_put(node);
	return err;
E
Erik Hugne 已提交
917
}
918 919 920

void tipc_node_unlock(struct tipc_node *node)
{
921
	struct net *net = node->net;
922
	u32 addr = 0;
923
	u32 flags = node->action_flags;
Y
Ying Xue 已提交
924
	u32 link_id = 0;
925
	struct list_head *publ_list;
926
	struct sk_buff_head *inputq = node->inputq;
927
	struct sk_buff_head *namedq;
928

929 930
	if (likely(!flags || (flags == TIPC_MSG_EVT))) {
		node->action_flags = 0;
931
		spin_unlock_bh(&node->lock);
932 933
		if (flags == TIPC_MSG_EVT)
			tipc_sk_rcv(net, inputq);
934 935 936
		return;
	}

Y
Ying Xue 已提交
937 938
	addr = node->addr;
	link_id = node->link_id;
939
	namedq = node->namedq;
940
	publ_list = &node->publ_list;
Y
Ying Xue 已提交
941

942 943 944 945
	node->action_flags &= ~(TIPC_MSG_EVT |
				TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |
				TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP |
				TIPC_WAKEUP_BCAST_USERS | TIPC_BCAST_MSG_EVT |
946
				TIPC_NAMED_MSG_EVT | TIPC_BCAST_RESET);
Y
Ying Xue 已提交
947

948 949
	spin_unlock_bh(&node->lock);

950 951
	if (flags & TIPC_NOTIFY_NODE_DOWN)
		tipc_publ_notify(net, publ_list, addr);
952

953
	if (flags & TIPC_WAKEUP_BCAST_USERS)
954
		tipc_bclink_wakeup_users(net);
955

Y
Ying Xue 已提交
956
	if (flags & TIPC_NOTIFY_NODE_UP)
957
		tipc_named_node_up(net, addr);
Y
Ying Xue 已提交
958 959

	if (flags & TIPC_NOTIFY_LINK_UP)
960
		tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
Y
Ying Xue 已提交
961 962 963
				     TIPC_NODE_SCOPE, link_id, addr);

	if (flags & TIPC_NOTIFY_LINK_DOWN)
964
		tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
Y
Ying Xue 已提交
965
				      link_id, addr);
966 967 968 969 970 971

	if (flags & TIPC_MSG_EVT)
		tipc_sk_rcv(net, inputq);

	if (flags & TIPC_NAMED_MSG_EVT)
		tipc_named_rcv(net, namedq);
972 973 974

	if (flags & TIPC_BCAST_MSG_EVT)
		tipc_bclink_input(net);
975 976

	if (flags & TIPC_BCAST_RESET)
977
		tipc_node_reset_links(node);
978
}
979 980

/* Caller should hold node lock for the passed node */
981
static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
982 983 984 985
{
	void *hdr;
	struct nlattr *attrs;

986
	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
			  NLM_F_MULTI, TIPC_NL_NODE_GET);
	if (!hdr)
		return -EMSGSIZE;

	attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE);
	if (!attrs)
		goto msg_full;

	if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
		goto attr_msg_full;
	if (tipc_node_is_up(node))
		if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP))
			goto attr_msg_full;

	nla_nest_end(msg->skb, attrs);
	genlmsg_end(msg->skb, hdr);

	return 0;

attr_msg_full:
	nla_nest_cancel(msg->skb, attrs);
msg_full:
	genlmsg_cancel(msg->skb, hdr);

	return -EMSGSIZE;
}

1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
static struct tipc_link *tipc_node_select_link(struct tipc_node *n, int sel,
					       int *bearer_id,
					       struct tipc_media_addr **maddr)
{
	int id = n->active_links[sel & 1];

	if (unlikely(id < 0))
		return NULL;

	*bearer_id = id;
	*maddr = &n->links[id].maddr;
	return n->links[id].link;
}

/**
 * tipc_node_xmit() is the general link level function for message sending
 * @net: the applicable net namespace
 * @list: chain of buffers containing message
 * @dnode: address of destination node
 * @selector: a number used for deterministic link selection
 * Consumes the buffer chain, except when returning -ELINKCONG
 * Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE
 */
int tipc_node_xmit(struct net *net, struct sk_buff_head *list,
		   u32 dnode, int selector)
{
	struct tipc_link *l = NULL;
	struct tipc_node *n;
	struct sk_buff_head xmitq;
	struct tipc_media_addr *maddr;
	int bearer_id;
	int rc = -EHOSTUNREACH;

	__skb_queue_head_init(&xmitq);
	n = tipc_node_find(net, dnode);
	if (likely(n)) {
		tipc_node_lock(n);
		l = tipc_node_select_link(n, selector, &bearer_id, &maddr);
		if (likely(l))
			rc = tipc_link_xmit(l, list, &xmitq);
		tipc_node_unlock(n);
1055 1056
		if (unlikely(rc == -ENOBUFS))
			tipc_node_link_down(n, bearer_id, false);
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
		tipc_node_put(n);
	}
	if (likely(!rc)) {
		tipc_bearer_xmit(net, bearer_id, &xmitq, maddr);
		return 0;
	}
	if (likely(in_own_node(net, dnode))) {
		tipc_sk_rcv(net, list);
		return 0;
	}
	return rc;
}

/* tipc_node_xmit_skb(): send single buffer to destination
 * Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE
 * messages, which will not be rejected
 * The only exception is datagram messages rerouted after secondary
 * lookup, which are rare and safe to dispose of anyway.
 * TODO: Return real return value, and let callers use
 * tipc_wait_for_sendpkt() where applicable
 */
int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode,
		       u32 selector)
{
	struct sk_buff_head head;
	int rc;

	skb_queue_head_init(&head);
	__skb_queue_tail(&head, skb);
	rc = tipc_node_xmit(net, &head, dnode, selector);
	if (rc == -ELINKCONG)
		kfree_skb(skb);
	return 0;
}

1092 1093 1094 1095 1096
/**
 * tipc_node_check_state - check and if necessary update node state
 * @skb: TIPC packet
 * @bearer_id: identity of bearer delivering the packet
 * Returns true if state is ok, otherwise consumes buffer and returns false
1097
 */
1098
static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb,
1099
				  int bearer_id, struct sk_buff_head *xmitq)
1100 1101
{
	struct tipc_msg *hdr = buf_msg(skb);
1102 1103
	int usr = msg_user(hdr);
	int mtyp = msg_type(hdr);
1104
	u16 oseqno = msg_seqno(hdr);
1105 1106 1107 1108 1109
	u16 iseqno = msg_seqno(msg_get_wrapped(hdr));
	u16 exp_pkts = msg_msgcnt(hdr);
	u16 rcv_nxt, syncpt, dlv_nxt;
	int state = n->state;
	struct tipc_link *l, *pl = NULL;
1110 1111
	struct tipc_media_addr *maddr;
	int i, pb_id;
1112

1113 1114 1115 1116
	l = n->links[bearer_id].link;
	if (!l)
		return false;
	rcv_nxt = l->rcv_nxt;
1117 1118


1119 1120
	if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL)))
		return true;
1121

1122 1123 1124 1125 1126 1127 1128
	/* Find parallel link, if any */
	for (i = 0; i < MAX_BEARERS; i++) {
		if ((i != bearer_id) && n->links[i].link) {
			pl = n->links[i].link;
			break;
		}
	}
1129

1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
	/* Update node accesibility if applicable */
	if (state == SELF_UP_PEER_COMING) {
		if (!tipc_link_is_up(l))
			return true;
		if (!msg_peer_link_is_up(hdr))
			return true;
		tipc_node_fsm_evt(n, PEER_ESTABL_CONTACT_EVT);
	}

	if (state == SELF_DOWN_PEER_LEAVING) {
		if (msg_peer_node_is_up(hdr))
			return false;
		tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
	}

	/* Ignore duplicate packets */
	if (less(oseqno, rcv_nxt))
		return true;

	/* Initiate or update failover mode if applicable */
	if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) {
		syncpt = oseqno + exp_pkts - 1;
1152 1153 1154 1155 1156
		if (pl && tipc_link_is_up(pl)) {
			pb_id = pl->bearer_id;
			__tipc_node_link_down(n, &pb_id, xmitq, &maddr);
			tipc_skb_queue_splice_tail_init(pl->inputq, l->inputq);
		}
1157 1158 1159 1160 1161 1162
		/* If pkts arrive out of order, use lowest calculated syncpt */
		if (less(syncpt, n->sync_point))
			n->sync_point = syncpt;
	}

	/* Open parallel link when tunnel link reaches synch point */
1163 1164 1165
	if ((n->state == NODE_FAILINGOVER) && !tipc_link_is_failingover(l)) {
		if (!more(rcv_nxt, n->sync_point))
			return true;
1166 1167
		tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT);
		if (pl)
1168
			tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT);
1169 1170 1171 1172 1173 1174
		return true;
	}

	/* Initiate or update synch mode if applicable */
	if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG)) {
		syncpt = iseqno + exp_pkts - 1;
1175 1176
		if (!tipc_link_is_up(l)) {
			tipc_link_fsm_evt(l, LINK_ESTABLISH_EVT);
1177
			__tipc_node_link_up(n, bearer_id, xmitq);
1178
		}
1179 1180
		if (n->state == SELF_UP_PEER_UP) {
			n->sync_point = syncpt;
1181
			tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT);
1182 1183 1184 1185
			tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT);
		}
		if (less(syncpt, n->sync_point))
			n->sync_point = syncpt;
1186
	}
1187 1188

	/* Open tunnel link when parallel link reaches synch point */
1189
	if ((n->state == NODE_SYNCHING) && tipc_link_is_synching(l)) {
1190 1191 1192
		if (pl)
			dlv_nxt = mod(pl->rcv_nxt - skb_queue_len(pl->inputq));
		if (!pl || more(dlv_nxt, n->sync_point)) {
1193
			tipc_link_fsm_evt(l, LINK_SYNCH_END_EVT);
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
			tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
			return true;
		}
		if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG))
			return true;
		if (usr == LINK_PROTOCOL)
			return true;
		return false;
	}
	return true;
1204 1205
}

1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
/**
 * tipc_rcv - process TIPC packets/messages arriving from off-node
 * @net: the applicable net namespace
 * @skb: TIPC packet
 * @bearer: pointer to bearer message arrived on
 *
 * Invoked with no locks held. Bearer pointer must point to a valid bearer
 * structure (i.e. cannot be NULL), but bearer can be inactive.
 */
void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b)
{
	struct sk_buff_head xmitq;
	struct tipc_node *n;
1219 1220
	struct tipc_msg *hdr = buf_msg(skb);
	int usr = msg_user(hdr);
1221
	int bearer_id = b->identity;
1222
	struct tipc_link_entry *le;
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
	int rc = 0;

	__skb_queue_head_init(&xmitq);

	/* Ensure message is well-formed */
	if (unlikely(!tipc_msg_validate(skb)))
		goto discard;

	/* Handle arrival of a non-unicast link packet */
	if (unlikely(msg_non_seq(hdr))) {
1233
		if (usr ==  LINK_CONFIG)
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
			tipc_disc_rcv(net, skb, b);
		else
			tipc_bclink_rcv(net, skb);
		return;
	}

	/* Locate neighboring node that sent packet */
	n = tipc_node_find(net, msg_prevnode(hdr));
	if (unlikely(!n))
		goto discard;
1244
	le = &n->links[bearer_id];
1245

1246
	tipc_node_lock(n);
1247

1248 1249
	/* Is reception permitted at the moment ? */
	if (!tipc_node_filter_pkt(n, hdr))
1250 1251
		goto unlock;

1252
	if (unlikely(msg_user(hdr) == LINK_PROTOCOL))
1253 1254
		tipc_bclink_sync_state(n, hdr);

1255
	/* Release acked broadcast packets */
1256 1257 1258
	if (unlikely(n->bclink.acked != msg_bcast_ack(hdr)))
		tipc_bclink_acknowledge(n, msg_bcast_ack(hdr));

1259
	/* Check and if necessary update node state */
1260
	if (likely(tipc_node_check_state(n, skb, bearer_id, &xmitq))) {
1261 1262 1263
		rc = tipc_link_rcv(le->link, skb, &xmitq);
		skb = NULL;
	}
1264 1265
unlock:
	tipc_node_unlock(n);
1266 1267

	if (unlikely(rc & TIPC_LINK_UP_EVT))
1268 1269
		tipc_node_link_up(n, bearer_id, &xmitq);

1270
	if (unlikely(rc & TIPC_LINK_DOWN_EVT))
1271
		tipc_node_link_down(n, bearer_id, false);
1272 1273 1274 1275 1276 1277 1278

	if (!skb_queue_empty(&le->inputq))
		tipc_sk_rcv(net, &le->inputq);

	if (!skb_queue_empty(&xmitq))
		tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);

1279 1280 1281 1282 1283
	tipc_node_put(n);
discard:
	kfree_skb(skb);
}

1284 1285 1286
int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	int err;
1287 1288
	struct net *net = sock_net(skb->sk);
	struct tipc_net *tn = net_generic(net, tipc_net_id);
1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
	int done = cb->args[0];
	int last_addr = cb->args[1];
	struct tipc_node *node;
	struct tipc_nl_msg msg;

	if (done)
		return 0;

	msg.skb = skb;
	msg.portid = NETLINK_CB(cb->skb).portid;
	msg.seq = cb->nlh->nlmsg_seq;

	rcu_read_lock();
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
	if (last_addr) {
		node = tipc_node_find(net, last_addr);
		if (!node) {
			rcu_read_unlock();
			/* We never set seq or call nl_dump_check_consistent()
			 * this means that setting prev_seq here will cause the
			 * consistence check to fail in the netlink callback
			 * handler. Resulting in the NLMSG_DONE message having
			 * the NLM_F_DUMP_INTR flag set if the node state
			 * changed while we released the lock.
			 */
			cb->prev_seq = 1;
			return -EPIPE;
		}
		tipc_node_put(node);
1317 1318
	}

1319
	list_for_each_entry_rcu(node, &tn->node_list, list) {
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
		if (last_addr) {
			if (node->addr == last_addr)
				last_addr = 0;
			else
				continue;
		}

		tipc_node_lock(node);
		err = __tipc_nl_add_node(&msg, node);
		if (err) {
			last_addr = node->addr;
			tipc_node_unlock(node);
			goto out;
		}

		tipc_node_unlock(node);
	}
	done = 1;
out:
	cb->args[0] = done;
	cb->args[1] = last_addr;
	rcu_read_unlock();

	return skb->len;
}