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