src/network/tc/tbf.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later
   2  * Copyright © 2019 VMware, Inc. */
   3
   4 #include <linux/pkt_sched.h>
   5 #include <math.h>
   6
   7 #include "alloc-util.h"
   8 #include "conf-parser.h"
   9 #include "netem.h"
  10 #include "netlink-util.h"
  11 #include "networkd-manager.h"
  12 #include "parse-util.h"
  13 #include "qdisc.h"
  14 #include "string-util.h"
  15 #include "strv.h"
  16 #include "tc-util.h"
  17
  18 static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
  19         uint32_t rtab[256], ptab[256];
  20         TokenBucketFilter *tbf;
  21         int r;
  22
  23         assert(link);
  24         assert(qdisc);
  25         assert(req);
  26
  27         assert_se(tbf = TBF(qdisc));
  28
  29         struct tc_tbf_qopt opt = {
  30                 .rate.rate = tbf->rate >= (1ULL << 32) ? ~0U : tbf->rate,
  31                 .peakrate.rate = tbf->peak_rate >= (1ULL << 32) ? ~0U : tbf->peak_rate,
  32                 .rate.mpu = tbf->mpu,
  33         };
  34
  35         if (tbf->limit > 0)
  36                 opt.limit = tbf->limit;
  37         else {
  38                 double lim, lim2;
  39
  40                 lim = tbf->rate * (double) tbf->latency / USEC_PER_SEC + tbf->burst;
  41                 if (tbf->peak_rate > 0) {
  42                         lim2 = tbf->peak_rate * (double) tbf->latency / USEC_PER_SEC + tbf->mtu;
  43                         lim = MIN(lim, lim2);
  44                 }
  45                 opt.limit = lim;
  46         }
  47
  48         r = tc_fill_ratespec_and_table(&opt.rate, rtab, tbf->mtu);
  49         if (r < 0)
  50                 return log_link_debug_errno(link, r, "Failed to calculate ratespec: %m");
  51
  52         r = tc_transmit_time(opt.rate.rate, tbf->burst, &opt.buffer);
  53         if (r < 0)
  54                 return log_link_debug_errno(link, r, "Failed to calculate buffer size: %m");
  55
  56         if (opt.peakrate.rate > 0) {
  57                 opt.peakrate.mpu = tbf->mpu;
  58
  59                 r = tc_fill_ratespec_and_table(&opt.peakrate, ptab, tbf->mtu);
  60                 if (r < 0)
  61                         return log_link_debug_errno(link, r, "Failed to calculate ratespec: %m");
  62
  63                 r = tc_transmit_time(opt.peakrate.rate, tbf->mtu, &opt.mtu);
  64                 if (r < 0)
  65                         return log_link_debug_errno(link, r, "Failed to calculate mtu size: %m");
  66         }
  67
  68         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "tbf");
  69         if (r < 0)
  70                 return r;
  71
  72         r = sd_netlink_message_append_data(req, TCA_TBF_PARMS, &opt, sizeof(opt));
  73         if (r < 0)
  74                 return r;
  75
  76         r = sd_netlink_message_append_data(req, TCA_TBF_BURST, &tbf->burst, sizeof(tbf->burst));
  77         if (r < 0)
  78                 return r;
  79
  80         if (tbf->rate >= (1ULL << 32)) {
  81                 r = sd_netlink_message_append_u64(req, TCA_TBF_RATE64, tbf->rate);
  82                 if (r < 0)
  83                         return r;
  84         }
  85
  86         r = sd_netlink_message_append_data(req, TCA_TBF_RTAB, rtab, sizeof(rtab));
  87         if (r < 0)
  88                 return r;
  89
  90         if (opt.peakrate.rate > 0) {
  91                 if (tbf->peak_rate >= (1ULL << 32)) {
  92                         r = sd_netlink_message_append_u64(req, TCA_TBF_PRATE64, tbf->peak_rate);
  93                         if (r < 0)
  94                                 return r;
  95                 }
  96
  97                 r = sd_netlink_message_append_u32(req, TCA_TBF_PBURST, tbf->mtu);
  98                 if (r < 0)
  99                         return r;
 100
 101                 r = sd_netlink_message_append_data(req, TCA_TBF_PTAB, ptab, sizeof(ptab));
 102                 if (r < 0)
 103                         return r;
 104         }
 105
 106         r = sd_netlink_message_close_container(req);
 107         if (r < 0)
 108                 return r;
 109
 110         return 0;
 111 }
 112
 113 int config_parse_token_bucket_filter_size(
 114                 const char *unit,
 115                 const char *filename,
 116                 unsigned line,
 117                 const char *section,
 118                 unsigned section_line,
 119                 const char *lvalue,
 120                 int ltype,
 121                 const char *rvalue,
 122                 void *data,
 123                 void *userdata) {
 124
 125         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 126         Network *network = ASSERT_PTR(data);
 127         TokenBucketFilter *tbf;
 128         uint64_t k;
 129         int r;
 130
 131         assert(filename);
 132         assert(lvalue);
 133         assert(rvalue);
 134
 135         r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
 136         if (r == -ENOMEM)
 137                 return log_oom();
 138         if (r < 0) {
 139                 log_syntax(unit, LOG_WARNING, filename, line, r,
 140                            "More than one kind of queueing discipline, ignoring assignment: %m");
 141                 return 0;
 142         }
 143
 144         tbf = TBF(qdisc);
 145
 146         if (isempty(rvalue)) {
 147                 if (STR_IN_SET(lvalue, "BurstBytes", "Burst"))
 148                         tbf->burst = 0;
 149                 else if (STR_IN_SET(lvalue, "LimitBytes", "LimitSize"))
 150                         tbf->limit = 0;
 151                 else if (streq(lvalue, "MTUBytes"))
 152                         tbf->mtu = 0;
 153                 else if (streq(lvalue, "MPUBytes"))
 154                         tbf->mpu = 0;
 155                 else
 156                         assert_not_reached();
 157
 158                 TAKE_PTR(qdisc);
 159                 return 0;
 160         }
 161
 162         r = parse_size(rvalue, 1024, &k);
 163         if (r < 0) {
 164                 log_syntax(unit, LOG_WARNING, filename, line, r,
 165                            "Failed to parse '%s=', ignoring assignment: %s",
 166                            lvalue, rvalue);
 167                 return 0;
 168         }
 169
 170         if (STR_IN_SET(lvalue, "BurstBytes", "Burst"))
 171                 tbf->burst = k;
 172         else if (STR_IN_SET(lvalue, "LimitBytes", "LimitSize"))
 173                 tbf->limit = k;
 174         else if (streq(lvalue, "MPUBytes"))
 175                 tbf->mpu = k;
 176         else if (streq(lvalue, "MTUBytes"))
 177                 tbf->mtu = k;
 178         else
 179                 assert_not_reached();
 180
 181         TAKE_PTR(qdisc);
 182
 183         return 0;
 184 }
 185
 186 int config_parse_token_bucket_filter_rate(
 187                 const char *unit,
 188                 const char *filename,
 189                 unsigned line,
 190                 const char *section,
 191                 unsigned section_line,
 192                 const char *lvalue,
 193                 int ltype,
 194                 const char *rvalue,
 195                 void *data,
 196                 void *userdata) {
 197
 198         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 199         Network *network = ASSERT_PTR(data);
 200         TokenBucketFilter *tbf;
 201         uint64_t k, *p;
 202         int r;
 203
 204         assert(filename);
 205         assert(lvalue);
 206         assert(rvalue);
 207
 208         r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
 209         if (r == -ENOMEM)
 210                 return log_oom();
 211         if (r < 0) {
 212                 log_syntax(unit, LOG_WARNING, filename, line, r,
 213                            "More than one kind of queueing discipline, ignoring assignment: %m");
 214                 return 0;
 215         }
 216
 217         tbf = TBF(qdisc);
 218         if (streq(lvalue, "Rate"))
 219                 p = &tbf->rate;
 220         else if (streq(lvalue, "PeakRate"))
 221                 p = &tbf->peak_rate;
 222         else
 223                 assert_not_reached();
 224
 225         if (isempty(rvalue)) {
 226                 *p = 0;
 227
 228                 TAKE_PTR(qdisc);
 229                 return 0;
 230         }
 231
 232         r = parse_size(rvalue, 1000, &k);
 233         if (r < 0) {
 234                 log_syntax(unit, LOG_WARNING, filename, line, r,
 235                            "Failed to parse '%s=', ignoring assignment: %s",
 236                            lvalue, rvalue);
 237                 return 0;
 238         }
 239
 240         *p = k / 8;
 241
 242         qdisc = NULL;
 243
 244         return 0;
 245 }
 246
 247 int config_parse_token_bucket_filter_latency(
 248                 const char *unit,
 249                 const char *filename,
 250                 unsigned line,
 251                 const char *section,
 252                 unsigned section_line,
 253                 const char *lvalue,
 254                 int ltype,
 255                 const char *rvalue,
 256                 void *data,
 257                 void *userdata) {
 258
 259         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 260         Network *network = ASSERT_PTR(data);
 261         TokenBucketFilter *tbf;
 262         usec_t u;
 263         int r;
 264
 265         assert(filename);
 266         assert(lvalue);
 267         assert(rvalue);
 268
 269         r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
 270         if (r == -ENOMEM)
 271                 return log_oom();
 272         if (r < 0) {
 273                 log_syntax(unit, LOG_WARNING, filename, line, r,
 274                            "More than one kind of queueing discipline, ignoring assignment: %m");
 275                 return 0;
 276         }
 277
 278         tbf = TBF(qdisc);
 279
 280         if (isempty(rvalue)) {
 281                 tbf->latency = 0;
 282
 283                 qdisc = NULL;
 284                 return 0;
 285         }
 286
 287         r = parse_sec(rvalue, &u);
 288         if (r < 0) {
 289                 log_syntax(unit, LOG_WARNING, filename, line, r,
 290                            "Failed to parse '%s=', ignoring assignment: %s",
 291                            lvalue, rvalue);
 292                 return 0;
 293         }
 294
 295         tbf->latency = u;
 296
 297         qdisc = NULL;
 298
 299         return 0;
 300 }
 301
 302 static int token_bucket_filter_verify(QDisc *qdisc) {
 303         TokenBucketFilter *tbf = TBF(qdisc);
 304
 305         if (tbf->limit > 0 && tbf->latency > 0)
 306                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 307                                          "%s: Specifying both LimitSize= and LatencySec= is not allowed. "
 308                                          "Ignoring [TokenBucketFilter] section from line %u.",
 309                                          qdisc->section->filename, qdisc->section->line);
 310
 311         if (tbf->limit == 0 && tbf->latency == 0)
 312                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 313                                          "%s: Either LimitSize= or LatencySec= is required. "
 314                                          "Ignoring [TokenBucketFilter] section from line %u.",
 315                                          qdisc->section->filename, qdisc->section->line);
 316
 317         if (tbf->rate == 0)
 318                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 319                                          "%s: Rate= is mandatory. "
 320                                          "Ignoring [TokenBucketFilter] section from line %u.",
 321                                          qdisc->section->filename, qdisc->section->line);
 322
 323         if (tbf->burst == 0)
 324                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 325                                          "%s: Burst= is mandatory. "
 326                                          "Ignoring [TokenBucketFilter] section from line %u.",
 327                                          qdisc->section->filename, qdisc->section->line);
 328
 329         if (tbf->peak_rate > 0 && tbf->mtu == 0)
 330                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 331                                          "%s: MTUBytes= is mandatory when PeakRate= is specified. "
 332                                          "Ignoring [TokenBucketFilter] section from line %u.",
 333                                          qdisc->section->filename, qdisc->section->line);
 334
 335         return 0;
 336 }
 337
 338 const QDiscVTable tbf_vtable = {
 339         .object_size = sizeof(TokenBucketFilter),
 340         .tca_kind = "tbf",
 341         .fill_message = token_bucket_filter_fill_message,
 342         .verify = token_bucket_filter_verify
 343 };