]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - net/sched/act_api.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
net_sched: acquire RTNL in tc_action_net_exit()
[mirror_ubuntu-bionic-kernel.git] / net / sched / act_api.c
1 /*
2 * net/sched/act_api.c Packet action API.
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 * Author: Jamal Hadi Salim
10 *
11 *
12 */
13
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/slab.h>
19 #include <linux/skbuff.h>
20 #include <linux/init.h>
21 #include <linux/kmod.h>
22 #include <linux/err.h>
23 #include <linux/module.h>
24 #include <net/net_namespace.h>
25 #include <net/sock.h>
26 #include <net/sch_generic.h>
27 #include <net/pkt_cls.h>
28 #include <net/act_api.h>
29 #include <net/netlink.h>
30
31 static int tcf_action_goto_chain_init(struct tc_action *a, struct tcf_proto *tp)
32 {
33 u32 chain_index = a->tcfa_action & TC_ACT_EXT_VAL_MASK;
34
35 if (!tp)
36 return -EINVAL;
37 a->goto_chain = tcf_chain_get(tp->chain->block, chain_index, true);
38 if (!a->goto_chain)
39 return -ENOMEM;
40 return 0;
41 }
42
43 static void tcf_action_goto_chain_fini(struct tc_action *a)
44 {
45 tcf_chain_put(a->goto_chain);
46 }
47
48 static void tcf_action_goto_chain_exec(const struct tc_action *a,
49 struct tcf_result *res)
50 {
51 const struct tcf_chain *chain = a->goto_chain;
52
53 res->goto_tp = rcu_dereference_bh(chain->filter_chain);
54 }
55
56 /* XXX: For standalone actions, we don't need a RCU grace period either, because
57 * actions are always connected to filters and filters are already destroyed in
58 * RCU callbacks, so after a RCU grace period actions are already disconnected
59 * from filters. Readers later can not find us.
60 */
61 static void free_tcf(struct tc_action *p)
62 {
63 free_percpu(p->cpu_bstats);
64 free_percpu(p->cpu_qstats);
65
66 if (p->act_cookie) {
67 kfree(p->act_cookie->data);
68 kfree(p->act_cookie);
69 }
70 if (p->goto_chain)
71 tcf_action_goto_chain_fini(p);
72
73 kfree(p);
74 }
75
76 static void tcf_idr_remove(struct tcf_idrinfo *idrinfo, struct tc_action *p)
77 {
78 spin_lock_bh(&idrinfo->lock);
79 idr_remove_ext(&idrinfo->action_idr, p->tcfa_index);
80 spin_unlock_bh(&idrinfo->lock);
81 gen_kill_estimator(&p->tcfa_rate_est);
82 free_tcf(p);
83 }
84
85 int __tcf_idr_release(struct tc_action *p, bool bind, bool strict)
86 {
87 int ret = 0;
88
89 ASSERT_RTNL();
90
91 if (p) {
92 if (bind)
93 p->tcfa_bindcnt--;
94 else if (strict && p->tcfa_bindcnt > 0)
95 return -EPERM;
96
97 p->tcfa_refcnt--;
98 if (p->tcfa_bindcnt <= 0 && p->tcfa_refcnt <= 0) {
99 if (p->ops->cleanup)
100 p->ops->cleanup(p, bind);
101 tcf_idr_remove(p->idrinfo, p);
102 ret = ACT_P_DELETED;
103 }
104 }
105
106 return ret;
107 }
108 EXPORT_SYMBOL(__tcf_idr_release);
109
110 static int tcf_dump_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb,
111 struct netlink_callback *cb)
112 {
113 int err = 0, index = -1, s_i = 0, n_i = 0;
114 u32 act_flags = cb->args[2];
115 unsigned long jiffy_since = cb->args[3];
116 struct nlattr *nest;
117 struct idr *idr = &idrinfo->action_idr;
118 struct tc_action *p;
119 unsigned long id = 1;
120
121 spin_lock_bh(&idrinfo->lock);
122
123 s_i = cb->args[0];
124
125 idr_for_each_entry_ext(idr, p, id) {
126 index++;
127 if (index < s_i)
128 continue;
129
130 if (jiffy_since &&
131 time_after(jiffy_since,
132 (unsigned long)p->tcfa_tm.lastuse))
133 continue;
134
135 nest = nla_nest_start(skb, n_i);
136 if (!nest)
137 goto nla_put_failure;
138 err = tcf_action_dump_1(skb, p, 0, 0);
139 if (err < 0) {
140 index--;
141 nlmsg_trim(skb, nest);
142 goto done;
143 }
144 nla_nest_end(skb, nest);
145 n_i++;
146 if (!(act_flags & TCA_FLAG_LARGE_DUMP_ON) &&
147 n_i >= TCA_ACT_MAX_PRIO)
148 goto done;
149 }
150 done:
151 if (index >= 0)
152 cb->args[0] = index + 1;
153
154 spin_unlock_bh(&idrinfo->lock);
155 if (n_i) {
156 if (act_flags & TCA_FLAG_LARGE_DUMP_ON)
157 cb->args[1] = n_i;
158 }
159 return n_i;
160
161 nla_put_failure:
162 nla_nest_cancel(skb, nest);
163 goto done;
164 }
165
166 static int tcf_del_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb,
167 const struct tc_action_ops *ops)
168 {
169 struct nlattr *nest;
170 int n_i = 0;
171 int ret = -EINVAL;
172 struct idr *idr = &idrinfo->action_idr;
173 struct tc_action *p;
174 unsigned long id = 1;
175
176 nest = nla_nest_start(skb, 0);
177 if (nest == NULL)
178 goto nla_put_failure;
179 if (nla_put_string(skb, TCA_KIND, ops->kind))
180 goto nla_put_failure;
181
182 idr_for_each_entry_ext(idr, p, id) {
183 ret = __tcf_idr_release(p, false, true);
184 if (ret == ACT_P_DELETED) {
185 module_put(ops->owner);
186 n_i++;
187 } else if (ret < 0) {
188 goto nla_put_failure;
189 }
190 }
191 if (nla_put_u32(skb, TCA_FCNT, n_i))
192 goto nla_put_failure;
193 nla_nest_end(skb, nest);
194
195 return n_i;
196 nla_put_failure:
197 nla_nest_cancel(skb, nest);
198 return ret;
199 }
200
201 int tcf_generic_walker(struct tc_action_net *tn, struct sk_buff *skb,
202 struct netlink_callback *cb, int type,
203 const struct tc_action_ops *ops)
204 {
205 struct tcf_idrinfo *idrinfo = tn->idrinfo;
206
207 if (type == RTM_DELACTION) {
208 return tcf_del_walker(idrinfo, skb, ops);
209 } else if (type == RTM_GETACTION) {
210 return tcf_dump_walker(idrinfo, skb, cb);
211 } else {
212 WARN(1, "tcf_generic_walker: unknown action %d\n", type);
213 return -EINVAL;
214 }
215 }
216 EXPORT_SYMBOL(tcf_generic_walker);
217
218 static struct tc_action *tcf_idr_lookup(u32 index, struct tcf_idrinfo *idrinfo)
219 {
220 struct tc_action *p = NULL;
221
222 spin_lock_bh(&idrinfo->lock);
223 p = idr_find_ext(&idrinfo->action_idr, index);
224 spin_unlock_bh(&idrinfo->lock);
225
226 return p;
227 }
228
229 int tcf_idr_search(struct tc_action_net *tn, struct tc_action **a, u32 index)
230 {
231 struct tcf_idrinfo *idrinfo = tn->idrinfo;
232 struct tc_action *p = tcf_idr_lookup(index, idrinfo);
233
234 if (p) {
235 *a = p;
236 return 1;
237 }
238 return 0;
239 }
240 EXPORT_SYMBOL(tcf_idr_search);
241
242 bool tcf_idr_check(struct tc_action_net *tn, u32 index, struct tc_action **a,
243 int bind)
244 {
245 struct tcf_idrinfo *idrinfo = tn->idrinfo;
246 struct tc_action *p = tcf_idr_lookup(index, idrinfo);
247
248 if (index && p) {
249 if (bind)
250 p->tcfa_bindcnt++;
251 p->tcfa_refcnt++;
252 *a = p;
253 return true;
254 }
255 return false;
256 }
257 EXPORT_SYMBOL(tcf_idr_check);
258
259 void tcf_idr_cleanup(struct tc_action *a, struct nlattr *est)
260 {
261 if (est)
262 gen_kill_estimator(&a->tcfa_rate_est);
263 free_tcf(a);
264 }
265 EXPORT_SYMBOL(tcf_idr_cleanup);
266
267 int tcf_idr_create(struct tc_action_net *tn, u32 index, struct nlattr *est,
268 struct tc_action **a, const struct tc_action_ops *ops,
269 int bind, bool cpustats)
270 {
271 struct tc_action *p = kzalloc(ops->size, GFP_KERNEL);
272 struct tcf_idrinfo *idrinfo = tn->idrinfo;
273 struct idr *idr = &idrinfo->action_idr;
274 int err = -ENOMEM;
275 unsigned long idr_index;
276
277 if (unlikely(!p))
278 return -ENOMEM;
279 p->tcfa_refcnt = 1;
280 if (bind)
281 p->tcfa_bindcnt = 1;
282
283 if (cpustats) {
284 p->cpu_bstats = netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu);
285 if (!p->cpu_bstats) {
286 err1:
287 kfree(p);
288 return err;
289 }
290 p->cpu_qstats = alloc_percpu(struct gnet_stats_queue);
291 if (!p->cpu_qstats) {
292 err2:
293 free_percpu(p->cpu_bstats);
294 goto err1;
295 }
296 }
297 spin_lock_init(&p->tcfa_lock);
298 /* user doesn't specify an index */
299 if (!index) {
300 idr_preload(GFP_KERNEL);
301 spin_lock_bh(&idrinfo->lock);
302 err = idr_alloc_ext(idr, NULL, &idr_index, 1, 0,
303 GFP_ATOMIC);
304 spin_unlock_bh(&idrinfo->lock);
305 idr_preload_end();
306 if (err) {
307 err3:
308 free_percpu(p->cpu_qstats);
309 goto err2;
310 }
311 p->tcfa_index = idr_index;
312 } else {
313 idr_preload(GFP_KERNEL);
314 spin_lock_bh(&idrinfo->lock);
315 err = idr_alloc_ext(idr, NULL, NULL, index, index + 1,
316 GFP_ATOMIC);
317 spin_unlock_bh(&idrinfo->lock);
318 idr_preload_end();
319 if (err)
320 goto err3;
321 p->tcfa_index = index;
322 }
323
324 p->tcfa_tm.install = jiffies;
325 p->tcfa_tm.lastuse = jiffies;
326 p->tcfa_tm.firstuse = 0;
327 if (est) {
328 err = gen_new_estimator(&p->tcfa_bstats, p->cpu_bstats,
329 &p->tcfa_rate_est,
330 &p->tcfa_lock, NULL, est);
331 if (err) {
332 goto err3;
333 }
334 }
335
336 p->idrinfo = idrinfo;
337 p->ops = ops;
338 INIT_LIST_HEAD(&p->list);
339 *a = p;
340 return 0;
341 }
342 EXPORT_SYMBOL(tcf_idr_create);
343
344 void tcf_idr_insert(struct tc_action_net *tn, struct tc_action *a)
345 {
346 struct tcf_idrinfo *idrinfo = tn->idrinfo;
347
348 spin_lock_bh(&idrinfo->lock);
349 idr_replace_ext(&idrinfo->action_idr, a, a->tcfa_index);
350 spin_unlock_bh(&idrinfo->lock);
351 }
352 EXPORT_SYMBOL(tcf_idr_insert);
353
354 void tcf_idrinfo_destroy(const struct tc_action_ops *ops,
355 struct tcf_idrinfo *idrinfo)
356 {
357 struct idr *idr = &idrinfo->action_idr;
358 struct tc_action *p;
359 int ret;
360 unsigned long id = 1;
361
362 idr_for_each_entry_ext(idr, p, id) {
363 ret = __tcf_idr_release(p, false, true);
364 if (ret == ACT_P_DELETED)
365 module_put(ops->owner);
366 else if (ret < 0)
367 return;
368 }
369 idr_destroy(&idrinfo->action_idr);
370 }
371 EXPORT_SYMBOL(tcf_idrinfo_destroy);
372
373 static LIST_HEAD(act_base);
374 static DEFINE_RWLOCK(act_mod_lock);
375
376 int tcf_register_action(struct tc_action_ops *act,
377 struct pernet_operations *ops)
378 {
379 struct tc_action_ops *a;
380 int ret;
381
382 if (!act->act || !act->dump || !act->init || !act->walk || !act->lookup)
383 return -EINVAL;
384
385 /* We have to register pernet ops before making the action ops visible,
386 * otherwise tcf_action_init_1() could get a partially initialized
387 * netns.
388 */
389 ret = register_pernet_subsys(ops);
390 if (ret)
391 return ret;
392
393 write_lock(&act_mod_lock);
394 list_for_each_entry(a, &act_base, head) {
395 if (act->type == a->type || (strcmp(act->kind, a->kind) == 0)) {
396 write_unlock(&act_mod_lock);
397 unregister_pernet_subsys(ops);
398 return -EEXIST;
399 }
400 }
401 list_add_tail(&act->head, &act_base);
402 write_unlock(&act_mod_lock);
403
404 return 0;
405 }
406 EXPORT_SYMBOL(tcf_register_action);
407
408 int tcf_unregister_action(struct tc_action_ops *act,
409 struct pernet_operations *ops)
410 {
411 struct tc_action_ops *a;
412 int err = -ENOENT;
413
414 write_lock(&act_mod_lock);
415 list_for_each_entry(a, &act_base, head) {
416 if (a == act) {
417 list_del(&act->head);
418 err = 0;
419 break;
420 }
421 }
422 write_unlock(&act_mod_lock);
423 if (!err)
424 unregister_pernet_subsys(ops);
425 return err;
426 }
427 EXPORT_SYMBOL(tcf_unregister_action);
428
429 /* lookup by name */
430 static struct tc_action_ops *tc_lookup_action_n(char *kind)
431 {
432 struct tc_action_ops *a, *res = NULL;
433
434 if (kind) {
435 read_lock(&act_mod_lock);
436 list_for_each_entry(a, &act_base, head) {
437 if (strcmp(kind, a->kind) == 0) {
438 if (try_module_get(a->owner))
439 res = a;
440 break;
441 }
442 }
443 read_unlock(&act_mod_lock);
444 }
445 return res;
446 }
447
448 /* lookup by nlattr */
449 static struct tc_action_ops *tc_lookup_action(struct nlattr *kind)
450 {
451 struct tc_action_ops *a, *res = NULL;
452
453 if (kind) {
454 read_lock(&act_mod_lock);
455 list_for_each_entry(a, &act_base, head) {
456 if (nla_strcmp(kind, a->kind) == 0) {
457 if (try_module_get(a->owner))
458 res = a;
459 break;
460 }
461 }
462 read_unlock(&act_mod_lock);
463 }
464 return res;
465 }
466
467 /*TCA_ACT_MAX_PRIO is 32, there count upto 32 */
468 #define TCA_ACT_MAX_PRIO_MASK 0x1FF
469 int tcf_action_exec(struct sk_buff *skb, struct tc_action **actions,
470 int nr_actions, struct tcf_result *res)
471 {
472 u32 jmp_prgcnt = 0;
473 u32 jmp_ttl = TCA_ACT_MAX_PRIO; /*matches actions per filter */
474 int i;
475 int ret = TC_ACT_OK;
476
477 if (skb_skip_tc_classify(skb))
478 return TC_ACT_OK;
479
480 restart_act_graph:
481 for (i = 0; i < nr_actions; i++) {
482 const struct tc_action *a = actions[i];
483
484 if (jmp_prgcnt > 0) {
485 jmp_prgcnt -= 1;
486 continue;
487 }
488 repeat:
489 ret = a->ops->act(skb, a, res);
490 if (ret == TC_ACT_REPEAT)
491 goto repeat; /* we need a ttl - JHS */
492
493 if (TC_ACT_EXT_CMP(ret, TC_ACT_JUMP)) {
494 jmp_prgcnt = ret & TCA_ACT_MAX_PRIO_MASK;
495 if (!jmp_prgcnt || (jmp_prgcnt > nr_actions)) {
496 /* faulty opcode, stop pipeline */
497 return TC_ACT_OK;
498 } else {
499 jmp_ttl -= 1;
500 if (jmp_ttl > 0)
501 goto restart_act_graph;
502 else /* faulty graph, stop pipeline */
503 return TC_ACT_OK;
504 }
505 } else if (TC_ACT_EXT_CMP(ret, TC_ACT_GOTO_CHAIN)) {
506 tcf_action_goto_chain_exec(a, res);
507 }
508
509 if (ret != TC_ACT_PIPE)
510 break;
511 }
512
513 return ret;
514 }
515 EXPORT_SYMBOL(tcf_action_exec);
516
517 int tcf_action_destroy(struct list_head *actions, int bind)
518 {
519 const struct tc_action_ops *ops;
520 struct tc_action *a, *tmp;
521 int ret = 0;
522
523 list_for_each_entry_safe(a, tmp, actions, list) {
524 ops = a->ops;
525 ret = __tcf_idr_release(a, bind, true);
526 if (ret == ACT_P_DELETED)
527 module_put(ops->owner);
528 else if (ret < 0)
529 return ret;
530 }
531 return ret;
532 }
533
534 int
535 tcf_action_dump_old(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
536 {
537 return a->ops->dump(skb, a, bind, ref);
538 }
539
540 int
541 tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
542 {
543 int err = -EINVAL;
544 unsigned char *b = skb_tail_pointer(skb);
545 struct nlattr *nest;
546
547 if (nla_put_string(skb, TCA_KIND, a->ops->kind))
548 goto nla_put_failure;
549 if (tcf_action_copy_stats(skb, a, 0))
550 goto nla_put_failure;
551 if (a->act_cookie) {
552 if (nla_put(skb, TCA_ACT_COOKIE, a->act_cookie->len,
553 a->act_cookie->data))
554 goto nla_put_failure;
555 }
556
557 nest = nla_nest_start(skb, TCA_OPTIONS);
558 if (nest == NULL)
559 goto nla_put_failure;
560 err = tcf_action_dump_old(skb, a, bind, ref);
561 if (err > 0) {
562 nla_nest_end(skb, nest);
563 return err;
564 }
565
566 nla_put_failure:
567 nlmsg_trim(skb, b);
568 return -1;
569 }
570 EXPORT_SYMBOL(tcf_action_dump_1);
571
572 int tcf_action_dump(struct sk_buff *skb, struct list_head *actions,
573 int bind, int ref)
574 {
575 struct tc_action *a;
576 int err = -EINVAL;
577 struct nlattr *nest;
578
579 list_for_each_entry(a, actions, list) {
580 nest = nla_nest_start(skb, a->order);
581 if (nest == NULL)
582 goto nla_put_failure;
583 err = tcf_action_dump_1(skb, a, bind, ref);
584 if (err < 0)
585 goto errout;
586 nla_nest_end(skb, nest);
587 }
588
589 return 0;
590
591 nla_put_failure:
592 err = -EINVAL;
593 errout:
594 nla_nest_cancel(skb, nest);
595 return err;
596 }
597
598 static struct tc_cookie *nla_memdup_cookie(struct nlattr **tb)
599 {
600 struct tc_cookie *c = kzalloc(sizeof(*c), GFP_KERNEL);
601 if (!c)
602 return NULL;
603
604 c->data = nla_memdup(tb[TCA_ACT_COOKIE], GFP_KERNEL);
605 if (!c->data) {
606 kfree(c);
607 return NULL;
608 }
609 c->len = nla_len(tb[TCA_ACT_COOKIE]);
610
611 return c;
612 }
613
614 struct tc_action *tcf_action_init_1(struct net *net, struct tcf_proto *tp,
615 struct nlattr *nla, struct nlattr *est,
616 char *name, int ovr, int bind)
617 {
618 struct tc_action *a;
619 struct tc_action_ops *a_o;
620 struct tc_cookie *cookie = NULL;
621 char act_name[IFNAMSIZ];
622 struct nlattr *tb[TCA_ACT_MAX + 1];
623 struct nlattr *kind;
624 int err;
625
626 if (name == NULL) {
627 err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL, NULL);
628 if (err < 0)
629 goto err_out;
630 err = -EINVAL;
631 kind = tb[TCA_ACT_KIND];
632 if (kind == NULL)
633 goto err_out;
634 if (nla_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ)
635 goto err_out;
636 if (tb[TCA_ACT_COOKIE]) {
637 int cklen = nla_len(tb[TCA_ACT_COOKIE]);
638
639 if (cklen > TC_COOKIE_MAX_SIZE)
640 goto err_out;
641
642 cookie = nla_memdup_cookie(tb);
643 if (!cookie) {
644 err = -ENOMEM;
645 goto err_out;
646 }
647 }
648 } else {
649 err = -EINVAL;
650 if (strlcpy(act_name, name, IFNAMSIZ) >= IFNAMSIZ)
651 goto err_out;
652 }
653
654 a_o = tc_lookup_action_n(act_name);
655 if (a_o == NULL) {
656 #ifdef CONFIG_MODULES
657 rtnl_unlock();
658 request_module("act_%s", act_name);
659 rtnl_lock();
660
661 a_o = tc_lookup_action_n(act_name);
662
663 /* We dropped the RTNL semaphore in order to
664 * perform the module load. So, even if we
665 * succeeded in loading the module we have to
666 * tell the caller to replay the request. We
667 * indicate this using -EAGAIN.
668 */
669 if (a_o != NULL) {
670 err = -EAGAIN;
671 goto err_mod;
672 }
673 #endif
674 err = -ENOENT;
675 goto err_out;
676 }
677
678 /* backward compatibility for policer */
679 if (name == NULL)
680 err = a_o->init(net, tb[TCA_ACT_OPTIONS], est, &a, ovr, bind);
681 else
682 err = a_o->init(net, nla, est, &a, ovr, bind);
683 if (err < 0)
684 goto err_mod;
685
686 if (name == NULL && tb[TCA_ACT_COOKIE]) {
687 if (a->act_cookie) {
688 kfree(a->act_cookie->data);
689 kfree(a->act_cookie);
690 }
691 a->act_cookie = cookie;
692 }
693
694 /* module count goes up only when brand new policy is created
695 * if it exists and is only bound to in a_o->init() then
696 * ACT_P_CREATED is not returned (a zero is).
697 */
698 if (err != ACT_P_CREATED)
699 module_put(a_o->owner);
700
701 if (TC_ACT_EXT_CMP(a->tcfa_action, TC_ACT_GOTO_CHAIN)) {
702 err = tcf_action_goto_chain_init(a, tp);
703 if (err) {
704 LIST_HEAD(actions);
705
706 list_add_tail(&a->list, &actions);
707 tcf_action_destroy(&actions, bind);
708 return ERR_PTR(err);
709 }
710 }
711
712 return a;
713
714 err_mod:
715 module_put(a_o->owner);
716 err_out:
717 if (cookie) {
718 kfree(cookie->data);
719 kfree(cookie);
720 }
721 return ERR_PTR(err);
722 }
723
724 static void cleanup_a(struct list_head *actions, int ovr)
725 {
726 struct tc_action *a;
727
728 if (!ovr)
729 return;
730
731 list_for_each_entry(a, actions, list)
732 a->tcfa_refcnt--;
733 }
734
735 int tcf_action_init(struct net *net, struct tcf_proto *tp, struct nlattr *nla,
736 struct nlattr *est, char *name, int ovr, int bind,
737 struct list_head *actions)
738 {
739 struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
740 struct tc_action *act;
741 int err;
742 int i;
743
744 err = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL, NULL);
745 if (err < 0)
746 return err;
747
748 for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) {
749 act = tcf_action_init_1(net, tp, tb[i], est, name, ovr, bind);
750 if (IS_ERR(act)) {
751 err = PTR_ERR(act);
752 goto err;
753 }
754 act->order = i;
755 if (ovr)
756 act->tcfa_refcnt++;
757 list_add_tail(&act->list, actions);
758 }
759
760 /* Remove the temp refcnt which was necessary to protect against
761 * destroying an existing action which was being replaced
762 */
763 cleanup_a(actions, ovr);
764 return 0;
765
766 err:
767 tcf_action_destroy(actions, bind);
768 return err;
769 }
770
771 int tcf_action_copy_stats(struct sk_buff *skb, struct tc_action *p,
772 int compat_mode)
773 {
774 int err = 0;
775 struct gnet_dump d;
776
777 if (p == NULL)
778 goto errout;
779
780 /* compat_mode being true specifies a call that is supposed
781 * to add additional backward compatibility statistic TLVs.
782 */
783 if (compat_mode) {
784 if (p->type == TCA_OLD_COMPAT)
785 err = gnet_stats_start_copy_compat(skb, 0,
786 TCA_STATS,
787 TCA_XSTATS,
788 &p->tcfa_lock, &d,
789 TCA_PAD);
790 else
791 return 0;
792 } else
793 err = gnet_stats_start_copy(skb, TCA_ACT_STATS,
794 &p->tcfa_lock, &d, TCA_ACT_PAD);
795
796 if (err < 0)
797 goto errout;
798
799 if (gnet_stats_copy_basic(NULL, &d, p->cpu_bstats, &p->tcfa_bstats) < 0 ||
800 gnet_stats_copy_rate_est(&d, &p->tcfa_rate_est) < 0 ||
801 gnet_stats_copy_queue(&d, p->cpu_qstats,
802 &p->tcfa_qstats,
803 p->tcfa_qstats.qlen) < 0)
804 goto errout;
805
806 if (gnet_stats_finish_copy(&d) < 0)
807 goto errout;
808
809 return 0;
810
811 errout:
812 return -1;
813 }
814
815 static int tca_get_fill(struct sk_buff *skb, struct list_head *actions,
816 u32 portid, u32 seq, u16 flags, int event, int bind,
817 int ref)
818 {
819 struct tcamsg *t;
820 struct nlmsghdr *nlh;
821 unsigned char *b = skb_tail_pointer(skb);
822 struct nlattr *nest;
823
824 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*t), flags);
825 if (!nlh)
826 goto out_nlmsg_trim;
827 t = nlmsg_data(nlh);
828 t->tca_family = AF_UNSPEC;
829 t->tca__pad1 = 0;
830 t->tca__pad2 = 0;
831
832 nest = nla_nest_start(skb, TCA_ACT_TAB);
833 if (nest == NULL)
834 goto out_nlmsg_trim;
835
836 if (tcf_action_dump(skb, actions, bind, ref) < 0)
837 goto out_nlmsg_trim;
838
839 nla_nest_end(skb, nest);
840
841 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
842 return skb->len;
843
844 out_nlmsg_trim:
845 nlmsg_trim(skb, b);
846 return -1;
847 }
848
849 static int
850 tcf_get_notify(struct net *net, u32 portid, struct nlmsghdr *n,
851 struct list_head *actions, int event)
852 {
853 struct sk_buff *skb;
854
855 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
856 if (!skb)
857 return -ENOBUFS;
858 if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, 0, event,
859 0, 0) <= 0) {
860 kfree_skb(skb);
861 return -EINVAL;
862 }
863
864 return rtnl_unicast(skb, net, portid);
865 }
866
867 static struct tc_action *tcf_action_get_1(struct net *net, struct nlattr *nla,
868 struct nlmsghdr *n, u32 portid)
869 {
870 struct nlattr *tb[TCA_ACT_MAX + 1];
871 const struct tc_action_ops *ops;
872 struct tc_action *a;
873 int index;
874 int err;
875
876 err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL, NULL);
877 if (err < 0)
878 goto err_out;
879
880 err = -EINVAL;
881 if (tb[TCA_ACT_INDEX] == NULL ||
882 nla_len(tb[TCA_ACT_INDEX]) < sizeof(index))
883 goto err_out;
884 index = nla_get_u32(tb[TCA_ACT_INDEX]);
885
886 err = -EINVAL;
887 ops = tc_lookup_action(tb[TCA_ACT_KIND]);
888 if (!ops) /* could happen in batch of actions */
889 goto err_out;
890 err = -ENOENT;
891 if (ops->lookup(net, &a, index) == 0)
892 goto err_mod;
893
894 module_put(ops->owner);
895 return a;
896
897 err_mod:
898 module_put(ops->owner);
899 err_out:
900 return ERR_PTR(err);
901 }
902
903 static int tca_action_flush(struct net *net, struct nlattr *nla,
904 struct nlmsghdr *n, u32 portid)
905 {
906 struct sk_buff *skb;
907 unsigned char *b;
908 struct nlmsghdr *nlh;
909 struct tcamsg *t;
910 struct netlink_callback dcb;
911 struct nlattr *nest;
912 struct nlattr *tb[TCA_ACT_MAX + 1];
913 const struct tc_action_ops *ops;
914 struct nlattr *kind;
915 int err = -ENOMEM;
916
917 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
918 if (!skb) {
919 pr_debug("tca_action_flush: failed skb alloc\n");
920 return err;
921 }
922
923 b = skb_tail_pointer(skb);
924
925 err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL, NULL);
926 if (err < 0)
927 goto err_out;
928
929 err = -EINVAL;
930 kind = tb[TCA_ACT_KIND];
931 ops = tc_lookup_action(kind);
932 if (!ops) /*some idjot trying to flush unknown action */
933 goto err_out;
934
935 nlh = nlmsg_put(skb, portid, n->nlmsg_seq, RTM_DELACTION,
936 sizeof(*t), 0);
937 if (!nlh)
938 goto out_module_put;
939 t = nlmsg_data(nlh);
940 t->tca_family = AF_UNSPEC;
941 t->tca__pad1 = 0;
942 t->tca__pad2 = 0;
943
944 nest = nla_nest_start(skb, TCA_ACT_TAB);
945 if (nest == NULL)
946 goto out_module_put;
947
948 err = ops->walk(net, skb, &dcb, RTM_DELACTION, ops);
949 if (err <= 0)
950 goto out_module_put;
951
952 nla_nest_end(skb, nest);
953
954 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
955 nlh->nlmsg_flags |= NLM_F_ROOT;
956 module_put(ops->owner);
957 err = rtnetlink_send(skb, net, portid, RTNLGRP_TC,
958 n->nlmsg_flags & NLM_F_ECHO);
959 if (err > 0)
960 return 0;
961
962 return err;
963
964 out_module_put:
965 module_put(ops->owner);
966 err_out:
967 kfree_skb(skb);
968 return err;
969 }
970
971 static int
972 tcf_del_notify(struct net *net, struct nlmsghdr *n, struct list_head *actions,
973 u32 portid)
974 {
975 int ret;
976 struct sk_buff *skb;
977
978 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
979 if (!skb)
980 return -ENOBUFS;
981
982 if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, 0, RTM_DELACTION,
983 0, 1) <= 0) {
984 kfree_skb(skb);
985 return -EINVAL;
986 }
987
988 /* now do the delete */
989 ret = tcf_action_destroy(actions, 0);
990 if (ret < 0) {
991 kfree_skb(skb);
992 return ret;
993 }
994
995 ret = rtnetlink_send(skb, net, portid, RTNLGRP_TC,
996 n->nlmsg_flags & NLM_F_ECHO);
997 if (ret > 0)
998 return 0;
999 return ret;
1000 }
1001
1002 static int
1003 tca_action_gd(struct net *net, struct nlattr *nla, struct nlmsghdr *n,
1004 u32 portid, int event)
1005 {
1006 int i, ret;
1007 struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
1008 struct tc_action *act;
1009 LIST_HEAD(actions);
1010
1011 ret = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL, NULL);
1012 if (ret < 0)
1013 return ret;
1014
1015 if (event == RTM_DELACTION && n->nlmsg_flags & NLM_F_ROOT) {
1016 if (tb[1] != NULL)
1017 return tca_action_flush(net, tb[1], n, portid);
1018 else
1019 return -EINVAL;
1020 }
1021
1022 for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) {
1023 act = tcf_action_get_1(net, tb[i], n, portid);
1024 if (IS_ERR(act)) {
1025 ret = PTR_ERR(act);
1026 goto err;
1027 }
1028 act->order = i;
1029 list_add_tail(&act->list, &actions);
1030 }
1031
1032 if (event == RTM_GETACTION)
1033 ret = tcf_get_notify(net, portid, n, &actions, event);
1034 else { /* delete */
1035 ret = tcf_del_notify(net, n, &actions, portid);
1036 if (ret)
1037 goto err;
1038 return ret;
1039 }
1040 err:
1041 if (event != RTM_GETACTION)
1042 tcf_action_destroy(&actions, 0);
1043 return ret;
1044 }
1045
1046 static int
1047 tcf_add_notify(struct net *net, struct nlmsghdr *n, struct list_head *actions,
1048 u32 portid)
1049 {
1050 struct sk_buff *skb;
1051 int err = 0;
1052
1053 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1054 if (!skb)
1055 return -ENOBUFS;
1056
1057 if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, n->nlmsg_flags,
1058 RTM_NEWACTION, 0, 0) <= 0) {
1059 kfree_skb(skb);
1060 return -EINVAL;
1061 }
1062
1063 err = rtnetlink_send(skb, net, portid, RTNLGRP_TC,
1064 n->nlmsg_flags & NLM_F_ECHO);
1065 if (err > 0)
1066 err = 0;
1067 return err;
1068 }
1069
1070 static int tcf_action_add(struct net *net, struct nlattr *nla,
1071 struct nlmsghdr *n, u32 portid, int ovr)
1072 {
1073 int ret = 0;
1074 LIST_HEAD(actions);
1075
1076 ret = tcf_action_init(net, NULL, nla, NULL, NULL, ovr, 0, &actions);
1077 if (ret)
1078 return ret;
1079
1080 return tcf_add_notify(net, n, &actions, portid);
1081 }
1082
1083 static u32 tcaa_root_flags_allowed = TCA_FLAG_LARGE_DUMP_ON;
1084 static const struct nla_policy tcaa_policy[TCA_ROOT_MAX + 1] = {
1085 [TCA_ROOT_FLAGS] = { .type = NLA_BITFIELD32,
1086 .validation_data = &tcaa_root_flags_allowed },
1087 [TCA_ROOT_TIME_DELTA] = { .type = NLA_U32 },
1088 };
1089
1090 static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n,
1091 struct netlink_ext_ack *extack)
1092 {
1093 struct net *net = sock_net(skb->sk);
1094 struct nlattr *tca[TCA_ROOT_MAX + 1];
1095 u32 portid = skb ? NETLINK_CB(skb).portid : 0;
1096 int ret = 0, ovr = 0;
1097
1098 if ((n->nlmsg_type != RTM_GETACTION) &&
1099 !netlink_capable(skb, CAP_NET_ADMIN))
1100 return -EPERM;
1101
1102 ret = nlmsg_parse(n, sizeof(struct tcamsg), tca, TCA_ROOT_MAX, NULL,
1103 extack);
1104 if (ret < 0)
1105 return ret;
1106
1107 if (tca[TCA_ACT_TAB] == NULL) {
1108 pr_notice("tc_ctl_action: received NO action attribs\n");
1109 return -EINVAL;
1110 }
1111
1112 /* n->nlmsg_flags & NLM_F_CREATE */
1113 switch (n->nlmsg_type) {
1114 case RTM_NEWACTION:
1115 /* we are going to assume all other flags
1116 * imply create only if it doesn't exist
1117 * Note that CREATE | EXCL implies that
1118 * but since we want avoid ambiguity (eg when flags
1119 * is zero) then just set this
1120 */
1121 if (n->nlmsg_flags & NLM_F_REPLACE)
1122 ovr = 1;
1123 replay:
1124 ret = tcf_action_add(net, tca[TCA_ACT_TAB], n, portid, ovr);
1125 if (ret == -EAGAIN)
1126 goto replay;
1127 break;
1128 case RTM_DELACTION:
1129 ret = tca_action_gd(net, tca[TCA_ACT_TAB], n,
1130 portid, RTM_DELACTION);
1131 break;
1132 case RTM_GETACTION:
1133 ret = tca_action_gd(net, tca[TCA_ACT_TAB], n,
1134 portid, RTM_GETACTION);
1135 break;
1136 default:
1137 BUG();
1138 }
1139
1140 return ret;
1141 }
1142
1143 static struct nlattr *find_dump_kind(struct nlattr **nla)
1144 {
1145 struct nlattr *tb1, *tb2[TCA_ACT_MAX + 1];
1146 struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
1147 struct nlattr *kind;
1148
1149 tb1 = nla[TCA_ACT_TAB];
1150 if (tb1 == NULL)
1151 return NULL;
1152
1153 if (nla_parse(tb, TCA_ACT_MAX_PRIO, nla_data(tb1),
1154 NLMSG_ALIGN(nla_len(tb1)), NULL, NULL) < 0)
1155 return NULL;
1156
1157 if (tb[1] == NULL)
1158 return NULL;
1159 if (nla_parse_nested(tb2, TCA_ACT_MAX, tb[1], NULL, NULL) < 0)
1160 return NULL;
1161 kind = tb2[TCA_ACT_KIND];
1162
1163 return kind;
1164 }
1165
1166 static int tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb)
1167 {
1168 struct net *net = sock_net(skb->sk);
1169 struct nlmsghdr *nlh;
1170 unsigned char *b = skb_tail_pointer(skb);
1171 struct nlattr *nest;
1172 struct tc_action_ops *a_o;
1173 int ret = 0;
1174 struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh);
1175 struct nlattr *tb[TCA_ROOT_MAX + 1];
1176 struct nlattr *count_attr = NULL;
1177 unsigned long jiffy_since = 0;
1178 struct nlattr *kind = NULL;
1179 struct nla_bitfield32 bf;
1180 u32 msecs_since = 0;
1181 u32 act_count = 0;
1182
1183 ret = nlmsg_parse(cb->nlh, sizeof(struct tcamsg), tb, TCA_ROOT_MAX,
1184 tcaa_policy, NULL);
1185 if (ret < 0)
1186 return ret;
1187
1188 kind = find_dump_kind(tb);
1189 if (kind == NULL) {
1190 pr_info("tc_dump_action: action bad kind\n");
1191 return 0;
1192 }
1193
1194 a_o = tc_lookup_action(kind);
1195 if (a_o == NULL)
1196 return 0;
1197
1198 cb->args[2] = 0;
1199 if (tb[TCA_ROOT_FLAGS]) {
1200 bf = nla_get_bitfield32(tb[TCA_ROOT_FLAGS]);
1201 cb->args[2] = bf.value;
1202 }
1203
1204 if (tb[TCA_ROOT_TIME_DELTA]) {
1205 msecs_since = nla_get_u32(tb[TCA_ROOT_TIME_DELTA]);
1206 }
1207
1208 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
1209 cb->nlh->nlmsg_type, sizeof(*t), 0);
1210 if (!nlh)
1211 goto out_module_put;
1212
1213 if (msecs_since)
1214 jiffy_since = jiffies - msecs_to_jiffies(msecs_since);
1215
1216 t = nlmsg_data(nlh);
1217 t->tca_family = AF_UNSPEC;
1218 t->tca__pad1 = 0;
1219 t->tca__pad2 = 0;
1220 cb->args[3] = jiffy_since;
1221 count_attr = nla_reserve(skb, TCA_ROOT_COUNT, sizeof(u32));
1222 if (!count_attr)
1223 goto out_module_put;
1224
1225 nest = nla_nest_start(skb, TCA_ACT_TAB);
1226 if (nest == NULL)
1227 goto out_module_put;
1228
1229 ret = a_o->walk(net, skb, cb, RTM_GETACTION, a_o);
1230 if (ret < 0)
1231 goto out_module_put;
1232
1233 if (ret > 0) {
1234 nla_nest_end(skb, nest);
1235 ret = skb->len;
1236 act_count = cb->args[1];
1237 memcpy(nla_data(count_attr), &act_count, sizeof(u32));
1238 cb->args[1] = 0;
1239 } else
1240 nlmsg_trim(skb, b);
1241
1242 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1243 if (NETLINK_CB(cb->skb).portid && ret)
1244 nlh->nlmsg_flags |= NLM_F_MULTI;
1245 module_put(a_o->owner);
1246 return skb->len;
1247
1248 out_module_put:
1249 module_put(a_o->owner);
1250 nlmsg_trim(skb, b);
1251 return skb->len;
1252 }
1253
1254 static int __init tc_action_init(void)
1255 {
1256 rtnl_register(PF_UNSPEC, RTM_NEWACTION, tc_ctl_action, NULL, 0);
1257 rtnl_register(PF_UNSPEC, RTM_DELACTION, tc_ctl_action, NULL, 0);
1258 rtnl_register(PF_UNSPEC, RTM_GETACTION, tc_ctl_action, tc_dump_action,
1259 0);
1260
1261 return 0;
1262 }
1263
1264 subsys_initcall(tc_action_init);
ubuntu-bionic-kernel mirror