[mirror_iproute2.git] / tc / q_mqprio.c

/*
 * q_mqprio.c	MQ prio qdisc
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 * Author:	John Fastabend, <john.r.fastabend@intel.com>
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

#include "utils.h"
#include "tc_util.h"

static void explain(void)
{
	fprintf(stderr, "Usage: ... mqprio [num_tc NUMBER] [map P0 P1 ...]\n");
	fprintf(stderr, "                  [queues count1@offset1 count2@offset2 ...] ");
	fprintf(stderr, "[hw 1|0]\n");
	fprintf(stderr, "                  [mode dcb|channel]\n");
	fprintf(stderr, "                  [shaper bw_rlimit SHAPER_PARAMS]\n"
		"Where: SHAPER_PARAMS := { min_rate MIN_RATE1 MIN_RATE2 ...|\n"
		"                          max_rate MAX_RATE1 MAX_RATE2 ... }\n");
}

static int mqprio_parse_opt(struct qdisc_util *qu, int argc,
			    char **argv, struct nlmsghdr *n, const char *dev)
{
	int idx;
	struct tc_mqprio_qopt opt = {
		.num_tc = 8,
		.prio_tc_map = { 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 1, 1, 3, 3, 3, 3 },
		.hw = 1,
		.count = { },
		.offset = { },
	};
	__u64 min_rate64[TC_QOPT_MAX_QUEUE] = {0};
	__u64 max_rate64[TC_QOPT_MAX_QUEUE] = {0};
	__u16 shaper = TC_MQPRIO_SHAPER_DCB;
	__u16 mode = TC_MQPRIO_MODE_DCB;
	struct rtattr *tail;
	__u32 flags = 0;

	while (argc > 0) {
		idx = 0;
		if (strcmp(*argv, "num_tc") == 0) {
			NEXT_ARG();
			if (get_u8(&opt.num_tc, *argv, 10)) {
				fprintf(stderr, "Illegal \"num_tc\"\n");
				return -1;
			}
		} else if (strcmp(*argv, "map") == 0) {
			while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
				NEXT_ARG();
				if (get_u8(&opt.prio_tc_map[idx], *argv, 10)) {
					PREV_ARG();
					break;
				}
				idx++;
			}
			for ( ; idx < TC_QOPT_MAX_QUEUE; idx++)
				opt.prio_tc_map[idx] = 0;
		} else if (strcmp(*argv, "queues") == 0) {
			char *tmp, *tok;

			while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
				NEXT_ARG();

				tmp = strdup(*argv);
				if (!tmp)
					break;

				tok = strtok(tmp, "@");
				if (get_u16(&opt.count[idx], tok, 10)) {
					free(tmp);
					PREV_ARG();
					break;
				}
				tok = strtok(NULL, "@");
				if (get_u16(&opt.offset[idx], tok, 10)) {
					free(tmp);
					PREV_ARG();
					break;
				}
				free(tmp);
				idx++;
			}
		} else if (strcmp(*argv, "hw") == 0) {
			NEXT_ARG();
			if (get_u8(&opt.hw, *argv, 10)) {
				fprintf(stderr, "Illegal \"hw\"\n");
				return -1;
			}
			idx++;
		} else if (opt.hw && strcmp(*argv, "mode") == 0) {
			NEXT_ARG();
			if (matches(*argv, "dcb") == 0) {
				mode = TC_MQPRIO_MODE_DCB;
			} else if (matches(*argv, "channel") == 0) {
				mode = TC_MQPRIO_MODE_CHANNEL;
			}  else {
				fprintf(stderr, "Illegal mode (%s)\n",
					*argv);
				return -1;
			}
			if (mode != TC_MQPRIO_MODE_DCB)
				flags |= TC_MQPRIO_F_MODE;
			idx++;
		} else if (opt.hw && strcmp(*argv, "shaper") == 0) {
			NEXT_ARG();
			if (matches(*argv, "dcb") == 0) {
				shaper = TC_MQPRIO_SHAPER_DCB;
			} else if (matches(*argv, "bw_rlimit") == 0) {
				shaper = TC_MQPRIO_SHAPER_BW_RATE;
				if (!NEXT_ARG_OK()) {
					fprintf(stderr, "Incomplete shaper arguments\n");
					return -1;
				}
			}  else {
				fprintf(stderr, "Illegal shaper (%s)\n",
					*argv);
				return -1;
			}
			if (shaper != TC_MQPRIO_SHAPER_DCB)
				flags |= TC_MQPRIO_F_SHAPER;
			idx++;
		} else if ((shaper == TC_MQPRIO_SHAPER_BW_RATE) &&
			   strcmp(*argv, "min_rate") == 0) {
			while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
				NEXT_ARG();
				if (get_rate64(&min_rate64[idx], *argv)) {
					PREV_ARG();
					break;
				}
				idx++;
			}
			if (idx < opt.num_tc && !NEXT_ARG_OK()) {
				fprintf(stderr, "Incomplete arguments, min_rate values expected\n");
				return -1;
			}
			flags |= TC_MQPRIO_F_MIN_RATE;
		} else if ((shaper == TC_MQPRIO_SHAPER_BW_RATE) &&
			   strcmp(*argv, "max_rate") == 0) {
			while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
				NEXT_ARG();
				if (get_rate64(&max_rate64[idx], *argv)) {
					PREV_ARG();
					break;
				}
				idx++;
			}
			if (idx < opt.num_tc && !NEXT_ARG_OK()) {
				fprintf(stderr, "Incomplete arguments, max_rate values expected\n");
				return -1;
			}
			flags |= TC_MQPRIO_F_MAX_RATE;
		} else if (strcmp(*argv, "help") == 0) {
			explain();
			return -1;
		} else {
			fprintf(stderr, "Unknown argument\n");
			return -1;
		}
		argc--; argv++;
	}

	tail = NLMSG_TAIL(n);
	addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));

	if (flags & TC_MQPRIO_F_MODE)
		addattr_l(n, 1024, TCA_MQPRIO_MODE,
			  &mode, sizeof(mode));
	if (flags & TC_MQPRIO_F_SHAPER)
		addattr_l(n, 1024, TCA_MQPRIO_SHAPER,
			  &shaper, sizeof(shaper));

	if (flags & TC_MQPRIO_F_MIN_RATE) {
		struct rtattr *start;

		start = addattr_nest(n, 1024,
				     TCA_MQPRIO_MIN_RATE64 | NLA_F_NESTED);

		for (idx = 0; idx < TC_QOPT_MAX_QUEUE; idx++)
			addattr_l(n, 1024, TCA_MQPRIO_MIN_RATE64,
				  &min_rate64[idx], sizeof(min_rate64[idx]));

		addattr_nest_end(n, start);
	}

	if (flags & TC_MQPRIO_F_MAX_RATE) {
		struct rtattr *start;

		start = addattr_nest(n, 1024,
				     TCA_MQPRIO_MAX_RATE64 | NLA_F_NESTED);

		for (idx = 0; idx < TC_QOPT_MAX_QUEUE; idx++)
			addattr_l(n, 1024, TCA_MQPRIO_MAX_RATE64,
				  &max_rate64[idx], sizeof(max_rate64[idx]));

		addattr_nest_end(n, start);
	}

	tail->rta_len = (void *)NLMSG_TAIL(n) - (void *)tail;

	return 0;
}

static int mqprio_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
{
	int i;
	struct tc_mqprio_qopt *qopt;
	__u64 min_rate64[TC_QOPT_MAX_QUEUE] = {0};
	__u64 max_rate64[TC_QOPT_MAX_QUEUE] = {0};
	int len;

	SPRINT_BUF(b1);

	if (opt == NULL)
		return 0;

	len = RTA_PAYLOAD(opt) - RTA_ALIGN(sizeof(*qopt));
	if (len < 0) {
		fprintf(stderr, "options size error\n");
		return -1;
	}

	qopt = RTA_DATA(opt);

	fprintf(f, " tc %u map ", qopt->num_tc);
	for (i = 0; i <= TC_PRIO_MAX; i++)
		fprintf(f, "%u ", qopt->prio_tc_map[i]);
	fprintf(f, "\n             queues:");
	for (i = 0; i < qopt->num_tc; i++)
		fprintf(f, "(%u:%u) ", qopt->offset[i],
			qopt->offset[i] + qopt->count[i] - 1);

	if (len > 0) {
		struct rtattr *tb[TCA_MQPRIO_MAX + 1];

		parse_rtattr(tb, TCA_MQPRIO_MAX,
			     RTA_DATA(opt) + RTA_ALIGN(sizeof(*qopt)),
			     len);

		if (tb[TCA_MQPRIO_MODE]) {
			__u16 *mode = RTA_DATA(tb[TCA_MQPRIO_MODE]);

			if (*mode == TC_MQPRIO_MODE_CHANNEL)
				fprintf(f, "\n             mode:channel");
		} else {
			fprintf(f, "\n             mode:dcb");
		}

		if (tb[TCA_MQPRIO_SHAPER]) {
			__u16 *shaper = RTA_DATA(tb[TCA_MQPRIO_SHAPER]);

			if (*shaper == TC_MQPRIO_SHAPER_BW_RATE)
				fprintf(f, "\n             shaper:bw_rlimit");
		} else {
			fprintf(f, "\n             shaper:dcb");
		}

		if (tb[TCA_MQPRIO_MIN_RATE64]) {
			struct rtattr *r;
			int rem = RTA_PAYLOAD(tb[TCA_MQPRIO_MIN_RATE64]);
			__u64 *min = min_rate64;

			for (r = RTA_DATA(tb[TCA_MQPRIO_MIN_RATE64]);
			     RTA_OK(r, rem); r = RTA_NEXT(r, rem)) {
				if (r->rta_type != TCA_MQPRIO_MIN_RATE64)
					return -1;
				*(min++) = rta_getattr_u64(r);
			}
			fprintf(f, "	min_rate:");
			for (i = 0; i < qopt->num_tc; i++)
				fprintf(f, "%s ", sprint_rate(min_rate64[i], b1));
		}

		if (tb[TCA_MQPRIO_MAX_RATE64]) {
			struct rtattr *r;
			int rem = RTA_PAYLOAD(tb[TCA_MQPRIO_MAX_RATE64]);
			__u64 *max = max_rate64;

			for (r = RTA_DATA(tb[TCA_MQPRIO_MAX_RATE64]);
			     RTA_OK(r, rem); r = RTA_NEXT(r, rem)) {
				if (r->rta_type != TCA_MQPRIO_MAX_RATE64)
					return -1;
				*(max++) = rta_getattr_u64(r);
			}
			fprintf(f, "	max_rate:");
			for (i = 0; i < qopt->num_tc; i++)
				fprintf(f, "%s ", sprint_rate(max_rate64[i], b1));
		}
	}
	return 0;
}

struct qdisc_util mqprio_qdisc_util = {
	.id		= "mqprio",
	.parse_qopt	= mqprio_parse_opt,
	.print_qopt	= mqprio_print_opt,
};
Commit	Line	Data
91495304 JF	1	/*
	2	* q_mqprio.c MQ prio qdisc
	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	* Author: John Fastabend, <john.r.fastabend@intel.com>
	10	*/
	11
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <unistd.h>
91495304 JF	15	#include <fcntl.h>
	16	#include <sys/socket.h>
	17	#include <netinet/in.h>
	18	#include <arpa/inet.h>
	19	#include <string.h>
	20
	21	#include "utils.h"
	22	#include "tc_util.h"
	23
	24	static void explain(void)
	25	{
	26	fprintf(stderr, "Usage: ... mqprio [num_tc NUMBER] [map P0 P1 ...]\n");
892eba30 JF	27	fprintf(stderr, " [queues count1@offset1 count2@offset2 ...] ");
892eba30 JF	28	fprintf(stderr, "[hw 1\|0]\n");
e1ac5b06 AN	29	fprintf(stderr, " [mode dcb\|channel]\n");
	30	fprintf(stderr, " [shaper bw_rlimit SHAPER_PARAMS]\n"
	31	"Where: SHAPER_PARAMS := { min_rate MIN_RATE1 MIN_RATE2 ...\|\n"
	32	" max_rate MAX_RATE1 MAX_RATE2 ... }\n");
91495304 JF	33	}
	34
	35	static int mqprio_parse_opt(struct qdisc_util *qu, int argc,
927e3cfb	36	char *argv, struct nlmsghdr n, const char *dev)
91495304 JF	37	{
	38	int idx;
	39	struct tc_mqprio_qopt opt = {
c4fc474b SH	40	.num_tc = 8,
	41	.prio_tc_map = { 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 1, 1, 3, 3, 3, 3 },
	42	.hw = 1,
	43	.count = { },
	44	.offset = { },
	45	};
e1ac5b06 AN	46	__u64 min_rate64[TC_QOPT_MAX_QUEUE] = {0};
	47	__u64 max_rate64[TC_QOPT_MAX_QUEUE] = {0};
	48	__u16 shaper = TC_MQPRIO_SHAPER_DCB;
	49	__u16 mode = TC_MQPRIO_MODE_DCB;
	50	struct rtattr *tail;
	51	__u32 flags = 0;
91495304 JF	52
	53	while (argc > 0) {
	54	idx = 0;
	55	if (strcmp(*argv, "num_tc") == 0) {
	56	NEXT_ARG();
	57	if (get_u8(&opt.num_tc, *argv, 10)) {
	58	fprintf(stderr, "Illegal \"num_tc\"\n");
	59	return -1;
	60	}
	61	} else if (strcmp(*argv, "map") == 0) {
	62	while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
	63	NEXT_ARG();
	64	if (get_u8(&opt.prio_tc_map[idx], *argv, 10)) {
	65	PREV_ARG();
	66	break;
	67	}
	68	idx++;
	69	}
	70	for ( ; idx < TC_QOPT_MAX_QUEUE; idx++)
	71	opt.prio_tc_map[idx] = 0;
892eba30 JF	72	} else if (strcmp(*argv, "queues") == 0) {
	73	char tmp, tok;
	74
91495304 JF	75	while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
91495304 JF	76	NEXT_ARG();
892eba30 JF	77
	78	tmp = strdup(*argv);
	79	if (!tmp)
	80	break;
	81
	82	tok = strtok(tmp, "@");
	83	if (get_u16(&opt.count[idx], tok, 10)) {
	84	free(tmp);
91495304 JF	85	PREV_ARG();
	86	break;
	87	}
892eba30 JF	88	tok = strtok(NULL, "@");
	89	if (get_u16(&opt.offset[idx], tok, 10)) {
	90	free(tmp);
91495304 JF	91	PREV_ARG();
	92	break;
	93	}
892eba30	94	free(tmp);
91495304 JF	95	idx++;
	96	}
	97	} else if (strcmp(*argv, "hw") == 0) {
	98	NEXT_ARG();
	99	if (get_u8(&opt.hw, *argv, 10)) {
	100	fprintf(stderr, "Illegal \"hw\"\n");
	101	return -1;
	102	}
	103	idx++;
e1ac5b06 AN	104	} else if (opt.hw && strcmp(*argv, "mode") == 0) {
	105	NEXT_ARG();
	106	if (matches(*argv, "dcb") == 0) {
	107	mode = TC_MQPRIO_MODE_DCB;
	108	} else if (matches(*argv, "channel") == 0) {
	109	mode = TC_MQPRIO_MODE_CHANNEL;
	110	} else {
	111	fprintf(stderr, "Illegal mode (%s)\n",
	112	*argv);
	113	return -1;
	114	}
	115	if (mode != TC_MQPRIO_MODE_DCB)
	116	flags \|= TC_MQPRIO_F_MODE;
	117	idx++;
	118	} else if (opt.hw && strcmp(*argv, "shaper") == 0) {
	119	NEXT_ARG();
	120	if (matches(*argv, "dcb") == 0) {
	121	shaper = TC_MQPRIO_SHAPER_DCB;
	122	} else if (matches(*argv, "bw_rlimit") == 0) {
	123	shaper = TC_MQPRIO_SHAPER_BW_RATE;
	124	if (!NEXT_ARG_OK()) {
	125	fprintf(stderr, "Incomplete shaper arguments\n");
	126	return -1;
	127	}
	128	} else {
	129	fprintf(stderr, "Illegal shaper (%s)\n",
	130	*argv);
	131	return -1;
	132	}
	133	if (shaper != TC_MQPRIO_SHAPER_DCB)
	134	flags \|= TC_MQPRIO_F_SHAPER;
	135	idx++;
	136	} else if ((shaper == TC_MQPRIO_SHAPER_BW_RATE) &&
	137	strcmp(*argv, "min_rate") == 0) {
	138	while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
	139	NEXT_ARG();
	140	if (get_rate64(&min_rate64[idx], *argv)) {
	141	PREV_ARG();
	142	break;
	143	}
	144	idx++;
	145	}
	146	if (idx < opt.num_tc && !NEXT_ARG_OK()) {
	147	fprintf(stderr, "Incomplete arguments, min_rate values expected\n");
	148	return -1;
	149	}
	150	flags \|= TC_MQPRIO_F_MIN_RATE;
	151	} else if ((shaper == TC_MQPRIO_SHAPER_BW_RATE) &&
	152	strcmp(*argv, "max_rate") == 0) {
	153	while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
	154	NEXT_ARG();
	155	if (get_rate64(&max_rate64[idx], *argv)) {
	156	PREV_ARG();
	157	break;
	158	}
	159	idx++;
	160	}
	161	if (idx < opt.num_tc && !NEXT_ARG_OK()) {
	162	fprintf(stderr, "Incomplete arguments, max_rate values expected\n");
	163	return -1;
	164	}
	165	flags \|= TC_MQPRIO_F_MAX_RATE;
91495304 JF	166	} else if (strcmp(*argv, "help") == 0) {
	167	explain();
	168	return -1;
	169	} else {
	170	fprintf(stderr, "Unknown argument\n");
	171	return -1;
	172	}
	173	argc--; argv++;
	174	}
	175
e1ac5b06	176	tail = NLMSG_TAIL(n);
91495304	177	addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
e1ac5b06 AN	178
	179	if (flags & TC_MQPRIO_F_MODE)
	180	addattr_l(n, 1024, TCA_MQPRIO_MODE,
	181	&mode, sizeof(mode));
	182	if (flags & TC_MQPRIO_F_SHAPER)
	183	addattr_l(n, 1024, TCA_MQPRIO_SHAPER,
	184	&shaper, sizeof(shaper));
	185
	186	if (flags & TC_MQPRIO_F_MIN_RATE) {
	187	struct rtattr *start;
	188
	189	start = addattr_nest(n, 1024,
	190	TCA_MQPRIO_MIN_RATE64 \| NLA_F_NESTED);
	191
	192	for (idx = 0; idx < TC_QOPT_MAX_QUEUE; idx++)
	193	addattr_l(n, 1024, TCA_MQPRIO_MIN_RATE64,
	194	&min_rate64[idx], sizeof(min_rate64[idx]));
	195
	196	addattr_nest_end(n, start);
	197	}
	198
	199	if (flags & TC_MQPRIO_F_MAX_RATE) {
	200	struct rtattr *start;
	201
	202	start = addattr_nest(n, 1024,
	203	TCA_MQPRIO_MAX_RATE64 \| NLA_F_NESTED);
	204
	205	for (idx = 0; idx < TC_QOPT_MAX_QUEUE; idx++)
	206	addattr_l(n, 1024, TCA_MQPRIO_MAX_RATE64,
	207	&max_rate64[idx], sizeof(max_rate64[idx]));
	208
	209	addattr_nest_end(n, start);
	210	}
	211
	212	tail->rta_len = (void )NLMSG_TAIL(n) - (void )tail;
	213
91495304 JF	214	return 0;
	215	}
	216
d1f28cf1	217	static int mqprio_print_opt(struct qdisc_util qu, FILE f, struct rtattr *opt)
91495304 JF	218	{
	219	int i;
	220	struct tc_mqprio_qopt *qopt;
e1ac5b06 AN	221	__u64 min_rate64[TC_QOPT_MAX_QUEUE] = {0};
	222	__u64 max_rate64[TC_QOPT_MAX_QUEUE] = {0};
	223	int len;
	224
	225	SPRINT_BUF(b1);
91495304 JF	226
	227	if (opt == NULL)
	228	return 0;
	229
e1ac5b06 AN	230	len = RTA_PAYLOAD(opt) - RTA_ALIGN(sizeof(*qopt));
	231	if (len < 0) {
	232	fprintf(stderr, "options size error\n");
	233	return -1;
	234	}
	235
91495304 JF	236	qopt = RTA_DATA(opt);
	237
	238	fprintf(f, " tc %u map ", qopt->num_tc);
	239	for (i = 0; i <= TC_PRIO_MAX; i++)
e2a4536a	240	fprintf(f, "%u ", qopt->prio_tc_map[i]);
91495304 JF	241	fprintf(f, "\n queues:");
91495304 JF	242	for (i = 0; i < qopt->num_tc; i++)
e2a4536a	243	fprintf(f, "(%u:%u) ", qopt->offset[i],
91495304	244	qopt->offset[i] + qopt->count[i] - 1);
e1ac5b06 AN	245
	246	if (len > 0) {
	247	struct rtattr *tb[TCA_MQPRIO_MAX + 1];
	248
	249	parse_rtattr(tb, TCA_MQPRIO_MAX,
	250	RTA_DATA(opt) + RTA_ALIGN(sizeof(*qopt)),
	251	len);
	252
	253	if (tb[TCA_MQPRIO_MODE]) {
	254	__u16 *mode = RTA_DATA(tb[TCA_MQPRIO_MODE]);
	255
	256	if (*mode == TC_MQPRIO_MODE_CHANNEL)
	257	fprintf(f, "\n mode:channel");
	258	} else {
	259	fprintf(f, "\n mode:dcb");
	260	}
	261
	262	if (tb[TCA_MQPRIO_SHAPER]) {
	263	__u16 *shaper = RTA_DATA(tb[TCA_MQPRIO_SHAPER]);
	264
	265	if (*shaper == TC_MQPRIO_SHAPER_BW_RATE)
	266	fprintf(f, "\n shaper:bw_rlimit");
	267	} else {
	268	fprintf(f, "\n shaper:dcb");
	269	}
	270
	271	if (tb[TCA_MQPRIO_MIN_RATE64]) {
	272	struct rtattr *r;
	273	int rem = RTA_PAYLOAD(tb[TCA_MQPRIO_MIN_RATE64]);
	274	__u64 *min = min_rate64;
	275
	276	for (r = RTA_DATA(tb[TCA_MQPRIO_MIN_RATE64]);
	277	RTA_OK(r, rem); r = RTA_NEXT(r, rem)) {
	278	if (r->rta_type != TCA_MQPRIO_MIN_RATE64)
	279	return -1;
	280	*(min++) = rta_getattr_u64(r);
	281	}
	282	fprintf(f, " min_rate:");
	283	for (i = 0; i < qopt->num_tc; i++)
	284	fprintf(f, "%s ", sprint_rate(min_rate64[i], b1));
	285	}
	286
	287	if (tb[TCA_MQPRIO_MAX_RATE64]) {
	288	struct rtattr *r;
	289	int rem = RTA_PAYLOAD(tb[TCA_MQPRIO_MAX_RATE64]);
	290	__u64 *max = max_rate64;
	291
	292	for (r = RTA_DATA(tb[TCA_MQPRIO_MAX_RATE64]);
	293	RTA_OK(r, rem); r = RTA_NEXT(r, rem)) {
	294	if (r->rta_type != TCA_MQPRIO_MAX_RATE64)
	295	return -1;
	296	*(max++) = rta_getattr_u64(r);
	297	}
	298	fprintf(f, " max_rate:");
	299	for (i = 0; i < qopt->num_tc; i++)
	300	fprintf(f, "%s ", sprint_rate(max_rate64[i], b1));
	301	}
	302	}
91495304 JF	303	return 0;
	304	}
	305
	306	struct qdisc_util mqprio_qdisc_util = {
	307	.id = "mqprio",
	308	.parse_qopt = mqprio_parse_opt,
	309	.print_qopt = mqprio_print_opt,
	310	};