2 * net/sched/sch_api.c Packet scheduler API.
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.
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
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
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 #include <linux/slab.h>
32 #include <linux/hashtable.h>
34 #include <net/net_namespace.h>
36 #include <net/netlink.h>
37 #include <net/pkt_sched.h>
39 static int qdisc_notify(struct net *net, struct sk_buff *oskb,
40 struct nlmsghdr *n, u32 clid,
41 struct Qdisc *old, struct Qdisc *new);
42 static int tclass_notify(struct net *net, struct sk_buff *oskb,
43 struct nlmsghdr *n, struct Qdisc *q,
44 unsigned long cl, int event);
51 This file consists of two interrelated parts:
53 1. queueing disciplines manager frontend.
54 2. traffic classes manager frontend.
56 Generally, queueing discipline ("qdisc") is a black box,
57 which is able to enqueue packets and to dequeue them (when
58 device is ready to send something) in order and at times
59 determined by algorithm hidden in it.
61 qdisc's are divided to two categories:
62 - "queues", which have no internal structure visible from outside.
63 - "schedulers", which split all the packets to "traffic classes",
64 using "packet classifiers" (look at cls_api.c)
66 In turn, classes may have child qdiscs (as rule, queues)
67 attached to them etc. etc. etc.
69 The goal of the routines in this file is to translate
70 information supplied by user in the form of handles
71 to more intelligible for kernel form, to make some sanity
72 checks and part of work, which is common to all qdiscs
73 and to provide rtnetlink notifications.
75 All real intelligent work is done inside qdisc modules.
79 Every discipline has two major routines: enqueue and dequeue.
83 dequeue usually returns a skb to send. It is allowed to return NULL,
84 but it does not mean that queue is empty, it just means that
85 discipline does not want to send anything this time.
86 Queue is really empty if q->q.qlen == 0.
87 For complicated disciplines with multiple queues q->q is not
88 real packet queue, but however q->q.qlen must be valid.
92 enqueue returns 0, if packet was enqueued successfully.
93 If packet (this one or another one) was dropped, it returns
95 NET_XMIT_DROP - this packet dropped
96 Expected action: do not backoff, but wait until queue will clear.
97 NET_XMIT_CN - probably this packet enqueued, but another one dropped.
98 Expected action: backoff or ignore
104 like dequeue but without removing a packet from the queue
108 returns qdisc to initial state: purge all buffers, clear all
109 timers, counters (except for statistics) etc.
113 initializes newly created qdisc.
117 destroys resources allocated by init and during lifetime of qdisc.
121 changes qdisc parameters.
124 /* Protects list of registered TC modules. It is pure SMP lock. */
125 static DEFINE_RWLOCK(qdisc_mod_lock);
128 /************************************************
129 * Queueing disciplines manipulation. *
130 ************************************************/
133 /* The list of all installed queueing disciplines. */
135 static struct Qdisc_ops *qdisc_base;
137 /* Register/unregister queueing discipline */
139 int register_qdisc(struct Qdisc_ops *qops)
141 struct Qdisc_ops *q, **qp;
144 write_lock(&qdisc_mod_lock);
145 for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
146 if (!strcmp(qops->id, q->id))
149 if (qops->enqueue == NULL)
150 qops->enqueue = noop_qdisc_ops.enqueue;
151 if (qops->peek == NULL) {
152 if (qops->dequeue == NULL)
153 qops->peek = noop_qdisc_ops.peek;
157 if (qops->dequeue == NULL)
158 qops->dequeue = noop_qdisc_ops.dequeue;
161 const struct Qdisc_class_ops *cops = qops->cl_ops;
163 if (!(cops->get && cops->put && cops->walk && cops->leaf))
166 if (cops->tcf_chain && !(cops->bind_tcf && cops->unbind_tcf))
174 write_unlock(&qdisc_mod_lock);
181 EXPORT_SYMBOL(register_qdisc);
183 int unregister_qdisc(struct Qdisc_ops *qops)
185 struct Qdisc_ops *q, **qp;
188 write_lock(&qdisc_mod_lock);
189 for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
197 write_unlock(&qdisc_mod_lock);
200 EXPORT_SYMBOL(unregister_qdisc);
202 /* Get default qdisc if not otherwise specified */
203 void qdisc_get_default(char *name, size_t len)
205 read_lock(&qdisc_mod_lock);
206 strlcpy(name, default_qdisc_ops->id, len);
207 read_unlock(&qdisc_mod_lock);
210 static struct Qdisc_ops *qdisc_lookup_default(const char *name)
212 struct Qdisc_ops *q = NULL;
214 for (q = qdisc_base; q; q = q->next) {
215 if (!strcmp(name, q->id)) {
216 if (!try_module_get(q->owner))
225 /* Set new default qdisc to use */
226 int qdisc_set_default(const char *name)
228 const struct Qdisc_ops *ops;
230 if (!capable(CAP_NET_ADMIN))
233 write_lock(&qdisc_mod_lock);
234 ops = qdisc_lookup_default(name);
236 /* Not found, drop lock and try to load module */
237 write_unlock(&qdisc_mod_lock);
238 request_module("sch_%s", name);
239 write_lock(&qdisc_mod_lock);
241 ops = qdisc_lookup_default(name);
245 /* Set new default */
246 module_put(default_qdisc_ops->owner);
247 default_qdisc_ops = ops;
249 write_unlock(&qdisc_mod_lock);
251 return ops ? 0 : -ENOENT;
254 /* We know handle. Find qdisc among all qdisc's attached to device
255 * (root qdisc, all its children, children of children etc.)
256 * Note: caller either uses rtnl or rcu_read_lock()
259 static struct Qdisc *qdisc_match_from_root(struct Qdisc *root, u32 handle)
263 if (!(root->flags & TCQ_F_BUILTIN) &&
264 root->handle == handle)
267 hash_for_each_possible_rcu(qdisc_dev(root)->qdisc_hash, q, hash, handle) {
268 if (q->handle == handle)
274 void qdisc_hash_add(struct Qdisc *q)
276 if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS)) {
277 struct Qdisc *root = qdisc_dev(q)->qdisc;
279 WARN_ON_ONCE(root == &noop_qdisc);
281 hash_add_rcu(qdisc_dev(q)->qdisc_hash, &q->hash, q->handle);
284 EXPORT_SYMBOL(qdisc_hash_add);
286 void qdisc_hash_del(struct Qdisc *q)
288 if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS)) {
290 hash_del_rcu(&q->hash);
293 EXPORT_SYMBOL(qdisc_hash_del);
295 struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle)
299 q = qdisc_match_from_root(dev->qdisc, handle);
303 if (dev_ingress_queue(dev))
304 q = qdisc_match_from_root(
305 dev_ingress_queue(dev)->qdisc_sleeping,
311 static struct Qdisc *qdisc_leaf(struct Qdisc *p, u32 classid)
315 const struct Qdisc_class_ops *cops = p->ops->cl_ops;
319 cl = cops->get(p, classid);
323 leaf = cops->leaf(p, cl);
328 /* Find queueing discipline by name */
330 static struct Qdisc_ops *qdisc_lookup_ops(struct nlattr *kind)
332 struct Qdisc_ops *q = NULL;
335 read_lock(&qdisc_mod_lock);
336 for (q = qdisc_base; q; q = q->next) {
337 if (nla_strcmp(kind, q->id) == 0) {
338 if (!try_module_get(q->owner))
343 read_unlock(&qdisc_mod_lock);
348 /* The linklayer setting were not transferred from iproute2, in older
349 * versions, and the rate tables lookup systems have been dropped in
350 * the kernel. To keep backward compatible with older iproute2 tc
351 * utils, we detect the linklayer setting by detecting if the rate
352 * table were modified.
354 * For linklayer ATM table entries, the rate table will be aligned to
355 * 48 bytes, thus some table entries will contain the same value. The
356 * mpu (min packet unit) is also encoded into the old rate table, thus
357 * starting from the mpu, we find low and high table entries for
358 * mapping this cell. If these entries contain the same value, when
359 * the rate tables have been modified for linklayer ATM.
361 * This is done by rounding mpu to the nearest 48 bytes cell/entry,
362 * and then roundup to the next cell, calc the table entry one below,
365 static __u8 __detect_linklayer(struct tc_ratespec *r, __u32 *rtab)
367 int low = roundup(r->mpu, 48);
368 int high = roundup(low+1, 48);
369 int cell_low = low >> r->cell_log;
370 int cell_high = (high >> r->cell_log) - 1;
372 /* rtab is too inaccurate at rates > 100Mbit/s */
373 if ((r->rate > (100000000/8)) || (rtab[0] == 0)) {
374 pr_debug("TC linklayer: Giving up ATM detection\n");
375 return TC_LINKLAYER_ETHERNET;
378 if ((cell_high > cell_low) && (cell_high < 256)
379 && (rtab[cell_low] == rtab[cell_high])) {
380 pr_debug("TC linklayer: Detected ATM, low(%d)=high(%d)=%u\n",
381 cell_low, cell_high, rtab[cell_high]);
382 return TC_LINKLAYER_ATM;
384 return TC_LINKLAYER_ETHERNET;
387 static struct qdisc_rate_table *qdisc_rtab_list;
389 struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct nlattr *tab)
391 struct qdisc_rate_table *rtab;
393 if (tab == NULL || r->rate == 0 || r->cell_log == 0 ||
394 nla_len(tab) != TC_RTAB_SIZE)
397 for (rtab = qdisc_rtab_list; rtab; rtab = rtab->next) {
398 if (!memcmp(&rtab->rate, r, sizeof(struct tc_ratespec)) &&
399 !memcmp(&rtab->data, nla_data(tab), 1024)) {
405 rtab = kmalloc(sizeof(*rtab), GFP_KERNEL);
409 memcpy(rtab->data, nla_data(tab), 1024);
410 if (r->linklayer == TC_LINKLAYER_UNAWARE)
411 r->linklayer = __detect_linklayer(r, rtab->data);
412 rtab->next = qdisc_rtab_list;
413 qdisc_rtab_list = rtab;
417 EXPORT_SYMBOL(qdisc_get_rtab);
419 void qdisc_put_rtab(struct qdisc_rate_table *tab)
421 struct qdisc_rate_table *rtab, **rtabp;
423 if (!tab || --tab->refcnt)
426 for (rtabp = &qdisc_rtab_list;
427 (rtab = *rtabp) != NULL;
428 rtabp = &rtab->next) {
436 EXPORT_SYMBOL(qdisc_put_rtab);
438 static LIST_HEAD(qdisc_stab_list);
439 static DEFINE_SPINLOCK(qdisc_stab_lock);
441 static const struct nla_policy stab_policy[TCA_STAB_MAX + 1] = {
442 [TCA_STAB_BASE] = { .len = sizeof(struct tc_sizespec) },
443 [TCA_STAB_DATA] = { .type = NLA_BINARY },
446 static struct qdisc_size_table *qdisc_get_stab(struct nlattr *opt)
448 struct nlattr *tb[TCA_STAB_MAX + 1];
449 struct qdisc_size_table *stab;
450 struct tc_sizespec *s;
451 unsigned int tsize = 0;
455 err = nla_parse_nested(tb, TCA_STAB_MAX, opt, stab_policy);
458 if (!tb[TCA_STAB_BASE])
459 return ERR_PTR(-EINVAL);
461 s = nla_data(tb[TCA_STAB_BASE]);
464 if (!tb[TCA_STAB_DATA])
465 return ERR_PTR(-EINVAL);
466 tab = nla_data(tb[TCA_STAB_DATA]);
467 tsize = nla_len(tb[TCA_STAB_DATA]) / sizeof(u16);
470 if (tsize != s->tsize || (!tab && tsize > 0))
471 return ERR_PTR(-EINVAL);
473 spin_lock(&qdisc_stab_lock);
475 list_for_each_entry(stab, &qdisc_stab_list, list) {
476 if (memcmp(&stab->szopts, s, sizeof(*s)))
478 if (tsize > 0 && memcmp(stab->data, tab, tsize * sizeof(u16)))
481 spin_unlock(&qdisc_stab_lock);
485 spin_unlock(&qdisc_stab_lock);
487 stab = kmalloc(sizeof(*stab) + tsize * sizeof(u16), GFP_KERNEL);
489 return ERR_PTR(-ENOMEM);
494 memcpy(stab->data, tab, tsize * sizeof(u16));
496 spin_lock(&qdisc_stab_lock);
497 list_add_tail(&stab->list, &qdisc_stab_list);
498 spin_unlock(&qdisc_stab_lock);
503 static void stab_kfree_rcu(struct rcu_head *head)
505 kfree(container_of(head, struct qdisc_size_table, rcu));
508 void qdisc_put_stab(struct qdisc_size_table *tab)
513 spin_lock(&qdisc_stab_lock);
515 if (--tab->refcnt == 0) {
516 list_del(&tab->list);
517 call_rcu_bh(&tab->rcu, stab_kfree_rcu);
520 spin_unlock(&qdisc_stab_lock);
522 EXPORT_SYMBOL(qdisc_put_stab);
524 static int qdisc_dump_stab(struct sk_buff *skb, struct qdisc_size_table *stab)
528 nest = nla_nest_start(skb, TCA_STAB);
530 goto nla_put_failure;
531 if (nla_put(skb, TCA_STAB_BASE, sizeof(stab->szopts), &stab->szopts))
532 goto nla_put_failure;
533 nla_nest_end(skb, nest);
541 void __qdisc_calculate_pkt_len(struct sk_buff *skb, const struct qdisc_size_table *stab)
545 pkt_len = skb->len + stab->szopts.overhead;
546 if (unlikely(!stab->szopts.tsize))
549 slot = pkt_len + stab->szopts.cell_align;
550 if (unlikely(slot < 0))
553 slot >>= stab->szopts.cell_log;
554 if (likely(slot < stab->szopts.tsize))
555 pkt_len = stab->data[slot];
557 pkt_len = stab->data[stab->szopts.tsize - 1] *
558 (slot / stab->szopts.tsize) +
559 stab->data[slot % stab->szopts.tsize];
561 pkt_len <<= stab->szopts.size_log;
563 if (unlikely(pkt_len < 1))
565 qdisc_skb_cb(skb)->pkt_len = pkt_len;
567 EXPORT_SYMBOL(__qdisc_calculate_pkt_len);
569 void qdisc_warn_nonwc(const char *txt, struct Qdisc *qdisc)
571 if (!(qdisc->flags & TCQ_F_WARN_NONWC)) {
572 pr_warn("%s: %s qdisc %X: is non-work-conserving?\n",
573 txt, qdisc->ops->id, qdisc->handle >> 16);
574 qdisc->flags |= TCQ_F_WARN_NONWC;
577 EXPORT_SYMBOL(qdisc_warn_nonwc);
579 static enum hrtimer_restart qdisc_watchdog(struct hrtimer *timer)
581 struct qdisc_watchdog *wd = container_of(timer, struct qdisc_watchdog,
585 __netif_schedule(qdisc_root(wd->qdisc));
588 return HRTIMER_NORESTART;
591 void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc)
593 hrtimer_init(&wd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
594 wd->timer.function = qdisc_watchdog;
597 EXPORT_SYMBOL(qdisc_watchdog_init);
599 void qdisc_watchdog_schedule_ns(struct qdisc_watchdog *wd, u64 expires)
601 if (test_bit(__QDISC_STATE_DEACTIVATED,
602 &qdisc_root_sleeping(wd->qdisc)->state))
605 if (wd->last_expires == expires)
608 wd->last_expires = expires;
609 hrtimer_start(&wd->timer,
610 ns_to_ktime(expires),
611 HRTIMER_MODE_ABS_PINNED);
613 EXPORT_SYMBOL(qdisc_watchdog_schedule_ns);
615 void qdisc_watchdog_cancel(struct qdisc_watchdog *wd)
617 hrtimer_cancel(&wd->timer);
619 EXPORT_SYMBOL(qdisc_watchdog_cancel);
621 static struct hlist_head *qdisc_class_hash_alloc(unsigned int n)
623 unsigned int size = n * sizeof(struct hlist_head), i;
624 struct hlist_head *h;
626 if (size <= PAGE_SIZE)
627 h = kmalloc(size, GFP_KERNEL);
629 h = (struct hlist_head *)
630 __get_free_pages(GFP_KERNEL, get_order(size));
633 for (i = 0; i < n; i++)
634 INIT_HLIST_HEAD(&h[i]);
639 static void qdisc_class_hash_free(struct hlist_head *h, unsigned int n)
641 unsigned int size = n * sizeof(struct hlist_head);
643 if (size <= PAGE_SIZE)
646 free_pages((unsigned long)h, get_order(size));
649 void qdisc_class_hash_grow(struct Qdisc *sch, struct Qdisc_class_hash *clhash)
651 struct Qdisc_class_common *cl;
652 struct hlist_node *next;
653 struct hlist_head *nhash, *ohash;
654 unsigned int nsize, nmask, osize;
657 /* Rehash when load factor exceeds 0.75 */
658 if (clhash->hashelems * 4 <= clhash->hashsize * 3)
660 nsize = clhash->hashsize * 2;
662 nhash = qdisc_class_hash_alloc(nsize);
666 ohash = clhash->hash;
667 osize = clhash->hashsize;
670 for (i = 0; i < osize; i++) {
671 hlist_for_each_entry_safe(cl, next, &ohash[i], hnode) {
672 h = qdisc_class_hash(cl->classid, nmask);
673 hlist_add_head(&cl->hnode, &nhash[h]);
676 clhash->hash = nhash;
677 clhash->hashsize = nsize;
678 clhash->hashmask = nmask;
679 sch_tree_unlock(sch);
681 qdisc_class_hash_free(ohash, osize);
683 EXPORT_SYMBOL(qdisc_class_hash_grow);
685 int qdisc_class_hash_init(struct Qdisc_class_hash *clhash)
687 unsigned int size = 4;
689 clhash->hash = qdisc_class_hash_alloc(size);
690 if (clhash->hash == NULL)
692 clhash->hashsize = size;
693 clhash->hashmask = size - 1;
694 clhash->hashelems = 0;
697 EXPORT_SYMBOL(qdisc_class_hash_init);
699 void qdisc_class_hash_destroy(struct Qdisc_class_hash *clhash)
701 qdisc_class_hash_free(clhash->hash, clhash->hashsize);
703 EXPORT_SYMBOL(qdisc_class_hash_destroy);
705 void qdisc_class_hash_insert(struct Qdisc_class_hash *clhash,
706 struct Qdisc_class_common *cl)
710 INIT_HLIST_NODE(&cl->hnode);
711 h = qdisc_class_hash(cl->classid, clhash->hashmask);
712 hlist_add_head(&cl->hnode, &clhash->hash[h]);
715 EXPORT_SYMBOL(qdisc_class_hash_insert);
717 void qdisc_class_hash_remove(struct Qdisc_class_hash *clhash,
718 struct Qdisc_class_common *cl)
720 hlist_del(&cl->hnode);
723 EXPORT_SYMBOL(qdisc_class_hash_remove);
725 /* Allocate an unique handle from space managed by kernel
726 * Possible range is [8000-FFFF]:0000 (0x8000 values)
728 static u32 qdisc_alloc_handle(struct net_device *dev)
731 static u32 autohandle = TC_H_MAKE(0x80000000U, 0);
734 autohandle += TC_H_MAKE(0x10000U, 0);
735 if (autohandle == TC_H_MAKE(TC_H_ROOT, 0))
736 autohandle = TC_H_MAKE(0x80000000U, 0);
737 if (!qdisc_lookup(dev, autohandle))
745 void qdisc_tree_reduce_backlog(struct Qdisc *sch, unsigned int n,
748 const struct Qdisc_class_ops *cops;
753 if (n == 0 && len == 0)
755 drops = max_t(int, n, 0);
757 while ((parentid = sch->parent)) {
758 if (TC_H_MAJ(parentid) == TC_H_MAJ(TC_H_INGRESS))
761 if (sch->flags & TCQ_F_NOPARENT)
763 /* TODO: perform the search on a per txq basis */
764 sch = qdisc_lookup(qdisc_dev(sch), TC_H_MAJ(parentid));
766 WARN_ON_ONCE(parentid != TC_H_ROOT);
769 cops = sch->ops->cl_ops;
770 if (cops->qlen_notify) {
771 cl = cops->get(sch, parentid);
772 cops->qlen_notify(sch, cl);
776 sch->qstats.backlog -= len;
777 __qdisc_qstats_drop(sch, drops);
781 EXPORT_SYMBOL(qdisc_tree_reduce_backlog);
783 static void notify_and_destroy(struct net *net, struct sk_buff *skb,
784 struct nlmsghdr *n, u32 clid,
785 struct Qdisc *old, struct Qdisc *new)
788 qdisc_notify(net, skb, n, clid, old, new);
794 /* Graft qdisc "new" to class "classid" of qdisc "parent" or
797 * When appropriate send a netlink notification using 'skb'
800 * On success, destroy old qdisc.
803 static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
804 struct sk_buff *skb, struct nlmsghdr *n, u32 classid,
805 struct Qdisc *new, struct Qdisc *old)
807 struct Qdisc *q = old;
808 struct net *net = dev_net(dev);
811 if (parent == NULL) {
812 unsigned int i, num_q, ingress;
815 num_q = dev->num_tx_queues;
816 if ((q && q->flags & TCQ_F_INGRESS) ||
817 (new && new->flags & TCQ_F_INGRESS)) {
820 if (!dev_ingress_queue(dev))
824 if (dev->flags & IFF_UP)
827 if (new && new->ops->attach)
830 for (i = 0; i < num_q; i++) {
831 struct netdev_queue *dev_queue = dev_ingress_queue(dev);
834 dev_queue = netdev_get_tx_queue(dev, i);
836 old = dev_graft_qdisc(dev_queue, new);
838 atomic_inc(&new->refcnt);
846 notify_and_destroy(net, skb, n, classid,
848 if (new && !new->ops->attach)
849 atomic_inc(&new->refcnt);
850 dev->qdisc = new ? : &noop_qdisc;
852 if (new && new->ops->attach)
853 new->ops->attach(new);
855 notify_and_destroy(net, skb, n, classid, old, new);
858 if (dev->flags & IFF_UP)
861 const struct Qdisc_class_ops *cops = parent->ops->cl_ops;
864 if (cops && cops->graft) {
865 unsigned long cl = cops->get(parent, classid);
867 err = cops->graft(parent, cl, new, &old);
868 cops->put(parent, cl);
873 notify_and_destroy(net, skb, n, classid, old, new);
878 /* lockdep annotation is needed for ingress; egress gets it only for name */
879 static struct lock_class_key qdisc_tx_lock;
880 static struct lock_class_key qdisc_rx_lock;
883 Allocate and initialize new qdisc.
885 Parameters are passed via opt.
888 static struct Qdisc *
889 qdisc_create(struct net_device *dev, struct netdev_queue *dev_queue,
890 struct Qdisc *p, u32 parent, u32 handle,
891 struct nlattr **tca, int *errp)
894 struct nlattr *kind = tca[TCA_KIND];
896 struct Qdisc_ops *ops;
897 struct qdisc_size_table *stab;
899 ops = qdisc_lookup_ops(kind);
900 #ifdef CONFIG_MODULES
901 if (ops == NULL && kind != NULL) {
903 if (nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) {
904 /* We dropped the RTNL semaphore in order to
905 * perform the module load. So, even if we
906 * succeeded in loading the module we have to
907 * tell the caller to replay the request. We
908 * indicate this using -EAGAIN.
909 * We replay the request because the device may
910 * go away in the mean time.
913 request_module("sch_%s", name);
915 ops = qdisc_lookup_ops(kind);
917 /* We will try again qdisc_lookup_ops,
918 * so don't keep a reference.
920 module_put(ops->owner);
932 sch = qdisc_alloc(dev_queue, ops);
938 sch->parent = parent;
940 if (handle == TC_H_INGRESS) {
941 sch->flags |= TCQ_F_INGRESS;
942 handle = TC_H_MAKE(TC_H_INGRESS, 0);
943 lockdep_set_class(qdisc_lock(sch), &qdisc_rx_lock);
946 handle = qdisc_alloc_handle(dev);
951 lockdep_set_class(qdisc_lock(sch), &qdisc_tx_lock);
952 if (!netif_is_multiqueue(dev))
953 sch->flags |= TCQ_F_ONETXQUEUE;
956 sch->handle = handle;
958 if (!ops->init || (err = ops->init(sch, tca[TCA_OPTIONS])) == 0) {
959 if (qdisc_is_percpu_stats(sch)) {
961 netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu);
962 if (!sch->cpu_bstats)
965 sch->cpu_qstats = alloc_percpu(struct gnet_stats_queue);
966 if (!sch->cpu_qstats)
971 stab = qdisc_get_stab(tca[TCA_STAB]);
976 rcu_assign_pointer(sch->stab, stab);
982 if (sch->flags & TCQ_F_MQROOT)
985 if ((sch->parent != TC_H_ROOT) &&
986 !(sch->flags & TCQ_F_INGRESS) &&
987 (!p || !(p->flags & TCQ_F_MQROOT)))
988 running = qdisc_root_sleeping_running(sch);
990 running = &sch->running;
992 err = gen_new_estimator(&sch->bstats,
1002 qdisc_hash_add(sch);
1008 kfree((char *) sch - sch->padded);
1010 module_put(ops->owner);
1016 free_percpu(sch->cpu_bstats);
1017 free_percpu(sch->cpu_qstats);
1019 * Any broken qdiscs that would require a ops->reset() here?
1020 * The qdisc was never in action so it shouldn't be necessary.
1022 qdisc_put_stab(rtnl_dereference(sch->stab));
1028 static int qdisc_change(struct Qdisc *sch, struct nlattr **tca)
1030 struct qdisc_size_table *ostab, *stab = NULL;
1033 if (tca[TCA_OPTIONS]) {
1034 if (sch->ops->change == NULL)
1036 err = sch->ops->change(sch, tca[TCA_OPTIONS]);
1041 if (tca[TCA_STAB]) {
1042 stab = qdisc_get_stab(tca[TCA_STAB]);
1044 return PTR_ERR(stab);
1047 ostab = rtnl_dereference(sch->stab);
1048 rcu_assign_pointer(sch->stab, stab);
1049 qdisc_put_stab(ostab);
1051 if (tca[TCA_RATE]) {
1052 /* NB: ignores errors from replace_estimator
1053 because change can't be undone. */
1054 if (sch->flags & TCQ_F_MQROOT)
1056 gen_replace_estimator(&sch->bstats,
1060 qdisc_root_sleeping_running(sch),
1067 struct check_loop_arg {
1068 struct qdisc_walker w;
1073 static int check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w);
1075 static int check_loop(struct Qdisc *q, struct Qdisc *p, int depth)
1077 struct check_loop_arg arg;
1079 if (q->ops->cl_ops == NULL)
1082 arg.w.stop = arg.w.skip = arg.w.count = 0;
1083 arg.w.fn = check_loop_fn;
1086 q->ops->cl_ops->walk(q, &arg.w);
1087 return arg.w.stop ? -ELOOP : 0;
1091 check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w)
1094 const struct Qdisc_class_ops *cops = q->ops->cl_ops;
1095 struct check_loop_arg *arg = (struct check_loop_arg *)w;
1097 leaf = cops->leaf(q, cl);
1099 if (leaf == arg->p || arg->depth > 7)
1101 return check_loop(leaf, arg->p, arg->depth + 1);
1110 static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n)
1112 struct net *net = sock_net(skb->sk);
1113 struct tcmsg *tcm = nlmsg_data(n);
1114 struct nlattr *tca[TCA_MAX + 1];
1115 struct net_device *dev;
1117 struct Qdisc *q = NULL;
1118 struct Qdisc *p = NULL;
1121 if ((n->nlmsg_type != RTM_GETQDISC) &&
1122 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
1125 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
1129 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
1133 clid = tcm->tcm_parent;
1135 if (clid != TC_H_ROOT) {
1136 if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) {
1137 p = qdisc_lookup(dev, TC_H_MAJ(clid));
1140 q = qdisc_leaf(p, clid);
1141 } else if (dev_ingress_queue(dev)) {
1142 q = dev_ingress_queue(dev)->qdisc_sleeping;
1150 if (tcm->tcm_handle && q->handle != tcm->tcm_handle)
1153 q = qdisc_lookup(dev, tcm->tcm_handle);
1158 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
1161 if (n->nlmsg_type == RTM_DELQDISC) {
1166 err = qdisc_graft(dev, p, skb, n, clid, NULL, q);
1170 qdisc_notify(net, skb, n, clid, NULL, q);
1176 * Create/change qdisc.
1179 static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n)
1181 struct net *net = sock_net(skb->sk);
1183 struct nlattr *tca[TCA_MAX + 1];
1184 struct net_device *dev;
1186 struct Qdisc *q, *p;
1189 if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
1193 /* Reinit, just in case something touches this. */
1194 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
1198 tcm = nlmsg_data(n);
1199 clid = tcm->tcm_parent;
1202 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
1208 if (clid != TC_H_ROOT) {
1209 if (clid != TC_H_INGRESS) {
1210 p = qdisc_lookup(dev, TC_H_MAJ(clid));
1213 q = qdisc_leaf(p, clid);
1214 } else if (dev_ingress_queue_create(dev)) {
1215 q = dev_ingress_queue(dev)->qdisc_sleeping;
1221 /* It may be default qdisc, ignore it */
1222 if (q && q->handle == 0)
1225 if (!q || !tcm->tcm_handle || q->handle != tcm->tcm_handle) {
1226 if (tcm->tcm_handle) {
1227 if (q && !(n->nlmsg_flags & NLM_F_REPLACE))
1229 if (TC_H_MIN(tcm->tcm_handle))
1231 q = qdisc_lookup(dev, tcm->tcm_handle);
1233 goto create_n_graft;
1234 if (n->nlmsg_flags & NLM_F_EXCL)
1236 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
1239 (p && check_loop(q, p, 0)))
1241 atomic_inc(&q->refcnt);
1245 goto create_n_graft;
1247 /* This magic test requires explanation.
1249 * We know, that some child q is already
1250 * attached to this parent and have choice:
1251 * either to change it or to create/graft new one.
1253 * 1. We are allowed to create/graft only
1254 * if CREATE and REPLACE flags are set.
1256 * 2. If EXCL is set, requestor wanted to say,
1257 * that qdisc tcm_handle is not expected
1258 * to exist, so that we choose create/graft too.
1260 * 3. The last case is when no flags are set.
1261 * Alas, it is sort of hole in API, we
1262 * cannot decide what to do unambiguously.
1263 * For now we select create/graft, if
1264 * user gave KIND, which does not match existing.
1266 if ((n->nlmsg_flags & NLM_F_CREATE) &&
1267 (n->nlmsg_flags & NLM_F_REPLACE) &&
1268 ((n->nlmsg_flags & NLM_F_EXCL) ||
1270 nla_strcmp(tca[TCA_KIND], q->ops->id))))
1271 goto create_n_graft;
1275 if (!tcm->tcm_handle)
1277 q = qdisc_lookup(dev, tcm->tcm_handle);
1280 /* Change qdisc parameters */
1283 if (n->nlmsg_flags & NLM_F_EXCL)
1285 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
1287 err = qdisc_change(q, tca);
1289 qdisc_notify(net, skb, n, clid, NULL, q);
1293 if (!(n->nlmsg_flags & NLM_F_CREATE))
1295 if (clid == TC_H_INGRESS) {
1296 if (dev_ingress_queue(dev))
1297 q = qdisc_create(dev, dev_ingress_queue(dev), p,
1298 tcm->tcm_parent, tcm->tcm_parent,
1303 struct netdev_queue *dev_queue;
1305 if (p && p->ops->cl_ops && p->ops->cl_ops->select_queue)
1306 dev_queue = p->ops->cl_ops->select_queue(p, tcm);
1308 dev_queue = p->dev_queue;
1310 dev_queue = netdev_get_tx_queue(dev, 0);
1312 q = qdisc_create(dev, dev_queue, p,
1313 tcm->tcm_parent, tcm->tcm_handle,
1323 err = qdisc_graft(dev, p, skb, n, clid, q, NULL);
1333 static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,
1334 u32 portid, u32 seq, u16 flags, int event)
1336 struct gnet_stats_basic_cpu __percpu *cpu_bstats = NULL;
1337 struct gnet_stats_queue __percpu *cpu_qstats = NULL;
1339 struct nlmsghdr *nlh;
1340 unsigned char *b = skb_tail_pointer(skb);
1342 struct qdisc_size_table *stab;
1346 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
1348 goto out_nlmsg_trim;
1349 tcm = nlmsg_data(nlh);
1350 tcm->tcm_family = AF_UNSPEC;
1353 tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
1354 tcm->tcm_parent = clid;
1355 tcm->tcm_handle = q->handle;
1356 tcm->tcm_info = atomic_read(&q->refcnt);
1357 if (nla_put_string(skb, TCA_KIND, q->ops->id))
1358 goto nla_put_failure;
1359 if (q->ops->dump && q->ops->dump(q, skb) < 0)
1360 goto nla_put_failure;
1363 stab = rtnl_dereference(q->stab);
1364 if (stab && qdisc_dump_stab(skb, stab) < 0)
1365 goto nla_put_failure;
1367 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
1368 NULL, &d, TCA_PAD) < 0)
1369 goto nla_put_failure;
1371 if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)
1372 goto nla_put_failure;
1374 if (qdisc_is_percpu_stats(q)) {
1375 cpu_bstats = q->cpu_bstats;
1376 cpu_qstats = q->cpu_qstats;
1379 if (gnet_stats_copy_basic(qdisc_root_sleeping_running(q),
1380 &d, cpu_bstats, &q->bstats) < 0 ||
1381 gnet_stats_copy_rate_est(&d, &q->bstats, &q->rate_est) < 0 ||
1382 gnet_stats_copy_queue(&d, cpu_qstats, &q->qstats, qlen) < 0)
1383 goto nla_put_failure;
1385 if (gnet_stats_finish_copy(&d) < 0)
1386 goto nla_put_failure;
1388 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1397 static bool tc_qdisc_dump_ignore(struct Qdisc *q)
1399 return (q->flags & TCQ_F_BUILTIN) ? true : false;
1402 static int qdisc_notify(struct net *net, struct sk_buff *oskb,
1403 struct nlmsghdr *n, u32 clid,
1404 struct Qdisc *old, struct Qdisc *new)
1406 struct sk_buff *skb;
1407 u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
1409 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1413 if (old && !tc_qdisc_dump_ignore(old)) {
1414 if (tc_fill_qdisc(skb, old, clid, portid, n->nlmsg_seq,
1415 0, RTM_DELQDISC) < 0)
1418 if (new && !tc_qdisc_dump_ignore(new)) {
1419 if (tc_fill_qdisc(skb, new, clid, portid, n->nlmsg_seq,
1420 old ? NLM_F_REPLACE : 0, RTM_NEWQDISC) < 0)
1425 return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
1426 n->nlmsg_flags & NLM_F_ECHO);
1433 static int tc_dump_qdisc_root(struct Qdisc *root, struct sk_buff *skb,
1434 struct netlink_callback *cb,
1435 int *q_idx_p, int s_q_idx)
1437 int ret = 0, q_idx = *q_idx_p;
1445 if (q_idx < s_q_idx) {
1448 if (!tc_qdisc_dump_ignore(q) &&
1449 tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).portid,
1450 cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0)
1454 hash_for_each(qdisc_dev(root)->qdisc_hash, b, q, hash) {
1455 if (q_idx < s_q_idx) {
1459 if (!tc_qdisc_dump_ignore(q) &&
1460 tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).portid,
1461 cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0)
1474 static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
1476 struct net *net = sock_net(skb->sk);
1479 struct net_device *dev;
1481 s_idx = cb->args[0];
1482 s_q_idx = q_idx = cb->args[1];
1486 for_each_netdev(net, dev) {
1487 struct netdev_queue *dev_queue;
1495 if (tc_dump_qdisc_root(dev->qdisc, skb, cb, &q_idx, s_q_idx) < 0)
1498 dev_queue = dev_ingress_queue(dev);
1500 tc_dump_qdisc_root(dev_queue->qdisc_sleeping, skb, cb,
1501 &q_idx, s_q_idx) < 0)
1510 cb->args[1] = q_idx;
1517 /************************************************
1518 * Traffic classes manipulation. *
1519 ************************************************/
1523 static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n)
1525 struct net *net = sock_net(skb->sk);
1526 struct tcmsg *tcm = nlmsg_data(n);
1527 struct nlattr *tca[TCA_MAX + 1];
1528 struct net_device *dev;
1529 struct Qdisc *q = NULL;
1530 const struct Qdisc_class_ops *cops;
1531 unsigned long cl = 0;
1532 unsigned long new_cl;
1538 if ((n->nlmsg_type != RTM_GETTCLASS) &&
1539 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
1542 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
1546 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
1551 parent == TC_H_UNSPEC - unspecified parent.
1552 parent == TC_H_ROOT - class is root, which has no parent.
1553 parent == X:0 - parent is root class.
1554 parent == X:Y - parent is a node in hierarchy.
1555 parent == 0:Y - parent is X:Y, where X:0 is qdisc.
1557 handle == 0:0 - generate handle from kernel pool.
1558 handle == 0:Y - class is X:Y, where X:0 is qdisc.
1559 handle == X:Y - clear.
1560 handle == X:0 - root class.
1563 /* Step 1. Determine qdisc handle X:0 */
1565 portid = tcm->tcm_parent;
1566 clid = tcm->tcm_handle;
1567 qid = TC_H_MAJ(clid);
1569 if (portid != TC_H_ROOT) {
1570 u32 qid1 = TC_H_MAJ(portid);
1573 /* If both majors are known, they must be identical. */
1578 } else if (qid == 0)
1579 qid = dev->qdisc->handle;
1581 /* Now qid is genuine qdisc handle consistent
1582 * both with parent and child.
1584 * TC_H_MAJ(portid) still may be unspecified, complete it now.
1587 portid = TC_H_MAKE(qid, portid);
1590 qid = dev->qdisc->handle;
1593 /* OK. Locate qdisc */
1594 q = qdisc_lookup(dev, qid);
1598 /* An check that it supports classes */
1599 cops = q->ops->cl_ops;
1603 /* Now try to get class */
1605 if (portid == TC_H_ROOT)
1608 clid = TC_H_MAKE(qid, clid);
1611 cl = cops->get(q, clid);
1615 if (n->nlmsg_type != RTM_NEWTCLASS ||
1616 !(n->nlmsg_flags & NLM_F_CREATE))
1619 switch (n->nlmsg_type) {
1622 if (n->nlmsg_flags & NLM_F_EXCL)
1628 err = cops->delete(q, cl);
1630 tclass_notify(net, skb, n, q, cl, RTM_DELTCLASS);
1633 err = tclass_notify(net, skb, n, q, cl, RTM_NEWTCLASS);
1644 err = cops->change(q, clid, portid, tca, &new_cl);
1646 tclass_notify(net, skb, n, q, new_cl, RTM_NEWTCLASS);
1656 static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,
1658 u32 portid, u32 seq, u16 flags, int event)
1661 struct nlmsghdr *nlh;
1662 unsigned char *b = skb_tail_pointer(skb);
1664 const struct Qdisc_class_ops *cl_ops = q->ops->cl_ops;
1667 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
1669 goto out_nlmsg_trim;
1670 tcm = nlmsg_data(nlh);
1671 tcm->tcm_family = AF_UNSPEC;
1674 tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
1675 tcm->tcm_parent = q->handle;
1676 tcm->tcm_handle = q->handle;
1678 if (nla_put_string(skb, TCA_KIND, q->ops->id))
1679 goto nla_put_failure;
1680 if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)
1681 goto nla_put_failure;
1683 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
1684 NULL, &d, TCA_PAD) < 0)
1685 goto nla_put_failure;
1687 if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)
1688 goto nla_put_failure;
1690 if (gnet_stats_finish_copy(&d) < 0)
1691 goto nla_put_failure;
1693 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1702 static int tclass_notify(struct net *net, struct sk_buff *oskb,
1703 struct nlmsghdr *n, struct Qdisc *q,
1704 unsigned long cl, int event)
1706 struct sk_buff *skb;
1707 u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
1709 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1713 if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0, event) < 0) {
1718 return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
1719 n->nlmsg_flags & NLM_F_ECHO);
1722 struct qdisc_dump_args {
1723 struct qdisc_walker w;
1724 struct sk_buff *skb;
1725 struct netlink_callback *cb;
1728 static int qdisc_class_dump(struct Qdisc *q, unsigned long cl, struct qdisc_walker *arg)
1730 struct qdisc_dump_args *a = (struct qdisc_dump_args *)arg;
1732 return tc_fill_tclass(a->skb, q, cl, NETLINK_CB(a->cb->skb).portid,
1733 a->cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWTCLASS);
1736 static int tc_dump_tclass_qdisc(struct Qdisc *q, struct sk_buff *skb,
1737 struct tcmsg *tcm, struct netlink_callback *cb,
1740 struct qdisc_dump_args arg;
1742 if (tc_qdisc_dump_ignore(q) ||
1743 *t_p < s_t || !q->ops->cl_ops ||
1745 TC_H_MAJ(tcm->tcm_parent) != q->handle)) {
1750 memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
1751 arg.w.fn = qdisc_class_dump;
1755 arg.w.skip = cb->args[1];
1757 q->ops->cl_ops->walk(q, &arg.w);
1758 cb->args[1] = arg.w.count;
1765 static int tc_dump_tclass_root(struct Qdisc *root, struct sk_buff *skb,
1766 struct tcmsg *tcm, struct netlink_callback *cb,
1775 if (tc_dump_tclass_qdisc(root, skb, tcm, cb, t_p, s_t) < 0)
1778 hash_for_each(qdisc_dev(root)->qdisc_hash, b, q, hash) {
1779 if (tc_dump_tclass_qdisc(q, skb, tcm, cb, t_p, s_t) < 0)
1786 static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
1788 struct tcmsg *tcm = nlmsg_data(cb->nlh);
1789 struct net *net = sock_net(skb->sk);
1790 struct netdev_queue *dev_queue;
1791 struct net_device *dev;
1794 if (nlmsg_len(cb->nlh) < sizeof(*tcm))
1796 dev = dev_get_by_index(net, tcm->tcm_ifindex);
1803 if (tc_dump_tclass_root(dev->qdisc, skb, tcm, cb, &t, s_t) < 0)
1806 dev_queue = dev_ingress_queue(dev);
1808 tc_dump_tclass_root(dev_queue->qdisc_sleeping, skb, tcm, cb,
1819 /* Main classifier routine: scans classifier chain attached
1820 * to this qdisc, (optionally) tests for protocol and asks
1821 * specific classifiers.
1823 int tc_classify(struct sk_buff *skb, const struct tcf_proto *tp,
1824 struct tcf_result *res, bool compat_mode)
1826 __be16 protocol = tc_skb_protocol(skb);
1827 #ifdef CONFIG_NET_CLS_ACT
1828 const struct tcf_proto *old_tp = tp;
1833 for (; tp; tp = rcu_dereference_bh(tp->next)) {
1836 if (tp->protocol != protocol &&
1837 tp->protocol != htons(ETH_P_ALL))
1840 err = tp->classify(skb, tp, res);
1841 #ifdef CONFIG_NET_CLS_ACT
1842 if (unlikely(err == TC_ACT_RECLASSIFY && !compat_mode))
1849 return TC_ACT_UNSPEC; /* signal: continue lookup */
1850 #ifdef CONFIG_NET_CLS_ACT
1852 if (unlikely(limit++ >= MAX_REC_LOOP)) {
1853 net_notice_ratelimited("%s: reclassify loop, rule prio %u, protocol %02x\n",
1854 tp->q->ops->id, tp->prio & 0xffff,
1855 ntohs(tp->protocol));
1860 protocol = tc_skb_protocol(skb);
1864 EXPORT_SYMBOL(tc_classify);
1866 bool tcf_destroy(struct tcf_proto *tp, bool force)
1868 if (tp->ops->destroy(tp, force)) {
1869 module_put(tp->ops->owner);
1877 void tcf_destroy_chain(struct tcf_proto __rcu **fl)
1879 struct tcf_proto *tp;
1881 while ((tp = rtnl_dereference(*fl)) != NULL) {
1882 RCU_INIT_POINTER(*fl, tp->next);
1883 tcf_destroy(tp, true);
1886 EXPORT_SYMBOL(tcf_destroy_chain);
1888 #ifdef CONFIG_PROC_FS
1889 static int psched_show(struct seq_file *seq, void *v)
1891 seq_printf(seq, "%08x %08x %08x %08x\n",
1892 (u32)NSEC_PER_USEC, (u32)PSCHED_TICKS2NS(1),
1894 (u32)NSEC_PER_SEC / hrtimer_resolution);
1899 static int psched_open(struct inode *inode, struct file *file)
1901 return single_open(file, psched_show, NULL);
1904 static const struct file_operations psched_fops = {
1905 .owner = THIS_MODULE,
1906 .open = psched_open,
1908 .llseek = seq_lseek,
1909 .release = single_release,
1912 static int __net_init psched_net_init(struct net *net)
1914 struct proc_dir_entry *e;
1916 e = proc_create("psched", 0, net->proc_net, &psched_fops);
1923 static void __net_exit psched_net_exit(struct net *net)
1925 remove_proc_entry("psched", net->proc_net);
1928 static int __net_init psched_net_init(struct net *net)
1933 static void __net_exit psched_net_exit(struct net *net)
1938 static struct pernet_operations psched_net_ops = {
1939 .init = psched_net_init,
1940 .exit = psched_net_exit,
1943 static int __init pktsched_init(void)
1947 err = register_pernet_subsys(&psched_net_ops);
1949 pr_err("pktsched_init: "
1950 "cannot initialize per netns operations\n");
1954 register_qdisc(&pfifo_fast_ops);
1955 register_qdisc(&pfifo_qdisc_ops);
1956 register_qdisc(&bfifo_qdisc_ops);
1957 register_qdisc(&pfifo_head_drop_qdisc_ops);
1958 register_qdisc(&mq_qdisc_ops);
1959 register_qdisc(&noqueue_qdisc_ops);
1961 rtnl_register(PF_UNSPEC, RTM_NEWQDISC, tc_modify_qdisc, NULL, NULL);
1962 rtnl_register(PF_UNSPEC, RTM_DELQDISC, tc_get_qdisc, NULL, NULL);
1963 rtnl_register(PF_UNSPEC, RTM_GETQDISC, tc_get_qdisc, tc_dump_qdisc, NULL);
1964 rtnl_register(PF_UNSPEC, RTM_NEWTCLASS, tc_ctl_tclass, NULL, NULL);
1965 rtnl_register(PF_UNSPEC, RTM_DELTCLASS, tc_ctl_tclass, NULL, NULL);
1966 rtnl_register(PF_UNSPEC, RTM_GETTCLASS, tc_ctl_tclass, tc_dump_tclass, NULL);
1971 subsys_initcall(pktsched_init);