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->bclink.deferred_queue);
115 hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]);
116 list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
117 if (n_ptr->addr < temp_node->addr)
120 list_add_tail_rcu(&n_ptr->list, &temp_node->list);
121 n_ptr->action_flags = TIPC_WAIT_PEER_LINKS_DOWN;
122 n_ptr->signature = INVALID_NODE_SIG;
125 spin_unlock_bh(&tn->node_list_lock);
129 static void tipc_node_delete(struct tipc_net *tn, struct tipc_node *n_ptr)
131 list_del_rcu(&n_ptr->list);
132 hlist_del_rcu(&n_ptr->hash);
133 kfree_rcu(n_ptr, rcu);
138 void tipc_node_stop(struct net *net)
140 struct tipc_net *tn = net_generic(net, tipc_net_id);
141 struct tipc_node *node, *t_node;
143 spin_lock_bh(&tn->node_list_lock);
144 list_for_each_entry_safe(node, t_node, &tn->node_list, list)
145 tipc_node_delete(tn, node);
146 spin_unlock_bh(&tn->node_list_lock);
149 int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
151 struct tipc_node *node;
152 struct tipc_sock_conn *conn;
154 if (in_own_node(net, dnode))
157 node = tipc_node_find(net, dnode);
159 pr_warn("Connecting sock to node 0x%x failed\n", dnode);
160 return -EHOSTUNREACH;
162 conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
164 return -EHOSTUNREACH;
165 conn->peer_node = dnode;
167 conn->peer_port = peer_port;
169 tipc_node_lock(node);
170 list_add_tail(&conn->list, &node->conn_sks);
171 tipc_node_unlock(node);
175 void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
177 struct tipc_node *node;
178 struct tipc_sock_conn *conn, *safe;
180 if (in_own_node(net, dnode))
183 node = tipc_node_find(net, dnode);
187 tipc_node_lock(node);
188 list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
189 if (port != conn->port)
191 list_del(&conn->list);
194 tipc_node_unlock(node);
198 * tipc_node_link_up - handle addition of link
200 * Link becomes active (alone or shared) or standby, depending on its priority.
202 void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
204 struct tipc_link **active = &n_ptr->active_links[0];
206 n_ptr->working_links++;
207 n_ptr->action_flags |= TIPC_NOTIFY_LINK_UP;
208 n_ptr->link_id = l_ptr->peer_bearer_id << 16 | l_ptr->bearer_id;
210 pr_debug("Established link <%s> on network plane %c\n",
211 l_ptr->name, l_ptr->net_plane);
214 active[0] = active[1] = l_ptr;
215 node_established_contact(n_ptr);
218 if (l_ptr->priority < active[0]->priority) {
219 pr_debug("New link <%s> becomes standby\n", l_ptr->name);
222 tipc_link_dup_queue_xmit(active[0], l_ptr);
223 if (l_ptr->priority == active[0]->priority) {
227 pr_debug("Old link <%s> becomes standby\n", active[0]->name);
228 if (active[1] != active[0])
229 pr_debug("Old link <%s> becomes standby\n", active[1]->name);
230 active[0] = active[1] = l_ptr;
232 /* Leave room for changeover header when returning 'mtu' to users: */
233 n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
234 n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
238 * node_select_active_links - select active link
240 static void node_select_active_links(struct tipc_node *n_ptr)
242 struct tipc_link **active = &n_ptr->active_links[0];
244 u32 highest_prio = 0;
246 active[0] = active[1] = NULL;
248 for (i = 0; i < MAX_BEARERS; i++) {
249 struct tipc_link *l_ptr = n_ptr->links[i];
251 if (!l_ptr || !tipc_link_is_up(l_ptr) ||
252 (l_ptr->priority < highest_prio))
255 if (l_ptr->priority > highest_prio) {
256 highest_prio = l_ptr->priority;
257 active[0] = active[1] = l_ptr;
265 * tipc_node_link_down - handle loss of link
267 void tipc_node_link_down(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
269 struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
270 struct tipc_link **active;
272 n_ptr->working_links--;
273 n_ptr->action_flags |= TIPC_NOTIFY_LINK_DOWN;
274 n_ptr->link_id = l_ptr->peer_bearer_id << 16 | l_ptr->bearer_id;
276 if (!tipc_link_is_active(l_ptr)) {
277 pr_debug("Lost standby link <%s> on network plane %c\n",
278 l_ptr->name, l_ptr->net_plane);
281 pr_debug("Lost link <%s> on network plane %c\n",
282 l_ptr->name, l_ptr->net_plane);
284 active = &n_ptr->active_links[0];
285 if (active[0] == l_ptr)
286 active[0] = active[1];
287 if (active[1] == l_ptr)
288 active[1] = active[0];
289 if (active[0] == l_ptr)
290 node_select_active_links(n_ptr);
291 if (tipc_node_is_up(n_ptr))
292 tipc_link_failover_send_queue(l_ptr);
294 node_lost_contact(n_ptr);
296 /* Leave room for changeover header when returning 'mtu' to users: */
298 n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
299 n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
303 /* Loopback link went down? No fragmentation needed from now on. */
304 if (n_ptr->addr == tn->own_addr) {
305 n_ptr->act_mtus[0] = MAX_MSG_SIZE;
306 n_ptr->act_mtus[1] = MAX_MSG_SIZE;
310 int tipc_node_active_links(struct tipc_node *n_ptr)
312 return n_ptr->active_links[0] != NULL;
315 int tipc_node_is_up(struct tipc_node *n_ptr)
317 return tipc_node_active_links(n_ptr);
320 void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
322 struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
324 n_ptr->links[l_ptr->bearer_id] = l_ptr;
325 spin_lock_bh(&tn->node_list_lock);
327 spin_unlock_bh(&tn->node_list_lock);
331 void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
333 struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
336 for (i = 0; i < MAX_BEARERS; i++) {
337 if (l_ptr != n_ptr->links[i])
339 n_ptr->links[i] = NULL;
340 spin_lock_bh(&tn->node_list_lock);
342 spin_unlock_bh(&tn->node_list_lock);
347 static void node_established_contact(struct tipc_node *n_ptr)
349 n_ptr->action_flags |= TIPC_NOTIFY_NODE_UP;
350 n_ptr->bclink.oos_state = 0;
351 n_ptr->bclink.acked = tipc_bclink_get_last_sent(n_ptr->net);
352 tipc_bclink_add_node(n_ptr->net, n_ptr->addr);
355 static void node_lost_contact(struct tipc_node *n_ptr)
357 char addr_string[16];
358 struct tipc_sock_conn *conn, *safe;
359 struct list_head *conns = &n_ptr->conn_sks;
361 struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
364 pr_debug("Lost contact with %s\n",
365 tipc_addr_string_fill(addr_string, n_ptr->addr));
367 /* Flush broadcast link info associated with lost node */
368 if (n_ptr->bclink.recv_permitted) {
369 __skb_queue_purge(&n_ptr->bclink.deferred_queue);
371 if (n_ptr->bclink.reasm_buf) {
372 kfree_skb(n_ptr->bclink.reasm_buf);
373 n_ptr->bclink.reasm_buf = NULL;
376 tipc_bclink_remove_node(n_ptr->net, n_ptr->addr);
377 tipc_bclink_acknowledge(n_ptr, INVALID_LINK_SEQ);
379 n_ptr->bclink.recv_permitted = false;
382 /* Abort link changeover */
383 for (i = 0; i < MAX_BEARERS; i++) {
384 struct tipc_link *l_ptr = n_ptr->links[i];
387 l_ptr->reset_checkpoint = l_ptr->next_in_no;
388 l_ptr->exp_msg_count = 0;
389 tipc_link_reset_fragments(l_ptr);
391 /* Link marked for deletion after failover? => do it now */
392 if (l_ptr->flags & LINK_STOPPED)
393 tipc_link_delete(l_ptr);
396 n_ptr->action_flags &= ~TIPC_WAIT_OWN_LINKS_DOWN;
398 /* Prevent re-contact with node until cleanup is done */
399 n_ptr->action_flags |= TIPC_WAIT_PEER_LINKS_DOWN;
401 /* Notify publications from this node */
402 n_ptr->action_flags |= TIPC_NOTIFY_NODE_DOWN;
404 /* Notify sockets connected to node */
405 list_for_each_entry_safe(conn, safe, conns, list) {
406 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
407 SHORT_H_SIZE, 0, tn->own_addr,
408 conn->peer_node, conn->port,
409 conn->peer_port, TIPC_ERR_NO_NODE);
411 skb_queue_tail(n_ptr->inputq, skb);
412 n_ptr->action_flags |= TIPC_MSG_EVT;
414 list_del(&conn->list);
419 struct sk_buff *tipc_node_get_nodes(struct net *net, const void *req_tlv_area,
422 struct tipc_net *tn = net_generic(net, tipc_net_id);
425 struct tipc_node *n_ptr;
426 struct tipc_node_info node_info;
429 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
430 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
432 domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
433 if (!tipc_addr_domain_valid(domain))
434 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
435 " (network address)");
437 spin_lock_bh(&tn->node_list_lock);
438 if (!tn->num_nodes) {
439 spin_unlock_bh(&tn->node_list_lock);
440 return tipc_cfg_reply_none();
443 /* For now, get space for all other nodes */
444 payload_size = TLV_SPACE(sizeof(node_info)) * tn->num_nodes;
445 if (payload_size > 32768u) {
446 spin_unlock_bh(&tn->node_list_lock);
447 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
448 " (too many nodes)");
450 spin_unlock_bh(&tn->node_list_lock);
452 buf = tipc_cfg_reply_alloc(payload_size);
456 /* Add TLVs for all nodes in scope */
458 list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
459 if (!tipc_in_scope(domain, n_ptr->addr))
461 node_info.addr = htonl(n_ptr->addr);
462 node_info.up = htonl(tipc_node_is_up(n_ptr));
463 tipc_cfg_append_tlv(buf, TIPC_TLV_NODE_INFO,
464 &node_info, sizeof(node_info));
470 struct sk_buff *tipc_node_get_links(struct net *net, const void *req_tlv_area,
473 struct tipc_net *tn = net_generic(net, tipc_net_id);
476 struct tipc_node *n_ptr;
477 struct tipc_link_info link_info;
480 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
481 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
483 domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
484 if (!tipc_addr_domain_valid(domain))
485 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
486 " (network address)");
489 return tipc_cfg_reply_none();
491 spin_lock_bh(&tn->node_list_lock);
492 /* Get space for all unicast links + broadcast link */
493 payload_size = TLV_SPACE((sizeof(link_info)) * (tn->num_links + 1));
494 if (payload_size > 32768u) {
495 spin_unlock_bh(&tn->node_list_lock);
496 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
497 " (too many links)");
499 spin_unlock_bh(&tn->node_list_lock);
501 buf = tipc_cfg_reply_alloc(payload_size);
505 /* Add TLV for broadcast link */
506 link_info.dest = htonl(tipc_cluster_mask(tn->own_addr));
507 link_info.up = htonl(1);
508 strlcpy(link_info.str, tipc_bclink_name, TIPC_MAX_LINK_NAME);
509 tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info));
511 /* Add TLVs for any other links in scope */
513 list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
516 if (!tipc_in_scope(domain, n_ptr->addr))
518 tipc_node_lock(n_ptr);
519 for (i = 0; i < MAX_BEARERS; i++) {
520 if (!n_ptr->links[i])
522 link_info.dest = htonl(n_ptr->addr);
523 link_info.up = htonl(tipc_link_is_up(n_ptr->links[i]));
524 strcpy(link_info.str, n_ptr->links[i]->name);
525 tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO,
526 &link_info, sizeof(link_info));
528 tipc_node_unlock(n_ptr);
535 * tipc_node_get_linkname - get the name of a link
537 * @bearer_id: id of the bearer
538 * @node: peer node address
539 * @linkname: link name output buffer
541 * Returns 0 on success
543 int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
544 char *linkname, size_t len)
546 struct tipc_link *link;
547 struct tipc_node *node = tipc_node_find(net, addr);
549 if ((bearer_id >= MAX_BEARERS) || !node)
551 tipc_node_lock(node);
552 link = node->links[bearer_id];
554 strncpy(linkname, link->name, len);
555 tipc_node_unlock(node);
558 tipc_node_unlock(node);
562 void tipc_node_unlock(struct tipc_node *node)
564 struct net *net = node->net;
566 u32 flags = node->action_flags;
568 struct list_head *publ_list;
569 struct sk_buff_head *inputq = node->inputq;
570 struct sk_buff_head *namedq;
572 if (likely(!flags || (flags == TIPC_MSG_EVT))) {
573 node->action_flags = 0;
574 spin_unlock_bh(&node->lock);
575 if (flags == TIPC_MSG_EVT)
576 tipc_sk_rcv(net, inputq);
581 link_id = node->link_id;
582 namedq = node->namedq;
583 publ_list = &node->publ_list;
585 node->action_flags &= ~(TIPC_MSG_EVT |
586 TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |
587 TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP |
588 TIPC_WAKEUP_BCAST_USERS | TIPC_BCAST_MSG_EVT |
591 spin_unlock_bh(&node->lock);
593 if (flags & TIPC_NOTIFY_NODE_DOWN)
594 tipc_publ_notify(net, publ_list, addr);
596 if (flags & TIPC_WAKEUP_BCAST_USERS)
597 tipc_bclink_wakeup_users(net);
599 if (flags & TIPC_NOTIFY_NODE_UP)
600 tipc_named_node_up(net, addr);
602 if (flags & TIPC_NOTIFY_LINK_UP)
603 tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
604 TIPC_NODE_SCOPE, link_id, addr);
606 if (flags & TIPC_NOTIFY_LINK_DOWN)
607 tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
610 if (flags & TIPC_MSG_EVT)
611 tipc_sk_rcv(net, inputq);
613 if (flags & TIPC_NAMED_MSG_EVT)
614 tipc_named_rcv(net, namedq);
616 if (flags & TIPC_BCAST_MSG_EVT)
617 tipc_bclink_input(net);
620 /* Caller should hold node lock for the passed node */
621 static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
624 struct nlattr *attrs;
626 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
627 NLM_F_MULTI, TIPC_NL_NODE_GET);
631 attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE);
635 if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
637 if (tipc_node_is_up(node))
638 if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP))
641 nla_nest_end(msg->skb, attrs);
642 genlmsg_end(msg->skb, hdr);
647 nla_nest_cancel(msg->skb, attrs);
649 genlmsg_cancel(msg->skb, hdr);
654 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
657 struct net *net = sock_net(skb->sk);
658 struct tipc_net *tn = net_generic(net, tipc_net_id);
659 int done = cb->args[0];
660 int last_addr = cb->args[1];
661 struct tipc_node *node;
662 struct tipc_nl_msg msg;
668 msg.portid = NETLINK_CB(cb->skb).portid;
669 msg.seq = cb->nlh->nlmsg_seq;
673 if (last_addr && !tipc_node_find(net, last_addr)) {
675 /* We never set seq or call nl_dump_check_consistent() this
676 * means that setting prev_seq here will cause the consistence
677 * check to fail in the netlink callback handler. Resulting in
678 * the NLMSG_DONE message having the NLM_F_DUMP_INTR flag set if
679 * the node state changed while we released the lock.
685 list_for_each_entry_rcu(node, &tn->node_list, list) {
687 if (node->addr == last_addr)
693 tipc_node_lock(node);
694 err = __tipc_nl_add_node(&msg, node);
696 last_addr = node->addr;
697 tipc_node_unlock(node);
701 tipc_node_unlock(node);
706 cb->args[1] = last_addr;