2 * lib/route/sch/htb.c HTB Qdisc
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation version 2.1
9 * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
10 * Copyright (c) 2005-2006 Petr Gotthard <petr.gotthard@siemens.com>
11 * Copyright (c) 2005-2006 Siemens AG Oesterreich
17 * @defgroup htb Hierachical Token Bucket (HTB)
21 #include <netlink-local.h>
22 #include <netlink-tc.h>
23 #include <netlink/netlink.h>
24 #include <netlink/cache.h>
25 #include <netlink/utils.h>
26 #include <netlink/route/tc.h>
27 #include <netlink/route/qdisc.h>
28 #include <netlink/route/qdisc-modules.h>
29 #include <netlink/route/class.h>
30 #include <netlink/route/class-modules.h>
31 #include <netlink/route/link.h>
32 #include <netlink/route/sch/htb.h>
35 #define SCH_HTB_HAS_RATE2QUANTUM 0x01
36 #define SCH_HTB_HAS_DEFCLS 0x02
38 #define SCH_HTB_HAS_PRIO 0x001
39 #define SCH_HTB_HAS_MTU 0x002
40 #define SCH_HTB_HAS_RATE 0x004
41 #define SCH_HTB_HAS_CEIL 0x008
42 #define SCH_HTB_HAS_RBUFFER 0x010
43 #define SCH_HTB_HAS_CBUFFER 0x020
44 #define SCH_HTB_HAS_QUANTUM 0x040
45 #define SCH_HTB_HAS_OVERHEAD 0x080
46 #define SCH_HTB_HAS_MPU 0x100
49 static inline struct rtnl_htb_qdisc *htb_qdisc(struct rtnl_qdisc *qdisc)
51 if (qdisc->q_subdata == NULL)
52 qdisc->q_subdata = calloc(1, sizeof(struct rtnl_htb_qdisc));
54 return (struct rtnl_htb_qdisc *) qdisc->q_subdata;
57 static struct nla_policy htb_policy[TCA_HTB_MAX+1] = {
58 [TCA_HTB_INIT] = { .minlen = sizeof(struct tc_htb_glob) },
59 [TCA_HTB_PARMS] = { .minlen = sizeof(struct tc_htb_opt) },
62 static int htb_qdisc_msg_parser(struct rtnl_qdisc *qdisc)
65 struct nlattr *tb[TCA_HTB_MAX + 1];
66 struct rtnl_htb_qdisc *d;
68 err = tca_parse(tb, TCA_HTB_MAX, (struct rtnl_tca *) qdisc, htb_policy);
74 if (tb[TCA_HTB_INIT]) {
75 struct tc_htb_glob opts;
77 nla_memcpy(&opts, tb[TCA_HTB_INIT], sizeof(opts));
78 d->qh_rate2quantum = opts.rate2quantum;
79 d->qh_defcls = opts.defcls;
81 d->qh_mask = (SCH_HTB_HAS_RATE2QUANTUM | SCH_HTB_HAS_DEFCLS);
87 static void htb_qdisc_free_data(struct rtnl_qdisc *qdisc)
89 free(qdisc->q_subdata);
92 static inline struct rtnl_htb_class *htb_class(struct rtnl_class *class)
94 if (class->c_subdata == NULL)
95 class->c_subdata = calloc(1, sizeof(struct rtnl_htb_class));
97 return (struct rtnl_htb_class *) class->c_subdata;
100 static int htb_class_msg_parser(struct rtnl_class *class)
103 struct nlattr *tb[TCA_HTB_MAX + 1];
104 struct rtnl_htb_class *d;
106 err = tca_parse(tb, TCA_HTB_MAX, (struct rtnl_tca *) class, htb_policy);
110 d = htb_class(class);
112 if (tb[TCA_HTB_PARMS]) {
113 struct tc_htb_opt opts;
115 nla_memcpy(&opts, tb[TCA_HTB_PARMS], sizeof(opts));
116 d->ch_prio = opts.prio;
117 rtnl_copy_ratespec(&d->ch_rate, &opts.rate);
118 rtnl_copy_ratespec(&d->ch_ceil, &opts.ceil);
119 d->ch_rbuffer = rtnl_tc_calc_bufsize(opts.buffer, opts.rate.rate);
120 d->ch_cbuffer = rtnl_tc_calc_bufsize(opts.cbuffer, opts.ceil.rate);
121 d->ch_quantum = opts.quantum;
122 d->ch_overhead = (opts.rate.mpu >> 8) & 0xff;
123 d->ch_mpu = opts.rate.mpu & 0xff;
125 d->ch_mask = (SCH_HTB_HAS_PRIO | SCH_HTB_HAS_RATE |
126 SCH_HTB_HAS_CEIL | SCH_HTB_HAS_RBUFFER |
127 SCH_HTB_HAS_CBUFFER | SCH_HTB_HAS_QUANTUM |
128 SCH_HTB_HAS_OVERHEAD | SCH_HTB_HAS_MPU);
134 static void htb_class_free_data(struct rtnl_class *class)
136 free(class->c_subdata);
139 static void htb_qdisc_dump_line(struct rtnl_qdisc *qdisc,
140 struct nl_dump_params *p)
142 struct rtnl_htb_qdisc *d = (struct rtnl_htb_qdisc *) qdisc->q_subdata;
147 if (d->qh_mask & SCH_HTB_HAS_RATE2QUANTUM)
148 nl_dump(p, " r2q %u", d->qh_rate2quantum);
150 if (d->qh_mask & SCH_HTB_HAS_DEFCLS) {
152 nl_dump(p, " default %s",
153 rtnl_tc_handle2str(d->qh_defcls, buf, sizeof(buf)));
157 static void htb_class_dump_line(struct rtnl_class *class,
158 struct nl_dump_params *p)
160 struct rtnl_htb_class *d = (struct rtnl_htb_class *) class->c_subdata;
165 if (d->ch_mask & SCH_HTB_HAS_RATE) {
169 r = nl_cancel_down_bytes(d->ch_rate.rs_rate, &ru);
170 rbit = nl_cancel_down_bits(d->ch_rate.rs_rate*8, &rubit);
172 nl_dump(p, " rate %.2f%s/s (%.0f%s) log %u",
173 r, ru, rbit, rubit, 1<<d->ch_rate.rs_cell_log);
177 static void htb_class_dump_details(struct rtnl_class *class,
178 struct nl_dump_params *p)
180 struct rtnl_htb_class *d = (struct rtnl_htb_class *) class->c_subdata;
186 if (d->ch_mask & SCH_HTB_HAS_CEIL) {
190 r = nl_cancel_down_bytes(d->ch_ceil.rs_rate, &ru);
191 rbit = nl_cancel_down_bits(d->ch_ceil.rs_rate*8, &rubit);
193 nl_dump(p, " ceil %.2f%s/s (%.0f%s) log %u",
194 r, ru, rbit, rubit, 1<<d->ch_ceil.rs_cell_log);
197 if (d->ch_mask & SCH_HTB_HAS_PRIO)
198 nl_dump(p, " prio %u", d->ch_prio);
200 if (d->ch_mask & SCH_HTB_HAS_MTU)
201 nl_dump(p, " mtu %u", d->ch_mtu);
203 if (d->ch_mask & SCH_HTB_HAS_RBUFFER) {
207 b = nl_cancel_down_bytes(d->ch_rbuffer, &bu);
208 nl_dump(p, " rbuffer %.2f%s", b, bu);
211 if (d->ch_mask & SCH_HTB_HAS_CBUFFER) {
215 b = nl_cancel_down_bytes(d->ch_cbuffer, &bu);
216 nl_dump(p, " cbuffer %.2f%s", b, bu);
219 if (d->ch_mask & SCH_HTB_HAS_QUANTUM)
220 nl_dump(p, " quantum %u", d->ch_quantum);
222 if (d->ch_mask & SCH_HTB_HAS_OVERHEAD)
223 nl_dump(p, " overhead %u", d->ch_overhead);
225 if (d->ch_mask & SCH_HTB_HAS_MPU)
226 nl_dump(p, " mpu %u", d->ch_mpu);
229 static struct nl_msg *htb_qdisc_get_opts(struct rtnl_qdisc *qdisc)
231 struct rtnl_htb_qdisc *d = (struct rtnl_htb_qdisc *) qdisc->q_subdata;
232 struct tc_htb_glob opts;
242 memset(&opts, 0, sizeof(opts));
243 opts.version = TC_HTB_PROTOVER;
245 if (d->qh_mask & SCH_HTB_HAS_RATE2QUANTUM)
246 opts.rate2quantum = d->qh_rate2quantum;
247 if (d->qh_mask & SCH_HTB_HAS_DEFCLS)
248 opts.defcls = d->qh_defcls;
250 nla_put(msg, TCA_HTB_INIT, sizeof(opts), &opts);
255 static uint8_t compute_cell(uint32_t rate, uint32_t mtu)
257 uint8_t cell_log = 0;
266 static struct nl_msg *htb_class_get_opts(struct rtnl_class *class)
268 struct rtnl_htb_class *d = (struct rtnl_htb_class *) class->c_subdata;
269 uint32_t mtu, rtable[RTNL_TC_RTABLE_SIZE], ctable[RTNL_TC_RTABLE_SIZE];
270 struct tc_htb_opt opts;
273 uint8_t overhead = 0, mpu = 0;
279 memset(&opts, 0, sizeof(opts));
281 /* if not set, zero (0) is used as priority */
282 if (d->ch_mask & SCH_HTB_HAS_PRIO)
283 opts.prio = d->ch_prio;
285 if (d->ch_mask & SCH_HTB_HAS_MTU)
288 mtu = 1600; /* eth packet len */
290 if (!(d->ch_mask & SCH_HTB_HAS_RATE))
293 rtnl_rcopy_ratespec(&opts.rate, &d->ch_rate);
294 /* if cell_log not set, compute default value */
295 if (opts.rate.cell_log == UINT8_MAX)
296 opts.rate.cell_log = compute_cell(opts.rate.rate, mtu);
298 /* if not set, configured rate is used as ceil, which implies no borrowing */
299 if (d->ch_mask & SCH_HTB_HAS_CEIL)
300 rtnl_rcopy_ratespec(&opts.ceil, &d->ch_ceil);
302 memcpy(&opts.ceil, &opts.rate, sizeof(struct tc_ratespec));
303 /* if cell_log not set, compute default value */
304 if (opts.ceil.cell_log == UINT8_MAX)
305 opts.ceil.cell_log = compute_cell(opts.ceil.rate, mtu);
307 if (d->ch_mask & SCH_HTB_HAS_RBUFFER)
308 buffer = d->ch_rbuffer;
310 buffer = opts.rate.rate / nl_get_hz() + mtu;
312 opts.buffer = rtnl_tc_calc_txtime(buffer, opts.rate.rate);
314 if (d->ch_mask & SCH_HTB_HAS_CBUFFER)
315 cbuffer = d->ch_cbuffer;
317 cbuffer = opts.ceil.rate / nl_get_hz() + mtu;
319 opts.cbuffer = rtnl_tc_calc_txtime(cbuffer, opts.ceil.rate);
321 if (d->ch_mask & SCH_HTB_HAS_QUANTUM)
322 opts.quantum = d->ch_quantum;
324 if (d->ch_mask & SCH_HTB_HAS_OVERHEAD)
325 overhead = d->ch_overhead;
327 if (d->ch_mask & SCH_HTB_HAS_MPU)
330 opts.rate.mpu = mpu | (overhead << 8);
331 opts.ceil.mpu = mpu | (overhead << 8);
333 nla_put(msg, TCA_HTB_PARMS, sizeof(opts), &opts);
335 rtnl_tc_build_rate_table(rtable, mpu, overhead,
336 1 << opts.rate.cell_log,
338 nla_put(msg, TCA_HTB_RTAB, sizeof(rtable), &rtable);
340 rtnl_tc_build_rate_table(ctable, mpu, overhead,
341 1 << opts.ceil.cell_log,
343 nla_put(msg, TCA_HTB_CTAB, sizeof(ctable), &ctable);
349 * @name Attribute Modifications
353 void rtnl_htb_set_rate2quantum(struct rtnl_qdisc *qdisc, uint32_t rate2quantum)
355 struct rtnl_htb_qdisc *d = htb_qdisc(qdisc);
359 d->qh_rate2quantum = rate2quantum;
360 d->qh_mask |= SCH_HTB_HAS_RATE2QUANTUM;
364 * Set default class of the htb qdisc to the specified value
365 * @arg qdisc qdisc to change
366 * @arg defcls new default class
368 void rtnl_htb_set_defcls(struct rtnl_qdisc *qdisc, uint32_t defcls)
370 struct rtnl_htb_qdisc *d = htb_qdisc(qdisc);
374 d->qh_defcls = defcls;
375 d->qh_mask |= SCH_HTB_HAS_DEFCLS;
378 void rtnl_htb_set_prio(struct rtnl_class *class, uint32_t prio)
380 struct rtnl_htb_class *d = htb_class(class);
385 d->ch_mask |= SCH_HTB_HAS_PRIO;
389 * Set MTU of the data link.
390 * @arg class HTB class to be modified.
391 * @arg mtu New MTU in bytes.
393 * Sets MTU of the data link controlled by the HTB class.
394 * If not set, the Ethernet MTU (1600) is used.
396 void rtnl_htb_set_mtu(struct rtnl_class *class, uint32_t mtu)
398 struct rtnl_htb_class *d = htb_class(class);
403 d->ch_mask |= SCH_HTB_HAS_MTU;
407 * Set rate of HTB class.
408 * @arg class HTB class to be modified.
409 * @arg rate New rate in bytes per second.
411 void rtnl_htb_set_rate(struct rtnl_class *class, uint32_t rate)
413 struct rtnl_htb_class *d = htb_class(class);
417 d->ch_rate.rs_cell_log = UINT8_MAX; /* use default value */
418 d->ch_rate.rs_rate = rate;
419 d->ch_mask |= SCH_HTB_HAS_RATE;
423 * Set ceil of HTB class.
424 * @arg class HTB class to be modified.
425 * @arg ceil New ceil in bytes per second.
427 void rtnl_htb_set_ceil(struct rtnl_class *class, uint32_t ceil)
429 struct rtnl_htb_class *d = htb_class(class);
433 d->ch_ceil.rs_cell_log = UINT8_MAX; /* use default value */
434 d->ch_ceil.rs_rate = ceil;
435 d->ch_mask |= SCH_HTB_HAS_CEIL;
439 * Set size of the rate bucket of HTB class.
440 * @arg class HTB class to be modified.
441 * @arg rbuffer New size in bytes.
443 void rtnl_htb_set_rbuffer(struct rtnl_class *class, uint32_t rbuffer)
445 struct rtnl_htb_class *d = htb_class(class);
449 d->ch_rbuffer = rbuffer;
450 d->ch_mask |= SCH_HTB_HAS_RBUFFER;
454 * Set size of the ceil bucket of HTB class.
455 * @arg class HTB class to be modified.
456 * @arg cbuffer New size in bytes.
458 void rtnl_htb_set_cbuffer(struct rtnl_class *class, uint32_t cbuffer)
460 struct rtnl_htb_class *d = htb_class(class);
464 d->ch_cbuffer = cbuffer;
465 d->ch_mask |= SCH_HTB_HAS_CBUFFER;
469 * Set how much bytes to serve from leaf at once of HTB class {use r2q}.
470 * @arg class HTB class to be modified.
471 * @arg quantum New size in bytes.
473 void rtnl_htb_set_quantum(struct rtnl_class *class, uint32_t quantum)
475 struct rtnl_htb_class *d = htb_class(class);
479 d->ch_quantum = quantum;
480 d->ch_mask |= SCH_HTB_HAS_QUANTUM;
484 * Set per-packet size overhead used in rate computations of HTB class.
485 * @arg class HTB class to be modified.
486 * @arg overhead Size in bytes.
488 void rtnl_htb_set_overhead(struct rtnl_class *class, uint8_t overhead)
490 struct rtnl_htb_class *d = htb_class(class);
494 d->ch_overhead = overhead;
495 d->ch_mask |= SCH_HTB_HAS_OVERHEAD;
499 * Set the minimum packet size used in rate computations of HTB class.
500 * @arg class HTB class to be modified.
501 * @arg mpu Size in bytes.
503 void rtnl_htb_set_mpu(struct rtnl_class *class, uint8_t mpu)
505 struct rtnl_htb_class *d = htb_class(class);
510 d->ch_mask |= SCH_HTB_HAS_MPU;
515 static struct rtnl_qdisc_ops htb_qdisc_ops = {
517 .qo_msg_parser = htb_qdisc_msg_parser,
518 .qo_free_data = htb_qdisc_free_data,
519 .qo_dump[NL_DUMP_LINE] = htb_qdisc_dump_line,
520 .qo_get_opts = htb_qdisc_get_opts,
523 static struct rtnl_class_ops htb_class_ops = {
525 .co_msg_parser = htb_class_msg_parser,
526 .co_free_data = htb_class_free_data,
528 [NL_DUMP_LINE] = htb_class_dump_line,
529 [NL_DUMP_DETAILS] = htb_class_dump_details,
531 .co_get_opts = htb_class_get_opts,
534 static void __init htb_init(void)
536 rtnl_qdisc_register(&htb_qdisc_ops);
537 rtnl_class_register(&htb_class_ops);
540 static void __exit htb_exit(void)
542 rtnl_qdisc_unregister(&htb_qdisc_ops);
543 rtnl_class_unregister(&htb_class_ops);