2006-01-03 02:04:38 +08:00
|
|
|
/*
|
|
|
|
|
* net/tipc/node.c: TIPC node management routines
|
2007-02-09 22:25:21 +08:00
|
|
|
*
|
2015-05-14 22:46:18 +08:00
|
|
|
* Copyright (c) 2000-2006, 2012-2015, Ericsson AB
|
2014-03-27 12:54:36 +08:00
|
|
|
* Copyright (c) 2005-2006, 2010-2014, Wind River Systems
|
2006-01-03 02:04:38 +08:00
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
2006-01-11 20:30:43 +08:00
|
|
|
* Redistribution and use in source and binary forms, with or without
|
2006-01-03 02:04:38 +08:00
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
|
*
|
2006-01-11 20:30:43 +08: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-03 02:04:38 +08:00
|
|
|
*
|
2006-01-11 20:30:43 +08: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-03 02:04:38 +08:00
|
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "core.h"
|
2015-02-09 16:50:18 +08:00
|
|
|
#include "link.h"
|
2006-01-03 02:04:38 +08:00
|
|
|
#include "node.h"
|
|
|
|
|
#include "name_distr.h"
|
2014-08-23 06:09:07 +08:00
|
|
|
#include "socket.h"
|
2015-05-14 22:46:13 +08:00
|
|
|
#include "bcast.h"
|
2006-01-03 02:04:38 +08:00
|
|
|
|
2008-09-03 14:38:32 +08:00
|
|
|
static void node_lost_contact(struct tipc_node *n_ptr);
|
|
|
|
|
static void node_established_contact(struct tipc_node *n_ptr);
|
2015-03-26 18:10:24 +08:00
|
|
|
static void tipc_node_delete(struct tipc_node *node);
|
2006-01-03 02:04:38 +08:00
|
|
|
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
struct tipc_sock_conn {
|
|
|
|
|
u32 port;
|
|
|
|
|
u32 peer_port;
|
|
|
|
|
u32 peer_node;
|
|
|
|
|
struct list_head list;
|
|
|
|
|
};
|
|
|
|
|
|
2014-11-20 17:29:17 +08:00
|
|
|
static const struct nla_policy tipc_nl_node_policy[TIPC_NLA_NODE_MAX + 1] = {
|
|
|
|
|
[TIPC_NLA_NODE_UNSPEC] = { .type = NLA_UNSPEC },
|
|
|
|
|
[TIPC_NLA_NODE_ADDR] = { .type = NLA_U32 },
|
|
|
|
|
[TIPC_NLA_NODE_UP] = { .type = NLA_FLAG }
|
|
|
|
|
};
|
|
|
|
|
|
2011-11-04 23:54:43 +08: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 12:49:13 +08:00
|
|
|
static unsigned int tipc_hashfn(u32 addr)
|
2011-11-04 23:54:43 +08:00
|
|
|
{
|
|
|
|
|
return addr & (NODE_HTABLE_SIZE - 1);
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-26 18:10:24 +08:00
|
|
|
static void tipc_node_kref_release(struct kref *kref)
|
|
|
|
|
{
|
|
|
|
|
struct tipc_node *node = container_of(kref, struct tipc_node, kref);
|
|
|
|
|
|
|
|
|
|
tipc_node_delete(node);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void tipc_node_put(struct tipc_node *node)
|
|
|
|
|
{
|
|
|
|
|
kref_put(&node->kref, tipc_node_kref_release);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void tipc_node_get(struct tipc_node *node)
|
|
|
|
|
{
|
|
|
|
|
kref_get(&node->kref);
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-28 03:03:24 +08:00
|
|
|
/*
|
2011-02-26 07:42:52 +08:00
|
|
|
* tipc_node_find - locate specified node object, if it exists
|
|
|
|
|
*/
|
2015-01-09 15:27:05 +08:00
|
|
|
struct tipc_node *tipc_node_find(struct net *net, u32 addr)
|
2011-02-26 07:42:52 +08:00
|
|
|
{
|
2015-01-09 15:27:05 +08:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2011-02-26 07:42:52 +08:00
|
|
|
struct tipc_node *node;
|
|
|
|
|
|
2015-01-09 15:27:10 +08:00
|
|
|
if (unlikely(!in_own_cluster_exact(net, addr)))
|
2011-02-26 07:42:52 +08:00
|
|
|
return NULL;
|
|
|
|
|
|
2014-03-27 12:54:37 +08:00
|
|
|
rcu_read_lock();
|
2015-01-09 15:27:05 +08:00
|
|
|
hlist_for_each_entry_rcu(node, &tn->node_htable[tipc_hashfn(addr)],
|
|
|
|
|
hash) {
|
2014-03-27 12:54:36 +08:00
|
|
|
if (node->addr == addr) {
|
2015-03-26 18:10:24 +08:00
|
|
|
tipc_node_get(node);
|
2014-03-27 12:54:37 +08:00
|
|
|
rcu_read_unlock();
|
2011-02-26 07:42:52 +08:00
|
|
|
return node;
|
2014-03-27 12:54:36 +08:00
|
|
|
}
|
2011-02-26 07:42:52 +08:00
|
|
|
}
|
2014-03-27 12:54:37 +08:00
|
|
|
rcu_read_unlock();
|
2011-02-26 07:42:52 +08:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
struct tipc_node *tipc_node_create(struct net *net, u32 addr)
|
2006-01-03 02:04:38 +08:00
|
|
|
{
|
2015-01-09 15:27:05 +08:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2011-02-26 07:42:52 +08:00
|
|
|
struct tipc_node *n_ptr, *temp_node;
|
2006-01-03 02:04:38 +08:00
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
spin_lock_bh(&tn->node_list_lock);
|
2015-02-03 21:59:19 +08:00
|
|
|
n_ptr = tipc_node_find(net, addr);
|
|
|
|
|
if (n_ptr)
|
|
|
|
|
goto exit;
|
2011-01-01 02:59:23 +08:00
|
|
|
n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
|
2006-06-26 14:52:17 +08:00
|
|
|
if (!n_ptr) {
|
2012-06-29 12:16:37 +08:00
|
|
|
pr_warn("Node creation failed, no memory\n");
|
2015-02-03 21:59:19 +08:00
|
|
|
goto exit;
|
2006-06-26 14:52:17 +08:00
|
|
|
}
|
|
|
|
|
n_ptr->addr = addr;
|
2015-01-09 15:27:05 +08:00
|
|
|
n_ptr->net = net;
|
2015-03-26 18:10:24 +08:00
|
|
|
kref_init(&n_ptr->kref);
|
2011-01-01 02:59:18 +08:00
|
|
|
spin_lock_init(&n_ptr->lock);
|
2011-02-26 07:42:52 +08:00
|
|
|
INIT_HLIST_NODE(&n_ptr->hash);
|
|
|
|
|
INIT_LIST_HEAD(&n_ptr->list);
|
2014-11-26 11:41:45 +08:00
|
|
|
INIT_LIST_HEAD(&n_ptr->publ_list);
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
INIT_LIST_HEAD(&n_ptr->conn_sks);
|
2015-07-17 04:54:21 +08:00
|
|
|
skb_queue_head_init(&n_ptr->bclink.namedq);
|
2015-03-14 04:08:10 +08:00
|
|
|
__skb_queue_head_init(&n_ptr->bclink.deferdq);
|
2015-01-09 15:27:05 +08:00
|
|
|
hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]);
|
|
|
|
|
list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
|
2011-02-26 07:42:52 +08:00
|
|
|
if (n_ptr->addr < temp_node->addr)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2014-03-27 12:54:37 +08:00
|
|
|
list_add_tail_rcu(&n_ptr->list, &temp_node->list);
|
2014-05-08 08:54:39 +08:00
|
|
|
n_ptr->action_flags = TIPC_WAIT_PEER_LINKS_DOWN;
|
2011-10-29 04:26:41 +08:00
|
|
|
n_ptr->signature = INVALID_NODE_SIG;
|
2015-07-17 04:54:22 +08:00
|
|
|
n_ptr->active_links[0] = INVALID_BEARER_ID;
|
|
|
|
|
n_ptr->active_links[1] = INVALID_BEARER_ID;
|
2015-03-26 18:10:24 +08:00
|
|
|
tipc_node_get(n_ptr);
|
2015-02-03 21:59:19 +08:00
|
|
|
exit:
|
2015-01-09 15:27:05 +08:00
|
|
|
spin_unlock_bh(&tn->node_list_lock);
|
2006-01-03 02:04:38 +08:00
|
|
|
return n_ptr;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-26 18:10:24 +08:00
|
|
|
static void tipc_node_delete(struct tipc_node *node)
|
2006-01-03 02:04:38 +08:00
|
|
|
{
|
2015-03-26 18:10:24 +08:00
|
|
|
list_del_rcu(&node->list);
|
|
|
|
|
hlist_del_rcu(&node->hash);
|
|
|
|
|
kfree_rcu(node, rcu);
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
void tipc_node_stop(struct net *net)
|
2014-03-27 12:54:36 +08:00
|
|
|
{
|
2015-01-09 15:27:05 +08:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2014-03-27 12:54:36 +08:00
|
|
|
struct tipc_node *node, *t_node;
|
|
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
spin_lock_bh(&tn->node_list_lock);
|
|
|
|
|
list_for_each_entry_safe(node, t_node, &tn->node_list, list)
|
2015-03-26 18:10:24 +08:00
|
|
|
tipc_node_put(node);
|
2015-01-09 15:27:05 +08:00
|
|
|
spin_unlock_bh(&tn->node_list_lock);
|
2014-03-27 12:54:36 +08:00
|
|
|
}
|
|
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
{
|
|
|
|
|
struct tipc_node *node;
|
|
|
|
|
struct tipc_sock_conn *conn;
|
2015-03-26 18:10:24 +08:00
|
|
|
int err = 0;
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
|
2015-01-09 15:27:10 +08:00
|
|
|
if (in_own_node(net, dnode))
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
return 0;
|
|
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
node = tipc_node_find(net, dnode);
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
if (!node) {
|
|
|
|
|
pr_warn("Connecting sock to node 0x%x failed\n", dnode);
|
|
|
|
|
return -EHOSTUNREACH;
|
|
|
|
|
}
|
|
|
|
|
conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
|
2015-03-26 18:10:24 +08:00
|
|
|
if (!conn) {
|
|
|
|
|
err = -EHOSTUNREACH;
|
|
|
|
|
goto exit;
|
|
|
|
|
}
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
conn->peer_node = dnode;
|
|
|
|
|
conn->port = port;
|
|
|
|
|
conn->peer_port = peer_port;
|
|
|
|
|
|
|
|
|
|
tipc_node_lock(node);
|
|
|
|
|
list_add_tail(&conn->list, &node->conn_sks);
|
|
|
|
|
tipc_node_unlock(node);
|
2015-03-26 18:10:24 +08:00
|
|
|
exit:
|
|
|
|
|
tipc_node_put(node);
|
|
|
|
|
return err;
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
}
|
|
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
{
|
|
|
|
|
struct tipc_node *node;
|
|
|
|
|
struct tipc_sock_conn *conn, *safe;
|
|
|
|
|
|
2015-01-09 15:27:10 +08:00
|
|
|
if (in_own_node(net, dnode))
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
return;
|
|
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
node = tipc_node_find(net, dnode);
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
if (!node)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
tipc_node_lock(node);
|
|
|
|
|
list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
|
|
|
|
|
if (port != conn->port)
|
|
|
|
|
continue;
|
|
|
|
|
list_del(&conn->list);
|
|
|
|
|
kfree(conn);
|
|
|
|
|
}
|
|
|
|
|
tipc_node_unlock(node);
|
2015-03-26 18:10:24 +08:00
|
|
|
tipc_node_put(node);
|
tipc: use message to abort connections when losing contact to node
In the current implementation, each 'struct tipc_node' instance keeps
a linked list of those ports/sockets that are connected to the node
represented by that struct. The purpose of this is to let the node
object know which sockets to alert when it loses contact with its peer
node, i.e., which sockets need to have their connections aborted.
This entails an unwanted direct reference from the node structure
back to the port/socket structure, and a need to grab port_lock
when we have to make an upcall to the port. We want to get rid of
this unecessary BH entry point into the socket, and also eliminate
its use of port_lock.
In this commit, we instead let the node struct keep list of "connected
socket" structs, which each represents a connected socket, but is
allocated independently by the node at the moment of connection. If
the node loses contact with its peer node, the list is traversed, and
a "connection abort" message is created for each entry in the list. The
message is sent to it respective connected socket using the ordinary
data path, and the receiving socket aborts its connections upon reception
of the message.
This enables us to get rid of the direct reference from 'struct node' to
´struct port', and another unwanted BH access point to the latter.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-23 06:09:08 +08:00
|
|
|
}
|
|
|
|
|
|
2006-01-03 02:04:38 +08:00
|
|
|
/**
|
2006-01-18 07:38:21 +08:00
|
|
|
* tipc_node_link_up - handle addition of link
|
2007-02-09 22:25:21 +08:00
|
|
|
*
|
2006-01-03 02:04:38 +08:00
|
|
|
* Link becomes active (alone or shared) or standby, depending on its priority.
|
|
|
|
|
*/
|
2015-07-17 04:54:19 +08:00
|
|
|
void tipc_node_link_up(struct tipc_node *n, int bearer_id)
|
2006-01-03 02:04:38 +08:00
|
|
|
{
|
2015-07-17 04:54:22 +08:00
|
|
|
int *slot0 = &n->active_links[0];
|
|
|
|
|
int *slot1 = &n->active_links[1];
|
|
|
|
|
struct tipc_link_entry *links = n->links;
|
|
|
|
|
struct tipc_link *l = n->links[bearer_id].link;
|
2006-01-03 02:04:38 +08:00
|
|
|
|
2015-07-17 04:54:19 +08:00
|
|
|
/* Leave room for tunnel header when returning 'mtu' to users: */
|
2015-07-17 04:54:22 +08:00
|
|
|
links[bearer_id].mtu = l->mtu - INT_H_SIZE;
|
2015-07-17 04:54:19 +08:00
|
|
|
|
|
|
|
|
n->working_links++;
|
|
|
|
|
n->action_flags |= TIPC_NOTIFY_LINK_UP;
|
|
|
|
|
n->link_id = l->peer_bearer_id << 16 | l->bearer_id;
|
2014-10-20 14:44:25 +08:00
|
|
|
|
2015-01-23 00:10:31 +08:00
|
|
|
pr_debug("Established link <%s> on network plane %c\n",
|
2015-07-17 04:54:19 +08:00
|
|
|
l->name, l->net_plane);
|
2007-02-09 22:25:21 +08:00
|
|
|
|
2015-07-17 04:54:19 +08:00
|
|
|
/* No active links ? => take both active slots */
|
2015-07-17 04:54:22 +08:00
|
|
|
if (*slot0 < 0) {
|
|
|
|
|
*slot0 = bearer_id;
|
|
|
|
|
*slot1 = bearer_id;
|
2015-07-17 04:54:19 +08:00
|
|
|
node_established_contact(n);
|
|
|
|
|
return;
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
2015-07-17 04:54:22 +08:00
|
|
|
|
|
|
|
|
/* Lower prio than current active ? => no slot */
|
|
|
|
|
if (l->priority < links[*slot0].link->priority) {
|
2015-07-17 04:54:19 +08:00
|
|
|
pr_debug("New link <%s> becomes standby\n", l->name);
|
|
|
|
|
return;
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
2015-07-17 04:54:22 +08:00
|
|
|
tipc_link_dup_queue_xmit(links[*slot0].link, l);
|
2015-07-17 04:54:19 +08:00
|
|
|
|
2015-07-17 04:54:22 +08:00
|
|
|
/* Same prio as current active ? => take one slot */
|
|
|
|
|
if (l->priority == links[*slot0].link->priority) {
|
|
|
|
|
*slot0 = bearer_id;
|
2015-07-17 04:54:19 +08:00
|
|
|
return;
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2015-07-17 04:54:22 +08:00
|
|
|
/* Higher prio than current active => take both active slots */
|
|
|
|
|
pr_debug("Old link <%s> now standby\n", links[*slot0].link->name);
|
|
|
|
|
*slot0 = bearer_id;
|
|
|
|
|
*slot1 = bearer_id;
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2006-01-18 07:38:21 +08:00
|
|
|
* tipc_node_link_down - handle loss of link
|
2006-01-03 02:04:38 +08:00
|
|
|
*/
|
2015-07-17 04:54:19 +08:00
|
|
|
void tipc_node_link_down(struct tipc_node *n, int bearer_id)
|
2006-01-03 02:04:38 +08:00
|
|
|
{
|
2015-07-17 04:54:22 +08:00
|
|
|
int *slot0 = &n->active_links[0];
|
|
|
|
|
int *slot1 = &n->active_links[1];
|
|
|
|
|
int i, highest = 0;
|
|
|
|
|
struct tipc_link *l, *_l;
|
2006-01-03 02:04:38 +08:00
|
|
|
|
2015-07-17 04:54:22 +08:00
|
|
|
l = n->links[bearer_id].link;
|
2015-07-17 04:54:19 +08:00
|
|
|
n->working_links--;
|
|
|
|
|
n->action_flags |= TIPC_NOTIFY_LINK_DOWN;
|
|
|
|
|
n->link_id = l->peer_bearer_id << 16 | l->bearer_id;
|
2006-06-26 14:52:50 +08:00
|
|
|
|
2015-01-23 00:10:31 +08:00
|
|
|
pr_debug("Lost link <%s> on network plane %c\n",
|
2015-07-17 04:54:19 +08:00
|
|
|
l->name, l->net_plane);
|
2014-06-26 09:41:33 +08:00
|
|
|
|
2015-07-17 04:54:22 +08:00
|
|
|
/* Select new active link if any available */
|
|
|
|
|
*slot0 = INVALID_BEARER_ID;
|
|
|
|
|
*slot1 = INVALID_BEARER_ID;
|
|
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
|
|
|
|
_l = n->links[i].link;
|
|
|
|
|
if (!_l || !tipc_link_is_up(_l))
|
|
|
|
|
continue;
|
|
|
|
|
if (_l->priority < highest)
|
|
|
|
|
continue;
|
|
|
|
|
if (_l->priority > highest) {
|
|
|
|
|
highest = _l->priority;
|
|
|
|
|
*slot0 = i;
|
|
|
|
|
*slot1 = i;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
*slot1 = i;
|
|
|
|
|
}
|
2015-07-17 04:54:19 +08:00
|
|
|
if (tipc_node_is_up(n))
|
|
|
|
|
tipc_link_failover_send_queue(l);
|
|
|
|
|
else
|
|
|
|
|
node_lost_contact(n);
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2015-07-17 04:54:19 +08:00
|
|
|
bool tipc_node_is_up(struct tipc_node *n)
|
2006-01-03 02:04:38 +08:00
|
|
|
{
|
2015-07-17 04:54:22 +08:00
|
|
|
return n->active_links[0] != INVALID_BEARER_ID;
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2015-07-17 04:54:20 +08:00
|
|
|
void tipc_node_check_dest(struct tipc_node *n, struct tipc_bearer *b,
|
|
|
|
|
bool *link_up, bool *addr_match,
|
|
|
|
|
struct tipc_media_addr *maddr)
|
|
|
|
|
{
|
|
|
|
|
struct tipc_link *l = n->links[b->identity].link;
|
|
|
|
|
struct tipc_media_addr *curr = &n->links[b->identity].maddr;
|
|
|
|
|
|
|
|
|
|
*link_up = l && tipc_link_is_up(l);
|
|
|
|
|
*addr_match = l && !memcmp(curr, maddr, sizeof(*maddr));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool tipc_node_update_dest(struct tipc_node *n, struct tipc_bearer *b,
|
|
|
|
|
struct tipc_media_addr *maddr)
|
|
|
|
|
{
|
|
|
|
|
struct tipc_link *l = n->links[b->identity].link;
|
|
|
|
|
struct tipc_media_addr *curr = &n->links[b->identity].maddr;
|
2015-07-17 04:54:21 +08:00
|
|
|
struct sk_buff_head *inputq = &n->links[b->identity].inputq;
|
2015-07-17 04:54:20 +08:00
|
|
|
|
|
|
|
|
if (!l)
|
2015-07-17 04:54:21 +08:00
|
|
|
l = tipc_link_create(n, b, maddr, inputq, &n->bclink.namedq);
|
2015-07-17 04:54:20 +08:00
|
|
|
if (!l)
|
|
|
|
|
return false;
|
|
|
|
|
memcpy(&l->media_addr, maddr, sizeof(*maddr));
|
|
|
|
|
memcpy(curr, maddr, sizeof(*maddr));
|
|
|
|
|
tipc_link_reset(l);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-30 09:58:42 +08:00
|
|
|
void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
|
2006-01-03 02:04:38 +08:00
|
|
|
{
|
2015-07-17 04:54:19 +08:00
|
|
|
n_ptr->links[l_ptr->bearer_id].link = l_ptr;
|
2011-03-01 00:32:27 +08:00
|
|
|
n_ptr->link_cnt++;
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2011-12-30 09:58:42 +08:00
|
|
|
void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
|
2006-01-03 02:04:38 +08: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-14 06:29:16 +08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
2015-07-17 04:54:19 +08:00
|
|
|
if (l_ptr != n_ptr->links[i].link)
|
2014-02-15 05:40:43 +08:00
|
|
|
continue;
|
2015-07-17 04:54:19 +08:00
|
|
|
n_ptr->links[i].link = NULL;
|
2014-02-15 05:40:43 +08: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-14 06:29:16 +08:00
|
|
|
}
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2008-09-03 14:38:32 +08:00
|
|
|
static void node_established_contact(struct tipc_node *n_ptr)
|
2006-01-03 02:04:38 +08:00
|
|
|
{
|
2014-05-08 08:54:39 +08: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 13:51:31 +08:00
|
|
|
n_ptr->bclink.oos_state = 0;
|
2015-01-09 15:27:07 +08:00
|
|
|
n_ptr->bclink.acked = tipc_bclink_get_last_sent(n_ptr->net);
|
|
|
|
|
tipc_bclink_add_node(n_ptr->net, n_ptr->addr);
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2008-09-03 14:38:32 +08:00
|
|
|
static void node_lost_contact(struct tipc_node *n_ptr)
|
2006-01-03 02:04:38 +08:00
|
|
|
{
|
|
|
|
|
char addr_string[16];
|
2015-02-05 21:36:42 +08:00
|
|
|
struct tipc_sock_conn *conn, *safe;
|
|
|
|
|
struct list_head *conns = &n_ptr->conn_sks;
|
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
|
|
|
|
|
uint i;
|
2006-01-03 02:04:38 +08:00
|
|
|
|
2015-01-23 00:10:31 +08:00
|
|
|
pr_debug("Lost contact with %s\n",
|
|
|
|
|
tipc_addr_string_fill(addr_string, n_ptr->addr));
|
2011-04-07 23:58:08 +08:00
|
|
|
|
|
|
|
|
/* Flush broadcast link info associated with lost node */
|
2012-11-16 13:51:30 +08:00
|
|
|
if (n_ptr->bclink.recv_permitted) {
|
2015-03-14 04:08:10 +08:00
|
|
|
__skb_queue_purge(&n_ptr->bclink.deferdq);
|
2011-04-07 23:58:08 +08:00
|
|
|
|
2014-05-14 17:39:12 +08:00
|
|
|
if (n_ptr->bclink.reasm_buf) {
|
|
|
|
|
kfree_skb(n_ptr->bclink.reasm_buf);
|
|
|
|
|
n_ptr->bclink.reasm_buf = NULL;
|
2011-04-07 23:58:08 +08:00
|
|
|
}
|
|
|
|
|
|
2015-01-09 15:27:07 +08:00
|
|
|
tipc_bclink_remove_node(n_ptr->net, n_ptr->addr);
|
2011-10-25 03:26:24 +08:00
|
|
|
tipc_bclink_acknowledge(n_ptr, INVALID_LINK_SEQ);
|
2006-01-03 02:04:38 +08:00
|
|
|
|
2012-11-16 13:51:30 +08:00
|
|
|
n_ptr->bclink.recv_permitted = false;
|
2011-04-07 23:58:08 +08:00
|
|
|
}
|
2006-01-03 02:04:38 +08:00
|
|
|
|
tipc: eliminate delayed link deletion at link failover
When a bearer is disabled manually, all its links have to be reset
and deleted. However, if there is a remaining, parallel link ready
to take over a deleted link's traffic, we currently delay the delete
of the removed link until the failover procedure is finished. This
is because the remaining link needs to access state from the reset
link, such as the last received packet number, and any partially
reassembled buffer, in order to perform a successful failover.
In this commit, we do instead move the state data over to the new
link, so that it can fulfill the procedure autonomously, without
accessing any data on the old link. This means that we can now
proceed and delete all pertaining links immediately when a bearer
is disabled. This saves us from some unnecessary complexity in such
situations.
We also choose to change the confusing definitions CHANGEOVER_PROTOCOL,
ORIGINAL_MSG and DUPLICATE_MSG to the more descriptive TUNNEL_PROTOCOL,
FAILOVER_MSG and SYNCH_MSG respectively.
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-04-02 21:33:01 +08:00
|
|
|
/* Abort any ongoing link failover */
|
2006-01-03 02:04:38 +08:00
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
2015-07-17 04:54:19 +08:00
|
|
|
struct tipc_link *l_ptr = n_ptr->links[i].link;
|
2007-02-09 22:25:21 +08:00
|
|
|
if (!l_ptr)
|
2006-01-03 02:04:38 +08:00
|
|
|
continue;
|
tipc: eliminate delayed link deletion at link failover
When a bearer is disabled manually, all its links have to be reset
and deleted. However, if there is a remaining, parallel link ready
to take over a deleted link's traffic, we currently delay the delete
of the removed link until the failover procedure is finished. This
is because the remaining link needs to access state from the reset
link, such as the last received packet number, and any partially
reassembled buffer, in order to perform a successful failover.
In this commit, we do instead move the state data over to the new
link, so that it can fulfill the procedure autonomously, without
accessing any data on the old link. This means that we can now
proceed and delete all pertaining links immediately when a bearer
is disabled. This saves us from some unnecessary complexity in such
situations.
We also choose to change the confusing definitions CHANGEOVER_PROTOCOL,
ORIGINAL_MSG and DUPLICATE_MSG to the more descriptive TUNNEL_PROTOCOL,
FAILOVER_MSG and SYNCH_MSG respectively.
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-04-02 21:33:01 +08:00
|
|
|
l_ptr->flags &= ~LINK_FAILINGOVER;
|
|
|
|
|
l_ptr->failover_checkpt = 0;
|
|
|
|
|
l_ptr->failover_pkts = 0;
|
|
|
|
|
kfree_skb(l_ptr->failover_skb);
|
|
|
|
|
l_ptr->failover_skb = NULL;
|
2006-01-18 07:38:21 +08:00
|
|
|
tipc_link_reset_fragments(l_ptr);
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2014-05-08 08:54:40 +08:00
|
|
|
n_ptr->action_flags &= ~TIPC_WAIT_OWN_LINKS_DOWN;
|
|
|
|
|
|
2015-02-05 21:36:42 +08:00
|
|
|
/* Prevent re-contact with node until cleanup is done */
|
|
|
|
|
n_ptr->action_flags |= TIPC_WAIT_PEER_LINKS_DOWN;
|
|
|
|
|
|
|
|
|
|
/* Notify publications from this node */
|
|
|
|
|
n_ptr->action_flags |= TIPC_NOTIFY_NODE_DOWN;
|
|
|
|
|
|
|
|
|
|
/* Notify sockets connected to node */
|
|
|
|
|
list_for_each_entry_safe(conn, safe, conns, list) {
|
|
|
|
|
skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
|
|
|
|
|
SHORT_H_SIZE, 0, tn->own_addr,
|
|
|
|
|
conn->peer_node, conn->port,
|
|
|
|
|
conn->peer_port, TIPC_ERR_NO_NODE);
|
|
|
|
|
if (likely(skb)) {
|
|
|
|
|
skb_queue_tail(n_ptr->inputq, skb);
|
|
|
|
|
n_ptr->action_flags |= TIPC_MSG_EVT;
|
|
|
|
|
}
|
|
|
|
|
list_del(&conn->list);
|
|
|
|
|
kfree(conn);
|
|
|
|
|
}
|
2006-01-03 02:04:38 +08:00
|
|
|
}
|
|
|
|
|
|
2014-04-24 22:26:47 +08: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
|
|
|
|
|
*/
|
2015-01-09 15:27:05 +08:00
|
|
|
int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
|
|
|
|
|
char *linkname, size_t len)
|
2014-04-24 22:26:47 +08:00
|
|
|
{
|
|
|
|
|
struct tipc_link *link;
|
2015-03-26 18:10:24 +08:00
|
|
|
int err = -EINVAL;
|
2015-01-09 15:27:05 +08:00
|
|
|
struct tipc_node *node = tipc_node_find(net, addr);
|
2014-04-24 22:26:47 +08:00
|
|
|
|
2015-03-26 18:10:24 +08:00
|
|
|
if (!node)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (bearer_id >= MAX_BEARERS)
|
|
|
|
|
goto exit;
|
|
|
|
|
|
2014-04-24 22:26:47 +08:00
|
|
|
tipc_node_lock(node);
|
2015-07-17 04:54:19 +08:00
|
|
|
link = node->links[bearer_id].link;
|
2014-04-24 22:26:47 +08:00
|
|
|
if (link) {
|
|
|
|
|
strncpy(linkname, link->name, len);
|
2015-03-26 18:10:24 +08:00
|
|
|
err = 0;
|
2014-04-24 22:26:47 +08:00
|
|
|
}
|
2015-03-26 18:10:24 +08:00
|
|
|
exit:
|
2014-04-24 22:26:47 +08:00
|
|
|
tipc_node_unlock(node);
|
2015-03-26 18:10:24 +08:00
|
|
|
tipc_node_put(node);
|
|
|
|
|
return err;
|
2014-04-24 22:26:47 +08:00
|
|
|
}
|
2014-05-05 08:56:12 +08:00
|
|
|
|
|
|
|
|
void tipc_node_unlock(struct tipc_node *node)
|
|
|
|
|
{
|
2015-01-09 15:27:05 +08:00
|
|
|
struct net *net = node->net;
|
2014-05-05 08:56:14 +08:00
|
|
|
u32 addr = 0;
|
tipc: resolve race problem at unicast message reception
TIPC handles message cardinality and sequencing at the link layer,
before passing messages upwards to the destination sockets. During the
upcall from link to socket no locks are held. It is therefore possible,
and we see it happen occasionally, that messages arriving in different
threads and delivered in sequence still bypass each other before they
reach the destination socket. This must not happen, since it violates
the sequentiality guarantee.
We solve this by adding a new input buffer queue to the link structure.
Arriving messages are added safely to the tail of that queue by the
link, while the head of the queue is consumed, also safely, by the
receiving socket. Sequentiality is secured per socket by only allowing
buffers to be dequeued inside the socket lock. Since there may be multiple
simultaneous readers of the queue, we use a 'filter' parameter to reduce
the risk that they peek the same buffer from the queue, hence also
reducing the risk of contention on the receiving socket locks.
This solves the sequentiality problem, and seems to cause no measurable
performance degradation.
A nice side effect of this change is that lock handling in the functions
tipc_rcv() and tipc_bcast_rcv() now becomes uniform, something that
will enable future simplifications of those functions.
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-02-05 21:36:41 +08:00
|
|
|
u32 flags = node->action_flags;
|
2014-10-20 14:44:25 +08:00
|
|
|
u32 link_id = 0;
|
2015-02-05 21:36:42 +08:00
|
|
|
struct list_head *publ_list;
|
tipc: resolve race problem at unicast message reception
TIPC handles message cardinality and sequencing at the link layer,
before passing messages upwards to the destination sockets. During the
upcall from link to socket no locks are held. It is therefore possible,
and we see it happen occasionally, that messages arriving in different
threads and delivered in sequence still bypass each other before they
reach the destination socket. This must not happen, since it violates
the sequentiality guarantee.
We solve this by adding a new input buffer queue to the link structure.
Arriving messages are added safely to the tail of that queue by the
link, while the head of the queue is consumed, also safely, by the
receiving socket. Sequentiality is secured per socket by only allowing
buffers to be dequeued inside the socket lock. Since there may be multiple
simultaneous readers of the queue, we use a 'filter' parameter to reduce
the risk that they peek the same buffer from the queue, hence also
reducing the risk of contention on the receiving socket locks.
This solves the sequentiality problem, and seems to cause no measurable
performance degradation.
A nice side effect of this change is that lock handling in the functions
tipc_rcv() and tipc_bcast_rcv() now becomes uniform, something that
will enable future simplifications of those functions.
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-02-05 21:36:41 +08:00
|
|
|
struct sk_buff_head *inputq = node->inputq;
|
2015-02-05 21:36:42 +08:00
|
|
|
struct sk_buff_head *namedq;
|
2014-05-05 08:56:12 +08:00
|
|
|
|
tipc: resolve race problem at unicast message reception
TIPC handles message cardinality and sequencing at the link layer,
before passing messages upwards to the destination sockets. During the
upcall from link to socket no locks are held. It is therefore possible,
and we see it happen occasionally, that messages arriving in different
threads and delivered in sequence still bypass each other before they
reach the destination socket. This must not happen, since it violates
the sequentiality guarantee.
We solve this by adding a new input buffer queue to the link structure.
Arriving messages are added safely to the tail of that queue by the
link, while the head of the queue is consumed, also safely, by the
receiving socket. Sequentiality is secured per socket by only allowing
buffers to be dequeued inside the socket lock. Since there may be multiple
simultaneous readers of the queue, we use a 'filter' parameter to reduce
the risk that they peek the same buffer from the queue, hence also
reducing the risk of contention on the receiving socket locks.
This solves the sequentiality problem, and seems to cause no measurable
performance degradation.
A nice side effect of this change is that lock handling in the functions
tipc_rcv() and tipc_bcast_rcv() now becomes uniform, something that
will enable future simplifications of those functions.
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-02-05 21:36:41 +08:00
|
|
|
if (likely(!flags || (flags == TIPC_MSG_EVT))) {
|
|
|
|
|
node->action_flags = 0;
|
2014-05-05 08:56:12 +08:00
|
|
|
spin_unlock_bh(&node->lock);
|
tipc: resolve race problem at unicast message reception
TIPC handles message cardinality and sequencing at the link layer,
before passing messages upwards to the destination sockets. During the
upcall from link to socket no locks are held. It is therefore possible,
and we see it happen occasionally, that messages arriving in different
threads and delivered in sequence still bypass each other before they
reach the destination socket. This must not happen, since it violates
the sequentiality guarantee.
We solve this by adding a new input buffer queue to the link structure.
Arriving messages are added safely to the tail of that queue by the
link, while the head of the queue is consumed, also safely, by the
receiving socket. Sequentiality is secured per socket by only allowing
buffers to be dequeued inside the socket lock. Since there may be multiple
simultaneous readers of the queue, we use a 'filter' parameter to reduce
the risk that they peek the same buffer from the queue, hence also
reducing the risk of contention on the receiving socket locks.
This solves the sequentiality problem, and seems to cause no measurable
performance degradation.
A nice side effect of this change is that lock handling in the functions
tipc_rcv() and tipc_bcast_rcv() now becomes uniform, something that
will enable future simplifications of those functions.
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-02-05 21:36:41 +08:00
|
|
|
if (flags == TIPC_MSG_EVT)
|
|
|
|
|
tipc_sk_rcv(net, inputq);
|
2014-05-05 08:56:12 +08:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-20 14:44:25 +08:00
|
|
|
addr = node->addr;
|
|
|
|
|
link_id = node->link_id;
|
tipc: resolve race problem at unicast message reception
TIPC handles message cardinality and sequencing at the link layer,
before passing messages upwards to the destination sockets. During the
upcall from link to socket no locks are held. It is therefore possible,
and we see it happen occasionally, that messages arriving in different
threads and delivered in sequence still bypass each other before they
reach the destination socket. This must not happen, since it violates
the sequentiality guarantee.
We solve this by adding a new input buffer queue to the link structure.
Arriving messages are added safely to the tail of that queue by the
link, while the head of the queue is consumed, also safely, by the
receiving socket. Sequentiality is secured per socket by only allowing
buffers to be dequeued inside the socket lock. Since there may be multiple
simultaneous readers of the queue, we use a 'filter' parameter to reduce
the risk that they peek the same buffer from the queue, hence also
reducing the risk of contention on the receiving socket locks.
This solves the sequentiality problem, and seems to cause no measurable
performance degradation.
A nice side effect of this change is that lock handling in the functions
tipc_rcv() and tipc_bcast_rcv() now becomes uniform, something that
will enable future simplifications of those functions.
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-02-05 21:36:41 +08:00
|
|
|
namedq = node->namedq;
|
2015-02-05 21:36:42 +08:00
|
|
|
publ_list = &node->publ_list;
|
2014-10-20 14:44:25 +08:00
|
|
|
|
2015-02-05 21:36:44 +08:00
|
|
|
node->action_flags &= ~(TIPC_MSG_EVT |
|
|
|
|
|
TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |
|
|
|
|
|
TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP |
|
|
|
|
|
TIPC_WAKEUP_BCAST_USERS | TIPC_BCAST_MSG_EVT |
|
tipc: fix potential deadlock when all links are reset
[ 60.988363] ======================================================
[ 60.988754] [ INFO: possible circular locking dependency detected ]
[ 60.989152] 3.19.0+ #194 Not tainted
[ 60.989377] -------------------------------------------------------
[ 60.989781] swapper/3/0 is trying to acquire lock:
[ 60.990079] (&(&n_ptr->lock)->rlock){+.-...}, at: [<ffffffffa0006dca>] tipc_link_retransmit+0x1aa/0x240 [tipc]
[ 60.990743]
[ 60.990743] but task is already holding lock:
[ 60.991106] (&(&bclink->lock)->rlock){+.-...}, at: [<ffffffffa00004be>] tipc_bclink_lock+0x8e/0xa0 [tipc]
[ 60.991738]
[ 60.991738] which lock already depends on the new lock.
[ 60.991738]
[ 60.992174]
[ 60.992174] the existing dependency chain (in reverse order) is:
[ 60.992174]
-> #1 (&(&bclink->lock)->rlock){+.-...}:
[ 60.992174] [<ffffffff810a9c0c>] lock_acquire+0x9c/0x140
[ 60.992174] [<ffffffff8179c41f>] _raw_spin_lock_bh+0x3f/0x50
[ 60.992174] [<ffffffffa00004be>] tipc_bclink_lock+0x8e/0xa0 [tipc]
[ 60.992174] [<ffffffffa0000f57>] tipc_bclink_add_node+0x97/0xf0 [tipc]
[ 60.992174] [<ffffffffa0011815>] tipc_node_link_up+0xf5/0x110 [tipc]
[ 60.992174] [<ffffffffa0007783>] link_state_event+0x2b3/0x4f0 [tipc]
[ 60.992174] [<ffffffffa00193c0>] tipc_link_proto_rcv+0x24c/0x418 [tipc]
[ 60.992174] [<ffffffffa0008857>] tipc_rcv+0x827/0xac0 [tipc]
[ 60.992174] [<ffffffffa0002ca3>] tipc_l2_rcv_msg+0x73/0xd0 [tipc]
[ 60.992174] [<ffffffff81646e66>] __netif_receive_skb_core+0x746/0x980
[ 60.992174] [<ffffffff816470c1>] __netif_receive_skb+0x21/0x70
[ 60.992174] [<ffffffff81647295>] netif_receive_skb_internal+0x35/0x130
[ 60.992174] [<ffffffff81648218>] napi_gro_receive+0x158/0x1d0
[ 60.992174] [<ffffffff81559e05>] e1000_clean_rx_irq+0x155/0x490
[ 60.992174] [<ffffffff8155c1b7>] e1000_clean+0x267/0x990
[ 60.992174] [<ffffffff81647b60>] net_rx_action+0x150/0x360
[ 60.992174] [<ffffffff8105ec43>] __do_softirq+0x123/0x360
[ 60.992174] [<ffffffff8105f12e>] irq_exit+0x8e/0xb0
[ 60.992174] [<ffffffff8179f9f5>] do_IRQ+0x65/0x110
[ 60.992174] [<ffffffff8179da6f>] ret_from_intr+0x0/0x13
[ 60.992174] [<ffffffff8100de9f>] arch_cpu_idle+0xf/0x20
[ 60.992174] [<ffffffff8109dfa6>] cpu_startup_entry+0x2f6/0x3f0
[ 60.992174] [<ffffffff81033cda>] start_secondary+0x13a/0x150
[ 60.992174]
-> #0 (&(&n_ptr->lock)->rlock){+.-...}:
[ 60.992174] [<ffffffff810a8f7d>] __lock_acquire+0x163d/0x1ca0
[ 60.992174] [<ffffffff810a9c0c>] lock_acquire+0x9c/0x140
[ 60.992174] [<ffffffff8179c41f>] _raw_spin_lock_bh+0x3f/0x50
[ 60.992174] [<ffffffffa0006dca>] tipc_link_retransmit+0x1aa/0x240 [tipc]
[ 60.992174] [<ffffffffa0001e11>] tipc_bclink_rcv+0x611/0x640 [tipc]
[ 60.992174] [<ffffffffa0008646>] tipc_rcv+0x616/0xac0 [tipc]
[ 60.992174] [<ffffffffa0002ca3>] tipc_l2_rcv_msg+0x73/0xd0 [tipc]
[ 60.992174] [<ffffffff81646e66>] __netif_receive_skb_core+0x746/0x980
[ 60.992174] [<ffffffff816470c1>] __netif_receive_skb+0x21/0x70
[ 60.992174] [<ffffffff81647295>] netif_receive_skb_internal+0x35/0x130
[ 60.992174] [<ffffffff81648218>] napi_gro_receive+0x158/0x1d0
[ 60.992174] [<ffffffff81559e05>] e1000_clean_rx_irq+0x155/0x490
[ 60.992174] [<ffffffff8155c1b7>] e1000_clean+0x267/0x990
[ 60.992174] [<ffffffff81647b60>] net_rx_action+0x150/0x360
[ 60.992174] [<ffffffff8105ec43>] __do_softirq+0x123/0x360
[ 60.992174] [<ffffffff8105f12e>] irq_exit+0x8e/0xb0
[ 60.992174] [<ffffffff8179f9f5>] do_IRQ+0x65/0x110
[ 60.992174] [<ffffffff8179da6f>] ret_from_intr+0x0/0x13
[ 60.992174] [<ffffffff8100de9f>] arch_cpu_idle+0xf/0x20
[ 60.992174] [<ffffffff8109dfa6>] cpu_startup_entry+0x2f6/0x3f0
[ 60.992174] [<ffffffff81033cda>] start_secondary+0x13a/0x150
[ 60.992174]
[ 60.992174] other info that might help us debug this:
[ 60.992174]
[ 60.992174] Possible unsafe locking scenario:
[ 60.992174]
[ 60.992174] CPU0 CPU1
[ 60.992174] ---- ----
[ 60.992174] lock(&(&bclink->lock)->rlock);
[ 60.992174] lock(&(&n_ptr->lock)->rlock);
[ 60.992174] lock(&(&bclink->lock)->rlock);
[ 60.992174] lock(&(&n_ptr->lock)->rlock);
[ 60.992174]
[ 60.992174] *** DEADLOCK ***
[ 60.992174]
[ 60.992174] 3 locks held by swapper/3/0:
[ 60.992174] #0: (rcu_read_lock){......}, at: [<ffffffff81646791>] __netif_receive_skb_core+0x71/0x980
[ 60.992174] #1: (rcu_read_lock){......}, at: [<ffffffffa0002c35>] tipc_l2_rcv_msg+0x5/0xd0 [tipc]
[ 60.992174] #2: (&(&bclink->lock)->rlock){+.-...}, at: [<ffffffffa00004be>] tipc_bclink_lock+0x8e/0xa0 [tipc]
[ 60.992174]
The correct the sequence of grabbing n_ptr->lock and bclink->lock
should be that the former is first held and the latter is then taken,
which exactly happened on CPU1. But especially when the retransmission
of broadcast link is failed, bclink->lock is first held in
tipc_bclink_rcv(), and n_ptr->lock is taken in link_retransmit_failure()
called by tipc_link_retransmit() subsequently, which is demonstrated on
CPU0. As a result, deadlock occurs.
If the order of holding the two locks happening on CPU0 is reversed, the
deadlock risk will be relieved. Therefore, the node lock taken in
link_retransmit_failure() originally is moved to tipc_bclink_rcv()
so that it's obtained before bclink lock. But the precondition of
the adjustment of node lock is that responding to bclink reset event
must be moved from tipc_bclink_unlock() to tipc_node_unlock().
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-03-26 18:10:23 +08:00
|
|
|
TIPC_NAMED_MSG_EVT | TIPC_BCAST_RESET);
|
2014-10-20 14:44:25 +08:00
|
|
|
|
2014-05-05 08:56:12 +08:00
|
|
|
spin_unlock_bh(&node->lock);
|
|
|
|
|
|
2015-02-05 21:36:42 +08:00
|
|
|
if (flags & TIPC_NOTIFY_NODE_DOWN)
|
|
|
|
|
tipc_publ_notify(net, publ_list, addr);
|
2014-08-23 06:09:07 +08:00
|
|
|
|
tipc: fix bug in multicast congestion handling
One aim of commit 50100a5e39461b2a61d6040e73c384766c29975d ("tipc:
use pseudo message to wake up sockets after link congestion") was
to handle link congestion abatement in a uniform way for both unicast
and multicast transmit. However, the latter doesn't work correctly,
and has been broken since the referenced commit was applied.
If a user now sends a burst of multicast messages that is big
enough to cause broadcast link congestion, it will be put to sleep,
and not be waked up when the congestion abates as it should be.
This has two reasons. First, the flag that is used, TIPC_WAKEUP_USERS,
is set correctly, but in the wrong field. Instead of setting it in the
'action_flags' field of the arrival node struct, it is by mistake set
in the dummy node struct that is owned by the broadcast link, where it
will never tested for. Second, we cannot use the same flag for waking
up unicast and multicast users, since the function tipc_node_unlock()
needs to pick the wakeup pseudo messages to deliver from different
queues. It must hence be able to distinguish between the two cases.
This commit solves this problem by adding a new flag
TIPC_WAKEUP_BCAST_USERS, and a new function tipc_bclink_wakeup_user().
The latter is to be called by tipc_node_unlock() when the named flag,
now set in the correct field, is encountered.
v2: using explicit 'unsigned int' declaration instead of 'uint', as
per comment from David Miller.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-10-08 02:12:34 +08:00
|
|
|
if (flags & TIPC_WAKEUP_BCAST_USERS)
|
2015-01-09 15:27:05 +08:00
|
|
|
tipc_bclink_wakeup_users(net);
|
tipc: fix bug in multicast congestion handling
One aim of commit 50100a5e39461b2a61d6040e73c384766c29975d ("tipc:
use pseudo message to wake up sockets after link congestion") was
to handle link congestion abatement in a uniform way for both unicast
and multicast transmit. However, the latter doesn't work correctly,
and has been broken since the referenced commit was applied.
If a user now sends a burst of multicast messages that is big
enough to cause broadcast link congestion, it will be put to sleep,
and not be waked up when the congestion abates as it should be.
This has two reasons. First, the flag that is used, TIPC_WAKEUP_USERS,
is set correctly, but in the wrong field. Instead of setting it in the
'action_flags' field of the arrival node struct, it is by mistake set
in the dummy node struct that is owned by the broadcast link, where it
will never tested for. Second, we cannot use the same flag for waking
up unicast and multicast users, since the function tipc_node_unlock()
needs to pick the wakeup pseudo messages to deliver from different
queues. It must hence be able to distinguish between the two cases.
This commit solves this problem by adding a new flag
TIPC_WAKEUP_BCAST_USERS, and a new function tipc_bclink_wakeup_user().
The latter is to be called by tipc_node_unlock() when the named flag,
now set in the correct field, is encountered.
v2: using explicit 'unsigned int' declaration instead of 'uint', as
per comment from David Miller.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-10-08 02:12:34 +08:00
|
|
|
|
2014-10-20 14:44:25 +08:00
|
|
|
if (flags & TIPC_NOTIFY_NODE_UP)
|
2015-01-09 15:27:05 +08:00
|
|
|
tipc_named_node_up(net, addr);
|
2014-10-20 14:44:25 +08:00
|
|
|
|
|
|
|
|
if (flags & TIPC_NOTIFY_LINK_UP)
|
2015-01-09 15:27:05 +08:00
|
|
|
tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
|
2014-10-20 14:44:25 +08:00
|
|
|
TIPC_NODE_SCOPE, link_id, addr);
|
|
|
|
|
|
|
|
|
|
if (flags & TIPC_NOTIFY_LINK_DOWN)
|
2015-01-09 15:27:05 +08:00
|
|
|
tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
|
2014-10-20 14:44:25 +08:00
|
|
|
link_id, addr);
|
tipc: resolve race problem at unicast message reception
TIPC handles message cardinality and sequencing at the link layer,
before passing messages upwards to the destination sockets. During the
upcall from link to socket no locks are held. It is therefore possible,
and we see it happen occasionally, that messages arriving in different
threads and delivered in sequence still bypass each other before they
reach the destination socket. This must not happen, since it violates
the sequentiality guarantee.
We solve this by adding a new input buffer queue to the link structure.
Arriving messages are added safely to the tail of that queue by the
link, while the head of the queue is consumed, also safely, by the
receiving socket. Sequentiality is secured per socket by only allowing
buffers to be dequeued inside the socket lock. Since there may be multiple
simultaneous readers of the queue, we use a 'filter' parameter to reduce
the risk that they peek the same buffer from the queue, hence also
reducing the risk of contention on the receiving socket locks.
This solves the sequentiality problem, and seems to cause no measurable
performance degradation.
A nice side effect of this change is that lock handling in the functions
tipc_rcv() and tipc_bcast_rcv() now becomes uniform, something that
will enable future simplifications of those functions.
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-02-05 21:36:41 +08:00
|
|
|
|
|
|
|
|
if (flags & TIPC_MSG_EVT)
|
|
|
|
|
tipc_sk_rcv(net, inputq);
|
|
|
|
|
|
|
|
|
|
if (flags & TIPC_NAMED_MSG_EVT)
|
|
|
|
|
tipc_named_rcv(net, namedq);
|
2015-02-05 21:36:44 +08:00
|
|
|
|
|
|
|
|
if (flags & TIPC_BCAST_MSG_EVT)
|
|
|
|
|
tipc_bclink_input(net);
|
tipc: fix potential deadlock when all links are reset
[ 60.988363] ======================================================
[ 60.988754] [ INFO: possible circular locking dependency detected ]
[ 60.989152] 3.19.0+ #194 Not tainted
[ 60.989377] -------------------------------------------------------
[ 60.989781] swapper/3/0 is trying to acquire lock:
[ 60.990079] (&(&n_ptr->lock)->rlock){+.-...}, at: [<ffffffffa0006dca>] tipc_link_retransmit+0x1aa/0x240 [tipc]
[ 60.990743]
[ 60.990743] but task is already holding lock:
[ 60.991106] (&(&bclink->lock)->rlock){+.-...}, at: [<ffffffffa00004be>] tipc_bclink_lock+0x8e/0xa0 [tipc]
[ 60.991738]
[ 60.991738] which lock already depends on the new lock.
[ 60.991738]
[ 60.992174]
[ 60.992174] the existing dependency chain (in reverse order) is:
[ 60.992174]
-> #1 (&(&bclink->lock)->rlock){+.-...}:
[ 60.992174] [<ffffffff810a9c0c>] lock_acquire+0x9c/0x140
[ 60.992174] [<ffffffff8179c41f>] _raw_spin_lock_bh+0x3f/0x50
[ 60.992174] [<ffffffffa00004be>] tipc_bclink_lock+0x8e/0xa0 [tipc]
[ 60.992174] [<ffffffffa0000f57>] tipc_bclink_add_node+0x97/0xf0 [tipc]
[ 60.992174] [<ffffffffa0011815>] tipc_node_link_up+0xf5/0x110 [tipc]
[ 60.992174] [<ffffffffa0007783>] link_state_event+0x2b3/0x4f0 [tipc]
[ 60.992174] [<ffffffffa00193c0>] tipc_link_proto_rcv+0x24c/0x418 [tipc]
[ 60.992174] [<ffffffffa0008857>] tipc_rcv+0x827/0xac0 [tipc]
[ 60.992174] [<ffffffffa0002ca3>] tipc_l2_rcv_msg+0x73/0xd0 [tipc]
[ 60.992174] [<ffffffff81646e66>] __netif_receive_skb_core+0x746/0x980
[ 60.992174] [<ffffffff816470c1>] __netif_receive_skb+0x21/0x70
[ 60.992174] [<ffffffff81647295>] netif_receive_skb_internal+0x35/0x130
[ 60.992174] [<ffffffff81648218>] napi_gro_receive+0x158/0x1d0
[ 60.992174] [<ffffffff81559e05>] e1000_clean_rx_irq+0x155/0x490
[ 60.992174] [<ffffffff8155c1b7>] e1000_clean+0x267/0x990
[ 60.992174] [<ffffffff81647b60>] net_rx_action+0x150/0x360
[ 60.992174] [<ffffffff8105ec43>] __do_softirq+0x123/0x360
[ 60.992174] [<ffffffff8105f12e>] irq_exit+0x8e/0xb0
[ 60.992174] [<ffffffff8179f9f5>] do_IRQ+0x65/0x110
[ 60.992174] [<ffffffff8179da6f>] ret_from_intr+0x0/0x13
[ 60.992174] [<ffffffff8100de9f>] arch_cpu_idle+0xf/0x20
[ 60.992174] [<ffffffff8109dfa6>] cpu_startup_entry+0x2f6/0x3f0
[ 60.992174] [<ffffffff81033cda>] start_secondary+0x13a/0x150
[ 60.992174]
-> #0 (&(&n_ptr->lock)->rlock){+.-...}:
[ 60.992174] [<ffffffff810a8f7d>] __lock_acquire+0x163d/0x1ca0
[ 60.992174] [<ffffffff810a9c0c>] lock_acquire+0x9c/0x140
[ 60.992174] [<ffffffff8179c41f>] _raw_spin_lock_bh+0x3f/0x50
[ 60.992174] [<ffffffffa0006dca>] tipc_link_retransmit+0x1aa/0x240 [tipc]
[ 60.992174] [<ffffffffa0001e11>] tipc_bclink_rcv+0x611/0x640 [tipc]
[ 60.992174] [<ffffffffa0008646>] tipc_rcv+0x616/0xac0 [tipc]
[ 60.992174] [<ffffffffa0002ca3>] tipc_l2_rcv_msg+0x73/0xd0 [tipc]
[ 60.992174] [<ffffffff81646e66>] __netif_receive_skb_core+0x746/0x980
[ 60.992174] [<ffffffff816470c1>] __netif_receive_skb+0x21/0x70
[ 60.992174] [<ffffffff81647295>] netif_receive_skb_internal+0x35/0x130
[ 60.992174] [<ffffffff81648218>] napi_gro_receive+0x158/0x1d0
[ 60.992174] [<ffffffff81559e05>] e1000_clean_rx_irq+0x155/0x490
[ 60.992174] [<ffffffff8155c1b7>] e1000_clean+0x267/0x990
[ 60.992174] [<ffffffff81647b60>] net_rx_action+0x150/0x360
[ 60.992174] [<ffffffff8105ec43>] __do_softirq+0x123/0x360
[ 60.992174] [<ffffffff8105f12e>] irq_exit+0x8e/0xb0
[ 60.992174] [<ffffffff8179f9f5>] do_IRQ+0x65/0x110
[ 60.992174] [<ffffffff8179da6f>] ret_from_intr+0x0/0x13
[ 60.992174] [<ffffffff8100de9f>] arch_cpu_idle+0xf/0x20
[ 60.992174] [<ffffffff8109dfa6>] cpu_startup_entry+0x2f6/0x3f0
[ 60.992174] [<ffffffff81033cda>] start_secondary+0x13a/0x150
[ 60.992174]
[ 60.992174] other info that might help us debug this:
[ 60.992174]
[ 60.992174] Possible unsafe locking scenario:
[ 60.992174]
[ 60.992174] CPU0 CPU1
[ 60.992174] ---- ----
[ 60.992174] lock(&(&bclink->lock)->rlock);
[ 60.992174] lock(&(&n_ptr->lock)->rlock);
[ 60.992174] lock(&(&bclink->lock)->rlock);
[ 60.992174] lock(&(&n_ptr->lock)->rlock);
[ 60.992174]
[ 60.992174] *** DEADLOCK ***
[ 60.992174]
[ 60.992174] 3 locks held by swapper/3/0:
[ 60.992174] #0: (rcu_read_lock){......}, at: [<ffffffff81646791>] __netif_receive_skb_core+0x71/0x980
[ 60.992174] #1: (rcu_read_lock){......}, at: [<ffffffffa0002c35>] tipc_l2_rcv_msg+0x5/0xd0 [tipc]
[ 60.992174] #2: (&(&bclink->lock)->rlock){+.-...}, at: [<ffffffffa00004be>] tipc_bclink_lock+0x8e/0xa0 [tipc]
[ 60.992174]
The correct the sequence of grabbing n_ptr->lock and bclink->lock
should be that the former is first held and the latter is then taken,
which exactly happened on CPU1. But especially when the retransmission
of broadcast link is failed, bclink->lock is first held in
tipc_bclink_rcv(), and n_ptr->lock is taken in link_retransmit_failure()
called by tipc_link_retransmit() subsequently, which is demonstrated on
CPU0. As a result, deadlock occurs.
If the order of holding the two locks happening on CPU0 is reversed, the
deadlock risk will be relieved. Therefore, the node lock taken in
link_retransmit_failure() originally is moved to tipc_bclink_rcv()
so that it's obtained before bclink lock. But the precondition of
the adjustment of node lock is that responding to bclink reset event
must be moved from tipc_bclink_unlock() to tipc_node_unlock().
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-03-26 18:10:23 +08:00
|
|
|
|
|
|
|
|
if (flags & TIPC_BCAST_RESET)
|
|
|
|
|
tipc_link_reset_all(node);
|
2014-05-05 08:56:12 +08:00
|
|
|
}
|
2014-11-20 17:29:17 +08:00
|
|
|
|
|
|
|
|
/* Caller should hold node lock for the passed node */
|
2014-11-24 18:10:29 +08:00
|
|
|
static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
|
2014-11-20 17:29:17 +08:00
|
|
|
{
|
|
|
|
|
void *hdr;
|
|
|
|
|
struct nlattr *attrs;
|
|
|
|
|
|
2015-02-09 16:50:03 +08:00
|
|
|
hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
|
2014-11-20 17:29:17 +08:00
|
|
|
NLM_F_MULTI, TIPC_NL_NODE_GET);
|
|
|
|
|
if (!hdr)
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
|
|
attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE);
|
|
|
|
|
if (!attrs)
|
|
|
|
|
goto msg_full;
|
|
|
|
|
|
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
|
|
|
|
|
goto attr_msg_full;
|
|
|
|
|
if (tipc_node_is_up(node))
|
|
|
|
|
if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP))
|
|
|
|
|
goto attr_msg_full;
|
|
|
|
|
|
|
|
|
|
nla_nest_end(msg->skb, attrs);
|
|
|
|
|
genlmsg_end(msg->skb, hdr);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
attr_msg_full:
|
|
|
|
|
nla_nest_cancel(msg->skb, attrs);
|
|
|
|
|
msg_full:
|
|
|
|
|
genlmsg_cancel(msg->skb, hdr);
|
|
|
|
|
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-17 04:54:24 +08:00
|
|
|
static struct tipc_link *tipc_node_select_link(struct tipc_node *n, int sel,
|
|
|
|
|
int *bearer_id,
|
|
|
|
|
struct tipc_media_addr **maddr)
|
|
|
|
|
{
|
|
|
|
|
int id = n->active_links[sel & 1];
|
|
|
|
|
|
|
|
|
|
if (unlikely(id < 0))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
*bearer_id = id;
|
|
|
|
|
*maddr = &n->links[id].maddr;
|
|
|
|
|
return n->links[id].link;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* tipc_node_xmit() is the general link level function for message sending
|
|
|
|
|
* @net: the applicable net namespace
|
|
|
|
|
* @list: chain of buffers containing message
|
|
|
|
|
* @dnode: address of destination node
|
|
|
|
|
* @selector: a number used for deterministic link selection
|
|
|
|
|
* Consumes the buffer chain, except when returning -ELINKCONG
|
|
|
|
|
* Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE
|
|
|
|
|
*/
|
|
|
|
|
int tipc_node_xmit(struct net *net, struct sk_buff_head *list,
|
|
|
|
|
u32 dnode, int selector)
|
|
|
|
|
{
|
|
|
|
|
struct tipc_link *l = NULL;
|
|
|
|
|
struct tipc_node *n;
|
|
|
|
|
struct sk_buff_head xmitq;
|
|
|
|
|
struct tipc_media_addr *maddr;
|
|
|
|
|
int bearer_id;
|
|
|
|
|
int rc = -EHOSTUNREACH;
|
|
|
|
|
|
|
|
|
|
__skb_queue_head_init(&xmitq);
|
|
|
|
|
n = tipc_node_find(net, dnode);
|
|
|
|
|
if (likely(n)) {
|
|
|
|
|
tipc_node_lock(n);
|
|
|
|
|
l = tipc_node_select_link(n, selector, &bearer_id, &maddr);
|
|
|
|
|
if (likely(l))
|
|
|
|
|
rc = tipc_link_xmit(l, list, &xmitq);
|
|
|
|
|
if (unlikely(rc == -ENOBUFS))
|
|
|
|
|
tipc_link_reset(l);
|
|
|
|
|
tipc_node_unlock(n);
|
|
|
|
|
tipc_node_put(n);
|
|
|
|
|
}
|
|
|
|
|
if (likely(!rc)) {
|
|
|
|
|
tipc_bearer_xmit(net, bearer_id, &xmitq, maddr);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (likely(in_own_node(net, dnode))) {
|
|
|
|
|
tipc_sk_rcv(net, list);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* tipc_node_xmit_skb(): send single buffer to destination
|
|
|
|
|
* Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE
|
|
|
|
|
* messages, which will not be rejected
|
|
|
|
|
* The only exception is datagram messages rerouted after secondary
|
|
|
|
|
* lookup, which are rare and safe to dispose of anyway.
|
|
|
|
|
* TODO: Return real return value, and let callers use
|
|
|
|
|
* tipc_wait_for_sendpkt() where applicable
|
|
|
|
|
*/
|
|
|
|
|
int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode,
|
|
|
|
|
u32 selector)
|
|
|
|
|
{
|
|
|
|
|
struct sk_buff_head head;
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
skb_queue_head_init(&head);
|
|
|
|
|
__skb_queue_tail(&head, skb);
|
|
|
|
|
rc = tipc_node_xmit(net, &head, dnode, selector);
|
|
|
|
|
if (rc == -ELINKCONG)
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-20 17:29:17 +08:00
|
|
|
int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
2015-01-09 15:27:05 +08:00
|
|
|
struct net *net = sock_net(skb->sk);
|
|
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2014-11-20 17:29:17 +08:00
|
|
|
int done = cb->args[0];
|
|
|
|
|
int last_addr = cb->args[1];
|
|
|
|
|
struct tipc_node *node;
|
|
|
|
|
struct tipc_nl_msg msg;
|
|
|
|
|
|
|
|
|
|
if (done)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
msg.skb = skb;
|
|
|
|
|
msg.portid = NETLINK_CB(cb->skb).portid;
|
|
|
|
|
msg.seq = cb->nlh->nlmsg_seq;
|
|
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2015-03-26 18:10:24 +08:00
|
|
|
if (last_addr) {
|
|
|
|
|
node = tipc_node_find(net, last_addr);
|
|
|
|
|
if (!node) {
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
/* We never set seq or call nl_dump_check_consistent()
|
|
|
|
|
* this means that setting prev_seq here will cause the
|
|
|
|
|
* consistence check to fail in the netlink callback
|
|
|
|
|
* handler. Resulting in the NLMSG_DONE message having
|
|
|
|
|
* the NLM_F_DUMP_INTR flag set if the node state
|
|
|
|
|
* changed while we released the lock.
|
|
|
|
|
*/
|
|
|
|
|
cb->prev_seq = 1;
|
|
|
|
|
return -EPIPE;
|
|
|
|
|
}
|
|
|
|
|
tipc_node_put(node);
|
2014-11-20 17:29:17 +08:00
|
|
|
}
|
|
|
|
|
|
2015-01-09 15:27:05 +08:00
|
|
|
list_for_each_entry_rcu(node, &tn->node_list, list) {
|
2014-11-20 17:29:17 +08:00
|
|
|
if (last_addr) {
|
|
|
|
|
if (node->addr == last_addr)
|
|
|
|
|
last_addr = 0;
|
|
|
|
|
else
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tipc_node_lock(node);
|
|
|
|
|
err = __tipc_nl_add_node(&msg, node);
|
|
|
|
|
if (err) {
|
|
|
|
|
last_addr = node->addr;
|
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
|
}
|
|
|
|
|
done = 1;
|
|
|
|
|
out:
|
|
|
|
|
cb->args[0] = done;
|
|
|
|
|
cb->args[1] = last_addr;
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
|
}
|