Merge branch 'red' of 84.73.165.173:/home/tgr/repos/net-2.6
commit
2d43f1128a
|
@ -93,6 +93,7 @@ struct tc_fifo_qopt
|
||||||
/* PRIO section */
|
/* PRIO section */
|
||||||
|
|
||||||
#define TCQ_PRIO_BANDS 16
|
#define TCQ_PRIO_BANDS 16
|
||||||
|
#define TCQ_MIN_PRIO_BANDS 2
|
||||||
|
|
||||||
struct tc_prio_qopt
|
struct tc_prio_qopt
|
||||||
{
|
{
|
||||||
|
@ -169,6 +170,7 @@ struct tc_red_qopt
|
||||||
unsigned char Scell_log; /* cell size for idle damping */
|
unsigned char Scell_log; /* cell size for idle damping */
|
||||||
unsigned char flags;
|
unsigned char flags;
|
||||||
#define TC_RED_ECN 1
|
#define TC_RED_ECN 1
|
||||||
|
#define TC_RED_HARDDROP 2
|
||||||
};
|
};
|
||||||
|
|
||||||
struct tc_red_xstats
|
struct tc_red_xstats
|
||||||
|
@ -194,38 +196,34 @@ enum
|
||||||
|
|
||||||
#define TCA_GRED_MAX (__TCA_GRED_MAX - 1)
|
#define TCA_GRED_MAX (__TCA_GRED_MAX - 1)
|
||||||
|
|
||||||
#define TCA_SET_OFF TCA_GRED_PARMS
|
|
||||||
struct tc_gred_qopt
|
struct tc_gred_qopt
|
||||||
{
|
{
|
||||||
__u32 limit; /* HARD maximal queue length (bytes)
|
__u32 limit; /* HARD maximal queue length (bytes) */
|
||||||
*/
|
__u32 qth_min; /* Min average length threshold (bytes) */
|
||||||
__u32 qth_min; /* Min average length threshold (bytes)
|
__u32 qth_max; /* Max average length threshold (bytes) */
|
||||||
*/
|
__u32 DP; /* upto 2^32 DPs */
|
||||||
__u32 qth_max; /* Max average length threshold (bytes)
|
__u32 backlog;
|
||||||
*/
|
__u32 qave;
|
||||||
__u32 DP; /* upto 2^32 DPs */
|
__u32 forced;
|
||||||
__u32 backlog;
|
__u32 early;
|
||||||
__u32 qave;
|
__u32 other;
|
||||||
__u32 forced;
|
__u32 pdrop;
|
||||||
__u32 early;
|
__u8 Wlog; /* log(W) */
|
||||||
__u32 other;
|
__u8 Plog; /* log(P_max/(qth_max-qth_min)) */
|
||||||
__u32 pdrop;
|
__u8 Scell_log; /* cell size for idle damping */
|
||||||
|
__u8 prio; /* prio of this VQ */
|
||||||
unsigned char Wlog; /* log(W) */
|
__u32 packets;
|
||||||
unsigned char Plog; /* log(P_max/(qth_max-qth_min)) */
|
__u32 bytesin;
|
||||||
unsigned char Scell_log; /* cell size for idle damping */
|
|
||||||
__u8 prio; /* prio of this VQ */
|
|
||||||
__u32 packets;
|
|
||||||
__u32 bytesin;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
/* gred setup */
|
/* gred setup */
|
||||||
struct tc_gred_sopt
|
struct tc_gred_sopt
|
||||||
{
|
{
|
||||||
__u32 DPs;
|
__u32 DPs;
|
||||||
__u32 def_DP;
|
__u32 def_DP;
|
||||||
__u8 grio;
|
__u8 grio;
|
||||||
__u8 pad1;
|
__u8 flags;
|
||||||
__u16 pad2;
|
__u16 pad1;
|
||||||
};
|
};
|
||||||
|
|
||||||
/* HTB section */
|
/* HTB section */
|
||||||
|
|
|
@ -2,6 +2,7 @@
|
||||||
#define _INET_ECN_H_
|
#define _INET_ECN_H_
|
||||||
|
|
||||||
#include <linux/ip.h>
|
#include <linux/ip.h>
|
||||||
|
#include <linux/skbuff.h>
|
||||||
#include <net/dsfield.h>
|
#include <net/dsfield.h>
|
||||||
|
|
||||||
enum {
|
enum {
|
||||||
|
@ -48,7 +49,7 @@ static inline __u8 INET_ECN_encapsulate(__u8 outer, __u8 inner)
|
||||||
(label) |= __constant_htons(INET_ECN_ECT_0 << 4); \
|
(label) |= __constant_htons(INET_ECN_ECT_0 << 4); \
|
||||||
} while (0)
|
} while (0)
|
||||||
|
|
||||||
static inline void IP_ECN_set_ce(struct iphdr *iph)
|
static inline int IP_ECN_set_ce(struct iphdr *iph)
|
||||||
{
|
{
|
||||||
u32 check = iph->check;
|
u32 check = iph->check;
|
||||||
u32 ecn = (iph->tos + 1) & INET_ECN_MASK;
|
u32 ecn = (iph->tos + 1) & INET_ECN_MASK;
|
||||||
|
@ -61,7 +62,7 @@ static inline void IP_ECN_set_ce(struct iphdr *iph)
|
||||||
* INET_ECN_CE => 00
|
* INET_ECN_CE => 00
|
||||||
*/
|
*/
|
||||||
if (!(ecn & 2))
|
if (!(ecn & 2))
|
||||||
return;
|
return !ecn;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* The following gives us:
|
* The following gives us:
|
||||||
|
@ -72,6 +73,7 @@ static inline void IP_ECN_set_ce(struct iphdr *iph)
|
||||||
|
|
||||||
iph->check = check + (check>=0xFFFF);
|
iph->check = check + (check>=0xFFFF);
|
||||||
iph->tos |= INET_ECN_CE;
|
iph->tos |= INET_ECN_CE;
|
||||||
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline void IP_ECN_clear(struct iphdr *iph)
|
static inline void IP_ECN_clear(struct iphdr *iph)
|
||||||
|
@ -87,11 +89,12 @@ static inline void ipv4_copy_dscp(struct iphdr *outer, struct iphdr *inner)
|
||||||
|
|
||||||
struct ipv6hdr;
|
struct ipv6hdr;
|
||||||
|
|
||||||
static inline void IP6_ECN_set_ce(struct ipv6hdr *iph)
|
static inline int IP6_ECN_set_ce(struct ipv6hdr *iph)
|
||||||
{
|
{
|
||||||
if (INET_ECN_is_not_ect(ipv6_get_dsfield(iph)))
|
if (INET_ECN_is_not_ect(ipv6_get_dsfield(iph)))
|
||||||
return;
|
return 0;
|
||||||
*(u32*)iph |= htonl(INET_ECN_CE << 20);
|
*(u32*)iph |= htonl(INET_ECN_CE << 20);
|
||||||
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline void IP6_ECN_clear(struct ipv6hdr *iph)
|
static inline void IP6_ECN_clear(struct ipv6hdr *iph)
|
||||||
|
@ -105,4 +108,21 @@ static inline void ipv6_copy_dscp(struct ipv6hdr *outer, struct ipv6hdr *inner)
|
||||||
ipv6_change_dsfield(inner, INET_ECN_MASK, dscp);
|
ipv6_change_dsfield(inner, INET_ECN_MASK, dscp);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static inline int INET_ECN_set_ce(struct sk_buff *skb)
|
||||||
|
{
|
||||||
|
switch (skb->protocol) {
|
||||||
|
case __constant_htons(ETH_P_IP):
|
||||||
|
if (skb->nh.raw + sizeof(struct iphdr) <= skb->tail)
|
||||||
|
return IP_ECN_set_ce(skb->nh.iph);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case __constant_htons(ETH_P_IPV6):
|
||||||
|
if (skb->nh.raw + sizeof(struct ipv6hdr) <= skb->tail)
|
||||||
|
return IP6_ECN_set_ce(skb->nh.ipv6h);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -0,0 +1,325 @@
|
||||||
|
#ifndef __NET_SCHED_RED_H
|
||||||
|
#define __NET_SCHED_RED_H
|
||||||
|
|
||||||
|
#include <linux/config.h>
|
||||||
|
#include <linux/types.h>
|
||||||
|
#include <net/pkt_sched.h>
|
||||||
|
#include <net/inet_ecn.h>
|
||||||
|
#include <net/dsfield.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:
|
||||||
|
-----------------------------
|
||||||
|
|
||||||
|
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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define RED_STAB_SIZE 256
|
||||||
|
#define RED_STAB_MASK (RED_STAB_SIZE - 1)
|
||||||
|
|
||||||
|
struct red_stats
|
||||||
|
{
|
||||||
|
u32 prob_drop; /* Early probability drops */
|
||||||
|
u32 prob_mark; /* Early probability marks */
|
||||||
|
u32 forced_drop; /* Forced drops, qavg > max_thresh */
|
||||||
|
u32 forced_mark; /* Forced marks, qavg > max_thresh */
|
||||||
|
u32 pdrop; /* Drops due to queue limits */
|
||||||
|
u32 other; /* Drops due to drop() calls */
|
||||||
|
u32 backlog;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct red_parms
|
||||||
|
{
|
||||||
|
/* Parameters */
|
||||||
|
u32 qth_min; /* Min avg length threshold: A scaled */
|
||||||
|
u32 qth_max; /* Max avg length threshold: A scaled */
|
||||||
|
u32 Scell_max;
|
||||||
|
u32 Rmask; /* Cached random mask, see red_rmask */
|
||||||
|
u8 Scell_log;
|
||||||
|
u8 Wlog; /* log(W) */
|
||||||
|
u8 Plog; /* random number bits */
|
||||||
|
u8 Stab[RED_STAB_SIZE];
|
||||||
|
|
||||||
|
/* Variables */
|
||||||
|
int qcount; /* Number of packets since last random
|
||||||
|
number generation */
|
||||||
|
u32 qR; /* Cached random number */
|
||||||
|
|
||||||
|
unsigned long qavg; /* Average queue length: A scaled */
|
||||||
|
psched_time_t qidlestart; /* Start of current idle period */
|
||||||
|
};
|
||||||
|
|
||||||
|
static inline u32 red_rmask(u8 Plog)
|
||||||
|
{
|
||||||
|
return Plog < 32 ? ((1 << Plog) - 1) : ~0UL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void red_set_parms(struct red_parms *p,
|
||||||
|
u32 qth_min, u32 qth_max, u8 Wlog, u8 Plog,
|
||||||
|
u8 Scell_log, u8 *stab)
|
||||||
|
{
|
||||||
|
/* Reset average queue length, the value is strictly bound
|
||||||
|
* to the parameters below, reseting hurts a bit but leaving
|
||||||
|
* it might result in an unreasonable qavg for a while. --TGR
|
||||||
|
*/
|
||||||
|
p->qavg = 0;
|
||||||
|
|
||||||
|
p->qcount = -1;
|
||||||
|
p->qth_min = qth_min << Wlog;
|
||||||
|
p->qth_max = qth_max << Wlog;
|
||||||
|
p->Wlog = Wlog;
|
||||||
|
p->Plog = Plog;
|
||||||
|
p->Rmask = red_rmask(Plog);
|
||||||
|
p->Scell_log = Scell_log;
|
||||||
|
p->Scell_max = (255 << Scell_log);
|
||||||
|
|
||||||
|
memcpy(p->Stab, stab, sizeof(p->Stab));
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline int red_is_idling(struct red_parms *p)
|
||||||
|
{
|
||||||
|
return !PSCHED_IS_PASTPERFECT(p->qidlestart);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void red_start_of_idle_period(struct red_parms *p)
|
||||||
|
{
|
||||||
|
PSCHED_GET_TIME(p->qidlestart);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void red_end_of_idle_period(struct red_parms *p)
|
||||||
|
{
|
||||||
|
PSCHED_SET_PASTPERFECT(p->qidlestart);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline void red_restart(struct red_parms *p)
|
||||||
|
{
|
||||||
|
red_end_of_idle_period(p);
|
||||||
|
p->qavg = 0;
|
||||||
|
p->qcount = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline unsigned long red_calc_qavg_from_idle_time(struct red_parms *p)
|
||||||
|
{
|
||||||
|
psched_time_t now;
|
||||||
|
long us_idle;
|
||||||
|
int shift;
|
||||||
|
|
||||||
|
PSCHED_GET_TIME(now);
|
||||||
|
us_idle = PSCHED_TDIFF_SAFE(now, p->qidlestart, p->Scell_max);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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.
|
||||||
|
*
|
||||||
|
* p->qavg *= (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 = p->Stab[(us_idle >> p->Scell_log) & RED_STAB_MASK];
|
||||||
|
|
||||||
|
if (shift)
|
||||||
|
return p->qavg >> shift;
|
||||||
|
else {
|
||||||
|
/* Approximate initial part of exponent with linear function:
|
||||||
|
*
|
||||||
|
* (1-W)^m ~= 1-mW + ...
|
||||||
|
*
|
||||||
|
* Seems, it is the best solution to
|
||||||
|
* problem of too coarse exponent tabulation.
|
||||||
|
*/
|
||||||
|
us_idle = (p->qavg * us_idle) >> p->Scell_log;
|
||||||
|
|
||||||
|
if (us_idle < (p->qavg >> 1))
|
||||||
|
return p->qavg - us_idle;
|
||||||
|
else
|
||||||
|
return p->qavg >> 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline unsigned long red_calc_qavg_no_idle_time(struct red_parms *p,
|
||||||
|
unsigned int backlog)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* NOTE: p->qavg is fixed point number with point at Wlog.
|
||||||
|
* The formula below is equvalent to floating point
|
||||||
|
* version:
|
||||||
|
*
|
||||||
|
* qavg = qavg*(1-W) + backlog*W;
|
||||||
|
*
|
||||||
|
* --ANK (980924)
|
||||||
|
*/
|
||||||
|
return p->qavg + (backlog - (p->qavg >> p->Wlog));
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline unsigned long red_calc_qavg(struct red_parms *p,
|
||||||
|
unsigned int backlog)
|
||||||
|
{
|
||||||
|
if (!red_is_idling(p))
|
||||||
|
return red_calc_qavg_no_idle_time(p, backlog);
|
||||||
|
else
|
||||||
|
return red_calc_qavg_from_idle_time(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline u32 red_random(struct red_parms *p)
|
||||||
|
{
|
||||||
|
return net_random() & p->Rmask;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline int red_mark_probability(struct red_parms *p, unsigned long qavg)
|
||||||
|
{
|
||||||
|
/* 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 qavg 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*(qavg - qth_min)/(qth_max-qth_min) < rnd/qcount
|
||||||
|
|
||||||
|
Any questions? --ANK (980924)
|
||||||
|
*/
|
||||||
|
return !(((qavg - p->qth_min) >> p->Wlog) * p->qcount < p->qR);
|
||||||
|
}
|
||||||
|
|
||||||
|
enum {
|
||||||
|
RED_BELOW_MIN_THRESH,
|
||||||
|
RED_BETWEEN_TRESH,
|
||||||
|
RED_ABOVE_MAX_TRESH,
|
||||||
|
};
|
||||||
|
|
||||||
|
static inline int red_cmp_thresh(struct red_parms *p, unsigned long qavg)
|
||||||
|
{
|
||||||
|
if (qavg < p->qth_min)
|
||||||
|
return RED_BELOW_MIN_THRESH;
|
||||||
|
else if (qavg >= p->qth_max)
|
||||||
|
return RED_ABOVE_MAX_TRESH;
|
||||||
|
else
|
||||||
|
return RED_BETWEEN_TRESH;
|
||||||
|
}
|
||||||
|
|
||||||
|
enum {
|
||||||
|
RED_DONT_MARK,
|
||||||
|
RED_PROB_MARK,
|
||||||
|
RED_HARD_MARK,
|
||||||
|
};
|
||||||
|
|
||||||
|
static inline int red_action(struct red_parms *p, unsigned long qavg)
|
||||||
|
{
|
||||||
|
switch (red_cmp_thresh(p, qavg)) {
|
||||||
|
case RED_BELOW_MIN_THRESH:
|
||||||
|
p->qcount = -1;
|
||||||
|
return RED_DONT_MARK;
|
||||||
|
|
||||||
|
case RED_BETWEEN_TRESH:
|
||||||
|
if (++p->qcount) {
|
||||||
|
if (red_mark_probability(p, qavg)) {
|
||||||
|
p->qcount = 0;
|
||||||
|
p->qR = red_random(p);
|
||||||
|
return RED_PROB_MARK;
|
||||||
|
}
|
||||||
|
} else
|
||||||
|
p->qR = red_random(p);
|
||||||
|
|
||||||
|
return RED_DONT_MARK;
|
||||||
|
|
||||||
|
case RED_ABOVE_MAX_TRESH:
|
||||||
|
p->qcount = -1;
|
||||||
|
return RED_HARD_MARK;
|
||||||
|
}
|
||||||
|
|
||||||
|
BUG();
|
||||||
|
return RED_DONT_MARK;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
File diff suppressed because it is too large
Load Diff
|
@ -9,76 +9,23 @@
|
||||||
* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
||||||
*
|
*
|
||||||
* Changes:
|
* Changes:
|
||||||
* J Hadi Salim <hadi@nortel.com> 980914: computation fixes
|
* J Hadi Salim 980914: computation fixes
|
||||||
* Alexey Makarenko <makar@phoenix.kharkov.ua> 990814: qave on idle link was calculated incorrectly.
|
* Alexey Makarenko <makar@phoenix.kharkov.ua> 990814: qave on idle link was calculated incorrectly.
|
||||||
* J Hadi Salim <hadi@nortelnetworks.com> 980816: ECN support
|
* J Hadi Salim 980816: ECN support
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include <linux/config.h>
|
#include <linux/config.h>
|
||||||
#include <linux/module.h>
|
#include <linux/module.h>
|
||||||
#include <asm/uaccess.h>
|
|
||||||
#include <asm/system.h>
|
|
||||||
#include <linux/bitops.h>
|
|
||||||
#include <linux/types.h>
|
#include <linux/types.h>
|
||||||
#include <linux/kernel.h>
|
#include <linux/kernel.h>
|
||||||
#include <linux/sched.h>
|
|
||||||
#include <linux/string.h>
|
|
||||||
#include <linux/mm.h>
|
|
||||||
#include <linux/socket.h>
|
|
||||||
#include <linux/sockios.h>
|
|
||||||
#include <linux/in.h>
|
|
||||||
#include <linux/errno.h>
|
|
||||||
#include <linux/interrupt.h>
|
|
||||||
#include <linux/if_ether.h>
|
|
||||||
#include <linux/inet.h>
|
|
||||||
#include <linux/netdevice.h>
|
#include <linux/netdevice.h>
|
||||||
#include <linux/etherdevice.h>
|
|
||||||
#include <linux/notifier.h>
|
|
||||||
#include <net/ip.h>
|
|
||||||
#include <net/route.h>
|
|
||||||
#include <linux/skbuff.h>
|
#include <linux/skbuff.h>
|
||||||
#include <net/sock.h>
|
|
||||||
#include <net/pkt_sched.h>
|
#include <net/pkt_sched.h>
|
||||||
#include <net/inet_ecn.h>
|
#include <net/inet_ecn.h>
|
||||||
#include <net/dsfield.h>
|
#include <net/red.h>
|
||||||
|
|
||||||
|
|
||||||
/* Random Early Detection (RED) algorithm.
|
/* Parameters, settable by user:
|
||||||
=======================================
|
|
||||||
|
|
||||||
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:
|
|
||||||
-----------------------------
|
-----------------------------
|
||||||
|
|
||||||
limit - bytes (must be > qth_max + burst)
|
limit - bytes (must be > qth_max + burst)
|
||||||
|
@ -89,243 +36,93 @@ Short description.
|
||||||
arbitrarily high (well, less than ram size)
|
arbitrarily high (well, less than ram size)
|
||||||
Really, this limit will never be reached
|
Really, this limit will never be reached
|
||||||
if RED works correctly.
|
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
|
struct red_sched_data
|
||||||
{
|
{
|
||||||
/* Parameters */
|
u32 limit; /* HARD maximal queue length */
|
||||||
u32 limit; /* HARD maximal queue length */
|
unsigned char flags;
|
||||||
u32 qth_min; /* Min average length threshold: A scaled */
|
struct red_parms parms;
|
||||||
u32 qth_max; /* Max average length threshold: A scaled */
|
struct red_stats stats;
|
||||||
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;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
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 q->flags & TC_RED_ECN;
|
||||||
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;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static int
|
static inline int red_use_harddrop(struct red_sched_data *q)
|
||||||
red_enqueue(struct sk_buff *skb, struct Qdisc* sch)
|
{
|
||||||
|
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 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)) {
|
if (red_is_idling(&q->parms))
|
||||||
long us_idle;
|
red_end_of_idle_period(&q->parms);
|
||||||
int shift;
|
|
||||||
|
|
||||||
PSCHED_GET_TIME(now);
|
switch (red_action(&q->parms, q->parms.qavg)) {
|
||||||
us_idle = PSCHED_TDIFF_SAFE(now, q->qidlestart, q->Scell_max);
|
case RED_DONT_MARK:
|
||||||
PSCHED_SET_PASTPERFECT(q->qidlestart);
|
break;
|
||||||
|
|
||||||
/*
|
case RED_PROB_MARK:
|
||||||
The problem: ideally, average length queue recalcultion should
|
sch->qstats.overlimits++;
|
||||||
be done over constant clock intervals. This is too expensive, so that
|
if (!red_use_ecn(q) || !INET_ECN_set_ce(skb)) {
|
||||||
the calculation is driven by outgoing packets.
|
q->stats.prob_drop++;
|
||||||
When the queue is idle we have to model this clock by hand.
|
goto congestion_drop;
|
||||||
|
}
|
||||||
|
|
||||||
SF+VJ proposed to "generate" m = idletime/(average_pkt_size/bandwidth)
|
q->stats.prob_mark++;
|
||||||
dummy packets as a burst after idle time, i.e.
|
break;
|
||||||
|
|
||||||
q->qave *= (1-W)^m
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
This is an apparently overcomplicated solution (f.e. we have to precompute
|
q->stats.forced_mark++;
|
||||||
a table to make this calculation in reasonable time)
|
break;
|
||||||
I believe that a simpler model may be used here,
|
|
||||||
but it is field for experiments.
|
|
||||||
*/
|
|
||||||
shift = q->Stab[us_idle>>q->Scell_log];
|
|
||||||
|
|
||||||
if (shift) {
|
|
||||||
q->qave >>= shift;
|
|
||||||
} else {
|
|
||||||
/* Approximate initial part of exponent
|
|
||||||
with linear function:
|
|
||||||
(1-W)^m ~= 1-mW + ...
|
|
||||||
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
} 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)
|
|
||||||
*/
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (q->qave < q->qth_min) {
|
if (sch->qstats.backlog + skb->len <= q->limit)
|
||||||
q->qcount = -1;
|
return qdisc_enqueue_tail(skb, sch);
|
||||||
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++;
|
|
||||||
}
|
|
||||||
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) {
|
q->stats.pdrop++;
|
||||||
/* The formula used below causes questions.
|
return qdisc_drop(skb, sch);
|
||||||
|
|
||||||
OK. qR is random number in the interval 0..Rmask
|
congestion_drop:
|
||||||
i.e. 0..(2^Plog). If we used floating point
|
qdisc_drop(skb, sch);
|
||||||
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:
|
|
||||||
kfree_skb(skb);
|
|
||||||
sch->qstats.drops++;
|
|
||||||
return NET_XMIT_CN;
|
return NET_XMIT_CN;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int
|
static int red_requeue(struct sk_buff *skb, struct Qdisc* sch)
|
||||||
red_requeue(struct sk_buff *skb, struct Qdisc* sch)
|
|
||||||
{
|
{
|
||||||
struct red_sched_data *q = qdisc_priv(sch);
|
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);
|
return qdisc_requeue(skb, sch);
|
||||||
sch->qstats.backlog += skb->len;
|
|
||||||
sch->qstats.requeues++;
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static struct sk_buff *
|
static struct sk_buff * red_dequeue(struct Qdisc* sch)
|
||||||
red_dequeue(struct Qdisc* sch)
|
|
||||||
{
|
{
|
||||||
struct sk_buff *skb;
|
struct sk_buff *skb;
|
||||||
struct red_sched_data *q = qdisc_priv(sch);
|
struct red_sched_data *q = qdisc_priv(sch);
|
||||||
|
|
||||||
skb = __skb_dequeue(&sch->q);
|
skb = qdisc_dequeue_head(sch);
|
||||||
if (skb) {
|
|
||||||
sch->qstats.backlog -= skb->len;
|
if (skb == NULL && !red_is_idling(&q->parms))
|
||||||
return skb;
|
red_start_of_idle_period(&q->parms);
|
||||||
}
|
|
||||||
PSCHED_GET_TIME(q->qidlestart);
|
return skb;
|
||||||
return NULL;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static unsigned int red_drop(struct Qdisc* sch)
|
static unsigned int red_drop(struct Qdisc* sch)
|
||||||
|
@ -333,16 +130,17 @@ static unsigned int red_drop(struct Qdisc* sch)
|
||||||
struct sk_buff *skb;
|
struct sk_buff *skb;
|
||||||
struct red_sched_data *q = qdisc_priv(sch);
|
struct red_sched_data *q = qdisc_priv(sch);
|
||||||
|
|
||||||
skb = __skb_dequeue_tail(&sch->q);
|
skb = qdisc_dequeue_tail(sch);
|
||||||
if (skb) {
|
if (skb) {
|
||||||
unsigned int len = skb->len;
|
unsigned int len = skb->len;
|
||||||
sch->qstats.backlog -= len;
|
q->stats.other++;
|
||||||
sch->qstats.drops++;
|
qdisc_drop(skb, sch);
|
||||||
q->st.other++;
|
|
||||||
kfree_skb(skb);
|
|
||||||
return len;
|
return len;
|
||||||
}
|
}
|
||||||
PSCHED_GET_TIME(q->qidlestart);
|
|
||||||
|
if (!red_is_idling(&q->parms))
|
||||||
|
red_start_of_idle_period(&q->parms);
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -350,43 +148,38 @@ static void red_reset(struct Qdisc* sch)
|
||||||
{
|
{
|
||||||
struct red_sched_data *q = qdisc_priv(sch);
|
struct red_sched_data *q = qdisc_priv(sch);
|
||||||
|
|
||||||
__skb_queue_purge(&sch->q);
|
qdisc_reset_queue(sch);
|
||||||
sch->qstats.backlog = 0;
|
red_restart(&q->parms);
|
||||||
PSCHED_SET_PASTPERFECT(q->qidlestart);
|
|
||||||
q->qave = 0;
|
|
||||||
q->qcount = -1;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static int red_change(struct Qdisc *sch, struct rtattr *opt)
|
static int red_change(struct Qdisc *sch, struct rtattr *opt)
|
||||||
{
|
{
|
||||||
struct red_sched_data *q = qdisc_priv(sch);
|
struct red_sched_data *q = qdisc_priv(sch);
|
||||||
struct rtattr *tb[TCA_RED_STAB];
|
struct rtattr *tb[TCA_RED_MAX];
|
||||||
struct tc_red_qopt *ctl;
|
struct tc_red_qopt *ctl;
|
||||||
|
|
||||||
if (opt == NULL ||
|
if (opt == NULL || rtattr_parse_nested(tb, TCA_RED_MAX, opt))
|
||||||
rtattr_parse_nested(tb, TCA_RED_STAB, opt) ||
|
return -EINVAL;
|
||||||
tb[TCA_RED_PARMS-1] == 0 || tb[TCA_RED_STAB-1] == 0 ||
|
|
||||||
|
if (tb[TCA_RED_PARMS-1] == NULL ||
|
||||||
RTA_PAYLOAD(tb[TCA_RED_PARMS-1]) < sizeof(*ctl) ||
|
RTA_PAYLOAD(tb[TCA_RED_PARMS-1]) < sizeof(*ctl) ||
|
||||||
RTA_PAYLOAD(tb[TCA_RED_STAB-1]) < 256)
|
tb[TCA_RED_STAB-1] == NULL ||
|
||||||
|
RTA_PAYLOAD(tb[TCA_RED_STAB-1]) < RED_STAB_SIZE)
|
||||||
return -EINVAL;
|
return -EINVAL;
|
||||||
|
|
||||||
ctl = RTA_DATA(tb[TCA_RED_PARMS-1]);
|
ctl = RTA_DATA(tb[TCA_RED_PARMS-1]);
|
||||||
|
|
||||||
sch_tree_lock(sch);
|
sch_tree_lock(sch);
|
||||||
q->flags = ctl->flags;
|
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;
|
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))
|
if (skb_queue_empty(&sch->q))
|
||||||
PSCHED_SET_PASTPERFECT(q->qidlestart);
|
red_end_of_idle_period(&q->parms);
|
||||||
|
|
||||||
sch_tree_unlock(sch);
|
sch_tree_unlock(sch);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -399,39 +192,39 @@ static int red_init(struct Qdisc* sch, struct rtattr *opt)
|
||||||
static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
|
static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
|
||||||
{
|
{
|
||||||
struct red_sched_data *q = qdisc_priv(sch);
|
struct red_sched_data *q = qdisc_priv(sch);
|
||||||
unsigned char *b = skb->tail;
|
struct rtattr *opts = NULL;
|
||||||
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;
|
opts = RTA_NEST(skb, TCA_OPTIONS);
|
||||||
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_PUT(skb, TCA_RED_PARMS, sizeof(opt), &opt);
|
||||||
rta->rta_len = skb->tail - b;
|
return RTA_NEST_END(skb, opts);
|
||||||
|
|
||||||
return skb->len;
|
|
||||||
|
|
||||||
rtattr_failure:
|
rtattr_failure:
|
||||||
skb_trim(skb, b - skb->data);
|
return RTA_NEST_CANCEL(skb, opts);
|
||||||
return -1;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
|
static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
|
||||||
{
|
{
|
||||||
struct red_sched_data *q = qdisc_priv(sch);
|
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 = {
|
static struct Qdisc_ops red_qdisc_ops = {
|
||||||
.next = NULL,
|
|
||||||
.cl_ops = NULL,
|
|
||||||
.id = "red",
|
.id = "red",
|
||||||
.priv_size = sizeof(struct red_sched_data),
|
.priv_size = sizeof(struct red_sched_data),
|
||||||
.enqueue = red_enqueue,
|
.enqueue = red_enqueue,
|
||||||
|
@ -450,10 +243,13 @@ static int __init red_module_init(void)
|
||||||
{
|
{
|
||||||
return register_qdisc(&red_qdisc_ops);
|
return register_qdisc(&red_qdisc_ops);
|
||||||
}
|
}
|
||||||
static void __exit red_module_exit(void)
|
|
||||||
|
static void __exit red_module_exit(void)
|
||||||
{
|
{
|
||||||
unregister_qdisc(&red_qdisc_ops);
|
unregister_qdisc(&red_qdisc_ops);
|
||||||
}
|
}
|
||||||
|
|
||||||
module_init(red_module_init)
|
module_init(red_module_init)
|
||||||
module_exit(red_module_exit)
|
module_exit(red_module_exit)
|
||||||
|
|
||||||
MODULE_LICENSE("GPL");
|
MODULE_LICENSE("GPL");
|
||||||
|
|
Loading…
Reference in New Issue