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