blob: 8d353ec77a6661820066e4cbee0d74cfe534ea08 [file] [log] [blame]
Per Lidenb97bf3f2006-01-02 19:04:38 +01001/*
2 * net/tipc/node.c: TIPC node management routines
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003 *
Jon Paul Maloy16e166b2014-06-25 20:41:33 -05004 * Copyright (c) 2000-2006, 2012-2014, Ericsson AB
Ying Xue46651c52014-03-27 12:54:36 +08005 * Copyright (c) 2005-2006, 2010-2014, Wind River Systems
Per Lidenb97bf3f2006-01-02 19:04:38 +01006 * All rights reserved.
7 *
Per Liden9ea1fd32006-01-11 13:30:43 +01008 * Redistribution and use in source and binary forms, with or without
Per Lidenb97bf3f2006-01-02 19:04:38 +01009 * modification, are permitted provided that the following conditions are met:
10 *
Per Liden9ea1fd32006-01-11 13:30:43 +010011 * 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.
Per Lidenb97bf3f2006-01-02 19:04:38 +010019 *
Per Liden9ea1fd32006-01-11 13:30:43 +010020 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
Per Lidenb97bf3f2006-01-02 19:04:38 +010034 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37#include "core.h"
38#include "config.h"
39#include "node.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010040#include "name_distr.h"
Jon Paul Maloy50100a52014-08-22 18:09:07 -040041#include "socket.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010042
Allan Stephensa635b462011-11-04 11:54:43 -040043#define NODE_HTABLE_SIZE 512
44
David S. Miller6c000552008-09-02 23:38:32 -070045static void node_lost_contact(struct tipc_node *n_ptr);
46static void node_established_contact(struct tipc_node *n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +010047
Allan Stephens672d99e2011-02-25 18:42:52 -050048static struct hlist_head node_htable[NODE_HTABLE_SIZE];
49LIST_HEAD(tipc_node_list);
50static u32 tipc_num_nodes;
Ying Xuedde20262014-03-27 12:54:39 +080051static u32 tipc_num_links;
Ying Xue46651c52014-03-27 12:54:36 +080052static DEFINE_SPINLOCK(node_list_lock);
Allan Stephens34e46252011-02-25 19:11:25 -050053
Jon Paul Maloy02be61a2014-08-22 18:09:08 -040054struct tipc_sock_conn {
55 u32 port;
56 u32 peer_port;
57 u32 peer_node;
58 struct list_head list;
59};
60
Richard Alpe3e4b6ab2014-11-20 10:29:17 +010061static const struct nla_policy tipc_nl_node_policy[TIPC_NLA_NODE_MAX + 1] = {
62 [TIPC_NLA_NODE_UNSPEC] = { .type = NLA_UNSPEC },
63 [TIPC_NLA_NODE_ADDR] = { .type = NLA_U32 },
64 [TIPC_NLA_NODE_UP] = { .type = NLA_FLAG }
65};
66
Allan Stephens1ec2bb02011-10-27 15:03:24 -040067/*
Allan Stephensa635b462011-11-04 11:54:43 -040068 * A trivial power-of-two bitmask technique is used for speed, since this
69 * operation is done for every incoming TIPC packet. The number of hash table
70 * entries has been chosen so that no hash chain exceeds 8 nodes and will
71 * usually be much smaller (typically only a single node).
72 */
Paul Gortmaker872f24d2012-04-23 04:49:13 +000073static unsigned int tipc_hashfn(u32 addr)
Allan Stephensa635b462011-11-04 11:54:43 -040074{
75 return addr & (NODE_HTABLE_SIZE - 1);
76}
77
78/*
Allan Stephens672d99e2011-02-25 18:42:52 -050079 * tipc_node_find - locate specified node object, if it exists
80 */
Allan Stephens672d99e2011-02-25 18:42:52 -050081struct tipc_node *tipc_node_find(u32 addr)
82{
83 struct tipc_node *node;
Allan Stephens672d99e2011-02-25 18:42:52 -050084
Allan Stephens336ebf52012-04-17 18:02:01 -040085 if (unlikely(!in_own_cluster_exact(addr)))
Allan Stephens672d99e2011-02-25 18:42:52 -050086 return NULL;
87
Ying Xue6c7a7622014-03-27 12:54:37 +080088 rcu_read_lock();
89 hlist_for_each_entry_rcu(node, &node_htable[tipc_hashfn(addr)], hash) {
Ying Xue46651c52014-03-27 12:54:36 +080090 if (node->addr == addr) {
Ying Xue6c7a7622014-03-27 12:54:37 +080091 rcu_read_unlock();
Allan Stephens672d99e2011-02-25 18:42:52 -050092 return node;
Ying Xue46651c52014-03-27 12:54:36 +080093 }
Allan Stephens672d99e2011-02-25 18:42:52 -050094 }
Ying Xue6c7a7622014-03-27 12:54:37 +080095 rcu_read_unlock();
Allan Stephens672d99e2011-02-25 18:42:52 -050096 return NULL;
97}
98
David S. Miller6c000552008-09-02 23:38:32 -070099struct tipc_node *tipc_node_create(u32 addr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100100{
Allan Stephens672d99e2011-02-25 18:42:52 -0500101 struct tipc_node *n_ptr, *temp_node;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100102
Ying Xue46651c52014-03-27 12:54:36 +0800103 spin_lock_bh(&node_list_lock);
Allan Stephens2ecb0922008-05-21 14:53:00 -0700104
Allan Stephens5af54792010-12-31 18:59:23 +0000105 n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
Allan Stephensa10bd922006-06-25 23:52:17 -0700106 if (!n_ptr) {
Ying Xue46651c52014-03-27 12:54:36 +0800107 spin_unlock_bh(&node_list_lock);
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400108 pr_warn("Node creation failed, no memory\n");
Allan Stephensa10bd922006-06-25 23:52:17 -0700109 return NULL;
110 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100111
Allan Stephensa10bd922006-06-25 23:52:17 -0700112 n_ptr->addr = addr;
Allan Stephens51a8e4d2010-12-31 18:59:18 +0000113 spin_lock_init(&n_ptr->lock);
Allan Stephens672d99e2011-02-25 18:42:52 -0500114 INIT_HLIST_NODE(&n_ptr->hash);
115 INIT_LIST_HEAD(&n_ptr->list);
Ying Xuea8f48af2014-11-26 11:41:45 +0800116 INIT_LIST_HEAD(&n_ptr->publ_list);
Jon Paul Maloy02be61a2014-08-22 18:09:08 -0400117 INIT_LIST_HEAD(&n_ptr->conn_sks);
Richard Alpe340b6e52014-12-10 09:46:54 +0100118 skb_queue_head_init(&n_ptr->waiting_sks);
Ying Xuebc6fecd2014-11-26 11:41:53 +0800119 __skb_queue_head_init(&n_ptr->bclink.deferred_queue);
Allan Stephens8f92df62010-12-31 18:59:19 +0000120
Ying Xue6c7a7622014-03-27 12:54:37 +0800121 hlist_add_head_rcu(&n_ptr->hash, &node_htable[tipc_hashfn(addr)]);
Allan Stephens672d99e2011-02-25 18:42:52 -0500122
Ying Xue6c7a7622014-03-27 12:54:37 +0800123 list_for_each_entry_rcu(temp_node, &tipc_node_list, list) {
Allan Stephens672d99e2011-02-25 18:42:52 -0500124 if (n_ptr->addr < temp_node->addr)
125 break;
126 }
Ying Xue6c7a7622014-03-27 12:54:37 +0800127 list_add_tail_rcu(&n_ptr->list, &temp_node->list);
Ying Xueaecb9bb2014-05-08 08:54:39 +0800128 n_ptr->action_flags = TIPC_WAIT_PEER_LINKS_DOWN;
Allan Stephensfc0eea62011-10-28 16:26:41 -0400129 n_ptr->signature = INVALID_NODE_SIG;
Allan Stephens672d99e2011-02-25 18:42:52 -0500130
131 tipc_num_nodes++;
Allan Stephensa10bd922006-06-25 23:52:17 -0700132
Ying Xue46651c52014-03-27 12:54:36 +0800133 spin_unlock_bh(&node_list_lock);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100134 return n_ptr;
135}
136
Ying Xue46651c52014-03-27 12:54:36 +0800137static void tipc_node_delete(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100138{
Ying Xue6c7a7622014-03-27 12:54:37 +0800139 list_del_rcu(&n_ptr->list);
140 hlist_del_rcu(&n_ptr->hash);
141 kfree_rcu(n_ptr, rcu);
Allan Stephens8f92df62010-12-31 18:59:19 +0000142
Allan Stephens672d99e2011-02-25 18:42:52 -0500143 tipc_num_nodes--;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100144}
145
Ying Xue46651c52014-03-27 12:54:36 +0800146void tipc_node_stop(void)
147{
148 struct tipc_node *node, *t_node;
149
150 spin_lock_bh(&node_list_lock);
151 list_for_each_entry_safe(node, t_node, &tipc_node_list, list)
152 tipc_node_delete(node);
153 spin_unlock_bh(&node_list_lock);
154}
155
Jon Paul Maloy02be61a2014-08-22 18:09:08 -0400156int tipc_node_add_conn(u32 dnode, u32 port, u32 peer_port)
157{
158 struct tipc_node *node;
159 struct tipc_sock_conn *conn;
160
161 if (in_own_node(dnode))
162 return 0;
163
164 node = tipc_node_find(dnode);
165 if (!node) {
166 pr_warn("Connecting sock to node 0x%x failed\n", dnode);
167 return -EHOSTUNREACH;
168 }
169 conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
170 if (!conn)
171 return -EHOSTUNREACH;
172 conn->peer_node = dnode;
173 conn->port = port;
174 conn->peer_port = peer_port;
175
176 tipc_node_lock(node);
177 list_add_tail(&conn->list, &node->conn_sks);
178 tipc_node_unlock(node);
179 return 0;
180}
181
182void tipc_node_remove_conn(u32 dnode, u32 port)
183{
184 struct tipc_node *node;
185 struct tipc_sock_conn *conn, *safe;
186
187 if (in_own_node(dnode))
188 return;
189
190 node = tipc_node_find(dnode);
191 if (!node)
192 return;
193
194 tipc_node_lock(node);
195 list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
196 if (port != conn->port)
197 continue;
198 list_del(&conn->list);
199 kfree(conn);
200 }
201 tipc_node_unlock(node);
202}
203
204void tipc_node_abort_sock_conns(struct list_head *conns)
205{
206 struct tipc_sock_conn *conn, *safe;
207 struct sk_buff *buf;
208
209 list_for_each_entry_safe(conn, safe, conns, list) {
210 buf = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
211 SHORT_H_SIZE, 0, tipc_own_addr,
212 conn->peer_node, conn->port,
213 conn->peer_port, TIPC_ERR_NO_NODE);
214 if (likely(buf))
215 tipc_sk_rcv(buf);
216 list_del(&conn->list);
217 kfree(conn);
218 }
219}
220
Per Lidenb97bf3f2006-01-02 19:04:38 +0100221/**
Per Liden4323add2006-01-18 00:38:21 +0100222 * tipc_node_link_up - handle addition of link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900223 *
Per Lidenb97bf3f2006-01-02 19:04:38 +0100224 * Link becomes active (alone or shared) or standby, depending on its priority.
225 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500226void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100227{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500228 struct tipc_link **active = &n_ptr->active_links[0];
Per Lidenb97bf3f2006-01-02 19:04:38 +0100229
Allan Stephens5392d642006-06-25 23:52:50 -0700230 n_ptr->working_links++;
Ying Xue7b8613e2014-10-20 14:44:25 +0800231 n_ptr->action_flags |= TIPC_NOTIFY_LINK_UP;
232 n_ptr->link_id = l_ptr->peer_bearer_id << 16 | l_ptr->bearer_id;
233
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400234 pr_info("Established link <%s> on network plane %c\n",
Ying Xue7a2f7d12014-04-21 10:55:46 +0800235 l_ptr->name, l_ptr->net_plane);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900236
Per Lidenb97bf3f2006-01-02 19:04:38 +0100237 if (!active[0]) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100238 active[0] = active[1] = l_ptr;
239 node_established_contact(n_ptr);
Jon Paul Maloy16e166b2014-06-25 20:41:33 -0500240 goto exit;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100241 }
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900242 if (l_ptr->priority < active[0]->priority) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400243 pr_info("New link <%s> becomes standby\n", l_ptr->name);
Jon Paul Maloy16e166b2014-06-25 20:41:33 -0500244 goto exit;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100245 }
Ying Xue247f0f32014-02-18 16:06:46 +0800246 tipc_link_dup_queue_xmit(active[0], l_ptr);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900247 if (l_ptr->priority == active[0]->priority) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100248 active[0] = l_ptr;
Jon Paul Maloy16e166b2014-06-25 20:41:33 -0500249 goto exit;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100250 }
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400251 pr_info("Old link <%s> becomes standby\n", active[0]->name);
Allan Stephensa10bd922006-06-25 23:52:17 -0700252 if (active[1] != active[0])
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400253 pr_info("Old link <%s> becomes standby\n", active[1]->name);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100254 active[0] = active[1] = l_ptr;
Jon Paul Maloy16e166b2014-06-25 20:41:33 -0500255exit:
256 /* Leave room for changeover header when returning 'mtu' to users: */
257 n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
258 n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100259}
260
261/**
262 * node_select_active_links - select active link
263 */
David S. Miller6c000552008-09-02 23:38:32 -0700264static void node_select_active_links(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100265{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500266 struct tipc_link **active = &n_ptr->active_links[0];
Per Lidenb97bf3f2006-01-02 19:04:38 +0100267 u32 i;
268 u32 highest_prio = 0;
269
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900270 active[0] = active[1] = NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100271
272 for (i = 0; i < MAX_BEARERS; i++) {
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500273 struct tipc_link *l_ptr = n_ptr->links[i];
Per Lidenb97bf3f2006-01-02 19:04:38 +0100274
Per Liden4323add2006-01-18 00:38:21 +0100275 if (!l_ptr || !tipc_link_is_up(l_ptr) ||
Per Lidenb97bf3f2006-01-02 19:04:38 +0100276 (l_ptr->priority < highest_prio))
277 continue;
278
279 if (l_ptr->priority > highest_prio) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900280 highest_prio = l_ptr->priority;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100281 active[0] = active[1] = l_ptr;
282 } else {
283 active[1] = l_ptr;
284 }
285 }
286}
287
288/**
Per Liden4323add2006-01-18 00:38:21 +0100289 * tipc_node_link_down - handle loss of link
Per Lidenb97bf3f2006-01-02 19:04:38 +0100290 */
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500291void tipc_node_link_down(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100292{
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500293 struct tipc_link **active;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100294
Allan Stephens5392d642006-06-25 23:52:50 -0700295 n_ptr->working_links--;
Ying Xue7b8613e2014-10-20 14:44:25 +0800296 n_ptr->action_flags |= TIPC_NOTIFY_LINK_DOWN;
297 n_ptr->link_id = l_ptr->peer_bearer_id << 16 | l_ptr->bearer_id;
Allan Stephens5392d642006-06-25 23:52:50 -0700298
Per Liden4323add2006-01-18 00:38:21 +0100299 if (!tipc_link_is_active(l_ptr)) {
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400300 pr_info("Lost standby link <%s> on network plane %c\n",
Ying Xue7a2f7d12014-04-21 10:55:46 +0800301 l_ptr->name, l_ptr->net_plane);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100302 return;
303 }
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400304 pr_info("Lost link <%s> on network plane %c\n",
Ying Xue7a2f7d12014-04-21 10:55:46 +0800305 l_ptr->name, l_ptr->net_plane);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100306
307 active = &n_ptr->active_links[0];
308 if (active[0] == l_ptr)
309 active[0] = active[1];
310 if (active[1] == l_ptr)
311 active[1] = active[0];
312 if (active[0] == l_ptr)
313 node_select_active_links(n_ptr);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900314 if (tipc_node_is_up(n_ptr))
Jon Paul Maloy170b3922014-01-07 17:02:41 -0500315 tipc_link_failover_send_queue(l_ptr);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900316 else
Per Lidenb97bf3f2006-01-02 19:04:38 +0100317 node_lost_contact(n_ptr);
Jon Paul Maloy16e166b2014-06-25 20:41:33 -0500318
319 /* Leave room for changeover header when returning 'mtu' to users: */
320 if (active[0]) {
321 n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
322 n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
323 return;
324 }
325
326 /* Loopback link went down? No fragmentation needed from now on. */
327 if (n_ptr->addr == tipc_own_addr) {
328 n_ptr->act_mtus[0] = MAX_MSG_SIZE;
329 n_ptr->act_mtus[1] = MAX_MSG_SIZE;
330 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100331}
332
Paul Gortmaker8f19afb2011-02-28 11:36:21 -0400333int tipc_node_active_links(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100334{
Allan Stephens76ae0d72010-08-17 11:00:12 +0000335 return n_ptr->active_links[0] != NULL;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100336}
337
David S. Miller6c000552008-09-02 23:38:32 -0700338int tipc_node_is_up(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100339{
Paul Gortmaker8f19afb2011-02-28 11:36:21 -0400340 return tipc_node_active_links(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100341}
342
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500343void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100344{
Ying Xue7a2f7d12014-04-21 10:55:46 +0800345 n_ptr->links[l_ptr->bearer_id] = l_ptr;
Ying Xuedde20262014-03-27 12:54:39 +0800346 spin_lock_bh(&node_list_lock);
347 tipc_num_links++;
348 spin_unlock_bh(&node_list_lock);
Allan Stephens37b9c082011-02-28 11:32:27 -0500349 n_ptr->link_cnt++;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100350}
351
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500352void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100353{
Jon Paul Maloy7d339392014-02-13 17:29:16 -0500354 int i;
355
356 for (i = 0; i < MAX_BEARERS; i++) {
Jon Paul Maloy074bb432014-02-14 16:40:43 -0500357 if (l_ptr != n_ptr->links[i])
358 continue;
359 n_ptr->links[i] = NULL;
Ying Xuedde20262014-03-27 12:54:39 +0800360 spin_lock_bh(&node_list_lock);
361 tipc_num_links--;
362 spin_unlock_bh(&node_list_lock);
Jon Paul Maloy074bb432014-02-14 16:40:43 -0500363 n_ptr->link_cnt--;
Jon Paul Maloy7d339392014-02-13 17:29:16 -0500364 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100365}
366
David S. Miller6c000552008-09-02 23:38:32 -0700367static void node_established_contact(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100368{
Ying Xueaecb9bb2014-05-08 08:54:39 +0800369 n_ptr->action_flags |= TIPC_NOTIFY_NODE_UP;
Jon Maloyc64f7a62012-11-16 13:51:31 +0800370 n_ptr->bclink.oos_state = 0;
Ying Xue818f4da2012-11-16 13:51:29 +0800371 n_ptr->bclink.acked = tipc_bclink_get_last_sent();
372 tipc_bclink_add_node(n_ptr->addr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100373}
374
David S. Miller6c000552008-09-02 23:38:32 -0700375static void node_lost_contact(struct tipc_node *n_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100376{
Per Lidenb97bf3f2006-01-02 19:04:38 +0100377 char addr_string[16];
378 u32 i;
379
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400380 pr_info("Lost contact with %s\n",
381 tipc_addr_string_fill(addr_string, n_ptr->addr));
Allan Stephensc5bd4d82011-04-07 11:58:08 -0400382
383 /* Flush broadcast link info associated with lost node */
Ying Xue389dd9b2012-11-16 13:51:30 +0800384 if (n_ptr->bclink.recv_permitted) {
Ying Xuebc6fecd2014-11-26 11:41:53 +0800385 __skb_queue_purge(&n_ptr->bclink.deferred_queue);
Allan Stephensc5bd4d82011-04-07 11:58:08 -0400386
Jon Paul Maloy37e22162014-05-14 05:39:12 -0400387 if (n_ptr->bclink.reasm_buf) {
388 kfree_skb(n_ptr->bclink.reasm_buf);
389 n_ptr->bclink.reasm_buf = NULL;
Allan Stephensc5bd4d82011-04-07 11:58:08 -0400390 }
391
Allan Stephenscd3decd2011-10-24 11:18:12 -0400392 tipc_bclink_remove_node(n_ptr->addr);
Allan Stephens365595912011-10-24 15:26:24 -0400393 tipc_bclink_acknowledge(n_ptr, INVALID_LINK_SEQ);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100394
Ying Xue389dd9b2012-11-16 13:51:30 +0800395 n_ptr->bclink.recv_permitted = false;
Allan Stephensc5bd4d82011-04-07 11:58:08 -0400396 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100397
398 /* Abort link changeover */
399 for (i = 0; i < MAX_BEARERS; i++) {
Paul Gortmakera18c4bc2011-12-29 20:58:42 -0500400 struct tipc_link *l_ptr = n_ptr->links[i];
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900401 if (!l_ptr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100402 continue;
403 l_ptr->reset_checkpoint = l_ptr->next_in_no;
404 l_ptr->exp_msg_count = 0;
Per Liden4323add2006-01-18 00:38:21 +0100405 tipc_link_reset_fragments(l_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100406 }
407
Ying Xueca9cf062014-05-08 08:54:40 +0800408 n_ptr->action_flags &= ~TIPC_WAIT_OWN_LINKS_DOWN;
409
Ying Xue9d561942014-05-05 08:56:13 +0800410 /* Notify subscribers and prevent re-contact with node until
411 * cleanup is done.
412 */
Ying Xueca9cf062014-05-08 08:54:40 +0800413 n_ptr->action_flags |= TIPC_WAIT_PEER_LINKS_DOWN |
414 TIPC_NOTIFY_NODE_DOWN;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100415}
416
Per Liden4323add2006-01-18 00:38:21 +0100417struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100418{
419 u32 domain;
420 struct sk_buff *buf;
David S. Miller6c000552008-09-02 23:38:32 -0700421 struct tipc_node *n_ptr;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900422 struct tipc_node_info node_info;
Allan Stephensea138472006-06-29 12:33:20 -0700423 u32 payload_size;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100424
425 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
Per Liden4323add2006-01-18 00:38:21 +0100426 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100427
Al Viro3e6c8cd2006-11-08 00:19:09 -0800428 domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
Per Liden4323add2006-01-18 00:38:21 +0100429 if (!tipc_addr_domain_valid(domain))
430 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
431 " (network address)");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100432
Ying Xue46651c52014-03-27 12:54:36 +0800433 spin_lock_bh(&node_list_lock);
Allan Stephens672d99e2011-02-25 18:42:52 -0500434 if (!tipc_num_nodes) {
Ying Xue46651c52014-03-27 12:54:36 +0800435 spin_unlock_bh(&node_list_lock);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900436 return tipc_cfg_reply_none();
Allan Stephens1aad72d2008-07-14 22:44:58 -0700437 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100438
Allan Stephens08c80e92010-12-31 18:59:17 +0000439 /* For now, get space for all other nodes */
Allan Stephens672d99e2011-02-25 18:42:52 -0500440 payload_size = TLV_SPACE(sizeof(node_info)) * tipc_num_nodes;
Allan Stephens1aad72d2008-07-14 22:44:58 -0700441 if (payload_size > 32768u) {
Ying Xue46651c52014-03-27 12:54:36 +0800442 spin_unlock_bh(&node_list_lock);
Allan Stephensea138472006-06-29 12:33:20 -0700443 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
444 " (too many nodes)");
Allan Stephens1aad72d2008-07-14 22:44:58 -0700445 }
Ying Xue22206462014-03-27 12:54:38 +0800446 spin_unlock_bh(&node_list_lock);
447
Allan Stephensea138472006-06-29 12:33:20 -0700448 buf = tipc_cfg_reply_alloc(payload_size);
Ying Xue22206462014-03-27 12:54:38 +0800449 if (!buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100450 return NULL;
451
452 /* Add TLVs for all nodes in scope */
Ying Xue6c7a7622014-03-27 12:54:37 +0800453 rcu_read_lock();
454 list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) {
Allan Stephens672d99e2011-02-25 18:42:52 -0500455 if (!tipc_in_scope(domain, n_ptr->addr))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100456 continue;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900457 node_info.addr = htonl(n_ptr->addr);
458 node_info.up = htonl(tipc_node_is_up(n_ptr));
459 tipc_cfg_append_tlv(buf, TIPC_TLV_NODE_INFO,
Per Liden4323add2006-01-18 00:38:21 +0100460 &node_info, sizeof(node_info));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100461 }
Ying Xue6c7a7622014-03-27 12:54:37 +0800462 rcu_read_unlock();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100463 return buf;
464}
465
Per Liden4323add2006-01-18 00:38:21 +0100466struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100467{
468 u32 domain;
469 struct sk_buff *buf;
David S. Miller6c000552008-09-02 23:38:32 -0700470 struct tipc_node *n_ptr;
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900471 struct tipc_link_info link_info;
Allan Stephensea138472006-06-29 12:33:20 -0700472 u32 payload_size;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100473
474 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
Per Liden4323add2006-01-18 00:38:21 +0100475 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100476
Al Viro3e6c8cd2006-11-08 00:19:09 -0800477 domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
Per Liden4323add2006-01-18 00:38:21 +0100478 if (!tipc_addr_domain_valid(domain))
479 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
480 " (network address)");
Per Lidenb97bf3f2006-01-02 19:04:38 +0100481
Allan Stephensb58343f2011-11-08 13:48:28 -0500482 if (!tipc_own_addr)
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900483 return tipc_cfg_reply_none();
484
Ying Xue46651c52014-03-27 12:54:36 +0800485 spin_lock_bh(&node_list_lock);
Allan Stephens7a54d4a2011-10-27 14:17:53 -0400486 /* Get space for all unicast links + broadcast link */
Ying Xuedde20262014-03-27 12:54:39 +0800487 payload_size = TLV_SPACE((sizeof(link_info)) * (tipc_num_links + 1));
Allan Stephens1aad72d2008-07-14 22:44:58 -0700488 if (payload_size > 32768u) {
Ying Xue46651c52014-03-27 12:54:36 +0800489 spin_unlock_bh(&node_list_lock);
Allan Stephensea138472006-06-29 12:33:20 -0700490 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
491 " (too many links)");
Allan Stephens1aad72d2008-07-14 22:44:58 -0700492 }
Ying Xuedde20262014-03-27 12:54:39 +0800493 spin_unlock_bh(&node_list_lock);
494
Allan Stephensea138472006-06-29 12:33:20 -0700495 buf = tipc_cfg_reply_alloc(payload_size);
Ying Xuedde20262014-03-27 12:54:39 +0800496 if (!buf)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100497 return NULL;
498
499 /* Add TLV for broadcast link */
Allan Stephensa3796f82011-02-23 11:44:49 -0500500 link_info.dest = htonl(tipc_cluster_mask(tipc_own_addr));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900501 link_info.up = htonl(1);
Stephen Hemminger4b704d52009-03-18 19:11:29 -0700502 strlcpy(link_info.str, tipc_bclink_name, TIPC_MAX_LINK_NAME);
Per Liden4323add2006-01-18 00:38:21 +0100503 tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info));
Per Lidenb97bf3f2006-01-02 19:04:38 +0100504
505 /* Add TLVs for any other links in scope */
Ying Xue6c7a7622014-03-27 12:54:37 +0800506 rcu_read_lock();
507 list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) {
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900508 u32 i;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100509
Allan Stephens672d99e2011-02-25 18:42:52 -0500510 if (!tipc_in_scope(domain, n_ptr->addr))
Per Lidenb97bf3f2006-01-02 19:04:38 +0100511 continue;
Allan Stephens1aad72d2008-07-14 22:44:58 -0700512 tipc_node_lock(n_ptr);
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900513 for (i = 0; i < MAX_BEARERS; i++) {
514 if (!n_ptr->links[i])
515 continue;
516 link_info.dest = htonl(n_ptr->addr);
517 link_info.up = htonl(tipc_link_is_up(n_ptr->links[i]));
518 strcpy(link_info.str, n_ptr->links[i]->name);
519 tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO,
Per Liden4323add2006-01-18 00:38:21 +0100520 &link_info, sizeof(link_info));
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900521 }
Allan Stephens1aad72d2008-07-14 22:44:58 -0700522 tipc_node_unlock(n_ptr);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100523 }
Ying Xue6c7a7622014-03-27 12:54:37 +0800524 rcu_read_unlock();
Per Lidenb97bf3f2006-01-02 19:04:38 +0100525 return buf;
526}
Erik Hugne78acb1f2014-04-24 16:26:47 +0200527
528/**
529 * tipc_node_get_linkname - get the name of a link
530 *
531 * @bearer_id: id of the bearer
532 * @node: peer node address
533 * @linkname: link name output buffer
534 *
535 * Returns 0 on success
536 */
537int tipc_node_get_linkname(u32 bearer_id, u32 addr, char *linkname, size_t len)
538{
539 struct tipc_link *link;
540 struct tipc_node *node = tipc_node_find(addr);
541
Erik Hugned7bb74c2014-04-28 08:20:09 +0200542 if ((bearer_id >= MAX_BEARERS) || !node)
Erik Hugne78acb1f2014-04-24 16:26:47 +0200543 return -EINVAL;
544 tipc_node_lock(node);
545 link = node->links[bearer_id];
546 if (link) {
547 strncpy(linkname, link->name, len);
548 tipc_node_unlock(node);
549 return 0;
550 }
551 tipc_node_unlock(node);
552 return -EINVAL;
553}
Ying Xue9db9fdd2014-05-05 08:56:12 +0800554
555void tipc_node_unlock(struct tipc_node *node)
556{
557 LIST_HEAD(nsub_list);
Jon Paul Maloy02be61a2014-08-22 18:09:08 -0400558 LIST_HEAD(conn_sks);
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400559 struct sk_buff_head waiting_sks;
Ying Xueca0c4272014-05-05 08:56:14 +0800560 u32 addr = 0;
Ying Xue7b8613e2014-10-20 14:44:25 +0800561 int flags = node->action_flags;
562 u32 link_id = 0;
Ying Xue9db9fdd2014-05-05 08:56:12 +0800563
Ying Xue7b8613e2014-10-20 14:44:25 +0800564 if (likely(!flags)) {
Ying Xue9db9fdd2014-05-05 08:56:12 +0800565 spin_unlock_bh(&node->lock);
566 return;
567 }
568
Ying Xue7b8613e2014-10-20 14:44:25 +0800569 addr = node->addr;
570 link_id = node->link_id;
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400571 __skb_queue_head_init(&waiting_sks);
Ying Xue7b8613e2014-10-20 14:44:25 +0800572
573 if (flags & TIPC_WAKEUP_USERS)
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400574 skb_queue_splice_init(&node->waiting_sks, &waiting_sks);
Ying Xue7b8613e2014-10-20 14:44:25 +0800575
576 if (flags & TIPC_NOTIFY_NODE_DOWN) {
Ying Xuea8f48af2014-11-26 11:41:45 +0800577 list_replace_init(&node->publ_list, &nsub_list);
Jon Paul Maloy02be61a2014-08-22 18:09:08 -0400578 list_replace_init(&node->conn_sks, &conn_sks);
Ying Xue9db9fdd2014-05-05 08:56:12 +0800579 }
Ying Xue7b8613e2014-10-20 14:44:25 +0800580 node->action_flags &= ~(TIPC_WAKEUP_USERS | TIPC_NOTIFY_NODE_DOWN |
581 TIPC_NOTIFY_NODE_UP | TIPC_NOTIFY_LINK_UP |
582 TIPC_NOTIFY_LINK_DOWN |
583 TIPC_WAKEUP_BCAST_USERS);
584
Ying Xue9db9fdd2014-05-05 08:56:12 +0800585 spin_unlock_bh(&node->lock);
586
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400587 while (!skb_queue_empty(&waiting_sks))
588 tipc_sk_rcv(__skb_dequeue(&waiting_sks));
589
Jon Paul Maloy02be61a2014-08-22 18:09:08 -0400590 if (!list_empty(&conn_sks))
591 tipc_node_abort_sock_conns(&conn_sks);
592
Ying Xue9db9fdd2014-05-05 08:56:12 +0800593 if (!list_empty(&nsub_list))
Ying Xuea8f48af2014-11-26 11:41:45 +0800594 tipc_publ_notify(&nsub_list, addr);
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400595
Jon Maloy908344c2014-10-07 14:12:34 -0400596 if (flags & TIPC_WAKEUP_BCAST_USERS)
597 tipc_bclink_wakeup_users();
598
Ying Xue7b8613e2014-10-20 14:44:25 +0800599 if (flags & TIPC_NOTIFY_NODE_UP)
Jon Paul Maloydbdf6d22014-07-16 20:40:58 -0400600 tipc_named_node_up(addr);
Ying Xue7b8613e2014-10-20 14:44:25 +0800601
602 if (flags & TIPC_NOTIFY_LINK_UP)
603 tipc_nametbl_publish(TIPC_LINK_STATE, addr, addr,
604 TIPC_NODE_SCOPE, link_id, addr);
605
606 if (flags & TIPC_NOTIFY_LINK_DOWN)
607 tipc_nametbl_withdraw(TIPC_LINK_STATE, addr,
608 link_id, addr);
Ying Xue9db9fdd2014-05-05 08:56:12 +0800609}
Richard Alpe3e4b6ab2014-11-20 10:29:17 +0100610
611/* Caller should hold node lock for the passed node */
Richard Alped8182802014-11-24 11:10:29 +0100612static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
Richard Alpe3e4b6ab2014-11-20 10:29:17 +0100613{
614 void *hdr;
615 struct nlattr *attrs;
616
617 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_v2_family,
618 NLM_F_MULTI, TIPC_NL_NODE_GET);
619 if (!hdr)
620 return -EMSGSIZE;
621
622 attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE);
623 if (!attrs)
624 goto msg_full;
625
626 if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
627 goto attr_msg_full;
628 if (tipc_node_is_up(node))
629 if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP))
630 goto attr_msg_full;
631
632 nla_nest_end(msg->skb, attrs);
633 genlmsg_end(msg->skb, hdr);
634
635 return 0;
636
637attr_msg_full:
638 nla_nest_cancel(msg->skb, attrs);
639msg_full:
640 genlmsg_cancel(msg->skb, hdr);
641
642 return -EMSGSIZE;
643}
644
645int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
646{
647 int err;
648 int done = cb->args[0];
649 int last_addr = cb->args[1];
650 struct tipc_node *node;
651 struct tipc_nl_msg msg;
652
653 if (done)
654 return 0;
655
656 msg.skb = skb;
657 msg.portid = NETLINK_CB(cb->skb).portid;
658 msg.seq = cb->nlh->nlmsg_seq;
659
660 rcu_read_lock();
661
662 if (last_addr && !tipc_node_find(last_addr)) {
663 rcu_read_unlock();
664 /* We never set seq or call nl_dump_check_consistent() this
665 * means that setting prev_seq here will cause the consistence
666 * check to fail in the netlink callback handler. Resulting in
667 * the NLMSG_DONE message having the NLM_F_DUMP_INTR flag set if
668 * the node state changed while we released the lock.
669 */
670 cb->prev_seq = 1;
671 return -EPIPE;
672 }
673
674 list_for_each_entry_rcu(node, &tipc_node_list, list) {
675 if (last_addr) {
676 if (node->addr == last_addr)
677 last_addr = 0;
678 else
679 continue;
680 }
681
682 tipc_node_lock(node);
683 err = __tipc_nl_add_node(&msg, node);
684 if (err) {
685 last_addr = node->addr;
686 tipc_node_unlock(node);
687 goto out;
688 }
689
690 tipc_node_unlock(node);
691 }
692 done = 1;
693out:
694 cb->args[0] = done;
695 cb->args[1] = last_addr;
696 rcu_read_unlock();
697
698 return skb->len;
699}