blob: 4bf2b599ef98af064bd70f19da1657996db6bdf4 [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)) {
WANG Congab0b3b92016-06-01 16:15:18 -0700100 qdisc_qstats_backlog_inc(sch, skb);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800101 sch->q.qlen++;
Jarek Poplawski378a2f02008-08-04 22:31:03 -0700102 } else if (net_xmit_drop_count(ret)) {
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800103 q->stats.pdrop++;
John Fastabend25331d62014-09-28 11:53:29 -0700104 qdisc_qstats_drop(sch);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800105 }
106 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Thomas Graf6b31b282005-11-05 21:14:05 +0100108congestion_drop:
Thomas Graf9e178ff2005-11-05 21:14:06 +0100109 qdisc_drop(skb, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 return NET_XMIT_CN;
111}
112
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000113static struct sk_buff *red_dequeue(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
115 struct sk_buff *skb;
116 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800117 struct Qdisc *child = q->qdisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800119 skb = child->dequeue(child);
Eric Dumazet9190b3b2011-01-20 23:31:33 -0800120 if (skb) {
121 qdisc_bstats_update(sch, skb);
WANG Congab0b3b92016-06-01 16:15:18 -0700122 qdisc_qstats_backlog_dec(sch, skb);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800123 sch->q.qlen--;
Eric Dumazet9190b3b2011-01-20 23:31:33 -0800124 } else {
Eric Dumazeteeca6682012-01-05 02:25:16 +0000125 if (!red_is_idling(&q->vars))
126 red_start_of_idle_period(&q->vars);
Eric Dumazet9190b3b2011-01-20 23:31:33 -0800127 }
Thomas Graf9e178ff2005-11-05 21:14:06 +0100128 return skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129}
130
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000131static struct sk_buff *red_peek(struct Qdisc *sch)
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700132{
133 struct red_sched_data *q = qdisc_priv(sch);
134 struct Qdisc *child = q->qdisc;
135
136 return child->ops->peek(child);
137}
138
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000139static unsigned int red_drop(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800142 struct Qdisc *child = q->qdisc;
143 unsigned int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800145 if (child->ops->drop && (len = child->ops->drop(child)) > 0) {
Thomas Graf6b31b282005-11-05 21:14:05 +0100146 q->stats.other++;
John Fastabend25331d62014-09-28 11:53:29 -0700147 qdisc_qstats_drop(sch);
WANG Congab0b3b92016-06-01 16:15:18 -0700148 sch->qstats.backlog -= len;
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800149 sch->q.qlen--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 return len;
151 }
Thomas Graf6b31b282005-11-05 21:14:05 +0100152
Eric Dumazeteeca6682012-01-05 02:25:16 +0000153 if (!red_is_idling(&q->vars))
154 red_start_of_idle_period(&q->vars);
Thomas Graf6a1b63d2005-11-05 21:14:07 +0100155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 return 0;
157}
158
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000159static void red_reset(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
161 struct red_sched_data *q = qdisc_priv(sch);
162
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800163 qdisc_reset(q->qdisc);
WANG Congab0b3b92016-06-01 16:15:18 -0700164 sch->qstats.backlog = 0;
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800165 sch->q.qlen = 0;
Eric Dumazeteeca6682012-01-05 02:25:16 +0000166 red_restart(&q->vars);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800169static void red_destroy(struct Qdisc *sch)
170{
171 struct red_sched_data *q = qdisc_priv(sch);
Eric Dumazet8af2a212011-12-08 06:06:03 +0000172
173 del_timer_sync(&q->adapt_timer);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800174 qdisc_destroy(q->qdisc);
175}
176
Patrick McHardy27a34212008-01-23 20:35:39 -0800177static const struct nla_policy red_policy[TCA_RED_MAX + 1] = {
178 [TCA_RED_PARMS] = { .len = sizeof(struct tc_red_qopt) },
179 [TCA_RED_STAB] = { .len = RED_STAB_SIZE },
Eric Dumazeta73ed262011-12-09 02:46:45 +0000180 [TCA_RED_MAX_P] = { .type = NLA_U32 },
Patrick McHardy27a34212008-01-23 20:35:39 -0800181};
182
Patrick McHardy1e904742008-01-22 22:11:17 -0800183static int red_change(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
185 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardy1e904742008-01-22 22:11:17 -0800186 struct nlattr *tb[TCA_RED_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 struct tc_red_qopt *ctl;
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800188 struct Qdisc *child = NULL;
Patrick McHardycee63722008-01-23 20:33:32 -0800189 int err;
Eric Dumazeta73ed262011-12-09 02:46:45 +0000190 u32 max_P;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Patrick McHardycee63722008-01-23 20:33:32 -0800192 if (opt == NULL)
Thomas Grafdba051f2005-11-05 21:14:08 +0100193 return -EINVAL;
194
Patrick McHardy27a34212008-01-23 20:35:39 -0800195 err = nla_parse_nested(tb, TCA_RED_MAX, opt, red_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800196 if (err < 0)
197 return err;
198
Patrick McHardy1e904742008-01-22 22:11:17 -0800199 if (tb[TCA_RED_PARMS] == NULL ||
Patrick McHardy27a34212008-01-23 20:35:39 -0800200 tb[TCA_RED_STAB] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 return -EINVAL;
202
Eric Dumazeta73ed262011-12-09 02:46:45 +0000203 max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;
204
Patrick McHardy1e904742008-01-22 22:11:17 -0800205 ctl = nla_data(tb[TCA_RED_PARMS]);
Nogah Frankel27d2bda2017-12-04 13:31:11 +0200206 if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog))
207 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800209 if (ctl->limit > 0) {
Patrick McHardyfb0305c2008-07-05 23:40:21 -0700210 child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit);
211 if (IS_ERR(child))
212 return PTR_ERR(child);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800213 }
214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 sch_tree_lock(sch);
216 q->flags = ctl->flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 q->limit = ctl->limit;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800218 if (child) {
WANG Congca375cf2016-02-25 14:55:01 -0800219 qdisc_tree_reduce_backlog(q->qdisc, q->qdisc->q.qlen,
220 q->qdisc->qstats.backlog);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800221 qdisc_destroy(q->qdisc);
222 q->qdisc = child;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800223 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Eric Dumazeteeca6682012-01-05 02:25:16 +0000225 red_set_parms(&q->parms,
226 ctl->qth_min, ctl->qth_max, ctl->Wlog,
Eric Dumazeta73ed262011-12-09 02:46:45 +0000227 ctl->Plog, ctl->Scell_log,
228 nla_data(tb[TCA_RED_STAB]),
229 max_P);
Eric Dumazeteeca6682012-01-05 02:25:16 +0000230 red_set_vars(&q->vars);
Thomas Graf6b31b282005-11-05 21:14:05 +0100231
Eric Dumazet8af2a212011-12-08 06:06:03 +0000232 del_timer(&q->adapt_timer);
233 if (ctl->flags & TC_RED_ADAPTATIVE)
234 mod_timer(&q->adapt_timer, jiffies + HZ/2);
235
Eric Dumazet1ee5fa12011-12-01 11:06:34 +0000236 if (!q->qdisc->q.qlen)
Eric Dumazeteeca6682012-01-05 02:25:16 +0000237 red_start_of_idle_period(&q->vars);
Thomas Grafdba051f2005-11-05 21:14:08 +0100238
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 sch_tree_unlock(sch);
240 return 0;
241}
242
Eric Dumazet8af2a212011-12-08 06:06:03 +0000243static inline void red_adaptative_timer(unsigned long arg)
244{
245 struct Qdisc *sch = (struct Qdisc *)arg;
246 struct red_sched_data *q = qdisc_priv(sch);
247 spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));
248
249 spin_lock(root_lock);
Eric Dumazeteeca6682012-01-05 02:25:16 +0000250 red_adaptative_algo(&q->parms, &q->vars);
Eric Dumazet8af2a212011-12-08 06:06:03 +0000251 mod_timer(&q->adapt_timer, jiffies + HZ/2);
252 spin_unlock(root_lock);
253}
254
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000255static int red_init(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256{
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800257 struct red_sched_data *q = qdisc_priv(sch);
258
259 q->qdisc = &noop_qdisc;
Eric Dumazet8af2a212011-12-08 06:06:03 +0000260 setup_timer(&q->adapt_timer, red_adaptative_timer, (unsigned long)sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 return red_change(sch, opt);
262}
263
264static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
265{
266 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardy1e904742008-01-22 22:11:17 -0800267 struct nlattr *opts = NULL;
Thomas Graf6b31b282005-11-05 21:14:05 +0100268 struct tc_red_qopt opt = {
269 .limit = q->limit,
270 .flags = q->flags,
271 .qth_min = q->parms.qth_min >> q->parms.Wlog,
272 .qth_max = q->parms.qth_max >> q->parms.Wlog,
273 .Wlog = q->parms.Wlog,
274 .Plog = q->parms.Plog,
275 .Scell_log = q->parms.Scell_log,
276 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
Eric Dumazet0dfb33a2011-01-03 08:11:38 +0000278 sch->qstats.backlog = q->qdisc->qstats.backlog;
Patrick McHardy1e904742008-01-22 22:11:17 -0800279 opts = nla_nest_start(skb, TCA_OPTIONS);
280 if (opts == NULL)
281 goto nla_put_failure;
David S. Miller1b34ec42012-03-29 05:11:39 -0400282 if (nla_put(skb, TCA_RED_PARMS, sizeof(opt), &opt) ||
283 nla_put_u32(skb, TCA_RED_MAX_P, q->parms.max_P))
284 goto nla_put_failure;
Patrick McHardy1e904742008-01-22 22:11:17 -0800285 return nla_nest_end(skb, opts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
Patrick McHardy1e904742008-01-22 22:11:17 -0800287nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -0700288 nla_nest_cancel(skb, opts);
289 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290}
291
292static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
293{
294 struct red_sched_data *q = qdisc_priv(sch);
Thomas Graf6b31b282005-11-05 21:14:05 +0100295 struct tc_red_xstats st = {
296 .early = q->stats.prob_drop + q->stats.forced_drop,
297 .pdrop = q->stats.pdrop,
298 .other = q->stats.other,
299 .marked = q->stats.prob_mark + q->stats.forced_mark,
300 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Thomas Graf6b31b282005-11-05 21:14:05 +0100302 return gnet_stats_copy_app(d, &st, sizeof(st));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303}
304
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800305static int red_dump_class(struct Qdisc *sch, unsigned long cl,
306 struct sk_buff *skb, struct tcmsg *tcm)
307{
308 struct red_sched_data *q = qdisc_priv(sch);
309
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800310 tcm->tcm_handle |= TC_H_MIN(1);
311 tcm->tcm_info = q->qdisc->handle;
312 return 0;
313}
314
315static int red_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
316 struct Qdisc **old)
317{
318 struct red_sched_data *q = qdisc_priv(sch);
319
320 if (new == NULL)
321 new = &noop_qdisc;
322
WANG Cong1188e142016-02-25 14:55:00 -0800323 *old = qdisc_replace(sch, new, &q->qdisc);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800324 return 0;
325}
326
327static struct Qdisc *red_leaf(struct Qdisc *sch, unsigned long arg)
328{
329 struct red_sched_data *q = qdisc_priv(sch);
330 return q->qdisc;
331}
332
333static unsigned long red_get(struct Qdisc *sch, u32 classid)
334{
335 return 1;
336}
337
338static void red_put(struct Qdisc *sch, unsigned long arg)
339{
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800340}
341
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800342static void red_walk(struct Qdisc *sch, struct qdisc_walker *walker)
343{
344 if (!walker->stop) {
345 if (walker->count >= walker->skip)
346 if (walker->fn(sch, 1, walker) < 0) {
347 walker->stop = 1;
348 return;
349 }
350 walker->count++;
351 }
352}
353
Eric Dumazet20fea082007-11-14 01:44:41 -0800354static const struct Qdisc_class_ops red_class_ops = {
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800355 .graft = red_graft,
356 .leaf = red_leaf,
357 .get = red_get,
358 .put = red_put,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800359 .walk = red_walk,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800360 .dump = red_dump_class,
361};
362
Eric Dumazet20fea082007-11-14 01:44:41 -0800363static struct Qdisc_ops red_qdisc_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 .id = "red",
365 .priv_size = sizeof(struct red_sched_data),
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800366 .cl_ops = &red_class_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 .enqueue = red_enqueue,
368 .dequeue = red_dequeue,
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700369 .peek = red_peek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 .drop = red_drop,
371 .init = red_init,
372 .reset = red_reset,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800373 .destroy = red_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 .change = red_change,
375 .dump = red_dump,
376 .dump_stats = red_dump_stats,
377 .owner = THIS_MODULE,
378};
379
380static int __init red_module_init(void)
381{
382 return register_qdisc(&red_qdisc_ops);
383}
Thomas Grafdba051f2005-11-05 21:14:08 +0100384
385static void __exit red_module_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
387 unregister_qdisc(&red_qdisc_ops);
388}
Thomas Grafdba051f2005-11-05 21:14:08 +0100389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390module_init(red_module_init)
391module_exit(red_module_exit)
Thomas Grafdba051f2005-11-05 21:14:08 +0100392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393MODULE_LICENSE("GPL");