mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-26 22:24:09 +08:00
4577139b2d
Even if we make use of classifier and actions from the egress
path, we're going into handle_ing() executing additional code
on a per-packet cost for ingress qdisc, just to realize that
nothing is attached on ingress.
Instead, this can just be blinded out as a no-op entirely with
the use of a static key. On input fast-path, we already make
use of static keys in various places, e.g. skb time stamping,
in RPS, etc. It makes sense to not waste time when we're assured
that no ingress qdisc is attached anywhere.
Enabling/disabling of that code path is being done via two
helpers, namely net_{inc,dec}_ingress_queue(), that are being
invoked under RTNL mutex when a ingress qdisc is being either
initialized or destructed.
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Alexei Starovoitov <ast@plumgrid.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
154 lines
3.4 KiB
C
154 lines
3.4 KiB
C
/* net/sched/sch_ingress.c - Ingress qdisc
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*
|
|
* Authors: Jamal Hadi Salim 1999
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/list.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <net/netlink.h>
|
|
#include <net/pkt_sched.h>
|
|
|
|
|
|
struct ingress_qdisc_data {
|
|
struct tcf_proto __rcu *filter_list;
|
|
};
|
|
|
|
/* ------------------------- Class/flow operations ------------------------- */
|
|
|
|
static struct Qdisc *ingress_leaf(struct Qdisc *sch, unsigned long arg)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static unsigned long ingress_get(struct Qdisc *sch, u32 classid)
|
|
{
|
|
return TC_H_MIN(classid) + 1;
|
|
}
|
|
|
|
static unsigned long ingress_bind_filter(struct Qdisc *sch,
|
|
unsigned long parent, u32 classid)
|
|
{
|
|
return ingress_get(sch, classid);
|
|
}
|
|
|
|
static void ingress_put(struct Qdisc *sch, unsigned long cl)
|
|
{
|
|
}
|
|
|
|
static void ingress_walk(struct Qdisc *sch, struct qdisc_walker *walker)
|
|
{
|
|
}
|
|
|
|
static struct tcf_proto __rcu **ingress_find_tcf(struct Qdisc *sch,
|
|
unsigned long cl)
|
|
{
|
|
struct ingress_qdisc_data *p = qdisc_priv(sch);
|
|
|
|
return &p->filter_list;
|
|
}
|
|
|
|
/* --------------------------- Qdisc operations ---------------------------- */
|
|
|
|
static int ingress_enqueue(struct sk_buff *skb, struct Qdisc *sch)
|
|
{
|
|
struct ingress_qdisc_data *p = qdisc_priv(sch);
|
|
struct tcf_result res;
|
|
struct tcf_proto *fl = rcu_dereference_bh(p->filter_list);
|
|
int result;
|
|
|
|
result = tc_classify(skb, fl, &res);
|
|
|
|
qdisc_bstats_update(sch, skb);
|
|
switch (result) {
|
|
case TC_ACT_SHOT:
|
|
result = TC_ACT_SHOT;
|
|
qdisc_qstats_drop(sch);
|
|
break;
|
|
case TC_ACT_STOLEN:
|
|
case TC_ACT_QUEUED:
|
|
result = TC_ACT_STOLEN;
|
|
break;
|
|
case TC_ACT_RECLASSIFY:
|
|
case TC_ACT_OK:
|
|
skb->tc_index = TC_H_MIN(res.classid);
|
|
default:
|
|
result = TC_ACT_OK;
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* ------------------------------------------------------------- */
|
|
|
|
static int ingress_init(struct Qdisc *sch, struct nlattr *opt)
|
|
{
|
|
net_inc_ingress_queue();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void ingress_destroy(struct Qdisc *sch)
|
|
{
|
|
struct ingress_qdisc_data *p = qdisc_priv(sch);
|
|
|
|
tcf_destroy_chain(&p->filter_list);
|
|
net_dec_ingress_queue();
|
|
}
|
|
|
|
static int ingress_dump(struct Qdisc *sch, struct sk_buff *skb)
|
|
{
|
|
struct nlattr *nest;
|
|
|
|
nest = nla_nest_start(skb, TCA_OPTIONS);
|
|
if (nest == NULL)
|
|
goto nla_put_failure;
|
|
return nla_nest_end(skb, nest);
|
|
|
|
nla_put_failure:
|
|
nla_nest_cancel(skb, nest);
|
|
return -1;
|
|
}
|
|
|
|
static const struct Qdisc_class_ops ingress_class_ops = {
|
|
.leaf = ingress_leaf,
|
|
.get = ingress_get,
|
|
.put = ingress_put,
|
|
.walk = ingress_walk,
|
|
.tcf_chain = ingress_find_tcf,
|
|
.bind_tcf = ingress_bind_filter,
|
|
.unbind_tcf = ingress_put,
|
|
};
|
|
|
|
static struct Qdisc_ops ingress_qdisc_ops __read_mostly = {
|
|
.cl_ops = &ingress_class_ops,
|
|
.id = "ingress",
|
|
.priv_size = sizeof(struct ingress_qdisc_data),
|
|
.enqueue = ingress_enqueue,
|
|
.init = ingress_init,
|
|
.destroy = ingress_destroy,
|
|
.dump = ingress_dump,
|
|
.owner = THIS_MODULE,
|
|
};
|
|
|
|
static int __init ingress_module_init(void)
|
|
{
|
|
return register_qdisc(&ingress_qdisc_ops);
|
|
}
|
|
|
|
static void __exit ingress_module_exit(void)
|
|
{
|
|
unregister_qdisc(&ingress_qdisc_ops);
|
|
}
|
|
|
|
module_init(ingress_module_init)
|
|
module_exit(ingress_module_exit)
|
|
MODULE_LICENSE("GPL");
|