1 /* net/sched/sch_ingress.c - Ingress and clsact qdisc
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License
5 * as published by the Free Software Foundation; either version
6 * 2 of the License, or (at your option) any later version.
8 * Authors: Jamal Hadi Salim 1999
11 #include <linux/module.h>
12 #include <linux/types.h>
13 #include <linux/list.h>
14 #include <linux/skbuff.h>
15 #include <linux/rtnetlink.h>
17 #include <net/netlink.h>
18 #include <net/pkt_sched.h>
19 #include <net/pkt_cls.h>
21 struct ingress_sched_data
{
22 struct tcf_block
*block
;
23 struct tcf_block_ext_info block_info
;
24 struct mini_Qdisc_pair miniqp
;
27 static struct Qdisc
*ingress_leaf(struct Qdisc
*sch
, unsigned long arg
)
32 static unsigned long ingress_find(struct Qdisc
*sch
, u32 classid
)
34 return TC_H_MIN(classid
) + 1;
37 static unsigned long ingress_bind_filter(struct Qdisc
*sch
,
38 unsigned long parent
, u32 classid
)
40 return ingress_find(sch
, classid
);
43 static void ingress_unbind_filter(struct Qdisc
*sch
, unsigned long cl
)
47 static void ingress_walk(struct Qdisc
*sch
, struct qdisc_walker
*walker
)
51 static struct tcf_block
*ingress_tcf_block(struct Qdisc
*sch
, unsigned long cl
)
53 struct ingress_sched_data
*q
= qdisc_priv(sch
);
58 static void clsact_chain_head_change(struct tcf_proto
*tp_head
, void *priv
)
60 struct mini_Qdisc_pair
*miniqp
= priv
;
62 mini_qdisc_pair_swap(miniqp
, tp_head
);
65 static int ingress_init(struct Qdisc
*sch
, struct nlattr
*opt
)
67 struct ingress_sched_data
*q
= qdisc_priv(sch
);
68 struct net_device
*dev
= qdisc_dev(sch
);
71 net_inc_ingress_queue();
73 mini_qdisc_pair_init(&q
->miniqp
, sch
, &dev
->miniq_ingress
);
75 q
->block_info
.binder_type
= TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS
;
76 q
->block_info
.chain_head_change
= clsact_chain_head_change
;
77 q
->block_info
.chain_head_change_priv
= &q
->miniqp
;
79 err
= tcf_block_get_ext(&q
->block
, sch
, &q
->block_info
);
83 sch
->flags
|= TCQ_F_CPUSTATS
;
88 static void ingress_destroy(struct Qdisc
*sch
)
90 struct ingress_sched_data
*q
= qdisc_priv(sch
);
92 tcf_block_put_ext(q
->block
, sch
, &q
->block_info
);
93 net_dec_ingress_queue();
96 static int ingress_dump(struct Qdisc
*sch
, struct sk_buff
*skb
)
100 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
102 goto nla_put_failure
;
104 return nla_nest_end(skb
, nest
);
107 nla_nest_cancel(skb
, nest
);
111 static const struct Qdisc_class_ops ingress_class_ops
= {
112 .leaf
= ingress_leaf
,
113 .find
= ingress_find
,
114 .walk
= ingress_walk
,
115 .tcf_block
= ingress_tcf_block
,
116 .bind_tcf
= ingress_bind_filter
,
117 .unbind_tcf
= ingress_unbind_filter
,
120 static struct Qdisc_ops ingress_qdisc_ops __read_mostly
= {
121 .cl_ops
= &ingress_class_ops
,
123 .priv_size
= sizeof(struct ingress_sched_data
),
124 .init
= ingress_init
,
125 .destroy
= ingress_destroy
,
126 .dump
= ingress_dump
,
127 .owner
= THIS_MODULE
,
130 struct clsact_sched_data
{
131 struct tcf_block
*ingress_block
;
132 struct tcf_block
*egress_block
;
133 struct tcf_block_ext_info ingress_block_info
;
134 struct tcf_block_ext_info egress_block_info
;
135 struct mini_Qdisc_pair miniqp_ingress
;
136 struct mini_Qdisc_pair miniqp_egress
;
139 static unsigned long clsact_find(struct Qdisc
*sch
, u32 classid
)
141 switch (TC_H_MIN(classid
)) {
142 case TC_H_MIN(TC_H_MIN_INGRESS
):
143 case TC_H_MIN(TC_H_MIN_EGRESS
):
144 return TC_H_MIN(classid
);
150 static unsigned long clsact_bind_filter(struct Qdisc
*sch
,
151 unsigned long parent
, u32 classid
)
153 return clsact_find(sch
, classid
);
156 static struct tcf_block
*clsact_tcf_block(struct Qdisc
*sch
, unsigned long cl
)
158 struct clsact_sched_data
*q
= qdisc_priv(sch
);
161 case TC_H_MIN(TC_H_MIN_INGRESS
):
162 return q
->ingress_block
;
163 case TC_H_MIN(TC_H_MIN_EGRESS
):
164 return q
->egress_block
;
170 static int clsact_init(struct Qdisc
*sch
, struct nlattr
*opt
)
172 struct clsact_sched_data
*q
= qdisc_priv(sch
);
173 struct net_device
*dev
= qdisc_dev(sch
);
176 net_inc_ingress_queue();
177 net_inc_egress_queue();
179 mini_qdisc_pair_init(&q
->miniqp_ingress
, sch
, &dev
->miniq_ingress
);
181 q
->ingress_block_info
.binder_type
= TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS
;
182 q
->ingress_block_info
.chain_head_change
= clsact_chain_head_change
;
183 q
->ingress_block_info
.chain_head_change_priv
= &q
->miniqp_ingress
;
185 err
= tcf_block_get_ext(&q
->ingress_block
, sch
, &q
->ingress_block_info
);
189 mini_qdisc_pair_init(&q
->miniqp_egress
, sch
, &dev
->miniq_egress
);
191 q
->egress_block_info
.binder_type
= TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS
;
192 q
->egress_block_info
.chain_head_change
= clsact_chain_head_change
;
193 q
->egress_block_info
.chain_head_change_priv
= &q
->miniqp_egress
;
195 err
= tcf_block_get_ext(&q
->egress_block
, sch
, &q
->egress_block_info
);
199 sch
->flags
|= TCQ_F_CPUSTATS
;
204 static void clsact_destroy(struct Qdisc
*sch
)
206 struct clsact_sched_data
*q
= qdisc_priv(sch
);
208 tcf_block_put_ext(q
->egress_block
, sch
, &q
->egress_block_info
);
209 tcf_block_put_ext(q
->ingress_block
, sch
, &q
->ingress_block_info
);
211 net_dec_ingress_queue();
212 net_dec_egress_queue();
215 static const struct Qdisc_class_ops clsact_class_ops
= {
216 .leaf
= ingress_leaf
,
218 .walk
= ingress_walk
,
219 .tcf_block
= clsact_tcf_block
,
220 .bind_tcf
= clsact_bind_filter
,
221 .unbind_tcf
= ingress_unbind_filter
,
224 static struct Qdisc_ops clsact_qdisc_ops __read_mostly
= {
225 .cl_ops
= &clsact_class_ops
,
227 .priv_size
= sizeof(struct clsact_sched_data
),
229 .destroy
= clsact_destroy
,
230 .dump
= ingress_dump
,
231 .owner
= THIS_MODULE
,
234 static int __init
ingress_module_init(void)
238 ret
= register_qdisc(&ingress_qdisc_ops
);
240 ret
= register_qdisc(&clsact_qdisc_ops
);
242 unregister_qdisc(&ingress_qdisc_ops
);
248 static void __exit
ingress_module_exit(void)
250 unregister_qdisc(&ingress_qdisc_ops
);
251 unregister_qdisc(&clsact_qdisc_ops
);
254 module_init(ingress_module_init
);
255 module_exit(ingress_module_exit
);
257 MODULE_ALIAS("sch_clsact");
258 MODULE_LICENSE("GPL");