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 #include "crypto.h"
48
49 #define INVALID_NODE_SIG 0x10000
50 #define NODE_CLEANUP_AFTER 300000
51
52 /* Flags used to take different actions according to flag type
53 * TIPC_NOTIFY_NODE_DOWN: notify node is down
54 * TIPC_NOTIFY_NODE_UP: notify node is up
55 * TIPC_DISTRIBUTE_NAME: publish or withdraw link state name type
56 */
57 enum {
58 TIPC_NOTIFY_NODE_DOWN = (1 << 3),
59 TIPC_NOTIFY_NODE_UP = (1 << 4),
60 TIPC_NOTIFY_LINK_UP = (1 << 6),
61 TIPC_NOTIFY_LINK_DOWN = (1 << 7)
62 };
63
64 struct tipc_link_entry {
65 struct tipc_link *link;
66 spinlock_t lock; /* per link */
67 u32 mtu;
68 struct sk_buff_head inputq;
69 struct tipc_media_addr maddr;
70 };
71
72 struct tipc_bclink_entry {
73 struct tipc_link *link;
74 struct sk_buff_head inputq1;
75 struct sk_buff_head arrvq;
76 struct sk_buff_head inputq2;
77 struct sk_buff_head namedq;
78 u16 named_rcv_nxt;
79 bool named_open;
80 };
81
82 /**
83 * struct tipc_node - TIPC node structure
84 * @addr: network address of node
85 * @ref: reference counter to node object
86 * @lock: rwlock governing access to structure
87 * @net: the applicable net namespace
88 * @hash: links to adjacent nodes in unsorted hash chain
89 * @inputq: pointer to input queue containing messages for msg event
90 * @namedq: pointer to name table input queue with name table messages
91 * @active_links: bearer ids of active links, used as index into links[] array
92 * @links: array containing references to all links to node
93 * @action_flags: bit mask of different types of node actions
94 * @state: connectivity state vs peer node
95 * @preliminary: a preliminary node or not
96 * @sync_point: sequence number where synch/failover is finished
97 * @list: links to adjacent nodes in sorted list of cluster's nodes
98 * @working_links: number of working links to node (both active and standby)
99 * @link_cnt: number of links to node
100 * @capabilities: bitmap, indicating peer node's functional capabilities
101 * @signature: node instance identifier
102 * @link_id: local and remote bearer ids of changing link, if any
103 * @publ_list: list of publications
104 * @rcu: rcu struct for tipc_node
105 * @delete_at: indicates the time for deleting a down node
106 * @crypto_rx: RX crypto handler
107 */
108 struct tipc_node {
109 u32 addr;
110 struct kref kref;
111 rwlock_t lock;
112 struct net *net;
113 struct hlist_node hash;
114 int active_links[2];
115 struct tipc_link_entry links[MAX_BEARERS];
116 struct tipc_bclink_entry bc_entry;
117 int action_flags;
118 struct list_head list;
119 int state;
120 bool preliminary;
121 bool failover_sent;
122 u16 sync_point;
123 int link_cnt;
124 u16 working_links;
125 u16 capabilities;
126 u32 signature;
127 u32 link_id;
128 u8 peer_id[16];
129 char peer_id_string[NODE_ID_STR_LEN];
130 struct list_head publ_list;
131 struct list_head conn_sks;
132 unsigned long keepalive_intv;
133 struct timer_list timer;
134 struct rcu_head rcu;
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
141 };
142
143 /* Node FSM states and events:
144 */
145 enum {
146 SELF_DOWN_PEER_DOWN = 0xdd,
147 SELF_UP_PEER_UP = 0xaa,
148 SELF_DOWN_PEER_LEAVING = 0xd1,
149 SELF_UP_PEER_COMING = 0xac,
150 SELF_COMING_PEER_UP = 0xca,
151 SELF_LEAVING_PEER_DOWN = 0x1d,
152 NODE_FAILINGOVER = 0xf0,
153 NODE_SYNCHING = 0xcc
154 };
155
156 enum {
157 SELF_ESTABL_CONTACT_EVT = 0xece,
158 SELF_LOST_CONTACT_EVT = 0x1ce,
159 PEER_ESTABL_CONTACT_EVT = 0x9ece,
160 PEER_LOST_CONTACT_EVT = 0x91ce,
161 NODE_FAILOVER_BEGIN_EVT = 0xfbe,
162 NODE_FAILOVER_END_EVT = 0xfee,
163 NODE_SYNCH_BEGIN_EVT = 0xcbe,
164 NODE_SYNCH_END_EVT = 0xcee
165 };
166
167 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,
168 struct sk_buff_head *xmitq,
169 struct tipc_media_addr **maddr);
170 static void tipc_node_link_down(struct tipc_node *n, int bearer_id,
171 bool delete);
172 static void node_lost_contact(struct tipc_node *n, struct sk_buff_head *inputq);
173 static void tipc_node_delete(struct tipc_node *node);
174 static void tipc_node_timeout(struct timer_list *t);
175 static void tipc_node_fsm_evt(struct tipc_node *n, int evt);
176 static struct tipc_node *tipc_node_find(struct net *net, u32 addr);
177 static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id);
178 static bool node_is_up(struct tipc_node *n);
179 static void tipc_node_delete_from_list(struct tipc_node *node);
180
181 struct tipc_sock_conn {
182 u32 port;
183 u32 peer_port;
184 u32 peer_node;
185 struct list_head list;
186 };
187
node_active_link(struct tipc_node * n,int sel)188 static struct tipc_link *node_active_link(struct tipc_node *n, int sel)
189 {
190 int bearer_id = n->active_links[sel & 1];
191
192 if (unlikely(bearer_id == INVALID_BEARER_ID))
193 return NULL;
194
195 return n->links[bearer_id].link;
196 }
197
tipc_node_get_mtu(struct net * net,u32 addr,u32 sel,bool connected)198 int tipc_node_get_mtu(struct net *net, u32 addr, u32 sel, bool connected)
199 {
200 struct tipc_node *n;
201 int bearer_id;
202 unsigned int mtu = MAX_MSG_SIZE;
203
204 n = tipc_node_find(net, addr);
205 if (unlikely(!n))
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 }
215
216 bearer_id = n->active_links[sel & 1];
217 if (likely(bearer_id != INVALID_BEARER_ID))
218 mtu = n->links[bearer_id].mtu;
219 tipc_node_put(n);
220 return mtu;
221 }
222
tipc_node_get_id(struct net * net,u32 addr,u8 * id)223 bool tipc_node_get_id(struct net *net, u32 addr, u8 *id)
224 {
225 u8 *own_id = tipc_own_id(net);
226 struct tipc_node *n;
227
228 if (!own_id)
229 return true;
230
231 if (addr == tipc_own_addr(net)) {
232 memcpy(id, own_id, TIPC_NODEID_LEN);
233 return true;
234 }
235 n = tipc_node_find(net, addr);
236 if (!n)
237 return false;
238
239 memcpy(id, &n->peer_id, TIPC_NODEID_LEN);
240 tipc_node_put(n);
241 return true;
242 }
243
tipc_node_get_capabilities(struct net * net,u32 addr)244 u16 tipc_node_get_capabilities(struct net *net, u32 addr)
245 {
246 struct tipc_node *n;
247 u16 caps;
248
249 n = tipc_node_find(net, addr);
250 if (unlikely(!n))
251 return TIPC_NODE_CAPABILITIES;
252 caps = n->capabilities;
253 tipc_node_put(n);
254 return caps;
255 }
256
tipc_node_get_addr(struct tipc_node * node)257 u32 tipc_node_get_addr(struct tipc_node *node)
258 {
259 return (node) ? node->addr : 0;
260 }
261
tipc_node_get_id_str(struct tipc_node * node)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 */
tipc_node_crypto_rx(struct tipc_node * __n)272 struct tipc_crypto *tipc_node_crypto_rx(struct tipc_node *__n)
273 {
274 return (__n) ? __n->crypto_rx : NULL;
275 }
276
tipc_node_crypto_rx_by_list(struct list_head * pos)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
tipc_node_crypto_rx_by_addr(struct net * net,u32 addr)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
tipc_node_free(struct rcu_head * rp)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
tipc_node_kref_release(struct kref * kref)301 static void tipc_node_kref_release(struct kref *kref)
302 {
303 struct tipc_node *n = container_of(kref, struct tipc_node, kref);
304
305 kfree(n->bc_entry.link);
306 call_rcu(&n->rcu, tipc_node_free);
307 }
308
tipc_node_put(struct tipc_node * node)309 void tipc_node_put(struct tipc_node *node)
310 {
311 kref_put(&node->kref, tipc_node_kref_release);
312 }
313
tipc_node_get(struct tipc_node * node)314 void tipc_node_get(struct tipc_node *node)
315 {
316 kref_get(&node->kref);
317 }
318
319 /*
320 * tipc_node_find - locate specified node object, if it exists
321 */
tipc_node_find(struct net * net,u32 addr)322 static struct tipc_node *tipc_node_find(struct net *net, u32 addr)
323 {
324 struct tipc_net *tn = tipc_net(net);
325 struct tipc_node *node;
326 unsigned int thash = tipc_hashfn(addr);
327
328 rcu_read_lock();
329 hlist_for_each_entry_rcu(node, &tn->node_htable[thash], hash) {
330 if (node->addr != addr || node->preliminary)
331 continue;
332 if (!kref_get_unless_zero(&node->kref))
333 node = NULL;
334 break;
335 }
336 rcu_read_unlock();
337 return node;
338 }
339
340 /* tipc_node_find_by_id - locate specified node object by its 128-bit id
341 * Note: this function is called only when a discovery request failed
342 * to find the node by its 32-bit id, and is not time critical
343 */
tipc_node_find_by_id(struct net * net,u8 * id)344 static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id)
345 {
346 struct tipc_net *tn = tipc_net(net);
347 struct tipc_node *n;
348 bool found = false;
349
350 rcu_read_lock();
351 list_for_each_entry_rcu(n, &tn->node_list, list) {
352 read_lock_bh(&n->lock);
353 if (!memcmp(id, n->peer_id, 16) &&
354 kref_get_unless_zero(&n->kref))
355 found = true;
356 read_unlock_bh(&n->lock);
357 if (found)
358 break;
359 }
360 rcu_read_unlock();
361 return found ? n : NULL;
362 }
363
tipc_node_read_lock(struct tipc_node * n)364 static void tipc_node_read_lock(struct tipc_node *n)
365 {
366 read_lock_bh(&n->lock);
367 }
368
tipc_node_read_unlock(struct tipc_node * n)369 static void tipc_node_read_unlock(struct tipc_node *n)
370 {
371 read_unlock_bh(&n->lock);
372 }
373
tipc_node_write_lock(struct tipc_node * n)374 static void tipc_node_write_lock(struct tipc_node *n)
375 {
376 write_lock_bh(&n->lock);
377 }
378
tipc_node_write_unlock_fast(struct tipc_node * n)379 static void tipc_node_write_unlock_fast(struct tipc_node *n)
380 {
381 write_unlock_bh(&n->lock);
382 }
383
tipc_node_write_unlock(struct tipc_node * n)384 static void tipc_node_write_unlock(struct tipc_node *n)
385 {
386 struct net *net = n->net;
387 u32 addr = 0;
388 u32 flags = n->action_flags;
389 u32 link_id = 0;
390 u32 bearer_id;
391 struct list_head *publ_list;
392
393 if (likely(!flags)) {
394 write_unlock_bh(&n->lock);
395 return;
396 }
397
398 addr = n->addr;
399 link_id = n->link_id;
400 bearer_id = link_id & 0xffff;
401 publ_list = &n->publ_list;
402
403 n->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |
404 TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP);
405
406 write_unlock_bh(&n->lock);
407
408 if (flags & TIPC_NOTIFY_NODE_DOWN)
409 tipc_publ_notify(net, publ_list, addr, n->capabilities);
410
411 if (flags & TIPC_NOTIFY_NODE_UP)
412 tipc_named_node_up(net, addr, n->capabilities);
413
414 if (flags & TIPC_NOTIFY_LINK_UP) {
415 tipc_mon_peer_up(net, addr, bearer_id);
416 tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
417 TIPC_NODE_SCOPE, link_id, link_id);
418 }
419 if (flags & TIPC_NOTIFY_LINK_DOWN) {
420 tipc_mon_peer_down(net, addr, bearer_id);
421 tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
422 addr, link_id);
423 }
424 }
425
tipc_node_assign_peer_net(struct tipc_node * n,u32 hash_mixes)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
tipc_node_create(struct net * net,u32 addr,u8 * peer_id,u16 capabilities,u32 hash_mixes,bool preliminary)454 struct tipc_node *tipc_node_create(struct net *net, u32 addr, u8 *peer_id,
455 u16 capabilities, u32 hash_mixes,
456 bool preliminary)
457 {
458 struct tipc_net *tn = net_generic(net, tipc_net_id);
459 struct tipc_link *l, *snd_l = tipc_bc_sndlink(net);
460 struct tipc_node *n, *temp_node;
461 unsigned long intv;
462 int bearer_id;
463 int i;
464
465 spin_lock_bh(&tn->node_list_lock);
466 n = tipc_node_find(net, addr) ?:
467 tipc_node_find_by_id(net, peer_id);
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);
501 if (n->capabilities == capabilities)
502 goto exit;
503 /* Same node may come back with new capabilities */
504 tipc_node_write_lock(n);
505 n->capabilities = capabilities;
506 for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {
507 l = n->links[bearer_id].link;
508 if (l)
509 tipc_link_update_caps(l, capabilities);
510 }
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
522 goto exit;
523 }
524 n = kzalloc(sizeof(*n), GFP_ATOMIC);
525 if (!n) {
526 pr_warn("Node creation failed, no memory\n");
527 goto exit;
528 }
529 tipc_nodeid2string(n->peer_id_string, peer_id);
530 #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
538 n->addr = addr;
539 n->preliminary = preliminary;
540 memcpy(&n->peer_id, peer_id, 16);
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);
546 n->capabilities = capabilities;
547 kref_init(&n->kref);
548 rwlock_init(&n->lock);
549 INIT_HLIST_NODE(&n->hash);
550 INIT_LIST_HEAD(&n->list);
551 INIT_LIST_HEAD(&n->publ_list);
552 INIT_LIST_HEAD(&n->conn_sks);
553 skb_queue_head_init(&n->bc_entry.namedq);
554 skb_queue_head_init(&n->bc_entry.inputq1);
555 __skb_queue_head_init(&n->bc_entry.arrvq);
556 skb_queue_head_init(&n->bc_entry.inputq2);
557 for (i = 0; i < MAX_BEARERS; i++)
558 spin_lock_init(&n->links[i].lock);
559 n->state = SELF_DOWN_PEER_LEAVING;
560 n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER);
561 n->signature = INVALID_NODE_SIG;
562 n->active_links[0] = INVALID_BEARER_ID;
563 n->active_links[1] = INVALID_BEARER_ID;
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)) {
569 pr_warn("Broadcast rcv link creation failed, no memory\n");
570 kfree(n);
571 n = NULL;
572 goto exit;
573 }
574 tipc_node_get(n);
575 timer_setup(&n->timer, tipc_node_timeout, 0);
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);
581 hlist_add_head_rcu(&n->hash, &tn->node_htable[tipc_hashfn(addr)]);
582 list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
583 if (n->addr < temp_node->addr)
584 break;
585 }
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, " ");
594 exit:
595 spin_unlock_bh(&tn->node_list_lock);
596 return n;
597 }
598
tipc_node_calculate_timer(struct tipc_node * n,struct tipc_link * l)599 static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l)
600 {
601 unsigned long tol = tipc_link_tolerance(l);
602 unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;
603
604 /* Link with lowest tolerance determines timer interval */
605 if (intv < n->keepalive_intv)
606 n->keepalive_intv = intv;
607
608 /* Ensure link's abort limit corresponds to current tolerance */
609 tipc_link_set_abort_limit(l, tol / n->keepalive_intv);
610 }
611
tipc_node_delete_from_list(struct tipc_node * node)612 static void tipc_node_delete_from_list(struct tipc_node *node)
613 {
614 #ifdef CONFIG_TIPC_CRYPTO
615 tipc_crypto_key_flush(node->crypto_rx);
616 #endif
617 list_del_rcu(&node->list);
618 hlist_del_rcu(&node->hash);
619 tipc_node_put(node);
620 }
621
tipc_node_delete(struct tipc_node * node)622 static void tipc_node_delete(struct tipc_node *node)
623 {
624 trace_tipc_node_delete(node, true, " ");
625 tipc_node_delete_from_list(node);
626
627 del_timer_sync(&node->timer);
628 tipc_node_put(node);
629 }
630
tipc_node_stop(struct net * net)631 void tipc_node_stop(struct net *net)
632 {
633 struct tipc_net *tn = tipc_net(net);
634 struct tipc_node *node, *t_node;
635
636 spin_lock_bh(&tn->node_list_lock);
637 list_for_each_entry_safe(node, t_node, &tn->node_list, list)
638 tipc_node_delete(node);
639 spin_unlock_bh(&tn->node_list_lock);
640 }
641
tipc_node_subscribe(struct net * net,struct list_head * subscr,u32 addr)642 void tipc_node_subscribe(struct net *net, struct list_head *subscr, u32 addr)
643 {
644 struct tipc_node *n;
645
646 if (in_own_node(net, addr))
647 return;
648
649 n = tipc_node_find(net, addr);
650 if (!n) {
651 pr_warn("Node subscribe rejected, unknown node 0x%x\n", addr);
652 return;
653 }
654 tipc_node_write_lock(n);
655 list_add_tail(subscr, &n->publ_list);
656 tipc_node_write_unlock_fast(n);
657 tipc_node_put(n);
658 }
659
tipc_node_unsubscribe(struct net * net,struct list_head * subscr,u32 addr)660 void tipc_node_unsubscribe(struct net *net, struct list_head *subscr, u32 addr)
661 {
662 struct tipc_node *n;
663
664 if (in_own_node(net, addr))
665 return;
666
667 n = tipc_node_find(net, addr);
668 if (!n) {
669 pr_warn("Node unsubscribe rejected, unknown node 0x%x\n", addr);
670 return;
671 }
672 tipc_node_write_lock(n);
673 list_del_init(subscr);
674 tipc_node_write_unlock_fast(n);
675 tipc_node_put(n);
676 }
677
tipc_node_add_conn(struct net * net,u32 dnode,u32 port,u32 peer_port)678 int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
679 {
680 struct tipc_node *node;
681 struct tipc_sock_conn *conn;
682 int err = 0;
683
684 if (in_own_node(net, dnode))
685 return 0;
686
687 node = tipc_node_find(net, dnode);
688 if (!node) {
689 pr_warn("Connecting sock to node 0x%x failed\n", dnode);
690 return -EHOSTUNREACH;
691 }
692 conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
693 if (!conn) {
694 err = -EHOSTUNREACH;
695 goto exit;
696 }
697 conn->peer_node = dnode;
698 conn->port = port;
699 conn->peer_port = peer_port;
700
701 tipc_node_write_lock(node);
702 list_add_tail(&conn->list, &node->conn_sks);
703 tipc_node_write_unlock(node);
704 exit:
705 tipc_node_put(node);
706 return err;
707 }
708
tipc_node_remove_conn(struct net * net,u32 dnode,u32 port)709 void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
710 {
711 struct tipc_node *node;
712 struct tipc_sock_conn *conn, *safe;
713
714 if (in_own_node(net, dnode))
715 return;
716
717 node = tipc_node_find(net, dnode);
718 if (!node)
719 return;
720
721 tipc_node_write_lock(node);
722 list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
723 if (port != conn->port)
724 continue;
725 list_del(&conn->list);
726 kfree(conn);
727 }
728 tipc_node_write_unlock(node);
729 tipc_node_put(node);
730 }
731
tipc_node_clear_links(struct tipc_node * node)732 static void tipc_node_clear_links(struct tipc_node *node)
733 {
734 int i;
735
736 for (i = 0; i < MAX_BEARERS; i++) {
737 struct tipc_link_entry *le = &node->links[i];
738
739 if (le->link) {
740 kfree(le->link);
741 le->link = NULL;
742 node->link_cnt--;
743 }
744 }
745 }
746
747 /* tipc_node_cleanup - delete nodes that does not
748 * have active links for NODE_CLEANUP_AFTER time
749 */
tipc_node_cleanup(struct tipc_node * peer)750 static bool tipc_node_cleanup(struct tipc_node *peer)
751 {
752 struct tipc_node *temp_node;
753 struct tipc_net *tn = tipc_net(peer->net);
754 bool deleted = false;
755
756 /* If lock held by tipc_node_stop() the node will be deleted anyway */
757 if (!spin_trylock_bh(&tn->node_list_lock))
758 return false;
759
760 tipc_node_write_lock(peer);
761
762 if (!node_is_up(peer) && time_after(jiffies, peer->delete_at)) {
763 tipc_node_clear_links(peer);
764 tipc_node_delete_from_list(peer);
765 deleted = true;
766 }
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));
781 spin_unlock_bh(&tn->node_list_lock);
782 return deleted;
783 }
784
785 /* tipc_node_timeout - handle expiration of node timer
786 */
tipc_node_timeout(struct timer_list * t)787 static void tipc_node_timeout(struct timer_list *t)
788 {
789 struct tipc_node *n = from_timer(n, t, timer);
790 struct tipc_link_entry *le;
791 struct sk_buff_head xmitq;
792 int remains = n->link_cnt;
793 int bearer_id;
794 int rc = 0;
795
796 trace_tipc_node_timeout(n, false, " ");
797 if (!node_is_up(n) && tipc_node_cleanup(n)) {
798 /*Removing the reference of Timer*/
799 tipc_node_put(n);
800 return;
801 }
802
803 #ifdef CONFIG_TIPC_CRYPTO
804 /* Take any crypto key related actions first */
805 tipc_crypto_timeout(n->crypto_rx);
806 #endif
807 __skb_queue_head_init(&xmitq);
808
809 /* Initial node interval to value larger (10 seconds), then it will be
810 * recalculated with link lowest tolerance
811 */
812 tipc_node_read_lock(n);
813 n->keepalive_intv = 10000;
814 tipc_node_read_unlock(n);
815 for (bearer_id = 0; remains && (bearer_id < MAX_BEARERS); bearer_id++) {
816 tipc_node_read_lock(n);
817 le = &n->links[bearer_id];
818 if (le->link) {
819 spin_lock_bh(&le->lock);
820 /* Link tolerance may change asynchronously: */
821 tipc_node_calculate_timer(n, le->link);
822 rc = tipc_link_timeout(le->link, &xmitq);
823 spin_unlock_bh(&le->lock);
824 remains--;
825 }
826 tipc_node_read_unlock(n);
827 tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr, n);
828 if (rc & TIPC_LINK_DOWN_EVT)
829 tipc_node_link_down(n, bearer_id, false);
830 }
831 mod_timer(&n->timer, jiffies + msecs_to_jiffies(n->keepalive_intv));
832 }
833
834 /**
835 * __tipc_node_link_up - handle addition of link
836 * Node lock must be held by caller
837 * Link becomes active (alone or shared) or standby, depending on its priority.
838 */
__tipc_node_link_up(struct tipc_node * n,int bearer_id,struct sk_buff_head * xmitq)839 static void __tipc_node_link_up(struct tipc_node *n, int bearer_id,
840 struct sk_buff_head *xmitq)
841 {
842 int *slot0 = &n->active_links[0];
843 int *slot1 = &n->active_links[1];
844 struct tipc_link *ol = node_active_link(n, 0);
845 struct tipc_link *nl = n->links[bearer_id].link;
846
847 if (!nl || tipc_link_is_up(nl))
848 return;
849
850 tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT);
851 if (!tipc_link_is_up(nl))
852 return;
853
854 n->working_links++;
855 n->action_flags |= TIPC_NOTIFY_LINK_UP;
856 n->link_id = tipc_link_id(nl);
857
858 /* Leave room for tunnel header when returning 'mtu' to users: */
859 n->links[bearer_id].mtu = tipc_link_mss(nl);
860
861 tipc_bearer_add_dest(n->net, bearer_id, n->addr);
862 tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id);
863
864 pr_debug("Established link <%s> on network plane %c\n",
865 tipc_link_name(nl), tipc_link_plane(nl));
866 trace_tipc_node_link_up(n, true, " ");
867
868 /* Ensure that a STATE message goes first */
869 tipc_link_build_state_msg(nl, xmitq);
870
871 /* First link? => give it both slots */
872 if (!ol) {
873 *slot0 = bearer_id;
874 *slot1 = bearer_id;
875 tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT);
876 n->action_flags |= TIPC_NOTIFY_NODE_UP;
877 tipc_link_set_active(nl, true);
878 tipc_bcast_add_peer(n->net, nl, xmitq);
879 return;
880 }
881
882 /* Second link => redistribute slots */
883 if (tipc_link_prio(nl) > tipc_link_prio(ol)) {
884 pr_debug("Old link <%s> becomes standby\n", tipc_link_name(ol));
885 *slot0 = bearer_id;
886 *slot1 = bearer_id;
887 tipc_link_set_active(nl, true);
888 tipc_link_set_active(ol, false);
889 } else if (tipc_link_prio(nl) == tipc_link_prio(ol)) {
890 tipc_link_set_active(nl, true);
891 *slot1 = bearer_id;
892 } else {
893 pr_debug("New link <%s> is standby\n", tipc_link_name(nl));
894 }
895
896 /* Prepare synchronization with first link */
897 tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq);
898 }
899
900 /**
901 * tipc_node_link_up - handle addition of link
902 *
903 * Link becomes active (alone or shared) or standby, depending on its priority.
904 */
tipc_node_link_up(struct tipc_node * n,int bearer_id,struct sk_buff_head * xmitq)905 static void tipc_node_link_up(struct tipc_node *n, int bearer_id,
906 struct sk_buff_head *xmitq)
907 {
908 struct tipc_media_addr *maddr;
909
910 tipc_node_write_lock(n);
911 __tipc_node_link_up(n, bearer_id, xmitq);
912 maddr = &n->links[bearer_id].maddr;
913 tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr, n);
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 */
tipc_node_link_failover(struct tipc_node * n,struct tipc_link * l,struct tipc_link * tnl,struct sk_buff_head * xmitq)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);
958 }
959
960 /**
961 * __tipc_node_link_down - handle loss of link
962 */
__tipc_node_link_down(struct tipc_node * n,int * bearer_id,struct sk_buff_head * xmitq,struct tipc_media_addr ** maddr)963 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,
964 struct sk_buff_head *xmitq,
965 struct tipc_media_addr **maddr)
966 {
967 struct tipc_link_entry *le = &n->links[*bearer_id];
968 int *slot0 = &n->active_links[0];
969 int *slot1 = &n->active_links[1];
970 int i, highest = 0, prio;
971 struct tipc_link *l, *_l, *tnl;
972
973 l = n->links[*bearer_id].link;
974 if (!l || tipc_link_is_reset(l))
975 return;
976
977 n->working_links--;
978 n->action_flags |= TIPC_NOTIFY_LINK_DOWN;
979 n->link_id = tipc_link_id(l);
980
981 tipc_bearer_remove_dest(n->net, *bearer_id, n->addr);
982
983 pr_debug("Lost link <%s> on network plane %c\n",
984 tipc_link_name(l), tipc_link_plane(l));
985
986 /* Select new active link if any available */
987 *slot0 = INVALID_BEARER_ID;
988 *slot1 = INVALID_BEARER_ID;
989 for (i = 0; i < MAX_BEARERS; i++) {
990 _l = n->links[i].link;
991 if (!_l || !tipc_link_is_up(_l))
992 continue;
993 if (_l == l)
994 continue;
995 prio = tipc_link_prio(_l);
996 if (prio < highest)
997 continue;
998 if (prio > highest) {
999 highest = prio;
1000 *slot0 = i;
1001 *slot1 = i;
1002 continue;
1003 }
1004 *slot1 = i;
1005 }
1006
1007 if (!node_is_up(n)) {
1008 if (tipc_link_peer_is_down(l))
1009 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
1010 tipc_node_fsm_evt(n, SELF_LOST_CONTACT_EVT);
1011 trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down!");
1012 tipc_link_fsm_evt(l, LINK_RESET_EVT);
1013 tipc_link_reset(l);
1014 tipc_link_build_reset_msg(l, xmitq);
1015 *maddr = &n->links[*bearer_id].maddr;
1016 node_lost_contact(n, &le->inputq);
1017 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
1018 return;
1019 }
1020 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
1021
1022 /* There is still a working link => initiate failover */
1023 *bearer_id = n->active_links[0];
1024 tnl = n->links[*bearer_id].link;
1025 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
1026 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
1027 n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1);
1028 tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq);
1029 trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down -> failover!");
1030 tipc_link_reset(l);
1031 tipc_link_fsm_evt(l, LINK_RESET_EVT);
1032 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
1033 tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT);
1034 *maddr = &n->links[*bearer_id].maddr;
1035 }
1036
tipc_node_link_down(struct tipc_node * n,int bearer_id,bool delete)1037 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, bool delete)
1038 {
1039 struct tipc_link_entry *le = &n->links[bearer_id];
1040 struct tipc_media_addr *maddr = NULL;
1041 struct tipc_link *l = le->link;
1042 int old_bearer_id = bearer_id;
1043 struct sk_buff_head xmitq;
1044
1045 if (!l)
1046 return;
1047
1048 __skb_queue_head_init(&xmitq);
1049
1050 tipc_node_write_lock(n);
1051 if (!tipc_link_is_establishing(l)) {
1052 __tipc_node_link_down(n, &bearer_id, &xmitq, &maddr);
1053 } else {
1054 /* Defuse pending tipc_node_link_up() */
1055 tipc_link_reset(l);
1056 tipc_link_fsm_evt(l, LINK_RESET_EVT);
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!");
1064 tipc_node_write_unlock(n);
1065 if (delete)
1066 tipc_mon_remove_peer(n->net, n->addr, old_bearer_id);
1067 if (!skb_queue_empty(&xmitq))
1068 tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr, n);
1069 tipc_sk_rcv(n->net, &le->inputq);
1070 }
1071
node_is_up(struct tipc_node * n)1072 static bool node_is_up(struct tipc_node *n)
1073 {
1074 return n->active_links[0] != INVALID_BEARER_ID;
1075 }
1076
tipc_node_is_up(struct net * net,u32 addr)1077 bool tipc_node_is_up(struct net *net, u32 addr)
1078 {
1079 struct tipc_node *n;
1080 bool retval = false;
1081
1082 if (in_own_node(net, addr))
1083 return true;
1084
1085 n = tipc_node_find(net, addr);
1086 if (!n)
1087 return false;
1088 retval = node_is_up(n);
1089 tipc_node_put(n);
1090 return retval;
1091 }
1092
tipc_node_suggest_addr(struct net * net,u32 addr)1093 static u32 tipc_node_suggest_addr(struct net *net, u32 addr)
1094 {
1095 struct tipc_node *n;
1096
1097 addr ^= tipc_net(net)->random;
1098 while ((n = tipc_node_find(net, addr))) {
1099 tipc_node_put(n);
1100 addr++;
1101 }
1102 return addr;
1103 }
1104
1105 /* tipc_node_try_addr(): Check if addr can be used by peer, suggest other if not
1106 * Returns suggested address if any, otherwise 0
1107 */
tipc_node_try_addr(struct net * net,u8 * id,u32 addr)1108 u32 tipc_node_try_addr(struct net *net, u8 *id, u32 addr)
1109 {
1110 struct tipc_net *tn = tipc_net(net);
1111 struct tipc_node *n;
1112 bool preliminary;
1113 u32 sugg_addr;
1114
1115 /* Suggest new address if some other peer is using this one */
1116 n = tipc_node_find(net, addr);
1117 if (n) {
1118 if (!memcmp(n->peer_id, id, NODE_ID_LEN))
1119 addr = 0;
1120 tipc_node_put(n);
1121 if (!addr)
1122 return 0;
1123 return tipc_node_suggest_addr(net, addr);
1124 }
1125
1126 /* Suggest previously used address if peer is known */
1127 n = tipc_node_find_by_id(net, id);
1128 if (n) {
1129 sugg_addr = n->addr;
1130 preliminary = n->preliminary;
1131 tipc_node_put(n);
1132 if (!preliminary)
1133 return sugg_addr;
1134 }
1135
1136 /* Even this node may be in conflict */
1137 if (tn->trial_addr == addr)
1138 return tipc_node_suggest_addr(net, addr);
1139
1140 return 0;
1141 }
1142
tipc_node_check_dest(struct net * net,u32 addr,u8 * peer_id,struct tipc_bearer * b,u16 capabilities,u32 signature,u32 hash_mixes,struct tipc_media_addr * maddr,bool * respond,bool * dupl_addr)1143 void tipc_node_check_dest(struct net *net, u32 addr,
1144 u8 *peer_id, struct tipc_bearer *b,
1145 u16 capabilities, u32 signature, u32 hash_mixes,
1146 struct tipc_media_addr *maddr,
1147 bool *respond, bool *dupl_addr)
1148 {
1149 struct tipc_node *n;
1150 struct tipc_link *l;
1151 struct tipc_link_entry *le;
1152 bool addr_match = false;
1153 bool sign_match = false;
1154 bool link_up = false;
1155 bool accept_addr = false;
1156 bool reset = true;
1157 char *if_name;
1158 unsigned long intv;
1159 u16 session;
1160
1161 *dupl_addr = false;
1162 *respond = false;
1163
1164 n = tipc_node_create(net, addr, peer_id, capabilities, hash_mixes,
1165 false);
1166 if (!n)
1167 return;
1168
1169 tipc_node_write_lock(n);
1170
1171 le = &n->links[b->identity];
1172
1173 /* Prepare to validate requesting node's signature and media address */
1174 l = le->link;
1175 link_up = l && tipc_link_is_up(l);
1176 addr_match = l && !memcmp(&le->maddr, maddr, sizeof(*maddr));
1177 sign_match = (signature == n->signature);
1178
1179 /* These three flags give us eight permutations: */
1180
1181 if (sign_match && addr_match && link_up) {
1182 /* All is fine. Do nothing. */
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;
1187 } else if (sign_match && addr_match && !link_up) {
1188 /* Respond. The link will come up in due time */
1189 *respond = true;
1190 } else if (sign_match && !addr_match && link_up) {
1191 /* Peer has changed i/f address without rebooting.
1192 * If so, the link will reset soon, and the next
1193 * discovery will be accepted. So we can ignore it.
1194 * It may also be an cloned or malicious peer having
1195 * chosen the same node address and signature as an
1196 * existing one.
1197 * Ignore requests until the link goes down, if ever.
1198 */
1199 *dupl_addr = true;
1200 } else if (sign_match && !addr_match && !link_up) {
1201 /* Peer link has changed i/f address without rebooting.
1202 * It may also be a cloned or malicious peer; we can't
1203 * distinguish between the two.
1204 * The signature is correct, so we must accept.
1205 */
1206 accept_addr = true;
1207 *respond = true;
1208 } else if (!sign_match && addr_match && link_up) {
1209 /* Peer node rebooted. Two possibilities:
1210 * - Delayed re-discovery; this link endpoint has already
1211 * reset and re-established contact with the peer, before
1212 * receiving a discovery message from that node.
1213 * (The peer happened to receive one from this node first).
1214 * - The peer came back so fast that our side has not
1215 * discovered it yet. Probing from this side will soon
1216 * reset the link, since there can be no working link
1217 * endpoint at the peer end, and the link will re-establish.
1218 * Accept the signature, since it comes from a known peer.
1219 */
1220 n->signature = signature;
1221 } else if (!sign_match && addr_match && !link_up) {
1222 /* The peer node has rebooted.
1223 * Accept signature, since it is a known peer.
1224 */
1225 n->signature = signature;
1226 *respond = true;
1227 } else if (!sign_match && !addr_match && link_up) {
1228 /* Peer rebooted with new address, or a new/duplicate peer.
1229 * Ignore until the link goes down, if ever.
1230 */
1231 *dupl_addr = true;
1232 } else if (!sign_match && !addr_match && !link_up) {
1233 /* Peer rebooted with new address, or it is a new peer.
1234 * Accept signature and address.
1235 */
1236 n->signature = signature;
1237 accept_addr = true;
1238 *respond = true;
1239 }
1240
1241 if (!accept_addr)
1242 goto exit;
1243
1244 /* Now create new link if not already existing */
1245 if (!l) {
1246 if (n->link_cnt == 2)
1247 goto exit;
1248
1249 if_name = strchr(b->name, ':') + 1;
1250 get_random_bytes(&session, sizeof(u16));
1251 if (!tipc_link_create(net, if_name, b->identity, b->tolerance,
1252 b->net_plane, b->mtu, b->priority,
1253 b->min_win, b->max_win, session,
1254 tipc_own_addr(net), addr, peer_id,
1255 n->capabilities,
1256 tipc_bc_sndlink(n->net), n->bc_entry.link,
1257 &le->inputq,
1258 &n->bc_entry.namedq, &l)) {
1259 *respond = false;
1260 goto exit;
1261 }
1262 trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link created!");
1263 tipc_link_reset(l);
1264 tipc_link_fsm_evt(l, LINK_RESET_EVT);
1265 if (n->state == NODE_FAILINGOVER)
1266 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
1267 le->link = l;
1268 n->link_cnt++;
1269 tipc_node_calculate_timer(n, l);
1270 if (n->link_cnt == 1) {
1271 intv = jiffies + msecs_to_jiffies(n->keepalive_intv);
1272 if (!mod_timer(&n->timer, intv))
1273 tipc_node_get(n);
1274 }
1275 }
1276 memcpy(&le->maddr, maddr, sizeof(*maddr));
1277 exit:
1278 tipc_node_write_unlock(n);
1279 if (reset && l && !tipc_link_is_reset(l))
1280 tipc_node_link_down(n, b->identity, false);
1281 tipc_node_put(n);
1282 }
1283
tipc_node_delete_links(struct net * net,int bearer_id)1284 void tipc_node_delete_links(struct net *net, int bearer_id)
1285 {
1286 struct tipc_net *tn = net_generic(net, tipc_net_id);
1287 struct tipc_node *n;
1288
1289 rcu_read_lock();
1290 list_for_each_entry_rcu(n, &tn->node_list, list) {
1291 tipc_node_link_down(n, bearer_id, true);
1292 }
1293 rcu_read_unlock();
1294 }
1295
tipc_node_reset_links(struct tipc_node * n)1296 static void tipc_node_reset_links(struct tipc_node *n)
1297 {
1298 int i;
1299
1300 pr_warn("Resetting all links to %x\n", n->addr);
1301
1302 trace_tipc_node_reset_links(n, true, " ");
1303 for (i = 0; i < MAX_BEARERS; i++) {
1304 tipc_node_link_down(n, i, false);
1305 }
1306 }
1307
1308 /* tipc_node_fsm_evt - node finite state machine
1309 * Determines when contact is allowed with peer node
1310 */
tipc_node_fsm_evt(struct tipc_node * n,int evt)1311 static void tipc_node_fsm_evt(struct tipc_node *n, int evt)
1312 {
1313 int state = n->state;
1314
1315 switch (state) {
1316 case SELF_DOWN_PEER_DOWN:
1317 switch (evt) {
1318 case SELF_ESTABL_CONTACT_EVT:
1319 state = SELF_UP_PEER_COMING;
1320 break;
1321 case PEER_ESTABL_CONTACT_EVT:
1322 state = SELF_COMING_PEER_UP;
1323 break;
1324 case SELF_LOST_CONTACT_EVT:
1325 case PEER_LOST_CONTACT_EVT:
1326 break;
1327 case NODE_SYNCH_END_EVT:
1328 case NODE_SYNCH_BEGIN_EVT:
1329 case NODE_FAILOVER_BEGIN_EVT:
1330 case NODE_FAILOVER_END_EVT:
1331 default:
1332 goto illegal_evt;
1333 }
1334 break;
1335 case SELF_UP_PEER_UP:
1336 switch (evt) {
1337 case SELF_LOST_CONTACT_EVT:
1338 state = SELF_DOWN_PEER_LEAVING;
1339 break;
1340 case PEER_LOST_CONTACT_EVT:
1341 state = SELF_LEAVING_PEER_DOWN;
1342 break;
1343 case NODE_SYNCH_BEGIN_EVT:
1344 state = NODE_SYNCHING;
1345 break;
1346 case NODE_FAILOVER_BEGIN_EVT:
1347 state = NODE_FAILINGOVER;
1348 break;
1349 case SELF_ESTABL_CONTACT_EVT:
1350 case PEER_ESTABL_CONTACT_EVT:
1351 case NODE_SYNCH_END_EVT:
1352 case NODE_FAILOVER_END_EVT:
1353 break;
1354 default:
1355 goto illegal_evt;
1356 }
1357 break;
1358 case SELF_DOWN_PEER_LEAVING:
1359 switch (evt) {
1360 case PEER_LOST_CONTACT_EVT:
1361 state = SELF_DOWN_PEER_DOWN;
1362 break;
1363 case SELF_ESTABL_CONTACT_EVT:
1364 case PEER_ESTABL_CONTACT_EVT:
1365 case SELF_LOST_CONTACT_EVT:
1366 break;
1367 case NODE_SYNCH_END_EVT:
1368 case NODE_SYNCH_BEGIN_EVT:
1369 case NODE_FAILOVER_BEGIN_EVT:
1370 case NODE_FAILOVER_END_EVT:
1371 default:
1372 goto illegal_evt;
1373 }
1374 break;
1375 case SELF_UP_PEER_COMING:
1376 switch (evt) {
1377 case PEER_ESTABL_CONTACT_EVT:
1378 state = SELF_UP_PEER_UP;
1379 break;
1380 case SELF_LOST_CONTACT_EVT:
1381 state = SELF_DOWN_PEER_DOWN;
1382 break;
1383 case SELF_ESTABL_CONTACT_EVT:
1384 case PEER_LOST_CONTACT_EVT:
1385 case NODE_SYNCH_END_EVT:
1386 case NODE_FAILOVER_BEGIN_EVT:
1387 break;
1388 case NODE_SYNCH_BEGIN_EVT:
1389 case NODE_FAILOVER_END_EVT:
1390 default:
1391 goto illegal_evt;
1392 }
1393 break;
1394 case SELF_COMING_PEER_UP:
1395 switch (evt) {
1396 case SELF_ESTABL_CONTACT_EVT:
1397 state = SELF_UP_PEER_UP;
1398 break;
1399 case PEER_LOST_CONTACT_EVT:
1400 state = SELF_DOWN_PEER_DOWN;
1401 break;
1402 case SELF_LOST_CONTACT_EVT:
1403 case PEER_ESTABL_CONTACT_EVT:
1404 break;
1405 case NODE_SYNCH_END_EVT:
1406 case NODE_SYNCH_BEGIN_EVT:
1407 case NODE_FAILOVER_BEGIN_EVT:
1408 case NODE_FAILOVER_END_EVT:
1409 default:
1410 goto illegal_evt;
1411 }
1412 break;
1413 case SELF_LEAVING_PEER_DOWN:
1414 switch (evt) {
1415 case SELF_LOST_CONTACT_EVT:
1416 state = SELF_DOWN_PEER_DOWN;
1417 break;
1418 case SELF_ESTABL_CONTACT_EVT:
1419 case PEER_ESTABL_CONTACT_EVT:
1420 case PEER_LOST_CONTACT_EVT:
1421 break;
1422 case NODE_SYNCH_END_EVT:
1423 case NODE_SYNCH_BEGIN_EVT:
1424 case NODE_FAILOVER_BEGIN_EVT:
1425 case NODE_FAILOVER_END_EVT:
1426 default:
1427 goto illegal_evt;
1428 }
1429 break;
1430 case NODE_FAILINGOVER:
1431 switch (evt) {
1432 case SELF_LOST_CONTACT_EVT:
1433 state = SELF_DOWN_PEER_LEAVING;
1434 break;
1435 case PEER_LOST_CONTACT_EVT:
1436 state = SELF_LEAVING_PEER_DOWN;
1437 break;
1438 case NODE_FAILOVER_END_EVT:
1439 state = SELF_UP_PEER_UP;
1440 break;
1441 case NODE_FAILOVER_BEGIN_EVT:
1442 case SELF_ESTABL_CONTACT_EVT:
1443 case PEER_ESTABL_CONTACT_EVT:
1444 break;
1445 case NODE_SYNCH_BEGIN_EVT:
1446 case NODE_SYNCH_END_EVT:
1447 default:
1448 goto illegal_evt;
1449 }
1450 break;
1451 case NODE_SYNCHING:
1452 switch (evt) {
1453 case SELF_LOST_CONTACT_EVT:
1454 state = SELF_DOWN_PEER_LEAVING;
1455 break;
1456 case PEER_LOST_CONTACT_EVT:
1457 state = SELF_LEAVING_PEER_DOWN;
1458 break;
1459 case NODE_SYNCH_END_EVT:
1460 state = SELF_UP_PEER_UP;
1461 break;
1462 case NODE_FAILOVER_BEGIN_EVT:
1463 state = NODE_FAILINGOVER;
1464 break;
1465 case NODE_SYNCH_BEGIN_EVT:
1466 case SELF_ESTABL_CONTACT_EVT:
1467 case PEER_ESTABL_CONTACT_EVT:
1468 break;
1469 case NODE_FAILOVER_END_EVT:
1470 default:
1471 goto illegal_evt;
1472 }
1473 break;
1474 default:
1475 pr_err("Unknown node fsm state %x\n", state);
1476 break;
1477 }
1478 trace_tipc_node_fsm(n->peer_id, n->state, state, evt);
1479 n->state = state;
1480 return;
1481
1482 illegal_evt:
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);
1485 }
1486
node_lost_contact(struct tipc_node * n,struct sk_buff_head * inputq)1487 static void node_lost_contact(struct tipc_node *n,
1488 struct sk_buff_head *inputq)
1489 {
1490 struct tipc_sock_conn *conn, *safe;
1491 struct tipc_link *l;
1492 struct list_head *conns = &n->conn_sks;
1493 struct sk_buff *skb;
1494 uint i;
1495
1496 pr_debug("Lost contact with %x\n", n->addr);
1497 n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER);
1498 trace_tipc_node_lost_contact(n, true, " ");
1499
1500 /* Clean up broadcast state */
1501 tipc_bcast_remove_peer(n->net, n->bc_entry.link);
1502 skb_queue_purge(&n->bc_entry.namedq);
1503
1504 /* Abort any ongoing link failover */
1505 for (i = 0; i < MAX_BEARERS; i++) {
1506 l = n->links[i].link;
1507 if (l)
1508 tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT);
1509 }
1510
1511 /* Notify publications from this node */
1512 n->action_flags |= TIPC_NOTIFY_NODE_DOWN;
1513 n->peer_net = NULL;
1514 n->peer_hash_mix = 0;
1515 /* Notify sockets connected to node */
1516 list_for_each_entry_safe(conn, safe, conns, list) {
1517 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
1518 SHORT_H_SIZE, 0, tipc_own_addr(n->net),
1519 conn->peer_node, conn->port,
1520 conn->peer_port, TIPC_ERR_NO_NODE);
1521 if (likely(skb))
1522 skb_queue_tail(inputq, skb);
1523 list_del(&conn->list);
1524 kfree(conn);
1525 }
1526 }
1527
1528 /**
1529 * tipc_node_get_linkname - get the name of a link
1530 *
1531 * @bearer_id: id of the bearer
1532 * @addr: peer node address
1533 * @linkname: link name output buffer
1534 *
1535 * Returns 0 on success
1536 */
tipc_node_get_linkname(struct net * net,u32 bearer_id,u32 addr,char * linkname,size_t len)1537 int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
1538 char *linkname, size_t len)
1539 {
1540 struct tipc_link *link;
1541 int err = -EINVAL;
1542 struct tipc_node *node = tipc_node_find(net, addr);
1543
1544 if (!node)
1545 return err;
1546
1547 if (bearer_id >= MAX_BEARERS)
1548 goto exit;
1549
1550 tipc_node_read_lock(node);
1551 link = node->links[bearer_id].link;
1552 if (link) {
1553 strncpy(linkname, tipc_link_name(link), len);
1554 err = 0;
1555 }
1556 tipc_node_read_unlock(node);
1557 exit:
1558 tipc_node_put(node);
1559 return err;
1560 }
1561
1562 /* Caller should hold node lock for the passed node */
__tipc_nl_add_node(struct tipc_nl_msg * msg,struct tipc_node * node)1563 static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
1564 {
1565 void *hdr;
1566 struct nlattr *attrs;
1567
1568 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
1569 NLM_F_MULTI, TIPC_NL_NODE_GET);
1570 if (!hdr)
1571 return -EMSGSIZE;
1572
1573 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_NODE);
1574 if (!attrs)
1575 goto msg_full;
1576
1577 if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
1578 goto attr_msg_full;
1579 if (node_is_up(node))
1580 if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP))
1581 goto attr_msg_full;
1582
1583 nla_nest_end(msg->skb, attrs);
1584 genlmsg_end(msg->skb, hdr);
1585
1586 return 0;
1587
1588 attr_msg_full:
1589 nla_nest_cancel(msg->skb, attrs);
1590 msg_full:
1591 genlmsg_cancel(msg->skb, hdr);
1592
1593 return -EMSGSIZE;
1594 }
1595
tipc_lxc_xmit(struct net * peer_net,struct sk_buff_head * list)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
1647 /**
1648 * tipc_node_xmit() is the general link level function for message sending
1649 * @net: the applicable net namespace
1650 * @list: chain of buffers containing message
1651 * @dnode: address of destination node
1652 * @selector: a number used for deterministic link selection
1653 * Consumes the buffer chain.
1654 * Returns 0 if success, otherwise: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE,-ENOBUF
1655 */
tipc_node_xmit(struct net * net,struct sk_buff_head * list,u32 dnode,int selector)1656 int tipc_node_xmit(struct net *net, struct sk_buff_head *list,
1657 u32 dnode, int selector)
1658 {
1659 struct tipc_link_entry *le = NULL;
1660 struct tipc_node *n;
1661 struct sk_buff_head xmitq;
1662 bool node_up = false;
1663 struct net *peer_net;
1664 int bearer_id;
1665 int rc;
1666
1667 if (in_own_node(net, dnode)) {
1668 tipc_loopback_trace(net, list);
1669 spin_lock_init(&list->lock);
1670 tipc_sk_rcv(net, list);
1671 return 0;
1672 }
1673
1674 n = tipc_node_find(net, dnode);
1675 if (unlikely(!n)) {
1676 __skb_queue_purge(list);
1677 return -EHOSTUNREACH;
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();
1695
1696 tipc_node_read_lock(n);
1697 bearer_id = n->active_links[selector & 1];
1698 if (unlikely(bearer_id == INVALID_BEARER_ID)) {
1699 tipc_node_read_unlock(n);
1700 tipc_node_put(n);
1701 __skb_queue_purge(list);
1702 return -EHOSTUNREACH;
1703 }
1704
1705 __skb_queue_head_init(&xmitq);
1706 le = &n->links[bearer_id];
1707 spin_lock_bh(&le->lock);
1708 rc = tipc_link_xmit(le->link, list, &xmitq);
1709 spin_unlock_bh(&le->lock);
1710 tipc_node_read_unlock(n);
1711
1712 if (unlikely(rc == -ENOBUFS))
1713 tipc_node_link_down(n, bearer_id, false);
1714 else
1715 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n);
1716
1717 tipc_node_put(n);
1718
1719 return rc;
1720 }
1721
1722 /* tipc_node_xmit_skb(): send single buffer to destination
1723 * Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE
1724 * messages, which will not be rejected
1725 * The only exception is datagram messages rerouted after secondary
1726 * lookup, which are rare and safe to dispose of anyway.
1727 */
tipc_node_xmit_skb(struct net * net,struct sk_buff * skb,u32 dnode,u32 selector)1728 int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode,
1729 u32 selector)
1730 {
1731 struct sk_buff_head head;
1732
1733 __skb_queue_head_init(&head);
1734 __skb_queue_tail(&head, skb);
1735 tipc_node_xmit(net, &head, dnode, selector);
1736 return 0;
1737 }
1738
1739 /* tipc_node_distr_xmit(): send single buffer msgs to individual destinations
1740 * Note: this is only for SYSTEM_IMPORTANCE messages, which cannot be rejected
1741 */
tipc_node_distr_xmit(struct net * net,struct sk_buff_head * xmitq)1742 int tipc_node_distr_xmit(struct net *net, struct sk_buff_head *xmitq)
1743 {
1744 struct sk_buff *skb;
1745 u32 selector, dnode;
1746
1747 while ((skb = __skb_dequeue(xmitq))) {
1748 selector = msg_origport(buf_msg(skb));
1749 dnode = msg_destnode(buf_msg(skb));
1750 tipc_node_xmit_skb(net, skb, dnode, selector);
1751 }
1752 return 0;
1753 }
1754
tipc_node_broadcast(struct net * net,struct sk_buff * skb,int rc_dests)1755 void tipc_node_broadcast(struct net *net, struct sk_buff *skb, int rc_dests)
1756 {
1757 struct sk_buff_head xmitq;
1758 struct sk_buff *txskb;
1759 struct tipc_node *n;
1760 u16 dummy;
1761 u32 dst;
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 */
1772 rcu_read_lock();
1773 list_for_each_entry_rcu(n, tipc_nodes(net), list) {
1774 dst = n->addr;
1775 if (in_own_node(net, dst))
1776 continue;
1777 if (!node_is_up(n))
1778 continue;
1779 txskb = pskb_copy(skb, GFP_ATOMIC);
1780 if (!txskb)
1781 break;
1782 msg_set_destnode(buf_msg(txskb), dst);
1783 tipc_node_xmit_skb(net, txskb, dst, 0);
1784 }
1785 rcu_read_unlock();
1786 kfree_skb(skb);
1787 }
1788
tipc_node_mcast_rcv(struct tipc_node * n)1789 static void tipc_node_mcast_rcv(struct tipc_node *n)
1790 {
1791 struct tipc_bclink_entry *be = &n->bc_entry;
1792
1793 /* 'arrvq' is under inputq2's lock protection */
1794 spin_lock_bh(&be->inputq2.lock);
1795 spin_lock_bh(&be->inputq1.lock);
1796 skb_queue_splice_tail_init(&be->inputq1, &be->arrvq);
1797 spin_unlock_bh(&be->inputq1.lock);
1798 spin_unlock_bh(&be->inputq2.lock);
1799 tipc_sk_mcast_rcv(n->net, &be->arrvq, &be->inputq2);
1800 }
1801
tipc_node_bc_sync_rcv(struct tipc_node * n,struct tipc_msg * hdr,int bearer_id,struct sk_buff_head * xmitq)1802 static void tipc_node_bc_sync_rcv(struct tipc_node *n, struct tipc_msg *hdr,
1803 int bearer_id, struct sk_buff_head *xmitq)
1804 {
1805 struct tipc_link *ucl;
1806 int rc;
1807
1808 rc = tipc_bcast_sync_rcv(n->net, n->bc_entry.link, hdr, xmitq);
1809
1810 if (rc & TIPC_LINK_DOWN_EVT) {
1811 tipc_node_reset_links(n);
1812 return;
1813 }
1814
1815 if (!(rc & TIPC_LINK_SND_STATE))
1816 return;
1817
1818 /* If probe message, a STATE response will be sent anyway */
1819 if (msg_probe(hdr))
1820 return;
1821
1822 /* Produce a STATE message carrying broadcast NACK */
1823 tipc_node_read_lock(n);
1824 ucl = n->links[bearer_id].link;
1825 if (ucl)
1826 tipc_link_build_state_msg(ucl, xmitq);
1827 tipc_node_read_unlock(n);
1828 }
1829
1830 /**
1831 * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node
1832 * @net: the applicable net namespace
1833 * @skb: TIPC packet
1834 * @bearer_id: id of bearer message arrived on
1835 *
1836 * Invoked with no locks held.
1837 */
tipc_node_bc_rcv(struct net * net,struct sk_buff * skb,int bearer_id)1838 static void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id)
1839 {
1840 int rc;
1841 struct sk_buff_head xmitq;
1842 struct tipc_bclink_entry *be;
1843 struct tipc_link_entry *le;
1844 struct tipc_msg *hdr = buf_msg(skb);
1845 int usr = msg_user(hdr);
1846 u32 dnode = msg_destnode(hdr);
1847 struct tipc_node *n;
1848
1849 __skb_queue_head_init(&xmitq);
1850
1851 /* If NACK for other node, let rcv link for that node peek into it */
1852 if ((usr == BCAST_PROTOCOL) && (dnode != tipc_own_addr(net)))
1853 n = tipc_node_find(net, dnode);
1854 else
1855 n = tipc_node_find(net, msg_prevnode(hdr));
1856 if (!n) {
1857 kfree_skb(skb);
1858 return;
1859 }
1860 be = &n->bc_entry;
1861 le = &n->links[bearer_id];
1862
1863 rc = tipc_bcast_rcv(net, be->link, skb);
1864
1865 /* Broadcast ACKs are sent on a unicast link */
1866 if (rc & TIPC_LINK_SND_STATE) {
1867 tipc_node_read_lock(n);
1868 tipc_link_build_state_msg(le->link, &xmitq);
1869 tipc_node_read_unlock(n);
1870 }
1871
1872 if (!skb_queue_empty(&xmitq))
1873 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n);
1874
1875 if (!skb_queue_empty(&be->inputq1))
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);
1883
1884 /* If reassembly or retransmission failure => reset all links to peer */
1885 if (rc & TIPC_LINK_DOWN_EVT)
1886 tipc_node_reset_links(n);
1887
1888 tipc_node_put(n);
1889 }
1890
1891 /**
1892 * tipc_node_check_state - check and if necessary update node state
1893 * @skb: TIPC packet
1894 * @bearer_id: identity of bearer delivering the packet
1895 * Returns true if state and msg are ok, otherwise false
1896 */
tipc_node_check_state(struct tipc_node * n,struct sk_buff * skb,int bearer_id,struct sk_buff_head * xmitq)1897 static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb,
1898 int bearer_id, struct sk_buff_head *xmitq)
1899 {
1900 struct tipc_msg *hdr = buf_msg(skb);
1901 int usr = msg_user(hdr);
1902 int mtyp = msg_type(hdr);
1903 u16 oseqno = msg_seqno(hdr);
1904 u16 exp_pkts = msg_msgcnt(hdr);
1905 u16 rcv_nxt, syncpt, dlv_nxt, inputq_len;
1906 int state = n->state;
1907 struct tipc_link *l, *tnl, *pl = NULL;
1908 struct tipc_media_addr *maddr;
1909 int pb_id;
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 }
1915 l = n->links[bearer_id].link;
1916 if (!l)
1917 return false;
1918 rcv_nxt = tipc_link_rcv_nxt(l);
1919
1920
1921 if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL)))
1922 return true;
1923
1924 /* Find parallel link, if any */
1925 for (pb_id = 0; pb_id < MAX_BEARERS; pb_id++) {
1926 if ((pb_id != bearer_id) && n->links[pb_id].link) {
1927 pl = n->links[pb_id].link;
1928 break;
1929 }
1930 }
1931
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)!");
1935 return false;
1936 }
1937
1938 /* Check and update node accesibility if applicable */
1939 if (state == SELF_UP_PEER_COMING) {
1940 if (!tipc_link_is_up(l))
1941 return true;
1942 if (!msg_peer_link_is_up(hdr))
1943 return true;
1944 tipc_node_fsm_evt(n, PEER_ESTABL_CONTACT_EVT);
1945 }
1946
1947 if (state == SELF_DOWN_PEER_LEAVING) {
1948 if (msg_peer_node_is_up(hdr))
1949 return false;
1950 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
1951 return true;
1952 }
1953
1954 if (state == SELF_LEAVING_PEER_DOWN)
1955 return false;
1956
1957 /* Ignore duplicate packets */
1958 if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt))
1959 return true;
1960
1961 /* Initiate or update failover mode if applicable */
1962 if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) {
1963 syncpt = oseqno + exp_pkts - 1;
1964 if (pl && !tipc_link_is_reset(pl)) {
1965 __tipc_node_link_down(n, &pb_id, xmitq, &maddr);
1966 trace_tipc_node_link_down(n, true,
1967 "node link down <- failover!");
1968 tipc_skb_queue_splice_tail_init(tipc_link_inputq(pl),
1969 tipc_link_inputq(l));
1970 }
1971
1972 /* If parallel link was already down, and this happened before
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.
1977 */
1978 if (n->state != NODE_FAILINGOVER)
1979 tipc_node_link_failover(n, pl, l, xmitq);
1980
1981 /* If pkts arrive out of order, use lowest calculated syncpt */
1982 if (less(syncpt, n->sync_point))
1983 n->sync_point = syncpt;
1984 }
1985
1986 /* Open parallel link when tunnel link reaches synch point */
1987 if ((n->state == NODE_FAILINGOVER) && tipc_link_is_up(l)) {
1988 if (!more(rcv_nxt, n->sync_point))
1989 return true;
1990 tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT);
1991 if (pl)
1992 tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT);
1993 return true;
1994 }
1995
1996 /* No synching needed if only one link */
1997 if (!pl || !tipc_link_is_up(pl))
1998 return true;
1999
2000 /* Initiate synch mode if applicable */
2001 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 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;
2006 if (!tipc_link_is_up(l))
2007 __tipc_node_link_up(n, bearer_id, xmitq);
2008 if (n->state == SELF_UP_PEER_UP) {
2009 n->sync_point = syncpt;
2010 tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT);
2011 tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT);
2012 }
2013 }
2014
2015 /* Open tunnel link when parallel link reaches synch point */
2016 if (n->state == NODE_SYNCHING) {
2017 if (tipc_link_is_synching(l)) {
2018 tnl = l;
2019 } else {
2020 tnl = pl;
2021 pl = l;
2022 }
2023 inputq_len = skb_queue_len(tipc_link_inputq(pl));
2024 dlv_nxt = tipc_link_rcv_nxt(pl) - inputq_len;
2025 if (more(dlv_nxt, n->sync_point)) {
2026 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
2027 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
2028 return true;
2029 }
2030 if (l == pl)
2031 return true;
2032 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG))
2033 return true;
2034 if (usr == LINK_PROTOCOL)
2035 return true;
2036 return false;
2037 }
2038 return true;
2039 }
2040
2041 /**
2042 * tipc_rcv - process TIPC packets/messages arriving from off-node
2043 * @net: the applicable net namespace
2044 * @skb: TIPC packet
2045 * @b: pointer to bearer message arrived on
2046 *
2047 * Invoked with no locks held. Bearer pointer must point to a valid bearer
2048 * structure (i.e. cannot be NULL), but bearer can be inactive.
2049 */
tipc_rcv(struct net * net,struct sk_buff * skb,struct tipc_bearer * b)2050 void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b)
2051 {
2052 struct sk_buff_head xmitq;
2053 struct tipc_link_entry *le;
2054 struct tipc_msg *hdr;
2055 struct tipc_node *n;
2056 int bearer_id = b->identity;
2057 u32 self = tipc_own_addr(net);
2058 int usr, rc = 0;
2059 u16 bc_ack;
2060 #ifdef CONFIG_TIPC_CRYPTO
2061 struct tipc_ehdr *ehdr;
2062
2063 /* Check if message must be decrypted first */
2064 if (TIPC_SKB_CB(skb)->decrypted || !tipc_ehdr_validate(skb))
2065 goto rcv;
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
2081 /* Ensure message is well-formed before touching the header */
2082 if (unlikely(!tipc_msg_validate(&skb)))
2083 goto discard;
2084 __skb_queue_head_init(&xmitq);
2085 hdr = buf_msg(skb);
2086 usr = msg_user(hdr);
2087 bc_ack = msg_bcast_ack(hdr);
2088
2089 /* Handle arrival of discovery or broadcast packet */
2090 if (unlikely(msg_non_seq(hdr))) {
2091 if (unlikely(usr == LINK_CONFIG))
2092 return tipc_disc_rcv(net, skb, b);
2093 else
2094 return tipc_node_bc_rcv(net, skb, bearer_id);
2095 }
2096
2097 /* Discard unicast link messages destined for another node */
2098 if (unlikely(!msg_short(hdr) && (msg_destnode(hdr) != self)))
2099 goto discard;
2100
2101 /* Locate neighboring node that sent packet */
2102 n = tipc_node_find(net, msg_prevnode(hdr));
2103 if (unlikely(!n))
2104 goto discard;
2105 le = &n->links[bearer_id];
2106
2107 /* Ensure broadcast reception is in synch with peer's send state */
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);
2114 tipc_node_bc_sync_rcv(n, hdr, bearer_id, &xmitq);
2115 } else if (unlikely(tipc_link_acked(n->bc_entry.link) != bc_ack)) {
2116 tipc_bcast_ack_rcv(net, n->bc_entry.link, hdr);
2117 }
2118
2119 /* Receive packet directly if conditions permit */
2120 tipc_node_read_lock(n);
2121 if (likely((n->state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) {
2122 spin_lock_bh(&le->lock);
2123 if (le->link) {
2124 rc = tipc_link_rcv(le->link, skb, &xmitq);
2125 skb = NULL;
2126 }
2127 spin_unlock_bh(&le->lock);
2128 }
2129 tipc_node_read_unlock(n);
2130
2131 /* Check/update node state before receiving */
2132 if (unlikely(skb)) {
2133 if (unlikely(skb_linearize(skb)))
2134 goto out_node_put;
2135 tipc_node_write_lock(n);
2136 if (tipc_node_check_state(n, skb, bearer_id, &xmitq)) {
2137 if (le->link) {
2138 rc = tipc_link_rcv(le->link, skb, &xmitq);
2139 skb = NULL;
2140 }
2141 }
2142 tipc_node_write_unlock(n);
2143 }
2144
2145 if (unlikely(rc & TIPC_LINK_UP_EVT))
2146 tipc_node_link_up(n, bearer_id, &xmitq);
2147
2148 if (unlikely(rc & TIPC_LINK_DOWN_EVT))
2149 tipc_node_link_down(n, bearer_id, false);
2150
2151 if (unlikely(!skb_queue_empty(&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);
2155
2156 if (unlikely(!skb_queue_empty(&n->bc_entry.inputq1)))
2157 tipc_node_mcast_rcv(n);
2158
2159 if (!skb_queue_empty(&le->inputq))
2160 tipc_sk_rcv(net, &le->inputq);
2161
2162 if (!skb_queue_empty(&xmitq))
2163 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n);
2164
2165 out_node_put:
2166 tipc_node_put(n);
2167 discard:
2168 kfree_skb(skb);
2169 }
2170
tipc_node_apply_property(struct net * net,struct tipc_bearer * b,int prop)2171 void tipc_node_apply_property(struct net *net, struct tipc_bearer *b,
2172 int prop)
2173 {
2174 struct tipc_net *tn = tipc_net(net);
2175 int bearer_id = b->identity;
2176 struct sk_buff_head xmitq;
2177 struct tipc_link_entry *e;
2178 struct tipc_node *n;
2179
2180 __skb_queue_head_init(&xmitq);
2181
2182 rcu_read_lock();
2183
2184 list_for_each_entry_rcu(n, &tn->node_list, list) {
2185 tipc_node_write_lock(n);
2186 e = &n->links[bearer_id];
2187 if (e->link) {
2188 if (prop == TIPC_NLA_PROP_TOL)
2189 tipc_link_set_tolerance(e->link, b->tolerance,
2190 &xmitq);
2191 else if (prop == TIPC_NLA_PROP_MTU)
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);
2196 }
2197
2198 tipc_node_write_unlock(n);
2199 tipc_bearer_xmit(net, bearer_id, &xmitq, &e->maddr, NULL);
2200 }
2201
2202 rcu_read_unlock();
2203 }
2204
tipc_nl_peer_rm(struct sk_buff * skb,struct genl_info * info)2205 int tipc_nl_peer_rm(struct sk_buff *skb, struct genl_info *info)
2206 {
2207 struct net *net = sock_net(skb->sk);
2208 struct tipc_net *tn = net_generic(net, tipc_net_id);
2209 struct nlattr *attrs[TIPC_NLA_NET_MAX + 1];
2210 struct tipc_node *peer, *temp_node;
2211 u32 addr;
2212 int err;
2213
2214 /* We identify the peer by its net */
2215 if (!info->attrs[TIPC_NLA_NET])
2216 return -EINVAL;
2217
2218 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_NET_MAX,
2219 info->attrs[TIPC_NLA_NET],
2220 tipc_nl_net_policy, info->extack);
2221 if (err)
2222 return err;
2223
2224 if (!attrs[TIPC_NLA_NET_ADDR])
2225 return -EINVAL;
2226
2227 addr = nla_get_u32(attrs[TIPC_NLA_NET_ADDR]);
2228
2229 if (in_own_node(net, addr))
2230 return -ENOTSUPP;
2231
2232 spin_lock_bh(&tn->node_list_lock);
2233 peer = tipc_node_find(net, addr);
2234 if (!peer) {
2235 spin_unlock_bh(&tn->node_list_lock);
2236 return -ENXIO;
2237 }
2238
2239 tipc_node_write_lock(peer);
2240 if (peer->state != SELF_DOWN_PEER_DOWN &&
2241 peer->state != SELF_DOWN_PEER_LEAVING) {
2242 tipc_node_write_unlock(peer);
2243 err = -EBUSY;
2244 goto err_out;
2245 }
2246
2247 tipc_node_clear_links(peer);
2248 tipc_node_write_unlock(peer);
2249 tipc_node_delete(peer);
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));
2257 err = 0;
2258 err_out:
2259 tipc_node_put(peer);
2260 spin_unlock_bh(&tn->node_list_lock);
2261
2262 return err;
2263 }
2264
tipc_nl_node_dump(struct sk_buff * skb,struct netlink_callback * cb)2265 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
2266 {
2267 int err;
2268 struct net *net = sock_net(skb->sk);
2269 struct tipc_net *tn = net_generic(net, tipc_net_id);
2270 int done = cb->args[0];
2271 int last_addr = cb->args[1];
2272 struct tipc_node *node;
2273 struct tipc_nl_msg msg;
2274
2275 if (done)
2276 return 0;
2277
2278 msg.skb = skb;
2279 msg.portid = NETLINK_CB(cb->skb).portid;
2280 msg.seq = cb->nlh->nlmsg_seq;
2281
2282 rcu_read_lock();
2283 if (last_addr) {
2284 node = tipc_node_find(net, last_addr);
2285 if (!node) {
2286 rcu_read_unlock();
2287 /* We never set seq or call nl_dump_check_consistent()
2288 * this means that setting prev_seq here will cause the
2289 * consistence check to fail in the netlink callback
2290 * handler. Resulting in the NLMSG_DONE message having
2291 * the NLM_F_DUMP_INTR flag set if the node state
2292 * changed while we released the lock.
2293 */
2294 cb->prev_seq = 1;
2295 return -EPIPE;
2296 }
2297 tipc_node_put(node);
2298 }
2299
2300 list_for_each_entry_rcu(node, &tn->node_list, list) {
2301 if (node->preliminary)
2302 continue;
2303 if (last_addr) {
2304 if (node->addr == last_addr)
2305 last_addr = 0;
2306 else
2307 continue;
2308 }
2309
2310 tipc_node_read_lock(node);
2311 err = __tipc_nl_add_node(&msg, node);
2312 if (err) {
2313 last_addr = node->addr;
2314 tipc_node_read_unlock(node);
2315 goto out;
2316 }
2317
2318 tipc_node_read_unlock(node);
2319 }
2320 done = 1;
2321 out:
2322 cb->args[0] = done;
2323 cb->args[1] = last_addr;
2324 rcu_read_unlock();
2325
2326 return skb->len;
2327 }
2328
2329 /* tipc_node_find_by_name - locate owner node of link by link's name
2330 * @net: the applicable net namespace
2331 * @name: pointer to link name string
2332 * @bearer_id: pointer to index in 'node->links' array where the link was found.
2333 *
2334 * Returns pointer to node owning the link, or 0 if no matching link is found.
2335 */
tipc_node_find_by_name(struct net * net,const char * link_name,unsigned int * bearer_id)2336 static struct tipc_node *tipc_node_find_by_name(struct net *net,
2337 const char *link_name,
2338 unsigned int *bearer_id)
2339 {
2340 struct tipc_net *tn = net_generic(net, tipc_net_id);
2341 struct tipc_link *l;
2342 struct tipc_node *n;
2343 struct tipc_node *found_node = NULL;
2344 int i;
2345
2346 *bearer_id = 0;
2347 rcu_read_lock();
2348 list_for_each_entry_rcu(n, &tn->node_list, list) {
2349 tipc_node_read_lock(n);
2350 for (i = 0; i < MAX_BEARERS; i++) {
2351 l = n->links[i].link;
2352 if (l && !strcmp(tipc_link_name(l), link_name)) {
2353 *bearer_id = i;
2354 found_node = n;
2355 break;
2356 }
2357 }
2358 tipc_node_read_unlock(n);
2359 if (found_node)
2360 break;
2361 }
2362 rcu_read_unlock();
2363
2364 return found_node;
2365 }
2366
tipc_nl_node_set_link(struct sk_buff * skb,struct genl_info * info)2367 int tipc_nl_node_set_link(struct sk_buff *skb, struct genl_info *info)
2368 {
2369 int err;
2370 int res = 0;
2371 int bearer_id;
2372 char *name;
2373 struct tipc_link *link;
2374 struct tipc_node *node;
2375 struct sk_buff_head xmitq;
2376 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
2377 struct net *net = sock_net(skb->sk);
2378
2379 __skb_queue_head_init(&xmitq);
2380
2381 if (!info->attrs[TIPC_NLA_LINK])
2382 return -EINVAL;
2383
2384 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
2385 info->attrs[TIPC_NLA_LINK],
2386 tipc_nl_link_policy, info->extack);
2387 if (err)
2388 return err;
2389
2390 if (!attrs[TIPC_NLA_LINK_NAME])
2391 return -EINVAL;
2392
2393 name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
2394
2395 if (strcmp(name, tipc_bclink_name) == 0)
2396 return tipc_nl_bc_link_set(net, attrs);
2397
2398 node = tipc_node_find_by_name(net, name, &bearer_id);
2399 if (!node)
2400 return -EINVAL;
2401
2402 tipc_node_read_lock(node);
2403
2404 link = node->links[bearer_id].link;
2405 if (!link) {
2406 res = -EINVAL;
2407 goto out;
2408 }
2409
2410 if (attrs[TIPC_NLA_LINK_PROP]) {
2411 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
2412
2413 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP], props);
2414 if (err) {
2415 res = err;
2416 goto out;
2417 }
2418
2419 if (props[TIPC_NLA_PROP_TOL]) {
2420 u32 tol;
2421
2422 tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
2423 tipc_link_set_tolerance(link, tol, &xmitq);
2424 }
2425 if (props[TIPC_NLA_PROP_PRIO]) {
2426 u32 prio;
2427
2428 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
2429 tipc_link_set_prio(link, prio, &xmitq);
2430 }
2431 if (props[TIPC_NLA_PROP_WIN]) {
2432 u32 max_win;
2433
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);
2438 }
2439 }
2440
2441 out:
2442 tipc_node_read_unlock(node);
2443 tipc_bearer_xmit(net, bearer_id, &xmitq, &node->links[bearer_id].maddr,
2444 NULL);
2445 return res;
2446 }
2447
tipc_nl_node_get_link(struct sk_buff * skb,struct genl_info * info)2448 int tipc_nl_node_get_link(struct sk_buff *skb, struct genl_info *info)
2449 {
2450 struct net *net = genl_info_net(info);
2451 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
2452 struct tipc_nl_msg msg;
2453 char *name;
2454 int err;
2455
2456 msg.portid = info->snd_portid;
2457 msg.seq = info->snd_seq;
2458
2459 if (!info->attrs[TIPC_NLA_LINK])
2460 return -EINVAL;
2461
2462 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
2463 info->attrs[TIPC_NLA_LINK],
2464 tipc_nl_link_policy, info->extack);
2465 if (err)
2466 return err;
2467
2468 if (!attrs[TIPC_NLA_LINK_NAME])
2469 return -EINVAL;
2470
2471 name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
2472
2473 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2474 if (!msg.skb)
2475 return -ENOMEM;
2476
2477 if (strcmp(name, tipc_bclink_name) == 0) {
2478 err = tipc_nl_add_bc_link(net, &msg, tipc_net(net)->bcl);
2479 if (err)
2480 goto err_free;
2481 } else {
2482 int bearer_id;
2483 struct tipc_node *node;
2484 struct tipc_link *link;
2485
2486 node = tipc_node_find_by_name(net, name, &bearer_id);
2487 if (!node) {
2488 err = -EINVAL;
2489 goto err_free;
2490 }
2491
2492 tipc_node_read_lock(node);
2493 link = node->links[bearer_id].link;
2494 if (!link) {
2495 tipc_node_read_unlock(node);
2496 err = -EINVAL;
2497 goto err_free;
2498 }
2499
2500 err = __tipc_nl_add_link(net, &msg, link, 0);
2501 tipc_node_read_unlock(node);
2502 if (err)
2503 goto err_free;
2504 }
2505
2506 return genlmsg_reply(msg.skb, info);
2507
2508 err_free:
2509 nlmsg_free(msg.skb);
2510 return err;
2511 }
2512
tipc_nl_node_reset_link_stats(struct sk_buff * skb,struct genl_info * info)2513 int tipc_nl_node_reset_link_stats(struct sk_buff *skb, struct genl_info *info)
2514 {
2515 int err;
2516 char *link_name;
2517 unsigned int bearer_id;
2518 struct tipc_link *link;
2519 struct tipc_node *node;
2520 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
2521 struct net *net = sock_net(skb->sk);
2522 struct tipc_net *tn = tipc_net(net);
2523 struct tipc_link_entry *le;
2524
2525 if (!info->attrs[TIPC_NLA_LINK])
2526 return -EINVAL;
2527
2528 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX,
2529 info->attrs[TIPC_NLA_LINK],
2530 tipc_nl_link_policy, info->extack);
2531 if (err)
2532 return err;
2533
2534 if (!attrs[TIPC_NLA_LINK_NAME])
2535 return -EINVAL;
2536
2537 link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
2538
2539 err = -EINVAL;
2540 if (!strcmp(link_name, tipc_bclink_name)) {
2541 err = tipc_bclink_reset_stats(net, tipc_bc_sndlink(net));
2542 if (err)
2543 return err;
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;
2559 }
2560
2561 node = tipc_node_find_by_name(net, link_name, &bearer_id);
2562 if (!node)
2563 return -EINVAL;
2564
2565 le = &node->links[bearer_id];
2566 tipc_node_read_lock(node);
2567 spin_lock_bh(&le->lock);
2568 link = node->links[bearer_id].link;
2569 if (!link) {
2570 spin_unlock_bh(&le->lock);
2571 tipc_node_read_unlock(node);
2572 return -EINVAL;
2573 }
2574 tipc_link_reset_stats(link);
2575 spin_unlock_bh(&le->lock);
2576 tipc_node_read_unlock(node);
2577 return 0;
2578 }
2579
2580 /* Caller should hold node lock */
__tipc_nl_add_node_links(struct net * net,struct tipc_nl_msg * msg,struct tipc_node * node,u32 * prev_link,bool bc_link)2581 static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg,
2582 struct tipc_node *node, u32 *prev_link,
2583 bool bc_link)
2584 {
2585 u32 i;
2586 int err;
2587
2588 for (i = *prev_link; i < MAX_BEARERS; i++) {
2589 *prev_link = i;
2590
2591 if (!node->links[i].link)
2592 continue;
2593
2594 err = __tipc_nl_add_link(net, msg,
2595 node->links[i].link, NLM_F_MULTI);
2596 if (err)
2597 return err;
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
2607 *prev_link = 0;
2608
2609 return 0;
2610 }
2611
tipc_nl_node_dump_link(struct sk_buff * skb,struct netlink_callback * cb)2612 int tipc_nl_node_dump_link(struct sk_buff *skb, struct netlink_callback *cb)
2613 {
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];
2617 struct tipc_net *tn = net_generic(net, tipc_net_id);
2618 struct tipc_node *node;
2619 struct tipc_nl_msg msg;
2620 u32 prev_node = cb->args[0];
2621 u32 prev_link = cb->args[1];
2622 int done = cb->args[2];
2623 bool bc_link = cb->args[3];
2624 int err;
2625
2626 if (done)
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 }
2644
2645 msg.skb = skb;
2646 msg.portid = NETLINK_CB(cb->skb).portid;
2647 msg.seq = cb->nlh->nlmsg_seq;
2648
2649 rcu_read_lock();
2650 if (prev_node) {
2651 node = tipc_node_find(net, prev_node);
2652 if (!node) {
2653 /* We never set seq or call nl_dump_check_consistent()
2654 * this means that setting prev_seq here will cause the
2655 * consistence check to fail in the netlink callback
2656 * handler. Resulting in the last NLMSG_DONE message
2657 * having the NLM_F_DUMP_INTR flag set.
2658 */
2659 cb->prev_seq = 1;
2660 goto out;
2661 }
2662 tipc_node_put(node);
2663
2664 list_for_each_entry_continue_rcu(node, &tn->node_list,
2665 list) {
2666 tipc_node_read_lock(node);
2667 err = __tipc_nl_add_node_links(net, &msg, node,
2668 &prev_link, bc_link);
2669 tipc_node_read_unlock(node);
2670 if (err)
2671 goto out;
2672
2673 prev_node = node->addr;
2674 }
2675 } else {
2676 err = tipc_nl_add_bc_link(net, &msg, tn->bcl);
2677 if (err)
2678 goto out;
2679
2680 list_for_each_entry_rcu(node, &tn->node_list, list) {
2681 tipc_node_read_lock(node);
2682 err = __tipc_nl_add_node_links(net, &msg, node,
2683 &prev_link, bc_link);
2684 tipc_node_read_unlock(node);
2685 if (err)
2686 goto out;
2687
2688 prev_node = node->addr;
2689 }
2690 }
2691 done = 1;
2692 out:
2693 rcu_read_unlock();
2694
2695 cb->args[0] = prev_node;
2696 cb->args[1] = prev_link;
2697 cb->args[2] = done;
2698 cb->args[3] = bc_link;
2699
2700 return skb->len;
2701 }
2702
tipc_nl_node_set_monitor(struct sk_buff * skb,struct genl_info * info)2703 int tipc_nl_node_set_monitor(struct sk_buff *skb, struct genl_info *info)
2704 {
2705 struct nlattr *attrs[TIPC_NLA_MON_MAX + 1];
2706 struct net *net = sock_net(skb->sk);
2707 int err;
2708
2709 if (!info->attrs[TIPC_NLA_MON])
2710 return -EINVAL;
2711
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);
2716 if (err)
2717 return err;
2718
2719 if (attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]) {
2720 u32 val;
2721
2722 val = nla_get_u32(attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]);
2723 err = tipc_nl_monitor_set_threshold(net, val);
2724 if (err)
2725 return err;
2726 }
2727
2728 return 0;
2729 }
2730
__tipc_nl_add_monitor_prop(struct net * net,struct tipc_nl_msg * msg)2731 static int __tipc_nl_add_monitor_prop(struct net *net, struct tipc_nl_msg *msg)
2732 {
2733 struct nlattr *attrs;
2734 void *hdr;
2735 u32 val;
2736
2737 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
2738 0, TIPC_NL_MON_GET);
2739 if (!hdr)
2740 return -EMSGSIZE;
2741
2742 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON);
2743 if (!attrs)
2744 goto msg_full;
2745
2746 val = tipc_nl_monitor_get_threshold(net);
2747
2748 if (nla_put_u32(msg->skb, TIPC_NLA_MON_ACTIVATION_THRESHOLD, val))
2749 goto attr_msg_full;
2750
2751 nla_nest_end(msg->skb, attrs);
2752 genlmsg_end(msg->skb, hdr);
2753
2754 return 0;
2755
2756 attr_msg_full:
2757 nla_nest_cancel(msg->skb, attrs);
2758 msg_full:
2759 genlmsg_cancel(msg->skb, hdr);
2760
2761 return -EMSGSIZE;
2762 }
2763
tipc_nl_node_get_monitor(struct sk_buff * skb,struct genl_info * info)2764 int tipc_nl_node_get_monitor(struct sk_buff *skb, struct genl_info *info)
2765 {
2766 struct net *net = sock_net(skb->sk);
2767 struct tipc_nl_msg msg;
2768 int err;
2769
2770 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2771 if (!msg.skb)
2772 return -ENOMEM;
2773 msg.portid = info->snd_portid;
2774 msg.seq = info->snd_seq;
2775
2776 err = __tipc_nl_add_monitor_prop(net, &msg);
2777 if (err) {
2778 nlmsg_free(msg.skb);
2779 return err;
2780 }
2781
2782 return genlmsg_reply(msg.skb, info);
2783 }
2784
tipc_nl_node_dump_monitor(struct sk_buff * skb,struct netlink_callback * cb)2785 int tipc_nl_node_dump_monitor(struct sk_buff *skb, struct netlink_callback *cb)
2786 {
2787 struct net *net = sock_net(skb->sk);
2788 u32 prev_bearer = cb->args[0];
2789 struct tipc_nl_msg msg;
2790 int bearer_id;
2791 int err;
2792
2793 if (prev_bearer == MAX_BEARERS)
2794 return 0;
2795
2796 msg.skb = skb;
2797 msg.portid = NETLINK_CB(cb->skb).portid;
2798 msg.seq = cb->nlh->nlmsg_seq;
2799
2800 rtnl_lock();
2801 for (bearer_id = prev_bearer; bearer_id < MAX_BEARERS; bearer_id++) {
2802 err = __tipc_nl_add_monitor(net, &msg, bearer_id);
2803 if (err)
2804 break;
2805 }
2806 rtnl_unlock();
2807 cb->args[0] = bearer_id;
2808
2809 return skb->len;
2810 }
2811
tipc_nl_node_dump_monitor_peer(struct sk_buff * skb,struct netlink_callback * cb)2812 int tipc_nl_node_dump_monitor_peer(struct sk_buff *skb,
2813 struct netlink_callback *cb)
2814 {
2815 struct net *net = sock_net(skb->sk);
2816 u32 prev_node = cb->args[1];
2817 u32 bearer_id = cb->args[2];
2818 int done = cb->args[0];
2819 struct tipc_nl_msg msg;
2820 int err;
2821
2822 if (!prev_node) {
2823 struct nlattr **attrs = genl_dumpit_info(cb)->attrs;
2824 struct nlattr *mon[TIPC_NLA_MON_MAX + 1];
2825
2826 if (!attrs[TIPC_NLA_MON])
2827 return -EINVAL;
2828
2829 err = nla_parse_nested_deprecated(mon, TIPC_NLA_MON_MAX,
2830 attrs[TIPC_NLA_MON],
2831 tipc_nl_monitor_policy,
2832 NULL);
2833 if (err)
2834 return err;
2835
2836 if (!mon[TIPC_NLA_MON_REF])
2837 return -EINVAL;
2838
2839 bearer_id = nla_get_u32(mon[TIPC_NLA_MON_REF]);
2840
2841 if (bearer_id >= MAX_BEARERS)
2842 return -EINVAL;
2843 }
2844
2845 if (done)
2846 return 0;
2847
2848 msg.skb = skb;
2849 msg.portid = NETLINK_CB(cb->skb).portid;
2850 msg.seq = cb->nlh->nlmsg_seq;
2851
2852 rtnl_lock();
2853 err = tipc_nl_add_monitor_peer(net, &msg, bearer_id, &prev_node);
2854 if (!err)
2855 done = 1;
2856
2857 rtnl_unlock();
2858 cb->args[0] = done;
2859 cb->args[1] = prev_node;
2860 cb->args[2] = bearer_id;
2861
2862 return skb->len;
2863 }
2864
2865 #ifdef CONFIG_TIPC_CRYPTO
tipc_nl_retrieve_key(struct nlattr ** attrs,struct tipc_aead_key ** pkey)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
tipc_nl_retrieve_nodeid(struct nlattr ** attrs,u8 ** node_id)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
tipc_nl_retrieve_rekeying(struct nlattr ** attrs,u32 * intv)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
__tipc_nl_node_set_key(struct sk_buff * skb,struct genl_info * info)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
tipc_nl_node_set_key(struct sk_buff * skb,struct genl_info * info)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
__tipc_nl_node_flush_key(struct sk_buff * skb,struct genl_info * info)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
tipc_nl_node_flush_key(struct sk_buff * skb,struct genl_info * info)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 */
tipc_node_dump(struct tipc_node * n,bool more,char * buf)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
tipc_node_pre_cleanup_net(struct net * exit_net)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 }
3117