2006-01-02 18:04:38 +00:00
|
|
|
/*
|
|
|
|
* net/tipc/link.c: TIPC link code
|
2007-02-09 14:25:21 +00:00
|
|
|
*
|
2014-01-07 22:02:41 +00:00
|
|
|
* Copyright (c) 1996-2007, 2012-2014, Ericsson AB
|
2013-06-17 14:54:42 +00:00
|
|
|
* Copyright (c) 2004-2007, 2010-2013, Wind River Systems
|
2006-01-02 18:04:38 +00:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
2006-01-11 12:30:43 +00:00
|
|
|
* Redistribution and use in source and binary forms, with or without
|
2006-01-02 18:04:38 +00:00
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
2006-01-11 12:30:43 +00: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 18:04:38 +00:00
|
|
|
*
|
2006-01-11 12:30:43 +00: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 18:04:38 +00:00
|
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "core.h"
|
|
|
|
#include "link.h"
|
2014-11-20 09:29:12 +00:00
|
|
|
#include "bcast.h"
|
2014-05-14 09:39:15 +00:00
|
|
|
#include "socket.h"
|
2006-01-02 18:04:38 +00:00
|
|
|
#include "name_distr.h"
|
|
|
|
#include "discover.h"
|
2014-11-20 09:29:07 +00:00
|
|
|
#include "netlink.h"
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2013-06-17 14:54:48 +00:00
|
|
|
#include <linux/pkt_sched.h>
|
|
|
|
|
2012-06-29 04:16:37 +00:00
|
|
|
/*
|
|
|
|
* Error message prefixes
|
|
|
|
*/
|
|
|
|
static const char *link_co_err = "Link changeover error, ";
|
|
|
|
static const char *link_rst_msg = "Resetting link ";
|
|
|
|
static const char *link_unk_evt = "Unknown link event ";
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2014-11-20 09:29:12 +00:00
|
|
|
static const struct nla_policy tipc_nl_link_policy[TIPC_NLA_LINK_MAX + 1] = {
|
|
|
|
[TIPC_NLA_LINK_UNSPEC] = { .type = NLA_UNSPEC },
|
|
|
|
[TIPC_NLA_LINK_NAME] = {
|
|
|
|
.type = NLA_STRING,
|
|
|
|
.len = TIPC_MAX_LINK_NAME
|
|
|
|
},
|
|
|
|
[TIPC_NLA_LINK_MTU] = { .type = NLA_U32 },
|
|
|
|
[TIPC_NLA_LINK_BROADCAST] = { .type = NLA_FLAG },
|
|
|
|
[TIPC_NLA_LINK_UP] = { .type = NLA_FLAG },
|
|
|
|
[TIPC_NLA_LINK_ACTIVE] = { .type = NLA_FLAG },
|
|
|
|
[TIPC_NLA_LINK_PROP] = { .type = NLA_NESTED },
|
|
|
|
[TIPC_NLA_LINK_STATS] = { .type = NLA_NESTED },
|
|
|
|
[TIPC_NLA_LINK_RX] = { .type = NLA_U32 },
|
|
|
|
[TIPC_NLA_LINK_TX] = { .type = NLA_U32 }
|
|
|
|
};
|
|
|
|
|
2014-11-20 09:29:07 +00:00
|
|
|
/* Properties valid for media, bearar and link */
|
|
|
|
static const struct nla_policy tipc_nl_prop_policy[TIPC_NLA_PROP_MAX + 1] = {
|
|
|
|
[TIPC_NLA_PROP_UNSPEC] = { .type = NLA_UNSPEC },
|
|
|
|
[TIPC_NLA_PROP_PRIO] = { .type = NLA_U32 },
|
|
|
|
[TIPC_NLA_PROP_TOL] = { .type = NLA_U32 },
|
|
|
|
[TIPC_NLA_PROP_WIN] = { .type = NLA_U32 }
|
|
|
|
};
|
|
|
|
|
2008-06-05 00:29:39 +00:00
|
|
|
/*
|
|
|
|
* Out-of-range value for link session numbers
|
|
|
|
*/
|
|
|
|
#define INVALID_SESSION 0x10000
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
/*
|
|
|
|
* Link state events:
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
|
|
|
#define STARTING_EVT 856384768 /* link processing trigger */
|
|
|
|
#define TRAFFIC_MSG_EVT 560815u /* rx'd ??? */
|
|
|
|
#define TIMEOUT_EVT 560817u /* link timer expired */
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
/*
|
|
|
|
* The following two 'message types' is really just implementation
|
|
|
|
* data conveniently stored in the message header.
|
2006-01-02 18:04:38 +00:00
|
|
|
* They must not be considered part of the protocol
|
|
|
|
*/
|
|
|
|
#define OPEN_MSG 0
|
|
|
|
#define CLOSED_MSG 1
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
/*
|
2006-01-02 18:04:38 +00:00
|
|
|
* State value stored in 'exp_msg_count'
|
|
|
|
*/
|
|
|
|
#define START_CHANGEOVER 100000u
|
|
|
|
|
2015-02-05 13:36:36 +00:00
|
|
|
static void link_handle_out_of_seq_msg(struct tipc_link *link,
|
|
|
|
struct sk_buff *skb);
|
|
|
|
static void tipc_link_proto_rcv(struct tipc_link *link,
|
|
|
|
struct sk_buff *skb);
|
|
|
|
static int tipc_link_tunnel_rcv(struct tipc_node *node,
|
|
|
|
struct sk_buff **skb);
|
2015-01-09 07:27:00 +00:00
|
|
|
static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tol);
|
2011-12-30 01:58:42 +00:00
|
|
|
static void link_state_event(struct tipc_link *l_ptr, u32 event);
|
|
|
|
static void link_reset_statistics(struct tipc_link *l_ptr);
|
|
|
|
static void link_print(struct tipc_link *l_ptr, const char *str);
|
2014-02-18 08:06:46 +00:00
|
|
|
static void tipc_link_sync_xmit(struct tipc_link *l);
|
|
|
|
static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf);
|
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 13:36:41 +00:00
|
|
|
static void tipc_link_input(struct tipc_link *l, struct sk_buff *skb);
|
|
|
|
static bool tipc_data_input(struct tipc_link *l, struct sk_buff *skb);
|
2010-10-13 13:20:35 +00:00
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
/*
|
2006-03-21 06:37:04 +00:00
|
|
|
* Simple link routines
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2006-03-21 06:37:04 +00:00
|
|
|
static unsigned int align(unsigned int i)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
return (i + 3) & ~3u;
|
|
|
|
}
|
|
|
|
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
static void tipc_link_release(struct kref *kref)
|
|
|
|
{
|
|
|
|
kfree(container_of(kref, struct tipc_link, ref));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tipc_link_get(struct tipc_link *l_ptr)
|
|
|
|
{
|
|
|
|
kref_get(&l_ptr->ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tipc_link_put(struct tipc_link *l_ptr)
|
|
|
|
{
|
|
|
|
kref_put(&l_ptr->ref, tipc_link_release);
|
|
|
|
}
|
|
|
|
|
2011-12-30 01:58:42 +00:00
|
|
|
static void link_init_max_pkt(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2015-01-09 07:27:06 +00:00
|
|
|
struct tipc_node *node = l_ptr->owner;
|
|
|
|
struct tipc_net *tn = net_generic(node->net, tipc_net_id);
|
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 02:55:46 +00:00
|
|
|
struct tipc_bearer *b_ptr;
|
2006-01-02 18:04:38 +00:00
|
|
|
u32 max_pkt;
|
2007-02-09 14:25:21 +00: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 02:55:46 +00:00
|
|
|
rcu_read_lock();
|
2015-01-09 07:27:06 +00:00
|
|
|
b_ptr = rcu_dereference_rtnl(tn->bearer_list[l_ptr->bearer_id]);
|
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 02:55:46 +00:00
|
|
|
if (!b_ptr) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
max_pkt = (b_ptr->mtu & ~3);
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
if (max_pkt > MAX_MSG_SIZE)
|
|
|
|
max_pkt = MAX_MSG_SIZE;
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
l_ptr->max_pkt_target = max_pkt;
|
2006-01-02 18:04:38 +00:00
|
|
|
if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT)
|
|
|
|
l_ptr->max_pkt = l_ptr->max_pkt_target;
|
2007-02-09 14:25:21 +00:00
|
|
|
else
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->max_pkt = MAX_PKT_DEFAULT;
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
l_ptr->max_pkt_probes = 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-03-21 06:37:04 +00:00
|
|
|
* Simple non-static link routines (i.e. referenced outside this file)
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2011-12-30 01:58:42 +00:00
|
|
|
int tipc_link_is_up(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
if (!l_ptr)
|
|
|
|
return 0;
|
2010-09-22 20:43:57 +00:00
|
|
|
return link_working_working(l_ptr) || link_working_unknown(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2011-12-30 01:58:42 +00:00
|
|
|
int tipc_link_is_active(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2010-09-22 20:43:57 +00:00
|
|
|
return (l_ptr->owner->active_links[0] == l_ptr) ||
|
|
|
|
(l_ptr->owner->active_links[1] == l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* link_timeout - handle expiration of link timer
|
|
|
|
* @l_ptr: pointer to link
|
|
|
|
*/
|
2015-01-09 07:27:00 +00:00
|
|
|
static void link_timeout(unsigned long data)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2015-01-09 07:27:00 +00:00
|
|
|
struct tipc_link *l_ptr = (struct tipc_link *)data;
|
2014-11-26 03:41:52 +00:00
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_node_lock(l_ptr->owner);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
/* update counters used in statistical profiling of send traffic */
|
2014-11-26 03:41:52 +00:00
|
|
|
l_ptr->stats.accu_queue_sz += skb_queue_len(&l_ptr->outqueue);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->stats.queue_sz_counts++;
|
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
skb = skb_peek(&l_ptr->outqueue);
|
|
|
|
if (skb) {
|
|
|
|
struct tipc_msg *msg = buf_msg(skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
u32 length = msg_size(msg);
|
|
|
|
|
2009-11-30 00:55:45 +00:00
|
|
|
if ((msg_user(msg) == MSG_FRAGMENTER) &&
|
|
|
|
(msg_type(msg) == FIRST_FRAGMENT)) {
|
2006-01-02 18:04:38 +00:00
|
|
|
length = msg_size(msg_get_wrapped(msg));
|
|
|
|
}
|
|
|
|
if (length) {
|
|
|
|
l_ptr->stats.msg_lengths_total += length;
|
|
|
|
l_ptr->stats.msg_length_counts++;
|
|
|
|
if (length <= 64)
|
|
|
|
l_ptr->stats.msg_length_profile[0]++;
|
|
|
|
else if (length <= 256)
|
|
|
|
l_ptr->stats.msg_length_profile[1]++;
|
|
|
|
else if (length <= 1024)
|
|
|
|
l_ptr->stats.msg_length_profile[2]++;
|
|
|
|
else if (length <= 4096)
|
|
|
|
l_ptr->stats.msg_length_profile[3]++;
|
|
|
|
else if (length <= 16384)
|
|
|
|
l_ptr->stats.msg_length_profile[4]++;
|
|
|
|
else if (length <= 32768)
|
|
|
|
l_ptr->stats.msg_length_profile[5]++;
|
|
|
|
else
|
|
|
|
l_ptr->stats.msg_length_profile[6]++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* do all other link processing performed on a periodic basis */
|
|
|
|
link_state_event(l_ptr, TIMEOUT_EVT);
|
|
|
|
|
|
|
|
if (l_ptr->next_out)
|
2014-11-26 03:41:48 +00:00
|
|
|
tipc_link_push_packets(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_node_unlock(l_ptr->owner);
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
tipc_link_put(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2015-01-09 07:27:00 +00:00
|
|
|
static void link_set_timer(struct tipc_link *link, unsigned long time)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
if (!mod_timer(&link->timer, jiffies + time))
|
|
|
|
tipc_link_get(link);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-01-17 23:38:21 +00:00
|
|
|
* tipc_link_create - create a new link
|
2011-02-28 16:32:27 +00:00
|
|
|
* @n_ptr: pointer to associated node
|
2006-01-02 18:04:38 +00:00
|
|
|
* @b_ptr: pointer to associated bearer
|
|
|
|
* @media_addr: media address to use when sending messages over link
|
2007-02-09 14:25:21 +00:00
|
|
|
*
|
2006-01-02 18:04:38 +00:00
|
|
|
* Returns pointer to link.
|
|
|
|
*/
|
2011-12-30 01:58:42 +00:00
|
|
|
struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
|
tipc: remove 'links' list from tipc_bearer struct
In our ongoing effort to simplify the TIPC locking structure,
we see a need to remove the linked list for tipc_links
in the bearer. This can be explained as follows.
Currently, we have three different ways to access a link,
via three different lists/tables:
1: Via a node hash table:
Used by the time-critical outgoing/incoming data paths.
(e.g. link_send_sections_fast() and tipc_recv_msg() ):
grab net_lock(read)
find node from node hash table
grab node_lock
select link
grab bearer_lock
send_msg()
release bearer_lock
release node lock
release net_lock
2: Via a global linked list for nodes:
Used by configuration commands (link_cmd_set_value())
grab net_lock(read)
find node and link from global node list (using link name)
grab node_lock
update link
release node lock
release net_lock
(Same locking order as above. No problem.)
3: Via the bearer's linked link list:
Used by notifications from interface (e.g. tipc_disable_bearer() )
grab net_lock(write)
grab bearer_lock
get link ptr from bearer's link list
get node from link
grab node_lock
delete link
release node lock
release bearer_lock
release net_lock
(Different order from above, but works because we grab the
outer net_lock in write mode first, excluding all other access.)
The first major goal in our simplification effort is to get rid
of the "big" net_lock, replacing it with rcu-locks when accessing
the node list and node hash array. This will come in a later patch
series.
But to get there we first need to rewrite access methods ##2 and 3,
since removal of net_lock would introduce three major problems:
a) In access method #2, we access the link before taking the
protecting node_lock. This will not work once net_lock is gone,
so we will have to change the access order. We will deal with
this in a later commit in this series, "tipc: add node lock
protection to link found by link_find_link()".
b) When the outer protection from net_lock is gone, taking
bearer_lock and node_lock in opposite order of method 1) and 2)
will become an obvious deadlock hazard. This is fixed in the
commit ("tipc: remove bearer_lock from tipc_bearer struct")
later in this series.
c) Similar to what is described in problem a), access method #3
starts with using a link pointer that is unprotected by node_lock,
in order to via that pointer find the correct node struct and
lock it. Before we remove net_lock, this access order must be
altered. This is what we do with this commit.
We can avoid introducing problem problem c) by even here using the
global node list to find the node, before accessing its links. When
we loop though the node list we use the own bearer identity as search
criteria, thus easily finding the links that are associated to the
resetting/disabling bearer. It should be noted that although this
method is somewhat slower than the current list traversal, it is in
no way time critical. This is only about resetting or deleting links,
something that must be considered relatively infrequent events.
As a bonus, we can get rid of the mutual pointers between links and
bearers. After this commit, pointer dependency go in one direction
only: from the link to the bearer.
This commit pre-empts introduction of problem c) as described above.
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:09 +00:00
|
|
|
struct tipc_bearer *b_ptr,
|
|
|
|
const struct tipc_media_addr *media_addr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2015-01-09 07:27:10 +00:00
|
|
|
struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
|
2011-12-30 01:58:42 +00:00
|
|
|
struct tipc_link *l_ptr;
|
2006-01-02 18:04:38 +00:00
|
|
|
struct tipc_msg *msg;
|
|
|
|
char *if_name;
|
2011-02-28 16:32:27 +00:00
|
|
|
char addr_string[16];
|
|
|
|
u32 peer = n_ptr->addr;
|
|
|
|
|
2014-11-14 17:33:19 +00:00
|
|
|
if (n_ptr->link_cnt >= MAX_BEARERS) {
|
2011-02-28 16:32:27 +00:00
|
|
|
tipc_addr_string_fill(addr_string, n_ptr->addr);
|
2014-11-14 17:33:19 +00:00
|
|
|
pr_err("Attempt to establish %uth link to %s. Max %u allowed.\n",
|
|
|
|
n_ptr->link_cnt, addr_string, MAX_BEARERS);
|
2011-02-28 16:32:27 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n_ptr->links[b_ptr->identity]) {
|
|
|
|
tipc_addr_string_fill(addr_string, n_ptr->addr);
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_err("Attempt to establish second link on <%s> to %s\n",
|
|
|
|
b_ptr->name, addr_string);
|
2011-02-28 16:32:27 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2006-07-21 21:51:30 +00:00
|
|
|
l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!l_ptr) {
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_warn("Link creation failed, no memory\n");
|
2006-01-02 18:04:38 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
kref_init(&l_ptr->ref);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->addr = peer;
|
2011-01-07 18:00:11 +00:00
|
|
|
if_name = strchr(b_ptr->name, ':') + 1;
|
2011-04-07 13:28:47 +00:00
|
|
|
sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
|
2015-01-09 07:27:10 +00:00
|
|
|
tipc_zone(tn->own_addr), tipc_cluster(tn->own_addr),
|
|
|
|
tipc_node(tn->own_addr),
|
2006-01-02 18:04:38 +00:00
|
|
|
if_name,
|
|
|
|
tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
|
2011-04-07 13:28:47 +00:00
|
|
|
/* note: peer i/f name is updated by reset/activate message */
|
2006-01-02 18:04:38 +00:00
|
|
|
memcpy(&l_ptr->media_addr, media_addr, sizeof(*media_addr));
|
2011-02-28 16:32:27 +00:00
|
|
|
l_ptr->owner = n_ptr;
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->checkpoint = 1;
|
2011-04-07 13:43:27 +00:00
|
|
|
l_ptr->peer_session = INVALID_SESSION;
|
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 02:55:46 +00:00
|
|
|
l_ptr->bearer_id = b_ptr->identity;
|
2011-10-18 15:34:29 +00:00
|
|
|
link_set_supervision_props(l_ptr, b_ptr->tolerance);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->state = RESET_UNKNOWN;
|
|
|
|
|
|
|
|
l_ptr->pmsg = (struct tipc_msg *)&l_ptr->proto_msg;
|
|
|
|
msg = l_ptr->pmsg;
|
2015-02-05 13:36:36 +00:00
|
|
|
tipc_msg_init(tn->own_addr, msg, LINK_PROTOCOL, RESET_MSG, INT_H_SIZE,
|
2015-01-09 07:27:10 +00:00
|
|
|
l_ptr->addr);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_size(msg, sizeof(l_ptr->proto_msg));
|
2015-01-09 07:27:12 +00:00
|
|
|
msg_set_session(msg, (tn->random & 0xffff));
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_bearer_id(msg, b_ptr->identity);
|
|
|
|
strcpy((char *)msg_data(msg), if_name);
|
|
|
|
|
|
|
|
l_ptr->priority = b_ptr->priority;
|
2011-10-18 15:34:29 +00:00
|
|
|
tipc_link_set_queue_limits(l_ptr, b_ptr->window);
|
2006-01-02 18:04:38 +00: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 02:55:46 +00:00
|
|
|
l_ptr->net_plane = b_ptr->net_plane;
|
2006-01-02 18:04:38 +00:00
|
|
|
link_init_max_pkt(l_ptr);
|
|
|
|
|
|
|
|
l_ptr->next_out_no = 1;
|
2014-11-26 03:41:52 +00:00
|
|
|
__skb_queue_head_init(&l_ptr->outqueue);
|
2014-11-26 03:41:53 +00:00
|
|
|
__skb_queue_head_init(&l_ptr->deferred_queue);
|
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 13:36:41 +00:00
|
|
|
skb_queue_head_init(&l_ptr->wakeupq);
|
|
|
|
skb_queue_head_init(&l_ptr->inputq);
|
|
|
|
skb_queue_head_init(&l_ptr->namedq);
|
2006-01-02 18:04:38 +00:00
|
|
|
link_reset_statistics(l_ptr);
|
2011-02-28 16:32:27 +00:00
|
|
|
tipc_node_attach_link(n_ptr, l_ptr);
|
2015-01-09 07:27:00 +00:00
|
|
|
setup_timer(&l_ptr->timer, link_timeout, (unsigned long)l_ptr);
|
2014-01-07 22:02:44 +00:00
|
|
|
link_state_event(l_ptr, STARTING_EVT);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
return l_ptr;
|
|
|
|
}
|
|
|
|
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
/**
|
|
|
|
* link_delete - Conditional deletion of link.
|
|
|
|
* If timer still running, real delete is done when it expires
|
|
|
|
* @link: link to be deleted
|
|
|
|
*/
|
|
|
|
void tipc_link_delete(struct tipc_link *link)
|
|
|
|
{
|
|
|
|
tipc_link_reset_fragments(link);
|
|
|
|
tipc_node_detach_link(link->owner, link);
|
|
|
|
tipc_link_put(link);
|
|
|
|
}
|
|
|
|
|
2015-01-09 07:27:05 +00:00
|
|
|
void tipc_link_delete_list(struct net *net, unsigned int bearer_id,
|
|
|
|
bool shutting_down)
|
2014-02-13 22:29:07 +00:00
|
|
|
{
|
2015-01-09 07:27:05 +00:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
struct tipc_link *link;
|
|
|
|
struct tipc_node *node;
|
2014-02-13 22:29:07 +00:00
|
|
|
|
2014-03-27 04:54:37 +00:00
|
|
|
rcu_read_lock();
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
list_for_each_entry_rcu(node, &tn->node_list, list) {
|
|
|
|
tipc_node_lock(node);
|
|
|
|
link = node->links[bearer_id];
|
|
|
|
if (!link) {
|
|
|
|
tipc_node_unlock(node);
|
tipc: remove 'links' list from tipc_bearer struct
In our ongoing effort to simplify the TIPC locking structure,
we see a need to remove the linked list for tipc_links
in the bearer. This can be explained as follows.
Currently, we have three different ways to access a link,
via three different lists/tables:
1: Via a node hash table:
Used by the time-critical outgoing/incoming data paths.
(e.g. link_send_sections_fast() and tipc_recv_msg() ):
grab net_lock(read)
find node from node hash table
grab node_lock
select link
grab bearer_lock
send_msg()
release bearer_lock
release node lock
release net_lock
2: Via a global linked list for nodes:
Used by configuration commands (link_cmd_set_value())
grab net_lock(read)
find node and link from global node list (using link name)
grab node_lock
update link
release node lock
release net_lock
(Same locking order as above. No problem.)
3: Via the bearer's linked link list:
Used by notifications from interface (e.g. tipc_disable_bearer() )
grab net_lock(write)
grab bearer_lock
get link ptr from bearer's link list
get node from link
grab node_lock
delete link
release node lock
release bearer_lock
release net_lock
(Different order from above, but works because we grab the
outer net_lock in write mode first, excluding all other access.)
The first major goal in our simplification effort is to get rid
of the "big" net_lock, replacing it with rcu-locks when accessing
the node list and node hash array. This will come in a later patch
series.
But to get there we first need to rewrite access methods ##2 and 3,
since removal of net_lock would introduce three major problems:
a) In access method #2, we access the link before taking the
protecting node_lock. This will not work once net_lock is gone,
so we will have to change the access order. We will deal with
this in a later commit in this series, "tipc: add node lock
protection to link found by link_find_link()".
b) When the outer protection from net_lock is gone, taking
bearer_lock and node_lock in opposite order of method 1) and 2)
will become an obvious deadlock hazard. This is fixed in the
commit ("tipc: remove bearer_lock from tipc_bearer struct")
later in this series.
c) Similar to what is described in problem a), access method #3
starts with using a link pointer that is unprotected by node_lock,
in order to via that pointer find the correct node struct and
lock it. Before we remove net_lock, this access order must be
altered. This is what we do with this commit.
We can avoid introducing problem problem c) by even here using the
global node list to find the node, before accessing its links. When
we loop though the node list we use the own bearer identity as search
criteria, thus easily finding the links that are associated to the
resetting/disabling bearer. It should be noted that although this
method is somewhat slower than the current list traversal, it is in
no way time critical. This is only about resetting or deleting links,
something that must be considered relatively infrequent events.
As a bonus, we can get rid of the mutual pointers between links and
bearers. After this commit, pointer dependency go in one direction
only: from the link to the bearer.
This commit pre-empts introduction of problem c) as described above.
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:09 +00:00
|
|
|
continue;
|
|
|
|
}
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
tipc_link_reset(link);
|
|
|
|
if (del_timer(&link->timer))
|
|
|
|
tipc_link_put(link);
|
|
|
|
link->flags |= LINK_STOPPED;
|
|
|
|
/* Delete link now, or when failover is finished: */
|
|
|
|
if (shutting_down || !tipc_node_is_up(node))
|
|
|
|
tipc_link_delete(link);
|
|
|
|
tipc_node_unlock(node);
|
2014-02-13 22:29:07 +00:00
|
|
|
}
|
2014-03-27 04:54:37 +00:00
|
|
|
rcu_read_unlock();
|
2014-02-13 22:29:07 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
/**
|
2014-08-22 22:09:07 +00:00
|
|
|
* link_schedule_user - schedule user for wakeup after congestion
|
|
|
|
* @link: congested link
|
|
|
|
* @oport: sending port
|
|
|
|
* @chain_sz: size of buffer chain that was attempted sent
|
|
|
|
* @imp: importance of message attempted sent
|
|
|
|
* Create pseudo msg to send back to user when congestion abates
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2014-08-22 22:09:07 +00:00
|
|
|
static bool link_schedule_user(struct tipc_link *link, u32 oport,
|
|
|
|
uint chain_sz, uint imp)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-08-22 22:09:07 +00:00
|
|
|
struct sk_buff *buf;
|
|
|
|
|
2015-02-05 13:36:36 +00:00
|
|
|
buf = tipc_msg_create(SOCK_WAKEUP, 0, INT_H_SIZE, 0,
|
|
|
|
link_own_addr(link), link_own_addr(link),
|
|
|
|
oport, 0, 0);
|
2014-08-22 22:09:07 +00:00
|
|
|
if (!buf)
|
|
|
|
return false;
|
|
|
|
TIPC_SKB_CB(buf)->chain_sz = chain_sz;
|
|
|
|
TIPC_SKB_CB(buf)->chain_imp = imp;
|
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 13:36:41 +00:00
|
|
|
skb_queue_tail(&link->wakeupq, buf);
|
2014-08-22 22:09:07 +00:00
|
|
|
link->stats.link_congs++;
|
|
|
|
return true;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2014-08-22 22:09:07 +00:00
|
|
|
/**
|
|
|
|
* link_prepare_wakeup - prepare users for wakeup after congestion
|
|
|
|
* @link: congested link
|
|
|
|
* Move a number of waiting users, as permitted by available space in
|
|
|
|
* the send queue, from link wait queue to node wait queue for wakeup
|
|
|
|
*/
|
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 13:36:41 +00:00
|
|
|
void link_prepare_wakeup(struct tipc_link *link)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-11-26 03:41:52 +00:00
|
|
|
uint pend_qsz = skb_queue_len(&link->outqueue);
|
2014-11-26 03:41:51 +00:00
|
|
|
struct sk_buff *skb, *tmp;
|
2014-08-22 22:09:07 +00: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 13:36:41 +00:00
|
|
|
skb_queue_walk_safe(&link->wakeupq, skb, tmp) {
|
2014-11-26 03:41:51 +00:00
|
|
|
if (pend_qsz >= link->queue_limit[TIPC_SKB_CB(skb)->chain_imp])
|
2006-01-02 18:04:38 +00:00
|
|
|
break;
|
2014-11-26 03:41:51 +00:00
|
|
|
pend_qsz += TIPC_SKB_CB(skb)->chain_sz;
|
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 13:36:41 +00:00
|
|
|
skb_unlink(skb, &link->wakeupq);
|
|
|
|
skb_queue_tail(&link->inputq, skb);
|
|
|
|
link->owner->inputq = &link->inputq;
|
|
|
|
link->owner->action_flags |= TIPC_MSG_EVT;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-01-17 23:38:21 +00:00
|
|
|
* tipc_link_reset_fragments - purge link's inbound message fragments queue
|
2006-01-02 18:04:38 +00:00
|
|
|
* @l_ptr: pointer to link
|
|
|
|
*/
|
2011-12-30 01:58:42 +00:00
|
|
|
void tipc_link_reset_fragments(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-05-14 09:39:12 +00:00
|
|
|
kfree_skb(l_ptr->reasm_buf);
|
|
|
|
l_ptr->reasm_buf = NULL;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
/**
|
2014-01-07 22:02:44 +00:00
|
|
|
* tipc_link_purge_queues - purge all pkt queues associated with link
|
2006-01-02 18:04:38 +00:00
|
|
|
* @l_ptr: pointer to link
|
|
|
|
*/
|
2014-01-07 22:02:44 +00:00
|
|
|
void tipc_link_purge_queues(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-11-26 03:41:53 +00:00
|
|
|
__skb_queue_purge(&l_ptr->deferred_queue);
|
2014-11-26 03:41:52 +00:00
|
|
|
__skb_queue_purge(&l_ptr->outqueue);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_link_reset_fragments(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2011-12-30 01:58:42 +00:00
|
|
|
void tipc_link_reset(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
u32 prev_state = l_ptr->state;
|
|
|
|
u32 checkpoint = l_ptr->next_in_no;
|
2006-06-26 06:52:50 +00:00
|
|
|
int was_active_link = tipc_link_is_active(l_ptr);
|
2014-08-22 22:09:07 +00:00
|
|
|
struct tipc_node *owner = l_ptr->owner;
|
2007-02-09 14:25:21 +00:00
|
|
|
|
2008-06-05 00:29:39 +00:00
|
|
|
msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff));
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2008-06-05 00:29:39 +00:00
|
|
|
/* Link is down, accept any session */
|
|
|
|
l_ptr->peer_session = INVALID_SESSION;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
/* Prepare for max packet size negotiation */
|
2006-01-02 18:04:38 +00:00
|
|
|
link_init_max_pkt(l_ptr);
|
2007-02-09 14:25:21 +00:00
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->state = RESET_UNKNOWN;
|
|
|
|
|
|
|
|
if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))
|
|
|
|
return;
|
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_node_link_down(l_ptr->owner, l_ptr);
|
2015-01-09 07:27:06 +00:00
|
|
|
tipc_bearer_remove_dest(owner->net, l_ptr->bearer_id, l_ptr->addr);
|
2010-10-12 14:25:58 +00:00
|
|
|
|
2014-01-07 22:02:42 +00:00
|
|
|
if (was_active_link && tipc_node_active_links(l_ptr->owner)) {
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->reset_checkpoint = checkpoint;
|
|
|
|
l_ptr->exp_msg_count = START_CHANGEOVER;
|
|
|
|
}
|
|
|
|
|
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 13:36:41 +00:00
|
|
|
/* Clean up all queues, except inputq: */
|
2014-11-26 03:41:52 +00:00
|
|
|
__skb_queue_purge(&l_ptr->outqueue);
|
2014-11-26 03:41:53 +00:00
|
|
|
__skb_queue_purge(&l_ptr->deferred_queue);
|
2015-03-09 20:16:22 +00:00
|
|
|
if (!owner->inputq)
|
|
|
|
owner->inputq = &l_ptr->inputq;
|
|
|
|
skb_queue_splice_init(&l_ptr->wakeupq, owner->inputq);
|
|
|
|
if (!skb_queue_empty(owner->inputq))
|
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 13:36:41 +00:00
|
|
|
owner->action_flags |= TIPC_MSG_EVT;
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->next_out = NULL;
|
|
|
|
l_ptr->unacked_window = 0;
|
|
|
|
l_ptr->checkpoint = 1;
|
|
|
|
l_ptr->next_out_no = 1;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
|
|
|
l_ptr->stale_count = 0;
|
|
|
|
link_reset_statistics(l_ptr);
|
|
|
|
}
|
|
|
|
|
2015-01-09 07:27:05 +00:00
|
|
|
void tipc_link_reset_list(struct net *net, unsigned int bearer_id)
|
2014-02-13 22:29:06 +00:00
|
|
|
{
|
2015-01-09 07:27:05 +00:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2014-02-13 22:29:06 +00:00
|
|
|
struct tipc_link *l_ptr;
|
tipc: remove 'links' list from tipc_bearer struct
In our ongoing effort to simplify the TIPC locking structure,
we see a need to remove the linked list for tipc_links
in the bearer. This can be explained as follows.
Currently, we have three different ways to access a link,
via three different lists/tables:
1: Via a node hash table:
Used by the time-critical outgoing/incoming data paths.
(e.g. link_send_sections_fast() and tipc_recv_msg() ):
grab net_lock(read)
find node from node hash table
grab node_lock
select link
grab bearer_lock
send_msg()
release bearer_lock
release node lock
release net_lock
2: Via a global linked list for nodes:
Used by configuration commands (link_cmd_set_value())
grab net_lock(read)
find node and link from global node list (using link name)
grab node_lock
update link
release node lock
release net_lock
(Same locking order as above. No problem.)
3: Via the bearer's linked link list:
Used by notifications from interface (e.g. tipc_disable_bearer() )
grab net_lock(write)
grab bearer_lock
get link ptr from bearer's link list
get node from link
grab node_lock
delete link
release node lock
release bearer_lock
release net_lock
(Different order from above, but works because we grab the
outer net_lock in write mode first, excluding all other access.)
The first major goal in our simplification effort is to get rid
of the "big" net_lock, replacing it with rcu-locks when accessing
the node list and node hash array. This will come in a later patch
series.
But to get there we first need to rewrite access methods ##2 and 3,
since removal of net_lock would introduce three major problems:
a) In access method #2, we access the link before taking the
protecting node_lock. This will not work once net_lock is gone,
so we will have to change the access order. We will deal with
this in a later commit in this series, "tipc: add node lock
protection to link found by link_find_link()".
b) When the outer protection from net_lock is gone, taking
bearer_lock and node_lock in opposite order of method 1) and 2)
will become an obvious deadlock hazard. This is fixed in the
commit ("tipc: remove bearer_lock from tipc_bearer struct")
later in this series.
c) Similar to what is described in problem a), access method #3
starts with using a link pointer that is unprotected by node_lock,
in order to via that pointer find the correct node struct and
lock it. Before we remove net_lock, this access order must be
altered. This is what we do with this commit.
We can avoid introducing problem problem c) by even here using the
global node list to find the node, before accessing its links. When
we loop though the node list we use the own bearer identity as search
criteria, thus easily finding the links that are associated to the
resetting/disabling bearer. It should be noted that although this
method is somewhat slower than the current list traversal, it is in
no way time critical. This is only about resetting or deleting links,
something that must be considered relatively infrequent events.
As a bonus, we can get rid of the mutual pointers between links and
bearers. After this commit, pointer dependency go in one direction
only: from the link to the bearer.
This commit pre-empts introduction of problem c) as described above.
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:09 +00:00
|
|
|
struct tipc_node *n_ptr;
|
2014-02-13 22:29:06 +00:00
|
|
|
|
2014-03-27 04:54:37 +00:00
|
|
|
rcu_read_lock();
|
2015-01-09 07:27:05 +00:00
|
|
|
list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
|
2014-05-05 00:56:09 +00:00
|
|
|
tipc_node_lock(n_ptr);
|
tipc: remove 'links' list from tipc_bearer struct
In our ongoing effort to simplify the TIPC locking structure,
we see a need to remove the linked list for tipc_links
in the bearer. This can be explained as follows.
Currently, we have three different ways to access a link,
via three different lists/tables:
1: Via a node hash table:
Used by the time-critical outgoing/incoming data paths.
(e.g. link_send_sections_fast() and tipc_recv_msg() ):
grab net_lock(read)
find node from node hash table
grab node_lock
select link
grab bearer_lock
send_msg()
release bearer_lock
release node lock
release net_lock
2: Via a global linked list for nodes:
Used by configuration commands (link_cmd_set_value())
grab net_lock(read)
find node and link from global node list (using link name)
grab node_lock
update link
release node lock
release net_lock
(Same locking order as above. No problem.)
3: Via the bearer's linked link list:
Used by notifications from interface (e.g. tipc_disable_bearer() )
grab net_lock(write)
grab bearer_lock
get link ptr from bearer's link list
get node from link
grab node_lock
delete link
release node lock
release bearer_lock
release net_lock
(Different order from above, but works because we grab the
outer net_lock in write mode first, excluding all other access.)
The first major goal in our simplification effort is to get rid
of the "big" net_lock, replacing it with rcu-locks when accessing
the node list and node hash array. This will come in a later patch
series.
But to get there we first need to rewrite access methods ##2 and 3,
since removal of net_lock would introduce three major problems:
a) In access method #2, we access the link before taking the
protecting node_lock. This will not work once net_lock is gone,
so we will have to change the access order. We will deal with
this in a later commit in this series, "tipc: add node lock
protection to link found by link_find_link()".
b) When the outer protection from net_lock is gone, taking
bearer_lock and node_lock in opposite order of method 1) and 2)
will become an obvious deadlock hazard. This is fixed in the
commit ("tipc: remove bearer_lock from tipc_bearer struct")
later in this series.
c) Similar to what is described in problem a), access method #3
starts with using a link pointer that is unprotected by node_lock,
in order to via that pointer find the correct node struct and
lock it. Before we remove net_lock, this access order must be
altered. This is what we do with this commit.
We can avoid introducing problem problem c) by even here using the
global node list to find the node, before accessing its links. When
we loop though the node list we use the own bearer identity as search
criteria, thus easily finding the links that are associated to the
resetting/disabling bearer. It should be noted that although this
method is somewhat slower than the current list traversal, it is in
no way time critical. This is only about resetting or deleting links,
something that must be considered relatively infrequent events.
As a bonus, we can get rid of the mutual pointers between links and
bearers. After this commit, pointer dependency go in one direction
only: from the link to the bearer.
This commit pre-empts introduction of problem c) as described above.
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:09 +00:00
|
|
|
l_ptr = n_ptr->links[bearer_id];
|
|
|
|
if (l_ptr)
|
|
|
|
tipc_link_reset(l_ptr);
|
2014-05-05 00:56:09 +00:00
|
|
|
tipc_node_unlock(n_ptr);
|
2014-02-13 22:29:06 +00:00
|
|
|
}
|
2014-03-27 04:54:37 +00:00
|
|
|
rcu_read_unlock();
|
2014-02-13 22:29:06 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2015-01-09 07:27:06 +00:00
|
|
|
static void link_activate(struct tipc_link *link)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2015-01-09 07:27:06 +00:00
|
|
|
struct tipc_node *node = link->owner;
|
|
|
|
|
|
|
|
link->next_in_no = 1;
|
|
|
|
link->stats.recv_info = 1;
|
|
|
|
tipc_node_link_up(node, link);
|
|
|
|
tipc_bearer_add_dest(node->net, link->bearer_id, link->addr);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* link_state_event - link finite state machine
|
|
|
|
* @l_ptr: pointer to link
|
|
|
|
* @event: state machine event to process
|
|
|
|
*/
|
2012-04-15 05:58:06 +00:00
|
|
|
static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2011-12-30 01:58:42 +00:00
|
|
|
struct tipc_link *other;
|
2015-01-09 07:27:00 +00:00
|
|
|
unsigned long cont_intv = l_ptr->cont_intv;
|
2006-01-02 18:04:38 +00: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 22:29:16 +00:00
|
|
|
if (l_ptr->flags & LINK_STOPPED)
|
|
|
|
return;
|
|
|
|
|
2014-02-13 22:29:08 +00:00
|
|
|
if (!(l_ptr->flags & LINK_STARTED) && (event != STARTING_EVT))
|
2006-01-02 18:04:38 +00:00
|
|
|
return; /* Not yet. */
|
|
|
|
|
2013-12-11 04:45:44 +00:00
|
|
|
/* Check whether changeover is going on */
|
|
|
|
if (l_ptr->exp_msg_count) {
|
2010-12-31 18:59:35 +00:00
|
|
|
if (event == TIMEOUT_EVT)
|
2006-01-02 18:04:38 +00:00
|
|
|
link_set_timer(l_ptr, cont_intv);
|
2013-12-11 04:45:44 +00:00
|
|
|
return;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (l_ptr->state) {
|
|
|
|
case WORKING_WORKING:
|
|
|
|
switch (event) {
|
|
|
|
case TRAFFIC_MSG_EVT:
|
|
|
|
case ACTIVATE_MSG:
|
|
|
|
break;
|
|
|
|
case TIMEOUT_EVT:
|
|
|
|
if (l_ptr->next_in_no != l_ptr->checkpoint) {
|
|
|
|
l_ptr->checkpoint = l_ptr->next_in_no;
|
2006-01-17 23:38:21 +00:00
|
|
|
if (tipc_bclink_acks_missing(l_ptr->owner)) {
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG,
|
|
|
|
0, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
} else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG,
|
|
|
|
1, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
}
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
l_ptr->state = WORKING_UNKNOWN;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv / 4);
|
|
|
|
break;
|
|
|
|
case RESET_MSG:
|
2015-01-22 16:10:31 +00:00
|
|
|
pr_debug("%s<%s>, requested by peer\n",
|
|
|
|
link_rst_msg, l_ptr->name);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_link_reset(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->state = RESET_RESET;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
|
|
|
|
0, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
default:
|
2015-01-22 16:10:31 +00:00
|
|
|
pr_debug("%s%u in WW state\n", link_unk_evt, event);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WORKING_UNKNOWN:
|
|
|
|
switch (event) {
|
|
|
|
case TRAFFIC_MSG_EVT:
|
|
|
|
case ACTIVATE_MSG:
|
|
|
|
l_ptr->state = WORKING_WORKING;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
case RESET_MSG:
|
2015-01-22 16:10:31 +00:00
|
|
|
pr_debug("%s<%s>, requested by peer while probing\n",
|
|
|
|
link_rst_msg, l_ptr->name);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_link_reset(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->state = RESET_RESET;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
|
|
|
|
0, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
case TIMEOUT_EVT:
|
|
|
|
if (l_ptr->next_in_no != l_ptr->checkpoint) {
|
|
|
|
l_ptr->state = WORKING_WORKING;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
|
|
|
l_ptr->checkpoint = l_ptr->next_in_no;
|
2006-01-17 23:38:21 +00:00
|
|
|
if (tipc_bclink_acks_missing(l_ptr->owner)) {
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG,
|
|
|
|
0, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
}
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
} else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG,
|
|
|
|
1, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv / 4);
|
|
|
|
} else { /* Link has failed */
|
2015-01-22 16:10:31 +00:00
|
|
|
pr_debug("%s<%s>, peer not responding\n",
|
|
|
|
link_rst_msg, l_ptr->name);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_link_reset(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->state = RESET_UNKNOWN;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, RESET_MSG,
|
|
|
|
0, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_err("%s%u in WU state\n", link_unk_evt, event);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RESET_UNKNOWN:
|
|
|
|
switch (event) {
|
|
|
|
case TRAFFIC_MSG_EVT:
|
|
|
|
break;
|
|
|
|
case ACTIVATE_MSG:
|
|
|
|
other = l_ptr->owner->active_links[0];
|
2010-12-31 18:59:27 +00:00
|
|
|
if (other && link_working_unknown(other))
|
2006-01-02 18:04:38 +00:00
|
|
|
break;
|
|
|
|
l_ptr->state = WORKING_WORKING;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
|
|
|
link_activate(l_ptr);
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
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 05:51:31 +00:00
|
|
|
if (l_ptr->owner->working_links == 1)
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_sync_xmit(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
case RESET_MSG:
|
|
|
|
l_ptr->state = RESET_RESET;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
|
|
|
|
1, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
case STARTING_EVT:
|
2014-02-13 22:29:08 +00:00
|
|
|
l_ptr->flags |= LINK_STARTED;
|
tipc: separate link starting event from link timeout event
When a new link instance is created, it is trigged to start by
sending it a TIPC_STARTING_EVT, whereafter a regular link
reset is applied to it.
The starting event is codewise treated as a timeout event, and prompts
a link RESET message to be sent to the peer node, carrying a link
session identifier. The later link_reset() call nudges this session
identifier, whereafter all subsequent RESET messages will be sent out
with the new identifier. The latter session number overrides the former,
causing the peer to unconditionally accept it irrespective of its
current working state.
We don't think that this causes any problem, but it is not in accordance
with the protocol spec, and may cause confusion when debugging TIPC
sessions.
To avoid this, we make the starting event distinct from the
subsequent timeout events, by not allowing the former to send
out any RESET message. This eliminates the described problem.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:20 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
2006-01-02 18:04:38 +00:00
|
|
|
case TIMEOUT_EVT:
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
default:
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_err("%s%u in RU state\n", link_unk_evt, event);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RESET_RESET:
|
|
|
|
switch (event) {
|
|
|
|
case TRAFFIC_MSG_EVT:
|
|
|
|
case ACTIVATE_MSG:
|
|
|
|
other = l_ptr->owner->active_links[0];
|
2010-12-31 18:59:27 +00:00
|
|
|
if (other && link_working_unknown(other))
|
2006-01-02 18:04:38 +00:00
|
|
|
break;
|
|
|
|
l_ptr->state = WORKING_WORKING;
|
|
|
|
l_ptr->fsm_msg_cnt = 0;
|
|
|
|
link_activate(l_ptr);
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
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 05:51:31 +00:00
|
|
|
if (l_ptr->owner->working_links == 1)
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_sync_xmit(l_ptr);
|
2006-01-02 18:04:38 +00:00
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
case RESET_MSG:
|
|
|
|
break;
|
|
|
|
case TIMEOUT_EVT:
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,
|
|
|
|
0, 0, 0, 0, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->fsm_msg_cnt++;
|
|
|
|
link_set_timer(l_ptr, cont_intv);
|
|
|
|
break;
|
|
|
|
default:
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_err("%s%u in RR state\n", link_unk_evt, event);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_err("Unknown link state %u/%u\n", l_ptr->state, event);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
/* tipc_link_cong: determine return value and how to treat the
|
|
|
|
* sent buffer during link congestion.
|
|
|
|
* - For plain, errorless user data messages we keep the buffer and
|
|
|
|
* return -ELINKONG.
|
|
|
|
* - For all other messages we discard the buffer and return -EHOSTUNREACH
|
|
|
|
* - For TIPC internal messages we also reset the link
|
|
|
|
*/
|
2014-11-26 03:41:55 +00:00
|
|
|
static int tipc_link_cong(struct tipc_link *link, struct sk_buff_head *list)
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
{
|
2014-11-26 03:41:55 +00:00
|
|
|
struct sk_buff *skb = skb_peek(list);
|
|
|
|
struct tipc_msg *msg = buf_msg(skb);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
uint imp = tipc_msg_tot_importance(msg);
|
|
|
|
u32 oport = msg_tot_origport(msg);
|
|
|
|
|
2014-08-22 22:09:07 +00:00
|
|
|
if (unlikely(imp > TIPC_CRITICAL_IMPORTANCE)) {
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
pr_warn("%s<%s>, send queue full", link_rst_msg, link->name);
|
|
|
|
tipc_link_reset(link);
|
2014-08-22 22:09:07 +00:00
|
|
|
goto drop;
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
}
|
2014-08-22 22:09:07 +00:00
|
|
|
if (unlikely(msg_errcode(msg)))
|
|
|
|
goto drop;
|
|
|
|
if (unlikely(msg_reroute_cnt(msg)))
|
|
|
|
goto drop;
|
2014-11-26 03:41:55 +00:00
|
|
|
if (TIPC_SKB_CB(skb)->wakeup_pending)
|
2014-08-22 22:09:07 +00:00
|
|
|
return -ELINKCONG;
|
2014-11-26 03:41:55 +00:00
|
|
|
if (link_schedule_user(link, oport, skb_queue_len(list), imp))
|
2014-08-22 22:09:07 +00:00
|
|
|
return -ELINKCONG;
|
|
|
|
drop:
|
2014-11-26 03:41:55 +00:00
|
|
|
__skb_queue_purge(list);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
return -EHOSTUNREACH;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-07-17 00:41:03 +00:00
|
|
|
* __tipc_link_xmit(): same as tipc_link_xmit, but destlink is known & locked
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
* @link: link to use
|
2014-11-26 03:41:55 +00:00
|
|
|
* @list: chain of buffers containing message
|
|
|
|
*
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
* Consumes the buffer chain, except when returning -ELINKCONG
|
|
|
|
* Returns 0 if success, otherwise errno: -ELINKCONG, -EMSGSIZE (plain socket
|
|
|
|
* user data messages) or -EHOSTUNREACH (all other messages/senders)
|
|
|
|
* Only the socket functions tipc_send_stream() and tipc_send_packet() need
|
|
|
|
* to act on the return value, since they may need to do more send attempts.
|
|
|
|
*/
|
2015-01-09 07:27:06 +00:00
|
|
|
int __tipc_link_xmit(struct net *net, struct tipc_link *link,
|
|
|
|
struct sk_buff_head *list)
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
{
|
2014-11-26 03:41:55 +00:00
|
|
|
struct tipc_msg *msg = buf_msg(skb_peek(list));
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
uint psz = msg_size(msg);
|
|
|
|
uint sndlim = link->queue_limit[0];
|
|
|
|
uint imp = tipc_msg_tot_importance(msg);
|
|
|
|
uint mtu = link->max_pkt;
|
|
|
|
uint ack = mod(link->next_in_no - 1);
|
|
|
|
uint seqno = link->next_out_no;
|
|
|
|
uint bc_last_in = link->owner->bclink.last_in;
|
|
|
|
struct tipc_media_addr *addr = &link->media_addr;
|
2014-11-26 03:41:52 +00:00
|
|
|
struct sk_buff_head *outqueue = &link->outqueue;
|
2014-11-26 03:41:55 +00:00
|
|
|
struct sk_buff *skb, *tmp;
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
|
|
|
|
/* Match queue limits against msg importance: */
|
2014-11-26 03:41:52 +00:00
|
|
|
if (unlikely(skb_queue_len(outqueue) >= link->queue_limit[imp]))
|
2014-11-26 03:41:55 +00:00
|
|
|
return tipc_link_cong(link, list);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
|
|
|
|
/* Has valid packet limit been used ? */
|
|
|
|
if (unlikely(psz > mtu)) {
|
2014-11-26 03:41:55 +00:00
|
|
|
__skb_queue_purge(list);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Prepare each packet for sending, and add to outqueue: */
|
2014-11-26 03:41:55 +00:00
|
|
|
skb_queue_walk_safe(list, skb, tmp) {
|
|
|
|
__skb_unlink(skb, list);
|
2014-11-26 03:41:52 +00:00
|
|
|
msg = buf_msg(skb);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
msg_set_word(msg, 2, ((ack << 16) | mod(seqno)));
|
|
|
|
msg_set_bcast_ack(msg, bc_last_in);
|
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
if (skb_queue_len(outqueue) < sndlim) {
|
|
|
|
__skb_queue_tail(outqueue, skb);
|
2015-01-09 07:27:06 +00:00
|
|
|
tipc_bearer_send(net, link->bearer_id,
|
|
|
|
skb, addr);
|
2014-11-26 03:41:52 +00:00
|
|
|
link->next_out = NULL;
|
|
|
|
link->unacked_window = 0;
|
|
|
|
} else if (tipc_msg_bundle(outqueue, skb, mtu)) {
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
link->stats.sent_bundled++;
|
|
|
|
continue;
|
2015-02-05 13:36:36 +00:00
|
|
|
} else if (tipc_msg_make_bundle(outqueue, skb, mtu,
|
2014-11-26 03:41:52 +00:00
|
|
|
link->addr)) {
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
link->stats.sent_bundled++;
|
|
|
|
link->stats.sent_bundles++;
|
|
|
|
if (!link->next_out)
|
2014-11-26 03:41:52 +00:00
|
|
|
link->next_out = skb_peek_tail(outqueue);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
} else {
|
2014-11-26 03:41:52 +00:00
|
|
|
__skb_queue_tail(outqueue, skb);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
if (!link->next_out)
|
2014-11-26 03:41:52 +00:00
|
|
|
link->next_out = skb;
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
}
|
|
|
|
seqno++;
|
|
|
|
}
|
|
|
|
link->next_out_no = seqno;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-26 03:41:55 +00:00
|
|
|
static void skb2list(struct sk_buff *skb, struct sk_buff_head *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 13:36:41 +00:00
|
|
|
skb_queue_head_init(list);
|
2014-11-26 03:41:55 +00:00
|
|
|
__skb_queue_tail(list, skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __tipc_link_xmit_skb(struct tipc_link *link, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct sk_buff_head head;
|
|
|
|
|
|
|
|
skb2list(skb, &head);
|
2015-01-09 07:27:06 +00:00
|
|
|
return __tipc_link_xmit(link->owner->net, link, &head);
|
2014-11-26 03:41:55 +00:00
|
|
|
}
|
|
|
|
|
2015-01-09 07:27:05 +00:00
|
|
|
int tipc_link_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode,
|
|
|
|
u32 selector)
|
2014-11-26 03:41:55 +00:00
|
|
|
{
|
|
|
|
struct sk_buff_head head;
|
|
|
|
|
|
|
|
skb2list(skb, &head);
|
2015-01-09 07:27:05 +00:00
|
|
|
return tipc_link_xmit(net, &head, dnode, selector);
|
2014-11-26 03:41:55 +00:00
|
|
|
}
|
|
|
|
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
/**
|
2014-07-17 00:41:03 +00:00
|
|
|
* tipc_link_xmit() is the general link level function for message sending
|
2015-01-09 07:27:05 +00:00
|
|
|
* @net: the applicable net namespace
|
2014-11-26 03:41:55 +00:00
|
|
|
* @list: chain of buffers containing message
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
* @dsz: amount of user data to be sent
|
|
|
|
* @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
|
|
|
|
*/
|
2015-01-09 07:27:05 +00:00
|
|
|
int tipc_link_xmit(struct net *net, struct sk_buff_head *list, u32 dnode,
|
|
|
|
u32 selector)
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
{
|
|
|
|
struct tipc_link *link = NULL;
|
|
|
|
struct tipc_node *node;
|
|
|
|
int rc = -EHOSTUNREACH;
|
|
|
|
|
2015-01-09 07:27:05 +00:00
|
|
|
node = tipc_node_find(net, dnode);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
if (node) {
|
|
|
|
tipc_node_lock(node);
|
|
|
|
link = node->active_links[selector & 1];
|
|
|
|
if (link)
|
2015-01-09 07:27:06 +00:00
|
|
|
rc = __tipc_link_xmit(net, link, list);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
tipc_node_unlock(node);
|
|
|
|
}
|
|
|
|
if (link)
|
|
|
|
return rc;
|
|
|
|
|
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 13:36:41 +00:00
|
|
|
if (likely(in_own_node(net, dnode)))
|
|
|
|
return tipc_sk_rcv(net, list);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00: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 13:36:41 +00:00
|
|
|
__skb_queue_purge(list);
|
tipc: introduce send functions for chained buffers in link
The current link implementation provides several different transmit
functions, depending on the characteristics of the message to be
sent: if it is an iovec or an sk_buff, if it needs fragmentation or
not, if the caller holds the node_lock or not. The permutation of
these options gives us an unwanted amount of unnecessarily complex
code.
As a first step towards simplifying the send path for all messages,
we introduce two new send functions at link level, tipc_link_xmit2()
and __tipc_link_xmit2(). The former looks up a link to the message
destination, and if one is found, it grabs the node lock and calls
the second function, which works exclusively inside the node lock
protection. If no link is found, and the destination is on the same
node, it delivers the message directly to the local destination
socket.
The new functions take a buffer chain where all packet headers are
already prepared, and the correct MTU has been used. These two
functions will later replace all other link-level transmit functions.
The functions are not backwards compatible, so we have added them
as new functions with temporary names. They are tested, but have no
users yet. Those will be added later in this series.
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-06-26 01:41:32 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
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 05:51:31 +00:00
|
|
|
/*
|
2014-02-18 08:06:46 +00:00
|
|
|
* tipc_link_sync_xmit - synchronize broadcast link endpoints.
|
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 05:51:31 +00:00
|
|
|
*
|
|
|
|
* Give a newly added peer node the sequence number where it should
|
|
|
|
* start receiving and acking broadcast packets.
|
|
|
|
*
|
|
|
|
* Called with node locked
|
|
|
|
*/
|
2014-07-17 00:40:59 +00:00
|
|
|
static void tipc_link_sync_xmit(struct tipc_link *link)
|
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 05:51:31 +00:00
|
|
|
{
|
2014-11-26 03:41:55 +00:00
|
|
|
struct sk_buff *skb;
|
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 05:51:31 +00:00
|
|
|
struct tipc_msg *msg;
|
|
|
|
|
2014-11-26 03:41:55 +00:00
|
|
|
skb = tipc_buf_acquire(INT_H_SIZE);
|
|
|
|
if (!skb)
|
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 05:51:31 +00:00
|
|
|
return;
|
|
|
|
|
2014-11-26 03:41:55 +00:00
|
|
|
msg = buf_msg(skb);
|
2015-02-05 13:36:36 +00:00
|
|
|
tipc_msg_init(link_own_addr(link), msg, BCAST_PROTOCOL, STATE_MSG,
|
2015-01-09 07:27:10 +00:00
|
|
|
INT_H_SIZE, link->addr);
|
2014-07-17 00:40:59 +00:00
|
|
|
msg_set_last_bcast(msg, link->owner->bclink.acked);
|
2014-11-26 03:41:55 +00:00
|
|
|
__tipc_link_xmit_skb(link, skb);
|
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 05:51:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-02-18 08:06:46 +00:00
|
|
|
* tipc_link_sync_rcv - synchronize broadcast link endpoints.
|
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 05:51:31 +00:00
|
|
|
* Receive the sequence number where we should start receiving and
|
|
|
|
* acking broadcast packets from a newly added peer node, and open
|
|
|
|
* up for reception of such packets.
|
|
|
|
*
|
|
|
|
* Called with node locked
|
|
|
|
*/
|
2014-02-18 08:06:46 +00:00
|
|
|
static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf)
|
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 05:51:31 +00:00
|
|
|
{
|
|
|
|
struct tipc_msg *msg = buf_msg(buf);
|
|
|
|
|
|
|
|
n->bclink.last_sent = n->bclink.last_in = msg_last_bcast(msg);
|
|
|
|
n->bclink.recv_permitted = true;
|
|
|
|
kfree_skb(buf);
|
|
|
|
}
|
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
struct sk_buff *tipc_skb_queue_next(const struct sk_buff_head *list,
|
|
|
|
const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
if (skb_queue_is_last(list, skb))
|
|
|
|
return NULL;
|
|
|
|
return skb->next;
|
|
|
|
}
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
/*
|
2014-11-26 03:41:48 +00:00
|
|
|
* tipc_link_push_packets - push unsent packets to bearer
|
|
|
|
*
|
|
|
|
* Push out the unsent messages of a link where congestion
|
|
|
|
* has abated. Node is locked.
|
|
|
|
*
|
|
|
|
* Called with node locked
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2014-11-26 03:41:48 +00:00
|
|
|
void tipc_link_push_packets(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-11-26 03:41:52 +00:00
|
|
|
struct sk_buff_head *outqueue = &l_ptr->outqueue;
|
|
|
|
struct sk_buff *skb = l_ptr->next_out;
|
2014-11-26 03:41:48 +00:00
|
|
|
struct tipc_msg *msg;
|
|
|
|
u32 next, first;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
skb_queue_walk_from(outqueue, skb) {
|
2014-11-26 03:41:48 +00:00
|
|
|
msg = buf_msg(skb);
|
|
|
|
next = msg_seqno(msg);
|
2014-11-26 03:41:52 +00:00
|
|
|
first = buf_seqno(skb_peek(outqueue));
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
if (mod(next - first) < l_ptr->queue_limit[0]) {
|
|
|
|
msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
|
2007-02-09 14:25:21 +00:00
|
|
|
msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
|
2012-11-15 03:34:45 +00:00
|
|
|
if (msg_user(msg) == MSG_BUNDLER)
|
2014-11-26 03:41:49 +00:00
|
|
|
TIPC_SKB_CB(skb)->bundling = false;
|
2015-01-09 07:27:06 +00:00
|
|
|
tipc_bearer_send(l_ptr->owner->net,
|
|
|
|
l_ptr->bearer_id, skb,
|
2014-11-26 03:41:48 +00:00
|
|
|
&l_ptr->media_addr);
|
2014-11-26 03:41:52 +00:00
|
|
|
l_ptr->next_out = tipc_skb_queue_next(outqueue, skb);
|
2014-11-26 03:41:48 +00:00
|
|
|
} else {
|
|
|
|
break;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-05 00:56:17 +00:00
|
|
|
void tipc_link_reset_all(struct tipc_node *node)
|
2006-06-26 06:40:01 +00:00
|
|
|
{
|
|
|
|
char addr_string[16];
|
|
|
|
u32 i;
|
|
|
|
|
2014-05-05 00:56:17 +00:00
|
|
|
tipc_node_lock(node);
|
2006-06-26 06:40:01 +00:00
|
|
|
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_warn("Resetting all links to %s\n",
|
2014-05-05 00:56:17 +00:00
|
|
|
tipc_addr_string_fill(addr_string, node->addr));
|
2006-06-26 06:40:01 +00:00
|
|
|
|
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
2014-05-05 00:56:17 +00:00
|
|
|
if (node->links[i]) {
|
|
|
|
link_print(node->links[i], "Resetting link\n");
|
|
|
|
tipc_link_reset(node->links[i]);
|
2006-06-26 06:40:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-05 00:56:17 +00:00
|
|
|
tipc_node_unlock(node);
|
2006-06-26 06:40:01 +00:00
|
|
|
}
|
|
|
|
|
2011-12-30 01:58:42 +00:00
|
|
|
static void link_retransmit_failure(struct tipc_link *l_ptr,
|
2013-06-17 14:54:47 +00:00
|
|
|
struct sk_buff *buf)
|
2006-06-26 06:40:01 +00:00
|
|
|
{
|
|
|
|
struct tipc_msg *msg = buf_msg(buf);
|
2015-01-09 07:27:07 +00:00
|
|
|
struct net *net = l_ptr->owner->net;
|
2006-06-26 06:40:01 +00:00
|
|
|
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_warn("Retransmission failure on link <%s>\n", l_ptr->name);
|
2006-06-26 06:40:01 +00:00
|
|
|
|
|
|
|
if (l_ptr->addr) {
|
|
|
|
/* Handle failure on standard link */
|
2010-12-31 18:59:27 +00:00
|
|
|
link_print(l_ptr, "Resetting link\n");
|
2006-06-26 06:40:01 +00:00
|
|
|
tipc_link_reset(l_ptr);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* Handle failure on broadcast link */
|
2008-09-03 06:38:32 +00:00
|
|
|
struct tipc_node *n_ptr;
|
2006-06-26 06:40:01 +00:00
|
|
|
char addr_string[16];
|
|
|
|
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_info("Msg seq number: %u, ", msg_seqno(msg));
|
|
|
|
pr_cont("Outstanding acks: %lu\n",
|
|
|
|
(unsigned long) TIPC_SKB_CB(buf)->handle);
|
2006-10-03 23:25:34 +00:00
|
|
|
|
2015-01-09 07:27:07 +00:00
|
|
|
n_ptr = tipc_bclink_retransmit_to(net);
|
2006-06-26 06:40:01 +00:00
|
|
|
tipc_node_lock(n_ptr);
|
|
|
|
|
2010-05-11 14:30:12 +00:00
|
|
|
tipc_addr_string_fill(addr_string, n_ptr->addr);
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_info("Broadcast link info for %s\n", addr_string);
|
2012-11-16 05:51:30 +00:00
|
|
|
pr_info("Reception permitted: %d, Acked: %u\n",
|
|
|
|
n_ptr->bclink.recv_permitted,
|
2012-06-29 04:16:37 +00:00
|
|
|
n_ptr->bclink.acked);
|
|
|
|
pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
|
|
|
|
n_ptr->bclink.last_in,
|
|
|
|
n_ptr->bclink.oos_state,
|
|
|
|
n_ptr->bclink.last_sent);
|
2006-06-26 06:40:01 +00:00
|
|
|
|
|
|
|
tipc_node_unlock(n_ptr);
|
|
|
|
|
2015-01-09 07:27:07 +00:00
|
|
|
tipc_bclink_set_flags(net, TIPC_BCLINK_RESET);
|
2006-06-26 06:40:01 +00:00
|
|
|
l_ptr->stale_count = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *skb,
|
2006-01-17 23:38:21 +00:00
|
|
|
u32 retransmits)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
struct tipc_msg *msg;
|
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
if (!skb)
|
2006-06-26 06:40:01 +00:00
|
|
|
return;
|
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
msg = buf_msg(skb);
|
2007-02-09 14:25:21 +00:00
|
|
|
|
tipc: remove interface state mirroring in bearer
struct 'tipc_bearer' is a generic representation of the underlying
media type, and exists in a one-to-one relationship to each interface
TIPC is using. The struct contains a 'blocked' flag that mirrors the
operational and execution state of the represented interface, and is
updated through notification calls from the latter. The users of
tipc_bearer are checking this flag before each attempt to send a
packet via the interface.
This state mirroring serves no purpose in the current code base. TIPC
links will not discover a media failure any faster through this
mechanism, and in reality the flag only adds overhead at packet
sending and reception.
Furthermore, the fact that the flag needs to be protected by a spinlock
aggregated into tipc_bearer has turned out to cause a serious and
completely unnecessary deadlock problem.
CPU0 CPU1
---- ----
Time 0: bearer_disable() link_timeout()
Time 1: spin_lock_bh(&b_ptr->lock) tipc_link_push_queue()
Time 2: tipc_link_delete() tipc_bearer_blocked(b_ptr)
Time 3: k_cancel_timer(&req->timer) spin_lock_bh(&b_ptr->lock)
Time 4: del_timer_sync(&req->timer)
I.e., del_timer_sync() on CPU0 never returns, because the timer handler
on CPU1 is waiting for the bearer lock.
We eliminate the 'blocked' flag from struct tipc_bearer, along with all
tests on this flag. This not only resolves the deadlock, but also
simplifies and speeds up the data path execution of TIPC. It also fits
well into our ongoing effort to make the locking policy simpler and
more manageable.
An effect of this change is that we can get rid of functions such as
tipc_bearer_blocked(), tipc_continue() and tipc_block_bearer().
We replace the latter with a new function, tipc_reset_bearer(), which
resets all links associated to the bearer immediately after an
interface goes down.
A user might notice one slight change in link behaviour after this
change. When an interface goes down, (e.g. through a NETDEV_DOWN
event) all attached links will be reset immediately, instead of
leaving it to each link to detect the failure through a timer-driven
mechanism. We consider this an improvement, and see no obvious risks
with the new behavior.
Signed-off-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Paul Gortmaker <Paul.Gortmaker@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-12-06 15:08:00 +00:00
|
|
|
/* Detect repeated retransmit failures */
|
|
|
|
if (l_ptr->last_retransmitted == msg_seqno(msg)) {
|
|
|
|
if (++l_ptr->stale_count > 100) {
|
2014-11-26 03:41:52 +00:00
|
|
|
link_retransmit_failure(l_ptr, skb);
|
tipc: remove interface state mirroring in bearer
struct 'tipc_bearer' is a generic representation of the underlying
media type, and exists in a one-to-one relationship to each interface
TIPC is using. The struct contains a 'blocked' flag that mirrors the
operational and execution state of the represented interface, and is
updated through notification calls from the latter. The users of
tipc_bearer are checking this flag before each attempt to send a
packet via the interface.
This state mirroring serves no purpose in the current code base. TIPC
links will not discover a media failure any faster through this
mechanism, and in reality the flag only adds overhead at packet
sending and reception.
Furthermore, the fact that the flag needs to be protected by a spinlock
aggregated into tipc_bearer has turned out to cause a serious and
completely unnecessary deadlock problem.
CPU0 CPU1
---- ----
Time 0: bearer_disable() link_timeout()
Time 1: spin_lock_bh(&b_ptr->lock) tipc_link_push_queue()
Time 2: tipc_link_delete() tipc_bearer_blocked(b_ptr)
Time 3: k_cancel_timer(&req->timer) spin_lock_bh(&b_ptr->lock)
Time 4: del_timer_sync(&req->timer)
I.e., del_timer_sync() on CPU0 never returns, because the timer handler
on CPU1 is waiting for the bearer lock.
We eliminate the 'blocked' flag from struct tipc_bearer, along with all
tests on this flag. This not only resolves the deadlock, but also
simplifies and speeds up the data path execution of TIPC. It also fits
well into our ongoing effort to make the locking policy simpler and
more manageable.
An effect of this change is that we can get rid of functions such as
tipc_bearer_blocked(), tipc_continue() and tipc_block_bearer().
We replace the latter with a new function, tipc_reset_bearer(), which
resets all links associated to the bearer immediately after an
interface goes down.
A user might notice one slight change in link behaviour after this
change. When an interface goes down, (e.g. through a NETDEV_DOWN
event) all attached links will be reset immediately, instead of
leaving it to each link to detect the failure through a timer-driven
mechanism. We consider this an improvement, and see no obvious risks
with the new behavior.
Signed-off-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Paul Gortmaker <Paul.Gortmaker@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-12-06 15:08:00 +00:00
|
|
|
return;
|
2006-06-26 06:40:01 +00:00
|
|
|
}
|
|
|
|
} else {
|
tipc: remove interface state mirroring in bearer
struct 'tipc_bearer' is a generic representation of the underlying
media type, and exists in a one-to-one relationship to each interface
TIPC is using. The struct contains a 'blocked' flag that mirrors the
operational and execution state of the represented interface, and is
updated through notification calls from the latter. The users of
tipc_bearer are checking this flag before each attempt to send a
packet via the interface.
This state mirroring serves no purpose in the current code base. TIPC
links will not discover a media failure any faster through this
mechanism, and in reality the flag only adds overhead at packet
sending and reception.
Furthermore, the fact that the flag needs to be protected by a spinlock
aggregated into tipc_bearer has turned out to cause a serious and
completely unnecessary deadlock problem.
CPU0 CPU1
---- ----
Time 0: bearer_disable() link_timeout()
Time 1: spin_lock_bh(&b_ptr->lock) tipc_link_push_queue()
Time 2: tipc_link_delete() tipc_bearer_blocked(b_ptr)
Time 3: k_cancel_timer(&req->timer) spin_lock_bh(&b_ptr->lock)
Time 4: del_timer_sync(&req->timer)
I.e., del_timer_sync() on CPU0 never returns, because the timer handler
on CPU1 is waiting for the bearer lock.
We eliminate the 'blocked' flag from struct tipc_bearer, along with all
tests on this flag. This not only resolves the deadlock, but also
simplifies and speeds up the data path execution of TIPC. It also fits
well into our ongoing effort to make the locking policy simpler and
more manageable.
An effect of this change is that we can get rid of functions such as
tipc_bearer_blocked(), tipc_continue() and tipc_block_bearer().
We replace the latter with a new function, tipc_reset_bearer(), which
resets all links associated to the bearer immediately after an
interface goes down.
A user might notice one slight change in link behaviour after this
change. When an interface goes down, (e.g. through a NETDEV_DOWN
event) all attached links will be reset immediately, instead of
leaving it to each link to detect the failure through a timer-driven
mechanism. We consider this an improvement, and see no obvious risks
with the new behavior.
Signed-off-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Paul Gortmaker <Paul.Gortmaker@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-12-06 15:08:00 +00:00
|
|
|
l_ptr->last_retransmitted = msg_seqno(msg);
|
|
|
|
l_ptr->stale_count = 1;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2006-06-26 06:40:01 +00:00
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
skb_queue_walk_from(&l_ptr->outqueue, skb) {
|
|
|
|
if (!retransmits || skb == l_ptr->next_out)
|
|
|
|
break;
|
|
|
|
msg = buf_msg(skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
|
2007-02-09 14:25:21 +00:00
|
|
|
msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
|
2015-01-09 07:27:06 +00:00
|
|
|
tipc_bearer_send(l_ptr->owner->net, l_ptr->bearer_id, skb,
|
|
|
|
&l_ptr->media_addr);
|
2012-11-15 03:34:45 +00:00
|
|
|
retransmits--;
|
|
|
|
l_ptr->stats.retransmitted++;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-26 03:41:54 +00:00
|
|
|
static void link_retrieve_defq(struct tipc_link *link,
|
|
|
|
struct sk_buff_head *list)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
u32 seq_no;
|
|
|
|
|
2014-11-26 03:41:54 +00:00
|
|
|
if (skb_queue_empty(&link->deferred_queue))
|
|
|
|
return;
|
|
|
|
|
|
|
|
seq_no = buf_seqno(skb_peek(&link->deferred_queue));
|
|
|
|
if (seq_no == mod(link->next_in_no))
|
|
|
|
skb_queue_splice_tail_init(&link->deferred_queue, list);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2008-04-16 02:04:54 +00:00
|
|
|
/**
|
|
|
|
* link_recv_buf_validate - validate basic format of received message
|
|
|
|
*
|
|
|
|
* This routine ensures a TIPC message has an acceptable header, and at least
|
|
|
|
* as much data as the header indicates it should. The routine also ensures
|
|
|
|
* that the entire message header is stored in the main fragment of the message
|
|
|
|
* buffer, to simplify future access to message header fields.
|
|
|
|
*
|
|
|
|
* Note: Having extra info present in the message header or data areas is OK.
|
|
|
|
* TIPC will ignore the excess, under the assumption that it is optional info
|
|
|
|
* introduced by a later release of the protocol.
|
|
|
|
*/
|
|
|
|
static int link_recv_buf_validate(struct sk_buff *buf)
|
|
|
|
{
|
|
|
|
static u32 min_data_hdr_size[8] = {
|
2011-05-31 19:03:18 +00:00
|
|
|
SHORT_H_SIZE, MCAST_H_SIZE, NAMED_H_SIZE, BASIC_H_SIZE,
|
2008-04-16 02:04:54 +00:00
|
|
|
MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tipc_msg *msg;
|
|
|
|
u32 tipc_hdr[2];
|
|
|
|
u32 size;
|
|
|
|
u32 hdr_size;
|
|
|
|
u32 min_hdr_size;
|
|
|
|
|
2014-02-11 10:38:26 +00:00
|
|
|
/* If this packet comes from the defer queue, the skb has already
|
|
|
|
* been validated
|
|
|
|
*/
|
|
|
|
if (unlikely(TIPC_SKB_CB(buf)->deferred))
|
|
|
|
return 1;
|
|
|
|
|
2008-04-16 02:04:54 +00:00
|
|
|
if (unlikely(buf->len < MIN_H_SIZE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
msg = skb_header_pointer(buf, 0, sizeof(tipc_hdr), tipc_hdr);
|
|
|
|
if (msg == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (unlikely(msg_version(msg) != TIPC_VERSION))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
size = msg_size(msg);
|
|
|
|
hdr_size = msg_hdr_sz(msg);
|
|
|
|
min_hdr_size = msg_isdata(msg) ?
|
|
|
|
min_data_hdr_size[msg_type(msg)] : INT_H_SIZE;
|
|
|
|
|
|
|
|
if (unlikely((hdr_size < min_hdr_size) ||
|
|
|
|
(size < hdr_size) ||
|
|
|
|
(buf->len < size) ||
|
|
|
|
(size - hdr_size > TIPC_MAX_USER_MSG_SIZE)))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return pskb_may_pull(buf, hdr_size);
|
|
|
|
}
|
|
|
|
|
2010-08-17 11:00:07 +00:00
|
|
|
/**
|
2014-01-07 22:02:41 +00:00
|
|
|
* tipc_rcv - process TIPC packets/messages arriving from off-node
|
2015-01-09 07:27:05 +00:00
|
|
|
* @net: the applicable net namespace
|
2014-11-26 03:41:54 +00:00
|
|
|
* @skb: TIPC packet
|
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 02:55:46 +00:00
|
|
|
* @b_ptr: pointer to bearer message arrived on
|
2010-08-17 11:00:07 +00:00
|
|
|
*
|
|
|
|
* Invoked with no locks held. Bearer pointer must point to a valid bearer
|
|
|
|
* structure (i.e. cannot be NULL), but bearer can be inactive.
|
|
|
|
*/
|
2015-01-09 07:27:04 +00:00
|
|
|
void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2015-01-09 07:27:10 +00:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2014-11-26 03:41:54 +00:00
|
|
|
struct sk_buff_head head;
|
|
|
|
struct tipc_node *n_ptr;
|
|
|
|
struct tipc_link *l_ptr;
|
|
|
|
struct sk_buff *skb1, *tmp;
|
|
|
|
struct tipc_msg *msg;
|
|
|
|
u32 seq_no;
|
|
|
|
u32 ackd;
|
|
|
|
u32 released;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2014-11-26 03:41:55 +00:00
|
|
|
skb2list(skb, &head);
|
2008-04-16 02:04:54 +00:00
|
|
|
|
2014-11-26 03:41:54 +00:00
|
|
|
while ((skb = __skb_dequeue(&head))) {
|
2008-04-16 02:04:54 +00:00
|
|
|
/* Ensure message is well-formed */
|
2014-11-26 03:41:54 +00:00
|
|
|
if (unlikely(!link_recv_buf_validate(skb)))
|
2013-10-30 03:26:57 +00:00
|
|
|
goto discard;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2008-04-16 02:03:23 +00:00
|
|
|
/* Ensure message data is a single contiguous unit */
|
2014-11-26 03:41:54 +00:00
|
|
|
if (unlikely(skb_linearize(skb)))
|
2013-10-30 03:26:57 +00:00
|
|
|
goto discard;
|
2008-04-16 02:03:23 +00:00
|
|
|
|
2008-04-16 02:04:54 +00:00
|
|
|
/* Handle arrival of a non-unicast link message */
|
2014-11-26 03:41:54 +00:00
|
|
|
msg = buf_msg(skb);
|
2008-04-16 02:04:54 +00:00
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
if (unlikely(msg_non_seq(msg))) {
|
2008-06-05 00:32:35 +00:00
|
|
|
if (msg_user(msg) == LINK_CONFIG)
|
2015-01-09 07:27:04 +00:00
|
|
|
tipc_disc_rcv(net, skb, b_ptr);
|
2008-06-05 00:32:35 +00:00
|
|
|
else
|
2015-01-09 07:27:04 +00:00
|
|
|
tipc_bclink_rcv(net, skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-02-09 14:25:21 +00:00
|
|
|
|
2011-04-05 19:15:04 +00:00
|
|
|
/* Discard unicast link messages destined for another node */
|
2006-06-26 06:39:31 +00:00
|
|
|
if (unlikely(!msg_short(msg) &&
|
2015-01-09 07:27:10 +00:00
|
|
|
(msg_destnode(msg) != tn->own_addr)))
|
2013-10-30 03:26:57 +00:00
|
|
|
goto discard;
|
2007-02-09 14:25:21 +00:00
|
|
|
|
2010-08-17 11:00:16 +00:00
|
|
|
/* Locate neighboring node that sent message */
|
2015-01-09 07:27:05 +00:00
|
|
|
n_ptr = tipc_node_find(net, msg_prevnode(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
if (unlikely(!n_ptr))
|
2013-10-30 03:26:57 +00:00
|
|
|
goto discard;
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_node_lock(n_ptr);
|
2008-04-16 02:04:54 +00:00
|
|
|
|
tipc: Ensure both nodes recognize loss of contact between them
Enhances TIPC to ensure that a node that loses contact with a
neighboring node does not allow contact to be re-established until
it sees that its peer has also recognized the loss of contact.
Previously, nodes that were connected by two or more links could
encounter a situation in which node A would lose contact with node B
on all of its links, purge its name table of names published by B,
and then fail to repopulate those names once contact with B was restored.
This would happen because B was able to re-establish one or more links
so quickly that it never reached a point where it had no links to A --
meaning that B never saw a loss of contact with A, and consequently
didn't re-publish its names to A.
This problem is now prevented by enhancing the cleanup done by TIPC
following a loss of contact with a neighboring node to ensure that
node A ignores all messages sent by B until it receives a LINK_PROTOCOL
message that indicates B has lost contact with A, thereby preventing
the (re)establishment of links between the nodes. The loss of contact
is recognized when a RESET or ACTIVATE message is received that has
a "redundant link exists" field of 0, indicating that B's sending link
endpoint is in a reset state and that B has no other working links.
Additionally, TIPC now suppresses the sending of (most) link protocol
messages to a neighboring node while it is cleaning up after an earlier
loss of contact with that node. This stops the peer node from prematurely
activating its link endpoint, which would prevent TIPC from later
activating its own end. TIPC still allows outgoing RESET messages to
occur during cleanup, to avoid problems if its own node recognizes
the loss of contact first and tries to notify the peer of the situation.
Finally, TIPC now recognizes an impending loss of contact with a peer node
as soon as it receives a RESET message on a working link that is the
peer's only link to the node, and ensures that the link protocol
suppression mentioned above goes into effect right away -- that is,
even before its own link endpoints have failed. This is necessary to
ensure correct operation when there are redundant links between the nodes,
since otherwise TIPC would send an ACTIVATE message upon receiving a RESET
on its first link and only begin suppressing when a RESET on its second
link was received, instead of initiating suppression with the first RESET
message as it needs to.
Note: The reworked cleanup code also eliminates a check that prevented
a link endpoint's discovery object from responding to incoming messages
while stale name table entries are being purged. This check is now
unnecessary and would have slowed down re-establishment of communication
between the nodes in some situations.
Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2011-05-27 15:00:51 +00:00
|
|
|
/* Locate unicast link endpoint that should handle message */
|
|
|
|
l_ptr = n_ptr->links[b_ptr->identity];
|
2013-10-30 03:26:57 +00:00
|
|
|
if (unlikely(!l_ptr))
|
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 13:36:41 +00:00
|
|
|
goto unlock;
|
2010-08-17 11:00:16 +00:00
|
|
|
|
tipc: Ensure both nodes recognize loss of contact between them
Enhances TIPC to ensure that a node that loses contact with a
neighboring node does not allow contact to be re-established until
it sees that its peer has also recognized the loss of contact.
Previously, nodes that were connected by two or more links could
encounter a situation in which node A would lose contact with node B
on all of its links, purge its name table of names published by B,
and then fail to repopulate those names once contact with B was restored.
This would happen because B was able to re-establish one or more links
so quickly that it never reached a point where it had no links to A --
meaning that B never saw a loss of contact with A, and consequently
didn't re-publish its names to A.
This problem is now prevented by enhancing the cleanup done by TIPC
following a loss of contact with a neighboring node to ensure that
node A ignores all messages sent by B until it receives a LINK_PROTOCOL
message that indicates B has lost contact with A, thereby preventing
the (re)establishment of links between the nodes. The loss of contact
is recognized when a RESET or ACTIVATE message is received that has
a "redundant link exists" field of 0, indicating that B's sending link
endpoint is in a reset state and that B has no other working links.
Additionally, TIPC now suppresses the sending of (most) link protocol
messages to a neighboring node while it is cleaning up after an earlier
loss of contact with that node. This stops the peer node from prematurely
activating its link endpoint, which would prevent TIPC from later
activating its own end. TIPC still allows outgoing RESET messages to
occur during cleanup, to avoid problems if its own node recognizes
the loss of contact first and tries to notify the peer of the situation.
Finally, TIPC now recognizes an impending loss of contact with a peer node
as soon as it receives a RESET message on a working link that is the
peer's only link to the node, and ensures that the link protocol
suppression mentioned above goes into effect right away -- that is,
even before its own link endpoints have failed. This is necessary to
ensure correct operation when there are redundant links between the nodes,
since otherwise TIPC would send an ACTIVATE message upon receiving a RESET
on its first link and only begin suppressing when a RESET on its second
link was received, instead of initiating suppression with the first RESET
message as it needs to.
Note: The reworked cleanup code also eliminates a check that prevented
a link endpoint's discovery object from responding to incoming messages
while stale name table entries are being purged. This check is now
unnecessary and would have slowed down re-establishment of communication
between the nodes in some situations.
Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2011-05-27 15:00:51 +00:00
|
|
|
/* Verify that communication with node is currently allowed */
|
2014-05-08 00:54:39 +00:00
|
|
|
if ((n_ptr->action_flags & TIPC_WAIT_PEER_LINKS_DOWN) &&
|
2014-05-05 00:56:11 +00:00
|
|
|
msg_user(msg) == LINK_PROTOCOL &&
|
|
|
|
(msg_type(msg) == RESET_MSG ||
|
|
|
|
msg_type(msg) == ACTIVATE_MSG) &&
|
|
|
|
!msg_redundant_link(msg))
|
2014-05-08 00:54:39 +00:00
|
|
|
n_ptr->action_flags &= ~TIPC_WAIT_PEER_LINKS_DOWN;
|
2014-05-05 00:56:11 +00:00
|
|
|
|
|
|
|
if (tipc_node_blocked(n_ptr))
|
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 13:36:41 +00:00
|
|
|
goto unlock;
|
2008-04-16 02:04:54 +00:00
|
|
|
|
|
|
|
/* Validate message sequence number info */
|
|
|
|
seq_no = msg_seqno(msg);
|
|
|
|
ackd = msg_ack(msg);
|
|
|
|
|
|
|
|
/* Release acked messages */
|
2012-11-16 05:51:30 +00:00
|
|
|
if (n_ptr->bclink.recv_permitted)
|
2011-10-24 19:26:24 +00:00
|
|
|
tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
released = 0;
|
|
|
|
skb_queue_walk_safe(&l_ptr->outqueue, skb1, tmp) {
|
|
|
|
if (skb1 == l_ptr->next_out ||
|
|
|
|
more(buf_seqno(skb1), ackd))
|
|
|
|
break;
|
|
|
|
__skb_unlink(skb1, &l_ptr->outqueue);
|
|
|
|
kfree_skb(skb1);
|
|
|
|
released = 1;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2008-04-16 02:04:54 +00:00
|
|
|
|
|
|
|
/* Try sending any messages link endpoint has pending */
|
2006-01-02 18:04:38 +00:00
|
|
|
if (unlikely(l_ptr->next_out))
|
2014-11-26 03:41:48 +00:00
|
|
|
tipc_link_push_packets(l_ptr);
|
2014-02-13 22:29:15 +00: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 13:36:41 +00:00
|
|
|
if (released && !skb_queue_empty(&l_ptr->wakeupq))
|
2014-08-22 22:09:07 +00:00
|
|
|
link_prepare_wakeup(l_ptr);
|
2014-02-13 22:29:15 +00:00
|
|
|
|
|
|
|
/* Process the incoming packet */
|
2013-10-30 03:26:57 +00:00
|
|
|
if (unlikely(!link_working_working(l_ptr))) {
|
|
|
|
if (msg_user(msg) == LINK_PROTOCOL) {
|
2015-02-05 13:36:36 +00:00
|
|
|
tipc_link_proto_rcv(l_ptr, skb);
|
2014-11-26 03:41:54 +00:00
|
|
|
link_retrieve_defq(l_ptr, &head);
|
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 13:36:41 +00:00
|
|
|
skb = NULL;
|
|
|
|
goto unlock;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2013-10-30 03:26:57 +00:00
|
|
|
|
|
|
|
/* Traffic message. Conditionally activate link */
|
|
|
|
link_state_event(l_ptr, TRAFFIC_MSG_EVT);
|
|
|
|
|
|
|
|
if (link_working_working(l_ptr)) {
|
|
|
|
/* Re-insert buffer in front of queue */
|
2014-11-26 03:41:54 +00:00
|
|
|
__skb_queue_head(&head, skb);
|
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 13:36:41 +00:00
|
|
|
skb = NULL;
|
|
|
|
goto unlock;
|
2013-10-30 03:26:57 +00: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 13:36:41 +00:00
|
|
|
goto unlock;
|
2013-10-30 03:26:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Link is now in state WORKING_WORKING */
|
|
|
|
if (unlikely(seq_no != mod(l_ptr->next_in_no))) {
|
2015-02-05 13:36:36 +00:00
|
|
|
link_handle_out_of_seq_msg(l_ptr, skb);
|
2014-11-26 03:41:54 +00:00
|
|
|
link_retrieve_defq(l_ptr, &head);
|
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 13:36:41 +00:00
|
|
|
skb = NULL;
|
|
|
|
goto unlock;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2013-10-30 03:26:57 +00:00
|
|
|
l_ptr->next_in_no++;
|
2014-11-26 03:41:53 +00:00
|
|
|
if (unlikely(!skb_queue_empty(&l_ptr->deferred_queue)))
|
2014-11-26 03:41:54 +00:00
|
|
|
link_retrieve_defq(l_ptr, &head);
|
2014-02-13 22:29:15 +00:00
|
|
|
|
2014-07-01 08:22:41 +00:00
|
|
|
if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
|
|
|
|
l_ptr->stats.sent_acks++;
|
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0, 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 13:36:41 +00:00
|
|
|
tipc_link_input(l_ptr, skb);
|
|
|
|
skb = NULL;
|
|
|
|
unlock:
|
2013-10-30 03:26:57 +00:00
|
|
|
tipc_node_unlock(n_ptr);
|
|
|
|
discard:
|
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 13:36:41 +00:00
|
|
|
if (unlikely(skb))
|
|
|
|
kfree_skb(skb);
|
2006-01-02 18:04:38 +00: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 13:36:41 +00:00
|
|
|
/* tipc_data_input - deliver data and name distr msgs to upper layer
|
2014-07-01 08:22:40 +00: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 13:36:41 +00:00
|
|
|
* Consumes buffer if message is of right type
|
2014-07-01 08:22:40 +00:00
|
|
|
* Node lock must be held
|
|
|
|
*/
|
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 13:36:41 +00:00
|
|
|
static bool tipc_data_input(struct tipc_link *link, struct sk_buff *skb)
|
2014-07-01 08:22:40 +00: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 13:36:41 +00:00
|
|
|
struct tipc_node *node = link->owner;
|
|
|
|
struct tipc_msg *msg = buf_msg(skb);
|
|
|
|
u32 dport = msg_destport(msg);
|
2014-07-01 08:22:40 +00:00
|
|
|
|
|
|
|
switch (msg_user(msg)) {
|
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 13:36:41 +00:00
|
|
|
case TIPC_LOW_IMPORTANCE:
|
|
|
|
case TIPC_MEDIUM_IMPORTANCE:
|
|
|
|
case TIPC_HIGH_IMPORTANCE:
|
|
|
|
case TIPC_CRITICAL_IMPORTANCE:
|
|
|
|
case CONN_MANAGER:
|
|
|
|
if (tipc_skb_queue_tail(&link->inputq, skb, dport)) {
|
|
|
|
node->inputq = &link->inputq;
|
|
|
|
node->action_flags |= TIPC_MSG_EVT;
|
2014-07-01 08:22:40 +00: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 13:36:41 +00:00
|
|
|
return true;
|
2014-07-01 08:22:40 +00:00
|
|
|
case NAME_DISTRIBUTOR:
|
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 13:36:41 +00:00
|
|
|
node->bclink.recv_permitted = true;
|
|
|
|
node->namedq = &link->namedq;
|
|
|
|
skb_queue_tail(&link->namedq, skb);
|
|
|
|
if (skb_queue_len(&link->namedq) == 1)
|
|
|
|
node->action_flags |= TIPC_NAMED_MSG_EVT;
|
|
|
|
return true;
|
|
|
|
case MSG_BUNDLER:
|
|
|
|
case CHANGEOVER_PROTOCOL:
|
|
|
|
case MSG_FRAGMENTER:
|
2014-07-01 08:22:40 +00:00
|
|
|
case BCAST_PROTOCOL:
|
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 13:36:41 +00:00
|
|
|
return false;
|
2014-07-01 08:22:40 +00:00
|
|
|
default:
|
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 13:36:41 +00:00
|
|
|
pr_warn("Dropping received illegal msg type\n");
|
|
|
|
kfree_skb(skb);
|
|
|
|
return false;
|
|
|
|
};
|
2014-07-01 08:22:40 +00: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 13:36:41 +00:00
|
|
|
|
|
|
|
/* tipc_link_input - process packet that has passed link protocol check
|
|
|
|
*
|
|
|
|
* Consumes buffer
|
|
|
|
* Node lock must be held
|
2014-07-01 08:22:40 +00: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 13:36:41 +00:00
|
|
|
static void tipc_link_input(struct tipc_link *link, struct sk_buff *skb)
|
2014-07-01 08:22:40 +00: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 13:36:41 +00:00
|
|
|
struct tipc_node *node = link->owner;
|
|
|
|
struct tipc_msg *msg = buf_msg(skb);
|
|
|
|
struct sk_buff *iskb;
|
|
|
|
int pos = 0;
|
|
|
|
|
|
|
|
if (likely(tipc_data_input(link, skb)))
|
|
|
|
return;
|
2014-07-01 08:22:40 +00:00
|
|
|
|
|
|
|
switch (msg_user(msg)) {
|
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 13:36:41 +00:00
|
|
|
case CHANGEOVER_PROTOCOL:
|
|
|
|
if (!tipc_link_tunnel_rcv(node, &skb))
|
|
|
|
break;
|
|
|
|
if (msg_user(buf_msg(skb)) != MSG_BUNDLER) {
|
|
|
|
tipc_data_input(link, skb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MSG_BUNDLER:
|
|
|
|
link->stats.recv_bundles++;
|
|
|
|
link->stats.recv_bundled += msg_msgcnt(msg);
|
|
|
|
|
|
|
|
while (tipc_msg_extract(skb, &iskb, &pos))
|
|
|
|
tipc_data_input(link, iskb);
|
2014-07-01 08:22:40 +00:00
|
|
|
break;
|
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 13:36:41 +00:00
|
|
|
case MSG_FRAGMENTER:
|
|
|
|
link->stats.recv_fragments++;
|
|
|
|
if (tipc_buf_append(&link->reasm_buf, &skb)) {
|
|
|
|
link->stats.recv_fragmented++;
|
|
|
|
tipc_data_input(link, skb);
|
|
|
|
} else if (!link->reasm_buf) {
|
|
|
|
tipc_link_reset(link);
|
|
|
|
}
|
2014-07-01 08:22:40 +00:00
|
|
|
break;
|
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 13:36:41 +00:00
|
|
|
case BCAST_PROTOCOL:
|
|
|
|
tipc_link_sync_rcv(node, skb);
|
2014-07-01 08:22:40 +00:00
|
|
|
break;
|
|
|
|
default:
|
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 13:36:41 +00:00
|
|
|
break;
|
|
|
|
};
|
2014-07-01 08:22:40 +00:00
|
|
|
}
|
|
|
|
|
2012-07-10 10:55:09 +00:00
|
|
|
/**
|
2011-10-25 14:44:35 +00:00
|
|
|
* tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
|
|
|
|
*
|
|
|
|
* Returns increase in queue length (i.e. 0 or 1)
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2014-11-26 03:41:53 +00:00
|
|
|
u32 tipc_link_defer_pkt(struct sk_buff_head *list, struct sk_buff *skb)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-11-26 03:41:53 +00:00
|
|
|
struct sk_buff *skb1;
|
|
|
|
u32 seq_no = buf_seqno(skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
/* Empty queue ? */
|
2014-11-26 03:41:53 +00:00
|
|
|
if (skb_queue_empty(list)) {
|
|
|
|
__skb_queue_tail(list, skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Last ? */
|
2014-11-26 03:41:53 +00:00
|
|
|
if (less(buf_seqno(skb_peek_tail(list)), seq_no)) {
|
|
|
|
__skb_queue_tail(list, skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-10-25 14:44:35 +00:00
|
|
|
/* Locate insertion point in queue, then insert; discard if duplicate */
|
2014-11-26 03:41:53 +00:00
|
|
|
skb_queue_walk(list, skb1) {
|
|
|
|
u32 curr_seqno = buf_seqno(skb1);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2011-10-25 14:44:35 +00:00
|
|
|
if (seq_no == curr_seqno) {
|
2014-11-26 03:41:53 +00:00
|
|
|
kfree_skb(skb);
|
2011-10-25 14:44:35 +00:00
|
|
|
return 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2011-10-25 14:44:35 +00:00
|
|
|
|
|
|
|
if (less(seq_no, curr_seqno))
|
2006-01-02 18:04:38 +00:00
|
|
|
break;
|
2011-10-25 14:44:35 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2014-11-26 03:41:53 +00:00
|
|
|
__skb_queue_before(list, skb1, skb);
|
2011-10-25 14:44:35 +00:00
|
|
|
return 1;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2011-10-25 14:44:35 +00:00
|
|
|
/*
|
2006-01-02 18:04:38 +00:00
|
|
|
* link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
|
|
|
|
*/
|
2015-02-05 13:36:36 +00:00
|
|
|
static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
|
2006-01-02 18:04:38 +00:00
|
|
|
struct sk_buff *buf)
|
|
|
|
{
|
2011-10-24 20:03:12 +00:00
|
|
|
u32 seq_no = buf_seqno(buf);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) {
|
2015-02-05 13:36:36 +00:00
|
|
|
tipc_link_proto_rcv(l_ptr, buf);
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Record OOS packet arrival (force mismatch on next timeout) */
|
|
|
|
l_ptr->checkpoint--;
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
/*
|
2006-01-02 18:04:38 +00:00
|
|
|
* Discard packet if a duplicate; otherwise add it to deferred queue
|
|
|
|
* and notify peer of gap as per protocol specification
|
|
|
|
*/
|
|
|
|
if (less(seq_no, mod(l_ptr->next_in_no))) {
|
|
|
|
l_ptr->stats.duplicates++;
|
2011-11-04 17:24:29 +00:00
|
|
|
kfree_skb(buf);
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-11-26 03:41:53 +00:00
|
|
|
if (tipc_link_defer_pkt(&l_ptr->deferred_queue, buf)) {
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->stats.deferred_recv++;
|
2014-02-11 10:38:26 +00:00
|
|
|
TIPC_SKB_CB(buf)->deferred = true;
|
2014-11-26 03:41:53 +00:00
|
|
|
if ((skb_queue_len(&l_ptr->deferred_queue) % 16) == 1)
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
|
2014-11-26 03:41:53 +00:00
|
|
|
} else {
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->stats.duplicates++;
|
2014-11-26 03:41:53 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send protocol message to the other endpoint.
|
|
|
|
*/
|
2014-02-18 08:06:46 +00:00
|
|
|
void tipc_link_proto_xmit(struct tipc_link *l_ptr, u32 msg_typ, int probe_msg,
|
|
|
|
u32 gap, u32 tolerance, u32 priority, u32 ack_mtu)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2006-03-21 06:36:47 +00:00
|
|
|
struct sk_buff *buf = NULL;
|
2006-01-02 18:04:38 +00:00
|
|
|
struct tipc_msg *msg = l_ptr->pmsg;
|
2007-02-09 14:25:21 +00:00
|
|
|
u32 msg_size = sizeof(l_ptr->proto_msg);
|
2011-02-28 20:30:20 +00:00
|
|
|
int r_flag;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2013-12-11 04:45:44 +00:00
|
|
|
/* Don't send protocol message during link changeover */
|
|
|
|
if (l_ptr->exp_msg_count)
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
tipc: Ensure both nodes recognize loss of contact between them
Enhances TIPC to ensure that a node that loses contact with a
neighboring node does not allow contact to be re-established until
it sees that its peer has also recognized the loss of contact.
Previously, nodes that were connected by two or more links could
encounter a situation in which node A would lose contact with node B
on all of its links, purge its name table of names published by B,
and then fail to repopulate those names once contact with B was restored.
This would happen because B was able to re-establish one or more links
so quickly that it never reached a point where it had no links to A --
meaning that B never saw a loss of contact with A, and consequently
didn't re-publish its names to A.
This problem is now prevented by enhancing the cleanup done by TIPC
following a loss of contact with a neighboring node to ensure that
node A ignores all messages sent by B until it receives a LINK_PROTOCOL
message that indicates B has lost contact with A, thereby preventing
the (re)establishment of links between the nodes. The loss of contact
is recognized when a RESET or ACTIVATE message is received that has
a "redundant link exists" field of 0, indicating that B's sending link
endpoint is in a reset state and that B has no other working links.
Additionally, TIPC now suppresses the sending of (most) link protocol
messages to a neighboring node while it is cleaning up after an earlier
loss of contact with that node. This stops the peer node from prematurely
activating its link endpoint, which would prevent TIPC from later
activating its own end. TIPC still allows outgoing RESET messages to
occur during cleanup, to avoid problems if its own node recognizes
the loss of contact first and tries to notify the peer of the situation.
Finally, TIPC now recognizes an impending loss of contact with a peer node
as soon as it receives a RESET message on a working link that is the
peer's only link to the node, and ensures that the link protocol
suppression mentioned above goes into effect right away -- that is,
even before its own link endpoints have failed. This is necessary to
ensure correct operation when there are redundant links between the nodes,
since otherwise TIPC would send an ACTIVATE message upon receiving a RESET
on its first link and only begin suppressing when a RESET on its second
link was received, instead of initiating suppression with the first RESET
message as it needs to.
Note: The reworked cleanup code also eliminates a check that prevented
a link endpoint's discovery object from responding to incoming messages
while stale name table entries are being purged. This check is now
unnecessary and would have slowed down re-establishment of communication
between the nodes in some situations.
Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2011-05-27 15:00:51 +00:00
|
|
|
|
|
|
|
/* Abort non-RESET send if communication with node is prohibited */
|
2014-05-05 00:56:11 +00:00
|
|
|
if ((tipc_node_blocked(l_ptr->owner)) && (msg_typ != RESET_MSG))
|
tipc: Ensure both nodes recognize loss of contact between them
Enhances TIPC to ensure that a node that loses contact with a
neighboring node does not allow contact to be re-established until
it sees that its peer has also recognized the loss of contact.
Previously, nodes that were connected by two or more links could
encounter a situation in which node A would lose contact with node B
on all of its links, purge its name table of names published by B,
and then fail to repopulate those names once contact with B was restored.
This would happen because B was able to re-establish one or more links
so quickly that it never reached a point where it had no links to A --
meaning that B never saw a loss of contact with A, and consequently
didn't re-publish its names to A.
This problem is now prevented by enhancing the cleanup done by TIPC
following a loss of contact with a neighboring node to ensure that
node A ignores all messages sent by B until it receives a LINK_PROTOCOL
message that indicates B has lost contact with A, thereby preventing
the (re)establishment of links between the nodes. The loss of contact
is recognized when a RESET or ACTIVATE message is received that has
a "redundant link exists" field of 0, indicating that B's sending link
endpoint is in a reset state and that B has no other working links.
Additionally, TIPC now suppresses the sending of (most) link protocol
messages to a neighboring node while it is cleaning up after an earlier
loss of contact with that node. This stops the peer node from prematurely
activating its link endpoint, which would prevent TIPC from later
activating its own end. TIPC still allows outgoing RESET messages to
occur during cleanup, to avoid problems if its own node recognizes
the loss of contact first and tries to notify the peer of the situation.
Finally, TIPC now recognizes an impending loss of contact with a peer node
as soon as it receives a RESET message on a working link that is the
peer's only link to the node, and ensures that the link protocol
suppression mentioned above goes into effect right away -- that is,
even before its own link endpoints have failed. This is necessary to
ensure correct operation when there are redundant links between the nodes,
since otherwise TIPC would send an ACTIVATE message upon receiving a RESET
on its first link and only begin suppressing when a RESET on its second
link was received, instead of initiating suppression with the first RESET
message as it needs to.
Note: The reworked cleanup code also eliminates a check that prevented
a link endpoint's discovery object from responding to incoming messages
while stale name table entries are being purged. This check is now
unnecessary and would have slowed down re-establishment of communication
between the nodes in some situations.
Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2011-05-27 15:00:51 +00:00
|
|
|
return;
|
|
|
|
|
2011-10-25 15:20:26 +00:00
|
|
|
/* Create protocol message with "out-of-sequence" sequence number */
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_type(msg, msg_typ);
|
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 02:55:46 +00:00
|
|
|
msg_set_net_plane(msg, l_ptr->net_plane);
|
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 18:17:53 +00:00
|
|
|
msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
|
2015-01-09 07:27:07 +00:00
|
|
|
msg_set_last_bcast(msg, tipc_bclink_get_last_sent(l_ptr->owner->net));
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
if (msg_typ == STATE_MSG) {
|
|
|
|
u32 next_sent = mod(l_ptr->next_out_no);
|
|
|
|
|
2006-01-17 23:38:21 +00:00
|
|
|
if (!tipc_link_is_up(l_ptr))
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
|
|
|
if (l_ptr->next_out)
|
2011-10-24 20:03:12 +00:00
|
|
|
next_sent = buf_seqno(l_ptr->next_out);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_next_sent(msg, next_sent);
|
2014-11-26 03:41:53 +00:00
|
|
|
if (!skb_queue_empty(&l_ptr->deferred_queue)) {
|
|
|
|
u32 rec = buf_seqno(skb_peek(&l_ptr->deferred_queue));
|
2006-01-02 18:04:38 +00:00
|
|
|
gap = mod(rec - mod(l_ptr->next_in_no));
|
|
|
|
}
|
|
|
|
msg_set_seq_gap(msg, gap);
|
|
|
|
if (gap)
|
|
|
|
l_ptr->stats.sent_nacks++;
|
|
|
|
msg_set_link_tolerance(msg, tolerance);
|
|
|
|
msg_set_linkprio(msg, priority);
|
|
|
|
msg_set_max_pkt(msg, ack_mtu);
|
|
|
|
msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
|
|
|
|
msg_set_probe(msg, probe_msg != 0);
|
2007-02-09 14:25:21 +00:00
|
|
|
if (probe_msg) {
|
2006-01-02 18:04:38 +00:00
|
|
|
u32 mtu = l_ptr->max_pkt;
|
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
if ((mtu < l_ptr->max_pkt_target) &&
|
2006-01-02 18:04:38 +00:00
|
|
|
link_working_working(l_ptr) &&
|
|
|
|
l_ptr->fsm_msg_cnt) {
|
|
|
|
msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
|
2007-02-09 14:25:21 +00:00
|
|
|
if (l_ptr->max_pkt_probes == 10) {
|
|
|
|
l_ptr->max_pkt_target = (msg_size - 4);
|
|
|
|
l_ptr->max_pkt_probes = 0;
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
|
2007-02-09 14:25:21 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->max_pkt_probes++;
|
2007-02-09 14:25:21 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
l_ptr->stats.sent_probes++;
|
2007-02-09 14:25:21 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->stats.sent_states++;
|
|
|
|
} else { /* RESET_MSG or ACTIVATE_MSG */
|
|
|
|
msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
|
|
|
|
msg_set_seq_gap(msg, 0);
|
|
|
|
msg_set_next_sent(msg, 1);
|
2011-01-18 20:15:34 +00:00
|
|
|
msg_set_probe(msg, 0);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_link_tolerance(msg, l_ptr->tolerance);
|
|
|
|
msg_set_linkprio(msg, l_ptr->priority);
|
|
|
|
msg_set_max_pkt(msg, l_ptr->max_pkt_target);
|
|
|
|
}
|
|
|
|
|
2011-02-28 20:30:20 +00:00
|
|
|
r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr));
|
|
|
|
msg_set_redundant_link(msg, r_flag);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_linkprio(msg, l_ptr->priority);
|
2011-10-25 15:20:26 +00:00
|
|
|
msg_set_size(msg, msg_size);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
msg_set_seqno(msg, mod(l_ptr->next_out_no + (0xffff/2)));
|
|
|
|
|
2010-10-13 13:20:35 +00:00
|
|
|
buf = tipc_buf_acquire(msg_size);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (!buf)
|
|
|
|
return;
|
|
|
|
|
2007-03-31 14:55:19 +00:00
|
|
|
skb_copy_to_linear_data(buf, msg, sizeof(l_ptr->proto_msg));
|
2013-06-17 14:54:48 +00:00
|
|
|
buf->priority = TC_PRIO_CONTROL;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2015-01-09 07:27:06 +00:00
|
|
|
tipc_bearer_send(l_ptr->owner->net, l_ptr->bearer_id, buf,
|
|
|
|
&l_ptr->media_addr);
|
2011-10-25 15:20:26 +00:00
|
|
|
l_ptr->unacked_window = 0;
|
2011-11-04 17:24:29 +00:00
|
|
|
kfree_skb(buf);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Receive protocol message :
|
2007-02-09 14:25:21 +00:00
|
|
|
* Note that network plane id propagates through the network, and may
|
|
|
|
* change at any time. The node with lowest address rules
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2015-02-05 13:36:36 +00:00
|
|
|
static void tipc_link_proto_rcv(struct tipc_link *l_ptr,
|
2015-01-09 07:27:04 +00:00
|
|
|
struct sk_buff *buf)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
u32 rec_gap = 0;
|
|
|
|
u32 max_pkt_info;
|
2007-02-09 14:25:21 +00:00
|
|
|
u32 max_pkt_ack;
|
2006-01-02 18:04:38 +00:00
|
|
|
u32 msg_tol;
|
|
|
|
struct tipc_msg *msg = buf_msg(buf);
|
|
|
|
|
2013-12-11 04:45:44 +00:00
|
|
|
/* Discard protocol message during link changeover */
|
|
|
|
if (l_ptr->exp_msg_count)
|
2006-01-02 18:04:38 +00:00
|
|
|
goto exit;
|
|
|
|
|
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 02:55:46 +00:00
|
|
|
if (l_ptr->net_plane != msg_net_plane(msg))
|
2015-02-05 13:36:36 +00:00
|
|
|
if (link_own_addr(l_ptr) > msg_prevnode(msg))
|
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 02:55:46 +00:00
|
|
|
l_ptr->net_plane = msg_net_plane(msg);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
switch (msg_type(msg)) {
|
2007-02-09 14:25:21 +00:00
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
case RESET_MSG:
|
2008-06-05 00:29:39 +00:00
|
|
|
if (!link_working_unknown(l_ptr) &&
|
|
|
|
(l_ptr->peer_session != INVALID_SESSION)) {
|
2011-04-07 13:54:43 +00:00
|
|
|
if (less_eq(msg_session(msg), l_ptr->peer_session))
|
|
|
|
break; /* duplicate or old reset: ignore */
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
tipc: Ensure both nodes recognize loss of contact between them
Enhances TIPC to ensure that a node that loses contact with a
neighboring node does not allow contact to be re-established until
it sees that its peer has also recognized the loss of contact.
Previously, nodes that were connected by two or more links could
encounter a situation in which node A would lose contact with node B
on all of its links, purge its name table of names published by B,
and then fail to repopulate those names once contact with B was restored.
This would happen because B was able to re-establish one or more links
so quickly that it never reached a point where it had no links to A --
meaning that B never saw a loss of contact with A, and consequently
didn't re-publish its names to A.
This problem is now prevented by enhancing the cleanup done by TIPC
following a loss of contact with a neighboring node to ensure that
node A ignores all messages sent by B until it receives a LINK_PROTOCOL
message that indicates B has lost contact with A, thereby preventing
the (re)establishment of links between the nodes. The loss of contact
is recognized when a RESET or ACTIVATE message is received that has
a "redundant link exists" field of 0, indicating that B's sending link
endpoint is in a reset state and that B has no other working links.
Additionally, TIPC now suppresses the sending of (most) link protocol
messages to a neighboring node while it is cleaning up after an earlier
loss of contact with that node. This stops the peer node from prematurely
activating its link endpoint, which would prevent TIPC from later
activating its own end. TIPC still allows outgoing RESET messages to
occur during cleanup, to avoid problems if its own node recognizes
the loss of contact first and tries to notify the peer of the situation.
Finally, TIPC now recognizes an impending loss of contact with a peer node
as soon as it receives a RESET message on a working link that is the
peer's only link to the node, and ensures that the link protocol
suppression mentioned above goes into effect right away -- that is,
even before its own link endpoints have failed. This is necessary to
ensure correct operation when there are redundant links between the nodes,
since otherwise TIPC would send an ACTIVATE message upon receiving a RESET
on its first link and only begin suppressing when a RESET on its second
link was received, instead of initiating suppression with the first RESET
message as it needs to.
Note: The reworked cleanup code also eliminates a check that prevented
a link endpoint's discovery object from responding to incoming messages
while stale name table entries are being purged. This check is now
unnecessary and would have slowed down re-establishment of communication
between the nodes in some situations.
Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2011-05-27 15:00:51 +00:00
|
|
|
|
|
|
|
if (!msg_redundant_link(msg) && (link_working_working(l_ptr) ||
|
|
|
|
link_working_unknown(l_ptr))) {
|
|
|
|
/*
|
|
|
|
* peer has lost contact -- don't allow peer's links
|
|
|
|
* to reactivate before we recognize loss & clean up
|
|
|
|
*/
|
2014-05-08 00:54:40 +00:00
|
|
|
l_ptr->owner->action_flags |= TIPC_WAIT_OWN_LINKS_DOWN;
|
tipc: Ensure both nodes recognize loss of contact between them
Enhances TIPC to ensure that a node that loses contact with a
neighboring node does not allow contact to be re-established until
it sees that its peer has also recognized the loss of contact.
Previously, nodes that were connected by two or more links could
encounter a situation in which node A would lose contact with node B
on all of its links, purge its name table of names published by B,
and then fail to repopulate those names once contact with B was restored.
This would happen because B was able to re-establish one or more links
so quickly that it never reached a point where it had no links to A --
meaning that B never saw a loss of contact with A, and consequently
didn't re-publish its names to A.
This problem is now prevented by enhancing the cleanup done by TIPC
following a loss of contact with a neighboring node to ensure that
node A ignores all messages sent by B until it receives a LINK_PROTOCOL
message that indicates B has lost contact with A, thereby preventing
the (re)establishment of links between the nodes. The loss of contact
is recognized when a RESET or ACTIVATE message is received that has
a "redundant link exists" field of 0, indicating that B's sending link
endpoint is in a reset state and that B has no other working links.
Additionally, TIPC now suppresses the sending of (most) link protocol
messages to a neighboring node while it is cleaning up after an earlier
loss of contact with that node. This stops the peer node from prematurely
activating its link endpoint, which would prevent TIPC from later
activating its own end. TIPC still allows outgoing RESET messages to
occur during cleanup, to avoid problems if its own node recognizes
the loss of contact first and tries to notify the peer of the situation.
Finally, TIPC now recognizes an impending loss of contact with a peer node
as soon as it receives a RESET message on a working link that is the
peer's only link to the node, and ensures that the link protocol
suppression mentioned above goes into effect right away -- that is,
even before its own link endpoints have failed. This is necessary to
ensure correct operation when there are redundant links between the nodes,
since otherwise TIPC would send an ACTIVATE message upon receiving a RESET
on its first link and only begin suppressing when a RESET on its second
link was received, instead of initiating suppression with the first RESET
message as it needs to.
Note: The reworked cleanup code also eliminates a check that prevented
a link endpoint's discovery object from responding to incoming messages
while stale name table entries are being purged. This check is now
unnecessary and would have slowed down re-establishment of communication
between the nodes in some situations.
Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2011-05-27 15:00:51 +00:00
|
|
|
}
|
|
|
|
|
2011-10-26 14:55:16 +00:00
|
|
|
link_state_event(l_ptr, RESET_MSG);
|
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
/* fall thru' */
|
|
|
|
case ACTIVATE_MSG:
|
|
|
|
/* Update link settings according other endpoint's values */
|
|
|
|
strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg));
|
|
|
|
|
2010-12-31 18:59:33 +00:00
|
|
|
msg_tol = msg_link_tolerance(msg);
|
|
|
|
if (msg_tol > l_ptr->tolerance)
|
2006-01-02 18:04:38 +00:00
|
|
|
link_set_supervision_props(l_ptr, msg_tol);
|
|
|
|
|
|
|
|
if (msg_linkprio(msg) > l_ptr->priority)
|
|
|
|
l_ptr->priority = msg_linkprio(msg);
|
|
|
|
|
|
|
|
max_pkt_info = msg_max_pkt(msg);
|
2007-02-09 14:25:21 +00:00
|
|
|
if (max_pkt_info) {
|
2006-01-02 18:04:38 +00:00
|
|
|
if (max_pkt_info < l_ptr->max_pkt_target)
|
|
|
|
l_ptr->max_pkt_target = max_pkt_info;
|
|
|
|
if (l_ptr->max_pkt > l_ptr->max_pkt_target)
|
|
|
|
l_ptr->max_pkt = l_ptr->max_pkt_target;
|
|
|
|
} else {
|
2007-02-09 14:25:21 +00:00
|
|
|
l_ptr->max_pkt = l_ptr->max_pkt_target;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2011-10-25 16:19:05 +00:00
|
|
|
/* Synchronize broadcast link info, if not done previously */
|
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 18:17:53 +00:00
|
|
|
if (!tipc_node_is_up(l_ptr->owner)) {
|
|
|
|
l_ptr->owner->bclink.last_sent =
|
|
|
|
l_ptr->owner->bclink.last_in =
|
|
|
|
msg_last_bcast(msg);
|
|
|
|
l_ptr->owner->bclink.oos_state = 0;
|
|
|
|
}
|
2011-10-25 16:19:05 +00:00
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->peer_session = msg_session(msg);
|
|
|
|
l_ptr->peer_bearer_id = msg_bearer_id(msg);
|
2011-10-26 14:55:16 +00:00
|
|
|
|
|
|
|
if (msg_type(msg) == ACTIVATE_MSG)
|
|
|
|
link_state_event(l_ptr, ACTIVATE_MSG);
|
2006-01-02 18:04:38 +00:00
|
|
|
break;
|
|
|
|
case STATE_MSG:
|
|
|
|
|
2010-12-31 18:59:33 +00:00
|
|
|
msg_tol = msg_link_tolerance(msg);
|
|
|
|
if (msg_tol)
|
2006-01-02 18:04:38 +00:00
|
|
|
link_set_supervision_props(l_ptr, msg_tol);
|
2007-02-09 14:25:21 +00:00
|
|
|
|
|
|
|
if (msg_linkprio(msg) &&
|
2006-01-02 18:04:38 +00:00
|
|
|
(msg_linkprio(msg) != l_ptr->priority)) {
|
2015-01-22 16:10:31 +00:00
|
|
|
pr_debug("%s<%s>, priority change %u->%u\n",
|
|
|
|
link_rst_msg, l_ptr->name,
|
|
|
|
l_ptr->priority, msg_linkprio(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->priority = msg_linkprio(msg);
|
2006-01-17 23:38:21 +00:00
|
|
|
tipc_link_reset(l_ptr); /* Enforce change to take effect */
|
2006-01-02 18:04:38 +00:00
|
|
|
break;
|
|
|
|
}
|
tipc: don't record link RESET or ACTIVATE messages as traffic
In the current code, all incoming LINK_PROTOCOL messages, irrespective
of type, nudge the "last message received" checkpoint, informing the
link state machine that a message was received from the peer since last
supervision timeout event. This inhibits the link from starting probing
the peer unnecessarily.
However, not only STATE messages are recorded as legitimate incoming
traffic this way, but even RESET and ACTIVATE messages, which in
reality are there to inform the link that the peer endpoint has been
reset. At the same time, some RESET messages may be dropped instead
of causing a link reset. This happens when the link endpoint thinks
it is fully up and working, and the session number of the RESET is
lower than or equal to the current link session. In such cases the
RESET is perceived as a delayed remnant from an earlier session, or
the current one, and dropped.
Now, if a TIPC module is removed and then immediately reinserted, e.g.
when using a script, RESET messages may arrive at the peer link endpoint
before this one has had time to discover the failure. The RESET may be
dropped because of the session number, but only after it has been
recorded as a legitimate traffic event. Hence, the receiving link will
not start probing, and not discover that the peer endpoint is down, at
the same time ignoring the periodic RESET messages coming from that
endpoint. We have ended up in a stale state where a failed link cannot
be re-established.
In this commit, we remedy this by nudging the checkpoint only for
received STATE messages, not for RESET or ACTIVATE messages.
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-05-14 09:39:10 +00:00
|
|
|
|
|
|
|
/* Record reception; force mismatch at next timeout: */
|
|
|
|
l_ptr->checkpoint--;
|
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
link_state_event(l_ptr, TRAFFIC_MSG_EVT);
|
|
|
|
l_ptr->stats.recv_states++;
|
|
|
|
if (link_reset_unknown(l_ptr))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (less_eq(mod(l_ptr->next_in_no), msg_next_sent(msg))) {
|
2007-02-09 14:25:21 +00:00
|
|
|
rec_gap = mod(msg_next_sent(msg) -
|
2006-01-02 18:04:38 +00:00
|
|
|
mod(l_ptr->next_in_no));
|
|
|
|
}
|
|
|
|
|
|
|
|
max_pkt_ack = msg_max_pkt(msg);
|
2007-02-09 14:25:21 +00:00
|
|
|
if (max_pkt_ack > l_ptr->max_pkt) {
|
|
|
|
l_ptr->max_pkt = max_pkt_ack;
|
|
|
|
l_ptr->max_pkt_probes = 0;
|
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
max_pkt_ack = 0;
|
2007-02-09 14:25:21 +00:00
|
|
|
if (msg_probe(msg)) {
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->stats.recv_probes++;
|
2010-12-31 18:59:35 +00:00
|
|
|
if (msg_size(msg) > sizeof(l_ptr->proto_msg))
|
2007-02-09 14:25:21 +00:00
|
|
|
max_pkt_ack = msg_size(msg);
|
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
/* Protocol message before retransmits, reduce loss risk */
|
2012-11-16 05:51:30 +00:00
|
|
|
if (l_ptr->owner->bclink.recv_permitted)
|
2015-02-05 13:36:36 +00:00
|
|
|
tipc_bclink_update_link_state(l_ptr->owner,
|
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 18:17:53 +00:00
|
|
|
msg_last_bcast(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
if (rec_gap || (msg_probe(msg))) {
|
2014-02-18 08:06:46 +00:00
|
|
|
tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, rec_gap, 0,
|
|
|
|
0, max_pkt_ack);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
if (msg_seq_gap(msg)) {
|
|
|
|
l_ptr->stats.recv_nacks++;
|
2014-11-26 03:41:52 +00:00
|
|
|
tipc_link_retransmit(l_ptr, skb_peek(&l_ptr->outqueue),
|
2006-01-17 23:38:21 +00:00
|
|
|
msg_seq_gap(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
exit:
|
2011-11-04 17:24:29 +00:00
|
|
|
kfree_skb(buf);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-01-07 22:02:41 +00:00
|
|
|
/* tipc_link_tunnel_xmit(): Tunnel one packet via a link belonging to
|
|
|
|
* a different bearer. Owner node is locked.
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2014-01-07 22:02:41 +00:00
|
|
|
static void tipc_link_tunnel_xmit(struct tipc_link *l_ptr,
|
|
|
|
struct tipc_msg *tunnel_hdr,
|
|
|
|
struct tipc_msg *msg,
|
|
|
|
u32 selector)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2011-12-30 01:58:42 +00:00
|
|
|
struct tipc_link *tunnel;
|
2014-11-26 03:41:55 +00:00
|
|
|
struct sk_buff *skb;
|
2006-01-02 18:04:38 +00:00
|
|
|
u32 length = msg_size(msg);
|
|
|
|
|
|
|
|
tunnel = l_ptr->owner->active_links[selector & 1];
|
2006-06-26 06:52:50 +00:00
|
|
|
if (!tipc_link_is_up(tunnel)) {
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_warn("%stunnel link no longer available\n", link_co_err);
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
2006-06-26 06:52:50 +00:00
|
|
|
}
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_size(tunnel_hdr, length + INT_H_SIZE);
|
2014-11-26 03:41:55 +00:00
|
|
|
skb = tipc_buf_acquire(length + INT_H_SIZE);
|
|
|
|
if (!skb) {
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_warn("%sunable to send tunnel msg\n", link_co_err);
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
2006-06-26 06:52:50 +00:00
|
|
|
}
|
2014-11-26 03:41:55 +00:00
|
|
|
skb_copy_to_linear_data(skb, tunnel_hdr, INT_H_SIZE);
|
|
|
|
skb_copy_to_linear_data_offset(skb, INT_H_SIZE, msg, length);
|
|
|
|
__tipc_link_xmit_skb(tunnel, skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-01-07 22:02:41 +00:00
|
|
|
/* tipc_link_failover_send_queue(): A link has gone down, but a second
|
|
|
|
* link is still active. We can do failover. Tunnel the failing link's
|
|
|
|
* whole send queue via the remaining link. This way, we don't lose
|
|
|
|
* any packets, and sequence order is preserved for subsequent traffic
|
|
|
|
* sent over the remaining link. Owner node is locked.
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2014-01-07 22:02:41 +00:00
|
|
|
void tipc_link_failover_send_queue(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-11-26 03:41:52 +00:00
|
|
|
u32 msgcount = skb_queue_len(&l_ptr->outqueue);
|
2011-12-30 01:58:42 +00:00
|
|
|
struct tipc_link *tunnel = l_ptr->owner->active_links[0];
|
2006-01-02 18:04:38 +00:00
|
|
|
struct tipc_msg tunnel_hdr;
|
2014-11-26 03:41:52 +00:00
|
|
|
struct sk_buff *skb;
|
2006-06-26 06:52:50 +00:00
|
|
|
int split_bundles;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
if (!tunnel)
|
|
|
|
return;
|
|
|
|
|
2015-02-05 13:36:36 +00:00
|
|
|
tipc_msg_init(link_own_addr(l_ptr), &tunnel_hdr, CHANGEOVER_PROTOCOL,
|
2015-01-09 07:27:10 +00:00
|
|
|
ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
|
|
|
|
msg_set_msgcnt(&tunnel_hdr, msgcount);
|
2006-06-26 06:51:37 +00:00
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
if (skb_queue_empty(&l_ptr->outqueue)) {
|
|
|
|
skb = tipc_buf_acquire(INT_H_SIZE);
|
|
|
|
if (skb) {
|
|
|
|
skb_copy_to_linear_data(skb, &tunnel_hdr, INT_H_SIZE);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_size(&tunnel_hdr, INT_H_SIZE);
|
2014-11-26 03:41:55 +00:00
|
|
|
__tipc_link_xmit_skb(tunnel, skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
} else {
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_warn("%sunable to send changeover msg\n",
|
|
|
|
link_co_err);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2006-06-26 06:51:37 +00:00
|
|
|
|
2007-02-09 14:25:21 +00:00
|
|
|
split_bundles = (l_ptr->owner->active_links[0] !=
|
2006-06-26 06:52:50 +00:00
|
|
|
l_ptr->owner->active_links[1]);
|
|
|
|
|
2014-11-26 03:41:52 +00:00
|
|
|
skb_queue_walk(&l_ptr->outqueue, skb) {
|
|
|
|
struct tipc_msg *msg = buf_msg(skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
|
|
|
if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
|
|
|
|
struct tipc_msg *m = msg_get_wrapped(msg);
|
2010-12-31 18:59:32 +00:00
|
|
|
unchar *pos = (unchar *)m;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2007-08-03 02:28:06 +00:00
|
|
|
msgcount = msg_msgcnt(msg);
|
2006-01-02 18:04:38 +00:00
|
|
|
while (msgcount--) {
|
2010-12-31 18:59:32 +00:00
|
|
|
msg_set_seqno(m, msg_seqno(msg));
|
2014-01-07 22:02:41 +00:00
|
|
|
tipc_link_tunnel_xmit(l_ptr, &tunnel_hdr, m,
|
|
|
|
msg_link_selector(m));
|
2006-01-02 18:04:38 +00:00
|
|
|
pos += align(msg_size(m));
|
|
|
|
m = (struct tipc_msg *)pos;
|
|
|
|
}
|
|
|
|
} else {
|
2014-01-07 22:02:41 +00:00
|
|
|
tipc_link_tunnel_xmit(l_ptr, &tunnel_hdr, msg,
|
|
|
|
msg_link_selector(msg));
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-18 08:06:46 +00:00
|
|
|
/* tipc_link_dup_queue_xmit(): A second link has become active. Tunnel a
|
2014-01-07 22:02:41 +00:00
|
|
|
* duplicate of the first link's send queue via the new link. This way, we
|
|
|
|
* are guaranteed that currently queued packets from a socket are delivered
|
|
|
|
* before future traffic from the same socket, even if this is using the
|
|
|
|
* new link. The last arriving copy of each duplicate packet is dropped at
|
|
|
|
* the receiving end by the regular protocol check, so packet cardinality
|
|
|
|
* and sequence order is preserved per sender/receiver socket pair.
|
|
|
|
* Owner node is locked.
|
|
|
|
*/
|
2014-02-18 08:06:46 +00:00
|
|
|
void tipc_link_dup_queue_xmit(struct tipc_link *l_ptr,
|
2014-01-07 22:02:41 +00:00
|
|
|
struct tipc_link *tunnel)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-11-26 03:41:52 +00:00
|
|
|
struct sk_buff *skb;
|
2006-01-02 18:04:38 +00:00
|
|
|
struct tipc_msg tunnel_hdr;
|
|
|
|
|
2015-02-05 13:36:36 +00:00
|
|
|
tipc_msg_init(link_own_addr(l_ptr), &tunnel_hdr, CHANGEOVER_PROTOCOL,
|
2015-01-09 07:27:10 +00:00
|
|
|
DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr);
|
2014-11-26 03:41:52 +00:00
|
|
|
msg_set_msgcnt(&tunnel_hdr, skb_queue_len(&l_ptr->outqueue));
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
|
2014-11-26 03:41:52 +00:00
|
|
|
skb_queue_walk(&l_ptr->outqueue, skb) {
|
|
|
|
struct sk_buff *outskb;
|
|
|
|
struct tipc_msg *msg = buf_msg(skb);
|
2006-01-02 18:04:38 +00:00
|
|
|
u32 length = msg_size(msg);
|
|
|
|
|
|
|
|
if (msg_user(msg) == MSG_BUNDLER)
|
|
|
|
msg_set_type(msg, CLOSED_MSG);
|
|
|
|
msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */
|
2007-02-09 14:25:21 +00:00
|
|
|
msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
|
2006-01-02 18:04:38 +00:00
|
|
|
msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
|
2014-11-26 03:41:52 +00:00
|
|
|
outskb = tipc_buf_acquire(length + INT_H_SIZE);
|
|
|
|
if (outskb == NULL) {
|
2012-06-29 04:16:37 +00:00
|
|
|
pr_warn("%sunable to send duplicate msg\n",
|
|
|
|
link_co_err);
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-11-26 03:41:52 +00:00
|
|
|
skb_copy_to_linear_data(outskb, &tunnel_hdr, INT_H_SIZE);
|
|
|
|
skb_copy_to_linear_data_offset(outskb, INT_H_SIZE, skb->data,
|
2007-03-31 14:55:19 +00:00
|
|
|
length);
|
2014-11-26 03:41:55 +00:00
|
|
|
__tipc_link_xmit_skb(tunnel, outskb);
|
2006-01-17 23:38:21 +00:00
|
|
|
if (!tipc_link_is_up(l_ptr))
|
2006-01-02 18:04:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* buf_extract - extracts embedded TIPC message from another message
|
|
|
|
* @skb: encapsulating message buffer
|
|
|
|
* @from_pos: offset to extract from
|
|
|
|
*
|
2007-02-09 14:25:21 +00:00
|
|
|
* Returns a new message buffer containing an embedded message. The
|
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 13:36:41 +00:00
|
|
|
* encapsulating buffer is left unchanged.
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
|
|
|
static struct sk_buff *buf_extract(struct sk_buff *skb, u32 from_pos)
|
|
|
|
{
|
|
|
|
struct tipc_msg *msg = (struct tipc_msg *)(skb->data + from_pos);
|
|
|
|
u32 size = msg_size(msg);
|
|
|
|
struct sk_buff *eb;
|
|
|
|
|
2010-10-13 13:20:35 +00:00
|
|
|
eb = tipc_buf_acquire(size);
|
2006-01-02 18:04:38 +00:00
|
|
|
if (eb)
|
2007-03-31 14:55:19 +00:00
|
|
|
skb_copy_to_linear_data(eb, msg, size);
|
2006-01-02 18:04:38 +00:00
|
|
|
return eb;
|
|
|
|
}
|
|
|
|
|
tipc: change reception of tunnelled duplicate packets
When a second link to a destination comes up, some sender sockets will
steer their subsequent traffic through the new link. In order to
guarantee preserved packet order and cardinality for those sockets, we
tunnel a duplicate of the old link's send queue through the new link
before we open it for regular traffic. The last arriving packet copy,
on whichever link, will be dropped at the receiving end based on the
original sequence number, to ensure that only one copy is delivered to
the end receiver.
In this commit, we change the algorithm for receiving DUPLICATE_MSG
packets, at the same time delegating it to a new subfunction,
tipc_link_dup_rcv(). Instead of returning an extracted inner packet to
the packet reception loop in tipc_rcv(), we just add it to the receiving
(new) link's deferred packet queue. The packet will then be processed by
that link when it receives its first non-tunneled packet, i.e., at
latest when the changeover procedure is finished.
Because tipc_link_tunnel_rcv()/tipc_link_dup_rcv() now is consuming all
packets of type DUPLICATE_MSG, the calling tipc_rcv() function can omit
testing for this. This in turn means that the current conditional jump
to the label 'protocol_check' becomes redundant, and we can remove that
label.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:10 +00:00
|
|
|
/* tipc_link_dup_rcv(): Receive a tunnelled DUPLICATE_MSG packet.
|
|
|
|
* Owner node is locked.
|
|
|
|
*/
|
2015-02-05 13:36:36 +00:00
|
|
|
static void tipc_link_dup_rcv(struct tipc_link *l_ptr,
|
tipc: change reception of tunnelled duplicate packets
When a second link to a destination comes up, some sender sockets will
steer their subsequent traffic through the new link. In order to
guarantee preserved packet order and cardinality for those sockets, we
tunnel a duplicate of the old link's send queue through the new link
before we open it for regular traffic. The last arriving packet copy,
on whichever link, will be dropped at the receiving end based on the
original sequence number, to ensure that only one copy is delivered to
the end receiver.
In this commit, we change the algorithm for receiving DUPLICATE_MSG
packets, at the same time delegating it to a new subfunction,
tipc_link_dup_rcv(). Instead of returning an extracted inner packet to
the packet reception loop in tipc_rcv(), we just add it to the receiving
(new) link's deferred packet queue. The packet will then be processed by
that link when it receives its first non-tunneled packet, i.e., at
latest when the changeover procedure is finished.
Because tipc_link_tunnel_rcv()/tipc_link_dup_rcv() now is consuming all
packets of type DUPLICATE_MSG, the calling tipc_rcv() function can omit
testing for this. This in turn means that the current conditional jump
to the label 'protocol_check' becomes redundant, and we can remove that
label.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:10 +00:00
|
|
|
struct sk_buff *t_buf)
|
|
|
|
{
|
|
|
|
struct sk_buff *buf;
|
|
|
|
|
|
|
|
if (!tipc_link_is_up(l_ptr))
|
|
|
|
return;
|
|
|
|
|
|
|
|
buf = buf_extract(t_buf, INT_H_SIZE);
|
|
|
|
if (buf == NULL) {
|
|
|
|
pr_warn("%sfailed to extract inner dup pkt\n", link_co_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add buffer to deferred queue, if applicable: */
|
2015-02-05 13:36:36 +00:00
|
|
|
link_handle_out_of_seq_msg(l_ptr, buf);
|
tipc: change reception of tunnelled duplicate packets
When a second link to a destination comes up, some sender sockets will
steer their subsequent traffic through the new link. In order to
guarantee preserved packet order and cardinality for those sockets, we
tunnel a duplicate of the old link's send queue through the new link
before we open it for regular traffic. The last arriving packet copy,
on whichever link, will be dropped at the receiving end based on the
original sequence number, to ensure that only one copy is delivered to
the end receiver.
In this commit, we change the algorithm for receiving DUPLICATE_MSG
packets, at the same time delegating it to a new subfunction,
tipc_link_dup_rcv(). Instead of returning an extracted inner packet to
the packet reception loop in tipc_rcv(), we just add it to the receiving
(new) link's deferred packet queue. The packet will then be processed by
that link when it receives its first non-tunneled packet, i.e., at
latest when the changeover procedure is finished.
Because tipc_link_tunnel_rcv()/tipc_link_dup_rcv() now is consuming all
packets of type DUPLICATE_MSG, the calling tipc_rcv() function can omit
testing for this. This in turn means that the current conditional jump
to the label 'protocol_check' becomes redundant, and we can remove that
label.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:10 +00:00
|
|
|
}
|
|
|
|
|
tipc: change reception of tunnelled failover packets
When a link is reset, and there is a redundant link available, all
sender sockets will steer their subsequent traffic through the
remaining link. In order to guarantee preserved packet order and
cardinality during the transition, we tunnel the failing link's send
queue through the remaining link before we allow any sockets to use it.
In this commit, we change the algorithm for receiving failover
("ORIGINAL_MSG") packets in tipc_link_tunnel_rcv(), at the same time
delegating it to a new subfuncton, tipc_link_failover_rcv(). Instead
of directly returning an extracted inner packet to the packet reception
loop in tipc_rcv(), we first check if it is a message fragment, in which
case we append it to the reset link's fragment chain. If the fragment
chain is complete, we return the whole chain instead of the individual
buffer, eliminating any need for the tipc_rcv() loop to do reassembly of
tunneled packets.
This change makes it possible to further simplify tipc_link_tunnel_rcv(),
as well as the calling tipc_rcv() loop. We will do that in later
commits. It also makes it possible to identify a single spot in the code
where we can tell that a failover procedure is finished, something that
is useful when we are deleting links after a failover. This will also
be done in a later commit.
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 22:29:11 +00:00
|
|
|
/* tipc_link_failover_rcv(): Receive a tunnelled ORIGINAL_MSG packet
|
|
|
|
* Owner node is locked.
|
|
|
|
*/
|
|
|
|
static struct sk_buff *tipc_link_failover_rcv(struct tipc_link *l_ptr,
|
|
|
|
struct sk_buff *t_buf)
|
|
|
|
{
|
|
|
|
struct tipc_msg *t_msg = buf_msg(t_buf);
|
|
|
|
struct sk_buff *buf = NULL;
|
|
|
|
struct tipc_msg *msg;
|
|
|
|
|
|
|
|
if (tipc_link_is_up(l_ptr))
|
|
|
|
tipc_link_reset(l_ptr);
|
|
|
|
|
|
|
|
/* First failover packet? */
|
|
|
|
if (l_ptr->exp_msg_count == START_CHANGEOVER)
|
|
|
|
l_ptr->exp_msg_count = msg_msgcnt(t_msg);
|
|
|
|
|
|
|
|
/* Should there be an inner packet? */
|
|
|
|
if (l_ptr->exp_msg_count) {
|
|
|
|
l_ptr->exp_msg_count--;
|
|
|
|
buf = buf_extract(t_buf, INT_H_SIZE);
|
|
|
|
if (buf == NULL) {
|
|
|
|
pr_warn("%sno inner failover pkt\n", link_co_err);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
msg = buf_msg(buf);
|
|
|
|
|
|
|
|
if (less(msg_seqno(msg), l_ptr->reset_checkpoint)) {
|
|
|
|
kfree_skb(buf);
|
|
|
|
buf = NULL;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
if (msg_user(msg) == MSG_FRAGMENTER) {
|
|
|
|
l_ptr->stats.recv_fragments++;
|
2014-05-14 09:39:12 +00:00
|
|
|
tipc_buf_append(&l_ptr->reasm_buf, &buf);
|
tipc: change reception of tunnelled failover packets
When a link is reset, and there is a redundant link available, all
sender sockets will steer their subsequent traffic through the
remaining link. In order to guarantee preserved packet order and
cardinality during the transition, we tunnel the failing link's send
queue through the remaining link before we allow any sockets to use it.
In this commit, we change the algorithm for receiving failover
("ORIGINAL_MSG") packets in tipc_link_tunnel_rcv(), at the same time
delegating it to a new subfuncton, tipc_link_failover_rcv(). Instead
of directly returning an extracted inner packet to the packet reception
loop in tipc_rcv(), we first check if it is a message fragment, in which
case we append it to the reset link's fragment chain. If the fragment
chain is complete, we return the whole chain instead of the individual
buffer, eliminating any need for the tipc_rcv() loop to do reassembly of
tunneled packets.
This change makes it possible to further simplify tipc_link_tunnel_rcv(),
as well as the calling tipc_rcv() loop. We will do that in later
commits. It also makes it possible to identify a single spot in the code
where we can tell that a failover procedure is finished, something that
is useful when we are deleting links after a failover. This will also
be done in a later commit.
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 22:29:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
exit:
|
tipc: add reference count to struct tipc_link
When a bearer is disabled, all pertaining links will be reset and
deleted. However, if there is a second active link towards a killed
link's destination, the delete has to be postponed until the failover
is finished. During this interval, we currently put the link in zombie
mode, i.e., we take it out of traffic, delete its timer, but leave it
attached to the owner node structure until all missing packets have
been received. When this is done, we detach the link from its node
and delete it, assuming that the synchronous timer deletion that was
initiated earlier in a different thread has finished.
This is unsafe, as the failover may finish before del_timer_sync()
has returned in the other thread.
We fix this by adding an atomic reference counter of type kref in
struct tipc_link. The counter keeps track of the references kept
to the link by the owner node and the timer. We then do a conditional
delete, based on the reference counter, both after the failover has
been finished and when the timer expires, if applicable. Whoever
comes last, will actually delete the link. This approach also implies
that we can make the deletion of the timer asynchronous.
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
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-03 13:59:17 +00:00
|
|
|
if ((!l_ptr->exp_msg_count) && (l_ptr->flags & LINK_STOPPED))
|
|
|
|
tipc_link_delete(l_ptr);
|
tipc: change reception of tunnelled failover packets
When a link is reset, and there is a redundant link available, all
sender sockets will steer their subsequent traffic through the
remaining link. In order to guarantee preserved packet order and
cardinality during the transition, we tunnel the failing link's send
queue through the remaining link before we allow any sockets to use it.
In this commit, we change the algorithm for receiving failover
("ORIGINAL_MSG") packets in tipc_link_tunnel_rcv(), at the same time
delegating it to a new subfuncton, tipc_link_failover_rcv(). Instead
of directly returning an extracted inner packet to the packet reception
loop in tipc_rcv(), we first check if it is a message fragment, in which
case we append it to the reset link's fragment chain. If the fragment
chain is complete, we return the whole chain instead of the individual
buffer, eliminating any need for the tipc_rcv() loop to do reassembly of
tunneled packets.
This change makes it possible to further simplify tipc_link_tunnel_rcv(),
as well as the calling tipc_rcv() loop. We will do that in later
commits. It also makes it possible to identify a single spot in the code
where we can tell that a failover procedure is finished, something that
is useful when we are deleting links after a failover. This will also
be done in a later commit.
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 22:29:11 +00:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
tipc: change reception of tunnelled duplicate packets
When a second link to a destination comes up, some sender sockets will
steer their subsequent traffic through the new link. In order to
guarantee preserved packet order and cardinality for those sockets, we
tunnel a duplicate of the old link's send queue through the new link
before we open it for regular traffic. The last arriving packet copy,
on whichever link, will be dropped at the receiving end based on the
original sequence number, to ensure that only one copy is delivered to
the end receiver.
In this commit, we change the algorithm for receiving DUPLICATE_MSG
packets, at the same time delegating it to a new subfunction,
tipc_link_dup_rcv(). Instead of returning an extracted inner packet to
the packet reception loop in tipc_rcv(), we just add it to the receiving
(new) link's deferred packet queue. The packet will then be processed by
that link when it receives its first non-tunneled packet, i.e., at
latest when the changeover procedure is finished.
Because tipc_link_tunnel_rcv()/tipc_link_dup_rcv() now is consuming all
packets of type DUPLICATE_MSG, the calling tipc_rcv() function can omit
testing for this. This in turn means that the current conditional jump
to the label 'protocol_check' becomes redundant, and we can remove that
label.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:10 +00:00
|
|
|
/* tipc_link_tunnel_rcv(): Receive a tunnelled packet, sent
|
2014-01-07 22:02:41 +00:00
|
|
|
* via other link as result of a failover (ORIGINAL_MSG) or
|
|
|
|
* a new active link (DUPLICATE_MSG). Failover packets are
|
|
|
|
* returned to the active link for delivery upwards.
|
|
|
|
* Owner node is locked.
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2015-02-05 13:36:36 +00:00
|
|
|
static int tipc_link_tunnel_rcv(struct tipc_node *n_ptr,
|
2014-01-07 22:02:41 +00:00
|
|
|
struct sk_buff **buf)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2014-02-13 22:29:14 +00:00
|
|
|
struct sk_buff *t_buf = *buf;
|
|
|
|
struct tipc_link *l_ptr;
|
|
|
|
struct tipc_msg *t_msg = buf_msg(t_buf);
|
|
|
|
u32 bearer_id = msg_bearer_id(t_msg);
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2014-02-13 22:29:13 +00:00
|
|
|
*buf = NULL;
|
|
|
|
|
2013-05-06 08:28:41 +00:00
|
|
|
if (bearer_id >= MAX_BEARERS)
|
|
|
|
goto exit;
|
tipc: change reception of tunnelled duplicate packets
When a second link to a destination comes up, some sender sockets will
steer their subsequent traffic through the new link. In order to
guarantee preserved packet order and cardinality for those sockets, we
tunnel a duplicate of the old link's send queue through the new link
before we open it for regular traffic. The last arriving packet copy,
on whichever link, will be dropped at the receiving end based on the
original sequence number, to ensure that only one copy is delivered to
the end receiver.
In this commit, we change the algorithm for receiving DUPLICATE_MSG
packets, at the same time delegating it to a new subfunction,
tipc_link_dup_rcv(). Instead of returning an extracted inner packet to
the packet reception loop in tipc_rcv(), we just add it to the receiving
(new) link's deferred packet queue. The packet will then be processed by
that link when it receives its first non-tunneled packet, i.e., at
latest when the changeover procedure is finished.
Because tipc_link_tunnel_rcv()/tipc_link_dup_rcv() now is consuming all
packets of type DUPLICATE_MSG, the calling tipc_rcv() function can omit
testing for this. This in turn means that the current conditional jump
to the label 'protocol_check' becomes redundant, and we can remove that
label.
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-02-13 22:29:10 +00:00
|
|
|
|
2014-02-13 22:29:14 +00:00
|
|
|
l_ptr = n_ptr->links[bearer_id];
|
|
|
|
if (!l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
goto exit;
|
|
|
|
|
2014-02-13 22:29:14 +00:00
|
|
|
if (msg_type(t_msg) == DUPLICATE_MSG)
|
2015-02-05 13:36:36 +00:00
|
|
|
tipc_link_dup_rcv(l_ptr, t_buf);
|
2014-02-13 22:29:14 +00:00
|
|
|
else if (msg_type(t_msg) == ORIGINAL_MSG)
|
|
|
|
*buf = tipc_link_failover_rcv(l_ptr, t_buf);
|
2014-02-13 22:29:13 +00:00
|
|
|
else
|
|
|
|
pr_warn("%sunknown tunnel pkt received\n", link_co_err);
|
2006-01-02 18:04:38 +00:00
|
|
|
exit:
|
2014-02-13 22:29:14 +00:00
|
|
|
kfree_skb(t_buf);
|
2014-02-13 22:29:13 +00:00
|
|
|
return *buf != NULL;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2015-01-09 07:27:00 +00:00
|
|
|
static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tol)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2015-01-09 07:27:00 +00:00
|
|
|
unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;
|
|
|
|
|
|
|
|
if ((tol < TIPC_MIN_LINK_TOL) || (tol > TIPC_MAX_LINK_TOL))
|
2011-01-18 18:24:55 +00:00
|
|
|
return;
|
|
|
|
|
2015-01-09 07:27:00 +00:00
|
|
|
l_ptr->tolerance = tol;
|
|
|
|
l_ptr->cont_intv = msecs_to_jiffies(intv);
|
|
|
|
l_ptr->abort_limit = tol / (jiffies_to_msecs(l_ptr->cont_intv) / 4);
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
2011-12-30 01:58:42 +00:00
|
|
|
void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
/* Data messages from this node, inclusive FIRST_FRAGM */
|
2008-03-06 23:06:55 +00:00
|
|
|
l_ptr->queue_limit[TIPC_LOW_IMPORTANCE] = window;
|
|
|
|
l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE] = (window / 3) * 4;
|
|
|
|
l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE] = (window / 3) * 5;
|
|
|
|
l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE] = (window / 3) * 6;
|
2006-01-02 18:04:38 +00:00
|
|
|
/* Transiting data messages,inclusive FIRST_FRAGM */
|
2008-03-06 23:06:55 +00:00
|
|
|
l_ptr->queue_limit[TIPC_LOW_IMPORTANCE + 4] = 300;
|
|
|
|
l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE + 4] = 600;
|
|
|
|
l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;
|
|
|
|
l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;
|
2006-01-02 18:04:38 +00:00
|
|
|
l_ptr->queue_limit[CONN_MANAGER] = 1200;
|
|
|
|
l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;
|
|
|
|
l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;
|
|
|
|
/* FRAGMENT and LAST_FRAGMENT packets */
|
|
|
|
l_ptr->queue_limit[MSG_FRAGMENTER] = 4000;
|
|
|
|
}
|
|
|
|
|
2014-02-13 22:29:18 +00:00
|
|
|
/* tipc_link_find_owner - locate owner node of link by link's name
|
2015-01-09 07:27:05 +00:00
|
|
|
* @net: the applicable net namespace
|
2014-02-13 22:29:18 +00:00
|
|
|
* @name: pointer to link name string
|
|
|
|
* @bearer_id: pointer to index in 'node->links' array where the link was found.
|
2007-02-09 14:25:21 +00:00
|
|
|
*
|
2014-02-13 22:29:18 +00:00
|
|
|
* Returns pointer to node owning the link, or 0 if no matching link is found.
|
2006-01-02 18:04:38 +00:00
|
|
|
*/
|
2015-01-09 07:27:05 +00:00
|
|
|
static struct tipc_node *tipc_link_find_owner(struct net *net,
|
|
|
|
const char *link_name,
|
2014-02-13 22:29:18 +00:00
|
|
|
unsigned int *bearer_id)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2015-01-09 07:27:05 +00:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2011-12-30 01:58:42 +00:00
|
|
|
struct tipc_link *l_ptr;
|
2013-10-18 05:23:21 +00:00
|
|
|
struct tipc_node *n_ptr;
|
2014-12-25 11:05:50 +00:00
|
|
|
struct tipc_node *found_node = NULL;
|
2013-10-18 05:23:21 +00:00
|
|
|
int i;
|
2006-01-02 18:04:38 +00:00
|
|
|
|
2014-02-13 22:29:18 +00:00
|
|
|
*bearer_id = 0;
|
2014-03-27 04:54:37 +00:00
|
|
|
rcu_read_lock();
|
2015-01-09 07:27:05 +00:00
|
|
|
list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
|
2014-02-14 21:40:44 +00:00
|
|
|
tipc_node_lock(n_ptr);
|
2013-10-18 05:23:21 +00:00
|
|
|
for (i = 0; i < MAX_BEARERS; i++) {
|
|
|
|
l_ptr = n_ptr->links[i];
|
2014-02-13 22:29:18 +00:00
|
|
|
if (l_ptr && !strcmp(l_ptr->name, link_name)) {
|
|
|
|
*bearer_id = i;
|
|
|
|
found_node = n_ptr;
|
|
|
|
break;
|
|
|
|
}
|
2013-10-18 05:23:21 +00:00
|
|
|
}
|
2014-02-14 21:40:44 +00:00
|
|
|
tipc_node_unlock(n_ptr);
|
2014-02-13 22:29:18 +00:00
|
|
|
if (found_node)
|
|
|
|
break;
|
2013-10-18 05:23:21 +00:00
|
|
|
}
|
2014-03-27 04:54:37 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2014-02-13 22:29:18 +00:00
|
|
|
return found_node;
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* link_reset_statistics - reset link statistics
|
|
|
|
* @l_ptr: pointer to link
|
|
|
|
*/
|
2011-12-30 01:58:42 +00:00
|
|
|
static void link_reset_statistics(struct tipc_link *l_ptr)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
|
|
|
memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));
|
|
|
|
l_ptr->stats.sent_info = l_ptr->next_out_no;
|
|
|
|
l_ptr->stats.recv_info = l_ptr->next_in_no;
|
|
|
|
}
|
|
|
|
|
2011-12-30 01:58:42 +00:00
|
|
|
static void link_print(struct tipc_link *l_ptr, const char *str)
|
2006-01-02 18:04:38 +00:00
|
|
|
{
|
2015-01-09 07:27:06 +00:00
|
|
|
struct tipc_net *tn = net_generic(l_ptr->owner->net, tipc_net_id);
|
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 02:55:46 +00:00
|
|
|
struct tipc_bearer *b_ptr;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2015-01-09 07:27:06 +00:00
|
|
|
b_ptr = rcu_dereference_rtnl(tn->bearer_list[l_ptr->bearer_id]);
|
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 02:55:46 +00:00
|
|
|
if (b_ptr)
|
|
|
|
pr_info("%s Link %x<%s>:", str, l_ptr->addr, b_ptr->name);
|
|
|
|
rcu_read_unlock();
|
2010-12-31 18:59:27 +00:00
|
|
|
|
2006-01-02 18:04:38 +00:00
|
|
|
if (link_working_unknown(l_ptr))
|
2012-07-11 23:27:56 +00:00
|
|
|
pr_cont(":WU\n");
|
2010-12-31 18:59:27 +00:00
|
|
|
else if (link_reset_reset(l_ptr))
|
2012-07-11 23:27:56 +00:00
|
|
|
pr_cont(":RR\n");
|
2010-12-31 18:59:27 +00:00
|
|
|
else if (link_reset_unknown(l_ptr))
|
2012-07-11 23:27:56 +00:00
|
|
|
pr_cont(":RU\n");
|
2010-12-31 18:59:27 +00:00
|
|
|
else if (link_working_working(l_ptr))
|
2012-07-11 23:27:56 +00:00
|
|
|
pr_cont(":WW\n");
|
|
|
|
else
|
|
|
|
pr_cont("\n");
|
2006-01-02 18:04:38 +00:00
|
|
|
}
|
2014-11-20 09:29:07 +00:00
|
|
|
|
|
|
|
/* Parse and validate nested (link) properties valid for media, bearer and link
|
|
|
|
*/
|
|
|
|
int tipc_nl_parse_link_prop(struct nlattr *prop, struct nlattr *props[])
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = nla_parse_nested(props, TIPC_NLA_PROP_MAX, prop,
|
|
|
|
tipc_nl_prop_policy);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (props[TIPC_NLA_PROP_PRIO]) {
|
|
|
|
u32 prio;
|
|
|
|
|
|
|
|
prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
|
|
|
|
if (prio > TIPC_MAX_LINK_PRI)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (props[TIPC_NLA_PROP_TOL]) {
|
|
|
|
u32 tol;
|
|
|
|
|
|
|
|
tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
|
|
|
|
if ((tol < TIPC_MIN_LINK_TOL) || (tol > TIPC_MAX_LINK_TOL))
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (props[TIPC_NLA_PROP_WIN]) {
|
|
|
|
u32 win;
|
|
|
|
|
|
|
|
win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
|
|
|
|
if ((win < TIPC_MIN_LINK_WIN) || (win > TIPC_MAX_LINK_WIN))
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2014-11-20 09:29:12 +00:00
|
|
|
|
2014-11-20 09:29:13 +00:00
|
|
|
int tipc_nl_link_set(struct sk_buff *skb, struct genl_info *info)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int res = 0;
|
|
|
|
int bearer_id;
|
|
|
|
char *name;
|
|
|
|
struct tipc_link *link;
|
|
|
|
struct tipc_node *node;
|
|
|
|
struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
|
2015-02-09 08:50:08 +00:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2014-11-20 09:29:13 +00:00
|
|
|
|
|
|
|
if (!info->attrs[TIPC_NLA_LINK])
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
|
|
|
|
info->attrs[TIPC_NLA_LINK],
|
|
|
|
tipc_nl_link_policy);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (!attrs[TIPC_NLA_LINK_NAME])
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
|
|
|
|
|
2015-01-09 07:27:05 +00:00
|
|
|
node = tipc_link_find_owner(net, name, &bearer_id);
|
2014-11-20 09:29:13 +00:00
|
|
|
if (!node)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
tipc_node_lock(node);
|
|
|
|
|
|
|
|
link = node->links[bearer_id];
|
|
|
|
if (!link) {
|
|
|
|
res = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (attrs[TIPC_NLA_LINK_PROP]) {
|
|
|
|
struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
|
|
|
|
|
|
|
|
err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP],
|
|
|
|
props);
|
|
|
|
if (err) {
|
|
|
|
res = err;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (props[TIPC_NLA_PROP_TOL]) {
|
|
|
|
u32 tol;
|
|
|
|
|
|
|
|
tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
|
|
|
|
link_set_supervision_props(link, tol);
|
|
|
|
tipc_link_proto_xmit(link, STATE_MSG, 0, 0, tol, 0, 0);
|
|
|
|
}
|
|
|
|
if (props[TIPC_NLA_PROP_PRIO]) {
|
|
|
|
u32 prio;
|
|
|
|
|
|
|
|
prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
|
|
|
|
link->priority = prio;
|
|
|
|
tipc_link_proto_xmit(link, STATE_MSG, 0, 0, 0, prio, 0);
|
|
|
|
}
|
|
|
|
if (props[TIPC_NLA_PROP_WIN]) {
|
|
|
|
u32 win;
|
|
|
|
|
|
|
|
win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
|
|
|
|
tipc_link_set_queue_limits(link, win);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
2014-11-24 10:10:29 +00:00
|
|
|
|
|
|
|
static int __tipc_nl_add_stats(struct sk_buff *skb, struct tipc_stats *s)
|
2014-11-20 09:29:12 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct nlattr *stats;
|
|
|
|
|
|
|
|
struct nla_map {
|
|
|
|
u32 key;
|
|
|
|
u32 val;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct nla_map map[] = {
|
|
|
|
{TIPC_NLA_STATS_RX_INFO, s->recv_info},
|
|
|
|
{TIPC_NLA_STATS_RX_FRAGMENTS, s->recv_fragments},
|
|
|
|
{TIPC_NLA_STATS_RX_FRAGMENTED, s->recv_fragmented},
|
|
|
|
{TIPC_NLA_STATS_RX_BUNDLES, s->recv_bundles},
|
|
|
|
{TIPC_NLA_STATS_RX_BUNDLED, s->recv_bundled},
|
|
|
|
{TIPC_NLA_STATS_TX_INFO, s->sent_info},
|
|
|
|
{TIPC_NLA_STATS_TX_FRAGMENTS, s->sent_fragments},
|
|
|
|
{TIPC_NLA_STATS_TX_FRAGMENTED, s->sent_fragmented},
|
|
|
|
{TIPC_NLA_STATS_TX_BUNDLES, s->sent_bundles},
|
|
|
|
{TIPC_NLA_STATS_TX_BUNDLED, s->sent_bundled},
|
|
|
|
{TIPC_NLA_STATS_MSG_PROF_TOT, (s->msg_length_counts) ?
|
|
|
|
s->msg_length_counts : 1},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_CNT, s->msg_length_counts},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_TOT, s->msg_lengths_total},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_P0, s->msg_length_profile[0]},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_P1, s->msg_length_profile[1]},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_P2, s->msg_length_profile[2]},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_P3, s->msg_length_profile[3]},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_P4, s->msg_length_profile[4]},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_P5, s->msg_length_profile[5]},
|
|
|
|
{TIPC_NLA_STATS_MSG_LEN_P6, s->msg_length_profile[6]},
|
|
|
|
{TIPC_NLA_STATS_RX_STATES, s->recv_states},
|
|
|
|
{TIPC_NLA_STATS_RX_PROBES, s->recv_probes},
|
|
|
|
{TIPC_NLA_STATS_RX_NACKS, s->recv_nacks},
|
|
|
|
{TIPC_NLA_STATS_RX_DEFERRED, s->deferred_recv},
|
|
|
|
{TIPC_NLA_STATS_TX_STATES, s->sent_states},
|
|
|
|
{TIPC_NLA_STATS_TX_PROBES, s->sent_probes},
|
|
|
|
{TIPC_NLA_STATS_TX_NACKS, s->sent_nacks},
|
|
|
|
{TIPC_NLA_STATS_TX_ACKS, s->sent_acks},
|
|
|
|
{TIPC_NLA_STATS_RETRANSMITTED, s->retransmitted},
|
|
|
|
{TIPC_NLA_STATS_DUPLICATES, s->duplicates},
|
|
|
|
{TIPC_NLA_STATS_LINK_CONGS, s->link_congs},
|
|
|
|
{TIPC_NLA_STATS_MAX_QUEUE, s->max_queue_sz},
|
|
|
|
{TIPC_NLA_STATS_AVG_QUEUE, s->queue_sz_counts ?
|
|
|
|
(s->accu_queue_sz / s->queue_sz_counts) : 0}
|
|
|
|
};
|
|
|
|
|
|
|
|
stats = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
|
|
|
|
if (!stats)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(map); i++)
|
|
|
|
if (nla_put_u32(skb, map[i].key, map[i].val))
|
|
|
|
goto msg_full;
|
|
|
|
|
|
|
|
nla_nest_end(skb, stats);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
msg_full:
|
|
|
|
nla_nest_cancel(skb, stats);
|
|
|
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Caller should hold appropriate locks to protect the link */
|
2015-01-09 07:27:10 +00:00
|
|
|
static int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,
|
|
|
|
struct tipc_link *link)
|
2014-11-20 09:29:12 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
void *hdr;
|
|
|
|
struct nlattr *attrs;
|
|
|
|
struct nlattr *prop;
|
2015-01-09 07:27:10 +00:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2014-11-20 09:29:12 +00:00
|
|
|
|
2015-02-09 08:50:03 +00:00
|
|
|
hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
|
2014-11-20 09:29:12 +00:00
|
|
|
NLM_F_MULTI, TIPC_NL_LINK_GET);
|
|
|
|
if (!hdr)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
|
|
|
|
if (!attrs)
|
|
|
|
goto msg_full;
|
|
|
|
|
|
|
|
if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, link->name))
|
|
|
|
goto attr_msg_full;
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_LINK_DEST,
|
2015-01-09 07:27:10 +00:00
|
|
|
tipc_cluster_mask(tn->own_addr)))
|
2014-11-20 09:29:12 +00:00
|
|
|
goto attr_msg_full;
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_LINK_MTU, link->max_pkt))
|
|
|
|
goto attr_msg_full;
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, link->next_in_no))
|
|
|
|
goto attr_msg_full;
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, link->next_out_no))
|
|
|
|
goto attr_msg_full;
|
|
|
|
|
|
|
|
if (tipc_link_is_up(link))
|
|
|
|
if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
|
|
|
|
goto attr_msg_full;
|
|
|
|
if (tipc_link_is_active(link))
|
|
|
|
if (nla_put_flag(msg->skb, TIPC_NLA_LINK_ACTIVE))
|
|
|
|
goto attr_msg_full;
|
|
|
|
|
|
|
|
prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
|
|
|
|
if (!prop)
|
|
|
|
goto attr_msg_full;
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
|
|
|
|
goto prop_msg_full;
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, link->tolerance))
|
|
|
|
goto prop_msg_full;
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN,
|
|
|
|
link->queue_limit[TIPC_LOW_IMPORTANCE]))
|
|
|
|
goto prop_msg_full;
|
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
|
|
|
|
goto prop_msg_full;
|
|
|
|
nla_nest_end(msg->skb, prop);
|
|
|
|
|
|
|
|
err = __tipc_nl_add_stats(msg->skb, &link->stats);
|
|
|
|
if (err)
|
|
|
|
goto attr_msg_full;
|
|
|
|
|
|
|
|
nla_nest_end(msg->skb, attrs);
|
|
|
|
genlmsg_end(msg->skb, hdr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
prop_msg_full:
|
|
|
|
nla_nest_cancel(msg->skb, prop);
|
|
|
|
attr_msg_full:
|
|
|
|
nla_nest_cancel(msg->skb, attrs);
|
|
|
|
msg_full:
|
|
|
|
genlmsg_cancel(msg->skb, hdr);
|
|
|
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Caller should hold node lock */
|
2015-01-09 07:27:10 +00:00
|
|
|
static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg,
|
|
|
|
struct tipc_node *node, u32 *prev_link)
|
2014-11-20 09:29:12 +00:00
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
for (i = *prev_link; i < MAX_BEARERS; i++) {
|
|
|
|
*prev_link = i;
|
|
|
|
|
|
|
|
if (!node->links[i])
|
|
|
|
continue;
|
|
|
|
|
2015-01-09 07:27:10 +00:00
|
|
|
err = __tipc_nl_add_link(net, msg, node->links[i]);
|
2014-11-20 09:29:12 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
*prev_link = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
2015-01-09 07:27:05 +00:00
|
|
|
struct net *net = sock_net(skb->sk);
|
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2014-11-20 09:29:12 +00:00
|
|
|
struct tipc_node *node;
|
|
|
|
struct tipc_nl_msg msg;
|
|
|
|
u32 prev_node = cb->args[0];
|
|
|
|
u32 prev_link = cb->args[1];
|
|
|
|
int done = cb->args[2];
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (done)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
msg.skb = skb;
|
|
|
|
msg.portid = NETLINK_CB(cb->skb).portid;
|
|
|
|
msg.seq = cb->nlh->nlmsg_seq;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
if (prev_node) {
|
2015-01-09 07:27:05 +00:00
|
|
|
node = tipc_node_find(net, prev_node);
|
2014-11-20 09:29:12 +00:00
|
|
|
if (!node) {
|
|
|
|
/* 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 last NLMSG_DONE message
|
|
|
|
* having the NLM_F_DUMP_INTR flag set.
|
|
|
|
*/
|
|
|
|
cb->prev_seq = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-01-09 07:27:05 +00:00
|
|
|
list_for_each_entry_continue_rcu(node, &tn->node_list,
|
|
|
|
list) {
|
2014-11-20 09:29:12 +00:00
|
|
|
tipc_node_lock(node);
|
2015-01-09 07:27:10 +00:00
|
|
|
err = __tipc_nl_add_node_links(net, &msg, node,
|
|
|
|
&prev_link);
|
2014-11-20 09:29:12 +00:00
|
|
|
tipc_node_unlock(node);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
prev_node = node->addr;
|
|
|
|
}
|
|
|
|
} else {
|
2015-01-09 07:27:07 +00:00
|
|
|
err = tipc_nl_add_bc_link(net, &msg);
|
2014-11-20 09:29:12 +00:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2015-01-09 07:27:05 +00:00
|
|
|
list_for_each_entry_rcu(node, &tn->node_list, list) {
|
2014-11-20 09:29:12 +00:00
|
|
|
tipc_node_lock(node);
|
2015-01-09 07:27:10 +00:00
|
|
|
err = __tipc_nl_add_node_links(net, &msg, node,
|
|
|
|
&prev_link);
|
2014-11-20 09:29:12 +00:00
|
|
|
tipc_node_unlock(node);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
prev_node = node->addr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
done = 1;
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
cb->args[0] = prev_node;
|
|
|
|
cb->args[1] = prev_link;
|
|
|
|
cb->args[2] = done;
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
int tipc_nl_link_get(struct sk_buff *skb, struct genl_info *info)
|
|
|
|
{
|
2015-01-09 07:27:05 +00:00
|
|
|
struct net *net = genl_info_net(info);
|
2014-11-20 09:29:12 +00:00
|
|
|
struct sk_buff *ans_skb;
|
|
|
|
struct tipc_nl_msg msg;
|
|
|
|
struct tipc_link *link;
|
|
|
|
struct tipc_node *node;
|
|
|
|
char *name;
|
|
|
|
int bearer_id;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!info->attrs[TIPC_NLA_LINK_NAME])
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
name = nla_data(info->attrs[TIPC_NLA_LINK_NAME]);
|
2015-01-09 07:27:05 +00:00
|
|
|
node = tipc_link_find_owner(net, name, &bearer_id);
|
2014-11-20 09:29:12 +00:00
|
|
|
if (!node)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ans_skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
|
|
|
|
if (!ans_skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
msg.skb = ans_skb;
|
|
|
|
msg.portid = info->snd_portid;
|
|
|
|
msg.seq = info->snd_seq;
|
|
|
|
|
|
|
|
tipc_node_lock(node);
|
|
|
|
link = node->links[bearer_id];
|
|
|
|
if (!link) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
2015-01-09 07:27:10 +00:00
|
|
|
err = __tipc_nl_add_link(net, &msg, link);
|
2014-11-20 09:29:12 +00:00
|
|
|
if (err)
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
|
|
|
|
return genlmsg_reply(ans_skb, info);
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
nlmsg_free(ans_skb);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2014-11-20 09:29:14 +00:00
|
|
|
|
|
|
|
int tipc_nl_link_reset_stats(struct sk_buff *skb, struct genl_info *info)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
char *link_name;
|
|
|
|
unsigned int bearer_id;
|
|
|
|
struct tipc_link *link;
|
|
|
|
struct tipc_node *node;
|
|
|
|
struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
|
2015-02-09 08:50:09 +00:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2014-11-20 09:29:14 +00:00
|
|
|
|
|
|
|
if (!info->attrs[TIPC_NLA_LINK])
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,
|
|
|
|
info->attrs[TIPC_NLA_LINK],
|
|
|
|
tipc_nl_link_policy);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (!attrs[TIPC_NLA_LINK_NAME])
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
|
|
|
|
|
|
|
|
if (strcmp(link_name, tipc_bclink_name) == 0) {
|
2015-01-09 07:27:07 +00:00
|
|
|
err = tipc_bclink_reset_stats(net);
|
2014-11-20 09:29:14 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-09 07:27:05 +00:00
|
|
|
node = tipc_link_find_owner(net, link_name, &bearer_id);
|
2014-11-20 09:29:14 +00:00
|
|
|
if (!node)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
tipc_node_lock(node);
|
|
|
|
|
|
|
|
link = node->links[bearer_id];
|
|
|
|
if (!link) {
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
link_reset_statistics(link);
|
|
|
|
|
|
|
|
tipc_node_unlock(node);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|