lib/route/sch/tbf.c

   1 /*
   2  * lib/route/sch/tbf.c          TBF Qdisc
   3  *
   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
   7  *      of the License.
   8  *
   9  * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup qdisc_api
  14  * @defgroup tbf Token Bucket Filter (TBF)
  15  * @{
  16  */
  17
  18 #include <netlink-local.h>
  19 #include <netlink-tc.h>
  20 #include <netlink/netlink.h>
  21 #include <netlink/cache.h>
  22 #include <netlink/utils.h>
  23 #include <netlink/route/tc.h>
  24 #include <netlink/route/qdisc.h>
  25 #include <netlink/route/qdisc-modules.h>
  26 #include <netlink/route/class.h>
  27 #include <netlink/route/class-modules.h>
  28 #include <netlink/route/link.h>
  29 #include <netlink/route/sch/tbf.h>
  30
  31 /** @cond SKIP */
  32 #define TBF_ATTR_LIMIT                  0x01
  33 #define TBF_ATTR_RATE                   0x02
  34 #define TBF_ATTR_PEAKRATE               0x10
  35 #define TBF_ATTR_MPU                    0x80
  36 /** @endcond */
  37
  38 static inline struct rtnl_tbf *tbf_qdisc(struct rtnl_qdisc *qdisc)
  39 {
  40         return (struct rtnl_tbf *) qdisc->q_subdata;
  41 }
  42
  43 static inline struct rtnl_tbf *tbf_alloc(struct rtnl_qdisc *qdisc)
  44 {
  45         if (!qdisc->q_subdata)
  46                 qdisc->q_subdata = calloc(1, sizeof(struct rtnl_tbf));
  47
  48         return tbf_qdisc(qdisc);
  49 }
  50
  51 static struct nla_policy tbf_policy[TCA_TBF_MAX+1] = {
  52         [TCA_TBF_PARMS] = { .minlen = sizeof(struct tc_tbf_qopt) },
  53 };
  54
  55 static int tbf_msg_parser(struct rtnl_qdisc *q)
  56 {
  57         int err;
  58         struct nlattr *tb[TCA_TBF_MAX + 1];
  59         struct rtnl_tbf *tbf;
  60
  61         err = tca_parse(tb, TCA_TBF_MAX, (struct rtnl_tca *) q, tbf_policy);
  62         if (err < 0)
  63                 return err;
  64
  65         tbf = tbf_alloc(q);
  66         if (!tbf)
  67                 return -NLE_NOMEM;
  68
  69         if (tb[TCA_TBF_PARMS]) {
  70                 struct tc_tbf_qopt opts;
  71                 int bufsize;
  72
  73                 nla_memcpy(&opts, tb[TCA_TBF_PARMS], sizeof(opts));
  74                 tbf->qt_limit = opts.limit;
  75                 tbf->qt_mpu = opts.rate.mpu;
  76
  77                 rtnl_copy_ratespec(&tbf->qt_rate, &opts.rate);
  78                 tbf->qt_rate_txtime = opts.buffer;
  79                 bufsize = rtnl_tc_calc_bufsize(nl_ticks2us(opts.buffer),
  80                                                opts.rate.rate);
  81                 tbf->qt_rate_bucket = bufsize;
  82
  83                 rtnl_copy_ratespec(&tbf->qt_peakrate, &opts.peakrate);
  84                 tbf->qt_peakrate_txtime = opts.mtu;
  85                 bufsize = rtnl_tc_calc_bufsize(nl_ticks2us(opts.mtu),
  86                                                opts.peakrate.rate);
  87                 tbf->qt_peakrate_bucket = bufsize;
  88
  89                 tbf->qt_mask = (TBF_ATTR_LIMIT | TBF_ATTR_MPU | TBF_ATTR_RATE |
  90                                 TBF_ATTR_PEAKRATE);
  91         }
  92
  93         return 0;
  94 }
  95
  96 static void tbf_free_data(struct rtnl_qdisc *qdisc)
  97 {
  98         free(qdisc->q_subdata);
  99 }
 100
 101 static void tbf_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
 102 {
 103         double r, rbit, lim;
 104         char *ru, *rubit, *limu;
 105         struct rtnl_tbf *tbf = tbf_qdisc(qdisc);
 106
 107         if (!tbf)
 108                 return;
 109
 110         r = nl_cancel_down_bytes(tbf->qt_rate.rs_rate, &ru);
 111         rbit = nl_cancel_down_bits(tbf->qt_rate.rs_rate*8, &rubit);
 112         lim = nl_cancel_down_bytes(tbf->qt_limit, &limu);
 113
 114         nl_dump(p, " rate %.2f%s/s (%.0f%s) limit %.2f%s",
 115                 r, ru, rbit, rubit, lim, limu);
 116 }
 117
 118 static void tbf_dump_details(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
 119 {
 120         struct rtnl_tbf *tbf = tbf_qdisc(qdisc);
 121
 122         if (!tbf)
 123                 return;
 124
 125         if (1) {
 126                 char *bu, *cu;
 127                 double bs = nl_cancel_down_bytes(tbf->qt_rate_bucket, &bu);
 128                 double cl = nl_cancel_down_bytes(1 << tbf->qt_rate.rs_cell_log,
 129                                                  &cu);
 130
 131                 nl_dump(p, "mpu %u rate-bucket-size %1.f%s "
 132                            "rate-cell-size %.1f%s\n",
 133                         tbf->qt_mpu, bs, bu, cl, cu);
 134
 135         }
 136
 137         if (tbf->qt_mask & TBF_ATTR_PEAKRATE) {
 138                 char *pru, *prbu, *bsu, *clu;
 139                 double pr, prb, bs, cl;
 140
 141                 pr = nl_cancel_down_bytes(tbf->qt_peakrate.rs_rate, &pru);
 142                 prb = nl_cancel_down_bits(tbf->qt_peakrate.rs_rate * 8, &prbu);
 143                 bs = nl_cancel_down_bits(tbf->qt_peakrate_bucket, &bsu);
 144                 cl = nl_cancel_down_bits(1 << tbf->qt_peakrate.rs_cell_log,
 145                                          &clu);
 146
 147                 nl_dump_line(p, "    peak-rate %.2f%s/s (%.0f%s) "
 148                                 "bucket-size %.1f%s cell-size %.1f%s"
 149                                 "latency %.1f%s",
 150                              pr, pru, prb, prbu, bs, bsu, cl, clu);
 151         }
 152 }
 153
 154 static struct nl_msg *tbf_get_opts(struct rtnl_qdisc *qdisc)
 155 {
 156         struct tc_tbf_qopt opts;
 157         struct rtnl_tbf *tbf;
 158         struct nl_msg *msg;
 159         uint32_t rtab[RTNL_TC_RTABLE_SIZE];
 160         uint32_t ptab[RTNL_TC_RTABLE_SIZE];
 161         int required = TBF_ATTR_RATE | TBF_ATTR_LIMIT;
 162
 163         memset(&opts, 0, sizeof(opts));
 164
 165         tbf = tbf_qdisc(qdisc);
 166         if (!tbf)
 167                 return NULL;
 168
 169         if (!(tbf->qt_mask & required) != required)
 170                 return NULL;
 171
 172         opts.limit = tbf->qt_limit;
 173         opts.buffer = tbf->qt_rate_txtime;
 174         tbf->qt_rate.rs_mpu = tbf->qt_mpu;
 175         rtnl_rcopy_ratespec(&opts.rate, &tbf->qt_rate);
 176
 177         rtnl_tc_build_rate_table(rtab, tbf->qt_mpu & 0xff, tbf->qt_mpu >> 8,
 178                                  1 << tbf->qt_rate.rs_cell_log,
 179                                  tbf->qt_rate.rs_rate);
 180
 181         if (tbf->qt_mask & TBF_ATTR_PEAKRATE) {
 182                 opts.mtu = tbf->qt_peakrate_txtime;
 183                 tbf->qt_peakrate.rs_mpu = tbf->qt_mpu;
 184                 rtnl_rcopy_ratespec(&opts.peakrate, &tbf->qt_peakrate);
 185
 186                 rtnl_tc_build_rate_table(ptab, tbf->qt_mpu & 0xff,
 187                                          tbf->qt_mpu >> 8,
 188                                          1 << tbf->qt_peakrate.rs_cell_log,
 189                                          tbf->qt_peakrate.rs_rate);
 190         }
 191
 192         msg = nlmsg_alloc();
 193         if (!msg)
 194                 goto nla_put_failure;
 195
 196         NLA_PUT(msg, TCA_TBF_PARMS, sizeof(opts), &opts);
 197         NLA_PUT(msg, TCA_TBF_RTAB, sizeof(rtab), rtab);
 198
 199         if (tbf->qt_mask & TBF_ATTR_PEAKRATE)
 200                 NLA_PUT(msg, TCA_TBF_PTAB, sizeof(ptab), ptab);
 201
 202         return msg;
 203
 204 nla_put_failure:
 205         nlmsg_free(msg);
 206         return NULL;
 207 }
 208
 209 /**
 210  * @name Attribute Access
 211  * @{
 212  */
 213
 214 /**
 215  * Set limit of TBF qdisc.
 216  * @arg qdisc           TBF qdisc to be modified.
 217  * @arg limit           New limit in bytes.
 218  * @return 0 on success or a negative error code.
 219  */
 220 int rtnl_qdisc_tbf_set_limit(struct rtnl_qdisc *qdisc, int limit)
 221 {
 222         struct rtnl_tbf *tbf;
 223
 224         tbf = tbf_alloc(qdisc);
 225         if (!tbf)
 226                 return -NLE_NOMEM;
 227
 228         tbf->qt_limit = limit;
 229         tbf->qt_mask |= TBF_ATTR_LIMIT;
 230
 231         return 0;
 232 }
 233
 234 static inline double calc_limit(struct rtnl_ratespec *spec, int latency,
 235                                 int bucket)
 236 {
 237         double limit;
 238
 239         limit = (double) spec->rs_rate * ((double) latency / 1000000.);
 240         limit += bucket;
 241
 242         return limit;
 243 }
 244
 245 /**
 246  * Set limit of TBF qdisc by latency.
 247  * @arg qdisc           TBF qdisc to be modified.
 248  * @arg latency         Latency in micro seconds.
 249  *
 250  * Calculates and sets the limit based on the desired latency and the
 251  * configured rate and peak rate. In order for this operation to succeed,
 252  * the rate and if required the peak rate must have been set in advance.
 253  *
 254  * @f[
 255  *   limit_n = \frac{{rate_n} \times {latency}}{10^6}+{bucketsize}_n
 256  * @f]
 257  * @f[
 258  *   limit = min(limit_{rate},limit_{peak})
 259  * @f]
 260  *
 261  * @return 0 on success or a negative error code.
 262  */
 263 int rtnl_qdisc_tbf_set_limit_by_latency(struct rtnl_qdisc *qdisc, int latency)
 264 {
 265         struct rtnl_tbf *tbf;
 266         double limit, limit2;
 267
 268         tbf = tbf_alloc(qdisc);
 269         if (!tbf)
 270                 return -NLE_NOMEM;
 271
 272         if (!(tbf->qt_mask & TBF_ATTR_RATE))
 273                 return -NLE_MISSING_ATTR;
 274
 275         limit = calc_limit(&tbf->qt_rate, latency, tbf->qt_rate_bucket);
 276
 277         if (tbf->qt_mask & TBF_ATTR_PEAKRATE) {
 278                 limit2 = calc_limit(&tbf->qt_peakrate, latency,
 279                                     tbf->qt_peakrate_bucket);
 280
 281                 if (limit2 < limit)
 282                         limit = limit2;
 283         }
 284
 285         return rtnl_qdisc_tbf_set_limit(qdisc, (int) limit);
 286 }
 287
 288 /**
 289  * Get limit of TBF qdisc.
 290  * @arg qdisc           TBF qdisc.
 291  * @return Limit in bytes or a negative error code.
 292  */
 293 int rtnl_qdisc_tbf_get_limit(struct rtnl_qdisc *qdisc)
 294 {
 295         struct rtnl_tbf *tbf;
 296
 297         tbf = tbf_qdisc(qdisc);
 298         if (tbf && (tbf->qt_mask & TBF_ATTR_LIMIT))
 299                 return tbf->qt_limit;
 300         else
 301                 return -NLE_NOATTR;
 302 }
 303
 304 /**
 305  * Set MPU of TBF qdisc.
 306  * @arg qdisc           TBF qdisc to be modified.
 307  * @arg mpu             New MPU in bytes.
 308  * @return 0 on success or a negative error code.
 309  */
 310 int rtnl_qdisc_tbf_set_mpu(struct rtnl_qdisc *qdisc, int mpu)
 311 {
 312         struct rtnl_tbf *tbf;
 313
 314         tbf = tbf_alloc(qdisc);
 315         if (!tbf)
 316                 return -NLE_NOMEM;
 317
 318         tbf->qt_mpu = mpu;
 319         tbf->qt_mask |= TBF_ATTR_MPU;
 320
 321         return 0;
 322 }
 323
 324 /**
 325  * Get MPU of TBF qdisc.
 326  * @arg qdisc           TBF qdisc.
 327  * @return MPU in bytes or a negative error code.
 328  */
 329 int rtnl_qdisc_tbf_get_mpu(struct rtnl_qdisc *qdisc)
 330 {
 331         struct rtnl_tbf *tbf;
 332
 333         tbf = tbf_qdisc(qdisc);
 334         if (tbf && (tbf->qt_mask & TBF_ATTR_MPU))
 335                 return tbf->qt_mpu;
 336         else
 337                 return -NLE_NOATTR;
 338 }
 339
 340 static inline int calc_cell_log(int cell, int bucket)
 341 {
 342         if (cell > 0)
 343                 cell = rtnl_tc_calc_cell_log(cell);
 344         else {
 345                 cell = 0;
 346
 347                 if (!bucket)
 348                         bucket = 2047; /* defaults to cell_log=3 */
 349
 350                 while ((bucket >> cell) > 255)
 351                         cell++;
 352         }
 353
 354         return cell;
 355 }
 356
 357 /**
 358  * Set rate of TBF qdisc.
 359  * @arg qdisc           TBF qdisc to be modified.
 360  * @arg rate            New rate in bytes per second.
 361  * @arg bucket          Size of bucket in bytes.
 362  * @arg cell            Size of a rate cell or 0 to get default value.
 363  * @return 0 on success or a negative error code.
 364  */
 365 int rtnl_qdisc_tbf_set_rate(struct rtnl_qdisc *qdisc, int rate, int bucket,
 366                             int cell)
 367 {
 368         struct rtnl_tbf *tbf;
 369         int cell_log;
 370
 371         tbf = tbf_alloc(qdisc);
 372         if (!tbf)
 373                 return -NLE_NOMEM;
 374
 375         cell_log = calc_cell_log(cell, bucket);
 376         if (cell_log < 0)
 377                 return cell_log;
 378
 379         tbf->qt_rate.rs_rate = rate;
 380         tbf->qt_rate_bucket = bucket;
 381         tbf->qt_rate.rs_cell_log = cell_log;
 382         tbf->qt_rate_txtime = rtnl_tc_calc_txtime(bucket, rate);
 383         tbf->qt_mask |= TBF_ATTR_RATE;
 384
 385         return 0;
 386 }
 387
 388 /**
 389  * Get rate of TBF qdisc.
 390  * @arg qdisc           TBF qdisc.
 391  * @return Rate in bytes per seconds or a negative error code.
 392  */
 393 int rtnl_qdisc_tbf_get_rate(struct rtnl_qdisc *qdisc)
 394 {
 395         struct rtnl_tbf *tbf;
 396
 397         tbf = tbf_qdisc(qdisc);
 398         if (tbf && (tbf->qt_mask & TBF_ATTR_RATE))
 399                 return tbf->qt_rate.rs_rate;
 400         else
 401                 return -1;
 402 }
 403
 404 /**
 405  * Get rate bucket size of TBF qdisc.
 406  * @arg qdisc           TBF qdisc.
 407  * @return Size of rate bucket or a negative error code.
 408  */
 409 int rtnl_qdisc_tbf_get_rate_bucket(struct rtnl_qdisc *qdisc)
 410 {
 411         struct rtnl_tbf *tbf;
 412
 413         tbf = tbf_qdisc(qdisc);
 414         if (tbf && (tbf->qt_mask & TBF_ATTR_RATE))
 415                 return tbf->qt_rate_bucket;
 416         else
 417                 return -1;
 418 }
 419
 420 /**
 421  * Get rate cell size of TBF qdisc.
 422  * @arg qdisc           TBF qdisc.
 423  * @return Size of rate cell in bytes or a negative error code.
 424  */
 425 int rtnl_qdisc_tbf_get_rate_cell(struct rtnl_qdisc *qdisc)
 426 {
 427         struct rtnl_tbf *tbf;
 428
 429         tbf = tbf_qdisc(qdisc);
 430         if (tbf && (tbf->qt_mask & TBF_ATTR_RATE))
 431                 return (1 << tbf->qt_rate.rs_cell_log);
 432         else
 433                 return -1;
 434 }
 435
 436 /**
 437  * Set peak rate of TBF qdisc.
 438  * @arg qdisc           TBF qdisc to be modified.
 439  * @arg rate            New peak rate in bytes per second.
 440  * @arg bucket          Size of peakrate bucket.
 441  * @arg cell            Size of a peakrate cell or 0 to get default value.
 442  * @return 0 on success or a negative error code.
 443  */
 444 int rtnl_qdisc_tbf_set_peakrate(struct rtnl_qdisc *qdisc, int rate, int bucket,
 445                                 int cell)
 446 {
 447         struct rtnl_tbf *tbf;
 448         int cell_log;
 449
 450         tbf = tbf_alloc(qdisc);
 451         if (!tbf)
 452                 return -NLE_NOMEM;
 453
 454         cell_log = calc_cell_log(cell, bucket);
 455         if (cell_log < 0)
 456                 return cell_log;
 457
 458         tbf->qt_peakrate.rs_rate = rate;
 459         tbf->qt_peakrate_bucket = bucket;
 460         tbf->qt_peakrate.rs_cell_log = cell_log;
 461         tbf->qt_peakrate_txtime = rtnl_tc_calc_txtime(bucket, rate);
 462
 463         tbf->qt_mask |= TBF_ATTR_PEAKRATE;
 464
 465         return 0;
 466 }
 467
 468 /**
 469  * Get peak rate of TBF qdisc.
 470  * @arg qdisc           TBF qdisc.
 471  * @return Peak rate in bytes per seconds or a negative error code.
 472  */
 473 int rtnl_qdisc_tbf_get_peakrate(struct rtnl_qdisc *qdisc)
 474 {
 475         struct rtnl_tbf *tbf;
 476
 477         tbf = tbf_qdisc(qdisc);
 478         if (tbf && (tbf->qt_mask & TBF_ATTR_PEAKRATE))
 479                 return tbf->qt_peakrate.rs_rate;
 480         else
 481                 return -1;
 482 }
 483
 484 /**
 485  * Get peak rate bucket size of TBF qdisc.
 486  * @arg qdisc           TBF qdisc.
 487  * @return Size of peak rate bucket or a negative error code.
 488  */
 489 int rtnl_qdisc_tbf_get_peakrate_bucket(struct rtnl_qdisc *qdisc)
 490 {
 491         struct rtnl_tbf *tbf;
 492
 493         tbf = tbf_qdisc(qdisc);
 494         if (tbf && (tbf->qt_mask & TBF_ATTR_PEAKRATE))
 495                 return tbf->qt_peakrate_bucket;
 496         else
 497                 return -1;
 498 }
 499
 500 /**
 501  * Get peak rate cell size of TBF qdisc.
 502  * @arg qdisc           TBF qdisc.
 503  * @return Size of peak rate cell in bytes or a negative error code.
 504  */
 505 int rtnl_qdisc_tbf_get_peakrate_cell(struct rtnl_qdisc *qdisc)
 506 {
 507         struct rtnl_tbf *tbf;
 508
 509         tbf = tbf_qdisc(qdisc);
 510         if (tbf && (tbf->qt_mask & TBF_ATTR_PEAKRATE))
 511                 return (1 << tbf->qt_peakrate.rs_cell_log);
 512         else
 513                 return -1;
 514 }
 515
 516 /** @} */
 517
 518 static struct rtnl_qdisc_ops tbf_qdisc_ops = {
 519         .qo_kind                = "tbf",
 520         .qo_msg_parser          = tbf_msg_parser,
 521         .qo_dump = {
 522             [NL_DUMP_LINE]      = tbf_dump_line,
 523             [NL_DUMP_DETAILS]   = tbf_dump_details,
 524         },
 525         .qo_free_data           = tbf_free_data,
 526         .qo_get_opts            = tbf_get_opts,
 527 };
 528
 529 static void __init tbf_init(void)
 530 {
 531         rtnl_qdisc_register(&tbf_qdisc_ops);
 532 }
 533
 534 static void __exit tbf_exit(void)
 535 {
 536         rtnl_qdisc_unregister(&tbf_qdisc_ops);
 537 }
 538
 539 /** @} */