]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - net/tipc/node.c
2 * net/tipc/node.c: TIPC node management routines
4 * Copyright (c) 2000-2006, Ericsson AB
5 * Copyright (c) 2005-2006, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
41 #include "name_distr.h"
43 static void node_lost_contact(struct tipc_node
*n_ptr
);
44 static void node_established_contact(struct tipc_node
*n_ptr
);
46 /* sorted list of nodes within cluster */
47 static struct tipc_node
*tipc_nodes
= NULL
;
49 static DEFINE_SPINLOCK(node_create_lock
);
54 * tipc_node_create - create neighboring node
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.)
63 struct tipc_node
*tipc_node_create(u32 addr
)
65 struct tipc_node
*n_ptr
;
66 struct tipc_node
**curr_node
;
69 spin_lock_bh(&node_create_lock
);
71 for (n_ptr
= tipc_nodes
; n_ptr
; n_ptr
= n_ptr
->next
) {
72 if (addr
< n_ptr
->addr
)
74 if (addr
== n_ptr
->addr
) {
75 spin_unlock_bh(&node_create_lock
);
80 n_ptr
= kzalloc(sizeof(*n_ptr
),GFP_ATOMIC
);
82 spin_unlock_bh(&node_create_lock
);
83 warn("Node creation failed, no memory\n");
88 spin_lock_init(&n_ptr
->lock
);
89 INIT_LIST_HEAD(&n_ptr
->nsub
);
91 n_num
= tipc_node(addr
);
92 tipc_net
.nodes
[n_num
] = n_ptr
;
93 if (n_num
> tipc_net
.highest_node
)
94 tipc_net
.highest_node
= n_num
;
96 /* Insert node into ordered list */
97 for (curr_node
= &tipc_nodes
; *curr_node
;
98 curr_node
= &(*curr_node
)->next
) {
99 if (addr
< (*curr_node
)->addr
) {
100 n_ptr
->next
= *curr_node
;
104 (*curr_node
) = n_ptr
;
105 spin_unlock_bh(&node_create_lock
);
109 void tipc_node_delete(struct tipc_node
*n_ptr
)
116 dbg("node %x deleted\n", n_ptr
->addr
);
117 n_num
= tipc_node(n_ptr
->addr
);
118 tipc_net
.nodes
[n_num
] = NULL
;
121 while (!tipc_net
.nodes
[tipc_net
.highest_node
])
122 if (--tipc_net
.highest_node
== 0)
128 * tipc_node_link_up - handle addition of link
130 * Link becomes active (alone or shared) or standby, depending on its priority.
133 void tipc_node_link_up(struct tipc_node
*n_ptr
, struct link
*l_ptr
)
135 struct link
**active
= &n_ptr
->active_links
[0];
137 n_ptr
->working_links
++;
139 info("Established link <%s> on network plane %c\n",
140 l_ptr
->name
, l_ptr
->b_ptr
->net_plane
);
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
);
148 if (l_ptr
->priority
< active
[0]->priority
) {
149 info("New link <%s> becomes standby\n", l_ptr
->name
);
152 tipc_link_send_duplicate(active
[0], l_ptr
);
153 if (l_ptr
->priority
== active
[0]->priority
) {
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
;
164 * node_select_active_links - select active link
167 static void node_select_active_links(struct tipc_node
*n_ptr
)
169 struct link
**active
= &n_ptr
->active_links
[0];
171 u32 highest_prio
= 0;
173 active
[0] = active
[1] = NULL
;
175 for (i
= 0; i
< MAX_BEARERS
; i
++) {
176 struct link
*l_ptr
= n_ptr
->links
[i
];
178 if (!l_ptr
|| !tipc_link_is_up(l_ptr
) ||
179 (l_ptr
->priority
< highest_prio
))
182 if (l_ptr
->priority
> highest_prio
) {
183 highest_prio
= l_ptr
->priority
;
184 active
[0] = active
[1] = l_ptr
;
192 * tipc_node_link_down - handle loss of link
195 void tipc_node_link_down(struct tipc_node
*n_ptr
, struct link
*l_ptr
)
197 struct link
**active
;
199 n_ptr
->working_links
--;
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
);
206 info("Lost link <%s> on network plane %c\n",
207 l_ptr
->name
, l_ptr
->b_ptr
->net_plane
);
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
);
219 node_lost_contact(n_ptr
);
222 int tipc_node_has_active_links(struct tipc_node
*n_ptr
)
224 return n_ptr
->active_links
[0] != NULL
;
227 int tipc_node_has_redundant_links(struct tipc_node
*n_ptr
)
229 return n_ptr
->working_links
> 1;
232 int tipc_node_is_up(struct tipc_node
*n_ptr
)
234 return tipc_node_has_active_links(n_ptr
);
237 struct tipc_node
*tipc_node_attach_link(struct link
*l_ptr
)
239 struct tipc_node
*n_ptr
= tipc_node_find(l_ptr
->addr
);
242 n_ptr
= tipc_node_create(l_ptr
->addr
);
244 u32 bearer_id
= l_ptr
->b_ptr
->identity
;
245 char addr_string
[16];
247 if (n_ptr
->link_cnt
>= 2) {
248 err("Attempt to create third link to %s\n",
249 tipc_addr_string_fill(addr_string
, n_ptr
->addr
));
253 if (!n_ptr
->links
[bearer_id
]) {
254 n_ptr
->links
[bearer_id
] = l_ptr
;
259 err("Attempt to establish second link on <%s> to %s\n",
260 l_ptr
->b_ptr
->publ
.name
,
261 tipc_addr_string_fill(addr_string
, l_ptr
->addr
));
266 void tipc_node_detach_link(struct tipc_node
*n_ptr
, struct link
*l_ptr
)
268 n_ptr
->links
[l_ptr
->b_ptr
->identity
] = NULL
;
274 * Routing table management - five cases to handle:
276 * 1: A link towards a zone/cluster external node comes up.
277 * => Send a multicast message updating routing tables of all
278 * system nodes within own cluster that the new destination
279 * can be reached via this node.
280 * (node.establishedContact()=>cluster.multicastNewRoute())
282 * 2: A link towards a slave node comes up.
283 * => Send a multicast message updating routing tables of all
284 * system nodes within own cluster that the new destination
285 * can be reached via this node.
286 * (node.establishedContact()=>cluster.multicastNewRoute())
287 * => Send a message to the slave node about existence
288 * of all system nodes within cluster:
289 * (node.establishedContact()=>cluster.sendLocalRoutes())
291 * 3: A new cluster local system node becomes available.
292 * => Send message(s) to this particular node containing
293 * information about all cluster external and slave
294 * nodes which can be reached via this node.
295 * (node.establishedContact()==>network.sendExternalRoutes())
296 * (node.establishedContact()==>network.sendSlaveRoutes())
297 * => Send messages to all directly connected slave nodes
298 * containing information about the existence of the new node
299 * (node.establishedContact()=>cluster.multicastNewRoute())
301 * 4: The link towards a zone/cluster external node or slave
303 * => Send a multcast message updating routing tables of all
304 * nodes within cluster that the new destination can not any
305 * longer be reached via this node.
306 * (node.lostAllLinks()=>cluster.bcastLostRoute())
308 * 5: A cluster local system node becomes unavailable.
309 * => Remove all references to this node from the local
310 * routing tables. Note: This is a completely node
312 * (node.lostAllLinks()=>network.removeAsRouter())
313 * => Send messages to all directly connected slave nodes
314 * containing information about loss of the node
315 * (node.establishedContact()=>cluster.multicastLostRoute())
319 static void node_established_contact(struct tipc_node
*n_ptr
)
321 dbg("node_established_contact:-> %x\n", n_ptr
->addr
);
322 tipc_k_signal((Handler
)tipc_named_node_up
, n_ptr
->addr
);
324 /* Syncronize broadcast acks */
325 n_ptr
->bclink
.acked
= tipc_bclink_get_last_sent();
327 if (n_ptr
->bclink
.supported
) {
328 tipc_nmap_add(&tipc_bcast_nmap
, n_ptr
->addr
);
329 if (n_ptr
->addr
< tipc_own_addr
)
334 static void node_cleanup_finished(unsigned long node_addr
)
336 struct tipc_node
*n_ptr
;
338 read_lock_bh(&tipc_net_lock
);
339 n_ptr
= tipc_node_find(node_addr
);
341 tipc_node_lock(n_ptr
);
342 n_ptr
->cleanup_required
= 0;
343 tipc_node_unlock(n_ptr
);
345 read_unlock_bh(&tipc_net_lock
);
348 static void node_lost_contact(struct tipc_node
*n_ptr
)
350 struct tipc_node_subscr
*ns
, *tns
;
351 char addr_string
[16];
354 /* Clean up broadcast reception remains */
355 n_ptr
->bclink
.gap_after
= n_ptr
->bclink
.gap_to
= 0;
356 while (n_ptr
->bclink
.deferred_head
) {
357 struct sk_buff
* buf
= n_ptr
->bclink
.deferred_head
;
358 n_ptr
->bclink
.deferred_head
= buf
->next
;
361 if (n_ptr
->bclink
.defragm
) {
362 buf_discard(n_ptr
->bclink
.defragm
);
363 n_ptr
->bclink
.defragm
= NULL
;
366 if (n_ptr
->bclink
.supported
) {
367 tipc_bclink_acknowledge(n_ptr
,
368 mod(n_ptr
->bclink
.acked
+ 10000));
369 tipc_nmap_remove(&tipc_bcast_nmap
, n_ptr
->addr
);
370 if (n_ptr
->addr
< tipc_own_addr
)
374 info("Lost contact with %s\n",
375 tipc_addr_string_fill(addr_string
, n_ptr
->addr
));
377 /* Abort link changeover */
378 for (i
= 0; i
< MAX_BEARERS
; i
++) {
379 struct link
*l_ptr
= n_ptr
->links
[i
];
382 l_ptr
->reset_checkpoint
= l_ptr
->next_in_no
;
383 l_ptr
->exp_msg_count
= 0;
384 tipc_link_reset_fragments(l_ptr
);
387 /* Notify subscribers */
388 list_for_each_entry_safe(ns
, tns
, &n_ptr
->nsub
, nodesub_list
) {
390 list_del_init(&ns
->nodesub_list
);
391 tipc_k_signal((Handler
)ns
->handle_node_down
,
392 (unsigned long)ns
->usr_handle
);
395 /* Prevent re-contact with node until all cleanup is done */
397 n_ptr
->cleanup_required
= 1;
398 tipc_k_signal((Handler
)node_cleanup_finished
, n_ptr
->addr
);
401 struct sk_buff
*tipc_node_get_nodes(const void *req_tlv_area
, int req_tlv_space
)
405 struct tipc_node
*n_ptr
;
406 struct tipc_node_info node_info
;
409 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_NET_ADDR
))
410 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
412 domain
= ntohl(*(__be32
*)TLV_DATA(req_tlv_area
));
413 if (!tipc_addr_domain_valid(domain
))
414 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
415 " (network address)");
417 read_lock_bh(&tipc_net_lock
);
419 read_unlock_bh(&tipc_net_lock
);
420 return tipc_cfg_reply_none();
423 /* For now, get space for all other nodes */
425 payload_size
= TLV_SPACE(sizeof(node_info
)) * (tipc_max_nodes
- 1);
426 if (payload_size
> 32768u) {
427 read_unlock_bh(&tipc_net_lock
);
428 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
429 " (too many nodes)");
431 buf
= tipc_cfg_reply_alloc(payload_size
);
433 read_unlock_bh(&tipc_net_lock
);
437 /* Add TLVs for all nodes in scope */
439 for (n_ptr
= tipc_nodes
; n_ptr
; n_ptr
= n_ptr
->next
) {
440 if (!tipc_in_scope(domain
, n_ptr
->addr
))
442 node_info
.addr
= htonl(n_ptr
->addr
);
443 node_info
.up
= htonl(tipc_node_is_up(n_ptr
));
444 tipc_cfg_append_tlv(buf
, TIPC_TLV_NODE_INFO
,
445 &node_info
, sizeof(node_info
));
448 read_unlock_bh(&tipc_net_lock
);
452 struct sk_buff
*tipc_node_get_links(const void *req_tlv_area
, int req_tlv_space
)
456 struct tipc_node
*n_ptr
;
457 struct tipc_link_info link_info
;
460 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_NET_ADDR
))
461 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
463 domain
= ntohl(*(__be32
*)TLV_DATA(req_tlv_area
));
464 if (!tipc_addr_domain_valid(domain
))
465 return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
466 " (network address)");
468 if (tipc_mode
!= TIPC_NET_MODE
)
469 return tipc_cfg_reply_none();
471 read_lock_bh(&tipc_net_lock
);
473 /* Get space for all unicast links + multicast link */
475 payload_size
= TLV_SPACE(sizeof(link_info
)) * (tipc_net
.links
+ 1);
476 if (payload_size
> 32768u) {
477 read_unlock_bh(&tipc_net_lock
);
478 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
479 " (too many links)");
481 buf
= tipc_cfg_reply_alloc(payload_size
);
483 read_unlock_bh(&tipc_net_lock
);
487 /* Add TLV for broadcast link */
489 link_info
.dest
= htonl(tipc_own_addr
& 0xfffff00);
490 link_info
.up
= htonl(1);
491 strlcpy(link_info
.str
, tipc_bclink_name
, TIPC_MAX_LINK_NAME
);
492 tipc_cfg_append_tlv(buf
, TIPC_TLV_LINK_INFO
, &link_info
, sizeof(link_info
));
494 /* Add TLVs for any other links in scope */
496 for (n_ptr
= tipc_nodes
; n_ptr
; n_ptr
= n_ptr
->next
) {
499 if (!tipc_in_scope(domain
, n_ptr
->addr
))
501 tipc_node_lock(n_ptr
);
502 for (i
= 0; i
< MAX_BEARERS
; i
++) {
503 if (!n_ptr
->links
[i
])
505 link_info
.dest
= htonl(n_ptr
->addr
);
506 link_info
.up
= htonl(tipc_link_is_up(n_ptr
->links
[i
]));
507 strcpy(link_info
.str
, n_ptr
->links
[i
]->name
);
508 tipc_cfg_append_tlv(buf
, TIPC_TLV_LINK_INFO
,
509 &link_info
, sizeof(link_info
));
511 tipc_node_unlock(n_ptr
);
514 read_unlock_bh(&tipc_net_lock
);