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

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

Version: ~ [ linux-5.15-rc7 ] ~ [ linux-5.14.14 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.75 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.155 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.213 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.252 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.287 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.289 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  * net/sched/cls_matchll.c              Match-all classifier
  4  *
  5  * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
  6  */
  7 
  8 #include <linux/kernel.h>
  9 #include <linux/init.h>
 10 #include <linux/module.h>
 11 #include <linux/percpu.h>
 12 
 13 #include <net/sch_generic.h>
 14 #include <net/pkt_cls.h>
 15 
 16 struct cls_mall_head {
 17         struct tcf_exts exts;
 18         struct tcf_result res;
 19         u32 handle;
 20         u32 flags;
 21         unsigned int in_hw_count;
 22         struct tc_matchall_pcnt __percpu *pf;
 23         struct rcu_work rwork;
 24         bool deleting;
 25 };
 26 
 27 static int mall_classify(struct sk_buff *skb, const struct tcf_proto *tp,
 28                          struct tcf_result *res)
 29 {
 30         struct cls_mall_head *head = rcu_dereference_bh(tp->root);
 31 
 32         if (unlikely(!head))
 33                 return -1;
 34 
 35         if (tc_skip_sw(head->flags))
 36                 return -1;
 37 
 38         *res = head->res;
 39         __this_cpu_inc(head->pf->rhit);
 40         return tcf_exts_exec(skb, &head->exts, res);
 41 }
 42 
 43 static int mall_init(struct tcf_proto *tp)
 44 {
 45         return 0;
 46 }
 47 
 48 static void __mall_destroy(struct cls_mall_head *head)
 49 {
 50         tcf_exts_destroy(&head->exts);
 51         tcf_exts_put_net(&head->exts);
 52         free_percpu(head->pf);
 53         kfree(head);
 54 }
 55 
 56 static void mall_destroy_work(struct work_struct *work)
 57 {
 58         struct cls_mall_head *head = container_of(to_rcu_work(work),
 59                                                   struct cls_mall_head,
 60                                                   rwork);
 61         rtnl_lock();
 62         __mall_destroy(head);
 63         rtnl_unlock();
 64 }
 65 
 66 static void mall_destroy_hw_filter(struct tcf_proto *tp,
 67                                    struct cls_mall_head *head,
 68                                    unsigned long cookie,
 69                                    struct netlink_ext_ack *extack)
 70 {
 71         struct tc_cls_matchall_offload cls_mall = {};
 72         struct tcf_block *block = tp->chain->block;
 73 
 74         tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack);
 75         cls_mall.command = TC_CLSMATCHALL_DESTROY;
 76         cls_mall.cookie = cookie;
 77 
 78         tc_setup_cb_destroy(block, tp, TC_SETUP_CLSMATCHALL, &cls_mall, false,
 79                             &head->flags, &head->in_hw_count, true);
 80 }
 81 
 82 static int mall_replace_hw_filter(struct tcf_proto *tp,
 83                                   struct cls_mall_head *head,
 84                                   unsigned long cookie,
 85                                   struct netlink_ext_ack *extack)
 86 {
 87         struct tc_cls_matchall_offload cls_mall = {};
 88         struct tcf_block *block = tp->chain->block;
 89         bool skip_sw = tc_skip_sw(head->flags);
 90         int err;
 91 
 92         cls_mall.rule = flow_rule_alloc(tcf_exts_num_actions(&head->exts));
 93         if (!cls_mall.rule)
 94                 return -ENOMEM;
 95 
 96         tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack);
 97         cls_mall.command = TC_CLSMATCHALL_REPLACE;
 98         cls_mall.cookie = cookie;
 99 
100         err = tc_setup_flow_action(&cls_mall.rule->action, &head->exts, true);
101         if (err) {
102                 kfree(cls_mall.rule);
103                 mall_destroy_hw_filter(tp, head, cookie, NULL);
104                 if (skip_sw)
105                         NL_SET_ERR_MSG_MOD(extack, "Failed to setup flow action");
106                 else
107                         err = 0;
108 
109                 return err;
110         }
111 
112         err = tc_setup_cb_add(block, tp, TC_SETUP_CLSMATCHALL, &cls_mall,
113                               skip_sw, &head->flags, &head->in_hw_count, true);
114         tc_cleanup_flow_action(&cls_mall.rule->action);
115         kfree(cls_mall.rule);
116 
117         if (err) {
118                 mall_destroy_hw_filter(tp, head, cookie, NULL);
119                 return err;
120         }
121 
122         if (skip_sw && !(head->flags & TCA_CLS_FLAGS_IN_HW))
123                 return -EINVAL;
124 
125         return 0;
126 }
127 
128 static void mall_destroy(struct tcf_proto *tp, bool rtnl_held,
129                          struct netlink_ext_ack *extack)
130 {
131         struct cls_mall_head *head = rtnl_dereference(tp->root);
132 
133         if (!head)
134                 return;
135 
136         tcf_unbind_filter(tp, &head->res);
137 
138         if (!tc_skip_hw(head->flags))
139                 mall_destroy_hw_filter(tp, head, (unsigned long) head, extack);
140 
141         if (tcf_exts_get_net(&head->exts))
142                 tcf_queue_work(&head->rwork, mall_destroy_work);
143         else
144                 __mall_destroy(head);
145 }
146 
147 static void *mall_get(struct tcf_proto *tp, u32 handle)
148 {
149         struct cls_mall_head *head = rtnl_dereference(tp->root);
150 
151         if (head && head->handle == handle)
152                 return head;
153 
154         return NULL;
155 }
156 
157 static const struct nla_policy mall_policy[TCA_MATCHALL_MAX + 1] = {
158         [TCA_MATCHALL_UNSPEC]           = { .type = NLA_UNSPEC },
159         [TCA_MATCHALL_CLASSID]          = { .type = NLA_U32 },
160         [TCA_MATCHALL_FLAGS]            = { .type = NLA_U32 },
161 };
162 
163 static int mall_set_parms(struct net *net, struct tcf_proto *tp,
164                           struct cls_mall_head *head,
165                           unsigned long base, struct nlattr **tb,
166                           struct nlattr *est, bool ovr,
167                           struct netlink_ext_ack *extack)
168 {
169         int err;
170 
171         err = tcf_exts_validate(net, tp, tb, est, &head->exts, ovr, true,
172                                 extack);
173         if (err < 0)
174                 return err;
175 
176         if (tb[TCA_MATCHALL_CLASSID]) {
177                 head->res.classid = nla_get_u32(tb[TCA_MATCHALL_CLASSID]);
178                 tcf_bind_filter(tp, &head->res, base);
179         }
180         return 0;
181 }
182 
183 static int mall_change(struct net *net, struct sk_buff *in_skb,
184                        struct tcf_proto *tp, unsigned long base,
185                        u32 handle, struct nlattr **tca,
186                        void **arg, bool ovr, bool rtnl_held,
187                        struct netlink_ext_ack *extack)
188 {
189         struct cls_mall_head *head = rtnl_dereference(tp->root);
190         struct nlattr *tb[TCA_MATCHALL_MAX + 1];
191         struct cls_mall_head *new;
192         u32 flags = 0;
193         int err;
194 
195         if (!tca[TCA_OPTIONS])
196                 return -EINVAL;
197 
198         if (head)
199                 return -EEXIST;
200 
201         err = nla_parse_nested_deprecated(tb, TCA_MATCHALL_MAX,
202                                           tca[TCA_OPTIONS], mall_policy, NULL);
203         if (err < 0)
204                 return err;
205 
206         if (tb[TCA_MATCHALL_FLAGS]) {
207                 flags = nla_get_u32(tb[TCA_MATCHALL_FLAGS]);
208                 if (!tc_flags_valid(flags))
209                         return -EINVAL;
210         }
211 
212         new = kzalloc(sizeof(*new), GFP_KERNEL);
213         if (!new)
214                 return -ENOBUFS;
215 
216         err = tcf_exts_init(&new->exts, net, TCA_MATCHALL_ACT, 0);
217         if (err)
218                 goto err_exts_init;
219 
220         if (!handle)
221                 handle = 1;
222         new->handle = handle;
223         new->flags = flags;
224         new->pf = alloc_percpu(struct tc_matchall_pcnt);
225         if (!new->pf) {
226                 err = -ENOMEM;
227                 goto err_alloc_percpu;
228         }
229 
230         err = mall_set_parms(net, tp, new, base, tb, tca[TCA_RATE], ovr,
231                              extack);
232         if (err)
233                 goto err_set_parms;
234 
235         if (!tc_skip_hw(new->flags)) {
236                 err = mall_replace_hw_filter(tp, new, (unsigned long)new,
237                                              extack);
238                 if (err)
239                         goto err_replace_hw_filter;
240         }
241 
242         if (!tc_in_hw(new->flags))
243                 new->flags |= TCA_CLS_FLAGS_NOT_IN_HW;
244 
245         *arg = head;
246         rcu_assign_pointer(tp->root, new);
247         return 0;
248 
249 err_replace_hw_filter:
250 err_set_parms:
251         free_percpu(new->pf);
252 err_alloc_percpu:
253         tcf_exts_destroy(&new->exts);
254 err_exts_init:
255         kfree(new);
256         return err;
257 }
258 
259 static int mall_delete(struct tcf_proto *tp, void *arg, bool *last,
260                        bool rtnl_held, struct netlink_ext_ack *extack)
261 {
262         struct cls_mall_head *head = rtnl_dereference(tp->root);
263 
264         head->deleting = true;
265         *last = true;
266         return 0;
267 }
268 
269 static void mall_walk(struct tcf_proto *tp, struct tcf_walker *arg,
270                       bool rtnl_held)
271 {
272         struct cls_mall_head *head = rtnl_dereference(tp->root);
273 
274         if (arg->count < arg->skip)
275                 goto skip;
276 
277         if (!head || head->deleting)
278                 return;
279         if (arg->fn(tp, head, arg) < 0)
280                 arg->stop = 1;
281 skip:
282         arg->count++;
283 }
284 
285 static int mall_reoffload(struct tcf_proto *tp, bool add, flow_setup_cb_t *cb,
286                           void *cb_priv, struct netlink_ext_ack *extack)
287 {
288         struct cls_mall_head *head = rtnl_dereference(tp->root);
289         struct tc_cls_matchall_offload cls_mall = {};
290         struct tcf_block *block = tp->chain->block;
291         int err;
292 
293         if (tc_skip_hw(head->flags))
294                 return 0;
295 
296         cls_mall.rule = flow_rule_alloc(tcf_exts_num_actions(&head->exts));
297         if (!cls_mall.rule)
298                 return -ENOMEM;
299 
300         tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack);
301         cls_mall.command = add ?
302                 TC_CLSMATCHALL_REPLACE : TC_CLSMATCHALL_DESTROY;
303         cls_mall.cookie = (unsigned long)head;
304 
305         err = tc_setup_flow_action(&cls_mall.rule->action, &head->exts, true);
306         if (err) {
307                 kfree(cls_mall.rule);
308                 if (add && tc_skip_sw(head->flags)) {
309                         NL_SET_ERR_MSG_MOD(extack, "Failed to setup flow action");
310                         return err;
311                 }
312                 return 0;
313         }
314 
315         err = tc_setup_cb_reoffload(block, tp, add, cb, TC_SETUP_CLSMATCHALL,
316                                     &cls_mall, cb_priv, &head->flags,
317                                     &head->in_hw_count);
318         tc_cleanup_flow_action(&cls_mall.rule->action);
319         kfree(cls_mall.rule);
320 
321         if (err)
322                 return err;
323 
324         return 0;
325 }
326 
327 static void mall_stats_hw_filter(struct tcf_proto *tp,
328                                  struct cls_mall_head *head,
329                                  unsigned long cookie)
330 {
331         struct tc_cls_matchall_offload cls_mall = {};
332         struct tcf_block *block = tp->chain->block;
333 
334         tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, NULL);
335         cls_mall.command = TC_CLSMATCHALL_STATS;
336         cls_mall.cookie = cookie;
337 
338         tc_setup_cb_call(block, TC_SETUP_CLSMATCHALL, &cls_mall, false, true);
339 
340         tcf_exts_stats_update(&head->exts, cls_mall.stats.bytes,
341                               cls_mall.stats.pkts, cls_mall.stats.lastused);
342 }
343 
344 static int mall_dump(struct net *net, struct tcf_proto *tp, void *fh,
345                      struct sk_buff *skb, struct tcmsg *t, bool rtnl_held)
346 {
347         struct tc_matchall_pcnt gpf = {};
348         struct cls_mall_head *head = fh;
349         struct nlattr *nest;
350         int cpu;
351 
352         if (!head)
353                 return skb->len;
354 
355         if (!tc_skip_hw(head->flags))
356                 mall_stats_hw_filter(tp, head, (unsigned long)head);
357 
358         t->tcm_handle = head->handle;
359 
360         nest = nla_nest_start_noflag(skb, TCA_OPTIONS);
361         if (!nest)
362                 goto nla_put_failure;
363 
364         if (head->res.classid &&
365             nla_put_u32(skb, TCA_MATCHALL_CLASSID, head->res.classid))
366                 goto nla_put_failure;
367 
368         if (head->flags && nla_put_u32(skb, TCA_MATCHALL_FLAGS, head->flags))
369                 goto nla_put_failure;
370 
371         for_each_possible_cpu(cpu) {
372                 struct tc_matchall_pcnt *pf = per_cpu_ptr(head->pf, cpu);
373 
374                 gpf.rhit += pf->rhit;
375         }
376 
377         if (nla_put_64bit(skb, TCA_MATCHALL_PCNT,
378                           sizeof(struct tc_matchall_pcnt),
379                           &gpf, TCA_MATCHALL_PAD))
380                 goto nla_put_failure;
381 
382         if (tcf_exts_dump(skb, &head->exts))
383                 goto nla_put_failure;
384 
385         nla_nest_end(skb, nest);
386 
387         if (tcf_exts_dump_stats(skb, &head->exts) < 0)
388                 goto nla_put_failure;
389 
390         return skb->len;
391 
392 nla_put_failure:
393         nla_nest_cancel(skb, nest);
394         return -1;
395 }
396 
397 static void mall_bind_class(void *fh, u32 classid, unsigned long cl, void *q,
398                             unsigned long base)
399 {
400         struct cls_mall_head *head = fh;
401 
402         if (head && head->res.classid == classid) {
403                 if (cl)
404                         __tcf_bind_filter(q, &head->res, base);
405                 else
406                         __tcf_unbind_filter(q, &head->res);
407         }
408 }
409 
410 static struct tcf_proto_ops cls_mall_ops __read_mostly = {
411         .kind           = "matchall",
412         .classify       = mall_classify,
413         .init           = mall_init,
414         .destroy        = mall_destroy,
415         .get            = mall_get,
416         .change         = mall_change,
417         .delete         = mall_delete,
418         .walk           = mall_walk,
419         .reoffload      = mall_reoffload,
420         .dump           = mall_dump,
421         .bind_class     = mall_bind_class,
422         .owner          = THIS_MODULE,
423 };
424 
425 static int __init cls_mall_init(void)
426 {
427         return register_tcf_proto_ops(&cls_mall_ops);
428 }
429 
430 static void __exit cls_mall_exit(void)
431 {
432         unregister_tcf_proto_ops(&cls_mall_ops);
433 }
434 
435 module_init(cls_mall_init);
436 module_exit(cls_mall_exit);
437 
438 MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>");
439 MODULE_DESCRIPTION("Match-all classifier");
440 MODULE_LICENSE("GPL v2");
441 

~ [ 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