[linux-2.6-block.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:
		sch->qstats.overlimits++;
		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:
		sch->qstats.overlimits++;
		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)) {
		sch->q.qlen++;
	} else if (net_xmit_drop_count(ret)) {
		q->stats.pdrop++;
		sch->qstats.drops++;
	}
	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);
		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++;
		sch->qstats.drops++;
		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->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_decrease_qlen(q->qdisc, q->qdisc->q.qlen);
		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;

	sch_tree_lock(sch);
	*old = q->qdisc;
	q->qdisc = new;
	qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
	qdisc_reset(*old);
	sch_tree_unlock(sch);
	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:
	77	sch->qstats.overlimits++;
	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:
	87	sch->qstats.overlimits++;
	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)) {
f38c39d6	100	sch->q.qlen++;
378a2f09	101	} else if (net_xmit_drop_count(ret)) {
f38c39d6 PM	102	q->stats.pdrop++;
	103	sch->qstats.drops++;
	104	}
	105	return ret;
6b31b28a TG	106
6b31b28a TG	107	congestion_drop:
9e178ff2	108	qdisc_drop(skb, sch);
1da177e4 LT	109	return NET_XMIT_CN;
	110	}
	111
cc7ec456	112	static struct sk_buff red_dequeue(struct Qdisc sch)
1da177e4 LT	113	{
	114	struct sk_buff *skb;
	115	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6	116	struct Qdisc *child = q->qdisc;
1da177e4	117
f38c39d6	118	skb = child->dequeue(child);
9190b3b3 ED	119	if (skb) {
9190b3b3 ED	120	qdisc_bstats_update(sch, skb);
f38c39d6	121	sch->q.qlen--;
9190b3b3	122	} else {
eeca6688 ED	123	if (!red_is_idling(&q->vars))
eeca6688 ED	124	red_start_of_idle_period(&q->vars);
9190b3b3	125	}
9e178ff2	126	return skb;
1da177e4 LT	127	}
1da177e4 LT	128
cc7ec456	129	static struct sk_buff red_peek(struct Qdisc sch)
8e3af978 JP	130	{
	131	struct red_sched_data *q = qdisc_priv(sch);
	132	struct Qdisc *child = q->qdisc;
	133
	134	return child->ops->peek(child);
	135	}
	136
cc7ec456	137	static unsigned int red_drop(struct Qdisc *sch)
1da177e4	138	{
1da177e4	139	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6 PM	140	struct Qdisc *child = q->qdisc;
f38c39d6 PM	141	unsigned int len;
1da177e4	142
f38c39d6	143	if (child->ops->drop && (len = child->ops->drop(child)) > 0) {
6b31b28a	144	q->stats.other++;
f38c39d6 PM	145	sch->qstats.drops++;
f38c39d6 PM	146	sch->q.qlen--;
1da177e4 LT	147	return len;
1da177e4 LT	148	}
6b31b28a	149
eeca6688 ED	150	if (!red_is_idling(&q->vars))
eeca6688 ED	151	red_start_of_idle_period(&q->vars);
6a1b63d4	152
1da177e4 LT	153	return 0;
	154	}
	155
cc7ec456	156	static void red_reset(struct Qdisc *sch)
1da177e4 LT	157	{
	158	struct red_sched_data *q = qdisc_priv(sch);
	159
f38c39d6 PM	160	qdisc_reset(q->qdisc);
f38c39d6 PM	161	sch->q.qlen = 0;
eeca6688	162	red_restart(&q->vars);
1da177e4 LT	163	}
1da177e4 LT	164
f38c39d6 PM	165	static void red_destroy(struct Qdisc *sch)
	166	{
	167	struct red_sched_data *q = qdisc_priv(sch);
8af2a218 ED	168
8af2a218 ED	169	del_timer_sync(&q->adapt_timer);
f38c39d6 PM	170	qdisc_destroy(q->qdisc);
	171	}
	172
27a3421e PM	173	static const struct nla_policy red_policy[TCA_RED_MAX + 1] = {
	174	[TCA_RED_PARMS] = { .len = sizeof(struct tc_red_qopt) },
	175	[TCA_RED_STAB] = { .len = RED_STAB_SIZE },
a73ed26b	176	[TCA_RED_MAX_P] = { .type = NLA_U32 },
27a3421e PM	177	};
27a3421e PM	178
1e90474c	179	static int red_change(struct Qdisc sch, struct nlattr opt)
1da177e4 LT	180	{
1da177e4 LT	181	struct red_sched_data *q = qdisc_priv(sch);
1e90474c	182	struct nlattr *tb[TCA_RED_MAX + 1];
1da177e4	183	struct tc_red_qopt *ctl;
f38c39d6	184	struct Qdisc *child = NULL;
cee63723	185	int err;
a73ed26b	186	u32 max_P;
1da177e4	187
cee63723	188	if (opt == NULL)
dba051f3 TG	189	return -EINVAL;
dba051f3 TG	190
27a3421e	191	err = nla_parse_nested(tb, TCA_RED_MAX, opt, red_policy);
cee63723 PM	192	if (err < 0)
	193	return err;
	194
1e90474c	195	if (tb[TCA_RED_PARMS] == NULL \|\|
27a3421e	196	tb[TCA_RED_STAB] == NULL)
1da177e4 LT	197	return -EINVAL;
1da177e4 LT	198
a73ed26b ED	199	max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;
a73ed26b ED	200
1e90474c	201	ctl = nla_data(tb[TCA_RED_PARMS]);
1da177e4	202
f38c39d6	203	if (ctl->limit > 0) {
fb0305ce PM	204	child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit);
	205	if (IS_ERR(child))
	206	return PTR_ERR(child);
f38c39d6 PM	207	}
f38c39d6 PM	208
1da177e4 LT	209	sch_tree_lock(sch);
1da177e4 LT	210	q->flags = ctl->flags;
1da177e4	211	q->limit = ctl->limit;
5e50da01 PM	212	if (child) {
5e50da01 PM	213	qdisc_tree_decrease_qlen(q->qdisc, q->qdisc->q.qlen);
b94c8afc PM	214	qdisc_destroy(q->qdisc);
b94c8afc PM	215	q->qdisc = child;
5e50da01	216	}
1da177e4	217
eeca6688 ED	218	red_set_parms(&q->parms,
eeca6688 ED	219	ctl->qth_min, ctl->qth_max, ctl->Wlog,
a73ed26b ED	220	ctl->Plog, ctl->Scell_log,
	221	nla_data(tb[TCA_RED_STAB]),
	222	max_P);
eeca6688	223	red_set_vars(&q->vars);
6b31b28a	224
8af2a218 ED	225	del_timer(&q->adapt_timer);
	226	if (ctl->flags & TC_RED_ADAPTATIVE)
	227	mod_timer(&q->adapt_timer, jiffies + HZ/2);
	228
1ee5fa1e	229	if (!q->qdisc->q.qlen)
eeca6688	230	red_start_of_idle_period(&q->vars);
dba051f3	231
1da177e4 LT	232	sch_tree_unlock(sch);
	233	return 0;
	234	}
	235
8af2a218 ED	236	static inline void red_adaptative_timer(unsigned long arg)
	237	{
	238	struct Qdisc sch = (struct Qdisc )arg;
	239	struct red_sched_data *q = qdisc_priv(sch);
	240	spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));
	241
	242	spin_lock(root_lock);
eeca6688	243	red_adaptative_algo(&q->parms, &q->vars);
8af2a218 ED	244	mod_timer(&q->adapt_timer, jiffies + HZ/2);
	245	spin_unlock(root_lock);
	246	}
	247
cc7ec456	248	static int red_init(struct Qdisc sch, struct nlattr opt)
1da177e4	249	{
f38c39d6 PM	250	struct red_sched_data *q = qdisc_priv(sch);
	251
	252	q->qdisc = &noop_qdisc;
8af2a218	253	setup_timer(&q->adapt_timer, red_adaptative_timer, (unsigned long)sch);
1da177e4 LT	254	return red_change(sch, opt);
	255	}
	256
	257	static int red_dump(struct Qdisc sch, struct sk_buff skb)
	258	{
	259	struct red_sched_data *q = qdisc_priv(sch);
1e90474c	260	struct nlattr *opts = NULL;
6b31b28a TG	261	struct tc_red_qopt opt = {
	262	.limit = q->limit,
	263	.flags = q->flags,
	264	.qth_min = q->parms.qth_min >> q->parms.Wlog,
	265	.qth_max = q->parms.qth_max >> q->parms.Wlog,
	266	.Wlog = q->parms.Wlog,
	267	.Plog = q->parms.Plog,
	268	.Scell_log = q->parms.Scell_log,
	269	};
1da177e4	270
0dfb33a0	271	sch->qstats.backlog = q->qdisc->qstats.backlog;
1e90474c PM	272	opts = nla_nest_start(skb, TCA_OPTIONS);
	273	if (opts == NULL)
	274	goto nla_put_failure;
1b34ec43 DM	275	if (nla_put(skb, TCA_RED_PARMS, sizeof(opt), &opt) \|\|
	276	nla_put_u32(skb, TCA_RED_MAX_P, q->parms.max_P))
	277	goto nla_put_failure;
1e90474c	278	return nla_nest_end(skb, opts);
1da177e4	279
1e90474c	280	nla_put_failure:
bc3ed28c TG	281	nla_nest_cancel(skb, opts);
bc3ed28c TG	282	return -EMSGSIZE;
1da177e4 LT	283	}
	284
	285	static int red_dump_stats(struct Qdisc sch, struct gnet_dump d)
	286	{
	287	struct red_sched_data *q = qdisc_priv(sch);
6b31b28a TG	288	struct tc_red_xstats st = {
	289	.early = q->stats.prob_drop + q->stats.forced_drop,
	290	.pdrop = q->stats.pdrop,
	291	.other = q->stats.other,
	292	.marked = q->stats.prob_mark + q->stats.forced_mark,
	293	};
	294
	295	return gnet_stats_copy_app(d, &st, sizeof(st));
1da177e4 LT	296	}
1da177e4 LT	297
f38c39d6 PM	298	static int red_dump_class(struct Qdisc *sch, unsigned long cl,
	299	struct sk_buff skb, struct tcmsg tcm)
	300	{
	301	struct red_sched_data *q = qdisc_priv(sch);
	302
f38c39d6 PM	303	tcm->tcm_handle \|= TC_H_MIN(1);
	304	tcm->tcm_info = q->qdisc->handle;
	305	return 0;
	306	}
	307
	308	static int red_graft(struct Qdisc sch, unsigned long arg, struct Qdisc new,
	309	struct Qdisc **old)
	310	{
	311	struct red_sched_data *q = qdisc_priv(sch);
	312
	313	if (new == NULL)
	314	new = &noop_qdisc;
	315
	316	sch_tree_lock(sch);
b94c8afc PM	317	*old = q->qdisc;
b94c8afc PM	318	q->qdisc = new;
5e50da01	319	qdisc_tree_decrease_qlen(old, (old)->q.qlen);
f38c39d6	320	qdisc_reset(*old);
f38c39d6 PM	321	sch_tree_unlock(sch);
	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");