Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | #include <linux/types.h> |
| 17 | #include <linux/kernel.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | #include <linux/string.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <linux/errno.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/skbuff.h> |
Patrick McHardy | 0ba4805 | 2007-07-02 22:49:07 -0700 | [diff] [blame] | 21 | #include <net/netlink.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #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 | |
| 100 | struct 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | struct Qdisc *qdisc; /* Inner qdisc, default - bfifo queue */ |
Patrick McHardy | f7f593e | 2007-03-16 01:20:07 -0700 | [diff] [blame] | 115 | struct qdisc_watchdog watchdog; /* Watchdog timer */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | }; |
| 117 | |
Jesper Dangaard Brouer | e9bef55 | 2007-09-12 16:35:24 +0200 | [diff] [blame] | 118 | #define L2T(q,L) qdisc_l2t((q)->R_tab,L) |
| 119 | #define L2T_P(q,L) qdisc_l2t((q)->P_tab,L) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | |
| 121 | static 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. Miller | 6974765 | 2008-08-17 23:55:36 -0700 | [diff] [blame] | 126 | if (qdisc_pkt_len(skb) > q->max_size) |
| 127 | return qdisc_reshape_fail(skb, sch); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | |
Jussi Kivilinna | 5f86173 | 2008-07-20 00:08:04 -0700 | [diff] [blame] | 129 | ret = qdisc_enqueue(skb, q->qdisc); |
| 130 | if (ret != 0) { |
Jarek Poplawski | 378a2f0 | 2008-08-04 22:31:03 -0700 | [diff] [blame] | 131 | if (net_xmit_drop_count(ret)) |
| 132 | sch->qstats.drops++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | return ret; |
| 134 | } |
| 135 | |
| 136 | sch->q.qlen++; |
Jussi Kivilinna | 0abf77e | 2008-07-20 00:08:27 -0700 | [diff] [blame] | 137 | sch->bstats.bytes += qdisc_pkt_len(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | sch->bstats.packets++; |
| 139 | return 0; |
| 140 | } |
| 141 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | static unsigned int tbf_drop(struct Qdisc* sch) |
| 143 | { |
| 144 | struct tbf_sched_data *q = qdisc_priv(sch); |
Patrick McHardy | 6d037a2 | 2006-03-20 19:00:49 -0800 | [diff] [blame] | 145 | unsigned int len = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | |
Patrick McHardy | 6d037a2 | 2006-03-20 19:00:49 -0800 | [diff] [blame] | 147 | if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | sch->q.qlen--; |
| 149 | sch->qstats.drops++; |
| 150 | } |
| 151 | return len; |
| 152 | } |
| 153 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | static 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 Poplawski | 03c05f0 | 2008-10-31 00:46:19 -0700 | [diff] [blame] | 159 | skb = q->qdisc->ops->peek(q->qdisc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | |
| 161 | if (skb) { |
| 162 | psched_time_t now; |
Patrick McHardy | f7f593e | 2007-03-16 01:20:07 -0700 | [diff] [blame] | 163 | long toks; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | long ptoks = 0; |
Jussi Kivilinna | 0abf77e | 2008-07-20 00:08:27 -0700 | [diff] [blame] | 165 | unsigned int len = qdisc_pkt_len(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | |
Patrick McHardy | 3bebcda | 2007-03-23 11:29:25 -0700 | [diff] [blame] | 167 | now = psched_get_time(); |
Patrick McHardy | 03cc45c | 2007-03-23 11:29:11 -0700 | [diff] [blame] | 168 | toks = psched_tdiff_bounded(now, q->t_c, q->buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | |
| 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 Poplawski | 77be155 | 2008-10-31 00:47:01 -0700 | [diff] [blame] | 182 | skb = qdisc_dequeue_peeked(q->qdisc); |
Jarek Poplawski | 03c05f0 | 2008-10-31 00:46:19 -0700 | [diff] [blame] | 183 | if (unlikely(!skb)) |
| 184 | return NULL; |
| 185 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | 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 McHardy | f7f593e | 2007-03-16 01:20:07 -0700 | [diff] [blame] | 194 | qdisc_watchdog_schedule(&q->watchdog, |
| 195 | now + max_t(long, -toks, -ptoks)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | |
| 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | sch->qstats.overlimits++; |
| 209 | } |
| 210 | return NULL; |
| 211 | } |
| 212 | |
| 213 | static 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 McHardy | 3bebcda | 2007-03-23 11:29:25 -0700 | [diff] [blame] | 219 | q->t_c = psched_get_time(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | q->tokens = q->buffer; |
| 221 | q->ptokens = q->mtu; |
Patrick McHardy | f7f593e | 2007-03-16 01:20:07 -0700 | [diff] [blame] | 222 | qdisc_watchdog_cancel(&q->watchdog); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | } |
| 224 | |
Patrick McHardy | 27a3421 | 2008-01-23 20:35:39 -0800 | [diff] [blame] | 225 | static 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 McHardy | 1e90474 | 2008-01-22 22:11:17 -0800 | [diff] [blame] | 231 | static int tbf_change(struct Qdisc* sch, struct nlattr *opt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | { |
Patrick McHardy | cee6372 | 2008-01-23 20:33:32 -0800 | [diff] [blame] | 233 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | struct tbf_sched_data *q = qdisc_priv(sch); |
Patrick McHardy | 1e90474 | 2008-01-22 22:11:17 -0800 | [diff] [blame] | 235 | struct nlattr *tb[TCA_TBF_PTAB + 1]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | 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 McHardy | 27a3421 | 2008-01-23 20:35:39 -0800 | [diff] [blame] | 242 | err = nla_parse_nested(tb, TCA_TBF_PTAB, opt, tbf_policy); |
Patrick McHardy | cee6372 | 2008-01-23 20:33:32 -0800 | [diff] [blame] | 243 | if (err < 0) |
| 244 | return err; |
| 245 | |
| 246 | err = -EINVAL; |
Patrick McHardy | 27a3421 | 2008-01-23 20:35:39 -0800 | [diff] [blame] | 247 | if (tb[TCA_TBF_PARMS] == NULL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | goto done; |
| 249 | |
Patrick McHardy | 1e90474 | 2008-01-22 22:11:17 -0800 | [diff] [blame] | 250 | qopt = nla_data(tb[TCA_TBF_PARMS]); |
| 251 | rtab = qdisc_get_rtab(&qopt->rate, tb[TCA_TBF_RTAB]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | if (rtab == NULL) |
| 253 | goto done; |
| 254 | |
| 255 | if (qopt->peakrate.rate) { |
| 256 | if (qopt->peakrate.rate > qopt->rate.rate) |
Patrick McHardy | 1e90474 | 2008-01-22 22:11:17 -0800 | [diff] [blame] | 257 | ptab = qdisc_get_rtab(&qopt->peakrate, tb[TCA_TBF_PTAB]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | 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 McHardy | 053cfed | 2006-03-20 19:01:21 -0800 | [diff] [blame] | 276 | if (qopt->limit > 0) { |
Patrick McHardy | fb0305c | 2008-07-05 23:40:21 -0700 | [diff] [blame] | 277 | child = fifo_create_dflt(sch, &bfifo_qdisc_ops, qopt->limit); |
| 278 | if (IS_ERR(child)) { |
| 279 | err = PTR_ERR(child); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | goto done; |
Patrick McHardy | fb0305c | 2008-07-05 23:40:21 -0700 | [diff] [blame] | 281 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | } |
| 283 | |
| 284 | sch_tree_lock(sch); |
Patrick McHardy | 5e50da0 | 2006-11-29 17:36:20 -0800 | [diff] [blame] | 285 | if (child) { |
| 286 | qdisc_tree_decrease_qlen(q->qdisc, q->qdisc->q.qlen); |
Patrick McHardy | b94c8af | 2008-11-20 04:11:36 -0800 | [diff] [blame] | 287 | qdisc_destroy(q->qdisc); |
| 288 | q->qdisc = child; |
Patrick McHardy | 5e50da0 | 2006-11-29 17:36:20 -0800 | [diff] [blame] | 289 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | 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 McHardy | b94c8af | 2008-11-20 04:11:36 -0800 | [diff] [blame] | 296 | |
Ilpo Järvinen | a0bffff | 2009-03-21 13:36:17 -0700 | [diff] [blame] | 297 | swap(q->R_tab, rtab); |
| 298 | swap(q->P_tab, ptab); |
Patrick McHardy | b94c8af | 2008-11-20 04:11:36 -0800 | [diff] [blame] | 299 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | sch_tree_unlock(sch); |
| 301 | err = 0; |
| 302 | done: |
| 303 | if (rtab) |
| 304 | qdisc_put_rtab(rtab); |
| 305 | if (ptab) |
| 306 | qdisc_put_rtab(ptab); |
| 307 | return err; |
| 308 | } |
| 309 | |
Patrick McHardy | 1e90474 | 2008-01-22 22:11:17 -0800 | [diff] [blame] | 310 | static int tbf_init(struct Qdisc* sch, struct nlattr *opt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | { |
| 312 | struct tbf_sched_data *q = qdisc_priv(sch); |
| 313 | |
| 314 | if (opt == NULL) |
| 315 | return -EINVAL; |
| 316 | |
Patrick McHardy | 3bebcda | 2007-03-23 11:29:25 -0700 | [diff] [blame] | 317 | q->t_c = psched_get_time(); |
Patrick McHardy | f7f593e | 2007-03-16 01:20:07 -0700 | [diff] [blame] | 318 | qdisc_watchdog_init(&q->watchdog, sch); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | q->qdisc = &noop_qdisc; |
| 320 | |
| 321 | return tbf_change(sch, opt); |
| 322 | } |
| 323 | |
| 324 | static void tbf_destroy(struct Qdisc *sch) |
| 325 | { |
| 326 | struct tbf_sched_data *q = qdisc_priv(sch); |
| 327 | |
Patrick McHardy | f7f593e | 2007-03-16 01:20:07 -0700 | [diff] [blame] | 328 | qdisc_watchdog_cancel(&q->watchdog); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | |
| 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 | |
| 338 | static int tbf_dump(struct Qdisc *sch, struct sk_buff *skb) |
| 339 | { |
| 340 | struct tbf_sched_data *q = qdisc_priv(sch); |
Patrick McHardy | 4b3550ef | 2008-01-23 20:34:11 -0800 | [diff] [blame] | 341 | struct nlattr *nest; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | struct tc_tbf_qopt opt; |
| 343 | |
Patrick McHardy | 4b3550ef | 2008-01-23 20:34:11 -0800 | [diff] [blame] | 344 | nest = nla_nest_start(skb, TCA_OPTIONS); |
| 345 | if (nest == NULL) |
| 346 | goto nla_put_failure; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 347 | |
| 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 McHardy | 1e90474 | 2008-01-22 22:11:17 -0800 | [diff] [blame] | 356 | NLA_PUT(skb, TCA_TBF_PARMS, sizeof(opt), &opt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | |
Patrick McHardy | 4b3550ef | 2008-01-23 20:34:11 -0800 | [diff] [blame] | 358 | nla_nest_end(skb, nest); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | return skb->len; |
| 360 | |
Patrick McHardy | 1e90474 | 2008-01-22 22:11:17 -0800 | [diff] [blame] | 361 | nla_put_failure: |
Patrick McHardy | 4b3550ef | 2008-01-23 20:34:11 -0800 | [diff] [blame] | 362 | nla_nest_cancel(skb, nest); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 363 | return -1; |
| 364 | } |
| 365 | |
| 366 | static 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | tcm->tcm_handle |= TC_H_MIN(1); |
| 372 | tcm->tcm_info = q->qdisc->handle; |
| 373 | |
| 374 | return 0; |
| 375 | } |
| 376 | |
| 377 | static 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 McHardy | b94c8af | 2008-11-20 04:11:36 -0800 | [diff] [blame] | 386 | *old = q->qdisc; |
| 387 | q->qdisc = new; |
Patrick McHardy | 5e50da0 | 2006-11-29 17:36:20 -0800 | [diff] [blame] | 388 | qdisc_tree_decrease_qlen(*old, (*old)->q.qlen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | qdisc_reset(*old); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | sch_tree_unlock(sch); |
| 391 | |
| 392 | return 0; |
| 393 | } |
| 394 | |
| 395 | static 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 | |
| 401 | static unsigned long tbf_get(struct Qdisc *sch, u32 classid) |
| 402 | { |
| 403 | return 1; |
| 404 | } |
| 405 | |
| 406 | static void tbf_put(struct Qdisc *sch, unsigned long arg) |
| 407 | { |
| 408 | } |
| 409 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 410 | static 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 Dumazet | 20fea08 | 2007-11-14 01:44:41 -0800 | [diff] [blame] | 422 | static const struct Qdisc_class_ops tbf_class_ops = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 423 | { |
| 424 | .graft = tbf_graft, |
| 425 | .leaf = tbf_leaf, |
| 426 | .get = tbf_get, |
| 427 | .put = tbf_put, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 428 | .walk = tbf_walk, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | .dump = tbf_dump_class, |
| 430 | }; |
| 431 | |
Eric Dumazet | 20fea08 | 2007-11-14 01:44:41 -0800 | [diff] [blame] | 432 | static struct Qdisc_ops tbf_qdisc_ops __read_mostly = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | .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 Poplawski | 77be155 | 2008-10-31 00:47:01 -0700 | [diff] [blame] | 439 | .peek = qdisc_peek_dequeued, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 440 | .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 | |
| 449 | static int __init tbf_module_init(void) |
| 450 | { |
| 451 | return register_qdisc(&tbf_qdisc_ops); |
| 452 | } |
| 453 | |
| 454 | static void __exit tbf_module_exit(void) |
| 455 | { |
| 456 | unregister_qdisc(&tbf_qdisc_ops); |
| 457 | } |
| 458 | module_init(tbf_module_init) |
| 459 | module_exit(tbf_module_exit) |
| 460 | MODULE_LICENSE("GPL"); |