2006-01-02 11:04:38 -07:00
|
|
|
/*
|
|
|
|
* net/tipc/net.c: TIPC network routing code
|
2007-02-09 07:25:21 -07:00
|
|
|
*
|
tipc: introduce message evaluation function
When a message arrives in a node and finds no destination
socket, we may need to drop it, reject it, or forward it after
a secondary destination lookup. The latter two cases currently
results in a code path that is perceived as complex, because it
follows a deep call chain via obscure functions such as
net_route_named_msg() and net_route_msg().
We now introduce a function, tipc_msg_eval(), that takes the
decision about whether such a message should be rejected or
forwarded, but leaves it to the caller to actually perform
the indicated action.
If the decision is 'reject', it is still the task of the recently
introduced function tipc_msg_reverse() to take the final decision
about whether the message is rejectable or not. In the latter case
it drops the message.
As a result of this change, we can finally eliminate the function
net_route_named_msg(), and hence become independent of net_route_msg().
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-25 19:41:36 -06:00
|
|
|
* Copyright (c) 1995-2006, 2014, Ericsson AB
|
2011-02-24 11:20:20 -07:00
|
|
|
* Copyright (c) 2005, 2010-2011, Wind River Systems
|
2006-01-02 11:04:38 -07:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
2006-01-11 05:30:43 -07: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.
|
|
|
|
*
|
|
|
|
* 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.
|
2006-01-02 11:04:38 -07:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "core.h"
|
|
|
|
#include "net.h"
|
|
|
|
#include "name_distr.h"
|
|
|
|
#include "subscr.h"
|
2014-05-14 03:39:15 -06:00
|
|
|
#include "socket.h"
|
2011-02-25 16:42:52 -07:00
|
|
|
#include "node.h"
|
2006-01-02 11:04:38 -07:00
|
|
|
#include "config.h"
|
|
|
|
|
2014-11-20 02:29:18 -07:00
|
|
|
static const struct nla_policy tipc_nl_net_policy[TIPC_NLA_NET_MAX + 1] = {
|
|
|
|
[TIPC_NLA_NET_UNSPEC] = { .type = NLA_UNSPEC },
|
|
|
|
[TIPC_NLA_NET_ID] = { .type = NLA_U32 }
|
|
|
|
};
|
|
|
|
|
2007-02-09 07:25:21 -07:00
|
|
|
/*
|
2006-01-02 11:04:38 -07:00
|
|
|
* The TIPC locking policy is designed to ensure a very fine locking
|
|
|
|
* granularity, permitting complete parallel access to individual
|
tipc: purge tipc_net_lock lock
Now tipc routing hierarchy comprises the structures 'node', 'link'and
'bearer'. The whole hierarchy is protected by a big read/write lock,
tipc_net_lock, to ensure that nothing is added or removed while code
is accessing any of these structures. Obviously the locking policy
makes node, link and bearer components closely bound together so that
their relationship becomes unnecessarily complex. In the worst case,
such locking policy not only has a negative influence on performance,
but also it's prone to lead to deadlock occasionally.
In order o decouple the complex relationship between bearer and node
as well as link, the locking policy is adjusted as follows:
- Bearer level
RTNL lock is used on update side, and RCU is used on read side.
Meanwhile, all bearer instances including broadcast bearer are
saved into bearer_list array.
- Node and link level
All node instances are saved into two tipc_node_list and node_htable
lists. The two lists are protected by node_list_lock on write side,
and they are guarded with RCU lock on read side. All members in node
structure including link instances are protected by node spin lock.
- The relationship between bearer and node
When link accesses bearer, it first needs to find the bearer with
its bearer identity from the bearer_list array. When bearer accesses
node, it can iterate the node_htable hash list with the node
address to find the corresponding node.
In the new locking policy, every component has its private locking
solution and the relationship between bearer and node is very simple,
that is, they can find each other with node address or bearer identity
from node_htable hash list or bearer_list array.
Until now above all changes have been done, so tipc_net_lock can be
removed safely.
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-20 20:55:48 -06:00
|
|
|
* port and node/link instances. The code consists of four major
|
2006-01-02 11:04:38 -07:00
|
|
|
* locking domains, each protected with their own disjunct set of locks.
|
|
|
|
*
|
tipc: purge tipc_net_lock lock
Now tipc routing hierarchy comprises the structures 'node', 'link'and
'bearer'. The whole hierarchy is protected by a big read/write lock,
tipc_net_lock, to ensure that nothing is added or removed while code
is accessing any of these structures. Obviously the locking policy
makes node, link and bearer components closely bound together so that
their relationship becomes unnecessarily complex. In the worst case,
such locking policy not only has a negative influence on performance,
but also it's prone to lead to deadlock occasionally.
In order o decouple the complex relationship between bearer and node
as well as link, the locking policy is adjusted as follows:
- Bearer level
RTNL lock is used on update side, and RCU is used on read side.
Meanwhile, all bearer instances including broadcast bearer are
saved into bearer_list array.
- Node and link level
All node instances are saved into two tipc_node_list and node_htable
lists. The two lists are protected by node_list_lock on write side,
and they are guarded with RCU lock on read side. All members in node
structure including link instances are protected by node spin lock.
- The relationship between bearer and node
When link accesses bearer, it first needs to find the bearer with
its bearer identity from the bearer_list array. When bearer accesses
node, it can iterate the node_htable hash list with the node
address to find the corresponding node.
In the new locking policy, every component has its private locking
solution and the relationship between bearer and node is very simple,
that is, they can find each other with node address or bearer identity
from node_htable hash list or bearer_list array.
Until now above all changes have been done, so tipc_net_lock can be
removed safely.
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-20 20:55:48 -06:00
|
|
|
* 1: The bearer level.
|
|
|
|
* RTNL lock is used to serialize the process of configuring bearer
|
|
|
|
* on update side, and RCU lock is applied on read side to make
|
|
|
|
* bearer instance valid on both paths of message transmission and
|
|
|
|
* reception.
|
2006-01-02 11:04:38 -07:00
|
|
|
*
|
tipc: purge tipc_net_lock lock
Now tipc routing hierarchy comprises the structures 'node', 'link'and
'bearer'. The whole hierarchy is protected by a big read/write lock,
tipc_net_lock, to ensure that nothing is added or removed while code
is accessing any of these structures. Obviously the locking policy
makes node, link and bearer components closely bound together so that
their relationship becomes unnecessarily complex. In the worst case,
such locking policy not only has a negative influence on performance,
but also it's prone to lead to deadlock occasionally.
In order o decouple the complex relationship between bearer and node
as well as link, the locking policy is adjusted as follows:
- Bearer level
RTNL lock is used on update side, and RCU is used on read side.
Meanwhile, all bearer instances including broadcast bearer are
saved into bearer_list array.
- Node and link level
All node instances are saved into two tipc_node_list and node_htable
lists. The two lists are protected by node_list_lock on write side,
and they are guarded with RCU lock on read side. All members in node
structure including link instances are protected by node spin lock.
- The relationship between bearer and node
When link accesses bearer, it first needs to find the bearer with
its bearer identity from the bearer_list array. When bearer accesses
node, it can iterate the node_htable hash list with the node
address to find the corresponding node.
In the new locking policy, every component has its private locking
solution and the relationship between bearer and node is very simple,
that is, they can find each other with node address or bearer identity
from node_htable hash list or bearer_list array.
Until now above all changes have been done, so tipc_net_lock can be
removed safely.
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-20 20:55:48 -06:00
|
|
|
* 2: The node and link level.
|
|
|
|
* All node instances are saved into two tipc_node_list and node_htable
|
|
|
|
* lists. The two lists are protected by node_list_lock on write side,
|
|
|
|
* and they are guarded with RCU lock on read side. Especially node
|
|
|
|
* instance is destroyed only when TIPC module is removed, and we can
|
|
|
|
* confirm that there has no any user who is accessing the node at the
|
|
|
|
* moment. Therefore, Except for iterating the two lists within RCU
|
|
|
|
* protection, it's no needed to hold RCU that we access node instance
|
|
|
|
* in other places.
|
2006-01-02 11:04:38 -07:00
|
|
|
*
|
tipc: purge tipc_net_lock lock
Now tipc routing hierarchy comprises the structures 'node', 'link'and
'bearer'. The whole hierarchy is protected by a big read/write lock,
tipc_net_lock, to ensure that nothing is added or removed while code
is accessing any of these structures. Obviously the locking policy
makes node, link and bearer components closely bound together so that
their relationship becomes unnecessarily complex. In the worst case,
such locking policy not only has a negative influence on performance,
but also it's prone to lead to deadlock occasionally.
In order o decouple the complex relationship between bearer and node
as well as link, the locking policy is adjusted as follows:
- Bearer level
RTNL lock is used on update side, and RCU is used on read side.
Meanwhile, all bearer instances including broadcast bearer are
saved into bearer_list array.
- Node and link level
All node instances are saved into two tipc_node_list and node_htable
lists. The two lists are protected by node_list_lock on write side,
and they are guarded with RCU lock on read side. All members in node
structure including link instances are protected by node spin lock.
- The relationship between bearer and node
When link accesses bearer, it first needs to find the bearer with
its bearer identity from the bearer_list array. When bearer accesses
node, it can iterate the node_htable hash list with the node
address to find the corresponding node.
In the new locking policy, every component has its private locking
solution and the relationship between bearer and node is very simple,
that is, they can find each other with node address or bearer identity
from node_htable hash list or bearer_list array.
Until now above all changes have been done, so tipc_net_lock can be
removed safely.
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-20 20:55:48 -06:00
|
|
|
* In addition, all members in node structure including link instances
|
|
|
|
* are protected by node spin lock.
|
2007-02-09 07:25:21 -07:00
|
|
|
*
|
tipc: purge tipc_net_lock lock
Now tipc routing hierarchy comprises the structures 'node', 'link'and
'bearer'. The whole hierarchy is protected by a big read/write lock,
tipc_net_lock, to ensure that nothing is added or removed while code
is accessing any of these structures. Obviously the locking policy
makes node, link and bearer components closely bound together so that
their relationship becomes unnecessarily complex. In the worst case,
such locking policy not only has a negative influence on performance,
but also it's prone to lead to deadlock occasionally.
In order o decouple the complex relationship between bearer and node
as well as link, the locking policy is adjusted as follows:
- Bearer level
RTNL lock is used on update side, and RCU is used on read side.
Meanwhile, all bearer instances including broadcast bearer are
saved into bearer_list array.
- Node and link level
All node instances are saved into two tipc_node_list and node_htable
lists. The two lists are protected by node_list_lock on write side,
and they are guarded with RCU lock on read side. All members in node
structure including link instances are protected by node spin lock.
- The relationship between bearer and node
When link accesses bearer, it first needs to find the bearer with
its bearer identity from the bearer_list array. When bearer accesses
node, it can iterate the node_htable hash list with the node
address to find the corresponding node.
In the new locking policy, every component has its private locking
solution and the relationship between bearer and node is very simple,
that is, they can find each other with node address or bearer identity
from node_htable hash list or bearer_list array.
Until now above all changes have been done, so tipc_net_lock can be
removed safely.
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-20 20:55:48 -06:00
|
|
|
* 3: The transport level of the protocol.
|
|
|
|
* This consists of the structures port, (and its user level
|
|
|
|
* representations, such as user_port and tipc_sock), reference and
|
|
|
|
* tipc_user (port.c, reg.c, socket.c).
|
2006-01-02 11:04:38 -07:00
|
|
|
*
|
tipc: purge tipc_net_lock lock
Now tipc routing hierarchy comprises the structures 'node', 'link'and
'bearer'. The whole hierarchy is protected by a big read/write lock,
tipc_net_lock, to ensure that nothing is added or removed while code
is accessing any of these structures. Obviously the locking policy
makes node, link and bearer components closely bound together so that
their relationship becomes unnecessarily complex. In the worst case,
such locking policy not only has a negative influence on performance,
but also it's prone to lead to deadlock occasionally.
In order o decouple the complex relationship between bearer and node
as well as link, the locking policy is adjusted as follows:
- Bearer level
RTNL lock is used on update side, and RCU is used on read side.
Meanwhile, all bearer instances including broadcast bearer are
saved into bearer_list array.
- Node and link level
All node instances are saved into two tipc_node_list and node_htable
lists. The two lists are protected by node_list_lock on write side,
and they are guarded with RCU lock on read side. All members in node
structure including link instances are protected by node spin lock.
- The relationship between bearer and node
When link accesses bearer, it first needs to find the bearer with
its bearer identity from the bearer_list array. When bearer accesses
node, it can iterate the node_htable hash list with the node
address to find the corresponding node.
In the new locking policy, every component has its private locking
solution and the relationship between bearer and node is very simple,
that is, they can find each other with node address or bearer identity
from node_htable hash list or bearer_list array.
Until now above all changes have been done, so tipc_net_lock can be
removed safely.
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-20 20:55:48 -06:00
|
|
|
* This layer has four different locks:
|
2006-01-02 11:04:38 -07:00
|
|
|
* - The tipc_port spin_lock. This is protecting each port instance
|
2007-02-09 07:25:21 -07:00
|
|
|
* from parallel data access and removal. Since we can not place
|
|
|
|
* this lock in the port itself, it has been placed in the
|
2006-01-02 11:04:38 -07:00
|
|
|
* corresponding reference table entry, which has the same life
|
2007-02-09 07:25:21 -07:00
|
|
|
* cycle as the module. This entry is difficult to access from
|
|
|
|
* outside the TIPC core, however, so a pointer to the lock has
|
|
|
|
* been added in the port instance, -to be used for unlocking
|
2006-01-02 11:04:38 -07:00
|
|
|
* only.
|
2007-02-09 07:25:21 -07:00
|
|
|
* - A read/write lock to protect the reference table itself (teg.c).
|
|
|
|
* (Nobody is using read-only access to this, so it can just as
|
2006-01-02 11:04:38 -07:00
|
|
|
* well be changed to a spin_lock)
|
|
|
|
* - A spin lock to protect the registry of kernel/driver users (reg.c)
|
2007-02-09 07:25:21 -07:00
|
|
|
* - A global spin_lock (tipc_port_lock), which only task is to ensure
|
2006-01-02 11:04:38 -07:00
|
|
|
* consistency where more than one port is involved in an operation,
|
|
|
|
* i.e., whe a port is part of a linked list of ports.
|
|
|
|
* There are two such lists; 'port_list', which is used for management,
|
|
|
|
* and 'wait_list', which is used to queue ports during congestion.
|
2007-02-09 07:25:21 -07:00
|
|
|
*
|
tipc: purge tipc_net_lock lock
Now tipc routing hierarchy comprises the structures 'node', 'link'and
'bearer'. The whole hierarchy is protected by a big read/write lock,
tipc_net_lock, to ensure that nothing is added or removed while code
is accessing any of these structures. Obviously the locking policy
makes node, link and bearer components closely bound together so that
their relationship becomes unnecessarily complex. In the worst case,
such locking policy not only has a negative influence on performance,
but also it's prone to lead to deadlock occasionally.
In order o decouple the complex relationship between bearer and node
as well as link, the locking policy is adjusted as follows:
- Bearer level
RTNL lock is used on update side, and RCU is used on read side.
Meanwhile, all bearer instances including broadcast bearer are
saved into bearer_list array.
- Node and link level
All node instances are saved into two tipc_node_list and node_htable
lists. The two lists are protected by node_list_lock on write side,
and they are guarded with RCU lock on read side. All members in node
structure including link instances are protected by node spin lock.
- The relationship between bearer and node
When link accesses bearer, it first needs to find the bearer with
its bearer identity from the bearer_list array. When bearer accesses
node, it can iterate the node_htable hash list with the node
address to find the corresponding node.
In the new locking policy, every component has its private locking
solution and the relationship between bearer and node is very simple,
that is, they can find each other with node address or bearer identity
from node_htable hash list or bearer_list array.
Until now above all changes have been done, so tipc_net_lock can be
removed safely.
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-20 20:55:48 -06:00
|
|
|
* 4: The name table (name_table.c, name_distr.c, subscription.c)
|
2007-02-09 07:25:21 -07:00
|
|
|
* - There is one big read/write-lock (tipc_nametbl_lock) protecting the
|
|
|
|
* overall name table structure. Nothing must be added/removed to
|
2006-01-02 11:04:38 -07:00
|
|
|
* this structure without holding write access to it.
|
|
|
|
* - There is one local spin_lock per sub_sequence, which can be seen
|
2006-01-17 16:38:21 -07:00
|
|
|
* as a sub-domain to the tipc_nametbl_lock domain. It is used only
|
2006-01-02 11:04:38 -07:00
|
|
|
* for translation operations, and is needed because a translation
|
|
|
|
* steps the root of the 'publication' linked list between each lookup.
|
2006-01-17 16:38:21 -07:00
|
|
|
* This is always used within the scope of a tipc_nametbl_lock(read).
|
2006-01-02 11:04:38 -07:00
|
|
|
* - A local spin_lock protecting the queue of subscriber events.
|
|
|
|
*/
|
|
|
|
|
2015-01-09 00:27:04 -07:00
|
|
|
int tipc_net_start(struct net *net, u32 addr)
|
2006-01-02 11:04:38 -07:00
|
|
|
{
|
2015-01-09 00:27:04 -07:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2006-01-02 11:04:38 -07:00
|
|
|
char addr_string[16];
|
2014-05-04 18:56:16 -06:00
|
|
|
int res;
|
2006-01-02 11:04:38 -07:00
|
|
|
|
2008-05-21 15:55:04 -06:00
|
|
|
tipc_own_addr = addr;
|
2006-01-17 16:38:21 -07:00
|
|
|
tipc_named_reinit();
|
2014-08-22 16:09:14 -06:00
|
|
|
tipc_sk_reinit();
|
2015-01-09 00:27:06 -07:00
|
|
|
res = tipc_bclink_init(net);
|
2014-05-04 18:56:16 -06:00
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
|
2015-01-09 00:27:05 -07:00
|
|
|
tipc_nametbl_publish(net, TIPC_CFG_SRV, tipc_own_addr, tipc_own_addr,
|
2014-04-03 00:28:01 -06:00
|
|
|
TIPC_ZONE_SCOPE, 0, tipc_own_addr);
|
tipc: purge tipc_net_lock lock
Now tipc routing hierarchy comprises the structures 'node', 'link'and
'bearer'. The whole hierarchy is protected by a big read/write lock,
tipc_net_lock, to ensure that nothing is added or removed while code
is accessing any of these structures. Obviously the locking policy
makes node, link and bearer components closely bound together so that
their relationship becomes unnecessarily complex. In the worst case,
such locking policy not only has a negative influence on performance,
but also it's prone to lead to deadlock occasionally.
In order o decouple the complex relationship between bearer and node
as well as link, the locking policy is adjusted as follows:
- Bearer level
RTNL lock is used on update side, and RCU is used on read side.
Meanwhile, all bearer instances including broadcast bearer are
saved into bearer_list array.
- Node and link level
All node instances are saved into two tipc_node_list and node_htable
lists. The two lists are protected by node_list_lock on write side,
and they are guarded with RCU lock on read side. All members in node
structure including link instances are protected by node spin lock.
- The relationship between bearer and node
When link accesses bearer, it first needs to find the bearer with
its bearer identity from the bearer_list array. When bearer accesses
node, it can iterate the node_htable hash list with the node
address to find the corresponding node.
In the new locking policy, every component has its private locking
solution and the relationship between bearer and node is very simple,
that is, they can find each other with node address or bearer identity
from node_htable hash list or bearer_list array.
Until now above all changes have been done, so tipc_net_lock can be
removed safely.
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-20 20:55:48 -06:00
|
|
|
|
2012-06-28 22:16:37 -06:00
|
|
|
pr_info("Started in network mode\n");
|
|
|
|
pr_info("Own node address %s, network identity %u\n",
|
2015-01-09 00:27:04 -07:00
|
|
|
tipc_addr_string_fill(addr_string, tipc_own_addr),
|
|
|
|
tn->net_id);
|
2014-05-04 18:56:16 -06:00
|
|
|
return 0;
|
2006-01-02 11:04:38 -07:00
|
|
|
}
|
|
|
|
|
2015-01-09 00:27:05 -07:00
|
|
|
void tipc_net_stop(struct net *net)
|
2006-01-02 11:04:38 -07:00
|
|
|
{
|
2011-11-08 11:48:28 -07:00
|
|
|
if (!tipc_own_addr)
|
2006-01-02 11:04:38 -07:00
|
|
|
return;
|
2014-03-26 22:54:36 -06:00
|
|
|
|
2015-01-09 00:27:05 -07:00
|
|
|
tipc_nametbl_withdraw(net, TIPC_CFG_SRV, tipc_own_addr, 0,
|
|
|
|
tipc_own_addr);
|
2014-04-20 20:55:44 -06:00
|
|
|
rtnl_lock();
|
2015-01-09 00:27:05 -07:00
|
|
|
tipc_bearer_stop(net);
|
2015-01-09 00:27:06 -07:00
|
|
|
tipc_bclink_stop(net);
|
2015-01-09 00:27:05 -07:00
|
|
|
tipc_node_stop(net);
|
2014-04-20 20:55:44 -06:00
|
|
|
rtnl_unlock();
|
2014-03-26 22:54:36 -06:00
|
|
|
|
2012-06-28 22:16:37 -06:00
|
|
|
pr_info("Left network mode\n");
|
2006-01-02 11:04:38 -07:00
|
|
|
}
|
2014-11-20 02:29:18 -07:00
|
|
|
|
2015-01-09 00:27:04 -07:00
|
|
|
static int __tipc_nl_add_net(struct net *net, struct tipc_nl_msg *msg)
|
2014-11-20 02:29:18 -07:00
|
|
|
{
|
2015-01-09 00:27:04 -07:00
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2014-11-20 02:29:18 -07:00
|
|
|
void *hdr;
|
|
|
|
struct nlattr *attrs;
|
|
|
|
|
|
|
|
hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_v2_family,
|
|
|
|
NLM_F_MULTI, TIPC_NL_NET_GET);
|
|
|
|
if (!hdr)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
attrs = nla_nest_start(msg->skb, TIPC_NLA_NET);
|
|
|
|
if (!attrs)
|
|
|
|
goto msg_full;
|
|
|
|
|
2015-01-09 00:27:04 -07:00
|
|
|
if (nla_put_u32(msg->skb, TIPC_NLA_NET_ID, tn->net_id))
|
2014-11-20 02:29:18 -07:00
|
|
|
goto attr_msg_full;
|
|
|
|
|
|
|
|
nla_nest_end(msg->skb, attrs);
|
|
|
|
genlmsg_end(msg->skb, hdr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
attr_msg_full:
|
|
|
|
nla_nest_cancel(msg->skb, attrs);
|
|
|
|
msg_full:
|
|
|
|
genlmsg_cancel(msg->skb, hdr);
|
|
|
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
int tipc_nl_net_dump(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
2015-01-09 00:27:04 -07:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2014-11-20 02:29:18 -07:00
|
|
|
int err;
|
|
|
|
int done = cb->args[0];
|
|
|
|
struct tipc_nl_msg msg;
|
|
|
|
|
|
|
|
if (done)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
msg.skb = skb;
|
|
|
|
msg.portid = NETLINK_CB(cb->skb).portid;
|
|
|
|
msg.seq = cb->nlh->nlmsg_seq;
|
|
|
|
|
2015-01-09 00:27:04 -07:00
|
|
|
err = __tipc_nl_add_net(net, &msg);
|
2014-11-20 02:29:18 -07:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
done = 1;
|
|
|
|
out:
|
|
|
|
cb->args[0] = done;
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
}
|
2014-11-20 02:29:19 -07:00
|
|
|
|
|
|
|
int tipc_nl_net_set(struct sk_buff *skb, struct genl_info *info)
|
|
|
|
{
|
2015-01-09 00:27:04 -07:00
|
|
|
struct net *net = genl_info_net(info);
|
|
|
|
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
2014-11-20 02:29:19 -07:00
|
|
|
struct nlattr *attrs[TIPC_NLA_NET_MAX + 1];
|
2015-01-09 00:27:04 -07:00
|
|
|
int err;
|
2014-11-20 02:29:19 -07:00
|
|
|
|
|
|
|
if (!info->attrs[TIPC_NLA_NET])
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
err = nla_parse_nested(attrs, TIPC_NLA_NET_MAX,
|
|
|
|
info->attrs[TIPC_NLA_NET],
|
|
|
|
tipc_nl_net_policy);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (attrs[TIPC_NLA_NET_ID]) {
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
/* Can't change net id once TIPC has joined a network */
|
|
|
|
if (tipc_own_addr)
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
val = nla_get_u32(attrs[TIPC_NLA_NET_ID]);
|
|
|
|
if (val < 1 || val > 9999)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-01-09 00:27:04 -07:00
|
|
|
tn->net_id = val;
|
2014-11-20 02:29:19 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (attrs[TIPC_NLA_NET_ADDR]) {
|
|
|
|
u32 addr;
|
|
|
|
|
|
|
|
/* Can't change net addr once TIPC has joined a network */
|
|
|
|
if (tipc_own_addr)
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
addr = nla_get_u32(attrs[TIPC_NLA_NET_ADDR]);
|
|
|
|
if (!tipc_addr_node_valid(addr))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
rtnl_lock();
|
2015-01-09 00:27:04 -07:00
|
|
|
tipc_net_start(net, addr);
|
2014-11-20 02:29:19 -07:00
|
|
|
rtnl_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|