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

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

Version: ~ [ linux-6.3-rc3 ] ~ [ linux-6.2.7 ] ~ [ linux-6.1.20 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.103 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.175 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.237 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.278 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.310 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

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

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

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

osdn.jp