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 <net/net_namespace.h> 24 #include <net/sock.h> 25 #include <net/sch_generic.h> 26 #include <net/act_api.h> 27 #include <net/netlink.h> 28 29 static void tcf_common_free_rcu(struct rcu_head *head) 30 { 31 kfree(container_of(head, struct tcf_common, tcfc_rcu)); 32 } 33 34 void tcf_hash_destroy(struct tcf_common *p, struct tcf_hashinfo *hinfo) 35 { 36 unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask); 37 struct tcf_common **p1p; 38 39 for (p1p = &hinfo->htab[h]; *p1p; p1p = &(*p1p)->tcfc_next) { 40 if (*p1p == p) { 41 write_lock_bh(hinfo->lock); 42 *p1p = p->tcfc_next; 43 write_unlock_bh(hinfo->lock); 44 gen_kill_estimator(&p->tcfc_bstats, 45 &p->tcfc_rate_est); 46 /* 47 * gen_estimator est_timer() might access p->tcfc_lock 48 * or bstats, wait a RCU grace period before freeing p 49 */ 50 call_rcu(&p->tcfc_rcu, tcf_common_free_rcu); 51 return; 52 } 53 } 54 WARN_ON(1); 55 } 56 EXPORT_SYMBOL(tcf_hash_destroy); 57 58 int tcf_hash_release(struct tcf_common *p, int bind, 59 struct tcf_hashinfo *hinfo) 60 { 61 int ret = 0; 62 63 if (p) { 64 if (bind) 65 p->tcfc_bindcnt--; 66 67 p->tcfc_refcnt--; 68 if (p->tcfc_bindcnt <= 0 && p->tcfc_refcnt <= 0) { 69 tcf_hash_destroy(p, hinfo); 70 ret = 1; 71 } 72 } 73 return ret; 74 } 75 EXPORT_SYMBOL(tcf_hash_release); 76 77 static int tcf_dump_walker(struct sk_buff *skb, struct netlink_callback *cb, 78 struct tc_action *a, struct tcf_hashinfo *hinfo) 79 { 80 struct tcf_common *p; 81 int err = 0, index = -1,i = 0, s_i = 0, n_i = 0; 82 struct nlattr *nest; 83 84 read_lock_bh(hinfo->lock); 85 86 s_i = cb->args[0]; 87 88 for (i = 0; i < (hinfo->hmask + 1); i++) { 89 p = hinfo->htab[tcf_hash(i, hinfo->hmask)]; 90 91 for (; p; p = p->tcfc_next) { 92 index++; 93 if (index < s_i) 94 continue; 95 a->priv = p; 96 a->order = n_i; 97 98 nest = nla_nest_start(skb, a->order); 99 if (nest == NULL) 100 goto nla_put_failure; 101 err = tcf_action_dump_1(skb, a, 0, 0); 102 if (err < 0) { 103 index--; 104 nlmsg_trim(skb, nest); 105 goto done; 106 } 107 nla_nest_end(skb, nest); 108 n_i++; 109 if (n_i >= TCA_ACT_MAX_PRIO) 110 goto done; 111 } 112 } 113 done: 114 read_unlock_bh(hinfo->lock); 115 if (n_i) 116 cb->args[0] += n_i; 117 return n_i; 118 119 nla_put_failure: 120 nla_nest_cancel(skb, nest); 121 goto done; 122 } 123 124 static int tcf_del_walker(struct sk_buff *skb, struct tc_action *a, 125 struct tcf_hashinfo *hinfo) 126 { 127 struct tcf_common *p, *s_p; 128 struct nlattr *nest; 129 int i= 0, n_i = 0; 130 131 nest = nla_nest_start(skb, a->order); 132 if (nest == NULL) 133 goto nla_put_failure; 134 NLA_PUT_STRING(skb, TCA_KIND, a->ops->kind); 135 for (i = 0; i < (hinfo->hmask + 1); i++) { 136 p = hinfo->htab[tcf_hash(i, hinfo->hmask)]; 137 138 while (p != NULL) { 139 s_p = p->tcfc_next; 140 if (ACT_P_DELETED == tcf_hash_release(p, 0, hinfo)) 141 module_put(a->ops->owner); 142 n_i++; 143 p = s_p; 144 } 145 } 146 NLA_PUT_U32(skb, TCA_FCNT, n_i); 147 nla_nest_end(skb, nest); 148 149 return n_i; 150 nla_put_failure: 151 nla_nest_cancel(skb, nest); 152 return -EINVAL; 153 } 154 155 int tcf_generic_walker(struct sk_buff *skb, struct netlink_callback *cb, 156 int type, struct tc_action *a) 157 { 158 struct tcf_hashinfo *hinfo = a->ops->hinfo; 159 160 if (type == RTM_DELACTION) { 161 return tcf_del_walker(skb, a, hinfo); 162 } else if (type == RTM_GETACTION) { 163 return tcf_dump_walker(skb, cb, a, hinfo); 164 } else { 165 WARN(1, "tcf_generic_walker: unknown action %d\n", type); 166 return -EINVAL; 167 } 168 } 169 EXPORT_SYMBOL(tcf_generic_walker); 170 171 struct tcf_common *tcf_hash_lookup(u32 index, struct tcf_hashinfo *hinfo) 172 { 173 struct tcf_common *p; 174 175 read_lock_bh(hinfo->lock); 176 for (p = hinfo->htab[tcf_hash(index, hinfo->hmask)]; p; 177 p = p->tcfc_next) { 178 if (p->tcfc_index == index) 179 break; 180 } 181 read_unlock_bh(hinfo->lock); 182 183 return p; 184 } 185 EXPORT_SYMBOL(tcf_hash_lookup); 186 187 u32 tcf_hash_new_index(u32 *idx_gen, struct tcf_hashinfo *hinfo) 188 { 189 u32 val = *idx_gen; 190 191 do { 192 if (++val == 0) 193 val = 1; 194 } while (tcf_hash_lookup(val, hinfo)); 195 196 return (*idx_gen = val); 197 } 198 EXPORT_SYMBOL(tcf_hash_new_index); 199 200 int tcf_hash_search(struct tc_action *a, u32 index) 201 { 202 struct tcf_hashinfo *hinfo = a->ops->hinfo; 203 struct tcf_common *p = tcf_hash_lookup(index, hinfo); 204 205 if (p) { 206 a->priv = p; 207 return 1; 208 } 209 return 0; 210 } 211 EXPORT_SYMBOL(tcf_hash_search); 212 213 struct tcf_common *tcf_hash_check(u32 index, struct tc_action *a, int bind, 214 struct tcf_hashinfo *hinfo) 215 { 216 struct tcf_common *p = NULL; 217 if (index && (p = tcf_hash_lookup(index, hinfo)) != NULL) { 218 if (bind) 219 p->tcfc_bindcnt++; 220 p->tcfc_refcnt++; 221 a->priv = p; 222 } 223 return p; 224 } 225 EXPORT_SYMBOL(tcf_hash_check); 226 227 struct tcf_common *tcf_hash_create(u32 index, struct nlattr *est, 228 struct tc_action *a, int size, int bind, 229 u32 *idx_gen, struct tcf_hashinfo *hinfo) 230 { 231 struct tcf_common *p = kzalloc(size, GFP_KERNEL); 232 233 if (unlikely(!p)) 234 return ERR_PTR(-ENOMEM); 235 p->tcfc_refcnt = 1; 236 if (bind) 237 p->tcfc_bindcnt = 1; 238 239 spin_lock_init(&p->tcfc_lock); 240 p->tcfc_index = index ? index : tcf_hash_new_index(idx_gen, hinfo); 241 p->tcfc_tm.install = jiffies; 242 p->tcfc_tm.lastuse = jiffies; 243 if (est) { 244 int err = gen_new_estimator(&p->tcfc_bstats, &p->tcfc_rate_est, 245 &p->tcfc_lock, est); 246 if (err) { 247 kfree(p); 248 return ERR_PTR(err); 249 } 250 } 251 252 a->priv = (void *) p; 253 return p; 254 } 255 EXPORT_SYMBOL(tcf_hash_create); 256 257 void tcf_hash_insert(struct tcf_common *p, struct tcf_hashinfo *hinfo) 258 { 259 unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask); 260 261 write_lock_bh(hinfo->lock); 262 p->tcfc_next = hinfo->htab[h]; 263 hinfo->htab[h] = p; 264 write_unlock_bh(hinfo->lock); 265 } 266 EXPORT_SYMBOL(tcf_hash_insert); 267 268 static struct tc_action_ops *act_base = NULL; 269 static DEFINE_RWLOCK(act_mod_lock); 270 271 int tcf_register_action(struct tc_action_ops *act) 272 { 273 struct tc_action_ops *a, **ap; 274 275 write_lock(&act_mod_lock); 276 for (ap = &act_base; (a = *ap) != NULL; ap = &a->next) { 277 if (act->type == a->type || (strcmp(act->kind, a->kind) == 0)) { 278 write_unlock(&act_mod_lock); 279 return -EEXIST; 280 } 281 } 282 act->next = NULL; 283 *ap = act; 284 write_unlock(&act_mod_lock); 285 return 0; 286 } 287 EXPORT_SYMBOL(tcf_register_action); 288 289 int tcf_unregister_action(struct tc_action_ops *act) 290 { 291 struct tc_action_ops *a, **ap; 292 int err = -ENOENT; 293 294 write_lock(&act_mod_lock); 295 for (ap = &act_base; (a = *ap) != NULL; ap = &a->next) 296 if (a == act) 297 break; 298 if (a) { 299 *ap = a->next; 300 a->next = NULL; 301 err = 0; 302 } 303 write_unlock(&act_mod_lock); 304 return err; 305 } 306 EXPORT_SYMBOL(tcf_unregister_action); 307 308 /* lookup by name */ 309 static struct tc_action_ops *tc_lookup_action_n(char *kind) 310 { 311 struct tc_action_ops *a = NULL; 312 313 if (kind) { 314 read_lock(&act_mod_lock); 315 for (a = act_base; a; a = a->next) { 316 if (strcmp(kind, a->kind) == 0) { 317 if (!try_module_get(a->owner)) { 318 read_unlock(&act_mod_lock); 319 return NULL; 320 } 321 break; 322 } 323 } 324 read_unlock(&act_mod_lock); 325 } 326 return a; 327 } 328 329 /* lookup by nlattr */ 330 static struct tc_action_ops *tc_lookup_action(struct nlattr *kind) 331 { 332 struct tc_action_ops *a = NULL; 333 334 if (kind) { 335 read_lock(&act_mod_lock); 336 for (a = act_base; a; a = a->next) { 337 if (nla_strcmp(kind, a->kind) == 0) { 338 if (!try_module_get(a->owner)) { 339 read_unlock(&act_mod_lock); 340 return NULL; 341 } 342 break; 343 } 344 } 345 read_unlock(&act_mod_lock); 346 } 347 return a; 348 } 349 350 #if 0 351 /* lookup by id */ 352 static struct tc_action_ops *tc_lookup_action_id(u32 type) 353 { 354 struct tc_action_ops *a = NULL; 355 356 if (type) { 357 read_lock(&act_mod_lock); 358 for (a = act_base; a; a = a->next) { 359 if (a->type == type) { 360 if (!try_module_get(a->owner)) { 361 read_unlock(&act_mod_lock); 362 return NULL; 363 } 364 break; 365 } 366 } 367 read_unlock(&act_mod_lock); 368 } 369 return a; 370 } 371 #endif 372 373 int tcf_action_exec(struct sk_buff *skb, struct tc_action *act, 374 struct tcf_result *res) 375 { 376 struct tc_action *a; 377 int ret = -1; 378 379 if (skb->tc_verd & TC_NCLS) { 380 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd); 381 ret = TC_ACT_OK; 382 goto exec_done; 383 } 384 while ((a = act) != NULL) { 385 repeat: 386 if (a->ops && a->ops->act) { 387 ret = a->ops->act(skb, a, res); 388 if (TC_MUNGED & skb->tc_verd) { 389 /* copied already, allow trampling */ 390 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd); 391 skb->tc_verd = CLR_TC_MUNGED(skb->tc_verd); 392 } 393 if (ret == TC_ACT_REPEAT) 394 goto repeat; /* we need a ttl - JHS */ 395 if (ret != TC_ACT_PIPE) 396 goto exec_done; 397 } 398 act = a->next; 399 } 400 exec_done: 401 return ret; 402 } 403 EXPORT_SYMBOL(tcf_action_exec); 404 405 void tcf_action_destroy(struct tc_action *act, int bind) 406 { 407 struct tc_action *a; 408 409 for (a = act; a; a = act) { 410 if (a->ops && a->ops->cleanup) { 411 if (a->ops->cleanup(a, bind) == ACT_P_DELETED) 412 module_put(a->ops->owner); 413 act = act->next; 414 kfree(a); 415 } else { 416 /*FIXME: Remove later - catch insertion bugs*/ 417 WARN(1, "tcf_action_destroy: BUG? destroying NULL ops\n"); 418 act = act->next; 419 kfree(a); 420 } 421 } 422 } 423 424 int 425 tcf_action_dump_old(struct sk_buff *skb, struct tc_action *a, int bind, int ref) 426 { 427 int err = -EINVAL; 428 429 if (a->ops == NULL || a->ops->dump == NULL) 430 return err; 431 return a->ops->dump(skb, a, bind, ref); 432 } 433 434 int 435 tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref) 436 { 437 int err = -EINVAL; 438 unsigned char *b = skb_tail_pointer(skb); 439 struct nlattr *nest; 440 441 if (a->ops == NULL || a->ops->dump == NULL) 442 return err; 443 444 NLA_PUT_STRING(skb, TCA_KIND, a->ops->kind); 445 if (tcf_action_copy_stats(skb, a, 0)) 446 goto nla_put_failure; 447 nest = nla_nest_start(skb, TCA_OPTIONS); 448 if (nest == NULL) 449 goto nla_put_failure; 450 if ((err = tcf_action_dump_old(skb, a, bind, ref)) > 0) { 451 nla_nest_end(skb, nest); 452 return err; 453 } 454 455 nla_put_failure: 456 nlmsg_trim(skb, b); 457 return -1; 458 } 459 EXPORT_SYMBOL(tcf_action_dump_1); 460 461 int 462 tcf_action_dump(struct sk_buff *skb, struct tc_action *act, int bind, int ref) 463 { 464 struct tc_action *a; 465 int err = -EINVAL; 466 struct nlattr *nest; 467 468 while ((a = act) != NULL) { 469 act = a->next; 470 nest = nla_nest_start(skb, a->order); 471 if (nest == NULL) 472 goto nla_put_failure; 473 err = tcf_action_dump_1(skb, a, bind, ref); 474 if (err < 0) 475 goto errout; 476 nla_nest_end(skb, nest); 477 } 478 479 return 0; 480 481 nla_put_failure: 482 err = -EINVAL; 483 errout: 484 nla_nest_cancel(skb, nest); 485 return err; 486 } 487 488 struct tc_action *tcf_action_init_1(struct nlattr *nla, struct nlattr *est, 489 char *name, int ovr, int bind) 490 { 491 struct tc_action *a; 492 struct tc_action_ops *a_o; 493 char act_name[IFNAMSIZ]; 494 struct nlattr *tb[TCA_ACT_MAX+1]; 495 struct nlattr *kind; 496 int err; 497 498 if (name == NULL) { 499 err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL); 500 if (err < 0) 501 goto err_out; 502 err = -EINVAL; 503 kind = tb[TCA_ACT_KIND]; 504 if (kind == NULL) 505 goto err_out; 506 if (nla_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ) 507 goto err_out; 508 } else { 509 err = -EINVAL; 510 if (strlcpy(act_name, name, IFNAMSIZ) >= IFNAMSIZ) 511 goto err_out; 512 } 513 514 a_o = tc_lookup_action_n(act_name); 515 if (a_o == NULL) { 516 #ifdef CONFIG_MODULES 517 rtnl_unlock(); 518 request_module("act_%s", act_name); 519 rtnl_lock(); 520 521 a_o = tc_lookup_action_n(act_name); 522 523 /* We dropped the RTNL semaphore in order to 524 * perform the module load. So, even if we 525 * succeeded in loading the module we have to 526 * tell the caller to replay the request. We 527 * indicate this using -EAGAIN. 528 */ 529 if (a_o != NULL) { 530 err = -EAGAIN; 531 goto err_mod; 532 } 533 #endif 534 err = -ENOENT; 535 goto err_out; 536 } 537 538 err = -ENOMEM; 539 a = kzalloc(sizeof(*a), GFP_KERNEL); 540 if (a == NULL) 541 goto err_mod; 542 543 /* backward compatibility for policer */ 544 if (name == NULL) 545 err = a_o->init(tb[TCA_ACT_OPTIONS], est, a, ovr, bind); 546 else 547 err = a_o->init(nla, est, a, ovr, bind); 548 if (err < 0) 549 goto err_free; 550 551 /* module count goes up only when brand new policy is created 552 if it exists and is only bound to in a_o->init() then 553 ACT_P_CREATED is not returned (a zero is). 554 */ 555 if (err != ACT_P_CREATED) 556 module_put(a_o->owner); 557 a->ops = a_o; 558 559 return a; 560 561 err_free: 562 kfree(a); 563 err_mod: 564 module_put(a_o->owner); 565 err_out: 566 return ERR_PTR(err); 567 } 568 569 struct tc_action *tcf_action_init(struct nlattr *nla, struct nlattr *est, 570 char *name, int ovr, int bind) 571 { 572 struct nlattr *tb[TCA_ACT_MAX_PRIO+1]; 573 struct tc_action *head = NULL, *act, *act_prev = NULL; 574 int err; 575 int i; 576 577 err = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL); 578 if (err < 0) 579 return ERR_PTR(err); 580 581 for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) { 582 act = tcf_action_init_1(tb[i], est, name, ovr, bind); 583 if (IS_ERR(act)) 584 goto err; 585 act->order = i; 586 587 if (head == NULL) 588 head = act; 589 else 590 act_prev->next = act; 591 act_prev = act; 592 } 593 return head; 594 595 err: 596 if (head != NULL) 597 tcf_action_destroy(head, bind); 598 return act; 599 } 600 601 int tcf_action_copy_stats(struct sk_buff *skb, struct tc_action *a, 602 int compat_mode) 603 { 604 int err = 0; 605 struct gnet_dump d; 606 struct tcf_act_hdr *h = a->priv; 607 608 if (h == NULL) 609 goto errout; 610 611 /* compat_mode being true specifies a call that is supposed 612 * to add additional backward compatibility statistic TLVs. 613 */ 614 if (compat_mode) { 615 if (a->type == TCA_OLD_COMPAT) 616 err = gnet_stats_start_copy_compat(skb, 0, 617 TCA_STATS, TCA_XSTATS, &h->tcf_lock, &d); 618 else 619 return 0; 620 } else 621 err = gnet_stats_start_copy(skb, TCA_ACT_STATS, 622 &h->tcf_lock, &d); 623 624 if (err < 0) 625 goto errout; 626 627 if (a->ops != NULL && a->ops->get_stats != NULL) 628 if (a->ops->get_stats(skb, a) < 0) 629 goto errout; 630 631 if (gnet_stats_copy_basic(&d, &h->tcf_bstats) < 0 || 632 gnet_stats_copy_rate_est(&d, &h->tcf_bstats, 633 &h->tcf_rate_est) < 0 || 634 gnet_stats_copy_queue(&d, &h->tcf_qstats) < 0) 635 goto errout; 636 637 if (gnet_stats_finish_copy(&d) < 0) 638 goto errout; 639 640 return 0; 641 642 errout: 643 return -1; 644 } 645 646 static int 647 tca_get_fill(struct sk_buff *skb, struct tc_action *a, u32 pid, u32 seq, 648 u16 flags, int event, int bind, int ref) 649 { 650 struct tcamsg *t; 651 struct nlmsghdr *nlh; 652 unsigned char *b = skb_tail_pointer(skb); 653 struct nlattr *nest; 654 655 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags); 656 657 t = NLMSG_DATA(nlh); 658 t->tca_family = AF_UNSPEC; 659 t->tca__pad1 = 0; 660 t->tca__pad2 = 0; 661 662 nest = nla_nest_start(skb, TCA_ACT_TAB); 663 if (nest == NULL) 664 goto nla_put_failure; 665 666 if (tcf_action_dump(skb, a, bind, ref) < 0) 667 goto nla_put_failure; 668 669 nla_nest_end(skb, nest); 670 671 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 672 return skb->len; 673 674 nla_put_failure: 675 nlmsg_failure: 676 nlmsg_trim(skb, b); 677 return -1; 678 } 679 680 static int 681 act_get_notify(struct net *net, u32 pid, struct nlmsghdr *n, 682 struct tc_action *a, int event) 683 { 684 struct sk_buff *skb; 685 686 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); 687 if (!skb) 688 return -ENOBUFS; 689 if (tca_get_fill(skb, a, pid, n->nlmsg_seq, 0, event, 0, 0) <= 0) { 690 kfree_skb(skb); 691 return -EINVAL; 692 } 693 694 return rtnl_unicast(skb, net, pid); 695 } 696 697 static struct tc_action * 698 tcf_action_get_1(struct nlattr *nla, struct nlmsghdr *n, u32 pid) 699 { 700 struct nlattr *tb[TCA_ACT_MAX+1]; 701 struct tc_action *a; 702 int index; 703 int err; 704 705 err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL); 706 if (err < 0) 707 goto err_out; 708 709 err = -EINVAL; 710 if (tb[TCA_ACT_INDEX] == NULL || 711 nla_len(tb[TCA_ACT_INDEX]) < sizeof(index)) 712 goto err_out; 713 index = nla_get_u32(tb[TCA_ACT_INDEX]); 714 715 err = -ENOMEM; 716 a = kzalloc(sizeof(struct tc_action), GFP_KERNEL); 717 if (a == NULL) 718 goto err_out; 719 720 err = -EINVAL; 721 a->ops = tc_lookup_action(tb[TCA_ACT_KIND]); 722 if (a->ops == NULL) 723 goto err_free; 724 if (a->ops->lookup == NULL) 725 goto err_mod; 726 err = -ENOENT; 727 if (a->ops->lookup(a, index) == 0) 728 goto err_mod; 729 730 module_put(a->ops->owner); 731 return a; 732 733 err_mod: 734 module_put(a->ops->owner); 735 err_free: 736 kfree(a); 737 err_out: 738 return ERR_PTR(err); 739 } 740 741 static void cleanup_a(struct tc_action *act) 742 { 743 struct tc_action *a; 744 745 for (a = act; a; a = act) { 746 act = a->next; 747 kfree(a); 748 } 749 } 750 751 static struct tc_action *create_a(int i) 752 { 753 struct tc_action *act; 754 755 act = kzalloc(sizeof(*act), GFP_KERNEL); 756 if (act == NULL) { 757 pr_debug("create_a: failed to alloc!\n"); 758 return NULL; 759 } 760 act->order = i; 761 return act; 762 } 763 764 static int tca_action_flush(struct net *net, struct nlattr *nla, 765 struct nlmsghdr *n, u32 pid) 766 { 767 struct sk_buff *skb; 768 unsigned char *b; 769 struct nlmsghdr *nlh; 770 struct tcamsg *t; 771 struct netlink_callback dcb; 772 struct nlattr *nest; 773 struct nlattr *tb[TCA_ACT_MAX+1]; 774 struct nlattr *kind; 775 struct tc_action *a = create_a(0); 776 int err = -ENOMEM; 777 778 if (a == NULL) { 779 pr_debug("tca_action_flush: couldnt create tc_action\n"); 780 return err; 781 } 782 783 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); 784 if (!skb) { 785 pr_debug("tca_action_flush: failed skb alloc\n"); 786 kfree(a); 787 return err; 788 } 789 790 b = skb_tail_pointer(skb); 791 792 err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL); 793 if (err < 0) 794 goto err_out; 795 796 err = -EINVAL; 797 kind = tb[TCA_ACT_KIND]; 798 a->ops = tc_lookup_action(kind); 799 if (a->ops == NULL) 800 goto err_out; 801 802 nlh = NLMSG_PUT(skb, pid, n->nlmsg_seq, RTM_DELACTION, sizeof(*t)); 803 t = NLMSG_DATA(nlh); 804 t->tca_family = AF_UNSPEC; 805 t->tca__pad1 = 0; 806 t->tca__pad2 = 0; 807 808 nest = nla_nest_start(skb, TCA_ACT_TAB); 809 if (nest == NULL) 810 goto nla_put_failure; 811 812 err = a->ops->walk(skb, &dcb, RTM_DELACTION, a); 813 if (err < 0) 814 goto nla_put_failure; 815 if (err == 0) 816 goto noflush_out; 817 818 nla_nest_end(skb, nest); 819 820 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 821 nlh->nlmsg_flags |= NLM_F_ROOT; 822 module_put(a->ops->owner); 823 kfree(a); 824 err = rtnetlink_send(skb, net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO); 825 if (err > 0) 826 return 0; 827 828 return err; 829 830 nla_put_failure: 831 nlmsg_failure: 832 module_put(a->ops->owner); 833 err_out: 834 noflush_out: 835 kfree_skb(skb); 836 kfree(a); 837 return err; 838 } 839 840 static int 841 tca_action_gd(struct net *net, struct nlattr *nla, struct nlmsghdr *n, 842 u32 pid, int event) 843 { 844 int i, ret; 845 struct nlattr *tb[TCA_ACT_MAX_PRIO+1]; 846 struct tc_action *head = NULL, *act, *act_prev = NULL; 847 848 ret = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL); 849 if (ret < 0) 850 return ret; 851 852 if (event == RTM_DELACTION && n->nlmsg_flags&NLM_F_ROOT) { 853 if (tb[1] != NULL) 854 return tca_action_flush(net, tb[1], n, pid); 855 else 856 return -EINVAL; 857 } 858 859 for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) { 860 act = tcf_action_get_1(tb[i], n, pid); 861 if (IS_ERR(act)) { 862 ret = PTR_ERR(act); 863 goto err; 864 } 865 act->order = i; 866 867 if (head == NULL) 868 head = act; 869 else 870 act_prev->next = act; 871 act_prev = act; 872 } 873 874 if (event == RTM_GETACTION) 875 ret = act_get_notify(net, pid, n, head, event); 876 else { /* delete */ 877 struct sk_buff *skb; 878 879 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); 880 if (!skb) { 881 ret = -ENOBUFS; 882 goto err; 883 } 884 885 if (tca_get_fill(skb, head, pid, n->nlmsg_seq, 0, event, 886 0, 1) <= 0) { 887 kfree_skb(skb); 888 ret = -EINVAL; 889 goto err; 890 } 891 892 /* now do the delete */ 893 tcf_action_destroy(head, 0); 894 ret = rtnetlink_send(skb, net, pid, RTNLGRP_TC, 895 n->nlmsg_flags&NLM_F_ECHO); 896 if (ret > 0) 897 return 0; 898 return ret; 899 } 900 err: 901 cleanup_a(head); 902 return ret; 903 } 904 905 static int tcf_add_notify(struct net *net, struct tc_action *a, 906 u32 pid, u32 seq, int event, u16 flags) 907 { 908 struct tcamsg *t; 909 struct nlmsghdr *nlh; 910 struct sk_buff *skb; 911 struct nlattr *nest; 912 unsigned char *b; 913 int err = 0; 914 915 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); 916 if (!skb) 917 return -ENOBUFS; 918 919 b = skb_tail_pointer(skb); 920 921 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags); 922 t = NLMSG_DATA(nlh); 923 t->tca_family = AF_UNSPEC; 924 t->tca__pad1 = 0; 925 t->tca__pad2 = 0; 926 927 nest = nla_nest_start(skb, TCA_ACT_TAB); 928 if (nest == NULL) 929 goto nla_put_failure; 930 931 if (tcf_action_dump(skb, a, 0, 0) < 0) 932 goto nla_put_failure; 933 934 nla_nest_end(skb, nest); 935 936 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 937 NETLINK_CB(skb).dst_group = RTNLGRP_TC; 938 939 err = rtnetlink_send(skb, net, pid, RTNLGRP_TC, flags&NLM_F_ECHO); 940 if (err > 0) 941 err = 0; 942 return err; 943 944 nla_put_failure: 945 nlmsg_failure: 946 kfree_skb(skb); 947 return -1; 948 } 949 950 951 static int 952 tcf_action_add(struct net *net, struct nlattr *nla, struct nlmsghdr *n, 953 u32 pid, int ovr) 954 { 955 int ret = 0; 956 struct tc_action *act; 957 struct tc_action *a; 958 u32 seq = n->nlmsg_seq; 959 960 act = tcf_action_init(nla, NULL, NULL, ovr, 0); 961 if (act == NULL) 962 goto done; 963 if (IS_ERR(act)) { 964 ret = PTR_ERR(act); 965 goto done; 966 } 967 968 /* dump then free all the actions after update; inserted policy 969 * stays intact 970 * */ 971 ret = tcf_add_notify(net, act, pid, seq, RTM_NEWACTION, n->nlmsg_flags); 972 for (a = act; a; a = act) { 973 act = a->next; 974 kfree(a); 975 } 976 done: 977 return ret; 978 } 979 980 static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n, void *arg) 981 { 982 struct net *net = sock_net(skb->sk); 983 struct nlattr *tca[TCA_ACT_MAX + 1]; 984 u32 pid = skb ? NETLINK_CB(skb).pid : 0; 985 int ret = 0, ovr = 0; 986 987 ret = nlmsg_parse(n, sizeof(struct tcamsg), tca, TCA_ACT_MAX, NULL); 988 if (ret < 0) 989 return ret; 990 991 if (tca[TCA_ACT_TAB] == NULL) { 992 pr_notice("tc_ctl_action: received NO action attribs\n"); 993 return -EINVAL; 994 } 995 996 /* n->nlmsg_flags&NLM_F_CREATE 997 * */ 998 switch (n->nlmsg_type) { 999 case RTM_NEWACTION: 1000 /* we are going to assume all other flags 1001 * imply create only if it doesnt exist 1002 * Note that CREATE | EXCL implies that 1003 * but since we want avoid ambiguity (eg when flags 1004 * is zero) then just set this 1005 */ 1006 if (n->nlmsg_flags&NLM_F_REPLACE) 1007 ovr = 1; 1008 replay: 1009 ret = tcf_action_add(net, tca[TCA_ACT_TAB], n, pid, ovr); 1010 if (ret == -EAGAIN) 1011 goto replay; 1012 break; 1013 case RTM_DELACTION: 1014 ret = tca_action_gd(net, tca[TCA_ACT_TAB], n, 1015 pid, RTM_DELACTION); 1016 break; 1017 case RTM_GETACTION: 1018 ret = tca_action_gd(net, tca[TCA_ACT_TAB], n, 1019 pid, RTM_GETACTION); 1020 break; 1021 default: 1022 BUG(); 1023 } 1024 1025 return ret; 1026 } 1027 1028 static struct nlattr * 1029 find_dump_kind(const struct nlmsghdr *n) 1030 { 1031 struct nlattr *tb1, *tb2[TCA_ACT_MAX+1]; 1032 struct nlattr *tb[TCA_ACT_MAX_PRIO + 1]; 1033 struct nlattr *nla[TCAA_MAX + 1]; 1034 struct nlattr *kind; 1035 1036 if (nlmsg_parse(n, sizeof(struct tcamsg), nla, TCAA_MAX, NULL) < 0) 1037 return NULL; 1038 tb1 = nla[TCA_ACT_TAB]; 1039 if (tb1 == NULL) 1040 return NULL; 1041 1042 if (nla_parse(tb, TCA_ACT_MAX_PRIO, nla_data(tb1), 1043 NLMSG_ALIGN(nla_len(tb1)), NULL) < 0) 1044 return NULL; 1045 1046 if (tb[1] == NULL) 1047 return NULL; 1048 if (nla_parse(tb2, TCA_ACT_MAX, nla_data(tb[1]), 1049 nla_len(tb[1]), NULL) < 0) 1050 return NULL; 1051 kind = tb2[TCA_ACT_KIND]; 1052 1053 return kind; 1054 } 1055 1056 static int 1057 tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb) 1058 { 1059 struct nlmsghdr *nlh; 1060 unsigned char *b = skb_tail_pointer(skb); 1061 struct nlattr *nest; 1062 struct tc_action_ops *a_o; 1063 struct tc_action a; 1064 int ret = 0; 1065 struct tcamsg *t = (struct tcamsg *) NLMSG_DATA(cb->nlh); 1066 struct nlattr *kind = find_dump_kind(cb->nlh); 1067 1068 if (kind == NULL) { 1069 pr_info("tc_dump_action: action bad kind\n"); 1070 return 0; 1071 } 1072 1073 a_o = tc_lookup_action(kind); 1074 if (a_o == NULL) { 1075 return 0; 1076 } 1077 1078 memset(&a, 0, sizeof(struct tc_action)); 1079 a.ops = a_o; 1080 1081 if (a_o->walk == NULL) { 1082 WARN(1, "tc_dump_action: %s !capable of dumping table\n", 1083 a_o->kind); 1084 goto nla_put_failure; 1085 } 1086 1087 nlh = NLMSG_PUT(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq, 1088 cb->nlh->nlmsg_type, sizeof(*t)); 1089 t = NLMSG_DATA(nlh); 1090 t->tca_family = AF_UNSPEC; 1091 t->tca__pad1 = 0; 1092 t->tca__pad2 = 0; 1093 1094 nest = nla_nest_start(skb, TCA_ACT_TAB); 1095 if (nest == NULL) 1096 goto nla_put_failure; 1097 1098 ret = a_o->walk(skb, cb, RTM_GETACTION, &a); 1099 if (ret < 0) 1100 goto nla_put_failure; 1101 1102 if (ret > 0) { 1103 nla_nest_end(skb, nest); 1104 ret = skb->len; 1105 } else 1106 nla_nest_cancel(skb, nest); 1107 1108 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 1109 if (NETLINK_CB(cb->skb).pid && ret) 1110 nlh->nlmsg_flags |= NLM_F_MULTI; 1111 module_put(a_o->owner); 1112 return skb->len; 1113 1114 nla_put_failure: 1115 nlmsg_failure: 1116 module_put(a_o->owner); 1117 nlmsg_trim(skb, b); 1118 return skb->len; 1119 } 1120 1121 static int __init tc_action_init(void) 1122 { 1123 rtnl_register(PF_UNSPEC, RTM_NEWACTION, tc_ctl_action, NULL); 1124 rtnl_register(PF_UNSPEC, RTM_DELACTION, tc_ctl_action, NULL); 1125 rtnl_register(PF_UNSPEC, RTM_GETACTION, tc_ctl_action, tc_dump_action); 1126 1127 return 0; 1128 } 1129 1130 subsys_initcall(tc_action_init); 1131