tc/tc_stab.c

   1 /*
   2  * tc_stab.c            "tc qdisc ... stab *".
   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:     Jussi Kivilinna, <jussi.kivilinna@mbnet.fi>
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <syslog.h>
  17 #include <fcntl.h>
  18 #include <math.h>
  19 #include <sys/socket.h>
  20 #include <sys/param.h>
  21 #include <netinet/in.h>
  22 #include <arpa/inet.h>
  23 #include <string.h>
  24 #include <malloc.h>
  25
  26 #include "utils.h"
  27 #include "tc_util.h"
  28 #include "tc_core.h"
  29 #include "tc_common.h"
  30
  31 static void stab_help(void)
  32 {
  33         fprintf(stderr,
  34                 "Usage: ... stab [ mtu BYTES ] [ tsize SLOTS ] [ mpu BYTES ] \n"
  35                 "                [ overhead BYTES ] [ linklayer TYPE ] ...\n"
  36                 "   mtu       : max packet size we create rate map for {2047}\n"
  37                 "   tsize     : how many slots should size table have {512}\n"
  38                 "   mpu       : minimum packet size used in rate computations\n"
  39                 "   overhead  : per-packet size overhead used in rate computations\n"
  40                 "   linklayer : adapting to a linklayer e.g. atm\n"
  41                 "Example: ... stab overhead 20 linklayer atm\n");
  42
  43         return;
  44 }
  45
  46 int check_size_table_opts(struct tc_sizespec *s)
  47 {
  48         return s->linklayer >= LINKLAYER_ETHERNET || s->mpu != 0 ||
  49                                                         s->overhead != 0;
  50 }
  51
  52 int parse_size_table(int *argcp, char ***argvp, struct tc_sizespec *sp)
  53 {
  54         char **argv = *argvp;
  55         int argc = *argcp;
  56         struct tc_sizespec s;
  57
  58         memset(&s, 0, sizeof(s));
  59
  60         NEXT_ARG();
  61         if (matches(*argv, "help") == 0) {
  62                 stab_help();
  63                 return -1;
  64         }
  65         while (argc > 0) {
  66                 if (matches(*argv, "mtu") == 0) {
  67                         NEXT_ARG();
  68                         if (s.mtu)
  69                                 duparg("mtu", *argv);
  70                         if (get_u32(&s.mtu, *argv, 10)) {
  71                                 invarg("mtu", "invalid mtu");
  72                                 return -1;
  73                         }
  74                 } else if (matches(*argv, "mpu") == 0) {
  75                         NEXT_ARG();
  76                         if (s.mpu)
  77                                 duparg("mpu", *argv);
  78                         if (get_u32(&s.mpu, *argv, 10)) {
  79                                 invarg("mpu", "invalid mpu");
  80                                 return -1;
  81                         }
  82                 } else if (matches(*argv, "overhead") == 0) {
  83                         NEXT_ARG();
  84                         if (s.overhead)
  85                                 duparg("overhead", *argv);
  86                         if (get_integer(&s.overhead, *argv, 10)) {
  87                                 invarg("overhead", "invalid overhead");
  88                                 return -1;
  89                         }
  90                 } else if (matches(*argv, "tsize") == 0) {
  91                         NEXT_ARG();
  92                         if (s.tsize)
  93                                 duparg("tsize", *argv);
  94                         if (get_u32(&s.tsize, *argv, 10)) {
  95                                 invarg("tsize", "invalid table size");
  96                                 return -1;
  97                         }
  98                 } else if (matches(*argv, "linklayer") == 0) {
  99                         NEXT_ARG();
 100                         if (s.linklayer != LINKLAYER_UNSPEC)
 101                                 duparg("linklayer", *argv);
 102                         if (get_linklayer(&s.linklayer, *argv)) {
 103                                 invarg("linklayer", "invalid linklayer");
 104                                 return -1;
 105                         }
 106                 } else
 107                         break;
 108                 argc--; argv++;
 109         }
 110
 111         if (!check_size_table_opts(&s))
 112                 return -1;
 113
 114         *sp = s;
 115         *argvp = argv;
 116         *argcp = argc;
 117         return 0;
 118 }
 119
 120 void print_size_table(FILE *fp, const char *prefix, struct rtattr *rta)
 121 {
 122         struct rtattr *tb[TCA_STAB_MAX + 1];
 123         SPRINT_BUF(b1);
 124
 125         parse_rtattr_nested(tb, TCA_STAB_MAX, rta);
 126
 127         if (tb[TCA_STAB_BASE]) {
 128                 struct tc_sizespec s = {0};
 129                 memcpy(&s, RTA_DATA(tb[TCA_STAB_BASE]),
 130                                 MIN(RTA_PAYLOAD(tb[TCA_STAB_BASE]), sizeof(s)));
 131
 132                 fprintf(fp, "%s", prefix);
 133                 if (s.linklayer)
 134                         fprintf(fp, "linklayer %s ",
 135                                         sprint_linklayer(s.linklayer, b1));
 136                 if (s.overhead)
 137                         fprintf(fp, "overhead %d ", s.overhead);
 138                 if (s.mpu)
 139                         fprintf(fp, "mpu %u ", s.mpu);
 140                 if (s.mtu)
 141                         fprintf(fp, "mtu %u ", s.mtu);
 142                 if (s.tsize)
 143                         fprintf(fp, "tsize %u ", s.tsize);
 144         }
 145
 146 #if 0
 147         if (tb[TCA_STAB_DATA]) {
 148                 unsigned i, j, dlen;
 149                 __u16 *data = RTA_DATA(tb[TCA_STAB_DATA]);
 150                 dlen = RTA_PAYLOAD(tb[TCA_STAB_DATA]) / sizeof(__u16);
 151
 152                 fprintf(fp, "\n%sstab data:", prefix);
 153                 for (i = 0; i < dlen/12; i++) {
 154                         fprintf(fp, "\n%s %3u:", prefix, i * 12);
 155                         for (j = 0; i * 12 + j < dlen; j++)
 156                                 fprintf(fp, " %05x", data[i * 12 + j]);
 157                 }
 158         }
 159 #endif
 160 }
 161