blob: 29a2dd9f30296f613123118976c963f557e899d6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/sched/sch_gred.c Generic Random Early Detection queue.
3 *
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version
8 * 2 of the License, or (at your option) any later version.
9 *
10 * Authors: J Hadi Salim (hadi@cyberus.ca) 1998-2002
11 *
12 * 991129: - Bug fix with grio mode
13 * - a better sing. AvgQ mode with Grio(WRED)
14 * - A finer grained VQ dequeue based on sugestion
15 * from Ren Liu
16 * - More error checks
17 *
Thomas Graf1e4dfaf2005-11-05 21:14:25 +010018 * For all the glorious comments look at include/net/red.h
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 */
20
21#include <linux/config.h>
22#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/types.h>
24#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/netdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <net/pkt_sched.h>
Thomas Graf22b33422005-11-05 21:14:16 +010028#include <net/red.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Thomas Graff62d6b92005-11-05 21:14:15 +010030#define GRED_DEF_PRIO (MAX_DPs / 2)
Thomas Graf716a1b42005-11-05 21:14:20 +010031#define GRED_VQ_MASK (MAX_DPs - 1)
Thomas Graff62d6b92005-11-05 21:14:15 +010032
Linus Torvalds1da177e2005-04-16 15:20:36 -070033struct gred_sched_data;
34struct gred_sched;
35
36struct gred_sched_data
37{
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 u32 limit; /* HARD maximal queue length */
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 u32 DP; /* the drop pramaters */
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 u32 bytesin; /* bytes seen on virtualQ so far*/
41 u32 packetsin; /* packets seen on virtualQ so far*/
42 u32 backlog; /* bytes on the virtualQ */
Thomas Graf1e4dfaf2005-11-05 21:14:25 +010043 u8 prio; /* the prio of this vq */
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Thomas Graf22b33422005-11-05 21:14:16 +010045 struct red_parms parms;
46 struct red_stats stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047};
48
Thomas Grafdea3f622005-11-05 21:14:09 +010049enum {
50 GRED_WRED_MODE = 1,
Thomas Grafd6fd4e92005-11-05 21:14:10 +010051 GRED_RIO_MODE,
Thomas Grafdea3f622005-11-05 21:14:09 +010052};
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054struct gred_sched
55{
56 struct gred_sched_data *tab[MAX_DPs];
Thomas Grafdea3f622005-11-05 21:14:09 +010057 unsigned long flags;
Thomas Grafb38c7ee2005-11-05 21:14:27 +010058 u32 red_flags;
Thomas Graf1e4dfaf2005-11-05 21:14:25 +010059 u32 DPs;
60 u32 def;
Thomas Graf70517032005-11-05 21:14:23 +010061 struct red_parms wred_set;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062};
63
Thomas Grafdea3f622005-11-05 21:14:09 +010064static inline int gred_wred_mode(struct gred_sched *table)
65{
66 return test_bit(GRED_WRED_MODE, &table->flags);
67}
68
69static inline void gred_enable_wred_mode(struct gred_sched *table)
70{
71 __set_bit(GRED_WRED_MODE, &table->flags);
72}
73
74static inline void gred_disable_wred_mode(struct gred_sched *table)
75{
76 __clear_bit(GRED_WRED_MODE, &table->flags);
77}
78
Thomas Grafd6fd4e92005-11-05 21:14:10 +010079static inline int gred_rio_mode(struct gred_sched *table)
80{
81 return test_bit(GRED_RIO_MODE, &table->flags);
82}
83
84static inline void gred_enable_rio_mode(struct gred_sched *table)
85{
86 __set_bit(GRED_RIO_MODE, &table->flags);
87}
88
89static inline void gred_disable_rio_mode(struct gred_sched *table)
90{
91 __clear_bit(GRED_RIO_MODE, &table->flags);
92}
93
Thomas Grafdea3f622005-11-05 21:14:09 +010094static inline int gred_wred_mode_check(struct Qdisc *sch)
95{
96 struct gred_sched *table = qdisc_priv(sch);
97 int i;
98
99 /* Really ugly O(n^2) but shouldn't be necessary too frequent. */
100 for (i = 0; i < table->DPs; i++) {
101 struct gred_sched_data *q = table->tab[i];
102 int n;
103
104 if (q == NULL)
105 continue;
106
107 for (n = 0; n < table->DPs; n++)
108 if (table->tab[n] && table->tab[n] != q &&
109 table->tab[n]->prio == q->prio)
110 return 1;
111 }
112
113 return 0;
114}
115
Thomas Graf22b33422005-11-05 21:14:16 +0100116static inline unsigned int gred_backlog(struct gred_sched *table,
117 struct gred_sched_data *q,
118 struct Qdisc *sch)
119{
120 if (gred_wred_mode(table))
121 return sch->qstats.backlog;
122 else
123 return q->backlog;
124}
125
Thomas Graf716a1b42005-11-05 21:14:20 +0100126static inline u16 tc_index_to_dp(struct sk_buff *skb)
127{
128 return skb->tc_index & GRED_VQ_MASK;
129}
130
Thomas Graf70517032005-11-05 21:14:23 +0100131static inline void gred_load_wred_set(struct gred_sched *table,
132 struct gred_sched_data *q)
133{
134 q->parms.qavg = table->wred_set.qavg;
135 q->parms.qidlestart = table->wred_set.qidlestart;
136}
137
138static inline void gred_store_wred_set(struct gred_sched *table,
139 struct gred_sched_data *q)
140{
141 table->wred_set.qavg = q->parms.qavg;
142}
143
Thomas Grafb38c7ee2005-11-05 21:14:27 +0100144static inline int gred_use_ecn(struct gred_sched *t)
145{
146 return t->red_flags & TC_RED_ECN;
147}
148
Thomas Grafbdc450a2005-11-05 21:14:28 +0100149static inline int gred_use_harddrop(struct gred_sched *t)
150{
151 return t->red_flags & TC_RED_HARDDROP;
152}
153
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100154static int gred_enqueue(struct sk_buff *skb, struct Qdisc* sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 struct gred_sched_data *q=NULL;
157 struct gred_sched *t= qdisc_priv(sch);
Thomas Graf22b33422005-11-05 21:14:16 +0100158 unsigned long qavg = 0;
Thomas Graf4a591832005-11-05 21:14:22 +0100159 u16 dp = tc_index_to_dp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Thomas Graf716a1b42005-11-05 21:14:20 +0100161 if (dp >= t->DPs || (q = t->tab[dp]) == NULL) {
Thomas Graf18e3fb842005-11-05 21:14:21 +0100162 dp = t->def;
163
164 if ((q = t->tab[dp]) == NULL) {
165 /* Pass through packets not assigned to a DP
166 * if no default DP has been configured. This
167 * allows for DP flows to be left untouched.
168 */
169 if (skb_queue_len(&sch->q) < sch->dev->tx_queue_len)
170 return qdisc_enqueue_tail(skb, sch);
171 else
172 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 }
Thomas Graf18e3fb842005-11-05 21:14:21 +0100174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 /* fix tc_index? --could be controvesial but needed for
176 requeueing */
Thomas Graf18e3fb842005-11-05 21:14:21 +0100177 skb->tc_index = (skb->tc_index & ~GRED_VQ_MASK) | dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 }
179
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100180 /* sum up all the qaves of prios <= to ours to get the new qave */
Thomas Grafd6fd4e92005-11-05 21:14:10 +0100181 if (!gred_wred_mode(t) && gred_rio_mode(t)) {
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100182 int i;
183
184 for (i = 0; i < t->DPs; i++) {
185 if (t->tab[i] && t->tab[i]->prio < q->prio &&
Thomas Graf22b33422005-11-05 21:14:16 +0100186 !red_is_idling(&t->tab[i]->parms))
187 qavg +=t->tab[i]->parms.qavg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 }
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 }
191
192 q->packetsin++;
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100193 q->bytesin += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100195 if (gred_wred_mode(t))
Thomas Graf70517032005-11-05 21:14:23 +0100196 gred_load_wred_set(t, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Thomas Graf22b33422005-11-05 21:14:16 +0100198 q->parms.qavg = red_calc_qavg(&q->parms, gred_backlog(t, q, sch));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Thomas Graf22b33422005-11-05 21:14:16 +0100200 if (red_is_idling(&q->parms))
201 red_end_of_idle_period(&q->parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Thomas Grafdea3f622005-11-05 21:14:09 +0100203 if (gred_wred_mode(t))
Thomas Graf70517032005-11-05 21:14:23 +0100204 gred_store_wred_set(t, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Thomas Graf22b33422005-11-05 21:14:16 +0100206 switch (red_action(&q->parms, q->parms.qavg + qavg)) {
207 case RED_DONT_MARK:
208 break;
209
210 case RED_PROB_MARK:
211 sch->qstats.overlimits++;
Thomas Grafb38c7ee2005-11-05 21:14:27 +0100212 if (!gred_use_ecn(t) || !INET_ECN_set_ce(skb)) {
213 q->stats.prob_drop++;
214 goto congestion_drop;
215 }
216
217 q->stats.prob_mark++;
218 break;
Thomas Graf22b33422005-11-05 21:14:16 +0100219
220 case RED_HARD_MARK:
221 sch->qstats.overlimits++;
Thomas Grafbdc450a2005-11-05 21:14:28 +0100222 if (gred_use_harddrop(t) || !gred_use_ecn(t) ||
223 !INET_ECN_set_ce(skb)) {
Thomas Grafb38c7ee2005-11-05 21:14:27 +0100224 q->stats.forced_drop++;
225 goto congestion_drop;
226 }
227 q->stats.forced_mark++;
228 break;
Thomas Graf22b33422005-11-05 21:14:16 +0100229 }
230
231 if (q->backlog + skb->len <= q->limit) {
232 q->backlog += skb->len;
Thomas Grafedf7a7b2005-11-05 21:14:19 +0100233 return qdisc_enqueue_tail(skb, sch);
Thomas Graf22b33422005-11-05 21:14:16 +0100234 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
Thomas Graf22b33422005-11-05 21:14:16 +0100236 q->stats.pdrop++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237drop:
Thomas Grafedf7a7b2005-11-05 21:14:19 +0100238 return qdisc_drop(skb, sch);
Thomas Grafc3b553c2005-11-05 21:14:18 +0100239
240congestion_drop:
Thomas Grafedf7a7b2005-11-05 21:14:19 +0100241 qdisc_drop(skb, sch);
Thomas Grafc3b553c2005-11-05 21:14:18 +0100242 return NET_XMIT_CN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243}
244
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100245static int gred_requeue(struct sk_buff *skb, struct Qdisc* sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246{
Thomas Graf716a1b42005-11-05 21:14:20 +0100247 struct gred_sched *t = qdisc_priv(sch);
Thomas Graf18e3fb842005-11-05 21:14:21 +0100248 struct gred_sched_data *q;
249 u16 dp = tc_index_to_dp(skb);
Thomas Graf22b33422005-11-05 21:14:16 +0100250
Thomas Graf18e3fb842005-11-05 21:14:21 +0100251 if (dp >= t->DPs || (q = t->tab[dp]) == NULL) {
252 if (net_ratelimit())
253 printk(KERN_WARNING "GRED: Unable to relocate VQ 0x%x "
254 "for requeue, screwing up backlog.\n",
255 tc_index_to_dp(skb));
256 } else {
257 if (red_is_idling(&q->parms))
258 red_end_of_idle_period(&q->parms);
259 q->backlog += skb->len;
260 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
Thomas Grafedf7a7b2005-11-05 21:14:19 +0100262 return qdisc_requeue(skb, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263}
264
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100265static struct sk_buff *gred_dequeue(struct Qdisc* sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
267 struct sk_buff *skb;
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100268 struct gred_sched *t = qdisc_priv(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Thomas Grafedf7a7b2005-11-05 21:14:19 +0100270 skb = qdisc_dequeue_head(sch);
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 if (skb) {
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100273 struct gred_sched_data *q;
Thomas Graf18e3fb842005-11-05 21:14:21 +0100274 u16 dp = tc_index_to_dp(skb);
275
276 if (dp >= t->DPs || (q = t->tab[dp]) == NULL) {
277 if (net_ratelimit())
278 printk(KERN_WARNING "GRED: Unable to relocate "
279 "VQ 0x%x after dequeue, screwing up "
280 "backlog.\n", tc_index_to_dp(skb));
281 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 q->backlog -= skb->len;
Thomas Graf18e3fb842005-11-05 21:14:21 +0100283
Thomas Grafdea3f622005-11-05 21:14:09 +0100284 if (!q->backlog && !gred_wred_mode(t))
Thomas Graf22b33422005-11-05 21:14:16 +0100285 red_start_of_idle_period(&q->parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 }
Thomas Graf18e3fb842005-11-05 21:14:21 +0100287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 return skb;
289 }
290
Thomas Grafd8f64e12005-11-05 21:14:26 +0100291 if (gred_wred_mode(t) && !red_is_idling(&t->wred_set))
Thomas Graf70517032005-11-05 21:14:23 +0100292 red_start_of_idle_period(&t->wred_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 return NULL;
295}
296
297static unsigned int gred_drop(struct Qdisc* sch)
298{
299 struct sk_buff *skb;
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100300 struct gred_sched *t = qdisc_priv(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Thomas Grafedf7a7b2005-11-05 21:14:19 +0100302 skb = qdisc_dequeue_tail(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 if (skb) {
304 unsigned int len = skb->len;
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100305 struct gred_sched_data *q;
Thomas Graf18e3fb842005-11-05 21:14:21 +0100306 u16 dp = tc_index_to_dp(skb);
307
308 if (dp >= t->DPs || (q = t->tab[dp]) == NULL) {
309 if (net_ratelimit())
310 printk(KERN_WARNING "GRED: Unable to relocate "
311 "VQ 0x%x while dropping, screwing up "
312 "backlog.\n", tc_index_to_dp(skb));
313 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 q->backlog -= len;
Thomas Graf22b33422005-11-05 21:14:16 +0100315 q->stats.other++;
Thomas Graf18e3fb842005-11-05 21:14:21 +0100316
Thomas Grafdea3f622005-11-05 21:14:09 +0100317 if (!q->backlog && !gred_wred_mode(t))
Thomas Graf22b33422005-11-05 21:14:16 +0100318 red_start_of_idle_period(&q->parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 }
320
Thomas Grafedf7a7b2005-11-05 21:14:19 +0100321 qdisc_drop(skb, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 return len;
323 }
324
Thomas Grafd8f64e12005-11-05 21:14:26 +0100325 if (gred_wred_mode(t) && !red_is_idling(&t->wred_set))
Thomas Graf70517032005-11-05 21:14:23 +0100326 red_start_of_idle_period(&t->wred_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 return 0;
329
330}
331
332static void gred_reset(struct Qdisc* sch)
333{
334 int i;
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100335 struct gred_sched *t = qdisc_priv(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Thomas Grafedf7a7b2005-11-05 21:14:19 +0100337 qdisc_reset_queue(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100339 for (i = 0; i < t->DPs; i++) {
340 struct gred_sched_data *q = t->tab[i];
341
342 if (!q)
343 continue;
344
Thomas Graf22b33422005-11-05 21:14:16 +0100345 red_restart(&q->parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 q->backlog = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 }
348}
349
Thomas Graf66396072005-11-05 21:14:13 +0100350static inline void gred_destroy_vq(struct gred_sched_data *q)
351{
352 kfree(q);
353}
354
355static inline int gred_change_table_def(struct Qdisc *sch, struct rtattr *dps)
356{
357 struct gred_sched *table = qdisc_priv(sch);
358 struct tc_gred_sopt *sopt;
359 int i;
360
361 if (dps == NULL || RTA_PAYLOAD(dps) < sizeof(*sopt))
362 return -EINVAL;
363
364 sopt = RTA_DATA(dps);
365
366 if (sopt->DPs > MAX_DPs || sopt->DPs == 0 || sopt->def_DP >= sopt->DPs)
367 return -EINVAL;
368
369 sch_tree_lock(sch);
370 table->DPs = sopt->DPs;
371 table->def = sopt->def_DP;
Thomas Grafb38c7ee2005-11-05 21:14:27 +0100372 table->red_flags = sopt->flags;
Thomas Graf66396072005-11-05 21:14:13 +0100373
374 /*
375 * Every entry point to GRED is synchronized with the above code
376 * and the DP is checked against DPs, i.e. shadowed VQs can no
377 * longer be found so we can unlock right here.
378 */
379 sch_tree_unlock(sch);
380
381 if (sopt->grio) {
382 gred_enable_rio_mode(table);
383 gred_disable_wred_mode(table);
384 if (gred_wred_mode_check(sch))
385 gred_enable_wred_mode(table);
386 } else {
387 gred_disable_rio_mode(table);
388 gred_disable_wred_mode(table);
389 }
390
391 for (i = table->DPs; i < MAX_DPs; i++) {
392 if (table->tab[i]) {
393 printk(KERN_WARNING "GRED: Warning: Destroying "
394 "shadowed VQ 0x%x\n", i);
395 gred_destroy_vq(table->tab[i]);
396 table->tab[i] = NULL;
397 }
398 }
399
Thomas Graf66396072005-11-05 21:14:13 +0100400 return 0;
401}
402
Thomas Graff62d6b92005-11-05 21:14:15 +0100403static inline int gred_change_vq(struct Qdisc *sch, int dp,
404 struct tc_gred_qopt *ctl, int prio, u8 *stab)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
406 struct gred_sched *table = qdisc_priv(sch);
407 struct gred_sched_data *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Thomas Graff62d6b92005-11-05 21:14:15 +0100409 if (table->tab[dp] == NULL) {
410 table->tab[dp] = kmalloc(sizeof(*q), GFP_KERNEL);
411 if (table->tab[dp] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 return -ENOMEM;
Thomas Graff62d6b92005-11-05 21:14:15 +0100413 memset(table->tab[dp], 0, sizeof(*q));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 }
415
Thomas Graff62d6b92005-11-05 21:14:15 +0100416 q = table->tab[dp];
417 q->DP = dp;
418 q->prio = prio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 q->limit = ctl->limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Thomas Graf22b33422005-11-05 21:14:16 +0100421 if (q->backlog == 0)
422 red_end_of_idle_period(&q->parms);
423
424 red_set_parms(&q->parms,
425 ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Plog,
426 ctl->Scell_log, stab);
427
Thomas Graff62d6b92005-11-05 21:14:15 +0100428 return 0;
429}
430
431static int gred_change(struct Qdisc *sch, struct rtattr *opt)
432{
433 struct gred_sched *table = qdisc_priv(sch);
434 struct tc_gred_qopt *ctl;
435 struct rtattr *tb[TCA_GRED_MAX];
436 int err = -EINVAL, prio = GRED_DEF_PRIO;
437 u8 *stab;
438
439 if (opt == NULL || rtattr_parse_nested(tb, TCA_GRED_MAX, opt))
440 return -EINVAL;
441
442 if (tb[TCA_GRED_PARMS-1] == NULL && tb[TCA_GRED_STAB-1] == NULL)
443 return gred_change_table_def(sch, opt);
444
445 if (tb[TCA_GRED_PARMS-1] == NULL ||
446 RTA_PAYLOAD(tb[TCA_GRED_PARMS-1]) < sizeof(*ctl) ||
447 tb[TCA_GRED_STAB-1] == NULL ||
448 RTA_PAYLOAD(tb[TCA_GRED_STAB-1]) < 256)
449 return -EINVAL;
450
451 ctl = RTA_DATA(tb[TCA_GRED_PARMS-1]);
452 stab = RTA_DATA(tb[TCA_GRED_STAB-1]);
453
454 if (ctl->DP >= table->DPs)
455 goto errout;
456
457 if (gred_rio_mode(table)) {
458 if (ctl->prio == 0) {
459 int def_prio = GRED_DEF_PRIO;
460
461 if (table->tab[table->def])
462 def_prio = table->tab[table->def]->prio;
463
464 printk(KERN_DEBUG "GRED: DP %u does not have a prio "
465 "setting default to %d\n", ctl->DP, def_prio);
466
467 prio = def_prio;
468 } else
469 prio = ctl->prio;
470 }
471
472 sch_tree_lock(sch);
473
474 err = gred_change_vq(sch, ctl->DP, ctl, prio, stab);
475 if (err < 0)
476 goto errout_locked;
477
Thomas Grafd6fd4e92005-11-05 21:14:10 +0100478 if (gred_rio_mode(table)) {
Thomas Grafdea3f622005-11-05 21:14:09 +0100479 gred_disable_wred_mode(table);
480 if (gred_wred_mode_check(sch))
481 gred_enable_wred_mode(table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 }
483
Thomas Graff62d6b92005-11-05 21:14:15 +0100484 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Thomas Graff62d6b92005-11-05 21:14:15 +0100486errout_locked:
487 sch_tree_unlock(sch);
488errout:
489 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490}
491
492static int gred_init(struct Qdisc *sch, struct rtattr *opt)
493{
Thomas Graf66396072005-11-05 21:14:13 +0100494 struct rtattr *tb[TCA_GRED_MAX];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
Thomas Graf66396072005-11-05 21:14:13 +0100496 if (opt == NULL || rtattr_parse_nested(tb, TCA_GRED_MAX, opt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 return -EINVAL;
498
Thomas Graf66396072005-11-05 21:14:13 +0100499 if (tb[TCA_GRED_PARMS-1] || tb[TCA_GRED_STAB-1])
500 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Thomas Graf66396072005-11-05 21:14:13 +0100502 return gred_change_table_def(sch, tb[TCA_GRED_DPS-1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503}
504
505static int gred_dump(struct Qdisc *sch, struct sk_buff *skb)
506{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 struct gred_sched *table = qdisc_priv(sch);
Thomas Graf05f1cc02005-11-05 21:14:11 +0100508 struct rtattr *parms, *opts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 int i;
Thomas Grafe0636822005-11-05 21:14:12 +0100510 struct tc_gred_sopt sopt = {
511 .DPs = table->DPs,
512 .def_DP = table->def,
513 .grio = gred_rio_mode(table),
Thomas Grafb38c7ee2005-11-05 21:14:27 +0100514 .flags = table->red_flags,
Thomas Grafe0636822005-11-05 21:14:12 +0100515 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Thomas Graf05f1cc02005-11-05 21:14:11 +0100517 opts = RTA_NEST(skb, TCA_OPTIONS);
Thomas Grafe0636822005-11-05 21:14:12 +0100518 RTA_PUT(skb, TCA_GRED_DPS, sizeof(sopt), &sopt);
Thomas Graf05f1cc02005-11-05 21:14:11 +0100519 parms = RTA_NEST(skb, TCA_GRED_PARMS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Thomas Graf05f1cc02005-11-05 21:14:11 +0100521 for (i = 0; i < MAX_DPs; i++) {
522 struct gred_sched_data *q = table->tab[i];
523 struct tc_gred_qopt opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524
Thomas Graf05f1cc02005-11-05 21:14:11 +0100525 memset(&opt, 0, sizeof(opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
527 if (!q) {
528 /* hack -- fix at some point with proper message
529 This is how we indicate to tc that there is no VQ
530 at this DP */
531
Thomas Graf05f1cc02005-11-05 21:14:11 +0100532 opt.DP = MAX_DPs + i;
533 goto append_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 }
535
Thomas Graf05f1cc02005-11-05 21:14:11 +0100536 opt.limit = q->limit;
537 opt.DP = q->DP;
538 opt.backlog = q->backlog;
539 opt.prio = q->prio;
Thomas Graf22b33422005-11-05 21:14:16 +0100540 opt.qth_min = q->parms.qth_min >> q->parms.Wlog;
541 opt.qth_max = q->parms.qth_max >> q->parms.Wlog;
542 opt.Wlog = q->parms.Wlog;
543 opt.Plog = q->parms.Plog;
544 opt.Scell_log = q->parms.Scell_log;
545 opt.other = q->stats.other;
546 opt.early = q->stats.prob_drop;
547 opt.forced = q->stats.forced_drop;
548 opt.pdrop = q->stats.pdrop;
Thomas Graf05f1cc02005-11-05 21:14:11 +0100549 opt.packets = q->packetsin;
550 opt.bytesin = q->bytesin;
551
Thomas Graf22b33422005-11-05 21:14:16 +0100552 if (gred_wred_mode(table)) {
553 q->parms.qidlestart =
554 table->tab[table->def]->parms.qidlestart;
555 q->parms.qavg = table->tab[table->def]->parms.qavg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Thomas Graf22b33422005-11-05 21:14:16 +0100558 opt.qave = red_calc_qavg(&q->parms, q->parms.qavg);
559
Thomas Graf05f1cc02005-11-05 21:14:11 +0100560append_opt:
561 RTA_APPEND(skb, sizeof(opt), &opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 }
563
Thomas Graf05f1cc02005-11-05 21:14:11 +0100564 RTA_NEST_END(skb, parms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Thomas Graf05f1cc02005-11-05 21:14:11 +0100566 return RTA_NEST_END(skb, opts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568rtattr_failure:
Thomas Graf05f1cc02005-11-05 21:14:11 +0100569 return RTA_NEST_CANCEL(skb, opts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570}
571
572static void gred_destroy(struct Qdisc *sch)
573{
574 struct gred_sched *table = qdisc_priv(sch);
575 int i;
576
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100577 for (i = 0; i < table->DPs; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 if (table->tab[i])
Thomas Graf66396072005-11-05 21:14:13 +0100579 gred_destroy_vq(table->tab[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 }
581}
582
583static struct Qdisc_ops gred_qdisc_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 .id = "gred",
585 .priv_size = sizeof(struct gred_sched),
586 .enqueue = gred_enqueue,
587 .dequeue = gred_dequeue,
588 .requeue = gred_requeue,
589 .drop = gred_drop,
590 .init = gred_init,
591 .reset = gred_reset,
592 .destroy = gred_destroy,
593 .change = gred_change,
594 .dump = gred_dump,
595 .owner = THIS_MODULE,
596};
597
598static int __init gred_module_init(void)
599{
600 return register_qdisc(&gred_qdisc_ops);
601}
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100602
603static void __exit gred_module_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
605 unregister_qdisc(&gred_qdisc_ops);
606}
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100607
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608module_init(gred_module_init)
609module_exit(gred_module_exit)
Thomas Graf1e4dfaf2005-11-05 21:14:25 +0100610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611MODULE_LICENSE("GPL");