[PKT_SCHED]: RED: Use new generic red interface

#include <net/pkt_sched.h>

#include <net/inet_ecn.h>

#include <net/dsfield.h>

#include <net/red.h>

/*	Random Early Detection (RED) algorithm.

	=======================================

	Source: Sally Floyd and Van Jacobson, "Random Early Detection Gateways

	for Congestion Avoidance", 1993, IEEE/ACM Transactions on Networking.

	This file codes a "divisionless" version of RED algorithm

	as written down in Fig.17 of the paper.

Short description.

------------------

	When a new packet arrives we calculate the average queue length:

	avg = (1-W)*avg + W*current_queue_len,

	W is the filter time constant (chosen as 2^(-Wlog)), it controls

	the inertia of the algorithm. To allow larger bursts, W should be

	decreased.

	if (avg > th_max) -> packet marked (dropped).

	if (avg < th_min) -> packet passes.

	if (th_min < avg < th_max) we calculate probability:

	Pb = max_P * (avg - th_min)/(th_max-th_min)

	and mark (drop) packet with this probability.

	Pb changes from 0 (at avg==th_min) to max_P (avg==th_max).

	max_P should be small (not 1), usually 0.01..0.02 is good value.

	max_P is chosen as a number, so that max_P/(th_max-th_min)

	is a negative power of two in order arithmetics to contain

	only shifts.

	Parameters, settable by user:

/*	Parameters, settable by user:

	-----------------------------

	limit		- bytes (must be > qth_max + burst)

	arbitrarily high (well, less than ram size)

	Really, this limit will never be reached

	if RED works correctly.

	qth_min		- bytes (should be < qth_max/2)

	qth_max		- bytes (should be at least 2*qth_min and less limit)

	Wlog	       	- bits (<32) log(1/W).

	Plog	       	- bits (<32)

	Plog is related to max_P by formula:

	max_P = (qth_max-qth_min)/2^Plog;

	F.e. if qth_max=128K and qth_min=32K, then Plog=22

	corresponds to max_P=0.02

	Scell_log

	Stab

	Lookup table for log((1-W)^(t/t_ave).

NOTES:

Upper bound on W.

-----------------

	If you want to allow bursts of L packets of size S,

	you should choose W:

	L + 1 - th_min/S < (1-(1-W)^L)/W

	th_min/S = 32         th_min/S = 4

	log(W)	L

	-1	33

	-2	35

	-3	39

	-4	46

	-5	57

	-6	75

	-7	101

	-8	135

	-9	190

	etc.

 */

struct red_sched_data

{

/* Parameters */

	u32			limit;		/* HARD maximal queue length */

	u32		qth_min;	/* Min average length threshold: A scaled */

	u32		qth_max;	/* Max average length threshold: A scaled */

	u32		Rmask;

	u32		Scell_max;

	unsigned char		flags;

	char		Wlog;		/* log(W)		*/

	char		Plog;		/* random number bits	*/

	char		Scell_log;

	u8		Stab[256];

/* Variables */

	unsigned long	qave;		/* Average queue length: A scaled */

	int		qcount;		/* Packets since last random number generation */

	u32		qR;		/* Cached random number */

	psched_time_t	qidlestart;	/* Start of idle period		*/

	struct tc_red_xstats st;

	struct red_parms	parms;

	struct red_stats	stats;

};

static int red_ecn_mark(struct sk_buff *skb)

static inline int red_use_ecn(struct red_sched_data *q)

{

	if (skb->nh.raw + 20 > skb->tail)

		return 0;

	switch (skb->protocol) {

	case __constant_htons(ETH_P_IP):

		if (INET_ECN_is_not_ect(skb->nh.iph->tos))

			return 0;

		IP_ECN_set_ce(skb->nh.iph);

		return 1;

	case __constant_htons(ETH_P_IPV6):

		if (INET_ECN_is_not_ect(ipv6_get_dsfield(skb->nh.ipv6h)))

			return 0;

		IP6_ECN_set_ce(skb->nh.ipv6h);

		return 1;

	default:

		return 0;

	}

	return q->flags & TC_RED_ECN;

}

static int

{

	struct red_sched_data *q = qdisc_priv(sch);

	psched_time_t now;

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

	if (!PSCHED_IS_PASTPERFECT(q->qidlestart)) {

		long us_idle;

		int  shift;

	if (red_is_idling(&q->parms))

		red_end_of_idle_period(&q->parms);

		PSCHED_GET_TIME(now);

		us_idle = PSCHED_TDIFF_SAFE(now, q->qidlestart, q->Scell_max);

		PSCHED_SET_PASTPERFECT(q->qidlestart);

	switch (red_action(&q->parms, q->parms.qavg)) {

		case RED_DONT_MARK:

			break;

/*

   The problem: ideally, average length queue recalcultion should

   be done over constant clock intervals. This is too expensive, so that

   the calculation is driven by outgoing packets.

   When the queue is idle we have to model this clock by hand.

   SF+VJ proposed to "generate" m = idletime/(average_pkt_size/bandwidth)

   dummy packets as a burst after idle time, i.e.

          q->qave *= (1-W)^m

   This is an apparently overcomplicated solution (f.e. we have to precompute

   a table to make this calculation in reasonable time)

   I believe that a simpler model may be used here,

   but it is field for experiments.

*/

		shift = q->Stab[us_idle>>q->Scell_log];

		case RED_PROB_MARK:

			sch->qstats.overlimits++;

			if (!red_use_ecn(q) || !INET_ECN_set_ce(skb)) {

				q->stats.prob_drop++;

				goto congestion_drop;

			}

		if (shift) {

			q->qave >>= shift;

		} else {

			/* Approximate initial part of exponent

			   with linear function:

			   (1-W)^m ~= 1-mW + ...

			q->stats.prob_mark++;

			break;

			   Seems, it is the best solution to

			   problem of too coarce exponent tabulation.

			 */

			us_idle = (q->qave * us_idle)>>q->Scell_log;

			if (us_idle < q->qave/2)

				q->qave -= us_idle;

			else

				q->qave >>= 1;

		case RED_HARD_MARK:

			sch->qstats.overlimits++;

			if (!red_use_ecn(q) || !INET_ECN_set_ce(skb)) {

				q->stats.forced_drop++;

				goto congestion_drop;

			}

	} else {

		q->qave += sch->qstats.backlog - (q->qave >> q->Wlog);

		/* NOTE:

		   q->qave is fixed point number with point at Wlog.

		   The formulae above is equvalent to floating point

		   version:

		   qave = qave*(1-W) + sch->qstats.backlog*W;

		                                           --ANK (980924)

		 */

			q->stats.forced_mark++;

			break;

	}

	if (q->qave < q->qth_min) {

		q->qcount = -1;

enqueue:

	if (sch->qstats.backlog + skb->len <= q->limit) {

		__skb_queue_tail(&sch->q, skb);

		sch->qstats.backlog += skb->len;

		sch->bstats.bytes += skb->len;

		sch->bstats.packets++;

		return NET_XMIT_SUCCESS;

		} else {

			q->st.pdrop++;

	}

	q->stats.pdrop++;

	kfree_skb(skb);

	sch->qstats.drops++;

	return NET_XMIT_DROP;

	}

	if (q->qave >= q->qth_max) {

		q->qcount = -1;

		sch->qstats.overlimits++;

mark:

		if  (!(q->flags&TC_RED_ECN) || !red_ecn_mark(skb)) {

			q->st.early++;

			goto drop;

		}

		q->st.marked++;

		goto enqueue;

	}

	if (++q->qcount) {

		/* The formula used below causes questions.

		   OK. qR is random number in the interval 0..Rmask

		   i.e. 0..(2^Plog). If we used floating point

		   arithmetics, it would be: (2^Plog)*rnd_num,

		   where rnd_num is less 1.

		   Taking into account, that qave have fixed

		   point at Wlog, and Plog is related to max_P by

		   max_P = (qth_max-qth_min)/2^Plog; two lines

		   below have the following floating point equivalent:

		   max_P*(qave - qth_min)/(qth_max-qth_min) < rnd/qcount

		   Any questions? --ANK (980924)

		 */

		if (((q->qave - q->qth_min)>>q->Wlog)*q->qcount < q->qR)

			goto enqueue;

		q->qcount = 0;

		q->qR = net_random()&q->Rmask;

		sch->qstats.overlimits++;

		goto mark;

	}

	q->qR = net_random()&q->Rmask;

	goto enqueue;

drop:

congestion_drop:

	kfree_skb(skb);

	sch->qstats.drops++;

	return NET_XMIT_CN;

{

	struct red_sched_data *q = qdisc_priv(sch);

	PSCHED_SET_PASTPERFECT(q->qidlestart);

	if (red_is_idling(&q->parms))

		red_end_of_idle_period(&q->parms);

	__skb_queue_head(&sch->q, skb);

	sch->qstats.backlog += skb->len;

		sch->qstats.backlog -= skb->len;

		return skb;

	}

	PSCHED_GET_TIME(q->qidlestart);

	red_start_of_idle_period(&q->parms);

	return NULL;

}

		unsigned int len = skb->len;

		sch->qstats.backlog -= len;

		sch->qstats.drops++;

		q->st.other++;

		q->stats.other++;

		kfree_skb(skb);

		return len;

	}

	PSCHED_GET_TIME(q->qidlestart);

	red_start_of_idle_period(&q->parms);

	return 0;

}

	__skb_queue_purge(&sch->q);

	sch->qstats.backlog = 0;

	PSCHED_SET_PASTPERFECT(q->qidlestart);

	q->qave = 0;

	q->qcount = -1;

	red_restart(&q->parms);

}

static int red_change(struct Qdisc *sch, struct rtattr *opt)

	sch_tree_lock(sch);

	q->flags = ctl->flags;

	q->Wlog = ctl->Wlog;

	q->Plog = ctl->Plog;

	q->Rmask = ctl->Plog < 32 ? ((1<<ctl->Plog) - 1) : ~0UL;

	q->Scell_log = ctl->Scell_log;

	q->Scell_max = (255<<q->Scell_log);

	q->qth_min = ctl->qth_min<<ctl->Wlog;

	q->qth_max = ctl->qth_max<<ctl->Wlog;

	q->limit = ctl->limit;

	memcpy(q->Stab, RTA_DATA(tb[TCA_RED_STAB-1]), 256);

	q->qcount = -1;

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

		PSCHED_SET_PASTPERFECT(q->qidlestart);

		red_end_of_idle_period(&q->parms);

	sch_tree_unlock(sch);

	return 0;

}

	struct red_sched_data *q = qdisc_priv(sch);

	unsigned char	 *b = skb->tail;

	struct rtattr *rta;

	struct tc_red_qopt opt;

	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,

	};

	rta = (struct rtattr*)b;

	RTA_PUT(skb, TCA_OPTIONS, 0, NULL);

	opt.limit = q->limit;

	opt.qth_min = q->qth_min>>q->Wlog;

	opt.qth_max = q->qth_max>>q->Wlog;

	opt.Wlog = q->Wlog;

	opt.Plog = q->Plog;

	opt.Scell_log = q->Scell_log;

	opt.flags = q->flags;

	RTA_PUT(skb, TCA_RED_PARMS, sizeof(opt), &opt);

	rta->rta_len = skb->tail - b;

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, &q->st, sizeof(q->st));

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

}

static struct Qdisc_ops red_qdisc_ops = {