mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-12-29 17:25:38 +00:00
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: Jiri Pirko <jiri@nvidia.com> Signed-off-by: Paolo Abeni <pabeni@redhat.com> Link: https://patch.msgid.link/8a721274fde18b872d1e3a61aaa916bb7b7996d3.1728460186.git.pabeni@redhat.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Paolo Abeni
Jakub Kicinski
parent
93954b40f6
commit
5d5d4700e7
@ -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);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user