2019-05-27 13:55:01 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* net/sched/sch_api.c Packet scheduler API.
|
|
|
|
*
|
|
|
|
* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
|
|
|
*
|
|
|
|
* Fixes:
|
|
|
|
*
|
|
|
|
* Rani Assaf <rani@magic.metawire.com> :980802: JIFFIES and CPU clock sources are repaired.
|
|
|
|
* Eduardo J. Blanco <ejbs@netlabs.com.uy> :990222: kmod support
|
|
|
|
* Jamal Hadi Salim <hadi@nortelnetworks.com>: 990601: ingress support
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/kmod.h>
|
|
|
|
#include <linux/list.h>
|
2007-03-16 15:19:15 +07:00
|
|
|
#include <linux/hrtimer.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2016-08-10 16:05:15 +07:00
|
|
|
#include <linux/hashtable.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-09-12 17:01:34 +07:00
|
|
|
#include <net/net_namespace.h>
|
2007-11-30 20:21:31 +07:00
|
|
|
#include <net/sock.h>
|
2007-03-26 13:06:12 +07:00
|
|
|
#include <net/netlink.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <net/pkt_sched.h>
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
#include <net/pkt_cls.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2020-05-27 11:35:25 +07:00
|
|
|
#include <trace/events/qdisc.h>
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
|
|
|
|
Short review.
|
|
|
|
-------------
|
|
|
|
|
|
|
|
This file consists of two interrelated parts:
|
|
|
|
|
|
|
|
1. queueing disciplines manager frontend.
|
|
|
|
2. traffic classes manager frontend.
|
|
|
|
|
|
|
|
Generally, queueing discipline ("qdisc") is a black box,
|
|
|
|
which is able to enqueue packets and to dequeue them (when
|
|
|
|
device is ready to send something) in order and at times
|
|
|
|
determined by algorithm hidden in it.
|
|
|
|
|
|
|
|
qdisc's are divided to two categories:
|
|
|
|
- "queues", which have no internal structure visible from outside.
|
|
|
|
- "schedulers", which split all the packets to "traffic classes",
|
|
|
|
using "packet classifiers" (look at cls_api.c)
|
|
|
|
|
|
|
|
In turn, classes may have child qdiscs (as rule, queues)
|
|
|
|
attached to them etc. etc. etc.
|
|
|
|
|
|
|
|
The goal of the routines in this file is to translate
|
|
|
|
information supplied by user in the form of handles
|
|
|
|
to more intelligible for kernel form, to make some sanity
|
|
|
|
checks and part of work, which is common to all qdiscs
|
|
|
|
and to provide rtnetlink notifications.
|
|
|
|
|
|
|
|
All real intelligent work is done inside qdisc modules.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Every discipline has two major routines: enqueue and dequeue.
|
|
|
|
|
|
|
|
---dequeue
|
|
|
|
|
|
|
|
dequeue usually returns a skb to send. It is allowed to return NULL,
|
|
|
|
but it does not mean that queue is empty, it just means that
|
|
|
|
discipline does not want to send anything this time.
|
|
|
|
Queue is really empty if q->q.qlen == 0.
|
|
|
|
For complicated disciplines with multiple queues q->q is not
|
|
|
|
real packet queue, but however q->q.qlen must be valid.
|
|
|
|
|
|
|
|
---enqueue
|
|
|
|
|
|
|
|
enqueue returns 0, if packet was enqueued successfully.
|
|
|
|
If packet (this one or another one) was dropped, it returns
|
|
|
|
not zero error code.
|
|
|
|
NET_XMIT_DROP - this packet dropped
|
|
|
|
Expected action: do not backoff, but wait until queue will clear.
|
|
|
|
NET_XMIT_CN - probably this packet enqueued, but another one dropped.
|
|
|
|
Expected action: backoff or ignore
|
|
|
|
|
|
|
|
Auxiliary routines:
|
|
|
|
|
2008-10-31 14:45:27 +07:00
|
|
|
---peek
|
|
|
|
|
|
|
|
like dequeue but without removing a packet from the queue
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
---reset
|
|
|
|
|
|
|
|
returns qdisc to initial state: purge all buffers, clear all
|
|
|
|
timers, counters (except for statistics) etc.
|
|
|
|
|
|
|
|
---init
|
|
|
|
|
|
|
|
initializes newly created qdisc.
|
|
|
|
|
|
|
|
---destroy
|
|
|
|
|
|
|
|
destroys resources allocated by init and during lifetime of qdisc.
|
|
|
|
|
|
|
|
---change
|
|
|
|
|
|
|
|
changes qdisc parameters.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Protects list of registered TC modules. It is pure SMP lock. */
|
|
|
|
static DEFINE_RWLOCK(qdisc_mod_lock);
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************
|
|
|
|
* Queueing disciplines manipulation. *
|
|
|
|
************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
/* The list of all installed queueing disciplines. */
|
|
|
|
|
|
|
|
static struct Qdisc_ops *qdisc_base;
|
|
|
|
|
2014-01-01 03:34:51 +07:00
|
|
|
/* Register/unregister queueing discipline */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
int register_qdisc(struct Qdisc_ops *qops)
|
|
|
|
{
|
|
|
|
struct Qdisc_ops *q, **qp;
|
|
|
|
int rc = -EEXIST;
|
|
|
|
|
|
|
|
write_lock(&qdisc_mod_lock);
|
|
|
|
for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
|
|
|
|
if (!strcmp(qops->id, q->id))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (qops->enqueue == NULL)
|
|
|
|
qops->enqueue = noop_qdisc_ops.enqueue;
|
2008-10-31 14:45:27 +07:00
|
|
|
if (qops->peek == NULL) {
|
2010-08-09 19:18:48 +07:00
|
|
|
if (qops->dequeue == NULL)
|
2008-10-31 14:45:27 +07:00
|
|
|
qops->peek = noop_qdisc_ops.peek;
|
2010-08-09 19:18:48 +07:00
|
|
|
else
|
|
|
|
goto out_einval;
|
2008-10-31 14:45:27 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
if (qops->dequeue == NULL)
|
|
|
|
qops->dequeue = noop_qdisc_ops.dequeue;
|
|
|
|
|
2010-08-09 19:18:48 +07:00
|
|
|
if (qops->cl_ops) {
|
|
|
|
const struct Qdisc_class_ops *cops = qops->cl_ops;
|
|
|
|
|
net_sched: remove tc class reference counting
For TC classes, their ->get() and ->put() are always paired, and the
reference counting is completely useless, because:
1) For class modification and dumping paths, we already hold RTNL lock,
so all of these ->get(),->change(),->put() are atomic.
2) For filter bindiing/unbinding, we use other reference counter than
this one, and they should have RTNL lock too.
3) For ->qlen_notify(), it is special because it is called on ->enqueue()
path, but we already hold qdisc tree lock there, and we hold this
tree lock when graft or delete the class too, so it should not be gone
or changed until we release the tree lock.
Therefore, this patch removes ->get() and ->put(), but:
1) Adds a new ->find() to find the pointer to a class by classid, no
refcnt.
2) Move the original class destroy upon the last refcnt into ->delete(),
right after releasing tree lock. This is fine because the class is
already removed from hash when holding the lock.
For those who also use ->put() as ->unbind(), just rename them to reflect
this change.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Acked-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-25 06:51:29 +07:00
|
|
|
if (!(cops->find && cops->walk && cops->leaf))
|
2010-08-09 19:18:48 +07:00
|
|
|
goto out_einval;
|
|
|
|
|
2017-05-17 16:07:55 +07:00
|
|
|
if (cops->tcf_block && !(cops->bind_tcf && cops->unbind_tcf))
|
2010-08-09 19:18:48 +07:00
|
|
|
goto out_einval;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
qops->next = NULL;
|
|
|
|
*qp = qops;
|
|
|
|
rc = 0;
|
|
|
|
out:
|
|
|
|
write_unlock(&qdisc_mod_lock);
|
|
|
|
return rc;
|
2010-08-09 19:18:48 +07:00
|
|
|
|
|
|
|
out_einval:
|
|
|
|
rc = -EINVAL;
|
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-01-23 13:10:23 +07:00
|
|
|
EXPORT_SYMBOL(register_qdisc);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
int unregister_qdisc(struct Qdisc_ops *qops)
|
|
|
|
{
|
|
|
|
struct Qdisc_ops *q, **qp;
|
|
|
|
int err = -ENOENT;
|
|
|
|
|
|
|
|
write_lock(&qdisc_mod_lock);
|
2011-01-20 02:26:56 +07:00
|
|
|
for (qp = &qdisc_base; (q = *qp) != NULL; qp = &q->next)
|
2005-04-17 05:20:36 +07:00
|
|
|
if (q == qops)
|
|
|
|
break;
|
|
|
|
if (q) {
|
|
|
|
*qp = q->next;
|
|
|
|
q->next = NULL;
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
write_unlock(&qdisc_mod_lock);
|
|
|
|
return err;
|
|
|
|
}
|
2008-01-23 13:10:23 +07:00
|
|
|
EXPORT_SYMBOL(unregister_qdisc);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-08-28 06:19:08 +07:00
|
|
|
/* Get default qdisc if not otherwise specified */
|
|
|
|
void qdisc_get_default(char *name, size_t len)
|
|
|
|
{
|
|
|
|
read_lock(&qdisc_mod_lock);
|
|
|
|
strlcpy(name, default_qdisc_ops->id, len);
|
|
|
|
read_unlock(&qdisc_mod_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct Qdisc_ops *qdisc_lookup_default(const char *name)
|
|
|
|
{
|
|
|
|
struct Qdisc_ops *q = NULL;
|
|
|
|
|
|
|
|
for (q = qdisc_base; q; q = q->next) {
|
|
|
|
if (!strcmp(name, q->id)) {
|
|
|
|
if (!try_module_get(q->owner))
|
|
|
|
q = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return q;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set new default qdisc to use */
|
|
|
|
int qdisc_set_default(const char *name)
|
|
|
|
{
|
|
|
|
const struct Qdisc_ops *ops;
|
|
|
|
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
write_lock(&qdisc_mod_lock);
|
|
|
|
ops = qdisc_lookup_default(name);
|
|
|
|
if (!ops) {
|
|
|
|
/* Not found, drop lock and try to load module */
|
|
|
|
write_unlock(&qdisc_mod_lock);
|
|
|
|
request_module("sch_%s", name);
|
|
|
|
write_lock(&qdisc_mod_lock);
|
|
|
|
|
|
|
|
ops = qdisc_lookup_default(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ops) {
|
|
|
|
/* Set new default */
|
|
|
|
module_put(default_qdisc_ops->owner);
|
|
|
|
default_qdisc_ops = ops;
|
|
|
|
}
|
|
|
|
write_unlock(&qdisc_mod_lock);
|
|
|
|
|
|
|
|
return ops ? 0 : -ENOENT;
|
|
|
|
}
|
|
|
|
|
2017-04-13 22:40:53 +07:00
|
|
|
#ifdef CONFIG_NET_SCH_DEFAULT
|
|
|
|
/* Set default value from kernel config */
|
|
|
|
static int __init sch_default_qdisc(void)
|
|
|
|
{
|
|
|
|
return qdisc_set_default(CONFIG_DEFAULT_NET_SCH);
|
|
|
|
}
|
|
|
|
late_initcall(sch_default_qdisc);
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* We know handle. Find qdisc among all qdisc's attached to device
|
2015-12-02 11:08:51 +07:00
|
|
|
* (root qdisc, all its children, children of children etc.)
|
|
|
|
* Note: caller either uses rtnl or rcu_read_lock()
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
2008-11-28 18:06:46 +07:00
|
|
|
static struct Qdisc *qdisc_match_from_root(struct Qdisc *root, u32 handle)
|
2008-08-09 13:23:39 +07:00
|
|
|
{
|
|
|
|
struct Qdisc *q;
|
|
|
|
|
2016-08-17 04:52:58 +07:00
|
|
|
if (!qdisc_dev(root))
|
|
|
|
return (root->handle == handle ? root : NULL);
|
|
|
|
|
2008-08-09 13:23:39 +07:00
|
|
|
if (!(root->flags & TCQ_F_BUILTIN) &&
|
|
|
|
root->handle == handle)
|
|
|
|
return root;
|
|
|
|
|
2016-08-10 16:05:15 +07:00
|
|
|
hash_for_each_possible_rcu(qdisc_dev(root)->qdisc_hash, q, hash, handle) {
|
2008-08-09 13:23:39 +07:00
|
|
|
if (q->handle == handle)
|
|
|
|
return q;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-03-08 22:03:32 +07:00
|
|
|
void qdisc_hash_add(struct Qdisc *q, bool invisible)
|
2008-08-22 17:24:05 +07:00
|
|
|
{
|
2014-03-08 23:01:19 +07:00
|
|
|
if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS)) {
|
2015-12-02 11:08:51 +07:00
|
|
|
ASSERT_RTNL();
|
2016-08-10 16:05:15 +07:00
|
|
|
hash_add_rcu(qdisc_dev(q)->qdisc_hash, &q->hash, q->handle);
|
2017-03-08 22:03:32 +07:00
|
|
|
if (invisible)
|
|
|
|
q->flags |= TCQ_F_INVISIBLE;
|
2014-03-08 23:01:19 +07:00
|
|
|
}
|
2008-08-22 17:24:05 +07:00
|
|
|
}
|
2016-08-10 16:05:15 +07:00
|
|
|
EXPORT_SYMBOL(qdisc_hash_add);
|
2008-08-22 17:24:05 +07:00
|
|
|
|
2016-08-10 16:05:15 +07:00
|
|
|
void qdisc_hash_del(struct Qdisc *q)
|
2008-08-22 17:24:05 +07:00
|
|
|
{
|
2015-12-02 11:08:51 +07:00
|
|
|
if ((q->parent != TC_H_ROOT) && !(q->flags & TCQ_F_INGRESS)) {
|
|
|
|
ASSERT_RTNL();
|
2016-08-10 16:05:15 +07:00
|
|
|
hash_del_rcu(&q->hash);
|
2015-12-02 11:08:51 +07:00
|
|
|
}
|
2008-08-22 17:24:05 +07:00
|
|
|
}
|
2016-08-10 16:05:15 +07:00
|
|
|
EXPORT_SYMBOL(qdisc_hash_del);
|
2008-08-22 17:24:05 +07:00
|
|
|
|
2008-07-17 14:50:32 +07:00
|
|
|
struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-08-22 17:24:05 +07:00
|
|
|
struct Qdisc *q;
|
|
|
|
|
2017-10-28 12:08:56 +07:00
|
|
|
if (!handle)
|
|
|
|
return NULL;
|
2009-09-04 13:41:18 +07:00
|
|
|
q = qdisc_match_from_root(dev->qdisc, handle);
|
|
|
|
if (q)
|
|
|
|
goto out;
|
2008-08-22 17:24:05 +07:00
|
|
|
|
2010-10-02 13:11:55 +07:00
|
|
|
if (dev_ingress_queue(dev))
|
|
|
|
q = qdisc_match_from_root(
|
|
|
|
dev_ingress_queue(dev)->qdisc_sleeping,
|
|
|
|
handle);
|
2008-11-26 04:56:06 +07:00
|
|
|
out:
|
2008-08-22 17:24:05 +07:00
|
|
|
return q;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2018-09-24 23:22:51 +07:00
|
|
|
struct Qdisc *qdisc_lookup_rcu(struct net_device *dev, u32 handle)
|
|
|
|
{
|
|
|
|
struct netdev_queue *nq;
|
|
|
|
struct Qdisc *q;
|
|
|
|
|
|
|
|
if (!handle)
|
|
|
|
return NULL;
|
|
|
|
q = qdisc_match_from_root(dev->qdisc, handle);
|
|
|
|
if (q)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nq = dev_ingress_queue_rcu(dev);
|
|
|
|
if (nq)
|
|
|
|
q = qdisc_match_from_root(nq->qdisc_sleeping, handle);
|
|
|
|
out:
|
|
|
|
return q;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static struct Qdisc *qdisc_leaf(struct Qdisc *p, u32 classid)
|
|
|
|
{
|
|
|
|
unsigned long cl;
|
2007-11-14 16:44:41 +07:00
|
|
|
const struct Qdisc_class_ops *cops = p->ops->cl_ops;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (cops == NULL)
|
|
|
|
return NULL;
|
net_sched: remove tc class reference counting
For TC classes, their ->get() and ->put() are always paired, and the
reference counting is completely useless, because:
1) For class modification and dumping paths, we already hold RTNL lock,
so all of these ->get(),->change(),->put() are atomic.
2) For filter bindiing/unbinding, we use other reference counter than
this one, and they should have RTNL lock too.
3) For ->qlen_notify(), it is special because it is called on ->enqueue()
path, but we already hold qdisc tree lock there, and we hold this
tree lock when graft or delete the class too, so it should not be gone
or changed until we release the tree lock.
Therefore, this patch removes ->get() and ->put(), but:
1) Adds a new ->find() to find the pointer to a class by classid, no
refcnt.
2) Move the original class destroy upon the last refcnt into ->delete(),
right after releasing tree lock. This is fine because the class is
already removed from hash when holding the lock.
For those who also use ->put() as ->unbind(), just rename them to reflect
this change.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Acked-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-25 06:51:29 +07:00
|
|
|
cl = cops->find(p, classid);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (cl == 0)
|
|
|
|
return NULL;
|
2018-12-13 15:43:23 +07:00
|
|
|
return cops->leaf(p, cl);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Find queueing discipline by name */
|
|
|
|
|
2008-01-23 13:11:17 +07:00
|
|
|
static struct Qdisc_ops *qdisc_lookup_ops(struct nlattr *kind)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct Qdisc_ops *q = NULL;
|
|
|
|
|
|
|
|
if (kind) {
|
|
|
|
read_lock(&qdisc_mod_lock);
|
|
|
|
for (q = qdisc_base; q; q = q->next) {
|
2008-01-23 13:11:17 +07:00
|
|
|
if (nla_strcmp(kind, q->id) == 0) {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!try_module_get(q->owner))
|
|
|
|
q = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock(&qdisc_mod_lock);
|
|
|
|
}
|
|
|
|
return q;
|
|
|
|
}
|
|
|
|
|
2013-08-15 04:47:11 +07:00
|
|
|
/* The linklayer setting were not transferred from iproute2, in older
|
|
|
|
* versions, and the rate tables lookup systems have been dropped in
|
|
|
|
* the kernel. To keep backward compatible with older iproute2 tc
|
|
|
|
* utils, we detect the linklayer setting by detecting if the rate
|
|
|
|
* table were modified.
|
|
|
|
*
|
|
|
|
* For linklayer ATM table entries, the rate table will be aligned to
|
|
|
|
* 48 bytes, thus some table entries will contain the same value. The
|
|
|
|
* mpu (min packet unit) is also encoded into the old rate table, thus
|
|
|
|
* starting from the mpu, we find low and high table entries for
|
|
|
|
* mapping this cell. If these entries contain the same value, when
|
|
|
|
* the rate tables have been modified for linklayer ATM.
|
|
|
|
*
|
|
|
|
* This is done by rounding mpu to the nearest 48 bytes cell/entry,
|
|
|
|
* and then roundup to the next cell, calc the table entry one below,
|
|
|
|
* and compare.
|
|
|
|
*/
|
|
|
|
static __u8 __detect_linklayer(struct tc_ratespec *r, __u32 *rtab)
|
|
|
|
{
|
|
|
|
int low = roundup(r->mpu, 48);
|
|
|
|
int high = roundup(low+1, 48);
|
|
|
|
int cell_low = low >> r->cell_log;
|
|
|
|
int cell_high = (high >> r->cell_log) - 1;
|
|
|
|
|
|
|
|
/* rtab is too inaccurate at rates > 100Mbit/s */
|
|
|
|
if ((r->rate > (100000000/8)) || (rtab[0] == 0)) {
|
|
|
|
pr_debug("TC linklayer: Giving up ATM detection\n");
|
|
|
|
return TC_LINKLAYER_ETHERNET;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cell_high > cell_low) && (cell_high < 256)
|
|
|
|
&& (rtab[cell_low] == rtab[cell_high])) {
|
|
|
|
pr_debug("TC linklayer: Detected ATM, low(%d)=high(%d)=%u\n",
|
|
|
|
cell_low, cell_high, rtab[cell_high]);
|
|
|
|
return TC_LINKLAYER_ATM;
|
|
|
|
}
|
|
|
|
return TC_LINKLAYER_ETHERNET;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static struct qdisc_rate_table *qdisc_rtab_list;
|
|
|
|
|
2016-09-18 19:45:33 +07:00
|
|
|
struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r,
|
2017-12-21 00:35:18 +07:00
|
|
|
struct nlattr *tab,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct qdisc_rate_table *rtab;
|
|
|
|
|
2013-06-02 18:15:55 +07:00
|
|
|
if (tab == NULL || r->rate == 0 || r->cell_log == 0 ||
|
2017-12-21 00:35:18 +07:00
|
|
|
nla_len(tab) != TC_RTAB_SIZE) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid rate table parameters for searching");
|
2013-06-02 18:15:55 +07:00
|
|
|
return NULL;
|
2017-12-21 00:35:18 +07:00
|
|
|
}
|
2013-06-02 18:15:55 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
for (rtab = qdisc_rtab_list; rtab; rtab = rtab->next) {
|
2013-06-02 18:15:55 +07:00
|
|
|
if (!memcmp(&rtab->rate, r, sizeof(struct tc_ratespec)) &&
|
|
|
|
!memcmp(&rtab->data, nla_data(tab), 1024)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
rtab->refcnt++;
|
|
|
|
return rtab;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rtab = kmalloc(sizeof(*rtab), GFP_KERNEL);
|
|
|
|
if (rtab) {
|
|
|
|
rtab->rate = *r;
|
|
|
|
rtab->refcnt = 1;
|
2008-01-23 13:11:17 +07:00
|
|
|
memcpy(rtab->data, nla_data(tab), 1024);
|
2013-08-15 04:47:11 +07:00
|
|
|
if (r->linklayer == TC_LINKLAYER_UNAWARE)
|
|
|
|
r->linklayer = __detect_linklayer(r, rtab->data);
|
2005-04-17 05:20:36 +07:00
|
|
|
rtab->next = qdisc_rtab_list;
|
|
|
|
qdisc_rtab_list = rtab;
|
2017-12-21 00:35:18 +07:00
|
|
|
} else {
|
|
|
|
NL_SET_ERR_MSG(extack, "Failed to allocate new qdisc rate table");
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
return rtab;
|
|
|
|
}
|
2008-01-23 13:10:23 +07:00
|
|
|
EXPORT_SYMBOL(qdisc_get_rtab);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
void qdisc_put_rtab(struct qdisc_rate_table *tab)
|
|
|
|
{
|
|
|
|
struct qdisc_rate_table *rtab, **rtabp;
|
|
|
|
|
|
|
|
if (!tab || --tab->refcnt)
|
|
|
|
return;
|
|
|
|
|
2011-01-20 02:26:56 +07:00
|
|
|
for (rtabp = &qdisc_rtab_list;
|
|
|
|
(rtab = *rtabp) != NULL;
|
|
|
|
rtabp = &rtab->next) {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (rtab == tab) {
|
|
|
|
*rtabp = rtab->next;
|
|
|
|
kfree(rtab);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-01-23 13:10:23 +07:00
|
|
|
EXPORT_SYMBOL(qdisc_put_rtab);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-20 14:08:47 +07:00
|
|
|
static LIST_HEAD(qdisc_stab_list);
|
|
|
|
|
|
|
|
static const struct nla_policy stab_policy[TCA_STAB_MAX + 1] = {
|
|
|
|
[TCA_STAB_BASE] = { .len = sizeof(struct tc_sizespec) },
|
|
|
|
[TCA_STAB_DATA] = { .type = NLA_BINARY },
|
|
|
|
};
|
|
|
|
|
2017-12-21 00:35:12 +07:00
|
|
|
static struct qdisc_size_table *qdisc_get_stab(struct nlattr *opt,
|
|
|
|
struct netlink_ext_ack *extack)
|
2008-07-20 14:08:47 +07:00
|
|
|
{
|
|
|
|
struct nlattr *tb[TCA_STAB_MAX + 1];
|
|
|
|
struct qdisc_size_table *stab;
|
|
|
|
struct tc_sizespec *s;
|
|
|
|
unsigned int tsize = 0;
|
|
|
|
u16 *tab = NULL;
|
|
|
|
int err;
|
|
|
|
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 19:07:28 +07:00
|
|
|
err = nla_parse_nested_deprecated(tb, TCA_STAB_MAX, opt, stab_policy,
|
|
|
|
extack);
|
2008-07-20 14:08:47 +07:00
|
|
|
if (err < 0)
|
|
|
|
return ERR_PTR(err);
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!tb[TCA_STAB_BASE]) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Size table base attribute is missing");
|
2008-07-20 14:08:47 +07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2008-07-20 14:08:47 +07:00
|
|
|
|
|
|
|
s = nla_data(tb[TCA_STAB_BASE]);
|
|
|
|
|
|
|
|
if (s->tsize > 0) {
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!tb[TCA_STAB_DATA]) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Size table data attribute is missing");
|
2008-07-20 14:08:47 +07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2008-07-20 14:08:47 +07:00
|
|
|
tab = nla_data(tb[TCA_STAB_DATA]);
|
|
|
|
tsize = nla_len(tb[TCA_STAB_DATA]) / sizeof(u16);
|
|
|
|
}
|
|
|
|
|
2017-12-21 00:35:12 +07:00
|
|
|
if (tsize != s->tsize || (!tab && tsize > 0)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid size of size table");
|
2008-07-20 14:08:47 +07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2008-07-20 14:08:47 +07:00
|
|
|
|
|
|
|
list_for_each_entry(stab, &qdisc_stab_list, list) {
|
|
|
|
if (memcmp(&stab->szopts, s, sizeof(*s)))
|
|
|
|
continue;
|
|
|
|
if (tsize > 0 && memcmp(stab->data, tab, tsize * sizeof(u16)))
|
|
|
|
continue;
|
|
|
|
stab->refcnt++;
|
|
|
|
return stab;
|
|
|
|
}
|
|
|
|
|
|
|
|
stab = kmalloc(sizeof(*stab) + tsize * sizeof(u16), GFP_KERNEL);
|
|
|
|
if (!stab)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
stab->refcnt = 1;
|
|
|
|
stab->szopts = *s;
|
|
|
|
if (tsize > 0)
|
|
|
|
memcpy(stab->data, tab, tsize * sizeof(u16));
|
|
|
|
|
|
|
|
list_add_tail(&stab->list, &qdisc_stab_list);
|
|
|
|
|
|
|
|
return stab;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qdisc_put_stab(struct qdisc_size_table *tab)
|
|
|
|
{
|
|
|
|
if (!tab)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (--tab->refcnt == 0) {
|
|
|
|
list_del(&tab->list);
|
2019-02-16 15:19:55 +07:00
|
|
|
kfree_rcu(tab, rcu);
|
2008-07-20 14:08:47 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_put_stab);
|
|
|
|
|
|
|
|
static int qdisc_dump_stab(struct sk_buff *skb, struct qdisc_size_table *stab)
|
|
|
|
{
|
|
|
|
struct nlattr *nest;
|
|
|
|
|
2019-04-26 16:13:06 +07:00
|
|
|
nest = nla_nest_start_noflag(skb, TCA_STAB);
|
2008-11-20 19:07:14 +07:00
|
|
|
if (nest == NULL)
|
|
|
|
goto nla_put_failure;
|
2012-03-29 16:11:39 +07:00
|
|
|
if (nla_put(skb, TCA_STAB_BASE, sizeof(stab->szopts), &stab->szopts))
|
|
|
|
goto nla_put_failure;
|
2008-07-20 14:08:47 +07:00
|
|
|
nla_nest_end(skb, nest);
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
|
|
|
|
nla_put_failure:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-09-18 19:45:33 +07:00
|
|
|
void __qdisc_calculate_pkt_len(struct sk_buff *skb,
|
|
|
|
const struct qdisc_size_table *stab)
|
2008-07-20 14:08:47 +07:00
|
|
|
{
|
|
|
|
int pkt_len, slot;
|
|
|
|
|
|
|
|
pkt_len = skb->len + stab->szopts.overhead;
|
|
|
|
if (unlikely(!stab->szopts.tsize))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
slot = pkt_len + stab->szopts.cell_align;
|
|
|
|
if (unlikely(slot < 0))
|
|
|
|
slot = 0;
|
|
|
|
|
|
|
|
slot >>= stab->szopts.cell_log;
|
|
|
|
if (likely(slot < stab->szopts.tsize))
|
|
|
|
pkt_len = stab->data[slot];
|
|
|
|
else
|
|
|
|
pkt_len = stab->data[stab->szopts.tsize - 1] *
|
|
|
|
(slot / stab->szopts.tsize) +
|
|
|
|
stab->data[slot % stab->szopts.tsize];
|
|
|
|
|
|
|
|
pkt_len <<= stab->szopts.size_log;
|
|
|
|
out:
|
|
|
|
if (unlikely(pkt_len < 1))
|
|
|
|
pkt_len = 1;
|
|
|
|
qdisc_skb_cb(skb)->pkt_len = pkt_len;
|
|
|
|
}
|
2011-01-20 10:48:19 +07:00
|
|
|
EXPORT_SYMBOL(__qdisc_calculate_pkt_len);
|
2008-07-20 14:08:47 +07:00
|
|
|
|
2014-06-12 01:35:18 +07:00
|
|
|
void qdisc_warn_nonwc(const char *txt, struct Qdisc *qdisc)
|
2009-02-01 16:12:42 +07:00
|
|
|
{
|
|
|
|
if (!(qdisc->flags & TCQ_F_WARN_NONWC)) {
|
2011-01-20 02:26:56 +07:00
|
|
|
pr_warn("%s: %s qdisc %X: is non-work-conserving?\n",
|
|
|
|
txt, qdisc->ops->id, qdisc->handle >> 16);
|
2009-02-01 16:12:42 +07:00
|
|
|
qdisc->flags |= TCQ_F_WARN_NONWC;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_warn_nonwc);
|
|
|
|
|
2007-03-16 15:19:15 +07:00
|
|
|
static enum hrtimer_restart qdisc_watchdog(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
struct qdisc_watchdog *wd = container_of(timer, struct qdisc_watchdog,
|
2009-09-02 07:59:25 +07:00
|
|
|
timer);
|
2007-03-16 15:19:15 +07:00
|
|
|
|
2014-10-03 12:43:09 +07:00
|
|
|
rcu_read_lock();
|
2008-08-19 10:51:18 +07:00
|
|
|
__netif_schedule(qdisc_root(wd->qdisc));
|
2014-10-03 12:43:09 +07:00
|
|
|
rcu_read_unlock();
|
2007-03-23 02:18:35 +07:00
|
|
|
|
2007-03-16 15:19:15 +07:00
|
|
|
return HRTIMER_NORESTART;
|
|
|
|
}
|
|
|
|
|
2018-07-04 05:42:52 +07:00
|
|
|
void qdisc_watchdog_init_clockid(struct qdisc_watchdog *wd, struct Qdisc *qdisc,
|
|
|
|
clockid_t clockid)
|
2007-03-16 15:19:15 +07:00
|
|
|
{
|
2018-07-04 05:42:52 +07:00
|
|
|
hrtimer_init(&wd->timer, clockid, HRTIMER_MODE_ABS_PINNED);
|
2009-09-02 07:59:25 +07:00
|
|
|
wd->timer.function = qdisc_watchdog;
|
2007-03-16 15:19:15 +07:00
|
|
|
wd->qdisc = qdisc;
|
|
|
|
}
|
2018-07-04 05:42:52 +07:00
|
|
|
EXPORT_SYMBOL(qdisc_watchdog_init_clockid);
|
|
|
|
|
|
|
|
void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc)
|
|
|
|
{
|
|
|
|
qdisc_watchdog_init_clockid(wd, qdisc, CLOCK_MONOTONIC);
|
|
|
|
}
|
2007-03-16 15:19:15 +07:00
|
|
|
EXPORT_SYMBOL(qdisc_watchdog_init);
|
|
|
|
|
2020-03-17 09:12:49 +07:00
|
|
|
void qdisc_watchdog_schedule_range_ns(struct qdisc_watchdog *wd, u64 expires,
|
|
|
|
u64 delta_ns)
|
2007-03-16 15:19:15 +07:00
|
|
|
{
|
2008-08-21 19:11:14 +07:00
|
|
|
if (test_bit(__QDISC_STATE_DEACTIVATED,
|
|
|
|
&qdisc_root_sleeping(wd->qdisc)->state))
|
|
|
|
return;
|
|
|
|
|
2020-03-17 09:12:50 +07:00
|
|
|
if (hrtimer_is_queued(&wd->timer)) {
|
|
|
|
/* If timer is already set in [expires, expires + delta_ns],
|
|
|
|
* do not reprogram it.
|
|
|
|
*/
|
|
|
|
if (wd->last_expires - expires <= delta_ns)
|
|
|
|
return;
|
|
|
|
}
|
2016-05-24 04:24:56 +07:00
|
|
|
|
|
|
|
wd->last_expires = expires;
|
2020-03-17 09:12:49 +07:00
|
|
|
hrtimer_start_range_ns(&wd->timer,
|
|
|
|
ns_to_ktime(expires),
|
|
|
|
delta_ns,
|
|
|
|
HRTIMER_MODE_ABS_PINNED);
|
2007-03-16 15:19:15 +07:00
|
|
|
}
|
2020-03-17 09:12:49 +07:00
|
|
|
EXPORT_SYMBOL(qdisc_watchdog_schedule_range_ns);
|
2007-03-16 15:19:15 +07:00
|
|
|
|
|
|
|
void qdisc_watchdog_cancel(struct qdisc_watchdog *wd)
|
|
|
|
{
|
2009-09-02 07:59:25 +07:00
|
|
|
hrtimer_cancel(&wd->timer);
|
2007-03-16 15:19:15 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_watchdog_cancel);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-23 04:20:11 +07:00
|
|
|
static struct hlist_head *qdisc_class_hash_alloc(unsigned int n)
|
2008-07-06 13:21:31 +07:00
|
|
|
{
|
|
|
|
struct hlist_head *h;
|
2017-08-23 02:26:46 +07:00
|
|
|
unsigned int i;
|
2008-07-06 13:21:31 +07:00
|
|
|
|
2017-08-23 02:26:46 +07:00
|
|
|
h = kvmalloc_array(n, sizeof(struct hlist_head), GFP_KERNEL);
|
2008-07-06 13:21:31 +07:00
|
|
|
|
|
|
|
if (h != NULL) {
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
INIT_HLIST_HEAD(&h[i]);
|
|
|
|
}
|
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qdisc_class_hash_grow(struct Qdisc *sch, struct Qdisc_class_hash *clhash)
|
|
|
|
{
|
|
|
|
struct Qdisc_class_common *cl;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
struct hlist_node *next;
|
2008-07-06 13:21:31 +07:00
|
|
|
struct hlist_head *nhash, *ohash;
|
|
|
|
unsigned int nsize, nmask, osize;
|
|
|
|
unsigned int i, h;
|
|
|
|
|
|
|
|
/* Rehash when load factor exceeds 0.75 */
|
|
|
|
if (clhash->hashelems * 4 <= clhash->hashsize * 3)
|
|
|
|
return;
|
|
|
|
nsize = clhash->hashsize * 2;
|
|
|
|
nmask = nsize - 1;
|
|
|
|
nhash = qdisc_class_hash_alloc(nsize);
|
|
|
|
if (nhash == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ohash = clhash->hash;
|
|
|
|
osize = clhash->hashsize;
|
|
|
|
|
|
|
|
sch_tree_lock(sch);
|
|
|
|
for (i = 0; i < osize; i++) {
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:06:00 +07:00
|
|
|
hlist_for_each_entry_safe(cl, next, &ohash[i], hnode) {
|
2008-07-06 13:21:31 +07:00
|
|
|
h = qdisc_class_hash(cl->classid, nmask);
|
|
|
|
hlist_add_head(&cl->hnode, &nhash[h]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
clhash->hash = nhash;
|
|
|
|
clhash->hashsize = nsize;
|
|
|
|
clhash->hashmask = nmask;
|
|
|
|
sch_tree_unlock(sch);
|
|
|
|
|
2017-08-23 02:26:46 +07:00
|
|
|
kvfree(ohash);
|
2008-07-06 13:21:31 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_class_hash_grow);
|
|
|
|
|
|
|
|
int qdisc_class_hash_init(struct Qdisc_class_hash *clhash)
|
|
|
|
{
|
|
|
|
unsigned int size = 4;
|
|
|
|
|
|
|
|
clhash->hash = qdisc_class_hash_alloc(size);
|
2017-12-21 00:35:11 +07:00
|
|
|
if (!clhash->hash)
|
2008-07-06 13:21:31 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
clhash->hashsize = size;
|
|
|
|
clhash->hashmask = size - 1;
|
|
|
|
clhash->hashelems = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_class_hash_init);
|
|
|
|
|
|
|
|
void qdisc_class_hash_destroy(struct Qdisc_class_hash *clhash)
|
|
|
|
{
|
2017-08-23 02:26:46 +07:00
|
|
|
kvfree(clhash->hash);
|
2008-07-06 13:21:31 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_class_hash_destroy);
|
|
|
|
|
|
|
|
void qdisc_class_hash_insert(struct Qdisc_class_hash *clhash,
|
|
|
|
struct Qdisc_class_common *cl)
|
|
|
|
{
|
|
|
|
unsigned int h;
|
|
|
|
|
|
|
|
INIT_HLIST_NODE(&cl->hnode);
|
|
|
|
h = qdisc_class_hash(cl->classid, clhash->hashmask);
|
|
|
|
hlist_add_head(&cl->hnode, &clhash->hash[h]);
|
|
|
|
clhash->hashelems++;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_class_hash_insert);
|
|
|
|
|
|
|
|
void qdisc_class_hash_remove(struct Qdisc_class_hash *clhash,
|
|
|
|
struct Qdisc_class_common *cl)
|
|
|
|
{
|
|
|
|
hlist_del(&cl->hnode);
|
|
|
|
clhash->hashelems--;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_class_hash_remove);
|
|
|
|
|
2012-01-03 07:00:11 +07:00
|
|
|
/* Allocate an unique handle from space managed by kernel
|
|
|
|
* Possible range is [8000-FFFF]:0000 (0x8000 values)
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
static u32 qdisc_alloc_handle(struct net_device *dev)
|
|
|
|
{
|
2012-01-03 07:00:11 +07:00
|
|
|
int i = 0x8000;
|
2005-04-17 05:20:36 +07:00
|
|
|
static u32 autohandle = TC_H_MAKE(0x80000000U, 0);
|
|
|
|
|
|
|
|
do {
|
|
|
|
autohandle += TC_H_MAKE(0x10000U, 0);
|
|
|
|
if (autohandle == TC_H_MAKE(TC_H_ROOT, 0))
|
|
|
|
autohandle = TC_H_MAKE(0x80000000U, 0);
|
2012-01-03 07:00:11 +07:00
|
|
|
if (!qdisc_lookup(dev, autohandle))
|
|
|
|
return autohandle;
|
|
|
|
cond_resched();
|
|
|
|
} while (--i > 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-01-03 07:00:11 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2019-01-09 23:10:57 +07:00
|
|
|
void qdisc_tree_reduce_backlog(struct Qdisc *sch, int n, int len)
|
2006-11-30 08:35:48 +07:00
|
|
|
{
|
2018-02-28 16:45:03 +07:00
|
|
|
bool qdisc_is_offloaded = sch->flags & TCQ_F_OFFLOADED;
|
2007-11-14 16:44:41 +07:00
|
|
|
const struct Qdisc_class_ops *cops;
|
2006-11-30 08:35:48 +07:00
|
|
|
unsigned long cl;
|
|
|
|
u32 parentid;
|
2017-08-15 20:39:59 +07:00
|
|
|
bool notify;
|
2013-10-07 22:32:32 +07:00
|
|
|
int drops;
|
2006-11-30 08:35:48 +07:00
|
|
|
|
2016-02-26 05:55:01 +07:00
|
|
|
if (n == 0 && len == 0)
|
2006-11-30 08:35:48 +07:00
|
|
|
return;
|
2013-10-07 22:32:32 +07:00
|
|
|
drops = max_t(int, n, 0);
|
2015-12-02 11:08:51 +07:00
|
|
|
rcu_read_lock();
|
2006-11-30 08:35:48 +07:00
|
|
|
while ((parentid = sch->parent)) {
|
2008-04-15 05:10:42 +07:00
|
|
|
if (TC_H_MAJ(parentid) == TC_H_MAJ(TC_H_INGRESS))
|
2015-12-02 11:08:51 +07:00
|
|
|
break;
|
2008-04-15 05:10:42 +07:00
|
|
|
|
2015-12-02 11:08:51 +07:00
|
|
|
if (sch->flags & TCQ_F_NOPARENT)
|
|
|
|
break;
|
2017-08-15 20:39:59 +07:00
|
|
|
/* Notify parent qdisc only if child qdisc becomes empty.
|
|
|
|
*
|
|
|
|
* If child was empty even before update then backlog
|
|
|
|
* counter is screwed and we skip notification because
|
|
|
|
* parent class is already passive.
|
2018-02-28 16:45:03 +07:00
|
|
|
*
|
|
|
|
* If the original child was offloaded then it is allowed
|
|
|
|
* to be seem as empty, so the parent is notified anyway.
|
2017-08-15 20:39:59 +07:00
|
|
|
*/
|
2018-02-28 16:45:03 +07:00
|
|
|
notify = !sch->q.qlen && !WARN_ON_ONCE(!n &&
|
|
|
|
!qdisc_is_offloaded);
|
2015-12-02 11:08:51 +07:00
|
|
|
/* TODO: perform the search on a per txq basis */
|
2008-07-09 07:06:30 +07:00
|
|
|
sch = qdisc_lookup(qdisc_dev(sch), TC_H_MAJ(parentid));
|
2007-07-31 07:11:50 +07:00
|
|
|
if (sch == NULL) {
|
2015-12-02 11:08:51 +07:00
|
|
|
WARN_ON_ONCE(parentid != TC_H_ROOT);
|
|
|
|
break;
|
2007-07-31 07:11:50 +07:00
|
|
|
}
|
2006-11-30 08:35:48 +07:00
|
|
|
cops = sch->ops->cl_ops;
|
2017-08-15 20:39:59 +07:00
|
|
|
if (notify && cops->qlen_notify) {
|
net_sched: remove tc class reference counting
For TC classes, their ->get() and ->put() are always paired, and the
reference counting is completely useless, because:
1) For class modification and dumping paths, we already hold RTNL lock,
so all of these ->get(),->change(),->put() are atomic.
2) For filter bindiing/unbinding, we use other reference counter than
this one, and they should have RTNL lock too.
3) For ->qlen_notify(), it is special because it is called on ->enqueue()
path, but we already hold qdisc tree lock there, and we hold this
tree lock when graft or delete the class too, so it should not be gone
or changed until we release the tree lock.
Therefore, this patch removes ->get() and ->put(), but:
1) Adds a new ->find() to find the pointer to a class by classid, no
refcnt.
2) Move the original class destroy upon the last refcnt into ->delete(),
right after releasing tree lock. This is fine because the class is
already removed from hash when holding the lock.
For those who also use ->put() as ->unbind(), just rename them to reflect
this change.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Acked-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-25 06:51:29 +07:00
|
|
|
cl = cops->find(sch, parentid);
|
2006-11-30 08:35:48 +07:00
|
|
|
cops->qlen_notify(sch, cl);
|
|
|
|
}
|
|
|
|
sch->q.qlen -= n;
|
2016-02-26 05:55:01 +07:00
|
|
|
sch->qstats.backlog -= len;
|
2014-09-29 01:53:29 +07:00
|
|
|
__qdisc_qstats_drop(sch, drops);
|
2006-11-30 08:35:48 +07:00
|
|
|
}
|
2015-12-02 11:08:51 +07:00
|
|
|
rcu_read_unlock();
|
2006-11-30 08:35:48 +07:00
|
|
|
}
|
2016-02-26 05:55:01 +07:00
|
|
|
EXPORT_SYMBOL(qdisc_tree_reduce_backlog);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2018-11-08 08:33:34 +07:00
|
|
|
int qdisc_offload_dump_helper(struct Qdisc *sch, enum tc_setup_type type,
|
|
|
|
void *type_data)
|
|
|
|
{
|
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
sch->flags &= ~TCQ_F_OFFLOADED;
|
|
|
|
if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err = dev->netdev_ops->ndo_setup_tc(dev, type, type_data);
|
|
|
|
if (err == -EOPNOTSUPP)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!err)
|
|
|
|
sch->flags |= TCQ_F_OFFLOADED;
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_offload_dump_helper);
|
|
|
|
|
2018-11-08 08:33:37 +07:00
|
|
|
void qdisc_offload_graft_helper(struct net_device *dev, struct Qdisc *sch,
|
|
|
|
struct Qdisc *new, struct Qdisc *old,
|
|
|
|
enum tc_setup_type type, void *type_data,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
bool any_qdisc_is_offloaded;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc)
|
|
|
|
return;
|
|
|
|
|
|
|
|
err = dev->netdev_ops->ndo_setup_tc(dev, type, type_data);
|
|
|
|
|
|
|
|
/* Don't report error if the graft is part of destroy operation. */
|
|
|
|
if (!err || !new || new == &noop_qdisc)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Don't report error if the parent, the old child and the new
|
|
|
|
* one are not offloaded.
|
|
|
|
*/
|
|
|
|
any_qdisc_is_offloaded = new->flags & TCQ_F_OFFLOADED;
|
|
|
|
any_qdisc_is_offloaded |= sch && sch->flags & TCQ_F_OFFLOADED;
|
|
|
|
any_qdisc_is_offloaded |= old && old->flags & TCQ_F_OFFLOADED;
|
|
|
|
|
|
|
|
if (any_qdisc_is_offloaded)
|
|
|
|
NL_SET_ERR_MSG(extack, "Offloading graft operation failed.");
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qdisc_offload_graft_helper);
|
|
|
|
|
2018-11-13 05:58:10 +07:00
|
|
|
static void qdisc_offload_graft_root(struct net_device *dev,
|
|
|
|
struct Qdisc *new, struct Qdisc *old,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
struct tc_root_qopt_offload graft_offload = {
|
|
|
|
.command = TC_ROOT_GRAFT,
|
|
|
|
.handle = new ? new->handle : 0,
|
|
|
|
.ingress = (new && new->flags & TCQ_F_INGRESS) ||
|
|
|
|
(old && old->flags & TCQ_F_INGRESS),
|
|
|
|
};
|
|
|
|
|
|
|
|
qdisc_offload_graft_helper(dev, NULL, new, old,
|
|
|
|
TC_SETUP_ROOT_QDISC, &graft_offload, extack);
|
|
|
|
}
|
|
|
|
|
2017-08-25 06:51:27 +07:00
|
|
|
static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,
|
|
|
|
u32 portid, u32 seq, u16 flags, int event)
|
|
|
|
{
|
|
|
|
struct gnet_stats_basic_cpu __percpu *cpu_bstats = NULL;
|
|
|
|
struct gnet_stats_queue __percpu *cpu_qstats = NULL;
|
|
|
|
struct tcmsg *tcm;
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
unsigned char *b = skb_tail_pointer(skb);
|
|
|
|
struct gnet_dump d;
|
|
|
|
struct qdisc_size_table *stab;
|
2018-01-17 17:46:52 +07:00
|
|
|
u32 block_index;
|
2017-08-25 06:51:27 +07:00
|
|
|
__u32 qlen;
|
|
|
|
|
|
|
|
cond_resched();
|
|
|
|
nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
|
|
|
|
if (!nlh)
|
|
|
|
goto out_nlmsg_trim;
|
|
|
|
tcm = nlmsg_data(nlh);
|
|
|
|
tcm->tcm_family = AF_UNSPEC;
|
|
|
|
tcm->tcm__pad1 = 0;
|
|
|
|
tcm->tcm__pad2 = 0;
|
|
|
|
tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
|
|
|
|
tcm->tcm_parent = clid;
|
|
|
|
tcm->tcm_handle = q->handle;
|
|
|
|
tcm->tcm_info = refcount_read(&q->refcnt);
|
|
|
|
if (nla_put_string(skb, TCA_KIND, q->ops->id))
|
|
|
|
goto nla_put_failure;
|
2018-01-17 17:46:52 +07:00
|
|
|
if (q->ops->ingress_block_get) {
|
|
|
|
block_index = q->ops->ingress_block_get(q);
|
|
|
|
if (block_index &&
|
|
|
|
nla_put_u32(skb, TCA_INGRESS_BLOCK, block_index))
|
|
|
|
goto nla_put_failure;
|
|
|
|
}
|
|
|
|
if (q->ops->egress_block_get) {
|
|
|
|
block_index = q->ops->egress_block_get(q);
|
|
|
|
if (block_index &&
|
|
|
|
nla_put_u32(skb, TCA_EGRESS_BLOCK, block_index))
|
|
|
|
goto nla_put_failure;
|
|
|
|
}
|
2017-08-25 06:51:27 +07:00
|
|
|
if (q->ops->dump && q->ops->dump(q, skb) < 0)
|
|
|
|
goto nla_put_failure;
|
2017-12-25 15:51:42 +07:00
|
|
|
if (nla_put_u8(skb, TCA_HW_OFFLOAD, !!(q->flags & TCQ_F_OFFLOADED)))
|
|
|
|
goto nla_put_failure;
|
2017-12-08 00:57:00 +07:00
|
|
|
qlen = qdisc_qlen_sum(q);
|
2017-08-25 06:51:27 +07:00
|
|
|
|
|
|
|
stab = rtnl_dereference(q->stab);
|
|
|
|
if (stab && qdisc_dump_stab(skb, stab) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
|
|
|
|
NULL, &d, TCA_PAD) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
if (qdisc_is_percpu_stats(q)) {
|
|
|
|
cpu_bstats = q->cpu_bstats;
|
|
|
|
cpu_qstats = q->cpu_qstats;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gnet_stats_copy_basic(qdisc_root_sleeping_running(q),
|
|
|
|
&d, cpu_bstats, &q->bstats) < 0 ||
|
|
|
|
gnet_stats_copy_rate_est(&d, &q->rate_est) < 0 ||
|
|
|
|
gnet_stats_copy_queue(&d, cpu_qstats, &q->qstats, qlen) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
if (gnet_stats_finish_copy(&d) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
nlh->nlmsg_len = skb_tail_pointer(skb) - b;
|
|
|
|
return skb->len;
|
|
|
|
|
|
|
|
out_nlmsg_trim:
|
|
|
|
nla_put_failure:
|
|
|
|
nlmsg_trim(skb, b);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool tc_qdisc_dump_ignore(struct Qdisc *q, bool dump_invisible)
|
|
|
|
{
|
|
|
|
if (q->flags & TCQ_F_BUILTIN)
|
|
|
|
return true;
|
|
|
|
if ((q->flags & TCQ_F_INVISIBLE) && !dump_invisible)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qdisc_notify(struct net *net, struct sk_buff *oskb,
|
|
|
|
struct nlmsghdr *n, u32 clid,
|
|
|
|
struct Qdisc *old, struct Qdisc *new)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
|
|
|
|
|
|
|
|
skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
|
|
|
|
if (!skb)
|
|
|
|
return -ENOBUFS;
|
|
|
|
|
|
|
|
if (old && !tc_qdisc_dump_ignore(old, false)) {
|
|
|
|
if (tc_fill_qdisc(skb, old, clid, portid, n->nlmsg_seq,
|
|
|
|
0, RTM_DELQDISC) < 0)
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
if (new && !tc_qdisc_dump_ignore(new, false)) {
|
|
|
|
if (tc_fill_qdisc(skb, new, clid, portid, n->nlmsg_seq,
|
|
|
|
old ? NLM_F_REPLACE : 0, RTM_NEWQDISC) < 0)
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (skb->len)
|
|
|
|
return rtnetlink_send(skb, net, portid, RTNLGRP_TC,
|
|
|
|
n->nlmsg_flags & NLM_F_ECHO);
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-03-19 22:40:13 +07:00
|
|
|
static void notify_and_destroy(struct net *net, struct sk_buff *skb,
|
|
|
|
struct nlmsghdr *n, u32 clid,
|
2008-07-17 18:54:10 +07:00
|
|
|
struct Qdisc *old, struct Qdisc *new)
|
|
|
|
{
|
|
|
|
if (new || old)
|
2010-03-19 22:40:13 +07:00
|
|
|
qdisc_notify(net, skb, n, clid, old, new);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-19 11:03:15 +07:00
|
|
|
if (old)
|
2018-09-24 23:22:50 +07:00
|
|
|
qdisc_put(old);
|
2008-07-17 18:54:10 +07:00
|
|
|
}
|
|
|
|
|
2019-04-10 19:32:40 +07:00
|
|
|
static void qdisc_clear_nolock(struct Qdisc *sch)
|
|
|
|
{
|
|
|
|
sch->flags &= ~TCQ_F_NOLOCK;
|
|
|
|
if (!(sch->flags & TCQ_F_CPUSTATS))
|
|
|
|
return;
|
|
|
|
|
|
|
|
free_percpu(sch->cpu_bstats);
|
|
|
|
free_percpu(sch->cpu_qstats);
|
|
|
|
sch->cpu_bstats = NULL;
|
|
|
|
sch->cpu_qstats = NULL;
|
|
|
|
sch->flags &= ~TCQ_F_CPUSTATS;
|
|
|
|
}
|
|
|
|
|
2008-07-17 18:54:10 +07:00
|
|
|
/* Graft qdisc "new" to class "classid" of qdisc "parent" or
|
|
|
|
* to device "dev".
|
|
|
|
*
|
|
|
|
* When appropriate send a netlink notification using 'skb'
|
|
|
|
* and "n".
|
|
|
|
*
|
|
|
|
* On success, destroy old qdisc.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int qdisc_graft(struct net_device *dev, struct Qdisc *parent,
|
2008-07-17 18:54:10 +07:00
|
|
|
struct sk_buff *skb, struct nlmsghdr *n, u32 classid,
|
2017-12-21 00:35:12 +07:00
|
|
|
struct Qdisc *new, struct Qdisc *old,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-17 18:54:10 +07:00
|
|
|
struct Qdisc *q = old;
|
2010-03-19 22:40:13 +07:00
|
|
|
struct net *net = dev_net(dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-02-09 21:25:16 +07:00
|
|
|
if (parent == NULL) {
|
2008-07-17 18:54:10 +07:00
|
|
|
unsigned int i, num_q, ingress;
|
|
|
|
|
|
|
|
ingress = 0;
|
|
|
|
num_q = dev->num_tx_queues;
|
2008-07-30 16:37:46 +07:00
|
|
|
if ((q && q->flags & TCQ_F_INGRESS) ||
|
|
|
|
(new && new->flags & TCQ_F_INGRESS)) {
|
2008-07-17 18:54:10 +07:00
|
|
|
num_q = 1;
|
|
|
|
ingress = 1;
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!dev_ingress_queue(dev)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Device does not have an ingress queue");
|
2010-10-02 13:11:55 +07:00
|
|
|
return -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2008-07-17 18:54:10 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->flags & IFF_UP)
|
|
|
|
dev_deactivate(dev);
|
|
|
|
|
2018-11-13 05:58:10 +07:00
|
|
|
qdisc_offload_graft_root(dev, new, old, extack);
|
|
|
|
|
2015-05-27 06:08:48 +07:00
|
|
|
if (new && new->ops->attach)
|
|
|
|
goto skip;
|
2009-09-06 15:58:51 +07:00
|
|
|
|
2008-07-17 18:54:10 +07:00
|
|
|
for (i = 0; i < num_q; i++) {
|
2010-10-02 13:11:55 +07:00
|
|
|
struct netdev_queue *dev_queue = dev_ingress_queue(dev);
|
2008-07-17 18:54:10 +07:00
|
|
|
|
|
|
|
if (!ingress)
|
|
|
|
dev_queue = netdev_get_tx_queue(dev, i);
|
|
|
|
|
2008-07-30 16:37:46 +07:00
|
|
|
old = dev_graft_qdisc(dev_queue, new);
|
|
|
|
if (new && i > 0)
|
2017-08-25 11:12:28 +07:00
|
|
|
qdisc_refcount_inc(new);
|
2008-07-30 16:37:46 +07:00
|
|
|
|
2009-09-14 05:35:44 +07:00
|
|
|
if (!ingress)
|
2018-09-24 23:22:50 +07:00
|
|
|
qdisc_put(old);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-07-17 18:54:10 +07:00
|
|
|
|
2015-05-27 06:08:48 +07:00
|
|
|
skip:
|
2009-09-14 05:35:44 +07:00
|
|
|
if (!ingress) {
|
2010-03-19 22:40:13 +07:00
|
|
|
notify_and_destroy(net, skb, n, classid,
|
|
|
|
dev->qdisc, new);
|
2009-09-14 05:35:44 +07:00
|
|
|
if (new && !new->ops->attach)
|
2017-08-25 11:12:28 +07:00
|
|
|
qdisc_refcount_inc(new);
|
2009-09-14 05:35:44 +07:00
|
|
|
dev->qdisc = new ? : &noop_qdisc;
|
2015-05-27 06:08:48 +07:00
|
|
|
|
|
|
|
if (new && new->ops->attach)
|
|
|
|
new->ops->attach(new);
|
2009-09-14 05:35:44 +07:00
|
|
|
} else {
|
2010-03-19 22:40:13 +07:00
|
|
|
notify_and_destroy(net, skb, n, classid, old, new);
|
2009-09-14 05:35:44 +07:00
|
|
|
}
|
2009-09-04 13:41:18 +07:00
|
|
|
|
2008-07-17 18:54:10 +07:00
|
|
|
if (dev->flags & IFF_UP)
|
|
|
|
dev_activate(dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2007-11-14 16:44:41 +07:00
|
|
|
const struct Qdisc_class_ops *cops = parent->ops->cl_ops;
|
2018-11-08 08:33:38 +07:00
|
|
|
unsigned long cl;
|
|
|
|
int err;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-12-08 00:58:19 +07:00
|
|
|
/* Only support running class lockless if parent is lockless */
|
|
|
|
if (new && (new->flags & TCQ_F_NOLOCK) &&
|
|
|
|
parent && !(parent->flags & TCQ_F_NOLOCK))
|
2019-04-10 19:32:40 +07:00
|
|
|
qdisc_clear_nolock(new);
|
2017-12-08 00:58:19 +07:00
|
|
|
|
2018-11-08 08:33:38 +07:00
|
|
|
if (!cops || !cops->graft)
|
|
|
|
return -EOPNOTSUPP;
|
net_sched: remove tc class reference counting
For TC classes, their ->get() and ->put() are always paired, and the
reference counting is completely useless, because:
1) For class modification and dumping paths, we already hold RTNL lock,
so all of these ->get(),->change(),->put() are atomic.
2) For filter bindiing/unbinding, we use other reference counter than
this one, and they should have RTNL lock too.
3) For ->qlen_notify(), it is special because it is called on ->enqueue()
path, but we already hold qdisc tree lock there, and we hold this
tree lock when graft or delete the class too, so it should not be gone
or changed until we release the tree lock.
Therefore, this patch removes ->get() and ->put(), but:
1) Adds a new ->find() to find the pointer to a class by classid, no
refcnt.
2) Move the original class destroy upon the last refcnt into ->delete(),
right after releasing tree lock. This is fine because the class is
already removed from hash when holding the lock.
For those who also use ->put() as ->unbind(), just rename them to reflect
this change.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Acked-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-25 06:51:29 +07:00
|
|
|
|
2018-11-08 08:33:38 +07:00
|
|
|
cl = cops->find(parent, classid);
|
|
|
|
if (!cl) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Specified class not found");
|
|
|
|
return -ENOENT;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2018-11-08 08:33:38 +07:00
|
|
|
|
|
|
|
err = cops->graft(parent, cl, new, &old, extack);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
notify_and_destroy(net, skb, n, classid, old, new);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2018-11-08 08:33:38 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2018-01-17 17:46:52 +07:00
|
|
|
static int qdisc_block_indexes_set(struct Qdisc *sch, struct nlattr **tca,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
u32 block_index;
|
|
|
|
|
|
|
|
if (tca[TCA_INGRESS_BLOCK]) {
|
|
|
|
block_index = nla_get_u32(tca[TCA_INGRESS_BLOCK]);
|
|
|
|
|
|
|
|
if (!block_index) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Ingress block index cannot be 0");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (!sch->ops->ingress_block_set) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Ingress block sharing is not supported");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
sch->ops->ingress_block_set(sch, block_index);
|
|
|
|
}
|
|
|
|
if (tca[TCA_EGRESS_BLOCK]) {
|
|
|
|
block_index = nla_get_u32(tca[TCA_EGRESS_BLOCK]);
|
|
|
|
|
|
|
|
if (!block_index) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Egress block index cannot be 0");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (!sch->ops->egress_block_set) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Egress block sharing is not supported");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
sch->ops->egress_block_set(sch, block_index);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
Allocate and initialize new qdisc.
|
|
|
|
|
|
|
|
Parameters are passed via opt.
|
|
|
|
*/
|
|
|
|
|
2016-09-18 19:45:33 +07:00
|
|
|
static struct Qdisc *qdisc_create(struct net_device *dev,
|
|
|
|
struct netdev_queue *dev_queue,
|
|
|
|
struct Qdisc *p, u32 parent, u32 handle,
|
2017-12-21 00:35:12 +07:00
|
|
|
struct nlattr **tca, int *errp,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int err;
|
2008-01-23 13:11:17 +07:00
|
|
|
struct nlattr *kind = tca[TCA_KIND];
|
2005-04-17 05:20:36 +07:00
|
|
|
struct Qdisc *sch;
|
|
|
|
struct Qdisc_ops *ops;
|
2008-07-20 14:08:47 +07:00
|
|
|
struct qdisc_size_table *stab;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
ops = qdisc_lookup_ops(kind);
|
2008-10-17 05:24:51 +07:00
|
|
|
#ifdef CONFIG_MODULES
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ops == NULL && kind != NULL) {
|
|
|
|
char name[IFNAMSIZ];
|
2008-01-23 13:11:17 +07:00
|
|
|
if (nla_strlcpy(name, kind, IFNAMSIZ) < IFNAMSIZ) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/* We dropped the RTNL semaphore in order to
|
|
|
|
* perform the module load. So, even if we
|
|
|
|
* succeeded in loading the module we have to
|
|
|
|
* tell the caller to replay the request. We
|
|
|
|
* indicate this using -EAGAIN.
|
|
|
|
* We replay the request because the device may
|
|
|
|
* go away in the mean time.
|
|
|
|
*/
|
|
|
|
rtnl_unlock();
|
|
|
|
request_module("sch_%s", name);
|
|
|
|
rtnl_lock();
|
|
|
|
ops = qdisc_lookup_ops(kind);
|
|
|
|
if (ops != NULL) {
|
|
|
|
/* We will try again qdisc_lookup_ops,
|
|
|
|
* so don't keep a reference.
|
|
|
|
*/
|
|
|
|
module_put(ops->owner);
|
|
|
|
err = -EAGAIN;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-08-04 06:36:51 +07:00
|
|
|
err = -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!ops) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Specified qdisc not found");
|
2005-04-17 05:20:36 +07:00
|
|
|
goto err_out;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-12-21 00:35:20 +07:00
|
|
|
sch = qdisc_alloc(dev_queue, ops, extack);
|
2005-07-06 04:15:09 +07:00
|
|
|
if (IS_ERR(sch)) {
|
|
|
|
err = PTR_ERR(sch);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto err_out2;
|
2005-07-06 04:15:09 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-31 07:11:50 +07:00
|
|
|
sch->parent = parent;
|
|
|
|
|
2005-07-06 04:15:09 +07:00
|
|
|
if (handle == TC_H_INGRESS) {
|
2005-04-17 05:20:36 +07:00
|
|
|
sch->flags |= TCQ_F_INGRESS;
|
2005-07-06 04:15:09 +07:00
|
|
|
handle = TC_H_MAKE(TC_H_INGRESS, 0);
|
2007-04-17 07:07:08 +07:00
|
|
|
} else {
|
|
|
|
if (handle == 0) {
|
|
|
|
handle = qdisc_alloc_handle(dev);
|
2019-02-15 17:23:25 +07:00
|
|
|
if (handle == 0) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Maximum number of qdisc handles was exceeded");
|
|
|
|
err = -ENOSPC;
|
2007-04-17 07:07:08 +07:00
|
|
|
goto err_out3;
|
2019-02-15 17:23:25 +07:00
|
|
|
}
|
2007-04-17 07:07:08 +07:00
|
|
|
}
|
2012-12-11 22:54:33 +07:00
|
|
|
if (!netif_is_multiqueue(dev))
|
2015-12-16 00:43:12 +07:00
|
|
|
sch->flags |= TCQ_F_ONETXQUEUE;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-07-06 04:15:09 +07:00
|
|
|
sch->handle = handle;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
qdisc: catch misconfig of attaching qdisc to tx_queue_len zero device
It is a clear misconfiguration to attach a qdisc to a device with
tx_queue_len zero, because some qdisc's (namely, pfifo, bfifo, gred,
htb, plug and sfb) inherit/copy this value as their queue length.
Why should the kernel catch such a misconfiguration? Because prior to
introducing the IFF_NO_QUEUE device flag, userspace found a loophole
in the qdisc config system that allowed them to achieve the equivalent
of IFF_NO_QUEUE, which is to remove the qdisc code path entirely from
a device. The loophole on older kernels is setting tx_queue_len=0,
*prior* to device qdisc init (the config time is significant, simply
setting tx_queue_len=0 doesn't trigger the loophole).
This loophole is currently used by Docker[1] to get better performance
and scalability out of the veth device. The Docker developers were
warned[1] that they needed to adjust the tx_queue_len if ever
attaching a qdisc. The OpenShift project didn't remember this warning
and attached a qdisc, this were caught and fixed in[2].
[1] https://github.com/docker/libcontainer/pull/193
[2] https://github.com/openshift/origin/pull/11126
Instead of fixing every userspace program that used this loophole, and
forgot to reset the tx_queue_len, prior to attaching a qdisc. Let's
catch the misconfiguration on the kernel side.
Signed-off-by: Jesper Dangaard Brouer <brouer@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-11-03 20:56:11 +07:00
|
|
|
/* This exist to keep backward compatible with a userspace
|
|
|
|
* loophole, what allowed userspace to get IFF_NO_QUEUE
|
|
|
|
* facility on older kernels by setting tx_queue_len=0 (prior
|
|
|
|
* to qdisc init), and then forgot to reinit tx_queue_len
|
|
|
|
* before again attaching a qdisc.
|
|
|
|
*/
|
|
|
|
if ((dev->priv_flags & IFF_NO_QUEUE) && (dev->tx_queue_len == 0)) {
|
|
|
|
dev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
|
|
|
|
netdev_info(dev, "Caught tx_queue_len zero misconfig\n");
|
|
|
|
}
|
|
|
|
|
2018-01-17 17:46:52 +07:00
|
|
|
err = qdisc_block_indexes_set(sch, tca, extack);
|
|
|
|
if (err)
|
|
|
|
goto err_out3;
|
|
|
|
|
2017-12-05 06:40:00 +07:00
|
|
|
if (ops->init) {
|
2017-12-21 00:35:13 +07:00
|
|
|
err = ops->init(sch, tca[TCA_OPTIONS], extack);
|
2017-12-05 06:40:00 +07:00
|
|
|
if (err != 0)
|
|
|
|
goto err_out5;
|
|
|
|
}
|
2014-09-29 01:52:56 +07:00
|
|
|
|
2017-12-05 06:40:00 +07:00
|
|
|
if (tca[TCA_STAB]) {
|
2017-12-21 00:35:12 +07:00
|
|
|
stab = qdisc_get_stab(tca[TCA_STAB], extack);
|
2017-12-05 06:40:00 +07:00
|
|
|
if (IS_ERR(stab)) {
|
|
|
|
err = PTR_ERR(stab);
|
|
|
|
goto err_out4;
|
2005-07-06 04:15:53 +07:00
|
|
|
}
|
2017-12-05 06:40:00 +07:00
|
|
|
rcu_assign_pointer(sch->stab, stab);
|
|
|
|
}
|
|
|
|
if (tca[TCA_RATE]) {
|
|
|
|
seqcount_t *running;
|
2008-08-22 17:24:05 +07:00
|
|
|
|
2017-12-05 06:40:00 +07:00
|
|
|
err = -EOPNOTSUPP;
|
2017-12-21 00:35:12 +07:00
|
|
|
if (sch->flags & TCQ_F_MQROOT) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Cannot attach rate estimator to a multi-queue root qdisc");
|
2017-12-05 06:40:00 +07:00
|
|
|
goto err_out4;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-12-05 06:40:00 +07:00
|
|
|
if (sch->parent != TC_H_ROOT &&
|
|
|
|
!(sch->flags & TCQ_F_INGRESS) &&
|
|
|
|
(!p || !(p->flags & TCQ_F_MQROOT)))
|
|
|
|
running = qdisc_root_sleeping_running(sch);
|
|
|
|
else
|
|
|
|
running = &sch->running;
|
|
|
|
|
|
|
|
err = gen_new_estimator(&sch->bstats,
|
|
|
|
sch->cpu_bstats,
|
|
|
|
&sch->rate_est,
|
|
|
|
NULL,
|
|
|
|
running,
|
|
|
|
tca[TCA_RATE]);
|
2017-12-21 00:35:12 +07:00
|
|
|
if (err) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Failed to generate new estimator");
|
2017-12-05 06:40:00 +07:00
|
|
|
goto err_out4;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2017-12-05 06:40:00 +07:00
|
|
|
|
|
|
|
qdisc_hash_add(sch, false);
|
2020-05-27 11:35:25 +07:00
|
|
|
trace_qdisc_create(ops, dev, parent);
|
2017-12-05 06:40:00 +07:00
|
|
|
|
|
|
|
return sch;
|
|
|
|
|
|
|
|
err_out5:
|
2017-02-11 01:31:49 +07:00
|
|
|
/* ops->init() failed, we call ->destroy() like qdisc_create_dflt() */
|
2017-06-28 11:53:54 +07:00
|
|
|
if (ops->destroy)
|
|
|
|
ops->destroy(sch);
|
2005-04-17 05:20:36 +07:00
|
|
|
err_out3:
|
|
|
|
dev_put(dev);
|
net, sched: fix panic when updating miniq {b,q}stats
While working on fixing another bug, I ran into the following panic
on arm64 by simply attaching clsact qdisc, adding a filter and running
traffic on ingress to it:
[...]
[ 178.188591] Unable to handle kernel read from unreadable memory at virtual address 810fb501f000
[ 178.197314] Mem abort info:
[ 178.200121] ESR = 0x96000004
[ 178.203168] Exception class = DABT (current EL), IL = 32 bits
[ 178.209095] SET = 0, FnV = 0
[ 178.212157] EA = 0, S1PTW = 0
[ 178.215288] Data abort info:
[ 178.218175] ISV = 0, ISS = 0x00000004
[ 178.222019] CM = 0, WnR = 0
[ 178.224997] user pgtable: 4k pages, 48-bit VAs, pgd = 0000000023cb3f33
[ 178.231531] [0000810fb501f000] *pgd=0000000000000000
[ 178.236508] Internal error: Oops: 96000004 [#1] SMP
[...]
[ 178.311855] CPU: 73 PID: 2497 Comm: ping Tainted: G W 4.15.0-rc7+ #5
[ 178.319413] Hardware name: FOXCONN R2-1221R-A4/C2U4N_MB, BIOS G31FB18A 03/31/2017
[ 178.326887] pstate: 60400005 (nZCv daif +PAN -UAO)
[ 178.331685] pc : __netif_receive_skb_core+0x49c/0xac8
[ 178.336728] lr : __netif_receive_skb+0x28/0x78
[ 178.341161] sp : ffff00002344b750
[ 178.344465] x29: ffff00002344b750 x28: ffff810fbdfd0580
[ 178.349769] x27: 0000000000000000 x26: ffff000009378000
[...]
[ 178.418715] x1 : 0000000000000054 x0 : 0000000000000000
[ 178.424020] Process ping (pid: 2497, stack limit = 0x000000009f0a3ff4)
[ 178.430537] Call trace:
[ 178.432976] __netif_receive_skb_core+0x49c/0xac8
[ 178.437670] __netif_receive_skb+0x28/0x78
[ 178.441757] process_backlog+0x9c/0x160
[ 178.445584] net_rx_action+0x2f8/0x3f0
[...]
Reason is that sch_ingress and sch_clsact are doing mini_qdisc_pair_init()
which sets up miniq pointers to cpu_{b,q}stats from the underlying qdisc.
Problem is that this cannot work since they are actually set up right after
the qdisc ->init() callback in qdisc_create(), so first packet going into
sch_handle_ingress() tries to call mini_qdisc_bstats_cpu_update() and we
therefore panic.
In order to fix this, allocation of {b,q}stats needs to happen before we
call into ->init(). In net-next, there's already such option through commit
d59f5ffa59d8 ("net: sched: a dflt qdisc may be used with per cpu stats").
However, the bug needs to be fixed in net still for 4.15. Thus, include
these bits to reduce any merge churn and reuse the static_flags field to
set TCQ_F_CPUSTATS, and remove the allocation from qdisc_create() since
there is no other user left. Prashant Bhole ran into the same issue but
for net-next, thus adding him below as well as co-author. Same issue was
also reported by Sandipan Das when using bcc.
Fixes: 46209401f8f6 ("net: core: introduce mini_Qdisc and eliminate usage of tp->q for clsact fastpath")
Reference: https://lists.iovisor.org/pipermail/iovisor-dev/2018-January/001190.html
Reported-by: Sandipan Das <sandipan@linux.vnet.ibm.com>
Co-authored-by: Prashant Bhole <bhole_prashant_q7@lab.ntt.co.jp>
Co-authored-by: John Fastabend <john.fastabend@gmail.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Cc: Jiri Pirko <jiri@resnulli.us>
Signed-off-by: David S. Miller <davem@davemloft.net>
2018-01-16 05:12:09 +07:00
|
|
|
qdisc_free(sch);
|
2005-04-17 05:20:36 +07:00
|
|
|
err_out2:
|
|
|
|
module_put(ops->owner);
|
|
|
|
err_out:
|
|
|
|
*errp = err;
|
|
|
|
return NULL;
|
2009-09-10 08:11:23 +07:00
|
|
|
|
|
|
|
err_out4:
|
|
|
|
/*
|
|
|
|
* Any broken qdiscs that would require a ops->reset() here?
|
|
|
|
* The qdisc was never in action so it shouldn't be necessary.
|
|
|
|
*/
|
2011-01-20 10:48:19 +07:00
|
|
|
qdisc_put_stab(rtnl_dereference(sch->stab));
|
2009-09-10 08:11:23 +07:00
|
|
|
if (ops->destroy)
|
|
|
|
ops->destroy(sch);
|
|
|
|
goto err_out3;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2017-12-21 00:35:12 +07:00
|
|
|
static int qdisc_change(struct Qdisc *sch, struct nlattr **tca,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2011-01-20 10:48:19 +07:00
|
|
|
struct qdisc_size_table *ostab, *stab = NULL;
|
2008-07-20 14:08:47 +07:00
|
|
|
int err = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-20 14:08:47 +07:00
|
|
|
if (tca[TCA_OPTIONS]) {
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!sch->ops->change) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Change operation not supported by specified qdisc");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2018-01-17 17:46:52 +07:00
|
|
|
if (tca[TCA_INGRESS_BLOCK] || tca[TCA_EGRESS_BLOCK]) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Change of blocks is not supported");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2017-12-21 00:35:14 +07:00
|
|
|
err = sch->ops->change(sch, tca[TCA_OPTIONS], extack);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2008-07-20 14:08:47 +07:00
|
|
|
|
|
|
|
if (tca[TCA_STAB]) {
|
2017-12-21 00:35:12 +07:00
|
|
|
stab = qdisc_get_stab(tca[TCA_STAB], extack);
|
2008-07-20 14:08:47 +07:00
|
|
|
if (IS_ERR(stab))
|
|
|
|
return PTR_ERR(stab);
|
|
|
|
}
|
|
|
|
|
2011-01-20 10:48:19 +07:00
|
|
|
ostab = rtnl_dereference(sch->stab);
|
|
|
|
rcu_assign_pointer(sch->stab, stab);
|
|
|
|
qdisc_put_stab(ostab);
|
2008-07-20 14:08:47 +07:00
|
|
|
|
2009-09-10 08:11:23 +07:00
|
|
|
if (tca[TCA_RATE]) {
|
2008-11-26 12:13:31 +07:00
|
|
|
/* NB: ignores errors from replace_estimator
|
|
|
|
because change can't be undone. */
|
2009-09-10 08:11:23 +07:00
|
|
|
if (sch->flags & TCQ_F_MQROOT)
|
|
|
|
goto out;
|
2014-09-29 01:52:56 +07:00
|
|
|
gen_replace_estimator(&sch->bstats,
|
|
|
|
sch->cpu_bstats,
|
|
|
|
&sch->rate_est,
|
2016-06-06 23:37:16 +07:00
|
|
|
NULL,
|
|
|
|
qdisc_root_sleeping_running(sch),
|
2014-09-29 01:52:56 +07:00
|
|
|
tca[TCA_RATE]);
|
2009-09-10 08:11:23 +07:00
|
|
|
}
|
|
|
|
out:
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-20 02:26:56 +07:00
|
|
|
struct check_loop_arg {
|
|
|
|
struct qdisc_walker w;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct Qdisc *p;
|
|
|
|
int depth;
|
|
|
|
};
|
|
|
|
|
2016-09-18 19:45:33 +07:00
|
|
|
static int check_loop_fn(struct Qdisc *q, unsigned long cl,
|
|
|
|
struct qdisc_walker *w);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static int check_loop(struct Qdisc *q, struct Qdisc *p, int depth)
|
|
|
|
{
|
|
|
|
struct check_loop_arg arg;
|
|
|
|
|
|
|
|
if (q->ops->cl_ops == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
arg.w.stop = arg.w.skip = arg.w.count = 0;
|
|
|
|
arg.w.fn = check_loop_fn;
|
|
|
|
arg.depth = depth;
|
|
|
|
arg.p = p;
|
|
|
|
q->ops->cl_ops->walk(q, &arg.w);
|
|
|
|
return arg.w.stop ? -ELOOP : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w)
|
|
|
|
{
|
|
|
|
struct Qdisc *leaf;
|
2007-11-14 16:44:41 +07:00
|
|
|
const struct Qdisc_class_ops *cops = q->ops->cl_ops;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct check_loop_arg *arg = (struct check_loop_arg *)w;
|
|
|
|
|
|
|
|
leaf = cops->leaf(q, cl);
|
|
|
|
if (leaf) {
|
|
|
|
if (leaf == arg->p || arg->depth > 7)
|
|
|
|
return -ELOOP;
|
|
|
|
return check_loop(leaf, arg->p, arg->depth + 1);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-10-04 05:05:36 +07:00
|
|
|
const struct nla_policy rtm_tca_policy[TCA_MAX + 1] = {
|
2019-10-08 03:26:28 +07:00
|
|
|
[TCA_KIND] = { .type = NLA_STRING },
|
2018-10-04 05:05:36 +07:00
|
|
|
[TCA_RATE] = { .type = NLA_BINARY,
|
|
|
|
.len = sizeof(struct tc_estimator) },
|
|
|
|
[TCA_STAB] = { .type = NLA_NESTED },
|
|
|
|
[TCA_DUMP_INVISIBLE] = { .type = NLA_FLAG },
|
|
|
|
[TCA_CHAIN] = { .type = NLA_U32 },
|
|
|
|
[TCA_INGRESS_BLOCK] = { .type = NLA_U32 },
|
|
|
|
[TCA_EGRESS_BLOCK] = { .type = NLA_U32 },
|
|
|
|
};
|
|
|
|
|
2018-10-11 03:00:58 +07:00
|
|
|
/*
|
|
|
|
* Delete/get qdisc.
|
|
|
|
*/
|
|
|
|
|
2017-04-16 23:48:24 +07:00
|
|
|
static int tc_get_qdisc(struct sk_buff *skb, struct nlmsghdr *n,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-03-26 00:26:21 +07:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2012-06-27 11:50:05 +07:00
|
|
|
struct tcmsg *tcm = nlmsg_data(n);
|
2008-01-23 13:11:17 +07:00
|
|
|
struct nlattr *tca[TCA_MAX + 1];
|
2005-04-17 05:20:36 +07:00
|
|
|
struct net_device *dev;
|
2013-03-26 00:36:33 +07:00
|
|
|
u32 clid;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct Qdisc *q = NULL;
|
|
|
|
struct Qdisc *p = NULL;
|
|
|
|
int err;
|
|
|
|
|
2014-04-30 22:25:43 +07:00
|
|
|
if ((n->nlmsg_type != RTM_GETQDISC) &&
|
2014-05-13 00:19:14 +07:00
|
|
|
!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
|
2012-11-16 10:03:00 +07:00
|
|
|
return -EPERM;
|
|
|
|
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 19:07:28 +07:00
|
|
|
err = nlmsg_parse_deprecated(n, sizeof(*tcm), tca, TCA_MAX,
|
|
|
|
rtm_tca_policy, extack);
|
2008-01-23 13:11:17 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2013-03-26 00:36:33 +07:00
|
|
|
dev = __dev_get_by_index(net, tcm->tcm_ifindex);
|
|
|
|
if (!dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
clid = tcm->tcm_parent;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (clid) {
|
|
|
|
if (clid != TC_H_ROOT) {
|
|
|
|
if (TC_H_MAJ(clid) != TC_H_MAJ(TC_H_INGRESS)) {
|
2011-01-20 02:26:56 +07:00
|
|
|
p = qdisc_lookup(dev, TC_H_MAJ(clid));
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!p) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Failed to find qdisc with specified classid");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
q = qdisc_leaf(p, clid);
|
2011-01-20 02:26:56 +07:00
|
|
|
} else if (dev_ingress_queue(dev)) {
|
|
|
|
q = dev_ingress_queue(dev)->qdisc_sleeping;
|
2007-02-09 21:25:16 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2009-09-04 13:41:18 +07:00
|
|
|
q = dev->qdisc;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!q) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Cannot find specified qdisc on specified device");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-12-21 00:35:12 +07:00
|
|
|
if (tcm->tcm_handle && q->handle != tcm->tcm_handle) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid handle");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2011-01-20 02:26:56 +07:00
|
|
|
q = qdisc_lookup(dev, tcm->tcm_handle);
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!q) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Failed to find qdisc with specified handle");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2017-12-21 00:35:12 +07:00
|
|
|
if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid qdisc name");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (n->nlmsg_type == RTM_DELQDISC) {
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!clid) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Classid cannot be zero");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
|
|
|
if (q->handle == 0) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Cannot delete qdisc with handle of zero");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
|
|
|
err = qdisc_graft(dev, p, skb, n, clid, NULL, q, extack);
|
2011-01-20 02:26:56 +07:00
|
|
|
if (err != 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
return err;
|
|
|
|
} else {
|
2010-03-19 22:40:13 +07:00
|
|
|
qdisc_notify(net, skb, n, clid, NULL, q);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-01-20 02:26:56 +07:00
|
|
|
* Create/change qdisc.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
2017-04-16 23:48:24 +07:00
|
|
|
static int tc_modify_qdisc(struct sk_buff *skb, struct nlmsghdr *n,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-03-26 00:26:21 +07:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
struct tcmsg *tcm;
|
2008-01-23 13:11:17 +07:00
|
|
|
struct nlattr *tca[TCA_MAX + 1];
|
2005-04-17 05:20:36 +07:00
|
|
|
struct net_device *dev;
|
|
|
|
u32 clid;
|
|
|
|
struct Qdisc *q, *p;
|
|
|
|
int err;
|
|
|
|
|
2014-05-13 00:19:14 +07:00
|
|
|
if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
|
2012-11-16 10:03:00 +07:00
|
|
|
return -EPERM;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
replay:
|
|
|
|
/* Reinit, just in case something touches this. */
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 19:07:28 +07:00
|
|
|
err = nlmsg_parse_deprecated(n, sizeof(*tcm), tca, TCA_MAX,
|
|
|
|
rtm_tca_policy, extack);
|
2013-03-26 00:36:33 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2012-06-27 11:50:05 +07:00
|
|
|
tcm = nlmsg_data(n);
|
2005-04-17 05:20:36 +07:00
|
|
|
clid = tcm->tcm_parent;
|
|
|
|
q = p = NULL;
|
|
|
|
|
2011-01-20 02:26:56 +07:00
|
|
|
dev = __dev_get_by_index(net, tcm->tcm_ifindex);
|
|
|
|
if (!dev)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2008-01-23 13:11:17 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (clid) {
|
|
|
|
if (clid != TC_H_ROOT) {
|
|
|
|
if (clid != TC_H_INGRESS) {
|
2011-01-20 02:26:56 +07:00
|
|
|
p = qdisc_lookup(dev, TC_H_MAJ(clid));
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!p) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Failed to find specified qdisc");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
q = qdisc_leaf(p, clid);
|
2011-01-20 02:26:56 +07:00
|
|
|
} else if (dev_ingress_queue_create(dev)) {
|
|
|
|
q = dev_ingress_queue(dev)->qdisc_sleeping;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
} else {
|
2009-09-04 13:41:18 +07:00
|
|
|
q = dev->qdisc;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* It may be default qdisc, ignore it */
|
|
|
|
if (q && q->handle == 0)
|
|
|
|
q = NULL;
|
|
|
|
|
|
|
|
if (!q || !tcm->tcm_handle || q->handle != tcm->tcm_handle) {
|
|
|
|
if (tcm->tcm_handle) {
|
2017-12-21 00:35:12 +07:00
|
|
|
if (q && !(n->nlmsg_flags & NLM_F_REPLACE)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "NLM_F_REPLACE needed to override");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EEXIST;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
|
|
|
if (TC_H_MIN(tcm->tcm_handle)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid minor handle");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2011-01-20 02:26:56 +07:00
|
|
|
q = qdisc_lookup(dev, tcm->tcm_handle);
|
2017-12-28 22:52:10 +07:00
|
|
|
if (!q)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto create_n_graft;
|
2017-12-21 00:35:12 +07:00
|
|
|
if (n->nlmsg_flags & NLM_F_EXCL) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Exclusivity flag on, cannot override");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EEXIST;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2017-12-05 06:39:59 +07:00
|
|
|
if (tca[TCA_KIND] &&
|
2017-12-21 00:35:12 +07:00
|
|
|
nla_strcmp(tca[TCA_KIND], q->ops->id)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid qdisc name");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
if (q == p ||
|
2017-12-21 00:35:12 +07:00
|
|
|
(p && check_loop(q, p, 0))) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Qdisc parent/child loop detected");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ELOOP;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2017-08-25 11:12:28 +07:00
|
|
|
qdisc_refcount_inc(q);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto graft;
|
|
|
|
} else {
|
2011-01-20 02:26:56 +07:00
|
|
|
if (!q)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto create_n_graft;
|
|
|
|
|
|
|
|
/* This magic test requires explanation.
|
|
|
|
*
|
|
|
|
* We know, that some child q is already
|
|
|
|
* attached to this parent and have choice:
|
|
|
|
* either to change it or to create/graft new one.
|
|
|
|
*
|
|
|
|
* 1. We are allowed to create/graft only
|
|
|
|
* if CREATE and REPLACE flags are set.
|
|
|
|
*
|
|
|
|
* 2. If EXCL is set, requestor wanted to say,
|
|
|
|
* that qdisc tcm_handle is not expected
|
|
|
|
* to exist, so that we choose create/graft too.
|
|
|
|
*
|
|
|
|
* 3. The last case is when no flags are set.
|
|
|
|
* Alas, it is sort of hole in API, we
|
|
|
|
* cannot decide what to do unambiguously.
|
|
|
|
* For now we select create/graft, if
|
|
|
|
* user gave KIND, which does not match existing.
|
|
|
|
*/
|
2011-01-20 02:26:56 +07:00
|
|
|
if ((n->nlmsg_flags & NLM_F_CREATE) &&
|
|
|
|
(n->nlmsg_flags & NLM_F_REPLACE) &&
|
|
|
|
((n->nlmsg_flags & NLM_F_EXCL) ||
|
2008-01-23 13:11:17 +07:00
|
|
|
(tca[TCA_KIND] &&
|
|
|
|
nla_strcmp(tca[TCA_KIND], q->ops->id))))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto create_n_graft;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!tcm->tcm_handle) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Handle cannot be zero");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
q = qdisc_lookup(dev, tcm->tcm_handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Change qdisc parameters */
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!q) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Specified qdisc not found");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
|
|
|
if (n->nlmsg_flags & NLM_F_EXCL) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Exclusivity flag on, cannot modify");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EEXIST;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
|
|
|
if (tca[TCA_KIND] && nla_strcmp(tca[TCA_KIND], q->ops->id)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid qdisc name");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
|
|
|
err = qdisc_change(q, tca, extack);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (err == 0)
|
2010-03-19 22:40:13 +07:00
|
|
|
qdisc_notify(net, skb, n, clid, NULL, q);
|
2005-04-17 05:20:36 +07:00
|
|
|
return err;
|
|
|
|
|
|
|
|
create_n_graft:
|
2017-12-21 00:35:12 +07:00
|
|
|
if (!(n->nlmsg_flags & NLM_F_CREATE)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Qdisc not found. To create specify NLM_F_CREATE flag");
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2010-10-02 13:11:55 +07:00
|
|
|
if (clid == TC_H_INGRESS) {
|
2017-12-21 00:35:12 +07:00
|
|
|
if (dev_ingress_queue(dev)) {
|
2010-10-02 13:11:55 +07:00
|
|
|
q = qdisc_create(dev, dev_ingress_queue(dev), p,
|
|
|
|
tcm->tcm_parent, tcm->tcm_parent,
|
2017-12-21 00:35:12 +07:00
|
|
|
tca, &err, extack);
|
|
|
|
} else {
|
|
|
|
NL_SET_ERR_MSG(extack, "Cannot find ingress queue for specified device");
|
2010-10-02 13:11:55 +07:00
|
|
|
err = -ENOENT;
|
2017-12-21 00:35:12 +07:00
|
|
|
}
|
2010-10-02 13:11:55 +07:00
|
|
|
} else {
|
2009-09-15 16:53:07 +07:00
|
|
|
struct netdev_queue *dev_queue;
|
2009-09-06 15:58:51 +07:00
|
|
|
|
|
|
|
if (p && p->ops->cl_ops && p->ops->cl_ops->select_queue)
|
2009-09-15 16:53:07 +07:00
|
|
|
dev_queue = p->ops->cl_ops->select_queue(p, tcm);
|
|
|
|
else if (p)
|
|
|
|
dev_queue = p->dev_queue;
|
|
|
|
else
|
|
|
|
dev_queue = netdev_get_tx_queue(dev, 0);
|
2009-09-06 15:58:51 +07:00
|
|
|
|
2009-09-15 16:53:07 +07:00
|
|
|
q = qdisc_create(dev, dev_queue, p,
|
2008-07-09 06:55:56 +07:00
|
|
|
tcm->tcm_parent, tcm->tcm_handle,
|
2017-12-21 00:35:12 +07:00
|
|
|
tca, &err, extack);
|
2009-09-06 15:58:51 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
if (q == NULL) {
|
|
|
|
if (err == -EAGAIN)
|
|
|
|
goto replay;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
graft:
|
2017-12-21 00:35:12 +07:00
|
|
|
err = qdisc_graft(dev, p, skb, n, clid, q, NULL, extack);
|
2008-08-19 12:30:01 +07:00
|
|
|
if (err) {
|
|
|
|
if (q)
|
2018-09-24 23:22:50 +07:00
|
|
|
qdisc_put(q);
|
2008-08-19 12:30:01 +07:00
|
|
|
return err;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-08-19 12:30:01 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-19 12:50:15 +07:00
|
|
|
static int tc_dump_qdisc_root(struct Qdisc *root, struct sk_buff *skb,
|
|
|
|
struct netlink_callback *cb,
|
2017-03-08 22:03:32 +07:00
|
|
|
int *q_idx_p, int s_q_idx, bool recur,
|
|
|
|
bool dump_invisible)
|
2008-07-19 12:50:15 +07:00
|
|
|
{
|
|
|
|
int ret = 0, q_idx = *q_idx_p;
|
|
|
|
struct Qdisc *q;
|
2016-08-10 16:05:15 +07:00
|
|
|
int b;
|
2008-07-19 12:50:15 +07:00
|
|
|
|
|
|
|
if (!root)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
q = root;
|
|
|
|
if (q_idx < s_q_idx) {
|
|
|
|
q_idx++;
|
|
|
|
} else {
|
2017-03-08 22:03:32 +07:00
|
|
|
if (!tc_qdisc_dump_ignore(q, dump_invisible) &&
|
2012-09-08 03:12:54 +07:00
|
|
|
tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).portid,
|
2016-09-18 19:45:33 +07:00
|
|
|
cb->nlh->nlmsg_seq, NLM_F_MULTI,
|
|
|
|
RTM_NEWQDISC) <= 0)
|
2008-07-19 12:50:15 +07:00
|
|
|
goto done;
|
|
|
|
q_idx++;
|
|
|
|
}
|
2016-08-17 04:52:58 +07:00
|
|
|
|
2016-08-17 04:53:46 +07:00
|
|
|
/* If dumping singletons, there is no qdisc_dev(root) and the singleton
|
|
|
|
* itself has already been dumped.
|
|
|
|
*
|
|
|
|
* If we've already dumped the top-level (ingress) qdisc above and the global
|
|
|
|
* qdisc hashtable, we don't want to hit it again
|
|
|
|
*/
|
|
|
|
if (!qdisc_dev(root) || !recur)
|
2016-08-17 04:52:58 +07:00
|
|
|
goto out;
|
|
|
|
|
2016-08-10 16:05:15 +07:00
|
|
|
hash_for_each(qdisc_dev(root)->qdisc_hash, b, q, hash) {
|
2008-07-19 12:50:15 +07:00
|
|
|
if (q_idx < s_q_idx) {
|
|
|
|
q_idx++;
|
|
|
|
continue;
|
|
|
|
}
|
2017-03-08 22:03:32 +07:00
|
|
|
if (!tc_qdisc_dump_ignore(q, dump_invisible) &&
|
2012-09-08 03:12:54 +07:00
|
|
|
tc_fill_qdisc(skb, q, q->parent, NETLINK_CB(cb->skb).portid,
|
2016-09-18 19:45:33 +07:00
|
|
|
cb->nlh->nlmsg_seq, NLM_F_MULTI,
|
|
|
|
RTM_NEWQDISC) <= 0)
|
2008-07-19 12:50:15 +07:00
|
|
|
goto done;
|
|
|
|
q_idx++;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
*q_idx_p = q_idx;
|
|
|
|
return ret;
|
|
|
|
done:
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static int tc_dump_qdisc(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
2008-03-26 00:26:21 +07:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2005-04-17 05:20:36 +07:00
|
|
|
int idx, q_idx;
|
|
|
|
int s_idx, s_q_idx;
|
|
|
|
struct net_device *dev;
|
2017-03-08 22:03:32 +07:00
|
|
|
const struct nlmsghdr *nlh = cb->nlh;
|
|
|
|
struct nlattr *tca[TCA_MAX + 1];
|
|
|
|
int err;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
s_idx = cb->args[0];
|
|
|
|
s_q_idx = q_idx = cb->args[1];
|
2009-11-10 14:54:49 +07:00
|
|
|
|
2007-05-04 05:13:45 +07:00
|
|
|
idx = 0;
|
2014-03-11 07:11:42 +07:00
|
|
|
ASSERT_RTNL();
|
2017-03-08 22:03:32 +07:00
|
|
|
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 19:07:28 +07:00
|
|
|
err = nlmsg_parse_deprecated(nlh, sizeof(struct tcmsg), tca, TCA_MAX,
|
|
|
|
rtm_tca_policy, cb->extack);
|
2017-03-08 22:03:32 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2014-03-11 07:11:42 +07:00
|
|
|
for_each_netdev(net, dev) {
|
2008-07-19 12:50:15 +07:00
|
|
|
struct netdev_queue *dev_queue;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (idx < s_idx)
|
2007-05-04 05:13:45 +07:00
|
|
|
goto cont;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (idx > s_idx)
|
|
|
|
s_q_idx = 0;
|
|
|
|
q_idx = 0;
|
2008-07-19 12:50:15 +07:00
|
|
|
|
2016-09-18 19:45:33 +07:00
|
|
|
if (tc_dump_qdisc_root(dev->qdisc, skb, cb, &q_idx, s_q_idx,
|
2017-03-08 22:03:32 +07:00
|
|
|
true, tca[TCA_DUMP_INVISIBLE]) < 0)
|
2008-07-19 12:50:15 +07:00
|
|
|
goto done;
|
|
|
|
|
2010-10-02 13:11:55 +07:00
|
|
|
dev_queue = dev_ingress_queue(dev);
|
|
|
|
if (dev_queue &&
|
|
|
|
tc_dump_qdisc_root(dev_queue->qdisc_sleeping, skb, cb,
|
2017-03-08 22:03:32 +07:00
|
|
|
&q_idx, s_q_idx, false,
|
|
|
|
tca[TCA_DUMP_INVISIBLE]) < 0)
|
2008-07-19 12:50:15 +07:00
|
|
|
goto done;
|
|
|
|
|
2007-05-04 05:13:45 +07:00
|
|
|
cont:
|
|
|
|
idx++;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
cb->args[0] = idx;
|
|
|
|
cb->args[1] = q_idx;
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************
|
|
|
|
* Traffic classes manipulation. *
|
|
|
|
************************************************/
|
|
|
|
|
2017-08-25 06:51:27 +07:00
|
|
|
static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,
|
|
|
|
unsigned long cl,
|
|
|
|
u32 portid, u32 seq, u16 flags, int event)
|
|
|
|
{
|
|
|
|
struct tcmsg *tcm;
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
unsigned char *b = skb_tail_pointer(skb);
|
|
|
|
struct gnet_dump d;
|
|
|
|
const struct Qdisc_class_ops *cl_ops = q->ops->cl_ops;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-08-25 06:51:27 +07:00
|
|
|
cond_resched();
|
|
|
|
nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);
|
|
|
|
if (!nlh)
|
|
|
|
goto out_nlmsg_trim;
|
|
|
|
tcm = nlmsg_data(nlh);
|
|
|
|
tcm->tcm_family = AF_UNSPEC;
|
|
|
|
tcm->tcm__pad1 = 0;
|
|
|
|
tcm->tcm__pad2 = 0;
|
|
|
|
tcm->tcm_ifindex = qdisc_dev(q)->ifindex;
|
|
|
|
tcm->tcm_parent = q->handle;
|
|
|
|
tcm->tcm_handle = q->handle;
|
|
|
|
tcm->tcm_info = 0;
|
|
|
|
if (nla_put_string(skb, TCA_KIND, q->ops->id))
|
|
|
|
goto nla_put_failure;
|
|
|
|
if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,
|
|
|
|
NULL, &d, TCA_PAD) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
if (gnet_stats_finish_copy(&d) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
nlh->nlmsg_len = skb_tail_pointer(skb) - b;
|
|
|
|
return skb->len;
|
|
|
|
|
|
|
|
out_nlmsg_trim:
|
|
|
|
nla_put_failure:
|
|
|
|
nlmsg_trim(skb, b);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tclass_notify(struct net *net, struct sk_buff *oskb,
|
|
|
|
struct nlmsghdr *n, struct Qdisc *q,
|
|
|
|
unsigned long cl, int event)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
|
2019-03-11 17:15:54 +07:00
|
|
|
int err = 0;
|
2017-08-25 06:51:27 +07:00
|
|
|
|
|
|
|
skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
|
|
|
|
if (!skb)
|
|
|
|
return -ENOBUFS;
|
|
|
|
|
|
|
|
if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0, event) < 0) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2019-03-11 17:15:54 +07:00
|
|
|
err = rtnetlink_send(skb, net, portid, RTNLGRP_TC,
|
|
|
|
n->nlmsg_flags & NLM_F_ECHO);
|
|
|
|
if (err > 0)
|
|
|
|
err = 0;
|
|
|
|
return err;
|
2017-08-25 06:51:27 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-08-25 06:51:28 +07:00
|
|
|
static int tclass_del_notify(struct net *net,
|
|
|
|
const struct Qdisc_class_ops *cops,
|
|
|
|
struct sk_buff *oskb, struct nlmsghdr *n,
|
|
|
|
struct Qdisc *q, unsigned long cl)
|
|
|
|
{
|
|
|
|
u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (!cops->delete)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
|
|
|
|
if (!skb)
|
|
|
|
return -ENOBUFS;
|
|
|
|
|
|
|
|
if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0,
|
|
|
|
RTM_DELTCLASS) < 0) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = cops->delete(q, cl);
|
|
|
|
if (err) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2019-03-11 17:15:54 +07:00
|
|
|
err = rtnetlink_send(skb, net, portid, RTNLGRP_TC,
|
|
|
|
n->nlmsg_flags & NLM_F_ECHO);
|
|
|
|
if (err > 0)
|
|
|
|
err = 0;
|
|
|
|
return err;
|
2017-08-25 06:51:28 +07:00
|
|
|
}
|
|
|
|
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
#ifdef CONFIG_NET_CLS
|
|
|
|
|
|
|
|
struct tcf_bind_args {
|
|
|
|
struct tcf_walker w;
|
2020-01-24 07:26:18 +07:00
|
|
|
unsigned long base;
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
unsigned long cl;
|
2020-01-24 07:26:18 +07:00
|
|
|
u32 classid;
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int tcf_node_bind(struct tcf_proto *tp, void *n, struct tcf_walker *arg)
|
|
|
|
{
|
|
|
|
struct tcf_bind_args *a = (void *)arg;
|
|
|
|
|
|
|
|
if (tp->ops->bind_class) {
|
2017-10-13 19:01:04 +07:00
|
|
|
struct Qdisc *q = tcf_block_q(tp->chain->block);
|
|
|
|
|
|
|
|
sch_tree_lock(q);
|
2020-01-24 07:26:18 +07:00
|
|
|
tp->ops->bind_class(n, a->classid, a->cl, q, a->base);
|
2017-10-13 19:01:04 +07:00
|
|
|
sch_tree_unlock(q);
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-24 08:27:08 +07:00
|
|
|
struct tc_bind_class_args {
|
|
|
|
struct qdisc_walker w;
|
|
|
|
unsigned long new_cl;
|
|
|
|
u32 portid;
|
|
|
|
u32 clid;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int tc_bind_class_walker(struct Qdisc *q, unsigned long cl,
|
|
|
|
struct qdisc_walker *w)
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
{
|
2020-01-24 08:27:08 +07:00
|
|
|
struct tc_bind_class_args *a = (struct tc_bind_class_args *)w;
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
const struct Qdisc_class_ops *cops = q->ops->cl_ops;
|
|
|
|
struct tcf_block *block;
|
|
|
|
struct tcf_chain *chain;
|
|
|
|
|
2017-12-21 00:35:16 +07:00
|
|
|
block = cops->tcf_block(q, cl, NULL);
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
if (!block)
|
2020-01-24 08:27:08 +07:00
|
|
|
return 0;
|
2019-02-11 15:55:36 +07:00
|
|
|
for (chain = tcf_get_next_chain(block, NULL);
|
|
|
|
chain;
|
|
|
|
chain = tcf_get_next_chain(block, chain)) {
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
struct tcf_proto *tp;
|
|
|
|
|
2019-02-11 15:55:45 +07:00
|
|
|
for (tp = tcf_get_next_proto(chain, NULL, true);
|
|
|
|
tp; tp = tcf_get_next_proto(chain, tp, true)) {
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
struct tcf_bind_args arg = {};
|
|
|
|
|
|
|
|
arg.w.fn = tcf_node_bind;
|
2020-01-24 08:27:08 +07:00
|
|
|
arg.classid = a->clid;
|
2020-01-24 07:26:18 +07:00
|
|
|
arg.base = cl;
|
2020-01-24 08:27:08 +07:00
|
|
|
arg.cl = a->new_cl;
|
2019-02-11 15:55:45 +07:00
|
|
|
tp->ops->walk(tp, &arg.w, true);
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
}
|
|
|
|
}
|
2020-01-24 08:27:08 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tc_bind_tclass(struct Qdisc *q, u32 portid, u32 clid,
|
|
|
|
unsigned long new_cl)
|
|
|
|
{
|
|
|
|
const struct Qdisc_class_ops *cops = q->ops->cl_ops;
|
|
|
|
struct tc_bind_class_args args = {};
|
|
|
|
|
|
|
|
if (!cops->tcf_block)
|
|
|
|
return;
|
|
|
|
args.portid = portid;
|
|
|
|
args.clid = clid;
|
|
|
|
args.new_cl = new_cl;
|
|
|
|
args.w.fn = tc_bind_class_walker;
|
|
|
|
q->ops->cl_ops->walk(q, &args.w);
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
static void tc_bind_tclass(struct Qdisc *q, u32 portid, u32 clid,
|
|
|
|
unsigned long new_cl)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2017-04-16 23:48:24 +07:00
|
|
|
static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-03-26 00:26:21 +07:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2012-06-27 11:50:05 +07:00
|
|
|
struct tcmsg *tcm = nlmsg_data(n);
|
2008-01-23 13:11:17 +07:00
|
|
|
struct nlattr *tca[TCA_MAX + 1];
|
2005-04-17 05:20:36 +07:00
|
|
|
struct net_device *dev;
|
|
|
|
struct Qdisc *q = NULL;
|
2007-11-14 16:44:41 +07:00
|
|
|
const struct Qdisc_class_ops *cops;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long cl = 0;
|
|
|
|
unsigned long new_cl;
|
2013-03-26 00:36:33 +07:00
|
|
|
u32 portid;
|
|
|
|
u32 clid;
|
|
|
|
u32 qid;
|
2005-04-17 05:20:36 +07:00
|
|
|
int err;
|
|
|
|
|
2014-04-30 22:25:43 +07:00
|
|
|
if ((n->nlmsg_type != RTM_GETTCLASS) &&
|
2014-05-13 00:19:14 +07:00
|
|
|
!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
|
2012-11-16 10:03:00 +07:00
|
|
|
return -EPERM;
|
|
|
|
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 19:07:28 +07:00
|
|
|
err = nlmsg_parse_deprecated(n, sizeof(*tcm), tca, TCA_MAX,
|
|
|
|
rtm_tca_policy, extack);
|
2008-01-23 13:11:17 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2013-03-26 00:36:33 +07:00
|
|
|
dev = __dev_get_by_index(net, tcm->tcm_ifindex);
|
|
|
|
if (!dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
parent == TC_H_UNSPEC - unspecified parent.
|
|
|
|
parent == TC_H_ROOT - class is root, which has no parent.
|
|
|
|
parent == X:0 - parent is root class.
|
|
|
|
parent == X:Y - parent is a node in hierarchy.
|
|
|
|
parent == 0:Y - parent is X:Y, where X:0 is qdisc.
|
|
|
|
|
|
|
|
handle == 0:0 - generate handle from kernel pool.
|
|
|
|
handle == 0:Y - class is X:Y, where X:0 is qdisc.
|
|
|
|
handle == X:Y - clear.
|
|
|
|
handle == X:0 - root class.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Step 1. Determine qdisc handle X:0 */
|
|
|
|
|
2013-03-26 00:36:33 +07:00
|
|
|
portid = tcm->tcm_parent;
|
|
|
|
clid = tcm->tcm_handle;
|
|
|
|
qid = TC_H_MAJ(clid);
|
|
|
|
|
2012-09-08 03:12:54 +07:00
|
|
|
if (portid != TC_H_ROOT) {
|
|
|
|
u32 qid1 = TC_H_MAJ(portid);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (qid && qid1) {
|
|
|
|
/* If both majors are known, they must be identical. */
|
|
|
|
if (qid != qid1)
|
|
|
|
return -EINVAL;
|
|
|
|
} else if (qid1) {
|
|
|
|
qid = qid1;
|
|
|
|
} else if (qid == 0)
|
2009-09-04 13:41:18 +07:00
|
|
|
qid = dev->qdisc->handle;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Now qid is genuine qdisc handle consistent
|
2011-01-20 02:26:56 +07:00
|
|
|
* both with parent and child.
|
|
|
|
*
|
2012-09-08 03:12:54 +07:00
|
|
|
* TC_H_MAJ(portid) still may be unspecified, complete it now.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2012-09-08 03:12:54 +07:00
|
|
|
if (portid)
|
|
|
|
portid = TC_H_MAKE(qid, portid);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
|
|
|
if (qid == 0)
|
2009-09-04 13:41:18 +07:00
|
|
|
qid = dev->qdisc->handle;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* OK. Locate qdisc */
|
2011-01-20 02:26:56 +07:00
|
|
|
q = qdisc_lookup(dev, qid);
|
|
|
|
if (!q)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
/* An check that it supports classes */
|
|
|
|
cops = q->ops->cl_ops;
|
|
|
|
if (cops == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Now try to get class */
|
|
|
|
if (clid == 0) {
|
2012-09-08 03:12:54 +07:00
|
|
|
if (portid == TC_H_ROOT)
|
2005-04-17 05:20:36 +07:00
|
|
|
clid = qid;
|
|
|
|
} else
|
|
|
|
clid = TC_H_MAKE(qid, clid);
|
|
|
|
|
|
|
|
if (clid)
|
net_sched: remove tc class reference counting
For TC classes, their ->get() and ->put() are always paired, and the
reference counting is completely useless, because:
1) For class modification and dumping paths, we already hold RTNL lock,
so all of these ->get(),->change(),->put() are atomic.
2) For filter bindiing/unbinding, we use other reference counter than
this one, and they should have RTNL lock too.
3) For ->qlen_notify(), it is special because it is called on ->enqueue()
path, but we already hold qdisc tree lock there, and we hold this
tree lock when graft or delete the class too, so it should not be gone
or changed until we release the tree lock.
Therefore, this patch removes ->get() and ->put(), but:
1) Adds a new ->find() to find the pointer to a class by classid, no
refcnt.
2) Move the original class destroy upon the last refcnt into ->delete(),
right after releasing tree lock. This is fine because the class is
already removed from hash when holding the lock.
For those who also use ->put() as ->unbind(), just rename them to reflect
this change.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Acked-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-25 06:51:29 +07:00
|
|
|
cl = cops->find(q, clid);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (cl == 0) {
|
|
|
|
err = -ENOENT;
|
2011-01-20 02:26:56 +07:00
|
|
|
if (n->nlmsg_type != RTM_NEWTCLASS ||
|
|
|
|
!(n->nlmsg_flags & NLM_F_CREATE))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
switch (n->nlmsg_type) {
|
2007-02-09 21:25:16 +07:00
|
|
|
case RTM_NEWTCLASS:
|
2005-04-17 05:20:36 +07:00
|
|
|
err = -EEXIST;
|
2011-01-20 02:26:56 +07:00
|
|
|
if (n->nlmsg_flags & NLM_F_EXCL)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case RTM_DELTCLASS:
|
2017-08-25 06:51:28 +07:00
|
|
|
err = tclass_del_notify(net, cops, skb, n, q, cl);
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
/* Unbind the class with flilters with 0 */
|
|
|
|
tc_bind_tclass(q, portid, clid, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
case RTM_GETTCLASS:
|
2010-03-19 22:40:13 +07:00
|
|
|
err = tclass_notify(net, skb, n, q, cl, RTM_NEWTCLASS);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
default:
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-17 17:46:52 +07:00
|
|
|
if (tca[TCA_INGRESS_BLOCK] || tca[TCA_EGRESS_BLOCK]) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Shared blocks are not supported for classes");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
new_cl = cl;
|
2009-09-04 13:41:16 +07:00
|
|
|
err = -EOPNOTSUPP;
|
|
|
|
if (cops->change)
|
2017-12-21 00:35:15 +07:00
|
|
|
err = cops->change(q, clid, portid, tca, &new_cl, extack);
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
if (err == 0) {
|
2010-03-19 22:40:13 +07:00
|
|
|
tclass_notify(net, skb, n, q, new_cl, RTM_NEWTCLASS);
|
net_sched: add reverse binding for tc class
TC filters when used as classifiers are bound to TC classes.
However, there is a hidden difference when adding them in different
orders:
1. If we add tc classes before its filters, everything is fine.
Logically, the classes exist before we specify their ID's in
filters, it is easy to bind them together, just as in the current
code base.
2. If we add tc filters before the tc classes they bind, we have to
do dynamic lookup in fast path. What's worse, this happens all
the time not just once, because on fast path tcf_result is passed
on stack, there is no way to propagate back to the one in tc filters.
This hidden difference hurts performance silently if we have many tc
classes in hierarchy.
This patch intends to close this gap by doing the reverse binding when
we create a new class, in this case we can actually search all the
filters in its parent, match and fixup by classid. And because
tcf_result is specific to each type of tc filter, we have to introduce
a new ops for each filter to tell how to bind the class.
Note, we still can NOT totally get rid of those class lookup in
->enqueue() because cgroup and flow filters have no way to determine
the classid at setup time, they still have to go through dynamic lookup.
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-31 04:30:36 +07:00
|
|
|
/* We just create a new class, need to do reverse binding. */
|
|
|
|
if (cl != new_cl)
|
|
|
|
tc_bind_tclass(q, portid, clid, new_cl);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-01-20 02:26:56 +07:00
|
|
|
struct qdisc_dump_args {
|
|
|
|
struct qdisc_walker w;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct netlink_callback *cb;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2016-09-18 19:45:33 +07:00
|
|
|
static int qdisc_class_dump(struct Qdisc *q, unsigned long cl,
|
|
|
|
struct qdisc_walker *arg)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct qdisc_dump_args *a = (struct qdisc_dump_args *)arg;
|
|
|
|
|
2012-09-08 03:12:54 +07:00
|
|
|
return tc_fill_tclass(a->skb, q, cl, NETLINK_CB(a->cb->skb).portid,
|
2016-09-18 19:45:33 +07:00
|
|
|
a->cb->nlh->nlmsg_seq, NLM_F_MULTI,
|
|
|
|
RTM_NEWTCLASS);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-07-19 12:50:15 +07:00
|
|
|
static int tc_dump_tclass_qdisc(struct Qdisc *q, struct sk_buff *skb,
|
|
|
|
struct tcmsg *tcm, struct netlink_callback *cb,
|
|
|
|
int *t_p, int s_t)
|
|
|
|
{
|
|
|
|
struct qdisc_dump_args arg;
|
|
|
|
|
2017-03-08 22:03:32 +07:00
|
|
|
if (tc_qdisc_dump_ignore(q, false) ||
|
2008-07-19 12:50:15 +07:00
|
|
|
*t_p < s_t || !q->ops->cl_ops ||
|
|
|
|
(tcm->tcm_parent &&
|
|
|
|
TC_H_MAJ(tcm->tcm_parent) != q->handle)) {
|
|
|
|
(*t_p)++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (*t_p > s_t)
|
|
|
|
memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
|
|
|
|
arg.w.fn = qdisc_class_dump;
|
|
|
|
arg.skb = skb;
|
|
|
|
arg.cb = cb;
|
|
|
|
arg.w.stop = 0;
|
|
|
|
arg.w.skip = cb->args[1];
|
|
|
|
arg.w.count = 0;
|
|
|
|
q->ops->cl_ops->walk(q, &arg.w);
|
|
|
|
cb->args[1] = arg.w.count;
|
|
|
|
if (arg.w.stop)
|
|
|
|
return -1;
|
|
|
|
(*t_p)++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tc_dump_tclass_root(struct Qdisc *root, struct sk_buff *skb,
|
|
|
|
struct tcmsg *tcm, struct netlink_callback *cb,
|
|
|
|
int *t_p, int s_t)
|
|
|
|
{
|
|
|
|
struct Qdisc *q;
|
2016-08-10 16:05:15 +07:00
|
|
|
int b;
|
2008-07-19 12:50:15 +07:00
|
|
|
|
|
|
|
if (!root)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (tc_dump_tclass_qdisc(root, skb, tcm, cb, t_p, s_t) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2016-08-17 04:52:58 +07:00
|
|
|
if (!qdisc_dev(root))
|
|
|
|
return 0;
|
|
|
|
|
2017-05-11 11:59:28 +07:00
|
|
|
if (tcm->tcm_parent) {
|
|
|
|
q = qdisc_match_from_root(root, TC_H_MAJ(tcm->tcm_parent));
|
2018-10-18 15:34:26 +07:00
|
|
|
if (q && q != root &&
|
|
|
|
tc_dump_tclass_qdisc(q, skb, tcm, cb, t_p, s_t) < 0)
|
2017-05-11 11:59:28 +07:00
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
2016-08-10 16:05:15 +07:00
|
|
|
hash_for_each(qdisc_dev(root)->qdisc_hash, b, q, hash) {
|
2008-07-19 12:50:15 +07:00
|
|
|
if (tc_dump_tclass_qdisc(q, skb, tcm, cb, t_p, s_t) < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static int tc_dump_tclass(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
2012-06-27 11:50:05 +07:00
|
|
|
struct tcmsg *tcm = nlmsg_data(cb->nlh);
|
2008-03-26 00:26:21 +07:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2008-07-19 12:50:15 +07:00
|
|
|
struct netdev_queue *dev_queue;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct net_device *dev;
|
2008-07-19 12:50:15 +07:00
|
|
|
int t, s_t;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-03-27 13:47:04 +07:00
|
|
|
if (nlmsg_len(cb->nlh) < sizeof(*tcm))
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
2011-01-20 02:26:56 +07:00
|
|
|
dev = dev_get_by_index(net, tcm->tcm_ifindex);
|
|
|
|
if (!dev)
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
s_t = cb->args[0];
|
|
|
|
t = 0;
|
|
|
|
|
2009-09-04 13:41:18 +07:00
|
|
|
if (tc_dump_tclass_root(dev->qdisc, skb, tcm, cb, &t, s_t) < 0)
|
2008-07-19 12:50:15 +07:00
|
|
|
goto done;
|
|
|
|
|
2010-10-02 13:11:55 +07:00
|
|
|
dev_queue = dev_ingress_queue(dev);
|
|
|
|
if (dev_queue &&
|
|
|
|
tc_dump_tclass_root(dev_queue->qdisc_sleeping, skb, tcm, cb,
|
|
|
|
&t, s_t) < 0)
|
2008-07-19 12:50:15 +07:00
|
|
|
goto done;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-19 12:50:15 +07:00
|
|
|
done:
|
2005-04-17 05:20:36 +07:00
|
|
|
cb->args[0] = t;
|
|
|
|
|
|
|
|
dev_put(dev);
|
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
static int psched_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
seq_printf(seq, "%08x %08x %08x %08x\n",
|
2009-06-15 16:31:47 +07:00
|
|
|
(u32)NSEC_PER_USEC, (u32)PSCHED_TICKS2NS(1),
|
2007-03-17 02:34:52 +07:00
|
|
|
1000000,
|
2015-04-15 04:08:28 +07:00
|
|
|
(u32)NSEC_PER_SEC / hrtimer_resolution);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-19 22:40:13 +07:00
|
|
|
static int __net_init psched_net_init(struct net *net)
|
|
|
|
{
|
|
|
|
struct proc_dir_entry *e;
|
|
|
|
|
2018-05-15 20:57:23 +07:00
|
|
|
e = proc_create_single("psched", 0, net->proc_net, psched_show);
|
2010-03-19 22:40:13 +07:00
|
|
|
if (e == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit psched_net_exit(struct net *net)
|
|
|
|
{
|
2013-02-18 08:34:56 +07:00
|
|
|
remove_proc_entry("psched", net->proc_net);
|
2010-03-19 22:40:13 +07:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
static int __net_init psched_net_init(struct net *net)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit psched_net_exit(struct net *net)
|
|
|
|
{
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
2010-03-19 22:40:13 +07:00
|
|
|
static struct pernet_operations psched_net_ops = {
|
|
|
|
.init = psched_net_init,
|
|
|
|
.exit = psched_net_exit,
|
|
|
|
};
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static int __init pktsched_init(void)
|
|
|
|
{
|
2010-03-19 22:40:13 +07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = register_pernet_subsys(&psched_net_ops);
|
|
|
|
if (err) {
|
2011-01-20 02:26:56 +07:00
|
|
|
pr_err("pktsched_init: "
|
2010-03-19 22:40:13 +07:00
|
|
|
"cannot initialize per netns operations\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-28 06:19:08 +07:00
|
|
|
register_qdisc(&pfifo_fast_ops);
|
2005-04-17 05:20:36 +07:00
|
|
|
register_qdisc(&pfifo_qdisc_ops);
|
|
|
|
register_qdisc(&bfifo_qdisc_ops);
|
2010-01-24 19:30:59 +07:00
|
|
|
register_qdisc(&pfifo_head_drop_qdisc_ops);
|
2009-09-06 15:58:51 +07:00
|
|
|
register_qdisc(&mq_qdisc_ops);
|
2015-08-28 02:21:38 +07:00
|
|
|
register_qdisc(&noqueue_qdisc_ops);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-08-10 01:41:48 +07:00
|
|
|
rtnl_register(PF_UNSPEC, RTM_NEWQDISC, tc_modify_qdisc, NULL, 0);
|
|
|
|
rtnl_register(PF_UNSPEC, RTM_DELQDISC, tc_get_qdisc, NULL, 0);
|
2016-09-18 19:45:33 +07:00
|
|
|
rtnl_register(PF_UNSPEC, RTM_GETQDISC, tc_get_qdisc, tc_dump_qdisc,
|
2017-08-10 01:41:48 +07:00
|
|
|
0);
|
|
|
|
rtnl_register(PF_UNSPEC, RTM_NEWTCLASS, tc_ctl_tclass, NULL, 0);
|
|
|
|
rtnl_register(PF_UNSPEC, RTM_DELTCLASS, tc_ctl_tclass, NULL, 0);
|
2016-09-18 19:45:33 +07:00
|
|
|
rtnl_register(PF_UNSPEC, RTM_GETTCLASS, tc_ctl_tclass, tc_dump_tclass,
|
2017-08-10 01:41:48 +07:00
|
|
|
0);
|
2007-03-23 01:55:50 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(pktsched_init);
|