whiterose

linux unikernel
Log | Files | Refs | README | LICENSE | git clone https://git.ne02ptzero.me/git/whiterose

node.c (64188B)


      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
      6  * All rights reserved.
      7  *
      8  * Redistribution and use in source and binary forms, with or without
      9  * modification, are permitted provided that the following conditions are met:
     10  *
     11  * 1. Redistributions of source code must retain the above copyright
     12  *    notice, this list of conditions and the following disclaimer.
     13  * 2. Redistributions in binary form must reproduce the above copyright
     14  *    notice, this list of conditions and the following disclaimer in the
     15  *    documentation and/or other materials provided with the distribution.
     16  * 3. Neither the names of the copyright holders nor the names of its
     17  *    contributors may be used to endorse or promote products derived from
     18  *    this software without specific prior written permission.
     19  *
     20  * Alternatively, this software may be distributed under the terms of the
     21  * GNU General Public License ("GPL") version 2 as published by the Free
     22  * Software Foundation.
     23  *
     24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
     28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     34  * POSSIBILITY OF SUCH DAMAGE.
     35  */
     36 
     37 #include "core.h"
     38 #include "link.h"
     39 #include "node.h"
     40 #include "name_distr.h"
     41 #include "socket.h"
     42 #include "bcast.h"
     43 #include "monitor.h"
     44 #include "discover.h"
     45 #include "netlink.h"
     46 #include "trace.h"
     47 
     48 #define INVALID_NODE_SIG	0x10000
     49 #define NODE_CLEANUP_AFTER	300000
     50 
     51 /* Flags used to take different actions according to flag type
     52  * TIPC_NOTIFY_NODE_DOWN: notify node is down
     53  * TIPC_NOTIFY_NODE_UP: notify node is up
     54  * TIPC_DISTRIBUTE_NAME: publish or withdraw link state name type
     55  */
     56 enum {
     57 	TIPC_NOTIFY_NODE_DOWN		= (1 << 3),
     58 	TIPC_NOTIFY_NODE_UP		= (1 << 4),
     59 	TIPC_NOTIFY_LINK_UP		= (1 << 6),
     60 	TIPC_NOTIFY_LINK_DOWN		= (1 << 7)
     61 };
     62 
     63 struct tipc_link_entry {
     64 	struct tipc_link *link;
     65 	spinlock_t lock; /* per link */
     66 	u32 mtu;
     67 	struct sk_buff_head inputq;
     68 	struct tipc_media_addr maddr;
     69 };
     70 
     71 struct tipc_bclink_entry {
     72 	struct tipc_link *link;
     73 	struct sk_buff_head inputq1;
     74 	struct sk_buff_head arrvq;
     75 	struct sk_buff_head inputq2;
     76 	struct sk_buff_head namedq;
     77 };
     78 
     79 /**
     80  * struct tipc_node - TIPC node structure
     81  * @addr: network address of node
     82  * @ref: reference counter to node object
     83  * @lock: rwlock governing access to structure
     84  * @net: the applicable net namespace
     85  * @hash: links to adjacent nodes in unsorted hash chain
     86  * @inputq: pointer to input queue containing messages for msg event
     87  * @namedq: pointer to name table input queue with name table messages
     88  * @active_links: bearer ids of active links, used as index into links[] array
     89  * @links: array containing references to all links to node
     90  * @action_flags: bit mask of different types of node actions
     91  * @state: connectivity state vs peer node
     92  * @sync_point: sequence number where synch/failover is finished
     93  * @list: links to adjacent nodes in sorted list of cluster's nodes
     94  * @working_links: number of working links to node (both active and standby)
     95  * @link_cnt: number of links to node
     96  * @capabilities: bitmap, indicating peer node's functional capabilities
     97  * @signature: node instance identifier
     98  * @link_id: local and remote bearer ids of changing link, if any
     99  * @publ_list: list of publications
    100  * @rcu: rcu struct for tipc_node
    101  * @delete_at: indicates the time for deleting a down node
    102  */
    103 struct tipc_node {
    104 	u32 addr;
    105 	struct kref kref;
    106 	rwlock_t lock;
    107 	struct net *net;
    108 	struct hlist_node hash;
    109 	int active_links[2];
    110 	struct tipc_link_entry links[MAX_BEARERS];
    111 	struct tipc_bclink_entry bc_entry;
    112 	int action_flags;
    113 	struct list_head list;
    114 	int state;
    115 	bool failover_sent;
    116 	u16 sync_point;
    117 	int link_cnt;
    118 	u16 working_links;
    119 	u16 capabilities;
    120 	u32 signature;
    121 	u32 link_id;
    122 	u8 peer_id[16];
    123 	struct list_head publ_list;
    124 	struct list_head conn_sks;
    125 	unsigned long keepalive_intv;
    126 	struct timer_list timer;
    127 	struct rcu_head rcu;
    128 	unsigned long delete_at;
    129 };
    130 
    131 /* Node FSM states and events:
    132  */
    133 enum {
    134 	SELF_DOWN_PEER_DOWN    = 0xdd,
    135 	SELF_UP_PEER_UP        = 0xaa,
    136 	SELF_DOWN_PEER_LEAVING = 0xd1,
    137 	SELF_UP_PEER_COMING    = 0xac,
    138 	SELF_COMING_PEER_UP    = 0xca,
    139 	SELF_LEAVING_PEER_DOWN = 0x1d,
    140 	NODE_FAILINGOVER       = 0xf0,
    141 	NODE_SYNCHING          = 0xcc
    142 };
    143 
    144 enum {
    145 	SELF_ESTABL_CONTACT_EVT = 0xece,
    146 	SELF_LOST_CONTACT_EVT   = 0x1ce,
    147 	PEER_ESTABL_CONTACT_EVT = 0x9ece,
    148 	PEER_LOST_CONTACT_EVT   = 0x91ce,
    149 	NODE_FAILOVER_BEGIN_EVT = 0xfbe,
    150 	NODE_FAILOVER_END_EVT   = 0xfee,
    151 	NODE_SYNCH_BEGIN_EVT    = 0xcbe,
    152 	NODE_SYNCH_END_EVT      = 0xcee
    153 };
    154 
    155 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,
    156 				  struct sk_buff_head *xmitq,
    157 				  struct tipc_media_addr **maddr);
    158 static void tipc_node_link_down(struct tipc_node *n, int bearer_id,
    159 				bool delete);
    160 static void node_lost_contact(struct tipc_node *n, struct sk_buff_head *inputq);
    161 static void tipc_node_delete(struct tipc_node *node);
    162 static void tipc_node_timeout(struct timer_list *t);
    163 static void tipc_node_fsm_evt(struct tipc_node *n, int evt);
    164 static struct tipc_node *tipc_node_find(struct net *net, u32 addr);
    165 static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id);
    166 static void tipc_node_put(struct tipc_node *node);
    167 static bool node_is_up(struct tipc_node *n);
    168 static void tipc_node_delete_from_list(struct tipc_node *node);
    169 
    170 struct tipc_sock_conn {
    171 	u32 port;
    172 	u32 peer_port;
    173 	u32 peer_node;
    174 	struct list_head list;
    175 };
    176 
    177 static struct tipc_link *node_active_link(struct tipc_node *n, int sel)
    178 {
    179 	int bearer_id = n->active_links[sel & 1];
    180 
    181 	if (unlikely(bearer_id == INVALID_BEARER_ID))
    182 		return NULL;
    183 
    184 	return n->links[bearer_id].link;
    185 }
    186 
    187 int tipc_node_get_mtu(struct net *net, u32 addr, u32 sel)
    188 {
    189 	struct tipc_node *n;
    190 	int bearer_id;
    191 	unsigned int mtu = MAX_MSG_SIZE;
    192 
    193 	n = tipc_node_find(net, addr);
    194 	if (unlikely(!n))
    195 		return mtu;
    196 
    197 	bearer_id = n->active_links[sel & 1];
    198 	if (likely(bearer_id != INVALID_BEARER_ID))
    199 		mtu = n->links[bearer_id].mtu;
    200 	tipc_node_put(n);
    201 	return mtu;
    202 }
    203 
    204 bool tipc_node_get_id(struct net *net, u32 addr, u8 *id)
    205 {
    206 	u8 *own_id = tipc_own_id(net);
    207 	struct tipc_node *n;
    208 
    209 	if (!own_id)
    210 		return true;
    211 
    212 	if (addr == tipc_own_addr(net)) {
    213 		memcpy(id, own_id, TIPC_NODEID_LEN);
    214 		return true;
    215 	}
    216 	n = tipc_node_find(net, addr);
    217 	if (!n)
    218 		return false;
    219 
    220 	memcpy(id, &n->peer_id, TIPC_NODEID_LEN);
    221 	tipc_node_put(n);
    222 	return true;
    223 }
    224 
    225 u16 tipc_node_get_capabilities(struct net *net, u32 addr)
    226 {
    227 	struct tipc_node *n;
    228 	u16 caps;
    229 
    230 	n = tipc_node_find(net, addr);
    231 	if (unlikely(!n))
    232 		return TIPC_NODE_CAPABILITIES;
    233 	caps = n->capabilities;
    234 	tipc_node_put(n);
    235 	return caps;
    236 }
    237 
    238 static void tipc_node_kref_release(struct kref *kref)
    239 {
    240 	struct tipc_node *n = container_of(kref, struct tipc_node, kref);
    241 
    242 	kfree(n->bc_entry.link);
    243 	kfree_rcu(n, rcu);
    244 }
    245 
    246 static void tipc_node_put(struct tipc_node *node)
    247 {
    248 	kref_put(&node->kref, tipc_node_kref_release);
    249 }
    250 
    251 static void tipc_node_get(struct tipc_node *node)
    252 {
    253 	kref_get(&node->kref);
    254 }
    255 
    256 /*
    257  * tipc_node_find - locate specified node object, if it exists
    258  */
    259 static struct tipc_node *tipc_node_find(struct net *net, u32 addr)
    260 {
    261 	struct tipc_net *tn = tipc_net(net);
    262 	struct tipc_node *node;
    263 	unsigned int thash = tipc_hashfn(addr);
    264 
    265 	rcu_read_lock();
    266 	hlist_for_each_entry_rcu(node, &tn->node_htable[thash], hash) {
    267 		if (node->addr != addr)
    268 			continue;
    269 		if (!kref_get_unless_zero(&node->kref))
    270 			node = NULL;
    271 		break;
    272 	}
    273 	rcu_read_unlock();
    274 	return node;
    275 }
    276 
    277 /* tipc_node_find_by_id - locate specified node object by its 128-bit id
    278  * Note: this function is called only when a discovery request failed
    279  * to find the node by its 32-bit id, and is not time critical
    280  */
    281 static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id)
    282 {
    283 	struct tipc_net *tn = tipc_net(net);
    284 	struct tipc_node *n;
    285 	bool found = false;
    286 
    287 	rcu_read_lock();
    288 	list_for_each_entry_rcu(n, &tn->node_list, list) {
    289 		read_lock_bh(&n->lock);
    290 		if (!memcmp(id, n->peer_id, 16) &&
    291 		    kref_get_unless_zero(&n->kref))
    292 			found = true;
    293 		read_unlock_bh(&n->lock);
    294 		if (found)
    295 			break;
    296 	}
    297 	rcu_read_unlock();
    298 	return found ? n : NULL;
    299 }
    300 
    301 static void tipc_node_read_lock(struct tipc_node *n)
    302 {
    303 	read_lock_bh(&n->lock);
    304 }
    305 
    306 static void tipc_node_read_unlock(struct tipc_node *n)
    307 {
    308 	read_unlock_bh(&n->lock);
    309 }
    310 
    311 static void tipc_node_write_lock(struct tipc_node *n)
    312 {
    313 	write_lock_bh(&n->lock);
    314 }
    315 
    316 static void tipc_node_write_unlock_fast(struct tipc_node *n)
    317 {
    318 	write_unlock_bh(&n->lock);
    319 }
    320 
    321 static void tipc_node_write_unlock(struct tipc_node *n)
    322 {
    323 	struct net *net = n->net;
    324 	u32 addr = 0;
    325 	u32 flags = n->action_flags;
    326 	u32 link_id = 0;
    327 	u32 bearer_id;
    328 	struct list_head *publ_list;
    329 
    330 	if (likely(!flags)) {
    331 		write_unlock_bh(&n->lock);
    332 		return;
    333 	}
    334 
    335 	addr = n->addr;
    336 	link_id = n->link_id;
    337 	bearer_id = link_id & 0xffff;
    338 	publ_list = &n->publ_list;
    339 
    340 	n->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |
    341 			     TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP);
    342 
    343 	write_unlock_bh(&n->lock);
    344 
    345 	if (flags & TIPC_NOTIFY_NODE_DOWN)
    346 		tipc_publ_notify(net, publ_list, addr);
    347 
    348 	if (flags & TIPC_NOTIFY_NODE_UP)
    349 		tipc_named_node_up(net, addr);
    350 
    351 	if (flags & TIPC_NOTIFY_LINK_UP) {
    352 		tipc_mon_peer_up(net, addr, bearer_id);
    353 		tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
    354 				     TIPC_NODE_SCOPE, link_id, link_id);
    355 	}
    356 	if (flags & TIPC_NOTIFY_LINK_DOWN) {
    357 		tipc_mon_peer_down(net, addr, bearer_id);
    358 		tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
    359 				      addr, link_id);
    360 	}
    361 }
    362 
    363 static struct tipc_node *tipc_node_create(struct net *net, u32 addr,
    364 					  u8 *peer_id, u16 capabilities)
    365 {
    366 	struct tipc_net *tn = net_generic(net, tipc_net_id);
    367 	struct tipc_node *n, *temp_node;
    368 	struct tipc_link *l;
    369 	int bearer_id;
    370 	int i;
    371 
    372 	spin_lock_bh(&tn->node_list_lock);
    373 	n = tipc_node_find(net, addr);
    374 	if (n) {
    375 		if (n->capabilities == capabilities)
    376 			goto exit;
    377 		/* Same node may come back with new capabilities */
    378 		write_lock_bh(&n->lock);
    379 		n->capabilities = capabilities;
    380 		for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {
    381 			l = n->links[bearer_id].link;
    382 			if (l)
    383 				tipc_link_update_caps(l, capabilities);
    384 		}
    385 		write_unlock_bh(&n->lock);
    386 		goto exit;
    387 	}
    388 	n = kzalloc(sizeof(*n), GFP_ATOMIC);
    389 	if (!n) {
    390 		pr_warn("Node creation failed, no memory\n");
    391 		goto exit;
    392 	}
    393 	n->addr = addr;
    394 	memcpy(&n->peer_id, peer_id, 16);
    395 	n->net = net;
    396 	n->capabilities = capabilities;
    397 	kref_init(&n->kref);
    398 	rwlock_init(&n->lock);
    399 	INIT_HLIST_NODE(&n->hash);
    400 	INIT_LIST_HEAD(&n->list);
    401 	INIT_LIST_HEAD(&n->publ_list);
    402 	INIT_LIST_HEAD(&n->conn_sks);
    403 	skb_queue_head_init(&n->bc_entry.namedq);
    404 	skb_queue_head_init(&n->bc_entry.inputq1);
    405 	__skb_queue_head_init(&n->bc_entry.arrvq);
    406 	skb_queue_head_init(&n->bc_entry.inputq2);
    407 	for (i = 0; i < MAX_BEARERS; i++)
    408 		spin_lock_init(&n->links[i].lock);
    409 	n->state = SELF_DOWN_PEER_LEAVING;
    410 	n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER);
    411 	n->signature = INVALID_NODE_SIG;
    412 	n->active_links[0] = INVALID_BEARER_ID;
    413 	n->active_links[1] = INVALID_BEARER_ID;
    414 	if (!tipc_link_bc_create(net, tipc_own_addr(net),
    415 				 addr, U16_MAX,
    416 				 tipc_link_window(tipc_bc_sndlink(net)),
    417 				 n->capabilities,
    418 				 &n->bc_entry.inputq1,
    419 				 &n->bc_entry.namedq,
    420 				 tipc_bc_sndlink(net),
    421 				 &n->bc_entry.link)) {
    422 		pr_warn("Broadcast rcv link creation failed, no memory\n");
    423 		kfree(n);
    424 		n = NULL;
    425 		goto exit;
    426 	}
    427 	tipc_node_get(n);
    428 	timer_setup(&n->timer, tipc_node_timeout, 0);
    429 	n->keepalive_intv = U32_MAX;
    430 	hlist_add_head_rcu(&n->hash, &tn->node_htable[tipc_hashfn(addr)]);
    431 	list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
    432 		if (n->addr < temp_node->addr)
    433 			break;
    434 	}
    435 	list_add_tail_rcu(&n->list, &temp_node->list);
    436 	trace_tipc_node_create(n, true, " ");
    437 exit:
    438 	spin_unlock_bh(&tn->node_list_lock);
    439 	return n;
    440 }
    441 
    442 static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l)
    443 {
    444 	unsigned long tol = tipc_link_tolerance(l);
    445 	unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;
    446 
    447 	/* Link with lowest tolerance determines timer interval */
    448 	if (intv < n->keepalive_intv)
    449 		n->keepalive_intv = intv;
    450 
    451 	/* Ensure link's abort limit corresponds to current tolerance */
    452 	tipc_link_set_abort_limit(l, tol / n->keepalive_intv);
    453 }
    454 
    455 static void tipc_node_delete_from_list(struct tipc_node *node)
    456 {
    457 	list_del_rcu(&node->list);
    458 	hlist_del_rcu(&node->hash);
    459 	tipc_node_put(node);
    460 }
    461 
    462 static void tipc_node_delete(struct tipc_node *node)
    463 {
    464 	trace_tipc_node_delete(node, true, " ");
    465 	tipc_node_delete_from_list(node);
    466 
    467 	del_timer_sync(&node->timer);
    468 	tipc_node_put(node);
    469 }
    470 
    471 void tipc_node_stop(struct net *net)
    472 {
    473 	struct tipc_net *tn = tipc_net(net);
    474 	struct tipc_node *node, *t_node;
    475 
    476 	spin_lock_bh(&tn->node_list_lock);
    477 	list_for_each_entry_safe(node, t_node, &tn->node_list, list)
    478 		tipc_node_delete(node);
    479 	spin_unlock_bh(&tn->node_list_lock);
    480 }
    481 
    482 void tipc_node_subscribe(struct net *net, struct list_head *subscr, u32 addr)
    483 {
    484 	struct tipc_node *n;
    485 
    486 	if (in_own_node(net, addr))
    487 		return;
    488 
    489 	n = tipc_node_find(net, addr);
    490 	if (!n) {
    491 		pr_warn("Node subscribe rejected, unknown node 0x%x\n", addr);
    492 		return;
    493 	}
    494 	tipc_node_write_lock(n);
    495 	list_add_tail(subscr, &n->publ_list);
    496 	tipc_node_write_unlock_fast(n);
    497 	tipc_node_put(n);
    498 }
    499 
    500 void tipc_node_unsubscribe(struct net *net, struct list_head *subscr, u32 addr)
    501 {
    502 	struct tipc_node *n;
    503 
    504 	if (in_own_node(net, addr))
    505 		return;
    506 
    507 	n = tipc_node_find(net, addr);
    508 	if (!n) {
    509 		pr_warn("Node unsubscribe rejected, unknown node 0x%x\n", addr);
    510 		return;
    511 	}
    512 	tipc_node_write_lock(n);
    513 	list_del_init(subscr);
    514 	tipc_node_write_unlock_fast(n);
    515 	tipc_node_put(n);
    516 }
    517 
    518 int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
    519 {
    520 	struct tipc_node *node;
    521 	struct tipc_sock_conn *conn;
    522 	int err = 0;
    523 
    524 	if (in_own_node(net, dnode))
    525 		return 0;
    526 
    527 	node = tipc_node_find(net, dnode);
    528 	if (!node) {
    529 		pr_warn("Connecting sock to node 0x%x failed\n", dnode);
    530 		return -EHOSTUNREACH;
    531 	}
    532 	conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
    533 	if (!conn) {
    534 		err = -EHOSTUNREACH;
    535 		goto exit;
    536 	}
    537 	conn->peer_node = dnode;
    538 	conn->port = port;
    539 	conn->peer_port = peer_port;
    540 
    541 	tipc_node_write_lock(node);
    542 	list_add_tail(&conn->list, &node->conn_sks);
    543 	tipc_node_write_unlock(node);
    544 exit:
    545 	tipc_node_put(node);
    546 	return err;
    547 }
    548 
    549 void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
    550 {
    551 	struct tipc_node *node;
    552 	struct tipc_sock_conn *conn, *safe;
    553 
    554 	if (in_own_node(net, dnode))
    555 		return;
    556 
    557 	node = tipc_node_find(net, dnode);
    558 	if (!node)
    559 		return;
    560 
    561 	tipc_node_write_lock(node);
    562 	list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
    563 		if (port != conn->port)
    564 			continue;
    565 		list_del(&conn->list);
    566 		kfree(conn);
    567 	}
    568 	tipc_node_write_unlock(node);
    569 	tipc_node_put(node);
    570 }
    571 
    572 static void  tipc_node_clear_links(struct tipc_node *node)
    573 {
    574 	int i;
    575 
    576 	for (i = 0; i < MAX_BEARERS; i++) {
    577 		struct tipc_link_entry *le = &node->links[i];
    578 
    579 		if (le->link) {
    580 			kfree(le->link);
    581 			le->link = NULL;
    582 			node->link_cnt--;
    583 		}
    584 	}
    585 }
    586 
    587 /* tipc_node_cleanup - delete nodes that does not
    588  * have active links for NODE_CLEANUP_AFTER time
    589  */
    590 static bool tipc_node_cleanup(struct tipc_node *peer)
    591 {
    592 	struct tipc_net *tn = tipc_net(peer->net);
    593 	bool deleted = false;
    594 
    595 	/* If lock held by tipc_node_stop() the node will be deleted anyway */
    596 	if (!spin_trylock_bh(&tn->node_list_lock))
    597 		return false;
    598 
    599 	tipc_node_write_lock(peer);
    600 
    601 	if (!node_is_up(peer) && time_after(jiffies, peer->delete_at)) {
    602 		tipc_node_clear_links(peer);
    603 		tipc_node_delete_from_list(peer);
    604 		deleted = true;
    605 	}
    606 	tipc_node_write_unlock(peer);
    607 	spin_unlock_bh(&tn->node_list_lock);
    608 	return deleted;
    609 }
    610 
    611 /* tipc_node_timeout - handle expiration of node timer
    612  */
    613 static void tipc_node_timeout(struct timer_list *t)
    614 {
    615 	struct tipc_node *n = from_timer(n, t, timer);
    616 	struct tipc_link_entry *le;
    617 	struct sk_buff_head xmitq;
    618 	int remains = n->link_cnt;
    619 	int bearer_id;
    620 	int rc = 0;
    621 
    622 	trace_tipc_node_timeout(n, false, " ");
    623 	if (!node_is_up(n) && tipc_node_cleanup(n)) {
    624 		/*Removing the reference of Timer*/
    625 		tipc_node_put(n);
    626 		return;
    627 	}
    628 
    629 	__skb_queue_head_init(&xmitq);
    630 
    631 	/* Initial node interval to value larger (10 seconds), then it will be
    632 	 * recalculated with link lowest tolerance
    633 	 */
    634 	tipc_node_read_lock(n);
    635 	n->keepalive_intv = 10000;
    636 	tipc_node_read_unlock(n);
    637 	for (bearer_id = 0; remains && (bearer_id < MAX_BEARERS); bearer_id++) {
    638 		tipc_node_read_lock(n);
    639 		le = &n->links[bearer_id];
    640 		if (le->link) {
    641 			spin_lock_bh(&le->lock);
    642 			/* Link tolerance may change asynchronously: */
    643 			tipc_node_calculate_timer(n, le->link);
    644 			rc = tipc_link_timeout(le->link, &xmitq);
    645 			spin_unlock_bh(&le->lock);
    646 			remains--;
    647 		}
    648 		tipc_node_read_unlock(n);
    649 		tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr);
    650 		if (rc & TIPC_LINK_DOWN_EVT)
    651 			tipc_node_link_down(n, bearer_id, false);
    652 	}
    653 	mod_timer(&n->timer, jiffies + msecs_to_jiffies(n->keepalive_intv));
    654 }
    655 
    656 /**
    657  * __tipc_node_link_up - handle addition of link
    658  * Node lock must be held by caller
    659  * Link becomes active (alone or shared) or standby, depending on its priority.
    660  */
    661 static void __tipc_node_link_up(struct tipc_node *n, int bearer_id,
    662 				struct sk_buff_head *xmitq)
    663 {
    664 	int *slot0 = &n->active_links[0];
    665 	int *slot1 = &n->active_links[1];
    666 	struct tipc_link *ol = node_active_link(n, 0);
    667 	struct tipc_link *nl = n->links[bearer_id].link;
    668 
    669 	if (!nl || tipc_link_is_up(nl))
    670 		return;
    671 
    672 	tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT);
    673 	if (!tipc_link_is_up(nl))
    674 		return;
    675 
    676 	n->working_links++;
    677 	n->action_flags |= TIPC_NOTIFY_LINK_UP;
    678 	n->link_id = tipc_link_id(nl);
    679 
    680 	/* Leave room for tunnel header when returning 'mtu' to users: */
    681 	n->links[bearer_id].mtu = tipc_link_mtu(nl) - INT_H_SIZE;
    682 
    683 	tipc_bearer_add_dest(n->net, bearer_id, n->addr);
    684 	tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id);
    685 
    686 	pr_debug("Established link <%s> on network plane %c\n",
    687 		 tipc_link_name(nl), tipc_link_plane(nl));
    688 	trace_tipc_node_link_up(n, true, " ");
    689 
    690 	/* Ensure that a STATE message goes first */
    691 	tipc_link_build_state_msg(nl, xmitq);
    692 
    693 	/* First link? => give it both slots */
    694 	if (!ol) {
    695 		*slot0 = bearer_id;
    696 		*slot1 = bearer_id;
    697 		tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT);
    698 		n->failover_sent = false;
    699 		n->action_flags |= TIPC_NOTIFY_NODE_UP;
    700 		tipc_link_set_active(nl, true);
    701 		tipc_bcast_add_peer(n->net, nl, xmitq);
    702 		return;
    703 	}
    704 
    705 	/* Second link => redistribute slots */
    706 	if (tipc_link_prio(nl) > tipc_link_prio(ol)) {
    707 		pr_debug("Old link <%s> becomes standby\n", tipc_link_name(ol));
    708 		*slot0 = bearer_id;
    709 		*slot1 = bearer_id;
    710 		tipc_link_set_active(nl, true);
    711 		tipc_link_set_active(ol, false);
    712 	} else if (tipc_link_prio(nl) == tipc_link_prio(ol)) {
    713 		tipc_link_set_active(nl, true);
    714 		*slot1 = bearer_id;
    715 	} else {
    716 		pr_debug("New link <%s> is standby\n", tipc_link_name(nl));
    717 	}
    718 
    719 	/* Prepare synchronization with first link */
    720 	tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq);
    721 }
    722 
    723 /**
    724  * tipc_node_link_up - handle addition of link
    725  *
    726  * Link becomes active (alone or shared) or standby, depending on its priority.
    727  */
    728 static void tipc_node_link_up(struct tipc_node *n, int bearer_id,
    729 			      struct sk_buff_head *xmitq)
    730 {
    731 	struct tipc_media_addr *maddr;
    732 
    733 	tipc_node_write_lock(n);
    734 	__tipc_node_link_up(n, bearer_id, xmitq);
    735 	maddr = &n->links[bearer_id].maddr;
    736 	tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr);
    737 	tipc_node_write_unlock(n);
    738 }
    739 
    740 /**
    741  * __tipc_node_link_down - handle loss of link
    742  */
    743 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,
    744 				  struct sk_buff_head *xmitq,
    745 				  struct tipc_media_addr **maddr)
    746 {
    747 	struct tipc_link_entry *le = &n->links[*bearer_id];
    748 	int *slot0 = &n->active_links[0];
    749 	int *slot1 = &n->active_links[1];
    750 	int i, highest = 0, prio;
    751 	struct tipc_link *l, *_l, *tnl;
    752 
    753 	l = n->links[*bearer_id].link;
    754 	if (!l || tipc_link_is_reset(l))
    755 		return;
    756 
    757 	n->working_links--;
    758 	n->action_flags |= TIPC_NOTIFY_LINK_DOWN;
    759 	n->link_id = tipc_link_id(l);
    760 
    761 	tipc_bearer_remove_dest(n->net, *bearer_id, n->addr);
    762 
    763 	pr_debug("Lost link <%s> on network plane %c\n",
    764 		 tipc_link_name(l), tipc_link_plane(l));
    765 
    766 	/* Select new active link if any available */
    767 	*slot0 = INVALID_BEARER_ID;
    768 	*slot1 = INVALID_BEARER_ID;
    769 	for (i = 0; i < MAX_BEARERS; i++) {
    770 		_l = n->links[i].link;
    771 		if (!_l || !tipc_link_is_up(_l))
    772 			continue;
    773 		if (_l == l)
    774 			continue;
    775 		prio = tipc_link_prio(_l);
    776 		if (prio < highest)
    777 			continue;
    778 		if (prio > highest) {
    779 			highest = prio;
    780 			*slot0 = i;
    781 			*slot1 = i;
    782 			continue;
    783 		}
    784 		*slot1 = i;
    785 	}
    786 
    787 	if (!node_is_up(n)) {
    788 		if (tipc_link_peer_is_down(l))
    789 			tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
    790 		tipc_node_fsm_evt(n, SELF_LOST_CONTACT_EVT);
    791 		trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down!");
    792 		tipc_link_fsm_evt(l, LINK_RESET_EVT);
    793 		tipc_link_reset(l);
    794 		tipc_link_build_reset_msg(l, xmitq);
    795 		*maddr = &n->links[*bearer_id].maddr;
    796 		node_lost_contact(n, &le->inputq);
    797 		tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
    798 		return;
    799 	}
    800 	tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
    801 
    802 	/* There is still a working link => initiate failover */
    803 	*bearer_id = n->active_links[0];
    804 	tnl = n->links[*bearer_id].link;
    805 	tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
    806 	tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
    807 	n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1);
    808 	tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq);
    809 	trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down -> failover!");
    810 	tipc_link_reset(l);
    811 	tipc_link_fsm_evt(l, LINK_RESET_EVT);
    812 	tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
    813 	tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT);
    814 	*maddr = &n->links[*bearer_id].maddr;
    815 }
    816 
    817 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, bool delete)
    818 {
    819 	struct tipc_link_entry *le = &n->links[bearer_id];
    820 	struct tipc_media_addr *maddr = NULL;
    821 	struct tipc_link *l = le->link;
    822 	int old_bearer_id = bearer_id;
    823 	struct sk_buff_head xmitq;
    824 
    825 	if (!l)
    826 		return;
    827 
    828 	__skb_queue_head_init(&xmitq);
    829 
    830 	tipc_node_write_lock(n);
    831 	if (!tipc_link_is_establishing(l)) {
    832 		__tipc_node_link_down(n, &bearer_id, &xmitq, &maddr);
    833 	} else {
    834 		/* Defuse pending tipc_node_link_up() */
    835 		tipc_link_reset(l);
    836 		tipc_link_fsm_evt(l, LINK_RESET_EVT);
    837 	}
    838 	if (delete) {
    839 		kfree(l);
    840 		le->link = NULL;
    841 		n->link_cnt--;
    842 	}
    843 	trace_tipc_node_link_down(n, true, "node link down or deleted!");
    844 	tipc_node_write_unlock(n);
    845 	if (delete)
    846 		tipc_mon_remove_peer(n->net, n->addr, old_bearer_id);
    847 	if (!skb_queue_empty(&xmitq))
    848 		tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr);
    849 	tipc_sk_rcv(n->net, &le->inputq);
    850 }
    851 
    852 static bool node_is_up(struct tipc_node *n)
    853 {
    854 	return n->active_links[0] != INVALID_BEARER_ID;
    855 }
    856 
    857 bool tipc_node_is_up(struct net *net, u32 addr)
    858 {
    859 	struct tipc_node *n;
    860 	bool retval = false;
    861 
    862 	if (in_own_node(net, addr))
    863 		return true;
    864 
    865 	n = tipc_node_find(net, addr);
    866 	if (!n)
    867 		return false;
    868 	retval = node_is_up(n);
    869 	tipc_node_put(n);
    870 	return retval;
    871 }
    872 
    873 static u32 tipc_node_suggest_addr(struct net *net, u32 addr)
    874 {
    875 	struct tipc_node *n;
    876 
    877 	addr ^= tipc_net(net)->random;
    878 	while ((n = tipc_node_find(net, addr))) {
    879 		tipc_node_put(n);
    880 		addr++;
    881 	}
    882 	return addr;
    883 }
    884 
    885 /* tipc_node_try_addr(): Check if addr can be used by peer, suggest other if not
    886  * Returns suggested address if any, otherwise 0
    887  */
    888 u32 tipc_node_try_addr(struct net *net, u8 *id, u32 addr)
    889 {
    890 	struct tipc_net *tn = tipc_net(net);
    891 	struct tipc_node *n;
    892 
    893 	/* Suggest new address if some other peer is using this one */
    894 	n = tipc_node_find(net, addr);
    895 	if (n) {
    896 		if (!memcmp(n->peer_id, id, NODE_ID_LEN))
    897 			addr = 0;
    898 		tipc_node_put(n);
    899 		if (!addr)
    900 			return 0;
    901 		return tipc_node_suggest_addr(net, addr);
    902 	}
    903 
    904 	/* Suggest previously used address if peer is known */
    905 	n = tipc_node_find_by_id(net, id);
    906 	if (n) {
    907 		addr = n->addr;
    908 		tipc_node_put(n);
    909 		return addr;
    910 	}
    911 
    912 	/* Even this node may be in conflict */
    913 	if (tn->trial_addr == addr)
    914 		return tipc_node_suggest_addr(net, addr);
    915 
    916 	return 0;
    917 }
    918 
    919 void tipc_node_check_dest(struct net *net, u32 addr,
    920 			  u8 *peer_id, struct tipc_bearer *b,
    921 			  u16 capabilities, u32 signature,
    922 			  struct tipc_media_addr *maddr,
    923 			  bool *respond, bool *dupl_addr)
    924 {
    925 	struct tipc_node *n;
    926 	struct tipc_link *l;
    927 	struct tipc_link_entry *le;
    928 	bool addr_match = false;
    929 	bool sign_match = false;
    930 	bool link_up = false;
    931 	bool accept_addr = false;
    932 	bool reset = true;
    933 	char *if_name;
    934 	unsigned long intv;
    935 	u16 session;
    936 
    937 	*dupl_addr = false;
    938 	*respond = false;
    939 
    940 	n = tipc_node_create(net, addr, peer_id, capabilities);
    941 	if (!n)
    942 		return;
    943 
    944 	tipc_node_write_lock(n);
    945 
    946 	le = &n->links[b->identity];
    947 
    948 	/* Prepare to validate requesting node's signature and media address */
    949 	l = le->link;
    950 	link_up = l && tipc_link_is_up(l);
    951 	addr_match = l && !memcmp(&le->maddr, maddr, sizeof(*maddr));
    952 	sign_match = (signature == n->signature);
    953 
    954 	/* These three flags give us eight permutations: */
    955 
    956 	if (sign_match && addr_match && link_up) {
    957 		/* All is fine. Do nothing. */
    958 		reset = false;
    959 	} else if (sign_match && addr_match && !link_up) {
    960 		/* Respond. The link will come up in due time */
    961 		*respond = true;
    962 	} else if (sign_match && !addr_match && link_up) {
    963 		/* Peer has changed i/f address without rebooting.
    964 		 * If so, the link will reset soon, and the next
    965 		 * discovery will be accepted. So we can ignore it.
    966 		 * It may also be an cloned or malicious peer having
    967 		 * chosen the same node address and signature as an
    968 		 * existing one.
    969 		 * Ignore requests until the link goes down, if ever.
    970 		 */
    971 		*dupl_addr = true;
    972 	} else if (sign_match && !addr_match && !link_up) {
    973 		/* Peer link has changed i/f address without rebooting.
    974 		 * It may also be a cloned or malicious peer; we can't
    975 		 * distinguish between the two.
    976 		 * The signature is correct, so we must accept.
    977 		 */
    978 		accept_addr = true;
    979 		*respond = true;
    980 	} else if (!sign_match && addr_match && link_up) {
    981 		/* Peer node rebooted. Two possibilities:
    982 		 *  - Delayed re-discovery; this link endpoint has already
    983 		 *    reset and re-established contact with the peer, before
    984 		 *    receiving a discovery message from that node.
    985 		 *    (The peer happened to receive one from this node first).
    986 		 *  - The peer came back so fast that our side has not
    987 		 *    discovered it yet. Probing from this side will soon
    988 		 *    reset the link, since there can be no working link
    989 		 *    endpoint at the peer end, and the link will re-establish.
    990 		 *  Accept the signature, since it comes from a known peer.
    991 		 */
    992 		n->signature = signature;
    993 	} else if (!sign_match && addr_match && !link_up) {
    994 		/*  The peer node has rebooted.
    995 		 *  Accept signature, since it is a known peer.
    996 		 */
    997 		n->signature = signature;
    998 		*respond = true;
    999 	} else if (!sign_match && !addr_match && link_up) {
   1000 		/* Peer rebooted with new address, or a new/duplicate peer.
   1001 		 * Ignore until the link goes down, if ever.
   1002 		 */
   1003 		*dupl_addr = true;
   1004 	} else if (!sign_match && !addr_match && !link_up) {
   1005 		/* Peer rebooted with new address, or it is a new peer.
   1006 		 * Accept signature and address.
   1007 		 */
   1008 		n->signature = signature;
   1009 		accept_addr = true;
   1010 		*respond = true;
   1011 	}
   1012 
   1013 	if (!accept_addr)
   1014 		goto exit;
   1015 
   1016 	/* Now create new link if not already existing */
   1017 	if (!l) {
   1018 		if (n->link_cnt == 2)
   1019 			goto exit;
   1020 
   1021 		if_name = strchr(b->name, ':') + 1;
   1022 		get_random_bytes(&session, sizeof(u16));
   1023 		if (!tipc_link_create(net, if_name, b->identity, b->tolerance,
   1024 				      b->net_plane, b->mtu, b->priority,
   1025 				      b->window, session,
   1026 				      tipc_own_addr(net), addr, peer_id,
   1027 				      n->capabilities,
   1028 				      tipc_bc_sndlink(n->net), n->bc_entry.link,
   1029 				      &le->inputq,
   1030 				      &n->bc_entry.namedq, &l)) {
   1031 			*respond = false;
   1032 			goto exit;
   1033 		}
   1034 		trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link created!");
   1035 		tipc_link_reset(l);
   1036 		tipc_link_fsm_evt(l, LINK_RESET_EVT);
   1037 		if (n->state == NODE_FAILINGOVER)
   1038 			tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
   1039 		le->link = l;
   1040 		n->link_cnt++;
   1041 		tipc_node_calculate_timer(n, l);
   1042 		if (n->link_cnt == 1) {
   1043 			intv = jiffies + msecs_to_jiffies(n->keepalive_intv);
   1044 			if (!mod_timer(&n->timer, intv))
   1045 				tipc_node_get(n);
   1046 		}
   1047 	}
   1048 	memcpy(&le->maddr, maddr, sizeof(*maddr));
   1049 exit:
   1050 	tipc_node_write_unlock(n);
   1051 	if (reset && l && !tipc_link_is_reset(l))
   1052 		tipc_node_link_down(n, b->identity, false);
   1053 	tipc_node_put(n);
   1054 }
   1055 
   1056 void tipc_node_delete_links(struct net *net, int bearer_id)
   1057 {
   1058 	struct tipc_net *tn = net_generic(net, tipc_net_id);
   1059 	struct tipc_node *n;
   1060 
   1061 	rcu_read_lock();
   1062 	list_for_each_entry_rcu(n, &tn->node_list, list) {
   1063 		tipc_node_link_down(n, bearer_id, true);
   1064 	}
   1065 	rcu_read_unlock();
   1066 }
   1067 
   1068 static void tipc_node_reset_links(struct tipc_node *n)
   1069 {
   1070 	int i;
   1071 
   1072 	pr_warn("Resetting all links to %x\n", n->addr);
   1073 
   1074 	trace_tipc_node_reset_links(n, true, " ");
   1075 	for (i = 0; i < MAX_BEARERS; i++) {
   1076 		tipc_node_link_down(n, i, false);
   1077 	}
   1078 }
   1079 
   1080 /* tipc_node_fsm_evt - node finite state machine
   1081  * Determines when contact is allowed with peer node
   1082  */
   1083 static void tipc_node_fsm_evt(struct tipc_node *n, int evt)
   1084 {
   1085 	int state = n->state;
   1086 
   1087 	switch (state) {
   1088 	case SELF_DOWN_PEER_DOWN:
   1089 		switch (evt) {
   1090 		case SELF_ESTABL_CONTACT_EVT:
   1091 			state = SELF_UP_PEER_COMING;
   1092 			break;
   1093 		case PEER_ESTABL_CONTACT_EVT:
   1094 			state = SELF_COMING_PEER_UP;
   1095 			break;
   1096 		case SELF_LOST_CONTACT_EVT:
   1097 		case PEER_LOST_CONTACT_EVT:
   1098 			break;
   1099 		case NODE_SYNCH_END_EVT:
   1100 		case NODE_SYNCH_BEGIN_EVT:
   1101 		case NODE_FAILOVER_BEGIN_EVT:
   1102 		case NODE_FAILOVER_END_EVT:
   1103 		default:
   1104 			goto illegal_evt;
   1105 		}
   1106 		break;
   1107 	case SELF_UP_PEER_UP:
   1108 		switch (evt) {
   1109 		case SELF_LOST_CONTACT_EVT:
   1110 			state = SELF_DOWN_PEER_LEAVING;
   1111 			break;
   1112 		case PEER_LOST_CONTACT_EVT:
   1113 			state = SELF_LEAVING_PEER_DOWN;
   1114 			break;
   1115 		case NODE_SYNCH_BEGIN_EVT:
   1116 			state = NODE_SYNCHING;
   1117 			break;
   1118 		case NODE_FAILOVER_BEGIN_EVT:
   1119 			state = NODE_FAILINGOVER;
   1120 			break;
   1121 		case SELF_ESTABL_CONTACT_EVT:
   1122 		case PEER_ESTABL_CONTACT_EVT:
   1123 		case NODE_SYNCH_END_EVT:
   1124 		case NODE_FAILOVER_END_EVT:
   1125 			break;
   1126 		default:
   1127 			goto illegal_evt;
   1128 		}
   1129 		break;
   1130 	case SELF_DOWN_PEER_LEAVING:
   1131 		switch (evt) {
   1132 		case PEER_LOST_CONTACT_EVT:
   1133 			state = SELF_DOWN_PEER_DOWN;
   1134 			break;
   1135 		case SELF_ESTABL_CONTACT_EVT:
   1136 		case PEER_ESTABL_CONTACT_EVT:
   1137 		case SELF_LOST_CONTACT_EVT:
   1138 			break;
   1139 		case NODE_SYNCH_END_EVT:
   1140 		case NODE_SYNCH_BEGIN_EVT:
   1141 		case NODE_FAILOVER_BEGIN_EVT:
   1142 		case NODE_FAILOVER_END_EVT:
   1143 		default:
   1144 			goto illegal_evt;
   1145 		}
   1146 		break;
   1147 	case SELF_UP_PEER_COMING:
   1148 		switch (evt) {
   1149 		case PEER_ESTABL_CONTACT_EVT:
   1150 			state = SELF_UP_PEER_UP;
   1151 			break;
   1152 		case SELF_LOST_CONTACT_EVT:
   1153 			state = SELF_DOWN_PEER_DOWN;
   1154 			break;
   1155 		case SELF_ESTABL_CONTACT_EVT:
   1156 		case PEER_LOST_CONTACT_EVT:
   1157 		case NODE_SYNCH_END_EVT:
   1158 		case NODE_FAILOVER_BEGIN_EVT:
   1159 			break;
   1160 		case NODE_SYNCH_BEGIN_EVT:
   1161 		case NODE_FAILOVER_END_EVT:
   1162 		default:
   1163 			goto illegal_evt;
   1164 		}
   1165 		break;
   1166 	case SELF_COMING_PEER_UP:
   1167 		switch (evt) {
   1168 		case SELF_ESTABL_CONTACT_EVT:
   1169 			state = SELF_UP_PEER_UP;
   1170 			break;
   1171 		case PEER_LOST_CONTACT_EVT:
   1172 			state = SELF_DOWN_PEER_DOWN;
   1173 			break;
   1174 		case SELF_LOST_CONTACT_EVT:
   1175 		case PEER_ESTABL_CONTACT_EVT:
   1176 			break;
   1177 		case NODE_SYNCH_END_EVT:
   1178 		case NODE_SYNCH_BEGIN_EVT:
   1179 		case NODE_FAILOVER_BEGIN_EVT:
   1180 		case NODE_FAILOVER_END_EVT:
   1181 		default:
   1182 			goto illegal_evt;
   1183 		}
   1184 		break;
   1185 	case SELF_LEAVING_PEER_DOWN:
   1186 		switch (evt) {
   1187 		case SELF_LOST_CONTACT_EVT:
   1188 			state = SELF_DOWN_PEER_DOWN;
   1189 			break;
   1190 		case SELF_ESTABL_CONTACT_EVT:
   1191 		case PEER_ESTABL_CONTACT_EVT:
   1192 		case PEER_LOST_CONTACT_EVT:
   1193 			break;
   1194 		case NODE_SYNCH_END_EVT:
   1195 		case NODE_SYNCH_BEGIN_EVT:
   1196 		case NODE_FAILOVER_BEGIN_EVT:
   1197 		case NODE_FAILOVER_END_EVT:
   1198 		default:
   1199 			goto illegal_evt;
   1200 		}
   1201 		break;
   1202 	case NODE_FAILINGOVER:
   1203 		switch (evt) {
   1204 		case SELF_LOST_CONTACT_EVT:
   1205 			state = SELF_DOWN_PEER_LEAVING;
   1206 			break;
   1207 		case PEER_LOST_CONTACT_EVT:
   1208 			state = SELF_LEAVING_PEER_DOWN;
   1209 			break;
   1210 		case NODE_FAILOVER_END_EVT:
   1211 			state = SELF_UP_PEER_UP;
   1212 			break;
   1213 		case NODE_FAILOVER_BEGIN_EVT:
   1214 		case SELF_ESTABL_CONTACT_EVT:
   1215 		case PEER_ESTABL_CONTACT_EVT:
   1216 			break;
   1217 		case NODE_SYNCH_BEGIN_EVT:
   1218 		case NODE_SYNCH_END_EVT:
   1219 		default:
   1220 			goto illegal_evt;
   1221 		}
   1222 		break;
   1223 	case NODE_SYNCHING:
   1224 		switch (evt) {
   1225 		case SELF_LOST_CONTACT_EVT:
   1226 			state = SELF_DOWN_PEER_LEAVING;
   1227 			break;
   1228 		case PEER_LOST_CONTACT_EVT:
   1229 			state = SELF_LEAVING_PEER_DOWN;
   1230 			break;
   1231 		case NODE_SYNCH_END_EVT:
   1232 			state = SELF_UP_PEER_UP;
   1233 			break;
   1234 		case NODE_FAILOVER_BEGIN_EVT:
   1235 			state = NODE_FAILINGOVER;
   1236 			break;
   1237 		case NODE_SYNCH_BEGIN_EVT:
   1238 		case SELF_ESTABL_CONTACT_EVT:
   1239 		case PEER_ESTABL_CONTACT_EVT:
   1240 			break;
   1241 		case NODE_FAILOVER_END_EVT:
   1242 		default:
   1243 			goto illegal_evt;
   1244 		}
   1245 		break;
   1246 	default:
   1247 		pr_err("Unknown node fsm state %x\n", state);
   1248 		break;
   1249 	}
   1250 	trace_tipc_node_fsm(n->peer_id, n->state, state, evt);
   1251 	n->state = state;
   1252 	return;
   1253 
   1254 illegal_evt:
   1255 	pr_err("Illegal node fsm evt %x in state %x\n", evt, state);
   1256 	trace_tipc_node_fsm(n->peer_id, n->state, state, evt);
   1257 }
   1258 
   1259 static void node_lost_contact(struct tipc_node *n,
   1260 			      struct sk_buff_head *inputq)
   1261 {
   1262 	struct tipc_sock_conn *conn, *safe;
   1263 	struct tipc_link *l;
   1264 	struct list_head *conns = &n->conn_sks;
   1265 	struct sk_buff *skb;
   1266 	uint i;
   1267 
   1268 	pr_debug("Lost contact with %x\n", n->addr);
   1269 	n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER);
   1270 	trace_tipc_node_lost_contact(n, true, " ");
   1271 
   1272 	/* Clean up broadcast state */
   1273 	tipc_bcast_remove_peer(n->net, n->bc_entry.link);
   1274 
   1275 	/* Abort any ongoing link failover */
   1276 	for (i = 0; i < MAX_BEARERS; i++) {
   1277 		l = n->links[i].link;
   1278 		if (l)
   1279 			tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT);
   1280 	}
   1281 
   1282 	/* Notify publications from this node */
   1283 	n->action_flags |= TIPC_NOTIFY_NODE_DOWN;
   1284 
   1285 	/* Notify sockets connected to node */
   1286 	list_for_each_entry_safe(conn, safe, conns, list) {
   1287 		skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
   1288 				      SHORT_H_SIZE, 0, tipc_own_addr(n->net),
   1289 				      conn->peer_node, conn->port,
   1290 				      conn->peer_port, TIPC_ERR_NO_NODE);
   1291 		if (likely(skb))
   1292 			skb_queue_tail(inputq, skb);
   1293 		list_del(&conn->list);
   1294 		kfree(conn);
   1295 	}
   1296 }
   1297 
   1298 /**
   1299  * tipc_node_get_linkname - get the name of a link
   1300  *
   1301  * @bearer_id: id of the bearer
   1302  * @node: peer node address
   1303  * @linkname: link name output buffer
   1304  *
   1305  * Returns 0 on success
   1306  */
   1307 int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
   1308 			   char *linkname, size_t len)
   1309 {
   1310 	struct tipc_link *link;
   1311 	int err = -EINVAL;
   1312 	struct tipc_node *node = tipc_node_find(net, addr);
   1313 
   1314 	if (!node)
   1315 		return err;
   1316 
   1317 	if (bearer_id >= MAX_BEARERS)
   1318 		goto exit;
   1319 
   1320 	tipc_node_read_lock(node);
   1321 	link = node->links[bearer_id].link;
   1322 	if (link) {
   1323 		strncpy(linkname, tipc_link_name(link), len);
   1324 		err = 0;
   1325 	}
   1326 	tipc_node_read_unlock(node);
   1327 exit:
   1328 	tipc_node_put(node);
   1329 	return err;
   1330 }
   1331 
   1332 /* Caller should hold node lock for the passed node */
   1333 static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
   1334 {
   1335 	void *hdr;
   1336 	struct nlattr *attrs;
   1337 
   1338 	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
   1339 			  NLM_F_MULTI, TIPC_NL_NODE_GET);
   1340 	if (!hdr)
   1341 		return -EMSGSIZE;
   1342 
   1343 	attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE);
   1344 	if (!attrs)
   1345 		goto msg_full;
   1346 
   1347 	if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
   1348 		goto attr_msg_full;
   1349 	if (node_is_up(node))
   1350 		if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP))
   1351 			goto attr_msg_full;
   1352 
   1353 	nla_nest_end(msg->skb, attrs);
   1354 	genlmsg_end(msg->skb, hdr);
   1355 
   1356 	return 0;
   1357 
   1358 attr_msg_full:
   1359 	nla_nest_cancel(msg->skb, attrs);
   1360 msg_full:
   1361 	genlmsg_cancel(msg->skb, hdr);
   1362 
   1363 	return -EMSGSIZE;
   1364 }
   1365 
   1366 /**
   1367  * tipc_node_xmit() is the general link level function for message sending
   1368  * @net: the applicable net namespace
   1369  * @list: chain of buffers containing message
   1370  * @dnode: address of destination node
   1371  * @selector: a number used for deterministic link selection
   1372  * Consumes the buffer chain.
   1373  * Returns 0 if success, otherwise: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE,-ENOBUF
   1374  */
   1375 int tipc_node_xmit(struct net *net, struct sk_buff_head *list,
   1376 		   u32 dnode, int selector)
   1377 {
   1378 	struct tipc_link_entry *le = NULL;
   1379 	struct tipc_node *n;
   1380 	struct sk_buff_head xmitq;
   1381 	int bearer_id;
   1382 	int rc;
   1383 
   1384 	if (in_own_node(net, dnode)) {
   1385 		tipc_sk_rcv(net, list);
   1386 		return 0;
   1387 	}
   1388 
   1389 	n = tipc_node_find(net, dnode);
   1390 	if (unlikely(!n)) {
   1391 		skb_queue_purge(list);
   1392 		return -EHOSTUNREACH;
   1393 	}
   1394 
   1395 	tipc_node_read_lock(n);
   1396 	bearer_id = n->active_links[selector & 1];
   1397 	if (unlikely(bearer_id == INVALID_BEARER_ID)) {
   1398 		tipc_node_read_unlock(n);
   1399 		tipc_node_put(n);
   1400 		skb_queue_purge(list);
   1401 		return -EHOSTUNREACH;
   1402 	}
   1403 
   1404 	__skb_queue_head_init(&xmitq);
   1405 	le = &n->links[bearer_id];
   1406 	spin_lock_bh(&le->lock);
   1407 	rc = tipc_link_xmit(le->link, list, &xmitq);
   1408 	spin_unlock_bh(&le->lock);
   1409 	tipc_node_read_unlock(n);
   1410 
   1411 	if (unlikely(rc == -ENOBUFS))
   1412 		tipc_node_link_down(n, bearer_id, false);
   1413 	else
   1414 		tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);
   1415 
   1416 	tipc_node_put(n);
   1417 
   1418 	return rc;
   1419 }
   1420 
   1421 /* tipc_node_xmit_skb(): send single buffer to destination
   1422  * Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE
   1423  * messages, which will not be rejected
   1424  * The only exception is datagram messages rerouted after secondary
   1425  * lookup, which are rare and safe to dispose of anyway.
   1426  */
   1427 int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode,
   1428 		       u32 selector)
   1429 {
   1430 	struct sk_buff_head head;
   1431 
   1432 	skb_queue_head_init(&head);
   1433 	__skb_queue_tail(&head, skb);
   1434 	tipc_node_xmit(net, &head, dnode, selector);
   1435 	return 0;
   1436 }
   1437 
   1438 /* tipc_node_distr_xmit(): send single buffer msgs to individual destinations
   1439  * Note: this is only for SYSTEM_IMPORTANCE messages, which cannot be rejected
   1440  */
   1441 int tipc_node_distr_xmit(struct net *net, struct sk_buff_head *xmitq)
   1442 {
   1443 	struct sk_buff *skb;
   1444 	u32 selector, dnode;
   1445 
   1446 	while ((skb = __skb_dequeue(xmitq))) {
   1447 		selector = msg_origport(buf_msg(skb));
   1448 		dnode = msg_destnode(buf_msg(skb));
   1449 		tipc_node_xmit_skb(net, skb, dnode, selector);
   1450 	}
   1451 	return 0;
   1452 }
   1453 
   1454 void tipc_node_broadcast(struct net *net, struct sk_buff *skb)
   1455 {
   1456 	struct sk_buff *txskb;
   1457 	struct tipc_node *n;
   1458 	u32 dst;
   1459 
   1460 	rcu_read_lock();
   1461 	list_for_each_entry_rcu(n, tipc_nodes(net), list) {
   1462 		dst = n->addr;
   1463 		if (in_own_node(net, dst))
   1464 			continue;
   1465 		if (!node_is_up(n))
   1466 			continue;
   1467 		txskb = pskb_copy(skb, GFP_ATOMIC);
   1468 		if (!txskb)
   1469 			break;
   1470 		msg_set_destnode(buf_msg(txskb), dst);
   1471 		tipc_node_xmit_skb(net, txskb, dst, 0);
   1472 	}
   1473 	rcu_read_unlock();
   1474 
   1475 	kfree_skb(skb);
   1476 }
   1477 
   1478 static void tipc_node_mcast_rcv(struct tipc_node *n)
   1479 {
   1480 	struct tipc_bclink_entry *be = &n->bc_entry;
   1481 
   1482 	/* 'arrvq' is under inputq2's lock protection */
   1483 	spin_lock_bh(&be->inputq2.lock);
   1484 	spin_lock_bh(&be->inputq1.lock);
   1485 	skb_queue_splice_tail_init(&be->inputq1, &be->arrvq);
   1486 	spin_unlock_bh(&be->inputq1.lock);
   1487 	spin_unlock_bh(&be->inputq2.lock);
   1488 	tipc_sk_mcast_rcv(n->net, &be->arrvq, &be->inputq2);
   1489 }
   1490 
   1491 static void tipc_node_bc_sync_rcv(struct tipc_node *n, struct tipc_msg *hdr,
   1492 				  int bearer_id, struct sk_buff_head *xmitq)
   1493 {
   1494 	struct tipc_link *ucl;
   1495 	int rc;
   1496 
   1497 	rc = tipc_bcast_sync_rcv(n->net, n->bc_entry.link, hdr);
   1498 
   1499 	if (rc & TIPC_LINK_DOWN_EVT) {
   1500 		tipc_node_reset_links(n);
   1501 		return;
   1502 	}
   1503 
   1504 	if (!(rc & TIPC_LINK_SND_STATE))
   1505 		return;
   1506 
   1507 	/* If probe message, a STATE response will be sent anyway */
   1508 	if (msg_probe(hdr))
   1509 		return;
   1510 
   1511 	/* Produce a STATE message carrying broadcast NACK */
   1512 	tipc_node_read_lock(n);
   1513 	ucl = n->links[bearer_id].link;
   1514 	if (ucl)
   1515 		tipc_link_build_state_msg(ucl, xmitq);
   1516 	tipc_node_read_unlock(n);
   1517 }
   1518 
   1519 /**
   1520  * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node
   1521  * @net: the applicable net namespace
   1522  * @skb: TIPC packet
   1523  * @bearer_id: id of bearer message arrived on
   1524  *
   1525  * Invoked with no locks held.
   1526  */
   1527 static void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id)
   1528 {
   1529 	int rc;
   1530 	struct sk_buff_head xmitq;
   1531 	struct tipc_bclink_entry *be;
   1532 	struct tipc_link_entry *le;
   1533 	struct tipc_msg *hdr = buf_msg(skb);
   1534 	int usr = msg_user(hdr);
   1535 	u32 dnode = msg_destnode(hdr);
   1536 	struct tipc_node *n;
   1537 
   1538 	__skb_queue_head_init(&xmitq);
   1539 
   1540 	/* If NACK for other node, let rcv link for that node peek into it */
   1541 	if ((usr == BCAST_PROTOCOL) && (dnode != tipc_own_addr(net)))
   1542 		n = tipc_node_find(net, dnode);
   1543 	else
   1544 		n = tipc_node_find(net, msg_prevnode(hdr));
   1545 	if (!n) {
   1546 		kfree_skb(skb);
   1547 		return;
   1548 	}
   1549 	be = &n->bc_entry;
   1550 	le = &n->links[bearer_id];
   1551 
   1552 	rc = tipc_bcast_rcv(net, be->link, skb);
   1553 
   1554 	/* Broadcast ACKs are sent on a unicast link */
   1555 	if (rc & TIPC_LINK_SND_STATE) {
   1556 		tipc_node_read_lock(n);
   1557 		tipc_link_build_state_msg(le->link, &xmitq);
   1558 		tipc_node_read_unlock(n);
   1559 	}
   1560 
   1561 	if (!skb_queue_empty(&xmitq))
   1562 		tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);
   1563 
   1564 	if (!skb_queue_empty(&be->inputq1))
   1565 		tipc_node_mcast_rcv(n);
   1566 
   1567 	/* Handle NAME_DISTRIBUTOR messages sent from 1.7 nodes */
   1568 	if (!skb_queue_empty(&n->bc_entry.namedq))
   1569 		tipc_named_rcv(net, &n->bc_entry.namedq);
   1570 
   1571 	/* If reassembly or retransmission failure => reset all links to peer */
   1572 	if (rc & TIPC_LINK_DOWN_EVT)
   1573 		tipc_node_reset_links(n);
   1574 
   1575 	tipc_node_put(n);
   1576 }
   1577 
   1578 /**
   1579  * tipc_node_check_state - check and if necessary update node state
   1580  * @skb: TIPC packet
   1581  * @bearer_id: identity of bearer delivering the packet
   1582  * Returns true if state and msg are ok, otherwise false
   1583  */
   1584 static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb,
   1585 				  int bearer_id, struct sk_buff_head *xmitq)
   1586 {
   1587 	struct tipc_msg *hdr = buf_msg(skb);
   1588 	int usr = msg_user(hdr);
   1589 	int mtyp = msg_type(hdr);
   1590 	u16 oseqno = msg_seqno(hdr);
   1591 	u16 iseqno = msg_seqno(msg_get_wrapped(hdr));
   1592 	u16 exp_pkts = msg_msgcnt(hdr);
   1593 	u16 rcv_nxt, syncpt, dlv_nxt, inputq_len;
   1594 	int state = n->state;
   1595 	struct tipc_link *l, *tnl, *pl = NULL;
   1596 	struct tipc_media_addr *maddr;
   1597 	int pb_id;
   1598 
   1599 	if (trace_tipc_node_check_state_enabled()) {
   1600 		trace_tipc_skb_dump(skb, false, "skb for node state check");
   1601 		trace_tipc_node_check_state(n, true, " ");
   1602 	}
   1603 	l = n->links[bearer_id].link;
   1604 	if (!l)
   1605 		return false;
   1606 	rcv_nxt = tipc_link_rcv_nxt(l);
   1607 
   1608 
   1609 	if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL)))
   1610 		return true;
   1611 
   1612 	/* Find parallel link, if any */
   1613 	for (pb_id = 0; pb_id < MAX_BEARERS; pb_id++) {
   1614 		if ((pb_id != bearer_id) && n->links[pb_id].link) {
   1615 			pl = n->links[pb_id].link;
   1616 			break;
   1617 		}
   1618 	}
   1619 
   1620 	if (!tipc_link_validate_msg(l, hdr)) {
   1621 		trace_tipc_skb_dump(skb, false, "PROTO invalid (2)!");
   1622 		trace_tipc_link_dump(l, TIPC_DUMP_NONE, "PROTO invalid (2)!");
   1623 		return false;
   1624 	}
   1625 
   1626 	/* Check and update node accesibility if applicable */
   1627 	if (state == SELF_UP_PEER_COMING) {
   1628 		if (!tipc_link_is_up(l))
   1629 			return true;
   1630 		if (!msg_peer_link_is_up(hdr))
   1631 			return true;
   1632 		tipc_node_fsm_evt(n, PEER_ESTABL_CONTACT_EVT);
   1633 	}
   1634 
   1635 	if (state == SELF_DOWN_PEER_LEAVING) {
   1636 		if (msg_peer_node_is_up(hdr))
   1637 			return false;
   1638 		tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
   1639 		return true;
   1640 	}
   1641 
   1642 	if (state == SELF_LEAVING_PEER_DOWN)
   1643 		return false;
   1644 
   1645 	/* Ignore duplicate packets */
   1646 	if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt))
   1647 		return true;
   1648 
   1649 	/* Initiate or update failover mode if applicable */
   1650 	if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) {
   1651 		syncpt = oseqno + exp_pkts - 1;
   1652 		if (pl && tipc_link_is_up(pl)) {
   1653 			__tipc_node_link_down(n, &pb_id, xmitq, &maddr);
   1654 			trace_tipc_node_link_down(n, true,
   1655 						  "node link down <- failover!");
   1656 			tipc_skb_queue_splice_tail_init(tipc_link_inputq(pl),
   1657 							tipc_link_inputq(l));
   1658 		}
   1659 		/* If parallel link was already down, and this happened before
   1660 		 * the tunnel link came up, FAILOVER was never sent. Ensure that
   1661 		 * FAILOVER is sent to get peer out of NODE_FAILINGOVER state.
   1662 		 */
   1663 		if (n->state != NODE_FAILINGOVER && !n->failover_sent) {
   1664 			tipc_link_create_dummy_tnl_msg(l, xmitq);
   1665 			n->failover_sent = true;
   1666 		}
   1667 		/* If pkts arrive out of order, use lowest calculated syncpt */
   1668 		if (less(syncpt, n->sync_point))
   1669 			n->sync_point = syncpt;
   1670 	}
   1671 
   1672 	/* Open parallel link when tunnel link reaches synch point */
   1673 	if ((n->state == NODE_FAILINGOVER) && tipc_link_is_up(l)) {
   1674 		if (!more(rcv_nxt, n->sync_point))
   1675 			return true;
   1676 		tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT);
   1677 		if (pl)
   1678 			tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT);
   1679 		return true;
   1680 	}
   1681 
   1682 	/* No synching needed if only one link */
   1683 	if (!pl || !tipc_link_is_up(pl))
   1684 		return true;
   1685 
   1686 	/* Initiate synch mode if applicable */
   1687 	if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) {
   1688 		syncpt = iseqno + exp_pkts - 1;
   1689 		if (!tipc_link_is_up(l))
   1690 			__tipc_node_link_up(n, bearer_id, xmitq);
   1691 		if (n->state == SELF_UP_PEER_UP) {
   1692 			n->sync_point = syncpt;
   1693 			tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT);
   1694 			tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT);
   1695 		}
   1696 	}
   1697 
   1698 	/* Open tunnel link when parallel link reaches synch point */
   1699 	if (n->state == NODE_SYNCHING) {
   1700 		if (tipc_link_is_synching(l)) {
   1701 			tnl = l;
   1702 		} else {
   1703 			tnl = pl;
   1704 			pl = l;
   1705 		}
   1706 		inputq_len = skb_queue_len(tipc_link_inputq(pl));
   1707 		dlv_nxt = tipc_link_rcv_nxt(pl) - inputq_len;
   1708 		if (more(dlv_nxt, n->sync_point)) {
   1709 			tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
   1710 			tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
   1711 			return true;
   1712 		}
   1713 		if (l == pl)
   1714 			return true;
   1715 		if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG))
   1716 			return true;
   1717 		if (usr == LINK_PROTOCOL)
   1718 			return true;
   1719 		return false;
   1720 	}
   1721 	return true;
   1722 }
   1723 
   1724 /**
   1725  * tipc_rcv - process TIPC packets/messages arriving from off-node
   1726  * @net: the applicable net namespace
   1727  * @skb: TIPC packet
   1728  * @bearer: pointer to bearer message arrived on
   1729  *
   1730  * Invoked with no locks held. Bearer pointer must point to a valid bearer
   1731  * structure (i.e. cannot be NULL), but bearer can be inactive.
   1732  */
   1733 void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b)
   1734 {
   1735 	struct sk_buff_head xmitq;
   1736 	struct tipc_node *n;
   1737 	struct tipc_msg *hdr;
   1738 	int bearer_id = b->identity;
   1739 	struct tipc_link_entry *le;
   1740 	u32 self = tipc_own_addr(net);
   1741 	int usr, rc = 0;
   1742 	u16 bc_ack;
   1743 
   1744 	__skb_queue_head_init(&xmitq);
   1745 
   1746 	/* Ensure message is well-formed before touching the header */
   1747 	if (unlikely(!tipc_msg_validate(&skb)))
   1748 		goto discard;
   1749 	hdr = buf_msg(skb);
   1750 	usr = msg_user(hdr);
   1751 	bc_ack = msg_bcast_ack(hdr);
   1752 
   1753 	/* Handle arrival of discovery or broadcast packet */
   1754 	if (unlikely(msg_non_seq(hdr))) {
   1755 		if (unlikely(usr == LINK_CONFIG))
   1756 			return tipc_disc_rcv(net, skb, b);
   1757 		else
   1758 			return tipc_node_bc_rcv(net, skb, bearer_id);
   1759 	}
   1760 
   1761 	/* Discard unicast link messages destined for another node */
   1762 	if (unlikely(!msg_short(hdr) && (msg_destnode(hdr) != self)))
   1763 		goto discard;
   1764 
   1765 	/* Locate neighboring node that sent packet */
   1766 	n = tipc_node_find(net, msg_prevnode(hdr));
   1767 	if (unlikely(!n))
   1768 		goto discard;
   1769 	le = &n->links[bearer_id];
   1770 
   1771 	/* Ensure broadcast reception is in synch with peer's send state */
   1772 	if (unlikely(usr == LINK_PROTOCOL))
   1773 		tipc_node_bc_sync_rcv(n, hdr, bearer_id, &xmitq);
   1774 	else if (unlikely(tipc_link_acked(n->bc_entry.link) != bc_ack))
   1775 		tipc_bcast_ack_rcv(net, n->bc_entry.link, hdr);
   1776 
   1777 	/* Receive packet directly if conditions permit */
   1778 	tipc_node_read_lock(n);
   1779 	if (likely((n->state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) {
   1780 		spin_lock_bh(&le->lock);
   1781 		if (le->link) {
   1782 			rc = tipc_link_rcv(le->link, skb, &xmitq);
   1783 			skb = NULL;
   1784 		}
   1785 		spin_unlock_bh(&le->lock);
   1786 	}
   1787 	tipc_node_read_unlock(n);
   1788 
   1789 	/* Check/update node state before receiving */
   1790 	if (unlikely(skb)) {
   1791 		if (unlikely(skb_linearize(skb)))
   1792 			goto discard;
   1793 		tipc_node_write_lock(n);
   1794 		if (tipc_node_check_state(n, skb, bearer_id, &xmitq)) {
   1795 			if (le->link) {
   1796 				rc = tipc_link_rcv(le->link, skb, &xmitq);
   1797 				skb = NULL;
   1798 			}
   1799 		}
   1800 		tipc_node_write_unlock(n);
   1801 	}
   1802 
   1803 	if (unlikely(rc & TIPC_LINK_UP_EVT))
   1804 		tipc_node_link_up(n, bearer_id, &xmitq);
   1805 
   1806 	if (unlikely(rc & TIPC_LINK_DOWN_EVT))
   1807 		tipc_node_link_down(n, bearer_id, false);
   1808 
   1809 	if (unlikely(!skb_queue_empty(&n->bc_entry.namedq)))
   1810 		tipc_named_rcv(net, &n->bc_entry.namedq);
   1811 
   1812 	if (unlikely(!skb_queue_empty(&n->bc_entry.inputq1)))
   1813 		tipc_node_mcast_rcv(n);
   1814 
   1815 	if (!skb_queue_empty(&le->inputq))
   1816 		tipc_sk_rcv(net, &le->inputq);
   1817 
   1818 	if (!skb_queue_empty(&xmitq))
   1819 		tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);
   1820 
   1821 	tipc_node_put(n);
   1822 discard:
   1823 	kfree_skb(skb);
   1824 }
   1825 
   1826 void tipc_node_apply_property(struct net *net, struct tipc_bearer *b,
   1827 			      int prop)
   1828 {
   1829 	struct tipc_net *tn = tipc_net(net);
   1830 	int bearer_id = b->identity;
   1831 	struct sk_buff_head xmitq;
   1832 	struct tipc_link_entry *e;
   1833 	struct tipc_node *n;
   1834 
   1835 	__skb_queue_head_init(&xmitq);
   1836 
   1837 	rcu_read_lock();
   1838 
   1839 	list_for_each_entry_rcu(n, &tn->node_list, list) {
   1840 		tipc_node_write_lock(n);
   1841 		e = &n->links[bearer_id];
   1842 		if (e->link) {
   1843 			if (prop == TIPC_NLA_PROP_TOL)
   1844 				tipc_link_set_tolerance(e->link, b->tolerance,
   1845 							&xmitq);
   1846 			else if (prop == TIPC_NLA_PROP_MTU)
   1847 				tipc_link_set_mtu(e->link, b->mtu);
   1848 		}
   1849 		tipc_node_write_unlock(n);
   1850 		tipc_bearer_xmit(net, bearer_id, &xmitq, &e->maddr);
   1851 	}
   1852 
   1853 	rcu_read_unlock();
   1854 }
   1855 
   1856 int tipc_nl_peer_rm(struct sk_buff *skb, struct genl_info *info)
   1857 {
   1858 	struct net *net = sock_net(skb->sk);
   1859 	struct tipc_net *tn = net_generic(net, tipc_net_id);
   1860 	struct nlattr *attrs[TIPC_NLA_NET_MAX + 1];
   1861 	struct tipc_node *peer;
   1862 	u32 addr;
   1863 	int err;
   1864 
   1865 	/* We identify the peer by its net */
   1866 	if (!info->attrs[TIPC_NLA_NET])
   1867 		return -EINVAL;
   1868 
   1869 	err = nla_parse_nested(attrs, TIPC_NLA_NET_MAX,
   1870 			       info->attrs[TIPC_NLA_NET], tipc_nl_net_policy,
   1871 			       info->extack);
   1872 	if (err)
   1873 		return err;
   1874 
   1875 	if (!attrs[TIPC_NLA_NET_ADDR])
   1876 		return -EINVAL;
   1877 
   1878 	addr = nla_get_u32(attrs[TIPC_NLA_NET_ADDR]);
   1879 
   1880 	if (in_own_node(net, addr))
   1881 		return -ENOTSUPP;
   1882 
   1883 	spin_lock_bh(&tn->node_list_lock);
   1884 	peer = tipc_node_find(net, addr);
   1885 	if (!peer) {
   1886 		spin_unlock_bh(&tn->node_list_lock);
   1887 		return -ENXIO;
   1888 	}
   1889 
   1890 	tipc_node_write_lock(peer);
   1891 	if (peer->state != SELF_DOWN_PEER_DOWN &&
   1892 	    peer->state != SELF_DOWN_PEER_LEAVING) {
   1893 		tipc_node_write_unlock(peer);
   1894 		err = -EBUSY;
   1895 		goto err_out;
   1896 	}
   1897 
   1898 	tipc_node_clear_links(peer);
   1899 	tipc_node_write_unlock(peer);
   1900 	tipc_node_delete(peer);
   1901 
   1902 	err = 0;
   1903 err_out:
   1904 	tipc_node_put(peer);
   1905 	spin_unlock_bh(&tn->node_list_lock);
   1906 
   1907 	return err;
   1908 }
   1909 
   1910 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
   1911 {
   1912 	int err;
   1913 	struct net *net = sock_net(skb->sk);
   1914 	struct tipc_net *tn = net_generic(net, tipc_net_id);
   1915 	int done = cb->args[0];
   1916 	int last_addr = cb->args[1];
   1917 	struct tipc_node *node;
   1918 	struct tipc_nl_msg msg;
   1919 
   1920 	if (done)
   1921 		return 0;
   1922 
   1923 	msg.skb = skb;
   1924 	msg.portid = NETLINK_CB(cb->skb).portid;
   1925 	msg.seq = cb->nlh->nlmsg_seq;
   1926 
   1927 	rcu_read_lock();
   1928 	if (last_addr) {
   1929 		node = tipc_node_find(net, last_addr);
   1930 		if (!node) {
   1931 			rcu_read_unlock();
   1932 			/* We never set seq or call nl_dump_check_consistent()
   1933 			 * this means that setting prev_seq here will cause the
   1934 			 * consistence check to fail in the netlink callback
   1935 			 * handler. Resulting in the NLMSG_DONE message having
   1936 			 * the NLM_F_DUMP_INTR flag set if the node state
   1937 			 * changed while we released the lock.
   1938 			 */
   1939 			cb->prev_seq = 1;
   1940 			return -EPIPE;
   1941 		}
   1942 		tipc_node_put(node);
   1943 	}
   1944 
   1945 	list_for_each_entry_rcu(node, &tn->node_list, list) {
   1946 		if (last_addr) {
   1947 			if (node->addr == last_addr)
   1948 				last_addr = 0;
   1949 			else
   1950 				continue;
   1951 		}
   1952 
   1953 		tipc_node_read_lock(node);
   1954 		err = __tipc_nl_add_node(&msg, node);
   1955 		if (err) {
   1956 			last_addr = node->addr;
   1957 			tipc_node_read_unlock(node);
   1958 			goto out;
   1959 		}
   1960 
   1961 		tipc_node_read_unlock(node);
   1962 	}
   1963 	done = 1;
   1964 out:
   1965 	cb->args[0] = done;
   1966 	cb->args[1] = last_addr;
   1967 	rcu_read_unlock();
   1968 
   1969 	return skb->len;
   1970 }
   1971 
   1972 /* tipc_node_find_by_name - locate owner node of link by link's name
   1973  * @net: the applicable net namespace
   1974  * @name: pointer to link name string
   1975  * @bearer_id: pointer to index in 'node->links' array where the link was found.
   1976  *
   1977  * Returns pointer to node owning the link, or 0 if no matching link is found.
   1978  */
   1979 static struct tipc_node *tipc_node_find_by_name(struct net *net,
   1980 						const char *link_name,
   1981 						unsigned int *bearer_id)
   1982 {
   1983 	struct tipc_net *tn = net_generic(net, tipc_net_id);
   1984 	struct tipc_link *l;
   1985 	struct tipc_node *n;
   1986 	struct tipc_node *found_node = NULL;
   1987 	int i;
   1988 
   1989 	*bearer_id = 0;
   1990 	rcu_read_lock();
   1991 	list_for_each_entry_rcu(n, &tn->node_list, list) {
   1992 		tipc_node_read_lock(n);
   1993 		for (i = 0; i < MAX_BEARERS; i++) {
   1994 			l = n->links[i].link;
   1995 			if (l && !strcmp(tipc_link_name(l), link_name)) {
   1996 				*bearer_id = i;
   1997 				found_node = n;
   1998 				break;
   1999 			}
   2000 		}
   2001 		tipc_node_read_unlock(n);
   2002 		if (found_node)
   2003 			break;
   2004 	}
   2005 	rcu_read_unlock();
   2006 
   2007 	return found_node;
   2008 }
   2009 
   2010 int tipc_nl_node_set_link(struct sk_buff *skb, struct genl_info *info)
   2011 {
   2012 	int err;
   2013 	int res = 0;
   2014 	int bearer_id;
   2015 	char *name;
   2016 	struct tipc_link *link;
   2017 	struct tipc_node *node;
   2018 	struct sk_buff_head xmitq;
   2019 	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
   2020 	struct net *net = sock_net(skb->sk);
   2021 
   2022 	__skb_queue_head_init(&xmitq);
   2023 
   2024 	if (!info->attrs[TIPC_NLA_LINK])
   2025 		return -EINVAL;
   2026 
   2027 	err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
   2028 			       info->attrs[TIPC_NLA_LINK],
   2029 			       tipc_nl_link_policy, info->extack);
   2030 	if (err)
   2031 		return err;
   2032 
   2033 	if (!attrs[TIPC_NLA_LINK_NAME])
   2034 		return -EINVAL;
   2035 
   2036 	name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
   2037 
   2038 	if (strcmp(name, tipc_bclink_name) == 0)
   2039 		return tipc_nl_bc_link_set(net, attrs);
   2040 
   2041 	node = tipc_node_find_by_name(net, name, &bearer_id);
   2042 	if (!node)
   2043 		return -EINVAL;
   2044 
   2045 	tipc_node_read_lock(node);
   2046 
   2047 	link = node->links[bearer_id].link;
   2048 	if (!link) {
   2049 		res = -EINVAL;
   2050 		goto out;
   2051 	}
   2052 
   2053 	if (attrs[TIPC_NLA_LINK_PROP]) {
   2054 		struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
   2055 
   2056 		err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP],
   2057 					      props);
   2058 		if (err) {
   2059 			res = err;
   2060 			goto out;
   2061 		}
   2062 
   2063 		if (props[TIPC_NLA_PROP_TOL]) {
   2064 			u32 tol;
   2065 
   2066 			tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
   2067 			tipc_link_set_tolerance(link, tol, &xmitq);
   2068 		}
   2069 		if (props[TIPC_NLA_PROP_PRIO]) {
   2070 			u32 prio;
   2071 
   2072 			prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
   2073 			tipc_link_set_prio(link, prio, &xmitq);
   2074 		}
   2075 		if (props[TIPC_NLA_PROP_WIN]) {
   2076 			u32 win;
   2077 
   2078 			win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
   2079 			tipc_link_set_queue_limits(link, win);
   2080 		}
   2081 	}
   2082 
   2083 out:
   2084 	tipc_node_read_unlock(node);
   2085 	tipc_bearer_xmit(net, bearer_id, &xmitq, &node->links[bearer_id].maddr);
   2086 	return res;
   2087 }
   2088 
   2089 int tipc_nl_node_get_link(struct sk_buff *skb, struct genl_info *info)
   2090 {
   2091 	struct net *net = genl_info_net(info);
   2092 	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
   2093 	struct tipc_nl_msg msg;
   2094 	char *name;
   2095 	int err;
   2096 
   2097 	msg.portid = info->snd_portid;
   2098 	msg.seq = info->snd_seq;
   2099 
   2100 	if (!info->attrs[TIPC_NLA_LINK])
   2101 		return -EINVAL;
   2102 
   2103 	err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
   2104 			       info->attrs[TIPC_NLA_LINK],
   2105 			       tipc_nl_link_policy, info->extack);
   2106 	if (err)
   2107 		return err;
   2108 
   2109 	if (!attrs[TIPC_NLA_LINK_NAME])
   2110 		return -EINVAL;
   2111 
   2112 	name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
   2113 
   2114 	msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
   2115 	if (!msg.skb)
   2116 		return -ENOMEM;
   2117 
   2118 	if (strcmp(name, tipc_bclink_name) == 0) {
   2119 		err = tipc_nl_add_bc_link(net, &msg);
   2120 		if (err)
   2121 			goto err_free;
   2122 	} else {
   2123 		int bearer_id;
   2124 		struct tipc_node *node;
   2125 		struct tipc_link *link;
   2126 
   2127 		node = tipc_node_find_by_name(net, name, &bearer_id);
   2128 		if (!node) {
   2129 			err = -EINVAL;
   2130 			goto err_free;
   2131 		}
   2132 
   2133 		tipc_node_read_lock(node);
   2134 		link = node->links[bearer_id].link;
   2135 		if (!link) {
   2136 			tipc_node_read_unlock(node);
   2137 			err = -EINVAL;
   2138 			goto err_free;
   2139 		}
   2140 
   2141 		err = __tipc_nl_add_link(net, &msg, link, 0);
   2142 		tipc_node_read_unlock(node);
   2143 		if (err)
   2144 			goto err_free;
   2145 	}
   2146 
   2147 	return genlmsg_reply(msg.skb, info);
   2148 
   2149 err_free:
   2150 	nlmsg_free(msg.skb);
   2151 	return err;
   2152 }
   2153 
   2154 int tipc_nl_node_reset_link_stats(struct sk_buff *skb, struct genl_info *info)
   2155 {
   2156 	int err;
   2157 	char *link_name;
   2158 	unsigned int bearer_id;
   2159 	struct tipc_link *link;
   2160 	struct tipc_node *node;
   2161 	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
   2162 	struct net *net = sock_net(skb->sk);
   2163 	struct tipc_link_entry *le;
   2164 
   2165 	if (!info->attrs[TIPC_NLA_LINK])
   2166 		return -EINVAL;
   2167 
   2168 	err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
   2169 			       info->attrs[TIPC_NLA_LINK],
   2170 			       tipc_nl_link_policy, info->extack);
   2171 	if (err)
   2172 		return err;
   2173 
   2174 	if (!attrs[TIPC_NLA_LINK_NAME])
   2175 		return -EINVAL;
   2176 
   2177 	link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
   2178 
   2179 	if (strcmp(link_name, tipc_bclink_name) == 0) {
   2180 		err = tipc_bclink_reset_stats(net);
   2181 		if (err)
   2182 			return err;
   2183 		return 0;
   2184 	}
   2185 
   2186 	node = tipc_node_find_by_name(net, link_name, &bearer_id);
   2187 	if (!node)
   2188 		return -EINVAL;
   2189 
   2190 	le = &node->links[bearer_id];
   2191 	tipc_node_read_lock(node);
   2192 	spin_lock_bh(&le->lock);
   2193 	link = node->links[bearer_id].link;
   2194 	if (!link) {
   2195 		spin_unlock_bh(&le->lock);
   2196 		tipc_node_read_unlock(node);
   2197 		return -EINVAL;
   2198 	}
   2199 	tipc_link_reset_stats(link);
   2200 	spin_unlock_bh(&le->lock);
   2201 	tipc_node_read_unlock(node);
   2202 	return 0;
   2203 }
   2204 
   2205 /* Caller should hold node lock  */
   2206 static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg,
   2207 				    struct tipc_node *node, u32 *prev_link)
   2208 {
   2209 	u32 i;
   2210 	int err;
   2211 
   2212 	for (i = *prev_link; i < MAX_BEARERS; i++) {
   2213 		*prev_link = i;
   2214 
   2215 		if (!node->links[i].link)
   2216 			continue;
   2217 
   2218 		err = __tipc_nl_add_link(net, msg,
   2219 					 node->links[i].link, NLM_F_MULTI);
   2220 		if (err)
   2221 			return err;
   2222 	}
   2223 	*prev_link = 0;
   2224 
   2225 	return 0;
   2226 }
   2227 
   2228 int tipc_nl_node_dump_link(struct sk_buff *skb, struct netlink_callback *cb)
   2229 {
   2230 	struct net *net = sock_net(skb->sk);
   2231 	struct tipc_net *tn = net_generic(net, tipc_net_id);
   2232 	struct tipc_node *node;
   2233 	struct tipc_nl_msg msg;
   2234 	u32 prev_node = cb->args[0];
   2235 	u32 prev_link = cb->args[1];
   2236 	int done = cb->args[2];
   2237 	int err;
   2238 
   2239 	if (done)
   2240 		return 0;
   2241 
   2242 	msg.skb = skb;
   2243 	msg.portid = NETLINK_CB(cb->skb).portid;
   2244 	msg.seq = cb->nlh->nlmsg_seq;
   2245 
   2246 	rcu_read_lock();
   2247 	if (prev_node) {
   2248 		node = tipc_node_find(net, prev_node);
   2249 		if (!node) {
   2250 			/* We never set seq or call nl_dump_check_consistent()
   2251 			 * this means that setting prev_seq here will cause the
   2252 			 * consistence check to fail in the netlink callback
   2253 			 * handler. Resulting in the last NLMSG_DONE message
   2254 			 * having the NLM_F_DUMP_INTR flag set.
   2255 			 */
   2256 			cb->prev_seq = 1;
   2257 			goto out;
   2258 		}
   2259 		tipc_node_put(node);
   2260 
   2261 		list_for_each_entry_continue_rcu(node, &tn->node_list,
   2262 						 list) {
   2263 			tipc_node_read_lock(node);
   2264 			err = __tipc_nl_add_node_links(net, &msg, node,
   2265 						       &prev_link);
   2266 			tipc_node_read_unlock(node);
   2267 			if (err)
   2268 				goto out;
   2269 
   2270 			prev_node = node->addr;
   2271 		}
   2272 	} else {
   2273 		err = tipc_nl_add_bc_link(net, &msg);
   2274 		if (err)
   2275 			goto out;
   2276 
   2277 		list_for_each_entry_rcu(node, &tn->node_list, list) {
   2278 			tipc_node_read_lock(node);
   2279 			err = __tipc_nl_add_node_links(net, &msg, node,
   2280 						       &prev_link);
   2281 			tipc_node_read_unlock(node);
   2282 			if (err)
   2283 				goto out;
   2284 
   2285 			prev_node = node->addr;
   2286 		}
   2287 	}
   2288 	done = 1;
   2289 out:
   2290 	rcu_read_unlock();
   2291 
   2292 	cb->args[0] = prev_node;
   2293 	cb->args[1] = prev_link;
   2294 	cb->args[2] = done;
   2295 
   2296 	return skb->len;
   2297 }
   2298 
   2299 int tipc_nl_node_set_monitor(struct sk_buff *skb, struct genl_info *info)
   2300 {
   2301 	struct nlattr *attrs[TIPC_NLA_MON_MAX + 1];
   2302 	struct net *net = sock_net(skb->sk);
   2303 	int err;
   2304 
   2305 	if (!info->attrs[TIPC_NLA_MON])
   2306 		return -EINVAL;
   2307 
   2308 	err = nla_parse_nested(attrs, TIPC_NLA_MON_MAX,
   2309 			       info->attrs[TIPC_NLA_MON],
   2310 			       tipc_nl_monitor_policy, info->extack);
   2311 	if (err)
   2312 		return err;
   2313 
   2314 	if (attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]) {
   2315 		u32 val;
   2316 
   2317 		val = nla_get_u32(attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]);
   2318 		err = tipc_nl_monitor_set_threshold(net, val);
   2319 		if (err)
   2320 			return err;
   2321 	}
   2322 
   2323 	return 0;
   2324 }
   2325 
   2326 static int __tipc_nl_add_monitor_prop(struct net *net, struct tipc_nl_msg *msg)
   2327 {
   2328 	struct nlattr *attrs;
   2329 	void *hdr;
   2330 	u32 val;
   2331 
   2332 	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
   2333 			  0, TIPC_NL_MON_GET);
   2334 	if (!hdr)
   2335 		return -EMSGSIZE;
   2336 
   2337 	attrs = nla_nest_start(msg->skb, TIPC_NLA_MON);
   2338 	if (!attrs)
   2339 		goto msg_full;
   2340 
   2341 	val = tipc_nl_monitor_get_threshold(net);
   2342 
   2343 	if (nla_put_u32(msg->skb, TIPC_NLA_MON_ACTIVATION_THRESHOLD, val))
   2344 		goto attr_msg_full;
   2345 
   2346 	nla_nest_end(msg->skb, attrs);
   2347 	genlmsg_end(msg->skb, hdr);
   2348 
   2349 	return 0;
   2350 
   2351 attr_msg_full:
   2352 	nla_nest_cancel(msg->skb, attrs);
   2353 msg_full:
   2354 	genlmsg_cancel(msg->skb, hdr);
   2355 
   2356 	return -EMSGSIZE;
   2357 }
   2358 
   2359 int tipc_nl_node_get_monitor(struct sk_buff *skb, struct genl_info *info)
   2360 {
   2361 	struct net *net = sock_net(skb->sk);
   2362 	struct tipc_nl_msg msg;
   2363 	int err;
   2364 
   2365 	msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
   2366 	if (!msg.skb)
   2367 		return -ENOMEM;
   2368 	msg.portid = info->snd_portid;
   2369 	msg.seq = info->snd_seq;
   2370 
   2371 	err = __tipc_nl_add_monitor_prop(net, &msg);
   2372 	if (err) {
   2373 		nlmsg_free(msg.skb);
   2374 		return err;
   2375 	}
   2376 
   2377 	return genlmsg_reply(msg.skb, info);
   2378 }
   2379 
   2380 int tipc_nl_node_dump_monitor(struct sk_buff *skb, struct netlink_callback *cb)
   2381 {
   2382 	struct net *net = sock_net(skb->sk);
   2383 	u32 prev_bearer = cb->args[0];
   2384 	struct tipc_nl_msg msg;
   2385 	int bearer_id;
   2386 	int err;
   2387 
   2388 	if (prev_bearer == MAX_BEARERS)
   2389 		return 0;
   2390 
   2391 	msg.skb = skb;
   2392 	msg.portid = NETLINK_CB(cb->skb).portid;
   2393 	msg.seq = cb->nlh->nlmsg_seq;
   2394 
   2395 	rtnl_lock();
   2396 	for (bearer_id = prev_bearer; bearer_id < MAX_BEARERS; bearer_id++) {
   2397 		err = __tipc_nl_add_monitor(net, &msg, bearer_id);
   2398 		if (err)
   2399 			break;
   2400 	}
   2401 	rtnl_unlock();
   2402 	cb->args[0] = bearer_id;
   2403 
   2404 	return skb->len;
   2405 }
   2406 
   2407 int tipc_nl_node_dump_monitor_peer(struct sk_buff *skb,
   2408 				   struct netlink_callback *cb)
   2409 {
   2410 	struct net *net = sock_net(skb->sk);
   2411 	u32 prev_node = cb->args[1];
   2412 	u32 bearer_id = cb->args[2];
   2413 	int done = cb->args[0];
   2414 	struct tipc_nl_msg msg;
   2415 	int err;
   2416 
   2417 	if (!prev_node) {
   2418 		struct nlattr **attrs;
   2419 		struct nlattr *mon[TIPC_NLA_MON_MAX + 1];
   2420 
   2421 		err = tipc_nlmsg_parse(cb->nlh, &attrs);
   2422 		if (err)
   2423 			return err;
   2424 
   2425 		if (!attrs[TIPC_NLA_MON])
   2426 			return -EINVAL;
   2427 
   2428 		err = nla_parse_nested(mon, TIPC_NLA_MON_MAX,
   2429 				       attrs[TIPC_NLA_MON],
   2430 				       tipc_nl_monitor_policy, NULL);
   2431 		if (err)
   2432 			return err;
   2433 
   2434 		if (!mon[TIPC_NLA_MON_REF])
   2435 			return -EINVAL;
   2436 
   2437 		bearer_id = nla_get_u32(mon[TIPC_NLA_MON_REF]);
   2438 
   2439 		if (bearer_id >= MAX_BEARERS)
   2440 			return -EINVAL;
   2441 	}
   2442 
   2443 	if (done)
   2444 		return 0;
   2445 
   2446 	msg.skb = skb;
   2447 	msg.portid = NETLINK_CB(cb->skb).portid;
   2448 	msg.seq = cb->nlh->nlmsg_seq;
   2449 
   2450 	rtnl_lock();
   2451 	err = tipc_nl_add_monitor_peer(net, &msg, bearer_id, &prev_node);
   2452 	if (!err)
   2453 		done = 1;
   2454 
   2455 	rtnl_unlock();
   2456 	cb->args[0] = done;
   2457 	cb->args[1] = prev_node;
   2458 	cb->args[2] = bearer_id;
   2459 
   2460 	return skb->len;
   2461 }
   2462 
   2463 u32 tipc_node_get_addr(struct tipc_node *node)
   2464 {
   2465 	return (node) ? node->addr : 0;
   2466 }
   2467 
   2468 /**
   2469  * tipc_node_dump - dump TIPC node data
   2470  * @n: tipc node to be dumped
   2471  * @more: dump more?
   2472  *        - false: dump only tipc node data
   2473  *        - true: dump node link data as well
   2474  * @buf: returned buffer of dump data in format
   2475  */
   2476 int tipc_node_dump(struct tipc_node *n, bool more, char *buf)
   2477 {
   2478 	int i = 0;
   2479 	size_t sz = (more) ? NODE_LMAX : NODE_LMIN;
   2480 
   2481 	if (!n) {
   2482 		i += scnprintf(buf, sz, "node data: (null)\n");
   2483 		return i;
   2484 	}
   2485 
   2486 	i += scnprintf(buf, sz, "node data: %x", n->addr);
   2487 	i += scnprintf(buf + i, sz - i, " %x", n->state);
   2488 	i += scnprintf(buf + i, sz - i, " %d", n->active_links[0]);
   2489 	i += scnprintf(buf + i, sz - i, " %d", n->active_links[1]);
   2490 	i += scnprintf(buf + i, sz - i, " %x", n->action_flags);
   2491 	i += scnprintf(buf + i, sz - i, " %u", n->failover_sent);
   2492 	i += scnprintf(buf + i, sz - i, " %u", n->sync_point);
   2493 	i += scnprintf(buf + i, sz - i, " %d", n->link_cnt);
   2494 	i += scnprintf(buf + i, sz - i, " %u", n->working_links);
   2495 	i += scnprintf(buf + i, sz - i, " %x", n->capabilities);
   2496 	i += scnprintf(buf + i, sz - i, " %lu\n", n->keepalive_intv);
   2497 
   2498 	if (!more)
   2499 		return i;
   2500 
   2501 	i += scnprintf(buf + i, sz - i, "link_entry[0]:\n");
   2502 	i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[0].mtu);
   2503 	i += scnprintf(buf + i, sz - i, " media: ");
   2504 	i += tipc_media_addr_printf(buf + i, sz - i, &n->links[0].maddr);
   2505 	i += scnprintf(buf + i, sz - i, "\n");
   2506 	i += tipc_link_dump(n->links[0].link, TIPC_DUMP_NONE, buf + i);
   2507 	i += scnprintf(buf + i, sz - i, " inputq: ");
   2508 	i += tipc_list_dump(&n->links[0].inputq, false, buf + i);
   2509 
   2510 	i += scnprintf(buf + i, sz - i, "link_entry[1]:\n");
   2511 	i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[1].mtu);
   2512 	i += scnprintf(buf + i, sz - i, " media: ");
   2513 	i += tipc_media_addr_printf(buf + i, sz - i, &n->links[1].maddr);
   2514 	i += scnprintf(buf + i, sz - i, "\n");
   2515 	i += tipc_link_dump(n->links[1].link, TIPC_DUMP_NONE, buf + i);
   2516 	i += scnprintf(buf + i, sz - i, " inputq: ");
   2517 	i += tipc_list_dump(&n->links[1].inputq, false, buf + i);
   2518 
   2519 	i += scnprintf(buf + i, sz - i, "bclink:\n ");
   2520 	i += tipc_link_dump(n->bc_entry.link, TIPC_DUMP_NONE, buf + i);
   2521 
   2522 	return i;
   2523 }