xref: /openbmc/linux/net/sched/act_api.c (revision 7490ca1e) 
1 /*
2  * net/sched/act_api.c	Packet action API.
3  *
4  *		This program is free software; you can redistribute it and/or
5  *		modify it under the terms of the GNU General Public License
6  *		as published by the Free Software Foundation; either version
7  *		2 of the License, or (at your option) any later version.
8  *
9  * Author:	Jamal Hadi Salim
10  *
11  *
12  */
13 
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/slab.h>
19 #include <linux/skbuff.h>
20 #include <linux/init.h>
21 #include <linux/kmod.h>
22 #include <linux/err.h>
23 #include <linux/module.h>
24 #include <net/net_namespace.h>
25 #include <net/sock.h>
26 #include <net/sch_generic.h>
27 #include <net/act_api.h>
28 #include <net/netlink.h>
29 
30 void tcf_hash_destroy(struct tcf_common *p, struct tcf_hashinfo *hinfo)
31 {
32 	unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask);
33 	struct tcf_common **p1p;
34 
35 	for (p1p = &hinfo->htab[h]; *p1p; p1p = &(*p1p)->tcfc_next) {
36 		if (*p1p == p) {
37 			write_lock_bh(hinfo->lock);
38 			*p1p = p->tcfc_next;
39 			write_unlock_bh(hinfo->lock);
40 			gen_kill_estimator(&p->tcfc_bstats,
41 					   &p->tcfc_rate_est);
42 			/*
43 			 * gen_estimator est_timer() might access p->tcfc_lock
44 			 * or bstats, wait a RCU grace period before freeing p
45 			 */
46 			kfree_rcu(p, tcfc_rcu);
47 			return;
48 		}
49 	}
50 	WARN_ON(1);
51 }
52 EXPORT_SYMBOL(tcf_hash_destroy);
53 
54 int tcf_hash_release(struct tcf_common *p, int bind,
55 		     struct tcf_hashinfo *hinfo)
56 {
57 	int ret = 0;
58 
59 	if (p) {
60 		if (bind)
61 			p->tcfc_bindcnt--;
62 
63 		p->tcfc_refcnt--;
64 		if (p->tcfc_bindcnt <= 0 && p->tcfc_refcnt <= 0) {
65 			tcf_hash_destroy(p, hinfo);
66 			ret = 1;
67 		}
68 	}
69 	return ret;
70 }
71 EXPORT_SYMBOL(tcf_hash_release);
72 
73 static int tcf_dump_walker(struct sk_buff *skb, struct netlink_callback *cb,
74 			   struct tc_action *a, struct tcf_hashinfo *hinfo)
75 {
76 	struct tcf_common *p;
77 	int err = 0, index = -1, i = 0, s_i = 0, n_i = 0;
78 	struct nlattr *nest;
79 
80 	read_lock_bh(hinfo->lock);
81 
82 	s_i = cb->args[0];
83 
84 	for (i = 0; i < (hinfo->hmask + 1); i++) {
85 		p = hinfo->htab[tcf_hash(i, hinfo->hmask)];
86 
87 		for (; p; p = p->tcfc_next) {
88 			index++;
89 			if (index < s_i)
90 				continue;
91 			a->priv = p;
92 			a->order = n_i;
93 
94 			nest = nla_nest_start(skb, a->order);
95 			if (nest == NULL)
96 				goto nla_put_failure;
97 			err = tcf_action_dump_1(skb, a, 0, 0);
98 			if (err < 0) {
99 				index--;
100 				nlmsg_trim(skb, nest);
101 				goto done;
102 			}
103 			nla_nest_end(skb, nest);
104 			n_i++;
105 			if (n_i >= TCA_ACT_MAX_PRIO)
106 				goto done;
107 		}
108 	}
109 done:
110 	read_unlock_bh(hinfo->lock);
111 	if (n_i)
112 		cb->args[0] += n_i;
113 	return n_i;
114 
115 nla_put_failure:
116 	nla_nest_cancel(skb, nest);
117 	goto done;
118 }
119 
120 static int tcf_del_walker(struct sk_buff *skb, struct tc_action *a,
121 			  struct tcf_hashinfo *hinfo)
122 {
123 	struct tcf_common *p, *s_p;
124 	struct nlattr *nest;
125 	int i = 0, n_i = 0;
126 
127 	nest = nla_nest_start(skb, a->order);
128 	if (nest == NULL)
129 		goto nla_put_failure;
130 	NLA_PUT_STRING(skb, TCA_KIND, 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 	NLA_PUT_U32(skb, TCA_FCNT, n_i);
143 	nla_nest_end(skb, nest);
144 
145 	return n_i;
146 nla_put_failure:
147 	nla_nest_cancel(skb, nest);
148 	return -EINVAL;
149 }
150 
151 int 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 		WARN(1, "tcf_generic_walker: unknown action %d\n", type);
162 		return -EINVAL;
163 	}
164 }
165 EXPORT_SYMBOL(tcf_generic_walker);
166 
167 struct tcf_common *tcf_hash_lookup(u32 index, struct tcf_hashinfo *hinfo)
168 {
169 	struct tcf_common *p;
170 
171 	read_lock_bh(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_bh(hinfo->lock);
178 
179 	return p;
180 }
181 EXPORT_SYMBOL(tcf_hash_lookup);
182 
183 u32 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 }
194 EXPORT_SYMBOL(tcf_hash_new_index);
195 
196 int 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 }
207 EXPORT_SYMBOL(tcf_hash_search);
208 
209 struct 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 		a->priv = p;
218 	}
219 	return p;
220 }
221 EXPORT_SYMBOL(tcf_hash_check);
222 
223 struct tcf_common *tcf_hash_create(u32 index, struct nlattr *est,
224 				   struct tc_action *a, int size, int bind,
225 				   u32 *idx_gen, struct tcf_hashinfo *hinfo)
226 {
227 	struct tcf_common *p = kzalloc(size, GFP_KERNEL);
228 
229 	if (unlikely(!p))
230 		return ERR_PTR(-ENOMEM);
231 	p->tcfc_refcnt = 1;
232 	if (bind)
233 		p->tcfc_bindcnt = 1;
234 
235 	spin_lock_init(&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 	if (est) {
240 		int err = gen_new_estimator(&p->tcfc_bstats, &p->tcfc_rate_est,
241 					    &p->tcfc_lock, est);
242 		if (err) {
243 			kfree(p);
244 			return ERR_PTR(err);
245 		}
246 	}
247 
248 	a->priv = (void *) p;
249 	return p;
250 }
251 EXPORT_SYMBOL(tcf_hash_create);
252 
253 void tcf_hash_insert(struct tcf_common *p, struct tcf_hashinfo *hinfo)
254 {
255 	unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask);
256 
257 	write_lock_bh(hinfo->lock);
258 	p->tcfc_next = hinfo->htab[h];
259 	hinfo->htab[h] = p;
260 	write_unlock_bh(hinfo->lock);
261 }
262 EXPORT_SYMBOL(tcf_hash_insert);
263 
264 static struct tc_action_ops *act_base = NULL;
265 static DEFINE_RWLOCK(act_mod_lock);
266 
267 int tcf_register_action(struct tc_action_ops *act)
268 {
269 	struct tc_action_ops *a, **ap;
270 
271 	write_lock(&act_mod_lock);
272 	for (ap = &act_base; (a = *ap) != NULL; ap = &a->next) {
273 		if (act->type == a->type || (strcmp(act->kind, a->kind) == 0)) {
274 			write_unlock(&act_mod_lock);
275 			return -EEXIST;
276 		}
277 	}
278 	act->next = NULL;
279 	*ap = act;
280 	write_unlock(&act_mod_lock);
281 	return 0;
282 }
283 EXPORT_SYMBOL(tcf_register_action);
284 
285 int tcf_unregister_action(struct tc_action_ops *act)
286 {
287 	struct tc_action_ops *a, **ap;
288 	int err = -ENOENT;
289 
290 	write_lock(&act_mod_lock);
291 	for (ap = &act_base; (a = *ap) != NULL; ap = &a->next)
292 		if (a == act)
293 			break;
294 	if (a) {
295 		*ap = a->next;
296 		a->next = NULL;
297 		err = 0;
298 	}
299 	write_unlock(&act_mod_lock);
300 	return err;
301 }
302 EXPORT_SYMBOL(tcf_unregister_action);
303 
304 /* lookup by name */
305 static struct tc_action_ops *tc_lookup_action_n(char *kind)
306 {
307 	struct tc_action_ops *a = NULL;
308 
309 	if (kind) {
310 		read_lock(&act_mod_lock);
311 		for (a = act_base; a; a = a->next) {
312 			if (strcmp(kind, a->kind) == 0) {
313 				if (!try_module_get(a->owner)) {
314 					read_unlock(&act_mod_lock);
315 					return NULL;
316 				}
317 				break;
318 			}
319 		}
320 		read_unlock(&act_mod_lock);
321 	}
322 	return a;
323 }
324 
325 /* lookup by nlattr */
326 static struct tc_action_ops *tc_lookup_action(struct nlattr *kind)
327 {
328 	struct tc_action_ops *a = NULL;
329 
330 	if (kind) {
331 		read_lock(&act_mod_lock);
332 		for (a = act_base; a; a = a->next) {
333 			if (nla_strcmp(kind, a->kind) == 0) {
334 				if (!try_module_get(a->owner)) {
335 					read_unlock(&act_mod_lock);
336 					return NULL;
337 				}
338 				break;
339 			}
340 		}
341 		read_unlock(&act_mod_lock);
342 	}
343 	return a;
344 }
345 
346 #if 0
347 /* lookup by id */
348 static struct tc_action_ops *tc_lookup_action_id(u32 type)
349 {
350 	struct tc_action_ops *a = NULL;
351 
352 	if (type) {
353 		read_lock(&act_mod_lock);
354 		for (a = act_base; a; a = a->next) {
355 			if (a->type == type) {
356 				if (!try_module_get(a->owner)) {
357 					read_unlock(&act_mod_lock);
358 					return NULL;
359 				}
360 				break;
361 			}
362 		}
363 		read_unlock(&act_mod_lock);
364 	}
365 	return a;
366 }
367 #endif
368 
369 int tcf_action_exec(struct sk_buff *skb, const struct tc_action *act,
370 		    struct tcf_result *res)
371 {
372 	const struct tc_action *a;
373 	int ret = -1;
374 
375 	if (skb->tc_verd & TC_NCLS) {
376 		skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
377 		ret = TC_ACT_OK;
378 		goto exec_done;
379 	}
380 	while ((a = act) != NULL) {
381 repeat:
382 		if (a->ops && a->ops->act) {
383 			ret = a->ops->act(skb, a, res);
384 			if (TC_MUNGED & skb->tc_verd) {
385 				/* copied already, allow trampling */
386 				skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
387 				skb->tc_verd = CLR_TC_MUNGED(skb->tc_verd);
388 			}
389 			if (ret == TC_ACT_REPEAT)
390 				goto repeat;	/* we need a ttl - JHS */
391 			if (ret != TC_ACT_PIPE)
392 				goto exec_done;
393 		}
394 		act = a->next;
395 	}
396 exec_done:
397 	return ret;
398 }
399 EXPORT_SYMBOL(tcf_action_exec);
400 
401 void tcf_action_destroy(struct tc_action *act, int bind)
402 {
403 	struct tc_action *a;
404 
405 	for (a = act; a; a = act) {
406 		if (a->ops && a->ops->cleanup) {
407 			if (a->ops->cleanup(a, bind) == ACT_P_DELETED)
408 				module_put(a->ops->owner);
409 			act = act->next;
410 			kfree(a);
411 		} else {
412 			/*FIXME: Remove later - catch insertion bugs*/
413 			WARN(1, "tcf_action_destroy: BUG? destroying NULL ops\n");
414 			act = act->next;
415 			kfree(a);
416 		}
417 	}
418 }
419 
420 int
421 tcf_action_dump_old(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
422 {
423 	int err = -EINVAL;
424 
425 	if (a->ops == NULL || a->ops->dump == NULL)
426 		return err;
427 	return a->ops->dump(skb, a, bind, ref);
428 }
429 
430 int
431 tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
432 {
433 	int err = -EINVAL;
434 	unsigned char *b = skb_tail_pointer(skb);
435 	struct nlattr *nest;
436 
437 	if (a->ops == NULL || a->ops->dump == NULL)
438 		return err;
439 
440 	NLA_PUT_STRING(skb, TCA_KIND, a->ops->kind);
441 	if (tcf_action_copy_stats(skb, a, 0))
442 		goto nla_put_failure;
443 	nest = nla_nest_start(skb, TCA_OPTIONS);
444 	if (nest == NULL)
445 		goto nla_put_failure;
446 	err = tcf_action_dump_old(skb, a, bind, ref);
447 	if (err > 0) {
448 		nla_nest_end(skb, nest);
449 		return err;
450 	}
451 
452 nla_put_failure:
453 	nlmsg_trim(skb, b);
454 	return -1;
455 }
456 EXPORT_SYMBOL(tcf_action_dump_1);
457 
458 int
459 tcf_action_dump(struct sk_buff *skb, struct tc_action *act, int bind, int ref)
460 {
461 	struct tc_action *a;
462 	int err = -EINVAL;
463 	struct nlattr *nest;
464 
465 	while ((a = act) != NULL) {
466 		act = a->next;
467 		nest = nla_nest_start(skb, a->order);
468 		if (nest == NULL)
469 			goto nla_put_failure;
470 		err = tcf_action_dump_1(skb, a, bind, ref);
471 		if (err < 0)
472 			goto errout;
473 		nla_nest_end(skb, nest);
474 	}
475 
476 	return 0;
477 
478 nla_put_failure:
479 	err = -EINVAL;
480 errout:
481 	nla_nest_cancel(skb, nest);
482 	return err;
483 }
484 
485 struct tc_action *tcf_action_init_1(struct nlattr *nla, struct nlattr *est,
486 				    char *name, int ovr, int bind)
487 {
488 	struct tc_action *a;
489 	struct tc_action_ops *a_o;
490 	char act_name[IFNAMSIZ];
491 	struct nlattr *tb[TCA_ACT_MAX + 1];
492 	struct nlattr *kind;
493 	int err;
494 
495 	if (name == NULL) {
496 		err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL);
497 		if (err < 0)
498 			goto err_out;
499 		err = -EINVAL;
500 		kind = tb[TCA_ACT_KIND];
501 		if (kind == NULL)
502 			goto err_out;
503 		if (nla_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ)
504 			goto err_out;
505 	} else {
506 		err = -EINVAL;
507 		if (strlcpy(act_name, name, IFNAMSIZ) >= IFNAMSIZ)
508 			goto err_out;
509 	}
510 
511 	a_o = tc_lookup_action_n(act_name);
512 	if (a_o == NULL) {
513 #ifdef CONFIG_MODULES
514 		rtnl_unlock();
515 		request_module("act_%s", act_name);
516 		rtnl_lock();
517 
518 		a_o = tc_lookup_action_n(act_name);
519 
520 		/* We dropped the RTNL semaphore in order to
521 		 * perform the module load.  So, even if we
522 		 * succeeded in loading the module we have to
523 		 * tell the caller to replay the request.  We
524 		 * indicate this using -EAGAIN.
525 		 */
526 		if (a_o != NULL) {
527 			err = -EAGAIN;
528 			goto err_mod;
529 		}
530 #endif
531 		err = -ENOENT;
532 		goto err_out;
533 	}
534 
535 	err = -ENOMEM;
536 	a = kzalloc(sizeof(*a), GFP_KERNEL);
537 	if (a == NULL)
538 		goto err_mod;
539 
540 	/* backward compatibility for policer */
541 	if (name == NULL)
542 		err = a_o->init(tb[TCA_ACT_OPTIONS], est, a, ovr, bind);
543 	else
544 		err = a_o->init(nla, est, a, ovr, bind);
545 	if (err < 0)
546 		goto err_free;
547 
548 	/* module count goes up only when brand new policy is created
549 	 * if it exists and is only bound to in a_o->init() then
550 	 * ACT_P_CREATED is not returned (a zero is).
551 	 */
552 	if (err != ACT_P_CREATED)
553 		module_put(a_o->owner);
554 	a->ops = a_o;
555 
556 	return a;
557 
558 err_free:
559 	kfree(a);
560 err_mod:
561 	module_put(a_o->owner);
562 err_out:
563 	return ERR_PTR(err);
564 }
565 
566 struct tc_action *tcf_action_init(struct nlattr *nla, struct nlattr *est,
567 				  char *name, int ovr, int bind)
568 {
569 	struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
570 	struct tc_action *head = NULL, *act, *act_prev = NULL;
571 	int err;
572 	int i;
573 
574 	err = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL);
575 	if (err < 0)
576 		return ERR_PTR(err);
577 
578 	for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) {
579 		act = tcf_action_init_1(tb[i], est, name, ovr, bind);
580 		if (IS_ERR(act))
581 			goto err;
582 		act->order = i;
583 
584 		if (head == NULL)
585 			head = act;
586 		else
587 			act_prev->next = act;
588 		act_prev = act;
589 	}
590 	return head;
591 
592 err:
593 	if (head != NULL)
594 		tcf_action_destroy(head, bind);
595 	return act;
596 }
597 
598 int tcf_action_copy_stats(struct sk_buff *skb, struct tc_action *a,
599 			  int compat_mode)
600 {
601 	int err = 0;
602 	struct gnet_dump d;
603 	struct tcf_act_hdr *h = a->priv;
604 
605 	if (h == NULL)
606 		goto errout;
607 
608 	/* compat_mode being true specifies a call that is supposed
609 	 * to add additional backward compatibility statistic TLVs.
610 	 */
611 	if (compat_mode) {
612 		if (a->type == TCA_OLD_COMPAT)
613 			err = gnet_stats_start_copy_compat(skb, 0,
614 				TCA_STATS, TCA_XSTATS, &h->tcf_lock, &d);
615 		else
616 			return 0;
617 	} else
618 		err = gnet_stats_start_copy(skb, TCA_ACT_STATS,
619 					    &h->tcf_lock, &d);
620 
621 	if (err < 0)
622 		goto errout;
623 
624 	if (a->ops != NULL && a->ops->get_stats != NULL)
625 		if (a->ops->get_stats(skb, a) < 0)
626 			goto errout;
627 
628 	if (gnet_stats_copy_basic(&d, &h->tcf_bstats) < 0 ||
629 	    gnet_stats_copy_rate_est(&d, &h->tcf_bstats,
630 				     &h->tcf_rate_est) < 0 ||
631 	    gnet_stats_copy_queue(&d, &h->tcf_qstats) < 0)
632 		goto errout;
633 
634 	if (gnet_stats_finish_copy(&d) < 0)
635 		goto errout;
636 
637 	return 0;
638 
639 errout:
640 	return -1;
641 }
642 
643 static int
644 tca_get_fill(struct sk_buff *skb, struct tc_action *a, u32 pid, u32 seq,
645 	     u16 flags, int event, int bind, int ref)
646 {
647 	struct tcamsg *t;
648 	struct nlmsghdr *nlh;
649 	unsigned char *b = skb_tail_pointer(skb);
650 	struct nlattr *nest;
651 
652 	nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags);
653 
654 	t = NLMSG_DATA(nlh);
655 	t->tca_family = AF_UNSPEC;
656 	t->tca__pad1 = 0;
657 	t->tca__pad2 = 0;
658 
659 	nest = nla_nest_start(skb, TCA_ACT_TAB);
660 	if (nest == NULL)
661 		goto nla_put_failure;
662 
663 	if (tcf_action_dump(skb, a, bind, ref) < 0)
664 		goto nla_put_failure;
665 
666 	nla_nest_end(skb, nest);
667 
668 	nlh->nlmsg_len = skb_tail_pointer(skb) - b;
669 	return skb->len;
670 
671 nla_put_failure:
672 nlmsg_failure:
673 	nlmsg_trim(skb, b);
674 	return -1;
675 }
676 
677 static int
678 act_get_notify(struct net *net, u32 pid, struct nlmsghdr *n,
679 	       struct tc_action *a, int event)
680 {
681 	struct sk_buff *skb;
682 
683 	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
684 	if (!skb)
685 		return -ENOBUFS;
686 	if (tca_get_fill(skb, a, pid, n->nlmsg_seq, 0, event, 0, 0) <= 0) {
687 		kfree_skb(skb);
688 		return -EINVAL;
689 	}
690 
691 	return rtnl_unicast(skb, net, pid);
692 }
693 
694 static struct tc_action *
695 tcf_action_get_1(struct nlattr *nla, struct nlmsghdr *n, u32 pid)
696 {
697 	struct nlattr *tb[TCA_ACT_MAX + 1];
698 	struct tc_action *a;
699 	int index;
700 	int err;
701 
702 	err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL);
703 	if (err < 0)
704 		goto err_out;
705 
706 	err = -EINVAL;
707 	if (tb[TCA_ACT_INDEX] == NULL ||
708 	    nla_len(tb[TCA_ACT_INDEX]) < sizeof(index))
709 		goto err_out;
710 	index = nla_get_u32(tb[TCA_ACT_INDEX]);
711 
712 	err = -ENOMEM;
713 	a = kzalloc(sizeof(struct tc_action), GFP_KERNEL);
714 	if (a == NULL)
715 		goto err_out;
716 
717 	err = -EINVAL;
718 	a->ops = tc_lookup_action(tb[TCA_ACT_KIND]);
719 	if (a->ops == NULL)
720 		goto err_free;
721 	if (a->ops->lookup == NULL)
722 		goto err_mod;
723 	err = -ENOENT;
724 	if (a->ops->lookup(a, index) == 0)
725 		goto err_mod;
726 
727 	module_put(a->ops->owner);
728 	return a;
729 
730 err_mod:
731 	module_put(a->ops->owner);
732 err_free:
733 	kfree(a);
734 err_out:
735 	return ERR_PTR(err);
736 }
737 
738 static void cleanup_a(struct tc_action *act)
739 {
740 	struct tc_action *a;
741 
742 	for (a = act; a; a = act) {
743 		act = a->next;
744 		kfree(a);
745 	}
746 }
747 
748 static struct tc_action *create_a(int i)
749 {
750 	struct tc_action *act;
751 
752 	act = kzalloc(sizeof(*act), GFP_KERNEL);
753 	if (act == NULL) {
754 		pr_debug("create_a: failed to alloc!\n");
755 		return NULL;
756 	}
757 	act->order = i;
758 	return act;
759 }
760 
761 static int tca_action_flush(struct net *net, struct nlattr *nla,
762 			    struct nlmsghdr *n, u32 pid)
763 {
764 	struct sk_buff *skb;
765 	unsigned char *b;
766 	struct nlmsghdr *nlh;
767 	struct tcamsg *t;
768 	struct netlink_callback dcb;
769 	struct nlattr *nest;
770 	struct nlattr *tb[TCA_ACT_MAX + 1];
771 	struct nlattr *kind;
772 	struct tc_action *a = create_a(0);
773 	int err = -ENOMEM;
774 
775 	if (a == NULL) {
776 		pr_debug("tca_action_flush: couldnt create tc_action\n");
777 		return err;
778 	}
779 
780 	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
781 	if (!skb) {
782 		pr_debug("tca_action_flush: failed skb alloc\n");
783 		kfree(a);
784 		return err;
785 	}
786 
787 	b = skb_tail_pointer(skb);
788 
789 	err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL);
790 	if (err < 0)
791 		goto err_out;
792 
793 	err = -EINVAL;
794 	kind = tb[TCA_ACT_KIND];
795 	a->ops = tc_lookup_action(kind);
796 	if (a->ops == NULL)
797 		goto err_out;
798 
799 	nlh = NLMSG_PUT(skb, pid, n->nlmsg_seq, RTM_DELACTION, sizeof(*t));
800 	t = NLMSG_DATA(nlh);
801 	t->tca_family = AF_UNSPEC;
802 	t->tca__pad1 = 0;
803 	t->tca__pad2 = 0;
804 
805 	nest = nla_nest_start(skb, TCA_ACT_TAB);
806 	if (nest == NULL)
807 		goto nla_put_failure;
808 
809 	err = a->ops->walk(skb, &dcb, RTM_DELACTION, a);
810 	if (err < 0)
811 		goto nla_put_failure;
812 	if (err == 0)
813 		goto noflush_out;
814 
815 	nla_nest_end(skb, nest);
816 
817 	nlh->nlmsg_len = skb_tail_pointer(skb) - b;
818 	nlh->nlmsg_flags |= NLM_F_ROOT;
819 	module_put(a->ops->owner);
820 	kfree(a);
821 	err = rtnetlink_send(skb, net, pid, RTNLGRP_TC,
822 			     n->nlmsg_flags & NLM_F_ECHO);
823 	if (err > 0)
824 		return 0;
825 
826 	return err;
827 
828 nla_put_failure:
829 nlmsg_failure:
830 	module_put(a->ops->owner);
831 err_out:
832 noflush_out:
833 	kfree_skb(skb);
834 	kfree(a);
835 	return err;
836 }
837 
838 static int
839 tca_action_gd(struct net *net, struct nlattr *nla, struct nlmsghdr *n,
840 	      u32 pid, int event)
841 {
842 	int i, ret;
843 	struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
844 	struct tc_action *head = NULL, *act, *act_prev = NULL;
845 
846 	ret = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL);
847 	if (ret < 0)
848 		return ret;
849 
850 	if (event == RTM_DELACTION && n->nlmsg_flags & NLM_F_ROOT) {
851 		if (tb[1] != NULL)
852 			return tca_action_flush(net, tb[1], n, pid);
853 		else
854 			return -EINVAL;
855 	}
856 
857 	for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) {
858 		act = tcf_action_get_1(tb[i], n, pid);
859 		if (IS_ERR(act)) {
860 			ret = PTR_ERR(act);
861 			goto err;
862 		}
863 		act->order = i;
864 
865 		if (head == NULL)
866 			head = act;
867 		else
868 			act_prev->next = act;
869 		act_prev = act;
870 	}
871 
872 	if (event == RTM_GETACTION)
873 		ret = act_get_notify(net, pid, n, head, event);
874 	else { /* delete */
875 		struct sk_buff *skb;
876 
877 		skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
878 		if (!skb) {
879 			ret = -ENOBUFS;
880 			goto err;
881 		}
882 
883 		if (tca_get_fill(skb, head, pid, n->nlmsg_seq, 0, event,
884 				 0, 1) <= 0) {
885 			kfree_skb(skb);
886 			ret = -EINVAL;
887 			goto err;
888 		}
889 
890 		/* now do the delete */
891 		tcf_action_destroy(head, 0);
892 		ret = rtnetlink_send(skb, net, pid, RTNLGRP_TC,
893 				     n->nlmsg_flags & NLM_F_ECHO);
894 		if (ret > 0)
895 			return 0;
896 		return ret;
897 	}
898 err:
899 	cleanup_a(head);
900 	return ret;
901 }
902 
903 static int tcf_add_notify(struct net *net, struct tc_action *a,
904 			  u32 pid, u32 seq, int event, u16 flags)
905 {
906 	struct tcamsg *t;
907 	struct nlmsghdr *nlh;
908 	struct sk_buff *skb;
909 	struct nlattr *nest;
910 	unsigned char *b;
911 	int err = 0;
912 
913 	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
914 	if (!skb)
915 		return -ENOBUFS;
916 
917 	b = skb_tail_pointer(skb);
918 
919 	nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags);
920 	t = NLMSG_DATA(nlh);
921 	t->tca_family = AF_UNSPEC;
922 	t->tca__pad1 = 0;
923 	t->tca__pad2 = 0;
924 
925 	nest = nla_nest_start(skb, TCA_ACT_TAB);
926 	if (nest == NULL)
927 		goto nla_put_failure;
928 
929 	if (tcf_action_dump(skb, a, 0, 0) < 0)
930 		goto nla_put_failure;
931 
932 	nla_nest_end(skb, nest);
933 
934 	nlh->nlmsg_len = skb_tail_pointer(skb) - b;
935 	NETLINK_CB(skb).dst_group = RTNLGRP_TC;
936 
937 	err = rtnetlink_send(skb, net, pid, RTNLGRP_TC, flags & NLM_F_ECHO);
938 	if (err > 0)
939 		err = 0;
940 	return err;
941 
942 nla_put_failure:
943 nlmsg_failure:
944 	kfree_skb(skb);
945 	return -1;
946 }
947 
948 
949 static int
950 tcf_action_add(struct net *net, struct nlattr *nla, struct nlmsghdr *n,
951 	       u32 pid, int ovr)
952 {
953 	int ret = 0;
954 	struct tc_action *act;
955 	struct tc_action *a;
956 	u32 seq = n->nlmsg_seq;
957 
958 	act = tcf_action_init(nla, NULL, NULL, ovr, 0);
959 	if (act == NULL)
960 		goto done;
961 	if (IS_ERR(act)) {
962 		ret = PTR_ERR(act);
963 		goto done;
964 	}
965 
966 	/* dump then free all the actions after update; inserted policy
967 	 * stays intact
968 	 */
969 	ret = tcf_add_notify(net, act, pid, seq, RTM_NEWACTION, n->nlmsg_flags);
970 	for (a = act; a; a = act) {
971 		act = a->next;
972 		kfree(a);
973 	}
974 done:
975 	return ret;
976 }
977 
978 static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
979 {
980 	struct net *net = sock_net(skb->sk);
981 	struct nlattr *tca[TCA_ACT_MAX + 1];
982 	u32 pid = skb ? NETLINK_CB(skb).pid : 0;
983 	int ret = 0, ovr = 0;
984 
985 	ret = nlmsg_parse(n, sizeof(struct tcamsg), tca, TCA_ACT_MAX, NULL);
986 	if (ret < 0)
987 		return ret;
988 
989 	if (tca[TCA_ACT_TAB] == NULL) {
990 		pr_notice("tc_ctl_action: received NO action attribs\n");
991 		return -EINVAL;
992 	}
993 
994 	/* n->nlmsg_flags & NLM_F_CREATE */
995 	switch (n->nlmsg_type) {
996 	case RTM_NEWACTION:
997 		/* we are going to assume all other flags
998 		 * imply create only if it doesn't exist
999 		 * Note that CREATE | EXCL implies that
1000 		 * but since we want avoid ambiguity (eg when flags
1001 		 * is zero) then just set this
1002 		 */
1003 		if (n->nlmsg_flags & NLM_F_REPLACE)
1004 			ovr = 1;
1005 replay:
1006 		ret = tcf_action_add(net, tca[TCA_ACT_TAB], n, pid, ovr);
1007 		if (ret == -EAGAIN)
1008 			goto replay;
1009 		break;
1010 	case RTM_DELACTION:
1011 		ret = tca_action_gd(net, tca[TCA_ACT_TAB], n,
1012 				    pid, RTM_DELACTION);
1013 		break;
1014 	case RTM_GETACTION:
1015 		ret = tca_action_gd(net, tca[TCA_ACT_TAB], n,
1016 				    pid, RTM_GETACTION);
1017 		break;
1018 	default:
1019 		BUG();
1020 	}
1021 
1022 	return ret;
1023 }
1024 
1025 static struct nlattr *
1026 find_dump_kind(const struct nlmsghdr *n)
1027 {
1028 	struct nlattr *tb1, *tb2[TCA_ACT_MAX + 1];
1029 	struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
1030 	struct nlattr *nla[TCAA_MAX + 1];
1031 	struct nlattr *kind;
1032 
1033 	if (nlmsg_parse(n, sizeof(struct tcamsg), nla, TCAA_MAX, NULL) < 0)
1034 		return NULL;
1035 	tb1 = nla[TCA_ACT_TAB];
1036 	if (tb1 == NULL)
1037 		return NULL;
1038 
1039 	if (nla_parse(tb, TCA_ACT_MAX_PRIO, nla_data(tb1),
1040 		      NLMSG_ALIGN(nla_len(tb1)), NULL) < 0)
1041 		return NULL;
1042 
1043 	if (tb[1] == NULL)
1044 		return NULL;
1045 	if (nla_parse(tb2, TCA_ACT_MAX, nla_data(tb[1]),
1046 		      nla_len(tb[1]), NULL) < 0)
1047 		return NULL;
1048 	kind = tb2[TCA_ACT_KIND];
1049 
1050 	return kind;
1051 }
1052 
1053 static int
1054 tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb)
1055 {
1056 	struct nlmsghdr *nlh;
1057 	unsigned char *b = skb_tail_pointer(skb);
1058 	struct nlattr *nest;
1059 	struct tc_action_ops *a_o;
1060 	struct tc_action a;
1061 	int ret = 0;
1062 	struct tcamsg *t = (struct tcamsg *) NLMSG_DATA(cb->nlh);
1063 	struct nlattr *kind = find_dump_kind(cb->nlh);
1064 
1065 	if (kind == NULL) {
1066 		pr_info("tc_dump_action: action bad kind\n");
1067 		return 0;
1068 	}
1069 
1070 	a_o = tc_lookup_action(kind);
1071 	if (a_o == NULL)
1072 		return 0;
1073 
1074 	memset(&a, 0, sizeof(struct tc_action));
1075 	a.ops = a_o;
1076 
1077 	if (a_o->walk == NULL) {
1078 		WARN(1, "tc_dump_action: %s !capable of dumping table\n",
1079 		     a_o->kind);
1080 		goto nla_put_failure;
1081 	}
1082 
1083 	nlh = NLMSG_PUT(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
1084 			cb->nlh->nlmsg_type, sizeof(*t));
1085 	t = NLMSG_DATA(nlh);
1086 	t->tca_family = AF_UNSPEC;
1087 	t->tca__pad1 = 0;
1088 	t->tca__pad2 = 0;
1089 
1090 	nest = nla_nest_start(skb, TCA_ACT_TAB);
1091 	if (nest == NULL)
1092 		goto nla_put_failure;
1093 
1094 	ret = a_o->walk(skb, cb, RTM_GETACTION, &a);
1095 	if (ret < 0)
1096 		goto nla_put_failure;
1097 
1098 	if (ret > 0) {
1099 		nla_nest_end(skb, nest);
1100 		ret = skb->len;
1101 	} else
1102 		nla_nest_cancel(skb, nest);
1103 
1104 	nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1105 	if (NETLINK_CB(cb->skb).pid && ret)
1106 		nlh->nlmsg_flags |= NLM_F_MULTI;
1107 	module_put(a_o->owner);
1108 	return skb->len;
1109 
1110 nla_put_failure:
1111 nlmsg_failure:
1112 	module_put(a_o->owner);
1113 	nlmsg_trim(skb, b);
1114 	return skb->len;
1115 }
1116 
1117 static int __init tc_action_init(void)
1118 {
1119 	rtnl_register(PF_UNSPEC, RTM_NEWACTION, tc_ctl_action, NULL, NULL);
1120 	rtnl_register(PF_UNSPEC, RTM_DELACTION, tc_ctl_action, NULL, NULL);
1121 	rtnl_register(PF_UNSPEC, RTM_GETACTION, tc_ctl_action, tc_dump_action,
1122 		      NULL);
1123 
1124 	return 0;
1125 }
1126 
1127 subsys_initcall(tc_action_init);
1128