2 * net/tipc/node.c: TIPC node management routines
4 * Copyright (c) 2000-2006, 2012-2016, Ericsson AB
5 * Copyright (c) 2005-2006, 2010-2014, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
40 #include "name_distr.h"
47 #define INVALID_NODE_SIG 0x10000
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
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)
61 struct tipc_link_entry
{
62 struct tipc_link
*link
;
63 spinlock_t lock
; /* per link */
65 struct sk_buff_head inputq
;
66 struct tipc_media_addr maddr
;
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
;
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
105 struct hlist_node hash
;
107 struct tipc_link_entry links
[MAX_BEARERS
];
108 struct tipc_bclink_entry bc_entry
;
110 struct list_head list
;
118 struct list_head publ_list
;
119 struct list_head conn_sks
;
120 unsigned long keepalive_intv
;
121 struct timer_list timer
;
125 /* Node FSM states and events:
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,
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
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
,
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
);
162 struct tipc_sock_conn
{
166 struct list_head list
;
169 static struct tipc_link
*node_active_link(struct tipc_node
*n
, int sel
)
171 int bearer_id
= n
->active_links
[sel
& 1];
173 if (unlikely(bearer_id
== INVALID_BEARER_ID
))
176 return n
->links
[bearer_id
].link
;
179 int tipc_node_get_mtu(struct net
*net
, u32 addr
, u32 sel
)
183 unsigned int mtu
= MAX_MSG_SIZE
;
185 n
= tipc_node_find(net
, addr
);
189 bearer_id
= n
->active_links
[sel
& 1];
190 if (likely(bearer_id
!= INVALID_BEARER_ID
))
191 mtu
= n
->links
[bearer_id
].mtu
;
196 u16
tipc_node_get_capabilities(struct net
*net
, u32 addr
)
201 n
= tipc_node_find(net
, addr
);
203 return TIPC_NODE_CAPABILITIES
;
204 caps
= n
->capabilities
;
209 static void tipc_node_kref_release(struct kref
*kref
)
211 struct tipc_node
*n
= container_of(kref
, struct tipc_node
, kref
);
213 kfree(n
->bc_entry
.link
);
217 static void tipc_node_put(struct tipc_node
*node
)
219 kref_put(&node
->kref
, tipc_node_kref_release
);
222 static void tipc_node_get(struct tipc_node
*node
)
224 kref_get(&node
->kref
);
228 * tipc_node_find - locate specified node object, if it exists
230 static struct tipc_node
*tipc_node_find(struct net
*net
, u32 addr
)
232 struct tipc_net
*tn
= tipc_net(net
);
233 struct tipc_node
*node
;
234 unsigned int thash
= tipc_hashfn(addr
);
236 if (unlikely(!in_own_cluster_exact(net
, addr
)))
240 hlist_for_each_entry_rcu(node
, &tn
->node_htable
[thash
], hash
) {
241 if (node
->addr
!= addr
)
243 if (!kref_get_unless_zero(&node
->kref
))
251 static void tipc_node_read_lock(struct tipc_node
*n
)
253 read_lock_bh(&n
->lock
);
256 static void tipc_node_read_unlock(struct tipc_node
*n
)
258 read_unlock_bh(&n
->lock
);
261 static void tipc_node_write_lock(struct tipc_node
*n
)
263 write_lock_bh(&n
->lock
);
266 static void tipc_node_write_unlock(struct tipc_node
*n
)
268 struct net
*net
= n
->net
;
270 u32 flags
= n
->action_flags
;
273 struct list_head
*publ_list
;
275 if (likely(!flags
)) {
276 write_unlock_bh(&n
->lock
);
281 link_id
= n
->link_id
;
282 bearer_id
= link_id
& 0xffff;
283 publ_list
= &n
->publ_list
;
285 n
->action_flags
&= ~(TIPC_NOTIFY_NODE_DOWN
| TIPC_NOTIFY_NODE_UP
|
286 TIPC_NOTIFY_LINK_DOWN
| TIPC_NOTIFY_LINK_UP
);
288 write_unlock_bh(&n
->lock
);
290 if (flags
& TIPC_NOTIFY_NODE_DOWN
)
291 tipc_publ_notify(net
, publ_list
, addr
);
293 if (flags
& TIPC_NOTIFY_NODE_UP
)
294 tipc_named_node_up(net
, addr
);
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
);
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
,
308 struct tipc_node
*tipc_node_create(struct net
*net
, u32 addr
, u16 capabilities
)
310 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
311 struct tipc_node
*n
, *temp_node
;
314 spin_lock_bh(&tn
->node_list_lock
);
315 n
= tipc_node_find(net
, addr
);
317 /* Same node may come back with new capabilities */
318 n
->capabilities
= capabilities
;
321 n
= kzalloc(sizeof(*n
), GFP_ATOMIC
);
323 pr_warn("Node creation failed, no memory\n");
328 n
->capabilities
= capabilities
;
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
,
347 tipc_link_window(tipc_bc_sndlink(net
)),
349 &n
->bc_entry
.inputq1
,
351 tipc_bc_sndlink(net
),
352 &n
->bc_entry
.link
)) {
353 pr_warn("Broadcast rcv link creation failed, no memory\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
)
366 list_add_tail_rcu(&n
->list
, &temp_node
->list
);
368 spin_unlock_bh(&tn
->node_list_lock
);
372 static void tipc_node_calculate_timer(struct tipc_node
*n
, struct tipc_link
*l
)
374 unsigned long tol
= tipc_link_tolerance(l
);
375 unsigned long intv
= ((tol
/ 4) > 500) ? 500 : tol
/ 4;
377 /* Link with lowest tolerance determines timer interval */
378 if (intv
< n
->keepalive_intv
)
379 n
->keepalive_intv
= intv
;
381 /* Ensure link's abort limit corresponds to current tolerance */
382 tipc_link_set_abort_limit(l
, tol
/ n
->keepalive_intv
);
385 static void tipc_node_delete(struct tipc_node
*node
)
387 list_del_rcu(&node
->list
);
388 hlist_del_rcu(&node
->hash
);
391 del_timer_sync(&node
->timer
);
395 void tipc_node_stop(struct net
*net
)
397 struct tipc_net
*tn
= tipc_net(net
);
398 struct tipc_node
*node
, *t_node
;
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
);
406 void tipc_node_subscribe(struct net
*net
, struct list_head
*subscr
, u32 addr
)
410 if (in_own_node(net
, addr
))
413 n
= tipc_node_find(net
, addr
);
415 pr_warn("Node subscribe rejected, unknown node 0x%x\n", addr
);
418 tipc_node_write_lock(n
);
419 list_add_tail(subscr
, &n
->publ_list
);
420 tipc_node_write_unlock(n
);
424 void tipc_node_unsubscribe(struct net
*net
, struct list_head
*subscr
, u32 addr
)
428 if (in_own_node(net
, addr
))
431 n
= tipc_node_find(net
, addr
);
433 pr_warn("Node unsubscribe rejected, unknown node 0x%x\n", addr
);
436 tipc_node_write_lock(n
);
437 list_del_init(subscr
);
438 tipc_node_write_unlock(n
);
442 int tipc_node_add_conn(struct net
*net
, u32 dnode
, u32 port
, u32 peer_port
)
444 struct tipc_node
*node
;
445 struct tipc_sock_conn
*conn
;
448 if (in_own_node(net
, dnode
))
451 node
= tipc_node_find(net
, dnode
);
453 pr_warn("Connecting sock to node 0x%x failed\n", dnode
);
454 return -EHOSTUNREACH
;
456 conn
= kmalloc(sizeof(*conn
), GFP_ATOMIC
);
461 conn
->peer_node
= dnode
;
463 conn
->peer_port
= peer_port
;
465 tipc_node_write_lock(node
);
466 list_add_tail(&conn
->list
, &node
->conn_sks
);
467 tipc_node_write_unlock(node
);
473 void tipc_node_remove_conn(struct net
*net
, u32 dnode
, u32 port
)
475 struct tipc_node
*node
;
476 struct tipc_sock_conn
*conn
, *safe
;
478 if (in_own_node(net
, dnode
))
481 node
= tipc_node_find(net
, dnode
);
485 tipc_node_write_lock(node
);
486 list_for_each_entry_safe(conn
, safe
, &node
->conn_sks
, list
) {
487 if (port
!= conn
->port
)
489 list_del(&conn
->list
);
492 tipc_node_write_unlock(node
);
496 /* tipc_node_timeout - handle expiration of node timer
498 static void tipc_node_timeout(unsigned long data
)
500 struct tipc_node
*n
= (struct tipc_node
*)data
;
501 struct tipc_link_entry
*le
;
502 struct sk_buff_head xmitq
;
506 __skb_queue_head_init(&xmitq
);
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
);
513 /* Link tolerance may change asynchronously: */
514 tipc_node_calculate_timer(n
, le
->link
);
515 rc
= tipc_link_timeout(le
->link
, &xmitq
);
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);
523 mod_timer(&n
->timer
, jiffies
+ msecs_to_jiffies(n
->keepalive_intv
));
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.
531 static void __tipc_node_link_up(struct tipc_node
*n
, int bearer_id
,
532 struct sk_buff_head
*xmitq
)
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
;
539 if (!nl
|| tipc_link_is_up(nl
))
542 tipc_link_fsm_evt(nl
, LINK_ESTABLISH_EVT
);
543 if (!tipc_link_is_up(nl
))
547 n
->action_flags
|= TIPC_NOTIFY_LINK_UP
;
548 n
->link_id
= tipc_link_id(nl
);
550 /* Leave room for tunnel header when returning 'mtu' to users: */
551 n
->links
[bearer_id
].mtu
= tipc_link_mtu(nl
) - INT_H_SIZE
;
553 tipc_bearer_add_dest(n
->net
, bearer_id
, n
->addr
);
554 tipc_bcast_inc_bearer_dst_cnt(n
->net
, bearer_id
);
556 pr_debug("Established link <%s> on network plane %c\n",
557 tipc_link_name(nl
), tipc_link_plane(nl
));
559 /* Ensure that a STATE message goes first */
560 tipc_link_build_state_msg(nl
, xmitq
);
562 /* First link? => give it both slots */
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
);
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
));
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);
584 pr_debug("New link <%s> is standby\n", tipc_link_name(nl
));
587 /* Prepare synchronization with first link */
588 tipc_link_tnl_prepare(ol
, nl
, SYNCH_MSG
, xmitq
);
592 * tipc_node_link_up - handle addition of link
594 * Link becomes active (alone or shared) or standby, depending on its priority.
596 static void tipc_node_link_up(struct tipc_node
*n
, int bearer_id
,
597 struct sk_buff_head
*xmitq
)
599 struct tipc_media_addr
*maddr
;
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
);
609 * __tipc_node_link_down - handle loss of link
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
)
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
;
621 l
= n
->links
[*bearer_id
].link
;
622 if (!l
|| tipc_link_is_reset(l
))
626 n
->action_flags
|= TIPC_NOTIFY_LINK_DOWN
;
627 n
->link_id
= tipc_link_id(l
);
629 tipc_bearer_remove_dest(n
->net
, *bearer_id
, n
->addr
);
631 pr_debug("Lost link <%s> on network plane %c\n",
632 tipc_link_name(l
), tipc_link_plane(l
));
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
))
643 prio
= tipc_link_prio(_l
);
646 if (prio
> highest
) {
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
);
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
);
667 tipc_bcast_dec_bearer_dst_cnt(n
->net
, *bearer_id
);
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
);
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
;
683 static void tipc_node_link_down(struct tipc_node
*n
, int bearer_id
, bool delete)
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
;
694 __skb_queue_head_init(&xmitq
);
696 tipc_node_write_lock(n
);
697 if (!tipc_link_is_establishing(l
)) {
698 __tipc_node_link_down(n
, &bearer_id
, &xmitq
, &maddr
);
705 /* Defuse pending tipc_node_link_up() */
706 tipc_link_fsm_evt(l
, LINK_RESET_EVT
);
708 tipc_node_write_unlock(n
);
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
);
715 static bool tipc_node_is_up(struct tipc_node
*n
)
717 return n
->active_links
[0] != INVALID_BEARER_ID
;
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
)
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;
740 n
= tipc_node_create(net
, onode
, capabilities
);
744 tipc_node_write_lock(n
);
746 le
= &n
->links
[b
->identity
];
748 /* Prepare to validate requesting node's signature and media address */
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
);
754 /* These three flags give us eight permutations: */
756 if (sign_match
&& addr_match
&& link_up
) {
757 /* All is fine. Do nothing. */
759 } else if (sign_match
&& addr_match
&& !link_up
) {
760 /* Respond. The link will come up in due time */
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
769 * Ignore requests until the link goes down, if ever.
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.
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.
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.
797 n
->signature
= signature
;
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.
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.
808 n
->signature
= signature
;
816 /* Now create new link if not already existing */
818 if (n
->link_cnt
== 2) {
819 pr_warn("Cannot establish 3rd link to %x\n", n
->addr
);
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
,
828 tipc_bc_sndlink(n
->net
), n
->bc_entry
.link
,
830 &n
->bc_entry
.namedq
, &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
);
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
))
847 memcpy(&le
->maddr
, maddr
, sizeof(*maddr
));
849 tipc_node_write_unlock(n
);
850 if (reset
&& l
&& !tipc_link_is_reset(l
))
851 tipc_node_link_down(n
, b
->identity
, false);
855 void tipc_node_delete_links(struct net
*net
, int bearer_id
)
857 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
861 list_for_each_entry_rcu(n
, &tn
->node_list
, list
) {
862 tipc_node_link_down(n
, bearer_id
, true);
867 static void tipc_node_reset_links(struct tipc_node
*n
)
869 char addr_string
[16];
872 pr_warn("Resetting all links to %s\n",
873 tipc_addr_string_fill(addr_string
, n
->addr
));
875 for (i
= 0; i
< MAX_BEARERS
; i
++) {
876 tipc_node_link_down(n
, i
, false);
880 /* tipc_node_fsm_evt - node finite state machine
881 * Determines when contact is allowed with peer node
883 static void tipc_node_fsm_evt(struct tipc_node
*n
, int evt
)
885 int state
= n
->state
;
888 case SELF_DOWN_PEER_DOWN
:
890 case SELF_ESTABL_CONTACT_EVT
:
891 state
= SELF_UP_PEER_COMING
;
893 case PEER_ESTABL_CONTACT_EVT
:
894 state
= SELF_COMING_PEER_UP
;
896 case SELF_LOST_CONTACT_EVT
:
897 case PEER_LOST_CONTACT_EVT
:
899 case NODE_SYNCH_END_EVT
:
900 case NODE_SYNCH_BEGIN_EVT
:
901 case NODE_FAILOVER_BEGIN_EVT
:
902 case NODE_FAILOVER_END_EVT
:
907 case SELF_UP_PEER_UP
:
909 case SELF_LOST_CONTACT_EVT
:
910 state
= SELF_DOWN_PEER_LEAVING
;
912 case PEER_LOST_CONTACT_EVT
:
913 state
= SELF_LEAVING_PEER_DOWN
;
915 case NODE_SYNCH_BEGIN_EVT
:
916 state
= NODE_SYNCHING
;
918 case NODE_FAILOVER_BEGIN_EVT
:
919 state
= NODE_FAILINGOVER
;
921 case SELF_ESTABL_CONTACT_EVT
:
922 case PEER_ESTABL_CONTACT_EVT
:
923 case NODE_SYNCH_END_EVT
:
924 case NODE_FAILOVER_END_EVT
:
930 case SELF_DOWN_PEER_LEAVING
:
932 case PEER_LOST_CONTACT_EVT
:
933 state
= SELF_DOWN_PEER_DOWN
;
935 case SELF_ESTABL_CONTACT_EVT
:
936 case PEER_ESTABL_CONTACT_EVT
:
937 case SELF_LOST_CONTACT_EVT
:
939 case NODE_SYNCH_END_EVT
:
940 case NODE_SYNCH_BEGIN_EVT
:
941 case NODE_FAILOVER_BEGIN_EVT
:
942 case NODE_FAILOVER_END_EVT
:
947 case SELF_UP_PEER_COMING
:
949 case PEER_ESTABL_CONTACT_EVT
:
950 state
= SELF_UP_PEER_UP
;
952 case SELF_LOST_CONTACT_EVT
:
953 state
= SELF_DOWN_PEER_DOWN
;
955 case SELF_ESTABL_CONTACT_EVT
:
956 case PEER_LOST_CONTACT_EVT
:
957 case NODE_SYNCH_END_EVT
:
958 case NODE_FAILOVER_BEGIN_EVT
:
960 case NODE_SYNCH_BEGIN_EVT
:
961 case NODE_FAILOVER_END_EVT
:
966 case SELF_COMING_PEER_UP
:
968 case SELF_ESTABL_CONTACT_EVT
:
969 state
= SELF_UP_PEER_UP
;
971 case PEER_LOST_CONTACT_EVT
:
972 state
= SELF_DOWN_PEER_DOWN
;
974 case SELF_LOST_CONTACT_EVT
:
975 case PEER_ESTABL_CONTACT_EVT
:
977 case NODE_SYNCH_END_EVT
:
978 case NODE_SYNCH_BEGIN_EVT
:
979 case NODE_FAILOVER_BEGIN_EVT
:
980 case NODE_FAILOVER_END_EVT
:
985 case SELF_LEAVING_PEER_DOWN
:
987 case SELF_LOST_CONTACT_EVT
:
988 state
= SELF_DOWN_PEER_DOWN
;
990 case SELF_ESTABL_CONTACT_EVT
:
991 case PEER_ESTABL_CONTACT_EVT
:
992 case PEER_LOST_CONTACT_EVT
:
994 case NODE_SYNCH_END_EVT
:
995 case NODE_SYNCH_BEGIN_EVT
:
996 case NODE_FAILOVER_BEGIN_EVT
:
997 case NODE_FAILOVER_END_EVT
:
1002 case NODE_FAILINGOVER
:
1004 case SELF_LOST_CONTACT_EVT
:
1005 state
= SELF_DOWN_PEER_LEAVING
;
1007 case PEER_LOST_CONTACT_EVT
:
1008 state
= SELF_LEAVING_PEER_DOWN
;
1010 case NODE_FAILOVER_END_EVT
:
1011 state
= SELF_UP_PEER_UP
;
1013 case NODE_FAILOVER_BEGIN_EVT
:
1014 case SELF_ESTABL_CONTACT_EVT
:
1015 case PEER_ESTABL_CONTACT_EVT
:
1017 case NODE_SYNCH_BEGIN_EVT
:
1018 case NODE_SYNCH_END_EVT
:
1025 case SELF_LOST_CONTACT_EVT
:
1026 state
= SELF_DOWN_PEER_LEAVING
;
1028 case PEER_LOST_CONTACT_EVT
:
1029 state
= SELF_LEAVING_PEER_DOWN
;
1031 case NODE_SYNCH_END_EVT
:
1032 state
= SELF_UP_PEER_UP
;
1034 case NODE_FAILOVER_BEGIN_EVT
:
1035 state
= NODE_FAILINGOVER
;
1037 case NODE_SYNCH_BEGIN_EVT
:
1038 case SELF_ESTABL_CONTACT_EVT
:
1039 case PEER_ESTABL_CONTACT_EVT
:
1041 case NODE_FAILOVER_END_EVT
:
1047 pr_err("Unknown node fsm state %x\n", state
);
1054 pr_err("Illegal node fsm evt %x in state %x\n", evt
, state
);
1057 static void node_lost_contact(struct tipc_node
*n
,
1058 struct sk_buff_head
*inputq
)
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
;
1067 pr_debug("Lost contact with %s\n",
1068 tipc_addr_string_fill(addr_string
, n
->addr
));
1070 /* Clean up broadcast state */
1071 tipc_bcast_remove_peer(n
->net
, n
->bc_entry
.link
);
1073 /* Abort any ongoing link failover */
1074 for (i
= 0; i
< MAX_BEARERS
; i
++) {
1075 l
= n
->links
[i
].link
;
1077 tipc_link_fsm_evt(l
, LINK_FAILOVER_END_EVT
);
1080 /* Notify publications from this node */
1081 n
->action_flags
|= TIPC_NOTIFY_NODE_DOWN
;
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
);
1090 skb_queue_tail(inputq
, skb
);
1091 list_del(&conn
->list
);
1097 * tipc_node_get_linkname - get the name of a link
1099 * @bearer_id: id of the bearer
1100 * @node: peer node address
1101 * @linkname: link name output buffer
1103 * Returns 0 on success
1105 int tipc_node_get_linkname(struct net
*net
, u32 bearer_id
, u32 addr
,
1106 char *linkname
, size_t len
)
1108 struct tipc_link
*link
;
1110 struct tipc_node
*node
= tipc_node_find(net
, addr
);
1115 if (bearer_id
>= MAX_BEARERS
)
1118 tipc_node_read_lock(node
);
1119 link
= node
->links
[bearer_id
].link
;
1121 strncpy(linkname
, tipc_link_name(link
), len
);
1125 tipc_node_read_unlock(node
);
1126 tipc_node_put(node
);
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
)
1134 struct nlattr
*attrs
;
1136 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_family
,
1137 NLM_F_MULTI
, TIPC_NL_NODE_GET
);
1141 attrs
= nla_nest_start(msg
->skb
, TIPC_NLA_NODE
);
1145 if (nla_put_u32(msg
->skb
, TIPC_NLA_NODE_ADDR
, node
->addr
))
1147 if (tipc_node_is_up(node
))
1148 if (nla_put_flag(msg
->skb
, TIPC_NLA_NODE_UP
))
1151 nla_nest_end(msg
->skb
, attrs
);
1152 genlmsg_end(msg
->skb
, hdr
);
1157 nla_nest_cancel(msg
->skb
, attrs
);
1159 genlmsg_cancel(msg
->skb
, hdr
);
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
1173 int tipc_node_xmit(struct net
*net
, struct sk_buff_head
*list
,
1174 u32 dnode
, int selector
)
1176 struct tipc_link_entry
*le
= NULL
;
1177 struct tipc_node
*n
;
1178 struct sk_buff_head xmitq
;
1182 if (in_own_node(net
, dnode
)) {
1183 tipc_sk_rcv(net
, list
);
1187 n
= tipc_node_find(net
, dnode
);
1189 skb_queue_purge(list
);
1190 return -EHOSTUNREACH
;
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
);
1198 skb_queue_purge(list
);
1199 return -EHOSTUNREACH
;
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
);
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);
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
1227 int tipc_node_xmit_skb(struct net
*net
, struct sk_buff
*skb
, u32 dnode
,
1230 struct sk_buff_head head
;
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
)
1241 void tipc_node_broadcast(struct net
*net
, struct sk_buff
*skb
)
1243 struct sk_buff
*txskb
;
1244 struct tipc_node
*n
;
1248 list_for_each_entry_rcu(n
, tipc_nodes(net
), list
) {
1250 if (in_own_node(net
, dst
))
1252 if (!tipc_node_is_up(n
))
1254 txskb
= pskb_copy(skb
, GFP_ATOMIC
);
1257 msg_set_destnode(buf_msg(txskb
), dst
);
1258 tipc_node_xmit_skb(net
, txskb
, dst
, 0);
1266 * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node
1267 * @net: the applicable net namespace
1269 * @bearer_id: id of bearer message arrived on
1271 * Invoked with no locks held.
1273 static void tipc_node_bc_rcv(struct net
*net
, struct sk_buff
*skb
, int bearer_id
)
1276 struct sk_buff_head xmitq
;
1277 struct tipc_bclink_entry
*be
;
1278 struct tipc_link_entry
*le
;
1279 struct tipc_msg
*hdr
= buf_msg(skb
);
1280 int usr
= msg_user(hdr
);
1281 u32 dnode
= msg_destnode(hdr
);
1282 struct tipc_node
*n
;
1284 __skb_queue_head_init(&xmitq
);
1286 /* If NACK for other node, let rcv link for that node peek into it */
1287 if ((usr
== BCAST_PROTOCOL
) && (dnode
!= tipc_own_addr(net
)))
1288 n
= tipc_node_find(net
, dnode
);
1290 n
= tipc_node_find(net
, msg_prevnode(hdr
));
1296 le
= &n
->links
[bearer_id
];
1298 rc
= tipc_bcast_rcv(net
, be
->link
, skb
);
1300 /* Broadcast ACKs are sent on a unicast link */
1301 if (rc
& TIPC_LINK_SND_BC_ACK
) {
1302 tipc_node_read_lock(n
);
1303 tipc_link_build_state_msg(le
->link
, &xmitq
);
1304 tipc_node_read_unlock(n
);
1307 if (!skb_queue_empty(&xmitq
))
1308 tipc_bearer_xmit(net
, bearer_id
, &xmitq
, &le
->maddr
);
1310 /* Deliver. 'arrvq' is under inputq2's lock protection */
1311 if (!skb_queue_empty(&be
->inputq1
)) {
1312 spin_lock_bh(&be
->inputq2
.lock
);
1313 spin_lock_bh(&be
->inputq1
.lock
);
1314 skb_queue_splice_tail_init(&be
->inputq1
, &be
->arrvq
);
1315 spin_unlock_bh(&be
->inputq1
.lock
);
1316 spin_unlock_bh(&be
->inputq2
.lock
);
1317 tipc_sk_mcast_rcv(net
, &be
->arrvq
, &be
->inputq2
);
1320 if (rc
& TIPC_LINK_DOWN_EVT
) {
1321 /* Reception reassembly failure => reset all links to peer */
1322 if (!tipc_link_is_up(be
->link
))
1323 tipc_node_reset_links(n
);
1325 /* Retransmission failure => reset all links to all peers */
1326 if (!tipc_link_is_up(tipc_bc_sndlink(net
)))
1327 tipc_bearer_reset_all(net
);
1334 * tipc_node_check_state - check and if necessary update node state
1336 * @bearer_id: identity of bearer delivering the packet
1337 * Returns true if state is ok, otherwise consumes buffer and returns false
1339 static bool tipc_node_check_state(struct tipc_node
*n
, struct sk_buff
*skb
,
1340 int bearer_id
, struct sk_buff_head
*xmitq
)
1342 struct tipc_msg
*hdr
= buf_msg(skb
);
1343 int usr
= msg_user(hdr
);
1344 int mtyp
= msg_type(hdr
);
1345 u16 oseqno
= msg_seqno(hdr
);
1346 u16 iseqno
= msg_seqno(msg_get_wrapped(hdr
));
1347 u16 exp_pkts
= msg_msgcnt(hdr
);
1348 u16 rcv_nxt
, syncpt
, dlv_nxt
, inputq_len
;
1349 int state
= n
->state
;
1350 struct tipc_link
*l
, *tnl
, *pl
= NULL
;
1351 struct tipc_media_addr
*maddr
;
1354 l
= n
->links
[bearer_id
].link
;
1357 rcv_nxt
= tipc_link_rcv_nxt(l
);
1360 if (likely((state
== SELF_UP_PEER_UP
) && (usr
!= TUNNEL_PROTOCOL
)))
1363 /* Find parallel link, if any */
1364 for (pb_id
= 0; pb_id
< MAX_BEARERS
; pb_id
++) {
1365 if ((pb_id
!= bearer_id
) && n
->links
[pb_id
].link
) {
1366 pl
= n
->links
[pb_id
].link
;
1371 /* Check and update node accesibility if applicable */
1372 if (state
== SELF_UP_PEER_COMING
) {
1373 if (!tipc_link_is_up(l
))
1375 if (!msg_peer_link_is_up(hdr
))
1377 tipc_node_fsm_evt(n
, PEER_ESTABL_CONTACT_EVT
);
1380 if (state
== SELF_DOWN_PEER_LEAVING
) {
1381 if (msg_peer_node_is_up(hdr
))
1383 tipc_node_fsm_evt(n
, PEER_LOST_CONTACT_EVT
);
1387 if (state
== SELF_LEAVING_PEER_DOWN
)
1390 /* Ignore duplicate packets */
1391 if ((usr
!= LINK_PROTOCOL
) && less(oseqno
, rcv_nxt
))
1394 /* Initiate or update failover mode if applicable */
1395 if ((usr
== TUNNEL_PROTOCOL
) && (mtyp
== FAILOVER_MSG
)) {
1396 syncpt
= oseqno
+ exp_pkts
- 1;
1397 if (pl
&& tipc_link_is_up(pl
)) {
1398 __tipc_node_link_down(n
, &pb_id
, xmitq
, &maddr
);
1399 tipc_skb_queue_splice_tail_init(tipc_link_inputq(pl
),
1400 tipc_link_inputq(l
));
1402 /* If pkts arrive out of order, use lowest calculated syncpt */
1403 if (less(syncpt
, n
->sync_point
))
1404 n
->sync_point
= syncpt
;
1407 /* Open parallel link when tunnel link reaches synch point */
1408 if ((n
->state
== NODE_FAILINGOVER
) && tipc_link_is_up(l
)) {
1409 if (!more(rcv_nxt
, n
->sync_point
))
1411 tipc_node_fsm_evt(n
, NODE_FAILOVER_END_EVT
);
1413 tipc_link_fsm_evt(pl
, LINK_FAILOVER_END_EVT
);
1417 /* No synching needed if only one link */
1418 if (!pl
|| !tipc_link_is_up(pl
))
1421 /* Initiate synch mode if applicable */
1422 if ((usr
== TUNNEL_PROTOCOL
) && (mtyp
== SYNCH_MSG
) && (oseqno
== 1)) {
1423 syncpt
= iseqno
+ exp_pkts
- 1;
1424 if (!tipc_link_is_up(l
)) {
1425 tipc_link_fsm_evt(l
, LINK_ESTABLISH_EVT
);
1426 __tipc_node_link_up(n
, bearer_id
, xmitq
);
1428 if (n
->state
== SELF_UP_PEER_UP
) {
1429 n
->sync_point
= syncpt
;
1430 tipc_link_fsm_evt(l
, LINK_SYNCH_BEGIN_EVT
);
1431 tipc_node_fsm_evt(n
, NODE_SYNCH_BEGIN_EVT
);
1435 /* Open tunnel link when parallel link reaches synch point */
1436 if (n
->state
== NODE_SYNCHING
) {
1437 if (tipc_link_is_synching(l
)) {
1443 inputq_len
= skb_queue_len(tipc_link_inputq(pl
));
1444 dlv_nxt
= tipc_link_rcv_nxt(pl
) - inputq_len
;
1445 if (more(dlv_nxt
, n
->sync_point
)) {
1446 tipc_link_fsm_evt(tnl
, LINK_SYNCH_END_EVT
);
1447 tipc_node_fsm_evt(n
, NODE_SYNCH_END_EVT
);
1452 if ((usr
== TUNNEL_PROTOCOL
) && (mtyp
== SYNCH_MSG
))
1454 if (usr
== LINK_PROTOCOL
)
1462 * tipc_rcv - process TIPC packets/messages arriving from off-node
1463 * @net: the applicable net namespace
1465 * @bearer: pointer to bearer message arrived on
1467 * Invoked with no locks held. Bearer pointer must point to a valid bearer
1468 * structure (i.e. cannot be NULL), but bearer can be inactive.
1470 void tipc_rcv(struct net
*net
, struct sk_buff
*skb
, struct tipc_bearer
*b
)
1472 struct sk_buff_head xmitq
;
1473 struct tipc_node
*n
;
1474 struct tipc_msg
*hdr
= buf_msg(skb
);
1475 int usr
= msg_user(hdr
);
1476 int bearer_id
= b
->identity
;
1477 struct tipc_link_entry
*le
;
1478 u16 bc_ack
= msg_bcast_ack(hdr
);
1479 u32 self
= tipc_own_addr(net
);
1482 __skb_queue_head_init(&xmitq
);
1484 /* Ensure message is well-formed */
1485 if (unlikely(!tipc_msg_validate(skb
)))
1488 /* Handle arrival of discovery or broadcast packet */
1489 if (unlikely(msg_non_seq(hdr
))) {
1490 if (unlikely(usr
== LINK_CONFIG
))
1491 return tipc_disc_rcv(net
, skb
, b
);
1493 return tipc_node_bc_rcv(net
, skb
, bearer_id
);
1496 /* Discard unicast link messages destined for another node */
1497 if (unlikely(!msg_short(hdr
) && (msg_destnode(hdr
) != self
)))
1500 /* Locate neighboring node that sent packet */
1501 n
= tipc_node_find(net
, msg_prevnode(hdr
));
1504 le
= &n
->links
[bearer_id
];
1506 /* Ensure broadcast reception is in synch with peer's send state */
1507 if (unlikely(usr
== LINK_PROTOCOL
))
1508 tipc_bcast_sync_rcv(net
, n
->bc_entry
.link
, hdr
);
1509 else if (unlikely(tipc_link_acked(n
->bc_entry
.link
) != bc_ack
))
1510 tipc_bcast_ack_rcv(net
, n
->bc_entry
.link
, bc_ack
);
1512 /* Receive packet directly if conditions permit */
1513 tipc_node_read_lock(n
);
1514 if (likely((n
->state
== SELF_UP_PEER_UP
) && (usr
!= TUNNEL_PROTOCOL
))) {
1515 spin_lock_bh(&le
->lock
);
1517 rc
= tipc_link_rcv(le
->link
, skb
, &xmitq
);
1520 spin_unlock_bh(&le
->lock
);
1522 tipc_node_read_unlock(n
);
1524 /* Check/update node state before receiving */
1525 if (unlikely(skb
)) {
1526 tipc_node_write_lock(n
);
1527 if (tipc_node_check_state(n
, skb
, bearer_id
, &xmitq
)) {
1529 rc
= tipc_link_rcv(le
->link
, skb
, &xmitq
);
1533 tipc_node_write_unlock(n
);
1536 if (unlikely(rc
& TIPC_LINK_UP_EVT
))
1537 tipc_node_link_up(n
, bearer_id
, &xmitq
);
1539 if (unlikely(rc
& TIPC_LINK_DOWN_EVT
))
1540 tipc_node_link_down(n
, bearer_id
, false);
1542 if (unlikely(!skb_queue_empty(&n
->bc_entry
.namedq
)))
1543 tipc_named_rcv(net
, &n
->bc_entry
.namedq
);
1545 if (!skb_queue_empty(&le
->inputq
))
1546 tipc_sk_rcv(net
, &le
->inputq
);
1548 if (!skb_queue_empty(&xmitq
))
1549 tipc_bearer_xmit(net
, bearer_id
, &xmitq
, &le
->maddr
);
1556 int tipc_nl_node_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1559 struct net
*net
= sock_net(skb
->sk
);
1560 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
1561 int done
= cb
->args
[0];
1562 int last_addr
= cb
->args
[1];
1563 struct tipc_node
*node
;
1564 struct tipc_nl_msg msg
;
1570 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
1571 msg
.seq
= cb
->nlh
->nlmsg_seq
;
1575 node
= tipc_node_find(net
, last_addr
);
1578 /* We never set seq or call nl_dump_check_consistent()
1579 * this means that setting prev_seq here will cause the
1580 * consistence check to fail in the netlink callback
1581 * handler. Resulting in the NLMSG_DONE message having
1582 * the NLM_F_DUMP_INTR flag set if the node state
1583 * changed while we released the lock.
1588 tipc_node_put(node
);
1591 list_for_each_entry_rcu(node
, &tn
->node_list
, list
) {
1593 if (node
->addr
== last_addr
)
1599 tipc_node_read_lock(node
);
1600 err
= __tipc_nl_add_node(&msg
, node
);
1602 last_addr
= node
->addr
;
1603 tipc_node_read_unlock(node
);
1607 tipc_node_read_unlock(node
);
1612 cb
->args
[1] = last_addr
;
1618 /* tipc_node_find_by_name - locate owner node of link by link's name
1619 * @net: the applicable net namespace
1620 * @name: pointer to link name string
1621 * @bearer_id: pointer to index in 'node->links' array where the link was found.
1623 * Returns pointer to node owning the link, or 0 if no matching link is found.
1625 static struct tipc_node
*tipc_node_find_by_name(struct net
*net
,
1626 const char *link_name
,
1627 unsigned int *bearer_id
)
1629 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
1630 struct tipc_link
*l
;
1631 struct tipc_node
*n
;
1632 struct tipc_node
*found_node
= NULL
;
1637 list_for_each_entry_rcu(n
, &tn
->node_list
, list
) {
1638 tipc_node_read_lock(n
);
1639 for (i
= 0; i
< MAX_BEARERS
; i
++) {
1640 l
= n
->links
[i
].link
;
1641 if (l
&& !strcmp(tipc_link_name(l
), link_name
)) {
1647 tipc_node_read_unlock(n
);
1656 int tipc_nl_node_set_link(struct sk_buff
*skb
, struct genl_info
*info
)
1662 struct tipc_link
*link
;
1663 struct tipc_node
*node
;
1664 struct sk_buff_head xmitq
;
1665 struct nlattr
*attrs
[TIPC_NLA_LINK_MAX
+ 1];
1666 struct net
*net
= sock_net(skb
->sk
);
1668 __skb_queue_head_init(&xmitq
);
1670 if (!info
->attrs
[TIPC_NLA_LINK
])
1673 err
= nla_parse_nested(attrs
, TIPC_NLA_LINK_MAX
,
1674 info
->attrs
[TIPC_NLA_LINK
],
1675 tipc_nl_link_policy
);
1679 if (!attrs
[TIPC_NLA_LINK_NAME
])
1682 name
= nla_data(attrs
[TIPC_NLA_LINK_NAME
]);
1684 if (strcmp(name
, tipc_bclink_name
) == 0)
1685 return tipc_nl_bc_link_set(net
, attrs
);
1687 node
= tipc_node_find_by_name(net
, name
, &bearer_id
);
1691 tipc_node_read_lock(node
);
1693 link
= node
->links
[bearer_id
].link
;
1699 if (attrs
[TIPC_NLA_LINK_PROP
]) {
1700 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
1702 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_LINK_PROP
],
1709 if (props
[TIPC_NLA_PROP_TOL
]) {
1712 tol
= nla_get_u32(props
[TIPC_NLA_PROP_TOL
]);
1713 tipc_link_set_tolerance(link
, tol
, &xmitq
);
1715 if (props
[TIPC_NLA_PROP_PRIO
]) {
1718 prio
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
1719 tipc_link_set_prio(link
, prio
, &xmitq
);
1721 if (props
[TIPC_NLA_PROP_WIN
]) {
1724 win
= nla_get_u32(props
[TIPC_NLA_PROP_WIN
]);
1725 tipc_link_set_queue_limits(link
, win
);
1730 tipc_node_read_unlock(node
);
1731 tipc_bearer_xmit(net
, bearer_id
, &xmitq
, &node
->links
[bearer_id
].maddr
);
1735 int tipc_nl_node_get_link(struct sk_buff
*skb
, struct genl_info
*info
)
1737 struct net
*net
= genl_info_net(info
);
1738 struct tipc_nl_msg msg
;
1742 msg
.portid
= info
->snd_portid
;
1743 msg
.seq
= info
->snd_seq
;
1745 if (!info
->attrs
[TIPC_NLA_LINK_NAME
])
1747 name
= nla_data(info
->attrs
[TIPC_NLA_LINK_NAME
]);
1749 msg
.skb
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1753 if (strcmp(name
, tipc_bclink_name
) == 0) {
1754 err
= tipc_nl_add_bc_link(net
, &msg
);
1756 nlmsg_free(msg
.skb
);
1761 struct tipc_node
*node
;
1762 struct tipc_link
*link
;
1764 node
= tipc_node_find_by_name(net
, name
, &bearer_id
);
1768 tipc_node_read_lock(node
);
1769 link
= node
->links
[bearer_id
].link
;
1771 tipc_node_read_unlock(node
);
1772 nlmsg_free(msg
.skb
);
1776 err
= __tipc_nl_add_link(net
, &msg
, link
, 0);
1777 tipc_node_read_unlock(node
);
1779 nlmsg_free(msg
.skb
);
1784 return genlmsg_reply(msg
.skb
, info
);
1787 int tipc_nl_node_reset_link_stats(struct sk_buff
*skb
, struct genl_info
*info
)
1791 unsigned int bearer_id
;
1792 struct tipc_link
*link
;
1793 struct tipc_node
*node
;
1794 struct nlattr
*attrs
[TIPC_NLA_LINK_MAX
+ 1];
1795 struct net
*net
= sock_net(skb
->sk
);
1796 struct tipc_link_entry
*le
;
1798 if (!info
->attrs
[TIPC_NLA_LINK
])
1801 err
= nla_parse_nested(attrs
, TIPC_NLA_LINK_MAX
,
1802 info
->attrs
[TIPC_NLA_LINK
],
1803 tipc_nl_link_policy
);
1807 if (!attrs
[TIPC_NLA_LINK_NAME
])
1810 link_name
= nla_data(attrs
[TIPC_NLA_LINK_NAME
]);
1812 if (strcmp(link_name
, tipc_bclink_name
) == 0) {
1813 err
= tipc_bclink_reset_stats(net
);
1819 node
= tipc_node_find_by_name(net
, link_name
, &bearer_id
);
1823 le
= &node
->links
[bearer_id
];
1824 tipc_node_read_lock(node
);
1825 spin_lock_bh(&le
->lock
);
1826 link
= node
->links
[bearer_id
].link
;
1828 spin_unlock_bh(&le
->lock
);
1829 tipc_node_read_unlock(node
);
1832 tipc_link_reset_stats(link
);
1833 spin_unlock_bh(&le
->lock
);
1834 tipc_node_read_unlock(node
);
1838 /* Caller should hold node lock */
1839 static int __tipc_nl_add_node_links(struct net
*net
, struct tipc_nl_msg
*msg
,
1840 struct tipc_node
*node
, u32
*prev_link
)
1845 for (i
= *prev_link
; i
< MAX_BEARERS
; i
++) {
1848 if (!node
->links
[i
].link
)
1851 err
= __tipc_nl_add_link(net
, msg
,
1852 node
->links
[i
].link
, NLM_F_MULTI
);
1861 int tipc_nl_node_dump_link(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1863 struct net
*net
= sock_net(skb
->sk
);
1864 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
1865 struct tipc_node
*node
;
1866 struct tipc_nl_msg msg
;
1867 u32 prev_node
= cb
->args
[0];
1868 u32 prev_link
= cb
->args
[1];
1869 int done
= cb
->args
[2];
1876 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
1877 msg
.seq
= cb
->nlh
->nlmsg_seq
;
1881 node
= tipc_node_find(net
, prev_node
);
1883 /* We never set seq or call nl_dump_check_consistent()
1884 * this means that setting prev_seq here will cause the
1885 * consistence check to fail in the netlink callback
1886 * handler. Resulting in the last NLMSG_DONE message
1887 * having the NLM_F_DUMP_INTR flag set.
1892 tipc_node_put(node
);
1894 list_for_each_entry_continue_rcu(node
, &tn
->node_list
,
1896 tipc_node_read_lock(node
);
1897 err
= __tipc_nl_add_node_links(net
, &msg
, node
,
1899 tipc_node_read_unlock(node
);
1903 prev_node
= node
->addr
;
1906 err
= tipc_nl_add_bc_link(net
, &msg
);
1910 list_for_each_entry_rcu(node
, &tn
->node_list
, list
) {
1911 tipc_node_read_lock(node
);
1912 err
= __tipc_nl_add_node_links(net
, &msg
, node
,
1914 tipc_node_read_unlock(node
);
1918 prev_node
= node
->addr
;
1925 cb
->args
[0] = prev_node
;
1926 cb
->args
[1] = prev_link
;
1932 int tipc_nl_node_set_monitor(struct sk_buff
*skb
, struct genl_info
*info
)
1934 struct nlattr
*attrs
[TIPC_NLA_MON_MAX
+ 1];
1935 struct net
*net
= sock_net(skb
->sk
);
1938 if (!info
->attrs
[TIPC_NLA_MON
])
1941 err
= nla_parse_nested(attrs
, TIPC_NLA_MON_MAX
,
1942 info
->attrs
[TIPC_NLA_MON
],
1943 tipc_nl_monitor_policy
);
1947 if (attrs
[TIPC_NLA_MON_ACTIVATION_THRESHOLD
]) {
1950 val
= nla_get_u32(attrs
[TIPC_NLA_MON_ACTIVATION_THRESHOLD
]);
1951 err
= tipc_nl_monitor_set_threshold(net
, val
);
1959 static int __tipc_nl_add_monitor_prop(struct net
*net
, struct tipc_nl_msg
*msg
)
1961 struct nlattr
*attrs
;
1965 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_family
,
1966 0, TIPC_NL_MON_GET
);
1970 attrs
= nla_nest_start(msg
->skb
, TIPC_NLA_MON
);
1974 val
= tipc_nl_monitor_get_threshold(net
);
1976 if (nla_put_u32(msg
->skb
, TIPC_NLA_MON_ACTIVATION_THRESHOLD
, val
))
1979 nla_nest_end(msg
->skb
, attrs
);
1980 genlmsg_end(msg
->skb
, hdr
);
1985 nla_nest_cancel(msg
->skb
, attrs
);
1987 genlmsg_cancel(msg
->skb
, hdr
);
1992 int tipc_nl_node_get_monitor(struct sk_buff
*skb
, struct genl_info
*info
)
1994 struct net
*net
= sock_net(skb
->sk
);
1995 struct tipc_nl_msg msg
;
1998 msg
.skb
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1999 msg
.portid
= info
->snd_portid
;
2000 msg
.seq
= info
->snd_seq
;
2002 err
= __tipc_nl_add_monitor_prop(net
, &msg
);
2004 nlmsg_free(msg
.skb
);
2008 return genlmsg_reply(msg
.skb
, info
);
2011 int tipc_nl_node_dump_monitor(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2013 struct net
*net
= sock_net(skb
->sk
);
2014 u32 prev_bearer
= cb
->args
[0];
2015 struct tipc_nl_msg msg
;
2019 if (prev_bearer
== MAX_BEARERS
)
2023 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
2024 msg
.seq
= cb
->nlh
->nlmsg_seq
;
2027 for (i
= prev_bearer
; i
< MAX_BEARERS
; i
++) {
2029 err
= __tipc_nl_add_monitor(net
, &msg
, prev_bearer
);
2036 cb
->args
[0] = prev_bearer
;
2041 int tipc_nl_node_dump_monitor_peer(struct sk_buff
*skb
,
2042 struct netlink_callback
*cb
)
2044 struct net
*net
= sock_net(skb
->sk
);
2045 u32 prev_node
= cb
->args
[1];
2046 u32 bearer_id
= cb
->args
[2];
2047 int done
= cb
->args
[0];
2048 struct tipc_nl_msg msg
;
2052 struct nlattr
**attrs
;
2053 struct nlattr
*mon
[TIPC_NLA_MON_MAX
+ 1];
2055 err
= tipc_nlmsg_parse(cb
->nlh
, &attrs
);
2059 if (!attrs
[TIPC_NLA_MON
])
2062 err
= nla_parse_nested(mon
, TIPC_NLA_MON_MAX
,
2063 attrs
[TIPC_NLA_MON
],
2064 tipc_nl_monitor_policy
);
2068 if (!mon
[TIPC_NLA_MON_REF
])
2071 bearer_id
= nla_get_u32(mon
[TIPC_NLA_MON_REF
]);
2073 if (bearer_id
>= MAX_BEARERS
)
2081 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
2082 msg
.seq
= cb
->nlh
->nlmsg_seq
;
2085 err
= tipc_nl_add_monitor_peer(net
, &msg
, bearer_id
, &prev_node
);
2091 cb
->args
[1] = prev_node
;
2092 cb
->args
[2] = bearer_id
;