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_chain *chain, int event)
 110 {
 111         struct tcf_proto *tp;
 112
 113         for (tp = rtnl_dereference(chain->filter_chain);
 114              tp; tp = rtnl_dereference(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 TC_H_MAJ(first);
 128 }
 129
 130 static struct tcf_proto *tcf_proto_create(const char *kind, u32 protocol,
 131                                           u32 prio, u32 parent, struct Qdisc *q,
 132                                           struct tcf_chain *chain)
 133 {
 134         struct tcf_proto *tp;
 135         int err;
 136
 137         tp = kzalloc(sizeof(*tp), GFP_KERNEL);
 138         if (!tp)
 139                 return ERR_PTR(-ENOBUFS);
 140
 141         err = -ENOENT;
 142         tp->ops = tcf_proto_lookup_ops(kind);
 143         if (!tp->ops) {
 144 #ifdef CONFIG_MODULES
 145                 rtnl_unlock();
 146                 request_module("cls_%s", kind);
 147                 rtnl_lock();
 148                 tp->ops = tcf_proto_lookup_ops(kind);
 149                 /* We dropped the RTNL semaphore in order to perform
 150                  * the module load. So, even if we succeeded in loading
 151                  * the module we have to replay the request. We indicate
 152                  * this using -EAGAIN.
 153                  */
 154                 if (tp->ops) {
 155                         module_put(tp->ops->owner);
 156                         err = -EAGAIN;
 157                 } else {
 158                         err = -ENOENT;
 159                 }
 160                 goto errout;
 161 #endif
 162         }
 163         tp->classify = tp->ops->classify;
 164         tp->protocol = protocol;
 165         tp->prio = prio;
 166         tp->classid = parent;
 167         tp->q = q;
 168         tp->chain = chain;
 169
 170         err = tp->ops->init(tp);
 171         if (err) {
 172                 module_put(tp->ops->owner);
 173                 goto errout;
 174         }
 175         return tp;
 176
 177 errout:
 178         kfree(tp);
 179         return ERR_PTR(err);
 180 }
 181
 182 static void tcf_proto_destroy(struct tcf_proto *tp)
 183 {
 184         tp->ops->destroy(tp);
 185         module_put(tp->ops->owner);
 186         kfree_rcu(tp, rcu);
 187 }
 188
 189 static struct tcf_chain *tcf_chain_create(struct tcf_block *block,
 190                                           u32 chain_index)
 191 {
 192         struct tcf_chain *chain;
 193
 194         chain = kzalloc(sizeof(*chain), GFP_KERNEL);
 195         if (!chain)
 196                 return NULL;
 197         list_add_tail(&chain->list, &block->chain_list);
 198         chain->block = block;
 199         chain->index = chain_index;
 200         chain->refcnt = 1;
 201         return chain;
 202 }
 203
 204 static void tcf_chain_destroy(struct tcf_chain *chain)
 205 {
 206         struct tcf_proto *tp;
 207
 208         list_del(&chain->list);
 209         while ((tp = rtnl_dereference(chain->filter_chain)) != NULL) {
 210                 RCU_INIT_POINTER(chain->filter_chain, tp->next);
 211                 tcf_proto_destroy(tp);
 212         }
 213         kfree(chain);
 214 }
 215
 216 struct tcf_chain *tcf_chain_get(struct tcf_block *block, u32 chain_index)
 217 {
 218         struct tcf_chain *chain;
 219
 220         list_for_each_entry(chain, &block->chain_list, list) {
 221                 if (chain->index == chain_index) {
 222                         chain->refcnt++;
 223                         return chain;
 224                 }
 225         }
 226         return tcf_chain_create(block, chain_index);
 227 }
 228 EXPORT_SYMBOL(tcf_chain_get);
 229
 230 void tcf_chain_put(struct tcf_chain *chain)
 231 {
 232         /* Destroy unused chain, with exception of chain 0, which is the
 233          * default one and has to be always present.
 234          */
 235         if (--chain->refcnt == 0 && !chain->filter_chain && chain->index != 0)
 236                 tcf_chain_destroy(chain);
 237 }
 238 EXPORT_SYMBOL(tcf_chain_put);
 239
 240 static void
 241 tcf_chain_filter_chain_ptr_set(struct tcf_chain *chain,
 242                                struct tcf_proto __rcu **p_filter_chain)
 243 {
 244         chain->p_filter_chain = p_filter_chain;
 245 }
 246
 247 int tcf_block_get(struct tcf_block **p_block,
 248                   struct tcf_proto __rcu **p_filter_chain)
 249 {
 250         struct tcf_block *block = kzalloc(sizeof(*block), GFP_KERNEL);
 251         struct tcf_chain *chain;
 252         int err;
 253
 254         if (!block)
 255                 return -ENOMEM;
 256         INIT_LIST_HEAD(&block->chain_list);
 257         /* Create chain 0 by default, it has to be always present. */
 258         chain = tcf_chain_create(block, 0);
 259         if (!chain) {
 260                 err = -ENOMEM;
 261                 goto err_chain_create;
 262         }
 263         tcf_chain_filter_chain_ptr_set(chain, p_filter_chain);
 264         *p_block = block;
 265         return 0;
 266
 267 err_chain_create:
 268         kfree(block);
 269         return err;
 270 }
 271 EXPORT_SYMBOL(tcf_block_get);
 272
 273 void tcf_block_put(struct tcf_block *block)
 274 {
 275         struct tcf_chain *chain, *tmp;
 276
 277         if (!block)
 278                 return;
 279
 280         list_for_each_entry_safe(chain, tmp, &block->chain_list, list)
 281                 tcf_chain_destroy(chain);
 282         kfree(block);
 283 }
 284 EXPORT_SYMBOL(tcf_block_put);
 285
 286 /* Main classifier routine: scans classifier chain attached
 287  * to this qdisc, (optionally) tests for protocol and asks
 288  * specific classifiers.
 289  */
 290 int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
 291                  struct tcf_result *res, bool compat_mode)
 292 {
 293         __be16 protocol = tc_skb_protocol(skb);
 294 #ifdef CONFIG_NET_CLS_ACT
 295         const int max_reclassify_loop = 4;
 296         const struct tcf_proto *old_tp = tp;
 297         int limit = 0;
 298
 299 reclassify:
 300 #endif
 301         for (; tp; tp = rcu_dereference_bh(tp->next)) {
 302                 int err;
 303
 304                 if (tp->protocol != protocol &&
 305                     tp->protocol != htons(ETH_P_ALL))
 306                         continue;
 307
 308                 err = tp->classify(skb, tp, res);
 309 #ifdef CONFIG_NET_CLS_ACT
 310                 if (unlikely(err == TC_ACT_RECLASSIFY && !compat_mode)) {
 311                         goto reset;
 312                 } else if (unlikely(TC_ACT_EXT_CMP(err, TC_ACT_GOTO_CHAIN))) {
 313                         old_tp = res->goto_tp;
 314                         goto reset;
 315                 }
 316 #endif
 317                 if (err >= 0)
 318                         return err;
 319         }
 320
 321         return TC_ACT_UNSPEC; /* signal: continue lookup */
 322 #ifdef CONFIG_NET_CLS_ACT
 323 reset:
 324         if (unlikely(limit++ >= max_reclassify_loop)) {
 325                 net_notice_ratelimited("%s: reclassify loop, rule prio %u, protocol %02x\n",
 326                                        tp->q->ops->id, tp->prio & 0xffff,
 327                                        ntohs(tp->protocol));
 328                 return TC_ACT_SHOT;
 329         }
 330
 331         tp = old_tp;
 332         protocol = tc_skb_protocol(skb);
 333         goto reclassify;
 334 #endif
 335 }
 336 EXPORT_SYMBOL(tcf_classify);
 337
 338 struct tcf_chain_info {
 339         struct tcf_proto __rcu **pprev;
 340         struct tcf_proto __rcu *next;
 341 };
 342
 343 static struct tcf_proto *tcf_chain_tp_prev(struct tcf_chain_info *chain_info)
 344 {
 345         return rtnl_dereference(*chain_info->pprev);
 346 }
 347
 348 static void tcf_chain_tp_insert(struct tcf_chain *chain,
 349                                 struct tcf_chain_info *chain_info,
 350                                 struct tcf_proto *tp)
 351 {
 352         if (chain->p_filter_chain &&
 353             *chain_info->pprev == chain->filter_chain)
 354                 *chain->p_filter_chain = tp;
 355         RCU_INIT_POINTER(tp->next, tcf_chain_tp_prev(chain_info));
 356         rcu_assign_pointer(*chain_info->pprev, tp);
 357 }
 358
 359 static void tcf_chain_tp_remove(struct tcf_chain *chain,
 360                                 struct tcf_chain_info *chain_info,
 361                                 struct tcf_proto *tp)
 362 {
 363         struct tcf_proto *next = rtnl_dereference(chain_info->next);
 364
 365         if (chain->p_filter_chain && tp == chain->filter_chain)
 366                 *chain->p_filter_chain = next;
 367         RCU_INIT_POINTER(*chain_info->pprev, next);
 368 }
 369
 370 static struct tcf_proto *tcf_chain_tp_find(struct tcf_chain *chain,
 371                                            struct tcf_chain_info *chain_info,
 372                                            u32 protocol, u32 prio,
 373                                            bool prio_allocate)
 374 {
 375         struct tcf_proto **pprev;
 376         struct tcf_proto *tp;
 377
 378         /* Check the chain for existence of proto-tcf with this priority */
 379         for (pprev = &chain->filter_chain;
 380              (tp = rtnl_dereference(*pprev)); pprev = &tp->next) {
 381                 if (tp->prio >= prio) {
 382                         if (tp->prio == prio) {
 383                                 if (prio_allocate ||
 384                                     (tp->protocol != protocol && protocol))
 385                                         return ERR_PTR(-EINVAL);
 386                         } else {
 387                                 tp = NULL;
 388                         }
 389                         break;
 390                 }
 391         }
 392         chain_info->pprev = pprev;
 393         chain_info->next = tp ? tp->next : NULL;
 394         return tp;
 395 }
 396
 397 /* Add/change/delete/get a filter node */
 398
 399 static int tc_ctl_tfilter(struct sk_buff *skb, struct nlmsghdr *n,
 400                           struct netlink_ext_ack *extack)
 401 {
 402         struct net *net = sock_net(skb->sk);
 403         struct nlattr *tca[TCA_MAX + 1];
 404         struct tcmsg *t;
 405         u32 protocol;
 406         u32 prio;
 407         bool prio_allocate;
 408         u32 parent;
 409         u32 chain_index;
 410         struct net_device *dev;
 411         struct Qdisc  *q;
 412         struct tcf_chain_info chain_info;
 413         struct tcf_chain *chain = NULL;
 414         struct tcf_block *block;
 415         struct tcf_proto *tp;
 416         const struct Qdisc_class_ops *cops;
 417         unsigned long cl;
 418         unsigned long fh;
 419         int err;
 420         int tp_created;
 421
 422         if ((n->nlmsg_type != RTM_GETTFILTER) &&
 423             !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
 424                 return -EPERM;
 425
 426 replay:
 427         tp_created = 0;
 428
 429         err = nlmsg_parse(n, sizeof(*t), tca, TCA_MAX, NULL, extack);
 430         if (err < 0)
 431                 return err;
 432
 433         t = nlmsg_data(n);
 434         protocol = TC_H_MIN(t->tcm_info);
 435         prio = TC_H_MAJ(t->tcm_info);
 436         prio_allocate = false;
 437         parent = t->tcm_parent;
 438         cl = 0;
 439
 440         if (prio == 0) {
 441                 switch (n->nlmsg_type) {
 442                 case RTM_DELTFILTER:
 443                         if (protocol || t->tcm_handle || tca[TCA_KIND])
 444                                 return -ENOENT;
 445                         break;
 446                 case RTM_NEWTFILTER:
 447                         /* If no priority is provided by the user,
 448                          * we allocate one.
 449                          */
 450                         if (n->nlmsg_flags & NLM_F_CREATE) {
 451                                 prio = TC_H_MAKE(0x80000000U, 0U);
 452                                 prio_allocate = true;
 453                                 break;
 454                         }
 455                         /* fall-through */
 456                 default:
 457                         return -ENOENT;
 458                 }
 459         }
 460
 461         /* Find head of filter chain. */
 462
 463         /* Find link */
 464         dev = __dev_get_by_index(net, t->tcm_ifindex);
 465         if (dev == NULL)
 466                 return -ENODEV;
 467
 468         /* Find qdisc */
 469         if (!parent) {
 470                 q = dev->qdisc;
 471                 parent = q->handle;
 472         } else {
 473                 q = qdisc_lookup(dev, TC_H_MAJ(t->tcm_parent));
 474                 if (q == NULL)
 475                         return -EINVAL;
 476         }
 477
 478         /* Is it classful? */
 479         cops = q->ops->cl_ops;
 480         if (!cops)
 481                 return -EINVAL;
 482
 483         if (!cops->tcf_block)
 484                 return -EOPNOTSUPP;
 485
 486         /* Do we search for filter, attached to class? */
 487         if (TC_H_MIN(parent)) {
 488                 cl = cops->get(q, parent);
 489                 if (cl == 0)
 490                         return -ENOENT;
 491         }
 492
 493         /* And the last stroke */
 494         block = cops->tcf_block(q, cl);
 495         if (!block) {
 496                 err = -EINVAL;
 497                 goto errout;
 498         }
 499
 500         chain_index = tca[TCA_CHAIN] ? nla_get_u32(tca[TCA_CHAIN]) : 0;
 501         if (chain_index > TC_ACT_EXT_VAL_MASK) {
 502                 err = -EINVAL;
 503                 goto errout;
 504         }
 505         chain = tcf_chain_get(block, chain_index);
 506         if (!chain) {
 507                 err = -ENOMEM;
 508                 goto errout;
 509         }
 510
 511         if (n->nlmsg_type == RTM_DELTFILTER && prio == 0) {
 512                 tfilter_notify_chain(net, skb, n, chain, RTM_DELTFILTER);
 513                 tcf_chain_destroy(chain);
 514                 err = 0;
 515                 goto errout;
 516         }
 517
 518         tp = tcf_chain_tp_find(chain, &chain_info, protocol,
 519                                prio, prio_allocate);
 520         if (IS_ERR(tp)) {
 521                 err = PTR_ERR(tp);
 522                 goto errout;
 523         }
 524
 525         if (tp == NULL) {
 526                 /* Proto-tcf does not exist, create new one */
 527
 528                 if (tca[TCA_KIND] == NULL || !protocol) {
 529                         err = -EINVAL;
 530                         goto errout;
 531                 }
 532
 533                 if (n->nlmsg_type != RTM_NEWTFILTER ||
 534                     !(n->nlmsg_flags & NLM_F_CREATE)) {
 535                         err = -ENOENT;
 536                         goto errout;
 537                 }
 538
 539                 if (prio_allocate)
 540                         prio = tcf_auto_prio(tcf_chain_tp_prev(&chain_info));
 541
 542                 tp = tcf_proto_create(nla_data(tca[TCA_KIND]),
 543                                       protocol, prio, parent, q, chain);
 544                 if (IS_ERR(tp)) {
 545                         err = PTR_ERR(tp);
 546                         goto errout;
 547                 }
 548                 tp_created = 1;
 549         } else if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], tp->ops->kind)) {
 550                 err = -EINVAL;
 551                 goto errout;
 552         }
 553
 554         fh = tp->ops->get(tp, t->tcm_handle);
 555
 556         if (fh == 0) {
 557                 if (n->nlmsg_type == RTM_DELTFILTER && t->tcm_handle == 0) {
 558                         tcf_chain_tp_remove(chain, &chain_info, tp);
 559                         tfilter_notify(net, skb, n, tp, fh,
 560                                        RTM_DELTFILTER, false);
 561                         tcf_proto_destroy(tp);
 562                         err = 0;
 563                         goto errout;
 564                 }
 565
 566                 if (n->nlmsg_type != RTM_NEWTFILTER ||
 567                     !(n->nlmsg_flags & NLM_F_CREATE)) {
 568                         err = -ENOENT;
 569                         goto errout;
 570                 }
 571         } else {
 572                 bool last;
 573
 574                 switch (n->nlmsg_type) {
 575                 case RTM_NEWTFILTER:
 576                         if (n->nlmsg_flags & NLM_F_EXCL) {
 577                                 if (tp_created)
 578                                         tcf_proto_destroy(tp);
 579                                 err = -EEXIST;
 580                                 goto errout;
 581                         }
 582                         break;
 583                 case RTM_DELTFILTER:
 584                         err = tp->ops->delete(tp, fh, &last);
 585                         if (err)
 586                                 goto errout;
 587                         tfilter_notify(net, skb, n, tp, t->tcm_handle,
 588                                        RTM_DELTFILTER, false);
 589                         if (last) {
 590                                 tcf_chain_tp_remove(chain, &chain_info, tp);
 591                                 tcf_proto_destroy(tp);
 592                         }
 593                         goto errout;
 594                 case RTM_GETTFILTER:
 595                         err = tfilter_notify(net, skb, n, tp, fh,
 596                                              RTM_NEWTFILTER, true);
 597                         goto errout;
 598                 default:
 599                         err = -EINVAL;
 600                         goto errout;
 601                 }
 602         }
 603
 604         err = tp->ops->change(net, skb, tp, cl, t->tcm_handle, tca, &fh,
 605                               n->nlmsg_flags & NLM_F_CREATE ? TCA_ACT_NOREPLACE : TCA_ACT_REPLACE);
 606         if (err == 0) {
 607                 if (tp_created)
 608                         tcf_chain_tp_insert(chain, &chain_info, tp);
 609                 tfilter_notify(net, skb, n, tp, fh, RTM_NEWTFILTER, false);
 610         } else {
 611                 if (tp_created)
 612                         tcf_proto_destroy(tp);
 613         }
 614
 615 errout:
 616         if (chain)
 617                 tcf_chain_put(chain);
 618         if (cl)
 619                 cops->put(q, cl);
 620         if (err == -EAGAIN)
 621                 /* Replay the request. */
 622                 goto replay;
 623         return err;
 624 }
 625
 626 static int tcf_fill_node(struct net *net, struct sk_buff *skb,
 627                          struct tcf_proto *tp, unsigned long fh, u32 portid,
 628                          u32 seq, u16 flags, int event)
 629 {
 630         struct tcmsg *tcm;
 631         struct nlmsghdr  *nlh;
 632         unsigned char *b = skb_tail_pointer(skb);
 633
 634         nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
 635         if (!nlh)
 636                 goto out_nlmsg_trim;
 637         tcm = nlmsg_data(nlh);
 638         tcm->tcm_family = AF_UNSPEC;
 639         tcm->tcm__pad1 = 0;
 640         tcm->tcm__pad2 = 0;
 641         tcm->tcm_ifindex = qdisc_dev(tp->q)->ifindex;
 642         tcm->tcm_parent = tp->classid;
 643         tcm->tcm_info = TC_H_MAKE(tp->prio, tp->protocol);
 644         if (nla_put_string(skb, TCA_KIND, tp->ops->kind))
 645                 goto nla_put_failure;
 646         if (nla_put_u32(skb, TCA_CHAIN, tp->chain->index))
 647                 goto nla_put_failure;
 648         tcm->tcm_handle = fh;
 649         if (RTM_DELTFILTER != event) {
 650                 tcm->tcm_handle = 0;
 651                 if (tp->ops->dump && tp->ops->dump(net, tp, fh, skb, tcm) < 0)
 652                         goto nla_put_failure;
 653         }
 654         nlh->nlmsg_len = skb_tail_pointer(skb) - b;
 655         return skb->len;
 656
 657 out_nlmsg_trim:
 658 nla_put_failure:
 659         nlmsg_trim(skb, b);
 660         return -1;
 661 }
 662
 663 static int tfilter_notify(struct net *net, struct sk_buff *oskb,
 664                           struct nlmsghdr *n, struct tcf_proto *tp,
 665                           unsigned long fh, int event, bool unicast)
 666 {
 667         struct sk_buff *skb;
 668         u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
 669
 670         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
 671         if (!skb)
 672                 return -ENOBUFS;
 673
 674         if (tcf_fill_node(net, skb, tp, fh, portid, n->nlmsg_seq,
 675                           n->nlmsg_flags, event) <= 0) {
 676                 kfree_skb(skb);
 677                 return -EINVAL;
 678         }
 679
 680         if (unicast)
 681                 return netlink_unicast(net->rtnl, skb, portid, MSG_DONTWAIT);
 682
 683         return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
 684                               n->nlmsg_flags & NLM_F_ECHO);
 685 }
 686
 687 struct tcf_dump_args {
 688         struct tcf_walker w;
 689         struct sk_buff *skb;
 690         struct netlink_callback *cb;
 691 };
 692
 693 static int tcf_node_dump(struct tcf_proto *tp, unsigned long n,
 694                          struct tcf_walker *arg)
 695 {
 696         struct tcf_dump_args *a = (void *)arg;
 697         struct net *net = sock_net(a->skb->sk);
 698
 699         return tcf_fill_node(net, a->skb, tp, n, NETLINK_CB(a->cb->skb).portid,
 700                              a->cb->nlh->nlmsg_seq, NLM_F_MULTI,
 701                              RTM_NEWTFILTER);
 702 }
 703
 704 static bool tcf_chain_dump(struct tcf_chain *chain, struct sk_buff *skb,
 705                            struct netlink_callback *cb,
 706                            long index_start, long *p_index)
 707 {
 708         struct net *net = sock_net(skb->sk);
 709         struct tcmsg *tcm = nlmsg_data(cb->nlh);
 710         struct tcf_dump_args arg;
 711         struct tcf_proto *tp;
 712
 713         for (tp = rtnl_dereference(chain->filter_chain);
 714              tp; tp = rtnl_dereference(tp->next), (*p_index)++) {
 715                 if (*p_index < index_start)
 716                         continue;
 717                 if (TC_H_MAJ(tcm->tcm_info) &&
 718                     TC_H_MAJ(tcm->tcm_info) != tp->prio)
 719                         continue;
 720                 if (TC_H_MIN(tcm->tcm_info) &&
 721                     TC_H_MIN(tcm->tcm_info) != tp->protocol)
 722                         continue;
 723                 if (*p_index > index_start)
 724                         memset(&cb->args[1], 0,
 725                                sizeof(cb->args) - sizeof(cb->args[0]));
 726                 if (cb->args[1] == 0) {
 727                         if (tcf_fill_node(net, skb, tp, 0,
 728                                           NETLINK_CB(cb->skb).portid,
 729                                           cb->nlh->nlmsg_seq, NLM_F_MULTI,
 730                                           RTM_NEWTFILTER) <= 0)
 731                                 return false;
 732
 733                         cb->args[1] = 1;
 734                 }
 735                 if (!tp->ops->walk)
 736                         continue;
 737                 arg.w.fn = tcf_node_dump;
 738                 arg.skb = skb;
 739                 arg.cb = cb;
 740                 arg.w.stop = 0;
 741                 arg.w.skip = cb->args[1] - 1;
 742                 arg.w.count = 0;
 743                 tp->ops->walk(tp, &arg.w);
 744                 cb->args[1] = arg.w.count + 1;
 745                 if (arg.w.stop)
 746                         return false;
 747         }
 748         return true;
 749 }
 750
 751 /* called with RTNL */
 752 static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
 753 {
 754         struct net *net = sock_net(skb->sk);
 755         struct nlattr *tca[TCA_MAX + 1];
 756         struct net_device *dev;
 757         struct Qdisc *q;
 758         struct tcf_block *block;
 759         struct tcf_chain *chain;
 760         struct tcmsg *tcm = nlmsg_data(cb->nlh);
 761         unsigned long cl = 0;
 762         const struct Qdisc_class_ops *cops;
 763         long index_start;
 764         long index;
 765         int err;
 766
 767         if (nlmsg_len(cb->nlh) < sizeof(*tcm))
 768                 return skb->len;
 769
 770         err = nlmsg_parse(cb->nlh, sizeof(*tcm), tca, TCA_MAX, NULL, NULL);
 771         if (err)
 772                 return err;
 773
 774         dev = __dev_get_by_index(net, tcm->tcm_ifindex);
 775         if (!dev)
 776                 return skb->len;
 777
 778         if (!tcm->tcm_parent)
 779                 q = dev->qdisc;
 780         else
 781                 q = qdisc_lookup(dev, TC_H_MAJ(tcm->tcm_parent));
 782         if (!q)
 783                 goto out;
 784         cops = q->ops->cl_ops;
 785         if (!cops)
 786                 goto errout;
 787         if (!cops->tcf_block)
 788                 goto errout;
 789         if (TC_H_MIN(tcm->tcm_parent)) {
 790                 cl = cops->get(q, tcm->tcm_parent);
 791                 if (cl == 0)
 792                         goto errout;
 793         }
 794         block = cops->tcf_block(q, cl);
 795         if (!block)
 796                 goto errout;
 797
 798         index_start = cb->args[0];
 799         index = 0;
 800
 801         list_for_each_entry(chain, &block->chain_list, list) {
 802                 if (tca[TCA_CHAIN] &&
 803                     nla_get_u32(tca[TCA_CHAIN]) != chain->index)
 804                         continue;
 805                 if (!tcf_chain_dump(chain, skb, cb, index_start, &index))
 806                         break;
 807         }
 808
 809         cb->args[0] = index;
 810
 811 errout:
 812         if (cl)
 813                 cops->put(q, cl);
 814 out:
 815         return skb->len;
 816 }
 817
 818 void tcf_exts_destroy(struct tcf_exts *exts)
 819 {
 820 #ifdef CONFIG_NET_CLS_ACT
 821         LIST_HEAD(actions);
 822
 823         tcf_exts_to_list(exts, &actions);
 824         tcf_action_destroy(&actions, TCA_ACT_UNBIND);
 825         kfree(exts->actions);
 826         exts->nr_actions = 0;
 827 #endif
 828 }
 829 EXPORT_SYMBOL(tcf_exts_destroy);
 830
 831 int tcf_exts_validate(struct net *net, struct tcf_proto *tp, struct nlattr **tb,
 832                       struct nlattr *rate_tlv, struct tcf_exts *exts, bool ovr)
 833 {
 834 #ifdef CONFIG_NET_CLS_ACT
 835         {
 836                 struct tc_action *act;
 837
 838                 if (exts->police && tb[exts->police]) {
 839                         act = tcf_action_init_1(net, tp, tb[exts->police],
 840                                                 rate_tlv, "police", ovr,
 841                                                 TCA_ACT_BIND);
 842                         if (IS_ERR(act))
 843                                 return PTR_ERR(act);
 844
 845                         act->type = exts->type = TCA_OLD_COMPAT;
 846                         exts->actions[0] = act;
 847                         exts->nr_actions = 1;
 848                 } else if (exts->action && tb[exts->action]) {
 849                         LIST_HEAD(actions);
 850                         int err, i = 0;
 851
 852                         err = tcf_action_init(net, tp, tb[exts->action],
 853                                               rate_tlv, NULL, ovr, TCA_ACT_BIND,
 854                                               &actions);
 855                         if (err)
 856                                 return err;
 857                         list_for_each_entry(act, &actions, list)
 858                                 exts->actions[i++] = act;
 859                         exts->nr_actions = i;
 860                 }
 861         }
 862 #else
 863         if ((exts->action && tb[exts->action]) ||
 864             (exts->police && tb[exts->police]))
 865                 return -EOPNOTSUPP;
 866 #endif
 867
 868         return 0;
 869 }
 870 EXPORT_SYMBOL(tcf_exts_validate);
 871
 872 void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst,
 873                      struct tcf_exts *src)
 874 {
 875 #ifdef CONFIG_NET_CLS_ACT
 876         struct tcf_exts old = *dst;
 877
 878         tcf_tree_lock(tp);
 879         dst->nr_actions = src->nr_actions;
 880         dst->actions = src->actions;
 881         dst->type = src->type;
 882         tcf_tree_unlock(tp);
 883
 884         tcf_exts_destroy(&old);
 885 #endif
 886 }
 887 EXPORT_SYMBOL(tcf_exts_change);
 888
 889 #ifdef CONFIG_NET_CLS_ACT
 890 static struct tc_action *tcf_exts_first_act(struct tcf_exts *exts)
 891 {
 892         if (exts->nr_actions == 0)
 893                 return NULL;
 894         else
 895                 return exts->actions[0];
 896 }
 897 #endif
 898
 899 int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts)
 900 {
 901 #ifdef CONFIG_NET_CLS_ACT
 902         struct nlattr *nest;
 903
 904         if (exts->action && exts->nr_actions) {
 905                 /*
 906                  * again for backward compatible mode - we want
 907                  * to work with both old and new modes of entering
 908                  * tc data even if iproute2  was newer - jhs
 909                  */
 910                 if (exts->type != TCA_OLD_COMPAT) {
 911                         LIST_HEAD(actions);
 912
 913                         nest = nla_nest_start(skb, exts->action);
 914                         if (nest == NULL)
 915                                 goto nla_put_failure;
 916
 917                         tcf_exts_to_list(exts, &actions);
 918                         if (tcf_action_dump(skb, &actions, 0, 0) < 0)
 919                                 goto nla_put_failure;
 920                         nla_nest_end(skb, nest);
 921                 } else if (exts->police) {
 922                         struct tc_action *act = tcf_exts_first_act(exts);
 923                         nest = nla_nest_start(skb, exts->police);
 924                         if (nest == NULL || !act)
 925                                 goto nla_put_failure;
 926                         if (tcf_action_dump_old(skb, act, 0, 0) < 0)
 927                                 goto nla_put_failure;
 928                         nla_nest_end(skb, nest);
 929                 }
 930         }
 931         return 0;
 932
 933 nla_put_failure:
 934         nla_nest_cancel(skb, nest);
 935         return -1;
 936 #else
 937         return 0;
 938 #endif
 939 }
 940 EXPORT_SYMBOL(tcf_exts_dump);
 941
 942
 943 int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts)
 944 {
 945 #ifdef CONFIG_NET_CLS_ACT
 946         struct tc_action *a = tcf_exts_first_act(exts);
 947         if (a != NULL && tcf_action_copy_stats(skb, a, 1) < 0)
 948                 return -1;
 949 #endif
 950         return 0;
 951 }
 952 EXPORT_SYMBOL(tcf_exts_dump_stats);
 953
 954 int tcf_exts_get_dev(struct net_device *dev, struct tcf_exts *exts,
 955                      struct net_device **hw_dev)
 956 {
 957 #ifdef CONFIG_NET_CLS_ACT
 958         const struct tc_action *a;
 959         LIST_HEAD(actions);
 960
 961         if (tc_no_actions(exts))
 962                 return -EINVAL;
 963
 964         tcf_exts_to_list(exts, &actions);
 965         list_for_each_entry(a, &actions, list) {
 966                 if (a->ops->get_dev) {
 967                         a->ops->get_dev(a, dev_net(dev), hw_dev);
 968                         break;
 969                 }
 970         }
 971         if (*hw_dev)
 972                 return 0;
 973 #endif
 974         return -EOPNOTSUPP;
 975 }
 976 EXPORT_SYMBOL(tcf_exts_get_dev);
 977
 978 static int __init tc_filter_init(void)
 979 {
 980         rtnl_register(PF_UNSPEC, RTM_NEWTFILTER, tc_ctl_tfilter, NULL, NULL);
 981         rtnl_register(PF_UNSPEC, RTM_DELTFILTER, tc_ctl_tfilter, NULL, NULL);
 982         rtnl_register(PF_UNSPEC, RTM_GETTFILTER, tc_ctl_tfilter,
 983                       tc_dump_tfilter, NULL);
 984
 985         return 0;
 986 }
 987
 988 subsys_initcall(tc_filter_init);