blob: 6c0534cc77582881fecb7b9276659f6d921e6daa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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:
Thomas Grafdba051f2005-11-05 21:14:08 +010012 * J Hadi Salim 980914: computation fixes
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * Alexey Makarenko <makar@phoenix.kharkov.ua> 990814: qave on idle link was calculated incorrectly.
Thomas Grafdba051f2005-11-05 21:14:08 +010014 * J Hadi Salim 980816: ECN support
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 */
16
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/types.h>
19#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <net/pkt_sched.h>
22#include <net/inet_ecn.h>
Thomas Graf6b31b282005-11-05 21:14:05 +010023#include <net/red.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25
Thomas Graf6b31b282005-11-05 21:14:05 +010026/* Parameters, settable by user:
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 -----------------------------
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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 */
38
Eric Dumazetcc7ec452011-01-19 19:26:56 +000039struct red_sched_data {
Thomas Graf6b31b282005-11-05 21:14:05 +010040 u32 limit; /* HARD maximal queue length */
41 unsigned char flags;
Eric Dumazet8af2a212011-12-08 06:06:03 +000042 struct timer_list adapt_timer;
Thomas Graf6b31b282005-11-05 21:14:05 +010043 struct red_parms parms;
Eric Dumazeteeca6682012-01-05 02:25:16 +000044 struct red_vars vars;
Thomas Graf6b31b282005-11-05 21:14:05 +010045 struct red_stats stats;
Patrick McHardyf38c39d2006-03-20 19:20:44 -080046 struct Qdisc *qdisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047};
48
Thomas Graf6b31b282005-11-05 21:14:05 +010049static inline int red_use_ecn(struct red_sched_data *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
Thomas Graf6b31b282005-11-05 21:14:05 +010051 return q->flags & TC_RED_ECN;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052}
53
Thomas Grafbdc450a2005-11-05 21:14:28 +010054static inline int red_use_harddrop(struct red_sched_data *q)
55{
56 return q->flags & TC_RED_HARDDROP;
57}
58
Eric Dumazetcc7ec452011-01-19 19:26:56 +000059static int red_enqueue(struct sk_buff *skb, struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060{
61 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardyf38c39d2006-03-20 19:20:44 -080062 struct Qdisc *child = q->qdisc;
63 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Eric Dumazeteeca6682012-01-05 02:25:16 +000065 q->vars.qavg = red_calc_qavg(&q->parms,
66 &q->vars,
67 child->qstats.backlog);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Eric Dumazeteeca6682012-01-05 02:25:16 +000069 if (red_is_idling(&q->vars))
70 red_end_of_idle_period(&q->vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
Eric Dumazeteeca6682012-01-05 02:25:16 +000072 switch (red_action(&q->parms, &q->vars, q->vars.qavg)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +000073 case RED_DONT_MARK:
74 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Eric Dumazetcc7ec452011-01-19 19:26:56 +000076 case RED_PROB_MARK:
John Fastabend25331d62014-09-28 11:53:29 -070077 qdisc_qstats_overlimit(sch);
Eric Dumazetcc7ec452011-01-19 19:26:56 +000078 if (!red_use_ecn(q) || !INET_ECN_set_ce(skb)) {
79 q->stats.prob_drop++;
80 goto congestion_drop;
81 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Eric Dumazetcc7ec452011-01-19 19:26:56 +000083 q->stats.prob_mark++;
84 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Eric Dumazetcc7ec452011-01-19 19:26:56 +000086 case RED_HARD_MARK:
John Fastabend25331d62014-09-28 11:53:29 -070087 qdisc_qstats_overlimit(sch);
Eric Dumazetcc7ec452011-01-19 19:26:56 +000088 if (red_use_harddrop(q) || !red_use_ecn(q) ||
89 !INET_ECN_set_ce(skb)) {
90 q->stats.forced_drop++;
91 goto congestion_drop;
92 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Eric Dumazetcc7ec452011-01-19 19:26:56 +000094 q->stats.forced_mark++;
95 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 }
97
Jussi Kivilinna5f861732008-07-20 00:08:04 -070098 ret = qdisc_enqueue(skb, child);
Patrick McHardyf38c39d2006-03-20 19:20:44 -080099 if (likely(ret == NET_XMIT_SUCCESS)) {
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800100 sch->q.qlen++;
Jarek Poplawski378a2f02008-08-04 22:31:03 -0700101 } else if (net_xmit_drop_count(ret)) {
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800102 q->stats.pdrop++;
John Fastabend25331d62014-09-28 11:53:29 -0700103 qdisc_qstats_drop(sch);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800104 }
105 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
Thomas Graf6b31b282005-11-05 21:14:05 +0100107congestion_drop:
Thomas Graf9e178ff2005-11-05 21:14:06 +0100108 qdisc_drop(skb, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 return NET_XMIT_CN;
110}
111
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000112static struct sk_buff *red_dequeue(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
114 struct sk_buff *skb;
115 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800116 struct Qdisc *child = q->qdisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800118 skb = child->dequeue(child);
Eric Dumazet9190b3b2011-01-20 23:31:33 -0800119 if (skb) {
120 qdisc_bstats_update(sch, skb);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800121 sch->q.qlen--;
Eric Dumazet9190b3b2011-01-20 23:31:33 -0800122 } else {
Eric Dumazeteeca6682012-01-05 02:25:16 +0000123 if (!red_is_idling(&q->vars))
124 red_start_of_idle_period(&q->vars);
Eric Dumazet9190b3b2011-01-20 23:31:33 -0800125 }
Thomas Graf9e178ff2005-11-05 21:14:06 +0100126 return skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127}
128
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000129static struct sk_buff *red_peek(struct Qdisc *sch)
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700130{
131 struct red_sched_data *q = qdisc_priv(sch);
132 struct Qdisc *child = q->qdisc;
133
134 return child->ops->peek(child);
135}
136
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000137static unsigned int red_drop(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800140 struct Qdisc *child = q->qdisc;
141 unsigned int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800143 if (child->ops->drop && (len = child->ops->drop(child)) > 0) {
Thomas Graf6b31b282005-11-05 21:14:05 +0100144 q->stats.other++;
John Fastabend25331d62014-09-28 11:53:29 -0700145 qdisc_qstats_drop(sch);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800146 sch->q.qlen--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 return len;
148 }
Thomas Graf6b31b282005-11-05 21:14:05 +0100149
Eric Dumazeteeca6682012-01-05 02:25:16 +0000150 if (!red_is_idling(&q->vars))
151 red_start_of_idle_period(&q->vars);
Thomas Graf6a1b63d2005-11-05 21:14:07 +0100152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 return 0;
154}
155
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000156static void red_reset(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
158 struct red_sched_data *q = qdisc_priv(sch);
159
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800160 qdisc_reset(q->qdisc);
161 sch->q.qlen = 0;
Eric Dumazeteeca6682012-01-05 02:25:16 +0000162 red_restart(&q->vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
164
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800165static void red_destroy(struct Qdisc *sch)
166{
167 struct red_sched_data *q = qdisc_priv(sch);
Eric Dumazet8af2a212011-12-08 06:06:03 +0000168
169 del_timer_sync(&q->adapt_timer);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800170 qdisc_destroy(q->qdisc);
171}
172
Patrick McHardy27a34212008-01-23 20:35:39 -0800173static const struct nla_policy red_policy[TCA_RED_MAX + 1] = {
174 [TCA_RED_PARMS] = { .len = sizeof(struct tc_red_qopt) },
175 [TCA_RED_STAB] = { .len = RED_STAB_SIZE },
Eric Dumazeta73ed262011-12-09 02:46:45 +0000176 [TCA_RED_MAX_P] = { .type = NLA_U32 },
Patrick McHardy27a34212008-01-23 20:35:39 -0800177};
178
Patrick McHardy1e904742008-01-22 22:11:17 -0800179static int red_change(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180{
181 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardy1e904742008-01-22 22:11:17 -0800182 struct nlattr *tb[TCA_RED_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 struct tc_red_qopt *ctl;
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800184 struct Qdisc *child = NULL;
Patrick McHardycee63722008-01-23 20:33:32 -0800185 int err;
Eric Dumazeta73ed262011-12-09 02:46:45 +0000186 u32 max_P;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Patrick McHardycee63722008-01-23 20:33:32 -0800188 if (opt == NULL)
Thomas Grafdba051f2005-11-05 21:14:08 +0100189 return -EINVAL;
190
Patrick McHardy27a34212008-01-23 20:35:39 -0800191 err = nla_parse_nested(tb, TCA_RED_MAX, opt, red_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800192 if (err < 0)
193 return err;
194
Patrick McHardy1e904742008-01-22 22:11:17 -0800195 if (tb[TCA_RED_PARMS] == NULL ||
Patrick McHardy27a34212008-01-23 20:35:39 -0800196 tb[TCA_RED_STAB] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return -EINVAL;
198
Eric Dumazeta73ed262011-12-09 02:46:45 +0000199 max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;
200
Patrick McHardy1e904742008-01-22 22:11:17 -0800201 ctl = nla_data(tb[TCA_RED_PARMS]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800203 if (ctl->limit > 0) {
Patrick McHardyfb0305c2008-07-05 23:40:21 -0700204 child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit);
205 if (IS_ERR(child))
206 return PTR_ERR(child);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800207 }
208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 sch_tree_lock(sch);
210 q->flags = ctl->flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 q->limit = ctl->limit;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800212 if (child) {
213 qdisc_tree_decrease_qlen(q->qdisc, q->qdisc->q.qlen);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800214 qdisc_destroy(q->qdisc);
215 q->qdisc = child;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800216 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Eric Dumazeteeca6682012-01-05 02:25:16 +0000218 red_set_parms(&q->parms,
219 ctl->qth_min, ctl->qth_max, ctl->Wlog,
Eric Dumazeta73ed262011-12-09 02:46:45 +0000220 ctl->Plog, ctl->Scell_log,
221 nla_data(tb[TCA_RED_STAB]),
222 max_P);
Eric Dumazeteeca6682012-01-05 02:25:16 +0000223 red_set_vars(&q->vars);
Thomas Graf6b31b282005-11-05 21:14:05 +0100224
Eric Dumazet8af2a212011-12-08 06:06:03 +0000225 del_timer(&q->adapt_timer);
226 if (ctl->flags & TC_RED_ADAPTATIVE)
227 mod_timer(&q->adapt_timer, jiffies + HZ/2);
228
Eric Dumazet1ee5fa12011-12-01 11:06:34 +0000229 if (!q->qdisc->q.qlen)
Eric Dumazeteeca6682012-01-05 02:25:16 +0000230 red_start_of_idle_period(&q->vars);
Thomas Grafdba051f2005-11-05 21:14:08 +0100231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 sch_tree_unlock(sch);
233 return 0;
234}
235
Eric Dumazet8af2a212011-12-08 06:06:03 +0000236static inline void red_adaptative_timer(unsigned long arg)
237{
238 struct Qdisc *sch = (struct Qdisc *)arg;
239 struct red_sched_data *q = qdisc_priv(sch);
240 spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));
241
242 spin_lock(root_lock);
Eric Dumazeteeca6682012-01-05 02:25:16 +0000243 red_adaptative_algo(&q->parms, &q->vars);
Eric Dumazet8af2a212011-12-08 06:06:03 +0000244 mod_timer(&q->adapt_timer, jiffies + HZ/2);
245 spin_unlock(root_lock);
246}
247
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000248static int red_init(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800250 struct red_sched_data *q = qdisc_priv(sch);
251
252 q->qdisc = &noop_qdisc;
Eric Dumazet8af2a212011-12-08 06:06:03 +0000253 setup_timer(&q->adapt_timer, red_adaptative_timer, (unsigned long)sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 return red_change(sch, opt);
255}
256
257static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
258{
259 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardy1e904742008-01-22 22:11:17 -0800260 struct nlattr *opts = NULL;
Thomas Graf6b31b282005-11-05 21:14:05 +0100261 struct tc_red_qopt opt = {
262 .limit = q->limit,
263 .flags = q->flags,
264 .qth_min = q->parms.qth_min >> q->parms.Wlog,
265 .qth_max = q->parms.qth_max >> q->parms.Wlog,
266 .Wlog = q->parms.Wlog,
267 .Plog = q->parms.Plog,
268 .Scell_log = q->parms.Scell_log,
269 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Eric Dumazet0dfb33a2011-01-03 08:11:38 +0000271 sch->qstats.backlog = q->qdisc->qstats.backlog;
Patrick McHardy1e904742008-01-22 22:11:17 -0800272 opts = nla_nest_start(skb, TCA_OPTIONS);
273 if (opts == NULL)
274 goto nla_put_failure;
David S. Miller1b34ec42012-03-29 05:11:39 -0400275 if (nla_put(skb, TCA_RED_PARMS, sizeof(opt), &opt) ||
276 nla_put_u32(skb, TCA_RED_MAX_P, q->parms.max_P))
277 goto nla_put_failure;
Patrick McHardy1e904742008-01-22 22:11:17 -0800278 return nla_nest_end(skb, opts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
Patrick McHardy1e904742008-01-22 22:11:17 -0800280nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -0700281 nla_nest_cancel(skb, opts);
282 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283}
284
285static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
286{
287 struct red_sched_data *q = qdisc_priv(sch);
Thomas Graf6b31b282005-11-05 21:14:05 +0100288 struct tc_red_xstats st = {
289 .early = q->stats.prob_drop + q->stats.forced_drop,
290 .pdrop = q->stats.pdrop,
291 .other = q->stats.other,
292 .marked = q->stats.prob_mark + q->stats.forced_mark,
293 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Thomas Graf6b31b282005-11-05 21:14:05 +0100295 return gnet_stats_copy_app(d, &st, sizeof(st));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800298static int red_dump_class(struct Qdisc *sch, unsigned long cl,
299 struct sk_buff *skb, struct tcmsg *tcm)
300{
301 struct red_sched_data *q = qdisc_priv(sch);
302
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800303 tcm->tcm_handle |= TC_H_MIN(1);
304 tcm->tcm_info = q->qdisc->handle;
305 return 0;
306}
307
308static int red_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
309 struct Qdisc **old)
310{
311 struct red_sched_data *q = qdisc_priv(sch);
312
313 if (new == NULL)
314 new = &noop_qdisc;
315
316 sch_tree_lock(sch);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800317 *old = q->qdisc;
318 q->qdisc = new;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800319 qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800320 qdisc_reset(*old);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800321 sch_tree_unlock(sch);
322 return 0;
323}
324
325static struct Qdisc *red_leaf(struct Qdisc *sch, unsigned long arg)
326{
327 struct red_sched_data *q = qdisc_priv(sch);
328 return q->qdisc;
329}
330
331static unsigned long red_get(struct Qdisc *sch, u32 classid)
332{
333 return 1;
334}
335
336static void red_put(struct Qdisc *sch, unsigned long arg)
337{
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800338}
339
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800340static void red_walk(struct Qdisc *sch, struct qdisc_walker *walker)
341{
342 if (!walker->stop) {
343 if (walker->count >= walker->skip)
344 if (walker->fn(sch, 1, walker) < 0) {
345 walker->stop = 1;
346 return;
347 }
348 walker->count++;
349 }
350}
351
Eric Dumazet20fea082007-11-14 01:44:41 -0800352static const struct Qdisc_class_ops red_class_ops = {
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800353 .graft = red_graft,
354 .leaf = red_leaf,
355 .get = red_get,
356 .put = red_put,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800357 .walk = red_walk,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800358 .dump = red_dump_class,
359};
360
Eric Dumazet20fea082007-11-14 01:44:41 -0800361static struct Qdisc_ops red_qdisc_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 .id = "red",
363 .priv_size = sizeof(struct red_sched_data),
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800364 .cl_ops = &red_class_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 .enqueue = red_enqueue,
366 .dequeue = red_dequeue,
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700367 .peek = red_peek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 .drop = red_drop,
369 .init = red_init,
370 .reset = red_reset,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800371 .destroy = red_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 .change = red_change,
373 .dump = red_dump,
374 .dump_stats = red_dump_stats,
375 .owner = THIS_MODULE,
376};
377
378static int __init red_module_init(void)
379{
380 return register_qdisc(&red_qdisc_ops);
381}
Thomas Grafdba051f2005-11-05 21:14:08 +0100382
383static void __exit red_module_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
385 unregister_qdisc(&red_qdisc_ops);
386}
Thomas Grafdba051f2005-11-05 21:14:08 +0100387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388module_init(red_module_init)
389module_exit(red_module_exit)
Thomas Grafdba051f2005-11-05 21:14:08 +0100390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391MODULE_LICENSE("GPL");