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