mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-11-04 10:40:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

tipc: make tipc node table aware of net namespace

Browse source 
Global variables associated with node table are below:
- node table list (node_htable)
- node hash table list (tipc_node_list)
- node table lock (node_list_lock)
- node number counter (tipc_num_nodes)
- node link number counter (tipc_num_links)

To make node table support namespace, above global variables must be
moved to tipc_net structure in order to keep secret for different
namespaces. As a consequence, these variables are allocated and
initialized when namespace is created, and deallocated when namespace
is destroyed. After the change, functions associated with these
variables have to utilize a namespace pointer to access them. So
adding namespace pointer as a parameter of these functions is the
major change made in the commit.

Signed-off-by: Ying Xue <ying.xue@windriver.com>
Tested-by: Tero Aho <Tero.Aho@coriant.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Ying Xue 2015-01-09 15:27:05 +08:00 committed by David S. Miller
parent c93d3baa24
commit f2f9800d49
21 changed files with 329 additions and 244 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

2
net/tipc/addr.h
View file

@ -40,6 +40,8 @@
#define TIPC_ZONE_MASK 0xff000000u #define TIPC_ZONE_MASK 0xff000000u
#define TIPC_CLUSTER_MASK 0xfffff000u #define TIPC_CLUSTER_MASK 0xfffff000u
extern u32 tipc_own_addr __read_mostly;
static inline u32 tipc_zone_mask(u32 addr) static inline u32 tipc_zone_mask(u32 addr)
{ {
return addr & TIPC_ZONE_MASK; return addr & TIPC_ZONE_MASK;

24
net/tipc/bcast.c
View file

@ -232,13 +232,12 @@ static void bclink_retransmit_pkt(u32 after, u32 to)
* *
* Called with no locks taken * Called with no locks taken
*/ */
void tipc_bclink_wakeup_users(void) void tipc_bclink_wakeup_users(struct net *net)
{ {
struct sk_buff *skb; struct sk_buff *skb;
while ((skb = skb_dequeue(&bclink->link.waiting_sks))) while ((skb = skb_dequeue(&bclink->link.waiting_sks)))
tipc_sk_rcv(skb); tipc_sk_rcv(net, skb);
} }
/** /**
@ -385,9 +384,9 @@ void tipc_bclink_update_link_state(struct net *net, struct tipc_node *n_ptr,
* Delay any upcoming NACK by this node if another node has already * Delay any upcoming NACK by this node if another node has already
* requested the first message this node is going to ask for. * requested the first message this node is going to ask for.
*/ */
static void bclink_peek_nack(struct tipc_msg *msg) static void bclink_peek_nack(struct net *net, struct tipc_msg *msg)
{ {
struct tipc_node *n_ptr = tipc_node_find(msg_destnode(msg)); struct tipc_node *n_ptr = tipc_node_find(net, msg_destnode(msg));
if (unlikely(!n_ptr)) if (unlikely(!n_ptr))
return; return;
@ -404,11 +403,12 @@ static void bclink_peek_nack(struct tipc_msg *msg)
/* tipc_bclink_xmit - broadcast buffer chain to all nodes in cluster /* tipc_bclink_xmit - broadcast buffer chain to all nodes in cluster
* and to identified node local sockets * and to identified node local sockets
* @net: the applicable net namespace
* @list: chain of buffers containing message * @list: chain of buffers containing message
* Consumes the buffer chain, except when returning -ELINKCONG * Consumes the buffer chain, except when returning -ELINKCONG
* Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE * Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE
*/ */
int tipc_bclink_xmit(struct sk_buff_head *list) int tipc_bclink_xmit(struct net *net, struct sk_buff_head *list)
{ {
int rc = 0; int rc = 0;
int bc = 0; int bc = 0;
@ -443,7 +443,7 @@ int tipc_bclink_xmit(struct sk_buff_head *list)
/* Deliver message clone */ /* Deliver message clone */
if (likely(!rc)) if (likely(!rc))
tipc_sk_mcast_rcv(skb); tipc_sk_mcast_rcv(net, skb);
else else
kfree_skb(skb); kfree_skb(skb);
@ -491,7 +491,7 @@ void tipc_bclink_rcv(struct net *net, struct sk_buff *buf)
if (msg_mc_netid(msg) != tn->net_id) if (msg_mc_netid(msg) != tn->net_id)
goto exit; goto exit;
node = tipc_node_find(msg_prevnode(msg)); node = tipc_node_find(net, msg_prevnode(msg));
if (unlikely(!node)) if (unlikely(!node))
goto exit; goto exit;
@ -514,7 +514,7 @@ void tipc_bclink_rcv(struct net *net, struct sk_buff *buf)
tipc_bclink_unlock(); tipc_bclink_unlock();
} else { } else {
tipc_node_unlock(node); tipc_node_unlock(node);
bclink_peek_nack(msg); bclink_peek_nack(net, msg);
} }
goto exit; goto exit;
} }
@ -532,7 +532,7 @@ void tipc_bclink_rcv(struct net *net, struct sk_buff *buf)
tipc_bclink_unlock(); tipc_bclink_unlock();
tipc_node_unlock(node); tipc_node_unlock(node);
if (likely(msg_mcast(msg))) if (likely(msg_mcast(msg)))
tipc_sk_mcast_rcv(buf); tipc_sk_mcast_rcv(net, buf);
else else
kfree_skb(buf); kfree_skb(buf);
} else if (msg_user(msg) == MSG_BUNDLER) { } else if (msg_user(msg) == MSG_BUNDLER) {
@ -542,7 +542,7 @@ void tipc_bclink_rcv(struct net *net, struct sk_buff *buf)
bcl->stats.recv_bundled += msg_msgcnt(msg); bcl->stats.recv_bundled += msg_msgcnt(msg);
tipc_bclink_unlock(); tipc_bclink_unlock();
tipc_node_unlock(node); tipc_node_unlock(node);
tipc_link_bundle_rcv(buf); tipc_link_bundle_rcv(net, buf);
} else if (msg_user(msg) == MSG_FRAGMENTER) { } else if (msg_user(msg) == MSG_FRAGMENTER) {
tipc_buf_append(&node->bclink.reasm_buf, &buf); tipc_buf_append(&node->bclink.reasm_buf, &buf);
if (unlikely(!buf && !node->bclink.reasm_buf)) if (unlikely(!buf && !node->bclink.reasm_buf))
@ -563,7 +563,7 @@ void tipc_bclink_rcv(struct net *net, struct sk_buff *buf)
bclink_accept_pkt(node, seqno); bclink_accept_pkt(node, seqno);
tipc_bclink_unlock(); tipc_bclink_unlock();
tipc_node_unlock(node); tipc_node_unlock(node);
tipc_named_rcv(buf); tipc_named_rcv(net, buf);
} else { } else {
tipc_bclink_lock(); tipc_bclink_lock();
bclink_accept_pkt(node, seqno); bclink_accept_pkt(node, seqno);

4
net/tipc/bcast.h
View file

@ -101,8 +101,8 @@ int tipc_bclink_reset_stats(void);
int tipc_bclink_set_queue_limits(u32 limit); int tipc_bclink_set_queue_limits(u32 limit);
void tipc_bcbearer_sort(struct tipc_node_map *nm_ptr, u32 node, bool action); void tipc_bcbearer_sort(struct tipc_node_map *nm_ptr, u32 node, bool action);
uint tipc_bclink_get_mtu(void); uint tipc_bclink_get_mtu(void);
int tipc_bclink_xmit(struct sk_buff_head *list); int tipc_bclink_xmit(struct net *net, struct sk_buff_head *list);
void tipc_bclink_wakeup_users(void); void tipc_bclink_wakeup_users(struct net *net);
int tipc_nl_add_bc_link(struct tipc_nl_msg *msg); int tipc_nl_add_bc_link(struct tipc_nl_msg *msg);
#endif #endif

25
net/tipc/bearer.c
View file

@ -69,7 +69,8 @@ static const struct nla_policy tipc_nl_media_policy[TIPC_NLA_MEDIA_MAX + 1] = {
struct tipc_bearer __rcu *bearer_list[MAX_BEARERS + 1]; struct tipc_bearer __rcu *bearer_list[MAX_BEARERS + 1];
static void bearer_disable(struct tipc_bearer *b_ptr, bool shutting_down); static void bearer_disable(struct net *net, struct tipc_bearer *b_ptr,
bool shutting_down);
/** /**
* tipc_media_find - locates specified media object by name * tipc_media_find - locates specified media object by name
@ -364,7 +365,7 @@ int tipc_enable_bearer(struct net *net, const char *name, u32 disc_domain,
res = tipc_disc_create(net, b_ptr, &b_ptr->bcast_addr); res = tipc_disc_create(net, b_ptr, &b_ptr->bcast_addr);
if (res) { if (res) {
bearer_disable(b_ptr, false); bearer_disable(net, b_ptr, false);
pr_warn("Bearer <%s> rejected, discovery object creation failed\n", pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
name); name);
return -EINVAL; return -EINVAL;
@ -384,7 +385,7 @@ int tipc_enable_bearer(struct net *net, const char *name, u32 disc_domain,
static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b_ptr) static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b_ptr)
{ {
pr_info("Resetting bearer <%s>\n", b_ptr->name); pr_info("Resetting bearer <%s>\n", b_ptr->name);
tipc_link_reset_list(b_ptr->identity); tipc_link_reset_list(net, b_ptr->identity);
tipc_disc_reset(net, b_ptr); tipc_disc_reset(net, b_ptr);
return 0; return 0;
} }
@ -394,14 +395,15 @@ static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b_ptr)
* *
* Note: This routine assumes caller holds RTNL lock. * Note: This routine assumes caller holds RTNL lock.
*/ */
static void bearer_disable(struct tipc_bearer *b_ptr, bool shutting_down) static void bearer_disable(struct net *net, struct tipc_bearer *b_ptr,
bool shutting_down)
{ {
u32 i; u32 i;
pr_info("Disabling bearer <%s>\n", b_ptr->name); pr_info("Disabling bearer <%s>\n", b_ptr->name);
b_ptr->media->disable_media(b_ptr); b_ptr->media->disable_media(b_ptr);
tipc_link_delete_list(b_ptr->identity, shutting_down); tipc_link_delete_list(net, b_ptr->identity, shutting_down);
if (b_ptr->link_req) if (b_ptr->link_req)
tipc_disc_delete(b_ptr->link_req); tipc_disc_delete(b_ptr->link_req);
@ -414,7 +416,7 @@ static void bearer_disable(struct tipc_bearer *b_ptr, bool shutting_down)
kfree_rcu(b_ptr, rcu); kfree_rcu(b_ptr, rcu);
} }
int tipc_disable_bearer(const char *name) int tipc_disable_bearer(struct net *net, const char *name)
{ {
struct tipc_bearer *b_ptr; struct tipc_bearer *b_ptr;
int res; int res;
@ -424,7 +426,7 @@ int tipc_disable_bearer(const char *name)
pr_warn("Attempt to disable unknown bearer <%s>\n", name); pr_warn("Attempt to disable unknown bearer <%s>\n", name);
res = -EINVAL; res = -EINVAL;
} else { } else {
bearer_disable(b_ptr, false); bearer_disable(net, b_ptr, false);
res = 0; res = 0;
} }
return res; return res;
@ -593,7 +595,7 @@ static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
break; break;
case NETDEV_UNREGISTER: case NETDEV_UNREGISTER:
case NETDEV_CHANGENAME: case NETDEV_CHANGENAME:
bearer_disable(b_ptr, false); bearer_disable(dev_net(dev), b_ptr, false);
break; break;
} }
return NOTIFY_OK; return NOTIFY_OK;
@ -626,7 +628,7 @@ void tipc_bearer_cleanup(void)
dev_remove_pack(&tipc_packet_type); dev_remove_pack(&tipc_packet_type);
} }
void tipc_bearer_stop(void) void tipc_bearer_stop(struct net *net)
{ {
struct tipc_bearer *b_ptr; struct tipc_bearer *b_ptr;
u32 i; u32 i;
@ -634,7 +636,7 @@ void tipc_bearer_stop(void)
for (i = 0; i < MAX_BEARERS; i++) { for (i = 0; i < MAX_BEARERS; i++) {
b_ptr = rtnl_dereference(bearer_list[i]); b_ptr = rtnl_dereference(bearer_list[i]);
if (b_ptr) { if (b_ptr) {
bearer_disable(b_ptr, true); bearer_disable(net, b_ptr, true);
bearer_list[i] = NULL; bearer_list[i] = NULL;
} }
} }
@ -772,6 +774,7 @@ int tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
char *name; char *name;
struct tipc_bearer *bearer; struct tipc_bearer *bearer;
struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1]; struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
struct net *net = genl_info_net(info);
if (!info->attrs[TIPC_NLA_BEARER]) if (!info->attrs[TIPC_NLA_BEARER])
return -EINVAL; return -EINVAL;
@ -794,7 +797,7 @@ int tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
return -EINVAL; return -EINVAL;
} }
bearer_disable(bearer, false); bearer_disable(net, bearer, false);
rtnl_unlock(); rtnl_unlock();
return 0; return 0;

4
net/tipc/bearer.h
View file

@ -168,7 +168,7 @@ extern struct tipc_bearer __rcu *bearer_list[];
void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b_ptr); void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b_ptr);
int tipc_enable_bearer(struct net *net, const char *bearer_name, int tipc_enable_bearer(struct net *net, const char *bearer_name,
u32 disc_domain, u32 priority); u32 disc_domain, u32 priority);
int tipc_disable_bearer(const char *name); int tipc_disable_bearer(struct net *net, const char *name);
/* /*
* Routines made available to TIPC by supported media types * Routines made available to TIPC by supported media types
@ -205,7 +205,7 @@ struct tipc_bearer *tipc_bearer_find(const char *name);
struct tipc_media *tipc_media_find(const char *name); struct tipc_media *tipc_media_find(const char *name);
int tipc_bearer_setup(void); int tipc_bearer_setup(void);
void tipc_bearer_cleanup(void); void tipc_bearer_cleanup(void);
void tipc_bearer_stop(void); void tipc_bearer_stop(struct net *net);
void tipc_bearer_send(u32 bearer_id, struct sk_buff *buf, void tipc_bearer_send(u32 bearer_id, struct sk_buff *buf,
struct tipc_media_addr *dest); struct tipc_media_addr *dest);

21
net/tipc/config.c
View file

@ -150,12 +150,12 @@ static struct sk_buff *cfg_enable_bearer(struct net *net)
return tipc_cfg_reply_none(); return tipc_cfg_reply_none();
} }
static struct sk_buff *cfg_disable_bearer(void) static struct sk_buff *cfg_disable_bearer(struct net *net)
{ {
if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_NAME)) if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_NAME))
return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR); return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
if (tipc_disable_bearer((char *)TLV_DATA(req_tlv_area))) if (tipc_disable_bearer(net, (char *)TLV_DATA(req_tlv_area)))
return tipc_cfg_reply_error_string("unable to disable bearer"); return tipc_cfg_reply_error_string("unable to disable bearer");
return tipc_cfg_reply_none(); return tipc_cfg_reply_none();
@ -232,16 +232,20 @@ struct sk_buff *tipc_cfg_do_cmd(struct net *net, u32 orig_node, u16 cmd,
rep_tlv_buf = tipc_cfg_reply_none(); rep_tlv_buf = tipc_cfg_reply_none();
break; break;
case TIPC_CMD_GET_NODES: case TIPC_CMD_GET_NODES:
rep_tlv_buf = tipc_node_get_nodes(req_tlv_area, req_tlv_space); rep_tlv_buf = tipc_node_get_nodes(net, req_tlv_area,
req_tlv_space);
break; break;
case TIPC_CMD_GET_LINKS: case TIPC_CMD_GET_LINKS:
rep_tlv_buf = tipc_node_get_links(req_tlv_area, req_tlv_space); rep_tlv_buf = tipc_node_get_links(net, req_tlv_area,
req_tlv_space);
break; break;
case TIPC_CMD_SHOW_LINK_STATS: case TIPC_CMD_SHOW_LINK_STATS:
rep_tlv_buf = tipc_link_cmd_show_stats(req_tlv_area, req_tlv_space); rep_tlv_buf = tipc_link_cmd_show_stats(net, req_tlv_area,
req_tlv_space);
break; break;
case TIPC_CMD_RESET_LINK_STATS: case TIPC_CMD_RESET_LINK_STATS:
rep_tlv_buf = tipc_link_cmd_reset_stats(req_tlv_area, req_tlv_space); rep_tlv_buf = tipc_link_cmd_reset_stats(net, req_tlv_area,
req_tlv_space);
break; break;
case TIPC_CMD_SHOW_NAME_TABLE: case TIPC_CMD_SHOW_NAME_TABLE:
rep_tlv_buf = tipc_nametbl_get(req_tlv_area, req_tlv_space); rep_tlv_buf = tipc_nametbl_get(req_tlv_area, req_tlv_space);
@ -261,13 +265,14 @@ struct sk_buff *tipc_cfg_do_cmd(struct net *net, u32 orig_node, u16 cmd,
case TIPC_CMD_SET_LINK_TOL: case TIPC_CMD_SET_LINK_TOL:
case TIPC_CMD_SET_LINK_PRI: case TIPC_CMD_SET_LINK_PRI:
case TIPC_CMD_SET_LINK_WINDOW: case TIPC_CMD_SET_LINK_WINDOW:
rep_tlv_buf = tipc_link_cmd_config(req_tlv_area, req_tlv_space, cmd); rep_tlv_buf = tipc_link_cmd_config(net, req_tlv_area,
req_tlv_space, cmd);
break; break;
case TIPC_CMD_ENABLE_BEARER: case TIPC_CMD_ENABLE_BEARER:
rep_tlv_buf = cfg_enable_bearer(net); rep_tlv_buf = cfg_enable_bearer(net);
break; break;
case TIPC_CMD_DISABLE_BEARER: case TIPC_CMD_DISABLE_BEARER:
rep_tlv_buf = cfg_disable_bearer(); rep_tlv_buf = cfg_disable_bearer(net);
break; break;
case TIPC_CMD_SET_NODE_ADDR: case TIPC_CMD_SET_NODE_ADDR:
rep_tlv_buf = cfg_set_own_addr(net); rep_tlv_buf = cfg_set_own_addr(net);

4
net/tipc/core.c
View file

@ -57,12 +57,15 @@ static int __net_init tipc_init_net(struct net *net)
struct tipc_net *tn = net_generic(net, tipc_net_id); struct tipc_net *tn = net_generic(net, tipc_net_id);
tn->net_id = 4711; tn->net_id = 4711;
INIT_LIST_HEAD(&tn->node_list);
spin_lock_init(&tn->node_list_lock);
return 0; return 0;
} }
static void __net_exit tipc_exit_net(struct net *net) static void __net_exit tipc_exit_net(struct net *net)
{ {
tipc_net_stop(net);
} }
static struct pernet_operations tipc_net_ops = { static struct pernet_operations tipc_net_ops = {
@ -144,7 +147,6 @@ static int __init tipc_init(void)
static void __exit tipc_exit(void) static void __exit tipc_exit(void)
{ {
unregister_pernet_subsys(&tipc_net_ops); unregister_pernet_subsys(&tipc_net_ops);
tipc_net_stop();
tipc_bearer_cleanup(); tipc_bearer_cleanup();
tipc_netlink_stop(); tipc_netlink_stop();
tipc_subscr_stop(); tipc_subscr_stop();

9
net/tipc/core.h
View file

@ -59,6 +59,8 @@
#include <linux/etherdevice.h> #include <linux/etherdevice.h>
#include <net/netns/generic.h> #include <net/netns/generic.h>
#include "node.h"
#define TIPC_MOD_VER "2.0.0" #define TIPC_MOD_VER "2.0.0"
int tipc_snprintf(char *buf, int len, const char *fmt, ...); int tipc_snprintf(char *buf, int len, const char *fmt, ...);
@ -78,6 +80,13 @@ extern int tipc_random __read_mostly;
struct tipc_net { struct tipc_net {
int net_id; int net_id;
/* Node table and node list */
spinlock_t node_list_lock;
struct hlist_head node_htable[NODE_HTABLE_SIZE];
struct list_head node_list;
u32 num_nodes;
u32 num_links;
}; };
#ifdef CONFIG_SYSCTL #ifdef CONFIG_SYSCTL

4
net/tipc/discover.c
View file

@ -162,9 +162,9 @@ void tipc_disc_rcv(struct net *net, struct sk_buff *buf,
return; return;
/* Locate, or if necessary, create, node: */ /* Locate, or if necessary, create, node: */
node = tipc_node_find(onode); node = tipc_node_find(net, onode);
if (!node) if (!node)
node = tipc_node_create(onode); node = tipc_node_create(net, onode);
if (!node) if (!node)
return; return;

107
net/tipc/link.c
View file

@ -114,7 +114,8 @@ static void link_reset_statistics(struct tipc_link *l_ptr);
static void link_print(struct tipc_link *l_ptr, const char *str); static void link_print(struct tipc_link *l_ptr, const char *str);
static void tipc_link_sync_xmit(struct tipc_link *l); static void tipc_link_sync_xmit(struct tipc_link *l);
static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf); static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf);
static int tipc_link_input(struct tipc_link *l, struct sk_buff *buf); static int tipc_link_input(struct net *net, struct tipc_link *l,
struct sk_buff *buf);
static int tipc_link_prepare_input(struct net *net, struct tipc_link *l, static int tipc_link_prepare_input(struct net *net, struct tipc_link *l,
struct sk_buff **buf); struct sk_buff **buf);
@ -310,13 +311,15 @@ struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
return l_ptr; return l_ptr;
} }
void tipc_link_delete_list(unsigned int bearer_id, bool shutting_down) void tipc_link_delete_list(struct net *net, unsigned int bearer_id,
bool shutting_down)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_link *l_ptr; struct tipc_link *l_ptr;
struct tipc_node *n_ptr; struct tipc_node *n_ptr;
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) { list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
tipc_node_lock(n_ptr); tipc_node_lock(n_ptr);
l_ptr = n_ptr->links[bearer_id]; l_ptr = n_ptr->links[bearer_id];
if (l_ptr) { if (l_ptr) {
@ -451,13 +454,14 @@ void tipc_link_reset(struct tipc_link *l_ptr)
link_reset_statistics(l_ptr); link_reset_statistics(l_ptr);
} }
void tipc_link_reset_list(unsigned int bearer_id) void tipc_link_reset_list(struct net *net, unsigned int bearer_id)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_link *l_ptr; struct tipc_link *l_ptr;
struct tipc_node *n_ptr; struct tipc_node *n_ptr;
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) { list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
tipc_node_lock(n_ptr); tipc_node_lock(n_ptr);
l_ptr = n_ptr->links[bearer_id]; l_ptr = n_ptr->links[bearer_id];
if (l_ptr) if (l_ptr)
@ -773,16 +777,18 @@ static int __tipc_link_xmit_skb(struct tipc_link *link, struct sk_buff *skb)
return __tipc_link_xmit(link, &head); return __tipc_link_xmit(link, &head);
} }
int tipc_link_xmit_skb(struct sk_buff *skb, u32 dnode, u32 selector) int tipc_link_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode,
u32 selector)
{ {
struct sk_buff_head head; struct sk_buff_head head;
skb2list(skb, &head); skb2list(skb, &head);
return tipc_link_xmit(&head, dnode, selector); return tipc_link_xmit(net, &head, dnode, selector);
} }
/** /**
* tipc_link_xmit() is the general link level function for message sending * tipc_link_xmit() is the general link level function for message sending
* @net: the applicable net namespace
* @list: chain of buffers containing message * @list: chain of buffers containing message
* @dsz: amount of user data to be sent * @dsz: amount of user data to be sent
* @dnode: address of destination node * @dnode: address of destination node
@ -790,13 +796,14 @@ int tipc_link_xmit_skb(struct sk_buff *skb, u32 dnode, u32 selector)
* Consumes the buffer chain, except when returning -ELINKCONG * Consumes the buffer chain, except when returning -ELINKCONG
* Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE * Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE
*/ */
int tipc_link_xmit(struct sk_buff_head *list, u32 dnode, u32 selector) int tipc_link_xmit(struct net *net, struct sk_buff_head *list, u32 dnode,
u32 selector)
{ {
struct tipc_link *link = NULL; struct tipc_link *link = NULL;
struct tipc_node *node; struct tipc_node *node;
int rc = -EHOSTUNREACH; int rc = -EHOSTUNREACH;
node = tipc_node_find(dnode); node = tipc_node_find(net, dnode);
if (node) { if (node) {
tipc_node_lock(node); tipc_node_lock(node);
link = node->active_links[selector & 1]; link = node->active_links[selector & 1];
@ -813,7 +820,7 @@ int tipc_link_xmit(struct sk_buff_head *list, u32 dnode, u32 selector)
* buffer, we just need to dequeue one SKB buffer from the * buffer, we just need to dequeue one SKB buffer from the
* head list. * head list.
*/ */
return tipc_sk_rcv(__skb_dequeue(list)); return tipc_sk_rcv(net, __skb_dequeue(list));
} }
__skb_queue_purge(list); __skb_queue_purge(list);
@ -1066,7 +1073,7 @@ static int link_recv_buf_validate(struct sk_buff *buf)
/** /**
* tipc_rcv - process TIPC packets/messages arriving from off-node * tipc_rcv - process TIPC packets/messages arriving from off-node
* @net: net namespace handler * @net: the applicable net namespace
* @skb: TIPC packet * @skb: TIPC packet
* @b_ptr: pointer to bearer message arrived on * @b_ptr: pointer to bearer message arrived on
* *
@ -1112,7 +1119,7 @@ void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b_ptr)
goto discard; goto discard;
/* Locate neighboring node that sent message */ /* Locate neighboring node that sent message */
n_ptr = tipc_node_find(msg_prevnode(msg)); n_ptr = tipc_node_find(net, msg_prevnode(msg));
if (unlikely(!n_ptr)) if (unlikely(!n_ptr))
goto discard; goto discard;
tipc_node_lock(n_ptr); tipc_node_lock(n_ptr);
@ -1203,7 +1210,7 @@ void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b_ptr)
} }
tipc_node_unlock(n_ptr); tipc_node_unlock(n_ptr);
if (tipc_link_input(l_ptr, skb) != 0) if (tipc_link_input(net, l_ptr, skb) != 0)
goto discard; goto discard;
continue; continue;
unlock_discard: unlock_discard:
@ -1263,7 +1270,8 @@ static int tipc_link_prepare_input(struct net *net, struct tipc_link *l,
/** /**
* tipc_link_input - Deliver message too higher layers * tipc_link_input - Deliver message too higher layers
*/ */
static int tipc_link_input(struct tipc_link *l, struct sk_buff *buf) static int tipc_link_input(struct net *net, struct tipc_link *l,
struct sk_buff *buf)
{ {
struct tipc_msg *msg = buf_msg(buf); struct tipc_msg *msg = buf_msg(buf);
int res = 0; int res = 0;
@ -1274,13 +1282,13 @@ static int tipc_link_input(struct tipc_link *l, struct sk_buff *buf)
case TIPC_HIGH_IMPORTANCE: case TIPC_HIGH_IMPORTANCE:
case TIPC_CRITICAL_IMPORTANCE: case TIPC_CRITICAL_IMPORTANCE:
case CONN_MANAGER: case CONN_MANAGER:
tipc_sk_rcv(buf); tipc_sk_rcv(net, buf);
break; break;
case NAME_DISTRIBUTOR: case NAME_DISTRIBUTOR:
tipc_named_rcv(buf); tipc_named_rcv(net, buf);
break; break;
case MSG_BUNDLER: case MSG_BUNDLER:
tipc_link_bundle_rcv(buf); tipc_link_bundle_rcv(net, buf);
break; break;
default: default:
res = -EINVAL; res = -EINVAL;
@ -1855,7 +1863,7 @@ static int tipc_link_tunnel_rcv(struct net *net, struct tipc_node *n_ptr,
/* /*
* Bundler functionality: * Bundler functionality:
*/ */
void tipc_link_bundle_rcv(struct sk_buff *buf) void tipc_link_bundle_rcv(struct net *net, struct sk_buff *buf)
{ {
u32 msgcount = msg_msgcnt(buf_msg(buf)); u32 msgcount = msg_msgcnt(buf_msg(buf));
u32 pos = INT_H_SIZE; u32 pos = INT_H_SIZE;
@ -1872,13 +1880,13 @@ void tipc_link_bundle_rcv(struct sk_buff *buf)
pos += align(msg_size(omsg)); pos += align(msg_size(omsg));
if (msg_isdata(omsg)) { if (msg_isdata(omsg)) {
if (unlikely(msg_type(omsg) == TIPC_MCAST_MSG)) if (unlikely(msg_type(omsg) == TIPC_MCAST_MSG))
tipc_sk_mcast_rcv(obuf); tipc_sk_mcast_rcv(net, obuf);
else else
tipc_sk_rcv(obuf); tipc_sk_rcv(net, obuf);
} else if (msg_user(omsg) == CONN_MANAGER) { } else if (msg_user(omsg) == CONN_MANAGER) {
tipc_sk_rcv(obuf); tipc_sk_rcv(net, obuf);
} else if (msg_user(omsg) == NAME_DISTRIBUTOR) { } else if (msg_user(omsg) == NAME_DISTRIBUTOR) {
tipc_named_rcv(obuf); tipc_named_rcv(net, obuf);
} else { } else {
pr_warn("Illegal bundled msg: %u\n", msg_user(omsg)); pr_warn("Illegal bundled msg: %u\n", msg_user(omsg));
kfree_skb(obuf); kfree_skb(obuf);
@ -1919,14 +1927,17 @@ void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window)
} }
/* tipc_link_find_owner - locate owner node of link by link's name /* tipc_link_find_owner - locate owner node of link by link's name
* @net: the applicable net namespace
* @name: pointer to link name string * @name: pointer to link name string
* @bearer_id: pointer to index in 'node->links' array where the link was found. * @bearer_id: pointer to index in 'node->links' array where the link was found.
* *
* Returns pointer to node owning the link, or 0 if no matching link is found. * Returns pointer to node owning the link, or 0 if no matching link is found.
*/ */
static struct tipc_node *tipc_link_find_owner(const char *link_name, static struct tipc_node *tipc_link_find_owner(struct net *net,
const char *link_name,
unsigned int *bearer_id) unsigned int *bearer_id)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_link *l_ptr; struct tipc_link *l_ptr;
struct tipc_node *n_ptr; struct tipc_node *n_ptr;
struct tipc_node *found_node = NULL; struct tipc_node *found_node = NULL;
@ -1934,7 +1945,7 @@ static struct tipc_node *tipc_link_find_owner(const char *link_name,
*bearer_id = 0; *bearer_id = 0;
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) { list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
tipc_node_lock(n_ptr); tipc_node_lock(n_ptr);
for (i = 0; i < MAX_BEARERS; i++) { for (i = 0; i < MAX_BEARERS; i++) {
l_ptr = n_ptr->links[i]; l_ptr = n_ptr->links[i];
@ -1978,6 +1989,7 @@ static int link_value_is_valid(u16 cmd, u32 new_value)
/** /**
* link_cmd_set_value - change priority/tolerance/window for link/bearer/media * link_cmd_set_value - change priority/tolerance/window for link/bearer/media
* @net: the applicable net namespace
* @name: ptr to link, bearer, or media name * @name: ptr to link, bearer, or media name
* @new_value: new value of link, bearer, or media setting * @new_value: new value of link, bearer, or media setting
* @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*) * @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*)
@ -1986,7 +1998,8 @@ static int link_value_is_valid(u16 cmd, u32 new_value)
* *
* Returns 0 if value updated and negative value on error. * Returns 0 if value updated and negative value on error.
*/ */
static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd) static int link_cmd_set_value(struct net *net, const char *name, u32 new_value,
u16 cmd)
{ {
struct tipc_node *node; struct tipc_node *node;
struct tipc_link *l_ptr; struct tipc_link *l_ptr;
@ -1995,7 +2008,7 @@ static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd)
int bearer_id; int bearer_id;
int res = 0; int res = 0;
node = tipc_link_find_owner(name, &bearer_id); node = tipc_link_find_owner(net, name, &bearer_id);
if (node) { if (node) {
tipc_node_lock(node); tipc_node_lock(node);
l_ptr = node->links[bearer_id]; l_ptr = node->links[bearer_id];
@ -2063,8 +2076,8 @@ static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd)
return res; return res;
} }
struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space, struct sk_buff *tipc_link_cmd_config(struct net *net, const void *req_tlv_area,
u16 cmd) int req_tlv_space, u16 cmd)
{ {
struct tipc_link_config *args; struct tipc_link_config *args;
u32 new_value; u32 new_value;
@ -2088,7 +2101,7 @@ struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space
" (cannot change setting on broadcast link)"); " (cannot change setting on broadcast link)");
} }
res = link_cmd_set_value(args->name, new_value, cmd); res = link_cmd_set_value(net, args->name, new_value, cmd);
if (res) if (res)
return tipc_cfg_reply_error_string("cannot change link setting"); return tipc_cfg_reply_error_string("cannot change link setting");
@ -2106,7 +2119,9 @@ static void link_reset_statistics(struct tipc_link *l_ptr)
l_ptr->stats.recv_info = l_ptr->next_in_no; l_ptr->stats.recv_info = l_ptr->next_in_no;
} }
struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space) struct sk_buff *tipc_link_cmd_reset_stats(struct net *net,
const void *req_tlv_area,
int req_tlv_space)
{ {
char *link_name; char *link_name;
struct tipc_link *l_ptr; struct tipc_link *l_ptr;
@ -2122,7 +2137,7 @@ struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_
return tipc_cfg_reply_error_string("link not found"); return tipc_cfg_reply_error_string("link not found");
return tipc_cfg_reply_none(); return tipc_cfg_reply_none();
} }
node = tipc_link_find_owner(link_name, &bearer_id); node = tipc_link_find_owner(net, link_name, &bearer_id);
if (!node) if (!node)
return tipc_cfg_reply_error_string("link not found"); return tipc_cfg_reply_error_string("link not found");
@ -2147,13 +2162,15 @@ static u32 percent(u32 count, u32 total)
/** /**
* tipc_link_stats - print link statistics * tipc_link_stats - print link statistics
* @net: the applicable net namespace
* @name: link name * @name: link name
* @buf: print buffer area * @buf: print buffer area
* @buf_size: size of print buffer area * @buf_size: size of print buffer area
* *
* Returns length of print buffer data string (or 0 if error) * Returns length of print buffer data string (or 0 if error)
*/ */
static int tipc_link_stats(const char *name, char *buf, const u32 buf_size) static int tipc_link_stats(struct net *net, const char *name, char *buf,
const u32 buf_size)
{ {
struct tipc_link *l; struct tipc_link *l;
struct tipc_stats *s; struct tipc_stats *s;
@ -2166,7 +2183,7 @@ static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
if (!strcmp(name, tipc_bclink_name)) if (!strcmp(name, tipc_bclink_name))
return tipc_bclink_stats(buf, buf_size); return tipc_bclink_stats(buf, buf_size);
node = tipc_link_find_owner(name, &bearer_id); node = tipc_link_find_owner(net, name, &bearer_id);
if (!node) if (!node)
return 0; return 0;
@ -2243,7 +2260,9 @@ static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
return ret; return ret;
} }
struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space) struct sk_buff *tipc_link_cmd_show_stats(struct net *net,
const void *req_tlv_area,
int req_tlv_space)
{ {
struct sk_buff *buf; struct sk_buff *buf;
struct tlv_desc *rep_tlv; struct tlv_desc *rep_tlv;
@ -2261,7 +2280,7 @@ struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_s
rep_tlv = (struct tlv_desc *)buf->data; rep_tlv = (struct tlv_desc *)buf->data;
pb = TLV_DATA(rep_tlv); pb = TLV_DATA(rep_tlv);
pb_len = ULTRA_STRING_MAX_LEN; pb_len = ULTRA_STRING_MAX_LEN;
str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area), str_len = tipc_link_stats(net, (char *)TLV_DATA(req_tlv_area),
pb, pb_len); pb, pb_len);
if (!str_len) { if (!str_len) {
kfree_skb(buf); kfree_skb(buf);
@ -2343,6 +2362,7 @@ int tipc_nl_link_set(struct sk_buff *skb, struct genl_info *info)
struct tipc_link *link; struct tipc_link *link;
struct tipc_node *node; struct tipc_node *node;
struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
struct net *net = genl_info_net(info);
if (!info->attrs[TIPC_NLA_LINK]) if (!info->attrs[TIPC_NLA_LINK])
return -EINVAL; return -EINVAL;
@ -2358,7 +2378,7 @@ int tipc_nl_link_set(struct sk_buff *skb, struct genl_info *info)
name = nla_data(attrs[TIPC_NLA_LINK_NAME]); name = nla_data(attrs[TIPC_NLA_LINK_NAME]);
node = tipc_link_find_owner(name, &bearer_id); node = tipc_link_find_owner(net, name, &bearer_id);
if (!node) if (!node)
return -EINVAL; return -EINVAL;
@ -2567,6 +2587,8 @@ static int __tipc_nl_add_node_links(struct tipc_nl_msg *msg,
int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb) int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb)
{ {
struct net *net = sock_net(skb->sk);
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_node *node; struct tipc_node *node;
struct tipc_nl_msg msg; struct tipc_nl_msg msg;
u32 prev_node = cb->args[0]; u32 prev_node = cb->args[0];
@ -2584,7 +2606,7 @@ int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb)
rcu_read_lock(); rcu_read_lock();
if (prev_node) { if (prev_node) {
node = tipc_node_find(prev_node); node = tipc_node_find(net, prev_node);
if (!node) { if (!node) {
/* We never set seq or call nl_dump_check_consistent() /* We never set seq or call nl_dump_check_consistent()
* this means that setting prev_seq here will cause the * this means that setting prev_seq here will cause the
@ -2596,7 +2618,8 @@ int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb)
goto out; goto out;
} }
list_for_each_entry_continue_rcu(node, &tipc_node_list, list) { list_for_each_entry_continue_rcu(node, &tn->node_list,
list) {
tipc_node_lock(node); tipc_node_lock(node);
err = __tipc_nl_add_node_links(&msg, node, &prev_link); err = __tipc_nl_add_node_links(&msg, node, &prev_link);
tipc_node_unlock(node); tipc_node_unlock(node);
@ -2610,7 +2633,7 @@ int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb)
if (err) if (err)
goto out; goto out;
list_for_each_entry_rcu(node, &tipc_node_list, list) { list_for_each_entry_rcu(node, &tn->node_list, list) {
tipc_node_lock(node); tipc_node_lock(node);
err = __tipc_nl_add_node_links(&msg, node, &prev_link); err = __tipc_nl_add_node_links(&msg, node, &prev_link);
tipc_node_unlock(node); tipc_node_unlock(node);
@ -2633,6 +2656,7 @@ int tipc_nl_link_dump(struct sk_buff *skb, struct netlink_callback *cb)
int tipc_nl_link_get(struct sk_buff *skb, struct genl_info *info) int tipc_nl_link_get(struct sk_buff *skb, struct genl_info *info)
{ {
struct net *net = genl_info_net(info);
struct sk_buff *ans_skb; struct sk_buff *ans_skb;
struct tipc_nl_msg msg; struct tipc_nl_msg msg;
struct tipc_link *link; struct tipc_link *link;
@ -2645,7 +2669,7 @@ int tipc_nl_link_get(struct sk_buff *skb, struct genl_info *info)
return -EINVAL; return -EINVAL;
name = nla_data(info->attrs[TIPC_NLA_LINK_NAME]); name = nla_data(info->attrs[TIPC_NLA_LINK_NAME]);
node = tipc_link_find_owner(name, &bearer_id); node = tipc_link_find_owner(net, name, &bearer_id);
if (!node) if (!node)
return -EINVAL; return -EINVAL;
@ -2687,6 +2711,7 @@ int tipc_nl_link_reset_stats(struct sk_buff *skb, struct genl_info *info)
struct tipc_link *link; struct tipc_link *link;
struct tipc_node *node; struct tipc_node *node;
struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];
struct net *net = genl_info_net(info);
if (!info->attrs[TIPC_NLA_LINK]) if (!info->attrs[TIPC_NLA_LINK])
return -EINVAL; return -EINVAL;
@ -2709,7 +2734,7 @@ int tipc_nl_link_reset_stats(struct sk_buff *skb, struct genl_info *info)
return 0; return 0;
} }
node = tipc_link_find_owner(link_name, &bearer_id); node = tipc_link_find_owner(net, link_name, &bearer_id);
if (!node) if (!node)
return -EINVAL; return -EINVAL;

24
net/tipc/link.h
View file

@ -200,27 +200,31 @@ struct tipc_port;
struct tipc_link *tipc_link_create(struct tipc_node *n_ptr, struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
struct tipc_bearer *b_ptr, struct tipc_bearer *b_ptr,
const struct tipc_media_addr *media_addr); const struct tipc_media_addr *media_addr);
void tipc_link_delete_list(unsigned int bearer_id, bool shutting_down); void tipc_link_delete_list(struct net *net, unsigned int bearer_id,
bool shutting_down);
void tipc_link_failover_send_queue(struct tipc_link *l_ptr); void tipc_link_failover_send_queue(struct tipc_link *l_ptr);
void tipc_link_dup_queue_xmit(struct tipc_link *l_ptr, struct tipc_link *dest); void tipc_link_dup_queue_xmit(struct tipc_link *l_ptr, struct tipc_link *dest);
void tipc_link_reset_fragments(struct tipc_link *l_ptr); void tipc_link_reset_fragments(struct tipc_link *l_ptr);
int tipc_link_is_up(struct tipc_link *l_ptr); int tipc_link_is_up(struct tipc_link *l_ptr);
int tipc_link_is_active(struct tipc_link *l_ptr); int tipc_link_is_active(struct tipc_link *l_ptr);
void tipc_link_purge_queues(struct tipc_link *l_ptr); void tipc_link_purge_queues(struct tipc_link *l_ptr);
struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, struct sk_buff *tipc_link_cmd_config(struct net *net, const void *req_tlv_area,
int req_tlv_space, int req_tlv_space, u16 cmd);
u16 cmd); struct sk_buff *tipc_link_cmd_show_stats(struct net *net,
struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, const void *req_tlv_area,
int req_tlv_space); int req_tlv_space);
struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, struct sk_buff *tipc_link_cmd_reset_stats(struct net *net,
const void *req_tlv_area,
int req_tlv_space); int req_tlv_space);
void tipc_link_reset_all(struct tipc_node *node); void tipc_link_reset_all(struct tipc_node *node);
void tipc_link_reset(struct tipc_link *l_ptr); void tipc_link_reset(struct tipc_link *l_ptr);
void tipc_link_reset_list(unsigned int bearer_id); void tipc_link_reset_list(struct net *net, unsigned int bearer_id);
int tipc_link_xmit_skb(struct sk_buff *skb, u32 dest, u32 selector); int tipc_link_xmit_skb(struct net *net, struct sk_buff *skb, u32 dest,
int tipc_link_xmit(struct sk_buff_head *list, u32 dest, u32 selector); u32 selector);
int tipc_link_xmit(struct net *net, struct sk_buff_head *list, u32 dest,
u32 selector);
int __tipc_link_xmit(struct tipc_link *link, struct sk_buff_head *list); int __tipc_link_xmit(struct tipc_link *link, struct sk_buff_head *list);
void tipc_link_bundle_rcv(struct sk_buff *buf); void tipc_link_bundle_rcv(struct net *net, struct sk_buff *buf);
void tipc_link_proto_xmit(struct tipc_link *l_ptr, u32 msg_typ, int prob, void tipc_link_proto_xmit(struct tipc_link *l_ptr, u32 msg_typ, int prob,
u32 gap, u32 tolerance, u32 priority, u32 acked_mtu); u32 gap, u32 tolerance, u32 priority, u32 acked_mtu);
void tipc_link_push_packets(struct tipc_link *l_ptr); void tipc_link_push_packets(struct tipc_link *l_ptr);

57
net/tipc/name_distr.c
View file

@ -81,14 +81,15 @@ static struct sk_buff *named_prepare_buf(u32 type, u32 size, u32 dest)
return buf; return buf;
} }
void named_cluster_distribute(struct sk_buff *skb) void named_cluster_distribute(struct net *net, struct sk_buff *skb)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct sk_buff *oskb; struct sk_buff *oskb;
struct tipc_node *node; struct tipc_node *node;
u32 dnode; u32 dnode;
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(node, &tipc_node_list, list) { list_for_each_entry_rcu(node, &tn->node_list, list) {
dnode = node->addr; dnode = node->addr;
if (in_own_node(dnode)) if (in_own_node(dnode))
continue; continue;
@ -98,7 +99,7 @@ void named_cluster_distribute(struct sk_buff *skb)
if (!oskb) if (!oskb)
break; break;
msg_set_destnode(buf_msg(oskb), dnode); msg_set_destnode(buf_msg(oskb), dnode);
tipc_link_xmit_skb(oskb, dnode, dnode); tipc_link_xmit_skb(net, oskb, dnode, dnode);
} }
rcu_read_unlock(); rcu_read_unlock();
@ -160,13 +161,14 @@ struct sk_buff *tipc_named_withdraw(struct publication *publ)
* @dnode: node to be updated * @dnode: node to be updated
* @pls: linked list of publication items to be packed into buffer chain * @pls: linked list of publication items to be packed into buffer chain
*/ */
static void named_distribute(struct sk_buff_head *list, u32 dnode, static void named_distribute(struct net *net, struct sk_buff_head *list,
struct list_head *pls) u32 dnode, struct list_head *pls)
{ {
struct publication *publ; struct publication *publ;
struct sk_buff *skb = NULL; struct sk_buff *skb = NULL;
struct distr_item *item = NULL; struct distr_item *item = NULL;
uint msg_dsz = (tipc_node_get_mtu(dnode, 0) / ITEM_SIZE) * ITEM_SIZE; uint msg_dsz = (tipc_node_get_mtu(net, dnode, 0) / ITEM_SIZE) *
ITEM_SIZE;
uint msg_rem = msg_dsz; uint msg_rem = msg_dsz;
list_for_each_entry(publ, pls, local_list) { list_for_each_entry(publ, pls, local_list) {
@ -202,30 +204,31 @@ static void named_distribute(struct sk_buff_head *list, u32 dnode,
/** /**
* tipc_named_node_up - tell specified node about all publications by this node * tipc_named_node_up - tell specified node about all publications by this node
*/ */
void tipc_named_node_up(u32 dnode) void tipc_named_node_up(struct net *net, u32 dnode)
{ {
struct sk_buff_head head; struct sk_buff_head head;
__skb_queue_head_init(&head); __skb_queue_head_init(&head);
rcu_read_lock(); rcu_read_lock();
named_distribute(&head, dnode, named_distribute(net, &head, dnode,
&tipc_nametbl->publ_list[TIPC_CLUSTER_SCOPE]); &tipc_nametbl->publ_list[TIPC_CLUSTER_SCOPE]);
named_distribute(&head, dnode, named_distribute(net, &head, dnode,
&tipc_nametbl->publ_list[TIPC_ZONE_SCOPE]); &tipc_nametbl->publ_list[TIPC_ZONE_SCOPE]);
rcu_read_unlock(); rcu_read_unlock();
tipc_link_xmit(&head, dnode, dnode); tipc_link_xmit(net, &head, dnode, dnode);
} }
static void tipc_publ_subscribe(struct publication *publ, u32 addr) static void tipc_publ_subscribe(struct net *net, struct publication *publ,
u32 addr)
{ {
struct tipc_node *node; struct tipc_node *node;
if (in_own_node(addr)) if (in_own_node(addr))
return; return;
node = tipc_node_find(addr); node = tipc_node_find(net, addr);
if (!node) { if (!node) {
pr_warn("Node subscription rejected, unknown node 0x%x\n", pr_warn("Node subscription rejected, unknown node 0x%x\n",
addr); addr);
@ -237,11 +240,12 @@ static void tipc_publ_subscribe(struct publication *publ, u32 addr)
tipc_node_unlock(node); tipc_node_unlock(node);
} }
static void tipc_publ_unsubscribe(struct publication *publ, u32 addr) static void tipc_publ_unsubscribe(struct net *net, struct publication *publ,
u32 addr)
{ {
struct tipc_node *node; struct tipc_node *node;
node = tipc_node_find(addr); node = tipc_node_find(net, addr);
if (!node) if (!node)
return; return;
@ -256,7 +260,7 @@ static void tipc_publ_unsubscribe(struct publication *publ, u32 addr)
* Invoked for each publication issued by a newly failed node. * Invoked for each publication issued by a newly failed node.
* Removes publication structure from name table & deletes it. * Removes publication structure from name table & deletes it.
*/ */
static void tipc_publ_purge(struct publication *publ, u32 addr) static void tipc_publ_purge(struct net *net, struct publication *publ, u32 addr)
{ {
struct publication *p; struct publication *p;
@ -264,7 +268,7 @@ static void tipc_publ_purge(struct publication *publ, u32 addr)
p = tipc_nametbl_remove_publ(publ->type, publ->lower, p = tipc_nametbl_remove_publ(publ->type, publ->lower,
publ->node, publ->ref, publ->key); publ->node, publ->ref, publ->key);
if (p) if (p)
tipc_publ_unsubscribe(p, addr); tipc_publ_unsubscribe(net, p, addr);
spin_unlock_bh(&tipc_nametbl_lock); spin_unlock_bh(&tipc_nametbl_lock);
if (p != publ) { if (p != publ) {
@ -277,12 +281,12 @@ static void tipc_publ_purge(struct publication *publ, u32 addr)
kfree_rcu(p, rcu); kfree_rcu(p, rcu);
} }
void tipc_publ_notify(struct list_head *nsub_list, u32 addr) void tipc_publ_notify(struct net *net, struct list_head *nsub_list, u32 addr)
{ {
struct publication *publ, *tmp; struct publication *publ, *tmp;
list_for_each_entry_safe(publ, tmp, nsub_list, nodesub_list) list_for_each_entry_safe(publ, tmp, nsub_list, nodesub_list)
tipc_publ_purge(publ, addr); tipc_publ_purge(net, publ, addr);
} }
/** /**
@ -292,7 +296,8 @@ void tipc_publ_notify(struct list_head *nsub_list, u32 addr)
* tipc_nametbl_lock must be held. * tipc_nametbl_lock must be held.
* Returns the publication item if successful, otherwise NULL. * Returns the publication item if successful, otherwise NULL.
*/ */
static bool tipc_update_nametbl(struct distr_item *i, u32 node, u32 dtype) static bool tipc_update_nametbl(struct net *net, struct distr_item *i,
u32 node, u32 dtype)
{ {
struct publication *publ = NULL; struct publication *publ = NULL;
@ -302,7 +307,7 @@ static bool tipc_update_nametbl(struct distr_item *i, u32 node, u32 dtype)
TIPC_CLUSTER_SCOPE, node, TIPC_CLUSTER_SCOPE, node,
ntohl(i->ref), ntohl(i->key)); ntohl(i->ref), ntohl(i->key));
if (publ) { if (publ) {
tipc_publ_subscribe(publ, node); tipc_publ_subscribe(net, publ, node);
return true; return true;
} }
} else if (dtype == WITHDRAWAL) { } else if (dtype == WITHDRAWAL) {
@ -310,7 +315,7 @@ static bool tipc_update_nametbl(struct distr_item *i, u32 node, u32 dtype)
node, ntohl(i->ref), node, ntohl(i->ref),
ntohl(i->key)); ntohl(i->key));
if (publ) { if (publ) {
tipc_publ_unsubscribe(publ, node); tipc_publ_unsubscribe(net, publ, node);
kfree_rcu(publ, rcu); kfree_rcu(publ, rcu);
return true; return true;
} }
@ -343,7 +348,7 @@ static void tipc_named_add_backlog(struct distr_item *i, u32 type, u32 node)
* tipc_named_process_backlog - try to process any pending name table updates * tipc_named_process_backlog - try to process any pending name table updates
* from the network. * from the network.
*/ */
void tipc_named_process_backlog(void) void tipc_named_process_backlog(struct net *net)
{ {
struct distr_queue_item *e, *tmp; struct distr_queue_item *e, *tmp;
char addr[16]; char addr[16];
@ -351,7 +356,7 @@ void tipc_named_process_backlog(void)
list_for_each_entry_safe(e, tmp, &tipc_dist_queue, next) { list_for_each_entry_safe(e, tmp, &tipc_dist_queue, next) {
if (time_after(e->expires, now)) { if (time_after(e->expires, now)) {
if (!tipc_update_nametbl(&e->i, e->node, e->dtype)) if (!tipc_update_nametbl(net, &e->i, e->node, e->dtype))
continue; continue;
} else { } else {
tipc_addr_string_fill(addr, e->node); tipc_addr_string_fill(addr, e->node);
@ -369,7 +374,7 @@ void tipc_named_process_backlog(void)
/** /**
* tipc_named_rcv - process name table update message sent by another node * tipc_named_rcv - process name table update message sent by another node
*/ */
void tipc_named_rcv(struct sk_buff *buf) void tipc_named_rcv(struct net *net, struct sk_buff *buf)
{ {
struct tipc_msg *msg = buf_msg(buf); struct tipc_msg *msg = buf_msg(buf);
struct distr_item *item = (struct distr_item *)msg_data(msg); struct distr_item *item = (struct distr_item *)msg_data(msg);
@ -378,11 +383,11 @@ void tipc_named_rcv(struct sk_buff *buf)
spin_lock_bh(&tipc_nametbl_lock); spin_lock_bh(&tipc_nametbl_lock);
while (count--) { while (count--) {
if (!tipc_update_nametbl(item, node, msg_type(msg))) if (!tipc_update_nametbl(net, item, node, msg_type(msg)))
tipc_named_add_backlog(item, msg_type(msg), node); tipc_named_add_backlog(item, msg_type(msg), node);
item++; item++;
} }
tipc_named_process_backlog(); tipc_named_process_backlog(net);
spin_unlock_bh(&tipc_nametbl_lock); spin_unlock_bh(&tipc_nametbl_lock);
kfree_skb(buf); kfree_skb(buf);
} }

10
net/tipc/name_distr.h
View file

@ -69,11 +69,11 @@ struct distr_item {
struct sk_buff *tipc_named_publish(struct publication *publ); struct sk_buff *tipc_named_publish(struct publication *publ);
struct sk_buff *tipc_named_withdraw(struct publication *publ); struct sk_buff *tipc_named_withdraw(struct publication *publ);
void named_cluster_distribute(struct sk_buff *buf); void named_cluster_distribute(struct net *net, struct sk_buff *buf);
void tipc_named_node_up(u32 dnode); void tipc_named_node_up(struct net *net, u32 dnode);
void tipc_named_rcv(struct sk_buff *buf); void tipc_named_rcv(struct net *net, struct sk_buff *buf);
void tipc_named_reinit(void); void tipc_named_reinit(void);
void tipc_named_process_backlog(void); void tipc_named_process_backlog(struct net *net);
void tipc_publ_notify(struct list_head *nsub_list, u32 addr); void tipc_publ_notify(struct net *net, struct list_head *nsub_list, u32 addr);
#endif #endif

16
net/tipc/name_table.c
View file

@ -650,8 +650,9 @@ int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
/* /*
* tipc_nametbl_publish - add name publication to network name tables * tipc_nametbl_publish - add name publication to network name tables
*/ */
struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper, struct publication *tipc_nametbl_publish(struct net *net, u32 type, u32 lower,
u32 scope, u32 port_ref, u32 key) u32 upper, u32 scope, u32 port_ref,
u32 key)
{ {
struct publication *publ; struct publication *publ;
struct sk_buff *buf = NULL; struct sk_buff *buf = NULL;
@ -670,19 +671,20 @@ struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper,
tipc_nametbl->local_publ_count++; tipc_nametbl->local_publ_count++;
buf = tipc_named_publish(publ); buf = tipc_named_publish(publ);
/* Any pending external events? */ /* Any pending external events? */
tipc_named_process_backlog(); tipc_named_process_backlog(net);
} }
spin_unlock_bh(&tipc_nametbl_lock); spin_unlock_bh(&tipc_nametbl_lock);
if (buf) if (buf)
named_cluster_distribute(buf); named_cluster_distribute(net, buf);
return publ; return publ;
} }
/** /**
* tipc_nametbl_withdraw - withdraw name publication from network name tables * tipc_nametbl_withdraw - withdraw name publication from network name tables
*/ */
int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key) int tipc_nametbl_withdraw(struct net *net, u32 type, u32 lower, u32 ref,
u32 key)
{ {
struct publication *publ; struct publication *publ;
struct sk_buff *skb = NULL; struct sk_buff *skb = NULL;
@ -693,7 +695,7 @@ int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
tipc_nametbl->local_publ_count--; tipc_nametbl->local_publ_count--;
skb = tipc_named_withdraw(publ); skb = tipc_named_withdraw(publ);
/* Any pending external events? */ /* Any pending external events? */
tipc_named_process_backlog(); tipc_named_process_backlog(net);
list_del_init(&publ->pport_list); list_del_init(&publ->pport_list);
kfree_rcu(publ, rcu); kfree_rcu(publ, rcu);
} else { } else {
@ -704,7 +706,7 @@ int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
spin_unlock_bh(&tipc_nametbl_lock); spin_unlock_bh(&tipc_nametbl_lock);
if (skb) { if (skb) {
named_cluster_distribute(skb); named_cluster_distribute(net, skb);
return 1; return 1;
} }
return 0; return 0;

8
net/tipc/name_table.h
View file

@ -104,9 +104,11 @@ struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space);
u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *node); u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *node);
int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit, int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
struct tipc_port_list *dports); struct tipc_port_list *dports);
struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper, struct publication *tipc_nametbl_publish(struct net *net, u32 type, u32 lower,
u32 scope, u32 port_ref, u32 key); u32 upper, u32 scope, u32 port_ref,
int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key); u32 key);
int tipc_nametbl_withdraw(struct net *net, u32 type, u32 lower, u32 ref,
u32 key);
struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper, struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
u32 scope, u32 node, u32 ref, u32 scope, u32 node, u32 ref,
u32 key); u32 key);

11
net/tipc/net.c
View file

@ -121,7 +121,7 @@ int tipc_net_start(struct net *net, u32 addr)
if (res) if (res)
return res; return res;
tipc_nametbl_publish(TIPC_CFG_SRV, tipc_own_addr, tipc_own_addr, tipc_nametbl_publish(net, TIPC_CFG_SRV, tipc_own_addr, tipc_own_addr,
TIPC_ZONE_SCOPE, 0, tipc_own_addr); TIPC_ZONE_SCOPE, 0, tipc_own_addr);
pr_info("Started in network mode\n"); pr_info("Started in network mode\n");
@ -131,16 +131,17 @@ int tipc_net_start(struct net *net, u32 addr)
return 0; return 0;
} }
void tipc_net_stop(void) void tipc_net_stop(struct net *net)
{ {
if (!tipc_own_addr) if (!tipc_own_addr)
return; return;
tipc_nametbl_withdraw(TIPC_CFG_SRV, tipc_own_addr, 0, tipc_own_addr); tipc_nametbl_withdraw(net, TIPC_CFG_SRV, tipc_own_addr, 0,
tipc_own_addr);
rtnl_lock(); rtnl_lock();
tipc_bearer_stop(); tipc_bearer_stop(net);
tipc_bclink_stop(); tipc_bclink_stop();
tipc_node_stop(); tipc_node_stop(net);
rtnl_unlock(); rtnl_unlock();
pr_info("Left network mode\n"); pr_info("Left network mode\n");

2
net/tipc/net.h
View file

@ -41,7 +41,7 @@
int tipc_net_start(struct net *net, u32 addr); int tipc_net_start(struct net *net, u32 addr);
void tipc_net_stop(void); void tipc_net_stop(struct net *net);
int tipc_nl_net_dump(struct sk_buff *skb, struct netlink_callback *cb); 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);

130
net/tipc/node.c
View file

@ -40,17 +40,9 @@
#include "name_distr.h" #include "name_distr.h"
#include "socket.h" #include "socket.h"
#define NODE_HTABLE_SIZE 512
static void node_lost_contact(struct tipc_node *n_ptr); static void node_lost_contact(struct tipc_node *n_ptr);
static void node_established_contact(struct tipc_node *n_ptr); static void node_established_contact(struct tipc_node *n_ptr);
static struct hlist_head node_htable[NODE_HTABLE_SIZE];
LIST_HEAD(tipc_node_list);
static u32 tipc_num_nodes;
static u32 tipc_num_links;
static DEFINE_SPINLOCK(node_list_lock);
struct tipc_sock_conn { struct tipc_sock_conn {
u32 port; u32 port;
u32 peer_port; u32 peer_port;
@ -78,15 +70,17 @@ static unsigned int tipc_hashfn(u32 addr)
/* /*
* tipc_node_find - locate specified node object, if it exists * tipc_node_find - locate specified node object, if it exists
*/ */
struct tipc_node *tipc_node_find(u32 addr) struct tipc_node *tipc_node_find(struct net *net, u32 addr)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_node *node; struct tipc_node *node;
if (unlikely(!in_own_cluster_exact(addr))) if (unlikely(!in_own_cluster_exact(addr)))
return NULL; return NULL;
rcu_read_lock(); rcu_read_lock();
hlist_for_each_entry_rcu(node, &node_htable[tipc_hashfn(addr)], hash) { hlist_for_each_entry_rcu(node, &tn->node_htable[tipc_hashfn(addr)],
hash) {
if (node->addr == addr) { if (node->addr == addr) {
rcu_read_unlock(); rcu_read_unlock();
return node; return node;
@ -96,20 +90,22 @@ struct tipc_node *tipc_node_find(u32 addr)
return NULL; return NULL;
} }
struct tipc_node *tipc_node_create(u32 addr) struct tipc_node *tipc_node_create(struct net *net, u32 addr)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_node *n_ptr, *temp_node; struct tipc_node *n_ptr, *temp_node;
spin_lock_bh(&node_list_lock); spin_lock_bh(&tn->node_list_lock);
n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC); n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
if (!n_ptr) { if (!n_ptr) {
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
pr_warn("Node creation failed, no memory\n"); pr_warn("Node creation failed, no memory\n");
return NULL; return NULL;
} }
n_ptr->addr = addr; n_ptr->addr = addr;
n_ptr->net = net;
spin_lock_init(&n_ptr->lock); spin_lock_init(&n_ptr->lock);
INIT_HLIST_NODE(&n_ptr->hash); INIT_HLIST_NODE(&n_ptr->hash);
INIT_LIST_HEAD(&n_ptr->list); INIT_LIST_HEAD(&n_ptr->list);
@ -118,9 +114,9 @@ struct tipc_node *tipc_node_create(u32 addr)
skb_queue_head_init(&n_ptr->waiting_sks); skb_queue_head_init(&n_ptr->waiting_sks);
__skb_queue_head_init(&n_ptr->bclink.deferred_queue); __skb_queue_head_init(&n_ptr->bclink.deferred_queue);
hlist_add_head_rcu(&n_ptr->hash, &node_htable[tipc_hashfn(addr)]); hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]);
list_for_each_entry_rcu(temp_node, &tipc_node_list, list) { list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
if (n_ptr->addr < temp_node->addr) if (n_ptr->addr < temp_node->addr)
break; break;
} }
@ -128,32 +124,33 @@ struct tipc_node *tipc_node_create(u32 addr)
n_ptr->action_flags = TIPC_WAIT_PEER_LINKS_DOWN; n_ptr->action_flags = TIPC_WAIT_PEER_LINKS_DOWN;
n_ptr->signature = INVALID_NODE_SIG; n_ptr->signature = INVALID_NODE_SIG;
tipc_num_nodes++; tn->num_nodes++;
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
return n_ptr; return n_ptr;
} }
static void tipc_node_delete(struct tipc_node *n_ptr) static void tipc_node_delete(struct tipc_net *tn, struct tipc_node *n_ptr)
{ {
list_del_rcu(&n_ptr->list); list_del_rcu(&n_ptr->list);
hlist_del_rcu(&n_ptr->hash); hlist_del_rcu(&n_ptr->hash);
kfree_rcu(n_ptr, rcu); kfree_rcu(n_ptr, rcu);
tipc_num_nodes--; tn->num_nodes--;
} }
void tipc_node_stop(void) void tipc_node_stop(struct net *net)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_node *node, *t_node; struct tipc_node *node, *t_node;
spin_lock_bh(&node_list_lock); spin_lock_bh(&tn->node_list_lock);
list_for_each_entry_safe(node, t_node, &tipc_node_list, list) list_for_each_entry_safe(node, t_node, &tn->node_list, list)
tipc_node_delete(node); tipc_node_delete(tn, node);
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
} }
int tipc_node_add_conn(u32 dnode, u32 port, u32 peer_port) int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
{ {
struct tipc_node *node; struct tipc_node *node;
struct tipc_sock_conn *conn; struct tipc_sock_conn *conn;
@ -161,7 +158,7 @@ int tipc_node_add_conn(u32 dnode, u32 port, u32 peer_port)
if (in_own_node(dnode)) if (in_own_node(dnode))
return 0; return 0;
node = tipc_node_find(dnode); node = tipc_node_find(net, dnode);
if (!node) { if (!node) {
pr_warn("Connecting sock to node 0x%x failed\n", dnode); pr_warn("Connecting sock to node 0x%x failed\n", dnode);
return -EHOSTUNREACH; return -EHOSTUNREACH;
@ -179,7 +176,7 @@ int tipc_node_add_conn(u32 dnode, u32 port, u32 peer_port)
return 0; return 0;
} }
void tipc_node_remove_conn(u32 dnode, u32 port) void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
{ {
struct tipc_node *node; struct tipc_node *node;
struct tipc_sock_conn *conn, *safe; struct tipc_sock_conn *conn, *safe;
@ -187,7 +184,7 @@ void tipc_node_remove_conn(u32 dnode, u32 port)
if (in_own_node(dnode)) if (in_own_node(dnode))
return; return;
node = tipc_node_find(dnode); node = tipc_node_find(net, dnode);
if (!node) if (!node)
return; return;
@ -201,7 +198,7 @@ void tipc_node_remove_conn(u32 dnode, u32 port)
tipc_node_unlock(node); tipc_node_unlock(node);
} }
void tipc_node_abort_sock_conns(struct list_head *conns) void tipc_node_abort_sock_conns(struct net *net, struct list_head *conns)
{ {
struct tipc_sock_conn *conn, *safe; struct tipc_sock_conn *conn, *safe;
struct sk_buff *buf; struct sk_buff *buf;
@ -212,7 +209,7 @@ void tipc_node_abort_sock_conns(struct list_head *conns)
conn->peer_node, conn->port, conn->peer_node, conn->port,
conn->peer_port, TIPC_ERR_NO_NODE); conn->peer_port, TIPC_ERR_NO_NODE);
if (likely(buf)) if (likely(buf))
tipc_sk_rcv(buf); tipc_sk_rcv(net, buf);
list_del(&conn->list); list_del(&conn->list);
kfree(conn); kfree(conn);
} }
@ -342,24 +339,27 @@ int tipc_node_is_up(struct tipc_node *n_ptr)
void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr) void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
{ {
struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
n_ptr->links[l_ptr->bearer_id] = l_ptr; n_ptr->links[l_ptr->bearer_id] = l_ptr;
spin_lock_bh(&node_list_lock); spin_lock_bh(&tn->node_list_lock);
tipc_num_links++; tn->num_links++;
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
n_ptr->link_cnt++; n_ptr->link_cnt++;
} }
void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr) void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr)
{ {
struct tipc_net *tn = net_generic(n_ptr->net, tipc_net_id);
int i; int i;
for (i = 0; i < MAX_BEARERS; i++) { for (i = 0; i < MAX_BEARERS; i++) {
if (l_ptr != n_ptr->links[i]) if (l_ptr != n_ptr->links[i])
continue; continue;
n_ptr->links[i] = NULL; n_ptr->links[i] = NULL;
spin_lock_bh(&node_list_lock); spin_lock_bh(&tn->node_list_lock);
tipc_num_links--; tn->num_links--;
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
n_ptr->link_cnt--; n_ptr->link_cnt--;
} }
} }
@ -414,8 +414,10 @@ static void node_lost_contact(struct tipc_node *n_ptr)
TIPC_NOTIFY_NODE_DOWN; TIPC_NOTIFY_NODE_DOWN;
} }
struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space) struct sk_buff *tipc_node_get_nodes(struct net *net, const void *req_tlv_area,
int req_tlv_space)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
u32 domain; u32 domain;
struct sk_buff *buf; struct sk_buff *buf;
struct tipc_node *n_ptr; struct tipc_node *n_ptr;
@ -430,20 +432,20 @@ struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
" (network address)"); " (network address)");
spin_lock_bh(&node_list_lock); spin_lock_bh(&tn->node_list_lock);
if (!tipc_num_nodes) { if (!tn->num_nodes) {
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
return tipc_cfg_reply_none(); return tipc_cfg_reply_none();
} }
/* For now, get space for all other nodes */ /* For now, get space for all other nodes */
payload_size = TLV_SPACE(sizeof(node_info)) * tipc_num_nodes; payload_size = TLV_SPACE(sizeof(node_info)) * tn->num_nodes;
if (payload_size > 32768u) { if (payload_size > 32768u) {
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
" (too many nodes)"); " (too many nodes)");
} }
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
buf = tipc_cfg_reply_alloc(payload_size); buf = tipc_cfg_reply_alloc(payload_size);
if (!buf) if (!buf)
@ -451,7 +453,7 @@ struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
/* Add TLVs for all nodes in scope */ /* Add TLVs for all nodes in scope */
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) { list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
if (!tipc_in_scope(domain, n_ptr->addr)) if (!tipc_in_scope(domain, n_ptr->addr))
continue; continue;
node_info.addr = htonl(n_ptr->addr); node_info.addr = htonl(n_ptr->addr);
@ -463,8 +465,10 @@ struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
return buf; return buf;
} }
struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space) struct sk_buff *tipc_node_get_links(struct net *net, const void *req_tlv_area,
int req_tlv_space)
{ {
struct tipc_net *tn = net_generic(net, tipc_net_id);
u32 domain; u32 domain;
struct sk_buff *buf; struct sk_buff *buf;
struct tipc_node *n_ptr; struct tipc_node *n_ptr;
@ -482,15 +486,15 @@ struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
if (!tipc_own_addr) if (!tipc_own_addr)
return tipc_cfg_reply_none(); return tipc_cfg_reply_none();
spin_lock_bh(&node_list_lock); spin_lock_bh(&tn->node_list_lock);
/* Get space for all unicast links + broadcast link */ /* Get space for all unicast links + broadcast link */
payload_size = TLV_SPACE((sizeof(link_info)) * (tipc_num_links + 1)); payload_size = TLV_SPACE((sizeof(link_info)) * (tn->num_links + 1));
if (payload_size > 32768u) { if (payload_size > 32768u) {
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
" (too many links)"); " (too many links)");
} }
spin_unlock_bh(&node_list_lock); spin_unlock_bh(&tn->node_list_lock);
buf = tipc_cfg_reply_alloc(payload_size); buf = tipc_cfg_reply_alloc(payload_size);
if (!buf) if (!buf)
@ -504,7 +508,7 @@ struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
/* Add TLVs for any other links in scope */ /* Add TLVs for any other links in scope */
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(n_ptr, &tipc_node_list, list) { list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {
u32 i; u32 i;
if (!tipc_in_scope(domain, n_ptr->addr)) if (!tipc_in_scope(domain, n_ptr->addr))
@ -534,10 +538,11 @@ struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
* *
* Returns 0 on success * Returns 0 on success
*/ */
int tipc_node_get_linkname(u32 bearer_id, u32 addr, char *linkname, size_t len) int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
char *linkname, size_t len)
{ {
struct tipc_link *link; struct tipc_link *link;
struct tipc_node *node = tipc_node_find(addr); struct tipc_node *node = tipc_node_find(net, addr);
if ((bearer_id >= MAX_BEARERS) || !node) if ((bearer_id >= MAX_BEARERS) || !node)
return -EINVAL; return -EINVAL;
@ -554,6 +559,7 @@ int tipc_node_get_linkname(u32 bearer_id, u32 addr, char *linkname, size_t len)
void tipc_node_unlock(struct tipc_node *node) void tipc_node_unlock(struct tipc_node *node)
{ {
struct net *net = node->net;
LIST_HEAD(nsub_list); LIST_HEAD(nsub_list);
LIST_HEAD(conn_sks); LIST_HEAD(conn_sks);
struct sk_buff_head waiting_sks; struct sk_buff_head waiting_sks;
@ -585,26 +591,26 @@ void tipc_node_unlock(struct tipc_node *node)
spin_unlock_bh(&node->lock); spin_unlock_bh(&node->lock);
while (!skb_queue_empty(&waiting_sks)) while (!skb_queue_empty(&waiting_sks))
tipc_sk_rcv(__skb_dequeue(&waiting_sks)); tipc_sk_rcv(net, __skb_dequeue(&waiting_sks));
if (!list_empty(&conn_sks)) if (!list_empty(&conn_sks))
tipc_node_abort_sock_conns(&conn_sks); tipc_node_abort_sock_conns(net, &conn_sks);
if (!list_empty(&nsub_list)) if (!list_empty(&nsub_list))
tipc_publ_notify(&nsub_list, addr); tipc_publ_notify(net, &nsub_list, addr);
if (flags & TIPC_WAKEUP_BCAST_USERS) if (flags & TIPC_WAKEUP_BCAST_USERS)
tipc_bclink_wakeup_users(); tipc_bclink_wakeup_users(net);
if (flags & TIPC_NOTIFY_NODE_UP) if (flags & TIPC_NOTIFY_NODE_UP)
tipc_named_node_up(addr); tipc_named_node_up(net, addr);
if (flags & TIPC_NOTIFY_LINK_UP) if (flags & TIPC_NOTIFY_LINK_UP)
tipc_nametbl_publish(TIPC_LINK_STATE, addr, addr, tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
TIPC_NODE_SCOPE, link_id, addr); TIPC_NODE_SCOPE, link_id, addr);
if (flags & TIPC_NOTIFY_LINK_DOWN) if (flags & TIPC_NOTIFY_LINK_DOWN)
tipc_nametbl_withdraw(TIPC_LINK_STATE, addr, tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
link_id, addr); link_id, addr);
} }
@ -645,6 +651,8 @@ static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb) int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
{ {
int err; int err;
struct net *net = sock_net(skb->sk);
struct tipc_net *tn = net_generic(net, tipc_net_id);
int done = cb->args[0]; int done = cb->args[0];
int last_addr = cb->args[1]; int last_addr = cb->args[1];
struct tipc_node *node; struct tipc_node *node;
@ -659,7 +667,7 @@ int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
rcu_read_lock(); rcu_read_lock();
if (last_addr && !tipc_node_find(last_addr)) { if (last_addr && !tipc_node_find(net, last_addr)) {
rcu_read_unlock(); rcu_read_unlock();
/* We never set seq or call nl_dump_check_consistent() this /* We never set seq or call nl_dump_check_consistent() this
* means that setting prev_seq here will cause the consistence * means that setting prev_seq here will cause the consistence
@ -671,7 +679,7 @@ int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
return -EPIPE; return -EPIPE;
} }
list_for_each_entry_rcu(node, &tipc_node_list, list) { list_for_each_entry_rcu(node, &tn->node_list, list) {
if (last_addr) { if (last_addr) {
if (node->addr == last_addr) if (node->addr == last_addr)
last_addr = 0; last_addr = 0;

35
net/tipc/node.h
View file

@ -42,10 +42,10 @@
#include "bearer.h" #include "bearer.h"
#include "msg.h" #include "msg.h"
/* /* Out-of-range value for node signature */
* Out-of-range value for node signature #define INVALID_NODE_SIG 0x10000
*/
#define INVALID_NODE_SIG 0x10000 #define NODE_HTABLE_SIZE 512
/* Flags used to take different actions according to flag type /* Flags used to take different actions according to flag type
* TIPC_WAIT_PEER_LINKS_DOWN: wait to see that peer's links are down * TIPC_WAIT_PEER_LINKS_DOWN: wait to see that peer's links are down
@ -90,6 +90,7 @@ struct tipc_node_bclink {
* struct tipc_node - TIPC node structure * struct tipc_node - TIPC node structure
* @addr: network address of node * @addr: network address of node
* @lock: spinlock governing access to structure * @lock: spinlock governing access to structure
* @net: the applicable net namespace
* @hash: links to adjacent nodes in unsorted hash chain * @hash: links to adjacent nodes in unsorted hash chain
* @active_links: pointers to active links to node * @active_links: pointers to active links to node
* @links: pointers to all links to node * @links: pointers to all links to node
@ -106,6 +107,7 @@ struct tipc_node_bclink {
struct tipc_node { struct tipc_node {
u32 addr; u32 addr;
spinlock_t lock; spinlock_t lock;
struct net *net;
struct hlist_node hash; struct hlist_node hash;
struct tipc_link *active_links[2]; struct tipc_link *active_links[2];
u32 act_mtus[2]; u32 act_mtus[2];
@ -123,23 +125,24 @@ struct tipc_node {
struct rcu_head rcu; struct rcu_head rcu;
}; };
extern struct list_head tipc_node_list; struct tipc_node *tipc_node_find(struct net *net, u32 addr);
struct tipc_node *tipc_node_create(struct net *net, u32 addr);
struct tipc_node *tipc_node_find(u32 addr); void tipc_node_stop(struct net *net);
struct tipc_node *tipc_node_create(u32 addr);
void tipc_node_stop(void);
void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr); void tipc_node_attach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr);
void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr); void tipc_node_detach_link(struct tipc_node *n_ptr, struct tipc_link *l_ptr);
void tipc_node_link_down(struct tipc_node *n_ptr, struct tipc_link *l_ptr); void tipc_node_link_down(struct tipc_node *n_ptr, struct tipc_link *l_ptr);
void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr); void tipc_node_link_up(struct tipc_node *n_ptr, struct tipc_link *l_ptr);
int tipc_node_active_links(struct tipc_node *n_ptr); int tipc_node_active_links(struct tipc_node *n_ptr);
int tipc_node_is_up(struct tipc_node *n_ptr); int tipc_node_is_up(struct tipc_node *n_ptr);
struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space); struct sk_buff *tipc_node_get_links(struct net *net, const void *req_tlv_area,
struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space); int req_tlv_space);
int tipc_node_get_linkname(u32 bearer_id, u32 node, char *linkname, size_t len); struct sk_buff *tipc_node_get_nodes(struct net *net, const void *req_tlv_area,
int req_tlv_space);
int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 node,
char *linkname, size_t len);
void tipc_node_unlock(struct tipc_node *node); void tipc_node_unlock(struct tipc_node *node);
int tipc_node_add_conn(u32 dnode, u32 port, u32 peer_port); int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port);
void tipc_node_remove_conn(u32 dnode, u32 port); void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port);
int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb); int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb);
@ -154,12 +157,12 @@ static inline bool tipc_node_blocked(struct tipc_node *node)
TIPC_NOTIFY_NODE_DOWN | TIPC_WAIT_OWN_LINKS_DOWN)); TIPC_NOTIFY_NODE_DOWN | TIPC_WAIT_OWN_LINKS_DOWN));
} }
static inline uint tipc_node_get_mtu(u32 addr, u32 selector) static inline uint tipc_node_get_mtu(struct net *net, u32 addr, u32 selector)
{ {
struct tipc_node *node; struct tipc_node *node;
u32 mtu; u32 mtu;
node = tipc_node_find(addr); node = tipc_node_find(net, addr);
if (likely(node)) if (likely(node))
mtu = node->act_mtus[selector & 1]; mtu = node->act_mtus[selector & 1];

72
net/tipc/socket.c
View file

@ -257,7 +257,7 @@ static void tsk_rej_rx_queue(struct sock *sk)
while ((skb = __skb_dequeue(&sk->sk_receive_queue))) { while ((skb = __skb_dequeue(&sk->sk_receive_queue))) {
if (tipc_msg_reverse(skb, &dnode, TIPC_ERR_NO_PORT)) if (tipc_msg_reverse(skb, &dnode, TIPC_ERR_NO_PORT))
tipc_link_xmit_skb(skb, dnode, 0); tipc_link_xmit_skb(sock_net(sk), skb, dnode, 0);
} }
} }
@ -473,6 +473,7 @@ static void tipc_sk_callback(struct rcu_head *head)
static int tipc_release(struct socket *sock) static int tipc_release(struct socket *sock)
{ {
struct sock *sk = sock->sk; struct sock *sk = sock->sk;
struct net *net = sock_net(sk);
struct tipc_sock *tsk; struct tipc_sock *tsk;
struct sk_buff *skb; struct sk_buff *skb;
u32 dnode, probing_state; u32 dnode, probing_state;
@ -503,10 +504,10 @@ static int tipc_release(struct socket *sock)
(sock->state == SS_CONNECTED)) { (sock->state == SS_CONNECTED)) {
sock->state = SS_DISCONNECTING; sock->state = SS_DISCONNECTING;
tsk->connected = 0; tsk->connected = 0;
tipc_node_remove_conn(dnode, tsk->portid); tipc_node_remove_conn(net, dnode, tsk->portid);
} }
if (tipc_msg_reverse(skb, &dnode, TIPC_ERR_NO_PORT)) if (tipc_msg_reverse(skb, &dnode, TIPC_ERR_NO_PORT))
tipc_link_xmit_skb(skb, dnode, 0); tipc_link_xmit_skb(net, skb, dnode, 0);
} }
} }
@ -521,8 +522,8 @@ static int tipc_release(struct socket *sock)
tsk_peer_port(tsk), tsk_peer_port(tsk),
tsk->portid, TIPC_ERR_NO_PORT); tsk->portid, TIPC_ERR_NO_PORT);
if (skb) if (skb)
tipc_link_xmit_skb(skb, dnode, tsk->portid); tipc_link_xmit_skb(net, skb, dnode, tsk->portid);
tipc_node_remove_conn(dnode, tsk->portid); tipc_node_remove_conn(net, dnode, tsk->portid);
} }
/* Discard any remaining (connection-based) messages in receive queue */ /* Discard any remaining (connection-based) messages in receive queue */
@ -725,6 +726,7 @@ static int tipc_sendmcast(struct socket *sock, struct tipc_name_seq *seq,
struct msghdr *msg, size_t dsz, long timeo) struct msghdr *msg, size_t dsz, long timeo)
{ {
struct sock *sk = sock->sk; struct sock *sk = sock->sk;
struct net *net = sock_net(sk);
struct tipc_msg *mhdr = &tipc_sk(sk)->phdr; struct tipc_msg *mhdr = &tipc_sk(sk)->phdr;
struct sk_buff_head head; struct sk_buff_head head;
uint mtu; uint mtu;
@ -747,7 +749,7 @@ static int tipc_sendmcast(struct socket *sock, struct tipc_name_seq *seq,
return rc; return rc;
do { do {
rc = tipc_bclink_xmit(&head); rc = tipc_bclink_xmit(net, &head);
if (likely(rc >= 0)) { if (likely(rc >= 0)) {
rc = dsz; rc = dsz;
break; break;
@ -766,7 +768,7 @@ static int tipc_sendmcast(struct socket *sock, struct tipc_name_seq *seq,
/* tipc_sk_mcast_rcv - Deliver multicast message to all destination sockets /* tipc_sk_mcast_rcv - Deliver multicast message to all destination sockets
*/ */
void tipc_sk_mcast_rcv(struct sk_buff *buf) void tipc_sk_mcast_rcv(struct net *net, struct sk_buff *buf)
{ {
struct tipc_msg *msg = buf_msg(buf); struct tipc_msg *msg = buf_msg(buf);
struct tipc_port_list dports = {0, NULL, }; struct tipc_port_list dports = {0, NULL, };
@ -798,7 +800,7 @@ void tipc_sk_mcast_rcv(struct sk_buff *buf)
continue; continue;
} }
msg_set_destport(msg, item->ports[i]); msg_set_destport(msg, item->ports[i]);
tipc_sk_rcv(b); tipc_sk_rcv(net, b);
} }
} }
tipc_port_list_free(&dports); tipc_port_list_free(&dports);
@ -886,6 +888,7 @@ static int tipc_sendmsg(struct kiocb *iocb, struct socket *sock,
DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name); DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
struct sock *sk = sock->sk; struct sock *sk = sock->sk;
struct tipc_sock *tsk = tipc_sk(sk); struct tipc_sock *tsk = tipc_sk(sk);
struct net *net = sock_net(sk);
struct tipc_msg *mhdr = &tsk->phdr; struct tipc_msg *mhdr = &tsk->phdr;
u32 dnode, dport; u32 dnode, dport;
struct sk_buff_head head; struct sk_buff_head head;
@ -960,7 +963,7 @@ static int tipc_sendmsg(struct kiocb *iocb, struct socket *sock,
} }
new_mtu: new_mtu:
mtu = tipc_node_get_mtu(dnode, tsk->portid); mtu = tipc_node_get_mtu(net, dnode, tsk->portid);
__skb_queue_head_init(&head); __skb_queue_head_init(&head);
rc = tipc_msg_build(mhdr, m, 0, dsz, mtu, &head); rc = tipc_msg_build(mhdr, m, 0, dsz, mtu, &head);
if (rc < 0) if (rc < 0)
@ -969,7 +972,7 @@ static int tipc_sendmsg(struct kiocb *iocb, struct socket *sock,
do { do {
skb = skb_peek(&head); skb = skb_peek(&head);
TIPC_SKB_CB(skb)->wakeup_pending = tsk->link_cong; TIPC_SKB_CB(skb)->wakeup_pending = tsk->link_cong;
rc = tipc_link_xmit(&head, dnode, tsk->portid); rc = tipc_link_xmit(net, &head, dnode, tsk->portid);
if (likely(rc >= 0)) { if (likely(rc >= 0)) {
if (sock->state != SS_READY) if (sock->state != SS_READY)
sock->state = SS_CONNECTING; sock->state = SS_CONNECTING;
@ -1038,6 +1041,7 @@ static int tipc_send_stream(struct kiocb *iocb, struct socket *sock,
struct msghdr *m, size_t dsz) struct msghdr *m, size_t dsz)
{ {
struct sock *sk = sock->sk; struct sock *sk = sock->sk;
struct net *net = sock_net(sk);
struct tipc_sock *tsk = tipc_sk(sk); struct tipc_sock *tsk = tipc_sk(sk);
struct tipc_msg *mhdr = &tsk->phdr; struct tipc_msg *mhdr = &tsk->phdr;
struct sk_buff_head head; struct sk_buff_head head;
@ -1081,7 +1085,7 @@ static int tipc_send_stream(struct kiocb *iocb, struct socket *sock,
goto exit; goto exit;
do { do {
if (likely(!tsk_conn_cong(tsk))) { if (likely(!tsk_conn_cong(tsk))) {
rc = tipc_link_xmit(&head, dnode, portid); rc = tipc_link_xmit(net, &head, dnode, portid);
if (likely(!rc)) { if (likely(!rc)) {
tsk->sent_unacked++; tsk->sent_unacked++;
sent += send; sent += send;
@ -1090,7 +1094,8 @@ static int tipc_send_stream(struct kiocb *iocb, struct socket *sock,
goto next; goto next;
} }
if (rc == -EMSGSIZE) { if (rc == -EMSGSIZE) {
tsk->max_pkt = tipc_node_get_mtu(dnode, portid); tsk->max_pkt = tipc_node_get_mtu(net, dnode,
portid);
goto next; goto next;
} }
if (rc != -ELINKCONG) if (rc != -ELINKCONG)
@ -1132,6 +1137,7 @@ static int tipc_send_packet(struct kiocb *iocb, struct socket *sock,
static void tipc_sk_finish_conn(struct tipc_sock *tsk, u32 peer_port, static void tipc_sk_finish_conn(struct tipc_sock *tsk, u32 peer_port,
u32 peer_node) u32 peer_node)
{ {
struct net *net = sock_net(&tsk->sk);
struct tipc_msg *msg = &tsk->phdr; struct tipc_msg *msg = &tsk->phdr;
msg_set_destnode(msg, peer_node); msg_set_destnode(msg, peer_node);
@ -1145,8 +1151,8 @@ static void tipc_sk_finish_conn(struct tipc_sock *tsk, u32 peer_port,
tsk->connected = 1; tsk->connected = 1;
if (!mod_timer(&tsk->timer, jiffies + tsk->probing_intv)) if (!mod_timer(&tsk->timer, jiffies + tsk->probing_intv))
sock_hold(&tsk->sk); sock_hold(&tsk->sk);
tipc_node_add_conn(peer_node, tsk->portid, peer_port); tipc_node_add_conn(net, peer_node, tsk->portid, peer_port);
tsk->max_pkt = tipc_node_get_mtu(peer_node, tsk->portid); tsk->max_pkt = tipc_node_get_mtu(net, peer_node, tsk->portid);
} }
/** /**
@ -1245,6 +1251,7 @@ static int tipc_sk_anc_data_recv(struct msghdr *m, struct tipc_msg *msg,
static void tipc_sk_send_ack(struct tipc_sock *tsk, uint ack) static void tipc_sk_send_ack(struct tipc_sock *tsk, uint ack)
{ {
struct net *net = sock_net(&tsk->sk);
struct sk_buff *skb = NULL; struct sk_buff *skb = NULL;
struct tipc_msg *msg; struct tipc_msg *msg;
u32 peer_port = tsk_peer_port(tsk); u32 peer_port = tsk_peer_port(tsk);
@ -1258,7 +1265,7 @@ static void tipc_sk_send_ack(struct tipc_sock *tsk, uint ack)
return; return;
msg = buf_msg(skb); msg = buf_msg(skb);
msg_set_msgcnt(msg, ack); msg_set_msgcnt(msg, ack);
tipc_link_xmit_skb(skb, dnode, msg_link_selector(msg)); tipc_link_xmit_skb(net, skb, dnode, msg_link_selector(msg));
} }
static int tipc_wait_for_rcvmsg(struct socket *sock, long *timeop) static int tipc_wait_for_rcvmsg(struct socket *sock, long *timeop)
@ -1551,6 +1558,7 @@ static void tipc_data_ready(struct sock *sk)
static int filter_connect(struct tipc_sock *tsk, struct sk_buff **buf) static int filter_connect(struct tipc_sock *tsk, struct sk_buff **buf)
{ {
struct sock *sk = &tsk->sk; struct sock *sk = &tsk->sk;
struct net *net = sock_net(sk);
struct socket *sock = sk->sk_socket; struct socket *sock = sk->sk_socket;
struct tipc_msg *msg = buf_msg(*buf); struct tipc_msg *msg = buf_msg(*buf);
int retval = -TIPC_ERR_NO_PORT; int retval = -TIPC_ERR_NO_PORT;
@ -1566,7 +1574,7 @@ static int filter_connect(struct tipc_sock *tsk, struct sk_buff **buf)
sock->state = SS_DISCONNECTING; sock->state = SS_DISCONNECTING;
tsk->connected = 0; tsk->connected = 0;
/* let timer expire on it's own */ /* let timer expire on it's own */
tipc_node_remove_conn(tsk_peer_node(tsk), tipc_node_remove_conn(net, tsk_peer_node(tsk),
tsk->portid); tsk->portid);
} }
retval = TIPC_OK; retval = TIPC_OK;
@ -1737,7 +1745,7 @@ static int tipc_backlog_rcv(struct sock *sk, struct sk_buff *skb)
if ((rc < 0) && !tipc_msg_reverse(skb, &onode, -rc)) if ((rc < 0) && !tipc_msg_reverse(skb, &onode, -rc))
return 0; return 0;
tipc_link_xmit_skb(skb, onode, 0); tipc_link_xmit_skb(sock_net(sk), skb, onode, 0);
return 0; return 0;
} }
@ -1748,7 +1756,7 @@ static int tipc_backlog_rcv(struct sock *sk, struct sk_buff *skb)
* Consumes buffer * Consumes buffer
* Returns 0 if success, or errno: -EHOSTUNREACH * Returns 0 if success, or errno: -EHOSTUNREACH
*/ */
int tipc_sk_rcv(struct sk_buff *skb) int tipc_sk_rcv(struct net *net, struct sk_buff *skb)
{ {
struct tipc_sock *tsk; struct tipc_sock *tsk;
struct sock *sk; struct sock *sk;
@ -1785,7 +1793,7 @@ int tipc_sk_rcv(struct sk_buff *skb)
if ((rc < 0) && !tipc_msg_reverse(skb, &dnode, -rc)) if ((rc < 0) && !tipc_msg_reverse(skb, &dnode, -rc))
return -EHOSTUNREACH; return -EHOSTUNREACH;
tipc_link_xmit_skb(skb, dnode, 0); tipc_link_xmit_skb(net, skb, dnode, 0);
return (rc < 0) ? -EHOSTUNREACH : 0; return (rc < 0) ? -EHOSTUNREACH : 0;
} }
@ -2042,6 +2050,7 @@ static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags)
static int tipc_shutdown(struct socket *sock, int how) static int tipc_shutdown(struct socket *sock, int how)
{ {
struct sock *sk = sock->sk; struct sock *sk = sock->sk;
struct net *net = sock_net(sk);
struct tipc_sock *tsk = tipc_sk(sk); struct tipc_sock *tsk = tipc_sk(sk);
struct sk_buff *skb; struct sk_buff *skb;
u32 dnode; u32 dnode;
@ -2065,8 +2074,9 @@ static int tipc_shutdown(struct socket *sock, int how)
goto restart; goto restart;
} }
if (tipc_msg_reverse(skb, &dnode, TIPC_CONN_SHUTDOWN)) if (tipc_msg_reverse(skb, &dnode, TIPC_CONN_SHUTDOWN))
tipc_link_xmit_skb(skb, dnode, tsk->portid); tipc_link_xmit_skb(net, skb, dnode,
tipc_node_remove_conn(dnode, tsk->portid); tsk->portid);
tipc_node_remove_conn(net, dnode, tsk->portid);
} else { } else {
dnode = tsk_peer_node(tsk); dnode = tsk_peer_node(tsk);
skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE,
@ -2074,11 +2084,11 @@ static int tipc_shutdown(struct socket *sock, int how)
0, dnode, tipc_own_addr, 0, dnode, tipc_own_addr,
tsk_peer_port(tsk), tsk_peer_port(tsk),
tsk->portid, TIPC_CONN_SHUTDOWN); tsk->portid, TIPC_CONN_SHUTDOWN);
tipc_link_xmit_skb(skb, dnode, tsk->portid); tipc_link_xmit_skb(net, skb, dnode, tsk->portid);
} }
tsk->connected = 0; tsk->connected = 0;
sock->state = SS_DISCONNECTING; sock->state = SS_DISCONNECTING;
tipc_node_remove_conn(dnode, tsk->portid); tipc_node_remove_conn(net, dnode, tsk->portid);
/* fall through */ /* fall through */
case SS_DISCONNECTING: case SS_DISCONNECTING:
@ -2130,7 +2140,7 @@ static void tipc_sk_timeout(unsigned long data)
} }
bh_unlock_sock(sk); bh_unlock_sock(sk);
if (skb) if (skb)
tipc_link_xmit_skb(skb, peer_node, tsk->portid); tipc_link_xmit_skb(sock_net(sk), skb, peer_node, tsk->portid);
exit: exit:
sock_put(sk); sock_put(sk);
} }
@ -2138,6 +2148,7 @@ static void tipc_sk_timeout(unsigned long data)
static int tipc_sk_publish(struct tipc_sock *tsk, uint scope, static int tipc_sk_publish(struct tipc_sock *tsk, uint scope,
struct tipc_name_seq const *seq) struct tipc_name_seq const *seq)
{ {
struct net *net = sock_net(&tsk->sk);
struct publication *publ; struct publication *publ;
u32 key; u32 key;
@ -2147,7 +2158,7 @@ static int tipc_sk_publish(struct tipc_sock *tsk, uint scope,
if (key == tsk->portid) if (key == tsk->portid)
return -EADDRINUSE; return -EADDRINUSE;
publ = tipc_nametbl_publish(seq->type, seq->lower, seq->upper, publ = tipc_nametbl_publish(net, seq->type, seq->lower, seq->upper,
scope, tsk->portid, key); scope, tsk->portid, key);
if (unlikely(!publ)) if (unlikely(!publ))
return -EINVAL; return -EINVAL;
@ -2161,6 +2172,7 @@ static int tipc_sk_publish(struct tipc_sock *tsk, uint scope,
static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope, static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope,
struct tipc_name_seq const *seq) struct tipc_name_seq const *seq)
{ {
struct net *net = sock_net(&tsk->sk);
struct publication *publ; struct publication *publ;
struct publication *safe; struct publication *safe;
int rc = -EINVAL; int rc = -EINVAL;
@ -2175,12 +2187,12 @@ static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope,
continue; continue;
if (publ->upper != seq->upper) if (publ->upper != seq->upper)
break; break;
tipc_nametbl_withdraw(publ->type, publ->lower, tipc_nametbl_withdraw(net, publ->type, publ->lower,
publ->ref, publ->key); publ->ref, publ->key);
rc = 0; rc = 0;
break; break;
} }
tipc_nametbl_withdraw(publ->type, publ->lower, tipc_nametbl_withdraw(net, publ->type, publ->lower,
publ->ref, publ->key); publ->ref, publ->key);
rc = 0; rc = 0;
} }
@ -2492,8 +2504,9 @@ static int tipc_getsockopt(struct socket *sock, int lvl, int opt,
return put_user(sizeof(value), ol); return put_user(sizeof(value), ol);
} }
static int tipc_ioctl(struct socket *sk, unsigned int cmd, unsigned long arg) static int tipc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{ {
struct sock *sk = sock->sk;
struct tipc_sioc_ln_req lnr; struct tipc_sioc_ln_req lnr;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
@ -2501,7 +2514,8 @@ static int tipc_ioctl(struct socket *sk, unsigned int cmd, unsigned long arg)
case SIOCGETLINKNAME: case SIOCGETLINKNAME:
if (copy_from_user(&lnr, argp, sizeof(lnr))) if (copy_from_user(&lnr, argp, sizeof(lnr)))
return -EFAULT; return -EFAULT;
if (!tipc_node_get_linkname(lnr.bearer_id & 0xffff, lnr.peer, if (!tipc_node_get_linkname(sock_net(sk),
lnr.bearer_id & 0xffff, lnr.peer,
lnr.linkname, TIPC_MAX_LINK_NAME)) { lnr.linkname, TIPC_MAX_LINK_NAME)) {
if (copy_to_user(argp, &lnr, sizeof(lnr))) if (copy_to_user(argp, &lnr, sizeof(lnr)))
return -EFAULT; return -EFAULT;

4
net/tipc/socket.h
View file

@ -49,9 +49,9 @@ int tipc_sock_create_local(int type, struct socket **res);
void tipc_sock_release_local(struct socket *sock); void tipc_sock_release_local(struct socket *sock);
int tipc_sock_accept_local(struct socket *sock, struct socket **newsock, int tipc_sock_accept_local(struct socket *sock, struct socket **newsock,
int flags); int flags);
int tipc_sk_rcv(struct sk_buff *buf); int tipc_sk_rcv(struct net *net, struct sk_buff *buf);
struct sk_buff *tipc_sk_socks_show(void); struct sk_buff *tipc_sk_socks_show(void);
void tipc_sk_mcast_rcv(struct sk_buff *buf); void tipc_sk_mcast_rcv(struct net *net, struct sk_buff *buf);
void tipc_sk_reinit(void); void tipc_sk_reinit(void);
int tipc_sk_rht_init(void); int tipc_sk_rht_init(void);
void tipc_sk_rht_destroy(void); void tipc_sk_rht_destroy(void);