blob: c8388f3c3426ab862414d1ce67e5ec3e9d13ecde [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/sched/sch_tbf.c Token Bucket Filter 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 * Dmitry Torokhov <dtor@mail.ru> - allow attaching inner qdiscs -
11 * original idea by Martin Devera
12 *
13 */
14
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/types.h>
17#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/skbuff.h>
Patrick McHardy0ba48052007-07-02 22:49:07 -070021#include <net/netlink.h>
Jiri Pirkob757c932013-02-12 00:12:05 +000022#include <net/sch_generic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <net/pkt_sched.h>
24
25
26/* Simple Token Bucket Filter.
27 =======================================
28
29 SOURCE.
30 -------
31
32 None.
33
34 Description.
35 ------------
36
37 A data flow obeys TBF with rate R and depth B, if for any
38 time interval t_i...t_f the number of transmitted bits
39 does not exceed B + R*(t_f-t_i).
40
41 Packetized version of this definition:
42 The sequence of packets of sizes s_i served at moments t_i
43 obeys TBF, if for any i<=k:
44
45 s_i+....+s_k <= B + R*(t_k - t_i)
46
47 Algorithm.
48 ----------
49
50 Let N(t_i) be B/R initially and N(t) grow continuously with time as:
51
52 N(t+delta) = min{B/R, N(t) + delta}
53
54 If the first packet in queue has length S, it may be
55 transmitted only at the time t_* when S/R <= N(t_*),
56 and in this case N(t) jumps:
57
58 N(t_* + 0) = N(t_* - 0) - S/R.
59
60
61
62 Actually, QoS requires two TBF to be applied to a data stream.
63 One of them controls steady state burst size, another
64 one with rate P (peak rate) and depth M (equal to link MTU)
65 limits bursts at a smaller time scale.
66
67 It is easy to see that P>R, and B>M. If P is infinity, this double
68 TBF is equivalent to a single one.
69
70 When TBF works in reshaping mode, latency is estimated as:
71
72 lat = max ((L-B)/R, (L-M)/P)
73
74
75 NOTES.
76 ------
77
78 If TBF throttles, it starts a watchdog timer, which will wake it up
79 when it is ready to transmit.
80 Note that the minimal timer resolution is 1/HZ.
81 If no new packets arrive during this period,
82 or if the device is not awaken by EOI for some previous packet,
83 TBF can stop its activity for 1/HZ.
84
85
86 This means, that with depth B, the maximal rate is
87
88 R_crit = B*HZ
89
90 F.e. for 10Mbit ethernet and HZ=100 the minimal allowed B is ~10Kbytes.
91
92 Note that the peak rate TBF is much more tough: with MTU 1500
93 P_crit = 150Kbytes/sec. So, if you need greater peak
94 rates, use alpha with HZ=1000 :-)
95
96 With classful TBF, limit is just kept for backwards compatibility.
97 It is passed to the default bfifo qdisc - if the inner qdisc is
98 changed the limit is not effective anymore.
99*/
100
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000101struct tbf_sched_data {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102/* Parameters */
103 u32 limit; /* Maximal length of backlog: bytes */
Jiri Pirkob757c932013-02-12 00:12:05 +0000104 s64 buffer; /* Token bucket depth/rate: MUST BE >= MTU/B */
105 s64 mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 u32 max_size;
Jiri Pirkob757c932013-02-12 00:12:05 +0000107 struct psched_ratecfg rate;
108 struct psched_ratecfg peak;
109 bool peak_present;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/* Variables */
Jiri Pirkob757c932013-02-12 00:12:05 +0000112 s64 tokens; /* Current number of B tokens */
113 s64 ptokens; /* Current number of P tokens */
114 s64 t_c; /* Time check-point */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 struct Qdisc *qdisc; /* Inner qdisc, default - bfifo queue */
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700116 struct qdisc_watchdog watchdog; /* Watchdog timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117};
118
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000119static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
121 struct tbf_sched_data *q = qdisc_priv(sch);
122 int ret;
123
David S. Miller69747652008-08-17 23:55:36 -0700124 if (qdisc_pkt_len(skb) > q->max_size)
125 return qdisc_reshape_fail(skb, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Jussi Kivilinna5f861732008-07-20 00:08:04 -0700127 ret = qdisc_enqueue(skb, q->qdisc);
Ben Greear9871e502010-08-10 01:45:40 -0700128 if (ret != NET_XMIT_SUCCESS) {
Jarek Poplawski378a2f02008-08-04 22:31:03 -0700129 if (net_xmit_drop_count(ret))
130 sch->qstats.drops++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 return ret;
132 }
133
134 sch->q.qlen++;
Ben Greear9871e502010-08-10 01:45:40 -0700135 return NET_XMIT_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000138static unsigned int tbf_drop(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139{
140 struct tbf_sched_data *q = qdisc_priv(sch);
Patrick McHardy6d037a22006-03-20 19:00:49 -0800141 unsigned int len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Patrick McHardy6d037a22006-03-20 19:00:49 -0800143 if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 sch->q.qlen--;
145 sch->qstats.drops++;
146 }
147 return len;
148}
149
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000150static struct sk_buff *tbf_dequeue(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
152 struct tbf_sched_data *q = qdisc_priv(sch);
153 struct sk_buff *skb;
154
Jarek Poplawski03c05f02008-10-31 00:46:19 -0700155 skb = q->qdisc->ops->peek(q->qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 if (skb) {
Jiri Pirkob757c932013-02-12 00:12:05 +0000158 s64 now;
159 s64 toks;
160 s64 ptoks = 0;
Jussi Kivilinna0abf77e2008-07-20 00:08:27 -0700161 unsigned int len = qdisc_pkt_len(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Jiri Pirkob757c932013-02-12 00:12:05 +0000163 now = ktime_to_ns(ktime_get());
164 toks = min_t(s64, now - q->t_c, q->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Jiri Pirkob757c932013-02-12 00:12:05 +0000166 if (q->peak_present) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 ptoks = toks + q->ptokens;
Jiri Pirkob757c932013-02-12 00:12:05 +0000168 if (ptoks > q->mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 ptoks = q->mtu;
Jiri Pirkob757c932013-02-12 00:12:05 +0000170 ptoks -= (s64) psched_l2t_ns(&q->peak, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 }
172 toks += q->tokens;
Jiri Pirkob757c932013-02-12 00:12:05 +0000173 if (toks > q->buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 toks = q->buffer;
Jiri Pirkob757c932013-02-12 00:12:05 +0000175 toks -= (s64) psched_l2t_ns(&q->rate, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177 if ((toks|ptoks) >= 0) {
Jarek Poplawski77be1552008-10-31 00:47:01 -0700178 skb = qdisc_dequeue_peeked(q->qdisc);
Jarek Poplawski03c05f02008-10-31 00:46:19 -0700179 if (unlikely(!skb))
180 return NULL;
181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 q->t_c = now;
183 q->tokens = toks;
184 q->ptokens = ptoks;
185 sch->q.qlen--;
Eric Dumazetfd245a42011-01-20 05:27:16 +0000186 qdisc_unthrottled(sch);
Eric Dumazet9190b3b2011-01-20 23:31:33 -0800187 qdisc_bstats_update(sch, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 return skb;
189 }
190
Jiri Pirkob757c932013-02-12 00:12:05 +0000191 qdisc_watchdog_schedule_ns(&q->watchdog,
192 now + max_t(long, -toks, -ptoks));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
194 /* Maybe we have a shorter packet in the queue,
195 which can be sent now. It sounds cool,
196 but, however, this is wrong in principle.
197 We MUST NOT reorder packets under these circumstances.
198
199 Really, if we split the flow into independent
200 subflows, it would be a very good solution.
201 This is the main idea of all FQ algorithms
202 (cf. CSZ, HPFQ, HFSC)
203 */
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 sch->qstats.overlimits++;
206 }
207 return NULL;
208}
209
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000210static void tbf_reset(struct Qdisc *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
212 struct tbf_sched_data *q = qdisc_priv(sch);
213
214 qdisc_reset(q->qdisc);
215 sch->q.qlen = 0;
Jiri Pirkob757c932013-02-12 00:12:05 +0000216 q->t_c = ktime_to_ns(ktime_get());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 q->tokens = q->buffer;
218 q->ptokens = q->mtu;
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700219 qdisc_watchdog_cancel(&q->watchdog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220}
221
Patrick McHardy27a34212008-01-23 20:35:39 -0800222static const struct nla_policy tbf_policy[TCA_TBF_MAX + 1] = {
223 [TCA_TBF_PARMS] = { .len = sizeof(struct tc_tbf_qopt) },
224 [TCA_TBF_RTAB] = { .type = NLA_BINARY, .len = TC_RTAB_SIZE },
225 [TCA_TBF_PTAB] = { .type = NLA_BINARY, .len = TC_RTAB_SIZE },
226};
227
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000228static int tbf_change(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
Patrick McHardycee63722008-01-23 20:33:32 -0800230 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 struct tbf_sched_data *q = qdisc_priv(sch);
Patrick McHardy1e904742008-01-22 22:11:17 -0800232 struct nlattr *tb[TCA_TBF_PTAB + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 struct tc_tbf_qopt *qopt;
234 struct qdisc_rate_table *rtab = NULL;
235 struct qdisc_rate_table *ptab = NULL;
236 struct Qdisc *child = NULL;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000237 int max_size, n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Patrick McHardy27a34212008-01-23 20:35:39 -0800239 err = nla_parse_nested(tb, TCA_TBF_PTAB, opt, tbf_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800240 if (err < 0)
241 return err;
242
243 err = -EINVAL;
Patrick McHardy27a34212008-01-23 20:35:39 -0800244 if (tb[TCA_TBF_PARMS] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 goto done;
246
Patrick McHardy1e904742008-01-22 22:11:17 -0800247 qopt = nla_data(tb[TCA_TBF_PARMS]);
248 rtab = qdisc_get_rtab(&qopt->rate, tb[TCA_TBF_RTAB]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 if (rtab == NULL)
250 goto done;
251
252 if (qopt->peakrate.rate) {
253 if (qopt->peakrate.rate > qopt->rate.rate)
Patrick McHardy1e904742008-01-22 22:11:17 -0800254 ptab = qdisc_get_rtab(&qopt->peakrate, tb[TCA_TBF_PTAB]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 if (ptab == NULL)
256 goto done;
257 }
258
259 for (n = 0; n < 256; n++)
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000260 if (rtab->data[n] > qopt->buffer)
261 break;
262 max_size = (n << qopt->rate.cell_log) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 if (ptab) {
264 int size;
265
266 for (n = 0; n < 256; n++)
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000267 if (ptab->data[n] > qopt->mtu)
268 break;
269 size = (n << qopt->peakrate.cell_log) - 1;
270 if (size < max_size)
271 max_size = size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 }
273 if (max_size < 0)
274 goto done;
275
stephen hemmingerf0cd1502010-05-14 14:38:59 +0000276 if (q->qdisc != &noop_qdisc) {
277 err = fifo_set_limit(q->qdisc, qopt->limit);
278 if (err)
279 goto done;
280 } else if (qopt->limit > 0) {
Patrick McHardyfb0305c2008-07-05 23:40:21 -0700281 child = fifo_create_dflt(sch, &bfifo_qdisc_ops, qopt->limit);
282 if (IS_ERR(child)) {
283 err = PTR_ERR(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 goto done;
Patrick McHardyfb0305c2008-07-05 23:40:21 -0700285 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 }
287
288 sch_tree_lock(sch);
Patrick McHardy5e50da02006-11-29 17:36:20 -0800289 if (child) {
290 qdisc_tree_decrease_qlen(q->qdisc, q->qdisc->q.qlen);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800291 qdisc_destroy(q->qdisc);
292 q->qdisc = child;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800293 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 q->limit = qopt->limit;
Jiri Pirkob757c932013-02-12 00:12:05 +0000295 q->mtu = PSCHED_TICKS2NS(qopt->mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 q->max_size = max_size;
Jiri Pirkob757c932013-02-12 00:12:05 +0000297 q->buffer = PSCHED_TICKS2NS(qopt->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 q->tokens = q->buffer;
299 q->ptokens = q->mtu;
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800300
Jiri Pirkob757c932013-02-12 00:12:05 +0000301 psched_ratecfg_precompute(&q->rate, rtab->rate.rate);
302 if (ptab) {
303 psched_ratecfg_precompute(&q->peak, ptab->rate.rate);
304 q->peak_present = true;
305 } else {
306 q->peak_present = false;
307 }
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 sch_tree_unlock(sch);
310 err = 0;
311done:
312 if (rtab)
313 qdisc_put_rtab(rtab);
314 if (ptab)
315 qdisc_put_rtab(ptab);
316 return err;
317}
318
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000319static int tbf_init(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{
321 struct tbf_sched_data *q = qdisc_priv(sch);
322
323 if (opt == NULL)
324 return -EINVAL;
325
Jiri Pirkob757c932013-02-12 00:12:05 +0000326 q->t_c = ktime_to_ns(ktime_get());
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700327 qdisc_watchdog_init(&q->watchdog, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 q->qdisc = &noop_qdisc;
329
330 return tbf_change(sch, opt);
331}
332
333static void tbf_destroy(struct Qdisc *sch)
334{
335 struct tbf_sched_data *q = qdisc_priv(sch);
336
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700337 qdisc_watchdog_cancel(&q->watchdog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 qdisc_destroy(q->qdisc);
339}
340
341static int tbf_dump(struct Qdisc *sch, struct sk_buff *skb)
342{
343 struct tbf_sched_data *q = qdisc_priv(sch);
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800344 struct nlattr *nest;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct tc_tbf_qopt opt;
346
Eric Dumazetb0460e42011-12-28 23:27:44 +0000347 sch->qstats.backlog = q->qdisc->qstats.backlog;
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800348 nest = nla_nest_start(skb, TCA_OPTIONS);
349 if (nest == NULL)
350 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 opt.limit = q->limit;
Jiri Pirkob757c932013-02-12 00:12:05 +0000353 opt.rate.rate = psched_ratecfg_getrate(&q->rate);
354 if (q->peak_present)
355 opt.peakrate.rate = psched_ratecfg_getrate(&q->peak);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 else
357 memset(&opt.peakrate, 0, sizeof(opt.peakrate));
Jiri Pirkob757c932013-02-12 00:12:05 +0000358 opt.mtu = PSCHED_NS2TICKS(q->mtu);
359 opt.buffer = PSCHED_NS2TICKS(q->buffer);
David S. Miller1b34ec42012-03-29 05:11:39 -0400360 if (nla_put(skb, TCA_TBF_PARMS, sizeof(opt), &opt))
361 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800363 nla_nest_end(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 return skb->len;
365
Patrick McHardy1e904742008-01-22 22:11:17 -0800366nla_put_failure:
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800367 nla_nest_cancel(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 return -1;
369}
370
371static int tbf_dump_class(struct Qdisc *sch, unsigned long cl,
372 struct sk_buff *skb, struct tcmsg *tcm)
373{
374 struct tbf_sched_data *q = qdisc_priv(sch);
375
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 tcm->tcm_handle |= TC_H_MIN(1);
377 tcm->tcm_info = q->qdisc->handle;
378
379 return 0;
380}
381
382static int tbf_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
383 struct Qdisc **old)
384{
385 struct tbf_sched_data *q = qdisc_priv(sch);
386
387 if (new == NULL)
388 new = &noop_qdisc;
389
390 sch_tree_lock(sch);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800391 *old = q->qdisc;
392 q->qdisc = new;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800393 qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 qdisc_reset(*old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 sch_tree_unlock(sch);
396
397 return 0;
398}
399
400static struct Qdisc *tbf_leaf(struct Qdisc *sch, unsigned long arg)
401{
402 struct tbf_sched_data *q = qdisc_priv(sch);
403 return q->qdisc;
404}
405
406static unsigned long tbf_get(struct Qdisc *sch, u32 classid)
407{
408 return 1;
409}
410
411static void tbf_put(struct Qdisc *sch, unsigned long arg)
412{
413}
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415static void tbf_walk(struct Qdisc *sch, struct qdisc_walker *walker)
416{
417 if (!walker->stop) {
418 if (walker->count >= walker->skip)
419 if (walker->fn(sch, 1, walker) < 0) {
420 walker->stop = 1;
421 return;
422 }
423 walker->count++;
424 }
425}
426
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000427static const struct Qdisc_class_ops tbf_class_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 .graft = tbf_graft,
429 .leaf = tbf_leaf,
430 .get = tbf_get,
431 .put = tbf_put,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 .walk = tbf_walk,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 .dump = tbf_dump_class,
434};
435
Eric Dumazet20fea082007-11-14 01:44:41 -0800436static struct Qdisc_ops tbf_qdisc_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 .next = NULL,
438 .cl_ops = &tbf_class_ops,
439 .id = "tbf",
440 .priv_size = sizeof(struct tbf_sched_data),
441 .enqueue = tbf_enqueue,
442 .dequeue = tbf_dequeue,
Jarek Poplawski77be1552008-10-31 00:47:01 -0700443 .peek = qdisc_peek_dequeued,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 .drop = tbf_drop,
445 .init = tbf_init,
446 .reset = tbf_reset,
447 .destroy = tbf_destroy,
448 .change = tbf_change,
449 .dump = tbf_dump,
450 .owner = THIS_MODULE,
451};
452
453static int __init tbf_module_init(void)
454{
455 return register_qdisc(&tbf_qdisc_ops);
456}
457
458static void __exit tbf_module_exit(void)
459{
460 unregister_qdisc(&tbf_qdisc_ops);
461}
462module_init(tbf_module_init)
463module_exit(tbf_module_exit)
464MODULE_LICENSE("GPL");