ac97db92ab68cd1502b8c3cfb74558b4b3d0d462
[sfrench/cifs-2.6.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 <linux/rhashtable.h>
25 #include <linux/list.h>
26 #include <net/net_namespace.h>
27 #include <net/sock.h>
28 #include <net/sch_generic.h>
29 #include <net/pkt_cls.h>
30 #include <net/act_api.h>
31 #include <net/netlink.h>
32
33 static int tcf_action_goto_chain_init(struct tc_action *a, struct tcf_proto *tp)
34 {
35         u32 chain_index = a->tcfa_action & TC_ACT_EXT_VAL_MASK;
36
37         if (!tp)
38                 return -EINVAL;
39         a->goto_chain = tcf_chain_get(tp->chain->block, chain_index, true);
40         if (!a->goto_chain)
41                 return -ENOMEM;
42         return 0;
43 }
44
45 static void tcf_action_goto_chain_fini(struct tc_action *a)
46 {
47         tcf_chain_put(a->goto_chain);
48 }
49
50 static void tcf_action_goto_chain_exec(const struct tc_action *a,
51                                        struct tcf_result *res)
52 {
53         const struct tcf_chain *chain = a->goto_chain;
54
55         res->goto_tp = rcu_dereference_bh(chain->filter_chain);
56 }
57
58 /* XXX: For standalone actions, we don't need a RCU grace period either, because
59  * actions are always connected to filters and filters are already destroyed in
60  * RCU callbacks, so after a RCU grace period actions are already disconnected
61  * from filters. Readers later can not find us.
62  */
63 static void free_tcf(struct tc_action *p)
64 {
65         free_percpu(p->cpu_bstats);
66         free_percpu(p->cpu_qstats);
67
68         if (p->act_cookie) {
69                 kfree(p->act_cookie->data);
70                 kfree(p->act_cookie);
71         }
72         if (p->goto_chain)
73                 tcf_action_goto_chain_fini(p);
74
75         kfree(p);
76 }
77
78 static void tcf_idr_remove(struct tcf_idrinfo *idrinfo, struct tc_action *p)
79 {
80         spin_lock_bh(&idrinfo->lock);
81         idr_remove_ext(&idrinfo->action_idr, p->tcfa_index);
82         spin_unlock_bh(&idrinfo->lock);
83         gen_kill_estimator(&p->tcfa_rate_est);
84         free_tcf(p);
85 }
86
87 int __tcf_idr_release(struct tc_action *p, bool bind, bool strict)
88 {
89         int ret = 0;
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 struct tcf_action_net {
1255         struct rhashtable egdev_ht;
1256 };
1257
1258 static unsigned int tcf_action_net_id;
1259
1260 struct tcf_action_egdev_cb {
1261         struct list_head list;
1262         tc_setup_cb_t *cb;
1263         void *cb_priv;
1264 };
1265
1266 struct tcf_action_egdev {
1267         struct rhash_head ht_node;
1268         const struct net_device *dev;
1269         unsigned int refcnt;
1270         struct list_head cb_list;
1271 };
1272
1273 static const struct rhashtable_params tcf_action_egdev_ht_params = {
1274         .key_offset = offsetof(struct tcf_action_egdev, dev),
1275         .head_offset = offsetof(struct tcf_action_egdev, ht_node),
1276         .key_len = sizeof(const struct net_device *),
1277 };
1278
1279 static struct tcf_action_egdev *
1280 tcf_action_egdev_lookup(const struct net_device *dev)
1281 {
1282         struct net *net = dev_net(dev);
1283         struct tcf_action_net *tan = net_generic(net, tcf_action_net_id);
1284
1285         return rhashtable_lookup_fast(&tan->egdev_ht, &dev,
1286                                       tcf_action_egdev_ht_params);
1287 }
1288
1289 static struct tcf_action_egdev *
1290 tcf_action_egdev_get(const struct net_device *dev)
1291 {
1292         struct tcf_action_egdev *egdev;
1293         struct tcf_action_net *tan;
1294
1295         egdev = tcf_action_egdev_lookup(dev);
1296         if (egdev)
1297                 goto inc_ref;
1298
1299         egdev = kzalloc(sizeof(*egdev), GFP_KERNEL);
1300         if (!egdev)
1301                 return NULL;
1302         INIT_LIST_HEAD(&egdev->cb_list);
1303         tan = net_generic(dev_net(dev), tcf_action_net_id);
1304         rhashtable_insert_fast(&tan->egdev_ht, &egdev->ht_node,
1305                                tcf_action_egdev_ht_params);
1306
1307 inc_ref:
1308         egdev->refcnt++;
1309         return egdev;
1310 }
1311
1312 static void tcf_action_egdev_put(struct tcf_action_egdev *egdev)
1313 {
1314         struct tcf_action_net *tan;
1315
1316         if (--egdev->refcnt)
1317                 return;
1318         tan = net_generic(dev_net(egdev->dev), tcf_action_net_id);
1319         rhashtable_remove_fast(&tan->egdev_ht, &egdev->ht_node,
1320                                tcf_action_egdev_ht_params);
1321         kfree(egdev);
1322 }
1323
1324 static struct tcf_action_egdev_cb *
1325 tcf_action_egdev_cb_lookup(struct tcf_action_egdev *egdev,
1326                            tc_setup_cb_t *cb, void *cb_priv)
1327 {
1328         struct tcf_action_egdev_cb *egdev_cb;
1329
1330         list_for_each_entry(egdev_cb, &egdev->cb_list, list)
1331                 if (egdev_cb->cb == cb && egdev_cb->cb_priv == cb_priv)
1332                         return egdev_cb;
1333         return NULL;
1334 }
1335
1336 static int tcf_action_egdev_cb_call(struct tcf_action_egdev *egdev,
1337                                     enum tc_setup_type type,
1338                                     void *type_data, bool err_stop)
1339 {
1340         struct tcf_action_egdev_cb *egdev_cb;
1341         int ok_count = 0;
1342         int err;
1343
1344         list_for_each_entry(egdev_cb, &egdev->cb_list, list) {
1345                 err = egdev_cb->cb(type, type_data, egdev_cb->cb_priv);
1346                 if (err) {
1347                         if (err_stop)
1348                                 return err;
1349                 } else {
1350                         ok_count++;
1351                 }
1352         }
1353         return ok_count;
1354 }
1355
1356 static int tcf_action_egdev_cb_add(struct tcf_action_egdev *egdev,
1357                                    tc_setup_cb_t *cb, void *cb_priv)
1358 {
1359         struct tcf_action_egdev_cb *egdev_cb;
1360
1361         egdev_cb = tcf_action_egdev_cb_lookup(egdev, cb, cb_priv);
1362         if (WARN_ON(egdev_cb))
1363                 return -EEXIST;
1364         egdev_cb = kzalloc(sizeof(*egdev_cb), GFP_KERNEL);
1365         if (!egdev_cb)
1366                 return -ENOMEM;
1367         egdev_cb->cb = cb;
1368         egdev_cb->cb_priv = cb_priv;
1369         list_add(&egdev_cb->list, &egdev->cb_list);
1370         return 0;
1371 }
1372
1373 static void tcf_action_egdev_cb_del(struct tcf_action_egdev *egdev,
1374                                     tc_setup_cb_t *cb, void *cb_priv)
1375 {
1376         struct tcf_action_egdev_cb *egdev_cb;
1377
1378         egdev_cb = tcf_action_egdev_cb_lookup(egdev, cb, cb_priv);
1379         if (WARN_ON(!egdev_cb))
1380                 return;
1381         list_del(&egdev_cb->list);
1382         kfree(egdev_cb);
1383 }
1384
1385 static int __tc_setup_cb_egdev_register(const struct net_device *dev,
1386                                         tc_setup_cb_t *cb, void *cb_priv)
1387 {
1388         struct tcf_action_egdev *egdev = tcf_action_egdev_get(dev);
1389         int err;
1390
1391         if (!egdev)
1392                 return -ENOMEM;
1393         err = tcf_action_egdev_cb_add(egdev, cb, cb_priv);
1394         if (err)
1395                 goto err_cb_add;
1396         return 0;
1397
1398 err_cb_add:
1399         tcf_action_egdev_put(egdev);
1400         return err;
1401 }
1402 int tc_setup_cb_egdev_register(const struct net_device *dev,
1403                                tc_setup_cb_t *cb, void *cb_priv)
1404 {
1405         int err;
1406
1407         rtnl_lock();
1408         err = __tc_setup_cb_egdev_register(dev, cb, cb_priv);
1409         rtnl_unlock();
1410         return err;
1411 }
1412 EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_register);
1413
1414 static void __tc_setup_cb_egdev_unregister(const struct net_device *dev,
1415                                            tc_setup_cb_t *cb, void *cb_priv)
1416 {
1417         struct tcf_action_egdev *egdev = tcf_action_egdev_lookup(dev);
1418
1419         if (WARN_ON(!egdev))
1420                 return;
1421         tcf_action_egdev_cb_del(egdev, cb, cb_priv);
1422         tcf_action_egdev_put(egdev);
1423 }
1424 void tc_setup_cb_egdev_unregister(const struct net_device *dev,
1425                                   tc_setup_cb_t *cb, void *cb_priv)
1426 {
1427         rtnl_lock();
1428         __tc_setup_cb_egdev_unregister(dev, cb, cb_priv);
1429         rtnl_unlock();
1430 }
1431 EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_unregister);
1432
1433 int tc_setup_cb_egdev_call(const struct net_device *dev,
1434                            enum tc_setup_type type, void *type_data,
1435                            bool err_stop)
1436 {
1437         struct tcf_action_egdev *egdev = tcf_action_egdev_lookup(dev);
1438
1439         if (!egdev)
1440                 return 0;
1441         return tcf_action_egdev_cb_call(egdev, type, type_data, err_stop);
1442 }
1443 EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_call);
1444
1445 static __net_init int tcf_action_net_init(struct net *net)
1446 {
1447         struct tcf_action_net *tan = net_generic(net, tcf_action_net_id);
1448
1449         return rhashtable_init(&tan->egdev_ht, &tcf_action_egdev_ht_params);
1450 }
1451
1452 static void __net_exit tcf_action_net_exit(struct net *net)
1453 {
1454         struct tcf_action_net *tan = net_generic(net, tcf_action_net_id);
1455
1456         rhashtable_destroy(&tan->egdev_ht);
1457 }
1458
1459 static struct pernet_operations tcf_action_net_ops = {
1460         .init = tcf_action_net_init,
1461         .exit = tcf_action_net_exit,
1462         .id = &tcf_action_net_id,
1463         .size = sizeof(struct tcf_action_net),
1464 };
1465
1466 static int __init tc_action_init(void)
1467 {
1468         int err;
1469
1470         err = register_pernet_subsys(&tcf_action_net_ops);
1471         if (err)
1472                 return err;
1473
1474         rtnl_register(PF_UNSPEC, RTM_NEWACTION, tc_ctl_action, NULL, 0);
1475         rtnl_register(PF_UNSPEC, RTM_DELACTION, tc_ctl_action, NULL, 0);
1476         rtnl_register(PF_UNSPEC, RTM_GETACTION, tc_ctl_action, tc_dump_action,
1477                       0);
1478
1479         return 0;
1480 }
1481
1482 subsys_initcall(tc_action_init);