net/sched/sch_api.c

   1 /*
   2  * net/sched/sch_api.c  Packet scheduler 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  * Fixes:
  12  *
  13  * Rani Assaf <rani@magic.metawire.com> :980802: JIFFIES and CPU clock sources are repaired.
  14  * Eduardo J. Blanco <ejbs@netlabs.com.uy> :990222: kmod support
  15  * Jamal Hadi Salim <hadi@nortelnetworks.com>: 990601: ingress support
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/types.h>
  20 #include <linux/kernel.h>
  21 #include <linux/string.h>
  22 #include <linux/errno.h>
  23 #include <linux/skbuff.h>
  24 #include <linux/init.h>
  25 #include <linux/proc_fs.h>
  26 #include <linux/seq_file.h>
  27 #include <linux/kmod.h>
  28 #include <linux/list.h>
  29 #include <linux/hrtimer.h>
  30 #include <linux/lockdep.h>
  31
  32 #include <net/net_namespace.h>
  33 #include <net/sock.h>
  34 #include <net/netlink.h>
  35 #include <net/pkt_sched.h>
  36
  37 static int qdisc_notify(struct sk_buff *oskb, struct nlmsghdr *n, u32 clid,
  38                         struct Qdisc *old, struct Qdisc *new);
  39 static int tclass_notify(struct sk_buff *oskb, struct nlmsghdr *n,
  40                          struct Qdisc *q, unsigned long cl, int event);
  41
  42 /*
  43
  44    Short review.
  45    -------------
  46
  47    This file consists of two interrelated parts:
  48
  49    1. queueing disciplines manager frontend.
  50    2. traffic classes manager frontend.
  51
  52    Generally, queueing discipline ("qdisc") is a black box,
  53    which is able to enqueue packets and to dequeue them (when
  54    device is ready to send something) in order and at times
  55    determined by algorithm hidden in it.
  56
  57    qdisc's are divided to two categories:
  58    - "queues", which have no internal structure visible from outside.
  59    - "schedulers", which split all the packets to "traffic classes",
  60      using "packet classifiers" (look at cls_api.c)
  61
  62    In turn, classes may have child qdiscs (as rule, queues)
  63    attached to them etc. etc. etc.
  64
  65    The goal of the routines in this file is to translate
  66    information supplied by user in the form of handles
  67    to more intelligible for kernel form, to make some sanity
  68    checks and part of work, which is common to all qdiscs
  69    and to provide rtnetlink notifications.
  70
  71    All real intelligent work is done inside qdisc modules.
  72
  73
  74
  75    Every discipline has two major routines: enqueue and dequeue.
  76
  77    ---dequeue
  78
  79    dequeue usually returns a skb to send. It is allowed to return NULL,
  80    but it does not mean that queue is empty, it just means that
  81    discipline does not want to send anything this time.
  82    Queue is really empty if q->q.qlen == 0.
  83    For complicated disciplines with multiple queues q->q is not
  84    real packet queue, but however q->q.qlen must be valid.
  85
  86    ---enqueue
  87
  88    enqueue returns 0, if packet was enqueued successfully.
  89    If packet (this one or another one) was dropped, it returns
  90    not zero error code.
  91    NET_XMIT_DROP        - this packet dropped
  92      Expected action: do not backoff, but wait until queue will clear.
  93    NET_XMIT_CN          - probably this packet enqueued, but another one dropped.
  94      Expected action: backoff or ignore
  95    NET_XMIT_POLICED     - dropped by police.
  96      Expected action: backoff or error to real-time apps.
  97
  98    Auxiliary routines:
  99
 100    ---peek
 101
 102    like dequeue but without removing a packet from the queue
 103
 104    ---reset
 105
 106    returns qdisc to initial state: purge all buffers, clear all
 107    timers, counters (except for statistics) etc.
 108
 109    ---init
 110
 111    initializes newly created qdisc.
 112
 113    ---destroy
 114
 115    destroys resources allocated by init and during lifetime of qdisc.
 116
 117    ---change
 118
 119    changes qdisc parameters.
 120  */
 121
 122 /* Protects list of registered TC modules. It is pure SMP lock. */
 123 static DEFINE_RWLOCK(qdisc_mod_lock);
 124
 125
 126 /************************************************
 127  *      Queueing disciplines manipulation.      *
 128  ************************************************/
 129
 130
 131 /* The list of all installed queueing disciplines. */
 132
 133 static struct Qdisc_ops *qdisc_base;
 134
 135 /* Register/uregister queueing discipline */
 136
 137 int register_qdisc(struct Qdisc_ops *qops)
 138 {
 139         struct Qdisc_ops *q, **qp;
 140         int rc = -EEXIST;
 141
 142         write_lock(&qdisc_mod_lock);
 143         for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
 144                 if (!strcmp(qops->id, q->id))
 145                         goto out;
 146
 147         if (qops->enqueue == NULL)
 148                 qops->enqueue = noop_qdisc_ops.enqueue;
 149         if (qops->peek == NULL) {
 150                 if (qops->dequeue == NULL) {
 151                         qops->peek = noop_qdisc_ops.peek;
 152                 } else {
 153                         rc = -EINVAL;
 154                         goto out;
 155                 }
 156         }
 157         if (qops->dequeue == NULL)
 158                 qops->dequeue = noop_qdisc_ops.dequeue;
 159
 160         qops->next = NULL;
 161         *qp = qops;
 162         rc = 0;
 163 out:
 164         write_unlock(&qdisc_mod_lock);
 165         return rc;
 166 }
 167 EXPORT_SYMBOL(register_qdisc);
 168
 169 int unregister_qdisc(struct Qdisc_ops *qops)
 170 {
 171         struct Qdisc_ops *q, **qp;
 172         int err = -ENOENT;
 173
 174         write_lock(&qdisc_mod_lock);
 175         for (qp = &qdisc_base; (q=*qp)!=NULL; qp = &q->next)
 176                 if (q == qops)
 177                         break;
 178         if (q) {
 179                 *qp = q->next;
 180                 q->next = NULL;
 181                 err = 0;
 182         }
 183         write_unlock(&qdisc_mod_lock);
 184         return err;
 185 }
 186 EXPORT_SYMBOL(unregister_qdisc);
 187
 188 /* We know handle. Find qdisc among all qdisc's attached to device
 189    (root qdisc, all its children, children of children etc.)
 190  */
 191
 192 static struct Qdisc *qdisc_match_from_root(struct Qdisc *root, u32 handle)
 193 {
 194         struct Qdisc *q;
 195
 196         if (!(root->flags & TCQ_F_BUILTIN) &&
 197             root->handle == handle)
 198                 return root;
 199
 200         list_for_each_entry(q, &root->list, list) {
 201                 if (q->handle == handle)
 202                         return q;
 203         }
 204         return NULL;
 205 }
 206
 207 static void qdisc_list_add(struct Qdisc *q)
 208 {
 209         if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS))
 210                 list_add_tail(&q->list, &qdisc_root_sleeping(q)->list);
 211 }
 212
 213 void qdisc_list_del(struct Qdisc *q)
 214 {
 215         if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS))
 216                 list_del(&q->list);
 217 }
 218 EXPORT_SYMBOL(qdisc_list_del);
 219
 220 struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle)
 221 {
 222         unsigned int i;
 223         struct Qdisc *q;
 224
 225         for (i = 0; i < dev->num_tx_queues; i++) {
 226                 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 227                 struct Qdisc *txq_root = txq->qdisc_sleeping;
 228
 229                 q = qdisc_match_from_root(txq_root, handle);
 230                 if (q)
 231                         goto out;
 232         }
 233
 234         q = qdisc_match_from_root(dev->rx_queue.qdisc_sleeping, handle);
 235 out:
 236         return q;
 237 }
 238
 239 static struct Qdisc *qdisc_leaf(struct Qdisc *p, u32 classid)
 240 {
 241         unsigned long cl;
 242         struct Qdisc *leaf;
 243         const struct Qdisc_class_ops *cops = p->ops->cl_ops;
 244
 245         if (cops == NULL)
 246                 return NULL;
 247         cl = cops->get(p, classid);
 248
 249         if (cl == 0)
 250                 return NULL;
 251         leaf = cops->leaf(p, cl);
 252         cops->put(p, cl);
 253         return leaf;
 254 }
 255
 256 /* Find queueing discipline by name */
 257
 258 static struct Qdisc_ops *qdisc_lookup_ops(struct nlattr *kind)
 259 {
 260         struct Qdisc_ops *q = NULL;
 261
 262         if (kind) {
 263                 read_lock(&qdisc_mod_lock);
 264                 for (q = qdisc_base; q; q = q->next) {
 265                         if (nla_strcmp(kind, q->id) == 0) {
 266                                 if (!try_module_get(q->owner))
 267                                         q = NULL;
 268                                 break;
 269                         }
 270                 }
 271                 read_unlock(&qdisc_mod_lock);
 272         }
 273         return q;
 274 }
 275
 276 static struct qdisc_rate_table *qdisc_rtab_list;
 277
 278 struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct nlattr *tab)
 279 {
 280         struct qdisc_rate_table *rtab;
 281
 282         for (rtab = qdisc_rtab_list; rtab; rtab = rtab->next) {
 283                 if (memcmp(&rtab->rate, r, sizeof(struct tc_ratespec)) == 0) {
 284                         rtab->refcnt++;
 285                         return rtab;
 286                 }
 287         }
 288
 289         if (tab == NULL || r->rate == 0 || r->cell_log == 0 ||
 290             nla_len(tab) != TC_RTAB_SIZE)
 291                 return NULL;
 292
 293         rtab = kmalloc(sizeof(*rtab), GFP_KERNEL);
 294         if (rtab) {
 295                 rtab->rate = *r;
 296                 rtab->refcnt = 1;
 297                 memcpy(rtab->data, nla_data(tab), 1024);
 298                 rtab->next = qdisc_rtab_list;
 299                 qdisc_rtab_list = rtab;
 300         }
 301         return rtab;
 302 }
 303 EXPORT_SYMBOL(qdisc_get_rtab);
 304
 305 void qdisc_put_rtab(struct qdisc_rate_table *tab)
 306 {
 307         struct qdisc_rate_table *rtab, **rtabp;
 308
 309         if (!tab || --tab->refcnt)
 310                 return;
 311
 312         for (rtabp = &qdisc_rtab_list; (rtab=*rtabp) != NULL; rtabp = &rtab->next) {
 313                 if (rtab == tab) {
 314                         *rtabp = rtab->next;
 315                         kfree(rtab);
 316                         return;
 317                 }
 318         }
 319 }
 320 EXPORT_SYMBOL(qdisc_put_rtab);
 321
 322 static LIST_HEAD(qdisc_stab_list);
 323 static DEFINE_SPINLOCK(qdisc_stab_lock);
 324
 325 static const struct nla_policy stab_policy[TCA_STAB_MAX + 1] = {
 326         [TCA_STAB_BASE] = { .len = sizeof(struct tc_sizespec) },
 327         [TCA_STAB_DATA] = { .type = NLA_BINARY },
 328 };
 329
 330 static struct qdisc_size_table *qdisc_get_stab(struct nlattr *opt)
 331 {
 332         struct nlattr *tb[TCA_STAB_MAX + 1];
 333         struct qdisc_size_table *stab;
 334         struct tc_sizespec *s;
 335         unsigned int tsize = 0;
 336         u16 *tab = NULL;
 337         int err;
 338
 339         err = nla_parse_nested(tb, TCA_STAB_MAX, opt, stab_policy);
 340         if (err < 0)
 341                 return ERR_PTR(err);
 342         if (!tb[TCA_STAB_BASE])
 343                 return ERR_PTR(-EINVAL);
 344
 345         s = nla_data(tb[TCA_STAB_BASE]);
 346
 347         if (s->tsize > 0) {
 348                 if (!tb[TCA_STAB_DATA])
 349                         return ERR_PTR(-EINVAL);
 350                 tab = nla_data(tb[TCA_STAB_DATA]);
 351                 tsize = nla_len(tb[TCA_STAB_DATA]) / sizeof(u16);
 352         }
 353
 354         if (!s || tsize != s->tsize || (!tab && tsize > 0))
 355                 return ERR_PTR(-EINVAL);
 356
 357         spin_lock(&qdisc_stab_lock);
 358
 359         list_for_each_entry(stab, &qdisc_stab_list, list) {
 360                 if (memcmp(&stab->szopts, s, sizeof(*s)))
 361                         continue;
 362                 if (tsize > 0 && memcmp(stab->data, tab, tsize * sizeof(u16)))
 363                         continue;
 364                 stab->refcnt++;
 365                 spin_unlock(&qdisc_stab_lock);
 366                 return stab;
 367         }
 368
 369         spin_unlock(&qdisc_stab_lock);
 370
 371         stab = kmalloc(sizeof(*stab) + tsize * sizeof(u16), GFP_KERNEL);
 372         if (!stab)
 373                 return ERR_PTR(-ENOMEM);
 374
 375         stab->refcnt = 1;
 376         stab->szopts = *s;
 377         if (tsize > 0)
 378                 memcpy(stab->data, tab, tsize * sizeof(u16));
 379
 380         spin_lock(&qdisc_stab_lock);
 381         list_add_tail(&stab->list, &qdisc_stab_list);
 382         spin_unlock(&qdisc_stab_lock);
 383
 384         return stab;
 385 }
 386
 387 void qdisc_put_stab(struct qdisc_size_table *tab)
 388 {
 389         if (!tab)
 390                 return;
 391
 392         spin_lock(&qdisc_stab_lock);
 393
 394         if (--tab->refcnt == 0) {
 395                 list_del(&tab->list);
 396                 kfree(tab);
 397         }
 398
 399         spin_unlock(&qdisc_stab_lock);
 400 }
 401 EXPORT_SYMBOL(qdisc_put_stab);
 402
 403 static int qdisc_dump_stab(struct sk_buff *skb, struct qdisc_size_table *stab)
 404 {
 405         struct nlattr *nest;
 406
 407         nest = nla_nest_start(skb, TCA_STAB);
 408         if (nest == NULL)
 409                 goto nla_put_failure;
 410         NLA_PUT(skb, TCA_STAB_BASE, sizeof(stab->szopts), &stab->szopts);
 411         nla_nest_end(skb, nest);
 412
 413         return skb->len;
 414
 415 nla_put_failure:
 416         return -1;
 417 }
 418
 419 void qdisc_calculate_pkt_len(struct sk_buff *skb, struct qdisc_size_table *stab)
 420 {
 421         int pkt_len, slot;
 422
 423         pkt_len = skb->len + stab->szopts.overhead;
 424         if (unlikely(!stab->szopts.tsize))
 425                 goto out;
 426
 427         slot = pkt_len + stab->szopts.cell_align;
 428         if (unlikely(slot < 0))
 429                 slot = 0;
 430
 431         slot >>= stab->szopts.cell_log;
 432         if (likely(slot < stab->szopts.tsize))
 433                 pkt_len = stab->data[slot];
 434         else
 435                 pkt_len = stab->data[stab->szopts.tsize - 1] *
 436                                 (slot / stab->szopts.tsize) +
 437                                 stab->data[slot % stab->szopts.tsize];
 438
 439         pkt_len <<= stab->szopts.size_log;
 440 out:
 441         if (unlikely(pkt_len < 1))
 442                 pkt_len = 1;
 443         qdisc_skb_cb(skb)->pkt_len = pkt_len;
 444 }
 445 EXPORT_SYMBOL(qdisc_calculate_pkt_len);
 446
 447 static enum hrtimer_restart qdisc_watchdog(struct hrtimer *timer)
 448 {
 449         struct qdisc_watchdog *wd = container_of(timer, struct qdisc_watchdog,
 450                                                  timer);
 451
 452         wd->qdisc->flags &= ~TCQ_F_THROTTLED;
 453         __netif_schedule(qdisc_root(wd->qdisc));
 454
 455         return HRTIMER_NORESTART;
 456 }
 457
 458 void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc)
 459 {
 460         hrtimer_init(&wd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
 461         wd->timer.function = qdisc_watchdog;
 462         wd->qdisc = qdisc;
 463 }
 464 EXPORT_SYMBOL(qdisc_watchdog_init);
 465
 466 void qdisc_watchdog_schedule(struct qdisc_watchdog *wd, psched_time_t expires)
 467 {
 468         ktime_t time;
 469
 470         if (test_bit(__QDISC_STATE_DEACTIVATED,
 471                      &qdisc_root_sleeping(wd->qdisc)->state))
 472                 return;
 473
 474         wd->qdisc->flags |= TCQ_F_THROTTLED;
 475         time = ktime_set(0, 0);
 476         time = ktime_add_ns(time, PSCHED_US2NS(expires));
 477         hrtimer_start(&wd->timer, time, HRTIMER_MODE_ABS);
 478 }
 479 EXPORT_SYMBOL(qdisc_watchdog_schedule);
 480
 481 void qdisc_watchdog_cancel(struct qdisc_watchdog *wd)
 482 {
 483         hrtimer_cancel(&wd->timer);
 484         wd->qdisc->flags &= ~TCQ_F_THROTTLED;
 485 }
 486 EXPORT_SYMBOL(qdisc_watchdog_cancel);
 487
 488 static struct hlist_head *qdisc_class_hash_alloc(unsigned int n)
 489 {
 490         unsigned int size = n * sizeof(struct hlist_head), i;
 491         struct hlist_head *h;
 492
 493         if (size <= PAGE_SIZE)
 494                 h = kmalloc(size, GFP_KERNEL);
 495         else
 496                 h = (struct hlist_head *)
 497                         __get_free_pages(GFP_KERNEL, get_order(size));
 498
 499         if (h != NULL) {
 500                 for (i = 0; i < n; i++)
 501                         INIT_HLIST_HEAD(&h[i]);
 502         }
 503         return h;
 504 }
 505
 506 static void qdisc_class_hash_free(struct hlist_head *h, unsigned int n)
 507 {
 508         unsigned int size = n * sizeof(struct hlist_head);
 509
 510         if (size <= PAGE_SIZE)
 511                 kfree(h);
 512         else
 513                 free_pages((unsigned long)h, get_order(size));
 514 }
 515
 516 void qdisc_class_hash_grow(struct Qdisc *sch, struct Qdisc_class_hash *clhash)
 517 {
 518         struct Qdisc_class_common *cl;
 519         struct hlist_node *n, *next;
 520         struct hlist_head *nhash, *ohash;
 521         unsigned int nsize, nmask, osize;
 522         unsigned int i, h;
 523
 524         /* Rehash when load factor exceeds 0.75 */
 525         if (clhash->hashelems * 4 <= clhash->hashsize * 3)
 526                 return;
 527         nsize = clhash->hashsize * 2;
 528         nmask = nsize - 1;
 529         nhash = qdisc_class_hash_alloc(nsize);
 530         if (nhash == NULL)
 531                 return;
 532
 533         ohash = clhash->hash;
 534         osize = clhash->hashsize;
 535
 536         sch_tree_lock(sch);
 537         for (i = 0; i < osize; i++) {
 538                 hlist_for_each_entry_safe(cl, n, next, &ohash[i], hnode) {
 539                         h = qdisc_class_hash(cl->classid, nmask);
 540                         hlist_add_head(&cl->hnode, &nhash[h]);
 541                 }
 542         }
 543         clhash->hash     = nhash;
 544         clhash->hashsize = nsize;
 545         clhash->hashmask = nmask;
 546         sch_tree_unlock(sch);
 547
 548         qdisc_class_hash_free(ohash, osize);
 549 }
 550 EXPORT_SYMBOL(qdisc_class_hash_grow);
 551
 552 int qdisc_class_hash_init(struct Qdisc_class_hash *clhash)
 553 {
 554         unsigned int size = 4;
 555
 556         clhash->hash = qdisc_class_hash_alloc(size);
 557         if (clhash->hash == NULL)
 558                 return -ENOMEM;
 559         clhash->hashsize  = size;
 560         clhash->hashmask  = size - 1;
 561         clhash->hashelems = 0;
 562         return 0;
 563 }
 564 EXPORT_SYMBOL(qdisc_class_hash_init);
 565
 566 void qdisc_class_hash_destroy(struct Qdisc_class_hash *clhash)
 567 {
 568         qdisc_class_hash_free(clhash->hash, clhash->hashsize);
 569 }
 570 EXPORT_SYMBOL(qdisc_class_hash_destroy);
 571
 572 void qdisc_class_hash_insert(struct Qdisc_class_hash *clhash,
 573                              struct Qdisc_class_common *cl)
 574 {
 575         unsigned int h;
 576
 577         INIT_HLIST_NODE(&cl->hnode);
 578         h = qdisc_class_hash(cl->classid, clhash->hashmask);
 579         hlist_add_head(&cl->hnode, &clhash->hash[h]);
 580         clhash->hashelems++;
 581 }
 582 EXPORT_SYMBOL(qdisc_class_hash_insert);
 583
 584 void qdisc_class_hash_remove(struct Qdisc_class_hash *clhash,
 585                              struct Qdisc_class_common *cl)
 586 {
 587         hlist_del(&cl->hnode);
 588         clhash->hashelems--;
 589 }
 590 EXPORT_SYMBOL(qdisc_class_hash_remove);
 591
 592 /* Allocate an unique handle from space managed by kernel */
 593
 594 static u32 qdisc_alloc_handle(struct net_device *dev)
 595 {
 596         int i = 0x10000;
 597         static u32 autohandle = TC_H_MAKE(0x80000000U, 0);
 598
 599         do {
 600                 autohandle += TC_H_MAKE(0x10000U, 0);
 601                 if (autohandle == TC_H_MAKE(TC_H_ROOT, 0))
 602                         autohandle = TC_H_MAKE(0x80000000U, 0);
 603         } while (qdisc_lookup(dev, autohandle) && --i > 0);
 604
 605         return i>0 ? autohandle : 0;
 606 }
 607
 608 /* Attach toplevel qdisc to device queue. */
 609
 610 static struct Qdisc *dev_graft_qdisc(struct netdev_queue *dev_queue,
 611                                      struct Qdisc *qdisc)
 612 {
 613         struct Qdisc *oqdisc = dev_queue->qdisc_sleeping;
 614         spinlock_t *root_lock;
 615
 616         root_lock = qdisc_lock(oqdisc);
 617         spin_lock_bh(root_lock);
 618
 619         /* Prune old scheduler */
 620         if (oqdisc && atomic_read(&oqdisc->refcnt) <= 1)
 621                 qdisc_reset(oqdisc);
 622
 623         /* ... and graft new one */
 624         if (qdisc == NULL)
 625                 qdisc = &noop_qdisc;
 626         dev_queue->qdisc_sleeping = qdisc;
 627         rcu_assign_pointer(dev_queue->qdisc, &noop_qdisc);
 628
 629         spin_unlock_bh(root_lock);
 630
 631         return oqdisc;
 632 }
 633
 634 void qdisc_tree_decrease_qlen(struct Qdisc *sch, unsigned int n)
 635 {
 636         const struct Qdisc_class_ops *cops;
 637         unsigned long cl;
 638         u32 parentid;
 639
 640         if (n == 0)
 641                 return;
 642         while ((parentid = sch->parent)) {
 643                 if (TC_H_MAJ(parentid) == TC_H_MAJ(TC_H_INGRESS))
 644                         return;
 645
 646                 sch = qdisc_lookup(qdisc_dev(sch), TC_H_MAJ(parentid));
 647                 if (sch == NULL) {
 648                         WARN_ON(parentid != TC_H_ROOT);
 649                         return;
 650                 }
 651                 cops = sch->ops->cl_ops;
 652                 if (cops->qlen_notify) {
 653                         cl = cops->get(sch, parentid);
 654                         cops->qlen_notify(sch, cl);
 655                         cops->put(sch, cl);
 656                 }
 657                 sch->q.qlen -= n;
 658         }
 659 }
 660 EXPORT_SYMBOL(qdisc_tree_decrease_qlen);
 661
 662 static void notify_and_destroy(struct sk_buff *skb, struct nlmsghdr *n, u32 clid,
 663                                struct Qdisc *old, struct Qdisc *new)
 664 {
 665         if (new || old)
 666                 qdisc_notify(skb, n, clid, old, new);
 667
 668         if (old)
 669                 qdisc_destroy(old);
 670 }
 671
 672 /* Graft qdisc "new" to class "classid" of qdisc "parent" or
 673  * to device "dev".
 674  *
 675  * When appropriate send a netlink notification using 'skb'
 676  * and "n".
 677  *
 678  * On success, destroy old qdisc.
 679  */
 680
 681 static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
 682                        struct sk_buff *skb, struct nlmsghdr *n, u32 classid,
 683                        struct Qdisc *new, struct Qdisc *old)
 684 {
 685         struct Qdisc *q = old;
 686         int err = 0;
 687
 688         if (parent == NULL) {
 689                 unsigned int i, num_q, ingress;
 690
 691                 ingress = 0;
 692                 num_q = dev->num_tx_queues;
 693                 if ((q && q->flags & TCQ_F_INGRESS) ||
 694                     (new && new->flags & TCQ_F_INGRESS)) {
 695                         num_q = 1;
 696                         ingress = 1;
 697                 }
 698
 699                 if (dev->flags & IFF_UP)
 700                         dev_deactivate(dev);
 701
 702                 for (i = 0; i < num_q; i++) {
 703                         struct netdev_queue *dev_queue = &dev->rx_queue;
 704
 705                         if (!ingress)
 706                                 dev_queue = netdev_get_tx_queue(dev, i);
 707
 708                         old = dev_graft_qdisc(dev_queue, new);
 709                         if (new && i > 0)
 710                                 atomic_inc(&new->refcnt);
 711
 712                         notify_and_destroy(skb, n, classid, old, new);
 713                 }
 714
 715                 if (dev->flags & IFF_UP)
 716                         dev_activate(dev);
 717         } else {
 718                 const struct Qdisc_class_ops *cops = parent->ops->cl_ops;
 719
 720                 err = -EINVAL;
 721
 722                 if (cops) {
 723                         unsigned long cl = cops->get(parent, classid);
 724                         if (cl) {
 725                                 err = cops->graft(parent, cl, new, &old);
 726                                 cops->put(parent, cl);
 727                         }
 728                 }
 729                 if (!err)
 730                         notify_and_destroy(skb, n, classid, old, new);
 731         }
 732         return err;
 733 }
 734
 735 /* lockdep annotation is needed for ingress; egress gets it only for name */
 736 static struct lock_class_key qdisc_tx_lock;
 737 static struct lock_class_key qdisc_rx_lock;
 738
 739 /*
 740    Allocate and initialize new qdisc.
 741
 742    Parameters are passed via opt.
 743  */
 744
 745 static struct Qdisc *
 746 qdisc_create(struct net_device *dev, struct netdev_queue *dev_queue,
 747              u32 parent, u32 handle, struct nlattr **tca, int *errp)
 748 {
 749         int err;
 750         struct nlattr *kind = tca[TCA_KIND];
 751         struct Qdisc *sch;
 752         struct Qdisc_ops *ops;
 753         struct qdisc_size_table *stab;
 754
 755         ops = qdisc_lookup_ops(kind);
 756 #ifdef CONFIG_MODULES
 757         if (ops == NULL && kind != NULL) {
 758                 char name[IFNAMSIZ];
 759                 if (nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) {
 760                         /* We dropped the RTNL semaphore in order to
 761                          * perform the module load.  So, even if we
 762                          * succeeded in loading the module we have to
 763                          * tell the caller to replay the request.  We
 764                          * indicate this using -EAGAIN.
 765                          * We replay the request because the device may
 766                          * go away in the mean time.
 767                          */
 768                         rtnl_unlock();
 769                         request_module("sch_%s", name);
 770                         rtnl_lock();
 771                         ops = qdisc_lookup_ops(kind);
 772                         if (ops != NULL) {
 773                                 /* We will try again qdisc_lookup_ops,
 774                                  * so don't keep a reference.
 775                                  */
 776                                 module_put(ops->owner);
 777                                 err = -EAGAIN;
 778                                 goto err_out;
 779                         }
 780                 }
 781         }
 782 #endif
 783
 784         err = -ENOENT;
 785         if (ops == NULL)
 786                 goto err_out;
 787
 788         sch = qdisc_alloc(dev_queue, ops);
 789         if (IS_ERR(sch)) {
 790                 err = PTR_ERR(sch);
 791                 goto err_out2;
 792         }
 793
 794         sch->parent = parent;
 795
 796         if (handle == TC_H_INGRESS) {
 797                 sch->flags |= TCQ_F_INGRESS;
 798                 handle = TC_H_MAKE(TC_H_INGRESS, 0);
 799                 lockdep_set_class(qdisc_lock(sch), &qdisc_rx_lock);
 800         } else {
 801                 if (handle == 0) {
 802                         handle = qdisc_alloc_handle(dev);
 803                         err = -ENOMEM;
 804                         if (handle == 0)
 805                                 goto err_out3;
 806                 }
 807                 lockdep_set_class(qdisc_lock(sch), &qdisc_tx_lock);
 808         }
 809
 810         sch->handle = handle;
 811
 812         if (!ops->init || (err = ops->init(sch, tca[TCA_OPTIONS])) == 0) {
 813                 if (tca[TCA_STAB]) {
 814                         stab = qdisc_get_stab(tca[TCA_STAB]);
 815                         if (IS_ERR(stab)) {
 816                                 err = PTR_ERR(stab);
 817                                 goto err_out3;
 818                         }
 819                         sch->stab = stab;
 820                 }
 821                 if (tca[TCA_RATE]) {
 822                         spinlock_t *root_lock;
 823
 824                         if ((sch->parent != TC_H_ROOT) &&
 825                             !(sch->flags & TCQ_F_INGRESS))
 826                                 root_lock = qdisc_root_sleeping_lock(sch);
 827                         else
 828                                 root_lock = qdisc_lock(sch);
 829
 830                         err = gen_new_estimator(&sch->bstats, &sch->rate_est,
 831                                                 root_lock, tca[TCA_RATE]);
 832                         if (err) {
 833                                 /*
 834                                  * Any broken qdiscs that would require
 835                                  * a ops->reset() here? The qdisc was never
 836                                  * in action so it shouldn't be necessary.
 837                                  */
 838                                 if (ops->destroy)
 839                                         ops->destroy(sch);
 840                                 goto err_out3;
 841                         }
 842                 }
 843
 844                 qdisc_list_add(sch);
 845
 846                 return sch;
 847         }
 848 err_out3:
 849         qdisc_put_stab(sch->stab);
 850         dev_put(dev);
 851         kfree((char *) sch - sch->padded);
 852 err_out2:
 853         module_put(ops->owner);
 854 err_out:
 855         *errp = err;
 856         return NULL;
 857 }
 858
 859 static int qdisc_change(struct Qdisc *sch, struct nlattr **tca)
 860 {
 861         struct qdisc_size_table *stab = NULL;
 862         int err = 0;
 863
 864         if (tca[TCA_OPTIONS]) {
 865                 if (sch->ops->change == NULL)
 866                         return -EINVAL;
 867                 err = sch->ops->change(sch, tca[TCA_OPTIONS]);
 868                 if (err)
 869                         return err;
 870         }
 871
 872         if (tca[TCA_STAB]) {
 873                 stab = qdisc_get_stab(tca[TCA_STAB]);
 874                 if (IS_ERR(stab))
 875                         return PTR_ERR(stab);
 876         }
 877
 878         qdisc_put_stab(sch->stab);
 879         sch->stab = stab;
 880
 881         if (tca[TCA_RATE])
 882                 /* NB: ignores errors from replace_estimator
 883                    because change can't be undone. */
 884                 gen_replace_estimator(&sch->bstats, &sch->rate_est,
 885                                             qdisc_root_sleeping_lock(sch),
 886                                             tca[TCA_RATE]);
 887
 888         return 0;
 889 }
 890
 891 struct check_loop_arg
 892 {
 893         struct qdisc_walker     w;
 894         struct Qdisc            *p;
 895         int                     depth;
 896 };
 897
 898 static int check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w);
 899
 900 static int check_loop(struct Qdisc *q, struct Qdisc *p, int depth)
 901 {
 902         struct check_loop_arg   arg;
 903
 904         if (q->ops->cl_ops == NULL)
 905                 return 0;
 906
 907         arg.w.stop = arg.w.skip = arg.w.count = 0;
 908         arg.w.fn = check_loop_fn;
 909         arg.depth = depth;
 910         arg.p = p;
 911         q->ops->cl_ops->walk(q, &arg.w);
 912         return arg.w.stop ? -ELOOP : 0;
 913 }
 914
 915 static int
 916 check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w)
 917 {
 918         struct Qdisc *leaf;
 919         const struct Qdisc_class_ops *cops = q->ops->cl_ops;
 920         struct check_loop_arg *arg = (struct check_loop_arg *)w;
 921
 922         leaf = cops->leaf(q, cl);
 923         if (leaf) {
 924                 if (leaf == arg->p || arg->depth > 7)
 925                         return -ELOOP;
 926                 return check_loop(leaf, arg->p, arg->depth + 1);
 927         }
 928         return 0;
 929 }
 930
 931 /*
 932  * Delete/get qdisc.
 933  */
 934
 935 static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
 936 {
 937         struct net *net = sock_net(skb->sk);
 938         struct tcmsg *tcm = NLMSG_DATA(n);
 939         struct nlattr *tca[TCA_MAX + 1];
 940         struct net_device *dev;
 941         u32 clid = tcm->tcm_parent;
 942         struct Qdisc *q = NULL;
 943         struct Qdisc *p = NULL;
 944         int err;
 945
 946         if (net != &init_net)
 947                 return -EINVAL;
 948
 949         if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
 950                 return -ENODEV;
 951
 952         err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
 953         if (err < 0)
 954                 return err;
 955
 956         if (clid) {
 957                 if (clid != TC_H_ROOT) {
 958                         if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) {
 959                                 if ((p = qdisc_lookup(dev, TC_H_MAJ(clid))) == NULL)
 960                                         return -ENOENT;
 961                                 q = qdisc_leaf(p, clid);
 962                         } else { /* ingress */
 963                                 q = dev->rx_queue.qdisc_sleeping;
 964                         }
 965                 } else {
 966                         struct netdev_queue *dev_queue;
 967                         dev_queue = netdev_get_tx_queue(dev, 0);
 968                         q = dev_queue->qdisc_sleeping;
 969                 }
 970                 if (!q)
 971                         return -ENOENT;
 972
 973                 if (tcm->tcm_handle && q->handle != tcm->tcm_handle)
 974                         return -EINVAL;
 975         } else {
 976                 if ((q = qdisc_lookup(dev, tcm->tcm_handle)) == NULL)
 977                         return -ENOENT;
 978         }
 979
 980         if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
 981                 return -EINVAL;
 982
 983         if (n->nlmsg_type == RTM_DELQDISC) {
 984                 if (!clid)
 985                         return -EINVAL;
 986                 if (q->handle == 0)
 987                         return -ENOENT;
 988                 if ((err = qdisc_graft(dev, p, skb, n, clid, NULL, q)) != 0)
 989                         return err;
 990         } else {
 991                 qdisc_notify(skb, n, clid, NULL, q);
 992         }
 993         return 0;
 994 }
 995
 996 /*
 997    Create/change qdisc.
 998  */
 999
1000 static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
1001 {
1002         struct net *net = sock_net(skb->sk);
1003         struct tcmsg *tcm;
1004         struct nlattr *tca[TCA_MAX + 1];
1005         struct net_device *dev;
1006         u32 clid;
1007         struct Qdisc *q, *p;
1008         int err;
1009
1010         if (net != &init_net)
1011                 return -EINVAL;
1012
1013 replay:
1014         /* Reinit, just in case something touches this. */
1015         tcm = NLMSG_DATA(n);
1016         clid = tcm->tcm_parent;
1017         q = p = NULL;
1018
1019         if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
1020                 return -ENODEV;
1021
1022         err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
1023         if (err < 0)
1024                 return err;
1025
1026         if (clid) {
1027                 if (clid != TC_H_ROOT) {
1028                         if (clid != TC_H_INGRESS) {
1029                                 if ((p = qdisc_lookup(dev, TC_H_MAJ(clid))) == NULL)
1030                                         return -ENOENT;
1031                                 q = qdisc_leaf(p, clid);
1032                         } else { /*ingress */
1033                                 q = dev->rx_queue.qdisc_sleeping;
1034                         }
1035                 } else {
1036                         struct netdev_queue *dev_queue;
1037                         dev_queue = netdev_get_tx_queue(dev, 0);
1038                         q = dev_queue->qdisc_sleeping;
1039                 }
1040
1041                 /* It may be default qdisc, ignore it */
1042                 if (q && q->handle == 0)
1043                         q = NULL;
1044
1045                 if (!q || !tcm->tcm_handle || q->handle != tcm->tcm_handle) {
1046                         if (tcm->tcm_handle) {
1047                                 if (q && !(n->nlmsg_flags&NLM_F_REPLACE))
1048                                         return -EEXIST;
1049                                 if (TC_H_MIN(tcm->tcm_handle))
1050                                         return -EINVAL;
1051                                 if ((q = qdisc_lookup(dev, tcm->tcm_handle)) == NULL)
1052                                         goto create_n_graft;
1053                                 if (n->nlmsg_flags&NLM_F_EXCL)
1054                                         return -EEXIST;
1055                                 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
1056                                         return -EINVAL;
1057                                 if (q == p ||
1058                                     (p && check_loop(q, p, 0)))
1059                                         return -ELOOP;
1060                                 atomic_inc(&q->refcnt);
1061                                 goto graft;
1062                         } else {
1063                                 if (q == NULL)
1064                                         goto create_n_graft;
1065
1066                                 /* This magic test requires explanation.
1067                                  *
1068                                  *   We know, that some child q is already
1069                                  *   attached to this parent and have choice:
1070                                  *   either to change it or to create/graft new one.
1071                                  *
1072                                  *   1. We are allowed to create/graft only
1073                                  *   if CREATE and REPLACE flags are set.
1074                                  *
1075                                  *   2. If EXCL is set, requestor wanted to say,
1076                                  *   that qdisc tcm_handle is not expected
1077                                  *   to exist, so that we choose create/graft too.
1078                                  *
1079                                  *   3. The last case is when no flags are set.
1080                                  *   Alas, it is sort of hole in API, we
1081                                  *   cannot decide what to do unambiguously.
1082                                  *   For now we select create/graft, if
1083                                  *   user gave KIND, which does not match existing.
1084                                  */
1085                                 if ((n->nlmsg_flags&NLM_F_CREATE) &&
1086                                     (n->nlmsg_flags&NLM_F_REPLACE) &&
1087                                     ((n->nlmsg_flags&NLM_F_EXCL) ||
1088                                      (tca[TCA_KIND] &&
1089                                       nla_strcmp(tca[TCA_KIND], q->ops->id))))
1090                                         goto create_n_graft;
1091                         }
1092                 }
1093         } else {
1094                 if (!tcm->tcm_handle)
1095                         return -EINVAL;
1096                 q = qdisc_lookup(dev, tcm->tcm_handle);
1097         }
1098
1099         /* Change qdisc parameters */
1100         if (q == NULL)
1101                 return -ENOENT;
1102         if (n->nlmsg_flags&NLM_F_EXCL)
1103                 return -EEXIST;
1104         if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
1105                 return -EINVAL;
1106         err = qdisc_change(q, tca);
1107         if (err == 0)
1108                 qdisc_notify(skb, n, clid, NULL, q);
1109         return err;
1110
1111 create_n_graft:
1112         if (!(n->nlmsg_flags&NLM_F_CREATE))
1113                 return -ENOENT;
1114         if (clid == TC_H_INGRESS)
1115                 q = qdisc_create(dev, &dev->rx_queue,
1116                                  tcm->tcm_parent, tcm->tcm_parent,
1117                                  tca, &err);
1118         else
1119                 q = qdisc_create(dev, netdev_get_tx_queue(dev, 0),
1120                                  tcm->tcm_parent, tcm->tcm_handle,
1121                                  tca, &err);
1122         if (q == NULL) {
1123                 if (err == -EAGAIN)
1124                         goto replay;
1125                 return err;
1126         }
1127
1128 graft:
1129         err = qdisc_graft(dev, p, skb, n, clid, q, NULL);
1130         if (err) {
1131                 if (q)
1132                         qdisc_destroy(q);
1133                 return err;
1134         }
1135
1136         return 0;
1137 }
1138
1139 static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,
1140                          u32 pid, u32 seq, u16 flags, int event)
1141 {
1142         struct tcmsg *tcm;
1143         struct nlmsghdr  *nlh;
1144         unsigned char *b = skb_tail_pointer(skb);
1145         struct gnet_dump d;
1146
1147         nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags);
1148         tcm = NLMSG_DATA(nlh);
1149         tcm->tcm_family = AF_UNSPEC;
1150         tcm->tcm__pad1 = 0;
1151         tcm->tcm__pad2 = 0;
1152         tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
1153         tcm->tcm_parent = clid;
1154         tcm->tcm_handle = q->handle;
1155         tcm->tcm_info = atomic_read(&q->refcnt);
1156         NLA_PUT_STRING(skb, TCA_KIND, q->ops->id);
1157         if (q->ops->dump && q->ops->dump(q, skb) < 0)
1158                 goto nla_put_failure;
1159         q->qstats.qlen = q->q.qlen;
1160
1161         if (q->stab && qdisc_dump_stab(skb, q->stab) < 0)
1162                 goto nla_put_failure;
1163
1164         if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
1165                                          qdisc_root_sleeping_lock(q), &d) < 0)
1166                 goto nla_put_failure;
1167
1168         if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)
1169                 goto nla_put_failure;
1170
1171         if (gnet_stats_copy_basic(&d, &q->bstats) < 0 ||
1172             gnet_stats_copy_rate_est(&d, &q->rate_est) < 0 ||
1173             gnet_stats_copy_queue(&d, &q->qstats) < 0)
1174                 goto nla_put_failure;
1175
1176         if (gnet_stats_finish_copy(&d) < 0)
1177                 goto nla_put_failure;
1178
1179         nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1180         return skb->len;
1181
1182 nlmsg_failure:
1183 nla_put_failure:
1184         nlmsg_trim(skb, b);
1185         return -1;
1186 }
1187
1188 static int qdisc_notify(struct sk_buff *oskb, struct nlmsghdr *n,
1189                         u32 clid, struct Qdisc *old, struct Qdisc *new)
1190 {
1191         struct sk_buff *skb;
1192         u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;
1193
1194         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1195         if (!skb)
1196                 return -ENOBUFS;
1197
1198         if (old && old->handle) {
1199                 if (tc_fill_qdisc(skb, old, clid, pid, n->nlmsg_seq, 0, RTM_DELQDISC) < 0)
1200                         goto err_out;
1201         }
1202         if (new) {
1203                 if (tc_fill_qdisc(skb, new, clid, pid, n->nlmsg_seq, old ? NLM_F_REPLACE : 0, RTM_NEWQDISC) < 0)
1204                         goto err_out;
1205         }
1206
1207         if (skb->len)
1208                 return rtnetlink_send(skb, &init_net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
1209
1210 err_out:
1211         kfree_skb(skb);
1212         return -EINVAL;
1213 }
1214
1215 static bool tc_qdisc_dump_ignore(struct Qdisc *q)
1216 {
1217         return (q->flags & TCQ_F_BUILTIN) ? true : false;
1218 }
1219
1220 static int tc_dump_qdisc_root(struct Qdisc *root, struct sk_buff *skb,
1221                               struct netlink_callback *cb,
1222                               int *q_idx_p, int s_q_idx)
1223 {
1224         int ret = 0, q_idx = *q_idx_p;
1225         struct Qdisc *q;
1226
1227         if (!root)
1228                 return 0;
1229
1230         q = root;
1231         if (q_idx < s_q_idx) {
1232                 q_idx++;
1233         } else {
1234                 if (!tc_qdisc_dump_ignore(q) &&
1235                     tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).pid,
1236                                   cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0)
1237                         goto done;
1238                 q_idx++;
1239         }
1240         list_for_each_entry(q, &root->list, list) {
1241                 if (q_idx < s_q_idx) {
1242                         q_idx++;
1243                         continue;
1244                 }
1245                 if (!tc_qdisc_dump_ignore(q) &&
1246                     tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).pid,
1247                                   cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0)
1248                         goto done;
1249                 q_idx++;
1250         }
1251
1252 out:
1253         *q_idx_p = q_idx;
1254         return ret;
1255 done:
1256         ret = -1;
1257         goto out;
1258 }
1259
1260 static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
1261 {
1262         struct net *net = sock_net(skb->sk);
1263         int idx, q_idx;
1264         int s_idx, s_q_idx;
1265         struct net_device *dev;
1266
1267         if (net != &init_net)
1268                 return 0;
1269
1270         s_idx = cb->args[0];
1271         s_q_idx = q_idx = cb->args[1];
1272         read_lock(&dev_base_lock);
1273         idx = 0;
1274         for_each_netdev(&init_net, dev) {
1275                 struct netdev_queue *dev_queue;
1276
1277                 if (idx < s_idx)
1278                         goto cont;
1279                 if (idx > s_idx)
1280                         s_q_idx = 0;
1281                 q_idx = 0;
1282
1283                 dev_queue = netdev_get_tx_queue(dev, 0);
1284                 if (tc_dump_qdisc_root(dev_queue->qdisc_sleeping, skb, cb, &q_idx, s_q_idx) < 0)
1285                         goto done;
1286
1287                 dev_queue = &dev->rx_queue;
1288                 if (tc_dump_qdisc_root(dev_queue->qdisc_sleeping, skb, cb, &q_idx, s_q_idx) < 0)
1289                         goto done;
1290
1291 cont:
1292                 idx++;
1293         }
1294
1295 done:
1296         read_unlock(&dev_base_lock);
1297
1298         cb->args[0] = idx;
1299         cb->args[1] = q_idx;
1300
1301         return skb->len;
1302 }
1303
1304
1305
1306 /************************************************
1307  *      Traffic classes manipulation.           *
1308  ************************************************/
1309
1310
1311
1312 static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
1313 {
1314         struct net *net = sock_net(skb->sk);
1315         struct netdev_queue *dev_queue;
1316         struct tcmsg *tcm = NLMSG_DATA(n);
1317         struct nlattr *tca[TCA_MAX + 1];
1318         struct net_device *dev;
1319         struct Qdisc *q = NULL;
1320         const struct Qdisc_class_ops *cops;
1321         unsigned long cl = 0;
1322         unsigned long new_cl;
1323         u32 pid = tcm->tcm_parent;
1324         u32 clid = tcm->tcm_handle;
1325         u32 qid = TC_H_MAJ(clid);
1326         int err;
1327
1328         if (net != &init_net)
1329                 return -EINVAL;
1330
1331         if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
1332                 return -ENODEV;
1333
1334         err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
1335         if (err < 0)
1336                 return err;
1337
1338         /*
1339            parent == TC_H_UNSPEC - unspecified parent.
1340            parent == TC_H_ROOT   - class is root, which has no parent.
1341            parent == X:0         - parent is root class.
1342            parent == X:Y         - parent is a node in hierarchy.
1343            parent == 0:Y         - parent is X:Y, where X:0 is qdisc.
1344
1345            handle == 0:0         - generate handle from kernel pool.
1346            handle == 0:Y         - class is X:Y, where X:0 is qdisc.
1347            handle == X:Y         - clear.
1348            handle == X:0         - root class.
1349          */
1350
1351         /* Step 1. Determine qdisc handle X:0 */
1352
1353         dev_queue = netdev_get_tx_queue(dev, 0);
1354         if (pid != TC_H_ROOT) {
1355                 u32 qid1 = TC_H_MAJ(pid);
1356
1357                 if (qid && qid1) {
1358                         /* If both majors are known, they must be identical. */
1359                         if (qid != qid1)
1360                                 return -EINVAL;
1361                 } else if (qid1) {
1362                         qid = qid1;
1363                 } else if (qid == 0)
1364                         qid = dev_queue->qdisc_sleeping->handle;
1365
1366                 /* Now qid is genuine qdisc handle consistent
1367                    both with parent and child.
1368
1369                    TC_H_MAJ(pid) still may be unspecified, complete it now.
1370                  */
1371                 if (pid)
1372                         pid = TC_H_MAKE(qid, pid);
1373         } else {
1374                 if (qid == 0)
1375                         qid = dev_queue->qdisc_sleeping->handle;
1376         }
1377
1378         /* OK. Locate qdisc */
1379         if ((q = qdisc_lookup(dev, qid)) == NULL)
1380                 return -ENOENT;
1381
1382         /* An check that it supports classes */
1383         cops = q->ops->cl_ops;
1384         if (cops == NULL)
1385                 return -EINVAL;
1386
1387         /* Now try to get class */
1388         if (clid == 0) {
1389                 if (pid == TC_H_ROOT)
1390                         clid = qid;
1391         } else
1392                 clid = TC_H_MAKE(qid, clid);
1393
1394         if (clid)
1395                 cl = cops->get(q, clid);
1396
1397         if (cl == 0) {
1398                 err = -ENOENT;
1399                 if (n->nlmsg_type != RTM_NEWTCLASS || !(n->nlmsg_flags&NLM_F_CREATE))
1400                         goto out;
1401         } else {
1402                 switch (n->nlmsg_type) {
1403                 case RTM_NEWTCLASS:
1404                         err = -EEXIST;
1405                         if (n->nlmsg_flags&NLM_F_EXCL)
1406                                 goto out;
1407                         break;
1408                 case RTM_DELTCLASS:
1409                         err = cops->delete(q, cl);
1410                         if (err == 0)
1411                                 tclass_notify(skb, n, q, cl, RTM_DELTCLASS);
1412                         goto out;
1413                 case RTM_GETTCLASS:
1414                         err = tclass_notify(skb, n, q, cl, RTM_NEWTCLASS);
1415                         goto out;
1416                 default:
1417                         err = -EINVAL;
1418                         goto out;
1419                 }
1420         }
1421
1422         new_cl = cl;
1423         err = cops->change(q, clid, pid, tca, &new_cl);
1424         if (err == 0)
1425                 tclass_notify(skb, n, q, new_cl, RTM_NEWTCLASS);
1426
1427 out:
1428         if (cl)
1429                 cops->put(q, cl);
1430
1431         return err;
1432 }
1433
1434
1435 static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,
1436                           unsigned long cl,
1437                           u32 pid, u32 seq, u16 flags, int event)
1438 {
1439         struct tcmsg *tcm;
1440         struct nlmsghdr  *nlh;
1441         unsigned char *b = skb_tail_pointer(skb);
1442         struct gnet_dump d;
1443         const struct Qdisc_class_ops *cl_ops = q->ops->cl_ops;
1444
1445         nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags);
1446         tcm = NLMSG_DATA(nlh);
1447         tcm->tcm_family = AF_UNSPEC;
1448         tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
1449         tcm->tcm_parent = q->handle;
1450         tcm->tcm_handle = q->handle;
1451         tcm->tcm_info = 0;
1452         NLA_PUT_STRING(skb, TCA_KIND, q->ops->id);
1453         if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)
1454                 goto nla_put_failure;
1455
1456         if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
1457                                          qdisc_root_sleeping_lock(q), &d) < 0)
1458                 goto nla_put_failure;
1459
1460         if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)
1461                 goto nla_put_failure;
1462
1463         if (gnet_stats_finish_copy(&d) < 0)
1464                 goto nla_put_failure;
1465
1466         nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1467         return skb->len;
1468
1469 nlmsg_failure:
1470 nla_put_failure:
1471         nlmsg_trim(skb, b);
1472         return -1;
1473 }
1474
1475 static int tclass_notify(struct sk_buff *oskb, struct nlmsghdr *n,
1476                           struct Qdisc *q, unsigned long cl, int event)
1477 {
1478         struct sk_buff *skb;
1479         u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;
1480
1481         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1482         if (!skb)
1483                 return -ENOBUFS;
1484
1485         if (tc_fill_tclass(skb, q, cl, pid, n->nlmsg_seq, 0, event) < 0) {
1486                 kfree_skb(skb);
1487                 return -EINVAL;
1488         }
1489
1490         return rtnetlink_send(skb, &init_net, pid, RTNLGRP_TC, n->nlmsg_flags&NLM_F_ECHO);
1491 }
1492
1493 struct qdisc_dump_args
1494 {
1495         struct qdisc_walker w;
1496         struct sk_buff *skb;
1497         struct netlink_callback *cb;
1498 };
1499
1500 static int qdisc_class_dump(struct Qdisc *q, unsigned long cl, struct qdisc_walker *arg)
1501 {
1502         struct qdisc_dump_args *a = (struct qdisc_dump_args *)arg;
1503
1504         return tc_fill_tclass(a->skb, q, cl, NETLINK_CB(a->cb->skb).pid,
1505                               a->cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWTCLASS);
1506 }
1507
1508 static int tc_dump_tclass_qdisc(struct Qdisc *q, struct sk_buff *skb,
1509                                 struct tcmsg *tcm, struct netlink_callback *cb,
1510                                 int *t_p, int s_t)
1511 {
1512         struct qdisc_dump_args arg;
1513
1514         if (tc_qdisc_dump_ignore(q) ||
1515             *t_p < s_t || !q->ops->cl_ops ||
1516             (tcm->tcm_parent &&
1517              TC_H_MAJ(tcm->tcm_parent) != q->handle)) {
1518                 (*t_p)++;
1519                 return 0;
1520         }
1521         if (*t_p > s_t)
1522                 memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
1523         arg.w.fn = qdisc_class_dump;
1524         arg.skb = skb;
1525         arg.cb = cb;
1526         arg.w.stop  = 0;
1527         arg.w.skip = cb->args[1];
1528         arg.w.count = 0;
1529         q->ops->cl_ops->walk(q, &arg.w);
1530         cb->args[1] = arg.w.count;
1531         if (arg.w.stop)
1532                 return -1;
1533         (*t_p)++;
1534         return 0;
1535 }
1536
1537 static int tc_dump_tclass_root(struct Qdisc *root, struct sk_buff *skb,
1538                                struct tcmsg *tcm, struct netlink_callback *cb,
1539                                int *t_p, int s_t)
1540 {
1541         struct Qdisc *q;
1542
1543         if (!root)
1544                 return 0;
1545
1546         if (tc_dump_tclass_qdisc(root, skb, tcm, cb, t_p, s_t) < 0)
1547                 return -1;
1548
1549         list_for_each_entry(q, &root->list, list) {
1550                 if (tc_dump_tclass_qdisc(q, skb, tcm, cb, t_p, s_t) < 0)
1551                         return -1;
1552         }
1553
1554         return 0;
1555 }
1556
1557 static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
1558 {
1559         struct tcmsg *tcm = (struct tcmsg*)NLMSG_DATA(cb->nlh);
1560         struct net *net = sock_net(skb->sk);
1561         struct netdev_queue *dev_queue;
1562         struct net_device *dev;
1563         int t, s_t;
1564
1565         if (net != &init_net)
1566                 return 0;
1567
1568         if (cb->nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*tcm)))
1569                 return 0;
1570         if ((dev = dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
1571                 return 0;
1572
1573         s_t = cb->args[0];
1574         t = 0;
1575
1576         dev_queue = netdev_get_tx_queue(dev, 0);
1577         if (tc_dump_tclass_root(dev_queue->qdisc_sleeping, skb, tcm, cb, &t, s_t) < 0)
1578                 goto done;
1579
1580         dev_queue = &dev->rx_queue;
1581         if (tc_dump_tclass_root(dev_queue->qdisc_sleeping, skb, tcm, cb, &t, s_t) < 0)
1582                 goto done;
1583
1584 done:
1585         cb->args[0] = t;
1586
1587         dev_put(dev);
1588         return skb->len;
1589 }
1590
1591 /* Main classifier routine: scans classifier chain attached
1592    to this qdisc, (optionally) tests for protocol and asks
1593    specific classifiers.
1594  */
1595 int tc_classify_compat(struct sk_buff *skb, struct tcf_proto *tp,
1596                        struct tcf_result *res)
1597 {
1598         __be16 protocol = skb->protocol;
1599         int err = 0;
1600
1601         for (; tp; tp = tp->next) {
1602                 if ((tp->protocol == protocol ||
1603                      tp->protocol == htons(ETH_P_ALL)) &&
1604                     (err = tp->classify(skb, tp, res)) >= 0) {
1605 #ifdef CONFIG_NET_CLS_ACT
1606                         if (err != TC_ACT_RECLASSIFY && skb->tc_verd)
1607                                 skb->tc_verd = SET_TC_VERD(skb->tc_verd, 0);
1608 #endif
1609                         return err;
1610                 }
1611         }
1612         return -1;
1613 }
1614 EXPORT_SYMBOL(tc_classify_compat);
1615
1616 int tc_classify(struct sk_buff *skb, struct tcf_proto *tp,
1617                 struct tcf_result *res)
1618 {
1619         int err = 0;
1620         __be16 protocol;
1621 #ifdef CONFIG_NET_CLS_ACT
1622         struct tcf_proto *otp = tp;
1623 reclassify:
1624 #endif
1625         protocol = skb->protocol;
1626
1627         err = tc_classify_compat(skb, tp, res);
1628 #ifdef CONFIG_NET_CLS_ACT
1629         if (err == TC_ACT_RECLASSIFY) {
1630                 u32 verd = G_TC_VERD(skb->tc_verd);
1631                 tp = otp;
1632
1633                 if (verd++ >= MAX_REC_LOOP) {
1634                         printk("rule prio %u protocol %02x reclassify loop, "
1635                                "packet dropped\n",
1636                                tp->prio&0xffff, ntohs(tp->protocol));
1637                         return TC_ACT_SHOT;
1638                 }
1639                 skb->tc_verd = SET_TC_VERD(skb->tc_verd, verd);
1640                 goto reclassify;
1641         }
1642 #endif
1643         return err;
1644 }
1645 EXPORT_SYMBOL(tc_classify);
1646
1647 void tcf_destroy(struct tcf_proto *tp)
1648 {
1649         tp->ops->destroy(tp);
1650         module_put(tp->ops->owner);
1651         kfree(tp);
1652 }
1653
1654 void tcf_destroy_chain(struct tcf_proto **fl)
1655 {
1656         struct tcf_proto *tp;
1657
1658         while ((tp = *fl) != NULL) {
1659                 *fl = tp->next;
1660                 tcf_destroy(tp);
1661         }
1662 }
1663 EXPORT_SYMBOL(tcf_destroy_chain);
1664
1665 #ifdef CONFIG_PROC_FS
1666 static int psched_show(struct seq_file *seq, void *v)
1667 {
1668         struct timespec ts;
1669
1670         hrtimer_get_res(CLOCK_MONOTONIC, &ts);
1671         seq_printf(seq, "%08x %08x %08x %08x\n",
1672                    (u32)NSEC_PER_USEC, (u32)PSCHED_US2NS(1),
1673                    1000000,
1674                    (u32)NSEC_PER_SEC/(u32)ktime_to_ns(timespec_to_ktime(ts)));
1675
1676         return 0;
1677 }
1678
1679 static int psched_open(struct inode *inode, struct file *file)
1680 {
1681         return single_open(file, psched_show, PDE(inode)->data);
1682 }
1683
1684 static const struct file_operations psched_fops = {
1685         .owner = THIS_MODULE,
1686         .open = psched_open,
1687         .read  = seq_read,
1688         .llseek = seq_lseek,
1689         .release = single_release,
1690 };
1691 #endif
1692
1693 static int __init pktsched_init(void)
1694 {
1695         register_qdisc(&pfifo_qdisc_ops);
1696         register_qdisc(&bfifo_qdisc_ops);
1697         proc_net_fops_create(&init_net, "psched", 0, &psched_fops);
1698
1699         rtnl_register(PF_UNSPEC, RTM_NEWQDISC, tc_modify_qdisc, NULL);
1700         rtnl_register(PF_UNSPEC, RTM_DELQDISC, tc_get_qdisc, NULL);
1701         rtnl_register(PF_UNSPEC, RTM_GETQDISC, tc_get_qdisc, tc_dump_qdisc);
1702         rtnl_register(PF_UNSPEC, RTM_NEWTCLASS, tc_ctl_tclass, NULL);
1703         rtnl_register(PF_UNSPEC, RTM_DELTCLASS, tc_ctl_tclass, NULL);
1704         rtnl_register(PF_UNSPEC, RTM_GETTCLASS, tc_ctl_tclass, tc_dump_tclass);
1705
1706         return 0;
1707 }
1708
1709 subsys_initcall(pktsched_init);