tipc: Remove prototype code for supporting multiple zones
[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, 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 /* sorted list of nodes within cluster */
47 static struct tipc_node *tipc_nodes = NULL;
48
49 static DEFINE_SPINLOCK(node_create_lock);
50
51 u32 tipc_own_tag = 0;
52
53 /**
54  * tipc_node_create - create neighboring node
55  *
56  * Currently, this routine is called by neighbor discovery code, which holds
57  * net_lock for reading only.  We must take node_create_lock to ensure a node
58  * isn't created twice if two different bearers discover the node at the same
59  * time.  (It would be preferable to switch to holding net_lock in write mode,
60  * but this is a non-trivial change.)
61  */
62
63 struct tipc_node *tipc_node_create(u32 addr)
64 {
65         struct cluster *c_ptr;
66         struct tipc_node *n_ptr;
67         struct tipc_node **curr_node;
68
69         spin_lock_bh(&node_create_lock);
70
71         for (n_ptr = tipc_nodes; n_ptr; n_ptr = n_ptr->next) {
72                 if (addr < n_ptr->addr)
73                         break;
74                 if (addr == n_ptr->addr) {
75                         spin_unlock_bh(&node_create_lock);
76                         return n_ptr;
77                 }
78         }
79
80         n_ptr = kzalloc(sizeof(*n_ptr),GFP_ATOMIC);
81         if (!n_ptr) {
82                 spin_unlock_bh(&node_create_lock);
83                 warn("Node creation failed, no memory\n");
84                 return NULL;
85         }
86
87         c_ptr = tipc_cltr_find(addr);
88         if (!c_ptr) {
89                 c_ptr = tipc_cltr_create(addr);
90         }
91         if (!c_ptr) {
92                 spin_unlock_bh(&node_create_lock);
93                 kfree(n_ptr);
94                 return NULL;
95         }
96
97         n_ptr->addr = addr;
98                 spin_lock_init(&n_ptr->lock);
99         INIT_LIST_HEAD(&n_ptr->nsub);
100         n_ptr->owner = c_ptr;
101         tipc_cltr_attach_node(c_ptr, n_ptr);
102         n_ptr->last_router = -1;
103
104         /* Insert node into ordered list */
105         for (curr_node = &tipc_nodes; *curr_node;
106              curr_node = &(*curr_node)->next) {
107                 if (addr < (*curr_node)->addr) {
108                         n_ptr->next = *curr_node;
109                         break;
110                 }
111         }
112         (*curr_node) = n_ptr;
113         spin_unlock_bh(&node_create_lock);
114         return n_ptr;
115 }
116
117 void tipc_node_delete(struct tipc_node *n_ptr)
118 {
119         if (!n_ptr)
120                 return;
121
122         dbg("node %x deleted\n", n_ptr->addr);
123         kfree(n_ptr);
124 }
125
126
127 /**
128  * tipc_node_link_up - handle addition of link
129  *
130  * Link becomes active (alone or shared) or standby, depending on its priority.
131  */
132
133 void tipc_node_link_up(struct tipc_node *n_ptr, struct link *l_ptr)
134 {
135         struct link **active = &n_ptr->active_links[0];
136
137         n_ptr->working_links++;
138
139         info("Established link <%s> on network plane %c\n",
140              l_ptr->name, l_ptr->b_ptr->net_plane);
141
142         if (!active[0]) {
143                 dbg(" link %x into %x/%x\n", l_ptr, &active[0], &active[1]);
144                 active[0] = active[1] = l_ptr;
145                 node_established_contact(n_ptr);
146                 return;
147         }
148         if (l_ptr->priority < active[0]->priority) {
149                 info("New link <%s> becomes standby\n", l_ptr->name);
150                 return;
151         }
152         tipc_link_send_duplicate(active[0], l_ptr);
153         if (l_ptr->priority == active[0]->priority) {
154                 active[0] = l_ptr;
155                 return;
156         }
157         info("Old link <%s> becomes standby\n", active[0]->name);
158         if (active[1] != active[0])
159                 info("Old link <%s> becomes standby\n", active[1]->name);
160         active[0] = active[1] = l_ptr;
161 }
162
163 /**
164  * node_select_active_links - select active link
165  */
166
167 static void node_select_active_links(struct tipc_node *n_ptr)
168 {
169         struct link **active = &n_ptr->active_links[0];
170         u32 i;
171         u32 highest_prio = 0;
172
173         active[0] = active[1] = NULL;
174
175         for (i = 0; i < MAX_BEARERS; i++) {
176                 struct link *l_ptr = n_ptr->links[i];
177
178                 if (!l_ptr || !tipc_link_is_up(l_ptr) ||
179                     (l_ptr->priority < highest_prio))
180                         continue;
181
182                 if (l_ptr->priority > highest_prio) {
183                         highest_prio = l_ptr->priority;
184                         active[0] = active[1] = l_ptr;
185                 } else {
186                         active[1] = l_ptr;
187                 }
188         }
189 }
190
191 /**
192  * tipc_node_link_down - handle loss of link
193  */
194
195 void tipc_node_link_down(struct tipc_node *n_ptr, struct link *l_ptr)
196 {
197         struct link **active;
198
199         n_ptr->working_links--;
200
201         if (!tipc_link_is_active(l_ptr)) {
202                 info("Lost standby link <%s> on network plane %c\n",
203                      l_ptr->name, l_ptr->b_ptr->net_plane);
204                 return;
205         }
206         info("Lost link <%s> on network plane %c\n",
207                 l_ptr->name, l_ptr->b_ptr->net_plane);
208
209         active = &n_ptr->active_links[0];
210         if (active[0] == l_ptr)
211                 active[0] = active[1];
212         if (active[1] == l_ptr)
213                 active[1] = active[0];
214         if (active[0] == l_ptr)
215                 node_select_active_links(n_ptr);
216         if (tipc_node_is_up(n_ptr))
217                 tipc_link_changeover(l_ptr);
218         else
219                 node_lost_contact(n_ptr);
220 }
221
222 int tipc_node_has_active_links(struct tipc_node *n_ptr)
223 {
224         return n_ptr->active_links[0] != NULL;
225 }
226
227 int tipc_node_has_redundant_links(struct tipc_node *n_ptr)
228 {
229         return n_ptr->working_links > 1;
230 }
231
232 static int tipc_node_has_active_routes(struct tipc_node *n_ptr)
233 {
234         return n_ptr && (n_ptr->last_router >= 0);
235 }
236
237 int tipc_node_is_up(struct tipc_node *n_ptr)
238 {
239         return tipc_node_has_active_links(n_ptr) || tipc_node_has_active_routes(n_ptr);
240 }
241
242 struct tipc_node *tipc_node_attach_link(struct link *l_ptr)
243 {
244         struct tipc_node *n_ptr = tipc_node_find(l_ptr->addr);
245
246         if (!n_ptr)
247                 n_ptr = tipc_node_create(l_ptr->addr);
248         if (n_ptr) {
249                 u32 bearer_id = l_ptr->b_ptr->identity;
250                 char addr_string[16];
251
252                 if (n_ptr->link_cnt >= 2) {
253                         err("Attempt to create third link to %s\n",
254                             tipc_addr_string_fill(addr_string, n_ptr->addr));
255                         return NULL;
256                 }
257
258                 if (!n_ptr->links[bearer_id]) {
259                         n_ptr->links[bearer_id] = l_ptr;
260                         tipc_net.links++;
261                         n_ptr->link_cnt++;
262                         return n_ptr;
263                 }
264                 err("Attempt to establish second link on <%s> to %s\n",
265                     l_ptr->b_ptr->publ.name,
266                     tipc_addr_string_fill(addr_string, l_ptr->addr));
267         }
268         return NULL;
269 }
270
271 void tipc_node_detach_link(struct tipc_node *n_ptr, struct link *l_ptr)
272 {
273         n_ptr->links[l_ptr->b_ptr->identity] = NULL;
274         tipc_net.links--;
275         n_ptr->link_cnt--;
276 }
277
278 /*
279  * Routing table management - five cases to handle:
280  *
281  * 1: A link towards a zone/cluster external node comes up.
282  *    => Send a multicast message updating routing tables of all
283  *    system nodes within own cluster that the new destination
284  *    can be reached via this node.
285  *    (node.establishedContact()=>cluster.multicastNewRoute())
286  *
287  * 2: A link towards a slave node comes up.
288  *    => Send a multicast message updating routing tables of all
289  *    system nodes within own cluster that the new destination
290  *    can be reached via this node.
291  *    (node.establishedContact()=>cluster.multicastNewRoute())
292  *    => Send a  message to the slave node about existence
293  *    of all system nodes within cluster:
294  *    (node.establishedContact()=>cluster.sendLocalRoutes())
295  *
296  * 3: A new cluster local system node becomes available.
297  *    => Send message(s) to this particular node containing
298  *    information about all cluster external and slave
299  *     nodes which can be reached via this node.
300  *    (node.establishedContact()==>network.sendExternalRoutes())
301  *    (node.establishedContact()==>network.sendSlaveRoutes())
302  *    => Send messages to all directly connected slave nodes
303  *    containing information about the existence of the new node
304  *    (node.establishedContact()=>cluster.multicastNewRoute())
305  *
306  * 4: The link towards a zone/cluster external node or slave
307  *    node goes down.
308  *    => Send a multcast message updating routing tables of all
309  *    nodes within cluster that the new destination can not any
310  *    longer be reached via this node.
311  *    (node.lostAllLinks()=>cluster.bcastLostRoute())
312  *
313  * 5: A cluster local system node becomes unavailable.
314  *    => Remove all references to this node from the local
315  *    routing tables. Note: This is a completely node
316  *    local operation.
317  *    (node.lostAllLinks()=>network.removeAsRouter())
318  *    => Send messages to all directly connected slave nodes
319  *    containing information about loss of the node
320  *    (node.establishedContact()=>cluster.multicastLostRoute())
321  *
322  */
323
324 static void node_established_contact(struct tipc_node *n_ptr)
325 {
326         struct cluster *c_ptr;
327
328         dbg("node_established_contact:-> %x\n", n_ptr->addr);
329         if (!tipc_node_has_active_routes(n_ptr) && in_own_cluster(n_ptr->addr)) {
330                 tipc_k_signal((Handler)tipc_named_node_up, n_ptr->addr);
331         }
332
333         /* Syncronize broadcast acks */
334         n_ptr->bclink.acked = tipc_bclink_get_last_sent();
335
336         if (is_slave(tipc_own_addr))
337                 return;
338         if (!in_own_cluster(n_ptr->addr)) {
339                 /* Usage case 1 (see above) */
340                 c_ptr = tipc_cltr_find(tipc_own_addr);
341                 if (!c_ptr)
342                         c_ptr = tipc_cltr_create(tipc_own_addr);
343                 if (c_ptr)
344                         tipc_cltr_bcast_new_route(c_ptr, n_ptr->addr, 1,
345                                                   tipc_max_nodes);
346                 return;
347         }
348
349         c_ptr = n_ptr->owner;
350         if (is_slave(n_ptr->addr)) {
351                 /* Usage case 2 (see above) */
352                 tipc_cltr_bcast_new_route(c_ptr, n_ptr->addr, 1, tipc_max_nodes);
353                 tipc_cltr_send_local_routes(c_ptr, n_ptr->addr);
354                 return;
355         }
356
357         if (n_ptr->bclink.supported) {
358                 tipc_nmap_add(&tipc_cltr_bcast_nodes, n_ptr->addr);
359                 if (n_ptr->addr < tipc_own_addr)
360                         tipc_own_tag++;
361         }
362
363         /* Case 3 (see above) */
364         tipc_net_send_external_routes(n_ptr->addr);
365         tipc_cltr_send_slave_routes(c_ptr, n_ptr->addr);
366         tipc_cltr_bcast_new_route(c_ptr, n_ptr->addr, LOWEST_SLAVE,
367                                   tipc_highest_allowed_slave);
368 }
369
370 static void node_cleanup_finished(unsigned long node_addr)
371 {
372         struct tipc_node *n_ptr;
373
374         read_lock_bh(&tipc_net_lock);
375         n_ptr = tipc_node_find(node_addr);
376         if (n_ptr) {
377                 tipc_node_lock(n_ptr);
378                 n_ptr->cleanup_required = 0;
379                 tipc_node_unlock(n_ptr);
380         }
381         read_unlock_bh(&tipc_net_lock);
382 }
383
384 static void node_lost_contact(struct tipc_node *n_ptr)
385 {
386         struct cluster *c_ptr;
387         struct tipc_node_subscr *ns, *tns;
388         char addr_string[16];
389         u32 i;
390
391         /* Clean up broadcast reception remains */
392         n_ptr->bclink.gap_after = n_ptr->bclink.gap_to = 0;
393         while (n_ptr->bclink.deferred_head) {
394                 struct sk_buff* buf = n_ptr->bclink.deferred_head;
395                 n_ptr->bclink.deferred_head = buf->next;
396                 buf_discard(buf);
397         }
398         if (n_ptr->bclink.defragm) {
399                 buf_discard(n_ptr->bclink.defragm);
400                 n_ptr->bclink.defragm = NULL;
401         }
402         if (in_own_cluster(n_ptr->addr) && n_ptr->bclink.supported) {
403                 tipc_bclink_acknowledge(n_ptr, mod(n_ptr->bclink.acked + 10000));
404         }
405
406         /* Update routing tables */
407         if (is_slave(tipc_own_addr)) {
408                 tipc_net_remove_as_router(n_ptr->addr);
409         } else {
410                 if (!in_own_cluster(n_ptr->addr)) {
411                         /* Case 4 (see above) */
412                         c_ptr = tipc_cltr_find(tipc_own_addr);
413                         tipc_cltr_bcast_lost_route(c_ptr, n_ptr->addr, 1,
414                                                    tipc_max_nodes);
415                 } else {
416                         /* Case 5 (see above) */
417                         c_ptr = tipc_cltr_find(n_ptr->addr);
418                         if (is_slave(n_ptr->addr)) {
419                                 tipc_cltr_bcast_lost_route(c_ptr, n_ptr->addr, 1,
420                                                            tipc_max_nodes);
421                         } else {
422                                 if (n_ptr->bclink.supported) {
423                                         tipc_nmap_remove(&tipc_cltr_bcast_nodes,
424                                                          n_ptr->addr);
425                                         if (n_ptr->addr < tipc_own_addr)
426                                                 tipc_own_tag--;
427                                 }
428                                 tipc_net_remove_as_router(n_ptr->addr);
429                                 tipc_cltr_bcast_lost_route(c_ptr, n_ptr->addr,
430                                                            LOWEST_SLAVE,
431                                                            tipc_highest_allowed_slave);
432                         }
433                 }
434         }
435         if (tipc_node_has_active_routes(n_ptr))
436                 return;
437
438         info("Lost contact with %s\n",
439              tipc_addr_string_fill(addr_string, n_ptr->addr));
440
441         /* Abort link changeover */
442         for (i = 0; i < MAX_BEARERS; i++) {
443                 struct link *l_ptr = n_ptr->links[i];
444                 if (!l_ptr)
445                         continue;
446                 l_ptr->reset_checkpoint = l_ptr->next_in_no;
447                 l_ptr->exp_msg_count = 0;
448                 tipc_link_reset_fragments(l_ptr);
449         }
450
451         /* Notify subscribers */
452         list_for_each_entry_safe(ns, tns, &n_ptr->nsub, nodesub_list) {
453                 ns->node = NULL;
454                 list_del_init(&ns->nodesub_list);
455                 tipc_k_signal((Handler)ns->handle_node_down,
456                               (unsigned long)ns->usr_handle);
457         }
458
459         /* Prevent re-contact with node until all cleanup is done */
460
461         n_ptr->cleanup_required = 1;
462         tipc_k_signal((Handler)node_cleanup_finished, n_ptr->addr);
463 }
464
465 /**
466  * tipc_node_select_next_hop - find the next-hop node for a message
467  *
468  * Called by when cluster local lookup has failed.
469  */
470
471 struct tipc_node *tipc_node_select_next_hop(u32 addr, u32 selector)
472 {
473         struct tipc_node *n_ptr;
474         u32 router_addr;
475
476         if (!tipc_addr_domain_valid(addr))
477                 return NULL;
478
479         /* Look for direct link to destination processsor */
480         n_ptr = tipc_node_find(addr);
481         if (n_ptr && tipc_node_has_active_links(n_ptr))
482                 return n_ptr;
483
484         /* Cluster local system nodes *must* have direct links */
485         if (!is_slave(addr) && in_own_cluster(addr))
486                 return NULL;
487
488         /* Look for cluster local router with direct link to node */
489         router_addr = tipc_node_select_router(n_ptr, selector);
490         if (router_addr)
491                 return tipc_node_select(router_addr, selector);
492
493         /* Slave nodes can only be accessed within own cluster via a
494            known router with direct link -- if no router was found,give up */
495         if (is_slave(addr))
496                 return NULL;
497
498         /* Inter zone/cluster -- find any direct link to remote cluster */
499         addr = tipc_addr(tipc_zone(addr), tipc_cluster(addr), 0);
500         n_ptr = tipc_net_select_remote_node(addr, selector);
501         if (n_ptr && tipc_node_has_active_links(n_ptr))
502                 return n_ptr;
503
504         /* Last resort -- look for any router to anywhere in remote zone */
505         router_addr =  tipc_net_select_router(addr, selector);
506         if (router_addr)
507                 return tipc_node_select(router_addr, selector);
508
509         return NULL;
510 }
511
512 /**
513  * tipc_node_select_router - select router to reach specified node
514  *
515  * Uses a deterministic and fair algorithm for selecting router node.
516  */
517
518 u32 tipc_node_select_router(struct tipc_node *n_ptr, u32 ref)
519 {
520         u32 ulim;
521         u32 mask;
522         u32 start;
523         u32 r;
524
525         if (!n_ptr)
526                 return 0;
527
528         if (n_ptr->last_router < 0)
529                 return 0;
530         ulim = ((n_ptr->last_router + 1) * 32) - 1;
531
532         /* Start entry must be random */
533         mask = tipc_max_nodes;
534         while (mask > ulim)
535                 mask >>= 1;
536         start = ref & mask;
537         r = start;
538
539         /* Lookup upwards with wrap-around */
540         do {
541                 if (((n_ptr->routers[r / 32]) >> (r % 32)) & 1)
542                         break;
543         } while (++r <= ulim);
544         if (r > ulim) {
545                 r = 1;
546                 do {
547                         if (((n_ptr->routers[r / 32]) >> (r % 32)) & 1)
548                                 break;
549                 } while (++r < start);
550                 assert(r != start);
551         }
552         assert(r && (r <= ulim));
553         return tipc_addr(own_zone(), own_cluster(), r);
554 }
555
556 void tipc_node_add_router(struct tipc_node *n_ptr, u32 router)
557 {
558         u32 r_num = tipc_node(router);
559
560         n_ptr->routers[r_num / 32] =
561                 ((1 << (r_num % 32)) | n_ptr->routers[r_num / 32]);
562         n_ptr->last_router = tipc_max_nodes / 32;
563         while ((--n_ptr->last_router >= 0) &&
564                !n_ptr->routers[n_ptr->last_router]);
565 }
566
567 void tipc_node_remove_router(struct tipc_node *n_ptr, u32 router)
568 {
569         u32 r_num = tipc_node(router);
570
571         if (n_ptr->last_router < 0)
572                 return;         /* No routes */
573
574         n_ptr->routers[r_num / 32] =
575                 ((~(1 << (r_num % 32))) & (n_ptr->routers[r_num / 32]));
576         n_ptr->last_router = tipc_max_nodes / 32;
577         while ((--n_ptr->last_router >= 0) &&
578                !n_ptr->routers[n_ptr->last_router]);
579
580         if (!tipc_node_is_up(n_ptr))
581                 node_lost_contact(n_ptr);
582 }
583
584 struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
585 {
586         u32 domain;
587         struct sk_buff *buf;
588         struct tipc_node *n_ptr;
589         struct tipc_node_info node_info;
590         u32 payload_size;
591
592         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
593                 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
594
595         domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
596         if (!tipc_addr_domain_valid(domain))
597                 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
598                                                    " (network address)");
599
600         read_lock_bh(&tipc_net_lock);
601         if (!tipc_nodes) {
602                 read_unlock_bh(&tipc_net_lock);
603                 return tipc_cfg_reply_none();
604         }
605
606         /* For now, get space for all other nodes
607            (will need to modify this when slave nodes are supported */
608
609         payload_size = TLV_SPACE(sizeof(node_info)) * (tipc_max_nodes - 1);
610         if (payload_size > 32768u) {
611                 read_unlock_bh(&tipc_net_lock);
612                 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
613                                                    " (too many nodes)");
614         }
615         buf = tipc_cfg_reply_alloc(payload_size);
616         if (!buf) {
617                 read_unlock_bh(&tipc_net_lock);
618                 return NULL;
619         }
620
621         /* Add TLVs for all nodes in scope */
622
623         for (n_ptr = tipc_nodes; n_ptr; n_ptr = n_ptr->next) {
624                 if (!tipc_in_scope(domain, n_ptr->addr))
625                         continue;
626                 node_info.addr = htonl(n_ptr->addr);
627                 node_info.up = htonl(tipc_node_is_up(n_ptr));
628                 tipc_cfg_append_tlv(buf, TIPC_TLV_NODE_INFO,
629                                     &node_info, sizeof(node_info));
630         }
631
632         read_unlock_bh(&tipc_net_lock);
633         return buf;
634 }
635
636 struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
637 {
638         u32 domain;
639         struct sk_buff *buf;
640         struct tipc_node *n_ptr;
641         struct tipc_link_info link_info;
642         u32 payload_size;
643
644         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
645                 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
646
647         domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
648         if (!tipc_addr_domain_valid(domain))
649                 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
650                                                    " (network address)");
651
652         if (tipc_mode != TIPC_NET_MODE)
653                 return tipc_cfg_reply_none();
654
655         read_lock_bh(&tipc_net_lock);
656
657         /* Get space for all unicast links + multicast link */
658
659         payload_size = TLV_SPACE(sizeof(link_info)) * (tipc_net.links + 1);
660         if (payload_size > 32768u) {
661                 read_unlock_bh(&tipc_net_lock);
662                 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
663                                                    " (too many links)");
664         }
665         buf = tipc_cfg_reply_alloc(payload_size);
666         if (!buf) {
667                 read_unlock_bh(&tipc_net_lock);
668                 return NULL;
669         }
670
671         /* Add TLV for broadcast link */
672
673         link_info.dest = htonl(tipc_own_addr & 0xfffff00);
674         link_info.up = htonl(1);
675         strlcpy(link_info.str, tipc_bclink_name, TIPC_MAX_LINK_NAME);
676         tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info));
677
678         /* Add TLVs for any other links in scope */
679
680         for (n_ptr = tipc_nodes; n_ptr; n_ptr = n_ptr->next) {
681                 u32 i;
682
683                 if (!tipc_in_scope(domain, n_ptr->addr))
684                         continue;
685                 tipc_node_lock(n_ptr);
686                 for (i = 0; i < MAX_BEARERS; i++) {
687                         if (!n_ptr->links[i])
688                                 continue;
689                         link_info.dest = htonl(n_ptr->addr);
690                         link_info.up = htonl(tipc_link_is_up(n_ptr->links[i]));
691                         strcpy(link_info.str, n_ptr->links[i]->name);
692                         tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO,
693                                             &link_info, sizeof(link_info));
694                 }
695                 tipc_node_unlock(n_ptr);
696         }
697
698         read_unlock_bh(&tipc_net_lock);
699         return buf;
700 }