2 * net/tipc/node.c: TIPC node management routines
4 * Copyright (c) 2000-2006, 2012-2014, 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"
43 static void node_lost_contact(struct tipc_node *n_ptr);
44 static void node_established_contact(struct tipc_node *n_ptr);
46 struct tipc_sock_conn {
50 struct list_head list;
53 static const struct nla_policy tipc_nl_node_policy[TIPC_NLA_NODE_MAX + 1] = {
54 [TIPC_NLA_NODE_UNSPEC] = { .type = NLA_UNSPEC },
55 [TIPC_NLA_NODE_ADDR] = { .type = NLA_U32 },
56 [TIPC_NLA_NODE_UP] = { .type = NLA_FLAG }
60 * A trivial power-of-two bitmask technique is used for speed, since this
61 * operation is done for every incoming TIPC packet. The number of hash table
62 * entries has been chosen so that no hash chain exceeds 8 nodes and will
63 * usually be much smaller (typically only a single node).
65 static unsigned int tipc_hashfn(u32 addr)
67 return addr & (NODE_HTABLE_SIZE - 1);
71 * tipc_node_find - locate specified node object, if it exists
73 struct tipc_node *tipc_node_find(struct net *net, u32 addr)
75 struct tipc_net *tn = net_generic(net, tipc_net_id);
76 struct tipc_node *node;
78 if (unlikely(!in_own_cluster_exact(net, addr)))
82 hlist_for_each_entry_rcu(node, &tn->node_htable[tipc_hashfn(addr)],
84 if (node->addr == addr) {
93 struct tipc_node *tipc_node_create(struct net *net, u32 addr)
95 struct tipc_net *tn = net_generic(net, tipc_net_id);
96 struct tipc_node *n_ptr, *temp_node;
98 spin_lock_bh(&tn->node_list_lock);
99 n_ptr = tipc_node_find(net, addr);
102 n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
104 pr_warn("Node creation failed, no memory\n");
109 spin_lock_init(&n_ptr->lock);
110 INIT_HLIST_NODE(&n_ptr->hash);
111 INIT_LIST_HEAD(&n_ptr->list);
112 INIT_LIST_HEAD(&n_ptr->publ_list);
113 INIT_LIST_HEAD(&n_ptr->conn_sks);
114 skb_queue_head_init(&n_ptr->waiting_sks);
115 __skb_queue_head_init(&n_ptr->bclink.deferred_queue);
117 hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]);
119 list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
120 if (n_ptr->addr < temp_node->addr)
123 list_add_tail_rcu(&n_ptr->list, &temp_node->list);
124 n_ptr->action_flags = TIPC_WAIT_PEER_LINKS_DOWN;
125 n_ptr->signature = INVALID_NODE_SIG;
128 spin_unlock_bh(&tn->node_list_lock);
132 static void tipc_node_delete(struct tipc_net *tn, struct tipc_node *n_ptr)
134 list_del_rcu(&n_ptr->list);
135 hlist_del_rcu(&n_ptr->hash);
136 kfree_rcu(n_ptr, rcu);
141 void tipc_node_stop(struct net *net)
143 struct tipc_net *tn = net_generic(net, tipc_net_id);
144 struct tipc_node *node, *t_node;
146 spin_lock_bh(&tn->node_list_lock);
147 list_for_each_entry_safe(node, t_node, &tn->node_list, list)
148 tipc_node_delete(tn, node);
149 spin_unlock_bh(&tn->node_list_lock);
152 int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
154 struct tipc_node *node;
155 struct tipc_sock_conn *conn;
157 if (in_own_node(net, dnode))
160 node = tipc_node_find(net, dnode);
162 pr_warn("Connecting sock to node 0x%x failed\n", dnode);
163 return -EHOSTUNREACH;
165 conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
167 return -EHOSTUNREACH;
168 conn->peer_node = dnode;
170 conn->peer_port = peer_port;
172 tipc_node_lock(node);
173 list_add_tail(&conn->list, &node->conn_sks);
174 tipc_node_unlock(node);
178 void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
180 struct tipc_node *node;
181 struct tipc_sock_conn *conn, *safe;
183 if (in_own_node(net, dnode))
186 node = tipc_node_find(net, dnode);
190 tipc_node_lock(node);
191 list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
192 if (port != conn->port)
194 list_del(&conn->list);
197 tipc_node_unlock(node);
200 void tipc_node_abort_sock_conns(struct net *net, struct list_head *conns)
202 struct tipc_net *tn = net_generic(net, tipc_net_id);
203 struct tipc_sock_conn *conn, *safe;
206 list_for_each_entry_safe(conn, safe, conns, list) {
207 buf = tipc_msg_create(net, TIPC_CRITICAL_IMPORTANCE,
208 TIPC_CONN_MSG, SHORT_H_SIZE, 0,
209 tn->own_addr, conn->peer_node,
210 conn->port, conn->peer_port,
213 tipc_sk_rcv(net, buf);
214 list_del(&conn->list);
220 * tipc_node_link_up - handle addition of link
222 * Link becomes active (alone or shared) or standby, depending on its priority.
224 void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
226 struct tipc_link **active = &n_ptr->active_links[0];
228 n_ptr->working_links++;
229 n_ptr->action_flags |= TIPC_NOTIFY_LINK_UP;
230 n_ptr->link_id = l_ptr->peer_bearer_id << 16 | l_ptr->bearer_id;
232 pr_debug("Established link <%s> on network plane %c\n",
233 l_ptr->name, l_ptr->net_plane);
236 active[0] = active[1] = l_ptr;
237 node_established_contact(n_ptr);
240 if (l_ptr->priority < active[0]->priority) {
241 pr_debug("New link <%s> becomes standby\n", l_ptr->name);
244 tipc_link_dup_queue_xmit(active[0], l_ptr);
245 if (l_ptr->priority == active[0]->priority) {
249 pr_debug("Old link <%s> becomes standby\n", active[0]->name);
250 if (active[1] != active[0])
251 pr_debug("Old link <%s> becomes standby\n", active[1]->name);
252 active[0] = active[1] = l_ptr;
254 /* Leave room for changeover header when returning 'mtu' to users: */
255 n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
256 n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
260 * node_select_active_links - select active link
262 static void node_select_active_links(struct tipc_node *n_ptr)
264 struct tipc_link **active = &n_ptr->active_links[0];
266 u32 highest_prio = 0;
268 active[0] = active[1] = NULL;
270 for (i = 0; i < MAX_BEARERS; i++) {
271 struct tipc_link *l_ptr = n_ptr->links[i];
273 if (!l_ptr || !tipc_link_is_up(l_ptr) ||
274 (l_ptr->priority < highest_prio))
277 if (l_ptr->priority > highest_prio) {
278 highest_prio = l_ptr->priority;
279 active[0] = active[1] = l_ptr;
287 * tipc_node_link_down - handle loss of link
289 void tipc_node_link_down(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
291 struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
292 struct tipc_link **active;
294 n_ptr->working_links--;
295 n_ptr->action_flags |= TIPC_NOTIFY_LINK_DOWN;
296 n_ptr->link_id = l_ptr->peer_bearer_id << 16 | l_ptr->bearer_id;
298 if (!tipc_link_is_active(l_ptr)) {
299 pr_debug("Lost standby link <%s> on network plane %c\n",
300 l_ptr->name, l_ptr->net_plane);
303 pr_debug("Lost link <%s> on network plane %c\n",
304 l_ptr->name, l_ptr->net_plane);
306 active = &n_ptr->active_links[0];
307 if (active[0] == l_ptr)
308 active[0] = active[1];
309 if (active[1] == l_ptr)
310 active[1] = active[0];
311 if (active[0] == l_ptr)
312 node_select_active_links(n_ptr);
313 if (tipc_node_is_up(n_ptr))
314 tipc_link_failover_send_queue(l_ptr);
316 node_lost_contact(n_ptr);
318 /* Leave room for changeover header when returning 'mtu' to users: */
320 n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
321 n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
325 /* Loopback link went down? No fragmentation needed from now on. */
326 if (n_ptr->addr == tn->own_addr) {
327 n_ptr->act_mtus[0] = MAX_MSG_SIZE;
328 n_ptr->act_mtus[1] = MAX_MSG_SIZE;
332 int tipc_node_active_links(struct tipc_node *n_ptr)
334 return n_ptr->active_links[0] != NULL;
337 int tipc_node_is_up(struct tipc_node *n_ptr)
339 return tipc_node_active_links(n_ptr);
342 void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
344 struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
346 n_ptr->links[l_ptr->bearer_id] = l_ptr;
347 spin_lock_bh(&tn->node_list_lock);
349 spin_unlock_bh(&tn->node_list_lock);
353 void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
355 struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
358 for (i = 0; i < MAX_BEARERS; i++) {
359 if (l_ptr != n_ptr->links[i])
361 n_ptr->links[i] = NULL;
362 spin_lock_bh(&tn->node_list_lock);
364 spin_unlock_bh(&tn->node_list_lock);
369 static void node_established_contact(struct tipc_node *n_ptr)
371 n_ptr->action_flags |= TIPC_NOTIFY_NODE_UP;
372 n_ptr->bclink.oos_state = 0;
373 n_ptr->bclink.acked = tipc_bclink_get_last_sent(n_ptr->net);
374 tipc_bclink_add_node(n_ptr->net, n_ptr->addr);
377 static void node_lost_contact(struct tipc_node *n_ptr)
379 char addr_string[16];
382 pr_debug("Lost contact with %s\n",
383 tipc_addr_string_fill(addr_string, n_ptr->addr));
385 /* Flush broadcast link info associated with lost node */
386 if (n_ptr->bclink.recv_permitted) {
387 __skb_queue_purge(&n_ptr->bclink.deferred_queue);
389 if (n_ptr->bclink.reasm_buf) {
390 kfree_skb(n_ptr->bclink.reasm_buf);
391 n_ptr->bclink.reasm_buf = NULL;
394 tipc_bclink_remove_node(n_ptr->net, n_ptr->addr);
395 tipc_bclink_acknowledge(n_ptr, INVALID_LINK_SEQ);
397 n_ptr->bclink.recv_permitted = false;
400 /* Abort link changeover */
401 for (i = 0; i < MAX_BEARERS; i++) {
402 struct tipc_link *l_ptr = n_ptr->links[i];
405 l_ptr->reset_checkpoint = l_ptr->next_in_no;
406 l_ptr->exp_msg_count = 0;
407 tipc_link_reset_fragments(l_ptr);
409 /* Link marked for deletion after failover? => do it now */
410 if (l_ptr->flags & LINK_STOPPED)
411 tipc_link_delete(l_ptr);
414 n_ptr->action_flags &= ~TIPC_WAIT_OWN_LINKS_DOWN;
416 /* Notify subscribers and prevent re-contact with node until
419 n_ptr->action_flags |= TIPC_WAIT_PEER_LINKS_DOWN |
420 TIPC_NOTIFY_NODE_DOWN;
423 struct sk_buff *tipc_node_get_nodes(struct net *net, const void *req_tlv_area,
426 struct tipc_net *tn = net_generic(net, tipc_net_id);
429 struct tipc_node *n_ptr;
430 struct tipc_node_info node_info;
433 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
434 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
436 domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
437 if (!tipc_addr_domain_valid(domain))
438 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
439 " (network address)");
441 spin_lock_bh(&tn->node_list_lock);
442 if (!tn->num_nodes) {
443 spin_unlock_bh(&tn->node_list_lock);
444 return tipc_cfg_reply_none();
447 /* For now, get space for all other nodes */
448 payload_size = TLV_SPACE(sizeof(node_info)) * tn->num_nodes;
449 if (payload_size > 32768u) {
450 spin_unlock_bh(&tn->node_list_lock);
451 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
452 " (too many nodes)");
454 spin_unlock_bh(&tn->node_list_lock);
456 buf = tipc_cfg_reply_alloc(payload_size);
460 /* Add TLVs for all nodes in scope */
462 list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
463 if (!tipc_in_scope(domain, n_ptr->addr))
465 node_info.addr = htonl(n_ptr->addr);
466 node_info.up = htonl(tipc_node_is_up(n_ptr));
467 tipc_cfg_append_tlv(buf, TIPC_TLV_NODE_INFO,
468 &node_info, sizeof(node_info));
474 struct sk_buff *tipc_node_get_links(struct net *net, const void *req_tlv_area,
477 struct tipc_net *tn = net_generic(net, tipc_net_id);
480 struct tipc_node *n_ptr;
481 struct tipc_link_info link_info;
484 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
485 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
487 domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
488 if (!tipc_addr_domain_valid(domain))
489 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
490 " (network address)");
493 return tipc_cfg_reply_none();
495 spin_lock_bh(&tn->node_list_lock);
496 /* Get space for all unicast links + broadcast link */
497 payload_size = TLV_SPACE((sizeof(link_info)) * (tn->num_links + 1));
498 if (payload_size > 32768u) {
499 spin_unlock_bh(&tn->node_list_lock);
500 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
501 " (too many links)");
503 spin_unlock_bh(&tn->node_list_lock);
505 buf = tipc_cfg_reply_alloc(payload_size);
509 /* Add TLV for broadcast link */
510 link_info.dest = htonl(tipc_cluster_mask(tn->own_addr));
511 link_info.up = htonl(1);
512 strlcpy(link_info.str, tipc_bclink_name, TIPC_MAX_LINK_NAME);
513 tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info));
515 /* Add TLVs for any other links in scope */
517 list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
520 if (!tipc_in_scope(domain, n_ptr->addr))
522 tipc_node_lock(n_ptr);
523 for (i = 0; i < MAX_BEARERS; i++) {
524 if (!n_ptr->links[i])
526 link_info.dest = htonl(n_ptr->addr);
527 link_info.up = htonl(tipc_link_is_up(n_ptr->links[i]));
528 strcpy(link_info.str, n_ptr->links[i]->name);
529 tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO,
530 &link_info, sizeof(link_info));
532 tipc_node_unlock(n_ptr);
539 * tipc_node_get_linkname - get the name of a link
541 * @bearer_id: id of the bearer
542 * @node: peer node address
543 * @linkname: link name output buffer
545 * Returns 0 on success
547 int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
548 char *linkname, size_t len)
550 struct tipc_link *link;
551 struct tipc_node *node = tipc_node_find(net, addr);
553 if ((bearer_id >= MAX_BEARERS) || !node)
555 tipc_node_lock(node);
556 link = node->links[bearer_id];
558 strncpy(linkname, link->name, len);
559 tipc_node_unlock(node);
562 tipc_node_unlock(node);
566 void tipc_node_unlock(struct tipc_node *node)
568 struct net *net = node->net;
569 LIST_HEAD(nsub_list);
571 struct sk_buff_head waiting_sks;
573 int flags = node->action_flags;
576 if (likely(!flags)) {
577 spin_unlock_bh(&node->lock);
582 link_id = node->link_id;
583 __skb_queue_head_init(&waiting_sks);
585 if (flags & TIPC_WAKEUP_USERS)
586 skb_queue_splice_init(&node->waiting_sks, &waiting_sks);
588 if (flags & TIPC_NOTIFY_NODE_DOWN) {
589 list_replace_init(&node->publ_list, &nsub_list);
590 list_replace_init(&node->conn_sks, &conn_sks);
592 node->action_flags &= ~(TIPC_WAKEUP_USERS | TIPC_NOTIFY_NODE_DOWN |
593 TIPC_NOTIFY_NODE_UP | TIPC_NOTIFY_LINK_UP |
594 TIPC_NOTIFY_LINK_DOWN |
595 TIPC_WAKEUP_BCAST_USERS);
597 spin_unlock_bh(&node->lock);
599 while (!skb_queue_empty(&waiting_sks))
600 tipc_sk_rcv(net, __skb_dequeue(&waiting_sks));
602 if (!list_empty(&conn_sks))
603 tipc_node_abort_sock_conns(net, &conn_sks);
605 if (!list_empty(&nsub_list))
606 tipc_publ_notify(net, &nsub_list, addr);
608 if (flags & TIPC_WAKEUP_BCAST_USERS)
609 tipc_bclink_wakeup_users(net);
611 if (flags & TIPC_NOTIFY_NODE_UP)
612 tipc_named_node_up(net, addr);
614 if (flags & TIPC_NOTIFY_LINK_UP)
615 tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
616 TIPC_NODE_SCOPE, link_id, addr);
618 if (flags & TIPC_NOTIFY_LINK_DOWN)
619 tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
623 /* Caller should hold node lock for the passed node */
624 static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
627 struct nlattr *attrs;
629 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_v2_family,
630 NLM_F_MULTI, TIPC_NL_NODE_GET);
634 attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE);
638 if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
640 if (tipc_node_is_up(node))
641 if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP))
644 nla_nest_end(msg->skb, attrs);
645 genlmsg_end(msg->skb, hdr);
650 nla_nest_cancel(msg->skb, attrs);
652 genlmsg_cancel(msg->skb, hdr);
657 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
660 struct net *net = sock_net(skb->sk);
661 struct tipc_net *tn = net_generic(net, tipc_net_id);
662 int done = cb->args[0];
663 int last_addr = cb->args[1];
664 struct tipc_node *node;
665 struct tipc_nl_msg msg;
671 msg.portid = NETLINK_CB(cb->skb).portid;
672 msg.seq = cb->nlh->nlmsg_seq;
676 if (last_addr && !tipc_node_find(net, last_addr)) {
678 /* We never set seq or call nl_dump_check_consistent() this
679 * means that setting prev_seq here will cause the consistence
680 * check to fail in the netlink callback handler. Resulting in
681 * the NLMSG_DONE message having the NLM_F_DUMP_INTR flag set if
682 * the node state changed while we released the lock.
688 list_for_each_entry_rcu(node, &tn->node_list, list) {
690 if (node->addr == last_addr)
696 tipc_node_lock(node);
697 err = __tipc_nl_add_node(&msg, node);
699 last_addr = node->addr;
700 tipc_node_unlock(node);
704 tipc_node_unlock(node);
709 cb->args[1] = last_addr;