mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 10:32:35 +00:00
241a94abcf
No functional change intended, aliases will be used in followup commits. Note for backporters: you may need to add aliases also for modules that are already removed in mainline kernel but still in your version. Patches were generated with the help of Coccinelle scripts like: cat >scripts/coccinelle/misc/tcf_alias.cocci <<EOD virtual patch virtual report @ haskernel @ @@ @ tcf_has_kind depends on report && haskernel @ identifier ops; constant K; @@ static struct tcf_proto_ops ops = { .kind = K, ... }; +char module_alias = K; EOD /usr/bin/spatch -D report --cocci-file scripts/coccinelle/misc/tcf_alias.cocci \ --dir . \ -I ./arch/x86/include -I ./arch/x86/include/generated -I ./include \ -I ./arch/x86/include/uapi -I ./arch/x86/include/generated/uapi \ -I ./include/uapi -I ./include/generated/uapi \ --include ./include/linux/compiler-version.h --include ./include/linux/kconfig.h \ --jobs 8 --chunksize 1 2>/dev/null | \ sed 's/char module_alias = "\([^"]*\)";/MODULE_ALIAS_NET_CLS("\1");/' And analogously for: static struct tc_action_ops ops = { .kind = K, static struct Qdisc_ops ops = { .id = K, (Someone familiar would be able to fit those into one .cocci file without sed post processing.) Signed-off-by: Michal Koutný <mkoutny@suse.com> Acked-by: Jamal Hadi Salim <jhs@mojatatu.com> Reviewed-by: Jiri Pirko <jiri@nvidia.com> Link: https://lore.kernel.org/r/20240201130943.19536-3-mkoutny@suse.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
228 lines
5.1 KiB
C
228 lines
5.1 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* net/sched/cls_cgroup.c Control Group Classifier
|
|
*
|
|
* Authors: Thomas Graf <tgraf@suug.ch>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/rcupdate.h>
|
|
#include <net/rtnetlink.h>
|
|
#include <net/pkt_cls.h>
|
|
#include <net/sock.h>
|
|
#include <net/cls_cgroup.h>
|
|
#include <net/tc_wrapper.h>
|
|
|
|
struct cls_cgroup_head {
|
|
u32 handle;
|
|
struct tcf_exts exts;
|
|
struct tcf_ematch_tree ematches;
|
|
struct tcf_proto *tp;
|
|
struct rcu_work rwork;
|
|
};
|
|
|
|
TC_INDIRECT_SCOPE int cls_cgroup_classify(struct sk_buff *skb,
|
|
const struct tcf_proto *tp,
|
|
struct tcf_result *res)
|
|
{
|
|
struct cls_cgroup_head *head = rcu_dereference_bh(tp->root);
|
|
u32 classid = task_get_classid(skb);
|
|
|
|
if (unlikely(!head))
|
|
return -1;
|
|
if (!classid)
|
|
return -1;
|
|
if (!tcf_em_tree_match(skb, &head->ematches, NULL))
|
|
return -1;
|
|
|
|
res->classid = classid;
|
|
res->class = 0;
|
|
|
|
return tcf_exts_exec(skb, &head->exts, res);
|
|
}
|
|
|
|
static void *cls_cgroup_get(struct tcf_proto *tp, u32 handle)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static int cls_cgroup_init(struct tcf_proto *tp)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static const struct nla_policy cgroup_policy[TCA_CGROUP_MAX + 1] = {
|
|
[TCA_CGROUP_EMATCHES] = { .type = NLA_NESTED },
|
|
};
|
|
|
|
static void __cls_cgroup_destroy(struct cls_cgroup_head *head)
|
|
{
|
|
tcf_exts_destroy(&head->exts);
|
|
tcf_em_tree_destroy(&head->ematches);
|
|
tcf_exts_put_net(&head->exts);
|
|
kfree(head);
|
|
}
|
|
|
|
static void cls_cgroup_destroy_work(struct work_struct *work)
|
|
{
|
|
struct cls_cgroup_head *head = container_of(to_rcu_work(work),
|
|
struct cls_cgroup_head,
|
|
rwork);
|
|
rtnl_lock();
|
|
__cls_cgroup_destroy(head);
|
|
rtnl_unlock();
|
|
}
|
|
|
|
static int cls_cgroup_change(struct net *net, struct sk_buff *in_skb,
|
|
struct tcf_proto *tp, unsigned long base,
|
|
u32 handle, struct nlattr **tca,
|
|
void **arg, u32 flags,
|
|
struct netlink_ext_ack *extack)
|
|
{
|
|
struct nlattr *tb[TCA_CGROUP_MAX + 1];
|
|
struct cls_cgroup_head *head = rtnl_dereference(tp->root);
|
|
struct cls_cgroup_head *new;
|
|
int err;
|
|
|
|
if (!tca[TCA_OPTIONS])
|
|
return -EINVAL;
|
|
|
|
if (!head && !handle)
|
|
return -EINVAL;
|
|
|
|
if (head && handle != head->handle)
|
|
return -ENOENT;
|
|
|
|
new = kzalloc(sizeof(*head), GFP_KERNEL);
|
|
if (!new)
|
|
return -ENOBUFS;
|
|
|
|
err = tcf_exts_init(&new->exts, net, TCA_CGROUP_ACT, TCA_CGROUP_POLICE);
|
|
if (err < 0)
|
|
goto errout;
|
|
new->handle = handle;
|
|
new->tp = tp;
|
|
err = nla_parse_nested_deprecated(tb, TCA_CGROUP_MAX,
|
|
tca[TCA_OPTIONS], cgroup_policy,
|
|
NULL);
|
|
if (err < 0)
|
|
goto errout;
|
|
|
|
err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &new->exts, flags,
|
|
extack);
|
|
if (err < 0)
|
|
goto errout;
|
|
|
|
err = tcf_em_tree_validate(tp, tb[TCA_CGROUP_EMATCHES], &new->ematches);
|
|
if (err < 0)
|
|
goto errout;
|
|
|
|
rcu_assign_pointer(tp->root, new);
|
|
if (head) {
|
|
tcf_exts_get_net(&head->exts);
|
|
tcf_queue_work(&head->rwork, cls_cgroup_destroy_work);
|
|
}
|
|
return 0;
|
|
errout:
|
|
tcf_exts_destroy(&new->exts);
|
|
kfree(new);
|
|
return err;
|
|
}
|
|
|
|
static void cls_cgroup_destroy(struct tcf_proto *tp, bool rtnl_held,
|
|
struct netlink_ext_ack *extack)
|
|
{
|
|
struct cls_cgroup_head *head = rtnl_dereference(tp->root);
|
|
|
|
/* Head can still be NULL due to cls_cgroup_init(). */
|
|
if (head) {
|
|
if (tcf_exts_get_net(&head->exts))
|
|
tcf_queue_work(&head->rwork, cls_cgroup_destroy_work);
|
|
else
|
|
__cls_cgroup_destroy(head);
|
|
}
|
|
}
|
|
|
|
static int cls_cgroup_delete(struct tcf_proto *tp, void *arg, bool *last,
|
|
bool rtnl_held, struct netlink_ext_ack *extack)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static void cls_cgroup_walk(struct tcf_proto *tp, struct tcf_walker *arg,
|
|
bool rtnl_held)
|
|
{
|
|
struct cls_cgroup_head *head = rtnl_dereference(tp->root);
|
|
|
|
if (arg->count < arg->skip)
|
|
goto skip;
|
|
|
|
if (!head)
|
|
return;
|
|
if (arg->fn(tp, head, arg) < 0) {
|
|
arg->stop = 1;
|
|
return;
|
|
}
|
|
skip:
|
|
arg->count++;
|
|
}
|
|
|
|
static int cls_cgroup_dump(struct net *net, struct tcf_proto *tp, void *fh,
|
|
struct sk_buff *skb, struct tcmsg *t, bool rtnl_held)
|
|
{
|
|
struct cls_cgroup_head *head = rtnl_dereference(tp->root);
|
|
struct nlattr *nest;
|
|
|
|
t->tcm_handle = head->handle;
|
|
|
|
nest = nla_nest_start_noflag(skb, TCA_OPTIONS);
|
|
if (nest == NULL)
|
|
goto nla_put_failure;
|
|
|
|
if (tcf_exts_dump(skb, &head->exts) < 0 ||
|
|
tcf_em_tree_dump(skb, &head->ematches, TCA_CGROUP_EMATCHES) < 0)
|
|
goto nla_put_failure;
|
|
|
|
nla_nest_end(skb, nest);
|
|
|
|
if (tcf_exts_dump_stats(skb, &head->exts) < 0)
|
|
goto nla_put_failure;
|
|
|
|
return skb->len;
|
|
|
|
nla_put_failure:
|
|
nla_nest_cancel(skb, nest);
|
|
return -1;
|
|
}
|
|
|
|
static struct tcf_proto_ops cls_cgroup_ops __read_mostly = {
|
|
.kind = "cgroup",
|
|
.init = cls_cgroup_init,
|
|
.change = cls_cgroup_change,
|
|
.classify = cls_cgroup_classify,
|
|
.destroy = cls_cgroup_destroy,
|
|
.get = cls_cgroup_get,
|
|
.delete = cls_cgroup_delete,
|
|
.walk = cls_cgroup_walk,
|
|
.dump = cls_cgroup_dump,
|
|
.owner = THIS_MODULE,
|
|
};
|
|
MODULE_ALIAS_NET_CLS("cgroup");
|
|
|
|
static int __init init_cgroup_cls(void)
|
|
{
|
|
return register_tcf_proto_ops(&cls_cgroup_ops);
|
|
}
|
|
|
|
static void __exit exit_cgroup_cls(void)
|
|
{
|
|
unregister_tcf_proto_ops(&cls_cgroup_ops);
|
|
}
|
|
|
|
module_init(init_cgroup_cls);
|
|
module_exit(exit_cgroup_cls);
|
|
MODULE_DESCRIPTION("TC cgroup classifier");
|
|
MODULE_LICENSE("GPL");
|