blob: 711dd26c95c325a42937ba083f970c5d8b77b197 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/sched/act_api.c Packet action API.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Author: Jamal Hadi Salim
10 *
11 *
12 */
13
14#include <asm/uaccess.h>
15#include <asm/system.h>
16#include <linux/bitops.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/types.h>
18#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/string.h>
20#include <linux/mm.h>
21#include <linux/socket.h>
22#include <linux/sockios.h>
23#include <linux/in.h>
24#include <linux/errno.h>
25#include <linux/interrupt.h>
26#include <linux/netdevice.h>
27#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/init.h>
29#include <linux/kmod.h>
30#include <net/sock.h>
31#include <net/sch_generic.h>
32#include <net/act_api.h>
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -070033#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
David S. Millere9ce1cd2006-08-21 23:54:55 -070035void tcf_hash_destroy(struct tcf_common *p, struct tcf_hashinfo *hinfo)
36{
37 unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask);
38 struct tcf_common **p1p;
39
40 for (p1p = &hinfo->htab[h]; *p1p; p1p = &(*p1p)->tcfc_next) {
41 if (*p1p == p) {
42 write_lock_bh(hinfo->lock);
43 *p1p = p->tcfc_next;
44 write_unlock_bh(hinfo->lock);
45#ifdef CONFIG_NET_ESTIMATOR
46 gen_kill_estimator(&p->tcfc_bstats,
47 &p->tcfc_rate_est);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#endif
David S. Millere9ce1cd2006-08-21 23:54:55 -070049 kfree(p);
50 return;
51 }
52 }
53 BUG_TRAP(0);
54}
55EXPORT_SYMBOL(tcf_hash_destroy);
56
57int tcf_hash_release(struct tcf_common *p, int bind,
58 struct tcf_hashinfo *hinfo)
59{
60 int ret = 0;
61
62 if (p) {
63 if (bind)
64 p->tcfc_bindcnt--;
65
66 p->tcfc_refcnt--;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +090067 if (p->tcfc_bindcnt <= 0 && p->tcfc_refcnt <= 0) {
David S. Millere9ce1cd2006-08-21 23:54:55 -070068 tcf_hash_destroy(p, hinfo);
69 ret = 1;
70 }
71 }
72 return ret;
73}
74EXPORT_SYMBOL(tcf_hash_release);
75
76static int tcf_dump_walker(struct sk_buff *skb, struct netlink_callback *cb,
77 struct tc_action *a, struct tcf_hashinfo *hinfo)
78{
79 struct tcf_common *p;
80 int err = 0, index = -1,i = 0, s_i = 0, n_i = 0;
81 struct rtattr *r ;
82
83 read_lock(hinfo->lock);
84
85 s_i = cb->args[0];
86
87 for (i = 0; i < (hinfo->hmask + 1); i++) {
88 p = hinfo->htab[tcf_hash(i, hinfo->hmask)];
89
90 for (; p; p = p->tcfc_next) {
91 index++;
92 if (index < s_i)
93 continue;
94 a->priv = p;
95 a->order = n_i;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -070096 r = (struct rtattr *)skb_tail_pointer(skb);
David S. Millere9ce1cd2006-08-21 23:54:55 -070097 RTA_PUT(skb, a->order, 0, NULL);
98 err = tcf_action_dump_1(skb, a, 0, 0);
99 if (err < 0) {
100 index--;
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700101 nlmsg_trim(skb, r);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700102 goto done;
103 }
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700104 r->rta_len = skb_tail_pointer(skb) - (u8 *)r;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700105 n_i++;
106 if (n_i >= TCA_ACT_MAX_PRIO)
107 goto done;
108 }
109 }
110done:
111 read_unlock(hinfo->lock);
112 if (n_i)
113 cb->args[0] += n_i;
114 return n_i;
115
116rtattr_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700117 nlmsg_trim(skb, r);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700118 goto done;
119}
120
121static int tcf_del_walker(struct sk_buff *skb, struct tc_action *a,
122 struct tcf_hashinfo *hinfo)
123{
124 struct tcf_common *p, *s_p;
125 struct rtattr *r ;
126 int i= 0, n_i = 0;
127
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700128 r = (struct rtattr *)skb_tail_pointer(skb);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700129 RTA_PUT(skb, a->order, 0, NULL);
130 RTA_PUT(skb, TCA_KIND, IFNAMSIZ, a->ops->kind);
131 for (i = 0; i < (hinfo->hmask + 1); i++) {
132 p = hinfo->htab[tcf_hash(i, hinfo->hmask)];
133
134 while (p != NULL) {
135 s_p = p->tcfc_next;
136 if (ACT_P_DELETED == tcf_hash_release(p, 0, hinfo))
137 module_put(a->ops->owner);
138 n_i++;
139 p = s_p;
140 }
141 }
142 RTA_PUT(skb, TCA_FCNT, 4, &n_i);
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700143 r->rta_len = skb_tail_pointer(skb) - (u8 *)r;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700144
145 return n_i;
146rtattr_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700147 nlmsg_trim(skb, r);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700148 return -EINVAL;
149}
150
151int tcf_generic_walker(struct sk_buff *skb, struct netlink_callback *cb,
152 int type, struct tc_action *a)
153{
154 struct tcf_hashinfo *hinfo = a->ops->hinfo;
155
156 if (type == RTM_DELACTION) {
157 return tcf_del_walker(skb, a, hinfo);
158 } else if (type == RTM_GETACTION) {
159 return tcf_dump_walker(skb, cb, a, hinfo);
160 } else {
161 printk("tcf_generic_walker: unknown action %d\n", type);
162 return -EINVAL;
163 }
164}
165EXPORT_SYMBOL(tcf_generic_walker);
166
167struct tcf_common *tcf_hash_lookup(u32 index, struct tcf_hashinfo *hinfo)
168{
169 struct tcf_common *p;
170
171 read_lock(hinfo->lock);
172 for (p = hinfo->htab[tcf_hash(index, hinfo->hmask)]; p;
173 p = p->tcfc_next) {
174 if (p->tcfc_index == index)
175 break;
176 }
177 read_unlock(hinfo->lock);
178
179 return p;
180}
181EXPORT_SYMBOL(tcf_hash_lookup);
182
183u32 tcf_hash_new_index(u32 *idx_gen, struct tcf_hashinfo *hinfo)
184{
185 u32 val = *idx_gen;
186
187 do {
188 if (++val == 0)
189 val = 1;
190 } while (tcf_hash_lookup(val, hinfo));
191
192 return (*idx_gen = val);
193}
194EXPORT_SYMBOL(tcf_hash_new_index);
195
196int tcf_hash_search(struct tc_action *a, u32 index)
197{
198 struct tcf_hashinfo *hinfo = a->ops->hinfo;
199 struct tcf_common *p = tcf_hash_lookup(index, hinfo);
200
201 if (p) {
202 a->priv = p;
203 return 1;
204 }
205 return 0;
206}
207EXPORT_SYMBOL(tcf_hash_search);
208
209struct tcf_common *tcf_hash_check(u32 index, struct tc_action *a, int bind,
210 struct tcf_hashinfo *hinfo)
211{
212 struct tcf_common *p = NULL;
213 if (index && (p = tcf_hash_lookup(index, hinfo)) != NULL) {
214 if (bind) {
215 p->tcfc_bindcnt++;
216 p->tcfc_refcnt++;
217 }
218 a->priv = p;
219 }
220 return p;
221}
222EXPORT_SYMBOL(tcf_hash_check);
223
224struct tcf_common *tcf_hash_create(u32 index, struct rtattr *est, struct tc_action *a, int size, int bind, u32 *idx_gen, struct tcf_hashinfo *hinfo)
225{
226 struct tcf_common *p = kzalloc(size, GFP_KERNEL);
227
228 if (unlikely(!p))
229 return p;
230 p->tcfc_refcnt = 1;
231 if (bind)
232 p->tcfc_bindcnt = 1;
233
234 spin_lock_init(&p->tcfc_lock);
235 p->tcfc_stats_lock = &p->tcfc_lock;
236 p->tcfc_index = index ? index : tcf_hash_new_index(idx_gen, hinfo);
237 p->tcfc_tm.install = jiffies;
238 p->tcfc_tm.lastuse = jiffies;
239#ifdef CONFIG_NET_ESTIMATOR
240 if (est)
241 gen_new_estimator(&p->tcfc_bstats, &p->tcfc_rate_est,
242 p->tcfc_stats_lock, est);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243#endif
David S. Millere9ce1cd2006-08-21 23:54:55 -0700244 a->priv = (void *) p;
245 return p;
246}
247EXPORT_SYMBOL(tcf_hash_create);
248
249void tcf_hash_insert(struct tcf_common *p, struct tcf_hashinfo *hinfo)
250{
251 unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask);
252
253 write_lock_bh(hinfo->lock);
254 p->tcfc_next = hinfo->htab[h];
255 hinfo->htab[h] = p;
256 write_unlock_bh(hinfo->lock);
257}
258EXPORT_SYMBOL(tcf_hash_insert);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260static struct tc_action_ops *act_base = NULL;
261static DEFINE_RWLOCK(act_mod_lock);
262
263int tcf_register_action(struct tc_action_ops *act)
264{
265 struct tc_action_ops *a, **ap;
266
267 write_lock(&act_mod_lock);
268 for (ap = &act_base; (a = *ap) != NULL; ap = &a->next) {
269 if (act->type == a->type || (strcmp(act->kind, a->kind) == 0)) {
270 write_unlock(&act_mod_lock);
271 return -EEXIST;
272 }
273 }
274 act->next = NULL;
275 *ap = act;
276 write_unlock(&act_mod_lock);
277 return 0;
278}
279
280int tcf_unregister_action(struct tc_action_ops *act)
281{
282 struct tc_action_ops *a, **ap;
283 int err = -ENOENT;
284
285 write_lock(&act_mod_lock);
286 for (ap = &act_base; (a = *ap) != NULL; ap = &a->next)
287 if (a == act)
288 break;
289 if (a) {
290 *ap = a->next;
291 a->next = NULL;
292 err = 0;
293 }
294 write_unlock(&act_mod_lock);
295 return err;
296}
297
298/* lookup by name */
299static struct tc_action_ops *tc_lookup_action_n(char *kind)
300{
301 struct tc_action_ops *a = NULL;
302
303 if (kind) {
304 read_lock(&act_mod_lock);
305 for (a = act_base; a; a = a->next) {
306 if (strcmp(kind, a->kind) == 0) {
307 if (!try_module_get(a->owner)) {
308 read_unlock(&act_mod_lock);
309 return NULL;
310 }
311 break;
312 }
313 }
314 read_unlock(&act_mod_lock);
315 }
316 return a;
317}
318
319/* lookup by rtattr */
320static struct tc_action_ops *tc_lookup_action(struct rtattr *kind)
321{
322 struct tc_action_ops *a = NULL;
323
324 if (kind) {
325 read_lock(&act_mod_lock);
326 for (a = act_base; a; a = a->next) {
327 if (rtattr_strcmp(kind, a->kind) == 0) {
328 if (!try_module_get(a->owner)) {
329 read_unlock(&act_mod_lock);
330 return NULL;
331 }
332 break;
333 }
334 }
335 read_unlock(&act_mod_lock);
336 }
337 return a;
338}
339
340#if 0
341/* lookup by id */
342static struct tc_action_ops *tc_lookup_action_id(u32 type)
343{
344 struct tc_action_ops *a = NULL;
345
346 if (type) {
347 read_lock(&act_mod_lock);
348 for (a = act_base; a; a = a->next) {
349 if (a->type == type) {
350 if (!try_module_get(a->owner)) {
351 read_unlock(&act_mod_lock);
352 return NULL;
353 }
354 break;
355 }
356 }
357 read_unlock(&act_mod_lock);
358 }
359 return a;
360}
361#endif
362
363int tcf_action_exec(struct sk_buff *skb, struct tc_action *act,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900364 struct tcf_result *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
366 struct tc_action *a;
367 int ret = -1;
368
369 if (skb->tc_verd & TC_NCLS) {
370 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 ret = TC_ACT_OK;
372 goto exec_done;
373 }
374 while ((a = act) != NULL) {
375repeat:
376 if (a->ops && a->ops->act) {
Patrick McHardyf43c5a02006-01-08 22:15:34 -0800377 ret = a->ops->act(skb, a, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 if (TC_MUNGED & skb->tc_verd) {
379 /* copied already, allow trampling */
380 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
381 skb->tc_verd = CLR_TC_MUNGED(skb->tc_verd);
382 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 if (ret == TC_ACT_REPEAT)
384 goto repeat; /* we need a ttl - JHS */
J Hadi Salim14d50e72005-05-03 16:29:13 -0700385 if (ret != TC_ACT_PIPE)
386 goto exec_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 }
388 act = a->next;
389 }
390exec_done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 return ret;
392}
393
394void tcf_action_destroy(struct tc_action *act, int bind)
395{
396 struct tc_action *a;
397
398 for (a = act; a; a = act) {
399 if (a->ops && a->ops->cleanup) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 if (a->ops->cleanup(a, bind) == ACT_P_DELETED)
401 module_put(a->ops->owner);
402 act = act->next;
403 kfree(a);
404 } else { /*FIXME: Remove later - catch insertion bugs*/
405 printk("tcf_action_destroy: BUG? destroying NULL ops\n");
406 act = act->next;
407 kfree(a);
408 }
409 }
410}
411
412int
413tcf_action_dump_old(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
414{
415 int err = -EINVAL;
416
417 if (a->ops == NULL || a->ops->dump == NULL)
418 return err;
419 return a->ops->dump(skb, a, bind, ref);
420}
421
422int
423tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
424{
425 int err = -EINVAL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700426 unsigned char *b = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 struct rtattr *r;
428
429 if (a->ops == NULL || a->ops->dump == NULL)
430 return err;
431
432 RTA_PUT(skb, TCA_KIND, IFNAMSIZ, a->ops->kind);
433 if (tcf_action_copy_stats(skb, a, 0))
434 goto rtattr_failure;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700435 r = (struct rtattr *)skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
437 if ((err = tcf_action_dump_old(skb, a, bind, ref)) > 0) {
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700438 r->rta_len = skb_tail_pointer(skb) - (u8 *)r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 return err;
440 }
441
442rtattr_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700443 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 return -1;
445}
446
447int
448tcf_action_dump(struct sk_buff *skb, struct tc_action *act, int bind, int ref)
449{
450 struct tc_action *a;
451 int err = -EINVAL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700452 unsigned char *b = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 struct rtattr *r ;
454
455 while ((a = act) != NULL) {
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700456 r = (struct rtattr *)skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 act = a->next;
458 RTA_PUT(skb, a->order, 0, NULL);
459 err = tcf_action_dump_1(skb, a, bind, ref);
460 if (err < 0)
Thomas Graf4fe683f2006-07-05 20:47:28 -0700461 goto errout;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700462 r->rta_len = skb_tail_pointer(skb) - (u8 *)r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 }
464
465 return 0;
466
467rtattr_failure:
Thomas Graf4fe683f2006-07-05 20:47:28 -0700468 err = -EINVAL;
469errout:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700470 nlmsg_trim(skb, b);
Thomas Graf4fe683f2006-07-05 20:47:28 -0700471 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472}
473
474struct tc_action *tcf_action_init_1(struct rtattr *rta, struct rtattr *est,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900475 char *name, int ovr, int bind, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476{
477 struct tc_action *a;
478 struct tc_action_ops *a_o;
479 char act_name[IFNAMSIZ];
480 struct rtattr *tb[TCA_ACT_MAX+1];
481 struct rtattr *kind;
482
483 *err = -EINVAL;
484
485 if (name == NULL) {
486 if (rtattr_parse_nested(tb, TCA_ACT_MAX, rta) < 0)
487 goto err_out;
488 kind = tb[TCA_ACT_KIND-1];
489 if (kind == NULL)
490 goto err_out;
491 if (rtattr_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ)
492 goto err_out;
493 } else {
494 if (strlcpy(act_name, name, IFNAMSIZ) >= IFNAMSIZ)
495 goto err_out;
496 }
497
498 a_o = tc_lookup_action_n(act_name);
499 if (a_o == NULL) {
500#ifdef CONFIG_KMOD
501 rtnl_unlock();
Patrick McHardy4bba3922006-01-08 22:22:14 -0800502 request_module("act_%s", act_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 rtnl_lock();
504
505 a_o = tc_lookup_action_n(act_name);
506
507 /* We dropped the RTNL semaphore in order to
508 * perform the module load. So, even if we
509 * succeeded in loading the module we have to
510 * tell the caller to replay the request. We
511 * indicate this using -EAGAIN.
512 */
513 if (a_o != NULL) {
514 *err = -EAGAIN;
515 goto err_mod;
516 }
517#endif
Thomas Grafd152b4e2006-07-05 20:45:57 -0700518 *err = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 goto err_out;
520 }
521
522 *err = -ENOMEM;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700523 a = kzalloc(sizeof(*a), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 if (a == NULL)
525 goto err_mod;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
527 /* backward compatibility for policer */
528 if (name == NULL)
529 *err = a_o->init(tb[TCA_ACT_OPTIONS-1], est, a, ovr, bind);
530 else
531 *err = a_o->init(rta, est, a, ovr, bind);
532 if (*err < 0)
533 goto err_free;
534
535 /* module count goes up only when brand new policy is created
536 if it exists and is only bound to in a_o->init() then
537 ACT_P_CREATED is not returned (a zero is).
538 */
539 if (*err != ACT_P_CREATED)
540 module_put(a_o->owner);
541 a->ops = a_o;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
543 *err = 0;
544 return a;
545
546err_free:
547 kfree(a);
548err_mod:
549 module_put(a_o->owner);
550err_out:
551 return NULL;
552}
553
554struct tc_action *tcf_action_init(struct rtattr *rta, struct rtattr *est,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900555 char *name, int ovr, int bind, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556{
557 struct rtattr *tb[TCA_ACT_MAX_PRIO+1];
558 struct tc_action *head = NULL, *act, *act_prev = NULL;
559 int i;
560
561 if (rtattr_parse_nested(tb, TCA_ACT_MAX_PRIO, rta) < 0) {
562 *err = -EINVAL;
563 return head;
564 }
565
566 for (i=0; i < TCA_ACT_MAX_PRIO && tb[i]; i++) {
567 act = tcf_action_init_1(tb[i], est, name, ovr, bind, err);
568 if (act == NULL)
569 goto err;
570 act->order = i+1;
571
572 if (head == NULL)
573 head = act;
574 else
575 act_prev->next = act;
576 act_prev = act;
577 }
578 return head;
579
580err:
581 if (head != NULL)
582 tcf_action_destroy(head, bind);
583 return NULL;
584}
585
586int tcf_action_copy_stats(struct sk_buff *skb, struct tc_action *a,
587 int compat_mode)
588{
589 int err = 0;
590 struct gnet_dump d;
591 struct tcf_act_hdr *h = a->priv;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 if (h == NULL)
594 goto errout;
595
596 /* compat_mode being true specifies a call that is supposed
597 * to add additional backward compatiblity statistic TLVs.
598 */
599 if (compat_mode) {
600 if (a->type == TCA_OLD_COMPAT)
601 err = gnet_stats_start_copy_compat(skb, 0,
David S. Millere9ce1cd2006-08-21 23:54:55 -0700602 TCA_STATS, TCA_XSTATS, h->tcf_stats_lock, &d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 else
604 return 0;
605 } else
606 err = gnet_stats_start_copy(skb, TCA_ACT_STATS,
David S. Millere9ce1cd2006-08-21 23:54:55 -0700607 h->tcf_stats_lock, &d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
609 if (err < 0)
610 goto errout;
611
612 if (a->ops != NULL && a->ops->get_stats != NULL)
613 if (a->ops->get_stats(skb, a) < 0)
614 goto errout;
615
David S. Millere9ce1cd2006-08-21 23:54:55 -0700616 if (gnet_stats_copy_basic(&d, &h->tcf_bstats) < 0 ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617#ifdef CONFIG_NET_ESTIMATOR
David S. Millere9ce1cd2006-08-21 23:54:55 -0700618 gnet_stats_copy_rate_est(&d, &h->tcf_rate_est) < 0 ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619#endif
David S. Millere9ce1cd2006-08-21 23:54:55 -0700620 gnet_stats_copy_queue(&d, &h->tcf_qstats) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 goto errout;
622
623 if (gnet_stats_finish_copy(&d) < 0)
624 goto errout;
625
626 return 0;
627
628errout:
629 return -1;
630}
631
632static int
633tca_get_fill(struct sk_buff *skb, struct tc_action *a, u32 pid, u32 seq,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900634 u16 flags, int event, int bind, int ref)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635{
636 struct tcamsg *t;
637 struct nlmsghdr *nlh;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700638 unsigned char *b = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 struct rtattr *x;
640
Jamal Hadi Salime431b8c2005-06-18 22:55:31 -0700641 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags);
642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 t = NLMSG_DATA(nlh);
644 t->tca_family = AF_UNSPEC;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700645 t->tca__pad1 = 0;
646 t->tca__pad2 = 0;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900647
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700648 x = (struct rtattr *)skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
650
651 if (tcf_action_dump(skb, a, bind, ref) < 0)
652 goto rtattr_failure;
653
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700654 x->rta_len = skb_tail_pointer(skb) - (u8 *)x;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900655
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700656 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 return skb->len;
658
659rtattr_failure:
660nlmsg_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700661 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 return -1;
663}
664
665static int
666act_get_notify(u32 pid, struct nlmsghdr *n, struct tc_action *a, int event)
667{
668 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
670 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
671 if (!skb)
672 return -ENOBUFS;
673 if (tca_get_fill(skb, a, pid, n->nlmsg_seq, 0, event, 0, 0) <= 0) {
674 kfree_skb(skb);
675 return -EINVAL;
676 }
Thomas Graf2942e902006-08-15 00:30:25 -0700677
678 return rtnl_unicast(skb, pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
681static struct tc_action *
682tcf_action_get_1(struct rtattr *rta, struct nlmsghdr *n, u32 pid, int *err)
683{
684 struct rtattr *tb[TCA_ACT_MAX+1];
685 struct tc_action *a;
686 int index;
687
688 *err = -EINVAL;
689 if (rtattr_parse_nested(tb, TCA_ACT_MAX, rta) < 0)
690 return NULL;
691
692 if (tb[TCA_ACT_INDEX - 1] == NULL ||
693 RTA_PAYLOAD(tb[TCA_ACT_INDEX - 1]) < sizeof(index))
694 return NULL;
695 index = *(int *)RTA_DATA(tb[TCA_ACT_INDEX - 1]);
696
697 *err = -ENOMEM;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700698 a = kzalloc(sizeof(struct tc_action), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 if (a == NULL)
700 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 *err = -EINVAL;
703 a->ops = tc_lookup_action(tb[TCA_ACT_KIND - 1]);
704 if (a->ops == NULL)
705 goto err_free;
706 if (a->ops->lookup == NULL)
707 goto err_mod;
708 *err = -ENOENT;
709 if (a->ops->lookup(a, index) == 0)
710 goto err_mod;
711
712 module_put(a->ops->owner);
713 *err = 0;
714 return a;
715err_mod:
716 module_put(a->ops->owner);
717err_free:
718 kfree(a);
719 return NULL;
720}
721
722static void cleanup_a(struct tc_action *act)
723{
724 struct tc_action *a;
725
726 for (a = act; a; a = act) {
727 act = a->next;
728 kfree(a);
729 }
730}
731
732static struct tc_action *create_a(int i)
733{
734 struct tc_action *act;
735
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700736 act = kzalloc(sizeof(*act), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 if (act == NULL) {
738 printk("create_a: failed to alloc!\n");
739 return NULL;
740 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 act->order = i;
742 return act;
743}
744
745static int tca_action_flush(struct rtattr *rta, struct nlmsghdr *n, u32 pid)
746{
747 struct sk_buff *skb;
748 unsigned char *b;
749 struct nlmsghdr *nlh;
750 struct tcamsg *t;
751 struct netlink_callback dcb;
752 struct rtattr *x;
753 struct rtattr *tb[TCA_ACT_MAX+1];
754 struct rtattr *kind;
755 struct tc_action *a = create_a(0);
756 int err = -EINVAL;
757
758 if (a == NULL) {
759 printk("tca_action_flush: couldnt create tc_action\n");
760 return err;
761 }
762
763 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
764 if (!skb) {
765 printk("tca_action_flush: failed skb alloc\n");
766 kfree(a);
767 return -ENOBUFS;
768 }
769
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700770 b = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
772 if (rtattr_parse_nested(tb, TCA_ACT_MAX, rta) < 0)
773 goto err_out;
774
775 kind = tb[TCA_ACT_KIND-1];
776 a->ops = tc_lookup_action(kind);
777 if (a->ops == NULL)
778 goto err_out;
779
780 nlh = NLMSG_PUT(skb, pid, n->nlmsg_seq, RTM_DELACTION, sizeof(*t));
781 t = NLMSG_DATA(nlh);
782 t->tca_family = AF_UNSPEC;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700783 t->tca__pad1 = 0;
784 t->tca__pad2 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700786 x = (struct rtattr *)skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
788
789 err = a->ops->walk(skb, &dcb, RTM_DELACTION, a);
790 if (err < 0)
791 goto rtattr_failure;
792
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700793 x->rta_len = skb_tail_pointer(skb) - (u8 *)x;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700795 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 nlh->nlmsg_flags |= NLM_F_ROOT;
797 module_put(a->ops->owner);
798 kfree(a);
Patrick McHardyac6d4392005-08-14 19:29:52 -0700799 err = rtnetlink_send(skb, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 if (err > 0)
801 return 0;
802
803 return err;
804
805rtattr_failure:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806nlmsg_failure:
Thomas Grafebbaeab2006-07-09 11:36:23 -0700807 module_put(a->ops->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808err_out:
809 kfree_skb(skb);
810 kfree(a);
811 return err;
812}
813
814static int
815tca_action_gd(struct rtattr *rta, struct nlmsghdr *n, u32 pid, int event)
816{
817 int i, ret = 0;
818 struct rtattr *tb[TCA_ACT_MAX_PRIO+1];
819 struct tc_action *head = NULL, *act, *act_prev = NULL;
820
821 if (rtattr_parse_nested(tb, TCA_ACT_MAX_PRIO, rta) < 0)
822 return -EINVAL;
823
824 if (event == RTM_DELACTION && n->nlmsg_flags&NLM_F_ROOT) {
825 if (tb[0] != NULL && tb[1] == NULL)
826 return tca_action_flush(tb[0], n, pid);
827 }
828
829 for (i=0; i < TCA_ACT_MAX_PRIO && tb[i]; i++) {
830 act = tcf_action_get_1(tb[i], n, pid, &ret);
831 if (act == NULL)
832 goto err;
833 act->order = i+1;
834
835 if (head == NULL)
836 head = act;
837 else
838 act_prev->next = act;
839 act_prev = act;
840 }
841
842 if (event == RTM_GETACTION)
843 ret = act_get_notify(pid, n, head, event);
844 else { /* delete */
845 struct sk_buff *skb;
846
847 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
848 if (!skb) {
849 ret = -ENOBUFS;
850 goto err;
851 }
852
853 if (tca_get_fill(skb, head, pid, n->nlmsg_seq, 0, event,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900854 0, 1) <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 kfree_skb(skb);
856 ret = -EINVAL;
857 goto err;
858 }
859
860 /* now do the delete */
861 tcf_action_destroy(head, 0);
Patrick McHardyac6d4392005-08-14 19:29:52 -0700862 ret = rtnetlink_send(skb, pid, RTNLGRP_TC,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900863 n->nlmsg_flags&NLM_F_ECHO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 if (ret > 0)
865 return 0;
866 return ret;
867 }
868err:
869 cleanup_a(head);
870 return ret;
871}
872
873static int tcf_add_notify(struct tc_action *a, u32 pid, u32 seq, int event,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900874 u16 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875{
876 struct tcamsg *t;
877 struct nlmsghdr *nlh;
878 struct sk_buff *skb;
879 struct rtattr *x;
880 unsigned char *b;
881 int err = 0;
882
883 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
884 if (!skb)
885 return -ENOBUFS;
886
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700887 b = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
Jamal Hadi Salime431b8c2005-06-18 22:55:31 -0700889 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 t = NLMSG_DATA(nlh);
891 t->tca_family = AF_UNSPEC;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700892 t->tca__pad1 = 0;
893 t->tca__pad2 = 0;
894
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700895 x = (struct rtattr *)skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
897
898 if (tcf_action_dump(skb, a, 0, 0) < 0)
899 goto rtattr_failure;
900
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700901 x->rta_len = skb_tail_pointer(skb) - (u8 *)x;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900902
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700903 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
Patrick McHardyac6d4392005-08-14 19:29:52 -0700904 NETLINK_CB(skb).dst_group = RTNLGRP_TC;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900905
Patrick McHardyac6d4392005-08-14 19:29:52 -0700906 err = rtnetlink_send(skb, pid, RTNLGRP_TC, flags&NLM_F_ECHO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 if (err > 0)
908 err = 0;
909 return err;
910
911rtattr_failure:
912nlmsg_failure:
Patrick McHardyf6e57462006-03-12 20:33:22 -0800913 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 return -1;
915}
916
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918static int
919tcf_action_add(struct rtattr *rta, struct nlmsghdr *n, u32 pid, int ovr)
920{
921 int ret = 0;
922 struct tc_action *act;
923 struct tc_action *a;
924 u32 seq = n->nlmsg_seq;
925
926 act = tcf_action_init(rta, NULL, NULL, ovr, 0, &ret);
927 if (act == NULL)
928 goto done;
929
930 /* dump then free all the actions after update; inserted policy
931 * stays intact
932 * */
933 ret = tcf_add_notify(act, pid, seq, RTM_NEWACTION, n->nlmsg_flags);
934 for (a = act; a; a = act) {
935 act = a->next;
936 kfree(a);
937 }
938done:
939 return ret;
940}
941
942static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
943{
944 struct rtattr **tca = arg;
945 u32 pid = skb ? NETLINK_CB(skb).pid : 0;
946 int ret = 0, ovr = 0;
947
948 if (tca[TCA_ACT_TAB-1] == NULL) {
949 printk("tc_ctl_action: received NO action attribs\n");
950 return -EINVAL;
951 }
952
953 /* n->nlmsg_flags&NLM_F_CREATE
954 * */
955 switch (n->nlmsg_type) {
956 case RTM_NEWACTION:
957 /* we are going to assume all other flags
958 * imply create only if it doesnt exist
959 * Note that CREATE | EXCL implies that
960 * but since we want avoid ambiguity (eg when flags
961 * is zero) then just set this
962 */
963 if (n->nlmsg_flags&NLM_F_REPLACE)
964 ovr = 1;
965replay:
966 ret = tcf_action_add(tca[TCA_ACT_TAB-1], n, pid, ovr);
967 if (ret == -EAGAIN)
968 goto replay;
969 break;
970 case RTM_DELACTION:
971 ret = tca_action_gd(tca[TCA_ACT_TAB-1], n, pid, RTM_DELACTION);
972 break;
973 case RTM_GETACTION:
974 ret = tca_action_gd(tca[TCA_ACT_TAB-1], n, pid, RTM_GETACTION);
975 break;
976 default:
977 BUG();
978 }
979
980 return ret;
981}
982
Thomas Graf26dab892006-07-05 20:45:06 -0700983static struct rtattr *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984find_dump_kind(struct nlmsghdr *n)
985{
986 struct rtattr *tb1, *tb2[TCA_ACT_MAX+1];
987 struct rtattr *tb[TCA_ACT_MAX_PRIO + 1];
988 struct rtattr *rta[TCAA_MAX + 1];
989 struct rtattr *kind;
990 int min_len = NLMSG_LENGTH(sizeof(struct tcamsg));
991 int attrlen = n->nlmsg_len - NLMSG_ALIGN(min_len);
992 struct rtattr *attr = (void *) n + NLMSG_ALIGN(min_len);
993
994 if (rtattr_parse(rta, TCAA_MAX, attr, attrlen) < 0)
995 return NULL;
996 tb1 = rta[TCA_ACT_TAB - 1];
997 if (tb1 == NULL)
998 return NULL;
999
1000 if (rtattr_parse(tb, TCA_ACT_MAX_PRIO, RTA_DATA(tb1),
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001001 NLMSG_ALIGN(RTA_PAYLOAD(tb1))) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 return NULL;
1003 if (tb[0] == NULL)
1004 return NULL;
1005
1006 if (rtattr_parse(tb2, TCA_ACT_MAX, RTA_DATA(tb[0]),
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001007 RTA_PAYLOAD(tb[0])) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 return NULL;
1009 kind = tb2[TCA_ACT_KIND-1];
1010
Thomas Graf26dab892006-07-05 20:45:06 -07001011 return kind;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012}
1013
1014static int
1015tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb)
1016{
1017 struct nlmsghdr *nlh;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001018 unsigned char *b = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 struct rtattr *x;
1020 struct tc_action_ops *a_o;
1021 struct tc_action a;
1022 int ret = 0;
1023 struct tcamsg *t = (struct tcamsg *) NLMSG_DATA(cb->nlh);
Thomas Graf26dab892006-07-05 20:45:06 -07001024 struct rtattr *kind = find_dump_kind(cb->nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025
1026 if (kind == NULL) {
1027 printk("tc_dump_action: action bad kind\n");
1028 return 0;
1029 }
1030
Thomas Graf26dab892006-07-05 20:45:06 -07001031 a_o = tc_lookup_action(kind);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 if (a_o == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 return 0;
1034 }
1035
1036 memset(&a, 0, sizeof(struct tc_action));
1037 a.ops = a_o;
1038
1039 if (a_o->walk == NULL) {
Thomas Graf26dab892006-07-05 20:45:06 -07001040 printk("tc_dump_action: %s !capable of dumping table\n", a_o->kind);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 goto rtattr_failure;
1042 }
1043
1044 nlh = NLMSG_PUT(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001045 cb->nlh->nlmsg_type, sizeof(*t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 t = NLMSG_DATA(nlh);
1047 t->tca_family = AF_UNSPEC;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001048 t->tca__pad1 = 0;
1049 t->tca__pad2 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001051 x = (struct rtattr *)skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
1053
1054 ret = a_o->walk(skb, cb, RTM_GETACTION, &a);
1055 if (ret < 0)
1056 goto rtattr_failure;
1057
1058 if (ret > 0) {
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001059 x->rta_len = skb_tail_pointer(skb) - (u8 *)x;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 ret = skb->len;
1061 } else
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -07001062 nlmsg_trim(skb, x);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001064 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 if (NETLINK_CB(cb->skb).pid && ret)
1066 nlh->nlmsg_flags |= NLM_F_MULTI;
1067 module_put(a_o->owner);
1068 return skb->len;
1069
1070rtattr_failure:
1071nlmsg_failure:
1072 module_put(a_o->owner);
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -07001073 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 return skb->len;
1075}
1076
1077static int __init tc_action_init(void)
1078{
Thomas Graf708914c2007-03-22 11:56:59 -07001079 rtnl_register(PF_UNSPEC, RTM_NEWACTION, tc_ctl_action, NULL);
1080 rtnl_register(PF_UNSPEC, RTM_DELACTION, tc_ctl_action, NULL);
1081 rtnl_register(PF_UNSPEC, RTM_GETACTION, tc_ctl_action, tc_dump_action);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 return 0;
1084}
1085
1086subsys_initcall(tc_action_init);
1087
1088EXPORT_SYMBOL(tcf_register_action);
1089EXPORT_SYMBOL(tcf_unregister_action);
1090EXPORT_SYMBOL(tcf_action_exec);
1091EXPORT_SYMBOL(tcf_action_dump_1);