1 /* 2 * net/sched/cls_api.c Packet classifier 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 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 10 * 11 * Changes: 12 * 13 * Eduardo J. Blanco <ejbs@netlabs.com.uy> :990222: kmod support 14 * 15 */ 16 17 #include <linux/module.h> 18 #include <linux/types.h> 19 #include <linux/kernel.h> 20 #include <linux/string.h> 21 #include <linux/errno.h> 22 #include <linux/skbuff.h> 23 #include <linux/init.h> 24 #include <linux/kmod.h> 25 #include <linux/err.h> 26 #include <linux/slab.h> 27 #include <net/net_namespace.h> 28 #include <net/sock.h> 29 #include <net/netlink.h> 30 #include <net/pkt_sched.h> 31 #include <net/pkt_cls.h> 32 33 /* The list of all installed classifier types */ 34 static LIST_HEAD(tcf_proto_base); 35 36 /* Protects list of registered TC modules. It is pure SMP lock. */ 37 static DEFINE_RWLOCK(cls_mod_lock); 38 39 /* Find classifier type by string name */ 40 41 static const struct tcf_proto_ops *tcf_proto_lookup_ops(struct nlattr *kind) 42 { 43 const struct tcf_proto_ops *t, *res = NULL; 44 45 if (kind) { 46 read_lock(&cls_mod_lock); 47 list_for_each_entry(t, &tcf_proto_base, head) { 48 if (nla_strcmp(kind, t->kind) == 0) { 49 if (try_module_get(t->owner)) 50 res = t; 51 break; 52 } 53 } 54 read_unlock(&cls_mod_lock); 55 } 56 return res; 57 } 58 59 /* Register(unregister) new classifier type */ 60 61 int register_tcf_proto_ops(struct tcf_proto_ops *ops) 62 { 63 struct tcf_proto_ops *t; 64 int rc = -EEXIST; 65 66 write_lock(&cls_mod_lock); 67 list_for_each_entry(t, &tcf_proto_base, head) 68 if (!strcmp(ops->kind, t->kind)) 69 goto out; 70 71 list_add_tail(&ops->head, &tcf_proto_base); 72 rc = 0; 73 out: 74 write_unlock(&cls_mod_lock); 75 return rc; 76 } 77 EXPORT_SYMBOL(register_tcf_proto_ops); 78 79 int unregister_tcf_proto_ops(struct tcf_proto_ops *ops) 80 { 81 struct tcf_proto_ops *t; 82 int rc = -ENOENT; 83 84 /* Wait for outstanding call_rcu()s, if any, from a 85 * tcf_proto_ops's destroy() handler. 86 */ 87 rcu_barrier(); 88 89 write_lock(&cls_mod_lock); 90 list_for_each_entry(t, &tcf_proto_base, head) { 91 if (t == ops) { 92 list_del(&t->head); 93 rc = 0; 94 break; 95 } 96 } 97 write_unlock(&cls_mod_lock); 98 return rc; 99 } 100 EXPORT_SYMBOL(unregister_tcf_proto_ops); 101 102 static int tfilter_notify(struct net *net, struct sk_buff *oskb, 103 struct nlmsghdr *n, struct tcf_proto *tp, 104 unsigned long fh, int event, bool unicast); 105 106 static void tfilter_notify_chain(struct net *net, struct sk_buff *oskb, 107 struct nlmsghdr *n, 108 struct tcf_proto __rcu **chain, int event) 109 { 110 struct tcf_proto __rcu **it_chain; 111 struct tcf_proto *tp; 112 113 for (it_chain = chain; (tp = rtnl_dereference(*it_chain)) != NULL; 114 it_chain = &tp->next) 115 tfilter_notify(net, oskb, n, tp, 0, event, false); 116 } 117 118 /* Select new prio value from the range, managed by kernel. */ 119 120 static inline u32 tcf_auto_prio(struct tcf_proto *tp) 121 { 122 u32 first = TC_H_MAKE(0xC0000000U, 0U); 123 124 if (tp) 125 first = tp->prio - 1; 126 127 return first; 128 } 129 130 /* Add/change/delete/get a filter node */ 131 132 static int tc_ctl_tfilter(struct sk_buff *skb, struct nlmsghdr *n) 133 { 134 struct net *net = sock_net(skb->sk); 135 struct nlattr *tca[TCA_MAX + 1]; 136 struct tcmsg *t; 137 u32 protocol; 138 u32 prio; 139 u32 nprio; 140 u32 parent; 141 struct net_device *dev; 142 struct Qdisc *q; 143 struct tcf_proto __rcu **back; 144 struct tcf_proto __rcu **chain; 145 struct tcf_proto *tp; 146 const struct tcf_proto_ops *tp_ops; 147 const struct Qdisc_class_ops *cops; 148 unsigned long cl; 149 unsigned long fh; 150 int err; 151 int tp_created = 0; 152 153 if ((n->nlmsg_type != RTM_GETTFILTER) && 154 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) 155 return -EPERM; 156 157 replay: 158 err = nlmsg_parse(n, sizeof(*t), tca, TCA_MAX, NULL); 159 if (err < 0) 160 return err; 161 162 t = nlmsg_data(n); 163 protocol = TC_H_MIN(t->tcm_info); 164 prio = TC_H_MAJ(t->tcm_info); 165 nprio = prio; 166 parent = t->tcm_parent; 167 cl = 0; 168 169 if (prio == 0) { 170 switch (n->nlmsg_type) { 171 case RTM_DELTFILTER: 172 if (protocol || t->tcm_handle || tca[TCA_KIND]) 173 return -ENOENT; 174 break; 175 case RTM_NEWTFILTER: 176 /* If no priority is provided by the user, 177 * we allocate one. 178 */ 179 if (n->nlmsg_flags & NLM_F_CREATE) { 180 prio = TC_H_MAKE(0x80000000U, 0U); 181 break; 182 } 183 /* fall-through */ 184 default: 185 return -ENOENT; 186 } 187 } 188 189 /* Find head of filter chain. */ 190 191 /* Find link */ 192 dev = __dev_get_by_index(net, t->tcm_ifindex); 193 if (dev == NULL) 194 return -ENODEV; 195 196 /* Find qdisc */ 197 if (!parent) { 198 q = dev->qdisc; 199 parent = q->handle; 200 } else { 201 q = qdisc_lookup(dev, TC_H_MAJ(t->tcm_parent)); 202 if (q == NULL) 203 return -EINVAL; 204 } 205 206 /* Is it classful? */ 207 cops = q->ops->cl_ops; 208 if (!cops) 209 return -EINVAL; 210 211 if (cops->tcf_chain == NULL) 212 return -EOPNOTSUPP; 213 214 /* Do we search for filter, attached to class? */ 215 if (TC_H_MIN(parent)) { 216 cl = cops->get(q, parent); 217 if (cl == 0) 218 return -ENOENT; 219 } 220 221 /* And the last stroke */ 222 chain = cops->tcf_chain(q, cl); 223 err = -EINVAL; 224 if (chain == NULL) 225 goto errout; 226 if (n->nlmsg_type == RTM_DELTFILTER && prio == 0) { 227 tfilter_notify_chain(net, skb, n, chain, RTM_DELTFILTER); 228 tcf_destroy_chain(chain); 229 err = 0; 230 goto errout; 231 } 232 233 /* Check the chain for existence of proto-tcf with this priority */ 234 for (back = chain; 235 (tp = rtnl_dereference(*back)) != NULL; 236 back = &tp->next) { 237 if (tp->prio >= prio) { 238 if (tp->prio == prio) { 239 if (!nprio || 240 (tp->protocol != protocol && protocol)) 241 goto errout; 242 } else 243 tp = NULL; 244 break; 245 } 246 } 247 248 if (tp == NULL) { 249 /* Proto-tcf does not exist, create new one */ 250 251 if (tca[TCA_KIND] == NULL || !protocol) 252 goto errout; 253 254 err = -ENOENT; 255 if (n->nlmsg_type != RTM_NEWTFILTER || 256 !(n->nlmsg_flags & NLM_F_CREATE)) 257 goto errout; 258 259 260 /* Create new proto tcf */ 261 262 err = -ENOBUFS; 263 tp = kzalloc(sizeof(*tp), GFP_KERNEL); 264 if (tp == NULL) 265 goto errout; 266 err = -ENOENT; 267 tp_ops = tcf_proto_lookup_ops(tca[TCA_KIND]); 268 if (tp_ops == NULL) { 269 #ifdef CONFIG_MODULES 270 struct nlattr *kind = tca[TCA_KIND]; 271 char name[IFNAMSIZ]; 272 273 if (kind != NULL && 274 nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) { 275 rtnl_unlock(); 276 request_module("cls_%s", name); 277 rtnl_lock(); 278 tp_ops = tcf_proto_lookup_ops(kind); 279 /* We dropped the RTNL semaphore in order to 280 * perform the module load. So, even if we 281 * succeeded in loading the module we have to 282 * replay the request. We indicate this using 283 * -EAGAIN. 284 */ 285 if (tp_ops != NULL) { 286 module_put(tp_ops->owner); 287 err = -EAGAIN; 288 } 289 } 290 #endif 291 kfree(tp); 292 goto errout; 293 } 294 tp->ops = tp_ops; 295 tp->protocol = protocol; 296 tp->prio = nprio ? : 297 TC_H_MAJ(tcf_auto_prio(rtnl_dereference(*back))); 298 tp->q = q; 299 tp->classify = tp_ops->classify; 300 tp->classid = parent; 301 302 err = tp_ops->init(tp); 303 if (err != 0) { 304 module_put(tp_ops->owner); 305 kfree(tp); 306 goto errout; 307 } 308 309 tp_created = 1; 310 311 } else if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], tp->ops->kind)) 312 goto errout; 313 314 fh = tp->ops->get(tp, t->tcm_handle); 315 316 if (fh == 0) { 317 if (n->nlmsg_type == RTM_DELTFILTER && t->tcm_handle == 0) { 318 struct tcf_proto *next = rtnl_dereference(tp->next); 319 320 RCU_INIT_POINTER(*back, next); 321 322 tfilter_notify(net, skb, n, tp, fh, 323 RTM_DELTFILTER, false); 324 tcf_destroy(tp, true); 325 err = 0; 326 goto errout; 327 } 328 329 err = -ENOENT; 330 if (n->nlmsg_type != RTM_NEWTFILTER || 331 !(n->nlmsg_flags & NLM_F_CREATE)) 332 goto errout; 333 } else { 334 switch (n->nlmsg_type) { 335 case RTM_NEWTFILTER: 336 err = -EEXIST; 337 if (n->nlmsg_flags & NLM_F_EXCL) { 338 if (tp_created) 339 tcf_destroy(tp, true); 340 goto errout; 341 } 342 break; 343 case RTM_DELTFILTER: 344 err = tp->ops->delete(tp, fh); 345 if (err == 0) { 346 struct tcf_proto *next = rtnl_dereference(tp->next); 347 348 tfilter_notify(net, skb, n, tp, fh, 349 RTM_DELTFILTER, false); 350 if (tcf_destroy(tp, false)) 351 RCU_INIT_POINTER(*back, next); 352 } 353 goto errout; 354 case RTM_GETTFILTER: 355 err = tfilter_notify(net, skb, n, tp, fh, 356 RTM_NEWTFILTER, true); 357 goto errout; 358 default: 359 err = -EINVAL; 360 goto errout; 361 } 362 } 363 364 err = tp->ops->change(net, skb, tp, cl, t->tcm_handle, tca, &fh, 365 n->nlmsg_flags & NLM_F_CREATE ? TCA_ACT_NOREPLACE : TCA_ACT_REPLACE); 366 if (err == 0) { 367 if (tp_created) { 368 RCU_INIT_POINTER(tp->next, rtnl_dereference(*back)); 369 rcu_assign_pointer(*back, tp); 370 } 371 tfilter_notify(net, skb, n, tp, fh, RTM_NEWTFILTER, false); 372 } else { 373 if (tp_created) 374 tcf_destroy(tp, true); 375 } 376 377 errout: 378 if (cl) 379 cops->put(q, cl); 380 if (err == -EAGAIN) 381 /* Replay the request. */ 382 goto replay; 383 return err; 384 } 385 386 static int tcf_fill_node(struct net *net, struct sk_buff *skb, 387 struct tcf_proto *tp, unsigned long fh, u32 portid, 388 u32 seq, u16 flags, int event) 389 { 390 struct tcmsg *tcm; 391 struct nlmsghdr *nlh; 392 unsigned char *b = skb_tail_pointer(skb); 393 394 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags); 395 if (!nlh) 396 goto out_nlmsg_trim; 397 tcm = nlmsg_data(nlh); 398 tcm->tcm_family = AF_UNSPEC; 399 tcm->tcm__pad1 = 0; 400 tcm->tcm__pad2 = 0; 401 tcm->tcm_ifindex = qdisc_dev(tp->q)->ifindex; 402 tcm->tcm_parent = tp->classid; 403 tcm->tcm_info = TC_H_MAKE(tp->prio, tp->protocol); 404 if (nla_put_string(skb, TCA_KIND, tp->ops->kind)) 405 goto nla_put_failure; 406 tcm->tcm_handle = fh; 407 if (RTM_DELTFILTER != event) { 408 tcm->tcm_handle = 0; 409 if (tp->ops->dump && tp->ops->dump(net, tp, fh, skb, tcm) < 0) 410 goto nla_put_failure; 411 } 412 nlh->nlmsg_len = skb_tail_pointer(skb) - b; 413 return skb->len; 414 415 out_nlmsg_trim: 416 nla_put_failure: 417 nlmsg_trim(skb, b); 418 return -1; 419 } 420 421 static int tfilter_notify(struct net *net, struct sk_buff *oskb, 422 struct nlmsghdr *n, struct tcf_proto *tp, 423 unsigned long fh, int event, bool unicast) 424 { 425 struct sk_buff *skb; 426 u32 portid = oskb ? NETLINK_CB(oskb).portid : 0; 427 428 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); 429 if (!skb) 430 return -ENOBUFS; 431 432 if (tcf_fill_node(net, skb, tp, fh, portid, n->nlmsg_seq, 0, event) <= 0) { 433 kfree_skb(skb); 434 return -EINVAL; 435 } 436 437 if (unicast) 438 return netlink_unicast(net->rtnl, skb, portid, MSG_DONTWAIT); 439 440 return rtnetlink_send(skb, net, portid, RTNLGRP_TC, 441 n->nlmsg_flags & NLM_F_ECHO); 442 } 443 444 struct tcf_dump_args { 445 struct tcf_walker w; 446 struct sk_buff *skb; 447 struct netlink_callback *cb; 448 }; 449 450 static int tcf_node_dump(struct tcf_proto *tp, unsigned long n, 451 struct tcf_walker *arg) 452 { 453 struct tcf_dump_args *a = (void *)arg; 454 struct net *net = sock_net(a->skb->sk); 455 456 return tcf_fill_node(net, a->skb, tp, n, NETLINK_CB(a->cb->skb).portid, 457 a->cb->nlh->nlmsg_seq, NLM_F_MULTI, 458 RTM_NEWTFILTER); 459 } 460 461 /* called with RTNL */ 462 static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb) 463 { 464 struct net *net = sock_net(skb->sk); 465 int t; 466 int s_t; 467 struct net_device *dev; 468 struct Qdisc *q; 469 struct tcf_proto *tp, __rcu **chain; 470 struct tcmsg *tcm = nlmsg_data(cb->nlh); 471 unsigned long cl = 0; 472 const struct Qdisc_class_ops *cops; 473 struct tcf_dump_args arg; 474 475 if (nlmsg_len(cb->nlh) < sizeof(*tcm)) 476 return skb->len; 477 dev = __dev_get_by_index(net, tcm->tcm_ifindex); 478 if (!dev) 479 return skb->len; 480 481 if (!tcm->tcm_parent) 482 q = dev->qdisc; 483 else 484 q = qdisc_lookup(dev, TC_H_MAJ(tcm->tcm_parent)); 485 if (!q) 486 goto out; 487 cops = q->ops->cl_ops; 488 if (!cops) 489 goto errout; 490 if (cops->tcf_chain == NULL) 491 goto errout; 492 if (TC_H_MIN(tcm->tcm_parent)) { 493 cl = cops->get(q, tcm->tcm_parent); 494 if (cl == 0) 495 goto errout; 496 } 497 chain = cops->tcf_chain(q, cl); 498 if (chain == NULL) 499 goto errout; 500 501 s_t = cb->args[0]; 502 503 for (tp = rtnl_dereference(*chain), t = 0; 504 tp; tp = rtnl_dereference(tp->next), t++) { 505 if (t < s_t) 506 continue; 507 if (TC_H_MAJ(tcm->tcm_info) && 508 TC_H_MAJ(tcm->tcm_info) != tp->prio) 509 continue; 510 if (TC_H_MIN(tcm->tcm_info) && 511 TC_H_MIN(tcm->tcm_info) != tp->protocol) 512 continue; 513 if (t > s_t) 514 memset(&cb->args[1], 0, 515 sizeof(cb->args)-sizeof(cb->args[0])); 516 if (cb->args[1] == 0) { 517 if (tcf_fill_node(net, skb, tp, 0, 518 NETLINK_CB(cb->skb).portid, 519 cb->nlh->nlmsg_seq, NLM_F_MULTI, 520 RTM_NEWTFILTER) <= 0) 521 break; 522 523 cb->args[1] = 1; 524 } 525 if (tp->ops->walk == NULL) 526 continue; 527 arg.w.fn = tcf_node_dump; 528 arg.skb = skb; 529 arg.cb = cb; 530 arg.w.stop = 0; 531 arg.w.skip = cb->args[1] - 1; 532 arg.w.count = 0; 533 tp->ops->walk(tp, &arg.w); 534 cb->args[1] = arg.w.count + 1; 535 if (arg.w.stop) 536 break; 537 } 538 539 cb->args[0] = t; 540 541 errout: 542 if (cl) 543 cops->put(q, cl); 544 out: 545 return skb->len; 546 } 547 548 void tcf_exts_destroy(struct tcf_exts *exts) 549 { 550 #ifdef CONFIG_NET_CLS_ACT 551 LIST_HEAD(actions); 552 553 tcf_exts_to_list(exts, &actions); 554 tcf_action_destroy(&actions, TCA_ACT_UNBIND); 555 kfree(exts->actions); 556 exts->nr_actions = 0; 557 #endif 558 } 559 EXPORT_SYMBOL(tcf_exts_destroy); 560 561 int tcf_exts_validate(struct net *net, struct tcf_proto *tp, struct nlattr **tb, 562 struct nlattr *rate_tlv, struct tcf_exts *exts, bool ovr) 563 { 564 #ifdef CONFIG_NET_CLS_ACT 565 { 566 struct tc_action *act; 567 568 if (exts->police && tb[exts->police]) { 569 act = tcf_action_init_1(net, tb[exts->police], rate_tlv, 570 "police", ovr, TCA_ACT_BIND); 571 if (IS_ERR(act)) 572 return PTR_ERR(act); 573 574 act->type = exts->type = TCA_OLD_COMPAT; 575 exts->actions[0] = act; 576 exts->nr_actions = 1; 577 } else if (exts->action && tb[exts->action]) { 578 LIST_HEAD(actions); 579 int err, i = 0; 580 581 err = tcf_action_init(net, tb[exts->action], rate_tlv, 582 NULL, ovr, TCA_ACT_BIND, 583 &actions); 584 if (err) 585 return err; 586 list_for_each_entry(act, &actions, list) 587 exts->actions[i++] = act; 588 exts->nr_actions = i; 589 } 590 } 591 #else 592 if ((exts->action && tb[exts->action]) || 593 (exts->police && tb[exts->police])) 594 return -EOPNOTSUPP; 595 #endif 596 597 return 0; 598 } 599 EXPORT_SYMBOL(tcf_exts_validate); 600 601 void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst, 602 struct tcf_exts *src) 603 { 604 #ifdef CONFIG_NET_CLS_ACT 605 struct tcf_exts old = *dst; 606 607 tcf_tree_lock(tp); 608 dst->nr_actions = src->nr_actions; 609 dst->actions = src->actions; 610 dst->type = src->type; 611 tcf_tree_unlock(tp); 612 613 tcf_exts_destroy(&old); 614 #endif 615 } 616 EXPORT_SYMBOL(tcf_exts_change); 617 618 #ifdef CONFIG_NET_CLS_ACT 619 static struct tc_action *tcf_exts_first_act(struct tcf_exts *exts) 620 { 621 if (exts->nr_actions == 0) 622 return NULL; 623 else 624 return exts->actions[0]; 625 } 626 #endif 627 628 int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts) 629 { 630 #ifdef CONFIG_NET_CLS_ACT 631 struct nlattr *nest; 632 633 if (exts->action && exts->nr_actions) { 634 /* 635 * again for backward compatible mode - we want 636 * to work with both old and new modes of entering 637 * tc data even if iproute2 was newer - jhs 638 */ 639 if (exts->type != TCA_OLD_COMPAT) { 640 LIST_HEAD(actions); 641 642 nest = nla_nest_start(skb, exts->action); 643 if (nest == NULL) 644 goto nla_put_failure; 645 646 tcf_exts_to_list(exts, &actions); 647 if (tcf_action_dump(skb, &actions, 0, 0) < 0) 648 goto nla_put_failure; 649 nla_nest_end(skb, nest); 650 } else if (exts->police) { 651 struct tc_action *act = tcf_exts_first_act(exts); 652 nest = nla_nest_start(skb, exts->police); 653 if (nest == NULL || !act) 654 goto nla_put_failure; 655 if (tcf_action_dump_old(skb, act, 0, 0) < 0) 656 goto nla_put_failure; 657 nla_nest_end(skb, nest); 658 } 659 } 660 return 0; 661 662 nla_put_failure: 663 nla_nest_cancel(skb, nest); 664 return -1; 665 #else 666 return 0; 667 #endif 668 } 669 EXPORT_SYMBOL(tcf_exts_dump); 670 671 672 int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts) 673 { 674 #ifdef CONFIG_NET_CLS_ACT 675 struct tc_action *a = tcf_exts_first_act(exts); 676 if (a != NULL && tcf_action_copy_stats(skb, a, 1) < 0) 677 return -1; 678 #endif 679 return 0; 680 } 681 EXPORT_SYMBOL(tcf_exts_dump_stats); 682 683 static int __init tc_filter_init(void) 684 { 685 rtnl_register(PF_UNSPEC, RTM_NEWTFILTER, tc_ctl_tfilter, NULL, NULL); 686 rtnl_register(PF_UNSPEC, RTM_DELTFILTER, tc_ctl_tfilter, NULL, NULL); 687 rtnl_register(PF_UNSPEC, RTM_GETTFILTER, tc_ctl_tfilter, 688 tc_dump_tfilter, NULL); 689 690 return 0; 691 } 692 693 subsys_initcall(tc_filter_init); 694