1 /* vi: set sw=4 ts=4: */
3 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
5 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
7 * Bernhard Reutner-Fischer adjusted for busybox
10 //config: bool "tc (3.1 kb)"
13 //config: Show / manipulate traffic control settings
15 //config:config FEATURE_TC_INGRESS
16 //config: bool "Enable ingress"
18 //config: depends on TC
20 //applet:IF_TC(APPLET(tc, BB_DIR_SBIN, BB_SUID_DROP))
22 //kbuild:lib-$(CONFIG_TC) += tc.o
24 //usage:#define tc_trivial_usage
25 /* //usage: "[OPTIONS] OBJECT CMD [dev STRING]" */
26 //usage: "OBJECT CMD [dev STRING]"
27 //usage:#define tc_full_usage "\n\n"
28 //usage: "OBJECT: qdisc|class|filter\n"
29 //usage: "CMD: add|del|change|replace|show\n"
31 //usage: "qdisc [handle QHANDLE] [root|"IF_FEATURE_TC_INGRESS("ingress|")"parent CLASSID]\n"
32 /* //usage: "[estimator INTERVAL TIME_CONSTANT]\n" */
33 //usage: " [[QDISC_KIND] [help|OPTIONS]]\n"
34 //usage: " QDISC_KIND := [p|b]fifo|tbf|prio|cbq|red|etc.\n"
35 //usage: "qdisc show [dev STRING]"IF_FEATURE_TC_INGRESS(" [ingress]")"\n"
36 //usage: "class [classid CLASSID] [root|parent CLASSID]\n"
37 //usage: " [[QDISC_KIND] [help|OPTIONS] ]\n"
38 //usage: "class show [ dev STRING ] [root|parent CLASSID]\n"
39 //usage: "filter [pref PRIO] [protocol PROTO]\n"
40 /* //usage: "\t[estimator INTERVAL TIME_CONSTANT]\n" */
41 //usage: " [root|classid CLASSID] [handle FILTERID]\n"
42 //usage: " [[FILTER_TYPE] [help|OPTIONS]]\n"
43 //usage: "filter show [dev STRING] [root|parent CLASSID]"
46 #include "common_bufsiz.h"
48 #include "libiproute/utils.h"
49 #include "libiproute/ip_common.h"
50 #include "libiproute/rt_names.h"
51 #include <linux/pkt_sched.h> /* for the TC_H_* macros */
53 /* This is the deprecated multiqueue interface */
61 #define TCA_PRIO_MAX (__TCA_PRIO_MAX - 1)
64 #define parse_rtattr_nested(tb, max, rta) \
65 (parse_rtattr((tb), (max), RTA_DATA(rta), RTA_PAYLOAD(rta)))
67 /* nullifies tb on error */
68 #define __parse_rtattr_nested_compat(tb, max, rta, len) \
69 ({if ((RTA_PAYLOAD(rta) >= len) && \
70 (RTA_PAYLOAD(rta) >= RTA_ALIGN(len) + sizeof(struct rtattr))) { \
71 rta = RTA_DATA(rta) + RTA_ALIGN(len); \
72 parse_rtattr_nested(tb, max, rta); \
74 memset(tb, 0, sizeof(struct rtattr *) * (max + 1)); \
77 #define parse_rtattr_nested_compat(tb, max, rta, data, len) \
78 ({data = RTA_PAYLOAD(rta) >= len ? RTA_DATA(rta) : NULL; \
79 __parse_rtattr_nested_compat(tb, max, rta, len); })
81 #define show_details (0) /* not implemented. Does anyone need it? */
82 #define use_iec (0) /* not currently documented in the upstream manpage */
87 uint32_t filter_qdisc;
88 uint32_t filter_parent;
90 uint32_t filter_proto;
92 #define G (*(struct globals*)bb_common_bufsiz1)
93 #define filter_ifindex (G.filter_ifindex)
94 #define filter_qdisc (G.filter_qdisc)
95 #define filter_parent (G.filter_parent)
96 #define filter_prio (G.filter_prio)
97 #define filter_proto (G.filter_proto)
98 #define INIT_G() do { \
99 setup_common_bufsiz(); \
100 BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
103 /* Allocates a buffer containing the name of a class id.
104 * The caller must free the returned memory. */
105 static char* print_tc_classid(uint32_t cid)
107 #if 0 /* IMPOSSIBLE */
108 if (cid == TC_H_ROOT)
109 return xasprintf("root");
112 if (cid == TC_H_UNSPEC)
113 return xasprintf("none");
114 else if (TC_H_MAJ(cid) == 0)
115 return xasprintf(":%x", TC_H_MIN(cid));
116 else if (TC_H_MIN(cid) == 0)
117 return xasprintf("%x:", TC_H_MAJ(cid)>>16);
119 return xasprintf("%x:%x", TC_H_MAJ(cid)>>16, TC_H_MIN(cid));
122 /* Get a qdisc handle. Return 0 on success, !0 otherwise. */
123 static int get_qdisc_handle(uint32_t *h, const char *str) {
128 if (strcmp(str, "none") == 0)
130 maj = strtoul(str, &p, 16);
134 if (*p != ':' && *p != '\0')
141 /* Get class ID. Return 0 on success, !0 otherwise. */
142 static int get_tc_classid(uint32_t *h, const char *str) {
147 if (strcmp(str, "root") == 0)
150 if (strcmp(str, "none") == 0)
152 maj = strtoul(str, &p, 16);
163 min = strtoul(str, &p, 16);
164 //FIXME: check for "" too?
165 if (*p != '\0' || min >= (1<<16))
175 static void print_rate(char *buf, int len, uint32_t rate)
177 double tmp = (double)rate*8;
180 if (tmp >= 1000*1024*1024)
181 snprintf(buf, len, "%.0fMibit", tmp/(1024*1024));
182 else if (tmp >= 1000*1024)
183 snprintf(buf, len, "%.0fKibit", tmp/1024);
185 snprintf(buf, len, "%.0fbit", tmp);
187 if (tmp >= 1000*1000000)
188 snprintf(buf, len, "%.0fMbit", tmp/1000000);
189 else if (tmp >= 1000*1000)
190 snprintf(buf, len, "%.0fKbit", tmp/1000);
192 snprintf(buf, len, "%.0fbit", tmp);
197 /* This is "pfifo_fast". */
198 static int prio_parse_opt(int argc, char **argv, struct nlmsghdr *n)
203 static int prio_print_opt(struct rtattr *opt)
206 struct tc_prio_qopt *qopt;
207 struct rtattr *tb[TCA_PRIO_MAX+1];
211 parse_rtattr_nested_compat(tb, TCA_PRIO_MAX, opt, qopt, sizeof(*qopt));
214 printf("bands %u priomap ", qopt->bands);
215 for (i=0; i<=TC_PRIO_MAX; i++)
216 printf(" %d", qopt->priomap[i]);
219 printf(" multiqueue: o%s ",
220 *(unsigned char *)RTA_DATA(tb[TCA_PRIO_MQ]) ? "n" : "ff");
226 /* Class Based Queue */
227 static int cbq_parse_opt(int argc, char **argv, struct nlmsghdr *n)
232 static int cbq_print_opt(struct rtattr *opt)
234 struct rtattr *tb[TCA_CBQ_MAX+1];
235 struct tc_ratespec *r = NULL;
236 struct tc_cbq_lssopt *lss = NULL;
237 struct tc_cbq_wrropt *wrr = NULL;
238 struct tc_cbq_fopt *fopt = NULL;
239 struct tc_cbq_ovl *ovl = NULL;
240 const char *const error = "CBQ: too short %s opt";
245 parse_rtattr_nested(tb, TCA_CBQ_MAX, opt);
247 if (tb[TCA_CBQ_RATE]) {
248 if (RTA_PAYLOAD(tb[TCA_CBQ_RATE]) < sizeof(*r))
249 bb_error_msg(error, "rate");
251 r = RTA_DATA(tb[TCA_CBQ_RATE]);
253 if (tb[TCA_CBQ_LSSOPT]) {
254 if (RTA_PAYLOAD(tb[TCA_CBQ_LSSOPT]) < sizeof(*lss))
255 bb_error_msg(error, "lss");
257 lss = RTA_DATA(tb[TCA_CBQ_LSSOPT]);
259 if (tb[TCA_CBQ_WRROPT]) {
260 if (RTA_PAYLOAD(tb[TCA_CBQ_WRROPT]) < sizeof(*wrr))
261 bb_error_msg(error, "wrr");
263 wrr = RTA_DATA(tb[TCA_CBQ_WRROPT]);
265 if (tb[TCA_CBQ_FOPT]) {
266 if (RTA_PAYLOAD(tb[TCA_CBQ_FOPT]) < sizeof(*fopt))
267 bb_error_msg(error, "fopt");
269 fopt = RTA_DATA(tb[TCA_CBQ_FOPT]);
271 if (tb[TCA_CBQ_OVL_STRATEGY]) {
272 if (RTA_PAYLOAD(tb[TCA_CBQ_OVL_STRATEGY]) < sizeof(*ovl))
273 bb_error_msg("CBQ: too short overlimit strategy %u/%u",
274 (unsigned) RTA_PAYLOAD(tb[TCA_CBQ_OVL_STRATEGY]),
275 (unsigned) sizeof(*ovl));
277 ovl = RTA_DATA(tb[TCA_CBQ_OVL_STRATEGY]);
281 print_rate(buf, sizeof(buf), r->rate);
282 printf("rate %s ", buf);
284 printf("cell %ub ", 1<<r->cell_log);
286 printf("mpu %ub ", r->mpu);
288 printf("overhead %ub ", r->overhead);
291 if (lss && lss->flags) {
294 if (lss->flags&TCF_CBQ_LSS_BOUNDED) {
298 if (lss->flags&TCF_CBQ_LSS_ISOLATED) {
306 if (wrr->priority != TC_CBQ_MAXPRIO)
307 printf("prio %u", wrr->priority);
309 printf("prio no-transmit");
311 printf("/%u ", wrr->cpriority);
312 if (wrr->weight != 1) {
313 print_rate(buf, sizeof(buf), wrr->weight);
314 printf("weight %s ", buf);
317 printf("allot %ub ", wrr->allot);
324 static FAST_FUNC int print_qdisc(
325 const struct sockaddr_nl *who UNUSED_PARAM,
326 struct nlmsghdr *hdr,
327 void *arg UNUSED_PARAM)
329 struct tcmsg *msg = NLMSG_DATA(hdr);
330 int len = hdr->nlmsg_len;
331 struct rtattr * tb[TCA_MAX+1];
334 if (hdr->nlmsg_type != RTM_NEWQDISC && hdr->nlmsg_type != RTM_DELQDISC) {
335 /* bb_error_msg("not a qdisc"); */
336 return 0; /* ??? mimic upstream; should perhaps return -1 */
338 len -= NLMSG_LENGTH(sizeof(*msg));
340 /* bb_error_msg("wrong len %d", len); */
343 /* not the desired interface? */
344 if (filter_ifindex && filter_ifindex != msg->tcm_ifindex)
346 memset (tb, 0, sizeof(tb));
347 parse_rtattr(tb, TCA_MAX, TCA_RTA(msg), len);
348 if (tb[TCA_KIND] == NULL) {
349 /* bb_error_msg("%s: NULL kind", "qdisc"); */
352 if (hdr->nlmsg_type == RTM_DELQDISC)
354 name = (char*)RTA_DATA(tb[TCA_KIND]);
355 printf("qdisc %s %x: ", name, msg->tcm_handle>>16);
356 if (filter_ifindex == 0)
357 printf("dev %s ", ll_index_to_name(msg->tcm_ifindex));
358 if (msg->tcm_parent == TC_H_ROOT)
360 else if (msg->tcm_parent) {
361 char *classid = print_tc_classid(msg->tcm_parent);
362 printf("parent %s ", classid);
363 if (ENABLE_FEATURE_CLEAN_UP)
366 if (msg->tcm_info != 1)
367 printf("refcnt %d ", msg->tcm_info);
368 if (tb[TCA_OPTIONS]) {
369 static const char _q_[] ALIGN1 = "pfifo_fast\0""cbq\0";
370 int qqq = index_in_strings(_q_, name);
371 if (qqq == 0) { /* pfifo_fast aka prio */
372 prio_print_opt(tb[TCA_OPTIONS]);
373 } else if (qqq == 1) { /* class based queuing */
374 cbq_print_opt(tb[TCA_OPTIONS]);
376 bb_error_msg("unknown %s", name);
382 static FAST_FUNC int print_class(
383 const struct sockaddr_nl *who UNUSED_PARAM,
384 struct nlmsghdr *hdr,
385 void *arg UNUSED_PARAM)
387 struct tcmsg *msg = NLMSG_DATA(hdr);
388 int len = hdr->nlmsg_len;
389 struct rtattr * tb[TCA_MAX+1];
390 char *name, *classid;
392 /*XXX Eventually factor out common code */
394 if (hdr->nlmsg_type != RTM_NEWTCLASS && hdr->nlmsg_type != RTM_DELTCLASS) {
395 /* bb_error_msg("not a class"); */
396 return 0; /* ??? mimic upstream; should perhaps return -1 */
398 len -= NLMSG_LENGTH(sizeof(*msg));
400 /* bb_error_msg("wrong len %d", len); */
403 /* not the desired interface? */
404 if (filter_qdisc && TC_H_MAJ(msg->tcm_handle^filter_qdisc))
406 memset (tb, 0, sizeof(tb));
407 parse_rtattr(tb, TCA_MAX, TCA_RTA(msg), len);
408 if (tb[TCA_KIND] == NULL) {
409 /* bb_error_msg("%s: NULL kind", "class"); */
412 if (hdr->nlmsg_type == RTM_DELTCLASS)
415 name = (char*)RTA_DATA(tb[TCA_KIND]);
416 classid = !msg->tcm_handle ? NULL : print_tc_classid(
417 filter_qdisc ? TC_H_MIN(msg->tcm_parent) : msg->tcm_parent);
418 printf ("class %s %s", name, classid);
419 if (ENABLE_FEATURE_CLEAN_UP)
422 if (filter_ifindex == 0)
423 printf("dev %s ", ll_index_to_name(msg->tcm_ifindex));
424 if (msg->tcm_parent == TC_H_ROOT)
426 else if (msg->tcm_parent) {
427 classid = print_tc_classid(filter_qdisc ?
428 TC_H_MIN(msg->tcm_parent) : msg->tcm_parent);
429 printf("parent %s ", classid);
430 if (ENABLE_FEATURE_CLEAN_UP)
434 printf("leaf %x ", msg->tcm_info >> 16);
435 /* Do that get_qdisc_kind(RTA_DATA(tb[TCA_KIND])). */
436 if (tb[TCA_OPTIONS]) {
437 static const char _q_[] ALIGN1 = "pfifo_fast\0""cbq\0";
438 int qqq = index_in_strings(_q_, name);
439 if (qqq == 0) { /* pfifo_fast aka prio */
440 /* nothing. */ /*prio_print_opt(tb[TCA_OPTIONS]);*/
441 } else if (qqq == 1) { /* class based queuing */
442 /* cbq_print_copt() is identical to cbq_print_opt(). */
443 cbq_print_opt(tb[TCA_OPTIONS]);
445 bb_error_msg("unknown %s", name);
452 static FAST_FUNC int print_filter(
453 const struct sockaddr_nl *who UNUSED_PARAM,
454 struct nlmsghdr *hdr UNUSED_PARAM,
455 void *arg UNUSED_PARAM)
460 int tc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
461 int tc_main(int argc UNUSED_PARAM, char **argv)
463 static const char objects[] ALIGN1 =
464 "qdisc\0""class\0""filter\0"
466 enum { OBJ_qdisc = 0, OBJ_class, OBJ_filter };
467 static const char commands[] ALIGN1 =
468 "add\0""delete\0""change\0"
469 "link\0" /* only qdisc */
474 CMD_add = 0, CMD_del, CMD_change,
479 static const char args[] ALIGN1 =
480 "dev\0" /* qdisc, class, filter */
481 "root\0" /* class, filter */
482 "parent\0" /* class, filter */
483 "qdisc\0" /* class */
484 "handle\0" /* change: qdisc, class(classid) list: filter */
485 "classid\0" /* change: for class use "handle" */
486 "preference\0""priority\0""protocol\0" /* filter */
495 ARG_pref, ARG_prio, ARG_proto
497 struct rtnl_handle rth;
499 int ret, obj, cmd, arg;
509 obj = index_in_substrings(objects, *argv++);
514 cmd = CMD_show; /* list is the default */
516 cmd = index_in_substrings(commands, *argv);
518 invarg_1_to_2(*argv, argv[-1]);
522 memset(&msg, 0, sizeof(msg));
524 msg.tcm_family = AF_UNSPEC;
528 arg = index_in_substrings(args, *argv);
529 if (arg == ARG_dev) {
532 duparg2("dev", *argv);
534 msg.tcm_ifindex = xll_name_to_index(dev);
536 filter_ifindex = msg.tcm_ifindex;
538 if ((arg == ARG_qdisc && obj == OBJ_class && cmd >= CMD_show)
539 || (arg == ARG_handle && obj == OBJ_qdisc && cmd == CMD_change)
542 /* We don't care about duparg2("qdisc handle",*argv) for now */
543 if (get_qdisc_handle(&filter_qdisc, *argv))
544 invarg_1_to_2(*argv, "qdisc");
549 || (obj == OBJ_filter && arg >= ARG_pref)
554 invarg_1_to_2(*argv, "command");
557 if (arg == ARG_root) {
559 duparg("parent", *argv);
560 msg.tcm_parent = TC_H_ROOT;
561 if (obj == OBJ_filter)
562 filter_parent = TC_H_ROOT;
564 if (arg == ARG_parent) {
567 duparg(*argv, "parent");
568 if (get_tc_classid(&handle, *argv))
569 invarg_1_to_2(*argv, "parent");
570 msg.tcm_parent = handle;
571 if (obj == OBJ_filter)
572 filter_parent = handle;
574 if (arg == ARG_handle) { /* filter::list */
576 duparg(*argv, "handle");
577 /* reject LONG_MIN || LONG_MAX */
579 slash = strchr(handle, '/');
583 msg.tcm_handle = get_u32(*argv, "handle");
584 /* if (slash) {if (get_u32(uint32_t &mask, slash+1, NULL)) inv mask; addattr32(n, MAX_MSG, TCA_FW_MASK, mask); */
586 if (arg == ARG_classid
592 if (arg == ARG_pref || arg == ARG_prio) { /* filter::list */
594 duparg(*argv, "priority");
595 filter_prio = get_u32(*argv, "priority");
597 if (arg == ARG_proto) { /* filter::list */
600 duparg(*argv, "protocol");
601 if (ll_proto_a2n(&tmp, *argv))
602 invarg_1_to_2(*argv, "protocol");
607 if (cmd >= CMD_show) { /* show or list */
608 if (obj == OBJ_filter)
609 msg.tcm_info = TC_H_MAKE(filter_prio<<16, filter_proto);
610 if (rtnl_dump_request(&rth, obj == OBJ_qdisc ? RTM_GETQDISC :
611 obj == OBJ_class ? RTM_GETTCLASS : RTM_GETTFILTER,
612 &msg, sizeof(msg)) < 0)
613 bb_simple_perror_msg_and_die("can't send dump request");
615 xrtnl_dump_filter(&rth, obj == OBJ_qdisc ? print_qdisc :
616 obj == OBJ_class ? print_class : print_filter,
619 if (ENABLE_FEATURE_CLEAN_UP) {