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

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

Version: ~ [ linux-5.12 ] ~ [ linux-5.11.16 ] ~ [ linux-5.10.32 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.114 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.188 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.231 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.267 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.267 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  * net/sched/act_api.c  Packet action API.
  4  *
  5  * Author:      Jamal Hadi Salim
  6  */
  7 
  8 #include <linux/types.h>
  9 #include <linux/kernel.h>
 10 #include <linux/string.h>
 11 #include <linux/errno.h>
 12 #include <linux/slab.h>
 13 #include <linux/skbuff.h>
 14 #include <linux/init.h>
 15 #include <linux/kmod.h>
 16 #include <linux/err.h>
 17 #include <linux/module.h>
 18 #include <net/net_namespace.h>
 19 #include <net/sock.h>
 20 #include <net/sch_generic.h>
 21 #include <net/pkt_cls.h>
 22 #include <net/act_api.h>
 23 #include <net/netlink.h>
 24 
 25 static void tcf_action_goto_chain_exec(const struct tc_action *a,
 26                                        struct tcf_result *res)
 27 {
 28         const struct tcf_chain *chain = rcu_dereference_bh(a->goto_chain);
 29 
 30         res->goto_tp = rcu_dereference_bh(chain->filter_chain);
 31 }
 32 
 33 static void tcf_free_cookie_rcu(struct rcu_head *p)
 34 {
 35         struct tc_cookie *cookie = container_of(p, struct tc_cookie, rcu);
 36 
 37         kfree(cookie->data);
 38         kfree(cookie);
 39 }
 40 
 41 static void tcf_set_action_cookie(struct tc_cookie __rcu **old_cookie,
 42                                   struct tc_cookie *new_cookie)
 43 {
 44         struct tc_cookie *old;
 45 
 46         old = xchg((__force struct tc_cookie **)old_cookie, new_cookie);
 47         if (old)
 48                 call_rcu(&old->rcu, tcf_free_cookie_rcu);
 49 }
 50 
 51 int tcf_action_check_ctrlact(int action, struct tcf_proto *tp,
 52                              struct tcf_chain **newchain,
 53                              struct netlink_ext_ack *extack)
 54 {
 55         int opcode = TC_ACT_EXT_OPCODE(action), ret = -EINVAL;
 56         u32 chain_index;
 57 
 58         if (!opcode)
 59                 ret = action > TC_ACT_VALUE_MAX ? -EINVAL : 0;
 60         else if (opcode <= TC_ACT_EXT_OPCODE_MAX || action == TC_ACT_UNSPEC)
 61                 ret = 0;
 62         if (ret) {
 63                 NL_SET_ERR_MSG(extack, "invalid control action");
 64                 goto end;
 65         }
 66 
 67         if (TC_ACT_EXT_CMP(action, TC_ACT_GOTO_CHAIN)) {
 68                 chain_index = action & TC_ACT_EXT_VAL_MASK;
 69                 if (!tp || !newchain) {
 70                         ret = -EINVAL;
 71                         NL_SET_ERR_MSG(extack,
 72                                        "can't goto NULL proto/chain");
 73                         goto end;
 74                 }
 75                 *newchain = tcf_chain_get_by_act(tp->chain->block, chain_index);
 76                 if (!*newchain) {
 77                         ret = -ENOMEM;
 78                         NL_SET_ERR_MSG(extack,
 79                                        "can't allocate goto_chain");
 80                 }
 81         }
 82 end:
 83         return ret;
 84 }
 85 EXPORT_SYMBOL(tcf_action_check_ctrlact);
 86 
 87 struct tcf_chain *tcf_action_set_ctrlact(struct tc_action *a, int action,
 88                                          struct tcf_chain *goto_chain)
 89 {
 90         a->tcfa_action = action;
 91         goto_chain = rcu_replace_pointer(a->goto_chain, goto_chain, 1);
 92         return goto_chain;
 93 }
 94 EXPORT_SYMBOL(tcf_action_set_ctrlact);
 95 
 96 /* XXX: For standalone actions, we don't need a RCU grace period either, because
 97  * actions are always connected to filters and filters are already destroyed in
 98  * RCU callbacks, so after a RCU grace period actions are already disconnected
 99  * from filters. Readers later can not find us.
100  */
101 static void free_tcf(struct tc_action *p)
102 {
103         struct tcf_chain *chain = rcu_dereference_protected(p->goto_chain, 1);
104 
105         free_percpu(p->cpu_bstats);
106         free_percpu(p->cpu_bstats_hw);
107         free_percpu(p->cpu_qstats);
108 
109         tcf_set_action_cookie(&p->act_cookie, NULL);
110         if (chain)
111                 tcf_chain_put_by_act(chain);
112 
113         kfree(p);
114 }
115 
116 static void tcf_action_cleanup(struct tc_action *p)
117 {
118         if (p->ops->cleanup)
119                 p->ops->cleanup(p);
120 
121         gen_kill_estimator(&p->tcfa_rate_est);
122         free_tcf(p);
123 }
124 
125 static int __tcf_action_put(struct tc_action *p, bool bind)
126 {
127         struct tcf_idrinfo *idrinfo = p->idrinfo;
128 
129         if (refcount_dec_and_mutex_lock(&p->tcfa_refcnt, &idrinfo->lock)) {
130                 if (bind)
131                         atomic_dec(&p->tcfa_bindcnt);
132                 idr_remove(&idrinfo->action_idr, p->tcfa_index);
133                 mutex_unlock(&idrinfo->lock);
134 
135                 tcf_action_cleanup(p);
136                 return 1;
137         }
138 
139         if (bind)
140                 atomic_dec(&p->tcfa_bindcnt);
141 
142         return 0;
143 }
144 
145 int __tcf_idr_release(struct tc_action *p, bool bind, bool strict)
146 {
147         int ret = 0;
148 
149         /* Release with strict==1 and bind==0 is only called through act API
150          * interface (classifiers always bind). Only case when action with
151          * positive reference count and zero bind count can exist is when it was
152          * also created with act API (unbinding last classifier will destroy the
153          * action if it was created by classifier). So only case when bind count
154          * can be changed after initial check is when unbound action is
155          * destroyed by act API while classifier binds to action with same id
156          * concurrently. This result either creation of new action(same behavior
157          * as before), or reusing existing action if concurrent process
158          * increments reference count before action is deleted. Both scenarios
159          * are acceptable.
160          */
161         if (p) {
162                 if (!bind && strict && atomic_read(&p->tcfa_bindcnt) > 0)
163                         return -EPERM;
164 
165                 if (__tcf_action_put(p, bind))
166                         ret = ACT_P_DELETED;
167         }
168 
169         return ret;
170 }
171 EXPORT_SYMBOL(__tcf_idr_release);
172 
173 static size_t tcf_action_shared_attrs_size(const struct tc_action *act)
174 {
175         struct tc_cookie *act_cookie;
176         u32 cookie_len = 0;
177 
178         rcu_read_lock();
179         act_cookie = rcu_dereference(act->act_cookie);
180 
181         if (act_cookie)
182                 cookie_len = nla_total_size(act_cookie->len);
183         rcu_read_unlock();
184 
185         return  nla_total_size(0) /* action number nested */
186                 + nla_total_size(IFNAMSIZ) /* TCA_ACT_KIND */
187                 + cookie_len /* TCA_ACT_COOKIE */
188                 + nla_total_size(sizeof(struct nla_bitfield32)) /* TCA_ACT_HW_STATS */
189                 + nla_total_size(0) /* TCA_ACT_STATS nested */
190                 + nla_total_size(sizeof(struct nla_bitfield32)) /* TCA_ACT_FLAGS */
191                 /* TCA_STATS_BASIC */
192                 + nla_total_size_64bit(sizeof(struct gnet_stats_basic))
193                 /* TCA_STATS_PKT64 */
194                 + nla_total_size_64bit(sizeof(u64))
195                 /* TCA_STATS_QUEUE */
196                 + nla_total_size_64bit(sizeof(struct gnet_stats_queue))
197                 + nla_total_size(0) /* TCA_OPTIONS nested */
198                 + nla_total_size(sizeof(struct tcf_t)); /* TCA_GACT_TM */
199 }
200 
201 static size_t tcf_action_full_attrs_size(size_t sz)
202 {
203         return NLMSG_HDRLEN                     /* struct nlmsghdr */
204                 + sizeof(struct tcamsg)
205                 + nla_total_size(0)             /* TCA_ACT_TAB nested */
206                 + sz;
207 }
208 
209 static size_t tcf_action_fill_size(const struct tc_action *act)
210 {
211         size_t sz = tcf_action_shared_attrs_size(act);
212 
213         if (act->ops->get_fill_size)
214                 return act->ops->get_fill_size(act) + sz;
215         return sz;
216 }
217 
218 static int tcf_dump_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb,
219                            struct netlink_callback *cb)
220 {
221         int err = 0, index = -1, s_i = 0, n_i = 0;
222         u32 act_flags = cb->args[2];
223         unsigned long jiffy_since = cb->args[3];
224         struct nlattr *nest;
225         struct idr *idr = &idrinfo->action_idr;
226         struct tc_action *p;
227         unsigned long id = 1;
228         unsigned long tmp;
229 
230         mutex_lock(&idrinfo->lock);
231 
232         s_i = cb->args[0];
233 
234         idr_for_each_entry_ul(idr, p, tmp, id) {
235                 index++;
236                 if (index < s_i)
237                         continue;
238                 if (IS_ERR(p))
239                         continue;
240 
241                 if (jiffy_since &&
242                     time_after(jiffy_since,
243                                (unsigned long)p->tcfa_tm.lastuse))
244                         continue;
245 
246                 nest = nla_nest_start_noflag(skb, n_i);
247                 if (!nest) {
248                         index--;
249                         goto nla_put_failure;
250                 }
251                 err = tcf_action_dump_1(skb, p, 0, 0);
252                 if (err < 0) {
253                         index--;
254                         nlmsg_trim(skb, nest);
255                         goto done;
256                 }
257                 nla_nest_end(skb, nest);
258                 n_i++;
259                 if (!(act_flags & TCA_FLAG_LARGE_DUMP_ON) &&
260                     n_i >= TCA_ACT_MAX_PRIO)
261                         goto done;
262         }
263 done:
264         if (index >= 0)
265                 cb->args[0] = index + 1;
266 
267         mutex_unlock(&idrinfo->lock);
268         if (n_i) {
269                 if (act_flags & TCA_FLAG_LARGE_DUMP_ON)
270                         cb->args[1] = n_i;
271         }
272         return n_i;
273 
274 nla_put_failure:
275         nla_nest_cancel(skb, nest);
276         goto done;
277 }
278 
279 static int tcf_idr_release_unsafe(struct tc_action *p)
280 {
281         if (atomic_read(&p->tcfa_bindcnt) > 0)
282                 return -EPERM;
283 
284         if (refcount_dec_and_test(&p->tcfa_refcnt)) {
285                 idr_remove(&p->idrinfo->action_idr, p->tcfa_index);
286                 tcf_action_cleanup(p);
287                 return ACT_P_DELETED;
288         }
289 
290         return 0;
291 }
292 
293 static int tcf_del_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb,
294                           const struct tc_action_ops *ops)
295 {
296         struct nlattr *nest;
297         int n_i = 0;
298         int ret = -EINVAL;
299         struct idr *idr = &idrinfo->action_idr;
300         struct tc_action *p;
301         unsigned long id = 1;
302         unsigned long tmp;
303 
304         nest = nla_nest_start_noflag(skb, 0);
305         if (nest == NULL)
306                 goto nla_put_failure;
307         if (nla_put_string(skb, TCA_KIND, ops->kind))
308                 goto nla_put_failure;
309 
310         mutex_lock(&idrinfo->lock);
311         idr_for_each_entry_ul(idr, p, tmp, id) {
312                 if (IS_ERR(p))
313                         continue;
314                 ret = tcf_idr_release_unsafe(p);
315                 if (ret == ACT_P_DELETED) {
316                         module_put(ops->owner);
317                         n_i++;
318                 } else if (ret < 0) {
319                         mutex_unlock(&idrinfo->lock);
320                         goto nla_put_failure;
321                 }
322         }
323         mutex_unlock(&idrinfo->lock);
324 
325         if (nla_put_u32(skb, TCA_FCNT, n_i))
326                 goto nla_put_failure;
327         nla_nest_end(skb, nest);
328 
329         return n_i;
330 nla_put_failure:
331         nla_nest_cancel(skb, nest);
332         return ret;
333 }
334 
335 int tcf_generic_walker(struct tc_action_net *tn, struct sk_buff *skb,
336                        struct netlink_callback *cb, int type,
337                        const struct tc_action_ops *ops,
338                        struct netlink_ext_ack *extack)
339 {
340         struct tcf_idrinfo *idrinfo = tn->idrinfo;
341 
342         if (type == RTM_DELACTION) {
343                 return tcf_del_walker(idrinfo, skb, ops);
344         } else if (type == RTM_GETACTION) {
345                 return tcf_dump_walker(idrinfo, skb, cb);
346         } else {
347                 WARN(1, "tcf_generic_walker: unknown command %d\n", type);
348                 NL_SET_ERR_MSG(extack, "tcf_generic_walker: unknown command");
349                 return -EINVAL;
350         }
351 }
352 EXPORT_SYMBOL(tcf_generic_walker);
353 
354 int tcf_idr_search(struct tc_action_net *tn, struct tc_action **a, u32 index)
355 {
356         struct tcf_idrinfo *idrinfo = tn->idrinfo;
357         struct tc_action *p;
358 
359         mutex_lock(&idrinfo->lock);
360         p = idr_find(&idrinfo->action_idr, index);
361         if (IS_ERR(p))
362                 p = NULL;
363         else if (p)
364                 refcount_inc(&p->tcfa_refcnt);
365         mutex_unlock(&idrinfo->lock);
366 
367         if (p) {
368                 *a = p;
369                 return true;
370         }
371         return false;
372 }
373 EXPORT_SYMBOL(tcf_idr_search);
374 
375 static int tcf_idr_delete_index(struct tcf_idrinfo *idrinfo, u32 index)
376 {
377         struct tc_action *p;
378         int ret = 0;
379 
380         mutex_lock(&idrinfo->lock);
381         p = idr_find(&idrinfo->action_idr, index);
382         if (!p) {
383                 mutex_unlock(&idrinfo->lock);
384                 return -ENOENT;
385         }
386 
387         if (!atomic_read(&p->tcfa_bindcnt)) {
388                 if (refcount_dec_and_test(&p->tcfa_refcnt)) {
389                         struct module *owner = p->ops->owner;
390 
391                         WARN_ON(p != idr_remove(&idrinfo->action_idr,
392                                                 p->tcfa_index));
393                         mutex_unlock(&idrinfo->lock);
394 
395                         tcf_action_cleanup(p);
396                         module_put(owner);
397                         return 0;
398                 }
399                 ret = 0;
400         } else {
401                 ret = -EPERM;
402         }
403 
404         mutex_unlock(&idrinfo->lock);
405         return ret;
406 }
407 
408 int tcf_idr_create(struct tc_action_net *tn, u32 index, struct nlattr *est,
409                    struct tc_action **a, const struct tc_action_ops *ops,
410                    int bind, bool cpustats, u32 flags)
411 {
412         struct tc_action *p = kzalloc(ops->size, GFP_KERNEL);
413         struct tcf_idrinfo *idrinfo = tn->idrinfo;
414         int err = -ENOMEM;
415 
416         if (unlikely(!p))
417                 return -ENOMEM;
418         refcount_set(&p->tcfa_refcnt, 1);
419         if (bind)
420                 atomic_set(&p->tcfa_bindcnt, 1);
421 
422         if (cpustats) {
423                 p->cpu_bstats = netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu);
424                 if (!p->cpu_bstats)
425                         goto err1;
426                 p->cpu_bstats_hw = netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu);
427                 if (!p->cpu_bstats_hw)
428                         goto err2;
429                 p->cpu_qstats = alloc_percpu(struct gnet_stats_queue);
430                 if (!p->cpu_qstats)
431                         goto err3;
432         }
433         spin_lock_init(&p->tcfa_lock);
434         p->tcfa_index = index;
435         p->tcfa_tm.install = jiffies;
436         p->tcfa_tm.lastuse = jiffies;
437         p->tcfa_tm.firstuse = 0;
438         p->tcfa_flags = flags;
439         if (est) {
440                 err = gen_new_estimator(&p->tcfa_bstats, p->cpu_bstats,
441                                         &p->tcfa_rate_est,
442                                         &p->tcfa_lock, NULL, est);
443                 if (err)
444                         goto err4;
445         }
446 
447         p->idrinfo = idrinfo;
448         p->ops = ops;
449         *a = p;
450         return 0;
451 err4:
452         free_percpu(p->cpu_qstats);
453 err3:
454         free_percpu(p->cpu_bstats_hw);
455 err2:
456         free_percpu(p->cpu_bstats);
457 err1:
458         kfree(p);
459         return err;
460 }
461 EXPORT_SYMBOL(tcf_idr_create);
462 
463 int tcf_idr_create_from_flags(struct tc_action_net *tn, u32 index,
464                               struct nlattr *est, struct tc_action **a,
465                               const struct tc_action_ops *ops, int bind,
466                               u32 flags)
467 {
468         /* Set cpustats according to actions flags. */
469         return tcf_idr_create(tn, index, est, a, ops, bind,
470                               !(flags & TCA_ACT_FLAGS_NO_PERCPU_STATS), flags);
471 }
472 EXPORT_SYMBOL(tcf_idr_create_from_flags);
473 
474 /* Cleanup idr index that was allocated but not initialized. */
475 
476 void tcf_idr_cleanup(struct tc_action_net *tn, u32 index)
477 {
478         struct tcf_idrinfo *idrinfo = tn->idrinfo;
479 
480         mutex_lock(&idrinfo->lock);
481         /* Remove ERR_PTR(-EBUSY) allocated by tcf_idr_check_alloc */
482         WARN_ON(!IS_ERR(idr_remove(&idrinfo->action_idr, index)));
483         mutex_unlock(&idrinfo->lock);
484 }
485 EXPORT_SYMBOL(tcf_idr_cleanup);
486 
487 /* Check if action with specified index exists. If actions is found, increments
488  * its reference and bind counters, and return 1. Otherwise insert temporary
489  * error pointer (to prevent concurrent users from inserting actions with same
490  * index) and return 0.
491  */
492 
493 int tcf_idr_check_alloc(struct tc_action_net *tn, u32 *index,
494                         struct tc_action **a, int bind)
495 {
496         struct tcf_idrinfo *idrinfo = tn->idrinfo;
497         struct tc_action *p;
498         int ret;
499 
500 again:
501         mutex_lock(&idrinfo->lock);
502         if (*index) {
503                 p = idr_find(&idrinfo->action_idr, *index);
504                 if (IS_ERR(p)) {
505                         /* This means that another process allocated
506                          * index but did not assign the pointer yet.
507                          */
508                         mutex_unlock(&idrinfo->lock);
509                         goto again;
510                 }
511 
512                 if (p) {
513                         refcount_inc(&p->tcfa_refcnt);
514                         if (bind)
515                                 atomic_inc(&p->tcfa_bindcnt);
516                         *a = p;
517                         ret = 1;
518                 } else {
519                         *a = NULL;
520                         ret = idr_alloc_u32(&idrinfo->action_idr, NULL, index,
521                                             *index, GFP_KERNEL);
522                         if (!ret)
523                                 idr_replace(&idrinfo->action_idr,
524                                             ERR_PTR(-EBUSY), *index);
525                 }
526         } else {
527                 *index = 1;
528                 *a = NULL;
529                 ret = idr_alloc_u32(&idrinfo->action_idr, NULL, index,
530                                     UINT_MAX, GFP_KERNEL);
531                 if (!ret)
532                         idr_replace(&idrinfo->action_idr, ERR_PTR(-EBUSY),
533                                     *index);
534         }
535         mutex_unlock(&idrinfo->lock);
536         return ret;
537 }
538 EXPORT_SYMBOL(tcf_idr_check_alloc);
539 
540 void tcf_idrinfo_destroy(const struct tc_action_ops *ops,
541                          struct tcf_idrinfo *idrinfo)
542 {
543         struct idr *idr = &idrinfo->action_idr;
544         struct tc_action *p;
545         int ret;
546         unsigned long id = 1;
547         unsigned long tmp;
548 
549         idr_for_each_entry_ul(idr, p, tmp, id) {
550                 ret = __tcf_idr_release(p, false, true);
551                 if (ret == ACT_P_DELETED)
552                         module_put(ops->owner);
553                 else if (ret < 0)
554                         return;
555         }
556         idr_destroy(&idrinfo->action_idr);
557 }
558 EXPORT_SYMBOL(tcf_idrinfo_destroy);
559 
560 static LIST_HEAD(act_base);
561 static DEFINE_RWLOCK(act_mod_lock);
562 
563 int tcf_register_action(struct tc_action_ops *act,
564                         struct pernet_operations *ops)
565 {
566         struct tc_action_ops *a;
567         int ret;
568 
569         if (!act->act || !act->dump || !act->init || !act->walk || !act->lookup)
570                 return -EINVAL;
571 
572         /* We have to register pernet ops before making the action ops visible,
573          * otherwise tcf_action_init_1() could get a partially initialized
574          * netns.
575          */
576         ret = register_pernet_subsys(ops);
577         if (ret)
578                 return ret;
579 
580         write_lock(&act_mod_lock);
581         list_for_each_entry(a, &act_base, head) {
582                 if (act->id == a->id || (strcmp(act->kind, a->kind) == 0)) {
583                         write_unlock(&act_mod_lock);
584                         unregister_pernet_subsys(ops);
585                         return -EEXIST;
586                 }
587         }
588         list_add_tail(&act->head, &act_base);
589         write_unlock(&act_mod_lock);
590 
591         return 0;
592 }
593 EXPORT_SYMBOL(tcf_register_action);
594 
595 int tcf_unregister_action(struct tc_action_ops *act,
596                           struct pernet_operations *ops)
597 {
598         struct tc_action_ops *a;
599         int err = -ENOENT;
600 
601         write_lock(&act_mod_lock);
602         list_for_each_entry(a, &act_base, head) {
603                 if (a == act) {
604                         list_del(&act->head);
605                         err = 0;
606                         break;
607                 }
608         }
609         write_unlock(&act_mod_lock);
610         if (!err)
611                 unregister_pernet_subsys(ops);
612         return err;
613 }
614 EXPORT_SYMBOL(tcf_unregister_action);
615 
616 /* lookup by name */
617 static struct tc_action_ops *tc_lookup_action_n(char *kind)
618 {
619         struct tc_action_ops *a, *res = NULL;
620 
621         if (kind) {
622                 read_lock(&act_mod_lock);
623                 list_for_each_entry(a, &act_base, head) {
624                         if (strcmp(kind, a->kind) == 0) {
625                                 if (try_module_get(a->owner))
626                                         res = a;
627                                 break;
628                         }
629                 }
630                 read_unlock(&act_mod_lock);
631         }
632         return res;
633 }
634 
635 /* lookup by nlattr */
636 static struct tc_action_ops *tc_lookup_action(struct nlattr *kind)
637 {
638         struct tc_action_ops *a, *res = NULL;
639 
640         if (kind) {
641                 read_lock(&act_mod_lock);
642                 list_for_each_entry(a, &act_base, head) {
643                         if (nla_strcmp(kind, a->kind) == 0) {
644                                 if (try_module_get(a->owner))
645                                         res = a;
646                                 break;
647                         }
648                 }
649                 read_unlock(&act_mod_lock);
650         }
651         return res;
652 }
653 
654 /*TCA_ACT_MAX_PRIO is 32, there count upto 32 */
655 #define TCA_ACT_MAX_PRIO_MASK 0x1FF
656 int tcf_action_exec(struct sk_buff *skb, struct tc_action **actions,
657                     int nr_actions, struct tcf_result *res)
658 {
659         u32 jmp_prgcnt = 0;
660         u32 jmp_ttl = TCA_ACT_MAX_PRIO; /*matches actions per filter */
661         int i;
662         int ret = TC_ACT_OK;
663 
664         if (skb_skip_tc_classify(skb))
665                 return TC_ACT_OK;
666 
667 restart_act_graph:
668         for (i = 0; i < nr_actions; i++) {
669                 const struct tc_action *a = actions[i];
670 
671                 if (jmp_prgcnt > 0) {
672                         jmp_prgcnt -= 1;
673                         continue;
674                 }
675 repeat:
676                 ret = a->ops->act(skb, a, res);
677                 if (ret == TC_ACT_REPEAT)
678                         goto repeat;    /* we need a ttl - JHS */
679 
680                 if (TC_ACT_EXT_CMP(ret, TC_ACT_JUMP)) {
681                         jmp_prgcnt = ret & TCA_ACT_MAX_PRIO_MASK;
682                         if (!jmp_prgcnt || (jmp_prgcnt > nr_actions)) {
683                                 /* faulty opcode, stop pipeline */
684                                 return TC_ACT_OK;
685                         } else {
686                                 jmp_ttl -= 1;
687                                 if (jmp_ttl > 0)
688                                         goto restart_act_graph;
689                                 else /* faulty graph, stop pipeline */
690                                         return TC_ACT_OK;
691                         }
692                 } else if (TC_ACT_EXT_CMP(ret, TC_ACT_GOTO_CHAIN)) {
693                         if (unlikely(!rcu_access_pointer(a->goto_chain))) {
694                                 net_warn_ratelimited("can't go to NULL chain!\n");
695                                 return TC_ACT_SHOT;
696                         }
697                         tcf_action_goto_chain_exec(a, res);
698                 }
699 
700                 if (ret != TC_ACT_PIPE)
701                         break;
702         }
703 
704         return ret;
705 }
706 EXPORT_SYMBOL(tcf_action_exec);
707 
708 int tcf_action_destroy(struct tc_action *actions[], int bind)
709 {
710         const struct tc_action_ops *ops;
711         struct tc_action *a;
712         int ret = 0, i;
713 
714         for (i = 0; i < TCA_ACT_MAX_PRIO && actions[i]; i++) {
715                 a = actions[i];
716                 actions[i] = NULL;
717                 ops = a->ops;
718                 ret = __tcf_idr_release(a, bind, true);
719                 if (ret == ACT_P_DELETED)
720                         module_put(ops->owner);
721                 else if (ret < 0)
722                         return ret;
723         }
724         return ret;
725 }
726 
727 static int tcf_action_put(struct tc_action *p)
728 {
729         return __tcf_action_put(p, false);
730 }
731 
732 /* Put all actions in this array, skip those NULL's. */
733 static void tcf_action_put_many(struct tc_action *actions[])
734 {
735         int i;
736 
737         for (i = 0; i < TCA_ACT_MAX_PRIO; i++) {
738                 struct tc_action *a = actions[i];
739                 const struct tc_action_ops *ops;
740 
741                 if (!a)
742                         continue;
743                 ops = a->ops;
744                 if (tcf_action_put(a))
745                         module_put(ops->owner);
746         }
747 }
748 
749 int
750 tcf_action_dump_old(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
751 {
752         return a->ops->dump(skb, a, bind, ref);
753 }
754 
755 static int
756 tcf_action_dump_terse(struct sk_buff *skb, struct tc_action *a)
757 {
758         unsigned char *b = skb_tail_pointer(skb);
759         struct tc_cookie *cookie;
760 
761         if (nla_put_string(skb, TCA_KIND, a->ops->kind))
762                 goto nla_put_failure;
763         if (tcf_action_copy_stats(skb, a, 0))
764                 goto nla_put_failure;
765 
766         rcu_read_lock();
767         cookie = rcu_dereference(a->act_cookie);
768         if (cookie) {
769                 if (nla_put(skb, TCA_ACT_COOKIE, cookie->len, cookie->data)) {
770                         rcu_read_unlock();
771                         goto nla_put_failure;
772                 }
773         }
774         rcu_read_unlock();
775 
776         return 0;
777 
778 nla_put_failure:
779         nlmsg_trim(skb, b);
780         return -1;
781 }
782 
783 int
784 tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
785 {
786         int err = -EINVAL;
787         unsigned char *b = skb_tail_pointer(skb);
788         struct nlattr *nest;
789 
790         if (tcf_action_dump_terse(skb, a))
791                 goto nla_put_failure;
792 
793         if (a->hw_stats != TCA_ACT_HW_STATS_ANY &&
794             nla_put_bitfield32(skb, TCA_ACT_HW_STATS,
795                                a->hw_stats, TCA_ACT_HW_STATS_ANY))
796                 goto nla_put_failure;
797 
798         if (a->used_hw_stats_valid &&
799             nla_put_bitfield32(skb, TCA_ACT_USED_HW_STATS,
800                                a->used_hw_stats, TCA_ACT_HW_STATS_ANY))
801                 goto nla_put_failure;
802 
803         if (a->tcfa_flags &&
804             nla_put_bitfield32(skb, TCA_ACT_FLAGS,
805                                a->tcfa_flags, a->tcfa_flags))
806                 goto nla_put_failure;
807 
808         nest = nla_nest_start_noflag(skb, TCA_OPTIONS);
809         if (nest == NULL)
810                 goto nla_put_failure;
811         err = tcf_action_dump_old(skb, a, bind, ref);
812         if (err > 0) {
813                 nla_nest_end(skb, nest);
814                 return err;
815         }
816 
817 nla_put_failure:
818         nlmsg_trim(skb, b);
819         return -1;
820 }
821 EXPORT_SYMBOL(tcf_action_dump_1);
822 
823 int tcf_action_dump(struct sk_buff *skb, struct tc_action *actions[],
824                     int bind, int ref, bool terse)
825 {
826         struct tc_action *a;
827         int err = -EINVAL, i;
828         struct nlattr *nest;
829 
830         for (i = 0; i < TCA_ACT_MAX_PRIO && actions[i]; i++) {
831                 a = actions[i];
832                 nest = nla_nest_start_noflag(skb, i + 1);
833                 if (nest == NULL)
834                         goto nla_put_failure;
835                 err = terse ? tcf_action_dump_terse(skb, a) :
836                         tcf_action_dump_1(skb, a, bind, ref);
837                 if (err < 0)
838                         goto errout;
839                 nla_nest_end(skb, nest);
840         }
841 
842         return 0;
843 
844 nla_put_failure:
845         err = -EINVAL;
846 errout:
847         nla_nest_cancel(skb, nest);
848         return err;
849 }
850 
851 static struct tc_cookie *nla_memdup_cookie(struct nlattr **tb)
852 {
853         struct tc_cookie *c = kzalloc(sizeof(*c), GFP_KERNEL);
854         if (!c)
855                 return NULL;
856 
857         c->data = nla_memdup(tb[TCA_ACT_COOKIE], GFP_KERNEL);
858         if (!c->data) {
859                 kfree(c);
860                 return NULL;
861         }
862         c->len = nla_len(tb[TCA_ACT_COOKIE]);
863 
864         return c;
865 }
866 
867 static u8 tcf_action_hw_stats_get(struct nlattr *hw_stats_attr)
868 {
869         struct nla_bitfield32 hw_stats_bf;
870 
871         /* If the user did not pass the attr, that means he does
872          * not care about the type. Return "any" in that case
873          * which is setting on all supported types.
874          */
875         if (!hw_stats_attr)
876                 return TCA_ACT_HW_STATS_ANY;
877         hw_stats_bf = nla_get_bitfield32(hw_stats_attr);
878         return hw_stats_bf.value;
879 }
880 
881 static const struct nla_policy tcf_action_policy[TCA_ACT_MAX + 1] = {
882         [TCA_ACT_KIND]          = { .type = NLA_STRING },
883         [TCA_ACT_INDEX]         = { .type = NLA_U32 },
884         [TCA_ACT_COOKIE]        = { .type = NLA_BINARY,
885                                     .len = TC_COOKIE_MAX_SIZE },
886         [TCA_ACT_OPTIONS]       = { .type = NLA_NESTED },
887         [TCA_ACT_FLAGS]         = NLA_POLICY_BITFIELD32(TCA_ACT_FLAGS_NO_PERCPU_STATS),
888         [TCA_ACT_HW_STATS]      = NLA_POLICY_BITFIELD32(TCA_ACT_HW_STATS_ANY),
889 };
890 
891 static void tcf_idr_insert_many(struct tc_action *actions[])
892 {
893         int i;
894 
895         for (i = 0; i < TCA_ACT_MAX_PRIO; i++) {
896                 struct tc_action *a = actions[i];
897                 struct tcf_idrinfo *idrinfo;
898 
899                 if (!a)
900                         continue;
901                 idrinfo = a->idrinfo;
902                 mutex_lock(&idrinfo->lock);
903                 /* Replace ERR_PTR(-EBUSY) allocated by tcf_idr_check_alloc if
904                  * it is just created, otherwise this is just a nop.
905                  */
906                 idr_replace(&idrinfo->action_idr, a, a->tcfa_index);
907                 mutex_unlock(&idrinfo->lock);
908         }
909 }
910 
911 struct tc_action *tcf_action_init_1(struct net *net, struct tcf_proto *tp,
912                                     struct nlattr *nla, struct nlattr *est,
913                                     char *name, int ovr, int bind,
914                                     bool rtnl_held,
915                                     struct netlink_ext_ack *extack)
916 {
917         struct nla_bitfield32 flags = { 0, 0 };
918         u8 hw_stats = TCA_ACT_HW_STATS_ANY;
919         struct tc_action *a;
920         struct tc_action_ops *a_o;
921         struct tc_cookie *cookie = NULL;
922         char act_name[IFNAMSIZ];
923         struct nlattr *tb[TCA_ACT_MAX + 1];
924         struct nlattr *kind;
925         int err;
926 
927         if (name == NULL) {
928                 err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla,
929                                                   tcf_action_policy, extack);
930                 if (err < 0)
931                         goto err_out;
932                 err = -EINVAL;
933                 kind = tb[TCA_ACT_KIND];
934                 if (!kind) {
935                         NL_SET_ERR_MSG(extack, "TC action kind must be specified");
936                         goto err_out;
937                 }
938                 if (nla_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ) {
939                         NL_SET_ERR_MSG(extack, "TC action name too long");
940                         goto err_out;
941                 }
942                 if (tb[TCA_ACT_COOKIE]) {
943                         cookie = nla_memdup_cookie(tb);
944                         if (!cookie) {
945                                 NL_SET_ERR_MSG(extack, "No memory to generate TC cookie");
946                                 err = -ENOMEM;
947                                 goto err_out;
948                         }
949                 }
950                 hw_stats = tcf_action_hw_stats_get(tb[TCA_ACT_HW_STATS]);
951                 if (tb[TCA_ACT_FLAGS])
952                         flags = nla_get_bitfield32(tb[TCA_ACT_FLAGS]);
953         } else {
954                 if (strlcpy(act_name, name, IFNAMSIZ) >= IFNAMSIZ) {
955                         NL_SET_ERR_MSG(extack, "TC action name too long");
956                         err = -EINVAL;
957                         goto err_out;
958                 }
959         }
960 
961         a_o = tc_lookup_action_n(act_name);
962         if (a_o == NULL) {
963 #ifdef CONFIG_MODULES
964                 if (rtnl_held)
965                         rtnl_unlock();
966                 request_module("act_%s", act_name);
967                 if (rtnl_held)
968                         rtnl_lock();
969 
970                 a_o = tc_lookup_action_n(act_name);
971 
972                 /* We dropped the RTNL semaphore in order to
973                  * perform the module load.  So, even if we
974                  * succeeded in loading the module we have to
975                  * tell the caller to replay the request.  We
976                  * indicate this using -EAGAIN.
977                  */
978                 if (a_o != NULL) {
979                         err = -EAGAIN;
980                         goto err_mod;
981                 }
982 #endif
983                 NL_SET_ERR_MSG(extack, "Failed to load TC action module");
984                 err = -ENOENT;
985                 goto err_out;
986         }
987 
988         /* backward compatibility for policer */
989         if (name == NULL)
990                 err = a_o->init(net, tb[TCA_ACT_OPTIONS], est, &a, ovr, bind,
991                                 rtnl_held, tp, flags.value, extack);
992         else
993                 err = a_o->init(net, nla, est, &a, ovr, bind, rtnl_held,
994                                 tp, flags.value, extack);
995         if (err < 0)
996                 goto err_mod;
997 
998         if (!name && tb[TCA_ACT_COOKIE])
999                 tcf_set_action_cookie(&a->act_cookie, cookie);
1000 
1001         if (!name)
1002                 a->hw_stats = hw_stats;
1003 
1004         /* module count goes up only when brand new policy is created
1005          * if it exists and is only bound to in a_o->init() then
1006          * ACT_P_CREATED is not returned (a zero is).
1007          */
1008         if (err != ACT_P_CREATED)
1009                 module_put(a_o->owner);
1010 
1011         return a;
1012 
1013 err_mod:
1014         module_put(a_o->owner);
1015 err_out:
1016         if (cookie) {
1017                 kfree(cookie->data);
1018                 kfree(cookie);
1019         }
1020         return ERR_PTR(err);
1021 }
1022 
1023 /* Returns numbers of initialized actions or negative error. */
1024 
1025 int tcf_action_init(struct net *net, struct tcf_proto *tp, struct nlattr *nla,
1026                     struct nlattr *est, char *name, int ovr, int bind,
1027                     struct tc_action *actions[], size_t *attr_size,
1028                     bool rtnl_held, struct netlink_ext_ack *extack)
1029 {
1030         struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
1031         struct tc_action *act;
1032         size_t sz = 0;
1033         int err;
1034         int i;
1035 
1036         err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX_PRIO, nla, NULL,
1037                                           extack);
1038         if (err < 0)
1039                 return err;
1040 
1041         for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) {
1042                 act = tcf_action_init_1(net, tp, tb[i], est, name, ovr, bind,
1043                                         rtnl_held, extack);
1044                 if (IS_ERR(act)) {
1045                         err = PTR_ERR(act);
1046                         goto err;
1047                 }
1048                 sz += tcf_action_fill_size(act);
1049                 /* Start from index 0 */
1050                 actions[i - 1] = act;
1051         }
1052 
1053         /* We have to commit them all together, because if any error happened in
1054          * between, we could not handle the failure gracefully.
1055          */
1056         tcf_idr_insert_many(actions);
1057 
1058         *attr_size = tcf_action_full_attrs_size(sz);
1059         return i - 1;
1060 
1061 err:
1062         tcf_action_destroy(actions, bind);
1063         return err;
1064 }
1065 
1066 void tcf_action_update_stats(struct tc_action *a, u64 bytes, u64 packets,
1067                              u64 drops, bool hw)
1068 {
1069         if (a->cpu_bstats) {
1070                 _bstats_cpu_update(this_cpu_ptr(a->cpu_bstats), bytes, packets);
1071 
1072                 this_cpu_ptr(a->cpu_qstats)->drops += drops;
1073 
1074                 if (hw)
1075                         _bstats_cpu_update(this_cpu_ptr(a->cpu_bstats_hw),
1076                                            bytes, packets);
1077                 return;
1078         }
1079 
1080         _bstats_update(&a->tcfa_bstats, bytes, packets);
1081         a->tcfa_qstats.drops += drops;
1082         if (hw)
1083                 _bstats_update(&a->tcfa_bstats_hw, bytes, packets);
1084 }
1085 EXPORT_SYMBOL(tcf_action_update_stats);
1086 
1087 int tcf_action_copy_stats(struct sk_buff *skb, struct tc_action *p,
1088                           int compat_mode)
1089 {
1090         int err = 0;
1091         struct gnet_dump d;
1092 
1093         if (p == NULL)
1094                 goto errout;
1095 
1096         /* compat_mode being true specifies a call that is supposed
1097          * to add additional backward compatibility statistic TLVs.
1098          */
1099         if (compat_mode) {
1100                 if (p->type == TCA_OLD_COMPAT)
1101                         err = gnet_stats_start_copy_compat(skb, 0,
1102                                                            TCA_STATS,
1103                                                            TCA_XSTATS,
1104                                                            &p->tcfa_lock, &d,
1105                                                            TCA_PAD);
1106                 else
1107                         return 0;
1108         } else
1109                 err = gnet_stats_start_copy(skb, TCA_ACT_STATS,
1110                                             &p->tcfa_lock, &d, TCA_ACT_PAD);
1111 
1112         if (err < 0)
1113                 goto errout;
1114 
1115         if (gnet_stats_copy_basic(NULL, &d, p->cpu_bstats, &p->tcfa_bstats) < 0 ||
1116             gnet_stats_copy_basic_hw(NULL, &d, p->cpu_bstats_hw,
1117                                      &p->tcfa_bstats_hw) < 0 ||
1118             gnet_stats_copy_rate_est(&d, &p->tcfa_rate_est) < 0 ||
1119             gnet_stats_copy_queue(&d, p->cpu_qstats,
1120                                   &p->tcfa_qstats,
1121                                   p->tcfa_qstats.qlen) < 0)
1122                 goto errout;
1123 
1124         if (gnet_stats_finish_copy(&d) < 0)
1125                 goto errout;
1126 
1127         return 0;
1128 
1129 errout:
1130         return -1;
1131 }
1132 
1133 static int tca_get_fill(struct sk_buff *skb, struct tc_action *actions[],
1134                         u32 portid, u32 seq, u16 flags, int event, int bind,
1135                         int ref)
1136 {
1137         struct tcamsg *t;
1138         struct nlmsghdr *nlh;
1139         unsigned char *b = skb_tail_pointer(skb);
1140         struct nlattr *nest;
1141 
1142         nlh = nlmsg_put(skb, portid, seq, event, sizeof(*t), flags);
1143         if (!nlh)
1144                 goto out_nlmsg_trim;
1145         t = nlmsg_data(nlh);
1146         t->tca_family = AF_UNSPEC;
1147         t->tca__pad1 = 0;
1148         t->tca__pad2 = 0;
1149 
1150         nest = nla_nest_start_noflag(skb, TCA_ACT_TAB);
1151         if (!nest)
1152                 goto out_nlmsg_trim;
1153 
1154         if (tcf_action_dump(skb, actions, bind, ref, false) < 0)
1155                 goto out_nlmsg_trim;
1156 
1157         nla_nest_end(skb, nest);
1158 
1159         nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1160         return skb->len;
1161 
1162 out_nlmsg_trim:
1163         nlmsg_trim(skb, b);
1164         return -1;
1165 }
1166 
1167 static int
1168 tcf_get_notify(struct net *net, u32 portid, struct nlmsghdr *n,
1169                struct tc_action *actions[], int event,
1170                struct netlink_ext_ack *extack)
1171 {
1172         struct sk_buff *skb;
1173 
1174         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1175         if (!skb)
1176                 return -ENOBUFS;
1177         if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, 0, event,
1178                          0, 1) <= 0) {
1179                 NL_SET_ERR_MSG(extack, "Failed to fill netlink attributes while adding TC action");
1180                 kfree_skb(skb);
1181                 return -EINVAL;
1182         }
1183 
1184         return rtnl_unicast(skb, net, portid);
1185 }
1186 
1187 static struct tc_action *tcf_action_get_1(struct net *net, struct nlattr *nla,
1188                                           struct nlmsghdr *n, u32 portid,
1189                                           struct netlink_ext_ack *extack)
1190 {
1191         struct nlattr *tb[TCA_ACT_MAX + 1];
1192         const struct tc_action_ops *ops;
1193         struct tc_action *a;
1194         int index;
1195         int err;
1196 
1197         err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla,
1198                                           tcf_action_policy, extack);
1199         if (err < 0)
1200                 goto err_out;
1201 
1202         err = -EINVAL;
1203         if (tb[TCA_ACT_INDEX] == NULL ||
1204             nla_len(tb[TCA_ACT_INDEX]) < sizeof(index)) {
1205                 NL_SET_ERR_MSG(extack, "Invalid TC action index value");
1206                 goto err_out;
1207         }
1208         index = nla_get_u32(tb[TCA_ACT_INDEX]);
1209 
1210         err = -EINVAL;
1211         ops = tc_lookup_action(tb[TCA_ACT_KIND]);
1212         if (!ops) { /* could happen in batch of actions */
1213                 NL_SET_ERR_MSG(extack, "Specified TC action kind not found");
1214                 goto err_out;
1215         }
1216         err = -ENOENT;
1217         if (ops->lookup(net, &a, index) == 0) {
1218                 NL_SET_ERR_MSG(extack, "TC action with specified index not found");
1219                 goto err_mod;
1220         }
1221 
1222         module_put(ops->owner);
1223         return a;
1224 
1225 err_mod:
1226         module_put(ops->owner);
1227 err_out:
1228         return ERR_PTR(err);
1229 }
1230 
1231 static int tca_action_flush(struct net *net, struct nlattr *nla,
1232                             struct nlmsghdr *n, u32 portid,
1233                             struct netlink_ext_ack *extack)
1234 {
1235         struct sk_buff *skb;
1236         unsigned char *b;
1237         struct nlmsghdr *nlh;
1238         struct tcamsg *t;
1239         struct netlink_callback dcb;
1240         struct nlattr *nest;
1241         struct nlattr *tb[TCA_ACT_MAX + 1];
1242         const struct tc_action_ops *ops;
1243         struct nlattr *kind;
1244         int err = -ENOMEM;
1245 
1246         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1247         if (!skb)
1248                 return err;
1249 
1250         b = skb_tail_pointer(skb);
1251 
1252         err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla,
1253                                           tcf_action_policy, extack);
1254         if (err < 0)
1255                 goto err_out;
1256 
1257         err = -EINVAL;
1258         kind = tb[TCA_ACT_KIND];
1259         ops = tc_lookup_action(kind);
1260         if (!ops) { /*some idjot trying to flush unknown action */
1261                 NL_SET_ERR_MSG(extack, "Cannot flush unknown TC action");
1262                 goto err_out;
1263         }
1264 
1265         nlh = nlmsg_put(skb, portid, n->nlmsg_seq, RTM_DELACTION,
1266                         sizeof(*t), 0);
1267         if (!nlh) {
1268                 NL_SET_ERR_MSG(extack, "Failed to create TC action flush notification");
1269                 goto out_module_put;
1270         }
1271         t = nlmsg_data(nlh);
1272         t->tca_family = AF_UNSPEC;
1273         t->tca__pad1 = 0;
1274         t->tca__pad2 = 0;
1275 
1276         nest = nla_nest_start_noflag(skb, TCA_ACT_TAB);
1277         if (!nest) {
1278                 NL_SET_ERR_MSG(extack, "Failed to add new netlink message");
1279                 goto out_module_put;
1280         }
1281 
1282         err = ops->walk(net, skb, &dcb, RTM_DELACTION, ops, extack);
1283         if (err <= 0) {
1284                 nla_nest_cancel(skb, nest);
1285                 goto out_module_put;
1286         }
1287 
1288         nla_nest_end(skb, nest);
1289 
1290         nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1291         nlh->nlmsg_flags |= NLM_F_ROOT;
1292         module_put(ops->owner);
1293         err = rtnetlink_send(skb, net, portid, RTNLGRP_TC,
1294                              n->nlmsg_flags & NLM_F_ECHO);
1295         if (err > 0)
1296                 return 0;
1297         if (err < 0)
1298                 NL_SET_ERR_MSG(extack, "Failed to send TC action flush notification");
1299 
1300         return err;
1301 
1302 out_module_put:
1303         module_put(ops->owner);
1304 err_out:
1305         kfree_skb(skb);
1306         return err;
1307 }
1308 
1309 static int tcf_action_delete(struct net *net, struct tc_action *actions[])
1310 {
1311         int i;
1312 
1313         for (i = 0; i < TCA_ACT_MAX_PRIO && actions[i]; i++) {
1314                 struct tc_action *a = actions[i];
1315                 const struct tc_action_ops *ops = a->ops;
1316                 /* Actions can be deleted concurrently so we must save their
1317                  * type and id to search again after reference is released.
1318                  */
1319                 struct tcf_idrinfo *idrinfo = a->idrinfo;
1320                 u32 act_index = a->tcfa_index;
1321 
1322                 actions[i] = NULL;
1323                 if (tcf_action_put(a)) {
1324                         /* last reference, action was deleted concurrently */
1325                         module_put(ops->owner);
1326                 } else  {
1327                         int ret;
1328 
1329                         /* now do the delete */
1330                         ret = tcf_idr_delete_index(idrinfo, act_index);
1331                         if (ret < 0)
1332                                 return ret;
1333                 }
1334         }
1335         return 0;
1336 }
1337 
1338 static int
1339 tcf_del_notify(struct net *net, struct nlmsghdr *n, struct tc_action *actions[],
1340                u32 portid, size_t attr_size, struct netlink_ext_ack *extack)
1341 {
1342         int ret;
1343         struct sk_buff *skb;
1344 
1345         skb = alloc_skb(attr_size <= NLMSG_GOODSIZE ? NLMSG_GOODSIZE : attr_size,
1346                         GFP_KERNEL);
1347         if (!skb)
1348                 return -ENOBUFS;
1349 
1350         if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, 0, RTM_DELACTION,
1351                          0, 2) <= 0) {
1352                 NL_SET_ERR_MSG(extack, "Failed to fill netlink TC action attributes");
1353                 kfree_skb(skb);
1354                 return -EINVAL;
1355         }
1356 
1357         /* now do the delete */
1358         ret = tcf_action_delete(net, actions);
1359         if (ret < 0) {
1360                 NL_SET_ERR_MSG(extack, "Failed to delete TC action");
1361                 kfree_skb(skb);
1362                 return ret;
1363         }
1364 
1365         ret = rtnetlink_send(skb, net, portid, RTNLGRP_TC,
1366                              n->nlmsg_flags & NLM_F_ECHO);
1367         if (ret > 0)
1368                 return 0;
1369         return ret;
1370 }
1371 
1372 static int
1373 tca_action_gd(struct net *net, struct nlattr *nla, struct nlmsghdr *n,
1374               u32 portid, int event, struct netlink_ext_ack *extack)
1375 {
1376         int i, ret;
1377         struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
1378         struct tc_action *act;
1379         size_t attr_size = 0;
1380         struct tc_action *actions[TCA_ACT_MAX_PRIO] = {};
1381 
1382         ret = nla_parse_nested_deprecated(tb, TCA_ACT_MAX_PRIO, nla, NULL,
1383                                           extack);
1384         if (ret < 0)
1385                 return ret;
1386 
1387         if (event == RTM_DELACTION && n->nlmsg_flags & NLM_F_ROOT) {
1388                 if (tb[1])
1389                         return tca_action_flush(net, tb[1], n, portid, extack);
1390 
1391                 NL_SET_ERR_MSG(extack, "Invalid netlink attributes while flushing TC action");
1392                 return -EINVAL;
1393         }
1394 
1395         for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) {
1396                 act = tcf_action_get_1(net, tb[i], n, portid, extack);
1397                 if (IS_ERR(act)) {
1398                         ret = PTR_ERR(act);
1399                         goto err;
1400                 }
1401                 attr_size += tcf_action_fill_size(act);
1402                 actions[i - 1] = act;
1403         }
1404 
1405         attr_size = tcf_action_full_attrs_size(attr_size);
1406 
1407         if (event == RTM_GETACTION)
1408                 ret = tcf_get_notify(net, portid, n, actions, event, extack);
1409         else { /* delete */
1410                 ret = tcf_del_notify(net, n, actions, portid, attr_size, extack);
1411                 if (ret)
1412                         goto err;
1413                 return 0;
1414         }
1415 err:
1416         tcf_action_put_many(actions);
1417         return ret;
1418 }
1419 
1420 static int
1421 tcf_add_notify(struct net *net, struct nlmsghdr *n, struct tc_action *actions[],
1422                u32 portid, size_t attr_size, struct netlink_ext_ack *extack)
1423 {
1424         struct sk_buff *skb;
1425         int err = 0;
1426 
1427         skb = alloc_skb(attr_size <= NLMSG_GOODSIZE ? NLMSG_GOODSIZE : attr_size,
1428                         GFP_KERNEL);
1429         if (!skb)
1430                 return -ENOBUFS;
1431 
1432         if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, n->nlmsg_flags,
1433                          RTM_NEWACTION, 0, 0) <= 0) {
1434                 NL_SET_ERR_MSG(extack, "Failed to fill netlink attributes while adding TC action");
1435                 kfree_skb(skb);
1436                 return -EINVAL;
1437         }
1438 
1439         err = rtnetlink_send(skb, net, portid, RTNLGRP_TC,
1440                              n->nlmsg_flags & NLM_F_ECHO);
1441         if (err > 0)
1442                 err = 0;
1443         return err;
1444 }
1445 
1446 static int tcf_action_add(struct net *net, struct nlattr *nla,
1447                           struct nlmsghdr *n, u32 portid, int ovr,
1448                           struct netlink_ext_ack *extack)
1449 {
1450         size_t attr_size = 0;
1451         int loop, ret;
1452         struct tc_action *actions[TCA_ACT_MAX_PRIO] = {};
1453 
1454         for (loop = 0; loop < 10; loop++) {
1455                 ret = tcf_action_init(net, NULL, nla, NULL, NULL, ovr, 0,
1456                                       actions, &attr_size, true, extack);
1457                 if (ret != -EAGAIN)
1458                         break;
1459         }
1460 
1461         if (ret < 0)
1462                 return ret;
1463         ret = tcf_add_notify(net, n, actions, portid, attr_size, extack);
1464         if (ovr)
1465                 tcf_action_put_many(actions);
1466 
1467         return ret;
1468 }
1469 
1470 static const struct nla_policy tcaa_policy[TCA_ROOT_MAX + 1] = {
1471         [TCA_ROOT_FLAGS] = NLA_POLICY_BITFIELD32(TCA_FLAG_LARGE_DUMP_ON),
1472         [TCA_ROOT_TIME_DELTA]      = { .type = NLA_U32 },
1473 };
1474 
1475 static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n,
1476                          struct netlink_ext_ack *extack)
1477 {
1478         struct net *net = sock_net(skb->sk);
1479         struct nlattr *tca[TCA_ROOT_MAX + 1];
1480         u32 portid = NETLINK_CB(skb).portid;
1481         int ret = 0, ovr = 0;
1482 
1483         if ((n->nlmsg_type != RTM_GETACTION) &&
1484             !netlink_capable(skb, CAP_NET_ADMIN))
1485                 return -EPERM;
1486 
1487         ret = nlmsg_parse_deprecated(n, sizeof(struct tcamsg), tca,
1488                                      TCA_ROOT_MAX, NULL, extack);
1489         if (ret < 0)
1490                 return ret;
1491 
1492         if (tca[TCA_ACT_TAB] == NULL) {
1493                 NL_SET_ERR_MSG(extack, "Netlink action attributes missing");
1494                 return -EINVAL;
1495         }
1496 
1497         /* n->nlmsg_flags & NLM_F_CREATE */
1498         switch (n->nlmsg_type) {
1499         case RTM_NEWACTION:
1500                 /* we are going to assume all other flags
1501                  * imply create only if it doesn't exist
1502                  * Note that CREATE | EXCL implies that
1503                  * but since we want avoid ambiguity (eg when flags
1504                  * is zero) then just set this
1505                  */
1506                 if (n->nlmsg_flags & NLM_F_REPLACE)
1507                         ovr = 1;
1508                 ret = tcf_action_add(net, tca[TCA_ACT_TAB], n, portid, ovr,
1509                                      extack);
1510                 break;
1511         case RTM_DELACTION:
1512                 ret = tca_action_gd(net, tca[TCA_ACT_TAB], n,
1513                                     portid, RTM_DELACTION, extack);
1514                 break;
1515         case RTM_GETACTION:
1516                 ret = tca_action_gd(net, tca[TCA_ACT_TAB], n,
1517                                     portid, RTM_GETACTION, extack);
1518                 break;
1519         default:
1520                 BUG();
1521         }
1522 
1523         return ret;
1524 }
1525 
1526 static struct nlattr *find_dump_kind(struct nlattr **nla)
1527 {
1528         struct nlattr *tb1, *tb2[TCA_ACT_MAX + 1];
1529         struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
1530         struct nlattr *kind;
1531 
1532         tb1 = nla[TCA_ACT_TAB];
1533         if (tb1 == NULL)
1534                 return NULL;
1535 
1536         if (nla_parse_deprecated(tb, TCA_ACT_MAX_PRIO, nla_data(tb1), NLMSG_ALIGN(nla_len(tb1)), NULL, NULL) < 0)
1537                 return NULL;
1538 
1539         if (tb[1] == NULL)
1540                 return NULL;
1541         if (nla_parse_nested_deprecated(tb2, TCA_ACT_MAX, tb[1], tcf_action_policy, NULL) < 0)
1542                 return NULL;
1543         kind = tb2[TCA_ACT_KIND];
1544 
1545         return kind;
1546 }
1547 
1548 static int tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb)
1549 {
1550         struct net *net = sock_net(skb->sk);
1551         struct nlmsghdr *nlh;
1552         unsigned char *b = skb_tail_pointer(skb);
1553         struct nlattr *nest;
1554         struct tc_action_ops *a_o;
1555         int ret = 0;
1556         struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh);
1557         struct nlattr *tb[TCA_ROOT_MAX + 1];
1558         struct nlattr *count_attr = NULL;
1559         unsigned long jiffy_since = 0;
1560         struct nlattr *kind = NULL;
1561         struct nla_bitfield32 bf;
1562         u32 msecs_since = 0;
1563         u32 act_count = 0;
1564 
1565         ret = nlmsg_parse_deprecated(cb->nlh, sizeof(struct tcamsg), tb,
1566                                      TCA_ROOT_MAX, tcaa_policy, cb->extack);
1567         if (ret < 0)
1568                 return ret;
1569 
1570         kind = find_dump_kind(tb);
1571         if (kind == NULL) {
1572                 pr_info("tc_dump_action: action bad kind\n");
1573                 return 0;
1574         }
1575 
1576         a_o = tc_lookup_action(kind);
1577         if (a_o == NULL)
1578                 return 0;
1579 
1580         cb->args[2] = 0;
1581         if (tb[TCA_ROOT_FLAGS]) {
1582                 bf = nla_get_bitfield32(tb[TCA_ROOT_FLAGS]);
1583                 cb->args[2] = bf.value;
1584         }
1585 
1586         if (tb[TCA_ROOT_TIME_DELTA]) {
1587                 msecs_since = nla_get_u32(tb[TCA_ROOT_TIME_DELTA]);
1588         }
1589 
1590         nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
1591                         cb->nlh->nlmsg_type, sizeof(*t), 0);
1592         if (!nlh)
1593                 goto out_module_put;
1594 
1595         if (msecs_since)
1596                 jiffy_since = jiffies - msecs_to_jiffies(msecs_since);
1597 
1598         t = nlmsg_data(nlh);
1599         t->tca_family = AF_UNSPEC;
1600         t->tca__pad1 = 0;
1601         t->tca__pad2 = 0;
1602         cb->args[3] = jiffy_since;
1603         count_attr = nla_reserve(skb, TCA_ROOT_COUNT, sizeof(u32));
1604         if (!count_attr)
1605                 goto out_module_put;
1606 
1607         nest = nla_nest_start_noflag(skb, TCA_ACT_TAB);
1608         if (nest == NULL)
1609                 goto out_module_put;
1610 
1611         ret = a_o->walk(net, skb, cb, RTM_GETACTION, a_o, NULL);
1612         if (ret < 0)
1613                 goto out_module_put;
1614 
1615         if (ret > 0) {
1616                 nla_nest_end(skb, nest);
1617                 ret = skb->len;
1618                 act_count = cb->args[1];
1619                 memcpy(nla_data(count_attr), &act_count, sizeof(u32));
1620                 cb->args[1] = 0;
1621         } else
1622                 nlmsg_trim(skb, b);
1623 
1624         nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1625         if (NETLINK_CB(cb->skb).portid && ret)
1626                 nlh->nlmsg_flags |= NLM_F_MULTI;
1627         module_put(a_o->owner);
1628         return skb->len;
1629 
1630 out_module_put:
1631         module_put(a_o->owner);
1632         nlmsg_trim(skb, b);
1633         return skb->len;
1634 }
1635 
1636 static int __init tc_action_init(void)
1637 {
1638         rtnl_register(PF_UNSPEC, RTM_NEWACTION, tc_ctl_action, NULL, 0);
1639         rtnl_register(PF_UNSPEC, RTM_DELACTION, tc_ctl_action, NULL, 0);
1640         rtnl_register(PF_UNSPEC, RTM_GETACTION, tc_ctl_action, tc_dump_action,
1641                       0);
1642 
1643         return 0;
1644 }
1645 
1646 subsys_initcall(tc_action_init);
1647 

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