tc/q_mqprio.c

   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>
  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");
  27         fprintf(stderr, "                  [queues count1@offset1 count2@offset2 ...] ");
  28         fprintf(stderr, "[hw 1|0]\n");
  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");
  33 }
  34
  35 static int mqprio_parse_opt(struct qdisc_util *qu, int argc,
  36                             char **argv, struct nlmsghdr *n, const char *dev)
  37 {
  38         int idx;
  39         struct tc_mqprio_qopt opt = {
  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         };
  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;
  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;
  72                 } else if (strcmp(*argv, "queues") == 0) {
  73                         char *tmp, *tok;
  74
  75                         while (idx < TC_QOPT_MAX_QUEUE && NEXT_ARG_OK()) {
  76                                 NEXT_ARG();
  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);
  85                                         PREV_ARG();
  86                                         break;
  87                                 }
  88                                 tok = strtok(NULL, "@");
  89                                 if (get_u16(&opt.offset[idx], tok, 10)) {
  90                                         free(tmp);
  91                                         PREV_ARG();
  92                                         break;
  93                                 }
  94                                 free(tmp);
  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++;
 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;
 166                 } else if (strcmp(*argv, "help") == 0) {
 167                         explain();
 168                         return -1;
 169                 } else {
 170                         invarg("unknown argument", *argv);
 171                 }
 172                 argc--; argv++;
 173         }
 174
 175         tail = NLMSG_TAIL(n);
 176         addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
 177
 178         if (flags & TC_MQPRIO_F_MODE)
 179                 addattr_l(n, 1024, TCA_MQPRIO_MODE,
 180                           &mode, sizeof(mode));
 181         if (flags & TC_MQPRIO_F_SHAPER)
 182                 addattr_l(n, 1024, TCA_MQPRIO_SHAPER,
 183                           &shaper, sizeof(shaper));
 184
 185         if (flags & TC_MQPRIO_F_MIN_RATE) {
 186                 struct rtattr *start;
 187
 188                 start = addattr_nest(n, 1024,
 189                                      TCA_MQPRIO_MIN_RATE64 | NLA_F_NESTED);
 190
 191                 for (idx = 0; idx < TC_QOPT_MAX_QUEUE; idx++)
 192                         addattr_l(n, 1024, TCA_MQPRIO_MIN_RATE64,
 193                                   &min_rate64[idx], sizeof(min_rate64[idx]));
 194
 195                 addattr_nest_end(n, start);
 196         }
 197
 198         if (flags & TC_MQPRIO_F_MAX_RATE) {
 199                 struct rtattr *start;
 200
 201                 start = addattr_nest(n, 1024,
 202                                      TCA_MQPRIO_MAX_RATE64 | NLA_F_NESTED);
 203
 204                 for (idx = 0; idx < TC_QOPT_MAX_QUEUE; idx++)
 205                         addattr_l(n, 1024, TCA_MQPRIO_MAX_RATE64,
 206                                   &max_rate64[idx], sizeof(max_rate64[idx]));
 207
 208                 addattr_nest_end(n, start);
 209         }
 210
 211         tail->rta_len = (void *)NLMSG_TAIL(n) - (void *)tail;
 212
 213         return 0;
 214 }
 215
 216 static int mqprio_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
 217 {
 218         int i;
 219         struct tc_mqprio_qopt *qopt;
 220         __u64 min_rate64[TC_QOPT_MAX_QUEUE] = {0};
 221         __u64 max_rate64[TC_QOPT_MAX_QUEUE] = {0};
 222         int len;
 223
 224         SPRINT_BUF(b1);
 225
 226         if (opt == NULL)
 227                 return 0;
 228
 229         len = RTA_PAYLOAD(opt) - RTA_ALIGN(sizeof(*qopt));
 230         if (len < 0) {
 231                 fprintf(stderr, "options size error\n");
 232                 return -1;
 233         }
 234
 235         qopt = RTA_DATA(opt);
 236
 237         fprintf(f, " tc %u map ", qopt->num_tc);
 238         for (i = 0; i <= TC_PRIO_MAX; i++)
 239                 fprintf(f, "%u ", qopt->prio_tc_map[i]);
 240         fprintf(f, "\n             queues:");
 241         for (i = 0; i < qopt->num_tc; i++)
 242                 fprintf(f, "(%u:%u) ", qopt->offset[i],
 243                         qopt->offset[i] + qopt->count[i] - 1);
 244
 245         if (len > 0) {
 246                 struct rtattr *tb[TCA_MQPRIO_MAX + 1];
 247
 248                 parse_rtattr(tb, TCA_MQPRIO_MAX,
 249                              RTA_DATA(opt) + RTA_ALIGN(sizeof(*qopt)),
 250                              len);
 251
 252                 if (tb[TCA_MQPRIO_MODE]) {
 253                         __u16 *mode = RTA_DATA(tb[TCA_MQPRIO_MODE]);
 254
 255                         if (*mode == TC_MQPRIO_MODE_CHANNEL)
 256                                 fprintf(f, "\n             mode:channel");
 257                 } else {
 258                         fprintf(f, "\n             mode:dcb");
 259                 }
 260
 261                 if (tb[TCA_MQPRIO_SHAPER]) {
 262                         __u16 *shaper = RTA_DATA(tb[TCA_MQPRIO_SHAPER]);
 263
 264                         if (*shaper == TC_MQPRIO_SHAPER_BW_RATE)
 265                                 fprintf(f, "\n             shaper:bw_rlimit");
 266                 } else {
 267                         fprintf(f, "\n             shaper:dcb");
 268                 }
 269
 270                 if (tb[TCA_MQPRIO_MIN_RATE64]) {
 271                         struct rtattr *r;
 272                         int rem = RTA_PAYLOAD(tb[TCA_MQPRIO_MIN_RATE64]);
 273                         __u64 *min = min_rate64;
 274
 275                         for (r = RTA_DATA(tb[TCA_MQPRIO_MIN_RATE64]);
 276                              RTA_OK(r, rem); r = RTA_NEXT(r, rem)) {
 277                                 if (r->rta_type != TCA_MQPRIO_MIN_RATE64)
 278                                         return -1;
 279                                 *(min++) = rta_getattr_u64(r);
 280                         }
 281                         fprintf(f, "    min_rate:");
 282                         for (i = 0; i < qopt->num_tc; i++)
 283                                 fprintf(f, "%s ", sprint_rate(min_rate64[i], b1));
 284                 }
 285
 286                 if (tb[TCA_MQPRIO_MAX_RATE64]) {
 287                         struct rtattr *r;
 288                         int rem = RTA_PAYLOAD(tb[TCA_MQPRIO_MAX_RATE64]);
 289                         __u64 *max = max_rate64;
 290
 291                         for (r = RTA_DATA(tb[TCA_MQPRIO_MAX_RATE64]);
 292                              RTA_OK(r, rem); r = RTA_NEXT(r, rem)) {
 293                                 if (r->rta_type != TCA_MQPRIO_MAX_RATE64)
 294                                         return -1;
 295                                 *(max++) = rta_getattr_u64(r);
 296                         }
 297                         fprintf(f, "    max_rate:");
 298                         for (i = 0; i < qopt->num_tc; i++)
 299                                 fprintf(f, "%s ", sprint_rate(max_rate64[i], b1));
 300                 }
 301         }
 302         return 0;
 303 }
 304
 305 struct qdisc_util mqprio_qdisc_util = {
 306         .id             = "mqprio",
 307         .parse_qopt     = mqprio_parse_opt,
 308         .print_qopt     = mqprio_print_opt,
 309 };