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