dccfa44c2d71d3be7d7d766987a7b1d0bdc9977d
[linux-2.6.git] / net / sched / sch_red.c
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:
12  * J Hadi Salim 980914: computation fixes
13  * Alexey Makarenko <makar@phoenix.kharkov.ua> 990814: qave on idle link was calculated incorrectly.
14  * J Hadi Salim 980816:  ECN support
15  */
16
17 #include <linux/config.h>
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/netdevice.h>
22 #include <linux/skbuff.h>
23 #include <net/pkt_sched.h>
24 #include <net/inet_ecn.h>
25 #include <net/red.h>
26
27
28 /*      Parameters, settable by user:
29         -----------------------------
30
31         limit           - bytes (must be > qth_max + burst)
32
33         Hard limit on queue length, should be chosen >qth_max
34         to allow packet bursts. This parameter does not
35         affect the algorithms behaviour and can be chosen
36         arbitrarily high (well, less than ram size)
37         Really, this limit will never be reached
38         if RED works correctly.
39  */
40
41 struct red_sched_data
42 {
43         u32                     limit;          /* HARD maximal queue length */
44         unsigned char           flags;
45         struct red_parms        parms;
46         struct red_stats        stats;
47 };
48
49 static inline int red_use_ecn(struct red_sched_data *q)
50 {
51         return q->flags & TC_RED_ECN;
52 }
53
54 static inline int red_use_harddrop(struct red_sched_data *q)
55 {
56         return q->flags & TC_RED_HARDDROP;
57 }
58
59 static int red_enqueue(struct sk_buff *skb, struct Qdisc* sch)
60 {
61         struct red_sched_data *q = qdisc_priv(sch);
62
63         q->parms.qavg = red_calc_qavg(&q->parms, sch->qstats.backlog);
64
65         if (red_is_idling(&q->parms))
66                 red_end_of_idle_period(&q->parms);
67
68         switch (red_action(&q->parms, q->parms.qavg)) {
69                 case RED_DONT_MARK:
70                         break;
71
72                 case RED_PROB_MARK:
73                         sch->qstats.overlimits++;
74                         if (!red_use_ecn(q) || !INET_ECN_set_ce(skb)) {
75                                 q->stats.prob_drop++;
76                                 goto congestion_drop;
77                         }
78
79                         q->stats.prob_mark++;
80                         break;
81
82                 case RED_HARD_MARK:
83                         sch->qstats.overlimits++;
84                         if (red_use_harddrop(q) || !red_use_ecn(q) ||
85                             !INET_ECN_set_ce(skb)) {
86                                 q->stats.forced_drop++;
87                                 goto congestion_drop;
88                         }
89
90                         q->stats.forced_mark++;
91                         break;
92         }
93
94         if (sch->qstats.backlog + skb->len <= q->limit)
95                 return qdisc_enqueue_tail(skb, sch);
96
97         q->stats.pdrop++;
98         return qdisc_drop(skb, sch);
99
100 congestion_drop:
101         qdisc_drop(skb, sch);
102         return NET_XMIT_CN;
103 }
104
105 static int red_requeue(struct sk_buff *skb, struct Qdisc* sch)
106 {
107         struct red_sched_data *q = qdisc_priv(sch);
108
109         if (red_is_idling(&q->parms))
110                 red_end_of_idle_period(&q->parms);
111
112         return qdisc_requeue(skb, sch);
113 }
114
115 static struct sk_buff * red_dequeue(struct Qdisc* sch)
116 {
117         struct sk_buff *skb;
118         struct red_sched_data *q = qdisc_priv(sch);
119
120         skb = qdisc_dequeue_head(sch);
121
122         if (skb == NULL && !red_is_idling(&q->parms))
123                 red_start_of_idle_period(&q->parms);
124
125         return skb;
126 }
127
128 static unsigned int red_drop(struct Qdisc* sch)
129 {
130         struct sk_buff *skb;
131         struct red_sched_data *q = qdisc_priv(sch);
132
133         skb = qdisc_dequeue_tail(sch);
134         if (skb) {
135                 unsigned int len = skb->len;
136                 q->stats.other++;
137                 qdisc_drop(skb, sch);
138                 return len;
139         }
140
141         if (!red_is_idling(&q->parms))
142                 red_start_of_idle_period(&q->parms);
143
144         return 0;
145 }
146
147 static void red_reset(struct Qdisc* sch)
148 {
149         struct red_sched_data *q = qdisc_priv(sch);
150
151         qdisc_reset_queue(sch);
152         red_restart(&q->parms);
153 }
154
155 static int red_change(struct Qdisc *sch, struct rtattr *opt)
156 {
157         struct red_sched_data *q = qdisc_priv(sch);
158         struct rtattr *tb[TCA_RED_MAX];
159         struct tc_red_qopt *ctl;
160
161         if (opt == NULL || rtattr_parse_nested(tb, TCA_RED_MAX, opt))
162                 return -EINVAL;
163
164         if (tb[TCA_RED_PARMS-1] == NULL ||
165             RTA_PAYLOAD(tb[TCA_RED_PARMS-1]) < sizeof(*ctl) ||
166             tb[TCA_RED_STAB-1] == NULL ||
167             RTA_PAYLOAD(tb[TCA_RED_STAB-1]) < RED_STAB_SIZE)
168                 return -EINVAL;
169
170         ctl = RTA_DATA(tb[TCA_RED_PARMS-1]);
171
172         sch_tree_lock(sch);
173         q->flags = ctl->flags;
174         q->limit = ctl->limit;
175
176         red_set_parms(&q->parms, ctl->qth_min, ctl->qth_max, ctl->Wlog,
177                                  ctl->Plog, ctl->Scell_log,
178                                  RTA_DATA(tb[TCA_RED_STAB-1]));
179
180         if (skb_queue_empty(&sch->q))
181                 red_end_of_idle_period(&q->parms);
182
183         sch_tree_unlock(sch);
184         return 0;
185 }
186
187 static int red_init(struct Qdisc* sch, struct rtattr *opt)
188 {
189         return red_change(sch, opt);
190 }
191
192 static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
193 {
194         struct red_sched_data *q = qdisc_priv(sch);
195         struct rtattr *opts = NULL;
196         struct tc_red_qopt opt = {
197                 .limit          = q->limit,
198                 .flags          = q->flags,
199                 .qth_min        = q->parms.qth_min >> q->parms.Wlog,
200                 .qth_max        = q->parms.qth_max >> q->parms.Wlog,
201                 .Wlog           = q->parms.Wlog,
202                 .Plog           = q->parms.Plog,
203                 .Scell_log      = q->parms.Scell_log,
204         };
205
206         opts = RTA_NEST(skb, TCA_OPTIONS);
207         RTA_PUT(skb, TCA_RED_PARMS, sizeof(opt), &opt);
208         return RTA_NEST_END(skb, opts);
209
210 rtattr_failure:
211         return RTA_NEST_CANCEL(skb, opts);
212 }
213
214 static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
215 {
216         struct red_sched_data *q = qdisc_priv(sch);
217         struct tc_red_xstats st = {
218                 .early  = q->stats.prob_drop + q->stats.forced_drop,
219                 .pdrop  = q->stats.pdrop,
220                 .other  = q->stats.other,
221                 .marked = q->stats.prob_mark + q->stats.forced_mark,
222         };
223
224         return gnet_stats_copy_app(d, &st, sizeof(st));
225 }
226
227 static struct Qdisc_ops red_qdisc_ops = {
228         .id             =       "red",
229         .priv_size      =       sizeof(struct red_sched_data),
230         .enqueue        =       red_enqueue,
231         .dequeue        =       red_dequeue,
232         .requeue        =       red_requeue,
233         .drop           =       red_drop,
234         .init           =       red_init,
235         .reset          =       red_reset,
236         .change         =       red_change,
237         .dump           =       red_dump,
238         .dump_stats     =       red_dump_stats,
239         .owner          =       THIS_MODULE,
240 };
241
242 static int __init red_module_init(void)
243 {
244         return register_qdisc(&red_qdisc_ops);
245 }
246
247 static void __exit red_module_exit(void)
248 {
249         unregister_qdisc(&red_qdisc_ops);
250 }
251
252 module_init(red_module_init)
253 module_exit(red_module_exit)
254
255 MODULE_LICENSE("GPL");