net/sched/cls_api.c

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