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