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