fb54719679a6b0bc4f49b00d5a1ee53cd9e7c641
[linux-3.10.git] / net / tipc / node.c
1 /*
2  * net/tipc/node.c: TIPC node management routines
3  *
4  * Copyright (c) 2000-2006, Ericsson AB
5  * Copyright (c) 2005-2006, Wind River Systems
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
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.
19  *
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.
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
34  * POSSIBILITY OF SUCH DAMAGE.
35  */
36
37 #include "core.h"
38 #include "config.h"
39 #include "node.h"
40 #include "port.h"
41 #include "name_distr.h"
42
43 static void node_lost_contact(struct tipc_node *n_ptr);
44 static void node_established_contact(struct tipc_node *n_ptr);
45
46 static DEFINE_SPINLOCK(node_create_lock);
47
48 u32 tipc_own_tag = 0;
49
50 /**
51  * tipc_node_create - create neighboring node
52  *
53  * Currently, this routine is called by neighbor discovery code, which holds
54  * net_lock for reading only.  We must take node_create_lock to ensure a node
55  * isn't created twice if two different bearers discover the node at the same
56  * time.  (It would be preferable to switch to holding net_lock in write mode,
57  * but this is a non-trivial change.)
58  */
59
60 struct tipc_node *tipc_node_create(u32 addr)
61 {
62         struct tipc_node *n_ptr;
63         u32 n_num;
64
65         spin_lock_bh(&node_create_lock);
66
67         n_ptr = tipc_node_find(addr);
68         if (n_ptr) {
69                 spin_unlock_bh(&node_create_lock);
70                 return n_ptr;
71         }
72
73         n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
74         if (!n_ptr) {
75                 spin_unlock_bh(&node_create_lock);
76                 warn("Node creation failed, no memory\n");
77                 return NULL;
78         }
79
80         n_ptr->addr = addr;
81         spin_lock_init(&n_ptr->lock);
82         INIT_LIST_HEAD(&n_ptr->nsub);
83
84         n_num = tipc_node(addr);
85         tipc_net.nodes[n_num] = n_ptr;
86         if (n_num > tipc_net.highest_node)
87                 tipc_net.highest_node = n_num;
88
89         spin_unlock_bh(&node_create_lock);
90         return n_ptr;
91 }
92
93 void tipc_node_delete(struct tipc_node *n_ptr)
94 {
95         u32 n_num;
96
97         if (!n_ptr)
98                 return;
99
100         n_num = tipc_node(n_ptr->addr);
101         tipc_net.nodes[n_num] = NULL;
102         kfree(n_ptr);
103
104         while (!tipc_net.nodes[tipc_net.highest_node])
105                 if (--tipc_net.highest_node == 0)
106                         break;
107 }
108
109
110 /**
111  * tipc_node_link_up - handle addition of link
112  *
113  * Link becomes active (alone or shared) or standby, depending on its priority.
114  */
115
116 void tipc_node_link_up(struct tipc_node *n_ptr, struct link *l_ptr)
117 {
118         struct link **active = &n_ptr->active_links[0];
119
120         n_ptr->working_links++;
121
122         info("Established link <%s> on network plane %c\n",
123              l_ptr->name, l_ptr->b_ptr->net_plane);
124
125         if (!active[0]) {
126                 active[0] = active[1] = l_ptr;
127                 node_established_contact(n_ptr);
128                 return;
129         }
130         if (l_ptr->priority < active[0]->priority) {
131                 info("New link <%s> becomes standby\n", l_ptr->name);
132                 return;
133         }
134         tipc_link_send_duplicate(active[0], l_ptr);
135         if (l_ptr->priority == active[0]->priority) {
136                 active[0] = l_ptr;
137                 return;
138         }
139         info("Old link <%s> becomes standby\n", active[0]->name);
140         if (active[1] != active[0])
141                 info("Old link <%s> becomes standby\n", active[1]->name);
142         active[0] = active[1] = l_ptr;
143 }
144
145 /**
146  * node_select_active_links - select active link
147  */
148
149 static void node_select_active_links(struct tipc_node *n_ptr)
150 {
151         struct link **active = &n_ptr->active_links[0];
152         u32 i;
153         u32 highest_prio = 0;
154
155         active[0] = active[1] = NULL;
156
157         for (i = 0; i < MAX_BEARERS; i++) {
158                 struct link *l_ptr = n_ptr->links[i];
159
160                 if (!l_ptr || !tipc_link_is_up(l_ptr) ||
161                     (l_ptr->priority < highest_prio))
162                         continue;
163
164                 if (l_ptr->priority > highest_prio) {
165                         highest_prio = l_ptr->priority;
166                         active[0] = active[1] = l_ptr;
167                 } else {
168                         active[1] = l_ptr;
169                 }
170         }
171 }
172
173 /**
174  * tipc_node_link_down - handle loss of link
175  */
176
177 void tipc_node_link_down(struct tipc_node *n_ptr, struct link *l_ptr)
178 {
179         struct link **active;
180
181         n_ptr->working_links--;
182
183         if (!tipc_link_is_active(l_ptr)) {
184                 info("Lost standby link <%s> on network plane %c\n",
185                      l_ptr->name, l_ptr->b_ptr->net_plane);
186                 return;
187         }
188         info("Lost link <%s> on network plane %c\n",
189                 l_ptr->name, l_ptr->b_ptr->net_plane);
190
191         active = &n_ptr->active_links[0];
192         if (active[0] == l_ptr)
193                 active[0] = active[1];
194         if (active[1] == l_ptr)
195                 active[1] = active[0];
196         if (active[0] == l_ptr)
197                 node_select_active_links(n_ptr);
198         if (tipc_node_is_up(n_ptr))
199                 tipc_link_changeover(l_ptr);
200         else
201                 node_lost_contact(n_ptr);
202 }
203
204 int tipc_node_has_active_links(struct tipc_node *n_ptr)
205 {
206         return n_ptr->active_links[0] != NULL;
207 }
208
209 int tipc_node_has_redundant_links(struct tipc_node *n_ptr)
210 {
211         return n_ptr->working_links > 1;
212 }
213
214 int tipc_node_is_up(struct tipc_node *n_ptr)
215 {
216         return tipc_node_has_active_links(n_ptr);
217 }
218
219 struct tipc_node *tipc_node_attach_link(struct link *l_ptr)
220 {
221         struct tipc_node *n_ptr = tipc_node_find(l_ptr->addr);
222
223         if (!n_ptr)
224                 n_ptr = tipc_node_create(l_ptr->addr);
225         if (n_ptr) {
226                 u32 bearer_id = l_ptr->b_ptr->identity;
227                 char addr_string[16];
228
229                 if (n_ptr->link_cnt >= 2) {
230                         err("Attempt to create third link to %s\n",
231                             tipc_addr_string_fill(addr_string, n_ptr->addr));
232                         return NULL;
233                 }
234
235                 if (!n_ptr->links[bearer_id]) {
236                         n_ptr->links[bearer_id] = l_ptr;
237                         tipc_net.links++;
238                         n_ptr->link_cnt++;
239                         return n_ptr;
240                 }
241                 err("Attempt to establish second link on <%s> to %s\n",
242                     l_ptr->b_ptr->publ.name,
243                     tipc_addr_string_fill(addr_string, l_ptr->addr));
244         }
245         return NULL;
246 }
247
248 void tipc_node_detach_link(struct tipc_node *n_ptr, struct link *l_ptr)
249 {
250         n_ptr->links[l_ptr->b_ptr->identity] = NULL;
251         tipc_net.links--;
252         n_ptr->link_cnt--;
253 }
254
255 /*
256  * Routing table management - five cases to handle:
257  *
258  * 1: A link towards a zone/cluster external node comes up.
259  *    => Send a multicast message updating routing tables of all
260  *    system nodes within own cluster that the new destination
261  *    can be reached via this node.
262  *    (node.establishedContact()=>cluster.multicastNewRoute())
263  *
264  * 2: A link towards a slave node comes up.
265  *    => Send a multicast message updating routing tables of all
266  *    system nodes within own cluster that the new destination
267  *    can be reached via this node.
268  *    (node.establishedContact()=>cluster.multicastNewRoute())
269  *    => Send a  message to the slave node about existence
270  *    of all system nodes within cluster:
271  *    (node.establishedContact()=>cluster.sendLocalRoutes())
272  *
273  * 3: A new cluster local system node becomes available.
274  *    => Send message(s) to this particular node containing
275  *    information about all cluster external and slave
276  *     nodes which can be reached via this node.
277  *    (node.establishedContact()==>network.sendExternalRoutes())
278  *    (node.establishedContact()==>network.sendSlaveRoutes())
279  *    => Send messages to all directly connected slave nodes
280  *    containing information about the existence of the new node
281  *    (node.establishedContact()=>cluster.multicastNewRoute())
282  *
283  * 4: The link towards a zone/cluster external node or slave
284  *    node goes down.
285  *    => Send a multcast message updating routing tables of all
286  *    nodes within cluster that the new destination can not any
287  *    longer be reached via this node.
288  *    (node.lostAllLinks()=>cluster.bcastLostRoute())
289  *
290  * 5: A cluster local system node becomes unavailable.
291  *    => Remove all references to this node from the local
292  *    routing tables. Note: This is a completely node
293  *    local operation.
294  *    (node.lostAllLinks()=>network.removeAsRouter())
295  *    => Send messages to all directly connected slave nodes
296  *    containing information about loss of the node
297  *    (node.establishedContact()=>cluster.multicastLostRoute())
298  *
299  */
300
301 static void node_established_contact(struct tipc_node *n_ptr)
302 {
303         tipc_k_signal((Handler)tipc_named_node_up, n_ptr->addr);
304
305         /* Syncronize broadcast acks */
306         n_ptr->bclink.acked = tipc_bclink_get_last_sent();
307
308         if (n_ptr->bclink.supported) {
309                 tipc_nmap_add(&tipc_bcast_nmap, n_ptr->addr);
310                 if (n_ptr->addr < tipc_own_addr)
311                         tipc_own_tag++;
312         }
313 }
314
315 static void node_cleanup_finished(unsigned long node_addr)
316 {
317         struct tipc_node *n_ptr;
318
319         read_lock_bh(&tipc_net_lock);
320         n_ptr = tipc_node_find(node_addr);
321         if (n_ptr) {
322                 tipc_node_lock(n_ptr);
323                 n_ptr->cleanup_required = 0;
324                 tipc_node_unlock(n_ptr);
325         }
326         read_unlock_bh(&tipc_net_lock);
327 }
328
329 static void node_lost_contact(struct tipc_node *n_ptr)
330 {
331         struct tipc_node_subscr *ns, *tns;
332         char addr_string[16];
333         u32 i;
334
335         /* Clean up broadcast reception remains */
336         n_ptr->bclink.gap_after = n_ptr->bclink.gap_to = 0;
337         while (n_ptr->bclink.deferred_head) {
338                 struct sk_buff* buf = n_ptr->bclink.deferred_head;
339                 n_ptr->bclink.deferred_head = buf->next;
340                 buf_discard(buf);
341         }
342         if (n_ptr->bclink.defragm) {
343                 buf_discard(n_ptr->bclink.defragm);
344                 n_ptr->bclink.defragm = NULL;
345         }
346
347         if (n_ptr->bclink.supported) {
348                 tipc_bclink_acknowledge(n_ptr,
349                                         mod(n_ptr->bclink.acked + 10000));
350                 tipc_nmap_remove(&tipc_bcast_nmap, n_ptr->addr);
351                 if (n_ptr->addr < tipc_own_addr)
352                         tipc_own_tag--;
353         }
354
355         info("Lost contact with %s\n",
356              tipc_addr_string_fill(addr_string, n_ptr->addr));
357
358         /* Abort link changeover */
359         for (i = 0; i < MAX_BEARERS; i++) {
360                 struct link *l_ptr = n_ptr->links[i];
361                 if (!l_ptr)
362                         continue;
363                 l_ptr->reset_checkpoint = l_ptr->next_in_no;
364                 l_ptr->exp_msg_count = 0;
365                 tipc_link_reset_fragments(l_ptr);
366         }
367
368         /* Notify subscribers */
369         list_for_each_entry_safe(ns, tns, &n_ptr->nsub, nodesub_list) {
370                 ns->node = NULL;
371                 list_del_init(&ns->nodesub_list);
372                 tipc_k_signal((Handler)ns->handle_node_down,
373                               (unsigned long)ns->usr_handle);
374         }
375
376         /* Prevent re-contact with node until all cleanup is done */
377
378         n_ptr->cleanup_required = 1;
379         tipc_k_signal((Handler)node_cleanup_finished, n_ptr->addr);
380 }
381
382 struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
383 {
384         u32 domain;
385         struct sk_buff *buf;
386         struct tipc_node *n_ptr;
387         struct tipc_node_info node_info;
388         u32 payload_size;
389         u32 n_num;
390
391         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
392                 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
393
394         domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
395         if (!tipc_addr_domain_valid(domain))
396                 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
397                                                    " (network address)");
398
399         read_lock_bh(&tipc_net_lock);
400         if (!tipc_net.nodes) {
401                 read_unlock_bh(&tipc_net_lock);
402                 return tipc_cfg_reply_none();
403         }
404
405         /* For now, get space for all other nodes */
406
407         payload_size = TLV_SPACE(sizeof(node_info)) *
408                 (tipc_net.highest_node - 1);
409         if (payload_size > 32768u) {
410                 read_unlock_bh(&tipc_net_lock);
411                 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
412                                                    " (too many nodes)");
413         }
414         buf = tipc_cfg_reply_alloc(payload_size);
415         if (!buf) {
416                 read_unlock_bh(&tipc_net_lock);
417                 return NULL;
418         }
419
420         /* Add TLVs for all nodes in scope */
421
422         for (n_num = 1; n_num <= tipc_net.highest_node; n_num++) {
423                 n_ptr = tipc_net.nodes[n_num];
424                 if (!n_ptr || !tipc_in_scope(domain, n_ptr->addr))
425                         continue;
426                 node_info.addr = htonl(n_ptr->addr);
427                 node_info.up = htonl(tipc_node_is_up(n_ptr));
428                 tipc_cfg_append_tlv(buf, TIPC_TLV_NODE_INFO,
429                                     &node_info, sizeof(node_info));
430         }
431
432         read_unlock_bh(&tipc_net_lock);
433         return buf;
434 }
435
436 struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
437 {
438         u32 domain;
439         struct sk_buff *buf;
440         struct tipc_node *n_ptr;
441         struct tipc_link_info link_info;
442         u32 payload_size;
443         u32 n_num;
444
445         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
446                 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
447
448         domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
449         if (!tipc_addr_domain_valid(domain))
450                 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
451                                                    " (network address)");
452
453         if (tipc_mode != TIPC_NET_MODE)
454                 return tipc_cfg_reply_none();
455
456         read_lock_bh(&tipc_net_lock);
457
458         /* Get space for all unicast links + multicast link */
459
460         payload_size = TLV_SPACE(sizeof(link_info)) * (tipc_net.links + 1);
461         if (payload_size > 32768u) {
462                 read_unlock_bh(&tipc_net_lock);
463                 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
464                                                    " (too many links)");
465         }
466         buf = tipc_cfg_reply_alloc(payload_size);
467         if (!buf) {
468                 read_unlock_bh(&tipc_net_lock);
469                 return NULL;
470         }
471
472         /* Add TLV for broadcast link */
473
474         link_info.dest = htonl(tipc_own_addr & 0xfffff00);
475         link_info.up = htonl(1);
476         strlcpy(link_info.str, tipc_bclink_name, TIPC_MAX_LINK_NAME);
477         tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info));
478
479         /* Add TLVs for any other links in scope */
480
481         for (n_num = 1; n_num <= tipc_net.highest_node; n_num++) {
482                 u32 i;
483
484                 n_ptr = tipc_net.nodes[n_num];
485                 if (!n_ptr || !tipc_in_scope(domain, n_ptr->addr))
486                         continue;
487                 tipc_node_lock(n_ptr);
488                 for (i = 0; i < MAX_BEARERS; i++) {
489                         if (!n_ptr->links[i])
490                                 continue;
491                         link_info.dest = htonl(n_ptr->addr);
492                         link_info.up = htonl(tipc_link_is_up(n_ptr->links[i]));
493                         strcpy(link_info.str, n_ptr->links[i]->name);
494                         tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO,
495                                             &link_info, sizeof(link_info));
496                 }
497                 tipc_node_unlock(n_ptr);
498         }
499
500         read_unlock_bh(&tipc_net_lock);
501         return buf;
502 }