[thirdparty/kernel/stable.git] / net / sched / sch_codel.c

/*
 * Codel - The Controlled-Delay Active Queue Management algorithm
 *
 *  Copyright (C) 2011-2012 Kathleen Nichols <nichols@pollere.com>
 *  Copyright (C) 2011-2012 Van Jacobson <van@pollere.net>
 *
 *  Implemented on linux by :
 *  Copyright (C) 2012 Michael D. Taht <dave.taht@bufferbloat.net>
 *  Copyright (C) 2012,2015 Eric Dumazet <edumazet@google.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The names of the authors may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * Alternatively, provided that this notice is retained in full, this
 * software may be distributed under the terms of the GNU General
 * Public License ("GPL") version 2, in which case the provisions of the
 * GPL apply INSTEAD OF those given above.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
#include <linux/prefetch.h>
#include <net/pkt_sched.h>
#include <net/codel.h>
#include <net/codel_impl.h>
#include <net/codel_qdisc.h>


#define DEFAULT_CODEL_LIMIT 1000

struct codel_sched_data {
	struct codel_params	params;
	struct codel_vars	vars;
	struct codel_stats	stats;
	u32			drop_overlimit;
};

/* This is the specific function called from codel_dequeue()
 * to dequeue a packet from queue. Note: backlog is handled in
 * codel, we dont need to reduce it here.
 */
static struct sk_buff *dequeue_func(struct codel_vars *vars, void *ctx)
{
	struct Qdisc *sch = ctx;
	struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);

	if (skb)
		sch->qstats.backlog -= qdisc_pkt_len(skb);

	prefetch(&skb->end); /* we'll need skb_shinfo() */
	return skb;
}

static void drop_func(struct sk_buff *skb, void *ctx)
{
	struct Qdisc *sch = ctx;

	kfree_skb(skb);
	qdisc_qstats_drop(sch);
}

static struct sk_buff *codel_qdisc_dequeue(struct Qdisc *sch)
{
	struct codel_sched_data *q = qdisc_priv(sch);
	struct sk_buff *skb;

	skb = codel_dequeue(sch, &sch->qstats.backlog, &q->params, &q->vars,
			    &q->stats, qdisc_pkt_len, codel_get_enqueue_time,
			    drop_func, dequeue_func);

	/* We cant call qdisc_tree_reduce_backlog() if our qlen is 0,
	 * or HTB crashes. Defer it for next round.
	 */
	if (q->stats.drop_count && sch->q.qlen) {
		qdisc_tree_reduce_backlog(sch, q->stats.drop_count, q->stats.drop_len);
		q->stats.drop_count = 0;
		q->stats.drop_len = 0;
	}
	if (skb)
		qdisc_bstats_update(sch, skb);
	return skb;
}

static int codel_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
			       struct sk_buff **to_free)
{
	struct codel_sched_data *q;

	if (likely(qdisc_qlen(sch) < sch->limit)) {
		codel_set_enqueue_time(skb);
		return qdisc_enqueue_tail(skb, sch);
	}
	q = qdisc_priv(sch);
	q->drop_overlimit++;
	return qdisc_drop(skb, sch, to_free);
}

static const struct nla_policy codel_policy[TCA_CODEL_MAX + 1] = {
	[TCA_CODEL_TARGET]	= { .type = NLA_U32 },
	[TCA_CODEL_LIMIT]	= { .type = NLA_U32 },
	[TCA_CODEL_INTERVAL]	= { .type = NLA_U32 },
	[TCA_CODEL_ECN]		= { .type = NLA_U32 },
	[TCA_CODEL_CE_THRESHOLD]= { .type = NLA_U32 },
};

static int codel_change(struct Qdisc *sch, struct nlattr *opt,
			struct netlink_ext_ack *extack)
{
	struct codel_sched_data *q = qdisc_priv(sch);
	struct nlattr *tb[TCA_CODEL_MAX + 1];
	unsigned int qlen, dropped = 0;
	int err;

	if (!opt)
		return -EINVAL;

	err = nla_parse_nested_deprecated(tb, TCA_CODEL_MAX, opt,
					  codel_policy, NULL);
	if (err < 0)
		return err;

	sch_tree_lock(sch);

	if (tb[TCA_CODEL_TARGET]) {
		u32 target = nla_get_u32(tb[TCA_CODEL_TARGET]);

		q->params.target = ((u64)target * NSEC_PER_USEC) >> CODEL_SHIFT;
	}

	if (tb[TCA_CODEL_CE_THRESHOLD]) {
		u64 val = nla_get_u32(tb[TCA_CODEL_CE_THRESHOLD]);

		q->params.ce_threshold = (val * NSEC_PER_USEC) >> CODEL_SHIFT;
	}

	if (tb[TCA_CODEL_INTERVAL]) {
		u32 interval = nla_get_u32(tb[TCA_CODEL_INTERVAL]);

		q->params.interval = ((u64)interval * NSEC_PER_USEC) >> CODEL_SHIFT;
	}

	if (tb[TCA_CODEL_LIMIT])
		sch->limit = nla_get_u32(tb[TCA_CODEL_LIMIT]);

	if (tb[TCA_CODEL_ECN])
		q->params.ecn = !!nla_get_u32(tb[TCA_CODEL_ECN]);

	qlen = sch->q.qlen;
	while (sch->q.qlen > sch->limit) {
		struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);

		dropped += qdisc_pkt_len(skb);
		qdisc_qstats_backlog_dec(sch, skb);
		rtnl_qdisc_drop(skb, sch);
	}
	qdisc_tree_reduce_backlog(sch, qlen - sch->q.qlen, dropped);

	sch_tree_unlock(sch);
	return 0;
}

static int codel_init(struct Qdisc *sch, struct nlattr *opt,
		      struct netlink_ext_ack *extack)
{
	struct codel_sched_data *q = qdisc_priv(sch);

	sch->limit = DEFAULT_CODEL_LIMIT;

	codel_params_init(&q->params);
	codel_vars_init(&q->vars);
	codel_stats_init(&q->stats);
	q->params.mtu = psched_mtu(qdisc_dev(sch));

	if (opt) {
		int err = codel_change(sch, opt, extack);

		if (err)
			return err;
	}

	if (sch->limit >= 1)
		sch->flags |= TCQ_F_CAN_BYPASS;
	else
		sch->flags &= ~TCQ_F_CAN_BYPASS;

	return 0;
}

static int codel_dump(struct Qdisc *sch, struct sk_buff *skb)
{
	struct codel_sched_data *q = qdisc_priv(sch);
	struct nlattr *opts;

	opts = nla_nest_start_noflag(skb, TCA_OPTIONS);
	if (opts == NULL)
		goto nla_put_failure;

	if (nla_put_u32(skb, TCA_CODEL_TARGET,
			codel_time_to_us(q->params.target)) ||
	    nla_put_u32(skb, TCA_CODEL_LIMIT,
			sch->limit) ||
	    nla_put_u32(skb, TCA_CODEL_INTERVAL,
			codel_time_to_us(q->params.interval)) ||
	    nla_put_u32(skb, TCA_CODEL_ECN,
			q->params.ecn))
		goto nla_put_failure;
	if (q->params.ce_threshold != CODEL_DISABLED_THRESHOLD &&
	    nla_put_u32(skb, TCA_CODEL_CE_THRESHOLD,
			codel_time_to_us(q->params.ce_threshold)))
		goto nla_put_failure;
	return nla_nest_end(skb, opts);

nla_put_failure:
	nla_nest_cancel(skb, opts);
	return -1;
}

static int codel_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
{
	const struct codel_sched_data *q = qdisc_priv(sch);
	struct tc_codel_xstats st = {
		.maxpacket	= q->stats.maxpacket,
		.count		= q->vars.count,
		.lastcount	= q->vars.lastcount,
		.drop_overlimit = q->drop_overlimit,
		.ldelay		= codel_time_to_us(q->vars.ldelay),
		.dropping	= q->vars.dropping,
		.ecn_mark	= q->stats.ecn_mark,
		.ce_mark	= q->stats.ce_mark,
	};

	if (q->vars.dropping) {
		codel_tdiff_t delta = q->vars.drop_next - codel_get_time();

		if (delta >= 0)
			st.drop_next = codel_time_to_us(delta);
		else
			st.drop_next = -codel_time_to_us(-delta);
	}

	return gnet_stats_copy_app(d, &st, sizeof(st));
}

static void codel_reset(struct Qdisc *sch)
{
	struct codel_sched_data *q = qdisc_priv(sch);

	qdisc_reset_queue(sch);
	codel_vars_init(&q->vars);
}

static struct Qdisc_ops codel_qdisc_ops __read_mostly = {
	.id		=	"codel",
	.priv_size	=	sizeof(struct codel_sched_data),

	.enqueue	=	codel_qdisc_enqueue,
	.dequeue	=	codel_qdisc_dequeue,
	.peek		=	qdisc_peek_dequeued,
	.init		=	codel_init,
	.reset		=	codel_reset,
	.change 	=	codel_change,
	.dump		=	codel_dump,
	.dump_stats	=	codel_dump_stats,
	.owner		=	THIS_MODULE,
};

static int __init codel_module_init(void)
{
	return register_qdisc(&codel_qdisc_ops);
}

static void __exit codel_module_exit(void)
{
	unregister_qdisc(&codel_qdisc_ops);
}

module_init(codel_module_init)
module_exit(codel_module_exit)

MODULE_DESCRIPTION("Controlled Delay queue discipline");
MODULE_AUTHOR("Dave Taht");
MODULE_AUTHOR("Eric Dumazet");
MODULE_LICENSE("Dual BSD/GPL");
Commit	Line	Data
76e3cc12 ED	1	/*
	2	* Codel - The Controlled-Delay Active Queue Management algorithm
	3	*
	4	* Copyright (C) 2011-2012 Kathleen Nichols <nichols@pollere.com>
	5	* Copyright (C) 2011-2012 Van Jacobson <van@pollere.net>
	6	*
	7	* Implemented on linux by :
	8	* Copyright (C) 2012 Michael D. Taht <dave.taht@bufferbloat.net>
80ba92fa	9	* Copyright (C) 2012,2015 Eric Dumazet <edumazet@google.com>
76e3cc12 ED	10	*
	11	* Redistribution and use in source and binary forms, with or without
	12	* modification, are permitted provided that the following conditions
	13	* are met:
	14	* 1. Redistributions of source code must retain the above copyright
	15	* notice, this list of conditions, and the following disclaimer,
	16	* without modification.
	17	* 2. Redistributions in binary form must reproduce the above copyright
	18	* notice, this list of conditions and the following disclaimer in the
	19	* documentation and/or other materials provided with the distribution.
	20	* 3. The names of the authors may not be used to endorse or promote products
	21	* derived from this software without specific prior written permission.
	22	*
	23	* Alternatively, provided that this notice is retained in full, this
	24	* software may be distributed under the terms of the GNU General
	25	* Public License ("GPL") version 2, in which case the provisions of the
	26	* GPL apply INSTEAD OF those given above.
	27	*
	28	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	29	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	30	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	31	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	32	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	33	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	34	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	35	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	36	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	37	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	38	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
	39	* DAMAGE.
	40	*
	41	*/
	42
	43	#include <linux/module.h>
	44	#include <linux/slab.h>
	45	#include <linux/types.h>
	46	#include <linux/kernel.h>
	47	#include <linux/errno.h>
	48	#include <linux/skbuff.h>
ce5b4b97	49	#include <linux/prefetch.h>
76e3cc12 ED	50	#include <net/pkt_sched.h>
76e3cc12 ED	51	#include <net/codel.h>
d068ca2a MK	52	#include <net/codel_impl.h>
d068ca2a MK	53	#include <net/codel_qdisc.h>
76e3cc12 ED	54
	55
	56	#define DEFAULT_CODEL_LIMIT 1000
	57
	58	struct codel_sched_data {
	59	struct codel_params params;
	60	struct codel_vars vars;
	61	struct codel_stats stats;
	62	u32 drop_overlimit;
	63	};
	64
	65	/* This is the specific function called from codel_dequeue()
	66	* to dequeue a packet from queue. Note: backlog is handled in
	67	* codel, we dont need to reduce it here.
	68	*/
79bdc4c8	69	static struct sk_buff dequeue_func(struct codel_vars vars, void *ctx)
76e3cc12	70	{
79bdc4c8	71	struct Qdisc *sch = ctx;
ed760cb8	72	struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);
76e3cc12	73
79bdc4c8 MK	74	if (skb)
	75	sch->qstats.backlog -= qdisc_pkt_len(skb);
	76
76e3cc12 ED	77	prefetch(&skb->end); /* we'll need skb_shinfo() */
	78	return skb;
	79	}
	80
79bdc4c8 MK	81	static void drop_func(struct sk_buff skb, void ctx)
	82	{
	83	struct Qdisc *sch = ctx;
	84
520ac30f ED	85	kfree_skb(skb);
520ac30f ED	86	qdisc_qstats_drop(sch);
79bdc4c8 MK	87	}
79bdc4c8 MK	88
76e3cc12 ED	89	static struct sk_buff codel_qdisc_dequeue(struct Qdisc sch)
	90	{
	91	struct codel_sched_data *q = qdisc_priv(sch);
	92	struct sk_buff *skb;
	93
79bdc4c8 MK	94	skb = codel_dequeue(sch, &sch->qstats.backlog, &q->params, &q->vars,
	95	&q->stats, qdisc_pkt_len, codel_get_enqueue_time,
	96	drop_func, dequeue_func);
865ec552	97
2ccccf5f	98	/* We cant call qdisc_tree_reduce_backlog() if our qlen is 0,
76e3cc12 ED	99	* or HTB crashes. Defer it for next round.
	100	*/
	101	if (q->stats.drop_count && sch->q.qlen) {
2ccccf5f	102	qdisc_tree_reduce_backlog(sch, q->stats.drop_count, q->stats.drop_len);
76e3cc12	103	q->stats.drop_count = 0;
2ccccf5f	104	q->stats.drop_len = 0;
76e3cc12 ED	105	}
	106	if (skb)
	107	qdisc_bstats_update(sch, skb);
	108	return skb;
	109	}
	110
520ac30f ED	111	static int codel_qdisc_enqueue(struct sk_buff skb, struct Qdisc sch,
520ac30f ED	112	struct sk_buff **to_free)
76e3cc12 ED	113	{
	114	struct codel_sched_data *q;
	115
	116	if (likely(qdisc_qlen(sch) < sch->limit)) {
	117	codel_set_enqueue_time(skb);
	118	return qdisc_enqueue_tail(skb, sch);
	119	}
	120	q = qdisc_priv(sch);
	121	q->drop_overlimit++;
520ac30f	122	return qdisc_drop(skb, sch, to_free);
76e3cc12 ED	123	}
	124
	125	static const struct nla_policy codel_policy[TCA_CODEL_MAX + 1] = {
	126	[TCA_CODEL_TARGET] = { .type = NLA_U32 },
	127	[TCA_CODEL_LIMIT] = { .type = NLA_U32 },
	128	[TCA_CODEL_INTERVAL] = { .type = NLA_U32 },
	129	[TCA_CODEL_ECN] = { .type = NLA_U32 },
80ba92fa	130	[TCA_CODEL_CE_THRESHOLD]= { .type = NLA_U32 },
76e3cc12 ED	131	};
76e3cc12 ED	132
2030721c AA	133	static int codel_change(struct Qdisc sch, struct nlattr opt,
2030721c AA	134	struct netlink_ext_ack *extack)
76e3cc12 ED	135	{
	136	struct codel_sched_data *q = qdisc_priv(sch);
	137	struct nlattr *tb[TCA_CODEL_MAX + 1];
2ccccf5f	138	unsigned int qlen, dropped = 0;
76e3cc12 ED	139	int err;
	140
	141	if (!opt)
	142	return -EINVAL;
	143
8cb08174 JB	144	err = nla_parse_nested_deprecated(tb, TCA_CODEL_MAX, opt,
8cb08174 JB	145	codel_policy, NULL);
76e3cc12 ED	146	if (err < 0)
	147	return err;
	148
	149	sch_tree_lock(sch);
	150
	151	if (tb[TCA_CODEL_TARGET]) {
	152	u32 target = nla_get_u32(tb[TCA_CODEL_TARGET]);
	153
	154	q->params.target = ((u64)target * NSEC_PER_USEC) >> CODEL_SHIFT;
	155	}
	156
80ba92fa ED	157	if (tb[TCA_CODEL_CE_THRESHOLD]) {
	158	u64 val = nla_get_u32(tb[TCA_CODEL_CE_THRESHOLD]);
	159
	160	q->params.ce_threshold = (val * NSEC_PER_USEC) >> CODEL_SHIFT;
	161	}
	162
76e3cc12 ED	163	if (tb[TCA_CODEL_INTERVAL]) {
	164	u32 interval = nla_get_u32(tb[TCA_CODEL_INTERVAL]);
	165
	166	q->params.interval = ((u64)interval * NSEC_PER_USEC) >> CODEL_SHIFT;
	167	}
	168
	169	if (tb[TCA_CODEL_LIMIT])
	170	sch->limit = nla_get_u32(tb[TCA_CODEL_LIMIT]);
	171
	172	if (tb[TCA_CODEL_ECN])
	173	q->params.ecn = !!nla_get_u32(tb[TCA_CODEL_ECN]);
	174
	175	qlen = sch->q.qlen;
	176	while (sch->q.qlen > sch->limit) {
ed760cb8	177	struct sk_buff *skb = __qdisc_dequeue_head(&sch->q);
76e3cc12	178
2ccccf5f	179	dropped += qdisc_pkt_len(skb);
25331d6c	180	qdisc_qstats_backlog_dec(sch, skb);
b3d7e2b2	181	rtnl_qdisc_drop(skb, sch);
76e3cc12	182	}
2ccccf5f	183	qdisc_tree_reduce_backlog(sch, qlen - sch->q.qlen, dropped);
76e3cc12 ED	184
	185	sch_tree_unlock(sch);
	186	return 0;
	187	}
	188
e63d7dfd AA	189	static int codel_init(struct Qdisc sch, struct nlattr opt,
e63d7dfd AA	190	struct netlink_ext_ack *extack)
76e3cc12 ED	191	{
	192	struct codel_sched_data *q = qdisc_priv(sch);
	193
	194	sch->limit = DEFAULT_CODEL_LIMIT;
	195
79bdc4c8	196	codel_params_init(&q->params);
76e3cc12 ED	197	codel_vars_init(&q->vars);
76e3cc12 ED	198	codel_stats_init(&q->stats);
79bdc4c8	199	q->params.mtu = psched_mtu(qdisc_dev(sch));
76e3cc12 ED	200
76e3cc12 ED	201	if (opt) {
2030721c	202	int err = codel_change(sch, opt, extack);
76e3cc12 ED	203
	204	if (err)
	205	return err;
	206	}
	207
	208	if (sch->limit >= 1)
	209	sch->flags \|= TCQ_F_CAN_BYPASS;
	210	else
	211	sch->flags &= ~TCQ_F_CAN_BYPASS;
	212
	213	return 0;
	214	}
	215
	216	static int codel_dump(struct Qdisc sch, struct sk_buff skb)
	217	{
	218	struct codel_sched_data *q = qdisc_priv(sch);
	219	struct nlattr *opts;
	220
ae0be8de	221	opts = nla_nest_start_noflag(skb, TCA_OPTIONS);
76e3cc12 ED	222	if (opts == NULL)
	223	goto nla_put_failure;
	224
	225	if (nla_put_u32(skb, TCA_CODEL_TARGET,
	226	codel_time_to_us(q->params.target)) \|\|
	227	nla_put_u32(skb, TCA_CODEL_LIMIT,
	228	sch->limit) \|\|
	229	nla_put_u32(skb, TCA_CODEL_INTERVAL,
	230	codel_time_to_us(q->params.interval)) \|\|
	231	nla_put_u32(skb, TCA_CODEL_ECN,
	232	q->params.ecn))
	233	goto nla_put_failure;
80ba92fa ED	234	if (q->params.ce_threshold != CODEL_DISABLED_THRESHOLD &&
	235	nla_put_u32(skb, TCA_CODEL_CE_THRESHOLD,
	236	codel_time_to_us(q->params.ce_threshold)))
	237	goto nla_put_failure;
76e3cc12 ED	238	return nla_nest_end(skb, opts);
	239
	240	nla_put_failure:
	241	nla_nest_cancel(skb, opts);
	242	return -1;
	243	}
	244
	245	static int codel_dump_stats(struct Qdisc sch, struct gnet_dump d)
	246	{
	247	const struct codel_sched_data *q = qdisc_priv(sch);
	248	struct tc_codel_xstats st = {
	249	.maxpacket = q->stats.maxpacket,
	250	.count = q->vars.count,
	251	.lastcount = q->vars.lastcount,
	252	.drop_overlimit = q->drop_overlimit,
	253	.ldelay = codel_time_to_us(q->vars.ldelay),
	254	.dropping = q->vars.dropping,
	255	.ecn_mark = q->stats.ecn_mark,
80ba92fa	256	.ce_mark = q->stats.ce_mark,
76e3cc12 ED	257	};
	258
	259	if (q->vars.dropping) {
	260	codel_tdiff_t delta = q->vars.drop_next - codel_get_time();
	261
	262	if (delta >= 0)
	263	st.drop_next = codel_time_to_us(delta);
	264	else
	265	st.drop_next = -codel_time_to_us(-delta);
	266	}
	267
	268	return gnet_stats_copy_app(d, &st, sizeof(st));
	269	}
	270
	271	static void codel_reset(struct Qdisc *sch)
	272	{
	273	struct codel_sched_data *q = qdisc_priv(sch);
	274
	275	qdisc_reset_queue(sch);
	276	codel_vars_init(&q->vars);
	277	}
	278
	279	static struct Qdisc_ops codel_qdisc_ops __read_mostly = {
	280	.id = "codel",
	281	.priv_size = sizeof(struct codel_sched_data),
	282
	283	.enqueue = codel_qdisc_enqueue,
	284	.dequeue = codel_qdisc_dequeue,
	285	.peek = qdisc_peek_dequeued,
	286	.init = codel_init,
	287	.reset = codel_reset,
	288	.change = codel_change,
	289	.dump = codel_dump,
	290	.dump_stats = codel_dump_stats,
	291	.owner = THIS_MODULE,
	292	};
	293
	294	static int __init codel_module_init(void)
	295	{
	296	return register_qdisc(&codel_qdisc_ops);
	297	}
	298
	299	static void __exit codel_module_exit(void)
	300	{
	301	unregister_qdisc(&codel_qdisc_ops);
	302	}
	303
	304	module_init(codel_module_init)
	305	module_exit(codel_module_exit)
	306
	307	MODULE_DESCRIPTION("Controlled Delay queue discipline");
	308	MODULE_AUTHOR("Dave Taht");
	309	MODULE_AUTHOR("Eric Dumazet");
	310	MODULE_LICENSE("Dual BSD/GPL");