blob: 8fb8107ab18847402b94278ee420f9623ed40b8c [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <net/pkt_sched.h>
23
24
25/* Simple Token Bucket Filter.
26 =======================================
27
28 SOURCE.
29 -------
30
31 None.
32
33 Description.
34 ------------
35
36 A data flow obeys TBF with rate R and depth B, if for any
37 time interval t_i...t_f the number of transmitted bits
38 does not exceed B + R*(t_f-t_i).
39
40 Packetized version of this definition:
41 The sequence of packets of sizes s_i served at moments t_i
42 obeys TBF, if for any i<=k:
43
44 s_i+....+s_k <= B + R*(t_k - t_i)
45
46 Algorithm.
47 ----------
48
49 Let N(t_i) be B/R initially and N(t) grow continuously with time as:
50
51 N(t+delta) = min{B/R, N(t) + delta}
52
53 If the first packet in queue has length S, it may be
54 transmitted only at the time t_* when S/R <= N(t_*),
55 and in this case N(t) jumps:
56
57 N(t_* + 0) = N(t_* - 0) - S/R.
58
59
60
61 Actually, QoS requires two TBF to be applied to a data stream.
62 One of them controls steady state burst size, another
63 one with rate P (peak rate) and depth M (equal to link MTU)
64 limits bursts at a smaller time scale.
65
66 It is easy to see that P>R, and B>M. If P is infinity, this double
67 TBF is equivalent to a single one.
68
69 When TBF works in reshaping mode, latency is estimated as:
70
71 lat = max ((L-B)/R, (L-M)/P)
72
73
74 NOTES.
75 ------
76
77 If TBF throttles, it starts a watchdog timer, which will wake it up
78 when it is ready to transmit.
79 Note that the minimal timer resolution is 1/HZ.
80 If no new packets arrive during this period,
81 or if the device is not awaken by EOI for some previous packet,
82 TBF can stop its activity for 1/HZ.
83
84
85 This means, that with depth B, the maximal rate is
86
87 R_crit = B*HZ
88
89 F.e. for 10Mbit ethernet and HZ=100 the minimal allowed B is ~10Kbytes.
90
91 Note that the peak rate TBF is much more tough: with MTU 1500
92 P_crit = 150Kbytes/sec. So, if you need greater peak
93 rates, use alpha with HZ=1000 :-)
94
95 With classful TBF, limit is just kept for backwards compatibility.
96 It is passed to the default bfifo qdisc - if the inner qdisc is
97 changed the limit is not effective anymore.
98*/
99
100struct tbf_sched_data
101{
102/* Parameters */
103 u32 limit; /* Maximal length of backlog: bytes */
104 u32 buffer; /* Token bucket depth/rate: MUST BE >= MTU/B */
105 u32 mtu;
106 u32 max_size;
107 struct qdisc_rate_table *R_tab;
108 struct qdisc_rate_table *P_tab;
109
110/* Variables */
111 long tokens; /* Current number of B tokens */
112 long ptokens; /* Current number of P tokens */
113 psched_time_t t_c; /* Time check-point */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 struct Qdisc *qdisc; /* Inner qdisc, default - bfifo queue */
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700115 struct qdisc_watchdog watchdog; /* Watchdog timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116};
117
Jesper Dangaard Brouere9bef552007-09-12 16:35:24 +0200118#define L2T(q,L) qdisc_l2t((q)->R_tab,L)
119#define L2T_P(q,L) qdisc_l2t((q)->P_tab,L)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121static int tbf_enqueue(struct sk_buff *skb, struct Qdisc* sch)
122{
123 struct tbf_sched_data *q = qdisc_priv(sch);
124 int ret;
125
David S. Miller69747652008-08-17 23:55:36 -0700126 if (qdisc_pkt_len(skb) > q->max_size)
127 return qdisc_reshape_fail(skb, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
Jussi Kivilinna5f861732008-07-20 00:08:04 -0700129 ret = qdisc_enqueue(skb, q->qdisc);
130 if (ret != 0) {
Jarek Poplawski378a2f02008-08-04 22:31:03 -0700131 if (net_xmit_drop_count(ret))
132 sch->qstats.drops++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 return ret;
134 }
135
136 sch->q.qlen++;
Jussi Kivilinna0abf77e2008-07-20 00:08:27 -0700137 sch->bstats.bytes += qdisc_pkt_len(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 sch->bstats.packets++;
139 return 0;
140}
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static unsigned int tbf_drop(struct Qdisc* sch)
143{
144 struct tbf_sched_data *q = qdisc_priv(sch);
Patrick McHardy6d037a22006-03-20 19:00:49 -0800145 unsigned int len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
Patrick McHardy6d037a22006-03-20 19:00:49 -0800147 if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 sch->q.qlen--;
149 sch->qstats.drops++;
150 }
151 return len;
152}
153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154static struct sk_buff *tbf_dequeue(struct Qdisc* sch)
155{
156 struct tbf_sched_data *q = qdisc_priv(sch);
157 struct sk_buff *skb;
158
Jarek Poplawski03c05f02008-10-31 00:46:19 -0700159 skb = q->qdisc->ops->peek(q->qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161 if (skb) {
162 psched_time_t now;
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700163 long toks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 long ptoks = 0;
Jussi Kivilinna0abf77e2008-07-20 00:08:27 -0700165 unsigned int len = qdisc_pkt_len(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Patrick McHardy3bebcda2007-03-23 11:29:25 -0700167 now = psched_get_time();
Patrick McHardy03cc45c2007-03-23 11:29:11 -0700168 toks = psched_tdiff_bounded(now, q->t_c, q->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 if (q->P_tab) {
171 ptoks = toks + q->ptokens;
172 if (ptoks > (long)q->mtu)
173 ptoks = q->mtu;
174 ptoks -= L2T_P(q, len);
175 }
176 toks += q->tokens;
177 if (toks > (long)q->buffer)
178 toks = q->buffer;
179 toks -= L2T(q, len);
180
181 if ((toks|ptoks) >= 0) {
Jarek Poplawski77be1552008-10-31 00:47:01 -0700182 skb = qdisc_dequeue_peeked(q->qdisc);
Jarek Poplawski03c05f02008-10-31 00:46:19 -0700183 if (unlikely(!skb))
184 return NULL;
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 q->t_c = now;
187 q->tokens = toks;
188 q->ptokens = ptoks;
189 sch->q.qlen--;
190 sch->flags &= ~TCQ_F_THROTTLED;
191 return skb;
192 }
193
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700194 qdisc_watchdog_schedule(&q->watchdog,
195 now + max_t(long, -toks, -ptoks));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
197 /* Maybe we have a shorter packet in the queue,
198 which can be sent now. It sounds cool,
199 but, however, this is wrong in principle.
200 We MUST NOT reorder packets under these circumstances.
201
202 Really, if we split the flow into independent
203 subflows, it would be a very good solution.
204 This is the main idea of all FQ algorithms
205 (cf. CSZ, HPFQ, HFSC)
206 */
207
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 sch->qstats.overlimits++;
209 }
210 return NULL;
211}
212
213static void tbf_reset(struct Qdisc* sch)
214{
215 struct tbf_sched_data *q = qdisc_priv(sch);
216
217 qdisc_reset(q->qdisc);
218 sch->q.qlen = 0;
Patrick McHardy3bebcda2007-03-23 11:29:25 -0700219 q->t_c = psched_get_time();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 q->tokens = q->buffer;
221 q->ptokens = q->mtu;
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700222 qdisc_watchdog_cancel(&q->watchdog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223}
224
Patrick McHardy27a34212008-01-23 20:35:39 -0800225static const struct nla_policy tbf_policy[TCA_TBF_MAX + 1] = {
226 [TCA_TBF_PARMS] = { .len = sizeof(struct tc_tbf_qopt) },
227 [TCA_TBF_RTAB] = { .type = NLA_BINARY, .len = TC_RTAB_SIZE },
228 [TCA_TBF_PTAB] = { .type = NLA_BINARY, .len = TC_RTAB_SIZE },
229};
230
Patrick McHardy1e904742008-01-22 22:11:17 -0800231static int tbf_change(struct Qdisc* sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232{
Patrick McHardycee63722008-01-23 20:33:32 -0800233 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 struct tbf_sched_data *q = qdisc_priv(sch);
Patrick McHardy1e904742008-01-22 22:11:17 -0800235 struct nlattr *tb[TCA_TBF_PTAB + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 struct tc_tbf_qopt *qopt;
237 struct qdisc_rate_table *rtab = NULL;
238 struct qdisc_rate_table *ptab = NULL;
239 struct Qdisc *child = NULL;
240 int max_size,n;
241
Patrick McHardy27a34212008-01-23 20:35:39 -0800242 err = nla_parse_nested(tb, TCA_TBF_PTAB, opt, tbf_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800243 if (err < 0)
244 return err;
245
246 err = -EINVAL;
Patrick McHardy27a34212008-01-23 20:35:39 -0800247 if (tb[TCA_TBF_PARMS] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 goto done;
249
Patrick McHardy1e904742008-01-22 22:11:17 -0800250 qopt = nla_data(tb[TCA_TBF_PARMS]);
251 rtab = qdisc_get_rtab(&qopt->rate, tb[TCA_TBF_RTAB]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 if (rtab == NULL)
253 goto done;
254
255 if (qopt->peakrate.rate) {
256 if (qopt->peakrate.rate > qopt->rate.rate)
Patrick McHardy1e904742008-01-22 22:11:17 -0800257 ptab = qdisc_get_rtab(&qopt->peakrate, tb[TCA_TBF_PTAB]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 if (ptab == NULL)
259 goto done;
260 }
261
262 for (n = 0; n < 256; n++)
263 if (rtab->data[n] > qopt->buffer) break;
264 max_size = (n << qopt->rate.cell_log)-1;
265 if (ptab) {
266 int size;
267
268 for (n = 0; n < 256; n++)
269 if (ptab->data[n] > qopt->mtu) break;
270 size = (n << qopt->peakrate.cell_log)-1;
271 if (size < max_size) max_size = size;
272 }
273 if (max_size < 0)
274 goto done;
275
Patrick McHardy053cfed2006-03-20 19:01:21 -0800276 if (qopt->limit > 0) {
Patrick McHardyfb0305c2008-07-05 23:40:21 -0700277 child = fifo_create_dflt(sch, &bfifo_qdisc_ops, qopt->limit);
278 if (IS_ERR(child)) {
279 err = PTR_ERR(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 goto done;
Patrick McHardyfb0305c2008-07-05 23:40:21 -0700281 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 }
283
284 sch_tree_lock(sch);
Patrick McHardy5e50da02006-11-29 17:36:20 -0800285 if (child) {
286 qdisc_tree_decrease_qlen(q->qdisc, q->qdisc->q.qlen);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800287 qdisc_destroy(q->qdisc);
288 q->qdisc = child;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800289 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 q->limit = qopt->limit;
291 q->mtu = qopt->mtu;
292 q->max_size = max_size;
293 q->buffer = qopt->buffer;
294 q->tokens = q->buffer;
295 q->ptokens = q->mtu;
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800296
Ilpo Järvinena0bffff2009-03-21 13:36:17 -0700297 swap(q->R_tab, rtab);
298 swap(q->P_tab, ptab);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 sch_tree_unlock(sch);
301 err = 0;
302done:
303 if (rtab)
304 qdisc_put_rtab(rtab);
305 if (ptab)
306 qdisc_put_rtab(ptab);
307 return err;
308}
309
Patrick McHardy1e904742008-01-22 22:11:17 -0800310static int tbf_init(struct Qdisc* sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
312 struct tbf_sched_data *q = qdisc_priv(sch);
313
314 if (opt == NULL)
315 return -EINVAL;
316
Patrick McHardy3bebcda2007-03-23 11:29:25 -0700317 q->t_c = psched_get_time();
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700318 qdisc_watchdog_init(&q->watchdog, sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 q->qdisc = &noop_qdisc;
320
321 return tbf_change(sch, opt);
322}
323
324static void tbf_destroy(struct Qdisc *sch)
325{
326 struct tbf_sched_data *q = qdisc_priv(sch);
327
Patrick McHardyf7f593e2007-03-16 01:20:07 -0700328 qdisc_watchdog_cancel(&q->watchdog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 if (q->P_tab)
331 qdisc_put_rtab(q->P_tab);
332 if (q->R_tab)
333 qdisc_put_rtab(q->R_tab);
334
335 qdisc_destroy(q->qdisc);
336}
337
338static int tbf_dump(struct Qdisc *sch, struct sk_buff *skb)
339{
340 struct tbf_sched_data *q = qdisc_priv(sch);
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800341 struct nlattr *nest;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 struct tc_tbf_qopt opt;
343
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800344 nest = nla_nest_start(skb, TCA_OPTIONS);
345 if (nest == NULL)
346 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 opt.limit = q->limit;
349 opt.rate = q->R_tab->rate;
350 if (q->P_tab)
351 opt.peakrate = q->P_tab->rate;
352 else
353 memset(&opt.peakrate, 0, sizeof(opt.peakrate));
354 opt.mtu = q->mtu;
355 opt.buffer = q->buffer;
Patrick McHardy1e904742008-01-22 22:11:17 -0800356 NLA_PUT(skb, TCA_TBF_PARMS, sizeof(opt), &opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800358 nla_nest_end(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 return skb->len;
360
Patrick McHardy1e904742008-01-22 22:11:17 -0800361nla_put_failure:
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800362 nla_nest_cancel(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return -1;
364}
365
366static int tbf_dump_class(struct Qdisc *sch, unsigned long cl,
367 struct sk_buff *skb, struct tcmsg *tcm)
368{
369 struct tbf_sched_data *q = qdisc_priv(sch);
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 tcm->tcm_handle |= TC_H_MIN(1);
372 tcm->tcm_info = q->qdisc->handle;
373
374 return 0;
375}
376
377static int tbf_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
378 struct Qdisc **old)
379{
380 struct tbf_sched_data *q = qdisc_priv(sch);
381
382 if (new == NULL)
383 new = &noop_qdisc;
384
385 sch_tree_lock(sch);
Patrick McHardyb94c8af2008-11-20 04:11:36 -0800386 *old = q->qdisc;
387 q->qdisc = new;
Patrick McHardy5e50da02006-11-29 17:36:20 -0800388 qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 qdisc_reset(*old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 sch_tree_unlock(sch);
391
392 return 0;
393}
394
395static struct Qdisc *tbf_leaf(struct Qdisc *sch, unsigned long arg)
396{
397 struct tbf_sched_data *q = qdisc_priv(sch);
398 return q->qdisc;
399}
400
401static unsigned long tbf_get(struct Qdisc *sch, u32 classid)
402{
403 return 1;
404}
405
406static void tbf_put(struct Qdisc *sch, unsigned long arg)
407{
408}
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410static void tbf_walk(struct Qdisc *sch, struct qdisc_walker *walker)
411{
412 if (!walker->stop) {
413 if (walker->count >= walker->skip)
414 if (walker->fn(sch, 1, walker) < 0) {
415 walker->stop = 1;
416 return;
417 }
418 walker->count++;
419 }
420}
421
Eric Dumazet20fea082007-11-14 01:44:41 -0800422static const struct Qdisc_class_ops tbf_class_ops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423{
424 .graft = tbf_graft,
425 .leaf = tbf_leaf,
426 .get = tbf_get,
427 .put = tbf_put,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 .walk = tbf_walk,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 .dump = tbf_dump_class,
430};
431
Eric Dumazet20fea082007-11-14 01:44:41 -0800432static struct Qdisc_ops tbf_qdisc_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 .next = NULL,
434 .cl_ops = &tbf_class_ops,
435 .id = "tbf",
436 .priv_size = sizeof(struct tbf_sched_data),
437 .enqueue = tbf_enqueue,
438 .dequeue = tbf_dequeue,
Jarek Poplawski77be1552008-10-31 00:47:01 -0700439 .peek = qdisc_peek_dequeued,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 .drop = tbf_drop,
441 .init = tbf_init,
442 .reset = tbf_reset,
443 .destroy = tbf_destroy,
444 .change = tbf_change,
445 .dump = tbf_dump,
446 .owner = THIS_MODULE,
447};
448
449static int __init tbf_module_init(void)
450{
451 return register_qdisc(&tbf_qdisc_ops);
452}
453
454static void __exit tbf_module_exit(void)
455{
456 unregister_qdisc(&tbf_qdisc_ops);
457}
458module_init(tbf_module_init)
459module_exit(tbf_module_exit)
460MODULE_LICENSE("GPL");