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