node.c 77.9 KB
Newer Older
P
Per Liden 已提交
1 2
/*
 * net/tipc/node.c: TIPC node management routines
3
 *
4
 * Copyright (c) 2000-2006, 2012-2016, 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 "monitor.h"
44
#include "discover.h"
45
#include "netlink.h"
T
Tuong Lien 已提交
46
#include "trace.h"
47
#include "crypto.h"
48

49
#define INVALID_NODE_SIG	0x10000
50
#define NODE_CLEANUP_AFTER	300000
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

/* Flags used to take different actions according to flag type
 * TIPC_NOTIFY_NODE_DOWN: notify node is down
 * TIPC_NOTIFY_NODE_UP: notify node is up
 * TIPC_DISTRIBUTE_NAME: publish or withdraw link state name type
 */
enum {
	TIPC_NOTIFY_NODE_DOWN		= (1 << 3),
	TIPC_NOTIFY_NODE_UP		= (1 << 4),
	TIPC_NOTIFY_LINK_UP		= (1 << 6),
	TIPC_NOTIFY_LINK_DOWN		= (1 << 7)
};

struct tipc_link_entry {
	struct tipc_link *link;
	spinlock_t lock; /* per link */
	u32 mtu;
	struct sk_buff_head inputq;
	struct tipc_media_addr maddr;
};

struct tipc_bclink_entry {
	struct tipc_link *link;
	struct sk_buff_head inputq1;
	struct sk_buff_head arrvq;
	struct sk_buff_head inputq2;
	struct sk_buff_head namedq;
78 79
	u16 named_rcv_nxt;
	bool named_open;
80 81 82 83 84
};

/**
 * struct tipc_node - TIPC node structure
 * @addr: network address of node
R
Randy Dunlap 已提交
85
 * @kref: reference counter to node object
86 87 88 89 90 91 92
 * @lock: rwlock governing access to structure
 * @net: the applicable net namespace
 * @hash: links to adjacent nodes in unsorted hash chain
 * @inputq: pointer to input queue containing messages for msg event
 * @namedq: pointer to name table input queue with name table messages
 * @active_links: bearer ids of active links, used as index into links[] array
 * @links: array containing references to all links to node
R
Randy Dunlap 已提交
93
 * @bc_entry: broadcast link entry
94 95
 * @action_flags: bit mask of different types of node actions
 * @state: connectivity state vs peer node
96
 * @preliminary: a preliminary node or not
R
Randy Dunlap 已提交
97
 * @failover_sent: failover sent or not
98 99 100 101 102 103 104
 * @sync_point: sequence number where synch/failover is finished
 * @list: links to adjacent nodes in sorted list of cluster's nodes
 * @working_links: number of working links to node (both active and standby)
 * @link_cnt: number of links to node
 * @capabilities: bitmap, indicating peer node's functional capabilities
 * @signature: node instance identifier
 * @link_id: local and remote bearer ids of changing link, if any
R
Randy Dunlap 已提交
105 106
 * @peer_id: 128-bit ID of peer
 * @peer_id_string: ID string of peer
107
 * @publ_list: list of publications
R
Randy Dunlap 已提交
108 109 110
 * @conn_sks: list of connections (FIXME)
 * @timer: node's keepalive timer
 * @keepalive_intv: keepalive interval in milliseconds
111
 * @rcu: rcu struct for tipc_node
112
 * @delete_at: indicates the time for deleting a down node
R
Randy Dunlap 已提交
113 114
 * @peer_net: peer's net namespace
 * @peer_hash_mix: hash for this peer (FIXME)
115
 * @crypto_rx: RX crypto handler
116 117 118 119 120 121 122 123 124 125 126 127 128
 */
struct tipc_node {
	u32 addr;
	struct kref kref;
	rwlock_t lock;
	struct net *net;
	struct hlist_node hash;
	int active_links[2];
	struct tipc_link_entry links[MAX_BEARERS];
	struct tipc_bclink_entry bc_entry;
	int action_flags;
	struct list_head list;
	int state;
129
	bool preliminary;
L
LUU Duc Canh 已提交
130
	bool failover_sent;
131 132 133 134 135 136
	u16 sync_point;
	int link_cnt;
	u16 working_links;
	u16 capabilities;
	u32 signature;
	u32 link_id;
137
	u8 peer_id[16];
138
	char peer_id_string[NODE_ID_STR_LEN];
139 140 141 142 143
	struct list_head publ_list;
	struct list_head conn_sks;
	unsigned long keepalive_intv;
	struct timer_list timer;
	struct rcu_head rcu;
144
	unsigned long delete_at;
145 146
	struct net *peer_net;
	u32 peer_hash_mix;
147 148 149
#ifdef CONFIG_TIPC_CRYPTO
	struct tipc_crypto *crypto_rx;
#endif
150 151
};

152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
/* 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
};

176 177 178 179 180 181
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);
182
static void tipc_node_delete(struct tipc_node *node);
183
static void tipc_node_timeout(struct timer_list *t);
184
static void tipc_node_fsm_evt(struct tipc_node *n, int evt);
185
static struct tipc_node *tipc_node_find(struct net *net, u32 addr);
186
static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id);
187
static bool node_is_up(struct tipc_node *n);
188
static void tipc_node_delete_from_list(struct tipc_node *node);
P
Per Liden 已提交
189

190 191 192 193 194 195 196
struct tipc_sock_conn {
	u32 port;
	u32 peer_port;
	u32 peer_node;
	struct list_head list;
};

197 198 199 200 201 202 203 204 205 206
static struct tipc_link *node_active_link(struct tipc_node *n, int sel)
{
	int bearer_id = n->active_links[sel & 1];

	if (unlikely(bearer_id == INVALID_BEARER_ID))
		return NULL;

	return n->links[bearer_id].link;
}

207
int tipc_node_get_mtu(struct net *net, u32 addr, u32 sel, bool connected)
208 209 210 211 212 213 214 215 216
{
	struct tipc_node *n;
	int bearer_id;
	unsigned int mtu = MAX_MSG_SIZE;

	n = tipc_node_find(net, addr);
	if (unlikely(!n))
		return mtu;

217 218 219 220 221 222 223 224
	/* Allow MAX_MSG_SIZE when building connection oriented message
	 * if they are in the same core network
	 */
	if (n->peer_net && connected) {
		tipc_node_put(n);
		return mtu;
	}

225 226 227 228 229 230
	bearer_id = n->active_links[sel & 1];
	if (likely(bearer_id != INVALID_BEARER_ID))
		mtu = n->links[bearer_id].mtu;
	tipc_node_put(n);
	return mtu;
}
231

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
bool tipc_node_get_id(struct net *net, u32 addr, u8 *id)
{
	u8 *own_id = tipc_own_id(net);
	struct tipc_node *n;

	if (!own_id)
		return true;

	if (addr == tipc_own_addr(net)) {
		memcpy(id, own_id, TIPC_NODEID_LEN);
		return true;
	}
	n = tipc_node_find(net, addr);
	if (!n)
		return false;

	memcpy(id, &n->peer_id, TIPC_NODEID_LEN);
	tipc_node_put(n);
	return true;
}

253 254 255 256 257 258 259 260 261 262 263 264 265
u16 tipc_node_get_capabilities(struct net *net, u32 addr)
{
	struct tipc_node *n;
	u16 caps;

	n = tipc_node_find(net, addr);
	if (unlikely(!n))
		return TIPC_NODE_CAPABILITIES;
	caps = n->capabilities;
	tipc_node_put(n);
	return caps;
}

266 267 268 269 270 271 272 273 274 275
u32 tipc_node_get_addr(struct tipc_node *node)
{
	return (node) ? node->addr : 0;
}

char *tipc_node_get_id_str(struct tipc_node *node)
{
	return node->peer_id_string;
}

276 277 278
#ifdef CONFIG_TIPC_CRYPTO
/**
 * tipc_node_crypto_rx - Retrieve crypto RX handle from node
R
Randy Dunlap 已提交
279
 * @__n: target tipc_node
280 281 282 283 284 285 286 287 288 289 290
 * Note: node ref counter must be held first!
 */
struct tipc_crypto *tipc_node_crypto_rx(struct tipc_node *__n)
{
	return (__n) ? __n->crypto_rx : NULL;
}

struct tipc_crypto *tipc_node_crypto_rx_by_list(struct list_head *pos)
{
	return container_of(pos, struct tipc_node, list)->crypto_rx;
}
291 292 293 294 295 296 297 298

struct tipc_crypto *tipc_node_crypto_rx_by_addr(struct net *net, u32 addr)
{
	struct tipc_node *n;

	n = tipc_node_find(net, addr);
	return (n) ? n->crypto_rx : NULL;
}
299 300
#endif

C
Chen Wandun 已提交
301
static void tipc_node_free(struct rcu_head *rp)
302 303 304 305 306 307 308 309 310
{
	struct tipc_node *n = container_of(rp, struct tipc_node, rcu);

#ifdef CONFIG_TIPC_CRYPTO
	tipc_crypto_stop(&n->crypto_rx);
#endif
	kfree(n);
}

311 312
static void tipc_node_kref_release(struct kref *kref)
{
313
	struct tipc_node *n = container_of(kref, struct tipc_node, kref);
314

315
	kfree(n->bc_entry.link);
316
	call_rcu(&n->rcu, tipc_node_free);
317 318
}

319
void tipc_node_put(struct tipc_node *node)
320 321 322 323
{
	kref_put(&node->kref, tipc_node_kref_release);
}

324
void tipc_node_get(struct tipc_node *node)
325 326 327 328
{
	kref_get(&node->kref);
}

329
/*
330 331
 * tipc_node_find - locate specified node object, if it exists
 */
332
static struct tipc_node *tipc_node_find(struct net *net, u32 addr)
333
{
334
	struct tipc_net *tn = tipc_net(net);
335
	struct tipc_node *node;
336
	unsigned int thash = tipc_hashfn(addr);
337

338
	rcu_read_lock();
339
	hlist_for_each_entry_rcu(node, &tn->node_htable[thash], hash) {
340
		if (node->addr != addr || node->preliminary)
341 342 343 344
			continue;
		if (!kref_get_unless_zero(&node->kref))
			node = NULL;
		break;
345
	}
346
	rcu_read_unlock();
347
	return node;
348 349
}

350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
/* tipc_node_find_by_id - locate specified node object by its 128-bit id
 * Note: this function is called only when a discovery request failed
 * to find the node by its 32-bit id, and is not time critical
 */
static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id)
{
	struct tipc_net *tn = tipc_net(net);
	struct tipc_node *n;
	bool found = false;

	rcu_read_lock();
	list_for_each_entry_rcu(n, &tn->node_list, list) {
		read_lock_bh(&n->lock);
		if (!memcmp(id, n->peer_id, 16) &&
		    kref_get_unless_zero(&n->kref))
			found = true;
		read_unlock_bh(&n->lock);
		if (found)
			break;
	}
	rcu_read_unlock();
	return found ? n : NULL;
}

374
static void tipc_node_read_lock(struct tipc_node *n)
J
Jon Paul Maloy 已提交
375 376 377 378
{
	read_lock_bh(&n->lock);
}

379
static void tipc_node_read_unlock(struct tipc_node *n)
J
Jon Paul Maloy 已提交
380 381 382 383 384 385 386 387 388
{
	read_unlock_bh(&n->lock);
}

static void tipc_node_write_lock(struct tipc_node *n)
{
	write_lock_bh(&n->lock);
}

389 390 391 392 393
static void tipc_node_write_unlock_fast(struct tipc_node *n)
{
	write_unlock_bh(&n->lock);
}

J
Jon Paul Maloy 已提交
394 395 396 397 398 399
static void tipc_node_write_unlock(struct tipc_node *n)
{
	struct net *net = n->net;
	u32 addr = 0;
	u32 flags = n->action_flags;
	u32 link_id = 0;
400
	u32 bearer_id;
J
Jon Paul Maloy 已提交
401 402 403 404 405 406 407 408 409
	struct list_head *publ_list;

	if (likely(!flags)) {
		write_unlock_bh(&n->lock);
		return;
	}

	addr = n->addr;
	link_id = n->link_id;
410
	bearer_id = link_id & 0xffff;
J
Jon Paul Maloy 已提交
411 412 413 414 415 416 417 418
	publ_list = &n->publ_list;

	n->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |
			     TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP);

	write_unlock_bh(&n->lock);

	if (flags & TIPC_NOTIFY_NODE_DOWN)
419
		tipc_publ_notify(net, publ_list, addr, n->capabilities);
J
Jon Paul Maloy 已提交
420 421

	if (flags & TIPC_NOTIFY_NODE_UP)
422
		tipc_named_node_up(net, addr, n->capabilities);
J
Jon Paul Maloy 已提交
423

424 425
	if (flags & TIPC_NOTIFY_LINK_UP) {
		tipc_mon_peer_up(net, addr, bearer_id);
J
Jon Paul Maloy 已提交
426
		tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
427
				     TIPC_NODE_SCOPE, link_id, link_id);
428 429 430
	}
	if (flags & TIPC_NOTIFY_LINK_DOWN) {
		tipc_mon_peer_down(net, addr, bearer_id);
J
Jon Paul Maloy 已提交
431
		tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
432
				      addr, link_id);
433
	}
J
Jon Paul Maloy 已提交
434 435
}

436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
static void tipc_node_assign_peer_net(struct tipc_node *n, u32 hash_mixes)
{
	int net_id = tipc_netid(n->net);
	struct tipc_net *tn_peer;
	struct net *tmp;
	u32 hash_chk;

	if (n->peer_net)
		return;

	for_each_net_rcu(tmp) {
		tn_peer = tipc_net(tmp);
		if (!tn_peer)
			continue;
		/* Integrity checking whether node exists in namespace or not */
		if (tn_peer->net_id != net_id)
			continue;
		if (memcmp(n->peer_id, tn_peer->node_id, NODE_ID_LEN))
			continue;
		hash_chk = tipc_net_hash_mixes(tmp, tn_peer->random);
		if (hash_mixes ^ hash_chk)
			continue;
		n->peer_net = tmp;
		n->peer_hash_mix = hash_mixes;
		break;
	}
}

464 465 466
struct tipc_node *tipc_node_create(struct net *net, u32 addr, u8 *peer_id,
				   u16 capabilities, u32 hash_mixes,
				   bool preliminary)
P
Per Liden 已提交
467
{
468
	struct tipc_net *tn = net_generic(net, tipc_net_id);
469
	struct tipc_node *n, *temp_node;
470
	struct tipc_link *l;
471
	unsigned long intv;
472
	int bearer_id;
J
Jon Paul Maloy 已提交
473
	int i;
P
Per Liden 已提交
474

475
	spin_lock_bh(&tn->node_list_lock);
476 477
	n = tipc_node_find(net, addr) ?:
		tipc_node_find_by_id(net, peer_id);
478
	if (n) {
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
		if (!n->preliminary)
			goto update;
		if (preliminary)
			goto exit;
		/* A preliminary node becomes "real" now, refresh its data */
		tipc_node_write_lock(n);
		n->preliminary = false;
		n->addr = addr;
		hlist_del_rcu(&n->hash);
		hlist_add_head_rcu(&n->hash,
				   &tn->node_htable[tipc_hashfn(addr)]);
		list_del_rcu(&n->list);
		list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
			if (n->addr < temp_node->addr)
				break;
		}
		list_add_tail_rcu(&n->list, &temp_node->list);
		tipc_node_write_unlock_fast(n);

update:
499 500
		if (n->peer_hash_mix ^ hash_mixes)
			tipc_node_assign_peer_net(n, hash_mixes);
501 502
		if (n->capabilities == capabilities)
			goto exit;
503
		/* Same node may come back with new capabilities */
504
		tipc_node_write_lock(n);
505
		n->capabilities = capabilities;
506 507 508 509 510
		for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {
			l = n->links[bearer_id].link;
			if (l)
				tipc_link_update_caps(l, capabilities);
		}
511 512
		tipc_node_write_unlock_fast(n);

513 514 515 516 517
		/* Calculate cluster capabilities */
		tn->capabilities = TIPC_NODE_CAPABILITIES;
		list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
			tn->capabilities &= temp_node->capabilities;
		}
518

519 520 521
		tipc_bcast_toggle_rcast(net,
					(tn->capabilities & TIPC_BCAST_RCAST));

522
		goto exit;
523
	}
524 525
	n = kzalloc(sizeof(*n), GFP_ATOMIC);
	if (!n) {
526
		pr_warn("Node creation failed, no memory\n");
527
		goto exit;
528
	}
529
	tipc_nodeid2string(n->peer_id_string, peer_id);
530 531 532 533 534 535 536 537
#ifdef CONFIG_TIPC_CRYPTO
	if (unlikely(tipc_crypto_start(&n->crypto_rx, net, n))) {
		pr_warn("Failed to start crypto RX(%s)!\n", n->peer_id_string);
		kfree(n);
		n = NULL;
		goto exit;
	}
#endif
538
	n->addr = addr;
539
	n->preliminary = preliminary;
540
	memcpy(&n->peer_id, peer_id, 16);
541
	n->net = net;
542 543 544 545
	n->peer_net = NULL;
	n->peer_hash_mix = 0;
	/* Assign kernel local namespace if exists */
	tipc_node_assign_peer_net(n, hash_mixes);
546 547 548 549 550 551 552 553 554 555 556
	n->capabilities = capabilities;
	kref_init(&n->kref);
	rwlock_init(&n->lock);
	INIT_HLIST_NODE(&n->hash);
	INIT_LIST_HEAD(&n->list);
	INIT_LIST_HEAD(&n->publ_list);
	INIT_LIST_HEAD(&n->conn_sks);
	skb_queue_head_init(&n->bc_entry.namedq);
	skb_queue_head_init(&n->bc_entry.inputq1);
	__skb_queue_head_init(&n->bc_entry.arrvq);
	skb_queue_head_init(&n->bc_entry.inputq2);
J
Jon Paul Maloy 已提交
557
	for (i = 0; i < MAX_BEARERS; i++)
558 559
		spin_lock_init(&n->links[i].lock);
	n->state = SELF_DOWN_PEER_LEAVING;
560
	n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER);
561 562 563
	n->signature = INVALID_NODE_SIG;
	n->active_links[0] = INVALID_BEARER_ID;
	n->active_links[1] = INVALID_BEARER_ID;
564
	n->bc_entry.link = NULL;
565
	tipc_node_get(n);
566
	timer_setup(&n->timer, tipc_node_timeout, 0);
567 568 569 570 571
	/* Start a slow timer anyway, crypto needs it */
	n->keepalive_intv = 10000;
	intv = jiffies + msecs_to_jiffies(n->keepalive_intv);
	if (!mod_timer(&n->timer, intv))
		tipc_node_get(n);
572 573 574 575 576 577
	hlist_add_head_rcu(&n->hash, &tn->node_htable[tipc_hashfn(addr)]);
	list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
		if (n->addr < temp_node->addr)
			break;
	}
	list_add_tail_rcu(&n->list, &temp_node->list);
578 579 580 581 582
	/* Calculate cluster capabilities */
	tn->capabilities = TIPC_NODE_CAPABILITIES;
	list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
		tn->capabilities &= temp_node->capabilities;
	}
583
	tipc_bcast_toggle_rcast(net, (tn->capabilities & TIPC_BCAST_RCAST));
T
Tuong Lien 已提交
584
	trace_tipc_node_create(n, true, " ");
585
exit:
586
	spin_unlock_bh(&tn->node_list_lock);
587
	return n;
P
Per Liden 已提交
588 589
}

590 591
static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l)
{
592
	unsigned long tol = tipc_link_tolerance(l);
593 594 595
	unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;

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

599 600
	/* Ensure link's abort limit corresponds to current tolerance */
	tipc_link_set_abort_limit(l, tol / n->keepalive_intv);
601 602
}

603
static void tipc_node_delete_from_list(struct tipc_node *node)
P
Per Liden 已提交
604
{
605 606 607
#ifdef CONFIG_TIPC_CRYPTO
	tipc_crypto_key_flush(node->crypto_rx);
#endif
608 609
	list_del_rcu(&node->list);
	hlist_del_rcu(&node->hash);
610
	tipc_node_put(node);
611 612 613 614
}

static void tipc_node_delete(struct tipc_node *node)
{
T
Tuong Lien 已提交
615
	trace_tipc_node_delete(node, true, " ");
616
	tipc_node_delete_from_list(node);
617 618 619

	del_timer_sync(&node->timer);
	tipc_node_put(node);
P
Per Liden 已提交
620 621
}

622
void tipc_node_stop(struct net *net)
623
{
624
	struct tipc_net *tn = tipc_net(net);
625 626
	struct tipc_node *node, *t_node;

627
	spin_lock_bh(&tn->node_list_lock);
628 629
	list_for_each_entry_safe(node, t_node, &tn->node_list, list)
		tipc_node_delete(node);
630
	spin_unlock_bh(&tn->node_list_lock);
631 632
}

633 634 635 636 637 638 639 640 641 642 643 644
void tipc_node_subscribe(struct net *net, struct list_head *subscr, u32 addr)
{
	struct tipc_node *n;

	if (in_own_node(net, addr))
		return;

	n = tipc_node_find(net, addr);
	if (!n) {
		pr_warn("Node subscribe rejected, unknown node 0x%x\n", addr);
		return;
	}
J
Jon Paul Maloy 已提交
645
	tipc_node_write_lock(n);
646
	list_add_tail(subscr, &n->publ_list);
647
	tipc_node_write_unlock_fast(n);
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
	tipc_node_put(n);
}

void tipc_node_unsubscribe(struct net *net, struct list_head *subscr, u32 addr)
{
	struct tipc_node *n;

	if (in_own_node(net, addr))
		return;

	n = tipc_node_find(net, addr);
	if (!n) {
		pr_warn("Node unsubscribe rejected, unknown node 0x%x\n", addr);
		return;
	}
J
Jon Paul Maloy 已提交
663
	tipc_node_write_lock(n);
664
	list_del_init(subscr);
665
	tipc_node_write_unlock_fast(n);
666 667 668
	tipc_node_put(n);
}

669
int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
670 671 672
{
	struct tipc_node *node;
	struct tipc_sock_conn *conn;
673
	int err = 0;
674

675
	if (in_own_node(net, dnode))
676 677
		return 0;

678
	node = tipc_node_find(net, dnode);
679 680 681 682 683
	if (!node) {
		pr_warn("Connecting sock to node 0x%x failed\n", dnode);
		return -EHOSTUNREACH;
	}
	conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
684 685 686 687
	if (!conn) {
		err = -EHOSTUNREACH;
		goto exit;
	}
688 689 690 691
	conn->peer_node = dnode;
	conn->port = port;
	conn->peer_port = peer_port;

J
Jon Paul Maloy 已提交
692
	tipc_node_write_lock(node);
693
	list_add_tail(&conn->list, &node->conn_sks);
J
Jon Paul Maloy 已提交
694
	tipc_node_write_unlock(node);
695 696 697
exit:
	tipc_node_put(node);
	return err;
698 699
}

700
void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
701 702 703 704
{
	struct tipc_node *node;
	struct tipc_sock_conn *conn, *safe;

705
	if (in_own_node(net, dnode))
706 707
		return;

708
	node = tipc_node_find(net, dnode);
709 710 711
	if (!node)
		return;

J
Jon Paul Maloy 已提交
712
	tipc_node_write_lock(node);
713 714 715 716 717 718
	list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
		if (port != conn->port)
			continue;
		list_del(&conn->list);
		kfree(conn);
	}
J
Jon Paul Maloy 已提交
719
	tipc_node_write_unlock(node);
720
	tipc_node_put(node);
721 722
}

723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
static void  tipc_node_clear_links(struct tipc_node *node)
{
	int i;

	for (i = 0; i < MAX_BEARERS; i++) {
		struct tipc_link_entry *le = &node->links[i];

		if (le->link) {
			kfree(le->link);
			le->link = NULL;
			node->link_cnt--;
		}
	}
}

/* tipc_node_cleanup - delete nodes that does not
 * have active links for NODE_CLEANUP_AFTER time
 */
741
static bool tipc_node_cleanup(struct tipc_node *peer)
742
{
743
	struct tipc_node *temp_node;
744 745 746
	struct tipc_net *tn = tipc_net(peer->net);
	bool deleted = false;

747 748 749 750
	/* If lock held by tipc_node_stop() the node will be deleted anyway */
	if (!spin_trylock_bh(&tn->node_list_lock))
		return false;

751 752 753 754 755 756 757 758
	tipc_node_write_lock(peer);

	if (!node_is_up(peer) && time_after(jiffies, peer->delete_at)) {
		tipc_node_clear_links(peer);
		tipc_node_delete_from_list(peer);
		deleted = true;
	}
	tipc_node_write_unlock(peer);
759

760 761 762 763 764
	if (!deleted) {
		spin_unlock_bh(&tn->node_list_lock);
		return deleted;
	}

765 766 767 768 769
	/* Calculate cluster capabilities */
	tn->capabilities = TIPC_NODE_CAPABILITIES;
	list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
		tn->capabilities &= temp_node->capabilities;
	}
770 771
	tipc_bcast_toggle_rcast(peer->net,
				(tn->capabilities & TIPC_BCAST_RCAST));
772 773 774 775
	spin_unlock_bh(&tn->node_list_lock);
	return deleted;
}

776 777
/* tipc_node_timeout - handle expiration of node timer
 */
778
static void tipc_node_timeout(struct timer_list *t)
779
{
780
	struct tipc_node *n = from_timer(n, t, timer);
781
	struct tipc_link_entry *le;
782
	struct sk_buff_head xmitq;
783
	int remains = n->link_cnt;
784 785 786
	int bearer_id;
	int rc = 0;

T
Tuong Lien 已提交
787
	trace_tipc_node_timeout(n, false, " ");
788 789 790 791 792 793
	if (!node_is_up(n) && tipc_node_cleanup(n)) {
		/*Removing the reference of Timer*/
		tipc_node_put(n);
		return;
	}

794 795 796 797
#ifdef CONFIG_TIPC_CRYPTO
	/* Take any crypto key related actions first */
	tipc_crypto_timeout(n->crypto_rx);
#endif
798 799
	__skb_queue_head_init(&xmitq);

800 801 802 803 804 805
	/* Initial node interval to value larger (10 seconds), then it will be
	 * recalculated with link lowest tolerance
	 */
	tipc_node_read_lock(n);
	n->keepalive_intv = 10000;
	tipc_node_read_unlock(n);
806
	for (bearer_id = 0; remains && (bearer_id < MAX_BEARERS); bearer_id++) {
J
Jon Paul Maloy 已提交
807
		tipc_node_read_lock(n);
808 809
		le = &n->links[bearer_id];
		if (le->link) {
810
			spin_lock_bh(&le->lock);
811
			/* Link tolerance may change asynchronously: */
812 813
			tipc_node_calculate_timer(n, le->link);
			rc = tipc_link_timeout(le->link, &xmitq);
814 815
			spin_unlock_bh(&le->lock);
			remains--;
816
		}
J
Jon Paul Maloy 已提交
817
		tipc_node_read_unlock(n);
818
		tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr, n);
819 820
		if (rc & TIPC_LINK_DOWN_EVT)
			tipc_node_link_down(n, bearer_id, false);
821
	}
822
	mod_timer(&n->timer, jiffies + msecs_to_jiffies(n->keepalive_intv));
823 824
}

P
Per Liden 已提交
825
/**
826
 * __tipc_node_link_up - handle addition of link
R
Randy Dunlap 已提交
827 828 829
 * @n: target tipc_node
 * @bearer_id: id of the bearer
 * @xmitq: queue for messages to be xmited on
830
 * Node lock must be held by caller
P
Per Liden 已提交
831 832
 * Link becomes active (alone or shared) or standby, depending on its priority.
 */
833 834
static void __tipc_node_link_up(struct tipc_node *n, int bearer_id,
				struct sk_buff_head *xmitq)
P
Per Liden 已提交
835
{
836 837
	int *slot0 = &n->active_links[0];
	int *slot1 = &n->active_links[1];
838 839
	struct tipc_link *ol = node_active_link(n, 0);
	struct tipc_link *nl = n->links[bearer_id].link;
840

841
	if (!nl || tipc_link_is_up(nl))
842 843 844 845
		return;

	tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT);
	if (!tipc_link_is_up(nl))
846 847
		return;

848 849
	n->working_links++;
	n->action_flags |= TIPC_NOTIFY_LINK_UP;
850
	n->link_id = tipc_link_id(nl);
851 852

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

855
	tipc_bearer_add_dest(n->net, bearer_id, n->addr);
856
	tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id);
857

858
	pr_debug("Established link <%s> on network plane %c\n",
859
		 tipc_link_name(nl), tipc_link_plane(nl));
T
Tuong Lien 已提交
860
	trace_tipc_node_link_up(n, true, " ");
861

862 863 864
	/* Ensure that a STATE message goes first */
	tipc_link_build_state_msg(nl, xmitq);

865 866
	/* First link? => give it both slots */
	if (!ol) {
867 868
		*slot0 = bearer_id;
		*slot1 = bearer_id;
869 870
		tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT);
		n->action_flags |= TIPC_NOTIFY_NODE_UP;
871
		tipc_link_set_active(nl, true);
872
		tipc_bcast_add_peer(n->net, nl, xmitq);
873
		return;
P
Per Liden 已提交
874
	}
875

876
	/* Second link => redistribute slots */
877 878
	if (tipc_link_prio(nl) > tipc_link_prio(ol)) {
		pr_debug("Old link <%s> becomes standby\n", tipc_link_name(ol));
879
		*slot0 = bearer_id;
880
		*slot1 = bearer_id;
881 882
		tipc_link_set_active(nl, true);
		tipc_link_set_active(ol, false);
883
	} else if (tipc_link_prio(nl) == tipc_link_prio(ol)) {
884
		tipc_link_set_active(nl, true);
885
		*slot1 = bearer_id;
886
	} else {
887
		pr_debug("New link <%s> is standby\n", tipc_link_name(nl));
P
Per Liden 已提交
888 889
	}

890 891
	/* Prepare synchronization with first link */
	tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq);
P
Per Liden 已提交
892 893 894
}

/**
895
 * tipc_node_link_up - handle addition of link
R
Randy Dunlap 已提交
896 897 898
 * @n: target tipc_node
 * @bearer_id: id of the bearer
 * @xmitq: queue for messages to be xmited on
899 900
 *
 * Link becomes active (alone or shared) or standby, depending on its priority.
P
Per Liden 已提交
901
 */
902 903
static void tipc_node_link_up(struct tipc_node *n, int bearer_id,
			      struct sk_buff_head *xmitq)
P
Per Liden 已提交
904
{
905 906
	struct tipc_media_addr *maddr;

J
Jon Paul Maloy 已提交
907
	tipc_node_write_lock(n);
908
	__tipc_node_link_up(n, bearer_id, xmitq);
909
	maddr = &n->links[bearer_id].maddr;
910
	tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr, n);
J
Jon Paul Maloy 已提交
911
	tipc_node_write_unlock(n);
912 913
}

914 915 916 917 918
/**
 * tipc_node_link_failover() - start failover in case "half-failover"
 *
 * This function is only called in a very special situation where link
 * failover can be already started on peer node but not on this node.
919 920
 * This can happen when e.g.::
 *
921 922
 *	1. Both links <1A-2A>, <1B-2B> down
 *	2. Link endpoint 2A up, but 1A still down (e.g. due to network
923
 *	disturbance, wrong session, etc.)
924 925
 *	3. Link <1B-2B> up
 *	4. Link endpoint 2A down (e.g. due to link tolerance timeout)
926
 *	5. Node 2 starts failover onto link <1B-2B>
927
 *
928
 *	==> Node 1 does never start link/node failover!
929 930 931 932 933 934 935 936 937 938 939 940 941 942
 *
 * @n: tipc node structure
 * @l: link peer endpoint failingover (- can be NULL)
 * @tnl: tunnel link
 * @xmitq: queue for messages to be xmited on tnl link later
 */
static void tipc_node_link_failover(struct tipc_node *n, struct tipc_link *l,
				    struct tipc_link *tnl,
				    struct sk_buff_head *xmitq)
{
	/* Avoid to be "self-failover" that can never end */
	if (!tipc_link_is_up(tnl))
		return;

943 944 945 946
	/* Don't rush, failure link may be in the process of resetting */
	if (l && !tipc_link_is_reset(l))
		return;

947 948 949 950 951 952 953 954 955 956 957
	tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
	tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);

	n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1);
	tipc_link_failover_prepare(l, tnl, xmitq);

	if (l)
		tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
	tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT);
}

958 959
/**
 * __tipc_node_link_down - handle loss of link
R
Randy Dunlap 已提交
960 961 962 963
 * @n: target tipc_node
 * @bearer_id: id of the bearer
 * @xmitq: queue for messages to be xmited on
 * @maddr: output media address of the bearer
964 965 966 967 968 969
 */
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];
970 971
	int *slot0 = &n->active_links[0];
	int *slot1 = &n->active_links[1];
972
	int i, highest = 0, prio;
973
	struct tipc_link *l, *_l, *tnl;
P
Per Liden 已提交
974

975
	l = n->links[*bearer_id].link;
976
	if (!l || tipc_link_is_reset(l))
977 978
		return;

979 980
	n->working_links--;
	n->action_flags |= TIPC_NOTIFY_LINK_DOWN;
981
	n->link_id = tipc_link_id(l);
982

983
	tipc_bearer_remove_dest(n->net, *bearer_id, n->addr);
984

985
	pr_debug("Lost link <%s> on network plane %c\n",
986
		 tipc_link_name(l), tipc_link_plane(l));
987

988 989 990 991 992 993 994
	/* 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;
995 996
		if (_l == l)
			continue;
997 998
		prio = tipc_link_prio(_l);
		if (prio < highest)
999
			continue;
1000 1001
		if (prio > highest) {
			highest = prio;
1002 1003 1004 1005 1006 1007
			*slot0 = i;
			*slot1 = i;
			continue;
		}
		*slot1 = i;
	}
1008

1009
	if (!node_is_up(n)) {
1010 1011 1012
		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);
T
Tuong Lien 已提交
1013
		trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down!");
1014
		tipc_link_fsm_evt(l, LINK_RESET_EVT);
1015
		tipc_link_reset(l);
1016 1017
		tipc_link_build_reset_msg(l, xmitq);
		*maddr = &n->links[*bearer_id].maddr;
1018
		node_lost_contact(n, &le->inputq);
1019
		tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
1020 1021
		return;
	}
1022
	tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
1023

1024
	/* There is still a working link => initiate failover */
1025 1026
	*bearer_id = n->active_links[0];
	tnl = n->links[*bearer_id].link;
1027 1028
	tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
	tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
1029
	n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1);
1030
	tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq);
T
Tuong Lien 已提交
1031
	trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down -> failover!");
1032
	tipc_link_reset(l);
1033
	tipc_link_fsm_evt(l, LINK_RESET_EVT);
1034
	tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
1035
	tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT);
1036
	*maddr = &n->links[*bearer_id].maddr;
1037 1038 1039 1040 1041
}

static void tipc_node_link_down(struct tipc_node *n, int bearer_id, bool delete)
{
	struct tipc_link_entry *le = &n->links[bearer_id];
J
Jon Maloy 已提交
1042
	struct tipc_media_addr *maddr = NULL;
1043
	struct tipc_link *l = le->link;
1044
	int old_bearer_id = bearer_id;
J
Jon Maloy 已提交
1045
	struct sk_buff_head xmitq;
1046

1047 1048 1049
	if (!l)
		return;

1050 1051
	__skb_queue_head_init(&xmitq);

J
Jon Paul Maloy 已提交
1052
	tipc_node_write_lock(n);
1053 1054 1055 1056
	if (!tipc_link_is_establishing(l)) {
		__tipc_node_link_down(n, &bearer_id, &xmitq, &maddr);
	} else {
		/* Defuse pending tipc_node_link_up() */
1057
		tipc_link_reset(l);
1058
		tipc_link_fsm_evt(l, LINK_RESET_EVT);
1059
	}
1060 1061 1062 1063 1064
	if (delete) {
		kfree(l);
		le->link = NULL;
		n->link_cnt--;
	}
T
Tuong Lien 已提交
1065
	trace_tipc_node_link_down(n, true, "node link down or deleted!");
J
Jon Paul Maloy 已提交
1066
	tipc_node_write_unlock(n);
1067 1068
	if (delete)
		tipc_mon_remove_peer(n->net, n->addr, old_bearer_id);
J
Jon Maloy 已提交
1069
	if (!skb_queue_empty(&xmitq))
1070
		tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr, n);
1071
	tipc_sk_rcv(n->net, &le->inputq);
P
Per Liden 已提交
1072 1073
}

1074
static bool node_is_up(struct tipc_node *n)
P
Per Liden 已提交
1075
{
1076
	return n->active_links[0] != INVALID_BEARER_ID;
P
Per Liden 已提交
1077 1078
}

1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
bool tipc_node_is_up(struct net *net, u32 addr)
{
	struct tipc_node *n;
	bool retval = false;

	if (in_own_node(net, addr))
		return true;

	n = tipc_node_find(net, addr);
	if (!n)
		return false;
	retval = node_is_up(n);
	tipc_node_put(n);
	return retval;
}

1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
static u32 tipc_node_suggest_addr(struct net *net, u32 addr)
{
	struct tipc_node *n;

	addr ^= tipc_net(net)->random;
	while ((n = tipc_node_find(net, addr))) {
		tipc_node_put(n);
		addr++;
	}
	return addr;
}

/* tipc_node_try_addr(): Check if addr can be used by peer, suggest other if not
1108
 * Returns suggested address if any, otherwise 0
1109 1110 1111 1112 1113
 */
u32 tipc_node_try_addr(struct net *net, u8 *id, u32 addr)
{
	struct tipc_net *tn = tipc_net(net);
	struct tipc_node *n;
1114 1115
	bool preliminary;
	u32 sugg_addr;
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130

	/* Suggest new address if some other peer is using this one */
	n = tipc_node_find(net, addr);
	if (n) {
		if (!memcmp(n->peer_id, id, NODE_ID_LEN))
			addr = 0;
		tipc_node_put(n);
		if (!addr)
			return 0;
		return tipc_node_suggest_addr(net, addr);
	}

	/* Suggest previously used address if peer is known */
	n = tipc_node_find_by_id(net, id);
	if (n) {
1131 1132
		sugg_addr = n->addr;
		preliminary = n->preliminary;
1133
		tipc_node_put(n);
1134 1135
		if (!preliminary)
			return sugg_addr;
1136
	}
1137 1138

	/* Even this node may be in conflict */
1139 1140 1141
	if (tn->trial_addr == addr)
		return tipc_node_suggest_addr(net, addr);

1142
	return 0;
1143 1144 1145 1146
}

void tipc_node_check_dest(struct net *net, u32 addr,
			  u8 *peer_id, struct tipc_bearer *b,
1147
			  u16 capabilities, u32 signature, u32 hash_mixes,
1148 1149
			  struct tipc_media_addr *maddr,
			  bool *respond, bool *dupl_addr)
1150
{
1151
	struct tipc_node *n;
1152
	struct tipc_link *l, *snd_l;
J
Jon Paul Maloy 已提交
1153
	struct tipc_link_entry *le;
1154 1155 1156 1157
	bool addr_match = false;
	bool sign_match = false;
	bool link_up = false;
	bool accept_addr = false;
1158
	bool reset = true;
1159
	char *if_name;
1160
	unsigned long intv;
1161
	u16 session;
J
Jon Paul Maloy 已提交
1162

1163 1164 1165
	*dupl_addr = false;
	*respond = false;

1166 1167
	n = tipc_node_create(net, addr, peer_id, capabilities, hash_mixes,
			     false);
1168 1169
	if (!n)
		return;
1170

J
Jon Paul Maloy 已提交
1171
	tipc_node_write_lock(n);
1172 1173 1174
	if (unlikely(!n->bc_entry.link)) {
		snd_l = tipc_bc_sndlink(net);
		if (!tipc_link_bc_create(net, tipc_own_addr(net),
1175
					 addr, peer_id, U16_MAX,
1176 1177
					 tipc_link_min_win(snd_l),
					 tipc_link_max_win(snd_l),
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
					 n->capabilities,
					 &n->bc_entry.inputq1,
					 &n->bc_entry.namedq, snd_l,
					 &n->bc_entry.link)) {
			pr_warn("Broadcast rcv link creation failed, no mem\n");
			tipc_node_write_unlock_fast(n);
			tipc_node_put(n);
			return;
		}
	}
1188

J
Jon Paul Maloy 已提交
1189
	le = &n->links[b->identity];
1190 1191

	/* Prepare to validate requesting node's signature and media address */
J
Jon Paul Maloy 已提交
1192
	l = le->link;
1193
	link_up = l && tipc_link_is_up(l);
J
Jon Paul Maloy 已提交
1194
	addr_match = l && !memcmp(&le->maddr, maddr, sizeof(*maddr));
1195 1196 1197 1198 1199 1200
	sign_match = (signature == n->signature);

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

	if (sign_match && addr_match && link_up) {
		/* All is fine. Do nothing. */
1201
		reset = false;
1202 1203 1204
		/* Peer node is not a container/local namespace */
		if (!n->peer_hash_mix)
			n->peer_hash_mix = hash_mixes;
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257
	} 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;
	}
1258

1259 1260
	if (!accept_addr)
		goto exit;
1261

1262
	/* Now create new link if not already existing */
1263
	if (!l) {
1264
		if (n->link_cnt == 2)
J
Jon Paul Maloy 已提交
1265
			goto exit;
1266

1267
		if_name = strchr(b->name, ':') + 1;
1268
		get_random_bytes(&session, sizeof(u16));
1269
		if (!tipc_link_create(net, if_name, b->identity, b->tolerance,
1270
				      b->net_plane, b->mtu, b->priority,
1271
				      b->min_win, b->max_win, session,
1272
				      tipc_own_addr(net), addr, peer_id,
1273
				      n->capabilities,
1274 1275 1276
				      tipc_bc_sndlink(n->net), n->bc_entry.link,
				      &le->inputq,
				      &n->bc_entry.namedq, &l)) {
1277 1278 1279
			*respond = false;
			goto exit;
		}
T
Tuong Lien 已提交
1280
		trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link created!");
J
Jon Paul Maloy 已提交
1281
		tipc_link_reset(l);
1282
		tipc_link_fsm_evt(l, LINK_RESET_EVT);
1283 1284
		if (n->state == NODE_FAILINGOVER)
			tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
J
Jon Paul Maloy 已提交
1285 1286
		le->link = l;
		n->link_cnt++;
1287
		tipc_node_calculate_timer(n, l);
1288 1289 1290
		if (n->link_cnt == 1) {
			intv = jiffies + msecs_to_jiffies(n->keepalive_intv);
			if (!mod_timer(&n->timer, intv))
1291
				tipc_node_get(n);
1292
		}
1293
	}
J
Jon Paul Maloy 已提交
1294
	memcpy(&le->maddr, maddr, sizeof(*maddr));
1295
exit:
J
Jon Paul Maloy 已提交
1296
	tipc_node_write_unlock(n);
1297
	if (reset && l && !tipc_link_is_reset(l))
1298
		tipc_node_link_down(n, b->identity, false);
1299
	tipc_node_put(n);
1300 1301
}

1302 1303 1304 1305 1306 1307 1308
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) {
1309
		tipc_node_link_down(n, bearer_id, true);
1310 1311 1312 1313 1314 1315
	}
	rcu_read_unlock();
}

static void tipc_node_reset_links(struct tipc_node *n)
{
1316
	int i;
1317

J
Jon Maloy 已提交
1318
	pr_warn("Resetting all links to %x\n", n->addr);
1319

T
Tuong Lien 已提交
1320
	trace_tipc_node_reset_links(n, true, " ");
1321
	for (i = 0; i < MAX_BEARERS; i++) {
1322
		tipc_node_link_down(n, i, false);
1323 1324 1325
	}
}

1326 1327 1328
/* tipc_node_fsm_evt - node finite state machine
 * Determines when contact is allowed with peer node
 */
1329
static void tipc_node_fsm_evt(struct tipc_node *n, int evt)
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
{
	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 已提交
1345 1346 1347 1348
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
1349
		default:
J
Jon Paul Maloy 已提交
1350
			goto illegal_evt;
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
		}
		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 已提交
1361 1362 1363 1364 1365 1366
		case NODE_SYNCH_BEGIN_EVT:
			state = NODE_SYNCHING;
			break;
		case NODE_FAILOVER_BEGIN_EVT:
			state = NODE_FAILINGOVER;
			break;
1367 1368
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
J
Jon Paul Maloy 已提交
1369 1370
		case NODE_SYNCH_END_EVT:
		case NODE_FAILOVER_END_EVT:
1371 1372
			break;
		default:
J
Jon Paul Maloy 已提交
1373
			goto illegal_evt;
1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
		}
		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 已提交
1385 1386 1387 1388
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
1389
		default:
J
Jon Paul Maloy 已提交
1390
			goto illegal_evt;
1391 1392 1393 1394 1395 1396 1397 1398
		}
		break;
	case SELF_UP_PEER_COMING:
		switch (evt) {
		case PEER_ESTABL_CONTACT_EVT:
			state = SELF_UP_PEER_UP;
			break;
		case SELF_LOST_CONTACT_EVT:
J
Jon Paul Maloy 已提交
1399
			state = SELF_DOWN_PEER_DOWN;
1400 1401 1402
			break;
		case SELF_ESTABL_CONTACT_EVT:
		case PEER_LOST_CONTACT_EVT:
J
Jon Paul Maloy 已提交
1403 1404
		case NODE_SYNCH_END_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
1405 1406
			break;
		case NODE_SYNCH_BEGIN_EVT:
J
Jon Paul Maloy 已提交
1407
		case NODE_FAILOVER_END_EVT:
1408
		default:
J
Jon Paul Maloy 已提交
1409
			goto illegal_evt;
1410 1411 1412 1413 1414 1415 1416 1417
		}
		break;
	case SELF_COMING_PEER_UP:
		switch (evt) {
		case SELF_ESTABL_CONTACT_EVT:
			state = SELF_UP_PEER_UP;
			break;
		case PEER_LOST_CONTACT_EVT:
J
Jon Paul Maloy 已提交
1418
			state = SELF_DOWN_PEER_DOWN;
1419 1420 1421 1422
			break;
		case SELF_LOST_CONTACT_EVT:
		case PEER_ESTABL_CONTACT_EVT:
			break;
J
Jon Paul Maloy 已提交
1423 1424 1425 1426
		case NODE_SYNCH_END_EVT:
		case NODE_SYNCH_BEGIN_EVT:
		case NODE_FAILOVER_BEGIN_EVT:
		case NODE_FAILOVER_END_EVT:
1427
		default:
J
Jon Paul Maloy 已提交
1428
			goto illegal_evt;
1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
		}
		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 已提交
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
		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:
1465
		default:
J
Jon Paul Maloy 已提交
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489
			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;
1490 1491 1492 1493 1494 1495
		}
		break;
	default:
		pr_err("Unknown node fsm state %x\n", state);
		break;
	}
T
Tuong Lien 已提交
1496
	trace_tipc_node_fsm(n->peer_id, n->state, state, evt);
1497
	n->state = state;
J
Jon Paul Maloy 已提交
1498 1499 1500 1501
	return;

illegal_evt:
	pr_err("Illegal node fsm evt %x in state %x\n", evt, state);
T
Tuong Lien 已提交
1502
	trace_tipc_node_fsm(n->peer_id, n->state, state, evt);
1503 1504
}

1505
static void node_lost_contact(struct tipc_node *n,
1506
			      struct sk_buff_head *inputq)
P
Per Liden 已提交
1507
{
1508
	struct tipc_sock_conn *conn, *safe;
1509
	struct tipc_link *l;
1510
	struct list_head *conns = &n->conn_sks;
1511 1512
	struct sk_buff *skb;
	uint i;
P
Per Liden 已提交
1513

J
Jon Maloy 已提交
1514
	pr_debug("Lost contact with %x\n", n->addr);
1515
	n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER);
T
Tuong Lien 已提交
1516
	trace_tipc_node_lost_contact(n, true, " ");
1517

1518
	/* Clean up broadcast state */
1519
	tipc_bcast_remove_peer(n->net, n->bc_entry.link);
1520
	skb_queue_purge(&n->bc_entry.namedq);
P
Per Liden 已提交
1521

1522
	/* Abort any ongoing link failover */
P
Per Liden 已提交
1523
	for (i = 0; i < MAX_BEARERS; i++) {
1524
		l = n->links[i].link;
1525 1526
		if (l)
			tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT);
P
Per Liden 已提交
1527
	}
1528

1529
	/* Notify publications from this node */
1530
	n->action_flags |= TIPC_NOTIFY_NODE_DOWN;
1531 1532
	n->peer_net = NULL;
	n->peer_hash_mix = 0;
1533 1534 1535
	/* Notify sockets connected to node */
	list_for_each_entry_safe(conn, safe, conns, list) {
		skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
1536
				      SHORT_H_SIZE, 0, tipc_own_addr(n->net),
1537 1538
				      conn->peer_node, conn->port,
				      conn->peer_port, TIPC_ERR_NO_NODE);
1539
		if (likely(skb))
1540
			skb_queue_tail(inputq, skb);
1541 1542 1543
		list_del(&conn->list);
		kfree(conn);
	}
P
Per Liden 已提交
1544 1545
}

E
Erik Hugne 已提交
1546 1547 1548
/**
 * tipc_node_get_linkname - get the name of a link
 *
R
Randy Dunlap 已提交
1549
 * @net: the applicable net namespace
E
Erik Hugne 已提交
1550
 * @bearer_id: id of the bearer
A
Andrew Lunn 已提交
1551
 * @addr: peer node address
E
Erik Hugne 已提交
1552
 * @linkname: link name output buffer
R
Randy Dunlap 已提交
1553
 * @len: size of @linkname output buffer
E
Erik Hugne 已提交
1554
 *
1555
 * Return: 0 on success
E
Erik Hugne 已提交
1556
 */
1557 1558
int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
			   char *linkname, size_t len)
E
Erik Hugne 已提交
1559 1560
{
	struct tipc_link *link;
1561
	int err = -EINVAL;
1562
	struct tipc_node *node = tipc_node_find(net, addr);
E
Erik Hugne 已提交
1563

1564 1565 1566 1567 1568 1569
	if (!node)
		return err;

	if (bearer_id >= MAX_BEARERS)
		goto exit;

J
Jon Paul Maloy 已提交
1570
	tipc_node_read_lock(node);
1571
	link = node->links[bearer_id].link;
E
Erik Hugne 已提交
1572
	if (link) {
1573
		strncpy(linkname, tipc_link_name(link), len);
1574
		err = 0;
E
Erik Hugne 已提交
1575
	}
J
Jon Paul Maloy 已提交
1576
	tipc_node_read_unlock(node);
1577
exit:
1578 1579
	tipc_node_put(node);
	return err;
E
Erik Hugne 已提交
1580
}
1581

1582
/* Caller should hold node lock for the passed node */
1583
static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
1584 1585 1586 1587
{
	void *hdr;
	struct nlattr *attrs;

1588
	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
1589 1590 1591 1592
			  NLM_F_MULTI, TIPC_NL_NODE_GET);
	if (!hdr)
		return -EMSGSIZE;

1593
	attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_NODE);
1594 1595 1596 1597 1598
	if (!attrs)
		goto msg_full;

	if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
		goto attr_msg_full;
1599
	if (node_is_up(node))
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
		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;
}

1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
static void tipc_lxc_xmit(struct net *peer_net, struct sk_buff_head *list)
{
	struct tipc_msg *hdr = buf_msg(skb_peek(list));
	struct sk_buff_head inputq;

	switch (msg_user(hdr)) {
	case TIPC_LOW_IMPORTANCE:
	case TIPC_MEDIUM_IMPORTANCE:
	case TIPC_HIGH_IMPORTANCE:
	case TIPC_CRITICAL_IMPORTANCE:
1626 1627
		if (msg_connected(hdr) || msg_named(hdr) ||
		    msg_direct(hdr)) {
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
			tipc_loopback_trace(peer_net, list);
			spin_lock_init(&list->lock);
			tipc_sk_rcv(peer_net, list);
			return;
		}
		if (msg_mcast(hdr)) {
			tipc_loopback_trace(peer_net, list);
			skb_queue_head_init(&inputq);
			tipc_sk_mcast_rcv(peer_net, list, &inputq);
			__skb_queue_purge(list);
			skb_queue_purge(&inputq);
			return;
		}
		return;
	case MSG_FRAGMENTER:
		if (tipc_msg_assemble(list)) {
			tipc_loopback_trace(peer_net, list);
			skb_queue_head_init(&inputq);
			tipc_sk_mcast_rcv(peer_net, list, &inputq);
			__skb_queue_purge(list);
			skb_queue_purge(&inputq);
		}
		return;
	case GROUP_PROTOCOL:
	case CONN_MANAGER:
		tipc_loopback_trace(peer_net, list);
		spin_lock_init(&list->lock);
		tipc_sk_rcv(peer_net, list);
		return;
	case LINK_PROTOCOL:
	case NAME_DISTRIBUTOR:
	case TUNNEL_PROTOCOL:
	case BCAST_PROTOCOL:
		return;
	default:
		return;
T
Tom Rix 已提交
1664
	}
1665 1666
}

1667 1668 1669 1670 1671 1672
/**
 * 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
1673
 * Consumes the buffer chain.
1674
 * Return: 0 if success, otherwise: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE,-ENOBUF
1675 1676 1677 1678
 */
int tipc_node_xmit(struct net *net, struct sk_buff_head *list,
		   u32 dnode, int selector)
{
J
Jon Paul Maloy 已提交
1679
	struct tipc_link_entry *le = NULL;
1680 1681
	struct tipc_node *n;
	struct sk_buff_head xmitq;
1682
	bool node_up = false;
1683 1684 1685 1686
	int bearer_id;
	int rc;

	if (in_own_node(net, dnode)) {
1687
		tipc_loopback_trace(net, list);
1688
		spin_lock_init(&list->lock);
1689 1690 1691
		tipc_sk_rcv(net, list);
		return 0;
	}
1692 1693

	n = tipc_node_find(net, dnode);
1694
	if (unlikely(!n)) {
1695
		__skb_queue_purge(list);
1696 1697 1698 1699
		return -EHOSTUNREACH;
	}

	tipc_node_read_lock(n);
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710
	node_up = node_is_up(n);
	if (node_up && n->peer_net && check_net(n->peer_net)) {
		/* xmit inner linux container */
		tipc_lxc_xmit(n->peer_net, list);
		if (likely(skb_queue_empty(list))) {
			tipc_node_read_unlock(n);
			tipc_node_put(n);
			return 0;
		}
	}

1711 1712
	bearer_id = n->active_links[selector & 1];
	if (unlikely(bearer_id == INVALID_BEARER_ID)) {
J
Jon Paul Maloy 已提交
1713
		tipc_node_read_unlock(n);
1714
		tipc_node_put(n);
1715
		__skb_queue_purge(list);
1716
		return -EHOSTUNREACH;
1717
	}
J
Jon Paul Maloy 已提交
1718

1719 1720 1721 1722 1723 1724 1725
	__skb_queue_head_init(&xmitq);
	le = &n->links[bearer_id];
	spin_lock_bh(&le->lock);
	rc = tipc_link_xmit(le->link, list, &xmitq);
	spin_unlock_bh(&le->lock);
	tipc_node_read_unlock(n);

1726
	if (unlikely(rc == -ENOBUFS))
1727
		tipc_node_link_down(n, bearer_id, false);
1728
	else
1729
		tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n);
1730 1731 1732

	tipc_node_put(n);

1733
	return rc;
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
}

/* 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.
 */
int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode,
		       u32 selector)
{
	struct sk_buff_head head;

1747
	__skb_queue_head_init(&head);
1748
	__skb_queue_tail(&head, skb);
1749
	tipc_node_xmit(net, &head, dnode, selector);
1750 1751 1752
	return 0;
}

1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
/* tipc_node_distr_xmit(): send single buffer msgs to individual destinations
 * Note: this is only for SYSTEM_IMPORTANCE messages, which cannot be rejected
 */
int tipc_node_distr_xmit(struct net *net, struct sk_buff_head *xmitq)
{
	struct sk_buff *skb;
	u32 selector, dnode;

	while ((skb = __skb_dequeue(xmitq))) {
		selector = msg_origport(buf_msg(skb));
		dnode = msg_destnode(buf_msg(skb));
		tipc_node_xmit_skb(net, skb, dnode, selector);
	}
	return 0;
}

1769
void tipc_node_broadcast(struct net *net, struct sk_buff *skb, int rc_dests)
1770
{
1771
	struct sk_buff_head xmitq;
1772 1773
	struct sk_buff *txskb;
	struct tipc_node *n;
1774
	u16 dummy;
1775 1776
	u32 dst;

1777 1778 1779 1780 1781 1782 1783 1784 1785
	/* Use broadcast if all nodes support it */
	if (!rc_dests && tipc_bcast_get_mode(net) != BCLINK_MODE_RCAST) {
		__skb_queue_head_init(&xmitq);
		__skb_queue_tail(&xmitq, skb);
		tipc_bcast_xmit(net, &xmitq, &dummy);
		return;
	}

	/* Otherwise use legacy replicast method */
1786 1787 1788 1789 1790
	rcu_read_lock();
	list_for_each_entry_rcu(n, tipc_nodes(net), list) {
		dst = n->addr;
		if (in_own_node(net, dst))
			continue;
1791
		if (!node_is_up(n))
1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802
			continue;
		txskb = pskb_copy(skb, GFP_ATOMIC);
		if (!txskb)
			break;
		msg_set_destnode(buf_msg(txskb), dst);
		tipc_node_xmit_skb(net, txskb, dst, 0);
	}
	rcu_read_unlock();
	kfree_skb(skb);
}

1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
static void tipc_node_mcast_rcv(struct tipc_node *n)
{
	struct tipc_bclink_entry *be = &n->bc_entry;

	/* 'arrvq' is under inputq2's lock protection */
	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(n->net, &be->arrvq, &be->inputq2);
}

1816 1817 1818 1819 1820 1821
static void tipc_node_bc_sync_rcv(struct tipc_node *n, struct tipc_msg *hdr,
				  int bearer_id, struct sk_buff_head *xmitq)
{
	struct tipc_link *ucl;
	int rc;

1822
	rc = tipc_bcast_sync_rcv(n->net, n->bc_entry.link, hdr, xmitq);
1823 1824

	if (rc & TIPC_LINK_DOWN_EVT) {
1825
		tipc_node_reset_links(n);
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843
		return;
	}

	if (!(rc & TIPC_LINK_SND_STATE))
		return;

	/* If probe message, a STATE response will be sent anyway */
	if (msg_probe(hdr))
		return;

	/* Produce a STATE message carrying broadcast NACK */
	tipc_node_read_lock(n);
	ucl = n->links[bearer_id].link;
	if (ucl)
		tipc_link_build_state_msg(ucl, xmitq);
	tipc_node_read_unlock(n);
}

1844 1845 1846 1847 1848 1849 1850 1851
/**
 * 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.
 */
1852
static void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id)
1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
{
	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 ACKs are sent on a unicast link */
1880
	if (rc & TIPC_LINK_SND_STATE) {
J
Jon Paul Maloy 已提交
1881
		tipc_node_read_lock(n);
1882
		tipc_link_build_state_msg(le->link, &xmitq);
J
Jon Paul Maloy 已提交
1883
		tipc_node_read_unlock(n);
1884 1885 1886
	}

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

1889 1890
	if (!skb_queue_empty(&be->inputq1))
		tipc_node_mcast_rcv(n);
1891

1892 1893
	/* Handle NAME_DISTRIBUTOR messages sent from 1.7 nodes */
	if (!skb_queue_empty(&n->bc_entry.namedq))
1894 1895 1896
		tipc_named_rcv(net, &n->bc_entry.namedq,
			       &n->bc_entry.named_rcv_nxt,
			       &n->bc_entry.named_open);
1897

1898 1899 1900
	/* If reassembly or retransmission failure => reset all links to peer */
	if (rc & TIPC_LINK_DOWN_EVT)
		tipc_node_reset_links(n);
1901

1902 1903 1904
	tipc_node_put(n);
}

1905 1906
/**
 * tipc_node_check_state - check and if necessary update node state
R
Randy Dunlap 已提交
1907
 * @n: target tipc_node
1908 1909
 * @skb: TIPC packet
 * @bearer_id: identity of bearer delivering the packet
R
Randy Dunlap 已提交
1910
 * @xmitq: queue for messages to be xmited on
1911
 * Return: true if state and msg are ok, otherwise false
1912
 */
1913
static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb,
1914
				  int bearer_id, struct sk_buff_head *xmitq)
1915 1916
{
	struct tipc_msg *hdr = buf_msg(skb);
1917 1918
	int usr = msg_user(hdr);
	int mtyp = msg_type(hdr);
1919
	u16 oseqno = msg_seqno(hdr);
1920
	u16 exp_pkts = msg_msgcnt(hdr);
1921
	u16 rcv_nxt, syncpt, dlv_nxt, inputq_len;
1922
	int state = n->state;
1923
	struct tipc_link *l, *tnl, *pl = NULL;
1924
	struct tipc_media_addr *maddr;
1925
	int pb_id;
1926

T
Tuong Lien 已提交
1927 1928 1929 1930
	if (trace_tipc_node_check_state_enabled()) {
		trace_tipc_skb_dump(skb, false, "skb for node state check");
		trace_tipc_node_check_state(n, true, " ");
	}
1931 1932 1933
	l = n->links[bearer_id].link;
	if (!l)
		return false;
1934
	rcv_nxt = tipc_link_rcv_nxt(l);
1935 1936


1937 1938
	if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL)))
		return true;
1939

1940
	/* Find parallel link, if any */
1941 1942 1943
	for (pb_id = 0; pb_id < MAX_BEARERS; pb_id++) {
		if ((pb_id != bearer_id) && n->links[pb_id].link) {
			pl = n->links[pb_id].link;
1944 1945 1946
			break;
		}
	}
1947

T
Tuong Lien 已提交
1948 1949 1950
	if (!tipc_link_validate_msg(l, hdr)) {
		trace_tipc_skb_dump(skb, false, "PROTO invalid (2)!");
		trace_tipc_link_dump(l, TIPC_DUMP_NONE, "PROTO invalid (2)!");
1951
		return false;
T
Tuong Lien 已提交
1952
	}
1953

J
Jon Paul Maloy 已提交
1954
	/* Check and update node accesibility if applicable */
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966
	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);
1967
		return true;
1968 1969
	}

J
Jon Paul Maloy 已提交
1970 1971 1972
	if (state == SELF_LEAVING_PEER_DOWN)
		return false;

1973
	/* Ignore duplicate packets */
1974
	if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt))
1975 1976 1977 1978 1979
		return true;

	/* Initiate or update failover mode if applicable */
	if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) {
		syncpt = oseqno + exp_pkts - 1;
1980
		if (pl && !tipc_link_is_reset(pl)) {
1981
			__tipc_node_link_down(n, &pb_id, xmitq, &maddr);
T
Tuong Lien 已提交
1982 1983
			trace_tipc_node_link_down(n, true,
						  "node link down <- failover!");
1984 1985
			tipc_skb_queue_splice_tail_init(tipc_link_inputq(pl),
							tipc_link_inputq(l));
1986
		}
1987

L
LUU Duc Canh 已提交
1988
		/* If parallel link was already down, and this happened before
1989 1990 1991 1992
		 * the tunnel link came up, node failover was never started.
		 * Ensure that a FAILOVER_MSG is sent to get peer out of
		 * NODE_FAILINGOVER state, also this node must accept
		 * TUNNEL_MSGs from peer.
L
LUU Duc Canh 已提交
1993
		 */
1994 1995 1996
		if (n->state != NODE_FAILINGOVER)
			tipc_node_link_failover(n, pl, l, xmitq);

1997 1998 1999 2000 2001 2002
		/* 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 */
2003
	if ((n->state == NODE_FAILINGOVER) && tipc_link_is_up(l)) {
2004 2005
		if (!more(rcv_nxt, n->sync_point))
			return true;
2006 2007
		tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT);
		if (pl)
2008
			tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT);
2009 2010 2011
		return true;
	}

2012 2013 2014 2015
	/* No synching needed if only one link */
	if (!pl || !tipc_link_is_up(pl))
		return true;

2016 2017
	/* Initiate synch mode if applicable */
	if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) {
2018 2019 2020 2021
		if (n->capabilities & TIPC_TUNNEL_ENHANCED)
			syncpt = msg_syncpt(hdr);
		else
			syncpt = msg_seqno(msg_inner_hdr(hdr)) + exp_pkts - 1;
2022
		if (!tipc_link_is_up(l))
2023
			__tipc_node_link_up(n, bearer_id, xmitq);
2024 2025
		if (n->state == SELF_UP_PEER_UP) {
			n->sync_point = syncpt;
2026
			tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT);
2027 2028
			tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT);
		}
2029
	}
2030 2031

	/* Open tunnel link when parallel link reaches synch point */
2032
	if (n->state == NODE_SYNCHING) {
2033 2034 2035 2036 2037 2038
		if (tipc_link_is_synching(l)) {
			tnl = l;
		} else {
			tnl = pl;
			pl = l;
		}
2039 2040
		inputq_len = skb_queue_len(tipc_link_inputq(pl));
		dlv_nxt = tipc_link_rcv_nxt(pl) - inputq_len;
2041
		if (more(dlv_nxt, n->sync_point)) {
2042
			tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
2043 2044 2045
			tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
			return true;
		}
2046 2047
		if (l == pl)
			return true;
2048 2049 2050 2051 2052 2053 2054
		if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG))
			return true;
		if (usr == LINK_PROTOCOL)
			return true;
		return false;
	}
	return true;
2055 2056
}

2057 2058 2059 2060
/**
 * tipc_rcv - process TIPC packets/messages arriving from off-node
 * @net: the applicable net namespace
 * @skb: TIPC packet
A
Andrew Lunn 已提交
2061
 * @b: pointer to bearer message arrived on
2062 2063 2064 2065 2066 2067 2068
 *
 * 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;
2069
	struct tipc_link_entry *le;
2070
	struct tipc_msg *hdr;
2071
	struct tipc_node *n;
2072
	int bearer_id = b->identity;
2073
	u32 self = tipc_own_addr(net);
2074 2075
	int usr, rc = 0;
	u16 bc_ack;
2076 2077
#ifdef CONFIG_TIPC_CRYPTO
	struct tipc_ehdr *ehdr;
2078

2079 2080 2081
	/* Check if message must be decrypted first */
	if (TIPC_SKB_CB(skb)->decrypted || !tipc_ehdr_validate(skb))
		goto rcv;
2082

2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
	ehdr = (struct tipc_ehdr *)skb->data;
	if (likely(ehdr->user != LINK_CONFIG)) {
		n = tipc_node_find(net, ntohl(ehdr->addr));
		if (unlikely(!n))
			goto discard;
	} else {
		n = tipc_node_find_by_id(net, ehdr->id);
	}
	tipc_crypto_rcv(net, (n) ? n->crypto_rx : NULL, &skb, b);
	if (!skb)
		return;

rcv:
#endif
2097
	/* Ensure message is well-formed before touching the header */
2098
	if (unlikely(!tipc_msg_validate(&skb)))
2099
		goto discard;
2100
	__skb_queue_head_init(&xmitq);
2101 2102 2103
	hdr = buf_msg(skb);
	usr = msg_user(hdr);
	bc_ack = msg_bcast_ack(hdr);
2104

2105
	/* Handle arrival of discovery or broadcast packet */
2106
	if (unlikely(msg_non_seq(hdr))) {
2107 2108
		if (unlikely(usr == LINK_CONFIG))
			return tipc_disc_rcv(net, skb, b);
2109
		else
2110
			return tipc_node_bc_rcv(net, skb, bearer_id);
2111 2112
	}

2113 2114 2115 2116
	/* Discard unicast link messages destined for another node */
	if (unlikely(!msg_short(hdr) && (msg_destnode(hdr) != self)))
		goto discard;

2117 2118 2119 2120
	/* Locate neighboring node that sent packet */
	n = tipc_node_find(net, msg_prevnode(hdr));
	if (unlikely(!n))
		goto discard;
2121
	le = &n->links[bearer_id];
2122

2123
	/* Ensure broadcast reception is in synch with peer's send state */
2124 2125 2126 2127 2128 2129
	if (unlikely(usr == LINK_PROTOCOL)) {
		if (unlikely(skb_linearize(skb))) {
			tipc_node_put(n);
			goto discard;
		}
		hdr = buf_msg(skb);
2130
		tipc_node_bc_sync_rcv(n, hdr, bearer_id, &xmitq);
2131
	} else if (unlikely(tipc_link_acked(n->bc_entry.link) != bc_ack)) {
2132
		tipc_bcast_ack_rcv(net, n->bc_entry.link, hdr);
2133
	}
2134

J
Jon Paul Maloy 已提交
2135 2136 2137
	/* Receive packet directly if conditions permit */
	tipc_node_read_lock(n);
	if (likely((n->state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) {
J
Jon Paul Maloy 已提交
2138
		spin_lock_bh(&le->lock);
J
Jon Paul Maloy 已提交
2139 2140 2141 2142
		if (le->link) {
			rc = tipc_link_rcv(le->link, skb, &xmitq);
			skb = NULL;
		}
J
Jon Paul Maloy 已提交
2143
		spin_unlock_bh(&le->lock);
2144
	}
J
Jon Paul Maloy 已提交
2145 2146 2147 2148
	tipc_node_read_unlock(n);

	/* Check/update node state before receiving */
	if (unlikely(skb)) {
2149
		if (unlikely(skb_linearize(skb)))
2150
			goto out_node_put;
J
Jon Paul Maloy 已提交
2151 2152 2153 2154 2155 2156 2157 2158 2159
		tipc_node_write_lock(n);
		if (tipc_node_check_state(n, skb, bearer_id, &xmitq)) {
			if (le->link) {
				rc = tipc_link_rcv(le->link, skb, &xmitq);
				skb = NULL;
			}
		}
		tipc_node_write_unlock(n);
	}
2160 2161

	if (unlikely(rc & TIPC_LINK_UP_EVT))
2162 2163
		tipc_node_link_up(n, bearer_id, &xmitq);

2164
	if (unlikely(rc & TIPC_LINK_DOWN_EVT))
2165
		tipc_node_link_down(n, bearer_id, false);
2166

2167
	if (unlikely(!skb_queue_empty(&n->bc_entry.namedq)))
2168 2169 2170
		tipc_named_rcv(net, &n->bc_entry.namedq,
			       &n->bc_entry.named_rcv_nxt,
			       &n->bc_entry.named_open);
2171

2172 2173 2174
	if (unlikely(!skb_queue_empty(&n->bc_entry.inputq1)))
		tipc_node_mcast_rcv(n);

2175 2176 2177 2178
	if (!skb_queue_empty(&le->inputq))
		tipc_sk_rcv(net, &le->inputq);

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

2181
out_node_put:
2182 2183 2184 2185 2186
	tipc_node_put(n);
discard:
	kfree_skb(skb);
}

2187 2188
void tipc_node_apply_property(struct net *net, struct tipc_bearer *b,
			      int prop)
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
{
	struct tipc_net *tn = tipc_net(net);
	int bearer_id = b->identity;
	struct sk_buff_head xmitq;
	struct tipc_link_entry *e;
	struct tipc_node *n;

	__skb_queue_head_init(&xmitq);

	rcu_read_lock();

	list_for_each_entry_rcu(n, &tn->node_list, list) {
		tipc_node_write_lock(n);
		e = &n->links[bearer_id];
2203 2204 2205 2206 2207 2208 2209
		if (e->link) {
			if (prop == TIPC_NLA_PROP_TOL)
				tipc_link_set_tolerance(e->link, b->tolerance,
							&xmitq);
			else if (prop == TIPC_NLA_PROP_MTU)
				tipc_link_set_mtu(e->link, b->mtu);
		}
2210
		tipc_node_write_unlock(n);
2211
		tipc_bearer_xmit(net, bearer_id, &xmitq, &e->maddr, NULL);
2212 2213 2214 2215 2216
	}

	rcu_read_unlock();
}

2217 2218 2219 2220 2221
int tipc_nl_peer_rm(struct sk_buff *skb, struct genl_info *info)
{
	struct net *net = sock_net(skb->sk);
	struct tipc_net *tn = net_generic(net, tipc_net_id);
	struct nlattr *attrs[TIPC_NLA_NET_MAX + 1];
2222
	struct tipc_node *peer, *temp_node;
2223 2224 2225 2226 2227 2228 2229
	u32 addr;
	int err;

	/* We identify the peer by its net */
	if (!info->attrs[TIPC_NLA_NET])
		return -EINVAL;

2230 2231 2232
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_NET_MAX,
					  info->attrs[TIPC_NLA_NET],
					  tipc_nl_net_policy, info->extack);
2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258
	if (err)
		return err;

	if (!attrs[TIPC_NLA_NET_ADDR])
		return -EINVAL;

	addr = nla_get_u32(attrs[TIPC_NLA_NET_ADDR]);

	if (in_own_node(net, addr))
		return -ENOTSUPP;

	spin_lock_bh(&tn->node_list_lock);
	peer = tipc_node_find(net, addr);
	if (!peer) {
		spin_unlock_bh(&tn->node_list_lock);
		return -ENXIO;
	}

	tipc_node_write_lock(peer);
	if (peer->state != SELF_DOWN_PEER_DOWN &&
	    peer->state != SELF_DOWN_PEER_LEAVING) {
		tipc_node_write_unlock(peer);
		err = -EBUSY;
		goto err_out;
	}

2259
	tipc_node_clear_links(peer);
2260 2261 2262
	tipc_node_write_unlock(peer);
	tipc_node_delete(peer);

2263 2264 2265 2266 2267
	/* Calculate cluster capabilities */
	tn->capabilities = TIPC_NODE_CAPABILITIES;
	list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
		tn->capabilities &= temp_node->capabilities;
	}
2268
	tipc_bcast_toggle_rcast(net, (tn->capabilities & TIPC_BCAST_RCAST));
2269 2270 2271 2272 2273 2274 2275 2276
	err = 0;
err_out:
	tipc_node_put(peer);
	spin_unlock_bh(&tn->node_list_lock);

	return err;
}

2277 2278 2279
int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	int err;
2280 2281
	struct net *net = sock_net(skb->sk);
	struct tipc_net *tn = net_generic(net, tipc_net_id);
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
	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();
2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
	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);
2310 2311
	}

2312
	list_for_each_entry_rcu(node, &tn->node_list, list) {
2313 2314
		if (node->preliminary)
			continue;
2315 2316 2317 2318 2319 2320 2321
		if (last_addr) {
			if (node->addr == last_addr)
				last_addr = 0;
			else
				continue;
		}

J
Jon Paul Maloy 已提交
2322
		tipc_node_read_lock(node);
2323 2324 2325
		err = __tipc_nl_add_node(&msg, node);
		if (err) {
			last_addr = node->addr;
J
Jon Paul Maloy 已提交
2326
			tipc_node_read_unlock(node);
2327 2328 2329
			goto out;
		}

J
Jon Paul Maloy 已提交
2330
		tipc_node_read_unlock(node);
2331 2332 2333 2334 2335 2336 2337 2338 2339
	}
	done = 1;
out:
	cb->args[0] = done;
	cb->args[1] = last_addr;
	rcu_read_unlock();

	return skb->len;
}
2340

2341
/* tipc_node_find_by_name - locate owner node of link by link's name
2342 2343 2344 2345 2346 2347
 * @net: the applicable net namespace
 * @name: pointer to link name string
 * @bearer_id: pointer to index in 'node->links' array where the link was found.
 *
 * Returns pointer to node owning the link, or 0 if no matching link is found.
 */
2348 2349 2350
static struct tipc_node *tipc_node_find_by_name(struct net *net,
						const char *link_name,
						unsigned int *bearer_id)
2351 2352
{
	struct tipc_net *tn = net_generic(net, tipc_net_id);
2353 2354
	struct tipc_link *l;
	struct tipc_node *n;
2355 2356 2357 2358 2359
	struct tipc_node *found_node = NULL;
	int i;

	*bearer_id = 0;
	rcu_read_lock();
2360 2361
	list_for_each_entry_rcu(n, &tn->node_list, list) {
		tipc_node_read_lock(n);
2362
		for (i = 0; i < MAX_BEARERS; i++) {
2363 2364
			l = n->links[i].link;
			if (l && !strcmp(tipc_link_name(l), link_name)) {
2365
				*bearer_id = i;
2366
				found_node = n;
2367 2368 2369
				break;
			}
		}
2370
		tipc_node_read_unlock(n);
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386
		if (found_node)
			break;
	}
	rcu_read_unlock();

	return found_node;
}

int tipc_nl_node_set_link(struct sk_buff *skb, struct genl_info *info)
{
	int err;
	int res = 0;
	int bearer_id;
	char *name;
	struct tipc_link *link;
	struct tipc_node *node;
2387
	struct sk_buff_head xmitq;
2388 2389 2390
	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
	struct net *net = sock_net(skb->sk);

2391 2392
	__skb_queue_head_init(&xmitq);

2393 2394 2395
	if (!info->attrs[TIPC_NLA_LINK])
		return -EINVAL;

2396 2397 2398
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
					  info->attrs[TIPC_NLA_LINK],
					  tipc_nl_link_policy, info->extack);
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409
	if (err)
		return err;

	if (!attrs[TIPC_NLA_LINK_NAME])
		return -EINVAL;

	name = nla_data(attrs[TIPC_NLA_LINK_NAME]);

	if (strcmp(name, tipc_bclink_name) == 0)
		return tipc_nl_bc_link_set(net, attrs);

2410
	node = tipc_node_find_by_name(net, name, &bearer_id);
2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
	if (!node)
		return -EINVAL;

	tipc_node_read_lock(node);

	link = node->links[bearer_id].link;
	if (!link) {
		res = -EINVAL;
		goto out;
	}

	if (attrs[TIPC_NLA_LINK_PROP]) {
		struct nlattr *props[TIPC_NLA_PROP_MAX + 1];

2425
		err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP], props);
2426 2427 2428 2429 2430 2431 2432 2433 2434
		if (err) {
			res = err;
			goto out;
		}

		if (props[TIPC_NLA_PROP_TOL]) {
			u32 tol;

			tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
2435
			tipc_link_set_tolerance(link, tol, &xmitq);
2436 2437 2438 2439 2440
		}
		if (props[TIPC_NLA_PROP_PRIO]) {
			u32 prio;

			prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
2441
			tipc_link_set_prio(link, prio, &xmitq);
2442 2443
		}
		if (props[TIPC_NLA_PROP_WIN]) {
2444
			u32 max_win;
2445

2446 2447 2448 2449
			max_win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
			tipc_link_set_queue_limits(link,
						   tipc_link_min_win(link),
						   max_win);
2450 2451 2452 2453 2454
		}
	}

out:
	tipc_node_read_unlock(node);
2455 2456
	tipc_bearer_xmit(net, bearer_id, &xmitq, &node->links[bearer_id].maddr,
			 NULL);
2457 2458 2459 2460 2461 2462
	return res;
}

int tipc_nl_node_get_link(struct sk_buff *skb, struct genl_info *info)
{
	struct net *net = genl_info_net(info);
2463
	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
2464 2465 2466 2467 2468 2469 2470
	struct tipc_nl_msg msg;
	char *name;
	int err;

	msg.portid = info->snd_portid;
	msg.seq = info->snd_seq;

2471
	if (!info->attrs[TIPC_NLA_LINK])
2472
		return -EINVAL;
2473

2474 2475 2476
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
					  info->attrs[TIPC_NLA_LINK],
					  tipc_nl_link_policy, info->extack);
2477 2478 2479 2480 2481 2482 2483
	if (err)
		return err;

	if (!attrs[TIPC_NLA_LINK_NAME])
		return -EINVAL;

	name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
2484 2485 2486 2487 2488 2489

	msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg.skb)
		return -ENOMEM;

	if (strcmp(name, tipc_bclink_name) == 0) {
2490
		err = tipc_nl_add_bc_link(net, &msg, tipc_net(net)->bcl);
2491 2492
		if (err)
			goto err_free;
2493 2494 2495 2496 2497
	} else {
		int bearer_id;
		struct tipc_node *node;
		struct tipc_link *link;

2498
		node = tipc_node_find_by_name(net, name, &bearer_id);
2499 2500 2501 2502
		if (!node) {
			err = -EINVAL;
			goto err_free;
		}
2503 2504 2505 2506 2507

		tipc_node_read_lock(node);
		link = node->links[bearer_id].link;
		if (!link) {
			tipc_node_read_unlock(node);
2508 2509
			err = -EINVAL;
			goto err_free;
2510 2511 2512 2513
		}

		err = __tipc_nl_add_link(net, &msg, link, 0);
		tipc_node_read_unlock(node);
2514 2515
		if (err)
			goto err_free;
2516 2517 2518
	}

	return genlmsg_reply(msg.skb, info);
2519 2520 2521 2522

err_free:
	nlmsg_free(msg.skb);
	return err;
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533
}

int tipc_nl_node_reset_link_stats(struct sk_buff *skb, struct genl_info *info)
{
	int err;
	char *link_name;
	unsigned int bearer_id;
	struct tipc_link *link;
	struct tipc_node *node;
	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
	struct net *net = sock_net(skb->sk);
2534
	struct tipc_net *tn = tipc_net(net);
2535 2536 2537 2538 2539
	struct tipc_link_entry *le;

	if (!info->attrs[TIPC_NLA_LINK])
		return -EINVAL;

2540 2541 2542
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
					  info->attrs[TIPC_NLA_LINK],
					  tipc_nl_link_policy, info->extack);
2543 2544 2545 2546 2547 2548 2549 2550
	if (err)
		return err;

	if (!attrs[TIPC_NLA_LINK_NAME])
		return -EINVAL;

	link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]);

2551 2552 2553
	err = -EINVAL;
	if (!strcmp(link_name, tipc_bclink_name)) {
		err = tipc_bclink_reset_stats(net, tipc_bc_sndlink(net));
2554 2555 2556
		if (err)
			return err;
		return 0;
2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
	} else if (strstr(link_name, tipc_bclink_name)) {
		rcu_read_lock();
		list_for_each_entry_rcu(node, &tn->node_list, list) {
			tipc_node_read_lock(node);
			link = node->bc_entry.link;
			if (link && !strcmp(link_name, tipc_link_name(link))) {
				err = tipc_bclink_reset_stats(net, link);
				tipc_node_read_unlock(node);
				break;
			}
			tipc_node_read_unlock(node);
		}
		rcu_read_unlock();
		return err;
2571 2572
	}

2573
	node = tipc_node_find_by_name(net, link_name, &bearer_id);
2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585
	if (!node)
		return -EINVAL;

	le = &node->links[bearer_id];
	tipc_node_read_lock(node);
	spin_lock_bh(&le->lock);
	link = node->links[bearer_id].link;
	if (!link) {
		spin_unlock_bh(&le->lock);
		tipc_node_read_unlock(node);
		return -EINVAL;
	}
2586
	tipc_link_reset_stats(link);
2587 2588 2589 2590 2591 2592 2593
	spin_unlock_bh(&le->lock);
	tipc_node_read_unlock(node);
	return 0;
}

/* Caller should hold node lock  */
static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg,
2594 2595
				    struct tipc_node *node, u32 *prev_link,
				    bool bc_link)
2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610
{
	u32 i;
	int err;

	for (i = *prev_link; i < MAX_BEARERS; i++) {
		*prev_link = i;

		if (!node->links[i].link)
			continue;

		err = __tipc_nl_add_link(net, msg,
					 node->links[i].link, NLM_F_MULTI);
		if (err)
			return err;
	}
2611 2612 2613 2614 2615 2616 2617 2618

	if (bc_link) {
		*prev_link = i;
		err = tipc_nl_add_bc_link(net, msg, node->bc_entry.link);
		if (err)
			return err;
	}

2619 2620 2621 2622 2623
	*prev_link = 0;

	return 0;
}

2624
int tipc_nl_node_dump_link(struct sk_buff *skb, struct netlink_callback *cb)
2625 2626
{
	struct net *net = sock_net(skb->sk);
2627 2628
	struct nlattr **attrs = genl_dumpit_info(cb)->attrs;
	struct nlattr *link[TIPC_NLA_LINK_MAX + 1];
2629 2630 2631 2632 2633 2634
	struct tipc_net *tn = net_generic(net, tipc_net_id);
	struct tipc_node *node;
	struct tipc_nl_msg msg;
	u32 prev_node = cb->args[0];
	u32 prev_link = cb->args[1];
	int done = cb->args[2];
2635
	bool bc_link = cb->args[3];
2636 2637 2638 2639 2640
	int err;

	if (done)
		return 0;

2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
	if (!prev_node) {
		/* Check if broadcast-receiver links dumping is needed */
		if (attrs && attrs[TIPC_NLA_LINK]) {
			err = nla_parse_nested_deprecated(link,
							  TIPC_NLA_LINK_MAX,
							  attrs[TIPC_NLA_LINK],
							  tipc_nl_link_policy,
							  NULL);
			if (unlikely(err))
				return err;
			if (unlikely(!link[TIPC_NLA_LINK_BROADCAST]))
				return -EINVAL;
			bc_link = true;
		}
	}

2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679
	msg.skb = skb;
	msg.portid = NETLINK_CB(cb->skb).portid;
	msg.seq = cb->nlh->nlmsg_seq;

	rcu_read_lock();
	if (prev_node) {
		node = tipc_node_find(net, prev_node);
		if (!node) {
			/* 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 last NLMSG_DONE message
			 * having the NLM_F_DUMP_INTR flag set.
			 */
			cb->prev_seq = 1;
			goto out;
		}
		tipc_node_put(node);

		list_for_each_entry_continue_rcu(node, &tn->node_list,
						 list) {
			tipc_node_read_lock(node);
			err = __tipc_nl_add_node_links(net, &msg, node,
2680
						       &prev_link, bc_link);
2681 2682 2683 2684 2685 2686 2687
			tipc_node_read_unlock(node);
			if (err)
				goto out;

			prev_node = node->addr;
		}
	} else {
2688
		err = tipc_nl_add_bc_link(net, &msg, tn->bcl);
2689 2690 2691 2692 2693 2694
		if (err)
			goto out;

		list_for_each_entry_rcu(node, &tn->node_list, list) {
			tipc_node_read_lock(node);
			err = __tipc_nl_add_node_links(net, &msg, node,
2695
						       &prev_link, bc_link);
2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
			tipc_node_read_unlock(node);
			if (err)
				goto out;

			prev_node = node->addr;
		}
	}
	done = 1;
out:
	rcu_read_unlock();

	cb->args[0] = prev_node;
	cb->args[1] = prev_link;
	cb->args[2] = done;
2710
	cb->args[3] = bc_link;
2711 2712 2713

	return skb->len;
}
2714 2715 2716 2717 2718 2719 2720 2721 2722 2723

int tipc_nl_node_set_monitor(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr *attrs[TIPC_NLA_MON_MAX + 1];
	struct net *net = sock_net(skb->sk);
	int err;

	if (!info->attrs[TIPC_NLA_MON])
		return -EINVAL;

2724 2725 2726 2727
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MON_MAX,
					  info->attrs[TIPC_NLA_MON],
					  tipc_nl_monitor_policy,
					  info->extack);
2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741
	if (err)
		return err;

	if (attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]) {
		u32 val;

		val = nla_get_u32(attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]);
		err = tipc_nl_monitor_set_threshold(net, val);
		if (err)
			return err;
	}

	return 0;
}
2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753

static int __tipc_nl_add_monitor_prop(struct net *net, struct tipc_nl_msg *msg)
{
	struct nlattr *attrs;
	void *hdr;
	u32 val;

	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
			  0, TIPC_NL_MON_GET);
	if (!hdr)
		return -EMSGSIZE;

2754
	attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON);
2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782
	if (!attrs)
		goto msg_full;

	val = tipc_nl_monitor_get_threshold(net);

	if (nla_put_u32(msg->skb, TIPC_NLA_MON_ACTIVATION_THRESHOLD, val))
		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;
}

int tipc_nl_node_get_monitor(struct sk_buff *skb, struct genl_info *info)
{
	struct net *net = sock_net(skb->sk);
	struct tipc_nl_msg msg;
	int err;

	msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
P
Pan Bian 已提交
2783 2784
	if (!msg.skb)
		return -ENOMEM;
2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
	msg.portid = info->snd_portid;
	msg.seq = info->snd_seq;

	err = __tipc_nl_add_monitor_prop(net, &msg);
	if (err) {
		nlmsg_free(msg.skb);
		return err;
	}

	return genlmsg_reply(msg.skb, info);
}
2796 2797 2798 2799 2800 2801

int tipc_nl_node_dump_monitor(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	u32 prev_bearer = cb->args[0];
	struct tipc_nl_msg msg;
2802
	int bearer_id;
2803 2804 2805 2806 2807 2808 2809 2810 2811 2812
	int err;

	if (prev_bearer == MAX_BEARERS)
		return 0;

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

	rtnl_lock();
2813
	for (bearer_id = prev_bearer; bearer_id < MAX_BEARERS; bearer_id++) {
2814
		err = __tipc_nl_add_monitor(net, &msg, bearer_id);
2815
		if (err)
2816
			break;
2817 2818
	}
	rtnl_unlock();
2819
	cb->args[0] = bearer_id;
2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834

	return skb->len;
}

int tipc_nl_node_dump_monitor_peer(struct sk_buff *skb,
				   struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	u32 prev_node = cb->args[1];
	u32 bearer_id = cb->args[2];
	int done = cb->args[0];
	struct tipc_nl_msg msg;
	int err;

	if (!prev_node) {
2835
		struct nlattr **attrs = genl_dumpit_info(cb)->attrs;
2836 2837 2838 2839 2840
		struct nlattr *mon[TIPC_NLA_MON_MAX + 1];

		if (!attrs[TIPC_NLA_MON])
			return -EINVAL;

2841 2842 2843 2844
		err = nla_parse_nested_deprecated(mon, TIPC_NLA_MON_MAX,
						  attrs[TIPC_NLA_MON],
						  tipc_nl_monitor_policy,
						  NULL);
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875
		if (err)
			return err;

		if (!mon[TIPC_NLA_MON_REF])
			return -EINVAL;

		bearer_id = nla_get_u32(mon[TIPC_NLA_MON_REF]);

		if (bearer_id >= MAX_BEARERS)
			return -EINVAL;
	}

	if (done)
		return 0;

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

	rtnl_lock();
	err = tipc_nl_add_monitor_peer(net, &msg, bearer_id, &prev_node);
	if (!err)
		done = 1;

	rtnl_unlock();
	cb->args[0] = done;
	cb->args[1] = prev_node;
	cb->args[2] = bearer_id;

	return skb->len;
}
T
Tuong Lien 已提交
2876

2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906
#ifdef CONFIG_TIPC_CRYPTO
static int tipc_nl_retrieve_key(struct nlattr **attrs,
				struct tipc_aead_key **key)
{
	struct nlattr *attr = attrs[TIPC_NLA_NODE_KEY];

	if (!attr)
		return -ENODATA;

	*key = (struct tipc_aead_key *)nla_data(attr);
	if (nla_len(attr) < tipc_aead_key_size(*key))
		return -EINVAL;

	return 0;
}

static int tipc_nl_retrieve_nodeid(struct nlattr **attrs, u8 **node_id)
{
	struct nlattr *attr = attrs[TIPC_NLA_NODE_ID];

	if (!attr)
		return -ENODATA;

	if (nla_len(attr) < TIPC_NODEID_LEN)
		return -EINVAL;

	*node_id = (u8 *)nla_data(attr);
	return 0;
}

2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917
static int tipc_nl_retrieve_rekeying(struct nlattr **attrs, u32 *intv)
{
	struct nlattr *attr = attrs[TIPC_NLA_NODE_REKEYING];

	if (!attr)
		return -ENODATA;

	*intv = nla_get_u32(attr);
	return 0;
}

C
Chen Wandun 已提交
2918
static int __tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info)
2919 2920 2921
{
	struct nlattr *attrs[TIPC_NLA_NODE_MAX + 1];
	struct net *net = sock_net(skb->sk);
2922
	struct tipc_crypto *tx = tipc_net(net)->crypto_tx, *c = tx;
2923 2924
	struct tipc_node *n = NULL;
	struct tipc_aead_key *ukey;
2925
	bool rekeying = true, master_key = false;
2926
	u8 *id, *own_id, mode;
2927
	u32 intv = 0;
2928 2929 2930 2931 2932 2933 2934 2935 2936
	int rc = 0;

	if (!info->attrs[TIPC_NLA_NODE])
		return -EINVAL;

	rc = nla_parse_nested(attrs, TIPC_NLA_NODE_MAX,
			      info->attrs[TIPC_NLA_NODE],
			      tipc_nl_node_policy, info->extack);
	if (rc)
2937
		return rc;
2938 2939 2940

	own_id = tipc_own_id(net);
	if (!own_id) {
2941 2942
		GENL_SET_ERR_MSG(info, "not found own node identity (set id?)");
		return -EPERM;
2943 2944
	}

2945 2946 2947 2948
	rc = tipc_nl_retrieve_rekeying(attrs, &intv);
	if (rc == -ENODATA)
		rekeying = false;

2949
	rc = tipc_nl_retrieve_key(attrs, &ukey);
2950 2951 2952
	if (rc == -ENODATA && rekeying)
		goto rekeying;
	else if (rc)
2953
		return rc;
2954

2955
	rc = tipc_aead_key_validate(ukey, info);
2956
	if (rc)
2957
		return rc;
2958 2959 2960 2961

	rc = tipc_nl_retrieve_nodeid(attrs, &id);
	switch (rc) {
	case -ENODATA:
2962
		mode = CLUSTER_KEY;
2963
		master_key = !!(attrs[TIPC_NLA_NODE_KEY_MASTER]);
2964 2965
		break;
	case 0:
2966 2967
		mode = PER_NODE_KEY;
		if (memcmp(id, own_id, NODE_ID_LEN)) {
2968 2969
			n = tipc_node_find_by_id(net, id) ?:
				tipc_node_create(net, 0, id, 0xffffu, 0, true);
2970 2971
			if (unlikely(!n))
				return -ENOMEM;
2972 2973 2974 2975
			c = n->crypto_rx;
		}
		break;
	default:
2976
		return rc;
2977 2978
	}

2979
	/* Initiate the TX/RX key */
2980
	rc = tipc_crypto_key_init(c, ukey, mode, master_key);
2981 2982 2983
	if (n)
		tipc_node_put(n);

2984
	if (unlikely(rc < 0)) {
2985 2986
		GENL_SET_ERR_MSG(info, "unable to initiate or attach new key");
		return rc;
2987 2988 2989 2990
	} else if (c == tx) {
		/* Distribute TX key but not master one */
		if (!master_key && tipc_crypto_key_distr(tx, rc, NULL))
			GENL_SET_ERR_MSG(info, "failed to replicate new key");
2991 2992 2993
rekeying:
		/* Schedule TX rekeying if needed */
		tipc_crypto_rekeying_sched(tx, rekeying, intv);
2994 2995 2996
	}

	return 0;
2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
}

int tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info)
{
	int err;

	rtnl_lock();
	err = __tipc_nl_node_set_key(skb, info);
	rtnl_unlock();

	return err;
}

C
Chen Wandun 已提交
3010 3011
static int __tipc_nl_node_flush_key(struct sk_buff *skb,
				    struct genl_info *info)
3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037
{
	struct net *net = sock_net(skb->sk);
	struct tipc_net *tn = tipc_net(net);
	struct tipc_node *n;

	tipc_crypto_key_flush(tn->crypto_tx);
	rcu_read_lock();
	list_for_each_entry_rcu(n, &tn->node_list, list)
		tipc_crypto_key_flush(n->crypto_rx);
	rcu_read_unlock();

	return 0;
}

int tipc_nl_node_flush_key(struct sk_buff *skb, struct genl_info *info)
{
	int err;

	rtnl_lock();
	err = __tipc_nl_node_flush_key(skb, info);
	rtnl_unlock();

	return err;
}
#endif

T
Tuong Lien 已提交
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093
/**
 * tipc_node_dump - dump TIPC node data
 * @n: tipc node to be dumped
 * @more: dump more?
 *        - false: dump only tipc node data
 *        - true: dump node link data as well
 * @buf: returned buffer of dump data in format
 */
int tipc_node_dump(struct tipc_node *n, bool more, char *buf)
{
	int i = 0;
	size_t sz = (more) ? NODE_LMAX : NODE_LMIN;

	if (!n) {
		i += scnprintf(buf, sz, "node data: (null)\n");
		return i;
	}

	i += scnprintf(buf, sz, "node data: %x", n->addr);
	i += scnprintf(buf + i, sz - i, " %x", n->state);
	i += scnprintf(buf + i, sz - i, " %d", n->active_links[0]);
	i += scnprintf(buf + i, sz - i, " %d", n->active_links[1]);
	i += scnprintf(buf + i, sz - i, " %x", n->action_flags);
	i += scnprintf(buf + i, sz - i, " %u", n->failover_sent);
	i += scnprintf(buf + i, sz - i, " %u", n->sync_point);
	i += scnprintf(buf + i, sz - i, " %d", n->link_cnt);
	i += scnprintf(buf + i, sz - i, " %u", n->working_links);
	i += scnprintf(buf + i, sz - i, " %x", n->capabilities);
	i += scnprintf(buf + i, sz - i, " %lu\n", n->keepalive_intv);

	if (!more)
		return i;

	i += scnprintf(buf + i, sz - i, "link_entry[0]:\n");
	i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[0].mtu);
	i += scnprintf(buf + i, sz - i, " media: ");
	i += tipc_media_addr_printf(buf + i, sz - i, &n->links[0].maddr);
	i += scnprintf(buf + i, sz - i, "\n");
	i += tipc_link_dump(n->links[0].link, TIPC_DUMP_NONE, buf + i);
	i += scnprintf(buf + i, sz - i, " inputq: ");
	i += tipc_list_dump(&n->links[0].inputq, false, buf + i);

	i += scnprintf(buf + i, sz - i, "link_entry[1]:\n");
	i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[1].mtu);
	i += scnprintf(buf + i, sz - i, " media: ");
	i += tipc_media_addr_printf(buf + i, sz - i, &n->links[1].maddr);
	i += scnprintf(buf + i, sz - i, "\n");
	i += tipc_link_dump(n->links[1].link, TIPC_DUMP_NONE, buf + i);
	i += scnprintf(buf + i, sz - i, " inputq: ");
	i += tipc_list_dump(&n->links[1].inputq, false, buf + i);

	i += scnprintf(buf + i, sz - i, "bclink:\n ");
	i += tipc_link_dump(n->bc_entry.link, TIPC_DUMP_NONE, buf + i);

	return i;
}
3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123

void tipc_node_pre_cleanup_net(struct net *exit_net)
{
	struct tipc_node *n;
	struct tipc_net *tn;
	struct net *tmp;

	rcu_read_lock();
	for_each_net_rcu(tmp) {
		if (tmp == exit_net)
			continue;
		tn = tipc_net(tmp);
		if (!tn)
			continue;
		spin_lock_bh(&tn->node_list_lock);
		list_for_each_entry_rcu(n, &tn->node_list, list) {
			if (!n->peer_net)
				continue;
			if (n->peer_net != exit_net)
				continue;
			tipc_node_write_lock(n);
			n->peer_net = NULL;
			n->peer_hash_mix = 0;
			tipc_node_write_unlock_fast(n);
			break;
		}
		spin_unlock_bh(&tn->node_list_lock);
	}
	rcu_read_unlock();
}