mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-20 23:22:20 +07:00
Merge branch 'tipc-introduce-128-bit-auto-configurable-node-id'
Jon Maloy says: ==================== tipc: introduce 128-bit auto-configurable node id We introduce a 128-bit free-format node identity as an alternative to the legacy <Zone.Cluster.Node> structured 32-bit node address. We also make configuration of this identity optional; if a bearer is enabled without a pre-configured node id it will be set automatically based on the used interface's MAC or IP address. ==================== Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
commit
19415dbf30
@ -169,6 +169,8 @@ enum {
|
||||
TIPC_NLA_NET_UNSPEC,
|
||||
TIPC_NLA_NET_ID, /* u32 */
|
||||
TIPC_NLA_NET_ADDR, /* u32 */
|
||||
TIPC_NLA_NET_NODEID, /* u64 */
|
||||
TIPC_NLA_NET_NODEID_W1, /* u64 */
|
||||
|
||||
__TIPC_NLA_NET_MAX,
|
||||
TIPC_NLA_NET_MAX = __TIPC_NLA_NET_MAX - 1
|
||||
|
||||
148
net/tipc/addr.c
148
net/tipc/addr.c
@ -1,7 +1,7 @@
|
||||
/*
|
||||
* net/tipc/addr.c: TIPC address utility routines
|
||||
*
|
||||
* Copyright (c) 2000-2006, Ericsson AB
|
||||
* Copyright (c) 2000-2006, 2018, Ericsson AB
|
||||
* Copyright (c) 2004-2005, 2010-2011, Wind River Systems
|
||||
* All rights reserved.
|
||||
*
|
||||
@ -34,82 +34,90 @@
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include "addr.h"
|
||||
#include "core.h"
|
||||
|
||||
/**
|
||||
* in_own_cluster - test for cluster inclusion; <0.0.0> always matches
|
||||
*/
|
||||
int in_own_cluster(struct net *net, u32 addr)
|
||||
{
|
||||
return in_own_cluster_exact(net, addr) || !addr;
|
||||
}
|
||||
|
||||
int in_own_cluster_exact(struct net *net, u32 addr)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
|
||||
return !((addr ^ tn->own_addr) >> 12);
|
||||
}
|
||||
|
||||
/**
|
||||
* in_own_node - test for node inclusion; <0.0.0> always matches
|
||||
*/
|
||||
int in_own_node(struct net *net, u32 addr)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
|
||||
return (addr == tn->own_addr) || !addr;
|
||||
}
|
||||
|
||||
/**
|
||||
* tipc_addr_domain_valid - validates a network domain address
|
||||
*
|
||||
* Accepts <Z.C.N>, <Z.C.0>, <Z.0.0>, and <0.0.0>,
|
||||
* where Z, C, and N are non-zero.
|
||||
*
|
||||
* Returns 1 if domain address is valid, otherwise 0
|
||||
*/
|
||||
int tipc_addr_domain_valid(u32 addr)
|
||||
{
|
||||
u32 n = tipc_node(addr);
|
||||
u32 c = tipc_cluster(addr);
|
||||
u32 z = tipc_zone(addr);
|
||||
|
||||
if (n && (!z || !c))
|
||||
return 0;
|
||||
if (c && !z)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* tipc_addr_node_valid - validates a proposed network address for this node
|
||||
*
|
||||
* Accepts <Z.C.N>, where Z, C, and N are non-zero.
|
||||
*
|
||||
* Returns 1 if address can be used, otherwise 0
|
||||
*/
|
||||
int tipc_addr_node_valid(u32 addr)
|
||||
{
|
||||
return tipc_addr_domain_valid(addr) && tipc_node(addr);
|
||||
}
|
||||
|
||||
int tipc_in_scope(u32 domain, u32 addr)
|
||||
bool tipc_in_scope(bool legacy_format, u32 domain, u32 addr)
|
||||
{
|
||||
if (!domain || (domain == addr))
|
||||
return 1;
|
||||
return true;
|
||||
if (!legacy_format)
|
||||
return false;
|
||||
if (domain == tipc_cluster_mask(addr)) /* domain <Z.C.0> */
|
||||
return 1;
|
||||
if (domain == tipc_zone_mask(addr)) /* domain <Z.0.0> */
|
||||
return 1;
|
||||
return 0;
|
||||
return true;
|
||||
if (domain == (addr & TIPC_ZONE_CLUSTER_MASK)) /* domain <Z.C.0> */
|
||||
return true;
|
||||
if (domain == (addr & TIPC_ZONE_MASK)) /* domain <Z.0.0> */
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
char *tipc_addr_string_fill(char *string, u32 addr)
|
||||
void tipc_set_node_id(struct net *net, u8 *id)
|
||||
{
|
||||
snprintf(string, 16, "<%u.%u.%u>",
|
||||
tipc_zone(addr), tipc_cluster(addr), tipc_node(addr));
|
||||
return string;
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
u32 *tmp = (u32 *)id;
|
||||
|
||||
memcpy(tn->node_id, id, NODE_ID_LEN);
|
||||
tipc_nodeid2string(tn->node_id_string, id);
|
||||
tn->trial_addr = tmp[0] ^ tmp[1] ^ tmp[2] ^ tmp[3];
|
||||
pr_info("Own node identity %s, cluster identity %u\n",
|
||||
tipc_own_id_string(net), tn->net_id);
|
||||
}
|
||||
|
||||
void tipc_set_node_addr(struct net *net, u32 addr)
|
||||
{
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
u8 node_id[NODE_ID_LEN] = {0,};
|
||||
|
||||
tn->node_addr = addr;
|
||||
if (!tipc_own_id(net)) {
|
||||
sprintf(node_id, "%x", addr);
|
||||
tipc_set_node_id(net, node_id);
|
||||
}
|
||||
tn->trial_addr = addr;
|
||||
pr_info("32-bit node address hash set to %x\n", addr);
|
||||
}
|
||||
|
||||
char *tipc_nodeid2string(char *str, u8 *id)
|
||||
{
|
||||
int i;
|
||||
u8 c;
|
||||
|
||||
/* Already a string ? */
|
||||
for (i = 0; i < NODE_ID_LEN; i++) {
|
||||
c = id[i];
|
||||
if (c >= '0' && c <= '9')
|
||||
continue;
|
||||
if (c >= 'A' && c <= 'Z')
|
||||
continue;
|
||||
if (c >= 'a' && c <= 'z')
|
||||
continue;
|
||||
if (c == '.')
|
||||
continue;
|
||||
if (c == ':')
|
||||
continue;
|
||||
if (c == '_')
|
||||
continue;
|
||||
if (c == '-')
|
||||
continue;
|
||||
if (c == '@')
|
||||
continue;
|
||||
if (c != 0)
|
||||
break;
|
||||
}
|
||||
if (i == NODE_ID_LEN) {
|
||||
memcpy(str, id, NODE_ID_LEN);
|
||||
str[NODE_ID_LEN] = 0;
|
||||
return str;
|
||||
}
|
||||
|
||||
/* Translate to hex string */
|
||||
for (i = 0; i < NODE_ID_LEN; i++)
|
||||
sprintf(&str[2 * i], "%02x", id[i]);
|
||||
|
||||
/* Strip off trailing zeroes */
|
||||
for (i = NODE_ID_STR_LEN - 2; str[i] == '0'; i--)
|
||||
str[i] = 0;
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/*
|
||||
* net/tipc/addr.h: Include file for TIPC address utility routines
|
||||
*
|
||||
* Copyright (c) 2000-2006, Ericsson AB
|
||||
* Copyright (c) 2000-2006, 2018, Ericsson AB
|
||||
* Copyright (c) 2004-2005, Wind River Systems
|
||||
* All rights reserved.
|
||||
*
|
||||
@ -45,14 +45,21 @@
|
||||
|
||||
static inline u32 tipc_own_addr(struct net *net)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
|
||||
return tn->own_addr;
|
||||
return tipc_net(net)->node_addr;
|
||||
}
|
||||
|
||||
static inline u32 tipc_zone_mask(u32 addr)
|
||||
static inline u8 *tipc_own_id(struct net *net)
|
||||
{
|
||||
return addr & TIPC_ZONE_MASK;
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
|
||||
if (!strlen(tn->node_id_string))
|
||||
return NULL;
|
||||
return tn->node_id;
|
||||
}
|
||||
|
||||
static inline char *tipc_own_id_string(struct net *net)
|
||||
{
|
||||
return tipc_net(net)->node_id_string;
|
||||
}
|
||||
|
||||
static inline u32 tipc_cluster_mask(u32 addr)
|
||||
@ -70,15 +77,15 @@ static inline int tipc_scope2node(struct net *net, int sc)
|
||||
return sc != TIPC_NODE_SCOPE ? 0 : tipc_own_addr(net);
|
||||
}
|
||||
|
||||
u32 tipc_own_addr(struct net *net);
|
||||
int in_own_cluster(struct net *net, u32 addr);
|
||||
int in_own_cluster_exact(struct net *net, u32 addr);
|
||||
int in_own_node(struct net *net, u32 addr);
|
||||
u32 addr_domain(struct net *net, u32 sc);
|
||||
int tipc_addr_domain_valid(u32);
|
||||
int tipc_addr_node_valid(u32 addr);
|
||||
int tipc_in_scope(u32 domain, u32 addr);
|
||||
int tipc_addr_scope(u32 domain);
|
||||
char *tipc_addr_string_fill(char *string, u32 addr);
|
||||
static inline int in_own_node(struct net *net, u32 addr)
|
||||
{
|
||||
return addr == tipc_own_addr(net) || !addr;
|
||||
}
|
||||
|
||||
bool tipc_in_scope(bool legacy_format, u32 domain, u32 addr);
|
||||
void tipc_set_node_id(struct net *net, u8 *id);
|
||||
void tipc_set_node_addr(struct net *net, u32 addr);
|
||||
char *tipc_nodeid2string(char *str, u8 *id);
|
||||
u32 tipc_node_id2hash(u8 *id128);
|
||||
|
||||
#endif
|
||||
|
||||
@ -210,7 +210,7 @@ void tipc_bearer_add_dest(struct net *net, u32 bearer_id, u32 dest)
|
||||
rcu_read_lock();
|
||||
b = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
|
||||
if (b)
|
||||
tipc_disc_add_dest(b->link_req);
|
||||
tipc_disc_add_dest(b->disc);
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
@ -222,7 +222,7 @@ void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
|
||||
rcu_read_lock();
|
||||
b = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
|
||||
if (b)
|
||||
tipc_disc_remove_dest(b->link_req);
|
||||
tipc_disc_remove_dest(b->disc);
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
@ -230,88 +230,67 @@ void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
|
||||
* tipc_enable_bearer - enable bearer with the given name
|
||||
*/
|
||||
static int tipc_enable_bearer(struct net *net, const char *name,
|
||||
u32 disc_domain, u32 priority,
|
||||
u32 disc_domain, u32 prio,
|
||||
struct nlattr *attr[])
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
struct tipc_bearer_names b_names;
|
||||
int with_this_prio = 1;
|
||||
struct tipc_bearer *b;
|
||||
struct tipc_media *m;
|
||||
struct tipc_bearer_names b_names;
|
||||
struct sk_buff *skb;
|
||||
char addr_string[16];
|
||||
u32 bearer_id;
|
||||
u32 with_this_prio;
|
||||
u32 i;
|
||||
int bearer_id = 0;
|
||||
int res = -EINVAL;
|
||||
char *errstr = "";
|
||||
|
||||
if (!tn->own_addr) {
|
||||
pr_warn("Bearer <%s> rejected, not supported in standalone mode\n",
|
||||
name);
|
||||
return -ENOPROTOOPT;
|
||||
}
|
||||
if (!bearer_name_validate(name, &b_names)) {
|
||||
pr_warn("Bearer <%s> rejected, illegal name\n", name);
|
||||
return -EINVAL;
|
||||
errstr = "illegal name";
|
||||
goto rejected;
|
||||
}
|
||||
if (tipc_addr_domain_valid(disc_domain) &&
|
||||
(disc_domain != tn->own_addr)) {
|
||||
if (tipc_in_scope(disc_domain, tn->own_addr)) {
|
||||
disc_domain = tn->own_addr & TIPC_ZONE_CLUSTER_MASK;
|
||||
res = 0; /* accept any node in own cluster */
|
||||
} else if (in_own_cluster_exact(net, disc_domain))
|
||||
res = 0; /* accept specified node in own cluster */
|
||||
}
|
||||
if (res) {
|
||||
pr_warn("Bearer <%s> rejected, illegal discovery domain\n",
|
||||
name);
|
||||
return -EINVAL;
|
||||
}
|
||||
if ((priority > TIPC_MAX_LINK_PRI) &&
|
||||
(priority != TIPC_MEDIA_LINK_PRI)) {
|
||||
pr_warn("Bearer <%s> rejected, illegal priority\n", name);
|
||||
return -EINVAL;
|
||||
|
||||
if (prio > TIPC_MAX_LINK_PRI && prio != TIPC_MEDIA_LINK_PRI) {
|
||||
errstr = "illegal priority";
|
||||
goto rejected;
|
||||
}
|
||||
|
||||
m = tipc_media_find(b_names.media_name);
|
||||
if (!m) {
|
||||
pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
|
||||
name, b_names.media_name);
|
||||
return -EINVAL;
|
||||
errstr = "media not registered";
|
||||
goto rejected;
|
||||
}
|
||||
|
||||
if (priority == TIPC_MEDIA_LINK_PRI)
|
||||
priority = m->priority;
|
||||
if (prio == TIPC_MEDIA_LINK_PRI)
|
||||
prio = m->priority;
|
||||
|
||||
restart:
|
||||
bearer_id = MAX_BEARERS;
|
||||
with_this_prio = 1;
|
||||
for (i = MAX_BEARERS; i-- != 0; ) {
|
||||
b = rtnl_dereference(tn->bearer_list[i]);
|
||||
if (!b) {
|
||||
bearer_id = i;
|
||||
continue;
|
||||
}
|
||||
/* Check new bearer vs existing ones and find free bearer id if any */
|
||||
while (bearer_id < MAX_BEARERS) {
|
||||
b = rtnl_dereference(tn->bearer_list[bearer_id]);
|
||||
if (!b)
|
||||
break;
|
||||
if (!strcmp(name, b->name)) {
|
||||
pr_warn("Bearer <%s> rejected, already enabled\n",
|
||||
name);
|
||||
return -EINVAL;
|
||||
errstr = "already enabled";
|
||||
goto rejected;
|
||||
}
|
||||
if ((b->priority == priority) &&
|
||||
(++with_this_prio > 2)) {
|
||||
if (priority-- == 0) {
|
||||
pr_warn("Bearer <%s> rejected, duplicate priority\n",
|
||||
name);
|
||||
return -EINVAL;
|
||||
}
|
||||
pr_warn("Bearer <%s> priority adjustment required %u->%u\n",
|
||||
name, priority + 1, priority);
|
||||
goto restart;
|
||||
bearer_id++;
|
||||
if (b->priority != prio)
|
||||
continue;
|
||||
if (++with_this_prio <= 2)
|
||||
continue;
|
||||
pr_warn("Bearer <%s>: already 2 bearers with priority %u\n",
|
||||
name, prio);
|
||||
if (prio == TIPC_MIN_LINK_PRI) {
|
||||
errstr = "cannot adjust to lower";
|
||||
goto rejected;
|
||||
}
|
||||
pr_warn("Bearer <%s>: trying with adjusted priority\n", name);
|
||||
prio--;
|
||||
bearer_id = 0;
|
||||
with_this_prio = 1;
|
||||
}
|
||||
|
||||
if (bearer_id >= MAX_BEARERS) {
|
||||
pr_warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
|
||||
name, MAX_BEARERS);
|
||||
return -EINVAL;
|
||||
errstr = "max 3 bearers permitted";
|
||||
goto rejected;
|
||||
}
|
||||
|
||||
b = kzalloc(sizeof(*b), GFP_ATOMIC);
|
||||
@ -322,10 +301,9 @@ static int tipc_enable_bearer(struct net *net, const char *name,
|
||||
b->media = m;
|
||||
res = m->enable_media(net, b, attr);
|
||||
if (res) {
|
||||
pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
|
||||
name, -res);
|
||||
kfree(b);
|
||||
return -EINVAL;
|
||||
errstr = "failed to enable media";
|
||||
goto rejected;
|
||||
}
|
||||
|
||||
b->identity = bearer_id;
|
||||
@ -333,15 +311,15 @@ static int tipc_enable_bearer(struct net *net, const char *name,
|
||||
b->window = m->window;
|
||||
b->domain = disc_domain;
|
||||
b->net_plane = bearer_id + 'A';
|
||||
b->priority = priority;
|
||||
b->priority = prio;
|
||||
test_and_set_bit_lock(0, &b->up);
|
||||
|
||||
res = tipc_disc_create(net, b, &b->bcast_addr, &skb);
|
||||
if (res) {
|
||||
bearer_disable(net, b);
|
||||
pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
|
||||
name);
|
||||
return -EINVAL;
|
||||
kfree(b);
|
||||
errstr = "failed to create discoverer";
|
||||
goto rejected;
|
||||
}
|
||||
|
||||
rcu_assign_pointer(tn->bearer_list[bearer_id], b);
|
||||
@ -353,9 +331,11 @@ static int tipc_enable_bearer(struct net *net, const char *name,
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
|
||||
name,
|
||||
tipc_addr_string_fill(addr_string, disc_domain), priority);
|
||||
pr_info("Enabled bearer <%s>, priority %u\n", name, prio);
|
||||
|
||||
return res;
|
||||
rejected:
|
||||
pr_warn("Enabling of bearer <%s> rejected, %s\n", name, errstr);
|
||||
return res;
|
||||
}
|
||||
|
||||
@ -385,8 +365,8 @@ static void bearer_disable(struct net *net, struct tipc_bearer *b)
|
||||
tipc_node_delete_links(net, bearer_id);
|
||||
b->media->disable_media(b);
|
||||
RCU_INIT_POINTER(b->media_ptr, NULL);
|
||||
if (b->link_req)
|
||||
tipc_disc_delete(b->link_req);
|
||||
if (b->disc)
|
||||
tipc_disc_delete(b->disc);
|
||||
RCU_INIT_POINTER(tn->bearer_list[bearer_id], NULL);
|
||||
kfree_rcu(b, rcu);
|
||||
tipc_mon_delete(net, bearer_id);
|
||||
@ -395,11 +375,13 @@ static void bearer_disable(struct net *net, struct tipc_bearer *b)
|
||||
int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
|
||||
struct nlattr *attr[])
|
||||
{
|
||||
char *dev_name = strchr((const char *)b->name, ':') + 1;
|
||||
int hwaddr_len = b->media->hwaddr_len;
|
||||
u8 node_id[NODE_ID_LEN] = {0,};
|
||||
struct net_device *dev;
|
||||
char *driver_name = strchr((const char *)b->name, ':') + 1;
|
||||
|
||||
/* Find device with specified name */
|
||||
dev = dev_get_by_name(net, driver_name);
|
||||
dev = dev_get_by_name(net, dev_name);
|
||||
if (!dev)
|
||||
return -ENODEV;
|
||||
if (tipc_mtu_bad(dev, 0)) {
|
||||
@ -407,6 +389,16 @@ int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Autoconfigure own node identity if needed */
|
||||
if (!tipc_own_id(net) && hwaddr_len <= NODE_ID_LEN) {
|
||||
memcpy(node_id, dev->dev_addr, hwaddr_len);
|
||||
tipc_net_init(net, node_id, 0);
|
||||
}
|
||||
if (!tipc_own_id(net)) {
|
||||
pr_warn("Failed to obtain node identity\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Associate TIPC bearer with L2 bearer */
|
||||
rcu_assign_pointer(b->media_ptr, dev);
|
||||
b->pt.dev = dev;
|
||||
@ -414,7 +406,7 @@ int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
|
||||
b->pt.func = tipc_l2_rcv_msg;
|
||||
dev_add_pack(&b->pt);
|
||||
memset(&b->bcast_addr, 0, sizeof(b->bcast_addr));
|
||||
memcpy(b->bcast_addr.value, dev->broadcast, b->media->hwaddr_len);
|
||||
memcpy(b->bcast_addr.value, dev->broadcast, hwaddr_len);
|
||||
b->bcast_addr.media_id = b->media->type_id;
|
||||
b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
|
||||
b->mtu = dev->mtu;
|
||||
@ -861,12 +853,10 @@ int __tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
|
||||
char *bearer;
|
||||
struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
|
||||
struct net *net = sock_net(skb->sk);
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
u32 domain;
|
||||
u32 domain = 0;
|
||||
u32 prio;
|
||||
|
||||
prio = TIPC_MEDIA_LINK_PRI;
|
||||
domain = tn->own_addr & TIPC_ZONE_CLUSTER_MASK;
|
||||
|
||||
if (!info->attrs[TIPC_NLA_BEARER])
|
||||
return -EINVAL;
|
||||
|
||||
@ -159,7 +159,7 @@ struct tipc_bearer {
|
||||
u32 tolerance;
|
||||
u32 domain;
|
||||
u32 identity;
|
||||
struct tipc_link_req *link_req;
|
||||
struct tipc_discoverer *disc;
|
||||
char net_plane;
|
||||
unsigned long up;
|
||||
};
|
||||
|
||||
@ -56,7 +56,11 @@ static int __net_init tipc_init_net(struct net *net)
|
||||
int err;
|
||||
|
||||
tn->net_id = 4711;
|
||||
tn->own_addr = 0;
|
||||
tn->node_addr = 0;
|
||||
tn->trial_addr = 0;
|
||||
tn->addr_trial_end = 0;
|
||||
memset(tn->node_id, 0, sizeof(tn->node_id));
|
||||
memset(tn->node_id_string, 0, sizeof(tn->node_id_string));
|
||||
tn->mon_threshold = TIPC_DEF_MON_THRESHOLD;
|
||||
get_random_bytes(&tn->random, sizeof(int));
|
||||
INIT_LIST_HEAD(&tn->node_list);
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/*
|
||||
* net/tipc/core.h: Include file for TIPC global declarations
|
||||
*
|
||||
* Copyright (c) 2005-2006, 2013 Ericsson AB
|
||||
* Copyright (c) 2005-2006, 2013-2018 Ericsson AB
|
||||
* Copyright (c) 2005-2007, 2010-2013, Wind River Systems
|
||||
* All rights reserved.
|
||||
*
|
||||
@ -72,15 +72,22 @@ struct tipc_monitor;
|
||||
#define NODE_HTABLE_SIZE 512
|
||||
#define MAX_BEARERS 3
|
||||
#define TIPC_DEF_MON_THRESHOLD 32
|
||||
#define NODE_ID_LEN 16
|
||||
#define NODE_ID_STR_LEN (NODE_ID_LEN * 2 + 1)
|
||||
|
||||
extern unsigned int tipc_net_id __read_mostly;
|
||||
extern int sysctl_tipc_rmem[3] __read_mostly;
|
||||
extern int sysctl_tipc_named_timeout __read_mostly;
|
||||
|
||||
struct tipc_net {
|
||||
u32 own_addr;
|
||||
u8 node_id[NODE_ID_LEN];
|
||||
u32 node_addr;
|
||||
u32 trial_addr;
|
||||
unsigned long addr_trial_end;
|
||||
char node_id_string[NODE_ID_STR_LEN];
|
||||
int net_id;
|
||||
int random;
|
||||
bool legacy_addr_format;
|
||||
|
||||
/* Node table and node list */
|
||||
spinlock_t node_list_lock;
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/*
|
||||
* net/tipc/discover.c
|
||||
*
|
||||
* Copyright (c) 2003-2006, 2014-2015, Ericsson AB
|
||||
* Copyright (c) 2003-2006, 2014-2018, Ericsson AB
|
||||
* Copyright (c) 2005-2006, 2010-2011, Wind River Systems
|
||||
* All rights reserved.
|
||||
*
|
||||
@ -39,34 +39,34 @@
|
||||
#include "discover.h"
|
||||
|
||||
/* min delay during bearer start up */
|
||||
#define TIPC_LINK_REQ_INIT msecs_to_jiffies(125)
|
||||
#define TIPC_DISC_INIT msecs_to_jiffies(125)
|
||||
/* max delay if bearer has no links */
|
||||
#define TIPC_LINK_REQ_FAST msecs_to_jiffies(1000)
|
||||
#define TIPC_DISC_FAST msecs_to_jiffies(1000)
|
||||
/* max delay if bearer has links */
|
||||
#define TIPC_LINK_REQ_SLOW msecs_to_jiffies(60000)
|
||||
#define TIPC_DISC_SLOW msecs_to_jiffies(60000)
|
||||
/* indicates no timer in use */
|
||||
#define TIPC_LINK_REQ_INACTIVE 0xffffffff
|
||||
#define TIPC_DISC_INACTIVE 0xffffffff
|
||||
|
||||
/**
|
||||
* struct tipc_link_req - information about an ongoing link setup request
|
||||
* struct tipc_discoverer - information about an ongoing link setup request
|
||||
* @bearer_id: identity of bearer issuing requests
|
||||
* @net: network namespace instance
|
||||
* @dest: destination address for request messages
|
||||
* @domain: network domain to which links can be established
|
||||
* @num_nodes: number of nodes currently discovered (i.e. with an active link)
|
||||
* @lock: spinlock for controlling access to requests
|
||||
* @buf: request message to be (repeatedly) sent
|
||||
* @skb: request message to be (repeatedly) sent
|
||||
* @timer: timer governing period between requests
|
||||
* @timer_intv: current interval between requests (in ms)
|
||||
*/
|
||||
struct tipc_link_req {
|
||||
struct tipc_discoverer {
|
||||
u32 bearer_id;
|
||||
struct tipc_media_addr dest;
|
||||
struct net *net;
|
||||
u32 domain;
|
||||
int num_nodes;
|
||||
spinlock_t lock;
|
||||
struct sk_buff *buf;
|
||||
struct sk_buff *skb;
|
||||
struct timer_list timer;
|
||||
unsigned long timer_intv;
|
||||
};
|
||||
@ -77,22 +77,42 @@ struct tipc_link_req {
|
||||
* @type: message type (request or response)
|
||||
* @b: ptr to bearer issuing message
|
||||
*/
|
||||
static void tipc_disc_init_msg(struct net *net, struct sk_buff *buf, u32 type,
|
||||
static void tipc_disc_init_msg(struct net *net, struct sk_buff *skb,
|
||||
u32 mtyp, struct tipc_bearer *b)
|
||||
{
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
u32 dest_domain = b->domain;
|
||||
struct tipc_msg *hdr;
|
||||
|
||||
hdr = buf_msg(skb);
|
||||
tipc_msg_init(tn->trial_addr, hdr, LINK_CONFIG, mtyp,
|
||||
MAX_H_SIZE, dest_domain);
|
||||
msg_set_size(hdr, MAX_H_SIZE + NODE_ID_LEN);
|
||||
msg_set_non_seq(hdr, 1);
|
||||
msg_set_node_sig(hdr, tn->random);
|
||||
msg_set_node_capabilities(hdr, TIPC_NODE_CAPABILITIES);
|
||||
msg_set_dest_domain(hdr, dest_domain);
|
||||
msg_set_bc_netid(hdr, tn->net_id);
|
||||
b->media->addr2msg(msg_media_addr(hdr), &b->addr);
|
||||
msg_set_node_id(hdr, tipc_own_id(net));
|
||||
}
|
||||
|
||||
static void tipc_disc_msg_xmit(struct net *net, u32 mtyp, u32 dst,
|
||||
u32 src, u32 sugg_addr,
|
||||
struct tipc_media_addr *maddr,
|
||||
struct tipc_bearer *b)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
struct tipc_msg *msg;
|
||||
u32 dest_domain = b->domain;
|
||||
struct tipc_msg *hdr;
|
||||
struct sk_buff *skb;
|
||||
|
||||
msg = buf_msg(buf);
|
||||
tipc_msg_init(tn->own_addr, msg, LINK_CONFIG, type,
|
||||
MAX_H_SIZE, dest_domain);
|
||||
msg_set_non_seq(msg, 1);
|
||||
msg_set_node_sig(msg, tn->random);
|
||||
msg_set_node_capabilities(msg, TIPC_NODE_CAPABILITIES);
|
||||
msg_set_dest_domain(msg, dest_domain);
|
||||
msg_set_bc_netid(msg, tn->net_id);
|
||||
b->media->addr2msg(msg_media_addr(msg), &b->addr);
|
||||
skb = tipc_buf_acquire(MAX_H_SIZE + NODE_ID_LEN, GFP_ATOMIC);
|
||||
if (!skb)
|
||||
return;
|
||||
hdr = buf_msg(skb);
|
||||
tipc_disc_init_msg(net, skb, mtyp, b);
|
||||
msg_set_sugg_node_addr(hdr, sugg_addr);
|
||||
msg_set_dest_domain(hdr, dst);
|
||||
tipc_bearer_xmit_skb(net, b->identity, skb, maddr);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -104,161 +124,207 @@ static void tipc_disc_init_msg(struct net *net, struct sk_buff *buf, u32 type,
|
||||
static void disc_dupl_alert(struct tipc_bearer *b, u32 node_addr,
|
||||
struct tipc_media_addr *media_addr)
|
||||
{
|
||||
char node_addr_str[16];
|
||||
char media_addr_str[64];
|
||||
|
||||
tipc_addr_string_fill(node_addr_str, node_addr);
|
||||
tipc_media_addr_printf(media_addr_str, sizeof(media_addr_str),
|
||||
media_addr);
|
||||
pr_warn("Duplicate %s using %s seen on <%s>\n", node_addr_str,
|
||||
pr_warn("Duplicate %x using %s seen on <%s>\n", node_addr,
|
||||
media_addr_str, b->name);
|
||||
}
|
||||
|
||||
/* tipc_disc_addr_trial(): - handle an address uniqueness trial from peer
|
||||
*/
|
||||
bool tipc_disc_addr_trial_msg(struct tipc_discoverer *d,
|
||||
struct tipc_media_addr *maddr,
|
||||
struct tipc_bearer *b,
|
||||
u32 dst, u32 src,
|
||||
u32 sugg_addr,
|
||||
u8 *peer_id,
|
||||
int mtyp)
|
||||
{
|
||||
struct net *net = d->net;
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
bool trial = time_before(jiffies, tn->addr_trial_end);
|
||||
u32 self = tipc_own_addr(net);
|
||||
|
||||
if (mtyp == DSC_TRIAL_FAIL_MSG) {
|
||||
if (!trial)
|
||||
return true;
|
||||
|
||||
/* Ignore if somebody else already gave new suggestion */
|
||||
if (dst != tn->trial_addr)
|
||||
return true;
|
||||
|
||||
/* Otherwise update trial address and restart trial period */
|
||||
tn->trial_addr = sugg_addr;
|
||||
msg_set_prevnode(buf_msg(d->skb), sugg_addr);
|
||||
tn->addr_trial_end = jiffies + msecs_to_jiffies(1000);
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Apply trial address if we just left trial period */
|
||||
if (!trial && !self) {
|
||||
tipc_net_finalize(net, tn->trial_addr);
|
||||
msg_set_type(buf_msg(d->skb), DSC_REQ_MSG);
|
||||
}
|
||||
|
||||
if (mtyp != DSC_TRIAL_MSG)
|
||||
return false;
|
||||
|
||||
sugg_addr = tipc_node_try_addr(net, peer_id, src);
|
||||
if (sugg_addr)
|
||||
tipc_disc_msg_xmit(net, DSC_TRIAL_FAIL_MSG, src,
|
||||
self, sugg_addr, maddr, b);
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* tipc_disc_rcv - handle incoming discovery message (request or response)
|
||||
* @net: the applicable net namespace
|
||||
* @buf: buffer containing message
|
||||
* @bearer: bearer that message arrived on
|
||||
* @net: applicable net namespace
|
||||
* @skb: buffer containing message
|
||||
* @b: bearer that message arrived on
|
||||
*/
|
||||
void tipc_disc_rcv(struct net *net, struct sk_buff *skb,
|
||||
struct tipc_bearer *bearer)
|
||||
struct tipc_bearer *b)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
struct tipc_media_addr maddr;
|
||||
struct sk_buff *rskb;
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
struct tipc_msg *hdr = buf_msg(skb);
|
||||
u32 ddom = msg_dest_domain(hdr);
|
||||
u32 onode = msg_prevnode(hdr);
|
||||
u32 net_id = msg_bc_netid(hdr);
|
||||
u32 mtyp = msg_type(hdr);
|
||||
u32 signature = msg_node_sig(hdr);
|
||||
u16 caps = msg_node_capabilities(hdr);
|
||||
bool respond = false;
|
||||
bool legacy = tn->legacy_addr_format;
|
||||
u32 sugg = msg_sugg_node_addr(hdr);
|
||||
u32 signature = msg_node_sig(hdr);
|
||||
u8 peer_id[NODE_ID_LEN] = {0,};
|
||||
u32 dst = msg_dest_domain(hdr);
|
||||
u32 net_id = msg_bc_netid(hdr);
|
||||
struct tipc_media_addr maddr;
|
||||
u32 src = msg_prevnode(hdr);
|
||||
u32 mtyp = msg_type(hdr);
|
||||
bool dupl_addr = false;
|
||||
bool respond = false;
|
||||
u32 self;
|
||||
int err;
|
||||
|
||||
err = bearer->media->msg2addr(bearer, &maddr, msg_media_addr(hdr));
|
||||
kfree_skb(skb);
|
||||
if (err)
|
||||
return;
|
||||
skb_linearize(skb);
|
||||
hdr = buf_msg(skb);
|
||||
|
||||
/* Ensure message from node is valid and communication is permitted */
|
||||
if (caps & TIPC_NODE_ID128)
|
||||
memcpy(peer_id, msg_node_id(hdr), NODE_ID_LEN);
|
||||
else
|
||||
sprintf(peer_id, "%x", src);
|
||||
|
||||
err = b->media->msg2addr(b, &maddr, msg_media_addr(hdr));
|
||||
kfree_skb(skb);
|
||||
if (err || maddr.broadcast) {
|
||||
pr_warn_ratelimited("Rcv corrupt discovery message\n");
|
||||
return;
|
||||
}
|
||||
/* Ignore discovery messages from own node */
|
||||
if (!memcmp(&maddr, &b->addr, sizeof(maddr)))
|
||||
return;
|
||||
if (net_id != tn->net_id)
|
||||
return;
|
||||
if (maddr.broadcast)
|
||||
return;
|
||||
if (!tipc_addr_domain_valid(ddom))
|
||||
return;
|
||||
if (!tipc_addr_node_valid(onode))
|
||||
if (tipc_disc_addr_trial_msg(b->disc, &maddr, b, dst,
|
||||
src, sugg, peer_id, mtyp))
|
||||
return;
|
||||
self = tipc_own_addr(net);
|
||||
|
||||
if (in_own_node(net, onode)) {
|
||||
if (memcmp(&maddr, &bearer->addr, sizeof(maddr)))
|
||||
disc_dupl_alert(bearer, tn->own_addr, &maddr);
|
||||
/* Message from somebody using this node's address */
|
||||
if (in_own_node(net, src)) {
|
||||
disc_dupl_alert(b, self, &maddr);
|
||||
return;
|
||||
}
|
||||
if (!tipc_in_scope(ddom, tn->own_addr))
|
||||
if (!tipc_in_scope(legacy, dst, self))
|
||||
return;
|
||||
if (!tipc_in_scope(bearer->domain, onode))
|
||||
if (!tipc_in_scope(legacy, b->domain, src))
|
||||
return;
|
||||
|
||||
tipc_node_check_dest(net, onode, bearer, caps, signature,
|
||||
tipc_node_check_dest(net, src, peer_id, b, caps, signature,
|
||||
&maddr, &respond, &dupl_addr);
|
||||
if (dupl_addr)
|
||||
disc_dupl_alert(bearer, onode, &maddr);
|
||||
disc_dupl_alert(b, src, &maddr);
|
||||
if (!respond)
|
||||
return;
|
||||
if (mtyp != DSC_REQ_MSG)
|
||||
return;
|
||||
tipc_disc_msg_xmit(net, DSC_RESP_MSG, src, self, 0, &maddr, b);
|
||||
}
|
||||
|
||||
/* Send response, if necessary */
|
||||
if (respond && (mtyp == DSC_REQ_MSG)) {
|
||||
rskb = tipc_buf_acquire(MAX_H_SIZE, GFP_ATOMIC);
|
||||
if (!rskb)
|
||||
return;
|
||||
tipc_disc_init_msg(net, rskb, DSC_RESP_MSG, bearer);
|
||||
tipc_bearer_xmit_skb(net, bearer->identity, rskb, &maddr);
|
||||
/* tipc_disc_add_dest - increment set of discovered nodes
|
||||
*/
|
||||
void tipc_disc_add_dest(struct tipc_discoverer *d)
|
||||
{
|
||||
spin_lock_bh(&d->lock);
|
||||
d->num_nodes++;
|
||||
spin_unlock_bh(&d->lock);
|
||||
}
|
||||
|
||||
/* tipc_disc_remove_dest - decrement set of discovered nodes
|
||||
*/
|
||||
void tipc_disc_remove_dest(struct tipc_discoverer *d)
|
||||
{
|
||||
int intv, num;
|
||||
|
||||
spin_lock_bh(&d->lock);
|
||||
d->num_nodes--;
|
||||
num = d->num_nodes;
|
||||
intv = d->timer_intv;
|
||||
if (!num && (intv == TIPC_DISC_INACTIVE || intv > TIPC_DISC_FAST)) {
|
||||
d->timer_intv = TIPC_DISC_INIT;
|
||||
mod_timer(&d->timer, jiffies + d->timer_intv);
|
||||
}
|
||||
spin_unlock_bh(&d->lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* disc_update - update frequency of periodic link setup requests
|
||||
* @req: ptr to link request structure
|
||||
*
|
||||
* Reinitiates discovery process if discovery object has no associated nodes
|
||||
* and is either not currently searching or is searching at a slow rate
|
||||
*/
|
||||
static void disc_update(struct tipc_link_req *req)
|
||||
{
|
||||
if (!req->num_nodes) {
|
||||
if ((req->timer_intv == TIPC_LINK_REQ_INACTIVE) ||
|
||||
(req->timer_intv > TIPC_LINK_REQ_FAST)) {
|
||||
req->timer_intv = TIPC_LINK_REQ_INIT;
|
||||
mod_timer(&req->timer, jiffies + req->timer_intv);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* tipc_disc_add_dest - increment set of discovered nodes
|
||||
* @req: ptr to link request structure
|
||||
*/
|
||||
void tipc_disc_add_dest(struct tipc_link_req *req)
|
||||
{
|
||||
spin_lock_bh(&req->lock);
|
||||
req->num_nodes++;
|
||||
spin_unlock_bh(&req->lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* tipc_disc_remove_dest - decrement set of discovered nodes
|
||||
* @req: ptr to link request structure
|
||||
*/
|
||||
void tipc_disc_remove_dest(struct tipc_link_req *req)
|
||||
{
|
||||
spin_lock_bh(&req->lock);
|
||||
req->num_nodes--;
|
||||
disc_update(req);
|
||||
spin_unlock_bh(&req->lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* disc_timeout - send a periodic link setup request
|
||||
* @data: ptr to link request structure
|
||||
*
|
||||
/* tipc_disc_timeout - send a periodic link setup request
|
||||
* Called whenever a link setup request timer associated with a bearer expires.
|
||||
* - Keep doubling time between sent request until limit is reached;
|
||||
* - Hold at fast polling rate if we don't have any associated nodes
|
||||
* - Otherwise hold at slow polling rate
|
||||
*/
|
||||
static void disc_timeout(struct timer_list *t)
|
||||
static void tipc_disc_timeout(struct timer_list *t)
|
||||
{
|
||||
struct tipc_link_req *req = from_timer(req, t, timer);
|
||||
struct sk_buff *skb;
|
||||
int max_delay;
|
||||
struct tipc_discoverer *d = from_timer(d, t, timer);
|
||||
struct tipc_net *tn = tipc_net(d->net);
|
||||
u32 self = tipc_own_addr(d->net);
|
||||
struct tipc_media_addr maddr;
|
||||
struct sk_buff *skb = NULL;
|
||||
struct net *net = d->net;
|
||||
u32 bearer_id;
|
||||
|
||||
spin_lock_bh(&req->lock);
|
||||
spin_lock_bh(&d->lock);
|
||||
|
||||
/* Stop searching if only desired node has been found */
|
||||
if (tipc_node(req->domain) && req->num_nodes) {
|
||||
req->timer_intv = TIPC_LINK_REQ_INACTIVE;
|
||||
if (tipc_node(d->domain) && d->num_nodes) {
|
||||
d->timer_intv = TIPC_DISC_INACTIVE;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/*
|
||||
* Send discovery message, then update discovery timer
|
||||
*
|
||||
* Keep doubling time between requests until limit is reached;
|
||||
* hold at fast polling rate if don't have any associated nodes,
|
||||
* otherwise hold at slow polling rate
|
||||
*/
|
||||
skb = skb_clone(req->buf, GFP_ATOMIC);
|
||||
if (skb)
|
||||
tipc_bearer_xmit_skb(req->net, req->bearer_id, skb, &req->dest);
|
||||
req->timer_intv *= 2;
|
||||
if (req->num_nodes)
|
||||
max_delay = TIPC_LINK_REQ_SLOW;
|
||||
else
|
||||
max_delay = TIPC_LINK_REQ_FAST;
|
||||
if (req->timer_intv > max_delay)
|
||||
req->timer_intv = max_delay;
|
||||
/* Did we just leave the address trial period ? */
|
||||
if (!self && !time_before(jiffies, tn->addr_trial_end)) {
|
||||
self = tn->trial_addr;
|
||||
tipc_net_finalize(net, self);
|
||||
msg_set_prevnode(buf_msg(d->skb), self);
|
||||
msg_set_type(buf_msg(d->skb), DSC_REQ_MSG);
|
||||
}
|
||||
|
||||
mod_timer(&req->timer, jiffies + req->timer_intv);
|
||||
/* Adjust timeout interval according to discovery phase */
|
||||
if (time_before(jiffies, tn->addr_trial_end)) {
|
||||
d->timer_intv = TIPC_DISC_INIT;
|
||||
} else {
|
||||
d->timer_intv *= 2;
|
||||
if (d->num_nodes && d->timer_intv > TIPC_DISC_SLOW)
|
||||
d->timer_intv = TIPC_DISC_SLOW;
|
||||
else if (!d->num_nodes && d->timer_intv > TIPC_DISC_FAST)
|
||||
d->timer_intv = TIPC_DISC_FAST;
|
||||
}
|
||||
|
||||
mod_timer(&d->timer, jiffies + d->timer_intv);
|
||||
memcpy(&maddr, &d->dest, sizeof(maddr));
|
||||
skb = skb_clone(d->skb, GFP_ATOMIC);
|
||||
bearer_id = d->bearer_id;
|
||||
exit:
|
||||
spin_unlock_bh(&req->lock);
|
||||
spin_unlock_bh(&d->lock);
|
||||
if (skb)
|
||||
tipc_bearer_xmit_skb(net, bearer_id, skb, &maddr);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -273,41 +339,47 @@ static void disc_timeout(struct timer_list *t)
|
||||
int tipc_disc_create(struct net *net, struct tipc_bearer *b,
|
||||
struct tipc_media_addr *dest, struct sk_buff **skb)
|
||||
{
|
||||
struct tipc_link_req *req;
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
struct tipc_discoverer *d;
|
||||
|
||||
req = kmalloc(sizeof(*req), GFP_ATOMIC);
|
||||
if (!req)
|
||||
d = kmalloc(sizeof(*d), GFP_ATOMIC);
|
||||
if (!d)
|
||||
return -ENOMEM;
|
||||
req->buf = tipc_buf_acquire(MAX_H_SIZE, GFP_ATOMIC);
|
||||
if (!req->buf) {
|
||||
kfree(req);
|
||||
d->skb = tipc_buf_acquire(MAX_H_SIZE + NODE_ID_LEN, GFP_ATOMIC);
|
||||
if (!d->skb) {
|
||||
kfree(d);
|
||||
return -ENOMEM;
|
||||
}
|
||||
tipc_disc_init_msg(net, d->skb, DSC_REQ_MSG, b);
|
||||
|
||||
tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b);
|
||||
memcpy(&req->dest, dest, sizeof(*dest));
|
||||
req->net = net;
|
||||
req->bearer_id = b->identity;
|
||||
req->domain = b->domain;
|
||||
req->num_nodes = 0;
|
||||
req->timer_intv = TIPC_LINK_REQ_INIT;
|
||||
spin_lock_init(&req->lock);
|
||||
timer_setup(&req->timer, disc_timeout, 0);
|
||||
mod_timer(&req->timer, jiffies + req->timer_intv);
|
||||
b->link_req = req;
|
||||
*skb = skb_clone(req->buf, GFP_ATOMIC);
|
||||
/* Do we need an address trial period first ? */
|
||||
if (!tipc_own_addr(net)) {
|
||||
tn->addr_trial_end = jiffies + msecs_to_jiffies(1000);
|
||||
msg_set_type(buf_msg(d->skb), DSC_TRIAL_MSG);
|
||||
}
|
||||
memcpy(&d->dest, dest, sizeof(*dest));
|
||||
d->net = net;
|
||||
d->bearer_id = b->identity;
|
||||
d->domain = b->domain;
|
||||
d->num_nodes = 0;
|
||||
d->timer_intv = TIPC_DISC_INIT;
|
||||
spin_lock_init(&d->lock);
|
||||
timer_setup(&d->timer, tipc_disc_timeout, 0);
|
||||
mod_timer(&d->timer, jiffies + d->timer_intv);
|
||||
b->disc = d;
|
||||
*skb = skb_clone(d->skb, GFP_ATOMIC);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* tipc_disc_delete - destroy object sending periodic link setup requests
|
||||
* @req: ptr to link request structure
|
||||
* @d: ptr to link duest structure
|
||||
*/
|
||||
void tipc_disc_delete(struct tipc_link_req *req)
|
||||
void tipc_disc_delete(struct tipc_discoverer *d)
|
||||
{
|
||||
del_timer_sync(&req->timer);
|
||||
kfree_skb(req->buf);
|
||||
kfree(req);
|
||||
del_timer_sync(&d->timer);
|
||||
kfree_skb(d->skb);
|
||||
kfree(d);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -318,19 +390,21 @@ void tipc_disc_delete(struct tipc_link_req *req)
|
||||
*/
|
||||
void tipc_disc_reset(struct net *net, struct tipc_bearer *b)
|
||||
{
|
||||
struct tipc_link_req *req = b->link_req;
|
||||
struct tipc_discoverer *d = b->disc;
|
||||
struct tipc_media_addr maddr;
|
||||
struct sk_buff *skb;
|
||||
|
||||
spin_lock_bh(&req->lock);
|
||||
tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b);
|
||||
req->net = net;
|
||||
req->bearer_id = b->identity;
|
||||
req->domain = b->domain;
|
||||
req->num_nodes = 0;
|
||||
req->timer_intv = TIPC_LINK_REQ_INIT;
|
||||
mod_timer(&req->timer, jiffies + req->timer_intv);
|
||||
skb = skb_clone(req->buf, GFP_ATOMIC);
|
||||
spin_lock_bh(&d->lock);
|
||||
tipc_disc_init_msg(net, d->skb, DSC_REQ_MSG, b);
|
||||
d->net = net;
|
||||
d->bearer_id = b->identity;
|
||||
d->domain = b->domain;
|
||||
d->num_nodes = 0;
|
||||
d->timer_intv = TIPC_DISC_INIT;
|
||||
memcpy(&maddr, &d->dest, sizeof(maddr));
|
||||
mod_timer(&d->timer, jiffies + d->timer_intv);
|
||||
skb = skb_clone(d->skb, GFP_ATOMIC);
|
||||
spin_unlock_bh(&d->lock);
|
||||
if (skb)
|
||||
tipc_bearer_xmit_skb(net, req->bearer_id, skb, &req->dest);
|
||||
spin_unlock_bh(&req->lock);
|
||||
tipc_bearer_xmit_skb(net, b->identity, skb, &maddr);
|
||||
}
|
||||
|
||||
@ -37,14 +37,14 @@
|
||||
#ifndef _TIPC_DISCOVER_H
|
||||
#define _TIPC_DISCOVER_H
|
||||
|
||||
struct tipc_link_req;
|
||||
struct tipc_discoverer;
|
||||
|
||||
int tipc_disc_create(struct net *net, struct tipc_bearer *b_ptr,
|
||||
struct tipc_media_addr *dest, struct sk_buff **skb);
|
||||
void tipc_disc_delete(struct tipc_link_req *req);
|
||||
void tipc_disc_delete(struct tipc_discoverer *req);
|
||||
void tipc_disc_reset(struct net *net, struct tipc_bearer *b_ptr);
|
||||
void tipc_disc_add_dest(struct tipc_link_req *req);
|
||||
void tipc_disc_remove_dest(struct tipc_link_req *req);
|
||||
void tipc_disc_add_dest(struct tipc_discoverer *req);
|
||||
void tipc_disc_remove_dest(struct tipc_discoverer *req);
|
||||
void tipc_disc_rcv(struct net *net, struct sk_buff *buf,
|
||||
struct tipc_bearer *b_ptr);
|
||||
|
||||
|
||||
@ -434,14 +434,16 @@ char *tipc_link_name(struct tipc_link *l)
|
||||
*/
|
||||
bool tipc_link_create(struct net *net, char *if_name, int bearer_id,
|
||||
int tolerance, char net_plane, u32 mtu, int priority,
|
||||
int window, u32 session, u32 ownnode, u32 peer,
|
||||
u16 peer_caps,
|
||||
int window, u32 session, u32 self,
|
||||
u32 peer, u8 *peer_id, u16 peer_caps,
|
||||
struct tipc_link *bc_sndlink,
|
||||
struct tipc_link *bc_rcvlink,
|
||||
struct sk_buff_head *inputq,
|
||||
struct sk_buff_head *namedq,
|
||||
struct tipc_link **link)
|
||||
{
|
||||
char peer_str[NODE_ID_STR_LEN] = {0,};
|
||||
char self_str[NODE_ID_STR_LEN] = {0,};
|
||||
struct tipc_link *l;
|
||||
|
||||
l = kzalloc(sizeof(*l), GFP_ATOMIC);
|
||||
@ -450,10 +452,18 @@ bool tipc_link_create(struct net *net, char *if_name, int bearer_id,
|
||||
*link = l;
|
||||
l->session = session;
|
||||
|
||||
/* Note: peer i/f name is completed by reset/activate message */
|
||||
sprintf(l->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
|
||||
tipc_zone(ownnode), tipc_cluster(ownnode), tipc_node(ownnode),
|
||||
if_name, tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
|
||||
/* Set link name for unicast links only */
|
||||
if (peer_id) {
|
||||
tipc_nodeid2string(self_str, tipc_own_id(net));
|
||||
if (strlen(self_str) > 16)
|
||||
sprintf(self_str, "%x", self);
|
||||
tipc_nodeid2string(peer_str, peer_id);
|
||||
if (strlen(peer_str) > 16)
|
||||
sprintf(peer_str, "%x", peer);
|
||||
}
|
||||
/* Peer i/f name will be completed by reset/activate message */
|
||||
sprintf(l->name, "%s:%s-%s:unknown", self_str, if_name, peer_str);
|
||||
|
||||
strcpy(l->if_name, if_name);
|
||||
l->addr = peer;
|
||||
l->peer_caps = peer_caps;
|
||||
@ -501,7 +511,7 @@ bool tipc_link_bc_create(struct net *net, u32 ownnode, u32 peer,
|
||||
struct tipc_link *l;
|
||||
|
||||
if (!tipc_link_create(net, "", MAX_BEARERS, 0, 'Z', mtu, 0, window,
|
||||
0, ownnode, peer, peer_caps, bc_sndlink,
|
||||
0, ownnode, peer, NULL, peer_caps, bc_sndlink,
|
||||
NULL, inputq, namedq, link))
|
||||
return false;
|
||||
|
||||
@ -1938,11 +1948,11 @@ static int __tipc_nl_add_stats(struct sk_buff *skb, struct tipc_stats *s)
|
||||
int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,
|
||||
struct tipc_link *link, int nlflags)
|
||||
{
|
||||
int err;
|
||||
void *hdr;
|
||||
u32 self = tipc_own_addr(net);
|
||||
struct nlattr *attrs;
|
||||
struct nlattr *prop;
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
void *hdr;
|
||||
int err;
|
||||
|
||||
hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
|
||||
nlflags, TIPC_NL_LINK_GET);
|
||||
@ -1955,8 +1965,7 @@ int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,
|
||||
|
||||
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,
|
||||
tipc_cluster_mask(tn->own_addr)))
|
||||
if (nla_put_u32(msg->skb, TIPC_NLA_LINK_DEST, tipc_cluster_mask(self)))
|
||||
goto attr_msg_full;
|
||||
if (nla_put_u32(msg->skb, TIPC_NLA_LINK_MTU, link->mtu))
|
||||
goto attr_msg_full;
|
||||
|
||||
@ -73,8 +73,8 @@ enum {
|
||||
|
||||
bool tipc_link_create(struct net *net, char *if_name, int bearer_id,
|
||||
int tolerance, char net_plane, u32 mtu, int priority,
|
||||
int window, u32 session, u32 ownnode, u32 peer,
|
||||
u16 peer_caps,
|
||||
int window, u32 session, u32 ownnode,
|
||||
u32 peer, u8 *peer_id, u16 peer_caps,
|
||||
struct tipc_link *bc_sndlink,
|
||||
struct tipc_link *bc_rcvlink,
|
||||
struct sk_buff_head *inputq,
|
||||
|
||||
@ -550,6 +550,8 @@ static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)
|
||||
*/
|
||||
#define DSC_REQ_MSG 0
|
||||
#define DSC_RESP_MSG 1
|
||||
#define DSC_TRIAL_MSG 2
|
||||
#define DSC_TRIAL_FAIL_MSG 3
|
||||
|
||||
/*
|
||||
* Group protocol message types
|
||||
@ -627,7 +629,6 @@ static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)
|
||||
msg_set_bits(m, 2, 0, 0xffff, n);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Word 4
|
||||
*/
|
||||
@ -925,6 +926,26 @@ static inline bool msg_is_reset(struct tipc_msg *hdr)
|
||||
return (msg_user(hdr) == LINK_PROTOCOL) && (msg_type(hdr) == RESET_MSG);
|
||||
}
|
||||
|
||||
static inline u32 msg_sugg_node_addr(struct tipc_msg *m)
|
||||
{
|
||||
return msg_word(m, 14);
|
||||
}
|
||||
|
||||
static inline void msg_set_sugg_node_addr(struct tipc_msg *m, u32 n)
|
||||
{
|
||||
msg_set_word(m, 14, n);
|
||||
}
|
||||
|
||||
static inline void msg_set_node_id(struct tipc_msg *hdr, u8 *id)
|
||||
{
|
||||
memcpy(msg_data(hdr), id, 16);
|
||||
}
|
||||
|
||||
static inline u8 *msg_node_id(struct tipc_msg *hdr)
|
||||
{
|
||||
return (u8 *)msg_data(hdr);
|
||||
}
|
||||
|
||||
struct sk_buff *tipc_buf_acquire(u32 size, gfp_t gfp);
|
||||
bool tipc_msg_validate(struct sk_buff **_skb);
|
||||
bool tipc_msg_reverse(u32 own_addr, struct sk_buff **skb, int err);
|
||||
|
||||
@ -68,14 +68,14 @@ static void publ_to_item(struct distr_item *i, struct publication *p)
|
||||
static struct sk_buff *named_prepare_buf(struct net *net, u32 type, u32 size,
|
||||
u32 dest)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
struct sk_buff *buf = tipc_buf_acquire(INT_H_SIZE + size, GFP_ATOMIC);
|
||||
u32 self = tipc_own_addr(net);
|
||||
struct tipc_msg *msg;
|
||||
|
||||
if (buf != NULL) {
|
||||
msg = buf_msg(buf);
|
||||
tipc_msg_init(tn->own_addr, msg, NAME_DISTRIBUTOR, type,
|
||||
INT_H_SIZE, dest);
|
||||
tipc_msg_init(self, msg, NAME_DISTRIBUTOR,
|
||||
type, INT_H_SIZE, dest);
|
||||
msg_set_size(msg, INT_H_SIZE + size);
|
||||
}
|
||||
return buf;
|
||||
@ -318,7 +318,6 @@ void tipc_named_process_backlog(struct net *net)
|
||||
{
|
||||
struct distr_queue_item *e, *tmp;
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
char addr[16];
|
||||
unsigned long now = get_jiffies_64();
|
||||
|
||||
list_for_each_entry_safe(e, tmp, &tn->dist_queue, next) {
|
||||
@ -326,12 +325,11 @@ void tipc_named_process_backlog(struct net *net)
|
||||
if (!tipc_update_nametbl(net, &e->i, e->node, e->dtype))
|
||||
continue;
|
||||
} else {
|
||||
tipc_addr_string_fill(addr, e->node);
|
||||
pr_warn_ratelimited("Dropping name table update (%d) of {%u, %u, %u} from %s key=%u\n",
|
||||
pr_warn_ratelimited("Dropping name table update (%d) of {%u, %u, %u} from %x key=%u\n",
|
||||
e->dtype, ntohl(e->i.type),
|
||||
ntohl(e->i.lower),
|
||||
ntohl(e->i.upper),
|
||||
addr, ntohl(e->i.key));
|
||||
e->node, ntohl(e->i.key));
|
||||
}
|
||||
list_del(&e->next);
|
||||
kfree(e);
|
||||
@ -382,13 +380,14 @@ void tipc_named_reinit(struct net *net)
|
||||
struct name_table *nt = tipc_name_table(net);
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
struct publication *publ;
|
||||
u32 self = tipc_own_addr(net);
|
||||
|
||||
spin_lock_bh(&tn->nametbl_lock);
|
||||
|
||||
list_for_each_entry_rcu(publ, &nt->node_scope, binding_node)
|
||||
publ->node = tn->own_addr;
|
||||
publ->node = self;
|
||||
list_for_each_entry_rcu(publ, &nt->cluster_scope, binding_node)
|
||||
publ->node = tn->own_addr;
|
||||
publ->node = self;
|
||||
|
||||
spin_unlock_bh(&tn->nametbl_lock);
|
||||
}
|
||||
|
||||
@ -499,7 +499,9 @@ struct publication *tipc_nametbl_remove_publ(struct net *net, u32 type,
|
||||
u32 tipc_nametbl_translate(struct net *net, u32 type, u32 instance,
|
||||
u32 *destnode)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
bool legacy = tn->legacy_addr_format;
|
||||
u32 self = tipc_own_addr(net);
|
||||
struct sub_seq *sseq;
|
||||
struct name_info *info;
|
||||
struct publication *publ;
|
||||
@ -507,7 +509,7 @@ u32 tipc_nametbl_translate(struct net *net, u32 type, u32 instance,
|
||||
u32 port = 0;
|
||||
u32 node = 0;
|
||||
|
||||
if (!tipc_in_scope(*destnode, tn->own_addr))
|
||||
if (!tipc_in_scope(legacy, *destnode, self))
|
||||
return 0;
|
||||
|
||||
rcu_read_lock();
|
||||
@ -521,7 +523,7 @@ u32 tipc_nametbl_translate(struct net *net, u32 type, u32 instance,
|
||||
info = sseq->info;
|
||||
|
||||
/* Closest-First Algorithm */
|
||||
if (likely(!*destnode)) {
|
||||
if (legacy && !*destnode) {
|
||||
if (!list_empty(&info->local_publ)) {
|
||||
publ = list_first_entry(&info->local_publ,
|
||||
struct publication,
|
||||
@ -538,7 +540,7 @@ u32 tipc_nametbl_translate(struct net *net, u32 type, u32 instance,
|
||||
}
|
||||
|
||||
/* Round-Robin Algorithm */
|
||||
else if (*destnode == tn->own_addr) {
|
||||
else if (*destnode == tipc_own_addr(net)) {
|
||||
if (list_empty(&info->local_publ))
|
||||
goto no_match;
|
||||
publ = list_first_entry(&info->local_publ, struct publication,
|
||||
@ -711,7 +713,7 @@ struct publication *tipc_nametbl_publish(struct net *net, u32 type, u32 lower,
|
||||
}
|
||||
|
||||
publ = tipc_nametbl_insert_publ(net, type, lower, upper, scope,
|
||||
tn->own_addr, port_ref, key);
|
||||
tipc_own_addr(net), port_ref, key);
|
||||
if (likely(publ)) {
|
||||
tn->nametbl->local_publ_count++;
|
||||
buf = tipc_named_publish(net, publ);
|
||||
@ -736,7 +738,7 @@ int tipc_nametbl_withdraw(struct net *net, u32 type, u32 lower, u32 port,
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
|
||||
spin_lock_bh(&tn->nametbl_lock);
|
||||
publ = tipc_nametbl_remove_publ(net, type, lower, tn->own_addr,
|
||||
publ = tipc_nametbl_remove_publ(net, type, lower, tipc_own_addr(net),
|
||||
port, key);
|
||||
if (likely(publ)) {
|
||||
tn->nametbl->local_publ_count--;
|
||||
|
||||
@ -104,38 +104,39 @@
|
||||
* - A local spin_lock protecting the queue of subscriber events.
|
||||
*/
|
||||
|
||||
int tipc_net_start(struct net *net, u32 addr)
|
||||
int tipc_net_init(struct net *net, u8 *node_id, u32 addr)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
char addr_string[16];
|
||||
if (tipc_own_id(net)) {
|
||||
pr_info("Cannot configure node identity twice\n");
|
||||
return -1;
|
||||
}
|
||||
pr_info("Started in network mode\n");
|
||||
|
||||
tn->own_addr = addr;
|
||||
if (node_id)
|
||||
tipc_set_node_id(net, node_id);
|
||||
if (addr)
|
||||
tipc_net_finalize(net, addr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Ensure that the new address is visible before we reinit. */
|
||||
void tipc_net_finalize(struct net *net, u32 addr)
|
||||
{
|
||||
tipc_set_node_addr(net, addr);
|
||||
smp_mb();
|
||||
|
||||
tipc_named_reinit(net);
|
||||
tipc_sk_reinit(net);
|
||||
|
||||
tipc_nametbl_publish(net, TIPC_CFG_SRV, tn->own_addr, tn->own_addr,
|
||||
TIPC_CLUSTER_SCOPE, 0, tn->own_addr);
|
||||
|
||||
pr_info("Started in network mode\n");
|
||||
pr_info("Own node address %s, network identity %u\n",
|
||||
tipc_addr_string_fill(addr_string, tn->own_addr),
|
||||
tn->net_id);
|
||||
return 0;
|
||||
tipc_nametbl_publish(net, TIPC_CFG_SRV, addr, addr,
|
||||
TIPC_CLUSTER_SCOPE, 0, addr);
|
||||
}
|
||||
|
||||
void tipc_net_stop(struct net *net)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
u32 self = tipc_own_addr(net);
|
||||
|
||||
if (!tn->own_addr)
|
||||
if (!self)
|
||||
return;
|
||||
|
||||
tipc_nametbl_withdraw(net, TIPC_CFG_SRV, tn->own_addr, 0,
|
||||
tn->own_addr);
|
||||
tipc_nametbl_withdraw(net, TIPC_CFG_SRV, self, 0, self);
|
||||
rtnl_lock();
|
||||
tipc_bearer_stop(net);
|
||||
tipc_node_stop(net);
|
||||
@ -147,8 +148,10 @@ void tipc_net_stop(struct net *net)
|
||||
static int __tipc_nl_add_net(struct net *net, struct tipc_nl_msg *msg)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
void *hdr;
|
||||
u64 *w0 = (u64 *)&tn->node_id[0];
|
||||
u64 *w1 = (u64 *)&tn->node_id[8];
|
||||
struct nlattr *attrs;
|
||||
void *hdr;
|
||||
|
||||
hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
|
||||
NLM_F_MULTI, TIPC_NL_NET_GET);
|
||||
@ -161,7 +164,10 @@ static int __tipc_nl_add_net(struct net *net, struct tipc_nl_msg *msg)
|
||||
|
||||
if (nla_put_u32(msg->skb, TIPC_NLA_NET_ID, tn->net_id))
|
||||
goto attr_msg_full;
|
||||
|
||||
if (nla_put_u64_64bit(msg->skb, TIPC_NLA_NET_NODEID, *w0, 0))
|
||||
goto attr_msg_full;
|
||||
if (nla_put_u64_64bit(msg->skb, TIPC_NLA_NET_NODEID_W1, *w1, 0))
|
||||
goto attr_msg_full;
|
||||
nla_nest_end(msg->skb, attrs);
|
||||
genlmsg_end(msg->skb, hdr);
|
||||
|
||||
@ -202,9 +208,9 @@ int tipc_nl_net_dump(struct sk_buff *skb, struct netlink_callback *cb)
|
||||
|
||||
int __tipc_nl_net_set(struct sk_buff *skb, struct genl_info *info)
|
||||
{
|
||||
struct net *net = sock_net(skb->sk);
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
struct nlattr *attrs[TIPC_NLA_NET_MAX + 1];
|
||||
struct net *net = sock_net(skb->sk);
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
int err;
|
||||
|
||||
if (!info->attrs[TIPC_NLA_NET])
|
||||
@ -213,16 +219,17 @@ int __tipc_nl_net_set(struct sk_buff *skb, struct genl_info *info)
|
||||
err = nla_parse_nested(attrs, TIPC_NLA_NET_MAX,
|
||||
info->attrs[TIPC_NLA_NET], tipc_nl_net_policy,
|
||||
info->extack);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Can't change net id once TIPC has joined a network */
|
||||
if (tipc_own_addr(net))
|
||||
return -EPERM;
|
||||
|
||||
if (attrs[TIPC_NLA_NET_ID]) {
|
||||
u32 val;
|
||||
|
||||
/* Can't change net id once TIPC has joined a network */
|
||||
if (tn->own_addr)
|
||||
return -EPERM;
|
||||
|
||||
val = nla_get_u32(attrs[TIPC_NLA_NET_ID]);
|
||||
if (val < 1 || val > 9999)
|
||||
return -EINVAL;
|
||||
@ -233,17 +240,22 @@ int __tipc_nl_net_set(struct sk_buff *skb, struct genl_info *info)
|
||||
if (attrs[TIPC_NLA_NET_ADDR]) {
|
||||
u32 addr;
|
||||
|
||||
/* Can't change net addr once TIPC has joined a network */
|
||||
if (tn->own_addr)
|
||||
return -EPERM;
|
||||
|
||||
addr = nla_get_u32(attrs[TIPC_NLA_NET_ADDR]);
|
||||
if (!tipc_addr_node_valid(addr))
|
||||
if (!addr)
|
||||
return -EINVAL;
|
||||
|
||||
tipc_net_start(net, addr);
|
||||
tn->legacy_addr_format = true;
|
||||
tipc_net_init(net, NULL, addr);
|
||||
}
|
||||
|
||||
if (attrs[TIPC_NLA_NET_NODEID]) {
|
||||
u8 node_id[NODE_ID_LEN];
|
||||
u64 *w0 = (u64 *)&node_id[0];
|
||||
u64 *w1 = (u64 *)&node_id[8];
|
||||
|
||||
*w0 = nla_get_u64(attrs[TIPC_NLA_NET_NODEID]);
|
||||
*w1 = nla_get_u64(attrs[TIPC_NLA_NET_NODEID_W1]);
|
||||
tipc_net_init(net, node_id, 0);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -41,10 +41,9 @@
|
||||
|
||||
extern const struct nla_policy tipc_nl_net_policy[];
|
||||
|
||||
int tipc_net_start(struct net *net, u32 addr);
|
||||
|
||||
int tipc_net_init(struct net *net, u8 *node_id, u32 addr);
|
||||
void tipc_net_finalize(struct net *net, u32 addr);
|
||||
void tipc_net_stop(struct net *net);
|
||||
|
||||
int tipc_nl_net_dump(struct sk_buff *skb, struct netlink_callback *cb);
|
||||
int tipc_nl_net_set(struct sk_buff *skb, struct genl_info *info);
|
||||
int __tipc_nl_net_set(struct sk_buff *skb, struct genl_info *info);
|
||||
|
||||
101
net/tipc/node.c
101
net/tipc/node.c
@ -115,6 +115,7 @@ struct tipc_node {
|
||||
u16 capabilities;
|
||||
u32 signature;
|
||||
u32 link_id;
|
||||
u8 peer_id[16];
|
||||
struct list_head publ_list;
|
||||
struct list_head conn_sks;
|
||||
unsigned long keepalive_intv;
|
||||
@ -156,6 +157,7 @@ static void tipc_node_delete(struct tipc_node *node);
|
||||
static void tipc_node_timeout(struct timer_list *t);
|
||||
static void tipc_node_fsm_evt(struct tipc_node *n, int evt);
|
||||
static struct tipc_node *tipc_node_find(struct net *net, u32 addr);
|
||||
static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id);
|
||||
static void tipc_node_put(struct tipc_node *node);
|
||||
static bool node_is_up(struct tipc_node *n);
|
||||
|
||||
@ -233,9 +235,6 @@ static struct tipc_node *tipc_node_find(struct net *net, u32 addr)
|
||||
struct tipc_node *node;
|
||||
unsigned int thash = tipc_hashfn(addr);
|
||||
|
||||
if (unlikely(!in_own_cluster_exact(net, addr)))
|
||||
return NULL;
|
||||
|
||||
rcu_read_lock();
|
||||
hlist_for_each_entry_rcu(node, &tn->node_htable[thash], hash) {
|
||||
if (node->addr != addr)
|
||||
@ -248,6 +247,30 @@ static struct tipc_node *tipc_node_find(struct net *net, u32 addr)
|
||||
return node;
|
||||
}
|
||||
|
||||
/* tipc_node_find_by_id - locate specified node object by its 128-bit id
|
||||
* Note: this function is called only when a discovery request failed
|
||||
* to find the node by its 32-bit id, and is not time critical
|
||||
*/
|
||||
static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id)
|
||||
{
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
struct tipc_node *n;
|
||||
bool found = false;
|
||||
|
||||
rcu_read_lock();
|
||||
list_for_each_entry_rcu(n, &tn->node_list, list) {
|
||||
read_lock_bh(&n->lock);
|
||||
if (!memcmp(id, n->peer_id, 16) &&
|
||||
kref_get_unless_zero(&n->kref))
|
||||
found = true;
|
||||
read_unlock_bh(&n->lock);
|
||||
if (found)
|
||||
break;
|
||||
}
|
||||
rcu_read_unlock();
|
||||
return found ? n : NULL;
|
||||
}
|
||||
|
||||
static void tipc_node_read_lock(struct tipc_node *n)
|
||||
{
|
||||
read_lock_bh(&n->lock);
|
||||
@ -310,7 +333,8 @@ static void tipc_node_write_unlock(struct tipc_node *n)
|
||||
}
|
||||
}
|
||||
|
||||
struct tipc_node *tipc_node_create(struct net *net, u32 addr, u16 capabilities)
|
||||
struct tipc_node *tipc_node_create(struct net *net, u32 addr,
|
||||
u8 *peer_id, u16 capabilities)
|
||||
{
|
||||
struct tipc_net *tn = net_generic(net, tipc_net_id);
|
||||
struct tipc_node *n, *temp_node;
|
||||
@ -329,6 +353,7 @@ struct tipc_node *tipc_node_create(struct net *net, u32 addr, u16 capabilities)
|
||||
goto exit;
|
||||
}
|
||||
n->addr = addr;
|
||||
memcpy(&n->peer_id, peer_id, 16);
|
||||
n->net = net;
|
||||
n->capabilities = capabilities;
|
||||
kref_init(&n->kref);
|
||||
@ -347,8 +372,8 @@ struct tipc_node *tipc_node_create(struct net *net, u32 addr, u16 capabilities)
|
||||
n->signature = INVALID_NODE_SIG;
|
||||
n->active_links[0] = INVALID_BEARER_ID;
|
||||
n->active_links[1] = INVALID_BEARER_ID;
|
||||
if (!tipc_link_bc_create(net, tipc_own_addr(net), n->addr,
|
||||
U16_MAX,
|
||||
if (!tipc_link_bc_create(net, tipc_own_addr(net),
|
||||
addr, U16_MAX,
|
||||
tipc_link_window(tipc_bc_sndlink(net)),
|
||||
n->capabilities,
|
||||
&n->bc_entry.inputq1,
|
||||
@ -738,8 +763,51 @@ bool tipc_node_is_up(struct net *net, u32 addr)
|
||||
return retval;
|
||||
}
|
||||
|
||||
void tipc_node_check_dest(struct net *net, u32 onode,
|
||||
struct tipc_bearer *b,
|
||||
static u32 tipc_node_suggest_addr(struct net *net, u32 addr)
|
||||
{
|
||||
struct tipc_node *n;
|
||||
|
||||
addr ^= tipc_net(net)->random;
|
||||
while ((n = tipc_node_find(net, addr))) {
|
||||
tipc_node_put(n);
|
||||
addr++;
|
||||
}
|
||||
return addr;
|
||||
}
|
||||
|
||||
/* tipc_node_try_addr(): Check if addr can be used by peer, suggest other if not
|
||||
*/
|
||||
u32 tipc_node_try_addr(struct net *net, u8 *id, u32 addr)
|
||||
{
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
struct tipc_node *n;
|
||||
|
||||
/* Suggest new address if some other peer is using this one */
|
||||
n = tipc_node_find(net, addr);
|
||||
if (n) {
|
||||
if (!memcmp(n->peer_id, id, NODE_ID_LEN))
|
||||
addr = 0;
|
||||
tipc_node_put(n);
|
||||
if (!addr)
|
||||
return 0;
|
||||
return tipc_node_suggest_addr(net, addr);
|
||||
}
|
||||
|
||||
/* Suggest previously used address if peer is known */
|
||||
n = tipc_node_find_by_id(net, id);
|
||||
if (n) {
|
||||
addr = n->addr;
|
||||
tipc_node_put(n);
|
||||
}
|
||||
/* Even this node may be in trial phase */
|
||||
if (tn->trial_addr == addr)
|
||||
return tipc_node_suggest_addr(net, addr);
|
||||
|
||||
return addr;
|
||||
}
|
||||
|
||||
void tipc_node_check_dest(struct net *net, u32 addr,
|
||||
u8 *peer_id, struct tipc_bearer *b,
|
||||
u16 capabilities, u32 signature,
|
||||
struct tipc_media_addr *maddr,
|
||||
bool *respond, bool *dupl_addr)
|
||||
@ -758,7 +826,7 @@ void tipc_node_check_dest(struct net *net, u32 onode,
|
||||
*dupl_addr = false;
|
||||
*respond = false;
|
||||
|
||||
n = tipc_node_create(net, onode, capabilities);
|
||||
n = tipc_node_create(net, addr, peer_id, capabilities);
|
||||
if (!n)
|
||||
return;
|
||||
|
||||
@ -836,15 +904,14 @@ void tipc_node_check_dest(struct net *net, u32 onode,
|
||||
|
||||
/* Now create new link if not already existing */
|
||||
if (!l) {
|
||||
if (n->link_cnt == 2) {
|
||||
pr_warn("Cannot establish 3rd link to %x\n", n->addr);
|
||||
if (n->link_cnt == 2)
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if_name = strchr(b->name, ':') + 1;
|
||||
if (!tipc_link_create(net, if_name, b->identity, b->tolerance,
|
||||
b->net_plane, b->mtu, b->priority,
|
||||
b->window, mod(tipc_net(net)->random),
|
||||
tipc_own_addr(net), onode,
|
||||
tipc_own_addr(net), addr, peer_id,
|
||||
n->capabilities,
|
||||
tipc_bc_sndlink(n->net), n->bc_entry.link,
|
||||
&le->inputq,
|
||||
@ -887,11 +954,9 @@ void tipc_node_delete_links(struct net *net, int bearer_id)
|
||||
|
||||
static void tipc_node_reset_links(struct tipc_node *n)
|
||||
{
|
||||
char addr_string[16];
|
||||
int i;
|
||||
|
||||
pr_warn("Resetting all links to %s\n",
|
||||
tipc_addr_string_fill(addr_string, n->addr));
|
||||
pr_warn("Resetting all links to %x\n", n->addr);
|
||||
|
||||
for (i = 0; i < MAX_BEARERS; i++) {
|
||||
tipc_node_link_down(n, i, false);
|
||||
@ -1078,15 +1143,13 @@ static void tipc_node_fsm_evt(struct tipc_node *n, int evt)
|
||||
static void node_lost_contact(struct tipc_node *n,
|
||||
struct sk_buff_head *inputq)
|
||||
{
|
||||
char addr_string[16];
|
||||
struct tipc_sock_conn *conn, *safe;
|
||||
struct tipc_link *l;
|
||||
struct list_head *conns = &n->conn_sks;
|
||||
struct sk_buff *skb;
|
||||
uint i;
|
||||
|
||||
pr_debug("Lost contact with %s\n",
|
||||
tipc_addr_string_fill(addr_string, n->addr));
|
||||
pr_debug("Lost contact with %x\n", n->addr);
|
||||
|
||||
/* Clean up broadcast state */
|
||||
tipc_bcast_remove_peer(n->net, n->bc_entry.link);
|
||||
|
||||
@ -49,17 +49,19 @@ enum {
|
||||
TIPC_BCAST_STATE_NACK = (1 << 2),
|
||||
TIPC_BLOCK_FLOWCTL = (1 << 3),
|
||||
TIPC_BCAST_RCAST = (1 << 4),
|
||||
TIPC_MCAST_GROUPS = (1 << 5)
|
||||
TIPC_NODE_ID128 = (1 << 5)
|
||||
};
|
||||
|
||||
#define TIPC_NODE_CAPABILITIES (TIPC_BCAST_SYNCH | \
|
||||
TIPC_BCAST_STATE_NACK | \
|
||||
TIPC_BCAST_RCAST | \
|
||||
TIPC_BLOCK_FLOWCTL)
|
||||
TIPC_BLOCK_FLOWCTL | \
|
||||
TIPC_NODE_ID128)
|
||||
#define INVALID_BEARER_ID -1
|
||||
|
||||
void tipc_node_stop(struct net *net);
|
||||
void tipc_node_check_dest(struct net *net, u32 onode,
|
||||
u32 tipc_node_try_addr(struct net *net, u8 *id, u32 addr);
|
||||
void tipc_node_check_dest(struct net *net, u32 onode, u8 *peer_id128,
|
||||
struct tipc_bearer *bearer,
|
||||
u16 capabilities, u32 signature,
|
||||
struct tipc_media_addr *maddr,
|
||||
|
||||
@ -289,10 +289,9 @@ static bool tipc_sk_type_connectionless(struct sock *sk)
|
||||
static bool tsk_peer_msg(struct tipc_sock *tsk, struct tipc_msg *msg)
|
||||
{
|
||||
struct sock *sk = &tsk->sk;
|
||||
struct tipc_net *tn = net_generic(sock_net(sk), tipc_net_id);
|
||||
u32 self = tipc_own_addr(sock_net(sk));
|
||||
u32 peer_port = tsk_peer_port(tsk);
|
||||
u32 orig_node;
|
||||
u32 peer_node;
|
||||
u32 orig_node, peer_node;
|
||||
|
||||
if (unlikely(!tipc_sk_connected(sk)))
|
||||
return false;
|
||||
@ -306,10 +305,10 @@ static bool tsk_peer_msg(struct tipc_sock *tsk, struct tipc_msg *msg)
|
||||
if (likely(orig_node == peer_node))
|
||||
return true;
|
||||
|
||||
if (!orig_node && (peer_node == tn->own_addr))
|
||||
if (!orig_node && peer_node == self)
|
||||
return true;
|
||||
|
||||
if (!peer_node && (orig_node == tn->own_addr))
|
||||
if (!peer_node && orig_node == self)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
@ -461,8 +460,8 @@ static int tipc_sk_create(struct net *net, struct socket *sock,
|
||||
/* Ensure tsk is visible before we read own_addr. */
|
||||
smp_mb();
|
||||
|
||||
tipc_msg_init(tn->own_addr, msg, TIPC_LOW_IMPORTANCE, TIPC_NAMED_MSG,
|
||||
NAMED_H_SIZE, 0);
|
||||
tipc_msg_init(tipc_own_addr(net), msg, TIPC_LOW_IMPORTANCE,
|
||||
TIPC_NAMED_MSG, NAMED_H_SIZE, 0);
|
||||
|
||||
msg_set_origport(msg, tsk->portid);
|
||||
timer_setup(&sk->sk_timer, tipc_sk_timeout, 0);
|
||||
@ -671,7 +670,6 @@ static int tipc_getname(struct socket *sock, struct sockaddr *uaddr,
|
||||
struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
|
||||
struct sock *sk = sock->sk;
|
||||
struct tipc_sock *tsk = tipc_sk(sk);
|
||||
struct tipc_net *tn = net_generic(sock_net(sock->sk), tipc_net_id);
|
||||
|
||||
memset(addr, 0, sizeof(*addr));
|
||||
if (peer) {
|
||||
@ -682,7 +680,7 @@ static int tipc_getname(struct socket *sock, struct sockaddr *uaddr,
|
||||
addr->addr.id.node = tsk_peer_node(tsk);
|
||||
} else {
|
||||
addr->addr.id.ref = tsk->portid;
|
||||
addr->addr.id.node = tn->own_addr;
|
||||
addr->addr.id.node = tipc_own_addr(sock_net(sk));
|
||||
}
|
||||
|
||||
addr->addrtype = TIPC_ADDR_ID;
|
||||
@ -2667,8 +2665,8 @@ void tipc_sk_reinit(struct net *net)
|
||||
while ((tsk = rhashtable_walk_next(&iter)) && !IS_ERR(tsk)) {
|
||||
spin_lock_bh(&tsk->sk.sk_lock.slock);
|
||||
msg = &tsk->phdr;
|
||||
msg_set_prevnode(msg, tn->own_addr);
|
||||
msg_set_orignode(msg, tn->own_addr);
|
||||
msg_set_prevnode(msg, tipc_own_addr(net));
|
||||
msg_set_orignode(msg, tipc_own_addr(net));
|
||||
spin_unlock_bh(&tsk->sk.sk_lock.slock);
|
||||
}
|
||||
|
||||
@ -3167,11 +3165,10 @@ static int __tipc_nl_add_sk_info(struct sk_buff *skb, struct tipc_sock
|
||||
*tsk)
|
||||
{
|
||||
struct net *net = sock_net(skb->sk);
|
||||
struct tipc_net *tn = tipc_net(net);
|
||||
struct sock *sk = &tsk->sk;
|
||||
|
||||
if (nla_put_u32(skb, TIPC_NLA_SOCK_REF, tsk->portid) ||
|
||||
nla_put_u32(skb, TIPC_NLA_SOCK_ADDR, tn->own_addr))
|
||||
nla_put_u32(skb, TIPC_NLA_SOCK_ADDR, tipc_own_addr(net)))
|
||||
return -EMSGSIZE;
|
||||
|
||||
if (tipc_sk_connected(sk)) {
|
||||
|
||||
@ -47,6 +47,8 @@
|
||||
#include <net/addrconf.h>
|
||||
#include <linux/tipc_netlink.h>
|
||||
#include "core.h"
|
||||
#include "addr.h"
|
||||
#include "net.h"
|
||||
#include "bearer.h"
|
||||
#include "netlink.h"
|
||||
#include "msg.h"
|
||||
@ -647,6 +649,7 @@ static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,
|
||||
struct udp_port_cfg udp_conf = {0};
|
||||
struct udp_tunnel_sock_cfg tuncfg = {NULL};
|
||||
struct nlattr *opts[TIPC_NLA_UDP_MAX + 1];
|
||||
u8 node_id[NODE_ID_LEN] = {0,};
|
||||
|
||||
ub = kzalloc(sizeof(*ub), GFP_ATOMIC);
|
||||
if (!ub)
|
||||
@ -677,6 +680,16 @@ static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,
|
||||
if (err)
|
||||
goto err;
|
||||
|
||||
/* Autoconfigure own node identity if needed */
|
||||
if (!tipc_own_id(net)) {
|
||||
memcpy(node_id, local.ipv6.in6_u.u6_addr8, 16);
|
||||
tipc_net_init(net, node_id, 0);
|
||||
}
|
||||
if (!tipc_own_id(net)) {
|
||||
pr_warn("Failed to set node id, please configure manually\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
b->bcast_addr.media_id = TIPC_MEDIA_TYPE_UDP;
|
||||
b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
|
||||
rcu_assign_pointer(b->media_ptr, ub);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user