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_STRING }, 836 [TCA_ACT_INDEX] = { .type = NLA_U32 }, 837 [TCA_ACT_COOKIE] = { .type = NLA_BINARY, 838 .len = TC_COOKIE_MAX_SIZE }, 839 [TCA_ACT_OPTIONS] = { .type = NLA_NESTED }, 840 }; 841 842 struct tc_action *tcf_action_init_1(struct net *net, struct tcf_proto *tp, 843 struct nlattr *nla, struct nlattr *est, 844 char *name, int ovr, int bind, 845 bool rtnl_held, 846 struct netlink_ext_ack *extack) 847 { 848 struct tc_action *a; 849 struct tc_action_ops *a_o; 850 struct tc_cookie *cookie = NULL; 851 char act_name[IFNAMSIZ]; 852 struct nlattr *tb[TCA_ACT_MAX + 1]; 853 struct nlattr *kind; 854 int err; 855 856 if (name == NULL) { 857 err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla, 858 tcf_action_policy, extack); 859 if (err < 0) 860 goto err_out; 861 err = -EINVAL; 862 kind = tb[TCA_ACT_KIND]; 863 if (!kind) { 864 NL_SET_ERR_MSG(extack, "TC action kind must be specified"); 865 goto err_out; 866 } 867 if (nla_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ) { 868 NL_SET_ERR_MSG(extack, "TC action name too long"); 869 goto err_out; 870 } 871 if (tb[TCA_ACT_COOKIE]) { 872 cookie = nla_memdup_cookie(tb); 873 if (!cookie) { 874 NL_SET_ERR_MSG(extack, "No memory to generate TC cookie"); 875 err = -ENOMEM; 876 goto err_out; 877 } 878 } 879 } else { 880 if (strlcpy(act_name, name, IFNAMSIZ) >= IFNAMSIZ) { 881 NL_SET_ERR_MSG(extack, "TC action name too long"); 882 err = -EINVAL; 883 goto err_out; 884 } 885 } 886 887 a_o = tc_lookup_action_n(act_name); 888 if (a_o == NULL) { 889 #ifdef CONFIG_MODULES 890 if (rtnl_held) 891 rtnl_unlock(); 892 request_module("act_%s", act_name); 893 if (rtnl_held) 894 rtnl_lock(); 895 896 a_o = tc_lookup_action_n(act_name); 897 898 /* We dropped the RTNL semaphore in order to 899 * perform the module load. So, even if we 900 * succeeded in loading the module we have to 901 * tell the caller to replay the request. We 902 * indicate this using -EAGAIN. 903 */ 904 if (a_o != NULL) { 905 err = -EAGAIN; 906 goto err_mod; 907 } 908 #endif 909 NL_SET_ERR_MSG(extack, "Failed to load TC action module"); 910 err = -ENOENT; 911 goto err_out; 912 } 913 914 /* backward compatibility for policer */ 915 if (name == NULL) 916 err = a_o->init(net, tb[TCA_ACT_OPTIONS], est, &a, ovr, bind, 917 rtnl_held, tp, extack); 918 else 919 err = a_o->init(net, nla, est, &a, ovr, bind, rtnl_held, 920 tp, extack); 921 if (err < 0) 922 goto err_mod; 923 924 if (!name && tb[TCA_ACT_COOKIE]) 925 tcf_set_action_cookie(&a->act_cookie, cookie); 926 927 /* module count goes up only when brand new policy is created 928 * if it exists and is only bound to in a_o->init() then 929 * ACT_P_CREATED is not returned (a zero is). 930 */ 931 if (err != ACT_P_CREATED) 932 module_put(a_o->owner); 933 934 if (TC_ACT_EXT_CMP(a->tcfa_action, TC_ACT_GOTO_CHAIN) && 935 !rcu_access_pointer(a->goto_chain)) { 936 tcf_action_destroy_1(a, bind); 937 NL_SET_ERR_MSG(extack, "can't use goto chain with NULL chain"); 938 return ERR_PTR(-EINVAL); 939 } 940 941 return a; 942 943 err_mod: 944 module_put(a_o->owner); 945 err_out: 946 if (cookie) { 947 kfree(cookie->data); 948 kfree(cookie); 949 } 950 return ERR_PTR(err); 951 } 952 953 /* Returns numbers of initialized actions or negative error. */ 954 955 int tcf_action_init(struct net *net, struct tcf_proto *tp, struct nlattr *nla, 956 struct nlattr *est, char *name, int ovr, int bind, 957 struct tc_action *actions[], size_t *attr_size, 958 bool rtnl_held, struct netlink_ext_ack *extack) 959 { 960 struct nlattr *tb[TCA_ACT_MAX_PRIO + 1]; 961 struct tc_action *act; 962 size_t sz = 0; 963 int err; 964 int i; 965 966 err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX_PRIO, nla, NULL, 967 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_noflag(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_deprecated(tb, TCA_ACT_MAX, nla, 1103 tcf_action_policy, extack); 1104 if (err < 0) 1105 goto err_out; 1106 1107 err = -EINVAL; 1108 if (tb[TCA_ACT_INDEX] == NULL || 1109 nla_len(tb[TCA_ACT_INDEX]) < sizeof(index)) { 1110 NL_SET_ERR_MSG(extack, "Invalid TC action index value"); 1111 goto err_out; 1112 } 1113 index = nla_get_u32(tb[TCA_ACT_INDEX]); 1114 1115 err = -EINVAL; 1116 ops = tc_lookup_action(tb[TCA_ACT_KIND]); 1117 if (!ops) { /* could happen in batch of actions */ 1118 NL_SET_ERR_MSG(extack, "Specified TC action kind not found"); 1119 goto err_out; 1120 } 1121 err = -ENOENT; 1122 if (ops->lookup(net, &a, index) == 0) { 1123 NL_SET_ERR_MSG(extack, "TC action with specified index not found"); 1124 goto err_mod; 1125 } 1126 1127 module_put(ops->owner); 1128 return a; 1129 1130 err_mod: 1131 module_put(ops->owner); 1132 err_out: 1133 return ERR_PTR(err); 1134 } 1135 1136 static int tca_action_flush(struct net *net, struct nlattr *nla, 1137 struct nlmsghdr *n, u32 portid, 1138 struct netlink_ext_ack *extack) 1139 { 1140 struct sk_buff *skb; 1141 unsigned char *b; 1142 struct nlmsghdr *nlh; 1143 struct tcamsg *t; 1144 struct netlink_callback dcb; 1145 struct nlattr *nest; 1146 struct nlattr *tb[TCA_ACT_MAX + 1]; 1147 const struct tc_action_ops *ops; 1148 struct nlattr *kind; 1149 int err = -ENOMEM; 1150 1151 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); 1152 if (!skb) 1153 return err; 1154 1155 b = skb_tail_pointer(skb); 1156 1157 err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla, 1158 tcf_action_policy, extack); 1159 if (err < 0) 1160 goto err_out; 1161 1162 err = -EINVAL; 1163 kind = tb[TCA_ACT_KIND]; 1164 ops = tc_lookup_action(kind); 1165 if (!ops) { /*some idjot trying to flush unknown action */ 1166 NL_SET_ERR_MSG(extack, "Cannot flush unknown TC action"); 1167 goto err_out; 1168 } 1169 1170 nlh = nlmsg_put(skb, portid, n->nlmsg_seq, RTM_DELACTION, 1171 sizeof(*t), 0); 1172 if (!nlh) { 1173 NL_SET_ERR_MSG(extack, "Failed to create TC action flush notification"); 1174 goto out_module_put; 1175 } 1176 t = nlmsg_data(nlh); 1177 t->tca_family = AF_UNSPEC; 1178 t->tca__pad1 = 0; 1179 t->tca__pad2 = 0; 1180 1181 nest = nla_nest_start_noflag(skb, TCA_ACT_TAB); 1182 if (!nest) { 1183 NL_SET_ERR_MSG(extack, "Failed to add new netlink message"); 1184 goto out_module_put; 1185 } 1186 1187 err = ops->walk(net, skb, &dcb, RTM_DELACTION, ops, extack); 1188 if (err <= 0) { 1189 nla_nest_cancel(skb, nest); 1190 goto out_module_put; 1191 } 1192 1193 nla_nest_end(skb, nest); 1194 1195 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 1196 nlh->nlmsg_flags |= NLM_F_ROOT; 1197 module_put(ops->owner); 1198 err = rtnetlink_send(skb, net, portid, RTNLGRP_TC, 1199 n->nlmsg_flags & NLM_F_ECHO); 1200 if (err > 0) 1201 return 0; 1202 if (err < 0) 1203 NL_SET_ERR_MSG(extack, "Failed to send TC action flush notification"); 1204 1205 return err; 1206 1207 out_module_put: 1208 module_put(ops->owner); 1209 err_out: 1210 kfree_skb(skb); 1211 return err; 1212 } 1213 1214 static int tcf_action_delete(struct net *net, struct tc_action *actions[]) 1215 { 1216 int i; 1217 1218 for (i = 0; i < TCA_ACT_MAX_PRIO && actions[i]; i++) { 1219 struct tc_action *a = actions[i]; 1220 const struct tc_action_ops *ops = a->ops; 1221 /* Actions can be deleted concurrently so we must save their 1222 * type and id to search again after reference is released. 1223 */ 1224 struct tcf_idrinfo *idrinfo = a->idrinfo; 1225 u32 act_index = a->tcfa_index; 1226 1227 actions[i] = NULL; 1228 if (tcf_action_put(a)) { 1229 /* last reference, action was deleted concurrently */ 1230 module_put(ops->owner); 1231 } else { 1232 int ret; 1233 1234 /* now do the delete */ 1235 ret = tcf_idr_delete_index(idrinfo, act_index); 1236 if (ret < 0) 1237 return ret; 1238 } 1239 } 1240 return 0; 1241 } 1242 1243 static int 1244 tcf_del_notify(struct net *net, struct nlmsghdr *n, struct tc_action *actions[], 1245 u32 portid, size_t attr_size, struct netlink_ext_ack *extack) 1246 { 1247 int ret; 1248 struct sk_buff *skb; 1249 1250 skb = alloc_skb(attr_size <= NLMSG_GOODSIZE ? NLMSG_GOODSIZE : attr_size, 1251 GFP_KERNEL); 1252 if (!skb) 1253 return -ENOBUFS; 1254 1255 if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, 0, RTM_DELACTION, 1256 0, 2) <= 0) { 1257 NL_SET_ERR_MSG(extack, "Failed to fill netlink TC action attributes"); 1258 kfree_skb(skb); 1259 return -EINVAL; 1260 } 1261 1262 /* now do the delete */ 1263 ret = tcf_action_delete(net, actions); 1264 if (ret < 0) { 1265 NL_SET_ERR_MSG(extack, "Failed to delete TC action"); 1266 kfree_skb(skb); 1267 return ret; 1268 } 1269 1270 ret = rtnetlink_send(skb, net, portid, RTNLGRP_TC, 1271 n->nlmsg_flags & NLM_F_ECHO); 1272 if (ret > 0) 1273 return 0; 1274 return ret; 1275 } 1276 1277 static int 1278 tca_action_gd(struct net *net, struct nlattr *nla, struct nlmsghdr *n, 1279 u32 portid, int event, struct netlink_ext_ack *extack) 1280 { 1281 int i, ret; 1282 struct nlattr *tb[TCA_ACT_MAX_PRIO + 1]; 1283 struct tc_action *act; 1284 size_t attr_size = 0; 1285 struct tc_action *actions[TCA_ACT_MAX_PRIO] = {}; 1286 1287 ret = nla_parse_nested_deprecated(tb, TCA_ACT_MAX_PRIO, nla, NULL, 1288 extack); 1289 if (ret < 0) 1290 return ret; 1291 1292 if (event == RTM_DELACTION && n->nlmsg_flags & NLM_F_ROOT) { 1293 if (tb[1]) 1294 return tca_action_flush(net, tb[1], n, portid, extack); 1295 1296 NL_SET_ERR_MSG(extack, "Invalid netlink attributes while flushing TC action"); 1297 return -EINVAL; 1298 } 1299 1300 for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) { 1301 act = tcf_action_get_1(net, tb[i], n, portid, extack); 1302 if (IS_ERR(act)) { 1303 ret = PTR_ERR(act); 1304 goto err; 1305 } 1306 attr_size += tcf_action_fill_size(act); 1307 actions[i - 1] = act; 1308 } 1309 1310 attr_size = tcf_action_full_attrs_size(attr_size); 1311 1312 if (event == RTM_GETACTION) 1313 ret = tcf_get_notify(net, portid, n, actions, event, extack); 1314 else { /* delete */ 1315 ret = tcf_del_notify(net, n, actions, portid, attr_size, extack); 1316 if (ret) 1317 goto err; 1318 return 0; 1319 } 1320 err: 1321 tcf_action_put_many(actions); 1322 return ret; 1323 } 1324 1325 static int 1326 tcf_add_notify(struct net *net, struct nlmsghdr *n, struct tc_action *actions[], 1327 u32 portid, size_t attr_size, struct netlink_ext_ack *extack) 1328 { 1329 struct sk_buff *skb; 1330 int err = 0; 1331 1332 skb = alloc_skb(attr_size <= NLMSG_GOODSIZE ? NLMSG_GOODSIZE : attr_size, 1333 GFP_KERNEL); 1334 if (!skb) 1335 return -ENOBUFS; 1336 1337 if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, n->nlmsg_flags, 1338 RTM_NEWACTION, 0, 0) <= 0) { 1339 NL_SET_ERR_MSG(extack, "Failed to fill netlink attributes while adding TC action"); 1340 kfree_skb(skb); 1341 return -EINVAL; 1342 } 1343 1344 err = rtnetlink_send(skb, net, portid, RTNLGRP_TC, 1345 n->nlmsg_flags & NLM_F_ECHO); 1346 if (err > 0) 1347 err = 0; 1348 return err; 1349 } 1350 1351 static int tcf_action_add(struct net *net, struct nlattr *nla, 1352 struct nlmsghdr *n, u32 portid, int ovr, 1353 struct netlink_ext_ack *extack) 1354 { 1355 size_t attr_size = 0; 1356 int loop, ret; 1357 struct tc_action *actions[TCA_ACT_MAX_PRIO] = {}; 1358 1359 for (loop = 0; loop < 10; loop++) { 1360 ret = tcf_action_init(net, NULL, nla, NULL, NULL, ovr, 0, 1361 actions, &attr_size, true, extack); 1362 if (ret != -EAGAIN) 1363 break; 1364 } 1365 1366 if (ret < 0) 1367 return ret; 1368 ret = tcf_add_notify(net, n, actions, portid, attr_size, extack); 1369 if (ovr) 1370 tcf_action_put_many(actions); 1371 1372 return ret; 1373 } 1374 1375 static u32 tcaa_root_flags_allowed = TCA_FLAG_LARGE_DUMP_ON; 1376 static const struct nla_policy tcaa_policy[TCA_ROOT_MAX + 1] = { 1377 [TCA_ROOT_FLAGS] = { .type = NLA_BITFIELD32, 1378 .validation_data = &tcaa_root_flags_allowed }, 1379 [TCA_ROOT_TIME_DELTA] = { .type = NLA_U32 }, 1380 }; 1381 1382 static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n, 1383 struct netlink_ext_ack *extack) 1384 { 1385 struct net *net = sock_net(skb->sk); 1386 struct nlattr *tca[TCA_ROOT_MAX + 1]; 1387 u32 portid = skb ? NETLINK_CB(skb).portid : 0; 1388 int ret = 0, ovr = 0; 1389 1390 if ((n->nlmsg_type != RTM_GETACTION) && 1391 !netlink_capable(skb, CAP_NET_ADMIN)) 1392 return -EPERM; 1393 1394 ret = nlmsg_parse_deprecated(n, sizeof(struct tcamsg), tca, 1395 TCA_ROOT_MAX, NULL, extack); 1396 if (ret < 0) 1397 return ret; 1398 1399 if (tca[TCA_ACT_TAB] == NULL) { 1400 NL_SET_ERR_MSG(extack, "Netlink action attributes missing"); 1401 return -EINVAL; 1402 } 1403 1404 /* n->nlmsg_flags & NLM_F_CREATE */ 1405 switch (n->nlmsg_type) { 1406 case RTM_NEWACTION: 1407 /* we are going to assume all other flags 1408 * imply create only if it doesn't exist 1409 * Note that CREATE | EXCL implies that 1410 * but since we want avoid ambiguity (eg when flags 1411 * is zero) then just set this 1412 */ 1413 if (n->nlmsg_flags & NLM_F_REPLACE) 1414 ovr = 1; 1415 ret = tcf_action_add(net, tca[TCA_ACT_TAB], n, portid, ovr, 1416 extack); 1417 break; 1418 case RTM_DELACTION: 1419 ret = tca_action_gd(net, tca[TCA_ACT_TAB], n, 1420 portid, RTM_DELACTION, extack); 1421 break; 1422 case RTM_GETACTION: 1423 ret = tca_action_gd(net, tca[TCA_ACT_TAB], n, 1424 portid, RTM_GETACTION, extack); 1425 break; 1426 default: 1427 BUG(); 1428 } 1429 1430 return ret; 1431 } 1432 1433 static struct nlattr *find_dump_kind(struct nlattr **nla) 1434 { 1435 struct nlattr *tb1, *tb2[TCA_ACT_MAX + 1]; 1436 struct nlattr *tb[TCA_ACT_MAX_PRIO + 1]; 1437 struct nlattr *kind; 1438 1439 tb1 = nla[TCA_ACT_TAB]; 1440 if (tb1 == NULL) 1441 return NULL; 1442 1443 if (nla_parse_deprecated(tb, TCA_ACT_MAX_PRIO, nla_data(tb1), NLMSG_ALIGN(nla_len(tb1)), NULL, NULL) < 0) 1444 return NULL; 1445 1446 if (tb[1] == NULL) 1447 return NULL; 1448 if (nla_parse_nested_deprecated(tb2, TCA_ACT_MAX, tb[1], tcf_action_policy, NULL) < 0) 1449 return NULL; 1450 kind = tb2[TCA_ACT_KIND]; 1451 1452 return kind; 1453 } 1454 1455 static int tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb) 1456 { 1457 struct net *net = sock_net(skb->sk); 1458 struct nlmsghdr *nlh; 1459 unsigned char *b = skb_tail_pointer(skb); 1460 struct nlattr *nest; 1461 struct tc_action_ops *a_o; 1462 int ret = 0; 1463 struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); 1464 struct nlattr *tb[TCA_ROOT_MAX + 1]; 1465 struct nlattr *count_attr = NULL; 1466 unsigned long jiffy_since = 0; 1467 struct nlattr *kind = NULL; 1468 struct nla_bitfield32 bf; 1469 u32 msecs_since = 0; 1470 u32 act_count = 0; 1471 1472 ret = nlmsg_parse_deprecated(cb->nlh, sizeof(struct tcamsg), tb, 1473 TCA_ROOT_MAX, tcaa_policy, cb->extack); 1474 if (ret < 0) 1475 return ret; 1476 1477 kind = find_dump_kind(tb); 1478 if (kind == NULL) { 1479 pr_info("tc_dump_action: action bad kind\n"); 1480 return 0; 1481 } 1482 1483 a_o = tc_lookup_action(kind); 1484 if (a_o == NULL) 1485 return 0; 1486 1487 cb->args[2] = 0; 1488 if (tb[TCA_ROOT_FLAGS]) { 1489 bf = nla_get_bitfield32(tb[TCA_ROOT_FLAGS]); 1490 cb->args[2] = bf.value; 1491 } 1492 1493 if (tb[TCA_ROOT_TIME_DELTA]) { 1494 msecs_since = nla_get_u32(tb[TCA_ROOT_TIME_DELTA]); 1495 } 1496 1497 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 1498 cb->nlh->nlmsg_type, sizeof(*t), 0); 1499 if (!nlh) 1500 goto out_module_put; 1501 1502 if (msecs_since) 1503 jiffy_since = jiffies - msecs_to_jiffies(msecs_since); 1504 1505 t = nlmsg_data(nlh); 1506 t->tca_family = AF_UNSPEC; 1507 t->tca__pad1 = 0; 1508 t->tca__pad2 = 0; 1509 cb->args[3] = jiffy_since; 1510 count_attr = nla_reserve(skb, TCA_ROOT_COUNT, sizeof(u32)); 1511 if (!count_attr) 1512 goto out_module_put; 1513 1514 nest = nla_nest_start_noflag(skb, TCA_ACT_TAB); 1515 if (nest == NULL) 1516 goto out_module_put; 1517 1518 ret = a_o->walk(net, skb, cb, RTM_GETACTION, a_o, NULL); 1519 if (ret < 0) 1520 goto out_module_put; 1521 1522 if (ret > 0) { 1523 nla_nest_end(skb, nest); 1524 ret = skb->len; 1525 act_count = cb->args[1]; 1526 memcpy(nla_data(count_attr), &act_count, sizeof(u32)); 1527 cb->args[1] = 0; 1528 } else 1529 nlmsg_trim(skb, b); 1530 1531 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 1532 if (NETLINK_CB(cb->skb).portid && ret) 1533 nlh->nlmsg_flags |= NLM_F_MULTI; 1534 module_put(a_o->owner); 1535 return skb->len; 1536 1537 out_module_put: 1538 module_put(a_o->owner); 1539 nlmsg_trim(skb, b); 1540 return skb->len; 1541 } 1542 1543 static int __init tc_action_init(void) 1544 { 1545 rtnl_register(PF_UNSPEC, RTM_NEWACTION, tc_ctl_action, NULL, 0); 1546 rtnl_register(PF_UNSPEC, RTM_DELACTION, tc_ctl_action, NULL, 0); 1547 rtnl_register(PF_UNSPEC, RTM_GETACTION, tc_ctl_action, tc_dump_action, 1548 0); 1549 1550 return 0; 1551 } 1552 1553 subsys_initcall(tc_action_init); 1554