node.c 36.8 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"
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 tipc_node_delete(struct tipc_node *node);
76
static void tipc_node_timeout(unsigned long data);
77
static void tipc_node_fsm_evt(struct tipc_node *n, int evt);
P
Per Liden 已提交
78

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

86 87 88 89 90 91
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 }
};

92 93 94 95 96 97
/*
 * 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).
 */
98
static unsigned int tipc_hashfn(u32 addr)
99 100 101 102
{
	return addr & (NODE_HTABLE_SIZE - 1);
}

103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
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);
}

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

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

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

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

149
	spin_lock_bh(&tn->node_list_lock);
150 151 152
	n_ptr = tipc_node_find(net, addr);
	if (n_ptr)
		goto exit;
153
	n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
154
	if (!n_ptr) {
155
		pr_warn("Node creation failed, no memory\n");
156
		goto exit;
157 158
	}
	n_ptr->addr = addr;
159
	n_ptr->net = net;
160
	n_ptr->capabilities = capabilities;
161
	kref_init(&n_ptr->kref);
162
	spin_lock_init(&n_ptr->lock);
163 164
	INIT_HLIST_NODE(&n_ptr->hash);
	INIT_LIST_HEAD(&n_ptr->list);
165
	INIT_LIST_HEAD(&n_ptr->publ_list);
166
	INIT_LIST_HEAD(&n_ptr->conn_sks);
167 168 169 170
	skb_queue_head_init(&n_ptr->bc_entry.namedq);
	skb_queue_head_init(&n_ptr->bc_entry.inputq1);
	__skb_queue_head_init(&n_ptr->bc_entry.arrvq);
	skb_queue_head_init(&n_ptr->bc_entry.inputq2);
171 172
	hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]);
	list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
173 174 175
		if (n_ptr->addr < temp_node->addr)
			break;
	}
176
	list_add_tail_rcu(&n_ptr->list, &temp_node->list);
177
	n_ptr->state = SELF_DOWN_PEER_LEAVING;
178
	n_ptr->signature = INVALID_NODE_SIG;
179 180
	n_ptr->active_links[0] = INVALID_BEARER_ID;
	n_ptr->active_links[1] = INVALID_BEARER_ID;
181
	if (!tipc_link_bc_create(net, tipc_own_addr(net), n_ptr->addr,
182 183 184 185 186 187 188 189 190 191 192
				 U16_MAX, tipc_bc_sndlink(net)->window,
				 n_ptr->capabilities,
				 &n_ptr->bc_entry.inputq1,
				 &n_ptr->bc_entry.namedq,
				 tipc_bc_sndlink(net),
				 &n_ptr->bc_entry.link)) {
		pr_warn("Broadcast rcv link creation failed, no memory\n");
		kfree(n_ptr);
		n_ptr = NULL;
		goto exit;
	}
193
	tipc_node_get(n_ptr);
194 195
	setup_timer(&n_ptr->timer, tipc_node_timeout, (unsigned long)n_ptr);
	n_ptr->keepalive_intv = U32_MAX;
196
exit:
197
	spin_unlock_bh(&tn->node_list_lock);
P
Per Liden 已提交
198 199 200
	return n_ptr;
}

201 202 203 204 205 206 207 208 209 210 211 212 213 214
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);
}

215
static void tipc_node_delete(struct tipc_node *node)
P
Per Liden 已提交
216
{
217 218
	list_del_rcu(&node->list);
	hlist_del_rcu(&node->hash);
219
	kfree(node->bc_entry.link);
220
	kfree_rcu(node, rcu);
P
Per Liden 已提交
221 222
}

223
void tipc_node_stop(struct net *net)
224
{
225
	struct tipc_net *tn = net_generic(net, tipc_net_id);
226 227
	struct tipc_node *node, *t_node;

228
	spin_lock_bh(&tn->node_list_lock);
229 230 231
	list_for_each_entry_safe(node, t_node, &tn->node_list, list) {
		if (del_timer(&node->timer))
			tipc_node_put(node);
232
		tipc_node_put(node);
233
	}
234
	spin_unlock_bh(&tn->node_list_lock);
235 236
}

237
int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
238 239 240
{
	struct tipc_node *node;
	struct tipc_sock_conn *conn;
241
	int err = 0;
242

243
	if (in_own_node(net, dnode))
244 245
		return 0;

246
	node = tipc_node_find(net, dnode);
247 248 249 250 251
	if (!node) {
		pr_warn("Connecting sock to node 0x%x failed\n", dnode);
		return -EHOSTUNREACH;
	}
	conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
252 253 254 255
	if (!conn) {
		err = -EHOSTUNREACH;
		goto exit;
	}
256 257 258 259 260 261 262
	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);
263 264 265
exit:
	tipc_node_put(node);
	return err;
266 267
}

268
void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
269 270 271 272
{
	struct tipc_node *node;
	struct tipc_sock_conn *conn, *safe;

273
	if (in_own_node(net, dnode))
274 275
		return;

276
	node = tipc_node_find(net, dnode);
277 278 279 280 281 282 283 284 285 286 287
	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);
288
	tipc_node_put(node);
289 290
}

291 292 293 294 295
/* tipc_node_timeout - handle expiration of node timer
 */
static void tipc_node_timeout(unsigned long data)
{
	struct tipc_node *n = (struct tipc_node *)data;
296
	struct tipc_link_entry *le;
297 298 299 300 301 302 303 304
	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);
305 306
		le = &n->links[bearer_id];
		if (le->link) {
307
			/* Link tolerance may change asynchronously: */
308 309
			tipc_node_calculate_timer(n, le->link);
			rc = tipc_link_timeout(le->link, &xmitq);
310 311
		}
		tipc_node_unlock(n);
312 313 314
		tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr);
		if (rc & TIPC_LINK_DOWN_EVT)
			tipc_node_link_down(n, bearer_id, false);
315 316 317 318 319 320
	}
	if (!mod_timer(&n->timer, jiffies + n->keepalive_intv))
		tipc_node_get(n);
	tipc_node_put(n);
}

P
Per Liden 已提交
321
/**
322 323
 * __tipc_node_link_up - handle addition of link
 * Node lock must be held by caller
P
Per Liden 已提交
324 325
 * Link becomes active (alone or shared) or standby, depending on its priority.
 */
326 327
static void __tipc_node_link_up(struct tipc_node *n, int bearer_id,
				struct sk_buff_head *xmitq)
P
Per Liden 已提交
328
{
329 330
	int *slot0 = &n->active_links[0];
	int *slot1 = &n->active_links[1];
331 332
	struct tipc_link *ol = node_active_link(n, 0);
	struct tipc_link *nl = n->links[bearer_id].link;
333

334 335 336 337 338
	if (!nl)
		return;

	tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT);
	if (!tipc_link_is_up(nl))
339 340
		return;

341 342
	n->working_links++;
	n->action_flags |= TIPC_NOTIFY_LINK_UP;
343 344 345 346
	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 已提交
347

348
	tipc_bearer_add_dest(n->net, bearer_id, n->addr);
349
	tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id);
350

351
	pr_debug("Established link <%s> on network plane %c\n",
352
		 nl->name, nl->net_plane);
353

354 355
	/* First link? => give it both slots */
	if (!ol) {
356 357
		*slot0 = bearer_id;
		*slot1 = bearer_id;
358 359
		tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT);
		n->action_flags |= TIPC_NOTIFY_NODE_UP;
360
		tipc_bcast_add_peer(n->net, nl, xmitq);
361
		return;
P
Per Liden 已提交
362
	}
363

364 365 366
	/* Second link => redistribute slots */
	if (nl->priority > ol->priority) {
		pr_debug("Old link <%s> becomes standby\n", ol->name);
367
		*slot0 = bearer_id;
368
		*slot1 = bearer_id;
369 370
		tipc_link_set_active(nl, true);
		tipc_link_set_active(ol, false);
371
	} else if (nl->priority == ol->priority) {
372
		tipc_link_set_active(nl, true);
373
		*slot1 = bearer_id;
374 375
	} else {
		pr_debug("New link <%s> is standby\n", nl->name);
P
Per Liden 已提交
376 377
	}

378 379
	/* Prepare synchronization with first link */
	tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq);
P
Per Liden 已提交
380 381 382
}

/**
383 384 385
 * tipc_node_link_up - handle addition of link
 *
 * Link becomes active (alone or shared) or standby, depending on its priority.
P
Per Liden 已提交
386
 */
387 388
static void tipc_node_link_up(struct tipc_node *n, int bearer_id,
			      struct sk_buff_head *xmitq)
P
Per Liden 已提交
389
{
390 391 392 393 394 395 396 397 398 399 400 401 402
	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];
403 404 405
	int *slot0 = &n->active_links[0];
	int *slot1 = &n->active_links[1];
	int i, highest = 0;
406
	struct tipc_link *l, *_l, *tnl;
P
Per Liden 已提交
407

408
	l = n->links[*bearer_id].link;
409
	if (!l || tipc_link_is_reset(l))
410 411
		return;

412 413
	n->working_links--;
	n->action_flags |= TIPC_NOTIFY_LINK_DOWN;
414
	n->link_id = l->peer_bearer_id << 16 | *bearer_id;
415

416
	tipc_bearer_remove_dest(n->net, *bearer_id, n->addr);
417

418
	pr_debug("Lost link <%s> on network plane %c\n",
419
		 l->name, l->net_plane);
420

421 422 423 424 425 426 427
	/* 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;
428 429
		if (_l == l)
			continue;
430 431 432 433 434 435 436 437 438 439
		if (_l->priority < highest)
			continue;
		if (_l->priority > highest) {
			highest = _l->priority;
			*slot0 = i;
			*slot1 = i;
			continue;
		}
		*slot1 = i;
	}
440

441
	if (!tipc_node_is_up(n)) {
442 443 444 445
		if (tipc_link_peer_is_down(l))
			tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
		tipc_node_fsm_evt(n, SELF_LOST_CONTACT_EVT);
		tipc_link_fsm_evt(l, LINK_RESET_EVT);
446
		tipc_link_reset(l);
447 448
		tipc_link_build_reset_msg(l, xmitq);
		*maddr = &n->links[*bearer_id].maddr;
449
		node_lost_contact(n, &le->inputq);
450
		tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
451 452
		return;
	}
453
	tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
454

455 456
	/* There is still a working link => initiate failover */
	tnl = node_active_link(n, 0);
457 458
	tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
	tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
459
	n->sync_point = tnl->rcv_nxt + (U16_MAX / 2 - 1);
460
	tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq);
461
	tipc_link_reset(l);
462
	tipc_link_fsm_evt(l, LINK_RESET_EVT);
463
	tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
464 465 466 467 468 469 470 471
	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];
472
	struct tipc_link *l = le->link;
473 474 475
	struct tipc_media_addr *maddr;
	struct sk_buff_head xmitq;

476 477 478
	if (!l)
		return;

479 480 481
	__skb_queue_head_init(&xmitq);

	tipc_node_lock(n);
482 483 484 485 486 487 488 489 490 491
	if (!tipc_link_is_establishing(l)) {
		__tipc_node_link_down(n, &bearer_id, &xmitq, &maddr);
		if (delete) {
			kfree(l);
			le->link = NULL;
			n->link_cnt--;
		}
	} else {
		/* Defuse pending tipc_node_link_up() */
		tipc_link_fsm_evt(l, LINK_RESET_EVT);
492 493 494 495
	}
	tipc_node_unlock(n);
	tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr);
	tipc_sk_rcv(n->net, &le->inputq);
P
Per Liden 已提交
496 497
}

498
bool tipc_node_is_up(struct tipc_node *n)
P
Per Liden 已提交
499
{
500
	return n->active_links[0] != INVALID_BEARER_ID;
P
Per Liden 已提交
501 502
}

503 504 505 506 507
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)
508
{
509 510
	struct tipc_node *n;
	struct tipc_link *l;
J
Jon Paul Maloy 已提交
511
	struct tipc_link_entry *le;
512 513 514 515
	bool addr_match = false;
	bool sign_match = false;
	bool link_up = false;
	bool accept_addr = false;
516
	bool reset = true;
517
	char *if_name;
J
Jon Paul Maloy 已提交
518

519 520 521 522 523 524
	*dupl_addr = false;
	*respond = false;

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

526 527
	tipc_node_lock(n);

J
Jon Paul Maloy 已提交
528
	le = &n->links[b->identity];
529 530

	/* Prepare to validate requesting node's signature and media address */
J
Jon Paul Maloy 已提交
531
	l = le->link;
532
	link_up = l && tipc_link_is_up(l);
J
Jon Paul Maloy 已提交
533
	addr_match = l && !memcmp(&le->maddr, maddr, sizeof(*maddr));
534 535 536 537 538 539
	sign_match = (signature == n->signature);

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

	if (sign_match && addr_match && link_up) {
		/* All is fine. Do nothing. */
540
		reset = false;
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
	} 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;
	}
594

595 596
	if (!accept_addr)
		goto exit;
597

598
	/* Now create new link if not already existing */
599
	if (!l) {
J
Jon Paul Maloy 已提交
600 601 602 603
		if (n->link_cnt == 2) {
			pr_warn("Cannot establish 3rd link to %x\n", n->addr);
			goto exit;
		}
604
		if_name = strchr(b->name, ':') + 1;
605
		if (!tipc_link_create(net, if_name, b->identity, b->tolerance,
606 607
				      b->net_plane, b->mtu, b->priority,
				      b->window, mod(tipc_net(net)->random),
608
				      tipc_own_addr(net), onode,
609 610 611 612
				      n->capabilities, &le->maddr,
				      tipc_bc_sndlink(n->net), n->bc_entry.link,
				      &le->inputq,
				      &n->bc_entry.namedq, &l)) {
613 614 615
			*respond = false;
			goto exit;
		}
J
Jon Paul Maloy 已提交
616
		tipc_link_reset(l);
617
		tipc_link_fsm_evt(l, LINK_RESET_EVT);
618 619
		if (n->state == NODE_FAILINGOVER)
			tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
J
Jon Paul Maloy 已提交
620 621
		le->link = l;
		n->link_cnt++;
622
		tipc_node_calculate_timer(n, l);
623
		if (n->link_cnt == 1)
624 625 626
			if (!mod_timer(&n->timer, jiffies + n->keepalive_intv))
				tipc_node_get(n);
	}
J
Jon Paul Maloy 已提交
627
	memcpy(&le->maddr, maddr, sizeof(*maddr));
628 629
exit:
	tipc_node_unlock(n);
630
	if (reset && !tipc_link_is_reset(l))
631
		tipc_node_link_down(n, b->identity, false);
632
	tipc_node_put(n);
633 634
}

635 636 637 638 639 640 641
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) {
642
		tipc_node_link_down(n, bearer_id, true);
643 644 645 646 647 648 649
	}
	rcu_read_unlock();
}

static void tipc_node_reset_links(struct tipc_node *n)
{
	char addr_string[16];
650
	int i;
651 652 653 654 655

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

	for (i = 0; i < MAX_BEARERS; i++) {
656
		tipc_node_link_down(n, i, false);
657 658 659
	}
}

660 661 662
/* tipc_node_fsm_evt - node finite state machine
 * Determines when contact is allowed with peer node
 */
663
static void tipc_node_fsm_evt(struct tipc_node *n, int evt)
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
{
	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 已提交
679 680 681 682
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
683
		default:
J
Jon Paul Maloy 已提交
684
			goto illegal_evt;
685 686 687 688 689 690 691 692 693 694
		}
		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 已提交
695 696 697 698 699 700
		case NODE_SYNCH_BEGIN_EVT:
			state = NODE_SYNCHING;
			break;
		case NODE_FAILOVER_BEGIN_EVT:
			state = NODE_FAILINGOVER;
			break;
701 702
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
J
Jon Paul Maloy 已提交
703 704
		case NODE_SYNCH_END_EVT:
		case NODE_FAILOVER_END_EVT:
705 706
			break;
		default:
J
Jon Paul Maloy 已提交
707
			goto illegal_evt;
708 709 710 711 712 713 714 715 716 717 718
		}
		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 已提交
719 720 721 722
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
723
		default:
J
Jon Paul Maloy 已提交
724
			goto illegal_evt;
725 726 727 728 729 730 731 732 733 734 735 736
		}
		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:
J
Jon Paul Maloy 已提交
737 738
		case NODE_SYNCH_END_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
739 740
			break;
		case NODE_SYNCH_BEGIN_EVT:
J
Jon Paul Maloy 已提交
741
		case NODE_FAILOVER_END_EVT:
742
		default:
J
Jon Paul Maloy 已提交
743
			goto illegal_evt;
744 745 746 747 748 749 750 751 752 753 754 755 756
		}
		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 已提交
757 758 759 760
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
761
		default:
J
Jon Paul Maloy 已提交
762
			goto illegal_evt;
763 764 765 766 767 768 769 770 771 772 773
		}
		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 已提交
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
		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:
799
		default:
J
Jon Paul Maloy 已提交
800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
			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;
824 825 826 827 828 829 830
		}
		break;
	default:
		pr_err("Unknown node fsm state %x\n", state);
		break;
	}
	n->state = state;
J
Jon Paul Maloy 已提交
831 832 833 834
	return;

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

837
bool tipc_node_filter_pkt(struct tipc_node *n, struct tipc_msg *hdr)
838 839 840 841 842
{
	int state = n->state;

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

844 845
	if (state == SELF_LEAVING_PEER_DOWN)
		return false;
846 847

	if (state == SELF_DOWN_PEER_LEAVING) {
848
		if (msg_peer_node_is_up(hdr))
849 850
			return false;
	}
851 852

	return true;
853 854
}

855
static void node_lost_contact(struct tipc_node *n,
856
			      struct sk_buff_head *inputq)
P
Per Liden 已提交
857 858
{
	char addr_string[16];
859
	struct tipc_sock_conn *conn, *safe;
860
	struct tipc_link *l;
861
	struct list_head *conns = &n->conn_sks;
862 863
	struct sk_buff *skb;
	uint i;
P
Per Liden 已提交
864

865
	pr_debug("Lost contact with %s\n",
866
		 tipc_addr_string_fill(addr_string, n->addr));
867

868
	/* Clean up broadcast state */
869
	tipc_bcast_remove_peer(n->net, n->bc_entry.link);
P
Per Liden 已提交
870

871
	/* Abort any ongoing link failover */
P
Per Liden 已提交
872
	for (i = 0; i < MAX_BEARERS; i++) {
873
		l = n->links[i].link;
874 875
		if (l)
			tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT);
P
Per Liden 已提交
876
	}
877

878
	/* Notify publications from this node */
879
	n->action_flags |= TIPC_NOTIFY_NODE_DOWN;
880 881 882 883

	/* Notify sockets connected to node */
	list_for_each_entry_safe(conn, safe, conns, list) {
		skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
884
				      SHORT_H_SIZE, 0, tipc_own_addr(n->net),
885 886
				      conn->peer_node, conn->port,
				      conn->peer_port, TIPC_ERR_NO_NODE);
887
		if (likely(skb))
888
			skb_queue_tail(inputq, skb);
889 890 891
		list_del(&conn->list);
		kfree(conn);
	}
P
Per Liden 已提交
892 893
}

E
Erik Hugne 已提交
894 895 896 897 898 899 900 901 902
/**
 * 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
 */
903 904
int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
			   char *linkname, size_t len)
E
Erik Hugne 已提交
905 906
{
	struct tipc_link *link;
907
	int err = -EINVAL;
908
	struct tipc_node *node = tipc_node_find(net, addr);
E
Erik Hugne 已提交
909

910 911 912 913 914 915
	if (!node)
		return err;

	if (bearer_id >= MAX_BEARERS)
		goto exit;

E
Erik Hugne 已提交
916
	tipc_node_lock(node);
917
	link = node->links[bearer_id].link;
E
Erik Hugne 已提交
918 919
	if (link) {
		strncpy(linkname, link->name, len);
920
		err = 0;
E
Erik Hugne 已提交
921
	}
922
exit:
E
Erik Hugne 已提交
923
	tipc_node_unlock(node);
924 925
	tipc_node_put(node);
	return err;
E
Erik Hugne 已提交
926
}
927 928 929

void tipc_node_unlock(struct tipc_node *node)
{
930
	struct net *net = node->net;
931
	u32 addr = 0;
932
	u32 flags = node->action_flags;
Y
Ying Xue 已提交
933
	u32 link_id = 0;
934
	struct list_head *publ_list;
935

936
	if (likely(!flags)) {
937 938 939 940
		spin_unlock_bh(&node->lock);
		return;
	}

Y
Ying Xue 已提交
941 942
	addr = node->addr;
	link_id = node->link_id;
943
	publ_list = &node->publ_list;
Y
Ying Xue 已提交
944

945
	node->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |
946 947
				TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP |
				TIPC_WAKEUP_BCAST_USERS | TIPC_BCAST_MSG_EVT |
948
				TIPC_BCAST_RESET);
Y
Ying Xue 已提交
949

950 951
	spin_unlock_bh(&node->lock);

952 953
	if (flags & TIPC_NOTIFY_NODE_DOWN)
		tipc_publ_notify(net, publ_list, addr);
954

955
	if (flags & TIPC_WAKEUP_BCAST_USERS)
956
		tipc_bclink_wakeup_users(net);
957

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

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

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

969 970
	if (flags & TIPC_BCAST_MSG_EVT)
		tipc_bclink_input(net);
971 972

	if (flags & TIPC_BCAST_RESET)
973
		tipc_node_reset_links(node);
974
}
975 976

/* Caller should hold node lock for the passed node */
977
static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
978 979 980 981
{
	void *hdr;
	struct nlattr *attrs;

982
	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
			  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;
}

1010 1011 1012 1013 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
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);
1051 1052
		if (unlikely(rc == -ENOBUFS))
			tipc_node_link_down(n, bearer_id, false);
1053 1054 1055 1056 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
		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;
}

1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
/**
 * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node
 * @net: the applicable net namespace
 * @skb: TIPC packet
 * @bearer_id: id of bearer message arrived on
 *
 * Invoked with no locks held.
 */
void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id)
{
	int rc;
	struct sk_buff_head xmitq;
	struct tipc_bclink_entry *be;
	struct tipc_link_entry *le;
	struct tipc_msg *hdr = buf_msg(skb);
	int usr = msg_user(hdr);
	u32 dnode = msg_destnode(hdr);
	struct tipc_node *n;

	__skb_queue_head_init(&xmitq);

	/* If NACK for other node, let rcv link for that node peek into it */
	if ((usr == BCAST_PROTOCOL) && (dnode != tipc_own_addr(net)))
		n = tipc_node_find(net, dnode);
	else
		n = tipc_node_find(net, msg_prevnode(hdr));
	if (!n) {
		kfree_skb(skb);
		return;
	}
	be = &n->bc_entry;
	le = &n->links[bearer_id];

	rc = tipc_bcast_rcv(net, be->link, skb);

	/* Broadcast link reset may happen at reassembly failure */
	if (rc & TIPC_LINK_DOWN_EVT)
		tipc_node_reset_links(n);

	/* Broadcast ACKs are sent on a unicast link */
	if (rc & TIPC_LINK_SND_BC_ACK) {
		tipc_node_lock(n);
		tipc_link_build_ack_msg(le->link, &xmitq);
		tipc_node_unlock(n);
	}

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

	/* Deliver. 'arrvq' is under inputq2's lock protection */
	if (!skb_queue_empty(&be->inputq1)) {
		spin_lock_bh(&be->inputq2.lock);
		spin_lock_bh(&be->inputq1.lock);
		skb_queue_splice_tail_init(&be->inputq1, &be->arrvq);
		spin_unlock_bh(&be->inputq1.lock);
		spin_unlock_bh(&be->inputq2.lock);
		tipc_sk_mcast_rcv(net, &be->arrvq, &be->inputq2);
	}
	tipc_node_put(n);
}

1149 1150 1151 1152 1153
/**
 * 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
1154
 */
1155
static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb,
1156
				  int bearer_id, struct sk_buff_head *xmitq)
1157 1158
{
	struct tipc_msg *hdr = buf_msg(skb);
1159 1160
	int usr = msg_user(hdr);
	int mtyp = msg_type(hdr);
1161
	u16 oseqno = msg_seqno(hdr);
1162 1163 1164 1165
	u16 iseqno = msg_seqno(msg_get_wrapped(hdr));
	u16 exp_pkts = msg_msgcnt(hdr);
	u16 rcv_nxt, syncpt, dlv_nxt;
	int state = n->state;
1166
	struct tipc_link *l, *tnl, *pl = NULL;
1167 1168
	struct tipc_media_addr *maddr;
	int i, pb_id;
1169

1170 1171 1172 1173
	l = n->links[bearer_id].link;
	if (!l)
		return false;
	rcv_nxt = l->rcv_nxt;
1174 1175


1176 1177
	if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL)))
		return true;
1178

1179 1180 1181 1182 1183 1184 1185
	/* 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;
		}
	}
1186

1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
	/* 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 */
1203
	if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt))
1204 1205 1206 1207 1208
		return true;

	/* Initiate or update failover mode if applicable */
	if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) {
		syncpt = oseqno + exp_pkts - 1;
1209 1210 1211 1212 1213
		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);
		}
1214 1215 1216 1217 1218 1219
		/* 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 */
1220
	if ((n->state == NODE_FAILINGOVER) && tipc_link_is_up(l)) {
1221 1222
		if (!more(rcv_nxt, n->sync_point))
			return true;
1223 1224
		tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT);
		if (pl)
1225
			tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT);
1226 1227 1228
		return true;
	}

1229 1230 1231 1232
	/* No synching needed if only one link */
	if (!pl || !tipc_link_is_up(pl))
		return true;

1233 1234
	/* Initiate synch mode if applicable */
	if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) {
1235
		syncpt = iseqno + exp_pkts - 1;
1236 1237
		if (!tipc_link_is_up(l)) {
			tipc_link_fsm_evt(l, LINK_ESTABLISH_EVT);
1238
			__tipc_node_link_up(n, bearer_id, xmitq);
1239
		}
1240 1241
		if (n->state == SELF_UP_PEER_UP) {
			n->sync_point = syncpt;
1242
			tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT);
1243 1244 1245 1246
			tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT);
		}
		if (less(syncpt, n->sync_point))
			n->sync_point = syncpt;
1247
	}
1248 1249

	/* Open tunnel link when parallel link reaches synch point */
1250
	if ((n->state == NODE_SYNCHING) && tipc_link_is_synching(l)) {
1251 1252 1253 1254 1255 1256
		if (tipc_link_is_synching(l)) {
			tnl = l;
		} else {
			tnl = pl;
			pl = l;
		}
1257 1258
		dlv_nxt = pl->rcv_nxt - mod(skb_queue_len(pl->inputq));
		if (more(dlv_nxt, n->sync_point)) {
1259
			tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
1260 1261 1262
			tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
			return true;
		}
1263 1264
		if (l == pl)
			return true;
1265 1266 1267 1268 1269 1270 1271
		if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG))
			return true;
		if (usr == LINK_PROTOCOL)
			return true;
		return false;
	}
	return true;
1272 1273
}

1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
/**
 * 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;
1287 1288
	struct tipc_msg *hdr = buf_msg(skb);
	int usr = msg_user(hdr);
1289
	int bearer_id = b->identity;
1290
	struct tipc_link_entry *le;
1291
	u16 bc_ack = msg_bcast_ack(hdr);
1292 1293 1294 1295 1296 1297 1298 1299
	int rc = 0;

	__skb_queue_head_init(&xmitq);

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

1300
	/* Handle arrival of discovery or broadcast packet */
1301
	if (unlikely(msg_non_seq(hdr))) {
1302 1303
		if (unlikely(usr == LINK_CONFIG))
			return tipc_disc_rcv(net, skb, b);
1304
		else
1305
			return tipc_node_bc_rcv(net, skb, bearer_id);
1306 1307 1308 1309 1310 1311
	}

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

1314 1315 1316 1317 1318 1319
	/* Ensure broadcast reception is in synch with peer's send state */
	if (unlikely(usr == LINK_PROTOCOL))
		tipc_bcast_sync_rcv(net, n->bc_entry.link, hdr);
	else if (unlikely(n->bc_entry.link->acked != bc_ack))
		tipc_bcast_ack_rcv(net, n->bc_entry.link, bc_ack);

1320
	tipc_node_lock(n);
1321

1322 1323
	/* Is reception permitted at the moment ? */
	if (!tipc_node_filter_pkt(n, hdr))
1324 1325
		goto unlock;

1326
	/* Check and if necessary update node state */
1327
	if (likely(tipc_node_check_state(n, skb, bearer_id, &xmitq))) {
1328 1329 1330
		rc = tipc_link_rcv(le->link, skb, &xmitq);
		skb = NULL;
	}
1331 1332
unlock:
	tipc_node_unlock(n);
1333 1334

	if (unlikely(rc & TIPC_LINK_UP_EVT))
1335 1336
		tipc_node_link_up(n, bearer_id, &xmitq);

1337
	if (unlikely(rc & TIPC_LINK_DOWN_EVT))
1338
		tipc_node_link_down(n, bearer_id, false);
1339

1340 1341
	if (unlikely(!skb_queue_empty(&n->bc_entry.namedq)))
		tipc_named_rcv(net, &n->bc_entry.namedq);
1342

1343 1344 1345 1346 1347 1348
	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);

1349 1350 1351 1352 1353
	tipc_node_put(n);
discard:
	kfree_skb(skb);
}

1354 1355 1356
int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	int err;
1357 1358
	struct net *net = sock_net(skb->sk);
	struct tipc_net *tn = net_generic(net, tipc_net_id);
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371
	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();
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
	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);
1387 1388
	}

1389
	list_for_each_entry_rcu(node, &tn->node_list, list) {
1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
		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;
}