Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5be9c086 authored by Jon Paul Maloy's avatar Jon Paul Maloy Committed by David S. Miller
Browse files

tipc: narrow down exposure of struct tipc_node 



In our effort to have less code and include dependencies between
entities such as node, link and bearer, we try to narrow down
the exposed interface towards the node as much as possible.

In this commit, we move the definition of struct tipc_node, along
with many of its associated function declarations, from node.h to
node.c. We also move some function definitions from link.c and
name_distr.c to node.c, since they access fields in struct tipc_node
that should not be externally visible. The moved functions are renamed
according to new location, and made static whenever possible.

There are no functional changes in this commit.

Reviewed-by: default avatarYing Xue <ying.xue@windriver.com>
Signed-off-by: default avatarJon Maloy <jon.maloy@ericsson.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 5405ff6e

net/tipc/bcast.h

+1 −0
Original line number Diff line number Diff line
@@ -43,6 +43,7 @@ struct tipc_node; 
struct tipc_msg;

struct tipc_nl_msg;

struct tipc_node_map;

extern const char tipc_bclink_name[];



int tipc_bcast_init(struct net *net);

void tipc_bcast_reinit(struct net *net);

net/tipc/link.c

+3 −334
Original line number Diff line number Diff line
@@ -50,23 +50,6 @@ 
 */

static const char *link_co_err = "Link tunneling error, ";

static const char *link_rst_msg = "Resetting link ";

static const char tipc_bclink_name[] = "broadcast-link";



static const struct nla_policy tipc_nl_link_policy[TIPC_NLA_LINK_MAX + 1] = {

	[TIPC_NLA_LINK_UNSPEC]		= { .type = NLA_UNSPEC },

	[TIPC_NLA_LINK_NAME] = {

		.type = NLA_STRING,

		.len = TIPC_MAX_LINK_NAME

	},

	[TIPC_NLA_LINK_MTU]		= { .type = NLA_U32 },

	[TIPC_NLA_LINK_BROADCAST]	= { .type = NLA_FLAG },

	[TIPC_NLA_LINK_UP]		= { .type = NLA_FLAG },

	[TIPC_NLA_LINK_ACTIVE]		= { .type = NLA_FLAG },

	[TIPC_NLA_LINK_PROP]		= { .type = NLA_NESTED },

	[TIPC_NLA_LINK_STATS]		= { .type = NLA_NESTED },

	[TIPC_NLA_LINK_RX]		= { .type = NLA_U32 },

	[TIPC_NLA_LINK_TX]		= { .type = NLA_U32 }

};



/* Properties valid for media, bearar and link */

static const struct nla_policy tipc_nl_prop_policy[TIPC_NLA_PROP_MAX + 1] = {
@@ -117,7 +100,6 @@ static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb, 
static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,

				      u16 rcvgap, int tolerance, int priority,

				      struct sk_buff_head *xmitq);

static void link_reset_statistics(struct tipc_link *l_ptr);

static void link_print(struct tipc_link *l_ptr, const char *str);

static void tipc_link_build_nack_msg(struct tipc_link *l,

				     struct sk_buff_head *xmitq);
@@ -1527,49 +1509,11 @@ void tipc_link_set_queue_limits(struct tipc_link *l, u32 win) 
	l->backlog[TIPC_SYSTEM_IMPORTANCE].limit   = max_bulk;

}



/* tipc_link_find_owner - locate owner node of link by link's name

 * @net: the applicable net namespace

 * @name: pointer to link name string

 * @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.

 */

static struct tipc_node *tipc_link_find_owner(struct net *net,

					      const char *link_name,

					      unsigned int *bearer_id)

{

	struct tipc_net *tn = net_generic(net, tipc_net_id);

	struct tipc_link *l_ptr;

	struct tipc_node *n_ptr;

	struct tipc_node *found_node = NULL;

	int i;



	*bearer_id = 0;

	rcu_read_lock();

	list_for_each_entry_rcu(n_ptr, &tn->node_list, list) {

		tipc_node_read_lock(n_ptr);

		for (i = 0; i < MAX_BEARERS; i++) {

			l_ptr = n_ptr->links[i].link;

			if (l_ptr && !strcmp(l_ptr->name, link_name)) {

				*bearer_id = i;

				found_node = n_ptr;

				break;

			}

		}

		tipc_node_read_unlock(n_ptr);

		if (found_node)

			break;

	}

	rcu_read_unlock();



	return found_node;

}



/**

 * link_reset_statistics - reset link statistics

 * @l_ptr: pointer to link

 */

static void link_reset_statistics(struct tipc_link *l_ptr)

void link_reset_statistics(struct tipc_link *l_ptr)

{

	memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));

	l_ptr->stats.sent_info = l_ptr->snd_nxt;
@@ -1626,84 +1570,6 @@ int tipc_nl_parse_link_prop(struct nlattr *prop, struct nlattr *props[]) 
	return 0;

}



int tipc_nl_link_set(struct sk_buff *skb, struct genl_info *info)

{

	int err;

	int res = 0;

	int bearer_id;

	char *name;

	struct tipc_link *link;

	struct tipc_node *node;

	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];

	struct net *net = sock_net(skb->sk);



	if (!info->attrs[TIPC_NLA_LINK])

		return -EINVAL;



	err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,

			       info->attrs[TIPC_NLA_LINK],

			       tipc_nl_link_policy);

	if (err)

		return err;



	if (!attrs[TIPC_NLA_LINK_NAME])

		return -EINVAL;



	name = nla_data(attrs[TIPC_NLA_LINK_NAME]);



	if (strcmp(name, tipc_bclink_name) == 0)

		return tipc_nl_bc_link_set(net, attrs);



	node = tipc_link_find_owner(net, name, &bearer_id);

	if (!node)

		return -EINVAL;



	tipc_node_read_lock(node);



	link = node->links[bearer_id].link;

	if (!link) {

		res = -EINVAL;

		goto out;

	}



	if (attrs[TIPC_NLA_LINK_PROP]) {

		struct nlattr *props[TIPC_NLA_PROP_MAX + 1];



		err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP],

					      props);

		if (err) {

			res = err;

			goto out;

		}



		if (props[TIPC_NLA_PROP_TOL]) {

			u32 tol;



			tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);

			link->tolerance = tol;

			tipc_link_proto_xmit(link, STATE_MSG, 0, 0, tol, 0);

		}

		if (props[TIPC_NLA_PROP_PRIO]) {

			u32 prio;



			prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);

			link->priority = prio;

			tipc_link_proto_xmit(link, STATE_MSG, 0, 0, 0, prio);

		}

		if (props[TIPC_NLA_PROP_WIN]) {

			u32 win;



			win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);

			tipc_link_set_queue_limits(link, win);

		}

	}



out:

	tipc_node_read_unlock(node);



	return res;

}



static int __tipc_nl_add_stats(struct sk_buff *skb, struct tipc_stats *s)

{

	int i;
@@ -1770,7 +1636,7 @@ static int __tipc_nl_add_stats(struct sk_buff *skb, struct tipc_stats *s) 
}



/* Caller should hold appropriate locks to protect the link */

static int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,

int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,

		       struct tipc_link *link, int nlflags)

{

	int err;
@@ -1839,200 +1705,3 @@ static int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg, 


	return -EMSGSIZE;

}
 


/* Caller should hold node lock  */

static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg,

				    struct tipc_node *node, u32 *prev_link)

{

	u32 i;

	int err;



	for (i = *prev_link; i < MAX_BEARERS; i++) {

		*prev_link = i;



		if (!node->links[i].link)

			continue;



		err = __tipc_nl_add_link(net, msg,

					 node->links[i].link, NLM_F_MULTI);

		if (err)

			return err;

	}

	*prev_link = 0;



	return 0;

}



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_nl_msg msg;

	u32 prev_node = cb->args[0];

	u32 prev_link = cb->args[1];

	int done = cb->args[2];

	int err;



	if (done)

		return 0;



	msg.skb = skb;

	msg.portid = NETLINK_CB(cb->skb).portid;

	msg.seq = cb->nlh->nlmsg_seq;



	rcu_read_lock();

	if (prev_node) {

		node = tipc_node_find(net, prev_node);

		if (!node) {

			/* We never set seq or call nl_dump_check_consistent()

			 * this means that setting prev_seq here will cause the

			 * consistence check to fail in the netlink callback

			 * handler. Resulting in the last NLMSG_DONE message

			 * having the NLM_F_DUMP_INTR flag set.

			 */

			cb->prev_seq = 1;

			goto out;

		}

		tipc_node_put(node);



		list_for_each_entry_continue_rcu(node, &tn->node_list,

						 list) {

			tipc_node_read_lock(node);

			err = __tipc_nl_add_node_links(net, &msg, node,

						       &prev_link);

			tipc_node_read_unlock(node);

			if (err)

				goto out;



			prev_node = node->addr;

		}

	} else {

		err = tipc_nl_add_bc_link(net, &msg);

		if (err)

			goto out;



		list_for_each_entry_rcu(node, &tn->node_list, list) {

			tipc_node_read_lock(node);

			err = __tipc_nl_add_node_links(net, &msg, node,

						       &prev_link);

			tipc_node_read_unlock(node);

			if (err)

				goto out;



			prev_node = node->addr;

		}

	}

	done = 1;

out:

	rcu_read_unlock();



	cb->args[0] = prev_node;

	cb->args[1] = prev_link;

	cb->args[2] = done;



	return skb->len;

}



int tipc_nl_link_get(struct sk_buff *skb, struct genl_info *info)

{

	struct net *net = genl_info_net(info);

	struct tipc_nl_msg msg;

	char *name;

	int err;



	msg.portid = info->snd_portid;

	msg.seq = info->snd_seq;



	if (!info->attrs[TIPC_NLA_LINK_NAME])

		return -EINVAL;

	name = nla_data(info->attrs[TIPC_NLA_LINK_NAME]);



	msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);

	if (!msg.skb)

		return -ENOMEM;



	if (strcmp(name, tipc_bclink_name) == 0) {

		err = tipc_nl_add_bc_link(net, &msg);

		if (err) {

			nlmsg_free(msg.skb);

			return err;

		}

	} else {

		int bearer_id;

		struct tipc_node *node;

		struct tipc_link *link;



		node = tipc_link_find_owner(net, name, &bearer_id);

		if (!node)

			return -EINVAL;



		tipc_node_read_lock(node);

		link = node->links[bearer_id].link;

		if (!link) {

			tipc_node_read_unlock(node);

			nlmsg_free(msg.skb);

			return -EINVAL;

		}



		err = __tipc_nl_add_link(net, &msg, link, 0);

		tipc_node_read_unlock(node);

		if (err) {

			nlmsg_free(msg.skb);

			return err;

		}

	}



	return genlmsg_reply(msg.skb, info);

}



int tipc_nl_link_reset_stats(struct sk_buff *skb, struct genl_info *info)

{

	int err;

	char *link_name;

	unsigned int bearer_id;

	struct tipc_link *link;

	struct tipc_node *node;

	struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1];

	struct net *net = sock_net(skb->sk);

	struct tipc_link_entry *le;



	if (!info->attrs[TIPC_NLA_LINK])

		return -EINVAL;



	err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX,

			       info->attrs[TIPC_NLA_LINK],

			       tipc_nl_link_policy);

	if (err)

		return err;



	if (!attrs[TIPC_NLA_LINK_NAME])

		return -EINVAL;



	link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]);



	if (strcmp(link_name, tipc_bclink_name) == 0) {

		err = tipc_bclink_reset_stats(net);

		if (err)

			return err;

		return 0;

	}



	node = tipc_link_find_owner(net, link_name, &bearer_id);

	if (!node)

		return -EINVAL;



	le = &node->links[bearer_id];

	tipc_node_read_lock(node);

	spin_lock_bh(&le->lock);

	link = le->link;

	if (!link) {

		spin_unlock_bh(&le->lock);

		tipc_node_read_unlock(node);

		return -EINVAL;

	}

	link_reset_statistics(link);

	spin_unlock_bh(&le->lock);

	tipc_node_read_unlock(node);

	return 0;

}

net/tipc/link.h

+5 −4
Original line number Diff line number Diff line
@@ -249,14 +249,15 @@ bool tipc_link_is_failingover(struct tipc_link *l); 
bool tipc_link_is_blocked(struct tipc_link *l);

void tipc_link_set_active(struct tipc_link *l, bool active);

void tipc_link_reset(struct tipc_link *l_ptr);

void link_reset_statistics(struct tipc_link *l);

int tipc_link_xmit(struct tipc_link *link,	struct sk_buff_head *list,

		   struct sk_buff_head *xmitq);

void tipc_link_proto_xmit(struct tipc_link *l, u32 msg_typ, int probe_msg,

			  u32 gap, u32 tolerance, u32 priority);

void tipc_link_set_queue_limits(struct tipc_link *l, u32 window);



int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,

		       struct tipc_link *link, int nlflags);

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_set(struct sk_buff *skb, struct genl_info *info);

int tipc_nl_link_reset_stats(struct sk_buff *skb, struct genl_info *info);

int tipc_nl_parse_link_prop(struct nlattr *prop, struct nlattr *props[]);

int tipc_link_timeout(struct tipc_link *l, struct sk_buff_head *xmitq);

int tipc_link_rcv(struct tipc_link *l, struct sk_buff *skb,

net/tipc/netlink.c

+3 −3
Original line number Diff line number Diff line
@@ -101,18 +101,18 @@ static const struct genl_ops tipc_genl_v2_ops[] = { 
	},

	{

		.cmd	= TIPC_NL_LINK_GET,

		.doit   = tipc_nl_link_get,

		.doit   = tipc_nl_node_get_link,

		.dumpit	= tipc_nl_link_dump,

		.policy = tipc_nl_policy,

	},

	{

		.cmd	= TIPC_NL_LINK_SET,

		.doit	= tipc_nl_link_set,

		.doit	= tipc_nl_node_set_link,

		.policy = tipc_nl_policy,

	},

	{

		.cmd	= TIPC_NL_LINK_RESET_STATS,

		.doit   = tipc_nl_link_reset_stats,

		.doit   = tipc_nl_node_reset_link_stats,

		.policy = tipc_nl_policy,

	},

	{

net/tipc/netlink_compat.c

+2 −2
Original line number Diff line number Diff line
@@ -1036,12 +1036,12 @@ static int tipc_nl_compat_handle(struct tipc_nl_compat_msg *msg) 
	case TIPC_CMD_SET_LINK_PRI:

	case TIPC_CMD_SET_LINK_WINDOW:

		msg->req_type =  TIPC_TLV_LINK_CONFIG;

		doit.doit = tipc_nl_link_set;

		doit.doit = tipc_nl_node_set_link;

		doit.transcode = tipc_nl_compat_link_set;

		return tipc_nl_compat_doit(&doit, msg);

	case TIPC_CMD_RESET_LINK_STATS:

		msg->req_type = TIPC_TLV_LINK_NAME;

		doit.doit = tipc_nl_link_reset_stats;

		doit.doit = tipc_nl_node_reset_link_stats;

		doit.transcode = tipc_nl_compat_link_reset_stats;

		return tipc_nl_compat_doit(&doit, msg);

	case TIPC_CMD_SHOW_NAME_TABLE: