2006-01-02 19:04:38 +01:00
|
|
|
/*
|
|
|
|
* net/tipc/node.c: TIPC node management routines
|
2007-02-09 15:25:21 +01:00
|
|
|
*
|
2014-06-26 03:41:33 +02:00
|
|
|
* Copyright (c) 2000-2006, 2012-2014, Ericsson AB
|
2014-03-27 05:54:36 +01:00
|
|
|
* Copyright (c) 2005-2006, 2010-2014, Wind River Systems
|
2006-01-02 19:04:38 +01:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
2006-01-11 13:30:43 +01:00
|
|
|
* Redistribution and use in source and binary forms, with or without
|
2006-01-02 19:04:38 +01:00
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
2006-01-11 13:30:43 +01:00
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. Neither the names of the copyright holders nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived from
|
|
|
|
* this software without specific prior written permission.
|
2006-01-02 19:04:38 +01:00
|
|
|
*
|
2006-01-11 13:30:43 +01:00
|
|
|
* Alternatively, this software may be distributed under the terms of the
|
|
|
|
* GNU General Public License ("GPL") version 2 as published by the Free
|
|
|
|
* Software Foundation.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
2006-01-02 19:04:38 +01:00
|
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "core.h"
|
|
|
|
#include "config.h"
|
|
|
|
#include "node.h"
|
|
|
|
#include "name_distr.h"
|
|
|
|
|
2011-11-04 16:54:43 +01:00
|
|
|
#define NODE_HTABLE_SIZE 512
|
|
|
|
|
2008-09-03 08:38:32 +02:00
|
|
|
static void node_lost_contact(struct tipc_node *n_ptr);
|
|
|
|
static void node_established_contact(struct tipc_node *n_ptr);
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2011-02-26 00:42:52 +01:00
|
|
|
static struct hlist_head node_htable[NODE_HTABLE_SIZE];
|
|
|
|
LIST_HEAD(tipc_node_list);
|
|
|
|
static u32 tipc_num_nodes;
|
2014-03-27 05:54:39 +01:00
|
|
|
static u32 tipc_num_links;
|
2014-03-27 05:54:36 +01:00
|
|
|
static DEFINE_SPINLOCK(node_list_lock);
|
2011-02-26 01:11:25 +01:00
|
|
|
|
2011-11-04 16:54:43 +01:00
|
|
|
/*
|
|
|
|
* A trivial power-of-two bitmask technique is used for speed, since this
|
|
|
|
* operation is done for every incoming TIPC packet. The number of hash table
|
|
|
|
* entries has been chosen so that no hash chain exceeds 8 nodes and will
|
|
|
|
* usually be much smaller (typically only a single node).
|
|
|
|
*/
|
2012-04-23 06:49:13 +02:00
|
|
|
static unsigned int tipc_hashfn(u32 addr)
|
2011-11-04 16:54:43 +01:00
|
|
|
{
|
|
|
|
return addr & (NODE_HTABLE_SIZE - 1);
|
|
|
|
}
|
|
|
|
|
2011-10-27 21:03:24 +02:00
|
|
|
/*
|
2011-02-26 00:42:52 +01:00
|
|
|
* tipc_node_find - locate specified node object, if it exists
|
|
|
|
*/
|
|
|
|
struct tipc_node *tipc_node_find(u32 addr)
|
|
|
|
{
|
|
|
|
struct tipc_node *node;
|
|
|
|
|
2012-04-18 00:02:01 +02:00
|
|
|
if (unlikely(!in_own_cluster_exact(addr)))
|
2011-02-26 00:42:52 +01:00
|
|
|
return NULL;
|
|
|
|
|
2014-03-27 05:54:37 +01:00
|
|
|
rcu_read_lock();
|
|
|
|
hlist_for_each_entry_rcu(node, &node_htable[tipc_hashfn(addr)], hash) {
|
2014-03-27 05:54:36 +01:00
|
|
|
if (node->addr == addr) {
|
2014-03-27 05:54:37 +01:00
|
|
|
rcu_read_unlock();
|
2011-02-26 00:42:52 +01:00
|
|
|
return node;
|
2014-03-27 05:54:36 +01:00
|
|
|
}
|
2011-02-26 00:42:52 +01:00
|
|
|
}
|
2014-03-27 05:54:37 +01:00
|
|
|
rcu_read_unlock();
|
2011-02-26 00:42:52 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-09-03 08:38:32 +02:00
|
|
|
struct tipc_node *tipc_node_create(u32 addr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
2011-02-26 00:42:52 +01:00
|
|
|
struct tipc_node *n_ptr, *temp_node;
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2014-03-27 05:54:36 +01:00
|
|
|
spin_lock_bh(&node_list_lock);
|
2008-05-21 23:53:00 +02:00
|
|
|
|
2010-12-31 19:59:23 +01:00
|
|
|
n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
|
2006-06-26 08:52:17 +02:00
|
|
|
if (!n_ptr) {
|
2014-03-27 05:54:36 +01:00
|
|
|
spin_unlock_bh(&node_list_lock);
|
2012-06-29 06:16:37 +02:00
|
|
|
pr_warn("Node creation failed, no memory\n");
|
2006-06-26 08:52:17 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
n_ptr->addr = addr;
|
2010-12-31 19:59:18 +01:00
|
|
|
spin_lock_init(&n_ptr->lock);
|
2011-02-26 00:42:52 +01:00
|
|
|
INIT_HLIST_NODE(&n_ptr->hash);
|
|
|
|
INIT_LIST_HEAD(&n_ptr->list);
|
2006-06-26 08:52:17 +02:00
|
|
|
INIT_LIST_HEAD(&n_ptr->nsub);
|
2010-12-31 19:59:19 +01:00
|
|
|
|
2014-03-27 05:54:37 +01:00
|
|
|
hlist_add_head_rcu(&n_ptr->hash, &node_htable[tipc_hashfn(addr)]);
|
2011-02-26 00:42:52 +01:00
|
|
|
|
2014-03-27 05:54:37 +01:00
|
|
|
list_for_each_entry_rcu(temp_node, &tipc_node_list, list) {
|
2011-02-26 00:42:52 +01:00
|
|
|
if (n_ptr->addr < temp_node->addr)
|
|
|
|
break;
|
|
|
|
}
|
2014-03-27 05:54:37 +01:00
|
|
|
list_add_tail_rcu(&n_ptr->list, &temp_node->list);
|
2014-05-08 02:54:39 +02:00
|
|
|
n_ptr->action_flags = TIPC_WAIT_PEER_LINKS_DOWN;
|
2011-10-28 22:26:41 +02:00
|
|
|
n_ptr->signature = INVALID_NODE_SIG;
|
2011-02-26 00:42:52 +01:00
|
|
|
|
|
|
|
tipc_num_nodes++;
|
2006-06-26 08:52:17 +02:00
|
|
|
|
2014-03-27 05:54:36 +01:00
|
|
|
spin_unlock_bh(&node_list_lock);
|
2006-01-02 19:04:38 +01:00
|
|
|
return n_ptr;
|
|
|
|
}
|
|
|
|
|
2014-03-27 05:54:36 +01:00
|
|
|
static void tipc_node_delete(struct tipc_node *n_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
2014-03-27 05:54:37 +01:00
|
|
|
list_del_rcu(&n_ptr->list);
|
|
|
|
hlist_del_rcu(&n_ptr->hash);
|
|
|
|
kfree_rcu(n_ptr, rcu);
|
2010-12-31 19:59:19 +01:00
|
|
|
|
2011-02-26 00:42:52 +01:00
|
|
|
tipc_num_nodes--;
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2014-03-27 05:54:36 +01:00
|
|
|
void tipc_node_stop(void)
|
|
|
|
{
|
|
|
|
struct tipc_node *node, *t_node;
|
|
|
|
|
|
|
|
spin_lock_bh(&node_list_lock);
|
|
|
|
list_for_each_entry_safe(node, t_node, &tipc_node_list, list)
|
|
|
|
tipc_node_delete(node);
|
|
|
|
spin_unlock_bh(&node_list_lock);
|
|
|
|
}
|
|
|
|
|
2006-01-02 19:04:38 +01:00
|
|
|
/**
|
2006-01-18 00:38:21 +01:00
|
|
|
* tipc_node_link_up - handle addition of link
|
2007-02-09 15:25:21 +01:00
|
|
|
*
|
2006-01-02 19:04:38 +01:00
|
|
|
* Link becomes active (alone or shared) or standby, depending on its priority.
|
|
|
|
*/
|
2011-12-30 02:58:42 +01:00
|
|
|
void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
2011-12-30 02:58:42 +01:00
|
|
|
struct tipc_link **active = &n_ptr->active_links[0];
|
2014-04-24 16:26:46 +02:00
|
|
|
u32 addr = n_ptr->addr;
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2006-06-26 08:52:50 +02:00
|
|
|
n_ptr->working_links++;
|
2014-04-24 16:26:46 +02:00
|
|
|
tipc_nametbl_publish(TIPC_LINK_STATE, addr, addr, TIPC_NODE_SCOPE,
|
|
|
|
l_ptr->bearer_id, addr);
|
2012-06-29 06:16:37 +02:00
|
|
|
pr_info("Established link <%s> on network plane %c\n",
|
tipc: decouple the relationship between bearer and link
Currently on both paths of message transmission and reception, the
read lock of tipc_net_lock must be held before bearer is accessed,
while the write lock of tipc_net_lock has to be taken before bearer
is configured. Although it can ensure that bearer is always valid on
the two data paths, link and bearer is closely bound together.
So as the part of effort of removing tipc_net_lock, the locking
policy of bearer protection will be adjusted as below: on the two
data paths, RCU is used, and on the configuration path of bearer,
RTNL lock is applied.
Now RCU just covers the path of message reception. To make it possible
to protect the path of message transmission with RCU, link should not
use its stored bearer pointer to access bearer, but it should use the
bearer identity of its attached bearer as index to get bearer instance
from bearer_list array, which can help us decouple the relationship
between bearer and link. As a result, bearer on the path of message
transmission can be safely protected by RCU when we access bearer_list
array within RCU lock protection.
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Tested-by: Erik Hugne <erik.hugne@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-04-21 04:55:46 +02:00
|
|
|
l_ptr->name, l_ptr->net_plane);
|
2007-02-09 15:25:21 +01:00
|
|
|
|
2006-01-02 19:04:38 +01:00
|
|
|
if (!active[0]) {
|
|
|
|
active[0] = active[1] = l_ptr;
|
|
|
|
node_established_contact(n_ptr);
|
2014-06-26 03:41:33 +02:00
|
|
|
goto exit;
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
2007-02-09 15:25:21 +01:00
|
|
|
if (l_ptr->priority < active[0]->priority) {
|
2012-06-29 06:16:37 +02:00
|
|
|
pr_info("New link <%s> becomes standby\n", l_ptr->name);
|
2014-06-26 03:41:33 +02:00
|
|
|
goto exit;
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
2014-02-18 09:06:46 +01:00
|
|
|
tipc_link_dup_queue_xmit(active[0], l_ptr);
|
2007-02-09 15:25:21 +01:00
|
|
|
if (l_ptr->priority == active[0]->priority) {
|
2006-01-02 19:04:38 +01:00
|
|
|
active[0] = l_ptr;
|
2014-06-26 03:41:33 +02:00
|
|
|
goto exit;
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
2012-06-29 06:16:37 +02:00
|
|
|
pr_info("Old link <%s> becomes standby\n", active[0]->name);
|
2006-06-26 08:52:17 +02:00
|
|
|
if (active[1] != active[0])
|
2012-06-29 06:16:37 +02:00
|
|
|
pr_info("Old link <%s> becomes standby\n", active[1]->name);
|
2006-01-02 19:04:38 +01:00
|
|
|
active[0] = active[1] = l_ptr;
|
2014-06-26 03:41:33 +02:00
|
|
|
exit:
|
|
|
|
/* Leave room for changeover header when returning 'mtu' to users: */
|
|
|
|
n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
|
|
|
|
n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* node_select_active_links - select active link
|
|
|
|
*/
|
2008-09-03 08:38:32 +02:00
|
|
|
static void node_select_active_links(struct tipc_node *n_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
2011-12-30 02:58:42 +01:00
|
|
|
struct tipc_link **active = &n_ptr->active_links[0];
|
2006-01-02 19:04:38 +01:00
|
|
|
u32 i;
|
|
|
|
u32 highest_prio = 0;
|
|
|
|
|
2007-02-09 15:25:21 +01:00
|
|
|
active[0] = active[1] = NULL;
|
2006-01-02 19:04:38 +01:00
|
|
|
|
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
2011-12-30 02:58:42 +01:00
|
|
|
struct tipc_link *l_ptr = n_ptr->links[i];
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2006-01-18 00:38:21 +01:00
|
|
|
if (!l_ptr || !tipc_link_is_up(l_ptr) ||
|
2006-01-02 19:04:38 +01:00
|
|
|
(l_ptr->priority < highest_prio))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (l_ptr->priority > highest_prio) {
|
2007-02-09 15:25:21 +01:00
|
|
|
highest_prio = l_ptr->priority;
|
2006-01-02 19:04:38 +01:00
|
|
|
active[0] = active[1] = l_ptr;
|
|
|
|
} else {
|
|
|
|
active[1] = l_ptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-01-18 00:38:21 +01:00
|
|
|
* tipc_node_link_down - handle loss of link
|
2006-01-02 19:04:38 +01:00
|
|
|
*/
|
2011-12-30 02:58:42 +01:00
|
|
|
void tipc_node_link_down(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
2011-12-30 02:58:42 +01:00
|
|
|
struct tipc_link **active;
|
2014-04-24 16:26:46 +02:00
|
|
|
u32 addr = n_ptr->addr;
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2006-06-26 08:52:50 +02:00
|
|
|
n_ptr->working_links--;
|
2014-04-24 16:26:46 +02:00
|
|
|
tipc_nametbl_withdraw(TIPC_LINK_STATE, addr, l_ptr->bearer_id, addr);
|
2006-06-26 08:52:50 +02:00
|
|
|
|
2006-01-18 00:38:21 +01:00
|
|
|
if (!tipc_link_is_active(l_ptr)) {
|
2012-06-29 06:16:37 +02:00
|
|
|
pr_info("Lost standby link <%s> on network plane %c\n",
|
tipc: decouple the relationship between bearer and link
Currently on both paths of message transmission and reception, the
read lock of tipc_net_lock must be held before bearer is accessed,
while the write lock of tipc_net_lock has to be taken before bearer
is configured. Although it can ensure that bearer is always valid on
the two data paths, link and bearer is closely bound together.
So as the part of effort of removing tipc_net_lock, the locking
policy of bearer protection will be adjusted as below: on the two
data paths, RCU is used, and on the configuration path of bearer,
RTNL lock is applied.
Now RCU just covers the path of message reception. To make it possible
to protect the path of message transmission with RCU, link should not
use its stored bearer pointer to access bearer, but it should use the
bearer identity of its attached bearer as index to get bearer instance
from bearer_list array, which can help us decouple the relationship
between bearer and link. As a result, bearer on the path of message
transmission can be safely protected by RCU when we access bearer_list
array within RCU lock protection.
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Tested-by: Erik Hugne <erik.hugne@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-04-21 04:55:46 +02:00
|
|
|
l_ptr->name, l_ptr->net_plane);
|
2006-01-02 19:04:38 +01:00
|
|
|
return;
|
|
|
|
}
|
2012-06-29 06:16:37 +02:00
|
|
|
pr_info("Lost link <%s> on network plane %c\n",
|
tipc: decouple the relationship between bearer and link
Currently on both paths of message transmission and reception, the
read lock of tipc_net_lock must be held before bearer is accessed,
while the write lock of tipc_net_lock has to be taken before bearer
is configured. Although it can ensure that bearer is always valid on
the two data paths, link and bearer is closely bound together.
So as the part of effort of removing tipc_net_lock, the locking
policy of bearer protection will be adjusted as below: on the two
data paths, RCU is used, and on the configuration path of bearer,
RTNL lock is applied.
Now RCU just covers the path of message reception. To make it possible
to protect the path of message transmission with RCU, link should not
use its stored bearer pointer to access bearer, but it should use the
bearer identity of its attached bearer as index to get bearer instance
from bearer_list array, which can help us decouple the relationship
between bearer and link. As a result, bearer on the path of message
transmission can be safely protected by RCU when we access bearer_list
array within RCU lock protection.
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Tested-by: Erik Hugne <erik.hugne@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-04-21 04:55:46 +02:00
|
|
|
l_ptr->name, l_ptr->net_plane);
|
2006-01-02 19:04:38 +01:00
|
|
|
|
|
|
|
active = &n_ptr->active_links[0];
|
|
|
|
if (active[0] == l_ptr)
|
|
|
|
active[0] = active[1];
|
|
|
|
if (active[1] == l_ptr)
|
|
|
|
active[1] = active[0];
|
|
|
|
if (active[0] == l_ptr)
|
|
|
|
node_select_active_links(n_ptr);
|
2007-02-09 15:25:21 +01:00
|
|
|
if (tipc_node_is_up(n_ptr))
|
2014-01-07 23:02:41 +01:00
|
|
|
tipc_link_failover_send_queue(l_ptr);
|
2007-02-09 15:25:21 +01:00
|
|
|
else
|
2006-01-02 19:04:38 +01:00
|
|
|
node_lost_contact(n_ptr);
|
2014-06-26 03:41:33 +02:00
|
|
|
|
|
|
|
/* Leave room for changeover header when returning 'mtu' to users: */
|
|
|
|
if (active[0]) {
|
|
|
|
n_ptr->act_mtus[0] = active[0]->max_pkt - INT_H_SIZE;
|
|
|
|
n_ptr->act_mtus[1] = active[1]->max_pkt - INT_H_SIZE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Loopback link went down? No fragmentation needed from now on. */
|
|
|
|
if (n_ptr->addr == tipc_own_addr) {
|
|
|
|
n_ptr->act_mtus[0] = MAX_MSG_SIZE;
|
|
|
|
n_ptr->act_mtus[1] = MAX_MSG_SIZE;
|
|
|
|
}
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2011-02-28 16:36:21 +01:00
|
|
|
int tipc_node_active_links(struct tipc_node *n_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
2010-08-17 13:00:12 +02:00
|
|
|
return n_ptr->active_links[0] != NULL;
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2008-09-03 08:38:32 +02:00
|
|
|
int tipc_node_is_up(struct tipc_node *n_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
2011-02-28 16:36:21 +01:00
|
|
|
return tipc_node_active_links(n_ptr);
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2011-12-30 02:58:42 +01:00
|
|
|
void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
tipc: decouple the relationship between bearer and link
Currently on both paths of message transmission and reception, the
read lock of tipc_net_lock must be held before bearer is accessed,
while the write lock of tipc_net_lock has to be taken before bearer
is configured. Although it can ensure that bearer is always valid on
the two data paths, link and bearer is closely bound together.
So as the part of effort of removing tipc_net_lock, the locking
policy of bearer protection will be adjusted as below: on the two
data paths, RCU is used, and on the configuration path of bearer,
RTNL lock is applied.
Now RCU just covers the path of message reception. To make it possible
to protect the path of message transmission with RCU, link should not
use its stored bearer pointer to access bearer, but it should use the
bearer identity of its attached bearer as index to get bearer instance
from bearer_list array, which can help us decouple the relationship
between bearer and link. As a result, bearer on the path of message
transmission can be safely protected by RCU when we access bearer_list
array within RCU lock protection.
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Tested-by: Erik Hugne <erik.hugne@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-04-21 04:55:46 +02:00
|
|
|
n_ptr->links[l_ptr->bearer_id] = l_ptr;
|
2014-03-27 05:54:39 +01:00
|
|
|
spin_lock_bh(&node_list_lock);
|
|
|
|
tipc_num_links++;
|
|
|
|
spin_unlock_bh(&node_list_lock);
|
2011-02-28 17:32:27 +01:00
|
|
|
n_ptr->link_cnt++;
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2011-12-30 02:58:42 +01:00
|
|
|
void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
tipc: delay delete of link when failover is needed
When a bearer is disabled, all its attached links are deleted.
Ideally, we should do link failover to redundant links on other bearers,
if there are any, in such cases. This would be consistent with current
behavior when a link is reset, but not deleted. However, due to the
complexity involved, and the (wrongly) perceived low demand for this
feature, it was never implemented until now.
We mark the doomed link for deletion with a new flag, but wait until the
failover process is finished before we actually delete it. With the
improved link tunnelling/failover code introduced earlier in this commit
series, it is now easy to identify a spot in the code where the failover
is finished and it is safe to delete the marked link. Moreover, the test
for the flag and the deletion can be done synchronously, and outside the
most time critical data path.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 23:29:16 +01:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
2014-02-14 22:40:43 +01:00
|
|
|
if (l_ptr != n_ptr->links[i])
|
|
|
|
continue;
|
|
|
|
n_ptr->links[i] = NULL;
|
2014-03-27 05:54:39 +01:00
|
|
|
spin_lock_bh(&node_list_lock);
|
|
|
|
tipc_num_links--;
|
|
|
|
spin_unlock_bh(&node_list_lock);
|
2014-02-14 22:40:43 +01:00
|
|
|
n_ptr->link_cnt--;
|
tipc: delay delete of link when failover is needed
When a bearer is disabled, all its attached links are deleted.
Ideally, we should do link failover to redundant links on other bearers,
if there are any, in such cases. This would be consistent with current
behavior when a link is reset, but not deleted. However, due to the
complexity involved, and the (wrongly) perceived low demand for this
feature, it was never implemented until now.
We mark the doomed link for deletion with a new flag, but wait until the
failover process is finished before we actually delete it. With the
improved link tunnelling/failover code introduced earlier in this commit
series, it is now easy to identify a spot in the code where the failover
is finished and it is safe to delete the marked link. Moreover, the test
for the flag and the deletion can be done synchronously, and outside the
most time critical data path.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 23:29:16 +01:00
|
|
|
}
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2008-09-03 08:38:32 +02:00
|
|
|
static void node_established_contact(struct tipc_node *n_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
2014-05-08 02:54:39 +02:00
|
|
|
n_ptr->action_flags |= TIPC_NOTIFY_NODE_UP;
|
tipc: introduce message to synchronize broadcast link
Upon establishing a first link between two nodes, there is
currently a risk that the two endpoints will disagree on exactly
which sequence number reception and acknowleding of broadcast
packets should start.
The following scenarios may happen:
1: Node A sends an ACTIVATE message to B, telling it to start acking
packets from sequence number N.
2: Node A sends out broadcast N, but does not expect an acknowledge
from B, since B is not yet in its broadcast receiver's list.
3: Node A receives ACK for N from all nodes except B, and releases
packet N.
4: Node B receives the ACTIVATE, activates its link endpoint, and
stores the value N as sequence number of first expected packet.
5: Node B sends a NAME_DISTR message to A.
6: Node A receives the NAME_DISTR message, and activates its endpoint.
At this moment B is added to A's broadcast receiver's set.
Node A also sets sequence number 0 as the first broadcast packet
to be received from B.
7: Node A sends broadcast N+1.
8: B receives N+1, determines there is a gap in the sequence, since
it is expecting N, and sends a NACK for N back to A.
9: Node A has already released N, so no retransmission is possible.
The broadcast link in direction A->B is stale.
In addition to, or instead of, 7-9 above, the following may happen:
10: Node B sends broadcast M > 0 to A.
11: Node A receives M, falsely decides there must be a gap, since
it is expecting packet 0, and asks for retransmission of packets
[0,M-1].
12: Node B has already released these packets, so the broadcast
link is stale in direction B->A.
We solve this problem by introducing a new unicast message type,
BCAST_PROTOCOL/STATE, to convey the sequence number of the next
sent broadcast packet to the other endpoint, at exactly the moment
that endpoint is added to the own node's broadcast receivers list,
and before any other unicast messages are permitted to be sent.
Furthermore, we don't allow any node to start receiving and
processing broadcast packets until this new synchronization
message has been received.
To maintain backwards compatibility, we still open up for
broadcast reception if we receive a NAME_DISTR message without
any preceding broadcast sync message. In this case, we must
assume that the other end has an older code version, and will
never send out the new synchronization message. Hence, for mixed
old and new nodes, the issue arising in 7-12 of the above may
happen with the same probability as before.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2012-11-16 06:51:31 +01:00
|
|
|
n_ptr->bclink.oos_state = 0;
|
2012-11-16 06:51:29 +01:00
|
|
|
n_ptr->bclink.acked = tipc_bclink_get_last_sent();
|
|
|
|
tipc_bclink_add_node(n_ptr->addr);
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2008-09-03 08:38:32 +02:00
|
|
|
static void node_lost_contact(struct tipc_node *n_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
|
|
|
char addr_string[16];
|
|
|
|
u32 i;
|
|
|
|
|
2012-06-29 06:16:37 +02:00
|
|
|
pr_info("Lost contact with %s\n",
|
|
|
|
tipc_addr_string_fill(addr_string, n_ptr->addr));
|
2011-04-07 17:58:08 +02:00
|
|
|
|
|
|
|
/* Flush broadcast link info associated with lost node */
|
2012-11-16 06:51:30 +01:00
|
|
|
if (n_ptr->bclink.recv_permitted) {
|
2013-12-11 05:45:38 +01:00
|
|
|
kfree_skb_list(n_ptr->bclink.deferred_head);
|
tipc: Major redesign of broadcast link ACK/NACK algorithms
Completely redesigns broadcast link ACK and NACK mechanisms to prevent
spurious retransmit requests in dual LAN networks, and to prevent the
broadcast link from stalling due to the failure of a receiving node to
acknowledge receiving a broadcast message or request its retransmission.
Note: These changes only impact the timing of when ACK and NACK messages
are sent, and not the basic broadcast link protocol itself, so inter-
operability with nodes using the "classic" algorithms is maintained.
The revised algorithms are as follows:
1) An explicit ACK message is still sent after receiving 16 in-sequence
messages, and implicit ACK information continues to be carried in other
unicast link message headers (including link state messages). However,
the timing of explicit ACKs is now based on the receiving node's absolute
network address rather than its relative network address to ensure that
the failure of another node does not delay the ACK beyond its 16 message
target.
2) A NACK message is now typically sent only when a message gap persists
for two consecutive incoming link state messages; this ensures that a
suspected gap is not confirmed until both LANs in a dual LAN network have
had an opportunity to deliver the message, thereby preventing spurious NACKs.
A NACK message can also be generated by the arrival of a single link state
message, if the deferred queue is so big that the current message gap
cannot be the result of "normal" mis-ordering due to the use of dual LANs
(or one LAN using a bonded interface). Since link state messages typically
arrive at different nodes at different times the problem of multiple nodes
issuing identical NACKs simultaneously is inherently avoided.
3) Nodes continue to "peek" at NACK messages sent by other nodes. If
another node requests retransmission of a message gap suspected (but not
yet confirmed) by the peeking node, the peeking node forgets about the
gap and does not generate a duplicate retransmit request. (If the peeking
node subsequently fails to receive the lost message, later link state
messages will cause it to rediscover and confirm the gap and send another
NACK.)
4) Message gap "equality" is now determined by the start of the gap only.
This is sufficient to deal with the most common cases of message loss,
and eliminates the need for complex end of gap computations.
5) A peeking node no longer tries to determine whether it should send a
complementary NACK, since the most common cases of message loss don't
require it to be sent. Consequently, the node no longer examines the
"broadcast tag" field of a NACK message when peeking.
Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2011-10-27 20:17:53 +02:00
|
|
|
n_ptr->bclink.deferred_size = 0;
|
2011-04-07 17:58:08 +02:00
|
|
|
|
2014-05-14 11:39:12 +02:00
|
|
|
if (n_ptr->bclink.reasm_buf) {
|
|
|
|
kfree_skb(n_ptr->bclink.reasm_buf);
|
|
|
|
n_ptr->bclink.reasm_buf = NULL;
|
2011-04-07 17:58:08 +02:00
|
|
|
}
|
|
|
|
|
2011-10-24 17:18:12 +02:00
|
|
|
tipc_bclink_remove_node(n_ptr->addr);
|
2011-10-24 21:26:24 +02:00
|
|
|
tipc_bclink_acknowledge(n_ptr, INVALID_LINK_SEQ);
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2012-11-16 06:51:30 +01:00
|
|
|
n_ptr->bclink.recv_permitted = false;
|
2011-04-07 17:58:08 +02:00
|
|
|
}
|
2006-01-02 19:04:38 +01:00
|
|
|
|
|
|
|
/* Abort link changeover */
|
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
2011-12-30 02:58:42 +01:00
|
|
|
struct tipc_link *l_ptr = n_ptr->links[i];
|
2007-02-09 15:25:21 +01:00
|
|
|
if (!l_ptr)
|
2006-01-02 19:04:38 +01:00
|
|
|
continue;
|
|
|
|
l_ptr->reset_checkpoint = l_ptr->next_in_no;
|
|
|
|
l_ptr->exp_msg_count = 0;
|
2006-01-18 00:38:21 +01:00
|
|
|
tipc_link_reset_fragments(l_ptr);
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2014-05-08 02:54:40 +02:00
|
|
|
n_ptr->action_flags &= ~TIPC_WAIT_OWN_LINKS_DOWN;
|
|
|
|
|
2014-05-05 02:56:13 +02:00
|
|
|
/* Notify subscribers and prevent re-contact with node until
|
|
|
|
* cleanup is done.
|
|
|
|
*/
|
2014-05-08 02:54:40 +02:00
|
|
|
n_ptr->action_flags |= TIPC_WAIT_PEER_LINKS_DOWN |
|
|
|
|
TIPC_NOTIFY_NODE_DOWN;
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
|
|
|
|
2006-01-18 00:38:21 +01:00
|
|
|
struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
|
|
|
u32 domain;
|
|
|
|
struct sk_buff *buf;
|
2008-09-03 08:38:32 +02:00
|
|
|
struct tipc_node *n_ptr;
|
2007-02-09 15:25:21 +01:00
|
|
|
struct tipc_node_info node_info;
|
2006-06-29 21:33:20 +02:00
|
|
|
u32 payload_size;
|
2006-01-02 19:04:38 +01:00
|
|
|
|
|
|
|
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
|
2006-01-18 00:38:21 +01:00
|
|
|
return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2006-11-08 09:19:09 +01:00
|
|
|
domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
|
2006-01-18 00:38:21 +01:00
|
|
|
if (!tipc_addr_domain_valid(domain))
|
|
|
|
return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
|
|
|
" (network address)");
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2014-03-27 05:54:36 +01:00
|
|
|
spin_lock_bh(&node_list_lock);
|
2011-02-26 00:42:52 +01:00
|
|
|
if (!tipc_num_nodes) {
|
2014-03-27 05:54:36 +01:00
|
|
|
spin_unlock_bh(&node_list_lock);
|
2007-02-09 15:25:21 +01:00
|
|
|
return tipc_cfg_reply_none();
|
2008-07-15 07:44:58 +02:00
|
|
|
}
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2010-12-31 19:59:17 +01:00
|
|
|
/* For now, get space for all other nodes */
|
2011-02-26 00:42:52 +01:00
|
|
|
payload_size = TLV_SPACE(sizeof(node_info)) * tipc_num_nodes;
|
2008-07-15 07:44:58 +02:00
|
|
|
if (payload_size > 32768u) {
|
2014-03-27 05:54:36 +01:00
|
|
|
spin_unlock_bh(&node_list_lock);
|
2006-06-29 21:33:20 +02:00
|
|
|
return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
|
|
|
|
" (too many nodes)");
|
2008-07-15 07:44:58 +02:00
|
|
|
}
|
2014-03-27 05:54:38 +01:00
|
|
|
spin_unlock_bh(&node_list_lock);
|
|
|
|
|
2006-06-29 21:33:20 +02:00
|
|
|
buf = tipc_cfg_reply_alloc(payload_size);
|
2014-03-27 05:54:38 +01:00
|
|
|
if (!buf)
|
2006-01-02 19:04:38 +01:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Add TLVs for all nodes in scope */
|
2014-03-27 05:54:37 +01:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) {
|
2011-02-26 00:42:52 +01:00
|
|
|
if (!tipc_in_scope(domain, n_ptr->addr))
|
2006-01-02 19:04:38 +01:00
|
|
|
continue;
|
2007-02-09 15:25:21 +01:00
|
|
|
node_info.addr = htonl(n_ptr->addr);
|
|
|
|
node_info.up = htonl(tipc_node_is_up(n_ptr));
|
|
|
|
tipc_cfg_append_tlv(buf, TIPC_TLV_NODE_INFO,
|
2006-01-18 00:38:21 +01:00
|
|
|
&node_info, sizeof(node_info));
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
2014-03-27 05:54:37 +01:00
|
|
|
rcu_read_unlock();
|
2006-01-02 19:04:38 +01:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2006-01-18 00:38:21 +01:00
|
|
|
struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
|
2006-01-02 19:04:38 +01:00
|
|
|
{
|
|
|
|
u32 domain;
|
|
|
|
struct sk_buff *buf;
|
2008-09-03 08:38:32 +02:00
|
|
|
struct tipc_node *n_ptr;
|
2007-02-09 15:25:21 +01:00
|
|
|
struct tipc_link_info link_info;
|
2006-06-29 21:33:20 +02:00
|
|
|
u32 payload_size;
|
2006-01-02 19:04:38 +01:00
|
|
|
|
|
|
|
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
|
2006-01-18 00:38:21 +01:00
|
|
|
return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2006-11-08 09:19:09 +01:00
|
|
|
domain = ntohl(*(__be32 *)TLV_DATA(req_tlv_area));
|
2006-01-18 00:38:21 +01:00
|
|
|
if (!tipc_addr_domain_valid(domain))
|
|
|
|
return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
|
|
|
|
" (network address)");
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2011-11-08 19:48:28 +01:00
|
|
|
if (!tipc_own_addr)
|
2007-02-09 15:25:21 +01:00
|
|
|
return tipc_cfg_reply_none();
|
|
|
|
|
2014-03-27 05:54:36 +01:00
|
|
|
spin_lock_bh(&node_list_lock);
|
tipc: Major redesign of broadcast link ACK/NACK algorithms
Completely redesigns broadcast link ACK and NACK mechanisms to prevent
spurious retransmit requests in dual LAN networks, and to prevent the
broadcast link from stalling due to the failure of a receiving node to
acknowledge receiving a broadcast message or request its retransmission.
Note: These changes only impact the timing of when ACK and NACK messages
are sent, and not the basic broadcast link protocol itself, so inter-
operability with nodes using the "classic" algorithms is maintained.
The revised algorithms are as follows:
1) An explicit ACK message is still sent after receiving 16 in-sequence
messages, and implicit ACK information continues to be carried in other
unicast link message headers (including link state messages). However,
the timing of explicit ACKs is now based on the receiving node's absolute
network address rather than its relative network address to ensure that
the failure of another node does not delay the ACK beyond its 16 message
target.
2) A NACK message is now typically sent only when a message gap persists
for two consecutive incoming link state messages; this ensures that a
suspected gap is not confirmed until both LANs in a dual LAN network have
had an opportunity to deliver the message, thereby preventing spurious NACKs.
A NACK message can also be generated by the arrival of a single link state
message, if the deferred queue is so big that the current message gap
cannot be the result of "normal" mis-ordering due to the use of dual LANs
(or one LAN using a bonded interface). Since link state messages typically
arrive at different nodes at different times the problem of multiple nodes
issuing identical NACKs simultaneously is inherently avoided.
3) Nodes continue to "peek" at NACK messages sent by other nodes. If
another node requests retransmission of a message gap suspected (but not
yet confirmed) by the peeking node, the peeking node forgets about the
gap and does not generate a duplicate retransmit request. (If the peeking
node subsequently fails to receive the lost message, later link state
messages will cause it to rediscover and confirm the gap and send another
NACK.)
4) Message gap "equality" is now determined by the start of the gap only.
This is sufficient to deal with the most common cases of message loss,
and eliminates the need for complex end of gap computations.
5) A peeking node no longer tries to determine whether it should send a
complementary NACK, since the most common cases of message loss don't
require it to be sent. Consequently, the node no longer examines the
"broadcast tag" field of a NACK message when peeking.
Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2011-10-27 20:17:53 +02:00
|
|
|
/* Get space for all unicast links + broadcast link */
|
2014-03-27 05:54:39 +01:00
|
|
|
payload_size = TLV_SPACE((sizeof(link_info)) * (tipc_num_links + 1));
|
2008-07-15 07:44:58 +02:00
|
|
|
if (payload_size > 32768u) {
|
2014-03-27 05:54:36 +01:00
|
|
|
spin_unlock_bh(&node_list_lock);
|
2006-06-29 21:33:20 +02:00
|
|
|
return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
|
|
|
|
" (too many links)");
|
2008-07-15 07:44:58 +02:00
|
|
|
}
|
2014-03-27 05:54:39 +01:00
|
|
|
spin_unlock_bh(&node_list_lock);
|
|
|
|
|
2006-06-29 21:33:20 +02:00
|
|
|
buf = tipc_cfg_reply_alloc(payload_size);
|
2014-03-27 05:54:39 +01:00
|
|
|
if (!buf)
|
2006-01-02 19:04:38 +01:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Add TLV for broadcast link */
|
2011-02-23 17:44:49 +01:00
|
|
|
link_info.dest = htonl(tipc_cluster_mask(tipc_own_addr));
|
2007-02-09 15:25:21 +01:00
|
|
|
link_info.up = htonl(1);
|
2009-03-19 03:11:29 +01:00
|
|
|
strlcpy(link_info.str, tipc_bclink_name, TIPC_MAX_LINK_NAME);
|
2006-01-18 00:38:21 +01:00
|
|
|
tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info));
|
2006-01-02 19:04:38 +01:00
|
|
|
|
|
|
|
/* Add TLVs for any other links in scope */
|
2014-03-27 05:54:37 +01:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) {
|
2007-02-09 15:25:21 +01:00
|
|
|
u32 i;
|
2006-01-02 19:04:38 +01:00
|
|
|
|
2011-02-26 00:42:52 +01:00
|
|
|
if (!tipc_in_scope(domain, n_ptr->addr))
|
2006-01-02 19:04:38 +01:00
|
|
|
continue;
|
2008-07-15 07:44:58 +02:00
|
|
|
tipc_node_lock(n_ptr);
|
2007-02-09 15:25:21 +01:00
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
|
|
|
if (!n_ptr->links[i])
|
|
|
|
continue;
|
|
|
|
link_info.dest = htonl(n_ptr->addr);
|
|
|
|
link_info.up = htonl(tipc_link_is_up(n_ptr->links[i]));
|
|
|
|
strcpy(link_info.str, n_ptr->links[i]->name);
|
|
|
|
tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO,
|
2006-01-18 00:38:21 +01:00
|
|
|
&link_info, sizeof(link_info));
|
2007-02-09 15:25:21 +01:00
|
|
|
}
|
2008-07-15 07:44:58 +02:00
|
|
|
tipc_node_unlock(n_ptr);
|
2006-01-02 19:04:38 +01:00
|
|
|
}
|
2014-03-27 05:54:37 +01:00
|
|
|
rcu_read_unlock();
|
2006-01-02 19:04:38 +01:00
|
|
|
return buf;
|
|
|
|
}
|
2014-04-24 16:26:47 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* tipc_node_get_linkname - get the name of a link
|
|
|
|
*
|
|
|
|
* @bearer_id: id of the bearer
|
|
|
|
* @node: peer node address
|
|
|
|
* @linkname: link name output buffer
|
|
|
|
*
|
|
|
|
* Returns 0 on success
|
|
|
|
*/
|
|
|
|
int tipc_node_get_linkname(u32 bearer_id, u32 addr, char *linkname, size_t len)
|
|
|
|
{
|
|
|
|
struct tipc_link *link;
|
|
|
|
struct tipc_node *node = tipc_node_find(addr);
|
|
|
|
|
2014-04-28 08:20:09 +02:00
|
|
|
if ((bearer_id >= MAX_BEARERS) || !node)
|
2014-04-24 16:26:47 +02:00
|
|
|
return -EINVAL;
|
|
|
|
tipc_node_lock(node);
|
|
|
|
link = node->links[bearer_id];
|
|
|
|
if (link) {
|
|
|
|
strncpy(linkname, link->name, len);
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2014-05-05 02:56:12 +02:00
|
|
|
|
|
|
|
void tipc_node_unlock(struct tipc_node *node)
|
|
|
|
{
|
|
|
|
LIST_HEAD(nsub_list);
|
2014-05-05 02:56:14 +02:00
|
|
|
u32 addr = 0;
|
2014-05-05 02:56:12 +02:00
|
|
|
|
2014-05-08 02:54:39 +02:00
|
|
|
if (likely(!node->action_flags)) {
|
2014-05-05 02:56:12 +02:00
|
|
|
spin_unlock_bh(&node->lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-05-08 02:54:39 +02:00
|
|
|
if (node->action_flags & TIPC_NOTIFY_NODE_DOWN) {
|
2014-05-05 02:56:12 +02:00
|
|
|
list_replace_init(&node->nsub, &nsub_list);
|
2014-05-08 02:54:39 +02:00
|
|
|
node->action_flags &= ~TIPC_NOTIFY_NODE_DOWN;
|
2014-05-05 02:56:12 +02:00
|
|
|
}
|
2014-05-08 02:54:39 +02:00
|
|
|
if (node->action_flags & TIPC_NOTIFY_NODE_UP) {
|
|
|
|
node->action_flags &= ~TIPC_NOTIFY_NODE_UP;
|
2014-07-17 02:40:58 +02:00
|
|
|
addr = node->addr;
|
2014-05-05 02:56:14 +02:00
|
|
|
}
|
2014-05-05 02:56:12 +02:00
|
|
|
spin_unlock_bh(&node->lock);
|
|
|
|
|
|
|
|
if (!list_empty(&nsub_list))
|
|
|
|
tipc_nodesub_notify(&nsub_list);
|
2014-07-17 02:40:58 +02:00
|
|
|
if (addr)
|
|
|
|
tipc_named_node_up(addr);
|
2014-05-05 02:56:12 +02:00
|
|
|
}
|