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