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