2019-05-27 14:55:01 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2006-08-11 14:35:16 +08:00
|
|
|
/*
|
2005-04-17 06:20:36 +08:00
|
|
|
* net/sched/sch_htb.c Hierarchical token bucket, feed tree version
|
|
|
|
*
|
|
|
|
* Authors: Martin Devera, <devik@cdi.cz>
|
|
|
|
*
|
|
|
|
* Credits (in time order) for older HTB versions:
|
|
|
|
* Stef Coene <stef.coene@docum.org>
|
|
|
|
* HTB support at LARTC mailing list
|
2007-02-09 22:25:16 +08:00
|
|
|
* Ondrej Kraus, <krauso@barr.cz>
|
2005-04-17 06:20:36 +08:00
|
|
|
* found missing INIT_QDISC(htb)
|
|
|
|
* Vladimir Smelhaus, Aamer Akhter, Bert Hubert
|
|
|
|
* helped a lot to locate nasty class stall bug
|
|
|
|
* Andi Kleen, Jamal Hadi, Bert Hubert
|
|
|
|
* code review and helpful comments on shaping
|
|
|
|
* Tomasz Wrona, <tw@eter.tym.pl>
|
|
|
|
* created test case so that I was able to fix nasty bug
|
|
|
|
* Wilfried Weissmann
|
|
|
|
* spotted bug in dequeue code and helped with fix
|
|
|
|
* Jiri Fojtasek
|
|
|
|
* fixed requeue routine
|
|
|
|
* and many others. thanks.
|
|
|
|
*/
|
|
|
|
#include <linux/module.h>
|
2008-06-17 07:39:32 +08:00
|
|
|
#include <linux/moduleparam.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/compiler.h>
|
2007-07-03 13:49:07 +08:00
|
|
|
#include <linux/rbtree.h>
|
2009-02-01 17:13:22 +08:00
|
|
|
#include <linux/workqueue.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 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2007-03-26 14:06:12 +08:00
|
|
|
#include <net/netlink.h>
|
2013-02-12 08:12:03 +08:00
|
|
|
#include <net/sch_generic.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <net/pkt_sched.h>
|
2017-02-09 21:38:56 +08:00
|
|
|
#include <net/pkt_cls.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* HTB algorithm.
|
|
|
|
Author: devik@cdi.cz
|
|
|
|
========================================================================
|
|
|
|
HTB is like TBF with multiple classes. It is also similar to CBQ because
|
2007-02-09 22:25:16 +08:00
|
|
|
it allows to assign priority to each class in hierarchy.
|
2005-04-17 06:20:36 +08:00
|
|
|
In fact it is another implementation of Floyd's formal sharing.
|
|
|
|
|
|
|
|
Levels:
|
2007-02-09 22:25:16 +08:00
|
|
|
Each class is assigned level. Leaf has ALWAYS level 0 and root
|
2005-04-17 06:20:36 +08:00
|
|
|
classes have level TC_HTB_MAXDEPTH-1. Interior nodes has level
|
|
|
|
one less than their parent.
|
|
|
|
*/
|
|
|
|
|
2008-06-17 07:39:32 +08:00
|
|
|
static int htb_hysteresis __read_mostly = 0; /* whether to use mode hysteresis for speedup */
|
2021-05-31 10:00:48 +08:00
|
|
|
#define HTB_VER 0x30011 /* major must be matched with number supplied by TC as version */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#if HTB_VER >> 16 != TC_HTB_PROTOVER
|
|
|
|
#error "Mismatched sch_htb.c and pkt_sch.h"
|
|
|
|
#endif
|
|
|
|
|
2008-06-17 07:39:32 +08:00
|
|
|
/* Module parameter and sysfs export */
|
|
|
|
module_param (htb_hysteresis, int, 0640);
|
|
|
|
MODULE_PARM_DESC(htb_hysteresis, "Hysteresis mode, less CPU load, less accurate");
|
|
|
|
|
2013-06-07 05:53:16 +08:00
|
|
|
static int htb_rate_est = 0; /* htb classes have a default rate estimator */
|
|
|
|
module_param(htb_rate_est, int, 0640);
|
|
|
|
MODULE_PARM_DESC(htb_rate_est, "setup a default rate estimator (4sec 16sec) for htb classes");
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* used internaly to keep status of single class */
|
|
|
|
enum htb_cmode {
|
2006-08-11 14:35:16 +08:00
|
|
|
HTB_CANT_SEND, /* class can't send and can't borrow */
|
|
|
|
HTB_MAY_BORROW, /* class can't send but may borrow */
|
|
|
|
HTB_CAN_SEND /* class can send */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
struct htb_prio {
|
|
|
|
union {
|
|
|
|
struct rb_root row;
|
|
|
|
struct rb_root feed;
|
|
|
|
};
|
|
|
|
struct rb_node *ptr;
|
|
|
|
/* When class changes from state 1->2 and disconnects from
|
|
|
|
* parent's feed then we lost ptr value and start from the
|
|
|
|
* first child again. Here we store classid of the
|
|
|
|
* last valid ptr (used when ptr is NULL).
|
|
|
|
*/
|
|
|
|
u32 last_ptr_id;
|
|
|
|
};
|
|
|
|
|
2013-06-13 22:58:30 +08:00
|
|
|
/* interior & leaf nodes; props specific to leaves are marked L:
|
|
|
|
* To reduce false sharing, place mostly read fields at beginning,
|
|
|
|
* and mostly written ones at the end.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class {
|
2008-07-06 14:22:35 +08:00
|
|
|
struct Qdisc_class_common common;
|
2013-06-13 22:58:30 +08:00
|
|
|
struct psched_ratecfg rate;
|
|
|
|
struct psched_ratecfg ceil;
|
|
|
|
s64 buffer, cbuffer;/* token bucket depth/rate */
|
|
|
|
s64 mbuffer; /* max wait time */
|
2013-08-02 13:32:07 +08:00
|
|
|
u32 prio; /* these two are used only by leaves... */
|
2013-06-13 22:58:30 +08:00
|
|
|
int quantum; /* but stored for parent-to-leaf return */
|
|
|
|
|
2014-09-13 11:05:27 +08:00
|
|
|
struct tcf_proto __rcu *filter_list; /* class attached filters */
|
2017-05-17 17:07:55 +08:00
|
|
|
struct tcf_block *block;
|
2013-06-13 22:58:30 +08:00
|
|
|
int filter_cnt;
|
|
|
|
|
|
|
|
int level; /* our level (see above) */
|
|
|
|
unsigned int children;
|
|
|
|
struct htb_class *parent; /* parent class */
|
|
|
|
|
2016-12-05 01:48:16 +08:00
|
|
|
struct net_rate_estimator __rcu *rate_est;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-13 22:58:30 +08:00
|
|
|
/*
|
|
|
|
* Written often fields
|
|
|
|
*/
|
2021-10-16 16:49:09 +08:00
|
|
|
struct gnet_stats_basic_sync bstats;
|
|
|
|
struct gnet_stats_basic_sync bstats_bias;
|
2013-06-13 22:58:30 +08:00
|
|
|
struct tc_htb_xstats xstats; /* our special stats */
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2013-06-13 22:58:30 +08:00
|
|
|
/* token bucket parameters */
|
|
|
|
s64 tokens, ctokens;/* current number of tokens */
|
|
|
|
s64 t_c; /* checkpoint time */
|
2008-12-04 13:09:45 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
union {
|
|
|
|
struct htb_class_leaf {
|
2013-06-15 18:30:10 +08:00
|
|
|
int deficit[TC_HTB_MAXDEPTH];
|
|
|
|
struct Qdisc *q;
|
2021-08-26 19:54:25 +08:00
|
|
|
struct netdev_queue *offload_queue;
|
2006-08-11 14:35:16 +08:00
|
|
|
} leaf;
|
|
|
|
struct htb_class_inner {
|
2013-06-15 18:30:10 +08:00
|
|
|
struct htb_prio clprio[TC_HTB_NUMPRIO];
|
2006-08-11 14:35:16 +08:00
|
|
|
} inner;
|
2018-09-08 04:29:14 +08:00
|
|
|
};
|
2013-06-13 22:58:30 +08:00
|
|
|
s64 pq_key;
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2013-06-13 22:58:30 +08:00
|
|
|
int prio_activity; /* for which prios are we active */
|
|
|
|
enum htb_cmode cmode; /* current mode of the class */
|
|
|
|
struct rb_node pq_node; /* node for event queue */
|
|
|
|
struct rb_node node[TC_HTB_NUMPRIO]; /* node for self or feed tree */
|
2016-06-22 14:16:51 +08:00
|
|
|
|
|
|
|
unsigned int drops ____cacheline_aligned_in_smp;
|
2017-09-19 03:36:22 +08:00
|
|
|
unsigned int overlimits;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
struct htb_level {
|
|
|
|
struct rb_root wait_pq;
|
|
|
|
struct htb_prio hprio[TC_HTB_NUMPRIO];
|
|
|
|
};
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_sched {
|
2008-07-06 14:22:35 +08:00
|
|
|
struct Qdisc_class_hash clhash;
|
2013-06-15 18:30:10 +08:00
|
|
|
int defcls; /* class where unclassified flows go to */
|
|
|
|
int rate2quantum; /* quant = rate / rate2quantum */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
/* filters for qdisc itself */
|
2014-09-13 11:05:27 +08:00
|
|
|
struct tcf_proto __rcu *filter_list;
|
2017-05-17 17:07:55 +08:00
|
|
|
struct tcf_block *block;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
#define HTB_WARN_TOOMANYEVENTS 0x1
|
|
|
|
unsigned int warned; /* only one warning */
|
|
|
|
int direct_qlen;
|
|
|
|
struct work_struct work;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
/* non shaped skbs; let them go directly thru */
|
2016-09-18 06:57:34 +08:00
|
|
|
struct qdisc_skb_head direct_queue;
|
2019-05-05 02:43:42 +08:00
|
|
|
u32 direct_pkts;
|
|
|
|
u32 overlimits;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
struct qdisc_watchdog watchdog;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
s64 now; /* cached dequeue time */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
/* time of nearest event per level (row) */
|
|
|
|
s64 near_ev_cache[TC_HTB_MAXDEPTH];
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
int row_mask[TC_HTB_MAXDEPTH];
|
2009-02-01 17:13:05 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
struct htb_level hlevel[TC_HTB_MAXDEPTH];
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
|
|
|
struct Qdisc **direct_qdiscs;
|
|
|
|
unsigned int num_direct_qdiscs;
|
|
|
|
|
|
|
|
bool offload;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/* find class in global hash table using given handle */
|
2006-08-11 14:35:16 +08:00
|
|
|
static inline struct htb_class *htb_find(u32 handle, struct Qdisc *sch)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2008-07-06 14:22:35 +08:00
|
|
|
struct Qdisc_class_common *clc;
|
2006-08-11 14:35:38 +08:00
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
clc = qdisc_class_find(&q->clhash, handle);
|
|
|
|
if (clc == NULL)
|
2005-04-17 06:20:36 +08:00
|
|
|
return NULL;
|
2008-07-06 14:22:35 +08:00
|
|
|
return container_of(clc, struct htb_class, common);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
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 07:51:29 +08:00
|
|
|
static unsigned long htb_search(struct Qdisc *sch, u32 handle)
|
|
|
|
{
|
|
|
|
return (unsigned long)htb_find(handle, sch);
|
|
|
|
}
|
2023-01-02 15:17:37 +08:00
|
|
|
|
|
|
|
#define HTB_DIRECT ((struct htb_class *)-1L)
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* htb_classify - classify a packet into class
|
2023-01-02 15:17:37 +08:00
|
|
|
* @skb: the socket buffer
|
|
|
|
* @sch: the active queue discipline
|
|
|
|
* @qerr: pointer for returned status code
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* It returns NULL if the packet should be dropped or -1 if the packet
|
|
|
|
* should be passed directly thru. In all other cases leaf class is returned.
|
|
|
|
* We allow direct class selection by classid in priority. The we examine
|
|
|
|
* filters in qdisc and in inner nodes (if higher filter points to the inner
|
|
|
|
* node). If we end up with classid MAJOR:0 we enqueue the skb into special
|
2007-02-09 22:25:16 +08:00
|
|
|
* internal fifo (direct). These packets then go directly thru. If we still
|
2011-03-31 09:57:33 +08:00
|
|
|
* have no valid leaf we try to use MAJOR:default leaf. It still unsuccessful
|
2005-04-17 06:20:36 +08:00
|
|
|
* then finish and return direct queue.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch,
|
|
|
|
int *qerr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
|
|
|
struct htb_class *cl;
|
|
|
|
struct tcf_result res;
|
|
|
|
struct tcf_proto *tcf;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
/* allow to select class by setting skb->priority to valid classid;
|
2011-01-20 03:26:56 +08:00
|
|
|
* note that nfmark can be used too by attaching filter fw with no
|
|
|
|
* rules in it
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
if (skb->priority == sch->handle)
|
2006-08-11 14:35:16 +08:00
|
|
|
return HTB_DIRECT; /* X:0 (direct flow) selected */
|
2011-01-20 03:26:56 +08:00
|
|
|
cl = htb_find(skb->priority, sch);
|
2014-01-17 21:22:32 +08:00
|
|
|
if (cl) {
|
|
|
|
if (cl->level == 0)
|
|
|
|
return cl;
|
|
|
|
/* Start with inner filter chain if a non-leaf class is selected */
|
2014-09-13 11:05:27 +08:00
|
|
|
tcf = rcu_dereference_bh(cl->filter_list);
|
2014-01-17 21:22:32 +08:00
|
|
|
} else {
|
2014-09-13 11:05:27 +08:00
|
|
|
tcf = rcu_dereference_bh(q->filter_list);
|
2014-01-17 21:22:32 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-08-05 13:39:11 +08:00
|
|
|
*qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
|
2021-07-29 02:08:00 +08:00
|
|
|
while (tcf && (result = tcf_classify(skb, NULL, tcf, &res, false)) >= 0) {
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
|
|
|
switch (result) {
|
|
|
|
case TC_ACT_QUEUED:
|
2006-08-11 14:35:16 +08:00
|
|
|
case TC_ACT_STOLEN:
|
2017-06-06 20:12:02 +08:00
|
|
|
case TC_ACT_TRAP:
|
2008-08-05 13:31:03 +08:00
|
|
|
*qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
|
2020-07-08 01:21:38 +08:00
|
|
|
fallthrough;
|
2005-04-17 06:20:36 +08:00
|
|
|
case TC_ACT_SHOT:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2011-01-20 03:26:56 +08:00
|
|
|
cl = (void *)res.class;
|
|
|
|
if (!cl) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (res.classid == sch->handle)
|
2006-08-11 14:35:16 +08:00
|
|
|
return HTB_DIRECT; /* X:0 (direct flow) */
|
2011-01-20 03:26:56 +08:00
|
|
|
cl = htb_find(res.classid, sch);
|
|
|
|
if (!cl)
|
2006-08-11 14:35:16 +08:00
|
|
|
break; /* filter selected invalid classid */
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (!cl->level)
|
2006-08-11 14:35:16 +08:00
|
|
|
return cl; /* we hit leaf; return it */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* we have got inner class; apply inner filter chain */
|
2014-09-13 11:05:27 +08:00
|
|
|
tcf = rcu_dereference_bh(cl->filter_list);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
/* classification failed; try to use default class */
|
2006-08-11 14:35:16 +08:00
|
|
|
cl = htb_find(TC_H_MAKE(TC_H_MAJ(sch->handle), q->defcls), sch);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!cl || cl->level)
|
2006-08-11 14:35:16 +08:00
|
|
|
return HTB_DIRECT; /* bad default .. this is safe bet */
|
2005-04-17 06:20:36 +08:00
|
|
|
return cl;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_add_to_id_tree - adds class to the round robin list
|
2021-06-03 22:07:49 +08:00
|
|
|
* @root: the root of the tree
|
|
|
|
* @cl: the class to add
|
|
|
|
* @prio: the give prio in class
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* Routine adds class to the list (actually tree) sorted by classid.
|
|
|
|
* Make sure that class is not already on such list for given prio.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static void htb_add_to_id_tree(struct rb_root *root,
|
|
|
|
struct htb_class *cl, int prio)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct rb_node **p = &root->rb_node, *parent = NULL;
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
while (*p) {
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *c;
|
|
|
|
parent = *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
c = rb_entry(parent, struct htb_class, node[prio]);
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
if (cl->common.classid > c->common.classid)
|
2005-04-17 06:20:36 +08:00
|
|
|
p = &parent->rb_right;
|
2006-08-11 14:35:16 +08:00
|
|
|
else
|
2005-04-17 06:20:36 +08:00
|
|
|
p = &parent->rb_left;
|
|
|
|
}
|
|
|
|
rb_link_node(&cl->node[prio], parent, p);
|
|
|
|
rb_insert_color(&cl->node[prio], root);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_add_to_wait_tree - adds class to the event queue with delay
|
2021-06-05 18:18:33 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the class to add
|
|
|
|
* @delay: delay in microseconds
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* The class is added to priority event queue to indicate that class will
|
|
|
|
* change its mode in cl->pq_key microseconds. Make sure that class is not
|
|
|
|
* already in the queue.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static void htb_add_to_wait_tree(struct htb_sched *q,
|
2012-10-31 14:04:11 +08:00
|
|
|
struct htb_class *cl, s64 delay)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-06-15 18:30:10 +08:00
|
|
|
struct rb_node **p = &q->hlevel[cl->level].wait_pq.rb_node, *parent = NULL;
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2007-03-16 16:22:39 +08:00
|
|
|
cl->pq_key = q->now + delay;
|
|
|
|
if (cl->pq_key == q->now)
|
2005-04-17 06:20:36 +08:00
|
|
|
cl->pq_key++;
|
|
|
|
|
|
|
|
/* update the nearest event cache */
|
2007-03-16 16:22:39 +08:00
|
|
|
if (q->near_ev_cache[cl->level] > cl->pq_key)
|
2005-04-17 06:20:36 +08:00
|
|
|
q->near_ev_cache[cl->level] = cl->pq_key;
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
while (*p) {
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *c;
|
|
|
|
parent = *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
c = rb_entry(parent, struct htb_class, pq_node);
|
2007-03-16 16:22:39 +08:00
|
|
|
if (cl->pq_key >= c->pq_key)
|
2005-04-17 06:20:36 +08:00
|
|
|
p = &parent->rb_right;
|
2006-08-11 14:35:16 +08:00
|
|
|
else
|
2005-04-17 06:20:36 +08:00
|
|
|
p = &parent->rb_left;
|
|
|
|
}
|
|
|
|
rb_link_node(&cl->pq_node, parent, p);
|
2013-06-15 18:30:10 +08:00
|
|
|
rb_insert_color(&cl->pq_node, &q->hlevel[cl->level].wait_pq);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_next_rb_node - finds next node in binary tree
|
2021-06-05 18:18:34 +08:00
|
|
|
* @n: the current node in binary tree
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* When we are past last key we return NULL.
|
|
|
|
* Average complexity is 2 steps per call.
|
|
|
|
*/
|
2006-08-11 14:36:01 +08:00
|
|
|
static inline void htb_next_rb_node(struct rb_node **n)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
*n = rb_next(*n);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_add_class_to_row - add class to its row
|
2021-06-05 18:18:35 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the class to add
|
|
|
|
* @mask: the given priorities in class in bitmap
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* The class is added to row at priorities marked in mask.
|
|
|
|
* It does nothing if mask == 0.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static inline void htb_add_class_to_row(struct htb_sched *q,
|
|
|
|
struct htb_class *cl, int mask)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
q->row_mask[cl->level] |= mask;
|
|
|
|
while (mask) {
|
|
|
|
int prio = ffz(~mask);
|
|
|
|
mask &= ~(1 << prio);
|
2013-06-15 18:30:10 +08:00
|
|
|
htb_add_to_id_tree(&q->hlevel[cl->level].hprio[prio].row, cl, prio);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-11 14:36:01 +08:00
|
|
|
/* If this triggers, it is a bug in this code, but it need not be fatal */
|
|
|
|
static void htb_safe_rb_erase(struct rb_node *rb, struct rb_root *root)
|
|
|
|
{
|
2006-10-04 04:49:10 +08:00
|
|
|
if (RB_EMPTY_NODE(rb)) {
|
2006-08-11 14:36:01 +08:00
|
|
|
WARN_ON(1);
|
|
|
|
} else {
|
|
|
|
rb_erase(rb, root);
|
|
|
|
RB_CLEAR_NODE(rb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* htb_remove_class_from_row - removes class from its row
|
2021-06-05 18:18:36 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the class to add
|
|
|
|
* @mask: the given priorities in class in bitmap
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* The class is removed from row at priorities marked in mask.
|
|
|
|
* It does nothing if mask == 0.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static inline void htb_remove_class_from_row(struct htb_sched *q,
|
|
|
|
struct htb_class *cl, int mask)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int m = 0;
|
2013-06-15 18:30:10 +08:00
|
|
|
struct htb_level *hlevel = &q->hlevel[cl->level];
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
while (mask) {
|
|
|
|
int prio = ffz(~mask);
|
2013-06-15 18:30:10 +08:00
|
|
|
struct htb_prio *hprio = &hlevel->hprio[prio];
|
2006-08-11 14:36:01 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
mask &= ~(1 << prio);
|
2013-06-15 18:30:10 +08:00
|
|
|
if (hprio->ptr == cl->node + prio)
|
|
|
|
htb_next_rb_node(&hprio->ptr);
|
2006-08-11 14:36:01 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
htb_safe_rb_erase(cl->node + prio, &hprio->row);
|
|
|
|
if (!hprio->row.rb_node)
|
2005-04-17 06:20:36 +08:00
|
|
|
m |= 1 << prio;
|
|
|
|
}
|
|
|
|
q->row_mask[cl->level] &= ~m;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_activate_prios - creates active classe's feed chain
|
2021-06-05 18:18:37 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the class to activate
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* The class is connected to ancestors and/or appropriate rows
|
2007-02-09 22:25:16 +08:00
|
|
|
* for priorities it is participating on. cl->cmode must be new
|
2005-04-17 06:20:36 +08:00
|
|
|
* (activated) mode. It does nothing if cl->prio_activity == 0.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static void htb_activate_prios(struct htb_sched *q, struct htb_class *cl)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct htb_class *p = cl->parent;
|
2006-08-11 14:35:16 +08:00
|
|
|
long m, mask = cl->prio_activity;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
while (cl->cmode == HTB_MAY_BORROW && p && mask) {
|
2006-08-11 14:35:16 +08:00
|
|
|
m = mask;
|
|
|
|
while (m) {
|
2023-01-28 06:40:37 +08:00
|
|
|
unsigned int prio = ffz(~m);
|
|
|
|
|
2023-02-06 21:18:32 +08:00
|
|
|
if (WARN_ON_ONCE(prio >= ARRAY_SIZE(p->inner.clprio)))
|
2023-01-28 06:40:37 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
m &= ~(1 << prio);
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2018-09-08 04:29:14 +08:00
|
|
|
if (p->inner.clprio[prio].feed.rb_node)
|
2005-04-17 06:20:36 +08:00
|
|
|
/* parent already has its feed in use so that
|
2011-01-20 03:26:56 +08:00
|
|
|
* reset bit in mask as parent is already ok
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
mask &= ~(1 << prio);
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2018-09-08 04:29:14 +08:00
|
|
|
htb_add_to_id_tree(&p->inner.clprio[prio].feed, cl, prio);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
p->prio_activity |= mask;
|
2006-08-11 14:35:16 +08:00
|
|
|
cl = p;
|
|
|
|
p = cl->parent;
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (cl->cmode == HTB_CAN_SEND && mask)
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_add_class_to_row(q, cl, mask);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_deactivate_prios - remove class from feed chain
|
2021-06-05 18:18:38 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the class to deactivate
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2007-02-09 22:25:16 +08:00
|
|
|
* cl->cmode must represent old mode (before deactivation). It does
|
2005-04-17 06:20:36 +08:00
|
|
|
* nothing if cl->prio_activity == 0. Class is removed from all feed
|
|
|
|
* chains and rows.
|
|
|
|
*/
|
|
|
|
static void htb_deactivate_prios(struct htb_sched *q, struct htb_class *cl)
|
|
|
|
{
|
|
|
|
struct htb_class *p = cl->parent;
|
2006-08-11 14:35:16 +08:00
|
|
|
long m, mask = cl->prio_activity;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
while (cl->cmode == HTB_MAY_BORROW && p && mask) {
|
2006-08-11 14:35:16 +08:00
|
|
|
m = mask;
|
|
|
|
mask = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
while (m) {
|
|
|
|
int prio = ffz(~m);
|
|
|
|
m &= ~(1 << prio);
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2018-09-08 04:29:14 +08:00
|
|
|
if (p->inner.clprio[prio].ptr == cl->node + prio) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* we are removing child which is pointed to from
|
2011-01-20 03:26:56 +08:00
|
|
|
* parent feed - forget the pointer but remember
|
|
|
|
* classid
|
|
|
|
*/
|
2018-09-08 04:29:14 +08:00
|
|
|
p->inner.clprio[prio].last_ptr_id = cl->common.classid;
|
|
|
|
p->inner.clprio[prio].ptr = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
htb_safe_rb_erase(cl->node + prio,
|
2018-09-08 04:29:14 +08:00
|
|
|
&p->inner.clprio[prio].feed);
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2018-09-08 04:29:14 +08:00
|
|
|
if (!p->inner.clprio[prio].feed.rb_node)
|
2005-04-17 06:20:36 +08:00
|
|
|
mask |= 1 << prio;
|
|
|
|
}
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
p->prio_activity &= ~mask;
|
2006-08-11 14:35:16 +08:00
|
|
|
cl = p;
|
|
|
|
p = cl->parent;
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-08-11 14:35:16 +08:00
|
|
|
if (cl->cmode == HTB_CAN_SEND && mask)
|
|
|
|
htb_remove_class_from_row(q, cl, mask);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-10-31 14:04:11 +08:00
|
|
|
static inline s64 htb_lowater(const struct htb_class *cl)
|
2006-08-11 14:34:02 +08:00
|
|
|
{
|
2008-06-17 07:39:32 +08:00
|
|
|
if (htb_hysteresis)
|
|
|
|
return cl->cmode != HTB_CANT_SEND ? -cl->cbuffer : 0;
|
|
|
|
else
|
|
|
|
return 0;
|
2006-08-11 14:34:02 +08:00
|
|
|
}
|
2012-10-31 14:04:11 +08:00
|
|
|
static inline s64 htb_hiwater(const struct htb_class *cl)
|
2006-08-11 14:34:02 +08:00
|
|
|
{
|
2008-06-17 07:39:32 +08:00
|
|
|
if (htb_hysteresis)
|
|
|
|
return cl->cmode == HTB_CAN_SEND ? -cl->buffer : 0;
|
|
|
|
else
|
|
|
|
return 0;
|
2006-08-11 14:34:02 +08:00
|
|
|
}
|
2008-06-17 07:39:32 +08:00
|
|
|
|
2006-08-11 14:34:02 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* htb_class_mode - computes and returns current class mode
|
2021-06-05 18:18:39 +08:00
|
|
|
* @cl: the target class
|
|
|
|
* @diff: diff time in microseconds
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* It computes cl's mode at time cl->t_c+diff and returns it. If mode
|
|
|
|
* is not HTB_CAN_SEND then cl->pq_key is updated to time difference
|
2007-02-09 22:25:16 +08:00
|
|
|
* from now to time when cl will change its state.
|
2005-04-17 06:20:36 +08:00
|
|
|
* Also it is worth to note that class mode doesn't change simply
|
2007-02-09 22:25:16 +08:00
|
|
|
* at cl->{c,}tokens == 0 but there can rather be hysteresis of
|
2005-04-17 06:20:36 +08:00
|
|
|
* 0 .. -cl->{c,}buffer range. It is meant to limit number of
|
|
|
|
* mode transitions per time unit. The speed gain is about 1/6.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static inline enum htb_cmode
|
2012-10-31 14:04:11 +08:00
|
|
|
htb_class_mode(struct htb_class *cl, s64 *diff)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-10-31 14:04:11 +08:00
|
|
|
s64 toks;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
if ((toks = (cl->ctokens + *diff)) < htb_lowater(cl)) {
|
|
|
|
*diff = -toks;
|
|
|
|
return HTB_CANT_SEND;
|
|
|
|
}
|
2006-08-11 14:34:02 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
if ((toks = (cl->tokens + *diff)) >= htb_hiwater(cl))
|
|
|
|
return HTB_CAN_SEND;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
*diff = -toks;
|
|
|
|
return HTB_MAY_BORROW;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_change_class_mode - changes classe's mode
|
2021-06-05 18:18:40 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the target class
|
|
|
|
* @diff: diff time in microseconds
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* This should be the only way how to change classe's mode under normal
|
2021-05-31 10:00:48 +08:00
|
|
|
* circumstances. Routine will update feed lists linkage, change mode
|
2005-04-17 06:20:36 +08:00
|
|
|
* and add class to the wait event queue if appropriate. New mode should
|
|
|
|
* be different from old one and cl->pq_key has to be valid if changing
|
|
|
|
* to mode other than HTB_CAN_SEND (see htb_add_to_wait_tree).
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static void
|
2012-10-31 14:04:11 +08:00
|
|
|
htb_change_class_mode(struct htb_sched *q, struct htb_class *cl, s64 *diff)
|
2006-08-11 14:35:16 +08:00
|
|
|
{
|
|
|
|
enum htb_cmode new_mode = htb_class_mode(cl, diff);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (new_mode == cl->cmode)
|
2006-08-11 14:35:16 +08:00
|
|
|
return;
|
|
|
|
|
2019-05-05 02:43:42 +08:00
|
|
|
if (new_mode == HTB_CANT_SEND) {
|
2017-09-19 03:36:22 +08:00
|
|
|
cl->overlimits++;
|
2019-05-05 02:43:42 +08:00
|
|
|
q->overlimits++;
|
|
|
|
}
|
2017-09-19 03:36:22 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
if (cl->prio_activity) { /* not necessary: speed optimization */
|
|
|
|
if (cl->cmode != HTB_CANT_SEND)
|
|
|
|
htb_deactivate_prios(q, cl);
|
2005-04-17 06:20:36 +08:00
|
|
|
cl->cmode = new_mode;
|
2006-08-11 14:35:16 +08:00
|
|
|
if (new_mode != HTB_CANT_SEND)
|
|
|
|
htb_activate_prios(q, cl);
|
|
|
|
} else
|
2005-04-17 06:20:36 +08:00
|
|
|
cl->cmode = new_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-02-09 22:25:16 +08:00
|
|
|
* htb_activate - inserts leaf cl into appropriate active feeds
|
2021-06-05 18:18:41 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the target class
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* Routine learns (new) priority of leaf and activates feed chain
|
|
|
|
* for the prio. It can be called on already active leaf safely.
|
|
|
|
* It also adds leaf into droplist.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static inline void htb_activate(struct htb_sched *q, struct htb_class *cl)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2018-09-08 04:29:14 +08:00
|
|
|
WARN_ON(cl->level || !cl->leaf.q || !cl->leaf.q->q.qlen);
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!cl->prio_activity) {
|
2008-12-04 13:09:45 +08:00
|
|
|
cl->prio_activity = 1 << cl->prio;
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_activate_prios(q, cl);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-02-09 22:25:16 +08:00
|
|
|
* htb_deactivate - remove leaf cl from active feeds
|
2021-06-05 18:18:42 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the target class
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* Make sure that leaf is active. In the other words it can't be called
|
|
|
|
* with non-active leaf. It also removes class from the drop list.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static inline void htb_deactivate(struct htb_sched *q, struct htb_class *cl)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-26 12:43:18 +08:00
|
|
|
WARN_ON(!cl->prio_activity);
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_deactivate_prios(q, cl);
|
2005-04-17 06:20:36 +08:00
|
|
|
cl->prio_activity = 0;
|
|
|
|
}
|
|
|
|
|
2016-06-22 14:16:49 +08:00
|
|
|
static int htb_enqueue(struct sk_buff *skb, struct Qdisc *sch,
|
|
|
|
struct sk_buff **to_free)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
treewide: Remove uninitialized_var() usage
Using uninitialized_var() is dangerous as it papers over real bugs[1]
(or can in the future), and suppresses unrelated compiler warnings
(e.g. "unused variable"). If the compiler thinks it is uninitialized,
either simply initialize the variable or make compiler changes.
In preparation for removing[2] the[3] macro[4], remove all remaining
needless uses with the following script:
git grep '\buninitialized_var\b' | cut -d: -f1 | sort -u | \
xargs perl -pi -e \
's/\buninitialized_var\(([^\)]+)\)/\1/g;
s:\s*/\* (GCC be quiet|to make compiler happy) \*/$::g;'
drivers/video/fbdev/riva/riva_hw.c was manually tweaked to avoid
pathological white-space.
No outstanding warnings were found building allmodconfig with GCC 9.3.0
for x86_64, i386, arm64, arm, powerpc, powerpc64le, s390x, mips, sparc64,
alpha, and m68k.
[1] https://lore.kernel.org/lkml/20200603174714.192027-1-glider@google.com/
[2] https://lore.kernel.org/lkml/CA+55aFw+Vbj0i=1TGqCR5vQkCzWJ0QxK6CernOU6eedsudAixw@mail.gmail.com/
[3] https://lore.kernel.org/lkml/CA+55aFwgbgqhbp1fkxvRKEpzyR5J8n1vKT1VZdz9knmPuXhOeg@mail.gmail.com/
[4] https://lore.kernel.org/lkml/CA+55aFz2500WfbKXAx8s67wrm9=yVJu65TpLgN_ybYNv0VEOKA@mail.gmail.com/
Reviewed-by: Leon Romanovsky <leonro@mellanox.com> # drivers/infiniband and mlx4/mlx5
Acked-by: Jason Gunthorpe <jgg@mellanox.com> # IB
Acked-by: Kalle Valo <kvalo@codeaurora.org> # wireless drivers
Reviewed-by: Chao Yu <yuchao0@huawei.com> # erofs
Signed-off-by: Kees Cook <keescook@chromium.org>
2020-06-04 04:09:38 +08:00
|
|
|
int ret;
|
2019-01-10 00:09:42 +08:00
|
|
|
unsigned int len = qdisc_pkt_len(skb);
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
|
|
|
struct htb_class *cl = htb_classify(skb, sch, &ret);
|
|
|
|
|
|
|
|
if (cl == HTB_DIRECT) {
|
|
|
|
/* enqueue to helper queue */
|
|
|
|
if (q->direct_queue.qlen < q->direct_qlen) {
|
2018-07-30 07:22:13 +08:00
|
|
|
__qdisc_enqueue_tail(skb, &q->direct_queue);
|
2006-08-11 14:35:16 +08:00
|
|
|
q->direct_pkts++;
|
|
|
|
} else {
|
2016-06-22 14:16:49 +08:00
|
|
|
return qdisc_drop(skb, sch, to_free);
|
2006-08-11 14:35:16 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
2006-08-11 14:35:16 +08:00
|
|
|
} else if (!cl) {
|
2008-08-05 13:39:11 +08:00
|
|
|
if (ret & __NET_XMIT_BYPASS)
|
2014-09-29 02:53:29 +08:00
|
|
|
qdisc_qstats_drop(sch);
|
2016-06-22 14:16:49 +08:00
|
|
|
__qdisc_drop(skb, to_free);
|
2006-08-11 14:35:16 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2018-09-08 04:29:14 +08:00
|
|
|
} else if ((ret = qdisc_enqueue(skb, cl->leaf.q,
|
2016-06-22 14:16:49 +08:00
|
|
|
to_free)) != NET_XMIT_SUCCESS) {
|
2008-08-05 13:31:03 +08:00
|
|
|
if (net_xmit_drop_count(ret)) {
|
2014-09-29 02:53:29 +08:00
|
|
|
qdisc_qstats_drop(sch);
|
2016-06-22 14:16:51 +08:00
|
|
|
cl->drops++;
|
2008-08-05 13:31:03 +08:00
|
|
|
}
|
2008-08-18 14:55:36 +08:00
|
|
|
return ret;
|
2006-08-11 14:35:16 +08:00
|
|
|
} else {
|
|
|
|
htb_activate(q, cl);
|
|
|
|
}
|
|
|
|
|
2019-01-10 00:09:42 +08:00
|
|
|
sch->qstats.backlog += len;
|
2006-08-11 14:35:16 +08:00
|
|
|
sch->q.qlen++;
|
|
|
|
return NET_XMIT_SUCCESS;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-10-31 14:04:11 +08:00
|
|
|
static inline void htb_accnt_tokens(struct htb_class *cl, int bytes, s64 diff)
|
2008-12-04 13:17:27 +08:00
|
|
|
{
|
2012-10-31 14:04:11 +08:00
|
|
|
s64 toks = diff + cl->tokens;
|
2008-12-04 13:17:27 +08:00
|
|
|
|
|
|
|
if (toks > cl->buffer)
|
|
|
|
toks = cl->buffer;
|
2013-02-12 08:12:03 +08:00
|
|
|
toks -= (s64) psched_l2t_ns(&cl->rate, bytes);
|
2008-12-04 13:17:27 +08:00
|
|
|
if (toks <= -cl->mbuffer)
|
|
|
|
toks = 1 - cl->mbuffer;
|
|
|
|
|
|
|
|
cl->tokens = toks;
|
|
|
|
}
|
|
|
|
|
2012-10-31 14:04:11 +08:00
|
|
|
static inline void htb_accnt_ctokens(struct htb_class *cl, int bytes, s64 diff)
|
2008-12-04 13:17:27 +08:00
|
|
|
{
|
2012-10-31 14:04:11 +08:00
|
|
|
s64 toks = diff + cl->ctokens;
|
2008-12-04 13:17:27 +08:00
|
|
|
|
|
|
|
if (toks > cl->cbuffer)
|
|
|
|
toks = cl->cbuffer;
|
2013-02-12 08:12:03 +08:00
|
|
|
toks -= (s64) psched_l2t_ns(&cl->ceil, bytes);
|
2008-12-04 13:17:27 +08:00
|
|
|
if (toks <= -cl->mbuffer)
|
|
|
|
toks = 1 - cl->mbuffer;
|
|
|
|
|
|
|
|
cl->ctokens = toks;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* htb_charge_class - charges amount "bytes" to leaf and ancestors
|
2021-06-05 18:18:43 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @cl: the class to start iterate
|
|
|
|
* @level: the minimum level to account
|
|
|
|
* @skb: the socket buffer
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* Routine assumes that packet "bytes" long was dequeued from leaf cl
|
|
|
|
* borrowing from "level". It accounts bytes to ceil leaky bucket for
|
|
|
|
* leaf and all ancestors and to rate bucket for ancestors at levels
|
|
|
|
* "level" and higher. It also handles possible change of mode resulting
|
|
|
|
* from the update. Note that mode can also increase here (MAY_BORROW to
|
|
|
|
* CAN_SEND) because we can use more precise clock that event queue here.
|
|
|
|
* In such case we remove class from event queue first.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static void htb_charge_class(struct htb_sched *q, struct htb_class *cl,
|
2007-07-11 13:43:16 +08:00
|
|
|
int level, struct sk_buff *skb)
|
2006-08-11 14:35:16 +08:00
|
|
|
{
|
2008-07-20 15:08:27 +08:00
|
|
|
int bytes = qdisc_pkt_len(skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
enum htb_cmode old_mode;
|
2012-10-31 14:04:11 +08:00
|
|
|
s64 diff;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
while (cl) {
|
2012-10-31 14:04:11 +08:00
|
|
|
diff = min_t(s64, q->now - cl->t_c, cl->mbuffer);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (cl->level >= level) {
|
2006-08-11 14:35:16 +08:00
|
|
|
if (cl->level == level)
|
|
|
|
cl->xstats.lends++;
|
2008-12-04 13:17:27 +08:00
|
|
|
htb_accnt_tokens(cl, bytes, diff);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
cl->xstats.borrows++;
|
2006-08-11 14:35:16 +08:00
|
|
|
cl->tokens += diff; /* we moved t_c; update tokens */
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-12-04 13:17:27 +08:00
|
|
|
htb_accnt_ctokens(cl, bytes, diff);
|
2005-04-17 06:20:36 +08:00
|
|
|
cl->t_c = q->now;
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
old_mode = cl->cmode;
|
|
|
|
diff = 0;
|
|
|
|
htb_change_class_mode(q, cl, &diff);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (old_mode != cl->cmode) {
|
|
|
|
if (old_mode != HTB_CAN_SEND)
|
2013-06-15 18:30:10 +08:00
|
|
|
htb_safe_rb_erase(&cl->pq_node, &q->hlevel[cl->level].wait_pq);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (cl->cmode != HTB_CAN_SEND)
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_add_to_wait_tree(q, cl, diff);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2011-01-09 16:30:54 +08:00
|
|
|
/* update basic stats except for leaves which are already updated */
|
|
|
|
if (cl->level)
|
|
|
|
bstats_update(&cl->bstats, skb);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
cl = cl->parent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_do_events - make mode changes to classes at the level
|
2021-06-05 18:18:44 +08:00
|
|
|
* @q: the priority event queue
|
|
|
|
* @level: which wait_pq in 'q->hlevel'
|
|
|
|
* @start: start jiffies
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2007-03-16 16:22:39 +08:00
|
|
|
* Scans event queue for pending events and applies them. Returns time of
|
2009-02-01 17:13:22 +08:00
|
|
|
* next pending event (0 for no event in pq, q->now for too many events).
|
2007-03-16 16:22:39 +08:00
|
|
|
* Note: Applied are events whose have cl->pq_key <= q->now.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2013-06-15 18:30:10 +08:00
|
|
|
static s64 htb_do_events(struct htb_sched *q, const int level,
|
2013-06-04 15:11:48 +08:00
|
|
|
unsigned long start)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-03-24 13:00:38 +08:00
|
|
|
/* don't run for longer than 2 jiffies; 2 is used instead of
|
2011-01-20 03:26:56 +08:00
|
|
|
* 1 to simplify things when jiffy is going to be incremented
|
|
|
|
* too soon
|
|
|
|
*/
|
2009-01-13 13:54:40 +08:00
|
|
|
unsigned long stop_at = start + 2;
|
2013-06-15 18:30:10 +08:00
|
|
|
struct rb_root *wait_pq = &q->hlevel[level].wait_pq;
|
|
|
|
|
2008-03-24 13:00:38 +08:00
|
|
|
while (time_before(jiffies, stop_at)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
struct htb_class *cl;
|
2012-10-31 14:04:11 +08:00
|
|
|
s64 diff;
|
2013-06-15 18:30:10 +08:00
|
|
|
struct rb_node *p = rb_first(wait_pq);
|
2006-10-12 16:52:05 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
if (!p)
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
cl = rb_entry(p, struct htb_class, pq_node);
|
2007-03-16 16:22:39 +08:00
|
|
|
if (cl->pq_key > q->now)
|
|
|
|
return cl->pq_key;
|
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
htb_safe_rb_erase(p, wait_pq);
|
2012-10-31 14:04:11 +08:00
|
|
|
diff = min_t(s64, q->now - cl->t_c, cl->mbuffer);
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_change_class_mode(q, cl, &diff);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (cl->cmode != HTB_CAN_SEND)
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_add_to_wait_tree(q, cl, diff);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-02-01 17:13:22 +08:00
|
|
|
|
|
|
|
/* too much load - let's continue after a break for scheduling */
|
2009-02-01 17:13:05 +08:00
|
|
|
if (!(q->warned & HTB_WARN_TOOMANYEVENTS)) {
|
2013-12-23 17:38:58 +08:00
|
|
|
pr_warn("htb: too many events!\n");
|
2009-02-01 17:13:05 +08:00
|
|
|
q->warned |= HTB_WARN_TOOMANYEVENTS;
|
|
|
|
}
|
2009-02-01 17:13:22 +08:00
|
|
|
|
|
|
|
return q->now;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns class->node+prio from id-tree where classe's id is >= id. NULL
|
2011-01-20 03:26:56 +08:00
|
|
|
* is no such one exists.
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
static struct rb_node *htb_id_find_next_upper(int prio, struct rb_node *n,
|
|
|
|
u32 id)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct rb_node *r = NULL;
|
|
|
|
while (n) {
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl =
|
|
|
|
rb_entry(n, struct htb_class, node[prio]);
|
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
if (id > cl->common.classid) {
|
2005-04-17 06:20:36 +08:00
|
|
|
n = n->rb_right;
|
2008-12-10 14:34:40 +08:00
|
|
|
} else if (id < cl->common.classid) {
|
2005-04-17 06:20:36 +08:00
|
|
|
r = n;
|
|
|
|
n = n->rb_left;
|
2008-12-10 14:34:40 +08:00
|
|
|
} else {
|
|
|
|
return n;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* htb_lookup_leaf - returns next leaf class in DRR order
|
2021-06-05 18:18:45 +08:00
|
|
|
* @hprio: the current one
|
|
|
|
* @prio: which prio in class
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* Find leaf where current feed pointers points to.
|
|
|
|
*/
|
2013-06-15 18:30:10 +08:00
|
|
|
static struct htb_class *htb_lookup_leaf(struct htb_prio *hprio, const int prio)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct {
|
|
|
|
struct rb_node *root;
|
|
|
|
struct rb_node **pptr;
|
|
|
|
u32 *pid;
|
2006-08-11 14:35:16 +08:00
|
|
|
} stk[TC_HTB_MAXDEPTH], *sp = stk;
|
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
BUG_ON(!hprio->row.rb_node);
|
|
|
|
sp->root = hprio->row.rb_node;
|
|
|
|
sp->pptr = &hprio->ptr;
|
|
|
|
sp->pid = &hprio->last_ptr_id;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
for (i = 0; i < 65535; i++) {
|
2006-08-11 14:35:16 +08:00
|
|
|
if (!*sp->pptr && *sp->pid) {
|
2007-02-09 22:25:16 +08:00
|
|
|
/* ptr was invalidated but id is valid - try to recover
|
2011-01-20 03:26:56 +08:00
|
|
|
* the original or next ptr
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
*sp->pptr =
|
|
|
|
htb_id_find_next_upper(prio, sp->root, *sp->pid);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-08-11 14:35:16 +08:00
|
|
|
*sp->pid = 0; /* ptr is valid now so that remove this hint as it
|
2011-01-20 03:26:56 +08:00
|
|
|
* can become out of date quickly
|
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
if (!*sp->pptr) { /* we are at right end; rewind & go up */
|
2005-04-17 06:20:36 +08:00
|
|
|
*sp->pptr = sp->root;
|
2006-08-11 14:35:16 +08:00
|
|
|
while ((*sp->pptr)->rb_left)
|
2005-04-17 06:20:36 +08:00
|
|
|
*sp->pptr = (*sp->pptr)->rb_left;
|
|
|
|
if (sp > stk) {
|
|
|
|
sp--;
|
2008-12-10 14:35:02 +08:00
|
|
|
if (!*sp->pptr) {
|
|
|
|
WARN_ON(1);
|
2006-08-11 14:35:16 +08:00
|
|
|
return NULL;
|
2008-12-10 14:35:02 +08:00
|
|
|
}
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_next_rb_node(sp->pptr);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct htb_class *cl;
|
2013-06-15 18:30:10 +08:00
|
|
|
struct htb_prio *clp;
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
cl = rb_entry(*sp->pptr, struct htb_class, node[prio]);
|
|
|
|
if (!cl->level)
|
2005-04-17 06:20:36 +08:00
|
|
|
return cl;
|
2018-09-08 04:29:14 +08:00
|
|
|
clp = &cl->inner.clprio[prio];
|
2013-06-15 18:30:10 +08:00
|
|
|
(++sp)->root = clp->feed.rb_node;
|
|
|
|
sp->pptr = &clp->ptr;
|
|
|
|
sp->pid = &clp->last_ptr_id;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2008-07-26 12:43:18 +08:00
|
|
|
WARN_ON(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* dequeues packet at given priority and level; call only if
|
2011-01-20 03:26:56 +08:00
|
|
|
* you are sure that there is active class at prio/level
|
|
|
|
*/
|
2013-06-15 18:30:10 +08:00
|
|
|
static struct sk_buff *htb_dequeue_tree(struct htb_sched *q, const int prio,
|
|
|
|
const int level)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sk_buff *skb = NULL;
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl, *start;
|
2013-06-15 18:30:10 +08:00
|
|
|
struct htb_level *hlevel = &q->hlevel[level];
|
|
|
|
struct htb_prio *hprio = &hlevel->hprio[prio];
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* look initial class up in the row */
|
2013-06-15 18:30:10 +08:00
|
|
|
start = cl = htb_lookup_leaf(hprio, prio);
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
do {
|
|
|
|
next:
|
2008-12-10 14:35:02 +08:00
|
|
|
if (unlikely(!cl))
|
2006-08-11 14:35:16 +08:00
|
|
|
return NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* class can be empty - it is unlikely but can be true if leaf
|
2011-01-20 03:26:56 +08:00
|
|
|
* qdisc drops packets in enqueue routine or if someone used
|
|
|
|
* graft operation on the leaf since last dequeue;
|
|
|
|
* simply deactivate and skip such class
|
|
|
|
*/
|
2018-09-08 04:29:14 +08:00
|
|
|
if (unlikely(cl->leaf.q->q.qlen == 0)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
struct htb_class *next;
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_deactivate(q, cl);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* row/level might become empty */
|
|
|
|
if ((q->row_mask[level] & (1 << prio)) == 0)
|
2006-08-11 14:35:16 +08:00
|
|
|
return NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
next = htb_lookup_leaf(hprio, prio);
|
2006-08-11 14:35:16 +08:00
|
|
|
|
|
|
|
if (cl == start) /* fix start if we just deleted it */
|
2005-04-17 06:20:36 +08:00
|
|
|
start = next;
|
|
|
|
cl = next;
|
|
|
|
goto next;
|
|
|
|
}
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2018-09-08 04:29:14 +08:00
|
|
|
skb = cl->leaf.q->dequeue(cl->leaf.q);
|
2006-08-11 14:35:16 +08:00
|
|
|
if (likely(skb != NULL))
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2008-12-04 13:09:10 +08:00
|
|
|
|
2018-09-08 04:29:14 +08:00
|
|
|
qdisc_warn_nonwc("htb", cl->leaf.q);
|
|
|
|
htb_next_rb_node(level ? &cl->parent->inner.clprio[prio].ptr:
|
2013-06-15 18:30:10 +08:00
|
|
|
&q->hlevel[0].hprio[prio].ptr);
|
|
|
|
cl = htb_lookup_leaf(hprio, prio);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
} while (cl != start);
|
|
|
|
|
|
|
|
if (likely(skb != NULL)) {
|
2012-11-06 00:40:49 +08:00
|
|
|
bstats_update(&cl->bstats, skb);
|
2018-09-08 04:29:14 +08:00
|
|
|
cl->leaf.deficit[level] -= qdisc_pkt_len(skb);
|
|
|
|
if (cl->leaf.deficit[level] < 0) {
|
|
|
|
cl->leaf.deficit[level] += cl->quantum;
|
|
|
|
htb_next_rb_node(level ? &cl->parent->inner.clprio[prio].ptr :
|
2013-06-15 18:30:10 +08:00
|
|
|
&q->hlevel[0].hprio[prio].ptr);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
/* this used to be after charge_class but this constelation
|
2011-01-20 03:26:56 +08:00
|
|
|
* gives us slightly better performance
|
|
|
|
*/
|
2018-09-08 04:29:14 +08:00
|
|
|
if (!cl->leaf.q->q.qlen)
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_deactivate(q, cl);
|
2007-07-11 13:43:16 +08:00
|
|
|
htb_charge_class(q, cl, level, skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct sk_buff *htb_dequeue(struct Qdisc *sch)
|
|
|
|
{
|
2011-01-21 15:31:33 +08:00
|
|
|
struct sk_buff *skb;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
|
|
|
int level;
|
2013-06-04 15:11:48 +08:00
|
|
|
s64 next_event;
|
2009-01-13 13:54:40 +08:00
|
|
|
unsigned long start_at;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* try to dequeue direct packets as high prio (!) to minimize cpu work */
|
2016-09-18 06:57:34 +08:00
|
|
|
skb = __qdisc_dequeue_head(&q->direct_queue);
|
2006-08-11 14:35:16 +08:00
|
|
|
if (skb != NULL) {
|
2011-01-21 15:31:33 +08:00
|
|
|
ok:
|
|
|
|
qdisc_bstats_update(sch, skb);
|
2016-02-26 06:55:02 +08:00
|
|
|
qdisc_qstats_backlog_dec(sch, skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
sch->q.qlen--;
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
if (!sch->q.qlen)
|
|
|
|
goto fin;
|
2014-08-23 09:32:09 +08:00
|
|
|
q->now = ktime_get_ns();
|
2009-01-13 13:54:40 +08:00
|
|
|
start_at = jiffies;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-12-21 23:04:59 +08:00
|
|
|
next_event = q->now + 5LLU * NSEC_PER_SEC;
|
2008-12-04 13:09:10 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
for (level = 0; level < TC_HTB_MAXDEPTH; level++) {
|
|
|
|
/* common case optimization - skip event handler quickly */
|
|
|
|
int m;
|
2013-06-15 18:30:10 +08:00
|
|
|
s64 event = q->near_ev_cache[level];
|
2007-03-16 16:22:39 +08:00
|
|
|
|
2013-06-15 18:30:10 +08:00
|
|
|
if (q->now >= event) {
|
2009-01-13 13:54:40 +08:00
|
|
|
event = htb_do_events(q, level, start_at);
|
2007-05-24 14:39:54 +08:00
|
|
|
if (!event)
|
2012-10-31 14:04:11 +08:00
|
|
|
event = q->now + NSEC_PER_SEC;
|
2007-05-24 14:39:54 +08:00
|
|
|
q->near_ev_cache[level] = event;
|
2013-06-15 18:30:10 +08:00
|
|
|
}
|
2007-03-16 16:22:39 +08:00
|
|
|
|
2009-01-13 13:54:16 +08:00
|
|
|
if (next_event > event)
|
2007-03-16 16:22:39 +08:00
|
|
|
next_event = event;
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
m = ~q->row_mask[level];
|
|
|
|
while (m != (int)(-1)) {
|
2006-08-11 14:35:16 +08:00
|
|
|
int prio = ffz(m);
|
2011-01-20 03:26:56 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
m |= 1 << prio;
|
2006-08-11 14:35:16 +08:00
|
|
|
skb = htb_dequeue_tree(q, prio, level);
|
2011-01-21 15:31:33 +08:00
|
|
|
if (likely(skb != NULL))
|
|
|
|
goto ok;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2016-05-24 05:24:56 +08:00
|
|
|
if (likely(next_event > q->now))
|
2016-06-11 07:41:39 +08:00
|
|
|
qdisc_watchdog_schedule_ns(&q->watchdog, next_event);
|
2016-05-24 05:24:56 +08:00
|
|
|
else
|
2009-02-01 17:13:22 +08:00
|
|
|
schedule_work(&q->work);
|
2005-04-17 06:20:36 +08:00
|
|
|
fin:
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* reset all classes */
|
|
|
|
/* always caled under BH & queue lock */
|
2006-08-11 14:35:16 +08:00
|
|
|
static void htb_reset(struct Qdisc *sch)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2008-07-06 14:22:35 +08:00
|
|
|
struct htb_class *cl;
|
|
|
|
unsigned int i;
|
2006-08-11 14:35:38 +08:00
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
for (i = 0; i < q->clhash.hashsize; 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 09:06:00 +08:00
|
|
|
hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (cl->level)
|
2018-09-08 04:29:14 +08:00
|
|
|
memset(&cl->inner, 0, sizeof(cl->inner));
|
2005-04-17 06:20:36 +08:00
|
|
|
else {
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (cl->leaf.q && !q->offload)
|
2018-09-08 04:29:14 +08:00
|
|
|
qdisc_reset(cl->leaf.q);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
cl->prio_activity = 0;
|
|
|
|
cl->cmode = HTB_CAN_SEND;
|
|
|
|
}
|
|
|
|
}
|
2007-03-16 16:22:39 +08:00
|
|
|
qdisc_watchdog_cancel(&q->watchdog);
|
2016-06-14 11:21:56 +08:00
|
|
|
__qdisc_reset_queue(&q->direct_queue);
|
2013-06-15 18:30:10 +08:00
|
|
|
memset(q->hlevel, 0, sizeof(q->hlevel));
|
2006-08-11 14:35:16 +08:00
|
|
|
memset(q->row_mask, 0, sizeof(q->row_mask));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-01-24 12:35:39 +08:00
|
|
|
static const struct nla_policy htb_policy[TCA_HTB_MAX + 1] = {
|
|
|
|
[TCA_HTB_PARMS] = { .len = sizeof(struct tc_htb_opt) },
|
|
|
|
[TCA_HTB_INIT] = { .len = sizeof(struct tc_htb_glob) },
|
|
|
|
[TCA_HTB_CTAB] = { .type = NLA_BINARY, .len = TC_RTAB_SIZE },
|
|
|
|
[TCA_HTB_RTAB] = { .type = NLA_BINARY, .len = TC_RTAB_SIZE },
|
2013-03-06 14:49:21 +08:00
|
|
|
[TCA_HTB_DIRECT_QLEN] = { .type = NLA_U32 },
|
2013-09-20 00:10:20 +08:00
|
|
|
[TCA_HTB_RATE64] = { .type = NLA_U64 },
|
|
|
|
[TCA_HTB_CEIL64] = { .type = NLA_U64 },
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
[TCA_HTB_OFFLOAD] = { .type = NLA_FLAG },
|
2008-01-24 12:35:39 +08:00
|
|
|
};
|
|
|
|
|
2009-02-01 17:13:22 +08:00
|
|
|
static void htb_work_func(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct htb_sched *q = container_of(work, struct htb_sched, work);
|
|
|
|
struct Qdisc *sch = q->watchdog.qdisc;
|
|
|
|
|
2016-06-14 12:16:27 +08:00
|
|
|
rcu_read_lock();
|
2009-02-01 17:13:22 +08:00
|
|
|
__netif_schedule(qdisc_root(sch));
|
2016-06-14 12:16:27 +08:00
|
|
|
rcu_read_unlock();
|
2009-02-01 17:13:22 +08:00
|
|
|
}
|
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
static void htb_set_lockdep_class_child(struct Qdisc *q)
|
|
|
|
{
|
|
|
|
static struct lock_class_key child_key;
|
|
|
|
|
|
|
|
lockdep_set_class(qdisc_lock(q), &child_key);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int htb_offload(struct net_device *dev, struct tc_htb_qopt_offload *opt)
|
|
|
|
{
|
|
|
|
return dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_HTB, opt);
|
|
|
|
}
|
|
|
|
|
2017-12-21 01:35:13 +08:00
|
|
|
static int htb_init(struct Qdisc *sch, struct nlattr *opt,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
struct tc_htb_qopt_offload offload_opt;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2013-03-06 14:49:21 +08:00
|
|
|
struct nlattr *tb[TCA_HTB_MAX + 1];
|
2005-04-17 06:20:36 +08:00
|
|
|
struct tc_htb_glob *gopt;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
unsigned int ntx;
|
2021-03-11 22:42:06 +08:00
|
|
|
bool offload;
|
2008-01-24 12:33:32 +08:00
|
|
|
int err;
|
|
|
|
|
2017-08-30 17:48:57 +08:00
|
|
|
qdisc_watchdog_init(&q->watchdog, sch);
|
|
|
|
INIT_WORK(&q->work, htb_work_func);
|
|
|
|
|
2008-01-24 12:33:32 +08:00
|
|
|
if (!opt)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-12-21 01:35:19 +08:00
|
|
|
err = tcf_block_get(&q->block, &q->filter_list, sch, extack);
|
2017-05-17 17:07:55 +08:00
|
|
|
if (err)
|
|
|
|
return 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 20:07:28 +08:00
|
|
|
err = nla_parse_nested_deprecated(tb, TCA_HTB_MAX, opt, htb_policy,
|
|
|
|
NULL);
|
2008-01-24 12:33:32 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2013-03-06 14:49:21 +08:00
|
|
|
if (!tb[TCA_HTB_INIT])
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EINVAL;
|
2013-03-06 14:49:21 +08:00
|
|
|
|
2008-01-23 14:11:17 +08:00
|
|
|
gopt = nla_data(tb[TCA_HTB_INIT]);
|
2013-03-06 14:49:21 +08:00
|
|
|
if (gopt->version != HTB_VER >> 16)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2021-03-11 22:42:06 +08:00
|
|
|
offload = nla_get_flag(tb[TCA_HTB_OFFLOAD]);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2021-03-11 22:42:06 +08:00
|
|
|
if (offload) {
|
2021-10-28 20:24:36 +08:00
|
|
|
if (sch->parent != TC_H_ROOT) {
|
|
|
|
NL_SET_ERR_MSG(extack, "HTB must be the root qdisc to use offload");
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
return -EOPNOTSUPP;
|
2021-10-28 20:24:36 +08:00
|
|
|
}
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2021-10-28 20:24:36 +08:00
|
|
|
if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc) {
|
|
|
|
NL_SET_ERR_MSG(extack, "hw-tc-offload ethtool feature flag must be on");
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
return -EOPNOTSUPP;
|
2021-10-28 20:24:36 +08:00
|
|
|
}
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
|
|
|
q->num_direct_qdiscs = dev->real_num_tx_queues;
|
|
|
|
q->direct_qdiscs = kcalloc(q->num_direct_qdiscs,
|
|
|
|
sizeof(*q->direct_qdiscs),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!q->direct_qdiscs)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
err = qdisc_class_hash_init(&q->clhash);
|
|
|
|
if (err < 0)
|
2022-09-02 16:34:30 +08:00
|
|
|
return err;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-03-06 14:49:21 +08:00
|
|
|
if (tb[TCA_HTB_DIRECT_QLEN])
|
|
|
|
q->direct_qlen = nla_get_u32(tb[TCA_HTB_DIRECT_QLEN]);
|
2015-08-18 16:30:49 +08:00
|
|
|
else
|
2013-03-06 14:49:21 +08:00
|
|
|
q->direct_qlen = qdisc_dev(sch)->tx_queue_len;
|
2015-08-18 16:30:49 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((q->rate2quantum = gopt->rate2quantum) < 1)
|
|
|
|
q->rate2quantum = 1;
|
|
|
|
q->defcls = gopt->defcls;
|
|
|
|
|
2021-03-11 22:42:06 +08:00
|
|
|
if (!offload)
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (ntx = 0; ntx < q->num_direct_qdiscs; ntx++) {
|
|
|
|
struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, ntx);
|
|
|
|
struct Qdisc *qdisc;
|
|
|
|
|
|
|
|
qdisc = qdisc_create_dflt(dev_queue, &pfifo_qdisc_ops,
|
|
|
|
TC_H_MAKE(sch->handle, 0), extack);
|
|
|
|
if (!qdisc) {
|
2022-09-02 16:34:30 +08:00
|
|
|
return -ENOMEM;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
htb_set_lockdep_class_child(qdisc);
|
|
|
|
q->direct_qdiscs[ntx] = qdisc;
|
|
|
|
qdisc->flags |= TCQ_F_ONETXQUEUE | TCQ_F_NOPARENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
sch->flags |= TCQ_F_MQROOT;
|
|
|
|
|
|
|
|
offload_opt = (struct tc_htb_qopt_offload) {
|
|
|
|
.command = TC_HTB_CREATE,
|
|
|
|
.parent_classid = TC_H_MAJ(sch->handle) >> 16,
|
|
|
|
.classid = TC_H_MIN(q->defcls),
|
|
|
|
.extack = extack,
|
|
|
|
};
|
|
|
|
err = htb_offload(dev, &offload_opt);
|
|
|
|
if (err)
|
2022-09-02 16:34:30 +08:00
|
|
|
return err;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2021-03-11 22:42:06 +08:00
|
|
|
/* Defer this assignment, so that htb_destroy skips offload-related
|
|
|
|
* parts (especially calling ndo_setup_tc) on errors.
|
|
|
|
*/
|
|
|
|
q->offload = true;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void htb_attach_offload(struct Qdisc *sch)
|
|
|
|
{
|
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
|
|
|
unsigned int ntx;
|
|
|
|
|
|
|
|
for (ntx = 0; ntx < q->num_direct_qdiscs; ntx++) {
|
|
|
|
struct Qdisc *old, *qdisc = q->direct_qdiscs[ntx];
|
|
|
|
|
|
|
|
old = dev_graft_qdisc(qdisc->dev_queue, qdisc);
|
|
|
|
qdisc_put(old);
|
|
|
|
qdisc_hash_add(qdisc, false);
|
|
|
|
}
|
|
|
|
for (ntx = q->num_direct_qdiscs; ntx < dev->num_tx_queues; ntx++) {
|
|
|
|
struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, ntx);
|
|
|
|
struct Qdisc *old = dev_graft_qdisc(dev_queue, NULL);
|
|
|
|
|
|
|
|
qdisc_put(old);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(q->direct_qdiscs);
|
|
|
|
q->direct_qdiscs = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void htb_attach_software(struct Qdisc *sch)
|
|
|
|
{
|
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
unsigned int ntx;
|
|
|
|
|
|
|
|
/* Resemble qdisc_graft behavior. */
|
|
|
|
for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
|
|
|
|
struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, ntx);
|
|
|
|
struct Qdisc *old = dev_graft_qdisc(dev_queue, sch);
|
|
|
|
|
|
|
|
qdisc_refcount_inc(sch);
|
|
|
|
|
|
|
|
qdisc_put(old);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void htb_attach(struct Qdisc *sch)
|
|
|
|
{
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
|
|
|
|
|
|
|
if (q->offload)
|
|
|
|
htb_attach_offload(sch);
|
|
|
|
else
|
|
|
|
htb_attach_software(sch);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int htb_dump(struct Qdisc *sch, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2008-01-24 12:34:11 +08:00
|
|
|
struct nlattr *nest;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct tc_htb_glob gopt;
|
2008-01-24 12:34:11 +08:00
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (q->offload)
|
|
|
|
sch->flags |= TCQ_F_OFFLOADED;
|
|
|
|
else
|
|
|
|
sch->flags &= ~TCQ_F_OFFLOADED;
|
|
|
|
|
2019-05-05 02:43:42 +08:00
|
|
|
sch->qstats.overlimits = q->overlimits;
|
2014-03-06 02:14:34 +08:00
|
|
|
/* Its safe to not acquire qdisc lock. As we hold RTNL,
|
|
|
|
* no change can happen on the qdisc parameters.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-24 12:34:11 +08:00
|
|
|
gopt.direct_pkts = q->direct_pkts;
|
2005-04-17 06:20:36 +08:00
|
|
|
gopt.version = HTB_VER;
|
|
|
|
gopt.rate2quantum = q->rate2quantum;
|
|
|
|
gopt.defcls = q->defcls;
|
2006-08-11 14:31:08 +08:00
|
|
|
gopt.debug = 0;
|
2008-01-24 12:34:11 +08:00
|
|
|
|
2019-04-26 17:13:06 +08:00
|
|
|
nest = nla_nest_start_noflag(skb, TCA_OPTIONS);
|
2008-01-24 12:34:11 +08:00
|
|
|
if (nest == NULL)
|
|
|
|
goto nla_put_failure;
|
2013-03-06 14:49:21 +08:00
|
|
|
if (nla_put(skb, TCA_HTB_INIT, sizeof(gopt), &gopt) ||
|
|
|
|
nla_put_u32(skb, TCA_HTB_DIRECT_QLEN, q->direct_qlen))
|
2012-03-29 17:11:39 +08:00
|
|
|
goto nla_put_failure;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (q->offload && nla_put_flag(skb, TCA_HTB_OFFLOAD))
|
|
|
|
goto nla_put_failure;
|
2008-01-24 12:34:11 +08:00
|
|
|
|
2014-03-06 02:14:34 +08:00
|
|
|
return nla_nest_end(skb, nest);
|
2008-01-24 12:34:11 +08:00
|
|
|
|
2008-01-23 14:11:17 +08:00
|
|
|
nla_put_failure:
|
2008-01-24 12:34:11 +08:00
|
|
|
nla_nest_cancel(skb, nest);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int htb_dump_class(struct Qdisc *sch, unsigned long arg,
|
2006-08-11 14:35:16 +08:00
|
|
|
struct sk_buff *skb, struct tcmsg *tcm)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl = (struct htb_class *)arg;
|
2021-01-19 20:08:14 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2008-01-24 12:34:11 +08:00
|
|
|
struct nlattr *nest;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct tc_htb_opt opt;
|
|
|
|
|
2014-03-06 02:14:34 +08:00
|
|
|
/* Its safe to not acquire qdisc lock. As we hold RTNL,
|
|
|
|
* no change can happen on the class parameters.
|
|
|
|
*/
|
2008-07-06 14:22:35 +08:00
|
|
|
tcm->tcm_parent = cl->parent ? cl->parent->common.classid : TC_H_ROOT;
|
|
|
|
tcm->tcm_handle = cl->common.classid;
|
2018-09-08 04:29:14 +08:00
|
|
|
if (!cl->level && cl->leaf.q)
|
|
|
|
tcm->tcm_info = cl->leaf.q->handle;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2019-04-26 17:13:06 +08:00
|
|
|
nest = nla_nest_start_noflag(skb, TCA_OPTIONS);
|
2008-01-24 12:34:11 +08:00
|
|
|
if (nest == NULL)
|
|
|
|
goto nla_put_failure;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
memset(&opt, 0, sizeof(opt));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-02 21:55:05 +08:00
|
|
|
psched_ratecfg_getrate(&opt.rate, &cl->rate);
|
2013-02-12 08:12:00 +08:00
|
|
|
opt.buffer = PSCHED_NS2TICKS(cl->buffer);
|
2013-06-02 21:55:05 +08:00
|
|
|
psched_ratecfg_getrate(&opt.ceil, &cl->ceil);
|
2013-02-12 08:12:00 +08:00
|
|
|
opt.cbuffer = PSCHED_NS2TICKS(cl->cbuffer);
|
2008-12-04 13:09:45 +08:00
|
|
|
opt.quantum = cl->quantum;
|
|
|
|
opt.prio = cl->prio;
|
2006-08-11 14:35:16 +08:00
|
|
|
opt.level = cl->level;
|
2012-03-29 17:11:39 +08:00
|
|
|
if (nla_put(skb, TCA_HTB_PARMS, sizeof(opt), &opt))
|
|
|
|
goto nla_put_failure;
|
2021-01-19 20:08:14 +08:00
|
|
|
if (q->offload && nla_put_flag(skb, TCA_HTB_OFFLOAD))
|
|
|
|
goto nla_put_failure;
|
2013-09-20 00:10:20 +08:00
|
|
|
if ((cl->rate.rate_bytes_ps >= (1ULL << 32)) &&
|
2016-04-25 16:25:15 +08:00
|
|
|
nla_put_u64_64bit(skb, TCA_HTB_RATE64, cl->rate.rate_bytes_ps,
|
|
|
|
TCA_HTB_PAD))
|
2013-09-20 00:10:20 +08:00
|
|
|
goto nla_put_failure;
|
|
|
|
if ((cl->ceil.rate_bytes_ps >= (1ULL << 32)) &&
|
2016-04-25 16:25:15 +08:00
|
|
|
nla_put_u64_64bit(skb, TCA_HTB_CEIL64, cl->ceil.rate_bytes_ps,
|
|
|
|
TCA_HTB_PAD))
|
2013-09-20 00:10:20 +08:00
|
|
|
goto nla_put_failure;
|
2008-01-24 12:34:11 +08:00
|
|
|
|
2014-03-06 02:14:34 +08:00
|
|
|
return nla_nest_end(skb, nest);
|
2008-01-24 12:34:11 +08:00
|
|
|
|
2008-01-23 14:11:17 +08:00
|
|
|
nla_put_failure:
|
2008-01-24 12:34:11 +08:00
|
|
|
nla_nest_cancel(skb, nest);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2021-01-19 20:08:14 +08:00
|
|
|
static void htb_offload_aggregate_stats(struct htb_sched *q,
|
|
|
|
struct htb_class *cl)
|
|
|
|
{
|
2021-10-16 16:49:08 +08:00
|
|
|
u64 bytes = 0, packets = 0;
|
2021-01-19 20:08:14 +08:00
|
|
|
struct htb_class *c;
|
|
|
|
unsigned int i;
|
|
|
|
|
2021-10-16 16:49:09 +08:00
|
|
|
gnet_stats_basic_sync_init(&cl->bstats);
|
2021-01-19 20:08:14 +08:00
|
|
|
|
|
|
|
for (i = 0; i < q->clhash.hashsize; i++) {
|
|
|
|
hlist_for_each_entry(c, &q->clhash.hash[i], common.hnode) {
|
|
|
|
struct htb_class *p = c;
|
|
|
|
|
|
|
|
while (p && p->level < cl->level)
|
|
|
|
p = p->parent;
|
|
|
|
|
|
|
|
if (p != cl)
|
|
|
|
continue;
|
|
|
|
|
2021-10-16 16:49:09 +08:00
|
|
|
bytes += u64_stats_read(&c->bstats_bias.bytes);
|
|
|
|
packets += u64_stats_read(&c->bstats_bias.packets);
|
2021-01-19 20:08:14 +08:00
|
|
|
if (c->level == 0) {
|
2021-10-16 16:49:09 +08:00
|
|
|
bytes += u64_stats_read(&c->leaf.q->bstats.bytes);
|
|
|
|
packets += u64_stats_read(&c->leaf.q->bstats.packets);
|
2021-01-19 20:08:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-10-16 16:49:08 +08:00
|
|
|
_bstats_update(&cl->bstats, bytes, packets);
|
2021-01-19 20:08:14 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static int
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_dump_class_stats(struct Qdisc *sch, unsigned long arg, struct gnet_dump *d)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl = (struct htb_class *)arg;
|
2021-01-19 20:08:14 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2016-06-22 14:16:51 +08:00
|
|
|
struct gnet_stats_queue qs = {
|
|
|
|
.drops = cl->drops,
|
2017-09-19 03:36:22 +08:00
|
|
|
.overlimits = cl->overlimits,
|
2016-06-22 14:16:51 +08:00
|
|
|
};
|
2014-09-29 02:53:57 +08:00
|
|
|
__u32 qlen = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2019-03-28 23:53:12 +08:00
|
|
|
if (!cl->level && cl->leaf.q)
|
|
|
|
qdisc_qstats_qlen_backlog(cl->leaf.q, &qlen, &qs.backlog);
|
|
|
|
|
2016-07-16 22:08:56 +08:00
|
|
|
cl->xstats.tokens = clamp_t(s64, PSCHED_NS2TICKS(cl->tokens),
|
|
|
|
INT_MIN, INT_MAX);
|
|
|
|
cl->xstats.ctokens = clamp_t(s64, PSCHED_NS2TICKS(cl->ctokens),
|
|
|
|
INT_MIN, INT_MAX);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2021-01-19 20:08:14 +08:00
|
|
|
if (q->offload) {
|
|
|
|
if (!cl->level) {
|
|
|
|
if (cl->leaf.q)
|
|
|
|
cl->bstats = cl->leaf.q->bstats;
|
|
|
|
else
|
2021-10-16 16:49:09 +08:00
|
|
|
gnet_stats_basic_sync_init(&cl->bstats);
|
2021-10-16 16:49:08 +08:00
|
|
|
_bstats_update(&cl->bstats,
|
2021-10-16 16:49:09 +08:00
|
|
|
u64_stats_read(&cl->bstats_bias.bytes),
|
|
|
|
u64_stats_read(&cl->bstats_bias.packets));
|
2021-01-19 20:08:14 +08:00
|
|
|
} else {
|
|
|
|
htb_offload_aggregate_stats(q, cl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
net: sched: Remove Qdisc::running sequence counter
The Qdisc::running sequence counter has two uses:
1. Reliably reading qdisc's tc statistics while the qdisc is running
(a seqcount read/retry loop at gnet_stats_add_basic()).
2. As a flag, indicating whether the qdisc in question is running
(without any retry loops).
For the first usage, the Qdisc::running sequence counter write section,
qdisc_run_begin() => qdisc_run_end(), covers a much wider area than what
is actually needed: the raw qdisc's bstats update. A u64_stats sync
point was thus introduced (in previous commits) inside the bstats
structure itself. A local u64_stats write section is then started and
stopped for the bstats updates.
Use that u64_stats sync point mechanism for the bstats read/retry loop
at gnet_stats_add_basic().
For the second qdisc->running usage, a __QDISC_STATE_RUNNING bit flag,
accessed with atomic bitops, is sufficient. Using a bit flag instead of
a sequence counter at qdisc_run_begin/end() and qdisc_is_running() leads
to the SMP barriers implicitly added through raw_read_seqcount() and
write_seqcount_begin/end() getting removed. All call sites have been
surveyed though, and no required ordering was identified.
Now that the qdisc->running sequence counter is no longer used, remove
it.
Note, using u64_stats implies no sequence counter protection for 64-bit
architectures. This can lead to the qdisc tc statistics "packets" vs.
"bytes" values getting out of sync on rare occasions. The individual
values will still be valid.
Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-10-16 16:49:10 +08:00
|
|
|
if (gnet_stats_copy_basic(d, NULL, &cl->bstats, true) < 0 ||
|
2016-12-05 01:48:16 +08:00
|
|
|
gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 ||
|
2016-06-22 14:16:51 +08:00
|
|
|
gnet_stats_copy_queue(d, NULL, &qs, qlen) < 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return gnet_stats_copy_app(d, &cl->xstats, sizeof(cl->xstats));
|
|
|
|
}
|
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
static struct netdev_queue *
|
|
|
|
htb_select_queue(struct Qdisc *sch, struct tcmsg *tcm)
|
|
|
|
{
|
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
struct tc_htb_qopt_offload offload_opt;
|
2021-03-11 22:42:05 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
int err;
|
|
|
|
|
2021-03-11 22:42:05 +08:00
|
|
|
if (!q->offload)
|
|
|
|
return sch->dev_queue;
|
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
offload_opt = (struct tc_htb_qopt_offload) {
|
|
|
|
.command = TC_HTB_LEAF_QUERY_QUEUE,
|
|
|
|
.classid = TC_H_MIN(tcm->tcm_parent),
|
|
|
|
};
|
|
|
|
err = htb_offload(dev, &offload_opt);
|
|
|
|
if (err || offload_opt.qid >= dev->num_tx_queues)
|
|
|
|
return NULL;
|
|
|
|
return netdev_get_tx_queue(dev, offload_opt.qid);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct Qdisc *
|
|
|
|
htb_graft_helper(struct netdev_queue *dev_queue, struct Qdisc *new_q)
|
|
|
|
{
|
|
|
|
struct net_device *dev = dev_queue->dev;
|
|
|
|
struct Qdisc *old_q;
|
|
|
|
|
|
|
|
if (dev->flags & IFF_UP)
|
|
|
|
dev_deactivate(dev);
|
|
|
|
old_q = dev_graft_qdisc(dev_queue, new_q);
|
|
|
|
if (new_q)
|
|
|
|
new_q->flags |= TCQ_F_ONETXQUEUE | TCQ_F_NOPARENT;
|
|
|
|
if (dev->flags & IFF_UP)
|
|
|
|
dev_activate(dev);
|
|
|
|
|
|
|
|
return old_q;
|
|
|
|
}
|
|
|
|
|
2021-08-26 19:54:25 +08:00
|
|
|
static struct netdev_queue *htb_offload_get_queue(struct htb_class *cl)
|
|
|
|
{
|
|
|
|
struct netdev_queue *queue;
|
|
|
|
|
|
|
|
queue = cl->leaf.offload_queue;
|
|
|
|
if (!(cl->leaf.q->flags & TCQ_F_BUILTIN))
|
|
|
|
WARN_ON(cl->leaf.q->dev_queue != queue);
|
|
|
|
|
|
|
|
return queue;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void htb_offload_move_qdisc(struct Qdisc *sch, struct htb_class *cl_old,
|
|
|
|
struct htb_class *cl_new, bool destroying)
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
{
|
|
|
|
struct netdev_queue *queue_old, *queue_new;
|
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
|
2021-08-26 19:54:25 +08:00
|
|
|
queue_old = htb_offload_get_queue(cl_old);
|
|
|
|
queue_new = htb_offload_get_queue(cl_new);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2021-08-26 19:54:25 +08:00
|
|
|
if (!destroying) {
|
|
|
|
struct Qdisc *qdisc;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2021-08-26 19:54:25 +08:00
|
|
|
if (dev->flags & IFF_UP)
|
|
|
|
dev_deactivate(dev);
|
|
|
|
qdisc = dev_graft_qdisc(queue_old, NULL);
|
|
|
|
WARN_ON(qdisc != cl_old->leaf.q);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(cl_old->leaf.q->flags & TCQ_F_BUILTIN))
|
|
|
|
cl_old->leaf.q->dev_queue = queue_new;
|
|
|
|
cl_old->leaf.offload_queue = queue_new;
|
|
|
|
|
|
|
|
if (!destroying) {
|
|
|
|
struct Qdisc *qdisc;
|
|
|
|
|
|
|
|
qdisc = dev_graft_qdisc(queue_new, cl_old->leaf.q);
|
|
|
|
if (dev->flags & IFF_UP)
|
|
|
|
dev_activate(dev);
|
|
|
|
WARN_ON(!(qdisc->flags & TCQ_F_BUILTIN));
|
|
|
|
}
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static int htb_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
|
2017-12-21 01:35:17 +08:00
|
|
|
struct Qdisc **old, struct netlink_ext_ack *extack)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct netdev_queue *dev_queue = sch->dev_queue;
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl = (struct htb_class *)arg;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
|
|
|
struct Qdisc *old_q;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-04 14:41:17 +08:00
|
|
|
if (cl->level)
|
|
|
|
return -EINVAL;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2021-08-26 19:54:25 +08:00
|
|
|
if (q->offload)
|
|
|
|
dev_queue = htb_offload_get_queue(cl);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
|
|
|
if (!new) {
|
|
|
|
new = qdisc_create_dflt(dev_queue, &pfifo_qdisc_ops,
|
|
|
|
cl->common.classid, extack);
|
|
|
|
if (!new)
|
|
|
|
return -ENOBUFS;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (q->offload) {
|
|
|
|
htb_set_lockdep_class_child(new);
|
|
|
|
/* One ref for cl->leaf.q, the other for dev_queue->qdisc. */
|
|
|
|
qdisc_refcount_inc(new);
|
|
|
|
old_q = htb_graft_helper(dev_queue, new);
|
|
|
|
}
|
2009-09-04 14:41:17 +08:00
|
|
|
|
2018-09-08 04:29:14 +08:00
|
|
|
*old = qdisc_replace(sch, new, &cl->leaf.q);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
|
|
|
if (q->offload) {
|
|
|
|
WARN_ON(old_q != *old);
|
|
|
|
qdisc_put(old_q);
|
|
|
|
}
|
|
|
|
|
2009-09-04 14:41:17 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
static struct Qdisc *htb_leaf(struct Qdisc *sch, unsigned long arg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl = (struct htb_class *)arg;
|
2018-09-08 04:29:14 +08:00
|
|
|
return !cl->level ? cl->leaf.q : NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-11-30 09:37:05 +08:00
|
|
|
static void htb_qlen_notify(struct Qdisc *sch, unsigned long arg)
|
|
|
|
{
|
|
|
|
struct htb_class *cl = (struct htb_class *)arg;
|
|
|
|
|
2017-08-15 21:39:59 +08:00
|
|
|
htb_deactivate(qdisc_priv(sch), cl);
|
2006-11-30 09:37:05 +08:00
|
|
|
}
|
|
|
|
|
2006-12-08 16:26:56 +08:00
|
|
|
static inline int htb_parent_last_child(struct htb_class *cl)
|
|
|
|
{
|
|
|
|
if (!cl->parent)
|
|
|
|
/* the root class */
|
|
|
|
return 0;
|
2008-07-06 14:22:53 +08:00
|
|
|
if (cl->parent->children > 1)
|
2006-12-08 16:26:56 +08:00
|
|
|
/* not the last child */
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
static void htb_parent_to_leaf(struct Qdisc *sch, struct htb_class *cl,
|
2008-05-04 11:46:29 +08:00
|
|
|
struct Qdisc *new_q)
|
2006-12-08 16:26:56 +08:00
|
|
|
{
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2006-12-08 16:26:56 +08:00
|
|
|
struct htb_class *parent = cl->parent;
|
|
|
|
|
2018-09-08 04:29:14 +08:00
|
|
|
WARN_ON(cl->level || !cl->leaf.q || cl->prio_activity);
|
2006-12-08 16:26:56 +08:00
|
|
|
|
2008-05-04 11:46:29 +08:00
|
|
|
if (parent->cmode != HTB_CAN_SEND)
|
2013-06-15 18:30:10 +08:00
|
|
|
htb_safe_rb_erase(&parent->pq_node,
|
|
|
|
&q->hlevel[parent->level].wait_pq);
|
2008-05-04 11:46:29 +08:00
|
|
|
|
2006-12-08 16:26:56 +08:00
|
|
|
parent->level = 0;
|
2018-09-08 04:29:14 +08:00
|
|
|
memset(&parent->inner, 0, sizeof(parent->inner));
|
|
|
|
parent->leaf.q = new_q ? new_q : &noop_qdisc;
|
2006-12-08 16:26:56 +08:00
|
|
|
parent->tokens = parent->buffer;
|
|
|
|
parent->ctokens = parent->cbuffer;
|
2014-08-23 09:32:09 +08:00
|
|
|
parent->t_c = ktime_get_ns();
|
2006-12-08 16:26:56 +08:00
|
|
|
parent->cmode = HTB_CAN_SEND;
|
2021-08-26 19:54:25 +08:00
|
|
|
if (q->offload)
|
|
|
|
parent->leaf.offload_queue = cl->leaf.offload_queue;
|
2006-12-08 16:26:56 +08:00
|
|
|
}
|
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
static void htb_parent_to_leaf_offload(struct Qdisc *sch,
|
|
|
|
struct netdev_queue *dev_queue,
|
|
|
|
struct Qdisc *new_q)
|
|
|
|
{
|
|
|
|
struct Qdisc *old_q;
|
|
|
|
|
|
|
|
/* One ref for cl->leaf.q, the other for dev_queue->qdisc. */
|
2021-06-04 19:03:18 +08:00
|
|
|
if (new_q)
|
|
|
|
qdisc_refcount_inc(new_q);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
old_q = htb_graft_helper(dev_queue, new_q);
|
|
|
|
WARN_ON(!(old_q->flags & TCQ_F_BUILTIN));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int htb_destroy_class_offload(struct Qdisc *sch, struct htb_class *cl,
|
|
|
|
bool last_child, bool destroying,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
struct tc_htb_qopt_offload offload_opt;
|
2021-08-26 19:54:25 +08:00
|
|
|
struct netdev_queue *dev_queue;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct Qdisc *q = cl->leaf.q;
|
2023-01-13 08:55:29 +08:00
|
|
|
struct Qdisc *old;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (cl->level)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
WARN_ON(!q);
|
2021-08-26 19:54:25 +08:00
|
|
|
dev_queue = htb_offload_get_queue(cl);
|
2023-01-13 08:55:29 +08:00
|
|
|
/* When destroying, caller qdisc_graft grafts the new qdisc and invokes
|
|
|
|
* qdisc_put for the qdisc being destroyed. htb_destroy_class_offload
|
|
|
|
* does not need to graft or qdisc_put the qdisc being destroyed.
|
|
|
|
*/
|
|
|
|
if (!destroying) {
|
|
|
|
old = htb_graft_helper(dev_queue, NULL);
|
|
|
|
/* Last qdisc grafted should be the same as cl->leaf.q when
|
|
|
|
* calling htb_delete.
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
*/
|
|
|
|
WARN_ON(old != q);
|
2023-01-13 08:55:29 +08:00
|
|
|
}
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2021-01-19 20:08:14 +08:00
|
|
|
if (cl->parent) {
|
2021-10-16 16:49:08 +08:00
|
|
|
_bstats_update(&cl->parent->bstats_bias,
|
2021-10-16 16:49:09 +08:00
|
|
|
u64_stats_read(&q->bstats.bytes),
|
|
|
|
u64_stats_read(&q->bstats.packets));
|
2021-01-19 20:08:14 +08:00
|
|
|
}
|
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
offload_opt = (struct tc_htb_qopt_offload) {
|
|
|
|
.command = !last_child ? TC_HTB_LEAF_DEL :
|
|
|
|
destroying ? TC_HTB_LEAF_DEL_LAST_FORCE :
|
|
|
|
TC_HTB_LEAF_DEL_LAST,
|
|
|
|
.classid = cl->common.classid,
|
|
|
|
.extack = extack,
|
|
|
|
};
|
|
|
|
err = htb_offload(qdisc_dev(sch), &offload_opt);
|
|
|
|
|
2023-01-13 08:55:29 +08:00
|
|
|
if (!destroying) {
|
|
|
|
if (!err)
|
|
|
|
qdisc_put(old);
|
|
|
|
else
|
|
|
|
htb_graft_helper(dev_queue, old);
|
|
|
|
}
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
|
|
|
if (last_child)
|
|
|
|
return err;
|
|
|
|
|
2021-08-26 19:54:25 +08:00
|
|
|
if (!err && offload_opt.classid != TC_H_MIN(cl->common.classid)) {
|
|
|
|
u32 classid = TC_H_MAJ(sch->handle) |
|
|
|
|
TC_H_MIN(offload_opt.classid);
|
|
|
|
struct htb_class *moved_cl = htb_find(classid, sch);
|
|
|
|
|
|
|
|
htb_offload_move_qdisc(sch, moved_cl, cl, destroying);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
static void htb_destroy_class(struct Qdisc *sch, struct htb_class *cl)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
if (!cl->level) {
|
2018-09-08 04:29:14 +08:00
|
|
|
WARN_ON(!cl->leaf.q);
|
2018-09-25 00:22:50 +08:00
|
|
|
qdisc_put(cl->leaf.q);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2016-12-05 01:48:16 +08:00
|
|
|
gen_kill_estimator(&cl->rate_est);
|
2017-05-17 17:07:55 +08:00
|
|
|
tcf_block_put(cl->block);
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree(cl);
|
|
|
|
}
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
static void htb_destroy(struct Qdisc *sch)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
struct tc_htb_qopt_offload offload_opt;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
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 09:06:00 +08:00
|
|
|
struct hlist_node *next;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
bool nonempty, changed;
|
2008-07-06 14:22:19 +08:00
|
|
|
struct htb_class *cl;
|
|
|
|
unsigned int i;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-02-01 17:13:22 +08:00
|
|
|
cancel_work_sync(&q->work);
|
2007-03-16 16:22:39 +08:00
|
|
|
qdisc_watchdog_cancel(&q->watchdog);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* This line used to be after htb_destroy_class call below
|
2011-01-20 03:26:56 +08:00
|
|
|
* and surprisingly it worked in 2.4. But it must precede it
|
|
|
|
* because filter need its target class alive to be able to call
|
|
|
|
* unbind_filter on it (without Oops).
|
|
|
|
*/
|
2017-05-17 17:07:55 +08:00
|
|
|
tcf_block_put(q->block);
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
for (i = 0; i < q->clhash.hashsize; i++) {
|
2017-08-15 21:35:21 +08:00
|
|
|
hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {
|
2017-05-17 17:07:55 +08:00
|
|
|
tcf_block_put(cl->block);
|
2017-08-15 21:35:21 +08:00
|
|
|
cl->block = NULL;
|
|
|
|
}
|
2008-07-06 14:22:19 +08:00
|
|
|
}
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
|
|
|
do {
|
|
|
|
nonempty = false;
|
|
|
|
changed = false;
|
|
|
|
for (i = 0; i < q->clhash.hashsize; i++) {
|
|
|
|
hlist_for_each_entry_safe(cl, next, &q->clhash.hash[i],
|
|
|
|
common.hnode) {
|
|
|
|
bool last_child;
|
|
|
|
|
|
|
|
if (!q->offload) {
|
|
|
|
htb_destroy_class(sch, cl);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
nonempty = true;
|
|
|
|
|
|
|
|
if (cl->level)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
changed = true;
|
|
|
|
|
|
|
|
last_child = htb_parent_last_child(cl);
|
|
|
|
htb_destroy_class_offload(sch, cl, last_child,
|
|
|
|
true, NULL);
|
|
|
|
qdisc_class_hash_remove(&q->clhash,
|
|
|
|
&cl->common);
|
|
|
|
if (cl->parent)
|
|
|
|
cl->parent->children--;
|
|
|
|
if (last_child)
|
|
|
|
htb_parent_to_leaf(sch, cl, NULL);
|
|
|
|
htb_destroy_class(sch, cl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (changed);
|
|
|
|
WARN_ON(nonempty);
|
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
qdisc_class_hash_destroy(&q->clhash);
|
2016-06-14 11:21:56 +08:00
|
|
|
__qdisc_reset_queue(&q->direct_queue);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2022-09-02 16:34:30 +08:00
|
|
|
if (q->offload) {
|
|
|
|
offload_opt = (struct tc_htb_qopt_offload) {
|
|
|
|
.command = TC_HTB_DESTROY,
|
|
|
|
};
|
|
|
|
htb_offload(dev, &offload_opt);
|
|
|
|
}
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
|
|
|
if (!q->direct_qdiscs)
|
|
|
|
return;
|
|
|
|
for (i = 0; i < q->num_direct_qdiscs && q->direct_qdiscs[i]; i++)
|
|
|
|
qdisc_put(q->direct_qdiscs[i]);
|
|
|
|
kfree(q->direct_qdiscs);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2021-01-19 20:08:12 +08:00
|
|
|
static int htb_delete(struct Qdisc *sch, unsigned long arg,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl = (struct htb_class *)arg;
|
2006-12-08 16:26:56 +08:00
|
|
|
struct Qdisc *new_q = NULL;
|
|
|
|
int last_child = 0;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
int err;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-12-23 17:38:59 +08:00
|
|
|
/* TODO: why don't allow to delete subtree ? references ? does
|
|
|
|
* tc subsys guarantee us that in htb_destroy it holds no class
|
|
|
|
* refs so that we can remove children safely there ?
|
|
|
|
*/
|
2008-07-06 14:22:53 +08:00
|
|
|
if (cl->children || cl->filter_cnt)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EBUSY;
|
2006-08-11 14:35:16 +08:00
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (!cl->level && htb_parent_last_child(cl))
|
|
|
|
last_child = 1;
|
|
|
|
|
|
|
|
if (q->offload) {
|
|
|
|
err = htb_destroy_class_offload(sch, cl, last_child, false,
|
|
|
|
extack);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (last_child) {
|
2021-08-26 19:54:25 +08:00
|
|
|
struct netdev_queue *dev_queue = sch->dev_queue;
|
|
|
|
|
|
|
|
if (q->offload)
|
|
|
|
dev_queue = htb_offload_get_queue(cl);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
|
|
|
new_q = qdisc_create_dflt(dev_queue, &pfifo_qdisc_ops,
|
2017-12-21 01:35:21 +08:00
|
|
|
cl->parent->common.classid,
|
|
|
|
NULL);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (q->offload) {
|
2021-06-04 19:03:18 +08:00
|
|
|
if (new_q)
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
htb_set_lockdep_class_child(new_q);
|
2021-06-04 19:03:18 +08:00
|
|
|
htb_parent_to_leaf_offload(sch, dev_queue, new_q);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
}
|
2006-12-08 16:26:56 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
sch_tree_lock(sch);
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2019-03-28 23:53:13 +08:00
|
|
|
if (!cl->level)
|
|
|
|
qdisc_purge_queue(cl->leaf.q);
|
2006-11-30 09:34:50 +08:00
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
/* delete from hash and active; remainder in destroy_class */
|
|
|
|
qdisc_class_hash_remove(&q->clhash, &cl->common);
|
2008-08-14 06:16:43 +08:00
|
|
|
if (cl->parent)
|
|
|
|
cl->parent->children--;
|
2007-03-28 05:04:24 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (cl->prio_activity)
|
2006-08-11 14:35:16 +08:00
|
|
|
htb_deactivate(q, cl);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-06 14:22:19 +08:00
|
|
|
if (cl->cmode != HTB_CAN_SEND)
|
2013-06-15 18:30:10 +08:00
|
|
|
htb_safe_rb_erase(&cl->pq_node,
|
|
|
|
&q->hlevel[cl->level].wait_pq);
|
2008-07-06 14:22:19 +08:00
|
|
|
|
2006-12-08 16:26:56 +08:00
|
|
|
if (last_child)
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
htb_parent_to_leaf(sch, cl, new_q);
|
2006-12-08 16:26:56 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
sch_tree_unlock(sch);
|
|
|
|
|
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 07:51:29 +08:00
|
|
|
htb_destroy_class(sch, cl);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
static int htb_change_class(struct Qdisc *sch, u32 classid,
|
2008-01-23 14:11:17 +08:00
|
|
|
u32 parentid, struct nlattr **tca,
|
2017-12-21 01:35:15 +08:00
|
|
|
unsigned long *arg, struct netlink_ext_ack *extack)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int err = -EINVAL;
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl = (struct htb_class *)*arg, *parent;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct tc_htb_qopt_offload offload_opt;
|
2008-01-23 14:11:17 +08:00
|
|
|
struct nlattr *opt = tca[TCA_OPTIONS];
|
2013-03-06 14:49:21 +08:00
|
|
|
struct nlattr *tb[TCA_HTB_MAX + 1];
|
2019-09-24 23:51:16 +08:00
|
|
|
struct Qdisc *parent_qdisc = NULL;
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct netdev_queue *dev_queue;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct tc_htb_opt *hopt;
|
2013-09-20 00:10:20 +08:00
|
|
|
u64 rate64, ceil64;
|
2018-03-30 10:11:21 +08:00
|
|
|
int warn = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* extract all subattrs from opt attr */
|
2008-01-24 12:33:32 +08:00
|
|
|
if (!opt)
|
|
|
|
goto failure;
|
|
|
|
|
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 20:07:28 +08:00
|
|
|
err = nla_parse_nested_deprecated(tb, TCA_HTB_MAX, opt, htb_policy,
|
|
|
|
NULL);
|
2008-01-24 12:33:32 +08:00
|
|
|
if (err < 0)
|
|
|
|
goto failure;
|
|
|
|
|
|
|
|
err = -EINVAL;
|
2008-01-24 12:35:39 +08:00
|
|
|
if (tb[TCA_HTB_PARMS] == NULL)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto failure;
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
parent = parentid == TC_H_ROOT ? NULL : htb_find(parentid, sch);
|
|
|
|
|
2008-01-23 14:11:17 +08:00
|
|
|
hopt = nla_data(tb[TCA_HTB_PARMS]);
|
2012-11-06 00:40:49 +08:00
|
|
|
if (!hopt->rate.rate || !hopt->ceil.rate)
|
2006-08-11 14:35:16 +08:00
|
|
|
goto failure;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2022-01-25 18:06:54 +08:00
|
|
|
if (q->offload) {
|
|
|
|
/* Options not supported by the offload. */
|
|
|
|
if (hopt->rate.overhead || hopt->ceil.overhead) {
|
|
|
|
NL_SET_ERR_MSG(extack, "HTB offload doesn't support the overhead parameter");
|
|
|
|
goto failure;
|
|
|
|
}
|
|
|
|
if (hopt->rate.mpu || hopt->ceil.mpu) {
|
|
|
|
NL_SET_ERR_MSG(extack, "HTB offload doesn't support the mpu parameter");
|
|
|
|
goto failure;
|
|
|
|
}
|
|
|
|
if (hopt->quantum) {
|
|
|
|
NL_SET_ERR_MSG(extack, "HTB offload doesn't support the quantum parameter");
|
|
|
|
goto failure;
|
|
|
|
}
|
|
|
|
if (hopt->prio) {
|
|
|
|
NL_SET_ERR_MSG(extack, "HTB offload doesn't support the prio parameter");
|
|
|
|
goto failure;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-15 05:47:11 +08:00
|
|
|
/* Keeping backward compatible with rate_table based iproute2 tc */
|
2013-12-11 15:48:37 +08:00
|
|
|
if (hopt->rate.linklayer == TC_LINKLAYER_UNAWARE)
|
2017-12-21 01:35:18 +08:00
|
|
|
qdisc_put_rtab(qdisc_get_rtab(&hopt->rate, tb[TCA_HTB_RTAB],
|
|
|
|
NULL));
|
2013-12-11 15:48:37 +08:00
|
|
|
|
|
|
|
if (hopt->ceil.linklayer == TC_LINKLAYER_UNAWARE)
|
2017-12-21 01:35:18 +08:00
|
|
|
qdisc_put_rtab(qdisc_get_rtab(&hopt->ceil, tb[TCA_HTB_CTAB],
|
|
|
|
NULL));
|
2013-08-15 05:47:11 +08:00
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
rate64 = tb[TCA_HTB_RATE64] ? nla_get_u64(tb[TCA_HTB_RATE64]) : 0;
|
|
|
|
ceil64 = tb[TCA_HTB_CEIL64] ? nla_get_u64(tb[TCA_HTB_CEIL64]) : 0;
|
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
if (!cl) { /* new class */
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
struct Qdisc *new_q, *old_q;
|
2006-08-11 14:36:01 +08:00
|
|
|
int prio;
|
2007-07-03 13:48:13 +08:00
|
|
|
struct {
|
2008-01-23 14:11:17 +08:00
|
|
|
struct nlattr nla;
|
2007-07-03 13:48:13 +08:00
|
|
|
struct gnet_estimator opt;
|
|
|
|
} est = {
|
2008-01-23 14:11:17 +08:00
|
|
|
.nla = {
|
|
|
|
.nla_len = nla_attr_size(sizeof(est.opt)),
|
|
|
|
.nla_type = TCA_RATE,
|
2007-07-03 13:48:13 +08:00
|
|
|
},
|
|
|
|
.opt = {
|
|
|
|
/* 4s interval, 16s averaging constant */
|
|
|
|
.interval = 2,
|
|
|
|
.ewma_log = 2,
|
|
|
|
},
|
|
|
|
};
|
2006-08-11 14:36:01 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* check for valid classid */
|
2009-11-30 08:55:45 +08:00
|
|
|
if (!classid || TC_H_MAJ(classid ^ sch->handle) ||
|
|
|
|
htb_find(classid, sch))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto failure;
|
|
|
|
|
|
|
|
/* check maximal depth */
|
|
|
|
if (parent && parent->parent && parent->parent->level < 2) {
|
2011-01-20 03:26:56 +08:00
|
|
|
pr_err("htb: tree is too deep\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
goto failure;
|
|
|
|
}
|
|
|
|
err = -ENOBUFS;
|
2011-01-20 03:26:56 +08:00
|
|
|
cl = kzalloc(sizeof(*cl), GFP_KERNEL);
|
|
|
|
if (!cl)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto failure;
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2021-10-16 16:49:09 +08:00
|
|
|
gnet_stats_basic_sync_init(&cl->bstats);
|
|
|
|
gnet_stats_basic_sync_init(&cl->bstats_bias);
|
2021-10-16 16:49:07 +08:00
|
|
|
|
2017-12-21 01:35:19 +08:00
|
|
|
err = tcf_block_get(&cl->block, &cl->filter_list, sch, extack);
|
2017-05-17 17:07:55 +08:00
|
|
|
if (err) {
|
|
|
|
kfree(cl);
|
|
|
|
goto failure;
|
|
|
|
}
|
2013-06-07 05:53:16 +08:00
|
|
|
if (htb_rate_est || tca[TCA_RATE]) {
|
2014-09-29 02:52:56 +08:00
|
|
|
err = gen_new_estimator(&cl->bstats, NULL,
|
|
|
|
&cl->rate_est,
|
2016-06-07 00:37:16 +08:00
|
|
|
NULL,
|
net: sched: Remove Qdisc::running sequence counter
The Qdisc::running sequence counter has two uses:
1. Reliably reading qdisc's tc statistics while the qdisc is running
(a seqcount read/retry loop at gnet_stats_add_basic()).
2. As a flag, indicating whether the qdisc in question is running
(without any retry loops).
For the first usage, the Qdisc::running sequence counter write section,
qdisc_run_begin() => qdisc_run_end(), covers a much wider area than what
is actually needed: the raw qdisc's bstats update. A u64_stats sync
point was thus introduced (in previous commits) inside the bstats
structure itself. A local u64_stats write section is then started and
stopped for the bstats updates.
Use that u64_stats sync point mechanism for the bstats read/retry loop
at gnet_stats_add_basic().
For the second qdisc->running usage, a __QDISC_STATE_RUNNING bit flag,
accessed with atomic bitops, is sufficient. Using a bit flag instead of
a sequence counter at qdisc_run_begin/end() and qdisc_is_running() leads
to the SMP barriers implicitly added through raw_read_seqcount() and
write_seqcount_begin/end() getting removed. All call sites have been
surveyed though, and no required ordering was identified.
Now that the qdisc->running sequence counter is no longer used, remove
it.
Note, using u64_stats implies no sequence counter protection for 64-bit
architectures. This can lead to the qdisc tc statistics "packets" vs.
"bytes" values getting out of sync on rare occasions. The individual
values will still be valid.
Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-10-16 16:49:10 +08:00
|
|
|
true,
|
2013-06-07 05:53:16 +08:00
|
|
|
tca[TCA_RATE] ? : &est.nla);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (err)
|
|
|
|
goto err_block_put;
|
2008-11-26 13:13:31 +08:00
|
|
|
}
|
|
|
|
|
2008-07-06 14:22:53 +08:00
|
|
|
cl->children = 0;
|
2006-08-11 14:36:01 +08:00
|
|
|
RB_CLEAR_NODE(&cl->pq_node);
|
|
|
|
|
|
|
|
for (prio = 0; prio < TC_HTB_NUMPRIO; prio++)
|
|
|
|
RB_CLEAR_NODE(&cl->node[prio]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
cl->common.classid = classid;
|
|
|
|
|
|
|
|
/* Make sure nothing interrupts us in between of two
|
|
|
|
* ndo_setup_tc calls.
|
|
|
|
*/
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* create leaf qdisc early because it uses kmalloc(GFP_KERNEL)
|
2011-01-20 03:26:56 +08:00
|
|
|
* so that can't be used inside of sch_tree_lock
|
|
|
|
* -- thanks to Karlis Peisenieks
|
|
|
|
*/
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (!q->offload) {
|
|
|
|
dev_queue = sch->dev_queue;
|
|
|
|
} else if (!(parent && !parent->level)) {
|
|
|
|
/* Assign a dev_queue to this classid. */
|
|
|
|
offload_opt = (struct tc_htb_qopt_offload) {
|
|
|
|
.command = TC_HTB_LEAF_ALLOC_QUEUE,
|
|
|
|
.classid = cl->common.classid,
|
|
|
|
.parent_classid = parent ?
|
|
|
|
TC_H_MIN(parent->common.classid) :
|
|
|
|
TC_HTB_CLASSID_ROOT,
|
|
|
|
.rate = max_t(u64, hopt->rate.rate, rate64),
|
|
|
|
.ceil = max_t(u64, hopt->ceil.rate, ceil64),
|
|
|
|
.extack = extack,
|
|
|
|
};
|
|
|
|
err = htb_offload(dev, &offload_opt);
|
|
|
|
if (err) {
|
|
|
|
pr_err("htb: TC_HTB_LEAF_ALLOC_QUEUE failed with err = %d\n",
|
|
|
|
err);
|
|
|
|
goto err_kill_estimator;
|
|
|
|
}
|
|
|
|
dev_queue = netdev_get_tx_queue(dev, offload_opt.qid);
|
|
|
|
} else { /* First child. */
|
2021-08-26 19:54:25 +08:00
|
|
|
dev_queue = htb_offload_get_queue(parent);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
old_q = htb_graft_helper(dev_queue, NULL);
|
|
|
|
WARN_ON(old_q != parent->leaf.q);
|
|
|
|
offload_opt = (struct tc_htb_qopt_offload) {
|
|
|
|
.command = TC_HTB_LEAF_TO_INNER,
|
|
|
|
.classid = cl->common.classid,
|
|
|
|
.parent_classid =
|
|
|
|
TC_H_MIN(parent->common.classid),
|
|
|
|
.rate = max_t(u64, hopt->rate.rate, rate64),
|
|
|
|
.ceil = max_t(u64, hopt->ceil.rate, ceil64),
|
|
|
|
.extack = extack,
|
|
|
|
};
|
|
|
|
err = htb_offload(dev, &offload_opt);
|
|
|
|
if (err) {
|
|
|
|
pr_err("htb: TC_HTB_LEAF_TO_INNER failed with err = %d\n",
|
|
|
|
err);
|
|
|
|
htb_graft_helper(dev_queue, old_q);
|
|
|
|
goto err_kill_estimator;
|
|
|
|
}
|
2021-10-16 16:49:08 +08:00
|
|
|
_bstats_update(&parent->bstats_bias,
|
2021-10-16 16:49:09 +08:00
|
|
|
u64_stats_read(&old_q->bstats.bytes),
|
|
|
|
u64_stats_read(&old_q->bstats.packets));
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
qdisc_put(old_q);
|
|
|
|
}
|
|
|
|
new_q = qdisc_create_dflt(dev_queue, &pfifo_qdisc_ops,
|
2017-12-21 01:35:21 +08:00
|
|
|
classid, NULL);
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (q->offload) {
|
|
|
|
if (new_q) {
|
|
|
|
htb_set_lockdep_class_child(new_q);
|
|
|
|
/* One ref for cl->leaf.q, the other for
|
|
|
|
* dev_queue->qdisc.
|
|
|
|
*/
|
|
|
|
qdisc_refcount_inc(new_q);
|
|
|
|
}
|
|
|
|
old_q = htb_graft_helper(dev_queue, new_q);
|
|
|
|
/* No qdisc_put needed. */
|
|
|
|
WARN_ON(!(old_q->flags & TCQ_F_BUILTIN));
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
sch_tree_lock(sch);
|
|
|
|
if (parent && !parent->level) {
|
|
|
|
/* turn parent into inner node */
|
2019-03-28 23:53:13 +08:00
|
|
|
qdisc_purge_queue(parent->leaf.q);
|
2019-09-24 23:51:16 +08:00
|
|
|
parent_qdisc = parent->leaf.q;
|
2006-08-11 14:35:16 +08:00
|
|
|
if (parent->prio_activity)
|
|
|
|
htb_deactivate(q, parent);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* remove from evt list because of level change */
|
|
|
|
if (parent->cmode != HTB_CAN_SEND) {
|
2013-06-15 18:30:10 +08:00
|
|
|
htb_safe_rb_erase(&parent->pq_node, &q->hlevel[0].wait_pq);
|
2005-04-17 06:20:36 +08:00
|
|
|
parent->cmode = HTB_CAN_SEND;
|
|
|
|
}
|
|
|
|
parent->level = (parent->parent ? parent->parent->level
|
2006-08-11 14:35:16 +08:00
|
|
|
: TC_HTB_MAXDEPTH) - 1;
|
2018-09-08 04:29:14 +08:00
|
|
|
memset(&parent->inner, 0, sizeof(parent->inner));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* leaf (we) needs elementary qdisc */
|
2018-09-08 04:29:14 +08:00
|
|
|
cl->leaf.q = new_q ? new_q : &noop_qdisc;
|
2021-08-26 19:54:25 +08:00
|
|
|
if (q->offload)
|
|
|
|
cl->leaf.offload_queue = dev_queue;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
cl->parent = parent;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* set class to be in HTB_CAN_SEND state */
|
2013-02-12 08:12:02 +08:00
|
|
|
cl->tokens = PSCHED_TICKS2NS(hopt->buffer);
|
|
|
|
cl->ctokens = PSCHED_TICKS2NS(hopt->cbuffer);
|
2013-06-04 15:11:48 +08:00
|
|
|
cl->mbuffer = 60ULL * NSEC_PER_SEC; /* 1min */
|
2014-08-23 09:32:09 +08:00
|
|
|
cl->t_c = ktime_get_ns();
|
2005-04-17 06:20:36 +08:00
|
|
|
cl->cmode = HTB_CAN_SEND;
|
|
|
|
|
|
|
|
/* attach to the hash list and parent's family */
|
2008-07-06 14:22:35 +08:00
|
|
|
qdisc_class_hash_insert(&q->clhash, &cl->common);
|
2008-07-06 14:22:53 +08:00
|
|
|
if (parent)
|
|
|
|
parent->children++;
|
2018-09-08 04:29:14 +08:00
|
|
|
if (cl->leaf.q != &noop_qdisc)
|
|
|
|
qdisc_hash_add(cl->leaf.q, true);
|
2007-07-03 13:48:13 +08:00
|
|
|
} else {
|
2008-11-26 13:13:31 +08:00
|
|
|
if (tca[TCA_RATE]) {
|
2014-09-29 02:52:56 +08:00
|
|
|
err = gen_replace_estimator(&cl->bstats, NULL,
|
|
|
|
&cl->rate_est,
|
2016-06-07 00:37:16 +08:00
|
|
|
NULL,
|
net: sched: Remove Qdisc::running sequence counter
The Qdisc::running sequence counter has two uses:
1. Reliably reading qdisc's tc statistics while the qdisc is running
(a seqcount read/retry loop at gnet_stats_add_basic()).
2. As a flag, indicating whether the qdisc in question is running
(without any retry loops).
For the first usage, the Qdisc::running sequence counter write section,
qdisc_run_begin() => qdisc_run_end(), covers a much wider area than what
is actually needed: the raw qdisc's bstats update. A u64_stats sync
point was thus introduced (in previous commits) inside the bstats
structure itself. A local u64_stats write section is then started and
stopped for the bstats updates.
Use that u64_stats sync point mechanism for the bstats read/retry loop
at gnet_stats_add_basic().
For the second qdisc->running usage, a __QDISC_STATE_RUNNING bit flag,
accessed with atomic bitops, is sufficient. Using a bit flag instead of
a sequence counter at qdisc_run_begin/end() and qdisc_is_running() leads
to the SMP barriers implicitly added through raw_read_seqcount() and
write_seqcount_begin/end() getting removed. All call sites have been
surveyed though, and no required ordering was identified.
Now that the qdisc->running sequence counter is no longer used, remove
it.
Note, using u64_stats implies no sequence counter protection for 64-bit
architectures. This can lead to the qdisc tc statistics "packets" vs.
"bytes" values getting out of sync on rare occasions. The individual
values will still be valid.
Signed-off-by: Ahmed S. Darwish <a.darwish@linutronix.de>
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-10-16 16:49:10 +08:00
|
|
|
true,
|
2008-11-26 13:13:31 +08:00
|
|
|
tca[TCA_RATE]);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
if (q->offload) {
|
|
|
|
struct net_device *dev = qdisc_dev(sch);
|
|
|
|
|
|
|
|
offload_opt = (struct tc_htb_qopt_offload) {
|
|
|
|
.command = TC_HTB_NODE_MODIFY,
|
|
|
|
.classid = cl->common.classid,
|
|
|
|
.rate = max_t(u64, hopt->rate.rate, rate64),
|
|
|
|
.ceil = max_t(u64, hopt->ceil.rate, ceil64),
|
|
|
|
.extack = extack,
|
|
|
|
};
|
|
|
|
err = htb_offload(dev, &offload_opt);
|
|
|
|
if (err)
|
|
|
|
/* Estimator was replaced, and rollback may fail
|
|
|
|
* as well, so we don't try to recover it, and
|
|
|
|
* the estimator won't work property with the
|
|
|
|
* offload anyway, because bstats are updated
|
|
|
|
* only when the stats are queried.
|
|
|
|
*/
|
|
|
|
return err;
|
|
|
|
}
|
2013-12-10 14:59:28 +08:00
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
sch_tree_lock(sch);
|
|
|
|
}
|
2013-12-10 14:59:28 +08:00
|
|
|
|
|
|
|
psched_ratecfg_precompute(&cl->rate, &hopt->rate, rate64);
|
|
|
|
psched_ratecfg_precompute(&cl->ceil, &hopt->ceil, ceil64);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* it used to be a nasty bug here, we have to check that node
|
2018-09-08 04:29:14 +08:00
|
|
|
* is really leaf before changing cl->leaf !
|
2011-01-20 03:26:56 +08:00
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!cl->level) {
|
2013-12-10 14:59:28 +08:00
|
|
|
u64 quantum = cl->rate.rate_bytes_ps;
|
|
|
|
|
|
|
|
do_div(quantum, q->rate2quantum);
|
|
|
|
cl->quantum = min_t(u64, quantum, INT_MAX);
|
|
|
|
|
2008-12-04 13:09:45 +08:00
|
|
|
if (!hopt->quantum && cl->quantum < 1000) {
|
2018-03-30 10:11:21 +08:00
|
|
|
warn = -1;
|
2008-12-04 13:09:45 +08:00
|
|
|
cl->quantum = 1000;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-12-04 13:09:45 +08:00
|
|
|
if (!hopt->quantum && cl->quantum > 200000) {
|
2018-03-30 10:11:21 +08:00
|
|
|
warn = 1;
|
2008-12-04 13:09:45 +08:00
|
|
|
cl->quantum = 200000;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (hopt->quantum)
|
2008-12-04 13:09:45 +08:00
|
|
|
cl->quantum = hopt->quantum;
|
|
|
|
if ((cl->prio = hopt->prio) >= TC_HTB_NUMPRIO)
|
|
|
|
cl->prio = TC_HTB_NUMPRIO - 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2013-02-12 08:11:59 +08:00
|
|
|
cl->buffer = PSCHED_TICKS2NS(hopt->buffer);
|
2013-09-11 08:36:37 +08:00
|
|
|
cl->cbuffer = PSCHED_TICKS2NS(hopt->cbuffer);
|
2012-10-31 14:04:11 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
sch_tree_unlock(sch);
|
2019-09-24 23:51:16 +08:00
|
|
|
qdisc_put(parent_qdisc);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-03-30 10:11:21 +08:00
|
|
|
if (warn)
|
|
|
|
pr_warn("HTB: quantum of class %X is %s. Consider r2q change.\n",
|
|
|
|
cl->common.classid, (warn == -1 ? "small" : "big"));
|
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
qdisc_class_hash_grow(sch, &q->clhash);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
*arg = (unsigned long)cl;
|
|
|
|
return 0;
|
|
|
|
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
err_kill_estimator:
|
|
|
|
gen_kill_estimator(&cl->rate_est);
|
|
|
|
err_block_put:
|
|
|
|
tcf_block_put(cl->block);
|
|
|
|
kfree(cl);
|
2005-04-17 06:20:36 +08:00
|
|
|
failure:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-12-21 01:35:16 +08:00
|
|
|
static struct tcf_block *htb_tcf_block(struct Qdisc *sch, unsigned long arg,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
|
|
|
struct htb_class *cl = (struct htb_class *)arg;
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2017-05-17 17:07:55 +08:00
|
|
|
return cl ? cl->block : q->block;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long htb_bind_filter(struct Qdisc *sch, unsigned long parent,
|
2006-08-11 14:35:16 +08:00
|
|
|
u32 classid)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-08-11 14:35:16 +08:00
|
|
|
struct htb_class *cl = htb_find(classid, sch);
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*if (cl && !cl->level) return 0;
|
2011-01-20 03:26:56 +08:00
|
|
|
* The line above used to be there to prevent attaching filters to
|
|
|
|
* leaves. But at least tc_index filter uses this just to get class
|
|
|
|
* for other reasons so that we have to allow for it.
|
|
|
|
* ----
|
|
|
|
* 19.6.2002 As Werner explained it is ok - bind filter is just
|
|
|
|
* another way to "lock" the class - unlike "get" this lock can
|
|
|
|
* be broken by class during destroy IIUC.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2006-08-11 14:35:16 +08:00
|
|
|
if (cl)
|
|
|
|
cl->filter_cnt++;
|
2005-04-17 06:20:36 +08:00
|
|
|
return (unsigned long)cl;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void htb_unbind_filter(struct Qdisc *sch, unsigned long arg)
|
|
|
|
{
|
|
|
|
struct htb_class *cl = (struct htb_class *)arg;
|
2006-08-11 14:31:08 +08:00
|
|
|
|
2006-08-11 14:35:16 +08:00
|
|
|
if (cl)
|
|
|
|
cl->filter_cnt--;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void htb_walk(struct Qdisc *sch, struct qdisc_walker *arg)
|
|
|
|
{
|
|
|
|
struct htb_sched *q = qdisc_priv(sch);
|
2008-07-06 14:22:35 +08:00
|
|
|
struct htb_class *cl;
|
|
|
|
unsigned int i;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (arg->stop)
|
|
|
|
return;
|
|
|
|
|
2008-07-06 14:22:35 +08:00
|
|
|
for (i = 0; i < q->clhash.hashsize; 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 09:06:00 +08:00
|
|
|
hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {
|
2022-09-21 10:41:18 +08:00
|
|
|
if (!tc_qdisc_stats_dump(sch, (unsigned long)cl, arg))
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-14 17:44:41 +08:00
|
|
|
static const struct Qdisc_class_ops htb_class_ops = {
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
.select_queue = htb_select_queue,
|
2005-04-17 06:20:36 +08:00
|
|
|
.graft = htb_graft,
|
|
|
|
.leaf = htb_leaf,
|
2006-11-30 09:37:05 +08:00
|
|
|
.qlen_notify = htb_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 07:51:29 +08:00
|
|
|
.find = htb_search,
|
2005-04-17 06:20:36 +08:00
|
|
|
.change = htb_change_class,
|
|
|
|
.delete = htb_delete,
|
|
|
|
.walk = htb_walk,
|
2017-05-17 17:07:55 +08:00
|
|
|
.tcf_block = htb_tcf_block,
|
2005-04-17 06:20:36 +08:00
|
|
|
.bind_tcf = htb_bind_filter,
|
|
|
|
.unbind_tcf = htb_unbind_filter,
|
|
|
|
.dump = htb_dump_class,
|
|
|
|
.dump_stats = htb_dump_class_stats,
|
|
|
|
};
|
|
|
|
|
2007-11-14 17:44:41 +08:00
|
|
|
static struct Qdisc_ops htb_qdisc_ops __read_mostly = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.cl_ops = &htb_class_ops,
|
|
|
|
.id = "htb",
|
|
|
|
.priv_size = sizeof(struct htb_sched),
|
|
|
|
.enqueue = htb_enqueue,
|
|
|
|
.dequeue = htb_dequeue,
|
2008-10-31 15:47:01 +08:00
|
|
|
.peek = qdisc_peek_dequeued,
|
2005-04-17 06:20:36 +08:00
|
|
|
.init = htb_init,
|
sch_htb: Hierarchical QoS hardware offload
HTB doesn't scale well because of contention on a single lock, and it
also consumes CPU. This patch adds support for offloading HTB to
hardware that supports hierarchical rate limiting.
In the offload mode, HTB passes control commands to the driver using
ndo_setup_tc. The driver has to replicate the whole hierarchy of classes
and their settings (rate, ceil) in the NIC. Every modification of the
HTB tree caused by the admin results in ndo_setup_tc being called.
After this setup, the HTB algorithm is done completely in the NIC. An SQ
(send queue) is created for every leaf class and attached to the
hierarchy, so that the NIC can calculate and obey aggregated rate
limits, too. In the future, it can be changed, so that multiple SQs will
back a single leaf class.
ndo_select_queue is responsible for selecting the right queue that
serves the traffic class of each packet.
The data path works as follows: a packet is classified by clsact, the
driver selects a hardware queue according to its class, and the packet
is enqueued into this queue's qdisc.
This solution addresses two main problems of scaling HTB:
1. Contention by flow classification. Currently the filters are attached
to the HTB instance as follows:
# tc filter add dev eth0 parent 1:0 protocol ip flower dst_port 80
classid 1:10
It's possible to move classification to clsact egress hook, which is
thread-safe and lock-free:
# tc filter add dev eth0 egress protocol ip flower dst_port 80
action skbedit priority 1:10
This way classification still happens in software, but the lock
contention is eliminated, and it happens before selecting the TX queue,
allowing the driver to translate the class to the corresponding hardware
queue in ndo_select_queue.
Note that this is already compatible with non-offloaded HTB and doesn't
require changes to the kernel nor iproute2.
2. Contention by handling packets. HTB is not multi-queue, it attaches
to a whole net device, and handling of all packets takes the same lock.
When HTB is offloaded, it registers itself as a multi-queue qdisc,
similarly to mq: HTB is attached to the netdev, and each queue has its
own qdisc.
Some features of HTB may be not supported by some particular hardware,
for example, the maximum number of classes may be limited, the
granularity of rate and ceil parameters may be different, etc. - so, the
offload is not enabled by default, a new parameter is used to enable it:
# tc qdisc replace dev eth0 root handle 1: htb offload
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Reviewed-by: Tariq Toukan <tariqt@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2021-01-19 20:08:13 +08:00
|
|
|
.attach = htb_attach,
|
2005-04-17 06:20:36 +08:00
|
|
|
.reset = htb_reset,
|
|
|
|
.destroy = htb_destroy,
|
|
|
|
.dump = htb_dump,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init htb_module_init(void)
|
|
|
|
{
|
2006-08-11 14:35:16 +08:00
|
|
|
return register_qdisc(&htb_qdisc_ops);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-08-11 14:35:16 +08:00
|
|
|
static void __exit htb_module_exit(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-08-11 14:35:16 +08:00
|
|
|
unregister_qdisc(&htb_qdisc_ops);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-08-11 14:35:16 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
module_init(htb_module_init)
|
|
|
|
module_exit(htb_module_exit)
|
|
|
|
MODULE_LICENSE("GPL");
|