2 * net/sched/act_police.c Input police filter
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 * J Hadi Salim (action changes)
13 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/skbuff.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/init.h>
21 #include <linux/slab.h>
22 #include <net/act_api.h>
23 #include <net/netlink.h>
26 struct tc_action common
;
35 struct psched_ratecfg rate
;
37 struct psched_ratecfg peak
;
41 #define to_police(pc) ((struct tcf_police *)pc)
43 #define POL_TAB_MASK 15
45 /* old policer structure from before tc actions */
46 struct tc_police_compat
{
52 struct tc_ratespec rate
;
53 struct tc_ratespec peakrate
;
56 /* Each policer is serialized by its individual spinlock */
58 static int police_net_id
;
59 static struct tc_action_ops act_police_ops
;
61 static int tcf_act_police_walker(struct net
*net
, struct sk_buff
*skb
,
62 struct netlink_callback
*cb
, int type
,
63 const struct tc_action_ops
*ops
)
65 struct tc_action_net
*tn
= net_generic(net
, police_net_id
);
66 struct tcf_hashinfo
*hinfo
= tn
->hinfo
;
67 int err
= 0, index
= -1, i
= 0, s_i
= 0, n_i
= 0;
70 spin_lock_bh(&hinfo
->lock
);
74 for (i
= 0; i
< (POL_TAB_MASK
+ 1); i
++) {
75 struct hlist_head
*head
;
78 head
= &hinfo
->htab
[tcf_hash(i
, POL_TAB_MASK
)];
80 hlist_for_each_entry_rcu(p
, head
, tcfa_head
) {
84 nest
= nla_nest_start(skb
, index
);
87 if (type
== RTM_DELACTION
)
88 err
= tcf_action_dump_1(skb
, p
, 0, 1);
90 err
= tcf_action_dump_1(skb
, p
, 0, 0);
93 nla_nest_cancel(skb
, nest
);
96 nla_nest_end(skb
, nest
);
101 spin_unlock_bh(&hinfo
->lock
);
107 nla_nest_cancel(skb
, nest
);
111 static const struct nla_policy police_policy
[TCA_POLICE_MAX
+ 1] = {
112 [TCA_POLICE_RATE
] = { .len
= TC_RTAB_SIZE
},
113 [TCA_POLICE_PEAKRATE
] = { .len
= TC_RTAB_SIZE
},
114 [TCA_POLICE_AVRATE
] = { .type
= NLA_U32
},
115 [TCA_POLICE_RESULT
] = { .type
= NLA_U32
},
118 static int tcf_act_police_init(struct net
*net
, struct nlattr
*nla
,
119 struct nlattr
*est
, struct tc_action
**a
,
123 struct nlattr
*tb
[TCA_POLICE_MAX
+ 1];
124 struct tc_police
*parm
;
125 struct tcf_police
*police
;
126 struct qdisc_rate_table
*R_tab
= NULL
, *P_tab
= NULL
;
127 struct tc_action_net
*tn
= net_generic(net
, police_net_id
);
134 err
= nla_parse_nested(tb
, TCA_POLICE_MAX
, nla
, police_policy
);
138 if (tb
[TCA_POLICE_TBF
] == NULL
)
140 size
= nla_len(tb
[TCA_POLICE_TBF
]);
141 if (size
!= sizeof(*parm
) && size
!= sizeof(struct tc_police_compat
))
144 parm
= nla_data(tb
[TCA_POLICE_TBF
]);
145 exists
= tcf_hash_check(tn
, parm
->index
, a
, bind
);
150 ret
= tcf_hash_create(tn
, parm
->index
, NULL
, a
,
151 &act_police_ops
, bind
, false);
156 tcf_hash_release(*a
, bind
);
161 police
= to_police(*a
);
162 if (parm
->rate
.rate
) {
164 R_tab
= qdisc_get_rtab(&parm
->rate
, tb
[TCA_POLICE_RATE
]);
168 if (parm
->peakrate
.rate
) {
169 P_tab
= qdisc_get_rtab(&parm
->peakrate
,
170 tb
[TCA_POLICE_PEAKRATE
]);
176 spin_lock_bh(&police
->tcf_lock
);
178 err
= gen_replace_estimator(&police
->tcf_bstats
, NULL
,
179 &police
->tcf_rate_est
,
184 } else if (tb
[TCA_POLICE_AVRATE
] &&
185 (ret
== ACT_P_CREATED
||
186 !gen_estimator_active(&police
->tcf_bstats
,
187 &police
->tcf_rate_est
))) {
192 /* No failure allowed after this point */
193 police
->tcfp_mtu
= parm
->mtu
;
194 if (police
->tcfp_mtu
== 0) {
195 police
->tcfp_mtu
= ~0;
197 police
->tcfp_mtu
= 255 << R_tab
->rate
.cell_log
;
200 police
->rate_present
= true;
201 psched_ratecfg_precompute(&police
->rate
, &R_tab
->rate
, 0);
202 qdisc_put_rtab(R_tab
);
204 police
->rate_present
= false;
207 police
->peak_present
= true;
208 psched_ratecfg_precompute(&police
->peak
, &P_tab
->rate
, 0);
209 qdisc_put_rtab(P_tab
);
211 police
->peak_present
= false;
214 if (tb
[TCA_POLICE_RESULT
])
215 police
->tcfp_result
= nla_get_u32(tb
[TCA_POLICE_RESULT
]);
216 police
->tcfp_burst
= PSCHED_TICKS2NS(parm
->burst
);
217 police
->tcfp_toks
= police
->tcfp_burst
;
218 if (police
->peak_present
) {
219 police
->tcfp_mtu_ptoks
= (s64
) psched_l2t_ns(&police
->peak
,
221 police
->tcfp_ptoks
= police
->tcfp_mtu_ptoks
;
223 police
->tcf_action
= parm
->action
;
225 if (tb
[TCA_POLICE_AVRATE
])
226 police
->tcfp_ewma_rate
= nla_get_u32(tb
[TCA_POLICE_AVRATE
]);
228 spin_unlock_bh(&police
->tcf_lock
);
229 if (ret
!= ACT_P_CREATED
)
232 police
->tcfp_t_c
= ktime_get_ns();
233 tcf_hash_insert(tn
, *a
);
238 spin_unlock_bh(&police
->tcf_lock
);
240 qdisc_put_rtab(P_tab
);
241 qdisc_put_rtab(R_tab
);
242 if (ret
== ACT_P_CREATED
)
243 tcf_hash_cleanup(*a
, est
);
247 static int tcf_act_police(struct sk_buff
*skb
, const struct tc_action
*a
,
248 struct tcf_result
*res
)
250 struct tcf_police
*police
= to_police(a
);
255 spin_lock(&police
->tcf_lock
);
257 bstats_update(&police
->tcf_bstats
, skb
);
258 tcf_lastuse_update(&police
->tcf_tm
);
260 if (police
->tcfp_ewma_rate
&&
261 police
->tcf_rate_est
.bps
>= police
->tcfp_ewma_rate
) {
262 police
->tcf_qstats
.overlimits
++;
263 if (police
->tcf_action
== TC_ACT_SHOT
)
264 police
->tcf_qstats
.drops
++;
265 spin_unlock(&police
->tcf_lock
);
266 return police
->tcf_action
;
269 if (qdisc_pkt_len(skb
) <= police
->tcfp_mtu
) {
270 if (!police
->rate_present
) {
271 spin_unlock(&police
->tcf_lock
);
272 return police
->tcfp_result
;
275 now
= ktime_get_ns();
276 toks
= min_t(s64
, now
- police
->tcfp_t_c
,
278 if (police
->peak_present
) {
279 ptoks
= toks
+ police
->tcfp_ptoks
;
280 if (ptoks
> police
->tcfp_mtu_ptoks
)
281 ptoks
= police
->tcfp_mtu_ptoks
;
282 ptoks
-= (s64
) psched_l2t_ns(&police
->peak
,
285 toks
+= police
->tcfp_toks
;
286 if (toks
> police
->tcfp_burst
)
287 toks
= police
->tcfp_burst
;
288 toks
-= (s64
) psched_l2t_ns(&police
->rate
, qdisc_pkt_len(skb
));
289 if ((toks
|ptoks
) >= 0) {
290 police
->tcfp_t_c
= now
;
291 police
->tcfp_toks
= toks
;
292 police
->tcfp_ptoks
= ptoks
;
293 spin_unlock(&police
->tcf_lock
);
294 return police
->tcfp_result
;
298 police
->tcf_qstats
.overlimits
++;
299 if (police
->tcf_action
== TC_ACT_SHOT
)
300 police
->tcf_qstats
.drops
++;
301 spin_unlock(&police
->tcf_lock
);
302 return police
->tcf_action
;
306 tcf_act_police_dump(struct sk_buff
*skb
, struct tc_action
*a
, int bind
, int ref
)
308 unsigned char *b
= skb_tail_pointer(skb
);
309 struct tcf_police
*police
= to_police(a
);
310 struct tc_police opt
= {
311 .index
= police
->tcf_index
,
312 .action
= police
->tcf_action
,
313 .mtu
= police
->tcfp_mtu
,
314 .burst
= PSCHED_NS2TICKS(police
->tcfp_burst
),
315 .refcnt
= police
->tcf_refcnt
- ref
,
316 .bindcnt
= police
->tcf_bindcnt
- bind
,
320 if (police
->rate_present
)
321 psched_ratecfg_getrate(&opt
.rate
, &police
->rate
);
322 if (police
->peak_present
)
323 psched_ratecfg_getrate(&opt
.peakrate
, &police
->peak
);
324 if (nla_put(skb
, TCA_POLICE_TBF
, sizeof(opt
), &opt
))
325 goto nla_put_failure
;
326 if (police
->tcfp_result
&&
327 nla_put_u32(skb
, TCA_POLICE_RESULT
, police
->tcfp_result
))
328 goto nla_put_failure
;
329 if (police
->tcfp_ewma_rate
&&
330 nla_put_u32(skb
, TCA_POLICE_AVRATE
, police
->tcfp_ewma_rate
))
331 goto nla_put_failure
;
333 t
.install
= jiffies_to_clock_t(jiffies
- police
->tcf_tm
.install
);
334 t
.lastuse
= jiffies_to_clock_t(jiffies
- police
->tcf_tm
.lastuse
);
335 t
.firstuse
= jiffies_to_clock_t(jiffies
- police
->tcf_tm
.firstuse
);
336 t
.expires
= jiffies_to_clock_t(police
->tcf_tm
.expires
);
337 if (nla_put_64bit(skb
, TCA_POLICE_TM
, sizeof(t
), &t
, TCA_POLICE_PAD
))
338 goto nla_put_failure
;
347 static int tcf_police_search(struct net
*net
, struct tc_action
**a
, u32 index
)
349 struct tc_action_net
*tn
= net_generic(net
, police_net_id
);
351 return tcf_hash_search(tn
, a
, index
);
354 MODULE_AUTHOR("Alexey Kuznetsov");
355 MODULE_DESCRIPTION("Policing actions");
356 MODULE_LICENSE("GPL");
358 static struct tc_action_ops act_police_ops
= {
360 .type
= TCA_ID_POLICE
,
361 .owner
= THIS_MODULE
,
362 .act
= tcf_act_police
,
363 .dump
= tcf_act_police_dump
,
364 .init
= tcf_act_police_init
,
365 .walk
= tcf_act_police_walker
,
366 .lookup
= tcf_police_search
,
367 .size
= sizeof(struct tcf_police
),
370 static __net_init
int police_init_net(struct net
*net
)
372 struct tc_action_net
*tn
= net_generic(net
, police_net_id
);
374 return tc_action_net_init(tn
, &act_police_ops
, POL_TAB_MASK
);
377 static void __net_exit
police_exit_net(struct net
*net
)
379 struct tc_action_net
*tn
= net_generic(net
, police_net_id
);
381 tc_action_net_exit(tn
);
384 static struct pernet_operations police_net_ops
= {
385 .init
= police_init_net
,
386 .exit
= police_exit_net
,
387 .id
= &police_net_id
,
388 .size
= sizeof(struct tc_action_net
),
392 police_init_module(void)
394 return tcf_register_action(&act_police_ops
, &police_net_ops
);
398 police_cleanup_module(void)
400 tcf_unregister_action(&act_police_ops
, &police_net_ops
);
403 module_init(police_init_module
);
404 module_exit(police_cleanup_module
);