[linux.git] / net / sched / sch_red.c

/*
 * net/sched/sch_red.c	Random Early Detection queue.
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 * Authors:	Alexey Kuznetsov, <[email protected]>
 *
 * Changes:
 * J Hadi Salim 980914:	computation fixes
 * Alexey Makarenko <[email protected]> 990814: qave on idle link was calculated incorrectly.
 * J Hadi Salim 980816:  ECN support
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/skbuff.h>
#include <net/pkt_sched.h>
#include <net/pkt_cls.h>
#include <net/inet_ecn.h>
#include <net/red.h>


/*	Parameters, settable by user:
	-----------------------------

	limit		- bytes (must be > qth_max + burst)

	Hard limit on queue length, should be chosen >qth_max
	to allow packet bursts. This parameter does not
	affect the algorithms behaviour and can be chosen
	arbitrarily high (well, less than ram size)
	Really, this limit will never be reached
	if RED works correctly.
 */

struct red_sched_data {
	u32			limit;		/* HARD maximal queue length */
	unsigned char		flags;
	struct timer_list	adapt_timer;
	struct Qdisc		*sch;
	struct red_parms	parms;
	struct red_vars		vars;
	struct red_stats	stats;
	struct Qdisc		*qdisc;
};

static inline int red_use_ecn(struct red_sched_data *q)
{
	return q->flags & TC_RED_ECN;
}

static inline int red_use_harddrop(struct red_sched_data *q)
{
	return q->flags & TC_RED_HARDDROP;
}

static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch,
		       struct sk_buff **to_free)
{
	struct red_sched_data *q = qdisc_priv(sch);
	struct Qdisc *child = q->qdisc;
	int ret;

	q->vars.qavg = red_calc_qavg(&q->parms,
				     &q->vars,
				     child->qstats.backlog);

	if (red_is_idling(&q->vars))
		red_end_of_idle_period(&q->vars);

	switch (red_action(&q->parms, &q->vars, q->vars.qavg)) {
	case RED_DONT_MARK:
		break;

	case RED_PROB_MARK:
		qdisc_qstats_overlimit(sch);
		if (!red_use_ecn(q) || !INET_ECN_set_ce(skb)) {
			q->stats.prob_drop++;
			goto congestion_drop;
		}

		q->stats.prob_mark++;
		break;

	case RED_HARD_MARK:
		qdisc_qstats_overlimit(sch);
		if (red_use_harddrop(q) || !red_use_ecn(q) ||
		    !INET_ECN_set_ce(skb)) {
			q->stats.forced_drop++;
			goto congestion_drop;
		}

		q->stats.forced_mark++;
		break;
	}

	ret = qdisc_enqueue(skb, child, to_free);
	if (likely(ret == NET_XMIT_SUCCESS)) {
		qdisc_qstats_backlog_inc(sch, skb);
		sch->q.qlen++;
	} else if (net_xmit_drop_count(ret)) {
		q->stats.pdrop++;
		qdisc_qstats_drop(sch);
	}
	return ret;

congestion_drop:
	qdisc_drop(skb, sch, to_free);
	return NET_XMIT_CN;
}

static struct sk_buff *red_dequeue(struct Qdisc *sch)
{
	struct sk_buff *skb;
	struct red_sched_data *q = qdisc_priv(sch);
	struct Qdisc *child = q->qdisc;

	skb = child->dequeue(child);
	if (skb) {
		qdisc_bstats_update(sch, skb);
		qdisc_qstats_backlog_dec(sch, skb);
		sch->q.qlen--;
	} else {
		if (!red_is_idling(&q->vars))
			red_start_of_idle_period(&q->vars);
	}
	return skb;
}

static struct sk_buff *red_peek(struct Qdisc *sch)
{
	struct red_sched_data *q = qdisc_priv(sch);
	struct Qdisc *child = q->qdisc;

	return child->ops->peek(child);
}

static void red_reset(struct Qdisc *sch)
{
	struct red_sched_data *q = qdisc_priv(sch);

	qdisc_reset(q->qdisc);
	sch->qstats.backlog = 0;
	sch->q.qlen = 0;
	red_restart(&q->vars);
}

static int red_offload(struct Qdisc *sch, bool enable)
{
	struct red_sched_data *q = qdisc_priv(sch);
	struct net_device *dev = qdisc_dev(sch);
	struct tc_red_qopt_offload opt = {
		.handle = sch->handle,
		.parent = sch->parent,
	};

	if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc)
		return -EOPNOTSUPP;

	if (enable) {
		opt.command = TC_RED_REPLACE;
		opt.set.min = q->parms.qth_min >> q->parms.Wlog;
		opt.set.max = q->parms.qth_max >> q->parms.Wlog;
		opt.set.probability = q->parms.max_P;
		opt.set.limit = q->limit;
		opt.set.is_ecn = red_use_ecn(q);
		opt.set.is_harddrop = red_use_harddrop(q);
		opt.set.qstats = &sch->qstats;
	} else {
		opt.command = TC_RED_DESTROY;
	}

	return dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_RED, &opt);
}

static void red_destroy(struct Qdisc *sch)
{
	struct red_sched_data *q = qdisc_priv(sch);

	del_timer_sync(&q->adapt_timer);
	red_offload(sch, false);
	qdisc_put(q->qdisc);
}

static const struct nla_policy red_policy[TCA_RED_MAX + 1] = {
	[TCA_RED_PARMS]	= { .len = sizeof(struct tc_red_qopt) },
	[TCA_RED_STAB]	= { .len = RED_STAB_SIZE },
	[TCA_RED_MAX_P] = { .type = NLA_U32 },
};

static int red_change(struct Qdisc *sch, struct nlattr *opt,
		      struct netlink_ext_ack *extack)
{
	struct Qdisc *old_child = NULL, *child = NULL;
	struct red_sched_data *q = qdisc_priv(sch);
	struct nlattr *tb[TCA_RED_MAX + 1];
	struct tc_red_qopt *ctl;
	int err;
	u32 max_P;

	if (opt == NULL)
		return -EINVAL;

	err = nla_parse_nested_deprecated(tb, TCA_RED_MAX, opt, red_policy,
					  NULL);
	if (err < 0)
		return err;

	if (tb[TCA_RED_PARMS] == NULL ||
	    tb[TCA_RED_STAB] == NULL)
		return -EINVAL;

	max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;

	ctl = nla_data(tb[TCA_RED_PARMS]);
	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog))
		return -EINVAL;

	if (ctl->limit > 0) {
		child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit,
					 extack);
		if (IS_ERR(child))
			return PTR_ERR(child);

		/* child is fifo, no need to check for noop_qdisc */
		qdisc_hash_add(child, true);
	}

	sch_tree_lock(sch);
	q->flags = ctl->flags;
	q->limit = ctl->limit;
	if (child) {
		qdisc_tree_flush_backlog(q->qdisc);
		old_child = q->qdisc;
		q->qdisc = child;
	}

	red_set_parms(&q->parms,
		      ctl->qth_min, ctl->qth_max, ctl->Wlog,
		      ctl->Plog, ctl->Scell_log,
		      nla_data(tb[TCA_RED_STAB]),
		      max_P);
	red_set_vars(&q->vars);

	del_timer(&q->adapt_timer);
	if (ctl->flags & TC_RED_ADAPTATIVE)
		mod_timer(&q->adapt_timer, jiffies + HZ/2);

	if (!q->qdisc->q.qlen)
		red_start_of_idle_period(&q->vars);

	sch_tree_unlock(sch);

	red_offload(sch, true);

	if (old_child)
		qdisc_put(old_child);
	return 0;
}

static inline void red_adaptative_timer(struct timer_list *t)
{
	struct red_sched_data *q = from_timer(q, t, adapt_timer);
	struct Qdisc *sch = q->sch;
	spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));

	spin_lock(root_lock);
	red_adaptative_algo(&q->parms, &q->vars);
	mod_timer(&q->adapt_timer, jiffies + HZ/2);
	spin_unlock(root_lock);
}

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

	q->qdisc = &noop_qdisc;
	q->sch = sch;
	timer_setup(&q->adapt_timer, red_adaptative_timer, 0);
	return red_change(sch, opt, extack);
}

static int red_dump_offload_stats(struct Qdisc *sch)
{
	struct tc_red_qopt_offload hw_stats = {
		.command = TC_RED_STATS,
		.handle = sch->handle,
		.parent = sch->parent,
		{
			.stats.bstats = &sch->bstats,
			.stats.qstats = &sch->qstats,
		},
	};

	return qdisc_offload_dump_helper(sch, TC_SETUP_QDISC_RED, &hw_stats);
}

static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
{
	struct red_sched_data *q = qdisc_priv(sch);
	struct nlattr *opts = NULL;
	struct tc_red_qopt opt = {
		.limit		= q->limit,
		.flags		= q->flags,
		.qth_min	= q->parms.qth_min >> q->parms.Wlog,
		.qth_max	= q->parms.qth_max >> q->parms.Wlog,
		.Wlog		= q->parms.Wlog,
		.Plog		= q->parms.Plog,
		.Scell_log	= q->parms.Scell_log,
	};
	int err;

	err = red_dump_offload_stats(sch);
	if (err)
		goto nla_put_failure;

	opts = nla_nest_start_noflag(skb, TCA_OPTIONS);
	if (opts == NULL)
		goto nla_put_failure;
	if (nla_put(skb, TCA_RED_PARMS, sizeof(opt), &opt) ||
	    nla_put_u32(skb, TCA_RED_MAX_P, q->parms.max_P))
		goto nla_put_failure;
	return nla_nest_end(skb, opts);

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

static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
{
	struct red_sched_data *q = qdisc_priv(sch);
	struct net_device *dev = qdisc_dev(sch);
	struct tc_red_xstats st = {0};

	if (sch->flags & TCQ_F_OFFLOADED) {
		struct tc_red_qopt_offload hw_stats_request = {
			.command = TC_RED_XSTATS,
			.handle = sch->handle,
			.parent = sch->parent,
			{
				.xstats = &q->stats,
			},
		};
		dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_RED,
					      &hw_stats_request);
	}
	st.early = q->stats.prob_drop + q->stats.forced_drop;
	st.pdrop = q->stats.pdrop;
	st.other = q->stats.other;
	st.marked = q->stats.prob_mark + q->stats.forced_mark;

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

static int red_dump_class(struct Qdisc *sch, unsigned long cl,
			  struct sk_buff *skb, struct tcmsg *tcm)
{
	struct red_sched_data *q = qdisc_priv(sch);

	tcm->tcm_handle |= TC_H_MIN(1);
	tcm->tcm_info = q->qdisc->handle;
	return 0;
}

static void red_graft_offload(struct Qdisc *sch,
			      struct Qdisc *new, struct Qdisc *old,
			      struct netlink_ext_ack *extack)
{
	struct tc_red_qopt_offload graft_offload = {
		.handle		= sch->handle,
		.parent		= sch->parent,
		.child_handle	= new->handle,
		.command	= TC_RED_GRAFT,
	};

	qdisc_offload_graft_helper(qdisc_dev(sch), sch, new, old,
				   TC_SETUP_QDISC_RED, &graft_offload, extack);
}

static int red_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
		     struct Qdisc **old, struct netlink_ext_ack *extack)
{
	struct red_sched_data *q = qdisc_priv(sch);

	if (new == NULL)
		new = &noop_qdisc;

	*old = qdisc_replace(sch, new, &q->qdisc);

	red_graft_offload(sch, new, *old, extack);
	return 0;
}

static struct Qdisc *red_leaf(struct Qdisc *sch, unsigned long arg)
{
	struct red_sched_data *q = qdisc_priv(sch);
	return q->qdisc;
}

static unsigned long red_find(struct Qdisc *sch, u32 classid)
{
	return 1;
}

static void red_walk(struct Qdisc *sch, struct qdisc_walker *walker)
{
	if (!walker->stop) {
		if (walker->count >= walker->skip)
			if (walker->fn(sch, 1, walker) < 0) {
				walker->stop = 1;
				return;
			}
		walker->count++;
	}
}

static const struct Qdisc_class_ops red_class_ops = {
	.graft		=	red_graft,
	.leaf		=	red_leaf,
	.find		=	red_find,
	.walk		=	red_walk,
	.dump		=	red_dump_class,
};

static struct Qdisc_ops red_qdisc_ops __read_mostly = {
	.id		=	"red",
	.priv_size	=	sizeof(struct red_sched_data),
	.cl_ops		=	&red_class_ops,
	.enqueue	=	red_enqueue,
	.dequeue	=	red_dequeue,
	.peek		=	red_peek,
	.init		=	red_init,
	.reset		=	red_reset,
	.destroy	=	red_destroy,
	.change		=	red_change,
	.dump		=	red_dump,
	.dump_stats	=	red_dump_stats,
	.owner		=	THIS_MODULE,
};

static int __init red_module_init(void)
{
	return register_qdisc(&red_qdisc_ops);
}

static void __exit red_module_exit(void)
{
	unregister_qdisc(&red_qdisc_ops);
}

module_init(red_module_init)
module_exit(red_module_exit)

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* net/sched/sch_red.c Random Early Detection queue.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*
	9	* Authors: Alexey Kuznetsov, <[email protected]>
	10	*
	11	* Changes:
dba051f3	12	* J Hadi Salim 980914: computation fixes
1da177e4	13	* Alexey Makarenko <[email protected]> 990814: qave on idle link was calculated incorrectly.
dba051f3	14	* J Hadi Salim 980816: ECN support
1da177e4 LT	15	*/
1da177e4 LT	16
1da177e4	17	#include <linux/module.h>
1da177e4 LT	18	#include <linux/types.h>
1da177e4 LT	19	#include <linux/kernel.h>
1da177e4	20	#include <linux/skbuff.h>
1da177e4	21	#include <net/pkt_sched.h>
602f3baf	22	#include <net/pkt_cls.h>
1da177e4	23	#include <net/inet_ecn.h>
6b31b28a	24	#include <net/red.h>
1da177e4 LT	25
1da177e4 LT	26
6b31b28a	27	/* Parameters, settable by user:
1da177e4 LT	28	-----------------------------
	29
	30	limit - bytes (must be > qth_max + burst)
	31
	32	Hard limit on queue length, should be chosen >qth_max
	33	to allow packet bursts. This parameter does not
	34	affect the algorithms behaviour and can be chosen
	35	arbitrarily high (well, less than ram size)
	36	Really, this limit will never be reached
	37	if RED works correctly.
1da177e4 LT	38	*/
1da177e4 LT	39
cc7ec456	40	struct red_sched_data {
6b31b28a TG	41	u32 limit; /* HARD maximal queue length */
6b31b28a TG	42	unsigned char flags;
8af2a218	43	struct timer_list adapt_timer;
cdeabbb8	44	struct Qdisc *sch;
6b31b28a	45	struct red_parms parms;
eeca6688	46	struct red_vars vars;
6b31b28a	47	struct red_stats stats;
f38c39d6	48	struct Qdisc *qdisc;
1da177e4 LT	49	};
1da177e4 LT	50
6b31b28a	51	static inline int red_use_ecn(struct red_sched_data *q)
1da177e4	52	{
6b31b28a	53	return q->flags & TC_RED_ECN;
1da177e4 LT	54	}
1da177e4 LT	55
bdc450a0 TG	56	static inline int red_use_harddrop(struct red_sched_data *q)
	57	{
	58	return q->flags & TC_RED_HARDDROP;
	59	}
	60
520ac30f ED	61	static int red_enqueue(struct sk_buff skb, struct Qdisc sch,
520ac30f ED	62	struct sk_buff **to_free)
1da177e4 LT	63	{
1da177e4 LT	64	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6 PM	65	struct Qdisc *child = q->qdisc;
f38c39d6 PM	66	int ret;
1da177e4	67
eeca6688 ED	68	q->vars.qavg = red_calc_qavg(&q->parms,
	69	&q->vars,
	70	child->qstats.backlog);
1da177e4	71
eeca6688 ED	72	if (red_is_idling(&q->vars))
eeca6688 ED	73	red_end_of_idle_period(&q->vars);
1da177e4	74
eeca6688	75	switch (red_action(&q->parms, &q->vars, q->vars.qavg)) {
cc7ec456 ED	76	case RED_DONT_MARK:
	77	break;
	78
	79	case RED_PROB_MARK:
25331d6c	80	qdisc_qstats_overlimit(sch);
cc7ec456 ED	81	if (!red_use_ecn(q) \|\| !INET_ECN_set_ce(skb)) {
	82	q->stats.prob_drop++;
	83	goto congestion_drop;
	84	}
	85
	86	q->stats.prob_mark++;
	87	break;
	88
	89	case RED_HARD_MARK:
25331d6c	90	qdisc_qstats_overlimit(sch);
cc7ec456 ED	91	if (red_use_harddrop(q) \|\| !red_use_ecn(q) \|\|
	92	!INET_ECN_set_ce(skb)) {
	93	q->stats.forced_drop++;
	94	goto congestion_drop;
	95	}
	96
	97	q->stats.forced_mark++;
	98	break;
1da177e4 LT	99	}
1da177e4 LT	100
520ac30f	101	ret = qdisc_enqueue(skb, child, to_free);
f38c39d6	102	if (likely(ret == NET_XMIT_SUCCESS)) {
d7f4f332	103	qdisc_qstats_backlog_inc(sch, skb);
f38c39d6	104	sch->q.qlen++;
378a2f09	105	} else if (net_xmit_drop_count(ret)) {
f38c39d6	106	q->stats.pdrop++;
25331d6c	107	qdisc_qstats_drop(sch);
f38c39d6 PM	108	}
f38c39d6 PM	109	return ret;
6b31b28a TG	110
6b31b28a TG	111	congestion_drop:
520ac30f	112	qdisc_drop(skb, sch, to_free);
1da177e4 LT	113	return NET_XMIT_CN;
	114	}
	115
cc7ec456	116	static struct sk_buff red_dequeue(struct Qdisc sch)
1da177e4 LT	117	{
	118	struct sk_buff *skb;
	119	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6	120	struct Qdisc *child = q->qdisc;
1da177e4	121
f38c39d6	122	skb = child->dequeue(child);
9190b3b3 ED	123	if (skb) {
9190b3b3 ED	124	qdisc_bstats_update(sch, skb);
d7f4f332	125	qdisc_qstats_backlog_dec(sch, skb);
f38c39d6	126	sch->q.qlen--;
9190b3b3	127	} else {
eeca6688 ED	128	if (!red_is_idling(&q->vars))
eeca6688 ED	129	red_start_of_idle_period(&q->vars);
9190b3b3	130	}
9e178ff2	131	return skb;
1da177e4 LT	132	}
1da177e4 LT	133
cc7ec456	134	static struct sk_buff red_peek(struct Qdisc sch)
8e3af978 JP	135	{
	136	struct red_sched_data *q = qdisc_priv(sch);
	137	struct Qdisc *child = q->qdisc;
	138
	139	return child->ops->peek(child);
	140	}
	141
cc7ec456	142	static void red_reset(struct Qdisc *sch)
1da177e4 LT	143	{
	144	struct red_sched_data *q = qdisc_priv(sch);
	145
f38c39d6	146	qdisc_reset(q->qdisc);
d7f4f332	147	sch->qstats.backlog = 0;
f38c39d6	148	sch->q.qlen = 0;
eeca6688	149	red_restart(&q->vars);
1da177e4 LT	150	}
1da177e4 LT	151
602f3baf NF	152	static int red_offload(struct Qdisc *sch, bool enable)
	153	{
	154	struct red_sched_data *q = qdisc_priv(sch);
	155	struct net_device *dev = qdisc_dev(sch);
	156	struct tc_red_qopt_offload opt = {
	157	.handle = sch->handle,
	158	.parent = sch->parent,
	159	};
	160
	161	if (!tc_can_offload(dev) \|\| !dev->netdev_ops->ndo_setup_tc)
	162	return -EOPNOTSUPP;
	163
	164	if (enable) {
	165	opt.command = TC_RED_REPLACE;
	166	opt.set.min = q->parms.qth_min >> q->parms.Wlog;
	167	opt.set.max = q->parms.qth_max >> q->parms.Wlog;
	168	opt.set.probability = q->parms.max_P;
c0b7490b	169	opt.set.limit = q->limit;
602f3baf	170	opt.set.is_ecn = red_use_ecn(q);
190852a5	171	opt.set.is_harddrop = red_use_harddrop(q);
416ef9b1	172	opt.set.qstats = &sch->qstats;
602f3baf NF	173	} else {
	174	opt.command = TC_RED_DESTROY;
	175	}
	176
8234af2d	177	return dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_RED, &opt);
602f3baf NF	178	}
602f3baf NF	179
f38c39d6 PM	180	static void red_destroy(struct Qdisc *sch)
	181	{
	182	struct red_sched_data *q = qdisc_priv(sch);
8af2a218 ED	183
8af2a218 ED	184	del_timer_sync(&q->adapt_timer);
602f3baf	185	red_offload(sch, false);
86bd446b	186	qdisc_put(q->qdisc);
f38c39d6 PM	187	}
f38c39d6 PM	188
27a3421e PM	189	static const struct nla_policy red_policy[TCA_RED_MAX + 1] = {
	190	[TCA_RED_PARMS] = { .len = sizeof(struct tc_red_qopt) },
	191	[TCA_RED_STAB] = { .len = RED_STAB_SIZE },
a73ed26b	192	[TCA_RED_MAX_P] = { .type = NLA_U32 },
27a3421e PM	193	};
27a3421e PM	194
2030721c AA	195	static int red_change(struct Qdisc sch, struct nlattr opt,
2030721c AA	196	struct netlink_ext_ack *extack)
1da177e4	197	{
0c8d13ac	198	struct Qdisc old_child = NULL, child = NULL;
1da177e4	199	struct red_sched_data *q = qdisc_priv(sch);
1e90474c	200	struct nlattr *tb[TCA_RED_MAX + 1];
1da177e4	201	struct tc_red_qopt *ctl;
cee63723	202	int err;
a73ed26b	203	u32 max_P;
1da177e4	204
cee63723	205	if (opt == NULL)
dba051f3 TG	206	return -EINVAL;
dba051f3 TG	207
8cb08174 JB	208	err = nla_parse_nested_deprecated(tb, TCA_RED_MAX, opt, red_policy,
8cb08174 JB	209	NULL);
cee63723 PM	210	if (err < 0)
	211	return err;
	212
1e90474c	213	if (tb[TCA_RED_PARMS] == NULL \|\|
27a3421e	214	tb[TCA_RED_STAB] == NULL)
1da177e4 LT	215	return -EINVAL;
1da177e4 LT	216
a73ed26b ED	217	max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;
a73ed26b ED	218
1e90474c	219	ctl = nla_data(tb[TCA_RED_PARMS]);
8afa10cb NF	220	if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog))
8afa10cb NF	221	return -EINVAL;
1da177e4	222
f38c39d6	223	if (ctl->limit > 0) {
a38a9882 AA	224	child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit,
a38a9882 AA	225	extack);
fb0305ce PM	226	if (IS_ERR(child))
fb0305ce PM	227	return PTR_ERR(child);
f38c39d6	228
44a63b13	229	/* child is fifo, no need to check for noop_qdisc */
49b49971	230	qdisc_hash_add(child, true);
44a63b13 PA	231	}
44a63b13 PA	232
1da177e4 LT	233	sch_tree_lock(sch);
1da177e4 LT	234	q->flags = ctl->flags;
1da177e4	235	q->limit = ctl->limit;
5e50da01	236	if (child) {
e5f0e8f8	237	qdisc_tree_flush_backlog(q->qdisc);
0c8d13ac	238	old_child = q->qdisc;
b94c8afc	239	q->qdisc = child;
5e50da01	240	}
1da177e4	241
eeca6688 ED	242	red_set_parms(&q->parms,
eeca6688 ED	243	ctl->qth_min, ctl->qth_max, ctl->Wlog,
a73ed26b ED	244	ctl->Plog, ctl->Scell_log,
	245	nla_data(tb[TCA_RED_STAB]),
	246	max_P);
eeca6688	247	red_set_vars(&q->vars);
6b31b28a	248
8af2a218 ED	249	del_timer(&q->adapt_timer);
	250	if (ctl->flags & TC_RED_ADAPTATIVE)
	251	mod_timer(&q->adapt_timer, jiffies + HZ/2);
	252
1ee5fa1e	253	if (!q->qdisc->q.qlen)
eeca6688	254	red_start_of_idle_period(&q->vars);
dba051f3	255
1da177e4	256	sch_tree_unlock(sch);
0c8d13ac	257
602f3baf	258	red_offload(sch, true);
0c8d13ac JK	259
	260	if (old_child)
	261	qdisc_put(old_child);
1da177e4 LT	262	return 0;
	263	}
	264
cdeabbb8	265	static inline void red_adaptative_timer(struct timer_list *t)
8af2a218	266	{
cdeabbb8 KC	267	struct red_sched_data *q = from_timer(q, t, adapt_timer);
cdeabbb8 KC	268	struct Qdisc *sch = q->sch;
8af2a218 ED	269	spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));
	270
	271	spin_lock(root_lock);
eeca6688	272	red_adaptative_algo(&q->parms, &q->vars);
8af2a218 ED	273	mod_timer(&q->adapt_timer, jiffies + HZ/2);
	274	spin_unlock(root_lock);
	275	}
	276
e63d7dfd AA	277	static int red_init(struct Qdisc sch, struct nlattr opt,
e63d7dfd AA	278	struct netlink_ext_ack *extack)
1da177e4	279	{
f38c39d6 PM	280	struct red_sched_data *q = qdisc_priv(sch);
	281
	282	q->qdisc = &noop_qdisc;
cdeabbb8 KC	283	q->sch = sch;
cdeabbb8 KC	284	timer_setup(&q->adapt_timer, red_adaptative_timer, 0);
2030721c	285	return red_change(sch, opt, extack);
1da177e4 LT	286	}
1da177e4 LT	287
dad54c0f	288	static int red_dump_offload_stats(struct Qdisc *sch)
602f3baf	289	{
602f3baf	290	struct tc_red_qopt_offload hw_stats = {
ee9d3429	291	.command = TC_RED_STATS,
602f3baf NF	292	.handle = sch->handle,
602f3baf NF	293	.parent = sch->parent,
ee9d3429 AM	294	{
	295	.stats.bstats = &sch->bstats,
	296	.stats.qstats = &sch->qstats,
	297	},
602f3baf	298	};
8234af2d	299
b592843c	300	return qdisc_offload_dump_helper(sch, TC_SETUP_QDISC_RED, &hw_stats);
602f3baf NF	301	}
602f3baf NF	302
1da177e4 LT	303	static int red_dump(struct Qdisc sch, struct sk_buff skb)
	304	{
	305	struct red_sched_data *q = qdisc_priv(sch);
1e90474c	306	struct nlattr *opts = NULL;
6b31b28a TG	307	struct tc_red_qopt opt = {
	308	.limit = q->limit,
	309	.flags = q->flags,
	310	.qth_min = q->parms.qth_min >> q->parms.Wlog,
	311	.qth_max = q->parms.qth_max >> q->parms.Wlog,
	312	.Wlog = q->parms.Wlog,
	313	.Plog = q->parms.Plog,
	314	.Scell_log = q->parms.Scell_log,
	315	};
602f3baf	316	int err;
1da177e4	317
dad54c0f	318	err = red_dump_offload_stats(sch);
602f3baf NF	319	if (err)
	320	goto nla_put_failure;
	321
ae0be8de	322	opts = nla_nest_start_noflag(skb, TCA_OPTIONS);
1e90474c PM	323	if (opts == NULL)
1e90474c PM	324	goto nla_put_failure;
1b34ec43 DM	325	if (nla_put(skb, TCA_RED_PARMS, sizeof(opt), &opt) \|\|
	326	nla_put_u32(skb, TCA_RED_MAX_P, q->parms.max_P))
	327	goto nla_put_failure;
1e90474c	328	return nla_nest_end(skb, opts);
1da177e4	329
1e90474c	330	nla_put_failure:
bc3ed28c TG	331	nla_nest_cancel(skb, opts);
bc3ed28c TG	332	return -EMSGSIZE;
1da177e4 LT	333	}
	334
	335	static int red_dump_stats(struct Qdisc sch, struct gnet_dump d)
	336	{
	337	struct red_sched_data *q = qdisc_priv(sch);
602f3baf	338	struct net_device *dev = qdisc_dev(sch);
f8253df5	339	struct tc_red_xstats st = {0};
6b31b28a	340
428a68af	341	if (sch->flags & TCQ_F_OFFLOADED) {
602f3baf	342	struct tc_red_qopt_offload hw_stats_request = {
ee9d3429	343	.command = TC_RED_XSTATS,
602f3baf NF	344	.handle = sch->handle,
602f3baf NF	345	.parent = sch->parent,
ee9d3429	346	{
f8253df5	347	.xstats = &q->stats,
ee9d3429	348	},
602f3baf	349	};
f8253df5 NF	350	dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_RED,
f8253df5 NF	351	&hw_stats_request);
602f3baf	352	}
f8253df5 NF	353	st.early = q->stats.prob_drop + q->stats.forced_drop;
	354	st.pdrop = q->stats.pdrop;
	355	st.other = q->stats.other;
	356	st.marked = q->stats.prob_mark + q->stats.forced_mark;
602f3baf	357
6b31b28a	358	return gnet_stats_copy_app(d, &st, sizeof(st));
1da177e4 LT	359	}
1da177e4 LT	360
f38c39d6 PM	361	static int red_dump_class(struct Qdisc *sch, unsigned long cl,
	362	struct sk_buff skb, struct tcmsg tcm)
	363	{
	364	struct red_sched_data *q = qdisc_priv(sch);
	365
f38c39d6 PM	366	tcm->tcm_handle \|= TC_H_MIN(1);
	367	tcm->tcm_info = q->qdisc->handle;
	368	return 0;
	369	}
	370
bf2a752b JK	371	static void red_graft_offload(struct Qdisc *sch,
	372	struct Qdisc new, struct Qdisc old,
	373	struct netlink_ext_ack *extack)
	374	{
	375	struct tc_red_qopt_offload graft_offload = {
	376	.handle = sch->handle,
	377	.parent = sch->parent,
	378	.child_handle = new->handle,
	379	.command = TC_RED_GRAFT,
	380	};
	381
	382	qdisc_offload_graft_helper(qdisc_dev(sch), sch, new, old,
	383	TC_SETUP_QDISC_RED, &graft_offload, extack);
	384	}
	385
f38c39d6	386	static int red_graft(struct Qdisc sch, unsigned long arg, struct Qdisc new,
653d6fd6	387	struct Qdisc *old, struct netlink_ext_ack extack)
f38c39d6 PM	388	{
	389	struct red_sched_data *q = qdisc_priv(sch);
	390
	391	if (new == NULL)
	392	new = &noop_qdisc;
	393
86a7996c	394	*old = qdisc_replace(sch, new, &q->qdisc);
bf2a752b JK	395
bf2a752b JK	396	red_graft_offload(sch, new, *old, extack);
f38c39d6 PM	397	return 0;
	398	}
	399
	400	static struct Qdisc red_leaf(struct Qdisc sch, unsigned long arg)
	401	{
	402	struct red_sched_data *q = qdisc_priv(sch);
	403	return q->qdisc;
	404	}
	405
143976ce	406	static unsigned long red_find(struct Qdisc *sch, u32 classid)
f38c39d6 PM	407	{
	408	return 1;
	409	}
	410
f38c39d6 PM	411	static void red_walk(struct Qdisc sch, struct qdisc_walker walker)
	412	{
	413	if (!walker->stop) {
	414	if (walker->count >= walker->skip)
	415	if (walker->fn(sch, 1, walker) < 0) {
	416	walker->stop = 1;
	417	return;
	418	}
	419	walker->count++;
	420	}
	421	}
	422
20fea08b	423	static const struct Qdisc_class_ops red_class_ops = {
f38c39d6 PM	424	.graft = red_graft,
f38c39d6 PM	425	.leaf = red_leaf,
143976ce	426	.find = red_find,
f38c39d6	427	.walk = red_walk,
f38c39d6 PM	428	.dump = red_dump_class,
	429	};
	430
20fea08b	431	static struct Qdisc_ops red_qdisc_ops __read_mostly = {
1da177e4 LT	432	.id = "red",
1da177e4 LT	433	.priv_size = sizeof(struct red_sched_data),
f38c39d6	434	.cl_ops = &red_class_ops,
1da177e4 LT	435	.enqueue = red_enqueue,
1da177e4 LT	436	.dequeue = red_dequeue,
8e3af978	437	.peek = red_peek,
1da177e4 LT	438	.init = red_init,
1da177e4 LT	439	.reset = red_reset,
f38c39d6	440	.destroy = red_destroy,
1da177e4 LT	441	.change = red_change,
	442	.dump = red_dump,
	443	.dump_stats = red_dump_stats,
	444	.owner = THIS_MODULE,
	445	};
	446
	447	static int __init red_module_init(void)
	448	{
	449	return register_qdisc(&red_qdisc_ops);
	450	}
dba051f3 TG	451
dba051f3 TG	452	static void __exit red_module_exit(void)
1da177e4 LT	453	{
	454	unregister_qdisc(&red_qdisc_ops);
	455	}
dba051f3	456
1da177e4 LT	457	module_init(red_module_init)
1da177e4 LT	458	module_exit(red_module_exit)
dba051f3	459
1da177e4	460	MODULE_LICENSE("GPL");