~hc/RK356X_SDK_RELEASE.git

..	..	@@ -43,6 +43,8 @@
43	43	#include "monitor.h"
44	44	#include "discover.h"
45	45	#include "netlink.h"
	46	+#include "trace.h"
	47	+#include "crypto.h"
46	48
47	49	#define INVALID_NODE_SIG 0x10000
48	50	#define NODE_CLEANUP_AFTER 300000
..	..	@@ -73,6 +75,8 @@
73	75	struct sk_buff_head arrvq;
74	76	struct sk_buff_head inputq2;
75	77	struct sk_buff_head namedq;
	78	+ u16 named_rcv_nxt;
	79	+ bool named_open;
76	80	};
77	81
78	82	/**
..	..	@@ -88,6 +92,7 @@
88	92	* @links: array containing references to all links to node
89	93	* @action_flags: bit mask of different types of node actions
90	94	* @state: connectivity state vs peer node
	95	+ * @preliminary: a preliminary node or not
91	96	* @sync_point: sequence number where synch/failover is finished
92	97	* @list: links to adjacent nodes in sorted list of cluster's nodes
93	98	* @working_links: number of working links to node (both active and standby)
..	..	@@ -98,6 +103,7 @@
98	103	* @publ_list: list of publications
99	104	* @rcu: rcu struct for tipc_node
100	105	* @delete_at: indicates the time for deleting a down node
	106	+ * @crypto_rx: RX crypto handler
101	107	*/
102	108	struct tipc_node {
103	109	u32 addr;
..	..	@@ -111,6 +117,7 @@
111	117	int action_flags;
112	118	struct list_head list;
113	119	int state;
	120	+ bool preliminary;
114	121	bool failover_sent;
115	122	u16 sync_point;
116	123	int link_cnt;
..	..	@@ -119,12 +126,18 @@
119	126	u32 signature;
120	127	u32 link_id;
121	128	u8 peer_id[16];
	129	+ char peer_id_string[NODE_ID_STR_LEN];
122	130	struct list_head publ_list;
123	131	struct list_head conn_sks;
124	132	unsigned long keepalive_intv;
125	133	struct timer_list timer;
126	134	struct rcu_head rcu;
127	135	unsigned long delete_at;
	136	+ struct net *peer_net;
	137	+ u32 peer_hash_mix;
	138	+#ifdef CONFIG_TIPC_CRYPTO
	139	+ struct tipc_crypto *crypto_rx;
	140	+#endif
128	141	};
129	142
130	143	/* Node FSM states and events:
..	..	@@ -162,7 +175,6 @@
162	175	static void tipc_node_fsm_evt(struct tipc_node *n, int evt);
163	176	static struct tipc_node tipc_node_find(struct net net, u32 addr);
164	177	static struct tipc_node tipc_node_find_by_id(struct net net, u8 *id);
165		-static void tipc_node_put(struct tipc_node *node);
166	178	static bool node_is_up(struct tipc_node *n);
167	179	static void tipc_node_delete_from_list(struct tipc_node *node);
168	180
..	..	@@ -183,7 +195,7 @@
183	195	return n->links[bearer_id].link;
184	196	}
185	197
186		-int tipc_node_get_mtu(struct net *net, u32 addr, u32 sel)
	198	+int tipc_node_get_mtu(struct net *net, u32 addr, u32 sel, bool connected)
187	199	{
188	200	struct tipc_node *n;
189	201	int bearer_id;
..	..	@@ -192,6 +204,14 @@
192	204	n = tipc_node_find(net, addr);
193	205	if (unlikely(!n))
194	206	return mtu;
	207	+
	208	+ /* Allow MAX_MSG_SIZE when building connection oriented message
	209	+ * if they are in the same core network
	210	+ */
	211	+ if (n->peer_net && connected) {
	212	+ tipc_node_put(n);
	213	+ return mtu;
	214	+ }
195	215
196	216	bearer_id = n->active_links[sel & 1];
197	217	if (likely(bearer_id != INVALID_BEARER_ID))
..	..	@@ -234,20 +254,64 @@
234	254	return caps;
235	255	}
236	256
	257	+u32 tipc_node_get_addr(struct tipc_node *node)
	258	+{
	259	+ return (node) ? node->addr : 0;
	260	+}
	261	+
	262	+char tipc_node_get_id_str(struct tipc_node node)
	263	+{
	264	+ return node->peer_id_string;
	265	+}
	266	+
	267	+#ifdef CONFIG_TIPC_CRYPTO
	268	+/**
	269	+ * tipc_node_crypto_rx - Retrieve crypto RX handle from node
	270	+ * Note: node ref counter must be held first!
	271	+ */
	272	+struct tipc_crypto tipc_node_crypto_rx(struct tipc_node __n)
	273	+{
	274	+ return (__n) ? __n->crypto_rx : NULL;
	275	+}
	276	+
	277	+struct tipc_crypto tipc_node_crypto_rx_by_list(struct list_head pos)
	278	+{
	279	+ return container_of(pos, struct tipc_node, list)->crypto_rx;
	280	+}
	281	+
	282	+struct tipc_crypto tipc_node_crypto_rx_by_addr(struct net net, u32 addr)
	283	+{
	284	+ struct tipc_node *n;
	285	+
	286	+ n = tipc_node_find(net, addr);
	287	+ return (n) ? n->crypto_rx : NULL;
	288	+}
	289	+#endif
	290	+
	291	+static void tipc_node_free(struct rcu_head *rp)
	292	+{
	293	+ struct tipc_node *n = container_of(rp, struct tipc_node, rcu);
	294	+
	295	+#ifdef CONFIG_TIPC_CRYPTO
	296	+ tipc_crypto_stop(&n->crypto_rx);
	297	+#endif
	298	+ kfree(n);
	299	+}
	300	+
237	301	static void tipc_node_kref_release(struct kref *kref)
238	302	{
239	303	struct tipc_node *n = container_of(kref, struct tipc_node, kref);
240	304
241	305	kfree(n->bc_entry.link);
242		- kfree_rcu(n, rcu);
	306	+ call_rcu(&n->rcu, tipc_node_free);
243	307	}
244	308
245		-static void tipc_node_put(struct tipc_node *node)
	309	+void tipc_node_put(struct tipc_node *node)
246	310	{
247	311	kref_put(&node->kref, tipc_node_kref_release);
248	312	}
249	313
250		-static void tipc_node_get(struct tipc_node *node)
	314	+void tipc_node_get(struct tipc_node *node)
251	315	{
252	316	kref_get(&node->kref);
253	317	}
..	..	@@ -263,7 +327,7 @@
263	327
264	328	rcu_read_lock();
265	329	hlist_for_each_entry_rcu(node, &tn->node_htable[thash], hash) {
266		- if (node->addr != addr)
	330	+ if (node->addr != addr \|\| node->preliminary)
267	331	continue;
268	332	if (!kref_get_unless_zero(&node->kref))
269	333	node = NULL;
..	..	@@ -342,10 +406,10 @@
342	406	write_unlock_bh(&n->lock);
343	407
344	408	if (flags & TIPC_NOTIFY_NODE_DOWN)
345		- tipc_publ_notify(net, publ_list, addr);
	409	+ tipc_publ_notify(net, publ_list, addr, n->capabilities);
346	410
347	411	if (flags & TIPC_NOTIFY_NODE_UP)
348		- tipc_named_node_up(net, addr);
	412	+ tipc_named_node_up(net, addr, n->capabilities);
349	413
350	414	if (flags & TIPC_NOTIFY_LINK_UP) {
351	415	tipc_mon_peer_up(net, addr, bearer_id);
..	..	@@ -359,29 +423,102 @@
359	423	}
360	424	}
361	425
362		-static struct tipc_node tipc_node_create(struct net net, u32 addr,
363		- u8 *peer_id, u16 capabilities)
	426	+static void tipc_node_assign_peer_net(struct tipc_node *n, u32 hash_mixes)
	427	+{
	428	+ int net_id = tipc_netid(n->net);
	429	+ struct tipc_net *tn_peer;
	430	+ struct net *tmp;
	431	+ u32 hash_chk;
	432	+
	433	+ if (n->peer_net)
	434	+ return;
	435	+
	436	+ for_each_net_rcu(tmp) {
	437	+ tn_peer = tipc_net(tmp);
	438	+ if (!tn_peer)
	439	+ continue;
	440	+ /* Integrity checking whether node exists in namespace or not */
	441	+ if (tn_peer->net_id != net_id)
	442	+ continue;
	443	+ if (memcmp(n->peer_id, tn_peer->node_id, NODE_ID_LEN))
	444	+ continue;
	445	+ hash_chk = tipc_net_hash_mixes(tmp, tn_peer->random);
	446	+ if (hash_mixes ^ hash_chk)
	447	+ continue;
	448	+ n->peer_net = tmp;
	449	+ n->peer_hash_mix = hash_mixes;
	450	+ break;
	451	+ }
	452	+}
	453	+
	454	+struct tipc_node tipc_node_create(struct net net, u32 addr, u8 *peer_id,
	455	+ u16 capabilities, u32 hash_mixes,
	456	+ bool preliminary)
364	457	{
365	458	struct tipc_net *tn = net_generic(net, tipc_net_id);
	459	+ struct tipc_link l, snd_l = tipc_bc_sndlink(net);
366	460	struct tipc_node n, temp_node;
367		- struct tipc_link *l;
	461	+ unsigned long intv;
368	462	int bearer_id;
369	463	int i;
370	464
371	465	spin_lock_bh(&tn->node_list_lock);
372		- n = tipc_node_find(net, addr);
	466	+ n = tipc_node_find(net, addr) ?:
	467	+ tipc_node_find_by_id(net, peer_id);
373	468	if (n) {
	469	+ if (!n->preliminary)
	470	+ goto update;
	471	+ if (preliminary)
	472	+ goto exit;
	473	+ /* A preliminary node becomes "real" now, refresh its data */
	474	+ tipc_node_write_lock(n);
	475	+ if (!tipc_link_bc_create(net, tipc_own_addr(net), addr, peer_id, U16_MAX,
	476	+ tipc_link_min_win(snd_l), tipc_link_max_win(snd_l),
	477	+ n->capabilities, &n->bc_entry.inputq1,
	478	+ &n->bc_entry.namedq, snd_l, &n->bc_entry.link)) {
	479	+ pr_warn("Broadcast rcv link refresh failed, no memory\n");
	480	+ tipc_node_write_unlock_fast(n);
	481	+ tipc_node_put(n);
	482	+ n = NULL;
	483	+ goto exit;
	484	+ }
	485	+ n->preliminary = false;
	486	+ n->addr = addr;
	487	+ hlist_del_rcu(&n->hash);
	488	+ hlist_add_head_rcu(&n->hash,
	489	+ &tn->node_htable[tipc_hashfn(addr)]);
	490	+ list_del_rcu(&n->list);
	491	+ list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
	492	+ if (n->addr < temp_node->addr)
	493	+ break;
	494	+ }
	495	+ list_add_tail_rcu(&n->list, &temp_node->list);
	496	+ tipc_node_write_unlock_fast(n);
	497	+
	498	+update:
	499	+ if (n->peer_hash_mix ^ hash_mixes)
	500	+ tipc_node_assign_peer_net(n, hash_mixes);
374	501	if (n->capabilities == capabilities)
375	502	goto exit;
376	503	/* Same node may come back with new capabilities */
377		- write_lock_bh(&n->lock);
	504	+ tipc_node_write_lock(n);
378	505	n->capabilities = capabilities;
379	506	for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {
380	507	l = n->links[bearer_id].link;
381	508	if (l)
382	509	tipc_link_update_caps(l, capabilities);
383	510	}
384		- write_unlock_bh(&n->lock);
	511	+ tipc_node_write_unlock_fast(n);
	512	+
	513	+ /* Calculate cluster capabilities */
	514	+ tn->capabilities = TIPC_NODE_CAPABILITIES;
	515	+ list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
	516	+ tn->capabilities &= temp_node->capabilities;
	517	+ }
	518	+
	519	+ tipc_bcast_toggle_rcast(net,
	520	+ (tn->capabilities & TIPC_BCAST_RCAST));
	521	+
385	522	goto exit;
386	523	}
387	524	n = kzalloc(sizeof(*n), GFP_ATOMIC);
..	..	@@ -389,9 +526,23 @@
389	526	pr_warn("Node creation failed, no memory\n");
390	527	goto exit;
391	528	}
	529	+ tipc_nodeid2string(n->peer_id_string, peer_id);
	530	+#ifdef CONFIG_TIPC_CRYPTO
	531	+ if (unlikely(tipc_crypto_start(&n->crypto_rx, net, n))) {
	532	+ pr_warn("Failed to start crypto RX(%s)!\n", n->peer_id_string);
	533	+ kfree(n);
	534	+ n = NULL;
	535	+ goto exit;
	536	+ }
	537	+#endif
392	538	n->addr = addr;
	539	+ n->preliminary = preliminary;
393	540	memcpy(&n->peer_id, peer_id, 16);
394	541	n->net = net;
	542	+ n->peer_net = NULL;
	543	+ n->peer_hash_mix = 0;
	544	+ /* Assign kernel local namespace if exists */
	545	+ tipc_node_assign_peer_net(n, hash_mixes);
395	546	n->capabilities = capabilities;
396	547	kref_init(&n->kref);
397	548	rwlock_init(&n->lock);
..	..	@@ -410,14 +561,11 @@
410	561	n->signature = INVALID_NODE_SIG;
411	562	n->active_links[0] = INVALID_BEARER_ID;
412	563	n->active_links[1] = INVALID_BEARER_ID;
413		- if (!tipc_link_bc_create(net, tipc_own_addr(net),
414		- addr, U16_MAX,
415		- tipc_link_window(tipc_bc_sndlink(net)),
416		- n->capabilities,
417		- &n->bc_entry.inputq1,
418		- &n->bc_entry.namedq,
419		- tipc_bc_sndlink(net),
420		- &n->bc_entry.link)) {
	564	+ if (!preliminary &&
	565	+ !tipc_link_bc_create(net, tipc_own_addr(net), addr, peer_id, U16_MAX,
	566	+ tipc_link_min_win(snd_l), tipc_link_max_win(snd_l),
	567	+ n->capabilities, &n->bc_entry.inputq1,
	568	+ &n->bc_entry.namedq, snd_l, &n->bc_entry.link)) {
421	569	pr_warn("Broadcast rcv link creation failed, no memory\n");
422	570	kfree(n);
423	571	n = NULL;
..	..	@@ -425,13 +573,24 @@
425	573	}
426	574	tipc_node_get(n);
427	575	timer_setup(&n->timer, tipc_node_timeout, 0);
428		- n->keepalive_intv = U32_MAX;
	576	+ /* Start a slow timer anyway, crypto needs it */
	577	+ n->keepalive_intv = 10000;
	578	+ intv = jiffies + msecs_to_jiffies(n->keepalive_intv);
	579	+ if (!mod_timer(&n->timer, intv))
	580	+ tipc_node_get(n);
429	581	hlist_add_head_rcu(&n->hash, &tn->node_htable[tipc_hashfn(addr)]);
430	582	list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
431	583	if (n->addr < temp_node->addr)
432	584	break;
433	585	}
434	586	list_add_tail_rcu(&n->list, &temp_node->list);
	587	+ /* Calculate cluster capabilities */
	588	+ tn->capabilities = TIPC_NODE_CAPABILITIES;
	589	+ list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
	590	+ tn->capabilities &= temp_node->capabilities;
	591	+ }
	592	+ tipc_bcast_toggle_rcast(net, (tn->capabilities & TIPC_BCAST_RCAST));
	593	+ trace_tipc_node_create(n, true, " ");
435	594	exit:
436	595	spin_unlock_bh(&tn->node_list_lock);
437	596	return n;
..	..	@@ -452,6 +611,9 @@
452	611
453	612	static void tipc_node_delete_from_list(struct tipc_node *node)
454	613	{
	614	+#ifdef CONFIG_TIPC_CRYPTO
	615	+ tipc_crypto_key_flush(node->crypto_rx);
	616	+#endif
455	617	list_del_rcu(&node->list);
456	618	hlist_del_rcu(&node->hash);
457	619	tipc_node_put(node);
..	..	@@ -459,6 +621,7 @@
459	621
460	622	static void tipc_node_delete(struct tipc_node *node)
461	623	{
	624	+ trace_tipc_node_delete(node, true, " ");
462	625	tipc_node_delete_from_list(node);
463	626
464	627	del_timer_sync(&node->timer);
..	..	@@ -586,6 +749,7 @@
586	749	*/
587	750	static bool tipc_node_cleanup(struct tipc_node *peer)
588	751	{
	752	+ struct tipc_node *temp_node;
589	753	struct tipc_net *tn = tipc_net(peer->net);
590	754	bool deleted = false;
591	755
..	..	@@ -601,6 +765,19 @@
601	765	deleted = true;
602	766	}
603	767	tipc_node_write_unlock(peer);
	768	+
	769	+ if (!deleted) {
	770	+ spin_unlock_bh(&tn->node_list_lock);
	771	+ return deleted;
	772	+ }
	773	+
	774	+ /* Calculate cluster capabilities */
	775	+ tn->capabilities = TIPC_NODE_CAPABILITIES;
	776	+ list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
	777	+ tn->capabilities &= temp_node->capabilities;
	778	+ }
	779	+ tipc_bcast_toggle_rcast(peer->net,
	780	+ (tn->capabilities & TIPC_BCAST_RCAST));
604	781	spin_unlock_bh(&tn->node_list_lock);
605	782	return deleted;
606	783	}
..	..	@@ -616,12 +793,17 @@
616	793	int bearer_id;
617	794	int rc = 0;
618	795
	796	+ trace_tipc_node_timeout(n, false, " ");
619	797	if (!node_is_up(n) && tipc_node_cleanup(n)) {
620	798	/Removing the reference of Timer/
621	799	tipc_node_put(n);
622	800	return;
623	801	}
624	802
	803	+#ifdef CONFIG_TIPC_CRYPTO
	804	+ /* Take any crypto key related actions first */
	805	+ tipc_crypto_timeout(n->crypto_rx);
	806	+#endif
625	807	__skb_queue_head_init(&xmitq);
626	808
627	809	/* Initial node interval to value larger (10 seconds), then it will be
..	..	@@ -642,7 +824,7 @@
642	824	remains--;
643	825	}
644	826	tipc_node_read_unlock(n);
645		- tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr);
	827	+ tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr, n);
646	828	if (rc & TIPC_LINK_DOWN_EVT)
647	829	tipc_node_link_down(n, bearer_id, false);
648	830	}
..	..	@@ -674,13 +856,14 @@
674	856	n->link_id = tipc_link_id(nl);
675	857
676	858	/* Leave room for tunnel header when returning 'mtu' to users: */
677		- n->links[bearer_id].mtu = tipc_link_mtu(nl) - INT_H_SIZE;
	859	+ n->links[bearer_id].mtu = tipc_link_mss(nl);
678	860
679	861	tipc_bearer_add_dest(n->net, bearer_id, n->addr);
680	862	tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id);
681	863
682	864	pr_debug("Established link <%s> on network plane %c\n",
683	865	tipc_link_name(nl), tipc_link_plane(nl));
	866	+ trace_tipc_node_link_up(n, true, " ");
684	867
685	868	/* Ensure that a STATE message goes first */
686	869	tipc_link_build_state_msg(nl, xmitq);
..	..	@@ -690,7 +873,6 @@
690	873	*slot0 = bearer_id;
691	874	*slot1 = bearer_id;
692	875	tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT);
693		- n->failover_sent = false;
694	876	n->action_flags \|= TIPC_NOTIFY_NODE_UP;
695	877	tipc_link_set_active(nl, true);
696	878	tipc_bcast_add_peer(n->net, nl, xmitq);
..	..	@@ -728,8 +910,51 @@
728	910	tipc_node_write_lock(n);
729	911	__tipc_node_link_up(n, bearer_id, xmitq);
730	912	maddr = &n->links[bearer_id].maddr;
731		- tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr);
	913	+ tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr, n);
732	914	tipc_node_write_unlock(n);
	915	+}
	916	+
	917	+/**
	918	+ * tipc_node_link_failover() - start failover in case "half-failover"
	919	+ *
	920	+ * This function is only called in a very special situation where link
	921	+ * failover can be already started on peer node but not on this node.
	922	+ * This can happen when e.g.
	923	+ * 1. Both links <1A-2A>, <1B-2B> down
	924	+ * 2. Link endpoint 2A up, but 1A still down (e.g. due to network
	925	+ * disturbance, wrong session, etc.)
	926	+ * 3. Link <1B-2B> up
	927	+ * 4. Link endpoint 2A down (e.g. due to link tolerance timeout)
	928	+ * 5. Node 2 starts failover onto link <1B-2B>
	929	+ *
	930	+ * ==> Node 1 does never start link/node failover!
	931	+ *
	932	+ * @n: tipc node structure
	933	+ * @l: link peer endpoint failingover (- can be NULL)
	934	+ * @tnl: tunnel link
	935	+ * @xmitq: queue for messages to be xmited on tnl link later
	936	+ */
	937	+static void tipc_node_link_failover(struct tipc_node n, struct tipc_link l,
	938	+ struct tipc_link *tnl,
	939	+ struct sk_buff_head *xmitq)
	940	+{
	941	+ /* Avoid to be "self-failover" that can never end */
	942	+ if (!tipc_link_is_up(tnl))
	943	+ return;
	944	+
	945	+ /* Don't rush, failure link may be in the process of resetting */
	946	+ if (l && !tipc_link_is_reset(l))
	947	+ return;
	948	+
	949	+ tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
	950	+ tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
	951	+
	952	+ n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1);
	953	+ tipc_link_failover_prepare(l, tnl, xmitq);
	954	+
	955	+ if (l)
	956	+ tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
	957	+ tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT);
733	958	}
734	959
735	960	/**
..	..	@@ -783,6 +1008,7 @@
783	1008	if (tipc_link_peer_is_down(l))
784	1009	tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
785	1010	tipc_node_fsm_evt(n, SELF_LOST_CONTACT_EVT);
	1011	+ trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down!");
786	1012	tipc_link_fsm_evt(l, LINK_RESET_EVT);
787	1013	tipc_link_reset(l);
788	1014	tipc_link_build_reset_msg(l, xmitq);
..	..	@@ -800,6 +1026,7 @@
800	1026	tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
801	1027	n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1);
802	1028	tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq);
	1029	+ trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down -> failover!");
803	1030	tipc_link_reset(l);
804	1031	tipc_link_fsm_evt(l, LINK_RESET_EVT);
805	1032	tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
..	..	@@ -823,20 +1050,22 @@
823	1050	tipc_node_write_lock(n);
824	1051	if (!tipc_link_is_establishing(l)) {
825	1052	__tipc_node_link_down(n, &bearer_id, &xmitq, &maddr);
826		- if (delete) {
827		- kfree(l);
828		- le->link = NULL;
829		- n->link_cnt--;
830		- }
831	1053	} else {
832	1054	/* Defuse pending tipc_node_link_up() */
	1055	+ tipc_link_reset(l);
833	1056	tipc_link_fsm_evt(l, LINK_RESET_EVT);
834	1057	}
	1058	+ if (delete) {
	1059	+ kfree(l);
	1060	+ le->link = NULL;
	1061	+ n->link_cnt--;
	1062	+ }
	1063	+ trace_tipc_node_link_down(n, true, "node link down or deleted!");
835	1064	tipc_node_write_unlock(n);
836	1065	if (delete)
837	1066	tipc_mon_remove_peer(n->net, n->addr, old_bearer_id);
838	1067	if (!skb_queue_empty(&xmitq))
839		- tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr);
	1068	+ tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr, n);
840	1069	tipc_sk_rcv(n->net, &le->inputq);
841	1070	}
842	1071
..	..	@@ -880,6 +1109,8 @@
880	1109	{
881	1110	struct tipc_net *tn = tipc_net(net);
882	1111	struct tipc_node *n;
	1112	+ bool preliminary;
	1113	+ u32 sugg_addr;
883	1114
884	1115	/* Suggest new address if some other peer is using this one */
885	1116	n = tipc_node_find(net, addr);
..	..	@@ -895,9 +1126,11 @@
895	1126	/* Suggest previously used address if peer is known */
896	1127	n = tipc_node_find_by_id(net, id);
897	1128	if (n) {
898		- addr = n->addr;
	1129	+ sugg_addr = n->addr;
	1130	+ preliminary = n->preliminary;
899	1131	tipc_node_put(n);
900		- return addr;
	1132	+ if (!preliminary)
	1133	+ return sugg_addr;
901	1134	}
902	1135
903	1136	/* Even this node may be in conflict */
..	..	@@ -909,7 +1142,7 @@
909	1142
910	1143	void tipc_node_check_dest(struct net *net, u32 addr,
911	1144	u8 peer_id, struct tipc_bearer b,
912		- u16 capabilities, u32 signature,
	1145	+ u16 capabilities, u32 signature, u32 hash_mixes,
913	1146	struct tipc_media_addr *maddr,
914	1147	bool respond, bool dupl_addr)
915	1148	{
..	..	@@ -928,7 +1161,8 @@
928	1161	*dupl_addr = false;
929	1162	*respond = false;
930	1163
931		- n = tipc_node_create(net, addr, peer_id, capabilities);
	1164	+ n = tipc_node_create(net, addr, peer_id, capabilities, hash_mixes,
	1165	+ false);
932	1166	if (!n)
933	1167	return;
934	1168
..	..	@@ -947,6 +1181,9 @@
947	1181	if (sign_match && addr_match && link_up) {
948	1182	/* All is fine. Do nothing. */
949	1183	reset = false;
	1184	+ /* Peer node is not a container/local namespace */
	1185	+ if (!n->peer_hash_mix)
	1186	+ n->peer_hash_mix = hash_mixes;
950	1187	} else if (sign_match && addr_match && !link_up) {
951	1188	/* Respond. The link will come up in due time */
952	1189	*respond = true;
..	..	@@ -1013,7 +1250,7 @@
1013	1250	get_random_bytes(&session, sizeof(u16));
1014	1251	if (!tipc_link_create(net, if_name, b->identity, b->tolerance,
1015	1252	b->net_plane, b->mtu, b->priority,
1016		- b->window, session,
	1253	+ b->min_win, b->max_win, session,
1017	1254	tipc_own_addr(net), addr, peer_id,
1018	1255	n->capabilities,
1019	1256	tipc_bc_sndlink(n->net), n->bc_entry.link,
..	..	@@ -1022,6 +1259,7 @@
1022	1259	*respond = false;
1023	1260	goto exit;
1024	1261	}
	1262	+ trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link created!");
1025	1263	tipc_link_reset(l);
1026	1264	tipc_link_fsm_evt(l, LINK_RESET_EVT);
1027	1265	if (n->state == NODE_FAILINGOVER)
..	..	@@ -1061,6 +1299,7 @@
1061	1299
1062	1300	pr_warn("Resetting all links to %x\n", n->addr);
1063	1301
	1302	+ trace_tipc_node_reset_links(n, true, " ");
1064	1303	for (i = 0; i < MAX_BEARERS; i++) {
1065	1304	tipc_node_link_down(n, i, false);
1066	1305	}
..	..	@@ -1236,11 +1475,13 @@
1236	1475	pr_err("Unknown node fsm state %x\n", state);
1237	1476	break;
1238	1477	}
	1478	+ trace_tipc_node_fsm(n->peer_id, n->state, state, evt);
1239	1479	n->state = state;
1240	1480	return;
1241	1481
1242	1482	illegal_evt:
1243	1483	pr_err("Illegal node fsm evt %x in state %x\n", evt, state);
	1484	+ trace_tipc_node_fsm(n->peer_id, n->state, state, evt);
1244	1485	}
1245	1486
1246	1487	static void node_lost_contact(struct tipc_node *n,
..	..	@@ -1254,9 +1495,11 @@
1254	1495
1255	1496	pr_debug("Lost contact with %x\n", n->addr);
1256	1497	n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER);
	1498	+ trace_tipc_node_lost_contact(n, true, " ");
1257	1499
1258	1500	/* Clean up broadcast state */
1259	1501	tipc_bcast_remove_peer(n->net, n->bc_entry.link);
	1502	+ skb_queue_purge(&n->bc_entry.namedq);
1260	1503
1261	1504	/* Abort any ongoing link failover */
1262	1505	for (i = 0; i < MAX_BEARERS; i++) {
..	..	@@ -1267,7 +1510,8 @@
1267	1510
1268	1511	/* Notify publications from this node */
1269	1512	n->action_flags \|= TIPC_NOTIFY_NODE_DOWN;
1270		-
	1513	+ n->peer_net = NULL;
	1514	+ n->peer_hash_mix = 0;
1271	1515	/* Notify sockets connected to node */
1272	1516	list_for_each_entry_safe(conn, safe, conns, list) {
1273	1517	skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
..	..	@@ -1285,7 +1529,7 @@
1285	1529	* tipc_node_get_linkname - get the name of a link
1286	1530	*
1287	1531	* @bearer_id: id of the bearer
1288		- * @node: peer node address
	1532	+ * @addr: peer node address
1289	1533	* @linkname: link name output buffer
1290	1534	*
1291	1535	* Returns 0 on success
..	..	@@ -1326,7 +1570,7 @@
1326	1570	if (!hdr)
1327	1571	return -EMSGSIZE;
1328	1572
1329		- attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE);
	1573	+ attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_NODE);
1330	1574	if (!attrs)
1331	1575	goto msg_full;
1332	1576
..	..	@@ -1349,6 +1593,57 @@
1349	1593	return -EMSGSIZE;
1350	1594	}
1351	1595
	1596	+static void tipc_lxc_xmit(struct net peer_net, struct sk_buff_head list)
	1597	+{
	1598	+ struct tipc_msg *hdr = buf_msg(skb_peek(list));
	1599	+ struct sk_buff_head inputq;
	1600	+
	1601	+ switch (msg_user(hdr)) {
	1602	+ case TIPC_LOW_IMPORTANCE:
	1603	+ case TIPC_MEDIUM_IMPORTANCE:
	1604	+ case TIPC_HIGH_IMPORTANCE:
	1605	+ case TIPC_CRITICAL_IMPORTANCE:
	1606	+ if (msg_connected(hdr) \|\| msg_named(hdr) \|\|
	1607	+ msg_direct(hdr)) {
	1608	+ tipc_loopback_trace(peer_net, list);
	1609	+ spin_lock_init(&list->lock);
	1610	+ tipc_sk_rcv(peer_net, list);
	1611	+ return;
	1612	+ }
	1613	+ if (msg_mcast(hdr)) {
	1614	+ tipc_loopback_trace(peer_net, list);
	1615	+ skb_queue_head_init(&inputq);
	1616	+ tipc_sk_mcast_rcv(peer_net, list, &inputq);
	1617	+ __skb_queue_purge(list);
	1618	+ skb_queue_purge(&inputq);
	1619	+ return;
	1620	+ }
	1621	+ return;
	1622	+ case MSG_FRAGMENTER:
	1623	+ if (tipc_msg_assemble(list)) {
	1624	+ tipc_loopback_trace(peer_net, list);
	1625	+ skb_queue_head_init(&inputq);
	1626	+ tipc_sk_mcast_rcv(peer_net, list, &inputq);
	1627	+ __skb_queue_purge(list);
	1628	+ skb_queue_purge(&inputq);
	1629	+ }
	1630	+ return;
	1631	+ case GROUP_PROTOCOL:
	1632	+ case CONN_MANAGER:
	1633	+ tipc_loopback_trace(peer_net, list);
	1634	+ spin_lock_init(&list->lock);
	1635	+ tipc_sk_rcv(peer_net, list);
	1636	+ return;
	1637	+ case LINK_PROTOCOL:
	1638	+ case NAME_DISTRIBUTOR:
	1639	+ case TUNNEL_PROTOCOL:
	1640	+ case BCAST_PROTOCOL:
	1641	+ return;
	1642	+ default:
	1643	+ return;
	1644	+ };
	1645	+}
	1646	+
1352	1647	/**
1353	1648	* tipc_node_xmit() is the general link level function for message sending
1354	1649	* @net: the applicable net namespace
..	..	@@ -1364,10 +1659,13 @@
1364	1659	struct tipc_link_entry *le = NULL;
1365	1660	struct tipc_node *n;
1366	1661	struct sk_buff_head xmitq;
	1662	+ bool node_up = false;
	1663	+ struct net *peer_net;
1367	1664	int bearer_id;
1368	1665	int rc;
1369	1666
1370	1667	if (in_own_node(net, dnode)) {
	1668	+ tipc_loopback_trace(net, list);
1371	1669	spin_lock_init(&list->lock);
1372	1670	tipc_sk_rcv(net, list);
1373	1671	return 0;
..	..	@@ -1378,6 +1676,22 @@
1378	1676	__skb_queue_purge(list);
1379	1677	return -EHOSTUNREACH;
1380	1678	}
	1679	+
	1680	+ rcu_read_lock();
	1681	+ tipc_node_read_lock(n);
	1682	+ node_up = node_is_up(n);
	1683	+ peer_net = n->peer_net;
	1684	+ tipc_node_read_unlock(n);
	1685	+ if (node_up && peer_net && check_net(peer_net)) {
	1686	+ /* xmit inner linux container */
	1687	+ tipc_lxc_xmit(peer_net, list);
	1688	+ if (likely(skb_queue_empty(list))) {
	1689	+ rcu_read_unlock();
	1690	+ tipc_node_put(n);
	1691	+ return 0;
	1692	+ }
	1693	+ }
	1694	+ rcu_read_unlock();
1381	1695
1382	1696	tipc_node_read_lock(n);
1383	1697	bearer_id = n->active_links[selector & 1];
..	..	@@ -1398,7 +1712,7 @@
1398	1712	if (unlikely(rc == -ENOBUFS))
1399	1713	tipc_node_link_down(n, bearer_id, false);
1400	1714	else
1401		- tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);
	1715	+ tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n);
1402	1716
1403	1717	tipc_node_put(n);
1404	1718
..	..	@@ -1438,12 +1752,23 @@
1438	1752	return 0;
1439	1753	}
1440	1754
1441		-void tipc_node_broadcast(struct net net, struct sk_buff skb)
	1755	+void tipc_node_broadcast(struct net net, struct sk_buff skb, int rc_dests)
1442	1756	{
	1757	+ struct sk_buff_head xmitq;
1443	1758	struct sk_buff *txskb;
1444	1759	struct tipc_node *n;
	1760	+ u16 dummy;
1445	1761	u32 dst;
1446	1762
	1763	+ /* Use broadcast if all nodes support it */
	1764	+ if (!rc_dests && tipc_bcast_get_mode(net) != BCLINK_MODE_RCAST) {
	1765	+ __skb_queue_head_init(&xmitq);
	1766	+ __skb_queue_tail(&xmitq, skb);
	1767	+ tipc_bcast_xmit(net, &xmitq, &dummy);
	1768	+ return;
	1769	+ }
	1770	+
	1771	+ /* Otherwise use legacy replicast method */
1447	1772	rcu_read_lock();
1448	1773	list_for_each_entry_rcu(n, tipc_nodes(net), list) {
1449	1774	dst = n->addr;
..	..	@@ -1458,7 +1783,6 @@
1458	1783	tipc_node_xmit_skb(net, txskb, dst, 0);
1459	1784	}
1460	1785	rcu_read_unlock();
1461		-
1462	1786	kfree_skb(skb);
1463	1787	}
1464	1788
..	..	@@ -1481,7 +1805,7 @@
1481	1805	struct tipc_link *ucl;
1482	1806	int rc;
1483	1807
1484		- rc = tipc_bcast_sync_rcv(n->net, n->bc_entry.link, hdr);
	1808	+ rc = tipc_bcast_sync_rcv(n->net, n->bc_entry.link, hdr, xmitq);
1485	1809
1486	1810	if (rc & TIPC_LINK_DOWN_EVT) {
1487	1811	tipc_node_reset_links(n);
..	..	@@ -1546,10 +1870,16 @@
1546	1870	}
1547	1871
1548	1872	if (!skb_queue_empty(&xmitq))
1549		- tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);
	1873	+ tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n);
1550	1874
1551	1875	if (!skb_queue_empty(&be->inputq1))
1552	1876	tipc_node_mcast_rcv(n);
	1877	+
	1878	+ /* Handle NAME_DISTRIBUTOR messages sent from 1.7 nodes */
	1879	+ if (!skb_queue_empty(&n->bc_entry.namedq))
	1880	+ tipc_named_rcv(net, &n->bc_entry.namedq,
	1881	+ &n->bc_entry.named_rcv_nxt,
	1882	+ &n->bc_entry.named_open);
1553	1883
1554	1884	/* If reassembly or retransmission failure => reset all links to peer */
1555	1885	if (rc & TIPC_LINK_DOWN_EVT)
..	..	@@ -1571,7 +1901,6 @@
1571	1901	int usr = msg_user(hdr);
1572	1902	int mtyp = msg_type(hdr);
1573	1903	u16 oseqno = msg_seqno(hdr);
1574		- u16 iseqno = msg_seqno(msg_get_wrapped(hdr));
1575	1904	u16 exp_pkts = msg_msgcnt(hdr);
1576	1905	u16 rcv_nxt, syncpt, dlv_nxt, inputq_len;
1577	1906	int state = n->state;
..	..	@@ -1579,6 +1908,10 @@
1579	1908	struct tipc_media_addr *maddr;
1580	1909	int pb_id;
1581	1910
	1911	+ if (trace_tipc_node_check_state_enabled()) {
	1912	+ trace_tipc_skb_dump(skb, false, "skb for node state check");
	1913	+ trace_tipc_node_check_state(n, true, " ");
	1914	+ }
1582	1915	l = n->links[bearer_id].link;
1583	1916	if (!l)
1584	1917	return false;
..	..	@@ -1596,8 +1929,11 @@
1596	1929	}
1597	1930	}
1598	1931
1599		- if (!tipc_link_validate_msg(l, hdr))
	1932	+ if (!tipc_link_validate_msg(l, hdr)) {
	1933	+ trace_tipc_skb_dump(skb, false, "PROTO invalid (2)!");
	1934	+ trace_tipc_link_dump(l, TIPC_DUMP_NONE, "PROTO invalid (2)!");
1600	1935	return false;
	1936	+ }
1601	1937
1602	1938	/* Check and update node accesibility if applicable */
1603	1939	if (state == SELF_UP_PEER_COMING) {
..	..	@@ -1625,19 +1961,23 @@
1625	1961	/* Initiate or update failover mode if applicable */
1626	1962	if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) {
1627	1963	syncpt = oseqno + exp_pkts - 1;
1628		- if (pl && tipc_link_is_up(pl)) {
	1964	+ if (pl && !tipc_link_is_reset(pl)) {
1629	1965	__tipc_node_link_down(n, &pb_id, xmitq, &maddr);
	1966	+ trace_tipc_node_link_down(n, true,
	1967	+ "node link down <- failover!");
1630	1968	tipc_skb_queue_splice_tail_init(tipc_link_inputq(pl),
1631	1969	tipc_link_inputq(l));
1632	1970	}
	1971	+
1633	1972	/* If parallel link was already down, and this happened before
1634		- * the tunnel link came up, FAILOVER was never sent. Ensure that
1635		- * FAILOVER is sent to get peer out of NODE_FAILINGOVER state.
	1973	+ * the tunnel link came up, node failover was never started.
	1974	+ * Ensure that a FAILOVER_MSG is sent to get peer out of
	1975	+ * NODE_FAILINGOVER state, also this node must accept
	1976	+ * TUNNEL_MSGs from peer.
1636	1977	*/
1637		- if (n->state != NODE_FAILINGOVER && !n->failover_sent) {
1638		- tipc_link_create_dummy_tnl_msg(l, xmitq);
1639		- n->failover_sent = true;
1640		- }
	1978	+ if (n->state != NODE_FAILINGOVER)
	1979	+ tipc_node_link_failover(n, pl, l, xmitq);
	1980	+
1641	1981	/* If pkts arrive out of order, use lowest calculated syncpt */
1642	1982	if (less(syncpt, n->sync_point))
1643	1983	n->sync_point = syncpt;
..	..	@@ -1659,7 +1999,10 @@
1659	1999
1660	2000	/* Initiate synch mode if applicable */
1661	2001	if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) {
1662		- syncpt = iseqno + exp_pkts - 1;
	2002	+ if (n->capabilities & TIPC_TUNNEL_ENHANCED)
	2003	+ syncpt = msg_syncpt(hdr);
	2004	+ else
	2005	+ syncpt = msg_seqno(msg_inner_hdr(hdr)) + exp_pkts - 1;
1663	2006	if (!tipc_link_is_up(l))
1664	2007	__tipc_node_link_up(n, bearer_id, xmitq);
1665	2008	if (n->state == SELF_UP_PEER_UP) {
..	..	@@ -1699,7 +2042,7 @@
1699	2042	* tipc_rcv - process TIPC packets/messages arriving from off-node
1700	2043	* @net: the applicable net namespace
1701	2044	* @skb: TIPC packet
1702		- * @bearer: pointer to bearer message arrived on
	2045	+ * @b: pointer to bearer message arrived on
1703	2046	*
1704	2047	* Invoked with no locks held. Bearer pointer must point to a valid bearer
1705	2048	* structure (i.e. cannot be NULL), but bearer can be inactive.
..	..	@@ -1707,19 +2050,38 @@
1707	2050	void tipc_rcv(struct net net, struct sk_buff skb, struct tipc_bearer *b)
1708	2051	{
1709	2052	struct sk_buff_head xmitq;
1710		- struct tipc_node *n;
1711		- struct tipc_msg *hdr;
1712		- int bearer_id = b->identity;
1713	2053	struct tipc_link_entry *le;
	2054	+ struct tipc_msg *hdr;
	2055	+ struct tipc_node *n;
	2056	+ int bearer_id = b->identity;
1714	2057	u32 self = tipc_own_addr(net);
1715	2058	int usr, rc = 0;
1716	2059	u16 bc_ack;
	2060	+#ifdef CONFIG_TIPC_CRYPTO
	2061	+ struct tipc_ehdr *ehdr;
1717	2062
1718		- __skb_queue_head_init(&xmitq);
	2063	+ /* Check if message must be decrypted first */
	2064	+ if (TIPC_SKB_CB(skb)->decrypted \|\| !tipc_ehdr_validate(skb))
	2065	+ goto rcv;
1719	2066
	2067	+ ehdr = (struct tipc_ehdr *)skb->data;
	2068	+ if (likely(ehdr->user != LINK_CONFIG)) {
	2069	+ n = tipc_node_find(net, ntohl(ehdr->addr));
	2070	+ if (unlikely(!n))
	2071	+ goto discard;
	2072	+ } else {
	2073	+ n = tipc_node_find_by_id(net, ehdr->id);
	2074	+ }
	2075	+ tipc_crypto_rcv(net, (n) ? n->crypto_rx : NULL, &skb, b);
	2076	+ if (!skb)
	2077	+ return;
	2078	+
	2079	+rcv:
	2080	+#endif
1720	2081	/* Ensure message is well-formed before touching the header */
1721	2082	if (unlikely(!tipc_msg_validate(&skb)))
1722	2083	goto discard;
	2084	+ __skb_queue_head_init(&xmitq);
1723	2085	hdr = buf_msg(skb);
1724	2086	usr = msg_user(hdr);
1725	2087	bc_ack = msg_bcast_ack(hdr);
..	..	@@ -1743,10 +2105,16 @@
1743	2105	le = &n->links[bearer_id];
1744	2106
1745	2107	/* Ensure broadcast reception is in synch with peer's send state */
1746		- if (unlikely(usr == LINK_PROTOCOL))
	2108	+ if (unlikely(usr == LINK_PROTOCOL)) {
	2109	+ if (unlikely(skb_linearize(skb))) {
	2110	+ tipc_node_put(n);
	2111	+ goto discard;
	2112	+ }
	2113	+ hdr = buf_msg(skb);
1747	2114	tipc_node_bc_sync_rcv(n, hdr, bearer_id, &xmitq);
1748		- else if (unlikely(tipc_link_acked(n->bc_entry.link) != bc_ack))
	2115	+ } else if (unlikely(tipc_link_acked(n->bc_entry.link) != bc_ack)) {
1749	2116	tipc_bcast_ack_rcv(net, n->bc_entry.link, hdr);
	2117	+ }
1750	2118
1751	2119	/* Receive packet directly if conditions permit */
1752	2120	tipc_node_read_lock(n);
..	..	@@ -1763,7 +2131,7 @@
1763	2131	/* Check/update node state before receiving */
1764	2132	if (unlikely(skb)) {
1765	2133	if (unlikely(skb_linearize(skb)))
1766		- goto discard;
	2134	+ goto out_node_put;
1767	2135	tipc_node_write_lock(n);
1768	2136	if (tipc_node_check_state(n, skb, bearer_id, &xmitq)) {
1769	2137	if (le->link) {
..	..	@@ -1781,7 +2149,9 @@
1781	2149	tipc_node_link_down(n, bearer_id, false);
1782	2150
1783	2151	if (unlikely(!skb_queue_empty(&n->bc_entry.namedq)))
1784		- tipc_named_rcv(net, &n->bc_entry.namedq);
	2152	+ tipc_named_rcv(net, &n->bc_entry.namedq,
	2153	+ &n->bc_entry.named_rcv_nxt,
	2154	+ &n->bc_entry.named_open);
1785	2155
1786	2156	if (unlikely(!skb_queue_empty(&n->bc_entry.inputq1)))
1787	2157	tipc_node_mcast_rcv(n);
..	..	@@ -1790,8 +2160,9 @@
1790	2160	tipc_sk_rcv(net, &le->inputq);
1791	2161
1792	2162	if (!skb_queue_empty(&xmitq))
1793		- tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);
	2163	+ tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n);
1794	2164
	2165	+out_node_put:
1795	2166	tipc_node_put(n);
1796	2167	discard:
1797	2168	kfree_skb(skb);
..	..	@@ -1819,9 +2190,13 @@
1819	2190	&xmitq);
1820	2191	else if (prop == TIPC_NLA_PROP_MTU)
1821	2192	tipc_link_set_mtu(e->link, b->mtu);
	2193	+
	2194	+ /* Update MTU for node link entry */
	2195	+ e->mtu = tipc_link_mss(e->link);
1822	2196	}
	2197	+
1823	2198	tipc_node_write_unlock(n);
1824		- tipc_bearer_xmit(net, bearer_id, &xmitq, &e->maddr);
	2199	+ tipc_bearer_xmit(net, bearer_id, &xmitq, &e->maddr, NULL);
1825	2200	}
1826	2201
1827	2202	rcu_read_unlock();
..	..	@@ -1832,7 +2207,7 @@
1832	2207	struct net *net = sock_net(skb->sk);
1833	2208	struct tipc_net *tn = net_generic(net, tipc_net_id);
1834	2209	struct nlattr *attrs[TIPC_NLA_NET_MAX + 1];
1835		- struct tipc_node *peer;
	2210	+ struct tipc_node peer, temp_node;
1836	2211	u32 addr;
1837	2212	int err;
1838	2213
..	..	@@ -1840,9 +2215,9 @@
1840	2215	if (!info->attrs[TIPC_NLA_NET])
1841	2216	return -EINVAL;
1842	2217
1843		- err = nla_parse_nested(attrs, TIPC_NLA_NET_MAX,
1844		- info->attrs[TIPC_NLA_NET], tipc_nl_net_policy,
1845		- info->extack);
	2218	+ err = nla_parse_nested_deprecated(attrs, TIPC_NLA_NET_MAX,
	2219	+ info->attrs[TIPC_NLA_NET],
	2220	+ tipc_nl_net_policy, info->extack);
1846	2221	if (err)
1847	2222	return err;
1848	2223
..	..	@@ -1873,6 +2248,12 @@
1873	2248	tipc_node_write_unlock(peer);
1874	2249	tipc_node_delete(peer);
1875	2250
	2251	+ /* Calculate cluster capabilities */
	2252	+ tn->capabilities = TIPC_NODE_CAPABILITIES;
	2253	+ list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
	2254	+ tn->capabilities &= temp_node->capabilities;
	2255	+ }
	2256	+ tipc_bcast_toggle_rcast(net, (tn->capabilities & TIPC_BCAST_RCAST));
1876	2257	err = 0;
1877	2258	err_out:
1878	2259	tipc_node_put(peer);
..	..	@@ -1917,6 +2298,8 @@
1917	2298	}
1918	2299
1919	2300	list_for_each_entry_rcu(node, &tn->node_list, list) {
	2301	+ if (node->preliminary)
	2302	+ continue;
1920	2303	if (last_addr) {
1921	2304	if (node->addr == last_addr)
1922	2305	last_addr = 0;
..	..	@@ -1998,9 +2381,9 @@
1998	2381	if (!info->attrs[TIPC_NLA_LINK])
1999	2382	return -EINVAL;
2000	2383
2001		- err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
2002		- info->attrs[TIPC_NLA_LINK],
2003		- tipc_nl_link_policy, info->extack);
	2384	+ err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
	2385	+ info->attrs[TIPC_NLA_LINK],
	2386	+ tipc_nl_link_policy, info->extack);
2004	2387	if (err)
2005	2388	return err;
2006	2389
..	..	@@ -2027,8 +2410,7 @@
2027	2410	if (attrs[TIPC_NLA_LINK_PROP]) {
2028	2411	struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
2029	2412
2030		- err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP],
2031		- props);
	2413	+ err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP], props);
2032	2414	if (err) {
2033	2415	res = err;
2034	2416	goto out;
..	..	@@ -2047,16 +2429,19 @@
2047	2429	tipc_link_set_prio(link, prio, &xmitq);
2048	2430	}
2049	2431	if (props[TIPC_NLA_PROP_WIN]) {
2050		- u32 win;
	2432	+ u32 max_win;
2051	2433
2052		- win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
2053		- tipc_link_set_queue_limits(link, win);
	2434	+ max_win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
	2435	+ tipc_link_set_queue_limits(link,
	2436	+ tipc_link_min_win(link),
	2437	+ max_win);
2054	2438	}
2055	2439	}
2056	2440
2057	2441	out:
2058	2442	tipc_node_read_unlock(node);
2059		- tipc_bearer_xmit(net, bearer_id, &xmitq, &node->links[bearer_id].maddr);
	2443	+ tipc_bearer_xmit(net, bearer_id, &xmitq, &node->links[bearer_id].maddr,
	2444	+ NULL);
2060	2445	return res;
2061	2446	}
2062	2447
..	..	@@ -2074,9 +2459,9 @@
2074	2459	if (!info->attrs[TIPC_NLA_LINK])
2075	2460	return -EINVAL;
2076	2461
2077		- err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
2078		- info->attrs[TIPC_NLA_LINK],
2079		- tipc_nl_link_policy, info->extack);
	2462	+ err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
	2463	+ info->attrs[TIPC_NLA_LINK],
	2464	+ tipc_nl_link_policy, info->extack);
2080	2465	if (err)
2081	2466	return err;
2082	2467
..	..	@@ -2090,7 +2475,7 @@
2090	2475	return -ENOMEM;
2091	2476
2092	2477	if (strcmp(name, tipc_bclink_name) == 0) {
2093		- err = tipc_nl_add_bc_link(net, &msg);
	2478	+ err = tipc_nl_add_bc_link(net, &msg, tipc_net(net)->bcl);
2094	2479	if (err)
2095	2480	goto err_free;
2096	2481	} else {
..	..	@@ -2134,14 +2519,15 @@
2134	2519	struct tipc_node *node;
2135	2520	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
2136	2521	struct net *net = sock_net(skb->sk);
	2522	+ struct tipc_net *tn = tipc_net(net);
2137	2523	struct tipc_link_entry *le;
2138	2524
2139	2525	if (!info->attrs[TIPC_NLA_LINK])
2140	2526	return -EINVAL;
2141	2527
2142		- err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
2143		- info->attrs[TIPC_NLA_LINK],
2144		- tipc_nl_link_policy, info->extack);
	2528	+ err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
	2529	+ info->attrs[TIPC_NLA_LINK],
	2530	+ tipc_nl_link_policy, info->extack);
2145	2531	if (err)
2146	2532	return err;
2147	2533
..	..	@@ -2150,11 +2536,26 @@
2150	2536
2151	2537	link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
2152	2538
2153		- if (strcmp(link_name, tipc_bclink_name) == 0) {
2154		- err = tipc_bclink_reset_stats(net);
	2539	+ err = -EINVAL;
	2540	+ if (!strcmp(link_name, tipc_bclink_name)) {
	2541	+ err = tipc_bclink_reset_stats(net, tipc_bc_sndlink(net));
2155	2542	if (err)
2156	2543	return err;
2157	2544	return 0;
	2545	+ } else if (strstr(link_name, tipc_bclink_name)) {
	2546	+ rcu_read_lock();
	2547	+ list_for_each_entry_rcu(node, &tn->node_list, list) {
	2548	+ tipc_node_read_lock(node);
	2549	+ link = node->bc_entry.link;
	2550	+ if (link && !strcmp(link_name, tipc_link_name(link))) {
	2551	+ err = tipc_bclink_reset_stats(net, link);
	2552	+ tipc_node_read_unlock(node);
	2553	+ break;
	2554	+ }
	2555	+ tipc_node_read_unlock(node);
	2556	+ }
	2557	+ rcu_read_unlock();
	2558	+ return err;
2158	2559	}
2159	2560
2160	2561	node = tipc_node_find_by_name(net, link_name, &bearer_id);
..	..	@@ -2178,7 +2579,8 @@
2178	2579
2179	2580	/* Caller should hold node lock */
2180	2581	static int __tipc_nl_add_node_links(struct net net, struct tipc_nl_msg msg,
2181		- struct tipc_node node, u32 prev_link)
	2582	+ struct tipc_node node, u32 prev_link,
	2583	+ bool bc_link)
2182	2584	{
2183	2585	u32 i;
2184	2586	int err;
..	..	@@ -2194,6 +2596,14 @@
2194	2596	if (err)
2195	2597	return err;
2196	2598	}
	2599	+
	2600	+ if (bc_link) {
	2601	+ *prev_link = i;
	2602	+ err = tipc_nl_add_bc_link(net, msg, node->bc_entry.link);
	2603	+ if (err)
	2604	+ return err;
	2605	+ }
	2606	+
2197	2607	*prev_link = 0;
2198	2608
2199	2609	return 0;
..	..	@@ -2202,16 +2612,35 @@
2202	2612	int tipc_nl_node_dump_link(struct sk_buff skb, struct netlink_callback cb)
2203	2613	{
2204	2614	struct net *net = sock_net(skb->sk);
	2615	+ struct nlattr **attrs = genl_dumpit_info(cb)->attrs;
	2616	+ struct nlattr *link[TIPC_NLA_LINK_MAX + 1];
2205	2617	struct tipc_net *tn = net_generic(net, tipc_net_id);
2206	2618	struct tipc_node *node;
2207	2619	struct tipc_nl_msg msg;
2208	2620	u32 prev_node = cb->args[0];
2209	2621	u32 prev_link = cb->args[1];
2210	2622	int done = cb->args[2];
	2623	+ bool bc_link = cb->args[3];
2211	2624	int err;
2212	2625
2213	2626	if (done)
2214	2627	return 0;
	2628	+
	2629	+ if (!prev_node) {
	2630	+ /* Check if broadcast-receiver links dumping is needed */
	2631	+ if (attrs && attrs[TIPC_NLA_LINK]) {
	2632	+ err = nla_parse_nested_deprecated(link,
	2633	+ TIPC_NLA_LINK_MAX,
	2634	+ attrs[TIPC_NLA_LINK],
	2635	+ tipc_nl_link_policy,
	2636	+ NULL);
	2637	+ if (unlikely(err))
	2638	+ return err;
	2639	+ if (unlikely(!link[TIPC_NLA_LINK_BROADCAST]))
	2640	+ return -EINVAL;
	2641	+ bc_link = true;
	2642	+ }
	2643	+ }
2215	2644
2216	2645	msg.skb = skb;
2217	2646	msg.portid = NETLINK_CB(cb->skb).portid;
..	..	@@ -2236,7 +2665,7 @@
2236	2665	list) {
2237	2666	tipc_node_read_lock(node);
2238	2667	err = __tipc_nl_add_node_links(net, &msg, node,
2239		- &prev_link);
	2668	+ &prev_link, bc_link);
2240	2669	tipc_node_read_unlock(node);
2241	2670	if (err)
2242	2671	goto out;
..	..	@@ -2244,14 +2673,14 @@
2244	2673	prev_node = node->addr;
2245	2674	}
2246	2675	} else {
2247		- err = tipc_nl_add_bc_link(net, &msg);
	2676	+ err = tipc_nl_add_bc_link(net, &msg, tn->bcl);
2248	2677	if (err)
2249	2678	goto out;
2250	2679
2251	2680	list_for_each_entry_rcu(node, &tn->node_list, list) {
2252	2681	tipc_node_read_lock(node);
2253	2682	err = __tipc_nl_add_node_links(net, &msg, node,
2254		- &prev_link);
	2683	+ &prev_link, bc_link);
2255	2684	tipc_node_read_unlock(node);
2256	2685	if (err)
2257	2686	goto out;
..	..	@@ -2266,6 +2695,7 @@
2266	2695	cb->args[0] = prev_node;
2267	2696	cb->args[1] = prev_link;
2268	2697	cb->args[2] = done;
	2698	+ cb->args[3] = bc_link;
2269	2699
2270	2700	return skb->len;
2271	2701	}
..	..	@@ -2279,9 +2709,10 @@
2279	2709	if (!info->attrs[TIPC_NLA_MON])
2280	2710	return -EINVAL;
2281	2711
2282		- err = nla_parse_nested(attrs, TIPC_NLA_MON_MAX,
2283		- info->attrs[TIPC_NLA_MON],
2284		- tipc_nl_monitor_policy, info->extack);
	2712	+ err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MON_MAX,
	2713	+ info->attrs[TIPC_NLA_MON],
	2714	+ tipc_nl_monitor_policy,
	2715	+ info->extack);
2285	2716	if (err)
2286	2717	return err;
2287	2718
..	..	@@ -2308,7 +2739,7 @@
2308	2739	if (!hdr)
2309	2740	return -EMSGSIZE;
2310	2741
2311		- attrs = nla_nest_start(msg->skb, TIPC_NLA_MON);
	2742	+ attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON);
2312	2743	if (!attrs)
2313	2744	goto msg_full;
2314	2745
..	..	@@ -2389,19 +2820,16 @@
2389	2820	int err;
2390	2821
2391	2822	if (!prev_node) {
2392		- struct nlattr **attrs;
	2823	+ struct nlattr **attrs = genl_dumpit_info(cb)->attrs;
2393	2824	struct nlattr *mon[TIPC_NLA_MON_MAX + 1];
2394		-
2395		- err = tipc_nlmsg_parse(cb->nlh, &attrs);
2396		- if (err)
2397		- return err;
2398	2825
2399	2826	if (!attrs[TIPC_NLA_MON])
2400	2827	return -EINVAL;
2401	2828
2402		- err = nla_parse_nested(mon, TIPC_NLA_MON_MAX,
2403		- attrs[TIPC_NLA_MON],
2404		- tipc_nl_monitor_policy, NULL);
	2829	+ err = nla_parse_nested_deprecated(mon, TIPC_NLA_MON_MAX,
	2830	+ attrs[TIPC_NLA_MON],
	2831	+ tipc_nl_monitor_policy,
	2832	+ NULL);
2405	2833	if (err)
2406	2834	return err;
2407	2835
..	..	@@ -2433,3 +2861,256 @@
2433	2861
2434	2862	return skb->len;
2435	2863	}
	2864	+
	2865	+#ifdef CONFIG_TIPC_CRYPTO
	2866	+static int tipc_nl_retrieve_key(struct nlattr **attrs,
	2867	+ struct tipc_aead_key **pkey)
	2868	+{
	2869	+ struct nlattr *attr = attrs[TIPC_NLA_NODE_KEY];
	2870	+ struct tipc_aead_key *key;
	2871	+
	2872	+ if (!attr)
	2873	+ return -ENODATA;
	2874	+
	2875	+ if (nla_len(attr) < sizeof(*key))
	2876	+ return -EINVAL;
	2877	+ key = (struct tipc_aead_key *)nla_data(attr);
	2878	+ if (key->keylen > TIPC_AEAD_KEYLEN_MAX \|\|
	2879	+ nla_len(attr) < tipc_aead_key_size(key))
	2880	+ return -EINVAL;
	2881	+
	2882	+ *pkey = key;
	2883	+ return 0;
	2884	+}
	2885	+
	2886	+static int tipc_nl_retrieve_nodeid(struct nlattr attrs, u8 node_id)
	2887	+{
	2888	+ struct nlattr *attr = attrs[TIPC_NLA_NODE_ID];
	2889	+
	2890	+ if (!attr)
	2891	+ return -ENODATA;
	2892	+
	2893	+ if (nla_len(attr) < TIPC_NODEID_LEN)
	2894	+ return -EINVAL;
	2895	+
	2896	+ node_id = (u8 )nla_data(attr);
	2897	+ return 0;
	2898	+}
	2899	+
	2900	+static int tipc_nl_retrieve_rekeying(struct nlattr *attrs, u32 intv)
	2901	+{
	2902	+ struct nlattr *attr = attrs[TIPC_NLA_NODE_REKEYING];
	2903	+
	2904	+ if (!attr)
	2905	+ return -ENODATA;
	2906	+
	2907	+ *intv = nla_get_u32(attr);
	2908	+ return 0;
	2909	+}
	2910	+
	2911	+static int __tipc_nl_node_set_key(struct sk_buff skb, struct genl_info info)
	2912	+{
	2913	+ struct nlattr *attrs[TIPC_NLA_NODE_MAX + 1];
	2914	+ struct net *net = sock_net(skb->sk);
	2915	+ struct tipc_crypto tx = tipc_net(net)->crypto_tx, c = tx;
	2916	+ struct tipc_node *n = NULL;
	2917	+ struct tipc_aead_key *ukey;
	2918	+ bool rekeying = true, master_key = false;
	2919	+ u8 id, own_id, mode;
	2920	+ u32 intv = 0;
	2921	+ int rc = 0;
	2922	+
	2923	+ if (!info->attrs[TIPC_NLA_NODE])
	2924	+ return -EINVAL;
	2925	+
	2926	+ rc = nla_parse_nested(attrs, TIPC_NLA_NODE_MAX,
	2927	+ info->attrs[TIPC_NLA_NODE],
	2928	+ tipc_nl_node_policy, info->extack);
	2929	+ if (rc)
	2930	+ return rc;
	2931	+
	2932	+ own_id = tipc_own_id(net);
	2933	+ if (!own_id) {
	2934	+ GENL_SET_ERR_MSG(info, "not found own node identity (set id?)");
	2935	+ return -EPERM;
	2936	+ }
	2937	+
	2938	+ rc = tipc_nl_retrieve_rekeying(attrs, &intv);
	2939	+ if (rc == -ENODATA)
	2940	+ rekeying = false;
	2941	+
	2942	+ rc = tipc_nl_retrieve_key(attrs, &ukey);
	2943	+ if (rc == -ENODATA && rekeying)
	2944	+ goto rekeying;
	2945	+ else if (rc)
	2946	+ return rc;
	2947	+
	2948	+ rc = tipc_aead_key_validate(ukey, info);
	2949	+ if (rc)
	2950	+ return rc;
	2951	+
	2952	+ rc = tipc_nl_retrieve_nodeid(attrs, &id);
	2953	+ switch (rc) {
	2954	+ case -ENODATA:
	2955	+ mode = CLUSTER_KEY;
	2956	+ master_key = !!(attrs[TIPC_NLA_NODE_KEY_MASTER]);
	2957	+ break;
	2958	+ case 0:
	2959	+ mode = PER_NODE_KEY;
	2960	+ if (memcmp(id, own_id, NODE_ID_LEN)) {
	2961	+ n = tipc_node_find_by_id(net, id) ?:
	2962	+ tipc_node_create(net, 0, id, 0xffffu, 0, true);
	2963	+ if (unlikely(!n))
	2964	+ return -ENOMEM;
	2965	+ c = n->crypto_rx;
	2966	+ }
	2967	+ break;
	2968	+ default:
	2969	+ return rc;
	2970	+ }
	2971	+
	2972	+ /* Initiate the TX/RX key */
	2973	+ rc = tipc_crypto_key_init(c, ukey, mode, master_key);
	2974	+ if (n)
	2975	+ tipc_node_put(n);
	2976	+
	2977	+ if (unlikely(rc < 0)) {
	2978	+ GENL_SET_ERR_MSG(info, "unable to initiate or attach new key");
	2979	+ return rc;
	2980	+ } else if (c == tx) {
	2981	+ /* Distribute TX key but not master one */
	2982	+ if (!master_key && tipc_crypto_key_distr(tx, rc, NULL))
	2983	+ GENL_SET_ERR_MSG(info, "failed to replicate new key");
	2984	+rekeying:
	2985	+ /* Schedule TX rekeying if needed */
	2986	+ tipc_crypto_rekeying_sched(tx, rekeying, intv);
	2987	+ }
	2988	+
	2989	+ return 0;
	2990	+}
	2991	+
	2992	+int tipc_nl_node_set_key(struct sk_buff skb, struct genl_info info)
	2993	+{
	2994	+ int err;
	2995	+
	2996	+ rtnl_lock();
	2997	+ err = __tipc_nl_node_set_key(skb, info);
	2998	+ rtnl_unlock();
	2999	+
	3000	+ return err;
	3001	+}
	3002	+
	3003	+static int __tipc_nl_node_flush_key(struct sk_buff *skb,
	3004	+ struct genl_info *info)
	3005	+{
	3006	+ struct net *net = sock_net(skb->sk);
	3007	+ struct tipc_net *tn = tipc_net(net);
	3008	+ struct tipc_node *n;
	3009	+
	3010	+ tipc_crypto_key_flush(tn->crypto_tx);
	3011	+ rcu_read_lock();
	3012	+ list_for_each_entry_rcu(n, &tn->node_list, list)
	3013	+ tipc_crypto_key_flush(n->crypto_rx);
	3014	+ rcu_read_unlock();
	3015	+
	3016	+ return 0;
	3017	+}
	3018	+
	3019	+int tipc_nl_node_flush_key(struct sk_buff skb, struct genl_info info)
	3020	+{
	3021	+ int err;
	3022	+
	3023	+ rtnl_lock();
	3024	+ err = __tipc_nl_node_flush_key(skb, info);
	3025	+ rtnl_unlock();
	3026	+
	3027	+ return err;
	3028	+}
	3029	+#endif
	3030	+
	3031	+/**
	3032	+ * tipc_node_dump - dump TIPC node data
	3033	+ * @n: tipc node to be dumped
	3034	+ * @more: dump more?
	3035	+ * - false: dump only tipc node data
	3036	+ * - true: dump node link data as well
	3037	+ * @buf: returned buffer of dump data in format
	3038	+ */
	3039	+int tipc_node_dump(struct tipc_node n, bool more, char buf)
	3040	+{
	3041	+ int i = 0;
	3042	+ size_t sz = (more) ? NODE_LMAX : NODE_LMIN;
	3043	+
	3044	+ if (!n) {
	3045	+ i += scnprintf(buf, sz, "node data: (null)\n");
	3046	+ return i;
	3047	+ }
	3048	+
	3049	+ i += scnprintf(buf, sz, "node data: %x", n->addr);
	3050	+ i += scnprintf(buf + i, sz - i, " %x", n->state);
	3051	+ i += scnprintf(buf + i, sz - i, " %d", n->active_links[0]);
	3052	+ i += scnprintf(buf + i, sz - i, " %d", n->active_links[1]);
	3053	+ i += scnprintf(buf + i, sz - i, " %x", n->action_flags);
	3054	+ i += scnprintf(buf + i, sz - i, " %u", n->failover_sent);
	3055	+ i += scnprintf(buf + i, sz - i, " %u", n->sync_point);
	3056	+ i += scnprintf(buf + i, sz - i, " %d", n->link_cnt);
	3057	+ i += scnprintf(buf + i, sz - i, " %u", n->working_links);
	3058	+ i += scnprintf(buf + i, sz - i, " %x", n->capabilities);
	3059	+ i += scnprintf(buf + i, sz - i, " %lu\n", n->keepalive_intv);
	3060	+
	3061	+ if (!more)
	3062	+ return i;
	3063	+
	3064	+ i += scnprintf(buf + i, sz - i, "link_entry[0]:\n");
	3065	+ i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[0].mtu);
	3066	+ i += scnprintf(buf + i, sz - i, " media: ");
	3067	+ i += tipc_media_addr_printf(buf + i, sz - i, &n->links[0].maddr);
	3068	+ i += scnprintf(buf + i, sz - i, "\n");
	3069	+ i += tipc_link_dump(n->links[0].link, TIPC_DUMP_NONE, buf + i);
	3070	+ i += scnprintf(buf + i, sz - i, " inputq: ");
	3071	+ i += tipc_list_dump(&n->links[0].inputq, false, buf + i);
	3072	+
	3073	+ i += scnprintf(buf + i, sz - i, "link_entry[1]:\n");
	3074	+ i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[1].mtu);
	3075	+ i += scnprintf(buf + i, sz - i, " media: ");
	3076	+ i += tipc_media_addr_printf(buf + i, sz - i, &n->links[1].maddr);
	3077	+ i += scnprintf(buf + i, sz - i, "\n");
	3078	+ i += tipc_link_dump(n->links[1].link, TIPC_DUMP_NONE, buf + i);
	3079	+ i += scnprintf(buf + i, sz - i, " inputq: ");
	3080	+ i += tipc_list_dump(&n->links[1].inputq, false, buf + i);
	3081	+
	3082	+ i += scnprintf(buf + i, sz - i, "bclink:\n ");
	3083	+ i += tipc_link_dump(n->bc_entry.link, TIPC_DUMP_NONE, buf + i);
	3084	+
	3085	+ return i;
	3086	+}
	3087	+
	3088	+void tipc_node_pre_cleanup_net(struct net *exit_net)
	3089	+{
	3090	+ struct tipc_node *n;
	3091	+ struct tipc_net *tn;
	3092	+ struct net *tmp;
	3093	+
	3094	+ rcu_read_lock();
	3095	+ for_each_net_rcu(tmp) {
	3096	+ if (tmp == exit_net)
	3097	+ continue;
	3098	+ tn = tipc_net(tmp);
	3099	+ if (!tn)
	3100	+ continue;
	3101	+ spin_lock_bh(&tn->node_list_lock);
	3102	+ list_for_each_entry_rcu(n, &tn->node_list, list) {
	3103	+ if (!n->peer_net)
	3104	+ continue;
	3105	+ if (n->peer_net != exit_net)
	3106	+ continue;
	3107	+ tipc_node_write_lock(n);
	3108	+ n->peer_net = NULL;
	3109	+ n->peer_hash_mix = 0;
	3110	+ tipc_node_write_unlock_fast(n);
	3111	+ break;
	3112	+ }
	3113	+ spin_unlock_bh(&tn->node_list_lock);
	3114	+ }
	3115	+ rcu_read_unlock();
	3116	+}