blob: 8c0508c0e287742a8fbbcbf49134e76e9e52b807 [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) {
WANG Cong2ccccf52016-02-25 14:55:01 -0800213 qdisc_tree_reduce_backlog(q->qdisc, q->qdisc->q.qlen,
214 q->qdisc->qstats.backlog);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800215 qdisc_destroy(q->qdisc);
216 q->qdisc = child;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800217 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
Eric Dumazeteeca6682012-01-05 02:25:16 +0000219 red_set_parms(&q->parms,
220 ctl->qth_min, ctl->qth_max, ctl->Wlog,
Eric Dumazeta73ed262011-12-09 02:46:45 +0000221 ctl->Plog, ctl->Scell_log,
222 nla_data(tb[TCA_RED_STAB]),
223 max_P);
Eric Dumazeteeca6682012-01-05 02:25:16 +0000224 red_set_vars(&q->vars);
Thomas Graf6b31b282005-11-05 21:14:05 +0100225
Eric Dumazet8af2a212011-12-08 06:06:03 +0000226 del_timer(&q->adapt_timer);
227 if (ctl->flags & TC_RED_ADAPTATIVE)
228 mod_timer(&q->adapt_timer, jiffies + HZ/2);
229
Eric Dumazet1ee5fa12011-12-01 11:06:34 +0000230 if (!q->qdisc->q.qlen)
Eric Dumazeteeca6682012-01-05 02:25:16 +0000231 red_start_of_idle_period(&q->vars);
Thomas Grafdba051f2005-11-05 21:14:08 +0100232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 sch_tree_unlock(sch);
234 return 0;
235}
236
Eric Dumazet8af2a212011-12-08 06:06:03 +0000237static inline void red_adaptative_timer(unsigned long arg)
238{
239 struct Qdisc *sch = (struct Qdisc *)arg;
240 struct red_sched_data *q = qdisc_priv(sch);
241 spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));
242
243 spin_lock(root_lock);
Eric Dumazeteeca6682012-01-05 02:25:16 +0000244 red_adaptative_algo(&q->parms, &q->vars);
Eric Dumazet8af2a212011-12-08 06:06:03 +0000245 mod_timer(&q->adapt_timer, jiffies + HZ/2);
246 spin_unlock(root_lock);
247}
248
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000249static int red_init(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250{
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800251 struct red_sched_data *q = qdisc_priv(sch);
252
253 q->qdisc = &noop_qdisc;
Eric Dumazet8af2a212011-12-08 06:06:03 +0000254 setup_timer(&q->adapt_timer, red_adaptative_timer, (unsigned long)sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 return red_change(sch, opt);
256}
257
258static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
259{
260 struct red_sched_data *q = qdisc_priv(sch);
Patrick McHardy1e904742008-01-22 22:11:17 -0800261 struct nlattr *opts = NULL;
Thomas Graf6b31b282005-11-05 21:14:05 +0100262 struct tc_red_qopt opt = {
263 .limit = q->limit,
264 .flags = q->flags,
265 .qth_min = q->parms.qth_min >> q->parms.Wlog,
266 .qth_max = q->parms.qth_max >> q->parms.Wlog,
267 .Wlog = q->parms.Wlog,
268 .Plog = q->parms.Plog,
269 .Scell_log = q->parms.Scell_log,
270 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Eric Dumazet0dfb33a2011-01-03 08:11:38 +0000272 sch->qstats.backlog = q->qdisc->qstats.backlog;
Patrick McHardy1e904742008-01-22 22:11:17 -0800273 opts = nla_nest_start(skb, TCA_OPTIONS);
274 if (opts == NULL)
275 goto nla_put_failure;
David S. Miller1b34ec42012-03-29 05:11:39 -0400276 if (nla_put(skb, TCA_RED_PARMS, sizeof(opt), &opt) ||
277 nla_put_u32(skb, TCA_RED_MAX_P, q->parms.max_P))
278 goto nla_put_failure;
Patrick McHardy1e904742008-01-22 22:11:17 -0800279 return nla_nest_end(skb, opts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Patrick McHardy1e904742008-01-22 22:11:17 -0800281nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -0700282 nla_nest_cancel(skb, opts);
283 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284}
285
286static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
287{
288 struct red_sched_data *q = qdisc_priv(sch);
Thomas Graf6b31b282005-11-05 21:14:05 +0100289 struct tc_red_xstats st = {
290 .early = q->stats.prob_drop + q->stats.forced_drop,
291 .pdrop = q->stats.pdrop,
292 .other = q->stats.other,
293 .marked = q->stats.prob_mark + q->stats.forced_mark,
294 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Thomas Graf6b31b282005-11-05 21:14:05 +0100296 return gnet_stats_copy_app(d, &st, sizeof(st));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297}
298
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800299static int red_dump_class(struct Qdisc *sch, unsigned long cl,
300 struct sk_buff *skb, struct tcmsg *tcm)
301{
302 struct red_sched_data *q = qdisc_priv(sch);
303
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800304 tcm->tcm_handle |= TC_H_MIN(1);
305 tcm->tcm_info = q->qdisc->handle;
306 return 0;
307}
308
309static int red_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
310 struct Qdisc **old)
311{
312 struct red_sched_data *q = qdisc_priv(sch);
313
314 if (new == NULL)
315 new = &noop_qdisc;
316
WANG Cong86a79962016-02-25 14:55:00 -0800317 *old = qdisc_replace(sch, new, &q->qdisc);
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800318 return 0;
319}
320
321static struct Qdisc *red_leaf(struct Qdisc *sch, unsigned long arg)
322{
323 struct red_sched_data *q = qdisc_priv(sch);
324 return q->qdisc;
325}
326
327static unsigned long red_get(struct Qdisc *sch, u32 classid)
328{
329 return 1;
330}
331
332static void red_put(struct Qdisc *sch, unsigned long arg)
333{
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800334}
335
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800336static void red_walk(struct Qdisc *sch, struct qdisc_walker *walker)
337{
338 if (!walker->stop) {
339 if (walker->count >= walker->skip)
340 if (walker->fn(sch, 1, walker) < 0) {
341 walker->stop = 1;
342 return;
343 }
344 walker->count++;
345 }
346}
347
Eric Dumazet20fea082007-11-14 01:44:41 -0800348static const struct Qdisc_class_ops red_class_ops = {
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800349 .graft = red_graft,
350 .leaf = red_leaf,
351 .get = red_get,
352 .put = red_put,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800353 .walk = red_walk,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800354 .dump = red_dump_class,
355};
356
Eric Dumazet20fea082007-11-14 01:44:41 -0800357static struct Qdisc_ops red_qdisc_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 .id = "red",
359 .priv_size = sizeof(struct red_sched_data),
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800360 .cl_ops = &red_class_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 .enqueue = red_enqueue,
362 .dequeue = red_dequeue,
Jarek Poplawski8e3af972008-10-31 00:45:55 -0700363 .peek = red_peek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 .drop = red_drop,
365 .init = red_init,
366 .reset = red_reset,
Patrick McHardyf38c39d2006-03-20 19:20:44 -0800367 .destroy = red_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 .change = red_change,
369 .dump = red_dump,
370 .dump_stats = red_dump_stats,
371 .owner = THIS_MODULE,
372};
373
374static int __init red_module_init(void)
375{
376 return register_qdisc(&red_qdisc_ops);
377}
Thomas Grafdba051f2005-11-05 21:14:08 +0100378
379static void __exit red_module_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
381 unregister_qdisc(&red_qdisc_ops);
382}
Thomas Grafdba051f2005-11-05 21:14:08 +0100383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384module_init(red_module_init)
385module_exit(red_module_exit)
Thomas Grafdba051f2005-11-05 21:14:08 +0100386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387MODULE_LICENSE("GPL");