blob: d512f49ee83c29143c5aea7315c9d4f2304c71bf [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>
Jiri Kosina59cc1f62016-08-10 11:05:15 +020032#include <linux/hashtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020034#include <net/net_namespace.h>
Denis V. Lunevb8542722007-12-01 00:21:31 +110035#include <net/sock.h>
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -070036#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <net/pkt_sched.h>
Cong Wang07d79fc2017-08-30 14:30:36 -070038#include <net/pkt_cls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Linus Torvalds1da177e2005-04-16 15:20:36 -070040/*
41
42 Short review.
43 -------------
44
45 This file consists of two interrelated parts:
46
47 1. queueing disciplines manager frontend.
48 2. traffic classes manager frontend.
49
50 Generally, queueing discipline ("qdisc") is a black box,
51 which is able to enqueue packets and to dequeue them (when
52 device is ready to send something) in order and at times
53 determined by algorithm hidden in it.
54
55 qdisc's are divided to two categories:
56 - "queues", which have no internal structure visible from outside.
57 - "schedulers", which split all the packets to "traffic classes",
58 using "packet classifiers" (look at cls_api.c)
59
60 In turn, classes may have child qdiscs (as rule, queues)
61 attached to them etc. etc. etc.
62
63 The goal of the routines in this file is to translate
64 information supplied by user in the form of handles
65 to more intelligible for kernel form, to make some sanity
66 checks and part of work, which is common to all qdiscs
67 and to provide rtnetlink notifications.
68
69 All real intelligent work is done inside qdisc modules.
70
71
72
73 Every discipline has two major routines: enqueue and dequeue.
74
75 ---dequeue
76
77 dequeue usually returns a skb to send. It is allowed to return NULL,
78 but it does not mean that queue is empty, it just means that
79 discipline does not want to send anything this time.
80 Queue is really empty if q->q.qlen == 0.
81 For complicated disciplines with multiple queues q->q is not
82 real packet queue, but however q->q.qlen must be valid.
83
84 ---enqueue
85
86 enqueue returns 0, if packet was enqueued successfully.
87 If packet (this one or another one) was dropped, it returns
88 not zero error code.
89 NET_XMIT_DROP - this packet dropped
90 Expected action: do not backoff, but wait until queue will clear.
91 NET_XMIT_CN - probably this packet enqueued, but another one dropped.
92 Expected action: backoff or ignore
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94 Auxiliary routines:
95
Jarek Poplawski99c0db22008-10-31 00:45:27 -070096 ---peek
97
98 like dequeue but without removing a packet from the queue
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 ---reset
101
102 returns qdisc to initial state: purge all buffers, clear all
103 timers, counters (except for statistics) etc.
104
105 ---init
106
107 initializes newly created qdisc.
108
109 ---destroy
110
111 destroys resources allocated by init and during lifetime of qdisc.
112
113 ---change
114
115 changes qdisc parameters.
116 */
117
118/* Protects list of registered TC modules. It is pure SMP lock. */
119static DEFINE_RWLOCK(qdisc_mod_lock);
120
121
122/************************************************
123 * Queueing disciplines manipulation. *
124 ************************************************/
125
126
127/* The list of all installed queueing disciplines. */
128
129static struct Qdisc_ops *qdisc_base;
130
Zhi Yong Wu21eb2182014-01-01 04:34:51 +0800131/* Register/unregister queueing discipline */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
133int register_qdisc(struct Qdisc_ops *qops)
134{
135 struct Qdisc_ops *q, **qp;
136 int rc = -EEXIST;
137
138 write_lock(&qdisc_mod_lock);
139 for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
140 if (!strcmp(qops->id, q->id))
141 goto out;
142
143 if (qops->enqueue == NULL)
144 qops->enqueue = noop_qdisc_ops.enqueue;
Jarek Poplawski99c0db22008-10-31 00:45:27 -0700145 if (qops->peek == NULL) {
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000146 if (qops->dequeue == NULL)
Jarek Poplawski99c0db22008-10-31 00:45:27 -0700147 qops->peek = noop_qdisc_ops.peek;
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000148 else
149 goto out_einval;
Jarek Poplawski99c0db22008-10-31 00:45:27 -0700150 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 if (qops->dequeue == NULL)
152 qops->dequeue = noop_qdisc_ops.dequeue;
153
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000154 if (qops->cl_ops) {
155 const struct Qdisc_class_ops *cops = qops->cl_ops;
156
WANG Cong143976c2017-08-24 16:51:29 -0700157 if (!(cops->find && cops->walk && cops->leaf))
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000158 goto out_einval;
159
Jiri Pirko6529eab2017-05-17 11:07:55 +0200160 if (cops->tcf_block && !(cops->bind_tcf && cops->unbind_tcf))
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000161 goto out_einval;
162 }
163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 qops->next = NULL;
165 *qp = qops;
166 rc = 0;
167out:
168 write_unlock(&qdisc_mod_lock);
169 return rc;
Jarek Poplawski68fd26b2010-08-09 12:18:48 +0000170
171out_einval:
172 rc = -EINVAL;
173 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174}
Patrick McHardy62e3ba12008-01-22 22:10:23 -0800175EXPORT_SYMBOL(register_qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177int unregister_qdisc(struct Qdisc_ops *qops)
178{
179 struct Qdisc_ops *q, **qp;
180 int err = -ENOENT;
181
182 write_lock(&qdisc_mod_lock);
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000183 for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 if (q == qops)
185 break;
186 if (q) {
187 *qp = q->next;
188 q->next = NULL;
189 err = 0;
190 }
191 write_unlock(&qdisc_mod_lock);
192 return err;
193}
Patrick McHardy62e3ba12008-01-22 22:10:23 -0800194EXPORT_SYMBOL(unregister_qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
stephen hemminger6da7c8f2013-08-27 16:19:08 -0700196/* Get default qdisc if not otherwise specified */
197void qdisc_get_default(char *name, size_t len)
198{
199 read_lock(&qdisc_mod_lock);
200 strlcpy(name, default_qdisc_ops->id, len);
201 read_unlock(&qdisc_mod_lock);
202}
203
204static struct Qdisc_ops *qdisc_lookup_default(const char *name)
205{
206 struct Qdisc_ops *q = NULL;
207
208 for (q = qdisc_base; q; q = q->next) {
209 if (!strcmp(name, q->id)) {
210 if (!try_module_get(q->owner))
211 q = NULL;
212 break;
213 }
214 }
215
216 return q;
217}
218
219/* Set new default qdisc to use */
220int qdisc_set_default(const char *name)
221{
222 const struct Qdisc_ops *ops;
223
224 if (!capable(CAP_NET_ADMIN))
225 return -EPERM;
226
227 write_lock(&qdisc_mod_lock);
228 ops = qdisc_lookup_default(name);
229 if (!ops) {
230 /* Not found, drop lock and try to load module */
231 write_unlock(&qdisc_mod_lock);
232 request_module("sch_%s", name);
233 write_lock(&qdisc_mod_lock);
234
235 ops = qdisc_lookup_default(name);
236 }
237
238 if (ops) {
239 /* Set new default */
240 module_put(default_qdisc_ops->owner);
241 default_qdisc_ops = ops;
242 }
243 write_unlock(&qdisc_mod_lock);
244
245 return ops ? 0 : -ENOENT;
246}
247
stephen hemminger8ea3e432017-04-13 08:40:53 -0700248#ifdef CONFIG_NET_SCH_DEFAULT
249/* Set default value from kernel config */
250static int __init sch_default_qdisc(void)
251{
252 return qdisc_set_default(CONFIG_DEFAULT_NET_SCH);
253}
254late_initcall(sch_default_qdisc);
255#endif
256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257/* We know handle. Find qdisc among all qdisc's attached to device
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800258 * (root qdisc, all its children, children of children etc.)
259 * Note: caller either uses rtnl or rcu_read_lock()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 */
261
Hannes Eder6113b742008-11-28 03:06:46 -0800262static struct Qdisc *qdisc_match_from_root(struct Qdisc *root, u32 handle)
David S. Miller8123b422008-08-08 23:23:39 -0700263{
264 struct Qdisc *q;
265
Jiri Kosina69012ae2016-08-16 23:52:58 +0200266 if (!qdisc_dev(root))
267 return (root->handle == handle ? root : NULL);
268
David S. Miller8123b422008-08-08 23:23:39 -0700269 if (!(root->flags & TCQ_F_BUILTIN) &&
270 root->handle == handle)
271 return root;
272
Jiri Kosina59cc1f62016-08-10 11:05:15 +0200273 hash_for_each_possible_rcu(qdisc_dev(root)->qdisc_hash, q, hash, handle) {
David S. Miller8123b422008-08-08 23:23:39 -0700274 if (q->handle == handle)
275 return q;
276 }
277 return NULL;
278}
279
Jiri Kosina49b49972017-03-08 16:03:32 +0100280void qdisc_hash_add(struct Qdisc *q, bool invisible)
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700281{
Eric Dumazet37314362014-03-08 08:01:19 -0800282 if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS)) {
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800283 ASSERT_RTNL();
Jiri Kosina59cc1f62016-08-10 11:05:15 +0200284 hash_add_rcu(qdisc_dev(q)->qdisc_hash, &q->hash, q->handle);
Jiri Kosina49b49972017-03-08 16:03:32 +0100285 if (invisible)
286 q->flags |= TCQ_F_INVISIBLE;
Eric Dumazet37314362014-03-08 08:01:19 -0800287 }
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700288}
Jiri Kosina59cc1f62016-08-10 11:05:15 +0200289EXPORT_SYMBOL(qdisc_hash_add);
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700290
Jiri Kosina59cc1f62016-08-10 11:05:15 +0200291void qdisc_hash_del(struct Qdisc *q)
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700292{
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800293 if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS)) {
294 ASSERT_RTNL();
Jiri Kosina59cc1f62016-08-10 11:05:15 +0200295 hash_del_rcu(&q->hash);
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800296 }
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700297}
Jiri Kosina59cc1f62016-08-10 11:05:15 +0200298EXPORT_SYMBOL(qdisc_hash_del);
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700299
David S. Milleread81cc2008-07-17 00:50:32 -0700300struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle)
Patrick McHardy43effa12006-11-29 17:35:48 -0800301{
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700302 struct Qdisc *q;
303
Cong Wang50317fc2017-10-27 22:08:56 -0700304 if (!handle)
305 return NULL;
Patrick McHardyaf356af2009-09-04 06:41:18 +0000306 q = qdisc_match_from_root(dev->qdisc, handle);
307 if (q)
308 goto out;
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700309
Eric Dumazet24824a02010-10-02 06:11:55 +0000310 if (dev_ingress_queue(dev))
311 q = qdisc_match_from_root(
312 dev_ingress_queue(dev)->qdisc_sleeping,
313 handle);
Jarek Poplawskif6486d42008-11-25 13:56:06 -0800314out:
Jarek Poplawskif6e0b232008-08-22 03:24:05 -0700315 return q;
Patrick McHardy43effa12006-11-29 17:35:48 -0800316}
317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318static struct Qdisc *qdisc_leaf(struct Qdisc *p, u32 classid)
319{
320 unsigned long cl;
321 struct Qdisc *leaf;
Eric Dumazet20fea082007-11-14 01:44:41 -0800322 const struct Qdisc_class_ops *cops = p->ops->cl_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
324 if (cops == NULL)
325 return NULL;
WANG Cong143976c2017-08-24 16:51:29 -0700326 cl = cops->find(p, classid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 if (cl == 0)
329 return NULL;
330 leaf = cops->leaf(p, cl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 return leaf;
332}
333
334/* Find queueing discipline by name */
335
Patrick McHardy1e904742008-01-22 22:11:17 -0800336static struct Qdisc_ops *qdisc_lookup_ops(struct nlattr *kind)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
338 struct Qdisc_ops *q = NULL;
339
340 if (kind) {
341 read_lock(&qdisc_mod_lock);
342 for (q = qdisc_base; q; q = q->next) {
Patrick McHardy1e904742008-01-22 22:11:17 -0800343 if (nla_strcmp(kind, q->id) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 if (!try_module_get(q->owner))
345 q = NULL;
346 break;
347 }
348 }
349 read_unlock(&qdisc_mod_lock);
350 }
351 return q;
352}
353
Jesper Dangaard Brouer8a8e3d82013-08-14 23:47:11 +0200354/* The linklayer setting were not transferred from iproute2, in older
355 * versions, and the rate tables lookup systems have been dropped in
356 * the kernel. To keep backward compatible with older iproute2 tc
357 * utils, we detect the linklayer setting by detecting if the rate
358 * table were modified.
359 *
360 * For linklayer ATM table entries, the rate table will be aligned to
361 * 48 bytes, thus some table entries will contain the same value. The
362 * mpu (min packet unit) is also encoded into the old rate table, thus
363 * starting from the mpu, we find low and high table entries for
364 * mapping this cell. If these entries contain the same value, when
365 * the rate tables have been modified for linklayer ATM.
366 *
367 * This is done by rounding mpu to the nearest 48 bytes cell/entry,
368 * and then roundup to the next cell, calc the table entry one below,
369 * and compare.
370 */
371static __u8 __detect_linklayer(struct tc_ratespec *r, __u32 *rtab)
372{
373 int low = roundup(r->mpu, 48);
374 int high = roundup(low+1, 48);
375 int cell_low = low >> r->cell_log;
376 int cell_high = (high >> r->cell_log) - 1;
377
378 /* rtab is too inaccurate at rates > 100Mbit/s */
379 if ((r->rate > (100000000/8)) || (rtab[0] == 0)) {
380 pr_debug("TC linklayer: Giving up ATM detection\n");
381 return TC_LINKLAYER_ETHERNET;
382 }
383
384 if ((cell_high > cell_low) && (cell_high < 256)
385 && (rtab[cell_low] == rtab[cell_high])) {
386 pr_debug("TC linklayer: Detected ATM, low(%d)=high(%d)=%u\n",
387 cell_low, cell_high, rtab[cell_high]);
388 return TC_LINKLAYER_ATM;
389 }
390 return TC_LINKLAYER_ETHERNET;
391}
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393static struct qdisc_rate_table *qdisc_rtab_list;
394
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -0400395struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r,
Alexander Aringe9bc3fa2017-12-20 12:35:18 -0500396 struct nlattr *tab,
397 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398{
399 struct qdisc_rate_table *rtab;
400
Eric Dumazet40edeff2013-06-02 11:15:55 +0000401 if (tab == NULL || r->rate == 0 || r->cell_log == 0 ||
Alexander Aringe9bc3fa2017-12-20 12:35:18 -0500402 nla_len(tab) != TC_RTAB_SIZE) {
403 NL_SET_ERR_MSG(extack, "Invalid rate table parameters for searching");
Eric Dumazet40edeff2013-06-02 11:15:55 +0000404 return NULL;
Alexander Aringe9bc3fa2017-12-20 12:35:18 -0500405 }
Eric Dumazet40edeff2013-06-02 11:15:55 +0000406
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 for (rtab = qdisc_rtab_list; rtab; rtab = rtab->next) {
Eric Dumazet40edeff2013-06-02 11:15:55 +0000408 if (!memcmp(&rtab->rate, r, sizeof(struct tc_ratespec)) &&
409 !memcmp(&rtab->data, nla_data(tab), 1024)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 rtab->refcnt++;
411 return rtab;
412 }
413 }
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 rtab = kmalloc(sizeof(*rtab), GFP_KERNEL);
416 if (rtab) {
417 rtab->rate = *r;
418 rtab->refcnt = 1;
Patrick McHardy1e904742008-01-22 22:11:17 -0800419 memcpy(rtab->data, nla_data(tab), 1024);
Jesper Dangaard Brouer8a8e3d82013-08-14 23:47:11 +0200420 if (r->linklayer == TC_LINKLAYER_UNAWARE)
421 r->linklayer = __detect_linklayer(r, rtab->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 rtab->next = qdisc_rtab_list;
423 qdisc_rtab_list = rtab;
Alexander Aringe9bc3fa2017-12-20 12:35:18 -0500424 } else {
425 NL_SET_ERR_MSG(extack, "Failed to allocate new qdisc rate table");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 }
427 return rtab;
428}
Patrick McHardy62e3ba12008-01-22 22:10:23 -0800429EXPORT_SYMBOL(qdisc_get_rtab);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431void qdisc_put_rtab(struct qdisc_rate_table *tab)
432{
433 struct qdisc_rate_table *rtab, **rtabp;
434
435 if (!tab || --tab->refcnt)
436 return;
437
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000438 for (rtabp = &qdisc_rtab_list;
439 (rtab = *rtabp) != NULL;
440 rtabp = &rtab->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (rtab == tab) {
442 *rtabp = rtab->next;
443 kfree(rtab);
444 return;
445 }
446 }
447}
Patrick McHardy62e3ba12008-01-22 22:10:23 -0800448EXPORT_SYMBOL(qdisc_put_rtab);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700450static LIST_HEAD(qdisc_stab_list);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700451
452static const struct nla_policy stab_policy[TCA_STAB_MAX + 1] = {
453 [TCA_STAB_BASE] = { .len = sizeof(struct tc_sizespec) },
454 [TCA_STAB_DATA] = { .type = NLA_BINARY },
455};
456
Alexander Aring09215592017-12-20 12:35:12 -0500457static struct qdisc_size_table *qdisc_get_stab(struct nlattr *opt,
458 struct netlink_ext_ack *extack)
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700459{
460 struct nlattr *tb[TCA_STAB_MAX + 1];
461 struct qdisc_size_table *stab;
462 struct tc_sizespec *s;
463 unsigned int tsize = 0;
464 u16 *tab = NULL;
465 int err;
466
Alexander Aring09215592017-12-20 12:35:12 -0500467 err = nla_parse_nested(tb, TCA_STAB_MAX, opt, stab_policy, extack);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700468 if (err < 0)
469 return ERR_PTR(err);
Alexander Aring09215592017-12-20 12:35:12 -0500470 if (!tb[TCA_STAB_BASE]) {
471 NL_SET_ERR_MSG(extack, "Size table base attribute is missing");
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700472 return ERR_PTR(-EINVAL);
Alexander Aring09215592017-12-20 12:35:12 -0500473 }
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700474
475 s = nla_data(tb[TCA_STAB_BASE]);
476
477 if (s->tsize > 0) {
Alexander Aring09215592017-12-20 12:35:12 -0500478 if (!tb[TCA_STAB_DATA]) {
479 NL_SET_ERR_MSG(extack, "Size table data attribute is missing");
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700480 return ERR_PTR(-EINVAL);
Alexander Aring09215592017-12-20 12:35:12 -0500481 }
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700482 tab = nla_data(tb[TCA_STAB_DATA]);
483 tsize = nla_len(tb[TCA_STAB_DATA]) / sizeof(u16);
484 }
485
Alexander Aring09215592017-12-20 12:35:12 -0500486 if (tsize != s->tsize || (!tab && tsize > 0)) {
487 NL_SET_ERR_MSG(extack, "Invalid size of size table");
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700488 return ERR_PTR(-EINVAL);
Alexander Aring09215592017-12-20 12:35:12 -0500489 }
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700490
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700491 list_for_each_entry(stab, &qdisc_stab_list, list) {
492 if (memcmp(&stab->szopts, s, sizeof(*s)))
493 continue;
494 if (tsize > 0 && memcmp(stab->data, tab, tsize * sizeof(u16)))
495 continue;
496 stab->refcnt++;
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700497 return stab;
498 }
499
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700500 stab = kmalloc(sizeof(*stab) + tsize * sizeof(u16), GFP_KERNEL);
501 if (!stab)
502 return ERR_PTR(-ENOMEM);
503
504 stab->refcnt = 1;
505 stab->szopts = *s;
506 if (tsize > 0)
507 memcpy(stab->data, tab, tsize * sizeof(u16));
508
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700509 list_add_tail(&stab->list, &qdisc_stab_list);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700510
511 return stab;
512}
513
Eric Dumazeta2da5702011-01-20 03:48:19 +0000514static void stab_kfree_rcu(struct rcu_head *head)
515{
516 kfree(container_of(head, struct qdisc_size_table, rcu));
517}
518
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700519void qdisc_put_stab(struct qdisc_size_table *tab)
520{
521 if (!tab)
522 return;
523
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700524 if (--tab->refcnt == 0) {
525 list_del(&tab->list);
Eric Dumazeta2da5702011-01-20 03:48:19 +0000526 call_rcu_bh(&tab->rcu, stab_kfree_rcu);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700527 }
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700528}
529EXPORT_SYMBOL(qdisc_put_stab);
530
531static int qdisc_dump_stab(struct sk_buff *skb, struct qdisc_size_table *stab)
532{
533 struct nlattr *nest;
534
535 nest = nla_nest_start(skb, TCA_STAB);
Patrick McHardy3aa46142008-11-20 04:07:14 -0800536 if (nest == NULL)
537 goto nla_put_failure;
David S. Miller1b34ec42012-03-29 05:11:39 -0400538 if (nla_put(skb, TCA_STAB_BASE, sizeof(stab->szopts), &stab->szopts))
539 goto nla_put_failure;
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700540 nla_nest_end(skb, nest);
541
542 return skb->len;
543
544nla_put_failure:
545 return -1;
546}
547
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -0400548void __qdisc_calculate_pkt_len(struct sk_buff *skb,
549 const struct qdisc_size_table *stab)
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700550{
551 int pkt_len, slot;
552
553 pkt_len = skb->len + stab->szopts.overhead;
554 if (unlikely(!stab->szopts.tsize))
555 goto out;
556
557 slot = pkt_len + stab->szopts.cell_align;
558 if (unlikely(slot < 0))
559 slot = 0;
560
561 slot >>= stab->szopts.cell_log;
562 if (likely(slot < stab->szopts.tsize))
563 pkt_len = stab->data[slot];
564 else
565 pkt_len = stab->data[stab->szopts.tsize - 1] *
566 (slot / stab->szopts.tsize) +
567 stab->data[slot % stab->szopts.tsize];
568
569 pkt_len <<= stab->szopts.size_log;
570out:
571 if (unlikely(pkt_len < 1))
572 pkt_len = 1;
573 qdisc_skb_cb(skb)->pkt_len = pkt_len;
574}
Eric Dumazeta2da5702011-01-20 03:48:19 +0000575EXPORT_SYMBOL(__qdisc_calculate_pkt_len);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -0700576
Florian Westphal6e765a02014-06-11 20:35:18 +0200577void qdisc_warn_nonwc(const char *txt, struct Qdisc *qdisc)
Jarek Poplawskib00355d2009-02-01 01:12:42 -0800578{
579 if (!(qdisc->flags & TCQ_F_WARN_NONWC)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000580 pr_warn("%s: %s qdisc %X: is non-work-conserving?\n",
581 txt, qdisc->ops->id, qdisc->handle >> 16);
Jarek Poplawskib00355d2009-02-01 01:12:42 -0800582 qdisc->flags |= TCQ_F_WARN_NONWC;
583 }
584}
585EXPORT_SYMBOL(qdisc_warn_nonwc);
586
Patrick McHardy41794772007-03-16 01:19:15 -0700587static enum hrtimer_restart qdisc_watchdog(struct hrtimer *timer)
588{
589 struct qdisc_watchdog *wd = container_of(timer, struct qdisc_watchdog,
David S. Miller2fbd3da2009-09-01 17:59:25 -0700590 timer);
Patrick McHardy41794772007-03-16 01:19:15 -0700591
John Fastabend1e203c12014-10-02 22:43:09 -0700592 rcu_read_lock();
David S. Miller8608db02008-08-18 20:51:18 -0700593 __netif_schedule(qdisc_root(wd->qdisc));
John Fastabend1e203c12014-10-02 22:43:09 -0700594 rcu_read_unlock();
Stephen Hemminger19365022007-03-22 12:18:35 -0700595
Patrick McHardy41794772007-03-16 01:19:15 -0700596 return HRTIMER_NORESTART;
597}
598
599void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc)
600{
Eric Dumazet4a8e3202014-09-20 18:01:30 -0700601 hrtimer_init(&wd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
David S. Miller2fbd3da2009-09-01 17:59:25 -0700602 wd->timer.function = qdisc_watchdog;
Patrick McHardy41794772007-03-16 01:19:15 -0700603 wd->qdisc = qdisc;
604}
605EXPORT_SYMBOL(qdisc_watchdog_init);
606
Eric Dumazet45f50be2016-06-10 16:41:39 -0700607void qdisc_watchdog_schedule_ns(struct qdisc_watchdog *wd, u64 expires)
Patrick McHardy41794772007-03-16 01:19:15 -0700608{
Jarek Poplawski2540e052008-08-21 05:11:14 -0700609 if (test_bit(__QDISC_STATE_DEACTIVATED,
610 &qdisc_root_sleeping(wd->qdisc)->state))
611 return;
612
Eric Dumazeta9efad82016-05-23 14:24:56 -0700613 if (wd->last_expires == expires)
614 return;
615
616 wd->last_expires = expires;
Eric Dumazet46baac32012-10-20 00:40:51 +0000617 hrtimer_start(&wd->timer,
Jiri Pirko34c5d292013-02-12 00:12:04 +0000618 ns_to_ktime(expires),
Eric Dumazet4a8e3202014-09-20 18:01:30 -0700619 HRTIMER_MODE_ABS_PINNED);
Patrick McHardy41794772007-03-16 01:19:15 -0700620}
Jiri Pirko34c5d292013-02-12 00:12:04 +0000621EXPORT_SYMBOL(qdisc_watchdog_schedule_ns);
Patrick McHardy41794772007-03-16 01:19:15 -0700622
623void qdisc_watchdog_cancel(struct qdisc_watchdog *wd)
624{
David S. Miller2fbd3da2009-09-01 17:59:25 -0700625 hrtimer_cancel(&wd->timer);
Patrick McHardy41794772007-03-16 01:19:15 -0700626}
627EXPORT_SYMBOL(qdisc_watchdog_cancel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
Adrian Bunka94f7792008-07-22 14:20:11 -0700629static struct hlist_head *qdisc_class_hash_alloc(unsigned int n)
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700630{
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700631 struct hlist_head *h;
Eric Dumazet9695fe62017-08-22 12:26:46 -0700632 unsigned int i;
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700633
Eric Dumazet9695fe62017-08-22 12:26:46 -0700634 h = kvmalloc_array(n, sizeof(struct hlist_head), GFP_KERNEL);
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700635
636 if (h != NULL) {
637 for (i = 0; i < n; i++)
638 INIT_HLIST_HEAD(&h[i]);
639 }
640 return h;
641}
642
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700643void qdisc_class_hash_grow(struct Qdisc *sch, struct Qdisc_class_hash *clhash)
644{
645 struct Qdisc_class_common *cl;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800646 struct hlist_node *next;
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700647 struct hlist_head *nhash, *ohash;
648 unsigned int nsize, nmask, osize;
649 unsigned int i, h;
650
651 /* Rehash when load factor exceeds 0.75 */
652 if (clhash->hashelems * 4 <= clhash->hashsize * 3)
653 return;
654 nsize = clhash->hashsize * 2;
655 nmask = nsize - 1;
656 nhash = qdisc_class_hash_alloc(nsize);
657 if (nhash == NULL)
658 return;
659
660 ohash = clhash->hash;
661 osize = clhash->hashsize;
662
663 sch_tree_lock(sch);
664 for (i = 0; i < osize; i++) {
Sasha Levinb67bfe02013-02-27 17:06:00 -0800665 hlist_for_each_entry_safe(cl, next, &ohash[i], hnode) {
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700666 h = qdisc_class_hash(cl->classid, nmask);
667 hlist_add_head(&cl->hnode, &nhash[h]);
668 }
669 }
670 clhash->hash = nhash;
671 clhash->hashsize = nsize;
672 clhash->hashmask = nmask;
673 sch_tree_unlock(sch);
674
Eric Dumazet9695fe62017-08-22 12:26:46 -0700675 kvfree(ohash);
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700676}
677EXPORT_SYMBOL(qdisc_class_hash_grow);
678
679int qdisc_class_hash_init(struct Qdisc_class_hash *clhash)
680{
681 unsigned int size = 4;
682
683 clhash->hash = qdisc_class_hash_alloc(size);
Alexander Aringac8ef4a2017-12-20 12:35:11 -0500684 if (!clhash->hash)
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700685 return -ENOMEM;
686 clhash->hashsize = size;
687 clhash->hashmask = size - 1;
688 clhash->hashelems = 0;
689 return 0;
690}
691EXPORT_SYMBOL(qdisc_class_hash_init);
692
693void qdisc_class_hash_destroy(struct Qdisc_class_hash *clhash)
694{
Eric Dumazet9695fe62017-08-22 12:26:46 -0700695 kvfree(clhash->hash);
Patrick McHardy6fe1c7a2008-07-05 23:21:31 -0700696}
697EXPORT_SYMBOL(qdisc_class_hash_destroy);
698
699void qdisc_class_hash_insert(struct Qdisc_class_hash *clhash,
700 struct Qdisc_class_common *cl)
701{
702 unsigned int h;
703
704 INIT_HLIST_NODE(&cl->hnode);
705 h = qdisc_class_hash(cl->classid, clhash->hashmask);
706 hlist_add_head(&cl->hnode, &clhash->hash[h]);
707 clhash->hashelems++;
708}
709EXPORT_SYMBOL(qdisc_class_hash_insert);
710
711void qdisc_class_hash_remove(struct Qdisc_class_hash *clhash,
712 struct Qdisc_class_common *cl)
713{
714 hlist_del(&cl->hnode);
715 clhash->hashelems--;
716}
717EXPORT_SYMBOL(qdisc_class_hash_remove);
718
Eric Dumazetfa0f5aa2012-01-03 00:00:11 +0000719/* Allocate an unique handle from space managed by kernel
720 * Possible range is [8000-FFFF]:0000 (0x8000 values)
721 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722static u32 qdisc_alloc_handle(struct net_device *dev)
723{
Eric Dumazetfa0f5aa2012-01-03 00:00:11 +0000724 int i = 0x8000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 static u32 autohandle = TC_H_MAKE(0x80000000U, 0);
726
727 do {
728 autohandle += TC_H_MAKE(0x10000U, 0);
729 if (autohandle == TC_H_MAKE(TC_H_ROOT, 0))
730 autohandle = TC_H_MAKE(0x80000000U, 0);
Eric Dumazetfa0f5aa2012-01-03 00:00:11 +0000731 if (!qdisc_lookup(dev, autohandle))
732 return autohandle;
733 cond_resched();
734 } while (--i > 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Eric Dumazetfa0f5aa2012-01-03 00:00:11 +0000736 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737}
738
WANG Cong2ccccf52016-02-25 14:55:01 -0800739void qdisc_tree_reduce_backlog(struct Qdisc *sch, unsigned int n,
740 unsigned int len)
Patrick McHardy43effa12006-11-29 17:35:48 -0800741{
Eric Dumazet20fea082007-11-14 01:44:41 -0800742 const struct Qdisc_class_ops *cops;
Patrick McHardy43effa12006-11-29 17:35:48 -0800743 unsigned long cl;
744 u32 parentid;
Konstantin Khlebnikov95946652017-08-15 16:39:59 +0300745 bool notify;
Eric Dumazet2c8c8e62013-10-07 08:32:32 -0700746 int drops;
Patrick McHardy43effa12006-11-29 17:35:48 -0800747
WANG Cong2ccccf52016-02-25 14:55:01 -0800748 if (n == 0 && len == 0)
Patrick McHardy43effa12006-11-29 17:35:48 -0800749 return;
Eric Dumazet2c8c8e62013-10-07 08:32:32 -0700750 drops = max_t(int, n, 0);
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800751 rcu_read_lock();
Patrick McHardy43effa12006-11-29 17:35:48 -0800752 while ((parentid = sch->parent)) {
Jarek Poplawski066a3b52008-04-14 15:10:42 -0700753 if (TC_H_MAJ(parentid) == TC_H_MAJ(TC_H_INGRESS))
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800754 break;
Jarek Poplawski066a3b52008-04-14 15:10:42 -0700755
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800756 if (sch->flags & TCQ_F_NOPARENT)
757 break;
Konstantin Khlebnikov95946652017-08-15 16:39:59 +0300758 /* Notify parent qdisc only if child qdisc becomes empty.
759 *
760 * If child was empty even before update then backlog
761 * counter is screwed and we skip notification because
762 * parent class is already passive.
763 */
764 notify = !sch->q.qlen && !WARN_ON_ONCE(!n);
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800765 /* TODO: perform the search on a per txq basis */
David S. Miller5ce2d482008-07-08 17:06:30 -0700766 sch = qdisc_lookup(qdisc_dev(sch), TC_H_MAJ(parentid));
Patrick McHardyffc8fef2007-07-30 17:11:50 -0700767 if (sch == NULL) {
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800768 WARN_ON_ONCE(parentid != TC_H_ROOT);
769 break;
Patrick McHardyffc8fef2007-07-30 17:11:50 -0700770 }
Patrick McHardy43effa12006-11-29 17:35:48 -0800771 cops = sch->ops->cl_ops;
Konstantin Khlebnikov95946652017-08-15 16:39:59 +0300772 if (notify && cops->qlen_notify) {
WANG Cong143976c2017-08-24 16:51:29 -0700773 cl = cops->find(sch, parentid);
Patrick McHardy43effa12006-11-29 17:35:48 -0800774 cops->qlen_notify(sch, cl);
Patrick McHardy43effa12006-11-29 17:35:48 -0800775 }
776 sch->q.qlen -= n;
WANG Cong2ccccf52016-02-25 14:55:01 -0800777 sch->qstats.backlog -= len;
John Fastabend25331d62014-09-28 11:53:29 -0700778 __qdisc_qstats_drop(sch, drops);
Patrick McHardy43effa12006-11-29 17:35:48 -0800779 }
Eric Dumazet4eaf3b82015-12-01 20:08:51 -0800780 rcu_read_unlock();
Patrick McHardy43effa12006-11-29 17:35:48 -0800781}
WANG Cong2ccccf52016-02-25 14:55:01 -0800782EXPORT_SYMBOL(qdisc_tree_reduce_backlog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
WANG Cong27d7f072017-08-24 16:51:27 -0700784static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,
785 u32 portid, u32 seq, u16 flags, int event)
786{
787 struct gnet_stats_basic_cpu __percpu *cpu_bstats = NULL;
788 struct gnet_stats_queue __percpu *cpu_qstats = NULL;
789 struct tcmsg *tcm;
790 struct nlmsghdr *nlh;
791 unsigned char *b = skb_tail_pointer(skb);
792 struct gnet_dump d;
793 struct qdisc_size_table *stab;
Jiri Pirkod47a6b02018-01-17 11:46:52 +0100794 u32 block_index;
WANG Cong27d7f072017-08-24 16:51:27 -0700795 __u32 qlen;
796
797 cond_resched();
798 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
799 if (!nlh)
800 goto out_nlmsg_trim;
801 tcm = nlmsg_data(nlh);
802 tcm->tcm_family = AF_UNSPEC;
803 tcm->tcm__pad1 = 0;
804 tcm->tcm__pad2 = 0;
805 tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
806 tcm->tcm_parent = clid;
807 tcm->tcm_handle = q->handle;
808 tcm->tcm_info = refcount_read(&q->refcnt);
809 if (nla_put_string(skb, TCA_KIND, q->ops->id))
810 goto nla_put_failure;
Jiri Pirkod47a6b02018-01-17 11:46:52 +0100811 if (q->ops->ingress_block_get) {
812 block_index = q->ops->ingress_block_get(q);
813 if (block_index &&
814 nla_put_u32(skb, TCA_INGRESS_BLOCK, block_index))
815 goto nla_put_failure;
816 }
817 if (q->ops->egress_block_get) {
818 block_index = q->ops->egress_block_get(q);
819 if (block_index &&
820 nla_put_u32(skb, TCA_EGRESS_BLOCK, block_index))
821 goto nla_put_failure;
822 }
WANG Cong27d7f072017-08-24 16:51:27 -0700823 if (q->ops->dump && q->ops->dump(q, skb) < 0)
824 goto nla_put_failure;
Nogah Frankel44edf2f2017-12-25 10:51:42 +0200825 if (nla_put_u8(skb, TCA_HW_OFFLOAD, !!(q->flags & TCQ_F_OFFLOADED)))
826 goto nla_put_failure;
John Fastabend7e660162017-12-07 09:57:00 -0800827 qlen = qdisc_qlen_sum(q);
WANG Cong27d7f072017-08-24 16:51:27 -0700828
829 stab = rtnl_dereference(q->stab);
830 if (stab && qdisc_dump_stab(skb, stab) < 0)
831 goto nla_put_failure;
832
833 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
834 NULL, &d, TCA_PAD) < 0)
835 goto nla_put_failure;
836
837 if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)
838 goto nla_put_failure;
839
840 if (qdisc_is_percpu_stats(q)) {
841 cpu_bstats = q->cpu_bstats;
842 cpu_qstats = q->cpu_qstats;
843 }
844
845 if (gnet_stats_copy_basic(qdisc_root_sleeping_running(q),
846 &d, cpu_bstats, &q->bstats) < 0 ||
847 gnet_stats_copy_rate_est(&d, &q->rate_est) < 0 ||
848 gnet_stats_copy_queue(&d, cpu_qstats, &q->qstats, qlen) < 0)
849 goto nla_put_failure;
850
851 if (gnet_stats_finish_copy(&d) < 0)
852 goto nla_put_failure;
853
854 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
855 return skb->len;
856
857out_nlmsg_trim:
858nla_put_failure:
859 nlmsg_trim(skb, b);
860 return -1;
861}
862
863static bool tc_qdisc_dump_ignore(struct Qdisc *q, bool dump_invisible)
864{
865 if (q->flags & TCQ_F_BUILTIN)
866 return true;
867 if ((q->flags & TCQ_F_INVISIBLE) && !dump_invisible)
868 return true;
869
870 return false;
871}
872
873static int qdisc_notify(struct net *net, struct sk_buff *oskb,
874 struct nlmsghdr *n, u32 clid,
875 struct Qdisc *old, struct Qdisc *new)
876{
877 struct sk_buff *skb;
878 u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
879
880 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
881 if (!skb)
882 return -ENOBUFS;
883
884 if (old && !tc_qdisc_dump_ignore(old, false)) {
885 if (tc_fill_qdisc(skb, old, clid, portid, n->nlmsg_seq,
886 0, RTM_DELQDISC) < 0)
887 goto err_out;
888 }
889 if (new && !tc_qdisc_dump_ignore(new, false)) {
890 if (tc_fill_qdisc(skb, new, clid, portid, n->nlmsg_seq,
891 old ? NLM_F_REPLACE : 0, RTM_NEWQDISC) < 0)
892 goto err_out;
893 }
894
895 if (skb->len)
896 return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
897 n->nlmsg_flags & NLM_F_ECHO);
898
899err_out:
900 kfree_skb(skb);
901 return -EINVAL;
902}
903
Tom Goff7316ae82010-03-19 15:40:13 +0000904static void notify_and_destroy(struct net *net, struct sk_buff *skb,
905 struct nlmsghdr *n, u32 clid,
David S. Miller99194cf2008-07-17 04:54:10 -0700906 struct Qdisc *old, struct Qdisc *new)
907{
908 if (new || old)
Tom Goff7316ae82010-03-19 15:40:13 +0000909 qdisc_notify(net, skb, n, clid, old, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
David S. Miller4d8863a2008-08-18 21:03:15 -0700911 if (old)
David S. Miller99194cf2008-07-17 04:54:10 -0700912 qdisc_destroy(old);
David S. Miller99194cf2008-07-17 04:54:10 -0700913}
914
915/* Graft qdisc "new" to class "classid" of qdisc "parent" or
916 * to device "dev".
917 *
918 * When appropriate send a netlink notification using 'skb'
919 * and "n".
920 *
921 * On success, destroy old qdisc.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 */
923
924static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
David S. Miller99194cf2008-07-17 04:54:10 -0700925 struct sk_buff *skb, struct nlmsghdr *n, u32 classid,
Alexander Aring09215592017-12-20 12:35:12 -0500926 struct Qdisc *new, struct Qdisc *old,
927 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928{
David S. Miller99194cf2008-07-17 04:54:10 -0700929 struct Qdisc *q = old;
Tom Goff7316ae82010-03-19 15:40:13 +0000930 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900933 if (parent == NULL) {
David S. Miller99194cf2008-07-17 04:54:10 -0700934 unsigned int i, num_q, ingress;
935
936 ingress = 0;
937 num_q = dev->num_tx_queues;
David S. Miller8d50b532008-07-30 02:37:46 -0700938 if ((q && q->flags & TCQ_F_INGRESS) ||
939 (new && new->flags & TCQ_F_INGRESS)) {
David S. Miller99194cf2008-07-17 04:54:10 -0700940 num_q = 1;
941 ingress = 1;
Alexander Aring09215592017-12-20 12:35:12 -0500942 if (!dev_ingress_queue(dev)) {
943 NL_SET_ERR_MSG(extack, "Device does not have an ingress queue");
Eric Dumazet24824a02010-10-02 06:11:55 +0000944 return -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -0500945 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 }
David S. Miller99194cf2008-07-17 04:54:10 -0700947
948 if (dev->flags & IFF_UP)
949 dev_deactivate(dev);
950
WANG Cong86e363d2015-05-26 16:08:48 -0700951 if (new && new->ops->attach)
952 goto skip;
David S. Miller6ec1c692009-09-06 01:58:51 -0700953
David S. Miller99194cf2008-07-17 04:54:10 -0700954 for (i = 0; i < num_q; i++) {
Eric Dumazet24824a02010-10-02 06:11:55 +0000955 struct netdev_queue *dev_queue = dev_ingress_queue(dev);
David S. Miller99194cf2008-07-17 04:54:10 -0700956
957 if (!ingress)
958 dev_queue = netdev_get_tx_queue(dev, i);
959
David S. Miller8d50b532008-07-30 02:37:46 -0700960 old = dev_graft_qdisc(dev_queue, new);
961 if (new && i > 0)
Eric Dumazet551143d2017-08-24 21:12:28 -0700962 qdisc_refcount_inc(new);
David S. Miller8d50b532008-07-30 02:37:46 -0700963
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000964 if (!ingress)
965 qdisc_destroy(old);
David S. Miller99194cf2008-07-17 04:54:10 -0700966 }
967
WANG Cong86e363d2015-05-26 16:08:48 -0700968skip:
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000969 if (!ingress) {
Tom Goff7316ae82010-03-19 15:40:13 +0000970 notify_and_destroy(net, skb, n, classid,
971 dev->qdisc, new);
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000972 if (new && !new->ops->attach)
Eric Dumazet551143d2017-08-24 21:12:28 -0700973 qdisc_refcount_inc(new);
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000974 dev->qdisc = new ? : &noop_qdisc;
WANG Cong86e363d2015-05-26 16:08:48 -0700975
976 if (new && new->ops->attach)
977 new->ops->attach(new);
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000978 } else {
Tom Goff7316ae82010-03-19 15:40:13 +0000979 notify_and_destroy(net, skb, n, classid, old, new);
Jarek Poplawski036d6a62009-09-13 22:35:44 +0000980 }
Patrick McHardyaf356af2009-09-04 06:41:18 +0000981
David S. Miller99194cf2008-07-17 04:54:10 -0700982 if (dev->flags & IFF_UP)
983 dev_activate(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 } else {
Eric Dumazet20fea082007-11-14 01:44:41 -0800985 const struct Qdisc_class_ops *cops = parent->ops->cl_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
John Fastabendc5ad1192017-12-07 09:58:19 -0800987 /* Only support running class lockless if parent is lockless */
988 if (new && (new->flags & TCQ_F_NOLOCK) &&
989 parent && !(parent->flags & TCQ_F_NOLOCK))
990 new->flags &= ~TCQ_F_NOLOCK;
991
Patrick McHardyc9f1d032009-09-04 06:41:13 +0000992 err = -EOPNOTSUPP;
993 if (cops && cops->graft) {
WANG Cong143976c2017-08-24 16:51:29 -0700994 unsigned long cl = cops->find(parent, classid);
995
Alexander Aring09215592017-12-20 12:35:12 -0500996 if (cl) {
Alexander Aring653d6fd2017-12-20 12:35:17 -0500997 err = cops->graft(parent, cl, new, &old,
998 extack);
Alexander Aring09215592017-12-20 12:35:12 -0500999 } else {
1000 NL_SET_ERR_MSG(extack, "Specified class not found");
Patrick McHardyc9f1d032009-09-04 06:41:13 +00001001 err = -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001002 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 }
David S. Miller99194cf2008-07-17 04:54:10 -07001004 if (!err)
Tom Goff7316ae82010-03-19 15:40:13 +00001005 notify_and_destroy(net, skb, n, classid, old, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 }
1007 return err;
1008}
1009
Jiri Pirkod47a6b02018-01-17 11:46:52 +01001010static int qdisc_block_indexes_set(struct Qdisc *sch, struct nlattr **tca,
1011 struct netlink_ext_ack *extack)
1012{
1013 u32 block_index;
1014
1015 if (tca[TCA_INGRESS_BLOCK]) {
1016 block_index = nla_get_u32(tca[TCA_INGRESS_BLOCK]);
1017
1018 if (!block_index) {
1019 NL_SET_ERR_MSG(extack, "Ingress block index cannot be 0");
1020 return -EINVAL;
1021 }
1022 if (!sch->ops->ingress_block_set) {
1023 NL_SET_ERR_MSG(extack, "Ingress block sharing is not supported");
1024 return -EOPNOTSUPP;
1025 }
1026 sch->ops->ingress_block_set(sch, block_index);
1027 }
1028 if (tca[TCA_EGRESS_BLOCK]) {
1029 block_index = nla_get_u32(tca[TCA_EGRESS_BLOCK]);
1030
1031 if (!block_index) {
1032 NL_SET_ERR_MSG(extack, "Egress block index cannot be 0");
1033 return -EINVAL;
1034 }
1035 if (!sch->ops->egress_block_set) {
1036 NL_SET_ERR_MSG(extack, "Egress block sharing is not supported");
1037 return -EOPNOTSUPP;
1038 }
1039 sch->ops->egress_block_set(sch, block_index);
1040 }
1041 return 0;
1042}
1043
Jarek Poplawski25bfcd52008-08-18 20:53:34 -07001044/* lockdep annotation is needed for ingress; egress gets it only for name */
1045static struct lock_class_key qdisc_tx_lock;
1046static struct lock_class_key qdisc_rx_lock;
1047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048/*
1049 Allocate and initialize new qdisc.
1050
1051 Parameters are passed via opt.
1052 */
1053
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04001054static struct Qdisc *qdisc_create(struct net_device *dev,
1055 struct netdev_queue *dev_queue,
1056 struct Qdisc *p, u32 parent, u32 handle,
Alexander Aring09215592017-12-20 12:35:12 -05001057 struct nlattr **tca, int *errp,
1058 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059{
1060 int err;
Patrick McHardy1e904742008-01-22 22:11:17 -08001061 struct nlattr *kind = tca[TCA_KIND];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 struct Qdisc *sch;
1063 struct Qdisc_ops *ops;
Jussi Kivilinna175f9c12008-07-20 00:08:47 -07001064 struct qdisc_size_table *stab;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
1066 ops = qdisc_lookup_ops(kind);
Johannes Berg95a5afc2008-10-16 15:24:51 -07001067#ifdef CONFIG_MODULES
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 if (ops == NULL && kind != NULL) {
1069 char name[IFNAMSIZ];
Patrick McHardy1e904742008-01-22 22:11:17 -08001070 if (nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 /* We dropped the RTNL semaphore in order to
1072 * perform the module load. So, even if we
1073 * succeeded in loading the module we have to
1074 * tell the caller to replay the request. We
1075 * indicate this using -EAGAIN.
1076 * We replay the request because the device may
1077 * go away in the mean time.
1078 */
1079 rtnl_unlock();
1080 request_module("sch_%s", name);
1081 rtnl_lock();
1082 ops = qdisc_lookup_ops(kind);
1083 if (ops != NULL) {
1084 /* We will try again qdisc_lookup_ops,
1085 * so don't keep a reference.
1086 */
1087 module_put(ops->owner);
1088 err = -EAGAIN;
1089 goto err_out;
1090 }
1091 }
1092 }
1093#endif
1094
Jamal Hadi Salimb9e2cc02006-08-03 16:36:51 -07001095 err = -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001096 if (!ops) {
1097 NL_SET_ERR_MSG(extack, "Specified qdisc not found");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 goto err_out;
Alexander Aring09215592017-12-20 12:35:12 -05001099 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Alexander Aringd0bd6842017-12-20 12:35:20 -05001101 sch = qdisc_alloc(dev_queue, ops, extack);
Thomas Graf3d54b822005-07-05 14:15:09 -07001102 if (IS_ERR(sch)) {
1103 err = PTR_ERR(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 goto err_out2;
Thomas Graf3d54b822005-07-05 14:15:09 -07001105 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Patrick McHardyffc8fef2007-07-30 17:11:50 -07001107 sch->parent = parent;
1108
Thomas Graf3d54b822005-07-05 14:15:09 -07001109 if (handle == TC_H_INGRESS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 sch->flags |= TCQ_F_INGRESS;
Thomas Graf3d54b822005-07-05 14:15:09 -07001111 handle = TC_H_MAKE(TC_H_INGRESS, 0);
Jarek Poplawski25bfcd52008-08-18 20:53:34 -07001112 lockdep_set_class(qdisc_lock(sch), &qdisc_rx_lock);
Patrick McHardyfd44de72007-04-16 17:07:08 -07001113 } else {
Patrick McHardyfd44de72007-04-16 17:07:08 -07001114 if (handle == 0) {
1115 handle = qdisc_alloc_handle(dev);
1116 err = -ENOMEM;
1117 if (handle == 0)
1118 goto err_out3;
1119 }
Jarek Poplawski25bfcd52008-08-18 20:53:34 -07001120 lockdep_set_class(qdisc_lock(sch), &qdisc_tx_lock);
Eric Dumazet1abbe132012-12-11 15:54:33 +00001121 if (!netif_is_multiqueue(dev))
Eric Dumazet225734d2015-12-15 09:43:12 -08001122 sch->flags |= TCQ_F_ONETXQUEUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 }
1124
Thomas Graf3d54b822005-07-05 14:15:09 -07001125 sch->handle = handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Jesper Dangaard Brouer84c46dd2016-11-03 14:56:11 +01001127 /* This exist to keep backward compatible with a userspace
1128 * loophole, what allowed userspace to get IFF_NO_QUEUE
1129 * facility on older kernels by setting tx_queue_len=0 (prior
1130 * to qdisc init), and then forgot to reinit tx_queue_len
1131 * before again attaching a qdisc.
1132 */
1133 if ((dev->priv_flags & IFF_NO_QUEUE) && (dev->tx_queue_len == 0)) {
1134 dev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
1135 netdev_info(dev, "Caught tx_queue_len zero misconfig\n");
1136 }
1137
Jiri Pirkod47a6b02018-01-17 11:46:52 +01001138 err = qdisc_block_indexes_set(sch, tca, extack);
1139 if (err)
1140 goto err_out3;
1141
Alexander Aring54160ef2017-12-04 18:40:00 -05001142 if (ops->init) {
Alexander Aringe63d7dfd2017-12-20 12:35:13 -05001143 err = ops->init(sch, tca[TCA_OPTIONS], extack);
Alexander Aring54160ef2017-12-04 18:40:00 -05001144 if (err != 0)
1145 goto err_out5;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 }
Alexander Aring54160ef2017-12-04 18:40:00 -05001147
Alexander Aring54160ef2017-12-04 18:40:00 -05001148 if (tca[TCA_STAB]) {
Alexander Aring09215592017-12-20 12:35:12 -05001149 stab = qdisc_get_stab(tca[TCA_STAB], extack);
Alexander Aring54160ef2017-12-04 18:40:00 -05001150 if (IS_ERR(stab)) {
1151 err = PTR_ERR(stab);
1152 goto err_out4;
1153 }
1154 rcu_assign_pointer(sch->stab, stab);
1155 }
1156 if (tca[TCA_RATE]) {
1157 seqcount_t *running;
1158
1159 err = -EOPNOTSUPP;
Alexander Aring09215592017-12-20 12:35:12 -05001160 if (sch->flags & TCQ_F_MQROOT) {
1161 NL_SET_ERR_MSG(extack, "Cannot attach rate estimator to a multi-queue root qdisc");
Alexander Aring54160ef2017-12-04 18:40:00 -05001162 goto err_out4;
Alexander Aring09215592017-12-20 12:35:12 -05001163 }
Alexander Aring54160ef2017-12-04 18:40:00 -05001164
1165 if (sch->parent != TC_H_ROOT &&
1166 !(sch->flags & TCQ_F_INGRESS) &&
1167 (!p || !(p->flags & TCQ_F_MQROOT)))
1168 running = qdisc_root_sleeping_running(sch);
1169 else
1170 running = &sch->running;
1171
1172 err = gen_new_estimator(&sch->bstats,
1173 sch->cpu_bstats,
1174 &sch->rate_est,
1175 NULL,
1176 running,
1177 tca[TCA_RATE]);
Alexander Aring09215592017-12-20 12:35:12 -05001178 if (err) {
1179 NL_SET_ERR_MSG(extack, "Failed to generate new estimator");
Alexander Aring54160ef2017-12-04 18:40:00 -05001180 goto err_out4;
Alexander Aring09215592017-12-20 12:35:12 -05001181 }
Alexander Aring54160ef2017-12-04 18:40:00 -05001182 }
1183
1184 qdisc_hash_add(sch, false);
1185
1186 return sch;
1187
1188err_out5:
Eric Dumazet87b60cf2017-02-10 10:31:49 -08001189 /* ops->init() failed, we call ->destroy() like qdisc_create_dflt() */
Gao Fengc1a48722017-06-28 12:53:54 +08001190 if (ops->destroy)
1191 ops->destroy(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192err_out3:
1193 dev_put(dev);
Daniel Borkmann81d947e2018-01-15 23:12:09 +01001194 qdisc_free(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195err_out2:
1196 module_put(ops->owner);
1197err_out:
1198 *errp = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 return NULL;
Patrick McHardy23bcf632009-09-09 18:11:23 -07001200
1201err_out4:
1202 /*
1203 * Any broken qdiscs that would require a ops->reset() here?
1204 * The qdisc was never in action so it shouldn't be necessary.
1205 */
Eric Dumazeta2da5702011-01-20 03:48:19 +00001206 qdisc_put_stab(rtnl_dereference(sch->stab));
Patrick McHardy23bcf632009-09-09 18:11:23 -07001207 if (ops->destroy)
1208 ops->destroy(sch);
1209 goto err_out3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210}
1211
Alexander Aring09215592017-12-20 12:35:12 -05001212static int qdisc_change(struct Qdisc *sch, struct nlattr **tca,
1213 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214{
Eric Dumazeta2da5702011-01-20 03:48:19 +00001215 struct qdisc_size_table *ostab, *stab = NULL;
Jussi Kivilinna175f9c12008-07-20 00:08:47 -07001216 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
Jussi Kivilinna175f9c12008-07-20 00:08:47 -07001218 if (tca[TCA_OPTIONS]) {
Alexander Aring09215592017-12-20 12:35:12 -05001219 if (!sch->ops->change) {
1220 NL_SET_ERR_MSG(extack, "Change operation not supported by specified qdisc");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 return -EINVAL;
Alexander Aring09215592017-12-20 12:35:12 -05001222 }
Jiri Pirkod47a6b02018-01-17 11:46:52 +01001223 if (tca[TCA_INGRESS_BLOCK] || tca[TCA_EGRESS_BLOCK]) {
1224 NL_SET_ERR_MSG(extack, "Change of blocks is not supported");
1225 return -EOPNOTSUPP;
1226 }
Alexander Aring20307212017-12-20 12:35:14 -05001227 err = sch->ops->change(sch, tca[TCA_OPTIONS], extack);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 if (err)
1229 return err;
1230 }
Jussi Kivilinna175f9c12008-07-20 00:08:47 -07001231
1232 if (tca[TCA_STAB]) {
Alexander Aring09215592017-12-20 12:35:12 -05001233 stab = qdisc_get_stab(tca[TCA_STAB], extack);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -07001234 if (IS_ERR(stab))
1235 return PTR_ERR(stab);
1236 }
1237
Eric Dumazeta2da5702011-01-20 03:48:19 +00001238 ostab = rtnl_dereference(sch->stab);
1239 rcu_assign_pointer(sch->stab, stab);
1240 qdisc_put_stab(ostab);
Jussi Kivilinna175f9c12008-07-20 00:08:47 -07001241
Patrick McHardy23bcf632009-09-09 18:11:23 -07001242 if (tca[TCA_RATE]) {
Stephen Hemminger71bcb092008-11-25 21:13:31 -08001243 /* NB: ignores errors from replace_estimator
1244 because change can't be undone. */
Patrick McHardy23bcf632009-09-09 18:11:23 -07001245 if (sch->flags & TCQ_F_MQROOT)
1246 goto out;
John Fastabend22e0f8b2014-09-28 11:52:56 -07001247 gen_replace_estimator(&sch->bstats,
1248 sch->cpu_bstats,
1249 &sch->rate_est,
Eric Dumazetedb09eb2016-06-06 09:37:16 -07001250 NULL,
1251 qdisc_root_sleeping_running(sch),
John Fastabend22e0f8b2014-09-28 11:52:56 -07001252 tca[TCA_RATE]);
Patrick McHardy23bcf632009-09-09 18:11:23 -07001253 }
1254out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 return 0;
1256}
1257
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001258struct check_loop_arg {
1259 struct qdisc_walker w;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 struct Qdisc *p;
1261 int depth;
1262};
1263
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04001264static int check_loop_fn(struct Qdisc *q, unsigned long cl,
1265 struct qdisc_walker *w);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
1267static int check_loop(struct Qdisc *q, struct Qdisc *p, int depth)
1268{
1269 struct check_loop_arg arg;
1270
1271 if (q->ops->cl_ops == NULL)
1272 return 0;
1273
1274 arg.w.stop = arg.w.skip = arg.w.count = 0;
1275 arg.w.fn = check_loop_fn;
1276 arg.depth = depth;
1277 arg.p = p;
1278 q->ops->cl_ops->walk(q, &arg.w);
1279 return arg.w.stop ? -ELOOP : 0;
1280}
1281
1282static int
1283check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w)
1284{
1285 struct Qdisc *leaf;
Eric Dumazet20fea082007-11-14 01:44:41 -08001286 const struct Qdisc_class_ops *cops = q->ops->cl_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 struct check_loop_arg *arg = (struct check_loop_arg *)w;
1288
1289 leaf = cops->leaf(q, cl);
1290 if (leaf) {
1291 if (leaf == arg->p || arg->depth > 7)
1292 return -ELOOP;
1293 return check_loop(leaf, arg->p, arg->depth + 1);
1294 }
1295 return 0;
1296}
1297
1298/*
1299 * Delete/get qdisc.
1300 */
1301
David Ahernc21ef3e2017-04-16 09:48:24 -07001302static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n,
1303 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001305 struct net *net = sock_net(skb->sk);
David S. Miller02ef22c2012-06-26 21:50:05 -07001306 struct tcmsg *tcm = nlmsg_data(n);
Patrick McHardy1e904742008-01-22 22:11:17 -08001307 struct nlattr *tca[TCA_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 struct net_device *dev;
Hong zhi guode179c82013-03-25 17:36:33 +00001309 u32 clid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 struct Qdisc *q = NULL;
1311 struct Qdisc *p = NULL;
1312 int err;
1313
Stéphane Graber4e8bbb82014-04-30 11:25:43 -04001314 if ((n->nlmsg_type != RTM_GETQDISC) &&
David S. Miller5f013c9b2014-05-12 13:19:14 -04001315 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
Eric W. Biedermandfc47ef2012-11-16 03:03:00 +00001316 return -EPERM;
1317
David Ahernc21ef3e2017-04-16 09:48:24 -07001318 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL, extack);
Patrick McHardy1e904742008-01-22 22:11:17 -08001319 if (err < 0)
1320 return err;
1321
Hong zhi guode179c82013-03-25 17:36:33 +00001322 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
1323 if (!dev)
1324 return -ENODEV;
1325
1326 clid = tcm->tcm_parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 if (clid) {
1328 if (clid != TC_H_ROOT) {
1329 if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001330 p = qdisc_lookup(dev, TC_H_MAJ(clid));
Alexander Aring09215592017-12-20 12:35:12 -05001331 if (!p) {
1332 NL_SET_ERR_MSG(extack, "Failed to find qdisc with specified classid");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 return -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 q = qdisc_leaf(p, clid);
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001336 } else if (dev_ingress_queue(dev)) {
1337 q = dev_ingress_queue(dev)->qdisc_sleeping;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 } else {
Patrick McHardyaf356af2009-09-04 06:41:18 +00001340 q = dev->qdisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 }
Alexander Aring09215592017-12-20 12:35:12 -05001342 if (!q) {
1343 NL_SET_ERR_MSG(extack, "Cannot find specified qdisc on specified device");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 return -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001345 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Alexander Aring09215592017-12-20 12:35:12 -05001347 if (tcm->tcm_handle && q->handle != tcm->tcm_handle) {
1348 NL_SET_ERR_MSG(extack, "Invalid handle");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 return -EINVAL;
Alexander Aring09215592017-12-20 12:35:12 -05001350 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 } else {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001352 q = qdisc_lookup(dev, tcm->tcm_handle);
Alexander Aring09215592017-12-20 12:35:12 -05001353 if (!q) {
1354 NL_SET_ERR_MSG(extack, "Failed to find qdisc with specified handle");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 return -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001356 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 }
1358
Alexander Aring09215592017-12-20 12:35:12 -05001359 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id)) {
1360 NL_SET_ERR_MSG(extack, "Invalid qdisc name");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 return -EINVAL;
Alexander Aring09215592017-12-20 12:35:12 -05001362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
1364 if (n->nlmsg_type == RTM_DELQDISC) {
Alexander Aring09215592017-12-20 12:35:12 -05001365 if (!clid) {
1366 NL_SET_ERR_MSG(extack, "Classid cannot be zero");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 return -EINVAL;
Alexander Aring09215592017-12-20 12:35:12 -05001368 }
1369 if (q->handle == 0) {
1370 NL_SET_ERR_MSG(extack, "Cannot delete qdisc with handle of zero");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 return -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001372 }
1373 err = qdisc_graft(dev, p, skb, n, clid, NULL, q, extack);
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001374 if (err != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 } else {
Tom Goff7316ae82010-03-19 15:40:13 +00001377 qdisc_notify(net, skb, n, clid, NULL, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 }
1379 return 0;
1380}
1381
1382/*
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001383 * Create/change qdisc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 */
1385
David Ahernc21ef3e2017-04-16 09:48:24 -07001386static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n,
1387 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001389 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 struct tcmsg *tcm;
Patrick McHardy1e904742008-01-22 22:11:17 -08001391 struct nlattr *tca[TCA_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 struct net_device *dev;
1393 u32 clid;
1394 struct Qdisc *q, *p;
1395 int err;
1396
David S. Miller5f013c9b2014-05-12 13:19:14 -04001397 if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
Eric W. Biedermandfc47ef2012-11-16 03:03:00 +00001398 return -EPERM;
1399
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400replay:
1401 /* Reinit, just in case something touches this. */
David Ahernc21ef3e2017-04-16 09:48:24 -07001402 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL, extack);
Hong zhi guode179c82013-03-25 17:36:33 +00001403 if (err < 0)
1404 return err;
1405
David S. Miller02ef22c2012-06-26 21:50:05 -07001406 tcm = nlmsg_data(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 clid = tcm->tcm_parent;
1408 q = p = NULL;
1409
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001410 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
1411 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 return -ENODEV;
1413
Patrick McHardy1e904742008-01-22 22:11:17 -08001414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 if (clid) {
1416 if (clid != TC_H_ROOT) {
1417 if (clid != TC_H_INGRESS) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001418 p = qdisc_lookup(dev, TC_H_MAJ(clid));
Alexander Aring09215592017-12-20 12:35:12 -05001419 if (!p) {
1420 NL_SET_ERR_MSG(extack, "Failed to find specified qdisc");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 return -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001422 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 q = qdisc_leaf(p, clid);
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001424 } else if (dev_ingress_queue_create(dev)) {
1425 q = dev_ingress_queue(dev)->qdisc_sleeping;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 }
1427 } else {
Patrick McHardyaf356af2009-09-04 06:41:18 +00001428 q = dev->qdisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 }
1430
1431 /* It may be default qdisc, ignore it */
1432 if (q && q->handle == 0)
1433 q = NULL;
1434
1435 if (!q || !tcm->tcm_handle || q->handle != tcm->tcm_handle) {
1436 if (tcm->tcm_handle) {
Alexander Aring09215592017-12-20 12:35:12 -05001437 if (q && !(n->nlmsg_flags & NLM_F_REPLACE)) {
1438 NL_SET_ERR_MSG(extack, "NLM_F_REPLACE needed to override");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 return -EEXIST;
Alexander Aring09215592017-12-20 12:35:12 -05001440 }
1441 if (TC_H_MIN(tcm->tcm_handle)) {
1442 NL_SET_ERR_MSG(extack, "Invalid minor handle");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 return -EINVAL;
Alexander Aring09215592017-12-20 12:35:12 -05001444 }
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001445 q = qdisc_lookup(dev, tcm->tcm_handle);
Jiri Pirko8ec69572017-12-28 16:52:10 +01001446 if (!q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 goto create_n_graft;
Alexander Aring09215592017-12-20 12:35:12 -05001448 if (n->nlmsg_flags & NLM_F_EXCL) {
1449 NL_SET_ERR_MSG(extack, "Exclusivity flag on, cannot override");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 return -EEXIST;
Alexander Aring09215592017-12-20 12:35:12 -05001451 }
Alexander Aring0ac4bd62017-12-04 18:39:59 -05001452 if (tca[TCA_KIND] &&
Alexander Aring09215592017-12-20 12:35:12 -05001453 nla_strcmp(tca[TCA_KIND], q->ops->id)) {
1454 NL_SET_ERR_MSG(extack, "Invalid qdisc name");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 return -EINVAL;
Alexander Aring09215592017-12-20 12:35:12 -05001456 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 if (q == p ||
Alexander Aring09215592017-12-20 12:35:12 -05001458 (p && check_loop(q, p, 0))) {
1459 NL_SET_ERR_MSG(extack, "Qdisc parent/child loop detected");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 return -ELOOP;
Alexander Aring09215592017-12-20 12:35:12 -05001461 }
Eric Dumazet551143d2017-08-24 21:12:28 -07001462 qdisc_refcount_inc(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 goto graft;
1464 } else {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001465 if (!q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 goto create_n_graft;
1467
1468 /* This magic test requires explanation.
1469 *
1470 * We know, that some child q is already
1471 * attached to this parent and have choice:
1472 * either to change it or to create/graft new one.
1473 *
1474 * 1. We are allowed to create/graft only
1475 * if CREATE and REPLACE flags are set.
1476 *
1477 * 2. If EXCL is set, requestor wanted to say,
1478 * that qdisc tcm_handle is not expected
1479 * to exist, so that we choose create/graft too.
1480 *
1481 * 3. The last case is when no flags are set.
1482 * Alas, it is sort of hole in API, we
1483 * cannot decide what to do unambiguously.
1484 * For now we select create/graft, if
1485 * user gave KIND, which does not match existing.
1486 */
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001487 if ((n->nlmsg_flags & NLM_F_CREATE) &&
1488 (n->nlmsg_flags & NLM_F_REPLACE) &&
1489 ((n->nlmsg_flags & NLM_F_EXCL) ||
Patrick McHardy1e904742008-01-22 22:11:17 -08001490 (tca[TCA_KIND] &&
1491 nla_strcmp(tca[TCA_KIND], q->ops->id))))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 goto create_n_graft;
1493 }
1494 }
1495 } else {
Alexander Aring09215592017-12-20 12:35:12 -05001496 if (!tcm->tcm_handle) {
1497 NL_SET_ERR_MSG(extack, "Handle cannot be zero");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 return -EINVAL;
Alexander Aring09215592017-12-20 12:35:12 -05001499 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 q = qdisc_lookup(dev, tcm->tcm_handle);
1501 }
1502
1503 /* Change qdisc parameters */
Alexander Aring09215592017-12-20 12:35:12 -05001504 if (!q) {
1505 NL_SET_ERR_MSG(extack, "Specified qdisc not found");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 return -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001507 }
1508 if (n->nlmsg_flags & NLM_F_EXCL) {
1509 NL_SET_ERR_MSG(extack, "Exclusivity flag on, cannot modify");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 return -EEXIST;
Alexander Aring09215592017-12-20 12:35:12 -05001511 }
1512 if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id)) {
1513 NL_SET_ERR_MSG(extack, "Invalid qdisc name");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 return -EINVAL;
Alexander Aring09215592017-12-20 12:35:12 -05001515 }
1516 err = qdisc_change(q, tca, extack);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 if (err == 0)
Tom Goff7316ae82010-03-19 15:40:13 +00001518 qdisc_notify(net, skb, n, clid, NULL, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 return err;
1520
1521create_n_graft:
Alexander Aring09215592017-12-20 12:35:12 -05001522 if (!(n->nlmsg_flags & NLM_F_CREATE)) {
1523 NL_SET_ERR_MSG(extack, "Qdisc not found. To create specify NLM_F_CREATE flag");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 return -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001525 }
Eric Dumazet24824a02010-10-02 06:11:55 +00001526 if (clid == TC_H_INGRESS) {
Alexander Aring09215592017-12-20 12:35:12 -05001527 if (dev_ingress_queue(dev)) {
Eric Dumazet24824a02010-10-02 06:11:55 +00001528 q = qdisc_create(dev, dev_ingress_queue(dev), p,
1529 tcm->tcm_parent, tcm->tcm_parent,
Alexander Aring09215592017-12-20 12:35:12 -05001530 tca, &err, extack);
1531 } else {
1532 NL_SET_ERR_MSG(extack, "Cannot find ingress queue for specified device");
Eric Dumazet24824a02010-10-02 06:11:55 +00001533 err = -ENOENT;
Alexander Aring09215592017-12-20 12:35:12 -05001534 }
Eric Dumazet24824a02010-10-02 06:11:55 +00001535 } else {
Jarek Poplawski926e61b2009-09-15 02:53:07 -07001536 struct netdev_queue *dev_queue;
David S. Miller6ec1c692009-09-06 01:58:51 -07001537
1538 if (p && p->ops->cl_ops && p->ops->cl_ops->select_queue)
Jarek Poplawski926e61b2009-09-15 02:53:07 -07001539 dev_queue = p->ops->cl_ops->select_queue(p, tcm);
1540 else if (p)
1541 dev_queue = p->dev_queue;
1542 else
1543 dev_queue = netdev_get_tx_queue(dev, 0);
David S. Miller6ec1c692009-09-06 01:58:51 -07001544
Jarek Poplawski926e61b2009-09-15 02:53:07 -07001545 q = qdisc_create(dev, dev_queue, p,
David S. Millerbb949fb2008-07-08 16:55:56 -07001546 tcm->tcm_parent, tcm->tcm_handle,
Alexander Aring09215592017-12-20 12:35:12 -05001547 tca, &err, extack);
David S. Miller6ec1c692009-09-06 01:58:51 -07001548 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 if (q == NULL) {
1550 if (err == -EAGAIN)
1551 goto replay;
1552 return err;
1553 }
1554
1555graft:
Alexander Aring09215592017-12-20 12:35:12 -05001556 err = qdisc_graft(dev, p, skb, n, clid, q, NULL, extack);
Ilpo Järvinene5befbd2008-08-18 22:30:01 -07001557 if (err) {
1558 if (q)
1559 qdisc_destroy(q);
1560 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 }
Ilpo Järvinene5befbd2008-08-18 22:30:01 -07001562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 return 0;
1564}
1565
David S. Miller30723672008-07-18 22:50:15 -07001566static int tc_dump_qdisc_root(struct Qdisc *root, struct sk_buff *skb,
1567 struct netlink_callback *cb,
Jiri Kosina49b49972017-03-08 16:03:32 +01001568 int *q_idx_p, int s_q_idx, bool recur,
1569 bool dump_invisible)
David S. Miller30723672008-07-18 22:50:15 -07001570{
1571 int ret = 0, q_idx = *q_idx_p;
1572 struct Qdisc *q;
Jiri Kosina59cc1f62016-08-10 11:05:15 +02001573 int b;
David S. Miller30723672008-07-18 22:50:15 -07001574
1575 if (!root)
1576 return 0;
1577
1578 q = root;
1579 if (q_idx < s_q_idx) {
1580 q_idx++;
1581 } else {
Jiri Kosina49b49972017-03-08 16:03:32 +01001582 if (!tc_qdisc_dump_ignore(q, dump_invisible) &&
Eric W. Biederman15e47302012-09-07 20:12:54 +00001583 tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).portid,
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04001584 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1585 RTM_NEWQDISC) <= 0)
David S. Miller30723672008-07-18 22:50:15 -07001586 goto done;
1587 q_idx++;
1588 }
Jiri Kosina69012ae2016-08-16 23:52:58 +02001589
Jiri Kosinaea327462016-08-16 23:53:46 +02001590 /* If dumping singletons, there is no qdisc_dev(root) and the singleton
1591 * itself has already been dumped.
1592 *
1593 * If we've already dumped the top-level (ingress) qdisc above and the global
1594 * qdisc hashtable, we don't want to hit it again
1595 */
1596 if (!qdisc_dev(root) || !recur)
Jiri Kosina69012ae2016-08-16 23:52:58 +02001597 goto out;
1598
Jiri Kosina59cc1f62016-08-10 11:05:15 +02001599 hash_for_each(qdisc_dev(root)->qdisc_hash, b, q, hash) {
David S. Miller30723672008-07-18 22:50:15 -07001600 if (q_idx < s_q_idx) {
1601 q_idx++;
1602 continue;
1603 }
Jiri Kosina49b49972017-03-08 16:03:32 +01001604 if (!tc_qdisc_dump_ignore(q, dump_invisible) &&
Eric W. Biederman15e47302012-09-07 20:12:54 +00001605 tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).portid,
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04001606 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1607 RTM_NEWQDISC) <= 0)
David S. Miller30723672008-07-18 22:50:15 -07001608 goto done;
1609 q_idx++;
1610 }
1611
1612out:
1613 *q_idx_p = q_idx;
1614 return ret;
1615done:
1616 ret = -1;
1617 goto out;
1618}
1619
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
1621{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001622 struct net *net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 int idx, q_idx;
1624 int s_idx, s_q_idx;
1625 struct net_device *dev;
Jiri Kosina49b49972017-03-08 16:03:32 +01001626 const struct nlmsghdr *nlh = cb->nlh;
Jiri Kosina49b49972017-03-08 16:03:32 +01001627 struct nlattr *tca[TCA_MAX + 1];
1628 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
1630 s_idx = cb->args[0];
1631 s_q_idx = q_idx = cb->args[1];
stephen hemmingerf1e90162009-11-10 07:54:49 +00001632
Pavel Emelianov7562f872007-05-03 15:13:45 -07001633 idx = 0;
Eric Dumazet15dc36e2014-03-10 17:11:42 -07001634 ASSERT_RTNL();
Jiri Kosina49b49972017-03-08 16:03:32 +01001635
Colin Ian King7e5dd532017-09-18 12:40:38 +01001636 err = nlmsg_parse(nlh, sizeof(struct tcmsg), tca, TCA_MAX, NULL, NULL);
Jiri Kosina49b49972017-03-08 16:03:32 +01001637 if (err < 0)
1638 return err;
1639
Eric Dumazet15dc36e2014-03-10 17:11:42 -07001640 for_each_netdev(net, dev) {
David S. Miller30723672008-07-18 22:50:15 -07001641 struct netdev_queue *dev_queue;
1642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 if (idx < s_idx)
Pavel Emelianov7562f872007-05-03 15:13:45 -07001644 goto cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 if (idx > s_idx)
1646 s_q_idx = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 q_idx = 0;
David S. Miller30723672008-07-18 22:50:15 -07001648
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04001649 if (tc_dump_qdisc_root(dev->qdisc, skb, cb, &q_idx, s_q_idx,
Jiri Kosina49b49972017-03-08 16:03:32 +01001650 true, tca[TCA_DUMP_INVISIBLE]) < 0)
David S. Miller30723672008-07-18 22:50:15 -07001651 goto done;
1652
Eric Dumazet24824a02010-10-02 06:11:55 +00001653 dev_queue = dev_ingress_queue(dev);
1654 if (dev_queue &&
1655 tc_dump_qdisc_root(dev_queue->qdisc_sleeping, skb, cb,
Jiri Kosina49b49972017-03-08 16:03:32 +01001656 &q_idx, s_q_idx, false,
1657 tca[TCA_DUMP_INVISIBLE]) < 0)
David S. Miller30723672008-07-18 22:50:15 -07001658 goto done;
1659
Pavel Emelianov7562f872007-05-03 15:13:45 -07001660cont:
1661 idx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 }
1663
1664done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 cb->args[0] = idx;
1666 cb->args[1] = q_idx;
1667
1668 return skb->len;
1669}
1670
1671
1672
1673/************************************************
1674 * Traffic classes manipulation. *
1675 ************************************************/
1676
WANG Cong27d7f072017-08-24 16:51:27 -07001677static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,
1678 unsigned long cl,
1679 u32 portid, u32 seq, u16 flags, int event)
1680{
1681 struct tcmsg *tcm;
1682 struct nlmsghdr *nlh;
1683 unsigned char *b = skb_tail_pointer(skb);
1684 struct gnet_dump d;
1685 const struct Qdisc_class_ops *cl_ops = q->ops->cl_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
WANG Cong27d7f072017-08-24 16:51:27 -07001687 cond_resched();
1688 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
1689 if (!nlh)
1690 goto out_nlmsg_trim;
1691 tcm = nlmsg_data(nlh);
1692 tcm->tcm_family = AF_UNSPEC;
1693 tcm->tcm__pad1 = 0;
1694 tcm->tcm__pad2 = 0;
1695 tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
1696 tcm->tcm_parent = q->handle;
1697 tcm->tcm_handle = q->handle;
1698 tcm->tcm_info = 0;
1699 if (nla_put_string(skb, TCA_KIND, q->ops->id))
1700 goto nla_put_failure;
1701 if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)
1702 goto nla_put_failure;
1703
1704 if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
1705 NULL, &d, TCA_PAD) < 0)
1706 goto nla_put_failure;
1707
1708 if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)
1709 goto nla_put_failure;
1710
1711 if (gnet_stats_finish_copy(&d) < 0)
1712 goto nla_put_failure;
1713
1714 nlh->nlmsg_len = skb_tail_pointer(skb) - b;
1715 return skb->len;
1716
1717out_nlmsg_trim:
1718nla_put_failure:
1719 nlmsg_trim(skb, b);
1720 return -1;
1721}
1722
1723static int tclass_notify(struct net *net, struct sk_buff *oskb,
1724 struct nlmsghdr *n, struct Qdisc *q,
1725 unsigned long cl, int event)
1726{
1727 struct sk_buff *skb;
1728 u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
1729
1730 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1731 if (!skb)
1732 return -ENOBUFS;
1733
1734 if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0, event) < 0) {
1735 kfree_skb(skb);
1736 return -EINVAL;
1737 }
1738
1739 return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
1740 n->nlmsg_flags & NLM_F_ECHO);
1741}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742
WANG Cong14546ba2017-08-24 16:51:28 -07001743static int tclass_del_notify(struct net *net,
1744 const struct Qdisc_class_ops *cops,
1745 struct sk_buff *oskb, struct nlmsghdr *n,
1746 struct Qdisc *q, unsigned long cl)
1747{
1748 u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
1749 struct sk_buff *skb;
1750 int err = 0;
1751
1752 if (!cops->delete)
1753 return -EOPNOTSUPP;
1754
1755 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1756 if (!skb)
1757 return -ENOBUFS;
1758
1759 if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0,
1760 RTM_DELTCLASS) < 0) {
1761 kfree_skb(skb);
1762 return -EINVAL;
1763 }
1764
1765 err = cops->delete(q, cl);
1766 if (err) {
1767 kfree_skb(skb);
1768 return err;
1769 }
1770
1771 return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
1772 n->nlmsg_flags & NLM_F_ECHO);
1773}
1774
Cong Wang07d79fc2017-08-30 14:30:36 -07001775#ifdef CONFIG_NET_CLS
1776
1777struct tcf_bind_args {
1778 struct tcf_walker w;
1779 u32 classid;
1780 unsigned long cl;
1781};
1782
1783static int tcf_node_bind(struct tcf_proto *tp, void *n, struct tcf_walker *arg)
1784{
1785 struct tcf_bind_args *a = (void *)arg;
1786
1787 if (tp->ops->bind_class) {
Jiri Pirko74e3be62017-10-13 14:01:04 +02001788 struct Qdisc *q = tcf_block_q(tp->chain->block);
1789
1790 sch_tree_lock(q);
Cong Wang07d79fc2017-08-30 14:30:36 -07001791 tp->ops->bind_class(n, a->classid, a->cl);
Jiri Pirko74e3be62017-10-13 14:01:04 +02001792 sch_tree_unlock(q);
Cong Wang07d79fc2017-08-30 14:30:36 -07001793 }
1794 return 0;
1795}
1796
1797static void tc_bind_tclass(struct Qdisc *q, u32 portid, u32 clid,
1798 unsigned long new_cl)
1799{
1800 const struct Qdisc_class_ops *cops = q->ops->cl_ops;
1801 struct tcf_block *block;
1802 struct tcf_chain *chain;
1803 unsigned long cl;
1804
1805 cl = cops->find(q, portid);
1806 if (!cl)
1807 return;
Alexander Aringcbaacc42017-12-20 12:35:16 -05001808 block = cops->tcf_block(q, cl, NULL);
Cong Wang07d79fc2017-08-30 14:30:36 -07001809 if (!block)
1810 return;
1811 list_for_each_entry(chain, &block->chain_list, list) {
1812 struct tcf_proto *tp;
1813
1814 for (tp = rtnl_dereference(chain->filter_chain);
1815 tp; tp = rtnl_dereference(tp->next)) {
1816 struct tcf_bind_args arg = {};
1817
1818 arg.w.fn = tcf_node_bind;
1819 arg.classid = clid;
1820 arg.cl = new_cl;
1821 tp->ops->walk(tp, &arg.w);
1822 }
1823 }
1824}
1825
1826#else
1827
1828static void tc_bind_tclass(struct Qdisc *q, u32 portid, u32 clid,
1829 unsigned long new_cl)
1830{
1831}
1832
1833#endif
1834
David Ahernc21ef3e2017-04-16 09:48:24 -07001835static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n,
1836 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001838 struct net *net = sock_net(skb->sk);
David S. Miller02ef22c2012-06-26 21:50:05 -07001839 struct tcmsg *tcm = nlmsg_data(n);
Patrick McHardy1e904742008-01-22 22:11:17 -08001840 struct nlattr *tca[TCA_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 struct net_device *dev;
1842 struct Qdisc *q = NULL;
Eric Dumazet20fea082007-11-14 01:44:41 -08001843 const struct Qdisc_class_ops *cops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 unsigned long cl = 0;
1845 unsigned long new_cl;
Hong zhi guode179c82013-03-25 17:36:33 +00001846 u32 portid;
1847 u32 clid;
1848 u32 qid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 int err;
1850
Stéphane Graber4e8bbb82014-04-30 11:25:43 -04001851 if ((n->nlmsg_type != RTM_GETTCLASS) &&
David S. Miller5f013c9b2014-05-12 13:19:14 -04001852 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
Eric W. Biedermandfc47ef2012-11-16 03:03:00 +00001853 return -EPERM;
1854
David Ahernc21ef3e2017-04-16 09:48:24 -07001855 err = nlmsg_parse(n, sizeof(*tcm), tca, TCA_MAX, NULL, extack);
Patrick McHardy1e904742008-01-22 22:11:17 -08001856 if (err < 0)
1857 return err;
1858
Hong zhi guode179c82013-03-25 17:36:33 +00001859 dev = __dev_get_by_index(net, tcm->tcm_ifindex);
1860 if (!dev)
1861 return -ENODEV;
1862
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 /*
1864 parent == TC_H_UNSPEC - unspecified parent.
1865 parent == TC_H_ROOT - class is root, which has no parent.
1866 parent == X:0 - parent is root class.
1867 parent == X:Y - parent is a node in hierarchy.
1868 parent == 0:Y - parent is X:Y, where X:0 is qdisc.
1869
1870 handle == 0:0 - generate handle from kernel pool.
1871 handle == 0:Y - class is X:Y, where X:0 is qdisc.
1872 handle == X:Y - clear.
1873 handle == X:0 - root class.
1874 */
1875
1876 /* Step 1. Determine qdisc handle X:0 */
1877
Hong zhi guode179c82013-03-25 17:36:33 +00001878 portid = tcm->tcm_parent;
1879 clid = tcm->tcm_handle;
1880 qid = TC_H_MAJ(clid);
1881
Eric W. Biederman15e47302012-09-07 20:12:54 +00001882 if (portid != TC_H_ROOT) {
1883 u32 qid1 = TC_H_MAJ(portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884
1885 if (qid && qid1) {
1886 /* If both majors are known, they must be identical. */
1887 if (qid != qid1)
1888 return -EINVAL;
1889 } else if (qid1) {
1890 qid = qid1;
1891 } else if (qid == 0)
Patrick McHardyaf356af2009-09-04 06:41:18 +00001892 qid = dev->qdisc->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
1894 /* Now qid is genuine qdisc handle consistent
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001895 * both with parent and child.
1896 *
Eric W. Biederman15e47302012-09-07 20:12:54 +00001897 * TC_H_MAJ(portid) still may be unspecified, complete it now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 */
Eric W. Biederman15e47302012-09-07 20:12:54 +00001899 if (portid)
1900 portid = TC_H_MAKE(qid, portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 } else {
1902 if (qid == 0)
Patrick McHardyaf356af2009-09-04 06:41:18 +00001903 qid = dev->qdisc->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 }
1905
1906 /* OK. Locate qdisc */
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001907 q = qdisc_lookup(dev, qid);
1908 if (!q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 return -ENOENT;
1910
1911 /* An check that it supports classes */
1912 cops = q->ops->cl_ops;
1913 if (cops == NULL)
1914 return -EINVAL;
1915
1916 /* Now try to get class */
1917 if (clid == 0) {
Eric W. Biederman15e47302012-09-07 20:12:54 +00001918 if (portid == TC_H_ROOT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 clid = qid;
1920 } else
1921 clid = TC_H_MAKE(qid, clid);
1922
1923 if (clid)
WANG Cong143976c2017-08-24 16:51:29 -07001924 cl = cops->find(q, clid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
1926 if (cl == 0) {
1927 err = -ENOENT;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001928 if (n->nlmsg_type != RTM_NEWTCLASS ||
1929 !(n->nlmsg_flags & NLM_F_CREATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 goto out;
1931 } else {
1932 switch (n->nlmsg_type) {
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09001933 case RTM_NEWTCLASS:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 err = -EEXIST;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001935 if (n->nlmsg_flags & NLM_F_EXCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 goto out;
1937 break;
1938 case RTM_DELTCLASS:
WANG Cong14546ba2017-08-24 16:51:28 -07001939 err = tclass_del_notify(net, cops, skb, n, q, cl);
Cong Wang07d79fc2017-08-30 14:30:36 -07001940 /* Unbind the class with flilters with 0 */
1941 tc_bind_tclass(q, portid, clid, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 goto out;
1943 case RTM_GETTCLASS:
Tom Goff7316ae82010-03-19 15:40:13 +00001944 err = tclass_notify(net, skb, n, q, cl, RTM_NEWTCLASS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 goto out;
1946 default:
1947 err = -EINVAL;
1948 goto out;
1949 }
1950 }
1951
Jiri Pirkod47a6b02018-01-17 11:46:52 +01001952 if (tca[TCA_INGRESS_BLOCK] || tca[TCA_EGRESS_BLOCK]) {
1953 NL_SET_ERR_MSG(extack, "Shared blocks are not supported for classes");
1954 return -EOPNOTSUPP;
1955 }
1956
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 new_cl = cl;
Patrick McHardyde6d5cd2009-09-04 06:41:16 +00001958 err = -EOPNOTSUPP;
1959 if (cops->change)
Alexander Aring793d81d2017-12-20 12:35:15 -05001960 err = cops->change(q, clid, portid, tca, &new_cl, extack);
Cong Wang07d79fc2017-08-30 14:30:36 -07001961 if (err == 0) {
Tom Goff7316ae82010-03-19 15:40:13 +00001962 tclass_notify(net, skb, n, q, new_cl, RTM_NEWTCLASS);
Cong Wang07d79fc2017-08-30 14:30:36 -07001963 /* We just create a new class, need to do reverse binding. */
1964 if (cl != new_cl)
1965 tc_bind_tclass(q, portid, clid, new_cl);
1966 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 return err;
1969}
1970
Eric Dumazetcc7ec452011-01-19 19:26:56 +00001971struct qdisc_dump_args {
1972 struct qdisc_walker w;
1973 struct sk_buff *skb;
1974 struct netlink_callback *cb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975};
1976
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04001977static int qdisc_class_dump(struct Qdisc *q, unsigned long cl,
1978 struct qdisc_walker *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979{
1980 struct qdisc_dump_args *a = (struct qdisc_dump_args *)arg;
1981
Eric W. Biederman15e47302012-09-07 20:12:54 +00001982 return tc_fill_tclass(a->skb, q, cl, NETLINK_CB(a->cb->skb).portid,
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04001983 a->cb->nlh->nlmsg_seq, NLM_F_MULTI,
1984 RTM_NEWTCLASS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985}
1986
David S. Miller30723672008-07-18 22:50:15 -07001987static int tc_dump_tclass_qdisc(struct Qdisc *q, struct sk_buff *skb,
1988 struct tcmsg *tcm, struct netlink_callback *cb,
1989 int *t_p, int s_t)
1990{
1991 struct qdisc_dump_args arg;
1992
Jiri Kosina49b49972017-03-08 16:03:32 +01001993 if (tc_qdisc_dump_ignore(q, false) ||
David S. Miller30723672008-07-18 22:50:15 -07001994 *t_p < s_t || !q->ops->cl_ops ||
1995 (tcm->tcm_parent &&
1996 TC_H_MAJ(tcm->tcm_parent) != q->handle)) {
1997 (*t_p)++;
1998 return 0;
1999 }
2000 if (*t_p > s_t)
2001 memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
2002 arg.w.fn = qdisc_class_dump;
2003 arg.skb = skb;
2004 arg.cb = cb;
2005 arg.w.stop = 0;
2006 arg.w.skip = cb->args[1];
2007 arg.w.count = 0;
2008 q->ops->cl_ops->walk(q, &arg.w);
2009 cb->args[1] = arg.w.count;
2010 if (arg.w.stop)
2011 return -1;
2012 (*t_p)++;
2013 return 0;
2014}
2015
2016static int tc_dump_tclass_root(struct Qdisc *root, struct sk_buff *skb,
2017 struct tcmsg *tcm, struct netlink_callback *cb,
2018 int *t_p, int s_t)
2019{
2020 struct Qdisc *q;
Jiri Kosina59cc1f62016-08-10 11:05:15 +02002021 int b;
David S. Miller30723672008-07-18 22:50:15 -07002022
2023 if (!root)
2024 return 0;
2025
2026 if (tc_dump_tclass_qdisc(root, skb, tcm, cb, t_p, s_t) < 0)
2027 return -1;
2028
Jiri Kosina69012ae2016-08-16 23:52:58 +02002029 if (!qdisc_dev(root))
2030 return 0;
2031
Eric Dumazetcb395b22017-05-10 21:59:28 -07002032 if (tcm->tcm_parent) {
2033 q = qdisc_match_from_root(root, TC_H_MAJ(tcm->tcm_parent));
2034 if (q && tc_dump_tclass_qdisc(q, skb, tcm, cb, t_p, s_t) < 0)
2035 return -1;
2036 return 0;
2037 }
Jiri Kosina59cc1f62016-08-10 11:05:15 +02002038 hash_for_each(qdisc_dev(root)->qdisc_hash, b, q, hash) {
David S. Miller30723672008-07-18 22:50:15 -07002039 if (tc_dump_tclass_qdisc(q, skb, tcm, cb, t_p, s_t) < 0)
2040 return -1;
2041 }
2042
2043 return 0;
2044}
2045
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
2047{
David S. Miller02ef22c2012-06-26 21:50:05 -07002048 struct tcmsg *tcm = nlmsg_data(cb->nlh);
David S. Miller30723672008-07-18 22:50:15 -07002049 struct net *net = sock_net(skb->sk);
2050 struct netdev_queue *dev_queue;
2051 struct net_device *dev;
2052 int t, s_t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053
Hong zhi guo573ce262013-03-27 06:47:04 +00002054 if (nlmsg_len(cb->nlh) < sizeof(*tcm))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 return 0;
Eric Dumazetcc7ec452011-01-19 19:26:56 +00002056 dev = dev_get_by_index(net, tcm->tcm_ifindex);
2057 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 return 0;
2059
2060 s_t = cb->args[0];
2061 t = 0;
2062
Patrick McHardyaf356af2009-09-04 06:41:18 +00002063 if (tc_dump_tclass_root(dev->qdisc, skb, tcm, cb, &t, s_t) < 0)
David S. Miller30723672008-07-18 22:50:15 -07002064 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065
Eric Dumazet24824a02010-10-02 06:11:55 +00002066 dev_queue = dev_ingress_queue(dev);
2067 if (dev_queue &&
2068 tc_dump_tclass_root(dev_queue->qdisc_sleeping, skb, tcm, cb,
2069 &t, s_t) < 0)
David S. Miller30723672008-07-18 22:50:15 -07002070 goto done;
2071
2072done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 cb->args[0] = t;
2074
2075 dev_put(dev);
2076 return skb->len;
2077}
2078
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079#ifdef CONFIG_PROC_FS
2080static int psched_show(struct seq_file *seq, void *v)
2081{
2082 seq_printf(seq, "%08x %08x %08x %08x\n",
Jarek Poplawskica44d6e2009-06-15 02:31:47 -07002083 (u32)NSEC_PER_USEC, (u32)PSCHED_TICKS2NS(1),
Patrick McHardy514bca32007-03-16 12:34:52 -07002084 1000000,
Thomas Gleixner1e317682015-04-14 21:08:28 +00002085 (u32)NSEC_PER_SEC / hrtimer_resolution);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086
2087 return 0;
2088}
2089
2090static int psched_open(struct inode *inode, struct file *file)
2091{
Tom Goff7e5ab152010-03-30 19:44:56 -07002092 return single_open(file, psched_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093}
2094
Arjan van de Venda7071d2007-02-12 00:55:36 -08002095static const struct file_operations psched_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 .open = psched_open,
2097 .read = seq_read,
2098 .llseek = seq_lseek,
2099 .release = single_release,
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +09002100};
Tom Goff7316ae82010-03-19 15:40:13 +00002101
2102static int __net_init psched_net_init(struct net *net)
2103{
2104 struct proc_dir_entry *e;
2105
Gao fengd4beaa62013-02-18 01:34:54 +00002106 e = proc_create("psched", 0, net->proc_net, &psched_fops);
Tom Goff7316ae82010-03-19 15:40:13 +00002107 if (e == NULL)
2108 return -ENOMEM;
2109
2110 return 0;
2111}
2112
2113static void __net_exit psched_net_exit(struct net *net)
2114{
Gao fengece31ff2013-02-18 01:34:56 +00002115 remove_proc_entry("psched", net->proc_net);
Tom Goff7316ae82010-03-19 15:40:13 +00002116}
2117#else
2118static int __net_init psched_net_init(struct net *net)
2119{
2120 return 0;
2121}
2122
2123static void __net_exit psched_net_exit(struct net *net)
2124{
2125}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126#endif
2127
Tom Goff7316ae82010-03-19 15:40:13 +00002128static struct pernet_operations psched_net_ops = {
2129 .init = psched_net_init,
2130 .exit = psched_net_exit,
2131};
2132
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133static int __init pktsched_init(void)
2134{
Tom Goff7316ae82010-03-19 15:40:13 +00002135 int err;
2136
2137 err = register_pernet_subsys(&psched_net_ops);
2138 if (err) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +00002139 pr_err("pktsched_init: "
Tom Goff7316ae82010-03-19 15:40:13 +00002140 "cannot initialize per netns operations\n");
2141 return err;
2142 }
2143
stephen hemminger6da7c8f2013-08-27 16:19:08 -07002144 register_qdisc(&pfifo_fast_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 register_qdisc(&pfifo_qdisc_ops);
2146 register_qdisc(&bfifo_qdisc_ops);
Hagen Paul Pfeifer57dbb2d2010-01-24 12:30:59 +00002147 register_qdisc(&pfifo_head_drop_qdisc_ops);
David S. Miller6ec1c692009-09-06 01:58:51 -07002148 register_qdisc(&mq_qdisc_ops);
Phil Sutterd66d6c32015-08-27 21:21:38 +02002149 register_qdisc(&noqueue_qdisc_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150
Florian Westphalb97bac62017-08-09 20:41:48 +02002151 rtnl_register(PF_UNSPEC, RTM_NEWQDISC, tc_modify_qdisc, NULL, 0);
2152 rtnl_register(PF_UNSPEC, RTM_DELQDISC, tc_get_qdisc, NULL, 0);
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04002153 rtnl_register(PF_UNSPEC, RTM_GETQDISC, tc_get_qdisc, tc_dump_qdisc,
Florian Westphalb97bac62017-08-09 20:41:48 +02002154 0);
2155 rtnl_register(PF_UNSPEC, RTM_NEWTCLASS, tc_ctl_tclass, NULL, 0);
2156 rtnl_register(PF_UNSPEC, RTM_DELTCLASS, tc_ctl_tclass, NULL, 0);
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -04002157 rtnl_register(PF_UNSPEC, RTM_GETTCLASS, tc_ctl_tclass, tc_dump_tclass,
Florian Westphalb97bac62017-08-09 20:41:48 +02002158 0);
Thomas Grafbe577dd2007-03-22 11:55:50 -07002159
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 return 0;
2161}
2162
2163subsys_initcall(pktsched_init);