2 * net/tipc/node.c: TIPC node management routines
4 * Copyright (c) 2000-2006, 2012-2015, 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"
45 #define INVALID_NODE_SIG 0x10000
47 /* Flags used to take different actions according to flag type
48 * TIPC_NOTIFY_NODE_DOWN: notify node is down
49 * TIPC_NOTIFY_NODE_UP: notify node is up
50 * TIPC_DISTRIBUTE_NAME: publish or withdraw link state name type
53 TIPC_NOTIFY_NODE_DOWN
= (1 << 3),
54 TIPC_NOTIFY_NODE_UP
= (1 << 4),
55 TIPC_NOTIFY_LINK_UP
= (1 << 6),
56 TIPC_NOTIFY_LINK_DOWN
= (1 << 7)
59 struct tipc_link_entry
{
60 struct tipc_link
*link
;
61 spinlock_t lock
; /* per link */
63 struct sk_buff_head inputq
;
64 struct tipc_media_addr maddr
;
67 struct tipc_bclink_entry
{
68 struct tipc_link
*link
;
69 struct sk_buff_head inputq1
;
70 struct sk_buff_head arrvq
;
71 struct sk_buff_head inputq2
;
72 struct sk_buff_head namedq
;
76 * struct tipc_node - TIPC node structure
77 * @addr: network address of node
78 * @ref: reference counter to node object
79 * @lock: rwlock governing access to structure
80 * @net: the applicable net namespace
81 * @hash: links to adjacent nodes in unsorted hash chain
82 * @inputq: pointer to input queue containing messages for msg event
83 * @namedq: pointer to name table input queue with name table messages
84 * @active_links: bearer ids of active links, used as index into links[] array
85 * @links: array containing references to all links to node
86 * @action_flags: bit mask of different types of node actions
87 * @state: connectivity state vs peer node
88 * @sync_point: sequence number where synch/failover is finished
89 * @list: links to adjacent nodes in sorted list of cluster's nodes
90 * @working_links: number of working links to node (both active and standby)
91 * @link_cnt: number of links to node
92 * @capabilities: bitmap, indicating peer node's functional capabilities
93 * @signature: node instance identifier
94 * @link_id: local and remote bearer ids of changing link, if any
95 * @publ_list: list of publications
96 * @rcu: rcu struct for tipc_node
103 struct hlist_node hash
;
105 struct tipc_link_entry links
[MAX_BEARERS
];
106 struct tipc_bclink_entry bc_entry
;
108 struct list_head list
;
116 struct list_head publ_list
;
117 struct list_head conn_sks
;
118 unsigned long keepalive_intv
;
119 struct timer_list timer
;
123 /* Node FSM states and events:
126 SELF_DOWN_PEER_DOWN
= 0xdd,
127 SELF_UP_PEER_UP
= 0xaa,
128 SELF_DOWN_PEER_LEAVING
= 0xd1,
129 SELF_UP_PEER_COMING
= 0xac,
130 SELF_COMING_PEER_UP
= 0xca,
131 SELF_LEAVING_PEER_DOWN
= 0x1d,
132 NODE_FAILINGOVER
= 0xf0,
137 SELF_ESTABL_CONTACT_EVT
= 0xece,
138 SELF_LOST_CONTACT_EVT
= 0x1ce,
139 PEER_ESTABL_CONTACT_EVT
= 0x9ece,
140 PEER_LOST_CONTACT_EVT
= 0x91ce,
141 NODE_FAILOVER_BEGIN_EVT
= 0xfbe,
142 NODE_FAILOVER_END_EVT
= 0xfee,
143 NODE_SYNCH_BEGIN_EVT
= 0xcbe,
144 NODE_SYNCH_END_EVT
= 0xcee
147 static void __tipc_node_link_down(struct tipc_node
*n
, int *bearer_id
,
148 struct sk_buff_head
*xmitq
,
149 struct tipc_media_addr
**maddr
);
150 static void tipc_node_link_down(struct tipc_node
*n
, int bearer_id
,
152 static void node_lost_contact(struct tipc_node
*n
, struct sk_buff_head
*inputq
);
153 static void tipc_node_delete(struct tipc_node
*node
);
154 static void tipc_node_timeout(unsigned long data
);
155 static void tipc_node_fsm_evt(struct tipc_node
*n
, int evt
);
156 static struct tipc_node
*tipc_node_find(struct net
*net
, u32 addr
);
157 static void tipc_node_put(struct tipc_node
*node
);
158 static bool tipc_node_is_up(struct tipc_node
*n
);
160 struct tipc_sock_conn
{
164 struct list_head list
;
167 static const struct nla_policy tipc_nl_link_policy
[TIPC_NLA_LINK_MAX
+ 1] = {
168 [TIPC_NLA_LINK_UNSPEC
] = { .type
= NLA_UNSPEC
},
169 [TIPC_NLA_LINK_NAME
] = {
171 .len
= TIPC_MAX_LINK_NAME
173 [TIPC_NLA_LINK_MTU
] = { .type
= NLA_U32
},
174 [TIPC_NLA_LINK_BROADCAST
] = { .type
= NLA_FLAG
},
175 [TIPC_NLA_LINK_UP
] = { .type
= NLA_FLAG
},
176 [TIPC_NLA_LINK_ACTIVE
] = { .type
= NLA_FLAG
},
177 [TIPC_NLA_LINK_PROP
] = { .type
= NLA_NESTED
},
178 [TIPC_NLA_LINK_STATS
] = { .type
= NLA_NESTED
},
179 [TIPC_NLA_LINK_RX
] = { .type
= NLA_U32
},
180 [TIPC_NLA_LINK_TX
] = { .type
= NLA_U32
}
183 static const struct nla_policy tipc_nl_node_policy
[TIPC_NLA_NODE_MAX
+ 1] = {
184 [TIPC_NLA_NODE_UNSPEC
] = { .type
= NLA_UNSPEC
},
185 [TIPC_NLA_NODE_ADDR
] = { .type
= NLA_U32
},
186 [TIPC_NLA_NODE_UP
] = { .type
= NLA_FLAG
}
189 static struct tipc_link
*node_active_link(struct tipc_node
*n
, int sel
)
191 int bearer_id
= n
->active_links
[sel
& 1];
193 if (unlikely(bearer_id
== INVALID_BEARER_ID
))
196 return n
->links
[bearer_id
].link
;
199 int tipc_node_get_mtu(struct net
*net
, u32 addr
, u32 sel
)
203 unsigned int mtu
= MAX_MSG_SIZE
;
205 n
= tipc_node_find(net
, addr
);
209 bearer_id
= n
->active_links
[sel
& 1];
210 if (likely(bearer_id
!= INVALID_BEARER_ID
))
211 mtu
= n
->links
[bearer_id
].mtu
;
216 * A trivial power-of-two bitmask technique is used for speed, since this
217 * operation is done for every incoming TIPC packet. The number of hash table
218 * entries has been chosen so that no hash chain exceeds 8 nodes and will
219 * usually be much smaller (typically only a single node).
221 static unsigned int tipc_hashfn(u32 addr
)
223 return addr
& (NODE_HTABLE_SIZE
- 1);
226 static void tipc_node_kref_release(struct kref
*kref
)
228 struct tipc_node
*n
= container_of(kref
, struct tipc_node
, kref
);
230 kfree(n
->bc_entry
.link
);
234 static void tipc_node_put(struct tipc_node
*node
)
236 kref_put(&node
->kref
, tipc_node_kref_release
);
239 static void tipc_node_get(struct tipc_node
*node
)
241 kref_get(&node
->kref
);
245 * tipc_node_find - locate specified node object, if it exists
247 static struct tipc_node
*tipc_node_find(struct net
*net
, u32 addr
)
249 struct tipc_net
*tn
= tipc_net(net
);
250 struct tipc_node
*node
;
251 unsigned int thash
= tipc_hashfn(addr
);
253 if (unlikely(!in_own_cluster_exact(net
, addr
)))
257 hlist_for_each_entry_rcu(node
, &tn
->node_htable
[thash
], hash
) {
258 if (node
->addr
!= addr
)
260 if (!kref_get_unless_zero(&node
->kref
))
268 static void tipc_node_read_lock(struct tipc_node
*n
)
270 read_lock_bh(&n
->lock
);
273 static void tipc_node_read_unlock(struct tipc_node
*n
)
275 read_unlock_bh(&n
->lock
);
278 static void tipc_node_write_lock(struct tipc_node
*n
)
280 write_lock_bh(&n
->lock
);
283 static void tipc_node_write_unlock(struct tipc_node
*n
)
285 struct net
*net
= n
->net
;
287 u32 flags
= n
->action_flags
;
289 struct list_head
*publ_list
;
291 if (likely(!flags
)) {
292 write_unlock_bh(&n
->lock
);
297 link_id
= n
->link_id
;
298 publ_list
= &n
->publ_list
;
300 n
->action_flags
&= ~(TIPC_NOTIFY_NODE_DOWN
| TIPC_NOTIFY_NODE_UP
|
301 TIPC_NOTIFY_LINK_DOWN
| TIPC_NOTIFY_LINK_UP
);
303 write_unlock_bh(&n
->lock
);
305 if (flags
& TIPC_NOTIFY_NODE_DOWN
)
306 tipc_publ_notify(net
, publ_list
, addr
);
308 if (flags
& TIPC_NOTIFY_NODE_UP
)
309 tipc_named_node_up(net
, addr
);
311 if (flags
& TIPC_NOTIFY_LINK_UP
)
312 tipc_nametbl_publish(net
, TIPC_LINK_STATE
, addr
, addr
,
313 TIPC_NODE_SCOPE
, link_id
, addr
);
315 if (flags
& TIPC_NOTIFY_LINK_DOWN
)
316 tipc_nametbl_withdraw(net
, TIPC_LINK_STATE
, addr
,
320 struct tipc_node
*tipc_node_create(struct net
*net
, u32 addr
, u16 capabilities
)
322 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
323 struct tipc_node
*n
, *temp_node
;
326 spin_lock_bh(&tn
->node_list_lock
);
327 n
= tipc_node_find(net
, addr
);
330 n
= kzalloc(sizeof(*n
), GFP_ATOMIC
);
332 pr_warn("Node creation failed, no memory\n");
337 n
->capabilities
= capabilities
;
339 rwlock_init(&n
->lock
);
340 INIT_HLIST_NODE(&n
->hash
);
341 INIT_LIST_HEAD(&n
->list
);
342 INIT_LIST_HEAD(&n
->publ_list
);
343 INIT_LIST_HEAD(&n
->conn_sks
);
344 skb_queue_head_init(&n
->bc_entry
.namedq
);
345 skb_queue_head_init(&n
->bc_entry
.inputq1
);
346 __skb_queue_head_init(&n
->bc_entry
.arrvq
);
347 skb_queue_head_init(&n
->bc_entry
.inputq2
);
348 for (i
= 0; i
< MAX_BEARERS
; i
++)
349 spin_lock_init(&n
->links
[i
].lock
);
350 n
->state
= SELF_DOWN_PEER_LEAVING
;
351 n
->signature
= INVALID_NODE_SIG
;
352 n
->active_links
[0] = INVALID_BEARER_ID
;
353 n
->active_links
[1] = INVALID_BEARER_ID
;
354 if (!tipc_link_bc_create(net
, tipc_own_addr(net
), n
->addr
,
356 tipc_link_window(tipc_bc_sndlink(net
)),
358 &n
->bc_entry
.inputq1
,
360 tipc_bc_sndlink(net
),
361 &n
->bc_entry
.link
)) {
362 pr_warn("Broadcast rcv link creation failed, no memory\n");
368 setup_timer(&n
->timer
, tipc_node_timeout
, (unsigned long)n
);
369 n
->keepalive_intv
= U32_MAX
;
370 hlist_add_head_rcu(&n
->hash
, &tn
->node_htable
[tipc_hashfn(addr
)]);
371 list_for_each_entry_rcu(temp_node
, &tn
->node_list
, list
) {
372 if (n
->addr
< temp_node
->addr
)
375 list_add_tail_rcu(&n
->list
, &temp_node
->list
);
377 spin_unlock_bh(&tn
->node_list_lock
);
381 static void tipc_node_calculate_timer(struct tipc_node
*n
, struct tipc_link
*l
)
383 unsigned long tol
= tipc_link_tolerance(l
);
384 unsigned long intv
= ((tol
/ 4) > 500) ? 500 : tol
/ 4;
385 unsigned long keepalive_intv
= msecs_to_jiffies(intv
);
387 /* Link with lowest tolerance determines timer interval */
388 if (keepalive_intv
< n
->keepalive_intv
)
389 n
->keepalive_intv
= keepalive_intv
;
391 /* Ensure link's abort limit corresponds to current interval */
392 tipc_link_set_abort_limit(l
, tol
/ jiffies_to_msecs(n
->keepalive_intv
));
395 static void tipc_node_delete(struct tipc_node
*node
)
397 list_del_rcu(&node
->list
);
398 hlist_del_rcu(&node
->hash
);
401 del_timer_sync(&node
->timer
);
405 void tipc_node_stop(struct net
*net
)
407 struct tipc_net
*tn
= tipc_net(net
);
408 struct tipc_node
*node
, *t_node
;
410 spin_lock_bh(&tn
->node_list_lock
);
411 list_for_each_entry_safe(node
, t_node
, &tn
->node_list
, list
)
412 tipc_node_delete(node
);
413 spin_unlock_bh(&tn
->node_list_lock
);
416 void tipc_node_subscribe(struct net
*net
, struct list_head
*subscr
, u32 addr
)
420 if (in_own_node(net
, addr
))
423 n
= tipc_node_find(net
, addr
);
425 pr_warn("Node subscribe rejected, unknown node 0x%x\n", addr
);
428 tipc_node_write_lock(n
);
429 list_add_tail(subscr
, &n
->publ_list
);
430 tipc_node_write_unlock(n
);
434 void tipc_node_unsubscribe(struct net
*net
, struct list_head
*subscr
, u32 addr
)
438 if (in_own_node(net
, addr
))
441 n
= tipc_node_find(net
, addr
);
443 pr_warn("Node unsubscribe rejected, unknown node 0x%x\n", addr
);
446 tipc_node_write_lock(n
);
447 list_del_init(subscr
);
448 tipc_node_write_unlock(n
);
452 int tipc_node_add_conn(struct net
*net
, u32 dnode
, u32 port
, u32 peer_port
)
454 struct tipc_node
*node
;
455 struct tipc_sock_conn
*conn
;
458 if (in_own_node(net
, dnode
))
461 node
= tipc_node_find(net
, dnode
);
463 pr_warn("Connecting sock to node 0x%x failed\n", dnode
);
464 return -EHOSTUNREACH
;
466 conn
= kmalloc(sizeof(*conn
), GFP_ATOMIC
);
471 conn
->peer_node
= dnode
;
473 conn
->peer_port
= peer_port
;
475 tipc_node_write_lock(node
);
476 list_add_tail(&conn
->list
, &node
->conn_sks
);
477 tipc_node_write_unlock(node
);
483 void tipc_node_remove_conn(struct net
*net
, u32 dnode
, u32 port
)
485 struct tipc_node
*node
;
486 struct tipc_sock_conn
*conn
, *safe
;
488 if (in_own_node(net
, dnode
))
491 node
= tipc_node_find(net
, dnode
);
495 tipc_node_write_lock(node
);
496 list_for_each_entry_safe(conn
, safe
, &node
->conn_sks
, list
) {
497 if (port
!= conn
->port
)
499 list_del(&conn
->list
);
502 tipc_node_write_unlock(node
);
506 /* tipc_node_timeout - handle expiration of node timer
508 static void tipc_node_timeout(unsigned long data
)
510 struct tipc_node
*n
= (struct tipc_node
*)data
;
511 struct tipc_link_entry
*le
;
512 struct sk_buff_head xmitq
;
516 __skb_queue_head_init(&xmitq
);
518 for (bearer_id
= 0; bearer_id
< MAX_BEARERS
; bearer_id
++) {
519 tipc_node_read_lock(n
);
520 le
= &n
->links
[bearer_id
];
521 spin_lock_bh(&le
->lock
);
523 /* Link tolerance may change asynchronously: */
524 tipc_node_calculate_timer(n
, le
->link
);
525 rc
= tipc_link_timeout(le
->link
, &xmitq
);
527 spin_unlock_bh(&le
->lock
);
528 tipc_node_read_unlock(n
);
529 tipc_bearer_xmit(n
->net
, bearer_id
, &xmitq
, &le
->maddr
);
530 if (rc
& TIPC_LINK_DOWN_EVT
)
531 tipc_node_link_down(n
, bearer_id
, false);
533 mod_timer(&n
->timer
, jiffies
+ n
->keepalive_intv
);
537 * __tipc_node_link_up - handle addition of link
538 * Node lock must be held by caller
539 * Link becomes active (alone or shared) or standby, depending on its priority.
541 static void __tipc_node_link_up(struct tipc_node
*n
, int bearer_id
,
542 struct sk_buff_head
*xmitq
)
544 int *slot0
= &n
->active_links
[0];
545 int *slot1
= &n
->active_links
[1];
546 struct tipc_link
*ol
= node_active_link(n
, 0);
547 struct tipc_link
*nl
= n
->links
[bearer_id
].link
;
552 tipc_link_fsm_evt(nl
, LINK_ESTABLISH_EVT
);
553 if (!tipc_link_is_up(nl
))
557 n
->action_flags
|= TIPC_NOTIFY_LINK_UP
;
558 n
->link_id
= tipc_link_id(nl
);
560 /* Leave room for tunnel header when returning 'mtu' to users: */
561 n
->links
[bearer_id
].mtu
= tipc_link_mtu(nl
) - INT_H_SIZE
;
563 tipc_bearer_add_dest(n
->net
, bearer_id
, n
->addr
);
564 tipc_bcast_inc_bearer_dst_cnt(n
->net
, bearer_id
);
566 pr_debug("Established link <%s> on network plane %c\n",
567 tipc_link_name(nl
), tipc_link_plane(nl
));
569 /* First link? => give it both slots */
573 tipc_node_fsm_evt(n
, SELF_ESTABL_CONTACT_EVT
);
574 n
->action_flags
|= TIPC_NOTIFY_NODE_UP
;
575 tipc_bcast_add_peer(n
->net
, nl
, xmitq
);
579 /* Second link => redistribute slots */
580 if (tipc_link_prio(nl
) > tipc_link_prio(ol
)) {
581 pr_debug("Old link <%s> becomes standby\n", tipc_link_name(ol
));
584 tipc_link_set_active(nl
, true);
585 tipc_link_set_active(ol
, false);
586 } else if (tipc_link_prio(nl
) == tipc_link_prio(ol
)) {
587 tipc_link_set_active(nl
, true);
590 pr_debug("New link <%s> is standby\n", tipc_link_name(nl
));
593 /* Prepare synchronization with first link */
594 tipc_link_tnl_prepare(ol
, nl
, SYNCH_MSG
, xmitq
);
598 * tipc_node_link_up - handle addition of link
600 * Link becomes active (alone or shared) or standby, depending on its priority.
602 static void tipc_node_link_up(struct tipc_node
*n
, int bearer_id
,
603 struct sk_buff_head
*xmitq
)
605 tipc_node_write_lock(n
);
606 __tipc_node_link_up(n
, bearer_id
, xmitq
);
607 tipc_node_write_unlock(n
);
611 * __tipc_node_link_down - handle loss of link
613 static void __tipc_node_link_down(struct tipc_node
*n
, int *bearer_id
,
614 struct sk_buff_head
*xmitq
,
615 struct tipc_media_addr
**maddr
)
617 struct tipc_link_entry
*le
= &n
->links
[*bearer_id
];
618 int *slot0
= &n
->active_links
[0];
619 int *slot1
= &n
->active_links
[1];
620 int i
, highest
= 0, prio
;
621 struct tipc_link
*l
, *_l
, *tnl
;
623 l
= n
->links
[*bearer_id
].link
;
624 if (!l
|| tipc_link_is_reset(l
))
628 n
->action_flags
|= TIPC_NOTIFY_LINK_DOWN
;
629 n
->link_id
= tipc_link_id(l
);
631 tipc_bearer_remove_dest(n
->net
, *bearer_id
, n
->addr
);
633 pr_debug("Lost link <%s> on network plane %c\n",
634 tipc_link_name(l
), tipc_link_plane(l
));
636 /* Select new active link if any available */
637 *slot0
= INVALID_BEARER_ID
;
638 *slot1
= INVALID_BEARER_ID
;
639 for (i
= 0; i
< MAX_BEARERS
; i
++) {
640 _l
= n
->links
[i
].link
;
641 if (!_l
|| !tipc_link_is_up(_l
))
645 prio
= tipc_link_prio(_l
);
648 if (prio
> highest
) {
657 if (!tipc_node_is_up(n
)) {
658 if (tipc_link_peer_is_down(l
))
659 tipc_node_fsm_evt(n
, PEER_LOST_CONTACT_EVT
);
660 tipc_node_fsm_evt(n
, SELF_LOST_CONTACT_EVT
);
661 tipc_link_fsm_evt(l
, LINK_RESET_EVT
);
663 tipc_link_build_reset_msg(l
, xmitq
);
664 *maddr
= &n
->links
[*bearer_id
].maddr
;
665 node_lost_contact(n
, &le
->inputq
);
666 tipc_bcast_dec_bearer_dst_cnt(n
->net
, *bearer_id
);
669 tipc_bcast_dec_bearer_dst_cnt(n
->net
, *bearer_id
);
671 /* There is still a working link => initiate failover */
672 *bearer_id
= n
->active_links
[0];
673 tnl
= n
->links
[*bearer_id
].link
;
674 tipc_link_fsm_evt(tnl
, LINK_SYNCH_END_EVT
);
675 tipc_node_fsm_evt(n
, NODE_SYNCH_END_EVT
);
676 n
->sync_point
= tipc_link_rcv_nxt(tnl
) + (U16_MAX
/ 2 - 1);
677 tipc_link_tnl_prepare(l
, tnl
, FAILOVER_MSG
, xmitq
);
679 tipc_link_fsm_evt(l
, LINK_RESET_EVT
);
680 tipc_link_fsm_evt(l
, LINK_FAILOVER_BEGIN_EVT
);
681 tipc_node_fsm_evt(n
, NODE_FAILOVER_BEGIN_EVT
);
682 *maddr
= &n
->links
[*bearer_id
].maddr
;
685 static void tipc_node_link_down(struct tipc_node
*n
, int bearer_id
, bool delete)
687 struct tipc_link_entry
*le
= &n
->links
[bearer_id
];
688 struct tipc_link
*l
= le
->link
;
689 struct tipc_media_addr
*maddr
;
690 struct sk_buff_head xmitq
;
695 __skb_queue_head_init(&xmitq
);
697 tipc_node_write_lock(n
);
698 if (!tipc_link_is_establishing(l
)) {
699 __tipc_node_link_down(n
, &bearer_id
, &xmitq
, &maddr
);
706 /* Defuse pending tipc_node_link_up() */
707 tipc_link_fsm_evt(l
, LINK_RESET_EVT
);
709 tipc_node_write_unlock(n
);
710 tipc_bearer_xmit(n
->net
, bearer_id
, &xmitq
, maddr
);
711 tipc_sk_rcv(n
->net
, &le
->inputq
);
714 static bool tipc_node_is_up(struct tipc_node
*n
)
716 return n
->active_links
[0] != INVALID_BEARER_ID
;
719 void tipc_node_check_dest(struct net
*net
, u32 onode
,
720 struct tipc_bearer
*b
,
721 u16 capabilities
, u32 signature
,
722 struct tipc_media_addr
*maddr
,
723 bool *respond
, bool *dupl_addr
)
727 struct tipc_link_entry
*le
;
728 bool addr_match
= false;
729 bool sign_match
= false;
730 bool link_up
= false;
731 bool accept_addr
= false;
738 n
= tipc_node_create(net
, onode
, capabilities
);
742 tipc_node_write_lock(n
);
744 le
= &n
->links
[b
->identity
];
746 /* Prepare to validate requesting node's signature and media address */
748 link_up
= l
&& tipc_link_is_up(l
);
749 addr_match
= l
&& !memcmp(&le
->maddr
, maddr
, sizeof(*maddr
));
750 sign_match
= (signature
== n
->signature
);
752 /* These three flags give us eight permutations: */
754 if (sign_match
&& addr_match
&& link_up
) {
755 /* All is fine. Do nothing. */
757 } else if (sign_match
&& addr_match
&& !link_up
) {
758 /* Respond. The link will come up in due time */
760 } else if (sign_match
&& !addr_match
&& link_up
) {
761 /* Peer has changed i/f address without rebooting.
762 * If so, the link will reset soon, and the next
763 * discovery will be accepted. So we can ignore it.
764 * It may also be an cloned or malicious peer having
765 * chosen the same node address and signature as an
767 * Ignore requests until the link goes down, if ever.
770 } else if (sign_match
&& !addr_match
&& !link_up
) {
771 /* Peer link has changed i/f address without rebooting.
772 * It may also be a cloned or malicious peer; we can't
773 * distinguish between the two.
774 * The signature is correct, so we must accept.
778 } else if (!sign_match
&& addr_match
&& link_up
) {
779 /* Peer node rebooted. Two possibilities:
780 * - Delayed re-discovery; this link endpoint has already
781 * reset and re-established contact with the peer, before
782 * receiving a discovery message from that node.
783 * (The peer happened to receive one from this node first).
784 * - The peer came back so fast that our side has not
785 * discovered it yet. Probing from this side will soon
786 * reset the link, since there can be no working link
787 * endpoint at the peer end, and the link will re-establish.
788 * Accept the signature, since it comes from a known peer.
790 n
->signature
= signature
;
791 } else if (!sign_match
&& addr_match
&& !link_up
) {
792 /* The peer node has rebooted.
793 * Accept signature, since it is a known peer.
795 n
->signature
= signature
;
797 } else if (!sign_match
&& !addr_match
&& link_up
) {
798 /* Peer rebooted with new address, or a new/duplicate peer.
799 * Ignore until the link goes down, if ever.
802 } else if (!sign_match
&& !addr_match
&& !link_up
) {
803 /* Peer rebooted with new address, or it is a new peer.
804 * Accept signature and address.
806 n
->signature
= signature
;
814 /* Now create new link if not already existing */
816 if (n
->link_cnt
== 2) {
817 pr_warn("Cannot establish 3rd link to %x\n", n
->addr
);
820 if_name
= strchr(b
->name
, ':') + 1;
821 if (!tipc_link_create(net
, if_name
, b
->identity
, b
->tolerance
,
822 b
->net_plane
, b
->mtu
, b
->priority
,
823 b
->window
, mod(tipc_net(net
)->random
),
824 tipc_own_addr(net
), onode
,
826 tipc_bc_sndlink(n
->net
), n
->bc_entry
.link
,
828 &n
->bc_entry
.namedq
, &l
)) {
833 tipc_link_fsm_evt(l
, LINK_RESET_EVT
);
834 if (n
->state
== NODE_FAILINGOVER
)
835 tipc_link_fsm_evt(l
, LINK_FAILOVER_BEGIN_EVT
);
838 tipc_node_calculate_timer(n
, l
);
839 if (n
->link_cnt
== 1)
840 if (!mod_timer(&n
->timer
, jiffies
+ n
->keepalive_intv
))
843 memcpy(&le
->maddr
, maddr
, sizeof(*maddr
));
845 tipc_node_write_unlock(n
);
846 if (reset
&& !tipc_link_is_reset(l
))
847 tipc_node_link_down(n
, b
->identity
, false);
851 void tipc_node_delete_links(struct net
*net
, int bearer_id
)
853 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
857 list_for_each_entry_rcu(n
, &tn
->node_list
, list
) {
858 tipc_node_link_down(n
, bearer_id
, true);
863 static void tipc_node_reset_links(struct tipc_node
*n
)
865 char addr_string
[16];
868 pr_warn("Resetting all links to %s\n",
869 tipc_addr_string_fill(addr_string
, n
->addr
));
871 for (i
= 0; i
< MAX_BEARERS
; i
++) {
872 tipc_node_link_down(n
, i
, false);
876 /* tipc_node_fsm_evt - node finite state machine
877 * Determines when contact is allowed with peer node
879 static void tipc_node_fsm_evt(struct tipc_node
*n
, int evt
)
881 int state
= n
->state
;
884 case SELF_DOWN_PEER_DOWN
:
886 case SELF_ESTABL_CONTACT_EVT
:
887 state
= SELF_UP_PEER_COMING
;
889 case PEER_ESTABL_CONTACT_EVT
:
890 state
= SELF_COMING_PEER_UP
;
892 case SELF_LOST_CONTACT_EVT
:
893 case PEER_LOST_CONTACT_EVT
:
895 case NODE_SYNCH_END_EVT
:
896 case NODE_SYNCH_BEGIN_EVT
:
897 case NODE_FAILOVER_BEGIN_EVT
:
898 case NODE_FAILOVER_END_EVT
:
903 case SELF_UP_PEER_UP
:
905 case SELF_LOST_CONTACT_EVT
:
906 state
= SELF_DOWN_PEER_LEAVING
;
908 case PEER_LOST_CONTACT_EVT
:
909 state
= SELF_LEAVING_PEER_DOWN
;
911 case NODE_SYNCH_BEGIN_EVT
:
912 state
= NODE_SYNCHING
;
914 case NODE_FAILOVER_BEGIN_EVT
:
915 state
= NODE_FAILINGOVER
;
917 case SELF_ESTABL_CONTACT_EVT
:
918 case PEER_ESTABL_CONTACT_EVT
:
919 case NODE_SYNCH_END_EVT
:
920 case NODE_FAILOVER_END_EVT
:
926 case SELF_DOWN_PEER_LEAVING
:
928 case PEER_LOST_CONTACT_EVT
:
929 state
= SELF_DOWN_PEER_DOWN
;
931 case SELF_ESTABL_CONTACT_EVT
:
932 case PEER_ESTABL_CONTACT_EVT
:
933 case SELF_LOST_CONTACT_EVT
:
935 case NODE_SYNCH_END_EVT
:
936 case NODE_SYNCH_BEGIN_EVT
:
937 case NODE_FAILOVER_BEGIN_EVT
:
938 case NODE_FAILOVER_END_EVT
:
943 case SELF_UP_PEER_COMING
:
945 case PEER_ESTABL_CONTACT_EVT
:
946 state
= SELF_UP_PEER_UP
;
948 case SELF_LOST_CONTACT_EVT
:
949 state
= SELF_DOWN_PEER_LEAVING
;
951 case SELF_ESTABL_CONTACT_EVT
:
952 case PEER_LOST_CONTACT_EVT
:
953 case NODE_SYNCH_END_EVT
:
954 case NODE_FAILOVER_BEGIN_EVT
:
956 case NODE_SYNCH_BEGIN_EVT
:
957 case NODE_FAILOVER_END_EVT
:
962 case SELF_COMING_PEER_UP
:
964 case SELF_ESTABL_CONTACT_EVT
:
965 state
= SELF_UP_PEER_UP
;
967 case PEER_LOST_CONTACT_EVT
:
968 state
= SELF_LEAVING_PEER_DOWN
;
970 case SELF_LOST_CONTACT_EVT
:
971 case PEER_ESTABL_CONTACT_EVT
:
973 case NODE_SYNCH_END_EVT
:
974 case NODE_SYNCH_BEGIN_EVT
:
975 case NODE_FAILOVER_BEGIN_EVT
:
976 case NODE_FAILOVER_END_EVT
:
981 case SELF_LEAVING_PEER_DOWN
:
983 case SELF_LOST_CONTACT_EVT
:
984 state
= SELF_DOWN_PEER_DOWN
;
986 case SELF_ESTABL_CONTACT_EVT
:
987 case PEER_ESTABL_CONTACT_EVT
:
988 case PEER_LOST_CONTACT_EVT
:
990 case NODE_SYNCH_END_EVT
:
991 case NODE_SYNCH_BEGIN_EVT
:
992 case NODE_FAILOVER_BEGIN_EVT
:
993 case NODE_FAILOVER_END_EVT
:
998 case NODE_FAILINGOVER
:
1000 case SELF_LOST_CONTACT_EVT
:
1001 state
= SELF_DOWN_PEER_LEAVING
;
1003 case PEER_LOST_CONTACT_EVT
:
1004 state
= SELF_LEAVING_PEER_DOWN
;
1006 case NODE_FAILOVER_END_EVT
:
1007 state
= SELF_UP_PEER_UP
;
1009 case NODE_FAILOVER_BEGIN_EVT
:
1010 case SELF_ESTABL_CONTACT_EVT
:
1011 case PEER_ESTABL_CONTACT_EVT
:
1013 case NODE_SYNCH_BEGIN_EVT
:
1014 case NODE_SYNCH_END_EVT
:
1021 case SELF_LOST_CONTACT_EVT
:
1022 state
= SELF_DOWN_PEER_LEAVING
;
1024 case PEER_LOST_CONTACT_EVT
:
1025 state
= SELF_LEAVING_PEER_DOWN
;
1027 case NODE_SYNCH_END_EVT
:
1028 state
= SELF_UP_PEER_UP
;
1030 case NODE_FAILOVER_BEGIN_EVT
:
1031 state
= NODE_FAILINGOVER
;
1033 case NODE_SYNCH_BEGIN_EVT
:
1034 case SELF_ESTABL_CONTACT_EVT
:
1035 case PEER_ESTABL_CONTACT_EVT
:
1037 case NODE_FAILOVER_END_EVT
:
1043 pr_err("Unknown node fsm state %x\n", state
);
1050 pr_err("Illegal node fsm evt %x in state %x\n", evt
, state
);
1053 static void node_lost_contact(struct tipc_node
*n
,
1054 struct sk_buff_head
*inputq
)
1056 char addr_string
[16];
1057 struct tipc_sock_conn
*conn
, *safe
;
1058 struct tipc_link
*l
;
1059 struct list_head
*conns
= &n
->conn_sks
;
1060 struct sk_buff
*skb
;
1063 pr_debug("Lost contact with %s\n",
1064 tipc_addr_string_fill(addr_string
, n
->addr
));
1066 /* Clean up broadcast state */
1067 tipc_bcast_remove_peer(n
->net
, n
->bc_entry
.link
);
1069 /* Abort any ongoing link failover */
1070 for (i
= 0; i
< MAX_BEARERS
; i
++) {
1071 l
= n
->links
[i
].link
;
1073 tipc_link_fsm_evt(l
, LINK_FAILOVER_END_EVT
);
1076 /* Notify publications from this node */
1077 n
->action_flags
|= TIPC_NOTIFY_NODE_DOWN
;
1079 /* Notify sockets connected to node */
1080 list_for_each_entry_safe(conn
, safe
, conns
, list
) {
1081 skb
= tipc_msg_create(TIPC_CRITICAL_IMPORTANCE
, TIPC_CONN_MSG
,
1082 SHORT_H_SIZE
, 0, tipc_own_addr(n
->net
),
1083 conn
->peer_node
, conn
->port
,
1084 conn
->peer_port
, TIPC_ERR_NO_NODE
);
1086 skb_queue_tail(inputq
, skb
);
1087 list_del(&conn
->list
);
1093 * tipc_node_get_linkname - get the name of a link
1095 * @bearer_id: id of the bearer
1096 * @node: peer node address
1097 * @linkname: link name output buffer
1099 * Returns 0 on success
1101 int tipc_node_get_linkname(struct net
*net
, u32 bearer_id
, u32 addr
,
1102 char *linkname
, size_t len
)
1104 struct tipc_link
*link
;
1106 struct tipc_node
*node
= tipc_node_find(net
, addr
);
1111 if (bearer_id
>= MAX_BEARERS
)
1114 tipc_node_read_lock(node
);
1115 link
= node
->links
[bearer_id
].link
;
1117 strncpy(linkname
, tipc_link_name(link
), len
);
1121 tipc_node_read_unlock(node
);
1122 tipc_node_put(node
);
1126 /* Caller should hold node lock for the passed node */
1127 static int __tipc_nl_add_node(struct tipc_nl_msg
*msg
, struct tipc_node
*node
)
1130 struct nlattr
*attrs
;
1132 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_family
,
1133 NLM_F_MULTI
, TIPC_NL_NODE_GET
);
1137 attrs
= nla_nest_start(msg
->skb
, TIPC_NLA_NODE
);
1141 if (nla_put_u32(msg
->skb
, TIPC_NLA_NODE_ADDR
, node
->addr
))
1143 if (tipc_node_is_up(node
))
1144 if (nla_put_flag(msg
->skb
, TIPC_NLA_NODE_UP
))
1147 nla_nest_end(msg
->skb
, attrs
);
1148 genlmsg_end(msg
->skb
, hdr
);
1153 nla_nest_cancel(msg
->skb
, attrs
);
1155 genlmsg_cancel(msg
->skb
, hdr
);
1161 * tipc_node_xmit() is the general link level function for message sending
1162 * @net: the applicable net namespace
1163 * @list: chain of buffers containing message
1164 * @dnode: address of destination node
1165 * @selector: a number used for deterministic link selection
1166 * Consumes the buffer chain, except when returning -ELINKCONG
1167 * Returns 0 if success, otherwise: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE,-ENOBUF
1169 int tipc_node_xmit(struct net
*net
, struct sk_buff_head
*list
,
1170 u32 dnode
, int selector
)
1172 struct tipc_link_entry
*le
= NULL
;
1173 struct tipc_node
*n
;
1174 struct sk_buff_head xmitq
;
1178 if (in_own_node(net
, dnode
)) {
1179 tipc_sk_rcv(net
, list
);
1183 n
= tipc_node_find(net
, dnode
);
1185 skb_queue_purge(list
);
1186 return -EHOSTUNREACH
;
1189 tipc_node_read_lock(n
);
1190 bearer_id
= n
->active_links
[selector
& 1];
1191 if (unlikely(bearer_id
== INVALID_BEARER_ID
)) {
1192 tipc_node_read_unlock(n
);
1194 skb_queue_purge(list
);
1195 return -EHOSTUNREACH
;
1198 __skb_queue_head_init(&xmitq
);
1199 le
= &n
->links
[bearer_id
];
1200 spin_lock_bh(&le
->lock
);
1201 rc
= tipc_link_xmit(le
->link
, list
, &xmitq
);
1202 spin_unlock_bh(&le
->lock
);
1203 tipc_node_read_unlock(n
);
1205 if (likely(rc
== 0))
1206 tipc_bearer_xmit(net
, bearer_id
, &xmitq
, &le
->maddr
);
1207 else if (rc
== -ENOBUFS
)
1208 tipc_node_link_down(n
, bearer_id
, false);
1215 /* tipc_node_xmit_skb(): send single buffer to destination
1216 * Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE
1217 * messages, which will not be rejected
1218 * The only exception is datagram messages rerouted after secondary
1219 * lookup, which are rare and safe to dispose of anyway.
1220 * TODO: Return real return value, and let callers use
1221 * tipc_wait_for_sendpkt() where applicable
1223 int tipc_node_xmit_skb(struct net
*net
, struct sk_buff
*skb
, u32 dnode
,
1226 struct sk_buff_head head
;
1229 skb_queue_head_init(&head
);
1230 __skb_queue_tail(&head
, skb
);
1231 rc
= tipc_node_xmit(net
, &head
, dnode
, selector
);
1232 if (rc
== -ELINKCONG
)
1237 void tipc_node_broadcast(struct net
*net
, struct sk_buff
*skb
)
1239 struct sk_buff
*txskb
;
1240 struct tipc_node
*n
;
1244 list_for_each_entry_rcu(n
, tipc_nodes(net
), list
) {
1246 if (in_own_node(net
, dst
))
1248 if (!tipc_node_is_up(n
))
1250 txskb
= pskb_copy(skb
, GFP_ATOMIC
);
1253 msg_set_destnode(buf_msg(txskb
), dst
);
1254 tipc_node_xmit_skb(net
, txskb
, dst
, 0);
1262 * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node
1263 * @net: the applicable net namespace
1265 * @bearer_id: id of bearer message arrived on
1267 * Invoked with no locks held.
1269 static void tipc_node_bc_rcv(struct net
*net
, struct sk_buff
*skb
, int bearer_id
)
1272 struct sk_buff_head xmitq
;
1273 struct tipc_bclink_entry
*be
;
1274 struct tipc_link_entry
*le
;
1275 struct tipc_msg
*hdr
= buf_msg(skb
);
1276 int usr
= msg_user(hdr
);
1277 u32 dnode
= msg_destnode(hdr
);
1278 struct tipc_node
*n
;
1280 __skb_queue_head_init(&xmitq
);
1282 /* If NACK for other node, let rcv link for that node peek into it */
1283 if ((usr
== BCAST_PROTOCOL
) && (dnode
!= tipc_own_addr(net
)))
1284 n
= tipc_node_find(net
, dnode
);
1286 n
= tipc_node_find(net
, msg_prevnode(hdr
));
1292 le
= &n
->links
[bearer_id
];
1294 rc
= tipc_bcast_rcv(net
, be
->link
, skb
);
1296 /* Broadcast link reset may happen at reassembly failure */
1297 if (rc
& TIPC_LINK_DOWN_EVT
)
1298 tipc_node_reset_links(n
);
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_ack_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
);
1323 * tipc_node_check_state - check and if necessary update node state
1325 * @bearer_id: identity of bearer delivering the packet
1326 * Returns true if state is ok, otherwise consumes buffer and returns false
1328 static bool tipc_node_check_state(struct tipc_node
*n
, struct sk_buff
*skb
,
1329 int bearer_id
, struct sk_buff_head
*xmitq
)
1331 struct tipc_msg
*hdr
= buf_msg(skb
);
1332 int usr
= msg_user(hdr
);
1333 int mtyp
= msg_type(hdr
);
1334 u16 oseqno
= msg_seqno(hdr
);
1335 u16 iseqno
= msg_seqno(msg_get_wrapped(hdr
));
1336 u16 exp_pkts
= msg_msgcnt(hdr
);
1337 u16 rcv_nxt
, syncpt
, dlv_nxt
, inputq_len
;
1338 int state
= n
->state
;
1339 struct tipc_link
*l
, *tnl
, *pl
= NULL
;
1340 struct tipc_media_addr
*maddr
;
1343 l
= n
->links
[bearer_id
].link
;
1346 rcv_nxt
= tipc_link_rcv_nxt(l
);
1349 if (likely((state
== SELF_UP_PEER_UP
) && (usr
!= TUNNEL_PROTOCOL
)))
1352 /* Find parallel link, if any */
1353 for (pb_id
= 0; pb_id
< MAX_BEARERS
; pb_id
++) {
1354 if ((pb_id
!= bearer_id
) && n
->links
[pb_id
].link
) {
1355 pl
= n
->links
[pb_id
].link
;
1360 /* Check and update node accesibility if applicable */
1361 if (state
== SELF_UP_PEER_COMING
) {
1362 if (!tipc_link_is_up(l
))
1364 if (!msg_peer_link_is_up(hdr
))
1366 tipc_node_fsm_evt(n
, PEER_ESTABL_CONTACT_EVT
);
1369 if (state
== SELF_DOWN_PEER_LEAVING
) {
1370 if (msg_peer_node_is_up(hdr
))
1372 tipc_node_fsm_evt(n
, PEER_LOST_CONTACT_EVT
);
1376 if (state
== SELF_LEAVING_PEER_DOWN
)
1379 /* Ignore duplicate packets */
1380 if ((usr
!= LINK_PROTOCOL
) && less(oseqno
, rcv_nxt
))
1383 /* Initiate or update failover mode if applicable */
1384 if ((usr
== TUNNEL_PROTOCOL
) && (mtyp
== FAILOVER_MSG
)) {
1385 syncpt
= oseqno
+ exp_pkts
- 1;
1386 if (pl
&& tipc_link_is_up(pl
)) {
1387 __tipc_node_link_down(n
, &pb_id
, xmitq
, &maddr
);
1388 tipc_skb_queue_splice_tail_init(tipc_link_inputq(pl
),
1389 tipc_link_inputq(l
));
1391 /* If pkts arrive out of order, use lowest calculated syncpt */
1392 if (less(syncpt
, n
->sync_point
))
1393 n
->sync_point
= syncpt
;
1396 /* Open parallel link when tunnel link reaches synch point */
1397 if ((n
->state
== NODE_FAILINGOVER
) && tipc_link_is_up(l
)) {
1398 if (!more(rcv_nxt
, n
->sync_point
))
1400 tipc_node_fsm_evt(n
, NODE_FAILOVER_END_EVT
);
1402 tipc_link_fsm_evt(pl
, LINK_FAILOVER_END_EVT
);
1406 /* No synching needed if only one link */
1407 if (!pl
|| !tipc_link_is_up(pl
))
1410 /* Initiate synch mode if applicable */
1411 if ((usr
== TUNNEL_PROTOCOL
) && (mtyp
== SYNCH_MSG
) && (oseqno
== 1)) {
1412 syncpt
= iseqno
+ exp_pkts
- 1;
1413 if (!tipc_link_is_up(l
)) {
1414 tipc_link_fsm_evt(l
, LINK_ESTABLISH_EVT
);
1415 __tipc_node_link_up(n
, bearer_id
, xmitq
);
1417 if (n
->state
== SELF_UP_PEER_UP
) {
1418 n
->sync_point
= syncpt
;
1419 tipc_link_fsm_evt(l
, LINK_SYNCH_BEGIN_EVT
);
1420 tipc_node_fsm_evt(n
, NODE_SYNCH_BEGIN_EVT
);
1424 /* Open tunnel link when parallel link reaches synch point */
1425 if (n
->state
== NODE_SYNCHING
) {
1426 if (tipc_link_is_synching(l
)) {
1432 inputq_len
= skb_queue_len(tipc_link_inputq(pl
));
1433 dlv_nxt
= tipc_link_rcv_nxt(pl
) - inputq_len
;
1434 if (more(dlv_nxt
, n
->sync_point
)) {
1435 tipc_link_fsm_evt(tnl
, LINK_SYNCH_END_EVT
);
1436 tipc_node_fsm_evt(n
, NODE_SYNCH_END_EVT
);
1441 if ((usr
== TUNNEL_PROTOCOL
) && (mtyp
== SYNCH_MSG
))
1443 if (usr
== LINK_PROTOCOL
)
1451 * tipc_rcv - process TIPC packets/messages arriving from off-node
1452 * @net: the applicable net namespace
1454 * @bearer: pointer to bearer message arrived on
1456 * Invoked with no locks held. Bearer pointer must point to a valid bearer
1457 * structure (i.e. cannot be NULL), but bearer can be inactive.
1459 void tipc_rcv(struct net
*net
, struct sk_buff
*skb
, struct tipc_bearer
*b
)
1461 struct sk_buff_head xmitq
;
1462 struct tipc_node
*n
;
1463 struct tipc_msg
*hdr
= buf_msg(skb
);
1464 int usr
= msg_user(hdr
);
1465 int bearer_id
= b
->identity
;
1466 struct tipc_link_entry
*le
;
1467 u16 bc_ack
= msg_bcast_ack(hdr
);
1470 __skb_queue_head_init(&xmitq
);
1472 /* Ensure message is well-formed */
1473 if (unlikely(!tipc_msg_validate(skb
)))
1476 /* Handle arrival of discovery or broadcast packet */
1477 if (unlikely(msg_non_seq(hdr
))) {
1478 if (unlikely(usr
== LINK_CONFIG
))
1479 return tipc_disc_rcv(net
, skb
, b
);
1481 return tipc_node_bc_rcv(net
, skb
, bearer_id
);
1484 /* Locate neighboring node that sent packet */
1485 n
= tipc_node_find(net
, msg_prevnode(hdr
));
1488 le
= &n
->links
[bearer_id
];
1490 /* Ensure broadcast reception is in synch with peer's send state */
1491 if (unlikely(usr
== LINK_PROTOCOL
))
1492 tipc_bcast_sync_rcv(net
, n
->bc_entry
.link
, hdr
);
1493 else if (unlikely(tipc_link_acked(n
->bc_entry
.link
) != bc_ack
))
1494 tipc_bcast_ack_rcv(net
, n
->bc_entry
.link
, bc_ack
);
1496 /* Receive packet directly if conditions permit */
1497 tipc_node_read_lock(n
);
1498 if (likely((n
->state
== SELF_UP_PEER_UP
) && (usr
!= TUNNEL_PROTOCOL
))) {
1499 spin_lock_bh(&le
->lock
);
1501 rc
= tipc_link_rcv(le
->link
, skb
, &xmitq
);
1504 spin_unlock_bh(&le
->lock
);
1506 tipc_node_read_unlock(n
);
1508 /* Check/update node state before receiving */
1509 if (unlikely(skb
)) {
1510 tipc_node_write_lock(n
);
1511 if (tipc_node_check_state(n
, skb
, bearer_id
, &xmitq
)) {
1513 rc
= tipc_link_rcv(le
->link
, skb
, &xmitq
);
1517 tipc_node_write_unlock(n
);
1520 if (unlikely(rc
& TIPC_LINK_UP_EVT
))
1521 tipc_node_link_up(n
, bearer_id
, &xmitq
);
1523 if (unlikely(rc
& TIPC_LINK_DOWN_EVT
))
1524 tipc_node_link_down(n
, bearer_id
, false);
1526 if (unlikely(!skb_queue_empty(&n
->bc_entry
.namedq
)))
1527 tipc_named_rcv(net
, &n
->bc_entry
.namedq
);
1529 if (!skb_queue_empty(&le
->inputq
))
1530 tipc_sk_rcv(net
, &le
->inputq
);
1532 if (!skb_queue_empty(&xmitq
))
1533 tipc_bearer_xmit(net
, bearer_id
, &xmitq
, &le
->maddr
);
1540 int tipc_nl_node_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1543 struct net
*net
= sock_net(skb
->sk
);
1544 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
1545 int done
= cb
->args
[0];
1546 int last_addr
= cb
->args
[1];
1547 struct tipc_node
*node
;
1548 struct tipc_nl_msg msg
;
1554 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
1555 msg
.seq
= cb
->nlh
->nlmsg_seq
;
1559 node
= tipc_node_find(net
, last_addr
);
1562 /* We never set seq or call nl_dump_check_consistent()
1563 * this means that setting prev_seq here will cause the
1564 * consistence check to fail in the netlink callback
1565 * handler. Resulting in the NLMSG_DONE message having
1566 * the NLM_F_DUMP_INTR flag set if the node state
1567 * changed while we released the lock.
1572 tipc_node_put(node
);
1575 list_for_each_entry_rcu(node
, &tn
->node_list
, list
) {
1577 if (node
->addr
== last_addr
)
1583 tipc_node_read_lock(node
);
1584 err
= __tipc_nl_add_node(&msg
, node
);
1586 last_addr
= node
->addr
;
1587 tipc_node_read_unlock(node
);
1591 tipc_node_read_unlock(node
);
1596 cb
->args
[1] = last_addr
;
1602 /* tipc_node_find_by_name - locate owner node of link by link's name
1603 * @net: the applicable net namespace
1604 * @name: pointer to link name string
1605 * @bearer_id: pointer to index in 'node->links' array where the link was found.
1607 * Returns pointer to node owning the link, or 0 if no matching link is found.
1609 static struct tipc_node
*tipc_node_find_by_name(struct net
*net
,
1610 const char *link_name
,
1611 unsigned int *bearer_id
)
1613 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
1614 struct tipc_link
*l
;
1615 struct tipc_node
*n
;
1616 struct tipc_node
*found_node
= NULL
;
1621 list_for_each_entry_rcu(n
, &tn
->node_list
, list
) {
1622 tipc_node_read_lock(n
);
1623 for (i
= 0; i
< MAX_BEARERS
; i
++) {
1624 l
= n
->links
[i
].link
;
1625 if (l
&& !strcmp(tipc_link_name(l
), link_name
)) {
1631 tipc_node_read_unlock(n
);
1640 int tipc_nl_node_set_link(struct sk_buff
*skb
, struct genl_info
*info
)
1646 struct tipc_link
*link
;
1647 struct tipc_node
*node
;
1648 struct sk_buff_head xmitq
;
1649 struct nlattr
*attrs
[TIPC_NLA_LINK_MAX
+ 1];
1650 struct net
*net
= sock_net(skb
->sk
);
1652 __skb_queue_head_init(&xmitq
);
1654 if (!info
->attrs
[TIPC_NLA_LINK
])
1657 err
= nla_parse_nested(attrs
, TIPC_NLA_LINK_MAX
,
1658 info
->attrs
[TIPC_NLA_LINK
],
1659 tipc_nl_link_policy
);
1663 if (!attrs
[TIPC_NLA_LINK_NAME
])
1666 name
= nla_data(attrs
[TIPC_NLA_LINK_NAME
]);
1668 if (strcmp(name
, tipc_bclink_name
) == 0)
1669 return tipc_nl_bc_link_set(net
, attrs
);
1671 node
= tipc_node_find_by_name(net
, name
, &bearer_id
);
1675 tipc_node_read_lock(node
);
1677 link
= node
->links
[bearer_id
].link
;
1683 if (attrs
[TIPC_NLA_LINK_PROP
]) {
1684 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
1686 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_LINK_PROP
],
1693 if (props
[TIPC_NLA_PROP_TOL
]) {
1696 tol
= nla_get_u32(props
[TIPC_NLA_PROP_TOL
]);
1697 tipc_link_set_tolerance(link
, tol
, &xmitq
);
1699 if (props
[TIPC_NLA_PROP_PRIO
]) {
1702 prio
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
1703 tipc_link_set_prio(link
, prio
, &xmitq
);
1705 if (props
[TIPC_NLA_PROP_WIN
]) {
1708 win
= nla_get_u32(props
[TIPC_NLA_PROP_WIN
]);
1709 tipc_link_set_queue_limits(link
, win
);
1714 tipc_node_read_unlock(node
);
1715 tipc_bearer_xmit(net
, bearer_id
, &xmitq
, &node
->links
[bearer_id
].maddr
);
1719 int tipc_nl_node_get_link(struct sk_buff
*skb
, struct genl_info
*info
)
1721 struct net
*net
= genl_info_net(info
);
1722 struct tipc_nl_msg msg
;
1726 msg
.portid
= info
->snd_portid
;
1727 msg
.seq
= info
->snd_seq
;
1729 if (!info
->attrs
[TIPC_NLA_LINK_NAME
])
1731 name
= nla_data(info
->attrs
[TIPC_NLA_LINK_NAME
]);
1733 msg
.skb
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1737 if (strcmp(name
, tipc_bclink_name
) == 0) {
1738 err
= tipc_nl_add_bc_link(net
, &msg
);
1740 nlmsg_free(msg
.skb
);
1745 struct tipc_node
*node
;
1746 struct tipc_link
*link
;
1748 node
= tipc_node_find_by_name(net
, name
, &bearer_id
);
1752 tipc_node_read_lock(node
);
1753 link
= node
->links
[bearer_id
].link
;
1755 tipc_node_read_unlock(node
);
1756 nlmsg_free(msg
.skb
);
1760 err
= __tipc_nl_add_link(net
, &msg
, link
, 0);
1761 tipc_node_read_unlock(node
);
1763 nlmsg_free(msg
.skb
);
1768 return genlmsg_reply(msg
.skb
, info
);
1771 int tipc_nl_node_reset_link_stats(struct sk_buff
*skb
, struct genl_info
*info
)
1775 unsigned int bearer_id
;
1776 struct tipc_link
*link
;
1777 struct tipc_node
*node
;
1778 struct nlattr
*attrs
[TIPC_NLA_LINK_MAX
+ 1];
1779 struct net
*net
= sock_net(skb
->sk
);
1780 struct tipc_link_entry
*le
;
1782 if (!info
->attrs
[TIPC_NLA_LINK
])
1785 err
= nla_parse_nested(attrs
, TIPC_NLA_LINK_MAX
,
1786 info
->attrs
[TIPC_NLA_LINK
],
1787 tipc_nl_link_policy
);
1791 if (!attrs
[TIPC_NLA_LINK_NAME
])
1794 link_name
= nla_data(attrs
[TIPC_NLA_LINK_NAME
]);
1796 if (strcmp(link_name
, tipc_bclink_name
) == 0) {
1797 err
= tipc_bclink_reset_stats(net
);
1803 node
= tipc_node_find_by_name(net
, link_name
, &bearer_id
);
1807 le
= &node
->links
[bearer_id
];
1808 tipc_node_read_lock(node
);
1809 spin_lock_bh(&le
->lock
);
1810 link
= node
->links
[bearer_id
].link
;
1812 spin_unlock_bh(&le
->lock
);
1813 tipc_node_read_unlock(node
);
1816 tipc_link_reset_stats(link
);
1817 spin_unlock_bh(&le
->lock
);
1818 tipc_node_read_unlock(node
);
1822 /* Caller should hold node lock */
1823 static int __tipc_nl_add_node_links(struct net
*net
, struct tipc_nl_msg
*msg
,
1824 struct tipc_node
*node
, u32
*prev_link
)
1829 for (i
= *prev_link
; i
< MAX_BEARERS
; i
++) {
1832 if (!node
->links
[i
].link
)
1835 err
= __tipc_nl_add_link(net
, msg
,
1836 node
->links
[i
].link
, NLM_F_MULTI
);
1845 int tipc_nl_node_dump_link(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1847 struct net
*net
= sock_net(skb
->sk
);
1848 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
1849 struct tipc_node
*node
;
1850 struct tipc_nl_msg msg
;
1851 u32 prev_node
= cb
->args
[0];
1852 u32 prev_link
= cb
->args
[1];
1853 int done
= cb
->args
[2];
1860 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
1861 msg
.seq
= cb
->nlh
->nlmsg_seq
;
1865 node
= tipc_node_find(net
, prev_node
);
1867 /* We never set seq or call nl_dump_check_consistent()
1868 * this means that setting prev_seq here will cause the
1869 * consistence check to fail in the netlink callback
1870 * handler. Resulting in the last NLMSG_DONE message
1871 * having the NLM_F_DUMP_INTR flag set.
1876 tipc_node_put(node
);
1878 list_for_each_entry_continue_rcu(node
, &tn
->node_list
,
1880 tipc_node_read_lock(node
);
1881 err
= __tipc_nl_add_node_links(net
, &msg
, node
,
1883 tipc_node_read_unlock(node
);
1887 prev_node
= node
->addr
;
1890 err
= tipc_nl_add_bc_link(net
, &msg
);
1894 list_for_each_entry_rcu(node
, &tn
->node_list
, list
) {
1895 tipc_node_read_lock(node
);
1896 err
= __tipc_nl_add_node_links(net
, &msg
, node
,
1898 tipc_node_read_unlock(node
);
1902 prev_node
= node
->addr
;
1909 cb
->args
[0] = prev_node
;
1910 cb
->args
[1] = prev_link
;