Commit 5d5d4700 authored by Paolo Abeni's avatar Paolo Abeni Committed by Jakub Kicinski
Browse files

net-shapers: implement NL group operation 



Allow grouping multiple leaves shaper under the given root.
The node and the leaves shapers are created, if needed, otherwise
the existing shapers are re-linked as requested.

Try hard to pre-allocated the needed resources, to avoid non
trivial H/W configuration rollbacks in case of any failure.

Reviewed-by: default avatarJiri Pirko <jiri@nvidia.com>
Signed-off-by: default avatarPaolo Abeni <pabeni@redhat.com>
Link: https://patch.msgid.link/8a721274fde18b872d1e3a61aaa916bb7b7996d3.1728460186.git.pabeni@redhat.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 93954b40

net/shaper/shaper.c

+350 −0
Original line number Diff line number Diff line
@@ -75,6 +75,24 @@ net_shaper_ops(struct net_shaper_binding *binding) 
	return NULL;

}



/* Count the number of [multi] attributes of the given type. */

static int net_shaper_list_len(struct genl_info *info, int type)

{

	struct nlattr *attr;

	int rem, cnt = 0;



	nla_for_each_attr_type(attr, type, genlmsg_data(info->genlhdr),

			       genlmsg_len(info->genlhdr), rem)

		cnt++;

	return cnt;

}



static int net_shaper_handle_size(void)

{

	return nla_total_size(nla_total_size(sizeof(u32)) +

			      nla_total_size(sizeof(u32)));

}



static int net_shaper_fill_binding(struct sk_buff *msg,

				   const struct net_shaper_binding *binding,

				   u32 type)
@@ -472,6 +490,74 @@ static int net_shaper_parse_info(struct net_shaper_binding *binding, 
	return 0;

}



/* Fetch the existing leaf and update it with the user-provided

 * attributes.

 */

static int net_shaper_parse_leaf(struct net_shaper_binding *binding,

				 const struct nlattr *attr,

				 const struct genl_info *info,

				 const struct net_shaper *node,

				 struct net_shaper *shaper)

{

	struct nlattr *tb[NET_SHAPER_A_WEIGHT + 1];

	bool exists;

	int ret;



	ret = nla_parse_nested(tb, NET_SHAPER_A_WEIGHT, attr,

			       net_shaper_leaf_info_nl_policy, info->extack);

	if (ret < 0)

		return ret;



	ret = net_shaper_parse_info(binding, tb, info, shaper, &exists);

	if (ret < 0)

		return ret;



	if (shaper->handle.scope != NET_SHAPER_SCOPE_QUEUE) {

		NL_SET_BAD_ATTR(info->extack, tb[NET_SHAPER_A_HANDLE]);

		return -EINVAL;

	}



	if (!exists)

		net_shaper_default_parent(&shaper->handle, &shaper->parent);

	return 0;

}



/* Alike net_parse_shaper_info(), but additionally allow the user specifying

 * the shaper's parent handle.

 */

static int net_shaper_parse_node(struct net_shaper_binding *binding,

				 struct nlattr **tb,

				 const struct genl_info *info,

				 struct net_shaper *shaper)

{

	bool exists;

	int ret;



	ret = net_shaper_parse_info(binding, tb, info, shaper, &exists);

	if (ret)

		return ret;



	if (shaper->handle.scope != NET_SHAPER_SCOPE_NODE &&

	    shaper->handle.scope != NET_SHAPER_SCOPE_NETDEV) {

		NL_SET_BAD_ATTR(info->extack, tb[NET_SHAPER_A_HANDLE]);

		return -EINVAL;

	}



	if (tb[NET_SHAPER_A_PARENT]) {

		ret = net_shaper_parse_handle(tb[NET_SHAPER_A_PARENT], info,

					      &shaper->parent);

		if (ret)

			return ret;



		if (shaper->parent.scope != NET_SHAPER_SCOPE_NODE &&

		    shaper->parent.scope != NET_SHAPER_SCOPE_NETDEV) {

			NL_SET_BAD_ATTR(info->extack, tb[NET_SHAPER_A_PARENT]);

			return -EINVAL;

		}

	}

	return 0;

}



static int net_shaper_generic_pre(struct genl_info *info, int type)

{

	struct net_shaper_nl_ctx *ctx = (struct net_shaper_nl_ctx *)info->ctx;
@@ -670,6 +756,123 @@ static int __net_shaper_delete(struct net_shaper_binding *binding, 
	return 0;

}



static int net_shaper_handle_cmp(const struct net_shaper_handle *a,

				 const struct net_shaper_handle *b)

{

	/* Must avoid holes in struct net_shaper_handle. */

	BUILD_BUG_ON(sizeof(*a) != 8);



	return memcmp(a, b, sizeof(*a));

}



static int net_shaper_parent_from_leaves(int leaves_count,

					 const struct net_shaper *leaves,

					 struct net_shaper *node,

					 struct netlink_ext_ack *extack)

{

	struct net_shaper_handle parent = leaves[0].parent;

	int i;



	for (i = 1; i < leaves_count; ++i) {

		if (net_shaper_handle_cmp(&leaves[i].parent, &parent)) {

			NL_SET_ERR_MSG_FMT(extack, "All the leaves shapers must have the same old parent");

			return -EINVAL;

		}

	}



	node->parent = parent;

	return 0;

}



static int __net_shaper_group(struct net_shaper_binding *binding,

			      int leaves_count, struct net_shaper *leaves,

			      struct net_shaper *node,

			      struct netlink_ext_ack *extack)

{

	const struct net_shaper_ops *ops = net_shaper_ops(binding);

	struct net_shaper_handle leaf_handle;

	struct net_shaper *parent = NULL;

	bool new_node = false;

	int i, ret;



	if (node->handle.scope == NET_SHAPER_SCOPE_NODE) {

		new_node = node->handle.id == NET_SHAPER_ID_UNSPEC;



		if (!new_node && !net_shaper_lookup(binding, &node->handle)) {

			/* The related attribute is not available when

			 * reaching here from the delete() op.

			 */

			NL_SET_ERR_MSG_FMT(extack, "Node shaper %d:%d does not exists",

					   node->handle.scope, node->handle.id);

			return -ENOENT;

		}



		/* When unspecified, the node parent scope is inherited from

		 * the leaves.

		 */

		if (node->parent.scope == NET_SHAPER_SCOPE_UNSPEC) {

			ret = net_shaper_parent_from_leaves(leaves_count,

							    leaves, node,

							    extack);

			if (ret)

				return ret;

		}



	} else {

		net_shaper_default_parent(&node->handle, &node->parent);

	}



	if (node->parent.scope == NET_SHAPER_SCOPE_NODE) {

		parent = net_shaper_lookup(binding, &node->parent);

		if (!parent) {

			NL_SET_ERR_MSG_FMT(extack, "Node parent shaper %d:%d does not exists",

					   node->parent.scope, node->parent.id);

			return -ENOENT;

		}

	}



	/* For newly created node scope shaper, the following will update

	 * the handle, due to id allocation.

	 */

	ret = net_shaper_pre_insert(binding, &node->handle, extack);

	if (ret)

		return ret;



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

		leaf_handle = leaves[i].handle;



		ret = net_shaper_pre_insert(binding, &leaf_handle, extack);

		if (ret)

			goto rollback;



		if (!net_shaper_handle_cmp(&leaves[i].parent, &node->handle))

			continue;



		/* The leaves shapers will be nested to the node, update the

		 * linking accordingly.

		 */

		leaves[i].parent = node->handle;

		node->leaves++;

	}



	ret = ops->group(binding, leaves_count, leaves, node, extack);

	if (ret < 0)

		goto rollback;



	/* The node's parent gains a new leaf only when the node itself

	 * is created by this group operation

	 */

	if (new_node && parent)

		parent->leaves++;

	net_shaper_commit(binding, 1, node);

	net_shaper_commit(binding, leaves_count, leaves);

	return 0;



rollback:

	net_shaper_rollback(binding);

	return ret;

}



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

{

	struct net_shaper_hierarchy *hierarchy;
@@ -714,6 +917,153 @@ int net_shaper_nl_delete_doit(struct sk_buff *skb, struct genl_info *info) 
	return ret;

}



static int net_shaper_group_send_reply(struct net_shaper_binding *binding,

				       const struct net_shaper_handle *handle,

				       struct genl_info *info,

				       struct sk_buff *msg)

{

	void *hdr;



	hdr = genlmsg_iput(msg, info);

	if (!hdr)

		goto free_msg;



	if (net_shaper_fill_binding(msg, binding, NET_SHAPER_A_IFINDEX) ||

	    net_shaper_fill_handle(msg, handle, NET_SHAPER_A_HANDLE))

		goto free_msg;



	genlmsg_end(msg, hdr);



	return genlmsg_reply(msg, info);



free_msg:

	/* Should never happen as msg is pre-allocated with enough space. */

	WARN_ONCE(true, "calculated message payload length (%d)",

		  net_shaper_handle_size());

	nlmsg_free(msg);

	return -EMSGSIZE;

}



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

{

	struct net_shaper **old_nodes, *leaves, node = {};

	struct net_shaper_hierarchy *hierarchy;

	struct net_shaper_binding *binding;

	int i, ret, rem, leaves_count;

	int old_nodes_count = 0;

	struct sk_buff *msg;

	struct nlattr *attr;



	if (GENL_REQ_ATTR_CHECK(info, NET_SHAPER_A_LEAVES))

		return -EINVAL;



	binding = net_shaper_binding_from_ctx(info->ctx);



	/* The group operation is optional. */

	if (!net_shaper_ops(binding)->group)

		return -EOPNOTSUPP;



	net_shaper_lock(binding);

	leaves_count = net_shaper_list_len(info, NET_SHAPER_A_LEAVES);

	if (!leaves_count) {

		NL_SET_BAD_ATTR(info->extack,

				info->attrs[NET_SHAPER_A_LEAVES]);

		ret = -EINVAL;

		goto unlock;

	}



	leaves = kcalloc(leaves_count, sizeof(struct net_shaper) +

			 sizeof(struct net_shaper *), GFP_KERNEL);

	if (!leaves) {

		ret = -ENOMEM;

		goto unlock;

	}

	old_nodes = (void *)&leaves[leaves_count];



	ret = net_shaper_parse_node(binding, info->attrs, info, &node);

	if (ret)

		goto free_leaves;



	i = 0;

	nla_for_each_attr_type(attr, NET_SHAPER_A_LEAVES,

			       genlmsg_data(info->genlhdr),

			       genlmsg_len(info->genlhdr), rem) {

		if (WARN_ON_ONCE(i >= leaves_count))

			goto free_leaves;



		ret = net_shaper_parse_leaf(binding, attr, info,

					    &node, &leaves[i]);

		if (ret)

			goto free_leaves;

		i++;

	}



	/* Prepare the msg reply in advance, to avoid device operation

	 * rollback on allocation failure.

	 */

	msg = genlmsg_new(net_shaper_handle_size(), GFP_KERNEL);

	if (!msg)

		goto free_leaves;



	hierarchy = net_shaper_hierarchy_setup(binding);

	if (!hierarchy) {

		ret = -ENOMEM;

		goto free_msg;

	}



	/* Record the node shapers that this group() operation can make

	 * childless for later cleanup.

	 */

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

		if (leaves[i].parent.scope == NET_SHAPER_SCOPE_NODE &&

		    net_shaper_handle_cmp(&leaves[i].parent, &node.handle)) {

			struct net_shaper *tmp;



			tmp = net_shaper_lookup(binding, &leaves[i].parent);

			if (!tmp)

				continue;



			old_nodes[old_nodes_count++] = tmp;

		}

	}



	ret = __net_shaper_group(binding, leaves_count, leaves, &node,

				 info->extack);

	if (ret)

		goto free_msg;



	/* Check if we need to delete any node left alone by the new leaves

	 * linkage.

	 */

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

		struct net_shaper *tmp = old_nodes[i];



		if (--tmp->leaves > 0)

			continue;



		/* Errors here are not fatal: the grouping operation is

		 * completed, and user-space can still explicitly clean-up

		 * left-over nodes.

		 */

		__net_shaper_delete(binding, tmp, info->extack);

	}



	ret = net_shaper_group_send_reply(binding, &node.handle, info, msg);

	if (ret)

		GENL_SET_ERR_MSG_FMT(info, "Can't send reply");



free_leaves:

	kfree(leaves);



unlock:

	net_shaper_unlock(binding);

	return ret;



free_msg:

	kfree_skb(msg);

	goto free_leaves;

}



static void net_shaper_flush(struct net_shaper_binding *binding)

{

	struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding);