[deliverable/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, <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/netdevice.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 red_parms	parms;
	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->parms.qavg = red_calc_qavg(&q->parms, child->qstats.backlog);

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

	switch (red_action(&q->parms, q->parms.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 = child->enqueue(skb, child);
	if (likely(ret == NET_XMIT_SUCCESS)) {
		sch->bstats.bytes += skb->len;
		sch->bstats.packets++;
		sch->q.qlen++;
	} else {
		q->stats.pdrop++;
		sch->qstats.drops++;
	}
	return ret;

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

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

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

	ret = child->ops->requeue(skb, child);
	if (likely(ret == NET_XMIT_SUCCESS)) {
		sch->qstats.requeues++;
		sch->q.qlen++;
	}
	return ret;
}

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)
		sch->q.qlen--;
	else if (!red_is_idling(&q->parms))
		red_start_of_idle_period(&q->parms);

	return skb;
}

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->parms))
		red_start_of_idle_period(&q->parms);

	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->parms);
}

static void red_destroy(struct Qdisc *sch)
{
	struct red_sched_data *q = qdisc_priv(sch);
	qdisc_destroy(q->qdisc);
}

static struct Qdisc *red_create_dflt(struct Qdisc *sch, u32 limit)
{
	struct Qdisc *q;
	struct rtattr *rta;
	int ret;

	q = qdisc_create_dflt(sch->dev, &bfifo_qdisc_ops,
			      TC_H_MAKE(sch->handle, 1));
	if (q) {
		rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)),
			      GFP_KERNEL);
		if (rta) {
			rta->rta_type = RTM_NEWQDISC;
			rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
			((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;

			ret = q->ops->change(q, rta);
			kfree(rta);

			if (ret == 0)
				return q;
		}
		qdisc_destroy(q);
	}
	return NULL;
}

static int red_change(struct Qdisc *sch, struct rtattr *opt)
{
	struct red_sched_data *q = qdisc_priv(sch);
	struct rtattr *tb[TCA_RED_MAX];
	struct tc_red_qopt *ctl;
	struct Qdisc *child = NULL;

	if (opt == NULL || rtattr_parse_nested(tb, TCA_RED_MAX, opt))
		return -EINVAL;

	if (tb[TCA_RED_PARMS-1] == NULL ||
	    RTA_PAYLOAD(tb[TCA_RED_PARMS-1]) < sizeof(*ctl) ||
	    tb[TCA_RED_STAB-1] == NULL ||
	    RTA_PAYLOAD(tb[TCA_RED_STAB-1]) < RED_STAB_SIZE)
		return -EINVAL;

	ctl = RTA_DATA(tb[TCA_RED_PARMS-1]);

	if (ctl->limit > 0) {
		child = red_create_dflt(sch, ctl->limit);
		if (child == NULL)
			return -ENOMEM;
	}

	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(xchg(&q->qdisc, child));
	}

	red_set_parms(&q->parms, ctl->qth_min, ctl->qth_max, ctl->Wlog,
				 ctl->Plog, ctl->Scell_log,
				 RTA_DATA(tb[TCA_RED_STAB-1]));

	if (skb_queue_empty(&sch->q))
		red_end_of_idle_period(&q->parms);

	sch_tree_unlock(sch);
	return 0;
}

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

	q->qdisc = &noop_qdisc;
	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 rtattr *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,
	};

	opts = RTA_NEST(skb, TCA_OPTIONS);
	RTA_PUT(skb, TCA_RED_PARMS, sizeof(opt), &opt);
	return RTA_NEST_END(skb, opts);

rtattr_failure:
	return RTA_NEST_CANCEL(skb, opts);
}

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);

	if (cl != 1)
		return -ENOENT;
	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 = xchg(&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)
{
	return;
}

static int red_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
			    struct rtattr **tca, unsigned long *arg)
{
	return -ENOSYS;
}

static int red_delete(struct Qdisc *sch, unsigned long cl)
{
	return -ENOSYS;
}

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 struct tcf_proto **red_find_tcf(struct Qdisc *sch, unsigned long cl)
{
	return NULL;
}

static struct Qdisc_class_ops red_class_ops = {
	.graft		=	red_graft,
	.leaf		=	red_leaf,
	.get		=	red_get,
	.put		=	red_put,
	.change		=	red_change_class,
	.delete		=	red_delete,
	.walk		=	red_walk,
	.tcf_chain	=	red_find_tcf,
	.dump		=	red_dump_class,
};

static struct Qdisc_ops red_qdisc_ops = {
	.id		=	"red",
	.priv_size	=	sizeof(struct red_sched_data),
	.cl_ops		=	&red_class_ops,
	.enqueue	=	red_enqueue,
	.dequeue	=	red_dequeue,
	.requeue	=	red_requeue,
	.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/netdevice.h>
1da177e4	21	#include <linux/skbuff.h>
1da177e4 LT	22	#include <net/pkt_sched.h>
1da177e4 LT	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	*/
	39
	40	struct red_sched_data
	41	{
6b31b28a TG	42	u32 limit; /* HARD maximal queue length */
	43	unsigned char flags;
	44	struct red_parms parms;
	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
dba051f3	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
f38c39d6	65	q->parms.qavg = red_calc_qavg(&q->parms, child->qstats.backlog);
1da177e4	66
6b31b28a TG	67	if (red_is_idling(&q->parms))
6b31b28a TG	68	red_end_of_idle_period(&q->parms);
1da177e4	69
6b31b28a TG	70	switch (red_action(&q->parms, q->parms.qavg)) {
	71	case RED_DONT_MARK:
	72	break;
1da177e4	73
6b31b28a TG	74	case RED_PROB_MARK:
	75	sch->qstats.overlimits++;
	76	if (!red_use_ecn(q) \|\| !INET_ECN_set_ce(skb)) {
	77	q->stats.prob_drop++;
	78	goto congestion_drop;
	79	}
1da177e4	80
6b31b28a TG	81	q->stats.prob_mark++;
	82	break;
	83
	84	case RED_HARD_MARK:
	85	sch->qstats.overlimits++;
bdc450a0 TG	86	if (red_use_harddrop(q) \|\| !red_use_ecn(q) \|\|
bdc450a0 TG	87	!INET_ECN_set_ce(skb)) {
6b31b28a TG	88	q->stats.forced_drop++;
	89	goto congestion_drop;
	90	}
	91
	92	q->stats.forced_mark++;
	93	break;
1da177e4 LT	94	}
1da177e4 LT	95
f38c39d6 PM	96	ret = child->enqueue(skb, child);
	97	if (likely(ret == NET_XMIT_SUCCESS)) {
	98	sch->bstats.bytes += skb->len;
	99	sch->bstats.packets++;
	100	sch->q.qlen++;
	101	} else {
	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
dba051f3	112	static int red_requeue(struct sk_buff skb, struct Qdisc sch)
1da177e4 LT	113	{
1da177e4 LT	114	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6 PM	115	struct Qdisc *child = q->qdisc;
f38c39d6 PM	116	int ret;
1da177e4	117
6b31b28a TG	118	if (red_is_idling(&q->parms))
6b31b28a TG	119	red_end_of_idle_period(&q->parms);
1da177e4	120
f38c39d6 PM	121	ret = child->ops->requeue(skb, child);
	122	if (likely(ret == NET_XMIT_SUCCESS)) {
	123	sch->qstats.requeues++;
	124	sch->q.qlen++;
	125	}
	126	return ret;
1da177e4 LT	127	}
1da177e4 LT	128
dba051f3	129	static struct sk_buff * red_dequeue(struct Qdisc* sch)
1da177e4 LT	130	{
	131	struct sk_buff *skb;
	132	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6	133	struct Qdisc *child = q->qdisc;
1da177e4	134
f38c39d6 PM	135	skb = child->dequeue(child);
	136	if (skb)
	137	sch->q.qlen--;
	138	else if (!red_is_idling(&q->parms))
9e178ff2 TG	139	red_start_of_idle_period(&q->parms);
	140
	141	return skb;
1da177e4 LT	142	}
	143
	144	static unsigned int red_drop(struct Qdisc* sch)
	145	{
1da177e4	146	struct red_sched_data *q = qdisc_priv(sch);
f38c39d6 PM	147	struct Qdisc *child = q->qdisc;
f38c39d6 PM	148	unsigned int len;
1da177e4	149
f38c39d6	150	if (child->ops->drop && (len = child->ops->drop(child)) > 0) {
6b31b28a	151	q->stats.other++;
f38c39d6 PM	152	sch->qstats.drops++;
f38c39d6 PM	153	sch->q.qlen--;
1da177e4 LT	154	return len;
1da177e4 LT	155	}
6b31b28a	156
6a1b63d4 TG	157	if (!red_is_idling(&q->parms))
	158	red_start_of_idle_period(&q->parms);
	159
1da177e4 LT	160	return 0;
	161	}
	162
	163	static void red_reset(struct Qdisc* sch)
	164	{
	165	struct red_sched_data *q = qdisc_priv(sch);
	166
f38c39d6 PM	167	qdisc_reset(q->qdisc);
f38c39d6 PM	168	sch->q.qlen = 0;
6b31b28a	169	red_restart(&q->parms);
1da177e4 LT	170	}
1da177e4 LT	171
f38c39d6 PM	172	static void red_destroy(struct Qdisc *sch)
	173	{
	174	struct red_sched_data *q = qdisc_priv(sch);
	175	qdisc_destroy(q->qdisc);
	176	}
	177
9f9afec4	178	static struct Qdisc red_create_dflt(struct Qdisc sch, u32 limit)
f38c39d6	179	{
9f9afec4	180	struct Qdisc *q;
f38c39d6 PM	181	struct rtattr *rta;
	182	int ret;
	183
9f9afec4 PM	184	q = qdisc_create_dflt(sch->dev, &bfifo_qdisc_ops,
9f9afec4 PM	185	TC_H_MAKE(sch->handle, 1));
f38c39d6 PM	186	if (q) {
f38c39d6 PM	187	rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)),
10297b99	188	GFP_KERNEL);
f38c39d6 PM	189	if (rta) {
	190	rta->rta_type = RTM_NEWQDISC;
	191	rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
	192	((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;
	193
	194	ret = q->ops->change(q, rta);
	195	kfree(rta);
	196
	197	if (ret == 0)
	198	return q;
	199	}
	200	qdisc_destroy(q);
	201	}
	202	return NULL;
	203	}
	204
1da177e4 LT	205	static int red_change(struct Qdisc sch, struct rtattr opt)
	206	{
	207	struct red_sched_data *q = qdisc_priv(sch);
dba051f3	208	struct rtattr *tb[TCA_RED_MAX];
1da177e4	209	struct tc_red_qopt *ctl;
f38c39d6	210	struct Qdisc *child = NULL;
1da177e4	211
dba051f3 TG	212	if (opt == NULL \|\| rtattr_parse_nested(tb, TCA_RED_MAX, opt))
	213	return -EINVAL;
	214
	215	if (tb[TCA_RED_PARMS-1] == NULL \|\|
1da177e4	216	RTA_PAYLOAD(tb[TCA_RED_PARMS-1]) < sizeof(*ctl) \|\|
dba051f3 TG	217	tb[TCA_RED_STAB-1] == NULL \|\|
dba051f3 TG	218	RTA_PAYLOAD(tb[TCA_RED_STAB-1]) < RED_STAB_SIZE)
1da177e4 LT	219	return -EINVAL;
	220
	221	ctl = RTA_DATA(tb[TCA_RED_PARMS-1]);
	222
f38c39d6	223	if (ctl->limit > 0) {
9f9afec4	224	child = red_create_dflt(sch, ctl->limit);
f38c39d6 PM	225	if (child == NULL)
	226	return -ENOMEM;
	227	}
	228
1da177e4 LT	229	sch_tree_lock(sch);
1da177e4 LT	230	q->flags = ctl->flags;
1da177e4	231	q->limit = ctl->limit;
5e50da01 PM	232	if (child) {
5e50da01 PM	233	qdisc_tree_decrease_qlen(q->qdisc, q->qdisc->q.qlen);
f38c39d6	234	qdisc_destroy(xchg(&q->qdisc, child));
5e50da01	235	}
1da177e4	236
6b31b28a TG	237	red_set_parms(&q->parms, ctl->qth_min, ctl->qth_max, ctl->Wlog,
	238	ctl->Plog, ctl->Scell_log,
	239	RTA_DATA(tb[TCA_RED_STAB-1]));
	240
b03efcfb	241	if (skb_queue_empty(&sch->q))
6b31b28a	242	red_end_of_idle_period(&q->parms);
dba051f3	243
1da177e4 LT	244	sch_tree_unlock(sch);
	245	return 0;
	246	}
	247
	248	static int red_init(struct Qdisc* sch, struct rtattr *opt)
	249	{
f38c39d6 PM	250	struct red_sched_data *q = qdisc_priv(sch);
	251
	252	q->qdisc = &noop_qdisc;
1da177e4 LT	253	return red_change(sch, opt);
	254	}
	255
	256	static int red_dump(struct Qdisc sch, struct sk_buff skb)
	257	{
	258	struct red_sched_data *q = qdisc_priv(sch);
dba051f3	259	struct rtattr *opts = NULL;
6b31b28a TG	260	struct tc_red_qopt opt = {
	261	.limit = q->limit,
	262	.flags = q->flags,
	263	.qth_min = q->parms.qth_min >> q->parms.Wlog,
	264	.qth_max = q->parms.qth_max >> q->parms.Wlog,
	265	.Wlog = q->parms.Wlog,
	266	.Plog = q->parms.Plog,
	267	.Scell_log = q->parms.Scell_log,
	268	};
1da177e4	269
dba051f3	270	opts = RTA_NEST(skb, TCA_OPTIONS);
1da177e4	271	RTA_PUT(skb, TCA_RED_PARMS, sizeof(opt), &opt);
dba051f3	272	return RTA_NEST_END(skb, opts);
1da177e4 LT	273
1da177e4 LT	274	rtattr_failure:
dba051f3	275	return RTA_NEST_CANCEL(skb, opts);
1da177e4 LT	276	}
	277
	278	static int red_dump_stats(struct Qdisc sch, struct gnet_dump d)
	279	{
	280	struct red_sched_data *q = qdisc_priv(sch);
6b31b28a TG	281	struct tc_red_xstats st = {
	282	.early = q->stats.prob_drop + q->stats.forced_drop,
	283	.pdrop = q->stats.pdrop,
	284	.other = q->stats.other,
	285	.marked = q->stats.prob_mark + q->stats.forced_mark,
	286	};
	287
	288	return gnet_stats_copy_app(d, &st, sizeof(st));
1da177e4 LT	289	}
1da177e4 LT	290
f38c39d6 PM	291	static int red_dump_class(struct Qdisc *sch, unsigned long cl,
	292	struct sk_buff skb, struct tcmsg tcm)
	293	{
	294	struct red_sched_data *q = qdisc_priv(sch);
	295
	296	if (cl != 1)
	297	return -ENOENT;
	298	tcm->tcm_handle \|= TC_H_MIN(1);
	299	tcm->tcm_info = q->qdisc->handle;
	300	return 0;
	301	}
	302
	303	static int red_graft(struct Qdisc sch, unsigned long arg, struct Qdisc new,
	304	struct Qdisc **old)
	305	{
	306	struct red_sched_data *q = qdisc_priv(sch);
	307
	308	if (new == NULL)
	309	new = &noop_qdisc;
	310
	311	sch_tree_lock(sch);
	312	*old = xchg(&q->qdisc, new);
5e50da01	313	qdisc_tree_decrease_qlen(old, (old)->q.qlen);
f38c39d6	314	qdisc_reset(*old);
f38c39d6 PM	315	sch_tree_unlock(sch);
	316	return 0;
	317	}
	318
	319	static struct Qdisc red_leaf(struct Qdisc sch, unsigned long arg)
	320	{
	321	struct red_sched_data *q = qdisc_priv(sch);
	322	return q->qdisc;
	323	}
	324
	325	static unsigned long red_get(struct Qdisc *sch, u32 classid)
	326	{
	327	return 1;
	328	}
	329
	330	static void red_put(struct Qdisc *sch, unsigned long arg)
	331	{
	332	return;
	333	}
	334
	335	static int red_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
	336	struct rtattr *tca, unsigned long arg)
	337	{
	338	return -ENOSYS;
	339	}
	340
	341	static int red_delete(struct Qdisc *sch, unsigned long cl)
	342	{
	343	return -ENOSYS;
	344	}
	345
	346	static void red_walk(struct Qdisc sch, struct qdisc_walker walker)
	347	{
	348	if (!walker->stop) {
	349	if (walker->count >= walker->skip)
	350	if (walker->fn(sch, 1, walker) < 0) {
	351	walker->stop = 1;
	352	return;
	353	}
	354	walker->count++;
	355	}
	356	}
	357
	358	static struct tcf_proto *red_find_tcf(struct Qdisc sch, unsigned long cl)
	359	{
	360	return NULL;
	361	}
	362
	363	static struct Qdisc_class_ops red_class_ops = {
	364	.graft = red_graft,
	365	.leaf = red_leaf,
	366	.get = red_get,
	367	.put = red_put,
	368	.change = red_change_class,
	369	.delete = red_delete,
	370	.walk = red_walk,
	371	.tcf_chain = red_find_tcf,
	372	.dump = red_dump_class,
	373	};
	374
1da177e4	375	static struct Qdisc_ops red_qdisc_ops = {
1da177e4 LT	376	.id = "red",
1da177e4 LT	377	.priv_size = sizeof(struct red_sched_data),
f38c39d6	378	.cl_ops = &red_class_ops,
1da177e4 LT	379	.enqueue = red_enqueue,
	380	.dequeue = red_dequeue,
	381	.requeue = red_requeue,
	382	.drop = red_drop,
	383	.init = red_init,
	384	.reset = red_reset,
f38c39d6	385	.destroy = red_destroy,
1da177e4 LT	386	.change = red_change,
	387	.dump = red_dump,
	388	.dump_stats = red_dump_stats,
	389	.owner = THIS_MODULE,
	390	};
	391
	392	static int __init red_module_init(void)
	393	{
	394	return register_qdisc(&red_qdisc_ops);
	395	}
dba051f3 TG	396
dba051f3 TG	397	static void __exit red_module_exit(void)
1da177e4 LT	398	{
	399	unregister_qdisc(&red_qdisc_ops);
	400	}
dba051f3	401
1da177e4 LT	402	module_init(red_module_init)
1da177e4 LT	403	module_exit(red_module_exit)
dba051f3	404
1da177e4	405	MODULE_LICENSE("GPL");