blob: 69791ca77a05f6231b1349bce5aeb38aa018bd8c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/sched/police.c Input police filter.
3 *
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.
8 *
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 * J Hadi Salim (action changes)
11 */
12
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/module.h>
14#include <linux/types.h>
15#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/rtnetlink.h>
20#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <net/act_api.h>
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -070023#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Jiri Pirko0e243212013-02-12 00:12:06 +000025struct tcf_police {
26 struct tcf_common common;
27 int tcfp_result;
28 u32 tcfp_ewma_rate;
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +000029 s64 tcfp_burst;
Jiri Pirko0e243212013-02-12 00:12:06 +000030 u32 tcfp_mtu;
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +000031 s64 tcfp_toks;
32 s64 tcfp_ptoks;
33 s64 tcfp_mtu_ptoks;
34 s64 tcfp_t_c;
35 struct psched_ratecfg rate;
36 bool rate_present;
37 struct psched_ratecfg peak;
38 bool peak_present;
Jiri Pirko0e243212013-02-12 00:12:06 +000039};
40#define to_police(pc) \
41 container_of(pc, struct tcf_police, common)
42
David S. Millere9ce1cd2006-08-21 23:54:55 -070043#define POL_TAB_MASK 15
David S. Millere9ce1cd2006-08-21 23:54:55 -070044
Patrick McHardy1e9b3d52006-11-30 19:54:05 -080045/* old policer structure from before tc actions */
Eric Dumazetcc7ec452011-01-19 19:26:56 +000046struct tc_police_compat {
Patrick McHardy1e9b3d52006-11-30 19:54:05 -080047 u32 index;
48 int action;
49 u32 limit;
50 u32 burst;
51 u32 mtu;
52 struct tc_ratespec rate;
53 struct tc_ratespec peakrate;
54};
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056/* Each policer is serialized by its individual spinlock */
57
Jamal Hadi Salim83b950c2006-04-06 22:24:22 -070058static int tcf_act_police_walker(struct sk_buff *skb, struct netlink_callback *cb,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +090059 int type, struct tc_action *a)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060{
WANG Congc779f7a2014-01-17 11:37:02 -080061 struct tcf_hashinfo *hinfo = a->ops->hinfo;
WANG Cong89819dc2013-12-15 20:15:09 -080062 struct hlist_head *head;
David S. Millere9ce1cd2006-08-21 23:54:55 -070063 struct tcf_common *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 int err = 0, index = -1, i = 0, s_i = 0, n_i = 0;
Patrick McHardy4b3550ef2008-01-23 20:34:11 -080065 struct nlattr *nest;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
WANG Congc779f7a2014-01-17 11:37:02 -080067 spin_lock_bh(&hinfo->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
69 s_i = cb->args[0];
70
David S. Millere9ce1cd2006-08-21 23:54:55 -070071 for (i = 0; i < (POL_TAB_MASK + 1); i++) {
WANG Congc779f7a2014-01-17 11:37:02 -080072 head = &hinfo->htab[tcf_hash(i, POL_TAB_MASK)];
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
WANG Cong89819dc2013-12-15 20:15:09 -080074 hlist_for_each_entry_rcu(p, head, tcfc_head) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 index++;
76 if (index < s_i)
77 continue;
78 a->priv = p;
79 a->order = index;
Patrick McHardy4b3550ef2008-01-23 20:34:11 -080080 nest = nla_nest_start(skb, a->order);
81 if (nest == NULL)
82 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 if (type == RTM_DELACTION)
84 err = tcf_action_dump_1(skb, a, 0, 1);
85 else
86 err = tcf_action_dump_1(skb, a, 0, 0);
87 if (err < 0) {
88 index--;
Patrick McHardy4b3550ef2008-01-23 20:34:11 -080089 nla_nest_cancel(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 goto done;
91 }
Patrick McHardy4b3550ef2008-01-23 20:34:11 -080092 nla_nest_end(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 n_i++;
94 }
95 }
96done:
WANG Congc779f7a2014-01-17 11:37:02 -080097 spin_unlock_bh(&hinfo->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 if (n_i)
99 cb->args[0] += n_i;
100 return n_i;
101
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800102nla_put_failure:
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800103 nla_nest_cancel(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 goto done;
105}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
Patrick McHardy53b2bf32008-01-23 20:36:30 -0800107static const struct nla_policy police_policy[TCA_POLICE_MAX + 1] = {
108 [TCA_POLICE_RATE] = { .len = TC_RTAB_SIZE },
109 [TCA_POLICE_PEAKRATE] = { .len = TC_RTAB_SIZE },
110 [TCA_POLICE_AVRATE] = { .type = NLA_U32 },
111 [TCA_POLICE_RESULT] = { .type = NLA_U32 },
112};
113
Benjamin LaHaisec1b52732013-01-14 05:15:39 +0000114static int tcf_act_police_locate(struct net *net, struct nlattr *nla,
115 struct nlattr *est, struct tc_action *a,
116 int ovr, int bind)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000118 unsigned int h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 int ret = 0, err;
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800120 struct nlattr *tb[TCA_POLICE_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 struct tc_police *parm;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700122 struct tcf_police *police;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 struct qdisc_rate_table *R_tab = NULL, *P_tab = NULL;
WANG Congc779f7a2014-01-17 11:37:02 -0800124 struct tcf_hashinfo *hinfo = a->ops->hinfo;
Patrick McHardy1e9b3d52006-11-30 19:54:05 -0800125 int size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Patrick McHardycee63722008-01-23 20:33:32 -0800127 if (nla == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 return -EINVAL;
129
Patrick McHardy53b2bf32008-01-23 20:36:30 -0800130 err = nla_parse_nested(tb, TCA_POLICE_MAX, nla, police_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800131 if (err < 0)
132 return err;
133
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800134 if (tb[TCA_POLICE_TBF] == NULL)
Patrick McHardy1e9b3d52006-11-30 19:54:05 -0800135 return -EINVAL;
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800136 size = nla_len(tb[TCA_POLICE_TBF]);
Patrick McHardy1e9b3d52006-11-30 19:54:05 -0800137 if (size != sizeof(*parm) && size != sizeof(struct tc_police_compat))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 return -EINVAL;
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800139 parm = nla_data(tb[TCA_POLICE_TBF]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
David S. Millere9ce1cd2006-08-21 23:54:55 -0700141 if (parm->index) {
WANG Cong6e6a50c2014-01-17 11:37:03 -0800142 if (tcf_hash_search(a, parm->index)) {
143 police = to_police(a->priv);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700144 if (bind) {
145 police->tcf_bindcnt += 1;
146 police->tcf_refcnt += 1;
Jamal Hadi Salim1a293212013-12-23 08:02:11 -0500147 return 0;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700148 }
149 if (ovr)
150 goto override;
Jamal Hadi Salim1a293212013-12-23 08:02:11 -0500151 /* not replacing */
152 return -EEXIST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 }
155
David S. Millere9ce1cd2006-08-21 23:54:55 -0700156 police = kzalloc(sizeof(*police), GFP_KERNEL);
157 if (police == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 ret = ACT_P_CREATED;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700160 police->tcf_refcnt = 1;
161 spin_lock_init(&police->tcf_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 if (bind)
David S. Millere9ce1cd2006-08-21 23:54:55 -0700163 police->tcf_bindcnt = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164override:
165 if (parm->rate.rate) {
166 err = -ENOMEM;
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800167 R_tab = qdisc_get_rtab(&parm->rate, tb[TCA_POLICE_RATE]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 if (R_tab == NULL)
169 goto failure;
Stephen Hemmingerc1b56872008-11-25 21:14:06 -0800170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 if (parm->peakrate.rate) {
172 P_tab = qdisc_get_rtab(&parm->peakrate,
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800173 tb[TCA_POLICE_PEAKRATE]);
Stephen Hemminger71bcb092008-11-25 21:13:31 -0800174 if (P_tab == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 }
177 }
Stephen Hemminger71bcb092008-11-25 21:13:31 -0800178
David S. Millere9ce1cd2006-08-21 23:54:55 -0700179 spin_lock_bh(&police->tcf_lock);
Stephen Hemminger71bcb092008-11-25 21:13:31 -0800180 if (est) {
John Fastabend22e0f8b2014-09-28 11:52:56 -0700181 err = gen_replace_estimator(&police->tcf_bstats, NULL,
Stephen Hemminger71bcb092008-11-25 21:13:31 -0800182 &police->tcf_rate_est,
183 &police->tcf_lock, est);
184 if (err)
185 goto failure_unlock;
Jarek Poplawskia883bf52009-03-04 17:38:10 -0800186 } else if (tb[TCA_POLICE_AVRATE] &&
187 (ret == ACT_P_CREATED ||
188 !gen_estimator_active(&police->tcf_bstats,
189 &police->tcf_rate_est))) {
190 err = -EINVAL;
191 goto failure_unlock;
Stephen Hemminger71bcb092008-11-25 21:13:31 -0800192 }
193
194 /* No failure allowed after this point */
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000195 police->tcfp_mtu = parm->mtu;
196 if (police->tcfp_mtu == 0) {
197 police->tcfp_mtu = ~0;
198 if (R_tab)
199 police->tcfp_mtu = 255 << R_tab->rate.cell_log;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 }
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000201 if (R_tab) {
202 police->rate_present = true;
Eric Dumazet3e1e3aa2013-09-19 09:10:03 -0700203 psched_ratecfg_precompute(&police->rate, &R_tab->rate, 0);
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000204 qdisc_put_rtab(R_tab);
205 } else {
206 police->rate_present = false;
207 }
208 if (P_tab) {
209 police->peak_present = true;
Eric Dumazet3e1e3aa2013-09-19 09:10:03 -0700210 psched_ratecfg_precompute(&police->peak, &P_tab->rate, 0);
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000211 qdisc_put_rtab(P_tab);
212 } else {
213 police->peak_present = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800216 if (tb[TCA_POLICE_RESULT])
Patrick McHardy1587bac2008-01-23 20:35:03 -0800217 police->tcfp_result = nla_get_u32(tb[TCA_POLICE_RESULT]);
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000218 police->tcfp_burst = PSCHED_TICKS2NS(parm->burst);
219 police->tcfp_toks = police->tcfp_burst;
220 if (police->peak_present) {
221 police->tcfp_mtu_ptoks = (s64) psched_l2t_ns(&police->peak,
222 police->tcfp_mtu);
223 police->tcfp_ptoks = police->tcfp_mtu_ptoks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 }
David S. Millere9ce1cd2006-08-21 23:54:55 -0700225 police->tcf_action = parm->action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800227 if (tb[TCA_POLICE_AVRATE])
Patrick McHardy1587bac2008-01-23 20:35:03 -0800228 police->tcfp_ewma_rate = nla_get_u32(tb[TCA_POLICE_AVRATE]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
David S. Millere9ce1cd2006-08-21 23:54:55 -0700230 spin_unlock_bh(&police->tcf_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 if (ret != ACT_P_CREATED)
232 return ret;
233
Eric Dumazetd2de8752014-08-22 18:32:09 -0700234 police->tcfp_t_c = ktime_get_ns();
David S. Millere9ce1cd2006-08-21 23:54:55 -0700235 police->tcf_index = parm->index ? parm->index :
WANG Cong4f1e9d82014-02-11 17:07:33 -0800236 tcf_hash_new_index(hinfo);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700237 h = tcf_hash(police->tcf_index, POL_TAB_MASK);
WANG Congc779f7a2014-01-17 11:37:02 -0800238 spin_lock_bh(&hinfo->lock);
239 hlist_add_head(&police->tcf_head, &hinfo->htab[h]);
240 spin_unlock_bh(&hinfo->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
David S. Millere9ce1cd2006-08-21 23:54:55 -0700242 a->priv = police;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 return ret;
244
Stephen Hemminger71bcb092008-11-25 21:13:31 -0800245failure_unlock:
246 spin_unlock_bh(&police->tcf_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247failure:
Yang Yingliang3b69a4c2013-12-17 15:29:16 +0800248 qdisc_put_rtab(P_tab);
249 qdisc_put_rtab(R_tab);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 if (ret == ACT_P_CREATED)
David S. Millere9ce1cd2006-08-21 23:54:55 -0700251 kfree(police);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 return err;
253}
254
Eric Dumazetdc7f9f62011-07-05 23:25:42 +0000255static int tcf_act_police(struct sk_buff *skb, const struct tc_action *a,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900256 struct tcf_result *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
David S. Millere9ce1cd2006-08-21 23:54:55 -0700258 struct tcf_police *police = a->priv;
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000259 s64 now;
260 s64 toks;
261 s64 ptoks = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
David S. Millere9ce1cd2006-08-21 23:54:55 -0700263 spin_lock(&police->tcf_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
Eric Dumazetbfe0d022011-01-09 08:30:54 +0000265 bstats_update(&police->tcf_bstats, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
David S. Millere9ce1cd2006-08-21 23:54:55 -0700267 if (police->tcfp_ewma_rate &&
268 police->tcf_rate_est.bps >= police->tcfp_ewma_rate) {
269 police->tcf_qstats.overlimits++;
Jarek Poplawskib9647582009-06-16 08:33:55 +0000270 if (police->tcf_action == TC_ACT_SHOT)
271 police->tcf_qstats.drops++;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700272 spin_unlock(&police->tcf_lock);
273 return police->tcf_action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Jussi Kivilinna0abf77e2008-07-20 00:08:27 -0700276 if (qdisc_pkt_len(skb) <= police->tcfp_mtu) {
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000277 if (!police->rate_present) {
David S. Millere9ce1cd2006-08-21 23:54:55 -0700278 spin_unlock(&police->tcf_lock);
279 return police->tcfp_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 }
281
Eric Dumazetd2de8752014-08-22 18:32:09 -0700282 now = ktime_get_ns();
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000283 toks = min_t(s64, now - police->tcfp_t_c,
284 police->tcfp_burst);
285 if (police->peak_present) {
David S. Millere9ce1cd2006-08-21 23:54:55 -0700286 ptoks = toks + police->tcfp_ptoks;
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000287 if (ptoks > police->tcfp_mtu_ptoks)
288 ptoks = police->tcfp_mtu_ptoks;
289 ptoks -= (s64) psched_l2t_ns(&police->peak,
290 qdisc_pkt_len(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 }
David S. Millere9ce1cd2006-08-21 23:54:55 -0700292 toks += police->tcfp_toks;
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000293 if (toks > police->tcfp_burst)
David S. Millere9ce1cd2006-08-21 23:54:55 -0700294 toks = police->tcfp_burst;
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000295 toks -= (s64) psched_l2t_ns(&police->rate, qdisc_pkt_len(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 if ((toks|ptoks) >= 0) {
David S. Millere9ce1cd2006-08-21 23:54:55 -0700297 police->tcfp_t_c = now;
298 police->tcfp_toks = toks;
299 police->tcfp_ptoks = ptoks;
300 spin_unlock(&police->tcf_lock);
301 return police->tcfp_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 }
303 }
304
David S. Millere9ce1cd2006-08-21 23:54:55 -0700305 police->tcf_qstats.overlimits++;
Jarek Poplawskib9647582009-06-16 08:33:55 +0000306 if (police->tcf_action == TC_ACT_SHOT)
307 police->tcf_qstats.drops++;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700308 spin_unlock(&police->tcf_lock);
309 return police->tcf_action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310}
311
312static int
313tcf_act_police_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
314{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700315 unsigned char *b = skb_tail_pointer(skb);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700316 struct tcf_police *police = a->priv;
Jeff Mahoney0f04cfd2010-08-31 13:21:42 +0000317 struct tc_police opt = {
318 .index = police->tcf_index,
319 .action = police->tcf_action,
320 .mtu = police->tcfp_mtu,
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000321 .burst = PSCHED_NS2TICKS(police->tcfp_burst),
Jeff Mahoney0f04cfd2010-08-31 13:21:42 +0000322 .refcnt = police->tcf_refcnt - ref,
323 .bindcnt = police->tcf_bindcnt - bind,
324 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000326 if (police->rate_present)
Eric Dumazet01cb71d2013-06-02 13:55:05 +0000327 psched_ratecfg_getrate(&opt.rate, &police->rate);
Jiri Pirkoc6d14ff2013-02-12 00:12:07 +0000328 if (police->peak_present)
Eric Dumazet01cb71d2013-06-02 13:55:05 +0000329 psched_ratecfg_getrate(&opt.peakrate, &police->peak);
David S. Miller1b34ec42012-03-29 05:11:39 -0400330 if (nla_put(skb, TCA_POLICE_TBF, sizeof(opt), &opt))
331 goto nla_put_failure;
332 if (police->tcfp_result &&
333 nla_put_u32(skb, TCA_POLICE_RESULT, police->tcfp_result))
334 goto nla_put_failure;
335 if (police->tcfp_ewma_rate &&
336 nla_put_u32(skb, TCA_POLICE_AVRATE, police->tcfp_ewma_rate))
337 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 return skb->len;
339
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800340nla_put_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700341 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 return -1;
343}
344
345MODULE_AUTHOR("Alexey Kuznetsov");
346MODULE_DESCRIPTION("Policing actions");
347MODULE_LICENSE("GPL");
348
349static struct tc_action_ops act_police_ops = {
350 .kind = "police",
351 .type = TCA_ID_POLICE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 .owner = THIS_MODULE,
353 .act = tcf_act_police,
354 .dump = tcf_act_police_dump,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 .init = tcf_act_police_locate,
Jamal Hadi Salim83b950c2006-04-06 22:24:22 -0700356 .walk = tcf_act_police_walker
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357};
358
359static int __init
360police_init_module(void)
361{
WANG Cong4f1e9d82014-02-11 17:07:33 -0800362 return tcf_register_action(&act_police_ops, POL_TAB_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363}
364
365static void __exit
366police_cleanup_module(void)
367{
368 tcf_unregister_action(&act_police_ops);
369}
370
371module_init(police_init_module);
372module_exit(police_cleanup_module);