blob: dca6c1a576f77e70ee7cab5c187946c96a7219d2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/module.h>
19#include <linux/types.h>
20#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#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>
Patrick McHardy41794772007-03-16 01:19:15 -070029#include <linux/hrtimer.h>
Jarek Poplawski25bfcd52008-08-18 20:53:34 -070030#include <linux/lockdep.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090031#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020033#include <net/net_namespace.h>
Denis V. Lunevb8542722007-12-01 00:21:31 +110034#include <net/sock.h>
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -070035#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <net/pkt_sched.h>
37
Tom Goff7316ae82010-03-19 15:40:13 +000038static int qdisc_notify(struct net *net, struct sk_buff *oskb,
39 struct nlmsghdr *n, u32 clid,
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 struct Qdisc *old, struct Qdisc *new);
Tom Goff7316ae82010-03-19 15:40:13 +000041static int tclass_notify(struct net *net, struct sk_buff *oskb,
42 struct nlmsghdr *n, struct Qdisc *q,
43 unsigned long cl, int event);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45/*
46
47 Short review.
48 -------------
49
50 This file consists of two interrelated parts:
51
52 1. queueing disciplines manager frontend.
53 2. traffic classes manager frontend.
54
55 Generally, queueing discipline ("qdisc") is a black box,
56 which is able to enqueue packets and to dequeue them (when
57 device is ready to send something) in order and at times
58 determined by algorithm hidden in it.
59
60 qdisc's are divided to two categories:
61 - "queues", which have no internal structure visible from outside.
62 - "schedulers", which split all the packets to "traffic classes",
63 using "packet classifiers" (look at cls_api.c)
64
65 In turn, classes may have child qdiscs (as rule, queues)
66 attached to them etc. etc. etc.
67
68 The goal of the routines in this file is to translate
69 information supplied by user in the form of handles
70 to more intelligible for kernel form, to make some sanity
71 checks and part of work, which is common to all qdiscs
72 and to provide rtnetlink notifications.
73
74 All real intelligent work is done inside qdisc modules.
75
76
77
78 Every discipline has two major routines: enqueue and dequeue.
79
80 ---dequeue
81
82 dequeue usually returns a skb to send. It is allowed to return NULL,
83 but it does not mean that queue is empty, it just means that
84 discipline does not want to send anything this time.
85 Queue is really empty if q->q.qlen == 0.
86 For complicated disciplines with multiple queues q->q is not
87 real packet queue, but however q->q.qlen must be valid.
88
89 ---enqueue
90
91 enqueue returns 0, if packet was enqueued successfully.
92 If packet (this one or another one) was dropped, it returns
93 not zero error code.
94 NET_XMIT_DROP - this packet dropped
95 Expected action: do not backoff, but wait until queue will clear.
96 NET_XMIT_CN - probably this packet enqueued, but another one dropped.
97 Expected action: backoff or ignore
98 NET_XMIT_POLICED - dropped by police.
99 Expected action: backoff or error to real-time apps.
100
101 Auxiliary routines:
102
Jarek Poplawski99c0db22008-10-31 00:45:27 -0700103 ---peek
104
105 like dequeue but without removing a packet from the queue
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 ---reset
108
109 returns qdisc to initial state: purge all buffers, clear all
110 timers, counters (except for statistics) etc.
111
112 ---init
113
114 initializes newly created qdisc.
115
116 ---destroy
117
118 destroys resources allocated by init and during lifetime of qdisc.
119
120 ---change
121
122 changes qdisc parameters.
123 */
124
125/* Protects list of registered TC modules. It is pure SMP lock. */
126static DEFINE_RWLOCK(qdisc_mod_lock);
127
128
129/************************************************
130 * Queueing disciplines manipulation. *
131 ************************************************/
132
133
134/* The list of all installed queueing disciplines. */
135
136static struct Qdisc_ops *qdisc_base;
137
138/* Register/uregister queueing discipline */
139
140int register_qdisc(struct Qdisc_ops *qops)
141{
142 struct Qdisc_ops *q, **qp;
143 int rc = -EEXIST;
144
145 write_lock(&qdisc_mod_lock);
146 for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
147 if (!strcmp(qops->id, q->id))
148 goto out;
149
150 if (qops->enqueue == NULL)
151 qops->enqueue = noop_qdisc_ops.enqueue;
Jarek Poplawski99c0db22008-10-31 00:45:27 -0700152 if (qops->peek == NULL) {
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000153 if (qops->dequeue == NULL)
Jarek Poplawski99c0db22008-10-31 00:45:27 -0700154 qops->peek = noop_qdisc_ops.peek;
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000155 else
156 goto out_einval;
Jarek Poplawski99c0db22008-10-31 00:45:27 -0700157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 if (qops->dequeue == NULL)
159 qops->dequeue = noop_qdisc_ops.dequeue;
160
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000161 if (qops->cl_ops) {
162 const struct Qdisc_class_ops *cops = qops->cl_ops;
163
Jarek Poplawski3e9e5a52010-08-10 22:31:20 +0000164 if (!(cops->get && cops->put && cops->walk && cops->leaf))
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000165 goto out_einval;
166
167 if (cops->tcf_chain && !(cops->bind_tcf && cops->unbind_tcf))
168 goto out_einval;
169 }
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 qops->next = NULL;
172 *qp = qops;
173 rc = 0;
174out:
175 write_unlock(&qdisc_mod_lock);
176 return rc;
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000177
178out_einval:
179 rc = -EINVAL;
180 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181}
Patrick McHardy62e3ba12008-01-22 22:10:23 -0800182EXPORT_SYMBOL(register_qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184int unregister_qdisc(struct Qdisc_ops *qops)
185{
186 struct Qdisc_ops *q, **qp;
187 int err = -ENOENT;
188
189 write_lock(&qdisc_mod_lock);
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000190 for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 if (q == qops)
192 break;
193 if (q) {
194 *qp = q->next;
195 q->next = NULL;
196 err = 0;
197 }
198 write_unlock(&qdisc_mod_lock);
199 return err;
200}
Patrick McHardy62e3ba12008-01-22 22:10:23 -0800201EXPORT_SYMBOL(unregister_qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
203/* We know handle. Find qdisc among all qdisc's attached to device
204 (root qdisc, all its children, children of children etc.)
205 */
206
Hannes Eder6113b742008-11-28 03:06:46 -0800207static struct Qdisc *qdisc_match_from_root(struct Qdisc *root, u32 handle)
David S. Miller8123b422008-08-08 23:23:39 -0700208{
209 struct Qdisc *q;
210
211 if (!(root->flags & TCQ_F_BUILTIN) &&
212 root->handle == handle)
213 return root;
214
215 list_for_each_entry(q, &root->list, list) {
216 if (q->handle == handle)
217 return q;
218 }
219 return NULL;
220}
221
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700222static void qdisc_list_add(struct Qdisc *q)
223{
Jarek Poplawskif6486d42008-11-25 13:56:06 -0800224 if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS))
Patrick McHardyaf356af2009-09-04 06:41:18 +0000225 list_add_tail(&q->list, &qdisc_dev(q)->qdisc->list);
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700226}
227
228void qdisc_list_del(struct Qdisc *q)
229{
Jarek Poplawskif6486d42008-11-25 13:56:06 -0800230 if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS))
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700231 list_del(&q->list);
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700232}
233EXPORT_SYMBOL(qdisc_list_del);
234
David S. Milleread81cc2008-07-17 00:50:32 -0700235struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle)
Patrick McHardy43effa12006-11-29 17:35:48 -0800236{
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700237 struct Qdisc *q;
238
Patrick McHardyaf356af2009-09-04 06:41:18 +0000239 q = qdisc_match_from_root(dev->qdisc, handle);
240 if (q)
241 goto out;
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700242
Eric Dumazet24824a02010-10-02 06:11:55 +0000243 if (dev_ingress_queue(dev))
244 q = qdisc_match_from_root(
245 dev_ingress_queue(dev)->qdisc_sleeping,
246 handle);
Jarek Poplawskif6486d42008-11-25 13:56:06 -0800247out:
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700248 return q;
Patrick McHardy43effa12006-11-29 17:35:48 -0800249}
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251static struct Qdisc *qdisc_leaf(struct Qdisc *p, u32 classid)
252{
253 unsigned long cl;
254 struct Qdisc *leaf;
Eric Dumazet20fea082007-11-14 01:44:41 -0800255 const struct Qdisc_class_ops *cops = p->ops->cl_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 if (cops == NULL)
258 return NULL;
259 cl = cops->get(p, classid);
260
261 if (cl == 0)
262 return NULL;
263 leaf = cops->leaf(p, cl);
264 cops->put(p, cl);
265 return leaf;
266}
267
268/* Find queueing discipline by name */
269
Patrick McHardy1e904742008-01-22 22:11:17 -0800270static struct Qdisc_ops *qdisc_lookup_ops(struct nlattr *kind)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271{
272 struct Qdisc_ops *q = NULL;
273
274 if (kind) {
275 read_lock(&qdisc_mod_lock);
276 for (q = qdisc_base; q; q = q->next) {
Patrick McHardy1e904742008-01-22 22:11:17 -0800277 if (nla_strcmp(kind, q->id) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 if (!try_module_get(q->owner))
279 q = NULL;
280 break;
281 }
282 }
283 read_unlock(&qdisc_mod_lock);
284 }
285 return q;
286}
287
288static struct qdisc_rate_table *qdisc_rtab_list;
289
Patrick McHardy1e904742008-01-22 22:11:17 -0800290struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct nlattr *tab)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291{
292 struct qdisc_rate_table *rtab;
293
294 for (rtab = qdisc_rtab_list; rtab; rtab = rtab->next) {
295 if (memcmp(&rtab->rate, r, sizeof(struct tc_ratespec)) == 0) {
296 rtab->refcnt++;
297 return rtab;
298 }
299 }
300
Patrick McHardy5feb5e12008-01-23 20:35:19 -0800301 if (tab == NULL || r->rate == 0 || r->cell_log == 0 ||
302 nla_len(tab) != TC_RTAB_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 return NULL;
304
305 rtab = kmalloc(sizeof(*rtab), GFP_KERNEL);
306 if (rtab) {
307 rtab->rate = *r;
308 rtab->refcnt = 1;
Patrick McHardy1e904742008-01-22 22:11:17 -0800309 memcpy(rtab->data, nla_data(tab), 1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 rtab->next = qdisc_rtab_list;
311 qdisc_rtab_list = rtab;
312 }
313 return rtab;
314}
Patrick McHardy62e3ba12008-01-22 22:10:23 -0800315EXPORT_SYMBOL(qdisc_get_rtab);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317void qdisc_put_rtab(struct qdisc_rate_table *tab)
318{
319 struct qdisc_rate_table *rtab, **rtabp;
320
321 if (!tab || --tab->refcnt)
322 return;
323
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000324 for (rtabp = &qdisc_rtab_list;
325 (rtab = *rtabp) != NULL;
326 rtabp = &rtab->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 if (rtab == tab) {
328 *rtabp = rtab->next;
329 kfree(rtab);
330 return;
331 }
332 }
333}
Patrick McHardy62e3ba12008-01-22 22:10:23 -0800334EXPORT_SYMBOL(qdisc_put_rtab);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700336static LIST_HEAD(qdisc_stab_list);
337static DEFINE_SPINLOCK(qdisc_stab_lock);
338
339static const struct nla_policy stab_policy[TCA_STAB_MAX + 1] = {
340 [TCA_STAB_BASE] = { .len = sizeof(struct tc_sizespec) },
341 [TCA_STAB_DATA] = { .type = NLA_BINARY },
342};
343
344static struct qdisc_size_table *qdisc_get_stab(struct nlattr *opt)
345{
346 struct nlattr *tb[TCA_STAB_MAX + 1];
347 struct qdisc_size_table *stab;
348 struct tc_sizespec *s;
349 unsigned int tsize = 0;
350 u16 *tab = NULL;
351 int err;
352
353 err = nla_parse_nested(tb, TCA_STAB_MAX, opt, stab_policy);
354 if (err < 0)
355 return ERR_PTR(err);
356 if (!tb[TCA_STAB_BASE])
357 return ERR_PTR(-EINVAL);
358
359 s = nla_data(tb[TCA_STAB_BASE]);
360
361 if (s->tsize > 0) {
362 if (!tb[TCA_STAB_DATA])
363 return ERR_PTR(-EINVAL);
364 tab = nla_data(tb[TCA_STAB_DATA]);
365 tsize = nla_len(tb[TCA_STAB_DATA]) / sizeof(u16);
366 }
367
Dan Carpenter00093fa2010-08-14 11:09:49 +0000368 if (tsize != s->tsize || (!tab && tsize > 0))
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700369 return ERR_PTR(-EINVAL);
370
David S. Millerf3b96052008-08-18 22:33:05 -0700371 spin_lock(&qdisc_stab_lock);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700372
373 list_for_each_entry(stab, &qdisc_stab_list, list) {
374 if (memcmp(&stab->szopts, s, sizeof(*s)))
375 continue;
376 if (tsize > 0 && memcmp(stab->data, tab, tsize * sizeof(u16)))
377 continue;
378 stab->refcnt++;
David S. Millerf3b96052008-08-18 22:33:05 -0700379 spin_unlock(&qdisc_stab_lock);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700380 return stab;
381 }
382
David S. Millerf3b96052008-08-18 22:33:05 -0700383 spin_unlock(&qdisc_stab_lock);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700384
385 stab = kmalloc(sizeof(*stab) + tsize * sizeof(u16), GFP_KERNEL);
386 if (!stab)
387 return ERR_PTR(-ENOMEM);
388
389 stab->refcnt = 1;
390 stab->szopts = *s;
391 if (tsize > 0)
392 memcpy(stab->data, tab, tsize * sizeof(u16));
393
David S. Millerf3b96052008-08-18 22:33:05 -0700394 spin_lock(&qdisc_stab_lock);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700395 list_add_tail(&stab->list, &qdisc_stab_list);
David S. Millerf3b96052008-08-18 22:33:05 -0700396 spin_unlock(&qdisc_stab_lock);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700397
398 return stab;
399}
400
Eric Dumazeta2da5702011-01-20 03:48:19 +0000401static void stab_kfree_rcu(struct rcu_head *head)
402{
403 kfree(container_of(head, struct qdisc_size_table, rcu));
404}
405
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700406void qdisc_put_stab(struct qdisc_size_table *tab)
407{
408 if (!tab)
409 return;
410
David S. Millerf3b96052008-08-18 22:33:05 -0700411 spin_lock(&qdisc_stab_lock);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700412
413 if (--tab->refcnt == 0) {
414 list_del(&tab->list);
Eric Dumazeta2da5702011-01-20 03:48:19 +0000415 call_rcu_bh(&tab->rcu, stab_kfree_rcu);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700416 }
417
David S. Millerf3b96052008-08-18 22:33:05 -0700418 spin_unlock(&qdisc_stab_lock);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700419}
420EXPORT_SYMBOL(qdisc_put_stab);
421
422static int qdisc_dump_stab(struct sk_buff *skb, struct qdisc_size_table *stab)
423{
424 struct nlattr *nest;
425
426 nest = nla_nest_start(skb, TCA_STAB);
Patrick McHardy3aa46142008-11-20 04:07:14 -0800427 if (nest == NULL)
428 goto nla_put_failure;
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700429 NLA_PUT(skb, TCA_STAB_BASE, sizeof(stab->szopts), &stab->szopts);
430 nla_nest_end(skb, nest);
431
432 return skb->len;
433
434nla_put_failure:
435 return -1;
436}
437
Eric Dumazeta2da5702011-01-20 03:48:19 +0000438void __qdisc_calculate_pkt_len(struct sk_buff *skb, const struct qdisc_size_table *stab)
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700439{
440 int pkt_len, slot;
441
442 pkt_len = skb->len + stab->szopts.overhead;
443 if (unlikely(!stab->szopts.tsize))
444 goto out;
445
446 slot = pkt_len + stab->szopts.cell_align;
447 if (unlikely(slot < 0))
448 slot = 0;
449
450 slot >>= stab->szopts.cell_log;
451 if (likely(slot < stab->szopts.tsize))
452 pkt_len = stab->data[slot];
453 else
454 pkt_len = stab->data[stab->szopts.tsize - 1] *
455 (slot / stab->szopts.tsize) +
456 stab->data[slot % stab->szopts.tsize];
457
458 pkt_len <<= stab->szopts.size_log;
459out:
460 if (unlikely(pkt_len < 1))
461 pkt_len = 1;
462 qdisc_skb_cb(skb)->pkt_len = pkt_len;
463}
Eric Dumazeta2da5702011-01-20 03:48:19 +0000464EXPORT_SYMBOL(__qdisc_calculate_pkt_len);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700465
Jarek Poplawskib00355d2009-02-01 01:12:42 -0800466void qdisc_warn_nonwc(char *txt, struct Qdisc *qdisc)
467{
468 if (!(qdisc->flags & TCQ_F_WARN_NONWC)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000469 pr_warn("%s: %s qdisc %X: is non-work-conserving?\n",
470 txt, qdisc->ops->id, qdisc->handle >> 16);
Jarek Poplawskib00355d2009-02-01 01:12:42 -0800471 qdisc->flags |= TCQ_F_WARN_NONWC;
472 }
473}
474EXPORT_SYMBOL(qdisc_warn_nonwc);
475
Patrick McHardy41794772007-03-16 01:19:15 -0700476static enum hrtimer_restart qdisc_watchdog(struct hrtimer *timer)
477{
478 struct qdisc_watchdog *wd = container_of(timer, struct qdisc_watchdog,
David S. Miller2fbd3da2009-09-01 17:59:25 -0700479 timer);
Patrick McHardy41794772007-03-16 01:19:15 -0700480
Eric Dumazetfd245a42011-01-20 05:27:16 +0000481 qdisc_unthrottled(wd->qdisc);
David S. Miller8608db02008-08-18 20:51:18 -0700482 __netif_schedule(qdisc_root(wd->qdisc));
Stephen Hemminger19365022007-03-22 12:18:35 -0700483
Patrick McHardy41794772007-03-16 01:19:15 -0700484 return HRTIMER_NORESTART;
485}
486
487void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc)
488{
David S. Miller2fbd3da2009-09-01 17:59:25 -0700489 hrtimer_init(&wd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
490 wd->timer.function = qdisc_watchdog;
Patrick McHardy41794772007-03-16 01:19:15 -0700491 wd->qdisc = qdisc;
492}
493EXPORT_SYMBOL(qdisc_watchdog_init);
494
495void qdisc_watchdog_schedule(struct qdisc_watchdog *wd, psched_time_t expires)
496{
497 ktime_t time;
498
Jarek Poplawski2540e052008-08-21 05:11:14 -0700499 if (test_bit(__QDISC_STATE_DEACTIVATED,
500 &qdisc_root_sleeping(wd->qdisc)->state))
501 return;
502
Eric Dumazetfd245a42011-01-20 05:27:16 +0000503 qdisc_throttled(wd->qdisc);
Patrick McHardy41794772007-03-16 01:19:15 -0700504 time = ktime_set(0, 0);
Jarek Poplawskica44d6e2009-06-15 02:31:47 -0700505 time = ktime_add_ns(time, PSCHED_TICKS2NS(expires));
David S. Miller2fbd3da2009-09-01 17:59:25 -0700506 hrtimer_start(&wd->timer, time, HRTIMER_MODE_ABS);
Patrick McHardy41794772007-03-16 01:19:15 -0700507}
508EXPORT_SYMBOL(qdisc_watchdog_schedule);
509
510void qdisc_watchdog_cancel(struct qdisc_watchdog *wd)
511{
David S. Miller2fbd3da2009-09-01 17:59:25 -0700512 hrtimer_cancel(&wd->timer);
Eric Dumazetfd245a42011-01-20 05:27:16 +0000513 qdisc_unthrottled(wd->qdisc);
Patrick McHardy41794772007-03-16 01:19:15 -0700514}
515EXPORT_SYMBOL(qdisc_watchdog_cancel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Adrian Bunka94f7792008-07-22 14:20:11 -0700517static struct hlist_head *qdisc_class_hash_alloc(unsigned int n)
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700518{
519 unsigned int size = n * sizeof(struct hlist_head), i;
520 struct hlist_head *h;
521
522 if (size <= PAGE_SIZE)
523 h = kmalloc(size, GFP_KERNEL);
524 else
525 h = (struct hlist_head *)
526 __get_free_pages(GFP_KERNEL, get_order(size));
527
528 if (h != NULL) {
529 for (i = 0; i < n; i++)
530 INIT_HLIST_HEAD(&h[i]);
531 }
532 return h;
533}
534
535static void qdisc_class_hash_free(struct hlist_head *h, unsigned int n)
536{
537 unsigned int size = n * sizeof(struct hlist_head);
538
539 if (size <= PAGE_SIZE)
540 kfree(h);
541 else
542 free_pages((unsigned long)h, get_order(size));
543}
544
545void qdisc_class_hash_grow(struct Qdisc *sch, struct Qdisc_class_hash *clhash)
546{
547 struct Qdisc_class_common *cl;
548 struct hlist_node *n, *next;
549 struct hlist_head *nhash, *ohash;
550 unsigned int nsize, nmask, osize;
551 unsigned int i, h;
552
553 /* Rehash when load factor exceeds 0.75 */
554 if (clhash->hashelems * 4 <= clhash->hashsize * 3)
555 return;
556 nsize = clhash->hashsize * 2;
557 nmask = nsize - 1;
558 nhash = qdisc_class_hash_alloc(nsize);
559 if (nhash == NULL)
560 return;
561
562 ohash = clhash->hash;
563 osize = clhash->hashsize;
564
565 sch_tree_lock(sch);
566 for (i = 0; i < osize; i++) {
567 hlist_for_each_entry_safe(cl, n, next, &ohash[i], hnode) {
568 h = qdisc_class_hash(cl->classid, nmask);
569 hlist_add_head(&cl->hnode, &nhash[h]);
570 }
571 }
572 clhash->hash = nhash;
573 clhash->hashsize = nsize;
574 clhash->hashmask = nmask;
575 sch_tree_unlock(sch);
576
577 qdisc_class_hash_free(ohash, osize);
578}
579EXPORT_SYMBOL(qdisc_class_hash_grow);
580
581int qdisc_class_hash_init(struct Qdisc_class_hash *clhash)
582{
583 unsigned int size = 4;
584
585 clhash->hash = qdisc_class_hash_alloc(size);
586 if (clhash->hash == NULL)
587 return -ENOMEM;
588 clhash->hashsize = size;
589 clhash->hashmask = size - 1;
590 clhash->hashelems = 0;
591 return 0;
592}
593EXPORT_SYMBOL(qdisc_class_hash_init);
594
595void qdisc_class_hash_destroy(struct Qdisc_class_hash *clhash)
596{
597 qdisc_class_hash_free(clhash->hash, clhash->hashsize);
598}
599EXPORT_SYMBOL(qdisc_class_hash_destroy);
600
601void qdisc_class_hash_insert(struct Qdisc_class_hash *clhash,
602 struct Qdisc_class_common *cl)
603{
604 unsigned int h;
605
606 INIT_HLIST_NODE(&cl->hnode);
607 h = qdisc_class_hash(cl->classid, clhash->hashmask);
608 hlist_add_head(&cl->hnode, &clhash->hash[h]);
609 clhash->hashelems++;
610}
611EXPORT_SYMBOL(qdisc_class_hash_insert);
612
613void qdisc_class_hash_remove(struct Qdisc_class_hash *clhash,
614 struct Qdisc_class_common *cl)
615{
616 hlist_del(&cl->hnode);
617 clhash->hashelems--;
618}
619EXPORT_SYMBOL(qdisc_class_hash_remove);
620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621/* Allocate an unique handle from space managed by kernel */
622
623static u32 qdisc_alloc_handle(struct net_device *dev)
624{
625 int i = 0x10000;
626 static u32 autohandle = TC_H_MAKE(0x80000000U, 0);
627
628 do {
629 autohandle += TC_H_MAKE(0x10000U, 0);
630 if (autohandle == TC_H_MAKE(TC_H_ROOT, 0))
631 autohandle = TC_H_MAKE(0x80000000U, 0);
632 } while (qdisc_lookup(dev, autohandle) && --i > 0);
633
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000634 return i > 0 ? autohandle : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635}
636
Patrick McHardy43effa12006-11-29 17:35:48 -0800637void qdisc_tree_decrease_qlen(struct Qdisc *sch, unsigned int n)
638{
Eric Dumazet20fea082007-11-14 01:44:41 -0800639 const struct Qdisc_class_ops *cops;
Patrick McHardy43effa12006-11-29 17:35:48 -0800640 unsigned long cl;
641 u32 parentid;
642
643 if (n == 0)
644 return;
645 while ((parentid = sch->parent)) {
Jarek Poplawski066a3b52008-04-14 15:10:42 -0700646 if (TC_H_MAJ(parentid) == TC_H_MAJ(TC_H_INGRESS))
647 return;
648
David S. Miller5ce2d482008-07-08 17:06:30 -0700649 sch = qdisc_lookup(qdisc_dev(sch), TC_H_MAJ(parentid));
Patrick McHardyffc8fef2007-07-30 17:11:50 -0700650 if (sch == NULL) {
651 WARN_ON(parentid != TC_H_ROOT);
652 return;
653 }
Patrick McHardy43effa12006-11-29 17:35:48 -0800654 cops = sch->ops->cl_ops;
655 if (cops->qlen_notify) {
656 cl = cops->get(sch, parentid);
657 cops->qlen_notify(sch, cl);
658 cops->put(sch, cl);
659 }
660 sch->q.qlen -= n;
661 }
662}
663EXPORT_SYMBOL(qdisc_tree_decrease_qlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Tom Goff7316ae82010-03-19 15:40:13 +0000665static void notify_and_destroy(struct net *net, struct sk_buff *skb,
666 struct nlmsghdr *n, u32 clid,
David S. Miller99194cf2008-07-17 04:54:10 -0700667 struct Qdisc *old, struct Qdisc *new)
668{
669 if (new || old)
Tom Goff7316ae82010-03-19 15:40:13 +0000670 qdisc_notify(net, skb, n, clid, old, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
David S. Miller4d8863a2008-08-18 21:03:15 -0700672 if (old)
David S. Miller99194cf2008-07-17 04:54:10 -0700673 qdisc_destroy(old);
David S. Miller99194cf2008-07-17 04:54:10 -0700674}
675
676/* Graft qdisc "new" to class "classid" of qdisc "parent" or
677 * to device "dev".
678 *
679 * When appropriate send a netlink notification using 'skb'
680 * and "n".
681 *
682 * On success, destroy old qdisc.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 */
684
685static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
David S. Miller99194cf2008-07-17 04:54:10 -0700686 struct sk_buff *skb, struct nlmsghdr *n, u32 classid,
687 struct Qdisc *new, struct Qdisc *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688{
David S. Miller99194cf2008-07-17 04:54:10 -0700689 struct Qdisc *q = old;
Tom Goff7316ae82010-03-19 15:40:13 +0000690 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900693 if (parent == NULL) {
David S. Miller99194cf2008-07-17 04:54:10 -0700694 unsigned int i, num_q, ingress;
695
696 ingress = 0;
697 num_q = dev->num_tx_queues;
David S. Miller8d50b532008-07-30 02:37:46 -0700698 if ((q && q->flags & TCQ_F_INGRESS) ||
699 (new && new->flags & TCQ_F_INGRESS)) {
David S. Miller99194cf2008-07-17 04:54:10 -0700700 num_q = 1;
701 ingress = 1;
Eric Dumazet24824a02010-10-02 06:11:55 +0000702 if (!dev_ingress_queue(dev))
703 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 }
David S. Miller99194cf2008-07-17 04:54:10 -0700705
706 if (dev->flags & IFF_UP)
707 dev_deactivate(dev);
708
David S. Miller6ec1c692009-09-06 01:58:51 -0700709 if (new && new->ops->attach) {
710 new->ops->attach(new);
711 num_q = 0;
712 }
713
David S. Miller99194cf2008-07-17 04:54:10 -0700714 for (i = 0; i < num_q; i++) {
Eric Dumazet24824a02010-10-02 06:11:55 +0000715 struct netdev_queue *dev_queue = dev_ingress_queue(dev);
David S. Miller99194cf2008-07-17 04:54:10 -0700716
717 if (!ingress)
718 dev_queue = netdev_get_tx_queue(dev, i);
719
David S. Miller8d50b532008-07-30 02:37:46 -0700720 old = dev_graft_qdisc(dev_queue, new);
721 if (new && i > 0)
722 atomic_inc(&new->refcnt);
723
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000724 if (!ingress)
725 qdisc_destroy(old);
David S. Miller99194cf2008-07-17 04:54:10 -0700726 }
727
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000728 if (!ingress) {
Tom Goff7316ae82010-03-19 15:40:13 +0000729 notify_and_destroy(net, skb, n, classid,
730 dev->qdisc, new);
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000731 if (new && !new->ops->attach)
732 atomic_inc(&new->refcnt);
733 dev->qdisc = new ? : &noop_qdisc;
734 } else {
Tom Goff7316ae82010-03-19 15:40:13 +0000735 notify_and_destroy(net, skb, n, classid, old, new);
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000736 }
Patrick McHardyaf356af2009-09-04 06:41:18 +0000737
David S. Miller99194cf2008-07-17 04:54:10 -0700738 if (dev->flags & IFF_UP)
739 dev_activate(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 } else {
Eric Dumazet20fea082007-11-14 01:44:41 -0800741 const struct Qdisc_class_ops *cops = parent->ops->cl_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Patrick McHardyc9f1d032009-09-04 06:41:13 +0000743 err = -EOPNOTSUPP;
744 if (cops && cops->graft) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 unsigned long cl = cops->get(parent, classid);
746 if (cl) {
David S. Miller99194cf2008-07-17 04:54:10 -0700747 err = cops->graft(parent, cl, new, &old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 cops->put(parent, cl);
Patrick McHardyc9f1d032009-09-04 06:41:13 +0000749 } else
750 err = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 }
David S. Miller99194cf2008-07-17 04:54:10 -0700752 if (!err)
Tom Goff7316ae82010-03-19 15:40:13 +0000753 notify_and_destroy(net, skb, n, classid, old, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 }
755 return err;
756}
757
Jarek Poplawski25bfcd52008-08-18 20:53:34 -0700758/* lockdep annotation is needed for ingress; egress gets it only for name */
759static struct lock_class_key qdisc_tx_lock;
760static struct lock_class_key qdisc_rx_lock;
761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762/*
763 Allocate and initialize new qdisc.
764
765 Parameters are passed via opt.
766 */
767
768static struct Qdisc *
David S. Millerbb949fb2008-07-08 16:55:56 -0700769qdisc_create(struct net_device *dev, struct netdev_queue *dev_queue,
Patrick McHardy23bcf632009-09-09 18:11:23 -0700770 struct Qdisc *p, u32 parent, u32 handle,
771 struct nlattr **tca, int *errp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772{
773 int err;
Patrick McHardy1e904742008-01-22 22:11:17 -0800774 struct nlattr *kind = tca[TCA_KIND];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 struct Qdisc *sch;
776 struct Qdisc_ops *ops;
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700777 struct qdisc_size_table *stab;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
779 ops = qdisc_lookup_ops(kind);
Johannes Berg95a5afc2008-10-16 15:24:51 -0700780#ifdef CONFIG_MODULES
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (ops == NULL && kind != NULL) {
782 char name[IFNAMSIZ];
Patrick McHardy1e904742008-01-22 22:11:17 -0800783 if (nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 /* We dropped the RTNL semaphore in order to
785 * perform the module load. So, even if we
786 * succeeded in loading the module we have to
787 * tell the caller to replay the request. We
788 * indicate this using -EAGAIN.
789 * We replay the request because the device may
790 * go away in the mean time.
791 */
792 rtnl_unlock();
793 request_module("sch_%s", name);
794 rtnl_lock();
795 ops = qdisc_lookup_ops(kind);
796 if (ops != NULL) {
797 /* We will try again qdisc_lookup_ops,
798 * so don't keep a reference.
799 */
800 module_put(ops->owner);
801 err = -EAGAIN;
802 goto err_out;
803 }
804 }
805 }
806#endif
807
Jamal Hadi Salimb9e2cc02006-08-03 16:36:51 -0700808 err = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 if (ops == NULL)
810 goto err_out;
811
David S. Miller5ce2d482008-07-08 17:06:30 -0700812 sch = qdisc_alloc(dev_queue, ops);
Thomas Graf3d54b822005-07-05 14:15:09 -0700813 if (IS_ERR(sch)) {
814 err = PTR_ERR(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 goto err_out2;
Thomas Graf3d54b822005-07-05 14:15:09 -0700816 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Patrick McHardyffc8fef2007-07-30 17:11:50 -0700818 sch->parent = parent;
819
Thomas Graf3d54b822005-07-05 14:15:09 -0700820 if (handle == TC_H_INGRESS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 sch->flags |= TCQ_F_INGRESS;
Thomas Graf3d54b822005-07-05 14:15:09 -0700822 handle = TC_H_MAKE(TC_H_INGRESS, 0);
Jarek Poplawski25bfcd52008-08-18 20:53:34 -0700823 lockdep_set_class(qdisc_lock(sch), &qdisc_rx_lock);
Patrick McHardyfd44de72007-04-16 17:07:08 -0700824 } else {
Patrick McHardyfd44de72007-04-16 17:07:08 -0700825 if (handle == 0) {
826 handle = qdisc_alloc_handle(dev);
827 err = -ENOMEM;
828 if (handle == 0)
829 goto err_out3;
830 }
Jarek Poplawski25bfcd52008-08-18 20:53:34 -0700831 lockdep_set_class(qdisc_lock(sch), &qdisc_tx_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 }
833
Thomas Graf3d54b822005-07-05 14:15:09 -0700834 sch->handle = handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Patrick McHardy1e904742008-01-22 22:11:17 -0800836 if (!ops->init || (err = ops->init(sch, tca[TCA_OPTIONS])) == 0) {
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700837 if (tca[TCA_STAB]) {
838 stab = qdisc_get_stab(tca[TCA_STAB]);
839 if (IS_ERR(stab)) {
840 err = PTR_ERR(stab);
Jarek Poplawski7c64b9f2009-09-15 23:42:05 -0700841 goto err_out4;
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700842 }
Eric Dumazeta2da5702011-01-20 03:48:19 +0000843 rcu_assign_pointer(sch->stab, stab);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700844 }
Patrick McHardy1e904742008-01-22 22:11:17 -0800845 if (tca[TCA_RATE]) {
Jarek Poplawskif6f9b932008-08-27 02:25:17 -0700846 spinlock_t *root_lock;
847
Patrick McHardy23bcf632009-09-09 18:11:23 -0700848 err = -EOPNOTSUPP;
849 if (sch->flags & TCQ_F_MQROOT)
850 goto err_out4;
851
Jarek Poplawskif6f9b932008-08-27 02:25:17 -0700852 if ((sch->parent != TC_H_ROOT) &&
Patrick McHardy23bcf632009-09-09 18:11:23 -0700853 !(sch->flags & TCQ_F_INGRESS) &&
854 (!p || !(p->flags & TCQ_F_MQROOT)))
Jarek Poplawskif6f9b932008-08-27 02:25:17 -0700855 root_lock = qdisc_root_sleeping_lock(sch);
856 else
857 root_lock = qdisc_lock(sch);
858
Thomas Graf023e09a2005-07-05 14:15:53 -0700859 err = gen_new_estimator(&sch->bstats, &sch->rate_est,
Jarek Poplawskif6f9b932008-08-27 02:25:17 -0700860 root_lock, tca[TCA_RATE]);
Patrick McHardy23bcf632009-09-09 18:11:23 -0700861 if (err)
862 goto err_out4;
Thomas Graf023e09a2005-07-05 14:15:53 -0700863 }
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700864
865 qdisc_list_add(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 return sch;
868 }
869err_out3:
870 dev_put(dev);
Thomas Graf3d54b822005-07-05 14:15:09 -0700871 kfree((char *) sch - sch->padded);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872err_out2:
873 module_put(ops->owner);
874err_out:
875 *errp = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 return NULL;
Patrick McHardy23bcf632009-09-09 18:11:23 -0700877
878err_out4:
879 /*
880 * Any broken qdiscs that would require a ops->reset() here?
881 * The qdisc was never in action so it shouldn't be necessary.
882 */
Eric Dumazeta2da5702011-01-20 03:48:19 +0000883 qdisc_put_stab(rtnl_dereference(sch->stab));
Patrick McHardy23bcf632009-09-09 18:11:23 -0700884 if (ops->destroy)
885 ops->destroy(sch);
886 goto err_out3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887}
888
Patrick McHardy1e904742008-01-22 22:11:17 -0800889static int qdisc_change(struct Qdisc *sch, struct nlattr **tca)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890{
Eric Dumazeta2da5702011-01-20 03:48:19 +0000891 struct qdisc_size_table *ostab, *stab = NULL;
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700892 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700894 if (tca[TCA_OPTIONS]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 if (sch->ops->change == NULL)
896 return -EINVAL;
Patrick McHardy1e904742008-01-22 22:11:17 -0800897 err = sch->ops->change(sch, tca[TCA_OPTIONS]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 if (err)
899 return err;
900 }
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700901
902 if (tca[TCA_STAB]) {
903 stab = qdisc_get_stab(tca[TCA_STAB]);
904 if (IS_ERR(stab))
905 return PTR_ERR(stab);
906 }
907
Eric Dumazeta2da5702011-01-20 03:48:19 +0000908 ostab = rtnl_dereference(sch->stab);
909 rcu_assign_pointer(sch->stab, stab);
910 qdisc_put_stab(ostab);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700911
Patrick McHardy23bcf632009-09-09 18:11:23 -0700912 if (tca[TCA_RATE]) {
Stephen Hemminger71bcb092008-11-25 21:13:31 -0800913 /* NB: ignores errors from replace_estimator
914 because change can't be undone. */
Patrick McHardy23bcf632009-09-09 18:11:23 -0700915 if (sch->flags & TCQ_F_MQROOT)
916 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 gen_replace_estimator(&sch->bstats, &sch->rate_est,
Stephen Hemminger71bcb092008-11-25 21:13:31 -0800918 qdisc_root_sleeping_lock(sch),
919 tca[TCA_RATE]);
Patrick McHardy23bcf632009-09-09 18:11:23 -0700920 }
921out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 return 0;
923}
924
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000925struct check_loop_arg {
926 struct qdisc_walker w;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 struct Qdisc *p;
928 int depth;
929};
930
931static int check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w);
932
933static int check_loop(struct Qdisc *q, struct Qdisc *p, int depth)
934{
935 struct check_loop_arg arg;
936
937 if (q->ops->cl_ops == NULL)
938 return 0;
939
940 arg.w.stop = arg.w.skip = arg.w.count = 0;
941 arg.w.fn = check_loop_fn;
942 arg.depth = depth;
943 arg.p = p;
944 q->ops->cl_ops->walk(q, &arg.w);
945 return arg.w.stop ? -ELOOP : 0;
946}
947
948static int
949check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w)
950{
951 struct Qdisc *leaf;
Eric Dumazet20fea082007-11-14 01:44:41 -0800952 const struct Qdisc_class_ops *cops = q->ops->cl_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 struct check_loop_arg *arg = (struct check_loop_arg *)w;
954
955 leaf = cops->leaf(q, cl);
956 if (leaf) {
957 if (leaf == arg->p || arg->depth > 7)
958 return -ELOOP;
959 return check_loop(leaf, arg->p, arg->depth + 1);
960 }
961 return 0;
962}
963
964/*
965 * Delete/get qdisc.
966 */
967
968static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
969{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900970 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 struct tcmsg *tcm = NLMSG_DATA(n);
Patrick McHardy1e904742008-01-22 22:11:17 -0800972 struct nlattr *tca[TCA_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 struct net_device *dev;
974 u32 clid = tcm->tcm_parent;
975 struct Qdisc *q = NULL;
976 struct Qdisc *p = NULL;
977 int err;
978
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000979 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
980 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 return -ENODEV;
982
Patrick McHardy1e904742008-01-22 22:11:17 -0800983 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
984 if (err < 0)
985 return err;
986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 if (clid) {
988 if (clid != TC_H_ROOT) {
989 if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000990 p = qdisc_lookup(dev, TC_H_MAJ(clid));
991 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 return -ENOENT;
993 q = qdisc_leaf(p, clid);
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000994 } else if (dev_ingress_queue(dev)) {
995 q = dev_ingress_queue(dev)->qdisc_sleeping;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900996 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 } else {
Patrick McHardyaf356af2009-09-04 06:41:18 +0000998 q = dev->qdisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 }
1000 if (!q)
1001 return -ENOENT;
1002
1003 if (tcm->tcm_handle && q->handle != tcm->tcm_handle)
1004 return -EINVAL;
1005 } else {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001006 q = qdisc_lookup(dev, tcm->tcm_handle);
1007 if (!q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 return -ENOENT;
1009 }
1010
Patrick McHardy1e904742008-01-22 22:11:17 -08001011 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 return -EINVAL;
1013
1014 if (n->nlmsg_type == RTM_DELQDISC) {
1015 if (!clid)
1016 return -EINVAL;
1017 if (q->handle == 0)
1018 return -ENOENT;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001019 err = qdisc_graft(dev, p, skb, n, clid, NULL, q);
1020 if (err != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 } else {
Tom Goff7316ae82010-03-19 15:40:13 +00001023 qdisc_notify(net, skb, n, clid, NULL, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 }
1025 return 0;
1026}
1027
1028/*
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001029 * Create/change qdisc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 */
1031
1032static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
1033{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001034 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 struct tcmsg *tcm;
Patrick McHardy1e904742008-01-22 22:11:17 -08001036 struct nlattr *tca[TCA_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 struct net_device *dev;
1038 u32 clid;
1039 struct Qdisc *q, *p;
1040 int err;
1041
1042replay:
1043 /* Reinit, just in case something touches this. */
1044 tcm = NLMSG_DATA(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 clid = tcm->tcm_parent;
1046 q = p = NULL;
1047
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001048 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
1049 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 return -ENODEV;
1051
Patrick McHardy1e904742008-01-22 22:11:17 -08001052 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
1053 if (err < 0)
1054 return err;
1055
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 if (clid) {
1057 if (clid != TC_H_ROOT) {
1058 if (clid != TC_H_INGRESS) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001059 p = qdisc_lookup(dev, TC_H_MAJ(clid));
1060 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 return -ENOENT;
1062 q = qdisc_leaf(p, clid);
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001063 } else if (dev_ingress_queue_create(dev)) {
1064 q = dev_ingress_queue(dev)->qdisc_sleeping;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 }
1066 } else {
Patrick McHardyaf356af2009-09-04 06:41:18 +00001067 q = dev->qdisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 }
1069
1070 /* It may be default qdisc, ignore it */
1071 if (q && q->handle == 0)
1072 q = NULL;
1073
1074 if (!q || !tcm->tcm_handle || q->handle != tcm->tcm_handle) {
1075 if (tcm->tcm_handle) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001076 if (q && !(n->nlmsg_flags & NLM_F_REPLACE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 return -EEXIST;
1078 if (TC_H_MIN(tcm->tcm_handle))
1079 return -EINVAL;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001080 q = qdisc_lookup(dev, tcm->tcm_handle);
1081 if (!q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 goto create_n_graft;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001083 if (n->nlmsg_flags & NLM_F_EXCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 return -EEXIST;
Patrick McHardy1e904742008-01-22 22:11:17 -08001085 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 return -EINVAL;
1087 if (q == p ||
1088 (p && check_loop(q, p, 0)))
1089 return -ELOOP;
1090 atomic_inc(&q->refcnt);
1091 goto graft;
1092 } else {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001093 if (!q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 goto create_n_graft;
1095
1096 /* This magic test requires explanation.
1097 *
1098 * We know, that some child q is already
1099 * attached to this parent and have choice:
1100 * either to change it or to create/graft new one.
1101 *
1102 * 1. We are allowed to create/graft only
1103 * if CREATE and REPLACE flags are set.
1104 *
1105 * 2. If EXCL is set, requestor wanted to say,
1106 * that qdisc tcm_handle is not expected
1107 * to exist, so that we choose create/graft too.
1108 *
1109 * 3. The last case is when no flags are set.
1110 * Alas, it is sort of hole in API, we
1111 * cannot decide what to do unambiguously.
1112 * For now we select create/graft, if
1113 * user gave KIND, which does not match existing.
1114 */
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001115 if ((n->nlmsg_flags & NLM_F_CREATE) &&
1116 (n->nlmsg_flags & NLM_F_REPLACE) &&
1117 ((n->nlmsg_flags & NLM_F_EXCL) ||
Patrick McHardy1e904742008-01-22 22:11:17 -08001118 (tca[TCA_KIND] &&
1119 nla_strcmp(tca[TCA_KIND], q->ops->id))))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 goto create_n_graft;
1121 }
1122 }
1123 } else {
1124 if (!tcm->tcm_handle)
1125 return -EINVAL;
1126 q = qdisc_lookup(dev, tcm->tcm_handle);
1127 }
1128
1129 /* Change qdisc parameters */
1130 if (q == NULL)
1131 return -ENOENT;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001132 if (n->nlmsg_flags & NLM_F_EXCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 return -EEXIST;
Patrick McHardy1e904742008-01-22 22:11:17 -08001134 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 return -EINVAL;
1136 err = qdisc_change(q, tca);
1137 if (err == 0)
Tom Goff7316ae82010-03-19 15:40:13 +00001138 qdisc_notify(net, skb, n, clid, NULL, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 return err;
1140
1141create_n_graft:
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001142 if (!(n->nlmsg_flags & NLM_F_CREATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 return -ENOENT;
Eric Dumazet24824a02010-10-02 06:11:55 +00001144 if (clid == TC_H_INGRESS) {
1145 if (dev_ingress_queue(dev))
1146 q = qdisc_create(dev, dev_ingress_queue(dev), p,
1147 tcm->tcm_parent, tcm->tcm_parent,
1148 tca, &err);
1149 else
1150 err = -ENOENT;
1151 } else {
Jarek Poplawski926e61b2009-09-15 02:53:07 -07001152 struct netdev_queue *dev_queue;
David S. Miller6ec1c692009-09-06 01:58:51 -07001153
1154 if (p && p->ops->cl_ops && p->ops->cl_ops->select_queue)
Jarek Poplawski926e61b2009-09-15 02:53:07 -07001155 dev_queue = p->ops->cl_ops->select_queue(p, tcm);
1156 else if (p)
1157 dev_queue = p->dev_queue;
1158 else
1159 dev_queue = netdev_get_tx_queue(dev, 0);
David S. Miller6ec1c692009-09-06 01:58:51 -07001160
Jarek Poplawski926e61b2009-09-15 02:53:07 -07001161 q = qdisc_create(dev, dev_queue, p,
David S. Millerbb949fb2008-07-08 16:55:56 -07001162 tcm->tcm_parent, tcm->tcm_handle,
Patrick McHardyffc8fef2007-07-30 17:11:50 -07001163 tca, &err);
David S. Miller6ec1c692009-09-06 01:58:51 -07001164 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 if (q == NULL) {
1166 if (err == -EAGAIN)
1167 goto replay;
1168 return err;
1169 }
1170
1171graft:
Ilpo Järvinene5befbd2008-08-18 22:30:01 -07001172 err = qdisc_graft(dev, p, skb, n, clid, q, NULL);
1173 if (err) {
1174 if (q)
1175 qdisc_destroy(q);
1176 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 }
Ilpo Järvinene5befbd2008-08-18 22:30:01 -07001178
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 return 0;
1180}
1181
1182static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,
Jamal Hadi Salime431b8c2005-06-18 22:55:31 -07001183 u32 pid, u32 seq, u16 flags, int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184{
1185 struct tcmsg *tcm;
1186 struct nlmsghdr *nlh;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001187 unsigned char *b = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 struct gnet_dump d;
Eric Dumazeta2da5702011-01-20 03:48:19 +00001189 struct qdisc_size_table *stab;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190
Jamal Hadi Salime431b8c2005-06-18 22:55:31 -07001191 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 tcm = NLMSG_DATA(nlh);
1193 tcm->tcm_family = AF_UNSPEC;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -07001194 tcm->tcm__pad1 = 0;
1195 tcm->tcm__pad2 = 0;
David S. Miller5ce2d482008-07-08 17:06:30 -07001196 tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 tcm->tcm_parent = clid;
1198 tcm->tcm_handle = q->handle;
1199 tcm->tcm_info = atomic_read(&q->refcnt);
Patrick McHardy57e1c482008-01-23 20:34:28 -08001200 NLA_PUT_STRING(skb, TCA_KIND, q->ops->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 if (q->ops->dump && q->ops->dump(q, skb) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001202 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 q->qstats.qlen = q->q.qlen;
1204
Eric Dumazeta2da5702011-01-20 03:48:19 +00001205 stab = rtnl_dereference(q->stab);
1206 if (stab && qdisc_dump_stab(skb, stab) < 0)
Jussi Kivilinna175f9c12008-07-20 00:08:47 -07001207 goto nla_put_failure;
1208
Jarek Poplawski102396a2008-08-29 14:21:52 -07001209 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
1210 qdisc_root_sleeping_lock(q), &d) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001211 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
1213 if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001214 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
1216 if (gnet_stats_copy_basic(&d, &q->bstats) < 0 ||
Eric Dumazetd250a5f2009-10-02 10:32:18 +00001217 gnet_stats_copy_rate_est(&d, &q->bstats, &q->rate_est) < 0 ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 gnet_stats_copy_queue(&d, &q->qstats) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001219 goto nla_put_failure;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001220
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 if (gnet_stats_finish_copy(&d) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001222 goto nla_put_failure;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001223
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001224 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 return skb->len;
1226
1227nlmsg_failure:
Patrick McHardy1e904742008-01-22 22:11:17 -08001228nla_put_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -07001229 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 return -1;
1231}
1232
Eric Dumazet53b0f082010-05-22 20:37:44 +00001233static bool tc_qdisc_dump_ignore(struct Qdisc *q)
1234{
1235 return (q->flags & TCQ_F_BUILTIN) ? true : false;
1236}
1237
Tom Goff7316ae82010-03-19 15:40:13 +00001238static int qdisc_notify(struct net *net, struct sk_buff *oskb,
1239 struct nlmsghdr *n, u32 clid,
1240 struct Qdisc *old, struct Qdisc *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241{
1242 struct sk_buff *skb;
1243 u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;
1244
1245 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1246 if (!skb)
1247 return -ENOBUFS;
1248
Eric Dumazet53b0f082010-05-22 20:37:44 +00001249 if (old && !tc_qdisc_dump_ignore(old)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001250 if (tc_fill_qdisc(skb, old, clid, pid, n->nlmsg_seq,
1251 0, RTM_DELQDISC) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 goto err_out;
1253 }
Eric Dumazet53b0f082010-05-22 20:37:44 +00001254 if (new && !tc_qdisc_dump_ignore(new)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001255 if (tc_fill_qdisc(skb, new, clid, pid, n->nlmsg_seq,
1256 old ? NLM_F_REPLACE : 0, RTM_NEWQDISC) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 goto err_out;
1258 }
1259
1260 if (skb->len)
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001261 return rtnetlink_send(skb, net, pid, RTNLGRP_TC,
1262 n->nlmsg_flags & NLM_F_ECHO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
1264err_out:
1265 kfree_skb(skb);
1266 return -EINVAL;
1267}
1268
David S. Miller30723672008-07-18 22:50:15 -07001269static int tc_dump_qdisc_root(struct Qdisc *root, struct sk_buff *skb,
1270 struct netlink_callback *cb,
1271 int *q_idx_p, int s_q_idx)
1272{
1273 int ret = 0, q_idx = *q_idx_p;
1274 struct Qdisc *q;
1275
1276 if (!root)
1277 return 0;
1278
1279 q = root;
1280 if (q_idx < s_q_idx) {
1281 q_idx++;
1282 } else {
1283 if (!tc_qdisc_dump_ignore(q) &&
1284 tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).pid,
1285 cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0)
1286 goto done;
1287 q_idx++;
1288 }
1289 list_for_each_entry(q, &root->list, list) {
1290 if (q_idx < s_q_idx) {
1291 q_idx++;
1292 continue;
1293 }
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001294 if (!tc_qdisc_dump_ignore(q) &&
David S. Miller30723672008-07-18 22:50:15 -07001295 tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).pid,
1296 cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWQDISC) <= 0)
1297 goto done;
1298 q_idx++;
1299 }
1300
1301out:
1302 *q_idx_p = q_idx;
1303 return ret;
1304done:
1305 ret = -1;
1306 goto out;
1307}
1308
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
1310{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001311 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 int idx, q_idx;
1313 int s_idx, s_q_idx;
1314 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315
1316 s_idx = cb->args[0];
1317 s_q_idx = q_idx = cb->args[1];
stephen hemmingerf1e90162009-11-10 07:54:49 +00001318
1319 rcu_read_lock();
Pavel Emelianov7562f872007-05-03 15:13:45 -07001320 idx = 0;
Tom Goff7316ae82010-03-19 15:40:13 +00001321 for_each_netdev_rcu(net, dev) {
David S. Miller30723672008-07-18 22:50:15 -07001322 struct netdev_queue *dev_queue;
1323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 if (idx < s_idx)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001325 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 if (idx > s_idx)
1327 s_q_idx = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 q_idx = 0;
David S. Miller30723672008-07-18 22:50:15 -07001329
Patrick McHardyaf356af2009-09-04 06:41:18 +00001330 if (tc_dump_qdisc_root(dev->qdisc, skb, cb, &q_idx, s_q_idx) < 0)
David S. Miller30723672008-07-18 22:50:15 -07001331 goto done;
1332
Eric Dumazet24824a02010-10-02 06:11:55 +00001333 dev_queue = dev_ingress_queue(dev);
1334 if (dev_queue &&
1335 tc_dump_qdisc_root(dev_queue->qdisc_sleeping, skb, cb,
1336 &q_idx, s_q_idx) < 0)
David S. Miller30723672008-07-18 22:50:15 -07001337 goto done;
1338
Pavel Emelianov7562f872007-05-03 15:13:45 -07001339cont:
1340 idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 }
1342
1343done:
stephen hemmingerf1e90162009-11-10 07:54:49 +00001344 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
1346 cb->args[0] = idx;
1347 cb->args[1] = q_idx;
1348
1349 return skb->len;
1350}
1351
1352
1353
1354/************************************************
1355 * Traffic classes manipulation. *
1356 ************************************************/
1357
1358
1359
1360static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, void *arg)
1361{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001362 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 struct tcmsg *tcm = NLMSG_DATA(n);
Patrick McHardy1e904742008-01-22 22:11:17 -08001364 struct nlattr *tca[TCA_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 struct net_device *dev;
1366 struct Qdisc *q = NULL;
Eric Dumazet20fea082007-11-14 01:44:41 -08001367 const struct Qdisc_class_ops *cops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 unsigned long cl = 0;
1369 unsigned long new_cl;
1370 u32 pid = tcm->tcm_parent;
1371 u32 clid = tcm->tcm_handle;
1372 u32 qid = TC_H_MAJ(clid);
1373 int err;
1374
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001375 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
1376 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 return -ENODEV;
1378
Patrick McHardy1e904742008-01-22 22:11:17 -08001379 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL);
1380 if (err < 0)
1381 return err;
1382
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 /*
1384 parent == TC_H_UNSPEC - unspecified parent.
1385 parent == TC_H_ROOT - class is root, which has no parent.
1386 parent == X:0 - parent is root class.
1387 parent == X:Y - parent is a node in hierarchy.
1388 parent == 0:Y - parent is X:Y, where X:0 is qdisc.
1389
1390 handle == 0:0 - generate handle from kernel pool.
1391 handle == 0:Y - class is X:Y, where X:0 is qdisc.
1392 handle == X:Y - clear.
1393 handle == X:0 - root class.
1394 */
1395
1396 /* Step 1. Determine qdisc handle X:0 */
1397
1398 if (pid != TC_H_ROOT) {
1399 u32 qid1 = TC_H_MAJ(pid);
1400
1401 if (qid && qid1) {
1402 /* If both majors are known, they must be identical. */
1403 if (qid != qid1)
1404 return -EINVAL;
1405 } else if (qid1) {
1406 qid = qid1;
1407 } else if (qid == 0)
Patrick McHardyaf356af2009-09-04 06:41:18 +00001408 qid = dev->qdisc->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
1410 /* Now qid is genuine qdisc handle consistent
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001411 * both with parent and child.
1412 *
1413 * TC_H_MAJ(pid) still may be unspecified, complete it now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 */
1415 if (pid)
1416 pid = TC_H_MAKE(qid, pid);
1417 } else {
1418 if (qid == 0)
Patrick McHardyaf356af2009-09-04 06:41:18 +00001419 qid = dev->qdisc->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 }
1421
1422 /* OK. Locate qdisc */
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001423 q = qdisc_lookup(dev, qid);
1424 if (!q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 return -ENOENT;
1426
1427 /* An check that it supports classes */
1428 cops = q->ops->cl_ops;
1429 if (cops == NULL)
1430 return -EINVAL;
1431
1432 /* Now try to get class */
1433 if (clid == 0) {
1434 if (pid == TC_H_ROOT)
1435 clid = qid;
1436 } else
1437 clid = TC_H_MAKE(qid, clid);
1438
1439 if (clid)
1440 cl = cops->get(q, clid);
1441
1442 if (cl == 0) {
1443 err = -ENOENT;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001444 if (n->nlmsg_type != RTM_NEWTCLASS ||
1445 !(n->nlmsg_flags & NLM_F_CREATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 goto out;
1447 } else {
1448 switch (n->nlmsg_type) {
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001449 case RTM_NEWTCLASS:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 err = -EEXIST;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001451 if (n->nlmsg_flags & NLM_F_EXCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 goto out;
1453 break;
1454 case RTM_DELTCLASS:
Patrick McHardyde6d5cd2009-09-04 06:41:16 +00001455 err = -EOPNOTSUPP;
1456 if (cops->delete)
1457 err = cops->delete(q, cl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 if (err == 0)
Tom Goff7316ae82010-03-19 15:40:13 +00001459 tclass_notify(net, skb, n, q, cl, RTM_DELTCLASS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 goto out;
1461 case RTM_GETTCLASS:
Tom Goff7316ae82010-03-19 15:40:13 +00001462 err = tclass_notify(net, skb, n, q, cl, RTM_NEWTCLASS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 goto out;
1464 default:
1465 err = -EINVAL;
1466 goto out;
1467 }
1468 }
1469
1470 new_cl = cl;
Patrick McHardyde6d5cd2009-09-04 06:41:16 +00001471 err = -EOPNOTSUPP;
1472 if (cops->change)
1473 err = cops->change(q, clid, pid, tca, &new_cl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 if (err == 0)
Tom Goff7316ae82010-03-19 15:40:13 +00001475 tclass_notify(net, skb, n, q, new_cl, RTM_NEWTCLASS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476
1477out:
1478 if (cl)
1479 cops->put(q, cl);
1480
1481 return err;
1482}
1483
1484
1485static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,
1486 unsigned long cl,
Jamal Hadi Salime431b8c2005-06-18 22:55:31 -07001487 u32 pid, u32 seq, u16 flags, int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488{
1489 struct tcmsg *tcm;
1490 struct nlmsghdr *nlh;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001491 unsigned char *b = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 struct gnet_dump d;
Eric Dumazet20fea082007-11-14 01:44:41 -08001493 const struct Qdisc_class_ops *cl_ops = q->ops->cl_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
Jamal Hadi Salime431b8c2005-06-18 22:55:31 -07001495 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 tcm = NLMSG_DATA(nlh);
1497 tcm->tcm_family = AF_UNSPEC;
Eric Dumazet16ebb5e2009-09-02 02:40:09 +00001498 tcm->tcm__pad1 = 0;
1499 tcm->tcm__pad2 = 0;
David S. Miller5ce2d482008-07-08 17:06:30 -07001500 tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 tcm->tcm_parent = q->handle;
1502 tcm->tcm_handle = q->handle;
1503 tcm->tcm_info = 0;
Patrick McHardy57e1c482008-01-23 20:34:28 -08001504 NLA_PUT_STRING(skb, TCA_KIND, q->ops->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001506 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507
Jarek Poplawski102396a2008-08-29 14:21:52 -07001508 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
1509 qdisc_root_sleeping_lock(q), &d) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001510 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511
1512 if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001513 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
1515 if (gnet_stats_finish_copy(&d) < 0)
Patrick McHardy1e904742008-01-22 22:11:17 -08001516 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001518 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 return skb->len;
1520
1521nlmsg_failure:
Patrick McHardy1e904742008-01-22 22:11:17 -08001522nla_put_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -07001523 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 return -1;
1525}
1526
Tom Goff7316ae82010-03-19 15:40:13 +00001527static int tclass_notify(struct net *net, struct sk_buff *oskb,
1528 struct nlmsghdr *n, struct Qdisc *q,
1529 unsigned long cl, int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530{
1531 struct sk_buff *skb;
1532 u32 pid = oskb ? NETLINK_CB(oskb).pid : 0;
1533
1534 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1535 if (!skb)
1536 return -ENOBUFS;
1537
1538 if (tc_fill_tclass(skb, q, cl, pid, n->nlmsg_seq, 0, event) < 0) {
1539 kfree_skb(skb);
1540 return -EINVAL;
1541 }
1542
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001543 return rtnetlink_send(skb, net, pid, RTNLGRP_TC,
1544 n->nlmsg_flags & NLM_F_ECHO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545}
1546
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001547struct qdisc_dump_args {
1548 struct qdisc_walker w;
1549 struct sk_buff *skb;
1550 struct netlink_callback *cb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551};
1552
1553static int qdisc_class_dump(struct Qdisc *q, unsigned long cl, struct qdisc_walker *arg)
1554{
1555 struct qdisc_dump_args *a = (struct qdisc_dump_args *)arg;
1556
1557 return tc_fill_tclass(a->skb, q, cl, NETLINK_CB(a->cb->skb).pid,
1558 a->cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWTCLASS);
1559}
1560
David S. Miller30723672008-07-18 22:50:15 -07001561static int tc_dump_tclass_qdisc(struct Qdisc *q, struct sk_buff *skb,
1562 struct tcmsg *tcm, struct netlink_callback *cb,
1563 int *t_p, int s_t)
1564{
1565 struct qdisc_dump_args arg;
1566
1567 if (tc_qdisc_dump_ignore(q) ||
1568 *t_p < s_t || !q->ops->cl_ops ||
1569 (tcm->tcm_parent &&
1570 TC_H_MAJ(tcm->tcm_parent) != q->handle)) {
1571 (*t_p)++;
1572 return 0;
1573 }
1574 if (*t_p > s_t)
1575 memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
1576 arg.w.fn = qdisc_class_dump;
1577 arg.skb = skb;
1578 arg.cb = cb;
1579 arg.w.stop = 0;
1580 arg.w.skip = cb->args[1];
1581 arg.w.count = 0;
1582 q->ops->cl_ops->walk(q, &arg.w);
1583 cb->args[1] = arg.w.count;
1584 if (arg.w.stop)
1585 return -1;
1586 (*t_p)++;
1587 return 0;
1588}
1589
1590static int tc_dump_tclass_root(struct Qdisc *root, struct sk_buff *skb,
1591 struct tcmsg *tcm, struct netlink_callback *cb,
1592 int *t_p, int s_t)
1593{
1594 struct Qdisc *q;
1595
1596 if (!root)
1597 return 0;
1598
1599 if (tc_dump_tclass_qdisc(root, skb, tcm, cb, t_p, s_t) < 0)
1600 return -1;
1601
1602 list_for_each_entry(q, &root->list, list) {
1603 if (tc_dump_tclass_qdisc(q, skb, tcm, cb, t_p, s_t) < 0)
1604 return -1;
1605 }
1606
1607 return 0;
1608}
1609
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
1611{
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001612 struct tcmsg *tcm = (struct tcmsg *)NLMSG_DATA(cb->nlh);
David S. Miller30723672008-07-18 22:50:15 -07001613 struct net *net = sock_net(skb->sk);
1614 struct netdev_queue *dev_queue;
1615 struct net_device *dev;
1616 int t, s_t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
1618 if (cb->nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*tcm)))
1619 return 0;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001620 dev = dev_get_by_index(net, tcm->tcm_ifindex);
1621 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 return 0;
1623
1624 s_t = cb->args[0];
1625 t = 0;
1626
Patrick McHardyaf356af2009-09-04 06:41:18 +00001627 if (tc_dump_tclass_root(dev->qdisc, skb, tcm, cb, &t, s_t) < 0)
David S. Miller30723672008-07-18 22:50:15 -07001628 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
Eric Dumazet24824a02010-10-02 06:11:55 +00001630 dev_queue = dev_ingress_queue(dev);
1631 if (dev_queue &&
1632 tc_dump_tclass_root(dev_queue->qdisc_sleeping, skb, tcm, cb,
1633 &t, s_t) < 0)
David S. Miller30723672008-07-18 22:50:15 -07001634 goto done;
1635
1636done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 cb->args[0] = t;
1638
1639 dev_put(dev);
1640 return skb->len;
1641}
1642
1643/* Main classifier routine: scans classifier chain attached
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001644 * to this qdisc, (optionally) tests for protocol and asks
1645 * specific classifiers.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 */
Eric Dumazetdc7f9f62011-07-05 23:25:42 +00001647int tc_classify_compat(struct sk_buff *skb, const struct tcf_proto *tp,
Patrick McHardy73ca4912007-07-15 00:02:31 -07001648 struct tcf_result *res)
1649{
1650 __be16 protocol = skb->protocol;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001651 int err;
Patrick McHardy73ca4912007-07-15 00:02:31 -07001652
1653 for (; tp; tp = tp->next) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001654 if (tp->protocol != protocol &&
1655 tp->protocol != htons(ETH_P_ALL))
1656 continue;
1657 err = tp->classify(skb, tp, res);
1658
1659 if (err >= 0) {
Patrick McHardy73ca4912007-07-15 00:02:31 -07001660#ifdef CONFIG_NET_CLS_ACT
1661 if (err != TC_ACT_RECLASSIFY && skb->tc_verd)
1662 skb->tc_verd = SET_TC_VERD(skb->tc_verd, 0);
1663#endif
1664 return err;
1665 }
1666 }
1667 return -1;
1668}
1669EXPORT_SYMBOL(tc_classify_compat);
1670
Eric Dumazetdc7f9f62011-07-05 23:25:42 +00001671int tc_classify(struct sk_buff *skb, const struct tcf_proto *tp,
Patrick McHardy73ca4912007-07-15 00:02:31 -07001672 struct tcf_result *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673{
1674 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675#ifdef CONFIG_NET_CLS_ACT
Eric Dumazetdc7f9f62011-07-05 23:25:42 +00001676 const struct tcf_proto *otp = tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677reclassify:
Hagen Paul Pfeifer52bc9742011-02-25 05:45:21 +00001678#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Patrick McHardy73ca4912007-07-15 00:02:31 -07001680 err = tc_classify_compat(skb, tp, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681#ifdef CONFIG_NET_CLS_ACT
Patrick McHardy73ca4912007-07-15 00:02:31 -07001682 if (err == TC_ACT_RECLASSIFY) {
1683 u32 verd = G_TC_VERD(skb->tc_verd);
1684 tp = otp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685
Patrick McHardy73ca4912007-07-15 00:02:31 -07001686 if (verd++ >= MAX_REC_LOOP) {
stephen hemmingerb60b6592010-05-11 14:24:12 +00001687 if (net_ratelimit())
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001688 pr_notice("%s: packet reclassify loop"
stephen hemmingerb60b6592010-05-11 14:24:12 +00001689 " rule prio %u protocol %02x\n",
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001690 tp->q->ops->id,
1691 tp->prio & 0xffff,
1692 ntohs(tp->protocol));
Patrick McHardy73ca4912007-07-15 00:02:31 -07001693 return TC_ACT_SHOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 }
Patrick McHardy73ca4912007-07-15 00:02:31 -07001695 skb->tc_verd = SET_TC_VERD(skb->tc_verd, verd);
1696 goto reclassify;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 }
Patrick McHardy73ca4912007-07-15 00:02:31 -07001698#endif
1699 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700}
Patrick McHardy73ca4912007-07-15 00:02:31 -07001701EXPORT_SYMBOL(tc_classify);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702
Patrick McHardya48b5a62007-03-23 11:29:43 -07001703void tcf_destroy(struct tcf_proto *tp)
1704{
1705 tp->ops->destroy(tp);
1706 module_put(tp->ops->owner);
1707 kfree(tp);
1708}
1709
Patrick McHardyff31ab52008-07-01 19:52:38 -07001710void tcf_destroy_chain(struct tcf_proto **fl)
Patrick McHardya48b5a62007-03-23 11:29:43 -07001711{
1712 struct tcf_proto *tp;
1713
Patrick McHardyff31ab52008-07-01 19:52:38 -07001714 while ((tp = *fl) != NULL) {
1715 *fl = tp->next;
Patrick McHardya48b5a62007-03-23 11:29:43 -07001716 tcf_destroy(tp);
1717 }
1718}
1719EXPORT_SYMBOL(tcf_destroy_chain);
1720
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721#ifdef CONFIG_PROC_FS
1722static int psched_show(struct seq_file *seq, void *v)
1723{
Patrick McHardy3c0cfc12007-10-10 16:32:41 -07001724 struct timespec ts;
1725
1726 hrtimer_get_res(CLOCK_MONOTONIC, &ts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 seq_printf(seq, "%08x %08x %08x %08x\n",
Jarek Poplawskica44d6e2009-06-15 02:31:47 -07001728 (u32)NSEC_PER_USEC, (u32)PSCHED_TICKS2NS(1),
Patrick McHardy514bca32007-03-16 12:34:52 -07001729 1000000,
Patrick McHardy3c0cfc12007-10-10 16:32:41 -07001730 (u32)NSEC_PER_SEC/(u32)ktime_to_ns(timespec_to_ktime(ts)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
1732 return 0;
1733}
1734
1735static int psched_open(struct inode *inode, struct file *file)
1736{
Tom Goff7e5ab152010-03-30 19:44:56 -07001737 return single_open(file, psched_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738}
1739
Arjan van de Venda7071d2007-02-12 00:55:36 -08001740static const struct file_operations psched_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 .owner = THIS_MODULE,
1742 .open = psched_open,
1743 .read = seq_read,
1744 .llseek = seq_lseek,
1745 .release = single_release,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001746};
Tom Goff7316ae82010-03-19 15:40:13 +00001747
1748static int __net_init psched_net_init(struct net *net)
1749{
1750 struct proc_dir_entry *e;
1751
1752 e = proc_net_fops_create(net, "psched", 0, &psched_fops);
1753 if (e == NULL)
1754 return -ENOMEM;
1755
1756 return 0;
1757}
1758
1759static void __net_exit psched_net_exit(struct net *net)
1760{
1761 proc_net_remove(net, "psched");
Tom Goff7316ae82010-03-19 15:40:13 +00001762}
1763#else
1764static int __net_init psched_net_init(struct net *net)
1765{
1766 return 0;
1767}
1768
1769static void __net_exit psched_net_exit(struct net *net)
1770{
1771}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772#endif
1773
Tom Goff7316ae82010-03-19 15:40:13 +00001774static struct pernet_operations psched_net_ops = {
1775 .init = psched_net_init,
1776 .exit = psched_net_exit,
1777};
1778
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779static int __init pktsched_init(void)
1780{
Tom Goff7316ae82010-03-19 15:40:13 +00001781 int err;
1782
1783 err = register_pernet_subsys(&psched_net_ops);
1784 if (err) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001785 pr_err("pktsched_init: "
Tom Goff7316ae82010-03-19 15:40:13 +00001786 "cannot initialize per netns operations\n");
1787 return err;
1788 }
1789
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 register_qdisc(&pfifo_qdisc_ops);
1791 register_qdisc(&bfifo_qdisc_ops);
Hagen Paul Pfeifer57dbb2d2010-01-24 12:30:59 +00001792 register_qdisc(&pfifo_head_drop_qdisc_ops);
David S. Miller6ec1c692009-09-06 01:58:51 -07001793 register_qdisc(&mq_qdisc_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Greg Rosec7ac8672011-06-10 01:27:09 +00001795 rtnl_register(PF_UNSPEC, RTM_NEWQDISC, tc_modify_qdisc, NULL, NULL);
1796 rtnl_register(PF_UNSPEC, RTM_DELQDISC, tc_get_qdisc, NULL, NULL);
1797 rtnl_register(PF_UNSPEC, RTM_GETQDISC, tc_get_qdisc, tc_dump_qdisc, NULL);
1798 rtnl_register(PF_UNSPEC, RTM_NEWTCLASS, tc_ctl_tclass, NULL, NULL);
1799 rtnl_register(PF_UNSPEC, RTM_DELTCLASS, tc_ctl_tclass, NULL, NULL);
1800 rtnl_register(PF_UNSPEC, RTM_GETTCLASS, tc_ctl_tclass, tc_dump_tclass, NULL);
Thomas Grafbe577dd2007-03-22 11:55:50 -07001801
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 return 0;
1803}
1804
1805subsys_initcall(pktsched_init);