[mirror_ubuntu-focal-kernel.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, <kuznet@ms2.inr.ac.ru>
 *
 * Changes:
 * J Hadi Salim 980914:	computation fixes
 * Alexey Makarenko <makar@phoenix.kharkov.ua> 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/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 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 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);
	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);
	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 unsigned int red_drop(struct Qdisc *sch)
{
	struct red_sched_data *q = qdisc_priv(sch);
	struct Qdisc *child = q->qdisc;
	unsigned int len;

	if (child->ops->drop && (len = child->ops->drop(child)) > 0) {
		q->stats.other++;
		qdisc_qstats_drop(sch);
		sch->qstats.backlog -= len;
		sch->q.qlen--;
		return len;
	}

	if (!red_is_idling(&q->vars))
		red_start_of_idle_period(&q->vars);

	return 0;
}

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 void red_destroy(struct Qdisc *sch)
{
	struct red_sched_data *q = qdisc_priv(sch);

	del_timer_sync(&q->adapt_timer);
	qdisc_destroy(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 red_sched_data *q = qdisc_priv(sch);
	struct nlattr *tb[TCA_RED_MAX + 1];
	struct tc_red_qopt *ctl;
	struct Qdisc *child = NULL;
	int err;
	u32 max_P;

	if (opt == NULL)
		return -EINVAL;

	err = nla_parse_nested(tb, TCA_RED_MAX, opt, red_policy);
	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 (ctl->limit > 0) {
		child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit);
		if (IS_ERR(child))
			return PTR_ERR(child);
	}

	sch_tree_lock(sch);
	q->flags = ctl->flags;
	q->limit = ctl->limit;
	if (child) {
		qdisc_tree_reduce_backlog(q->qdisc, q->qdisc->q.qlen,
					  q->qdisc->qstats.backlog);
		qdisc_destroy(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);
	return 0;
}

static inline void red_adaptative_timer(unsigned long arg)
{
	struct Qdisc *sch = (struct Qdisc *)arg;
	struct red_sched_data *q = qdisc_priv(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 red_sched_data *q = qdisc_priv(sch);

	q->qdisc = &noop_qdisc;
	setup_timer(&q->adapt_timer, red_adaptative_timer, (unsigned long)sch);
	return red_change(sch, opt);
}

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,
	};

	sch->qstats.backlog = q->qdisc->qstats.backlog;
	opts = nla_nest_start(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 tc_red_xstats st = {
		.early	= q->stats.prob_drop + q->stats.forced_drop,
		.pdrop	= q->stats.pdrop,
		.other	= q->stats.other,
		.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 int red_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
		     struct Qdisc **old)
{
	struct red_sched_data *q = qdisc_priv(sch);

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

	*old = qdisc_replace(sch, new, &q->qdisc);
	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_get(struct Qdisc *sch, u32 classid)
{
	return 1;
}

static void red_put(struct Qdisc *sch, unsigned long arg)
{
}

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,
	.get		=	red_get,
	.put		=	red_put,
	.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,
	.drop		=	red_drop,
	.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, <kuznet@ms2.inr.ac.ru>
	10	*
	11	* Changes:
dba051f3	12	* J Hadi Salim 980914: computation fixes
1da177e4	13	* Alexey Makarenko <makar@phoenix.kharkov.ua> 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 LT	21	#include <net/pkt_sched.h>
1da177e4 LT	22	#include <net/inet_ecn.h>
6b31b28a	23	#include <net/red.h>
1da177e4 LT	24
1da177e4 LT	25
6b31b28a	26	/* Parameters, settable by user:
1da177e4 LT	27	-----------------------------
	28
	29	limit - bytes (must be > qth_max + burst)
	30
	31	Hard limit on queue length, should be chosen >qth_max
	32	to allow packet bursts. This parameter does not
	33	affect the algorithms behaviour and can be chosen
	34	arbitrarily high (well, less than ram size)
	35	Really, this limit will never be reached
	36	if RED works correctly.
1da177e4 LT	37	*/
1da177e4 LT	38
cc7ec456	39	struct red_sched_data {
6b31b28a TG	40	u32 limit; /* HARD maximal queue length */
6b31b28a TG	41	unsigned char flags;
8af2a218	42	struct timer_list adapt_timer;
6b31b28a	43	struct red_parms parms;
eeca6688	44	struct red_vars vars;
6b31b28a	45	struct red_stats stats;
f38c39d6	46	struct Qdisc *qdisc;
1da177e4 LT	47	};
1da177e4 LT	48
6b31b28a	49	static inline int red_use_ecn(struct red_sched_data *q)
1da177e4	50	{
6b31b28a	51	return q->flags & TC_RED_ECN;
1da177e4 LT	52	}
1da177e4 LT	53
bdc450a0 TG	54	static inline int red_use_harddrop(struct red_sched_data *q)
	55	{
	56	return q->flags & TC_RED_HARDDROP;
	57	}
	58
cc7ec456	59	static int red_enqueue(struct sk_buff skb, struct Qdisc sch)
1da177e4 LT	60	{
1da177e4 LT	61	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6 PM	62	struct Qdisc *child = q->qdisc;
f38c39d6 PM	63	int ret;
1da177e4	64
eeca6688 ED	65	q->vars.qavg = red_calc_qavg(&q->parms,
	66	&q->vars,
	67	child->qstats.backlog);
1da177e4	68
eeca6688 ED	69	if (red_is_idling(&q->vars))
eeca6688 ED	70	red_end_of_idle_period(&q->vars);
1da177e4	71
eeca6688	72	switch (red_action(&q->parms, &q->vars, q->vars.qavg)) {
cc7ec456 ED	73	case RED_DONT_MARK:
	74	break;
	75
	76	case RED_PROB_MARK:
25331d6c	77	qdisc_qstats_overlimit(sch);
cc7ec456 ED	78	if (!red_use_ecn(q) \|\| !INET_ECN_set_ce(skb)) {
	79	q->stats.prob_drop++;
	80	goto congestion_drop;
	81	}
	82
	83	q->stats.prob_mark++;
	84	break;
	85
	86	case RED_HARD_MARK:
25331d6c	87	qdisc_qstats_overlimit(sch);
cc7ec456 ED	88	if (red_use_harddrop(q) \|\| !red_use_ecn(q) \|\|
	89	!INET_ECN_set_ce(skb)) {
	90	q->stats.forced_drop++;
	91	goto congestion_drop;
	92	}
	93
	94	q->stats.forced_mark++;
	95	break;
1da177e4 LT	96	}
1da177e4 LT	97
5f86173b	98	ret = qdisc_enqueue(skb, child);
f38c39d6	99	if (likely(ret == NET_XMIT_SUCCESS)) {
d7f4f332	100	qdisc_qstats_backlog_inc(sch, skb);
f38c39d6	101	sch->q.qlen++;
378a2f09	102	} else if (net_xmit_drop_count(ret)) {
f38c39d6	103	q->stats.pdrop++;
25331d6c	104	qdisc_qstats_drop(sch);
f38c39d6 PM	105	}
f38c39d6 PM	106	return ret;
6b31b28a TG	107
6b31b28a TG	108	congestion_drop:
9e178ff2	109	qdisc_drop(skb, sch);
1da177e4 LT	110	return NET_XMIT_CN;
	111	}
	112
cc7ec456	113	static struct sk_buff red_dequeue(struct Qdisc sch)
1da177e4 LT	114	{
	115	struct sk_buff *skb;
	116	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6	117	struct Qdisc *child = q->qdisc;
1da177e4	118
f38c39d6	119	skb = child->dequeue(child);
9190b3b3 ED	120	if (skb) {
9190b3b3 ED	121	qdisc_bstats_update(sch, skb);
d7f4f332	122	qdisc_qstats_backlog_dec(sch, skb);
f38c39d6	123	sch->q.qlen--;
9190b3b3	124	} else {
eeca6688 ED	125	if (!red_is_idling(&q->vars))
eeca6688 ED	126	red_start_of_idle_period(&q->vars);
9190b3b3	127	}
9e178ff2	128	return skb;
1da177e4 LT	129	}
1da177e4 LT	130
cc7ec456	131	static struct sk_buff red_peek(struct Qdisc sch)
8e3af978 JP	132	{
	133	struct red_sched_data *q = qdisc_priv(sch);
	134	struct Qdisc *child = q->qdisc;
	135
	136	return child->ops->peek(child);
	137	}
	138
cc7ec456	139	static unsigned int red_drop(struct Qdisc *sch)
1da177e4	140	{
1da177e4	141	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6 PM	142	struct Qdisc *child = q->qdisc;
f38c39d6 PM	143	unsigned int len;
1da177e4	144
f38c39d6	145	if (child->ops->drop && (len = child->ops->drop(child)) > 0) {
6b31b28a	146	q->stats.other++;
25331d6c	147	qdisc_qstats_drop(sch);
d7f4f332	148	sch->qstats.backlog -= len;
f38c39d6	149	sch->q.qlen--;
1da177e4 LT	150	return len;
1da177e4 LT	151	}
6b31b28a	152
eeca6688 ED	153	if (!red_is_idling(&q->vars))
eeca6688 ED	154	red_start_of_idle_period(&q->vars);
6a1b63d4	155
1da177e4 LT	156	return 0;
	157	}
	158
cc7ec456	159	static void red_reset(struct Qdisc *sch)
1da177e4 LT	160	{
	161	struct red_sched_data *q = qdisc_priv(sch);
	162
f38c39d6	163	qdisc_reset(q->qdisc);
d7f4f332	164	sch->qstats.backlog = 0;
f38c39d6	165	sch->q.qlen = 0;
eeca6688	166	red_restart(&q->vars);
1da177e4 LT	167	}
1da177e4 LT	168
f38c39d6 PM	169	static void red_destroy(struct Qdisc *sch)
	170	{
	171	struct red_sched_data *q = qdisc_priv(sch);
8af2a218 ED	172
8af2a218 ED	173	del_timer_sync(&q->adapt_timer);
f38c39d6 PM	174	qdisc_destroy(q->qdisc);
	175	}
	176
27a3421e PM	177	static const struct nla_policy red_policy[TCA_RED_MAX + 1] = {
	178	[TCA_RED_PARMS] = { .len = sizeof(struct tc_red_qopt) },
	179	[TCA_RED_STAB] = { .len = RED_STAB_SIZE },
a73ed26b	180	[TCA_RED_MAX_P] = { .type = NLA_U32 },
27a3421e PM	181	};
27a3421e PM	182
1e90474c	183	static int red_change(struct Qdisc sch, struct nlattr opt)
1da177e4 LT	184	{
1da177e4 LT	185	struct red_sched_data *q = qdisc_priv(sch);
1e90474c	186	struct nlattr *tb[TCA_RED_MAX + 1];
1da177e4	187	struct tc_red_qopt *ctl;
f38c39d6	188	struct Qdisc *child = NULL;
cee63723	189	int err;
a73ed26b	190	u32 max_P;
1da177e4	191
cee63723	192	if (opt == NULL)
dba051f3 TG	193	return -EINVAL;
dba051f3 TG	194
27a3421e	195	err = nla_parse_nested(tb, TCA_RED_MAX, opt, red_policy);
cee63723 PM	196	if (err < 0)
	197	return err;
	198
1e90474c	199	if (tb[TCA_RED_PARMS] == NULL \|\|
27a3421e	200	tb[TCA_RED_STAB] == NULL)
1da177e4 LT	201	return -EINVAL;
1da177e4 LT	202
a73ed26b ED	203	max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;
a73ed26b ED	204
1e90474c	205	ctl = nla_data(tb[TCA_RED_PARMS]);
1da177e4	206
f38c39d6	207	if (ctl->limit > 0) {
fb0305ce PM	208	child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit);
	209	if (IS_ERR(child))
	210	return PTR_ERR(child);
f38c39d6 PM	211	}
f38c39d6 PM	212
1da177e4 LT	213	sch_tree_lock(sch);
1da177e4 LT	214	q->flags = ctl->flags;
1da177e4	215	q->limit = ctl->limit;
5e50da01	216	if (child) {
2ccccf5f WC	217	qdisc_tree_reduce_backlog(q->qdisc, q->qdisc->q.qlen,
2ccccf5f WC	218	q->qdisc->qstats.backlog);
b94c8afc PM	219	qdisc_destroy(q->qdisc);
b94c8afc PM	220	q->qdisc = child;
5e50da01	221	}
1da177e4	222
eeca6688 ED	223	red_set_parms(&q->parms,
eeca6688 ED	224	ctl->qth_min, ctl->qth_max, ctl->Wlog,
a73ed26b ED	225	ctl->Plog, ctl->Scell_log,
	226	nla_data(tb[TCA_RED_STAB]),
	227	max_P);
eeca6688	228	red_set_vars(&q->vars);
6b31b28a	229
8af2a218 ED	230	del_timer(&q->adapt_timer);
	231	if (ctl->flags & TC_RED_ADAPTATIVE)
	232	mod_timer(&q->adapt_timer, jiffies + HZ/2);
	233
1ee5fa1e	234	if (!q->qdisc->q.qlen)
eeca6688	235	red_start_of_idle_period(&q->vars);
dba051f3	236
1da177e4 LT	237	sch_tree_unlock(sch);
	238	return 0;
	239	}
	240
8af2a218 ED	241	static inline void red_adaptative_timer(unsigned long arg)
	242	{
	243	struct Qdisc sch = (struct Qdisc )arg;
	244	struct red_sched_data *q = qdisc_priv(sch);
	245	spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));
	246
	247	spin_lock(root_lock);
eeca6688	248	red_adaptative_algo(&q->parms, &q->vars);
8af2a218 ED	249	mod_timer(&q->adapt_timer, jiffies + HZ/2);
	250	spin_unlock(root_lock);
	251	}
	252
cc7ec456	253	static int red_init(struct Qdisc sch, struct nlattr opt)
1da177e4	254	{
f38c39d6 PM	255	struct red_sched_data *q = qdisc_priv(sch);
	256
	257	q->qdisc = &noop_qdisc;
8af2a218	258	setup_timer(&q->adapt_timer, red_adaptative_timer, (unsigned long)sch);
1da177e4 LT	259	return red_change(sch, opt);
	260	}
	261
	262	static int red_dump(struct Qdisc sch, struct sk_buff skb)
	263	{
	264	struct red_sched_data *q = qdisc_priv(sch);
1e90474c	265	struct nlattr *opts = NULL;
6b31b28a TG	266	struct tc_red_qopt opt = {
	267	.limit = q->limit,
	268	.flags = q->flags,
	269	.qth_min = q->parms.qth_min >> q->parms.Wlog,
	270	.qth_max = q->parms.qth_max >> q->parms.Wlog,
	271	.Wlog = q->parms.Wlog,
	272	.Plog = q->parms.Plog,
	273	.Scell_log = q->parms.Scell_log,
	274	};
1da177e4	275
0dfb33a0	276	sch->qstats.backlog = q->qdisc->qstats.backlog;
1e90474c PM	277	opts = nla_nest_start(skb, TCA_OPTIONS);
	278	if (opts == NULL)
	279	goto nla_put_failure;
1b34ec43 DM	280	if (nla_put(skb, TCA_RED_PARMS, sizeof(opt), &opt) \|\|
	281	nla_put_u32(skb, TCA_RED_MAX_P, q->parms.max_P))
	282	goto nla_put_failure;
1e90474c	283	return nla_nest_end(skb, opts);
1da177e4	284
1e90474c	285	nla_put_failure:
bc3ed28c TG	286	nla_nest_cancel(skb, opts);
bc3ed28c TG	287	return -EMSGSIZE;
1da177e4 LT	288	}
	289
	290	static int red_dump_stats(struct Qdisc sch, struct gnet_dump d)
	291	{
	292	struct red_sched_data *q = qdisc_priv(sch);
6b31b28a TG	293	struct tc_red_xstats st = {
	294	.early = q->stats.prob_drop + q->stats.forced_drop,
	295	.pdrop = q->stats.pdrop,
	296	.other = q->stats.other,
	297	.marked = q->stats.prob_mark + q->stats.forced_mark,
	298	};
	299
	300	return gnet_stats_copy_app(d, &st, sizeof(st));
1da177e4 LT	301	}
1da177e4 LT	302
f38c39d6 PM	303	static int red_dump_class(struct Qdisc *sch, unsigned long cl,
	304	struct sk_buff skb, struct tcmsg tcm)
	305	{
	306	struct red_sched_data *q = qdisc_priv(sch);
	307
f38c39d6 PM	308	tcm->tcm_handle \|= TC_H_MIN(1);
	309	tcm->tcm_info = q->qdisc->handle;
	310	return 0;
	311	}
	312
	313	static int red_graft(struct Qdisc sch, unsigned long arg, struct Qdisc new,
	314	struct Qdisc **old)
	315	{
	316	struct red_sched_data *q = qdisc_priv(sch);
	317
	318	if (new == NULL)
	319	new = &noop_qdisc;
	320
86a7996c	321	*old = qdisc_replace(sch, new, &q->qdisc);
f38c39d6 PM	322	return 0;
	323	}
	324
	325	static struct Qdisc red_leaf(struct Qdisc sch, unsigned long arg)
	326	{
	327	struct red_sched_data *q = qdisc_priv(sch);
	328	return q->qdisc;
	329	}
	330
	331	static unsigned long red_get(struct Qdisc *sch, u32 classid)
	332	{
	333	return 1;
	334	}
	335
	336	static void red_put(struct Qdisc *sch, unsigned long arg)
	337	{
f38c39d6 PM	338	}
f38c39d6 PM	339
f38c39d6 PM	340	static void red_walk(struct Qdisc sch, struct qdisc_walker walker)
	341	{
	342	if (!walker->stop) {
	343	if (walker->count >= walker->skip)
	344	if (walker->fn(sch, 1, walker) < 0) {
	345	walker->stop = 1;
	346	return;
	347	}
	348	walker->count++;
	349	}
	350	}
	351
20fea08b	352	static const struct Qdisc_class_ops red_class_ops = {
f38c39d6 PM	353	.graft = red_graft,
	354	.leaf = red_leaf,
	355	.get = red_get,
	356	.put = red_put,
f38c39d6	357	.walk = red_walk,
f38c39d6 PM	358	.dump = red_dump_class,
	359	};
	360
20fea08b	361	static struct Qdisc_ops red_qdisc_ops __read_mostly = {
1da177e4 LT	362	.id = "red",
1da177e4 LT	363	.priv_size = sizeof(struct red_sched_data),
f38c39d6	364	.cl_ops = &red_class_ops,
1da177e4 LT	365	.enqueue = red_enqueue,
1da177e4 LT	366	.dequeue = red_dequeue,
8e3af978	367	.peek = red_peek,
1da177e4 LT	368	.drop = red_drop,
	369	.init = red_init,
	370	.reset = red_reset,
f38c39d6	371	.destroy = red_destroy,
1da177e4 LT	372	.change = red_change,
	373	.dump = red_dump,
	374	.dump_stats = red_dump_stats,
	375	.owner = THIS_MODULE,
	376	};
	377
	378	static int __init red_module_init(void)
	379	{
	380	return register_qdisc(&red_qdisc_ops);
	381	}
dba051f3 TG	382
dba051f3 TG	383	static void __exit red_module_exit(void)
1da177e4 LT	384	{
	385	unregister_qdisc(&red_qdisc_ops);
	386	}
dba051f3	387
1da177e4 LT	388	module_init(red_module_init)
1da177e4 LT	389	module_exit(red_module_exit)
dba051f3	390
1da177e4	391	MODULE_LICENSE("GPL");