~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sched/act_police.c

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.6 ] ~ [ linux-5.4.22 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.106 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.171 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.214 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.214 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * net/sched/act_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 
 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>
 24 
 25 struct tcf_police {
 26         struct tcf_common       common;
 27         int                     tcfp_result;
 28         u32                     tcfp_ewma_rate;
 29         s64                     tcfp_burst;
 30         u32                     tcfp_mtu;
 31         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;
 39 };
 40 #define to_police(pc)   \
 41         container_of(pc, struct tcf_police, common)
 42 
 43 #define POL_TAB_MASK     15
 44 
 45 /* old policer structure from before tc actions */
 46 struct tc_police_compat {
 47         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 
 56 /* Each policer is serialized by its individual spinlock */
 57 
 58 static int police_net_id;
 59 
 60 static int tcf_act_police_walker(struct net *net, struct sk_buff *skb,
 61                                  struct netlink_callback *cb, int type,
 62                                  struct tc_action *a)
 63 {
 64         struct tc_action_net *tn = net_generic(net, police_net_id);
 65         struct tcf_hashinfo *hinfo = tn->hinfo;
 66         struct hlist_head *head;
 67         struct tcf_common *p;
 68         int err = 0, index = -1, i = 0, s_i = 0, n_i = 0;
 69         struct nlattr *nest;
 70 
 71         spin_lock_bh(&hinfo->lock);
 72 
 73         s_i = cb->args[0];
 74 
 75         for (i = 0; i < (POL_TAB_MASK + 1); i++) {
 76                 head = &hinfo->htab[tcf_hash(i, POL_TAB_MASK)];
 77 
 78                 hlist_for_each_entry_rcu(p, head, tcfc_head) {
 79                         index++;
 80                         if (index < s_i)
 81                                 continue;
 82                         a->priv = p;
 83                         a->order = index;
 84                         nest = nla_nest_start(skb, a->order);
 85                         if (nest == NULL)
 86                                 goto nla_put_failure;
 87                         if (type == RTM_DELACTION)
 88                                 err = tcf_action_dump_1(skb, a, 0, 1);
 89                         else
 90                                 err = tcf_action_dump_1(skb, a, 0, 0);
 91                         if (err < 0) {
 92                                 index--;
 93                                 nla_nest_cancel(skb, nest);
 94                                 goto done;
 95                         }
 96                         nla_nest_end(skb, nest);
 97                         n_i++;
 98                 }
 99         }
100 done:
101         spin_unlock_bh(&hinfo->lock);
102         if (n_i)
103                 cb->args[0] += n_i;
104         return n_i;
105 
106 nla_put_failure:
107         nla_nest_cancel(skb, nest);
108         goto done;
109 }
110 
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 },
116 };
117 
118 static int tcf_act_police_locate(struct net *net, struct nlattr *nla,
119                                  struct nlattr *est, struct tc_action *a,
120                                  int ovr, int bind)
121 {
122         unsigned int h;
123         int ret = 0, err;
124         struct nlattr *tb[TCA_POLICE_MAX + 1];
125         struct tc_police *parm;
126         struct tcf_police *police;
127         struct qdisc_rate_table *R_tab = NULL, *P_tab = NULL;
128         struct tc_action_net *tn = net_generic(net, police_net_id);
129         struct tcf_hashinfo *hinfo = tn->hinfo;
130         int size;
131 
132         if (nla == NULL)
133                 return -EINVAL;
134 
135         err = nla_parse_nested(tb, TCA_POLICE_MAX, nla, police_policy);
136         if (err < 0)
137                 return err;
138 
139         if (tb[TCA_POLICE_TBF] == NULL)
140                 return -EINVAL;
141         size = nla_len(tb[TCA_POLICE_TBF]);
142         if (size != sizeof(*parm) && size != sizeof(struct tc_police_compat))
143                 return -EINVAL;
144         parm = nla_data(tb[TCA_POLICE_TBF]);
145 
146         if (parm->index) {
147                 if (tcf_hash_search(tn, a, parm->index)) {
148                         police = to_police(a->priv);
149                         if (bind) {
150                                 police->tcf_bindcnt += 1;
151                                 police->tcf_refcnt += 1;
152                                 return 0;
153                         }
154                         if (ovr)
155                                 goto override;
156                         /* not replacing */
157                         return -EEXIST;
158                 }
159         }
160 
161         police = kzalloc(sizeof(*police), GFP_KERNEL);
162         if (police == NULL)
163                 return -ENOMEM;
164         ret = ACT_P_CREATED;
165         police->tcf_refcnt = 1;
166         spin_lock_init(&police->tcf_lock);
167         if (bind)
168                 police->tcf_bindcnt = 1;
169 override:
170         if (parm->rate.rate) {
171                 err = -ENOMEM;
172                 R_tab = qdisc_get_rtab(&parm->rate, tb[TCA_POLICE_RATE]);
173                 if (R_tab == NULL)
174                         goto failure;
175 
176                 if (parm->peakrate.rate) {
177                         P_tab = qdisc_get_rtab(&parm->peakrate,
178                                                tb[TCA_POLICE_PEAKRATE]);
179                         if (P_tab == NULL)
180                                 goto failure;
181                 }
182         }
183 
184         spin_lock_bh(&police->tcf_lock);
185         if (est) {
186                 err = gen_replace_estimator(&police->tcf_bstats, NULL,
187                                             &police->tcf_rate_est,
188                                             &police->tcf_lock, est);
189                 if (err)
190                         goto failure_unlock;
191         } else if (tb[TCA_POLICE_AVRATE] &&
192                    (ret == ACT_P_CREATED ||
193                     !gen_estimator_active(&police->tcf_bstats,
194                                           &police->tcf_rate_est))) {
195                 err = -EINVAL;
196                 goto failure_unlock;
197         }
198 
199         /* No failure allowed after this point */
200         police->tcfp_mtu = parm->mtu;
201         if (police->tcfp_mtu == 0) {
202                 police->tcfp_mtu = ~0;
203                 if (R_tab)
204                         police->tcfp_mtu = 255 << R_tab->rate.cell_log;
205         }
206         if (R_tab) {
207                 police->rate_present = true;
208                 psched_ratecfg_precompute(&police->rate, &R_tab->rate, 0);
209                 qdisc_put_rtab(R_tab);
210         } else {
211                 police->rate_present = false;
212         }
213         if (P_tab) {
214                 police->peak_present = true;
215                 psched_ratecfg_precompute(&police->peak, &P_tab->rate, 0);
216                 qdisc_put_rtab(P_tab);
217         } else {
218                 police->peak_present = false;
219         }
220 
221         if (tb[TCA_POLICE_RESULT])
222                 police->tcfp_result = nla_get_u32(tb[TCA_POLICE_RESULT]);
223         police->tcfp_burst = PSCHED_TICKS2NS(parm->burst);
224         police->tcfp_toks = police->tcfp_burst;
225         if (police->peak_present) {
226                 police->tcfp_mtu_ptoks = (s64) psched_l2t_ns(&police->peak,
227                                                              police->tcfp_mtu);
228                 police->tcfp_ptoks = police->tcfp_mtu_ptoks;
229         }
230         police->tcf_action = parm->action;
231 
232         if (tb[TCA_POLICE_AVRATE])
233                 police->tcfp_ewma_rate = nla_get_u32(tb[TCA_POLICE_AVRATE]);
234 
235         spin_unlock_bh(&police->tcf_lock);
236         if (ret != ACT_P_CREATED)
237                 return ret;
238 
239         police->tcfp_t_c = ktime_get_ns();
240         police->tcf_index = parm->index ? parm->index :
241                 tcf_hash_new_index(tn);
242         h = tcf_hash(police->tcf_index, POL_TAB_MASK);
243         spin_lock_bh(&hinfo->lock);
244         hlist_add_head(&police->tcf_head, &hinfo->htab[h]);
245         spin_unlock_bh(&hinfo->lock);
246 
247         a->priv = police;
248         return ret;
249 
250 failure_unlock:
251         spin_unlock_bh(&police->tcf_lock);
252 failure:
253         qdisc_put_rtab(P_tab);
254         qdisc_put_rtab(R_tab);
255         if (ret == ACT_P_CREATED)
256                 kfree(police);
257         return err;
258 }
259 
260 static int tcf_act_police(struct sk_buff *skb, const struct tc_action *a,
261                           struct tcf_result *res)
262 {
263         struct tcf_police *police = a->priv;
264         s64 now;
265         s64 toks;
266         s64 ptoks = 0;
267 
268         spin_lock(&police->tcf_lock);
269 
270         bstats_update(&police->tcf_bstats, skb);
271 
272         if (police->tcfp_ewma_rate &&
273             police->tcf_rate_est.bps >= police->tcfp_ewma_rate) {
274                 police->tcf_qstats.overlimits++;
275                 if (police->tcf_action == TC_ACT_SHOT)
276                         police->tcf_qstats.drops++;
277                 spin_unlock(&police->tcf_lock);
278                 return police->tcf_action;
279         }
280 
281         if (qdisc_pkt_len(skb) <= police->tcfp_mtu) {
282                 if (!police->rate_present) {
283                         spin_unlock(&police->tcf_lock);
284                         return police->tcfp_result;
285                 }
286 
287                 now = ktime_get_ns();
288                 toks = min_t(s64, now - police->tcfp_t_c,
289                              police->tcfp_burst);
290                 if (police->peak_present) {
291                         ptoks = toks + police->tcfp_ptoks;
292                         if (ptoks > police->tcfp_mtu_ptoks)
293                                 ptoks = police->tcfp_mtu_ptoks;
294                         ptoks -= (s64) psched_l2t_ns(&police->peak,
295                                                      qdisc_pkt_len(skb));
296                 }
297                 toks += police->tcfp_toks;
298                 if (toks > police->tcfp_burst)
299                         toks = police->tcfp_burst;
300                 toks -= (s64) psched_l2t_ns(&police->rate, qdisc_pkt_len(skb));
301                 if ((toks|ptoks) >= 0) {
302                         police->tcfp_t_c = now;
303                         police->tcfp_toks = toks;
304                         police->tcfp_ptoks = ptoks;
305                         spin_unlock(&police->tcf_lock);
306                         return police->tcfp_result;
307                 }
308         }
309 
310         police->tcf_qstats.overlimits++;
311         if (police->tcf_action == TC_ACT_SHOT)
312                 police->tcf_qstats.drops++;
313         spin_unlock(&police->tcf_lock);
314         return police->tcf_action;
315 }
316 
317 static int
318 tcf_act_police_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
319 {
320         unsigned char *b = skb_tail_pointer(skb);
321         struct tcf_police *police = a->priv;
322         struct tc_police opt = {
323                 .index = police->tcf_index,
324                 .action = police->tcf_action,
325                 .mtu = police->tcfp_mtu,
326                 .burst = PSCHED_NS2TICKS(police->tcfp_burst),
327                 .refcnt = police->tcf_refcnt - ref,
328                 .bindcnt = police->tcf_bindcnt - bind,
329         };
330 
331         if (police->rate_present)
332                 psched_ratecfg_getrate(&opt.rate, &police->rate);
333         if (police->peak_present)
334                 psched_ratecfg_getrate(&opt.peakrate, &police->peak);
335         if (nla_put(skb, TCA_POLICE_TBF, sizeof(opt), &opt))
336                 goto nla_put_failure;
337         if (police->tcfp_result &&
338             nla_put_u32(skb, TCA_POLICE_RESULT, police->tcfp_result))
339                 goto nla_put_failure;
340         if (police->tcfp_ewma_rate &&
341             nla_put_u32(skb, TCA_POLICE_AVRATE, police->tcfp_ewma_rate))
342                 goto nla_put_failure;
343         return skb->len;
344 
345 nla_put_failure:
346         nlmsg_trim(skb, b);
347         return -1;
348 }
349 
350 static int tcf_police_search(struct net *net, struct tc_action *a, u32 index)
351 {
352         struct tc_action_net *tn = net_generic(net, police_net_id);
353 
354         return tcf_hash_search(tn, a, index);
355 }
356 
357 MODULE_AUTHOR("Alexey Kuznetsov");
358 MODULE_DESCRIPTION("Policing actions");
359 MODULE_LICENSE("GPL");
360 
361 static struct tc_action_ops act_police_ops = {
362         .kind           =       "police",
363         .type           =       TCA_ID_POLICE,
364         .owner          =       THIS_MODULE,
365         .act            =       tcf_act_police,
366         .dump           =       tcf_act_police_dump,
367         .init           =       tcf_act_police_locate,
368         .walk           =       tcf_act_police_walker,
369         .lookup         =       tcf_police_search,
370 };
371 
372 static __net_init int police_init_net(struct net *net)
373 {
374         struct tc_action_net *tn = net_generic(net, police_net_id);
375 
376         return tc_action_net_init(tn, &act_police_ops, POL_TAB_MASK);
377 }
378 
379 static void __net_exit police_exit_net(struct net *net)
380 {
381         struct tc_action_net *tn = net_generic(net, police_net_id);
382 
383         tc_action_net_exit(tn);
384 }
385 
386 static struct pernet_operations police_net_ops = {
387         .init = police_init_net,
388         .exit = police_exit_net,
389         .id   = &police_net_id,
390         .size = sizeof(struct tc_action_net),
391 };
392 
393 static int __init
394 police_init_module(void)
395 {
396         return tcf_register_action(&act_police_ops, &police_net_ops);
397 }
398 
399 static void __exit
400 police_cleanup_module(void)
401 {
402         tcf_unregister_action(&act_police_ops, &police_net_ops);
403 }
404 
405 module_init(police_init_module);
406 module_exit(police_cleanup_module);
407 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp